[jbehave-scm] [777] trunk/plugins/intellij: [JBEHAVE-98] Getting ready to for plugin surgery, added additional bonus of coverage support

Fri, 03 Aug 2007 18:57:57 -0700

Title: [777] trunk/plugins/intellij: [JBEHAVE-98] Getting ready to for plugin surgery, added additional bonus of coverage support

Diff

Modified: trunk/plugins/intellij/META-INF/plugin.xml (776 => 777)

--- trunk/plugins/intellij/META-INF/plugin.xml	2007-07-17 12:01:09 UTC (rev 776)
+++ trunk/plugins/intellij/META-INF/plugin.xml	2007-08-04 01:57:52 UTC (rev 777)
@@ -1,17 +1,18 @@
 <!DOCTYPE idea-plugin PUBLIC "Plugin/DTD" "http://plugins.intellij.net/plugin.dtd">
 <idea-plugin>
-    <name>JBehave Plugin</name>
-    <description>JBehave Launcher that launches the verification process of the current behavior.</description>
-    <version>1.0.1</version>
-    <vendor logo="/behave.png" url="" email="[EMAIL PROTECTED]">JBehave</vendor>
-    <change-notes>
-        Update to Selena
-    </change-notes>
-    <idea-version since-build="6951"/>
+  <name>JBehave Plugin</name>
+  <description>JBehave Launcher that launches the verification process of the current behavior.</description>
+  <version>1.5</version>
+  <vendor logo="/behave.png" url="" email="[EMAIL PROTECTED]">JBehave</vendor>
+  <change-notes>
+    GUI runner
+  </change-notes>
+  <idea-version since-build="7065"/>
 
-    <application-components>
-        <component>
-            <implementation-class>org.jbehave.plugin.idea.JBehaveConfigurationType</implementation-class>
-        </component>
-    </application-components>
+  <application-components>
+    <component>
+      <implementation-class>org.jbehave.plugin.idea.selena.JBehaveConfigurationType</implementation-class>
+      <option name="workspace" value="true"/>
+    </component>
+  </application-components>
 </idea-plugin>
\ No newline at end of file

Modified: trunk/plugins/intellij/jbehave-intellij.iml (776 => 777)

--- trunk/plugins/intellij/jbehave-intellij.iml	2007-07-17 12:01:09 UTC (rev 776)
+++ trunk/plugins/intellij/jbehave-intellij.iml	2007-08-04 01:57:52 UTC (rev 777)
@@ -9,7 +9,6 @@
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="idea" level="application" />
     <orderEntryProperties />
   </component>
 </module>

Modified: trunk/plugins/intellij/jbehave-intellij.ipr (776 => 777)

--- trunk/plugins/intellij/jbehave-intellij.ipr	2007-07-17 12:01:09 UTC (rev 776)
+++ trunk/plugins/intellij/jbehave-intellij.ipr	2007-08-04 01:57:52 UTC (rev 777)
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project relativePaths="false" version="4">
+<project version="4" relativePaths="false">
   <component name="AntConfiguration">
     <defaultAnt bundledAnt="true" />
   </component>
@@ -33,9 +33,11 @@
       <entry name="?*.tld" />
     </wildcardResourcePatterns>
   </component>
+  <component name="DataSourceManagerImpl" />
   <component name="DependenciesAnalyzeManager">
     <option name="myForwardDirection" value="false" />
   </component>
+  <component name="DependencyValidationManager" />
   <component name="EclipseCompilerSettings">
     <option name="DEBUGGING_INFO" value="true" />
     <option name="GENERATE_NO_WARNINGS" value="true" />
@@ -51,13 +53,14 @@
     <option name="MAXIMUM_HEAP_SIZE" value="128" />
   </component>
   <component name="EntryPointsManager">
-    <entry_points version="2.0" />
+    <entry_points />
   </component>
   <component name="ExportToHTMLSettings">
     <option name="PRINT_LINE_NUMBERS" value="false" />
     <option name="OPEN_IN_BROWSER" value="false" />
     <option name="OUTPUT_DIRECTORY" />
   </component>
+  <component name="GUI Designer component loader factory" />
   <component name="IdProvider" IDEtalkID="AE237564EECF1BAFF27FA2D75D5BA545" />
   <component name="InspectionProjectProfileManager">
     <option name="PROJECT_PROFILE" value="Project Default" />
@@ -254,7 +257,7 @@
       <module fileurl="file://$PROJECT_DIR$/jbehave-intellij.iml" filepath="$PROJECT_DIR$/jbehave-intellij.iml" />
     </modules>
   </component>
-  <component name="ProjectRootManager" version="2" assert-keyword="true" jdk-15="true" project-jdk-name="IDEA 6951" project-jdk-type="IDEA JDK">
+  <component name="ProjectRootManager" version="2" assert-keyword="true" jdk-15="true" project-jdk-name="IDEA 7051" project-jdk-type="IDEA JDK">
     <output url="" />
   </component>
   <component name="ProjectRunConfigurationManager">
@@ -279,6 +282,7 @@
       </method>
     </configuration>
   </component>
+  <component name="RAILS_PROJECT_VIEW_PANE" />
   <component name="RUBY_DOC_SETTINGS">
     <RUBY_DOC NAME="DEFAULTS" VALUE="TRUE" />
     <RUBY_DOC NAME="NUMBER" VALUE="0" />
@@ -290,9 +294,11 @@
     <option name="GENERATE_IIOP_STUBS" value="false" />
     <option name="ADDITIONAL_OPTIONS_STRING" value="" />
   </component>
+  <component name="StarteamVcsAdapter" />
   <component name="VcsDirectoryMappings">
     <mapping directory="" vcs="svn" />
   </component>
+  <component name="VssVcs" />
   <component name="com.intellij.jsf.UserDefinedFacesConfigs">
     <option name="USER_DEFINED_CONFIGS">
       <value>
@@ -300,5 +306,12 @@
       </value>
     </option>
   </component>
+  <component name="libraryTable" />
+  <component name="uidesigner-configuration">
+    <option name="INSTRUMENT_CLASSES" value="true" />
+    <option name="COPY_FORMS_RUNTIME_TO_OUTPUT" value="true" />
+    <option name="DEFAULT_LAYOUT_MANAGER" value="GridLayoutManager" />
+  </component>
+  <UsedPathMacros />
 </project>

Modified: trunk/plugins/intellij/src/org/jbehave/plugin/idea/Constants.java (776 => 777)

--- trunk/plugins/intellij/src/org/jbehave/plugin/idea/Constants.java	2007-07-17 12:01:09 UTC (rev 776)
+++ trunk/plugins/intellij/src/org/jbehave/plugin/idea/Constants.java	2007-08-04 01:57:52 UTC (rev 777)
@@ -1,8 +1,15 @@
 package org.jbehave.plugin.idea;
 
-public class Constants {
-  static final String BEHAVIOURS_INTERFACE = "org.jbehave.core.behaviour.Behaviours";
-  static final String JBEHAVE_RUNNER_CLASS = "org.jbehave.core.BehaviourRunner";
+import javax.swing.*;
 
-  private Constants(){}
+import com.intellij.openapi.util.IconLoader;
+
+public class Constants
+{
+  public static final String BEHAVIOURS_INTERFACE = "org.jbehave.core.behaviour.Behaviours";
+  public static final String JBEHAVE_RUNNER_CLASS = "org.jbehave.core.BehaviourRunner";
+  public static final Icon LOGO = IconLoader.getIcon("/behave.png");
+
+  private Constants() {
+  }
 }

Modified: trunk/plugins/intellij/src/org/jbehave/plugin/idea/JBehaveConfigurationProducer.java (776 => 777)

--- trunk/plugins/intellij/src/org/jbehave/plugin/idea/JBehaveConfigurationProducer.java	2007-07-17 12:01:09 UTC (rev 776)
+++ trunk/plugins/intellij/src/org/jbehave/plugin/idea/JBehaveConfigurationProducer.java	2007-08-04 01:57:52 UTC (rev 777)
@@ -9,41 +9,42 @@
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiMethod;
 
-public class JBehaveConfigurationProducer extends RuntimeConfigurationProducer implements Cloneable {
-    private PsiClass behaviorClass;
-    private JBehaveConfigurationType configurationType;
+public class JBehaveConfigurationProducer extends RuntimeConfigurationProducer implements Cloneable
+{
+  private PsiClass behaviorClass;
+  private JBehaveConfigurationType configurationType;
 
-    public JBehaveConfigurationProducer(PsiClass behaviorClass, JBehaveConfigurationType configurationType) {
-        super(configurationType);
-        this.behaviorClass = behaviorClass;
-        this.configurationType = configurationType;
-    }
+  public JBehaveConfigurationProducer(PsiClass behaviorClass, JBehaveConfigurationType configurationType) {
+    super(configurationType);
+    this.behaviorClass = behaviorClass;
+    this.configurationType = configurationType;
+  }
 
-    public PsiElement getSourceElement() {
-        return behaviorClass;
-    }
+  public PsiElement getSourceElement() {
+    return behaviorClass;
+  }
 
-    protected RunnerAndConfigurationSettingsImpl createConfigurationByElement(Location location, ConfigurationContext configurationContext) {
-        location = ExecutionUtil.stepIntoSingleClass(location);
-        PsiClass aClass = configurationType.getBehaviorClass(location.getPsiElement());
-        if (aClass == null) return null;
-        PsiMethod currentMethod = configurationType.getBehaviourMethodElement(location.getPsiElement());
-        RunnerAndConfigurationSettingsImpl settings = cloneTemplateConfiguration(location.getProject(), configurationContext);
-        JBehaveRunConfiguration configuration = (JBehaveRunConfiguration) settings.getConfiguration();
-        configuration.setBehaviorClass(ClassUtil.fullName(aClass));
-        if (currentMethod != null) {
-            configuration.setBehaviorMethod(currentMethod.getName());
-        }
-        configuration.setModule(ExecutionUtil.findModule(aClass));
-        configuration.setName(createName(aClass, currentMethod));
-        return settings;
+  protected RunnerAndConfigurationSettingsImpl createConfigurationByElement(Location location, ConfigurationContext configurationContext) {
+    location = ExecutionUtil.stepIntoSingleClass(location);
+    PsiClass aClass = configurationType.getBehaviorClass(location.getPsiElement());
+    if (aClass == null) return null;
+    PsiMethod currentMethod = configurationType.getBehaviourMethodElement(location.getPsiElement());
+    RunnerAndConfigurationSettingsImpl settings = cloneTemplateConfiguration(location.getProject(), configurationContext);
+    JBehaveRunConfiguration configuration = (JBehaveRunConfiguration) settings.getConfiguration();
+    configuration.setBehaviorClass(ClassUtil.fullName(aClass));
+    if (currentMethod != null) {
+      configuration.setBehaviorMethod(currentMethod.getName());
     }
+    configuration.setModule(ExecutionUtil.findModule(aClass));
+    configuration.setName(createName(aClass, currentMethod));
+    return settings;
+  }
 
-    private String createName(PsiClass aClass, PsiMethod currentMethod) {
-        return currentMethod == null ? ClassUtil.shortName(aClass) : currentMethod.getName();
-    }
+  private String createName(PsiClass aClass, PsiMethod currentMethod) {
+    return currentMethod == null ? ClassUtil.shortName(aClass) : currentMethod.getName();
+  }
 
-    public int compareTo(Object o) {
-        return -1;
-    }
+  public int compareTo(Object o) {
+    return PREFERED;
+  }
 }

Copied: trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/CommandLineState.java (from rev 776, trunk/plugins/intellij/src/org/jbehave/plugin/idea/JBehaveCommandLineState.java) (0 => 777)

--- trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/CommandLineState.java	                        (rev 0)
+++ trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/CommandLineState.java	2007-08-04 01:57:52 UTC (rev 777)
@@ -0,0 +1,31 @@
+package org.jbehave.plugin.idea.selena;
+
+import com.intellij.execution.ExecutionException;
+import com.intellij.execution.configurations.*;
+import org.jbehave.plugin.idea.Constants;
+
+public class CommandLineState extends JavaCommandLineState
+{
+  private JBehaveConfiguration config;
+
+  CommandLineState(JBehaveConfiguration configurationData, RunnerSettings runner, ConfigurationPerRunnerSettings configuration) {
+    super(runner, configuration);
+    this.config = configurationData;
+  }
+
+  protected JavaParameters createJavaParameters() throws ExecutionException {
+    JavaParameters parameters = new JavaParameters();
+    parameters.setMainClass(Constants.JBEHAVE_RUNNER_CLASS);
+    ConfigurationData data = ""
+    String behaviorClass = data.getBehaviorClass();
+    String behaviourMethod = data.getBehaviourMethod();
+    String behaviourLocator = behaviorClass;
+    if (behaviourMethod.length() > 0) {
+      behaviourLocator += ":" + behaviourMethod;
+    }
+    parameters.getProgramParametersList().addParametersString(behaviourLocator);
+    parameters.configureByModule(data.getModule(config.getProject()), JavaParameters.JDK_AND_CLASSES_AND_TESTS);
+    parameters.setWorkingDirectory(config.getWorkingDirectoryPath());
+    return parameters;
+  }
+}
\ No newline at end of file

Added: trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/ConfigurationData.java (0 => 777)

--- trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/ConfigurationData.java	                        (rev 0)
+++ trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/ConfigurationData.java	2007-08-04 01:57:52 UTC (rev 777)
@@ -0,0 +1,124 @@
+package org.jbehave.plugin.idea.selena;
+
+import com.intellij.execution.junit.TestSearchScope;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModuleManager;
+import com.intellij.openapi.project.Project;
+
+public class ConfigurationData
+{
+  private String packageName = "";
+  private String behaviorClass = "";
+  private String behaviourMethod = "";
+  private String moduleName = "";
+  private Module module;
+  private String vmParameters;
+  private TestSearchScope.Wrapper searchScope = new TestSearchScope.Wrapper();
+  private String workingPath;
+
+  public void setPackageName(String name) {
+    this.packageName = name;
+  }
+
+  public String getPackageName() {
+    return packageName;
+  }
+
+  public void setBehaviorClass(String name) {
+    this.behaviorClass = name;
+  }
+
+  public String getBehaviorClass() {
+    return behaviorClass;
+  }
+
+  public String getBehaviourMethod() {
+    return behaviourMethod;
+  }
+
+  public void setBehaviorMethod(String behaviourMethod) {
+    this.behaviourMethod = behaviourMethod;
+  }
+
+  public String getModuleName() {
+    return moduleName;
+  }
+
+  public void setModuleName(String moduleName) {
+    if (!this.moduleName.equals(moduleName)) {
+      this.moduleName = moduleName;
+      this.module = null;
+    }
+  }
+
+  public Module getModule(Project project) {
+    if (module == null) {
+      module = lookup(getModules(project), moduleName);
+    }
+    return module;
+  }
+
+  public Module[] getModules(Project project) {
+    return ModuleManager.getInstance(project).getModules();
+  }
+
+  private Module lookup(Module[] modules, String moduleName) {
+    for (Module module : modules) {
+      if (module.getName().equals(moduleName)) {
+        return module;
+      }
+    }
+    return modules.length > 0 ? modules[0] : null;
+  }
+
+  public ConfigurationData copy() {
+    ConfigurationData data = "" ConfigurationData();
+    data.setBehaviorClass(getBehaviorClass());
+    data.setBehaviorMethod(getBehaviourMethod());
+    data.setModuleName(getModuleName());
+    data.setPackageName(getPackageName());
+    data.setVmParameters(getVmParameters());
+    return data;
+  }
+
+  public TestSearchScope getScope() {
+    return searchScope.getScope();
+  }
+
+  public void setScope(TestSearchScope testseachscope) {
+    searchScope.setScope(testseachscope);
+  }
+
+  public boolean isGeneratedName(String name) {
+    return name.equals(suggestName());
+  }
+
+  public String suggestName() {
+    return isMethodSpecified() ? behaviourMethod : shortName();
+  }
+
+  private String shortName() {
+    int index = behaviorClass.lastIndexOf('.');
+    return index == -1 ? behaviorClass : behaviorClass.substring(index + 1);
+  }
+
+  public void setVmParameters(String value) {
+    vmParameters = value;
+  }
+
+  public String getVmParameters() {
+    return vmParameters;
+  }
+
+  public boolean isMethodSpecified() {
+    return behaviourMethod.length() != 0;
+  }
+
+  public void setWorkingPath(String workingPath) {
+    this.workingPath = workingPath;
+  }
+
+  public String getWorkingPath() {
+    return workingPath;
+  }
+}

Added: trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/JBehaveConfiguration.java (0 => 777)

--- trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/JBehaveConfiguration.java	                        (rev 0)
+++ trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/JBehaveConfiguration.java	2007-08-04 01:57:52 UTC (rev 777)
@@ -0,0 +1,306 @@
+package org.jbehave.plugin.idea.selena;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import com.intellij.diagnostic.logging.LogConfigurationPanel;
+import com.intellij.execution.*;
+import com.intellij.execution.configurations.*;
+import com.intellij.execution.configurations.coverage.CoverageEnabledConfiguration;
+import com.intellij.execution.filters.TextConsoleBuilderFactory;
+import com.intellij.execution.junit.RefactoringListeners;
+import com.intellij.execution.junit.SourceScope;
+import com.intellij.execution.runners.RunnerInfo;
+import com.intellij.openapi.actionSystem.DataContext;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModuleUtil;
+import com.intellij.openapi.options.SettingsEditor;
+import com.intellij.openapi.options.SettingsEditorGroup;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.InvalidDataException;
+import com.intellij.openapi.util.WriteExternalException;
+import com.intellij.psi.*;
+import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.refactoring.listeners.RefactoringElementListener;
+import com.intellij.util.PathUtil;
+import org.jdom.Element;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class JBehaveConfiguration extends CoverageEnabledConfiguration implements RunJavaConfiguration
+{
+  protected ConfigurationData data;
+  protected transient Project project;
+  public boolean ALTERNATIVE_JRE_PATH_ENABLED;
+
+  public String ALTERNATIVE_JRE_PATH;
+  public static final String DEFAULT_PACKAGE_NAME = ExecutionBundle.message("default.package.presentable.name");
+  public static final String DEFAULT_PACKAGE_CONFIGURATION_NAME = ExecutionBundle.message("default.package.configuration.name");
+
+  private final RefactoringListeners.Accessor<PsiPackage> myPackage = new RefactoringListeners.Accessor<PsiPackage>()
+  {
+    public void setName(final String qualifiedName) {
+      final boolean generatedName = isGeneratedName();
+      data.setPackageName(qualifiedName);
+      if (generatedName) setGeneratedName();
+    }
+
+    @Nullable
+    public PsiPackage getPsiElement() {
+      final String qualifiedName = data.getPackageName();
+      return qualifiedName != null ? PsiManager.getInstance(getProject()).findPackage(qualifiedName) : null;
+    }
+
+    public void setPsiElement(final PsiPackage psiPackage) {
+      setName(psiPackage.getQualifiedName());
+    }
+  };
+  private final RefactoringListeners.Accessor<PsiClass> myClass = new RefactoringListeners.Accessor<PsiClass>()
+  {
+    public void setName(final String qualifiedName) {
+      final boolean generatedName = isGeneratedName();
+      data.setBehaviorClass(qualifiedName);
+      if (generatedName) setGeneratedName();
+    }
+
+    @Nullable
+    public PsiClass getPsiElement() {
+      final String qualifiedName = data.getBehaviorClass();
+      return qualifiedName != null ? PsiManager.getInstance(getProject()).findClass(qualifiedName, GlobalSearchScope.allScope(project)) : null;
+    }
+
+    public void setPsiElement(final PsiClass psiClass) {
+      setName(psiClass.getQualifiedName());
+    }
+  };
+
+  public JBehaveConfiguration(String name, Project project, ConfigurationFactory factory) {
+    this(name, project, new ConfigurationData(), factory);
+  }
+
+  private JBehaveConfiguration(String name, Project project, ConfigurationData data, ConfigurationFactory factory) {
+    super(name, new RunConfigurationModule(project, false), factory);
+    this.data = ""
+    this.project = project;
+  }
+
+  public RunProfileState getState(DataContext dataContext, RunnerInfo runnerInfo, RunnerSettings runnerSettings, ConfigurationPerRunnerSettings configurationPerRunnerSettings) {
+    CommandLineState state = new CommandLineState(this, runnerSettings, configurationPerRunnerSettings);
+    state.setConsoleBuilder(TextConsoleBuilderFactory.getInstance().createBuilder(getProject()));
+    state.setModulesToCompile(getModules());
+    return state;
+  }
+
+  public ConfigurationData getData() {
+    return data;
+  }
+
+  @NotNull
+  public String getCoverageFileName() {
+    final String name = getGeneratedName();
+    if (name.equals(DEFAULT_PACKAGE_NAME)) {
+      return DEFAULT_PACKAGE_CONFIGURATION_NAME;
+    }
+    return name;
+  }
+
+  protected boolean isMergeDataByDefault() {
+    return false;
+  }
+
+  @Override
+  protected ModuleBasedConfiguration createInstance() {
+    return new JBehaveConfiguration(getName(), getProject(), data.copy(),
+                                    JBehaveConfigurationType.getInstance().getConfigurationFactories()[0]);
+  }
+
+  @Override
+  public Collection<Module> getValidModules() {
+    //TODO add handling for package
+    return RunConfigurationModule.getModulesForClass(getProject(), data.getBehaviorClass());
+  }
+
+  @Override
+  public boolean isGeneratedName() {
+    return data.isGeneratedName(getName());
+  }
+
+  @Override
+  public String suggestedName() {
+    return data.suggestName();
+  }
+
+  public void setProperty(int type, String value) {
+    switch (type) {
+      case RunJavaConfiguration.PROGRAM_PARAMETERS_PROPERTY:
+        break;
+
+      case RunJavaConfiguration.VM_PARAMETERS_PROPERTY:
+        data.setVmParameters(value);
+        break;
+
+      case RunJavaConfiguration.WORKING_DIRECTORY_PROPERTY:
+        setWorkingDirectoryPath(value);
+        break;
+    }
+  }
+
+  public String getProperty(int type) {
+    switch (type) {
+      case RunJavaConfiguration.PROGRAM_PARAMETERS_PROPERTY:
+        return "";
+
+      case RunJavaConfiguration.VM_PARAMETERS_PROPERTY:
+        return data.getVmParameters();
+
+      case RunJavaConfiguration.WORKING_DIRECTORY_PROPERTY:
+        return getWorkingDirectoryPath();
+    }
+    throw new IllegalArgumentException("unknow property " + type);
+  }
+
+  public void setClassConfiguration(PsiClass psiclass) {
+    setModule(ExecutionUtil.findModule(psiclass));
+    data.setBehaviorClass(psiclass.getQualifiedName());
+    setGeneratedName();
+  }
+
+  public void setPackageConfiguration(Module module, PsiPackage pkg) {
+    data.setPackageName(pkg.getQualifiedName());
+    setModule(module);
+    setGeneratedName();
+  }
+
+  public void setMethodConfiguration(Location<PsiMethod> location) {
+    PsiClass psiClass = location.getParentElement(PsiClass.class);
+    setClassConfiguration(psiClass);
+    data.setBehaviorMethod(location.getPsiElement().getName());
+    setGeneratedName();
+  }
+
+  public void setGeneratedName() {
+    setName(getGeneratedName());
+  }
+
+  public String getGeneratedName() {
+    return data.suggestName();
+  }
+
+  public void setModule(Module module) {
+    super.setModule(module);
+    data.setModuleName(module.getName());
+  }
+
+  public SettingsEditor<? extends RunConfiguration> getConfigurationEditor() {
+    SettingsEditorGroup<JBehaveConfiguration> group = new SettingsEditorGroup<JBehaveConfiguration>();
+    group.addEditor(ExecutionBundle.message("run.configuration.configuration.tab.title"), new JBehaveConfigurationEditor(getProject()));
+    group.addEditor(ExecutionBundle.message("coverage.tab.title"), new JBehaveCoverageConfigurationEditor(getProject()));
+    group.addEditor(ExecutionBundle.message("logs.tab.title"), new LogConfigurationPanel());
+    return group;
+  }
+
+  public boolean needAdditionalConsole() {
+    return false;
+  }
+
+  @Override
+  public void checkConfiguration() throws RuntimeConfigurationException {
+    final SourceScope scope = data.getScope().getSourceScope(this);
+    if (scope == null) {
+      throw new RuntimeConfigurationException("Invalid scope specified");
+    }
+    PsiClass psiClass = PsiManager.getInstance(project).findClass(data.getBehaviorClass(), scope.getGlobalSearchScope());
+    if (psiClass == null) {
+      throw new RuntimeConfigurationException("Invalid class '" + data.getBehaviorClass() + "'specified");
+    }
+    if (data.isMethodSpecified()) {
+      PsiMethod[] methods = psiClass.findMethodsByName(data.getBehaviourMethod(), true);
+      if (methods.length == 0) {
+        throw new RuntimeConfigurationException("Invalid method '" + data.getBehaviourMethod() + "'specified");
+      }
+      boolean foundSuitableMethod = false;
+      for (PsiMethod method : methods) {
+        if (method.getParameterList().getParametersCount() == 0) {
+          foundSuitableMethod = true;
+          break;
+        }
+      }
+      if (!foundSuitableMethod) {
+        throw new RuntimeConfigurationException("Method specified " + data.getBehaviourMethod() + " should not have any parameter");
+      }
+    }
+  }
+
+  @Override
+  public void readExternal(Element element)
+      throws InvalidDataException {
+    super.readExternal(element);
+    RunConfigurationField.readFromElement(data, element);
+  }
+
+  @Override
+  public void writeExternal(Element element)
+      throws WriteExternalException {
+    super.writeExternal(element);
+    RunConfigurationField.writeToElement(data, element);
+  }
+
+  @Nullable
+  public RefactoringElementListener getRefactoringElementListener(final PsiElement element) {
+    if (data.isMethodSpecified()) {
+      if (!(element instanceof PsiMethod)) {
+        return RefactoringListeners.getClassOrPackageListener(element, myClass);
+      }
+      final PsiMethod method = (PsiMethod) element;
+      if (!method.getName().equals(data.getBehaviourMethod())) return null;
+      if (!method.getContainingClass().equals(myClass.getPsiElement())) return null;
+      return new RefactoringElementListener()
+      {
+        public void elementMoved(PsiElement newElement) {
+          setMethod((PsiMethod) newElement);
+        }
+
+        public void elementRenamed(PsiElement newElement) {
+          setMethod((PsiMethod) newElement);
+        }
+
+        private void setMethod(PsiMethod psiMethod) {
+          boolean needToChangeName = isGeneratedName();
+          data.setBehaviorMethod(psiMethod.getName());
+          if (needToChangeName) {
+            setName(data.suggestName());
+          }
+        }
+      };
+    } else {
+      if (element instanceof PsiClass) {
+        return RefactoringListeners.getClassOrPackageListener(element, myClass);
+      }
+    }
+    return null;
+  }
+
+  public void restoreOriginalModule(final Module originalModule) {
+    if (originalModule == null) return;
+    final Module[] classModules = getModules();
+    final Collection<Module> modules = ModuleUtil.collectModulesDependsOn(Arrays.asList(classModules));
+    if (modules.contains(originalModule)) setModule(originalModule);
+  }
+
+  public void setWorkingDirectoryPath(String path) {
+    path = PathUtil.getCanonicalPath(path);
+    if (path.equals(projectBasePath())) {
+      path = null;
+    }
+    data.setWorkingPath(path);
+  }
+
+  public String getWorkingDirectoryPath() {
+    String value = data.getWorkingPath();
+    return value == null ? projectBasePath() : value;
+  }
+
+  private String projectBasePath() {
+    return PathUtil.getCanonicalPath(getProject().getBaseDir().getPath());
+  }
+}
\ No newline at end of file

Added: trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/JBehaveConfigurationEditor.java (0 => 777)

--- trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/JBehaveConfigurationEditor.java	                        (rev 0)
+++ trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/JBehaveConfigurationEditor.java	2007-08-04 01:57:52 UTC (rev 777)
@@ -0,0 +1,138 @@
+package org.jbehave.plugin.idea.selena;
+
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import javax.swing.*;
+
+import com.intellij.execution.junit.SourceScope;
+import com.intellij.execution.junit2.configuration.ClassBrowser;
+import com.intellij.ide.util.TreeClassChooser;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModuleManager;
+import com.intellij.openapi.options.ConfigurationException;
+import com.intellij.openapi.options.SettingsEditor;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.ui.TextFieldWithBrowseButton;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.search.GlobalSearchScope;
+import org.jetbrains.annotations.NotNull;
+
+public class JBehaveConfigurationEditor extends SettingsEditor<JBehaveConfiguration>
+{
+  private Project project;
+
+  private TextFieldWithBrowseButton behaviorClassInput;
+  private JComboBox moduleComponent;
+  private JComponent editorUi;
+
+  public JBehaveConfigurationEditor(Project project) {
+    this.project = project;
+    initComponents();
+  }
+
+  private void initComponents() {
+    initClassChooser();
+    initModuleComboBox();
+    editorUi = createEditorUi();
+  }
+
+  private void initClassChooser() {
+    behaviorClassInput = new TextFieldWithBrowseButton();
+    behaviorClassInput.addActionListener(new ActionListener()
+    {
+      public void actionPerformed(ActionEvent e) {
+        BehaviorClassBrowser browser = new BehaviorClassBrowser(project, "Choose Behavior");
+        browser.setField(behaviorClassInput);
+        behaviorClassInput.setText(browser.show());
+      }
+    });
+  }
+
+  private void initModuleComboBox() {
+    moduleComponent = new JComboBox(ModuleManager.getInstance(project).getSortedModules());
+    moduleComponent.setRenderer(new DefaultListCellRenderer()
+    {
+      public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
+        JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+        if (value != null) {
+          Module module = (Module) value;
+          label.setText(module.getName());
+          label.setIcon(module.getModuleType().getNodeIcon(false));
+        }
+        return label;
+      }
+    });
+    moduleComponent.setSelectedIndex(0);
+  }
+
+  private JComponent createEditorUi() {
+    JPanel panel = new JPanel();
+    panel.setLayout(new GridBagLayout());
+    panel.add(behaviorClassInput, new GridBagConstraints(
+        0, 0, 1, 1, 1.0, 0.0, GridBagConstraints.CENTER, GridBagConstraints.HORIZONTAL,
+        new Insets(4, 4, 0, 4), 0, 0
+    ));
+    panel.add(new Label("Use classpath and JDK of module:"), new GridBagConstraints(
+        0, 1, 1, 1, 1.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL,
+        new Insets(4, 4, 0, 4), 0, 0
+    ));
+    panel.add(moduleComponent, new GridBagConstraints(
+        0, 2, 1, 1, 1.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL,
+        new Insets(4, 4, 0, 4), 0, 0
+    ));
+    panel.add(new JPanel(), new GridBagConstraints(
+        0, 5, 1, 1, 1.0, 1.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH,
+        new Insets(0, 0, 0, 0), 0, 0
+    ));
+    return panel;
+  }
+
+  protected void resetEditorFrom(JBehaveConfiguration configuration) {
+    ConfigurationData data = ""
+    behaviorClassInput.setText(data.getBehaviorClass());
+    moduleComponent.setSelectedItem(data.getModule(project));
+  }
+
+  protected void applyEditorTo(JBehaveConfiguration configuration) throws ConfigurationException {
+    ConfigurationData data = ""
+    data.setBehaviorClass(behaviorClassInput.getText());
+    configuration.setModule((Module) moduleComponent.getSelectedItem());
+  }
+
+  @NotNull
+  protected JComponent createEditor() {
+    return editorUi;
+  }
+
+  protected void disposeEditor() {
+  }
+
+  private static class BehaviorClassBrowser extends ClassBrowser
+  {
+    public BehaviorClassBrowser(Project project, String name) {
+      super(project, name);
+    }
+
+    protected TreeClassChooser.ClassFilterWithScope getFilter() throws NoFilterException {
+      return new TreeClassChooser.ClassFilterWithScope()
+      {
+        public GlobalSearchScope getScope() {
+          return SourceScope.wholeProject(getProject()).getGlobalSearchScope();
+        }
+
+        public boolean isAccepted(PsiClass aClass) {
+          return true;
+        }
+      };
+    }
+
+    protected PsiClass findClass(String name) {
+      return null;
+    }
+
+    public String show() {
+      return super.showDialog();
+    }
+  }
+}

Copied: trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/JBehaveConfigurationProducer.java (from rev 776, trunk/plugins/intellij/src/org/jbehave/plugin/idea/JBehaveConfigurationProducer.java) (0 => 777)

--- trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/JBehaveConfigurationProducer.java	                        (rev 0)
+++ trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/JBehaveConfigurationProducer.java	2007-08-04 01:57:52 UTC (rev 777)
@@ -0,0 +1,47 @@
+package org.jbehave.plugin.idea.selena;
+
+import com.intellij.execution.ExecutionUtil;
+import com.intellij.execution.Location;
+import com.intellij.execution.actions.ConfigurationContext;
+import com.intellij.execution.impl.RunnerAndConfigurationSettingsImpl;
+import com.intellij.execution.junit.RuntimeConfigurationProducer;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiMethod;
+
+public class JBehaveConfigurationProducer extends RuntimeConfigurationProducer implements Cloneable
+{
+  private PsiClass behaviorClass;
+  private JBehaveConfigurationType configurationType;
+
+  public JBehaveConfigurationProducer(PsiClass behaviorClass, JBehaveConfigurationType configurationType) {
+    super(configurationType);
+    this.behaviorClass = behaviorClass;
+    this.configurationType = configurationType;
+  }
+
+  public PsiElement getSourceElement() {
+    return behaviorClass;
+  }
+
+  protected RunnerAndConfigurationSettingsImpl createConfigurationByElement(Location location, ConfigurationContext configurationContext) {
+    location = ExecutionUtil.stepIntoSingleClass(location);
+    PsiClass aClass = configurationType.getBehaviorClass(location.getPsiElement());
+    if (aClass == null) return null;
+    PsiMethod currentMethod = configurationType.getBehaviourMethodElement(location.getPsiElement());
+    RunnerAndConfigurationSettingsImpl settings = cloneTemplateConfiguration(location.getProject(), configurationContext);
+    JBehaveConfiguration configuration = (JBehaveConfiguration) settings.getConfiguration();
+    ConfigurationData data = ""
+    data.setBehaviorClass(aClass.getQualifiedName());
+    if (currentMethod != null) {
+      data.setBehaviorMethod(currentMethod.getName());
+    }
+    configuration.setModule(ExecutionUtil.findModule(aClass));
+    configuration.setName(data.suggestName());
+    return settings;
+  }
+
+  public int compareTo(Object o) {
+    return PREFERED;
+  }
+}
\ No newline at end of file

Copied: trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/JBehaveConfigurationType.java (from rev 776, trunk/plugins/intellij/src/org/jbehave/plugin/idea/JBehaveConfigurationType.java) (0 => 777)

--- trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/JBehaveConfigurationType.java	                        (rev 0)
+++ trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/JBehaveConfigurationType.java	2007-08-04 01:57:52 UTC (rev 777)
@@ -0,0 +1,197 @@
+package org.jbehave.plugin.idea.selena;
+
+import javax.swing.*;
+
+import com.intellij.execution.LocatableConfigurationType;
+import com.intellij.execution.Location;
+import com.intellij.execution.RunnerAndConfigurationSettings;
+import com.intellij.execution.configurations.ConfigurationFactory;
+import com.intellij.execution.configurations.RunConfiguration;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Comparing;
+import com.intellij.psi.*;
+import com.intellij.psi.search.GlobalSearchScope;
+import org.jbehave.plugin.idea.Constants;
+import org.jetbrains.annotations.NotNull;
+
+public class JBehaveConfigurationType implements LocatableConfigurationType
+{
+  private final ConfigurationFactory factory;
+
+  public JBehaveConfigurationType() {
+    this.factory = new ConfigurationFactory(this)
+    {
+
+      public RunConfiguration createTemplateConfiguration(Project project) {
+        return new JBehaveConfiguration("", project, this);
+      }
+    };
+  }
+
+  public String getDisplayName() {
+    return "JBehave";
+  }
+
+  public String getConfigurationTypeDescription() {
+    return "JBehave Configuration";
+  }
+
+  public Icon getIcon() {
+    return Constants.LOGO;
+  }
+
+  public ConfigurationFactory[] getConfigurationFactories() {
+    return new ConfigurationFactory[] {factory};
+  }
+
+  @NotNull
+  public String getComponentName() {
+    return "#org.jbehave.plugin.idea.JBehaveConfigurationType";
+  }
+
+  public void initComponent() {
+  }
+
+  public void disposeComponent() {
+  }
+
+  public boolean isConfigurationByElement(RunConfiguration configuration, Project project, PsiElement element) {
+    PsiClass behaviorClass = getBehaviorClass(element);
+    if (behaviorClass == null)
+      return false;
+    ConfigurationData data = "" configuration).getData();
+    return Comparing.equal(behaviorClass.getQualifiedName(), data.getBehaviorClass())
+        && Comparing.equal(getBehaviourMethodName(element), data.getBehaviourMethod());
+  }
+
+  private String getBehaviourMethodName(PsiElement element) {
+    PsiMethod method = getBehaviourMethodElement(element);
+    return method == null ? null : method.getName();
+  }
+
+  public PsiClass getBehaviorClass(PsiElement element) {
+    for (PsiElement current = element; current != null; current = current.getParent()) {
+      if (current instanceof PsiClass) {
+        PsiClass currentClass = (PsiClass) current;
+        if (isBehaviorClass(currentClass)) {
+          return currentClass;
+        }
+      } else if (current instanceof PsiFile) {
+        PsiClass psiClass = getMainClass((PsiFile) current);
+        if (psiClass != null && isBehaviorClass(psiClass)) {
+          return psiClass;
+        }
+      }
+    }
+    PsiFile file = element.getContainingFile();
+    if (file instanceof PsiJavaFile) {
+      PsiClass[] definedClasses = ((PsiJavaFile) file).getClasses();
+      for (int i = 0; i < definedClasses.length; i++) {
+        PsiClass definedClass = definedClasses[i];
+        if (isBehaviorClass(definedClass)) {
+          return definedClass;
+        }
+      }
+      for (int i = 0; i < definedClasses.length; i++) {
+        PsiClass definedClass = definedClasses[i];
+        PsiClass behaviorCandidate = checkIfThereIsOneWithBehaviorAtEnd(definedClass);
+        if (behaviorCandidate != null && isBehaviorClass(behaviorCandidate)) {
+          return behaviorCandidate;
+        }
+      }
+    }
+    return null;
+  }
+
+  private PsiClass checkIfThereIsOneWithBehaviorAtEnd(PsiClass psiClass) {
+    String nameToCheck = psiClass.getQualifiedName() + "Behavior";
+    Project project = psiClass.getProject();
+    return PsiManager.getInstance(project).findClass(nameToCheck, GlobalSearchScope.allScope(project));
+  }
+
+  private PsiClass getMainClass(PsiFile psiFile) {
+    if (psiFile instanceof PsiJavaFile) {
+      PsiJavaFile javaFile = (PsiJavaFile) psiFile;
+      PsiClass[] definedClasses = javaFile.getClasses();
+      for (int i = 0; i < definedClasses.length; i++) {
+        PsiClass definedClass = definedClasses[i];
+        if (isPublic(definedClass)) {
+          return definedClass;
+        }
+      }
+    }
+    return null;
+  }
+
+  private boolean isBehaviorClass(PsiClass psiClass) {
+    if (!isRunnableClass(psiClass)) {
+      return false;
+    }
+    return implementsBehaviorsInterface(psiClass) || containsShouldMethod(psiClass);
+  }
+
+  private boolean implementsBehaviorsInterface(PsiClass psiClass) {
+    PsiClassType[] interfaces = psiClass.getImplementsListTypes();
+    for (int i = 0; i < interfaces.length; i++) {
+      PsiClassType anInterface = interfaces[i];
+      if (Constants.BEHAVIOURS_INTERFACE.equals(anInterface.resolve().getQualifiedName())) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private boolean containsShouldMethod(PsiClass psiClass) {
+    PsiMethod[] methods = psiClass.getAllMethods();
+    for (int i = 0; i < methods.length; i++) {
+      if (isBehaviorMethod(methods[i])) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private boolean isRunnableClass(PsiClass psiClass) {
+    return isPublic(psiClass) && !psiClass.isInterface() && !isAbstract(psiClass);
+  }
+
+  private boolean isAbstract(PsiModifierListOwner definition) {
+    return definition.getModifierList().hasModifierProperty("abstract");
+  }
+
+  private boolean isBehaviorMethod(PsiMethod method) {
+    return method.getName().startsWith("should") && isPublic(method) && isVoid(method);
+  }
+
+  private boolean isPublic(PsiModifierListOwner definition) {
+    PsiModifierList modifierList = definition.getModifierList();
+    return modifierList != null && modifierList.hasModifierProperty("public");
+  }
+
+  private boolean isVoid(PsiMethod method) {
+    return PsiType.VOID.equals(method.getReturnType());
+  }
+
+  public RunnerAndConfigurationSettings createConfigurationByLocation(Location location) {
+    PsiClass behaviorClass = getBehaviorClass(location.getPsiElement());
+    if (behaviorClass == null) {
+      return null;
+    }
+    return new JBehaveConfigurationProducer(behaviorClass, this).createProducer(location, null).getConfiguration();
+  }
+
+  public static JBehaveConfigurationType getInstance() {
+    return ApplicationManager.getApplication().getComponent(JBehaveConfigurationType.class);
+  }
+
+  public PsiMethod getBehaviourMethodElement(PsiElement psiElement) {
+    if (psiElement instanceof PsiIdentifier && psiElement.getParent() instanceof PsiMethod) {
+      PsiMethod method = (PsiMethod) psiElement.getParent();
+      if (method.getName().startsWith("should")) {
+        return method;
+      }
+    }
+    return null;
+  }
+}
\ No newline at end of file

Added: trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/JBehaveCoverageConfigurationEditor.java (0 => 777)

--- trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/JBehaveCoverageConfigurationEditor.java	                        (rev 0)
+++ trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/JBehaveCoverageConfigurationEditor.java	2007-08-04 01:57:52 UTC (rev 777)
@@ -0,0 +1,19 @@
+package org.jbehave.plugin.idea.selena;
+
+import com.intellij.execution.configurations.coverage.CoverageConfigurable;
+import com.intellij.execution.util.JreVersionDetector;
+import com.intellij.openapi.project.Project;
+
+public class JBehaveCoverageConfigurationEditor extends CoverageConfigurable<JBehaveConfiguration>
+{
+  private JreVersionDetector myVersionDetector = new JreVersionDetector();
+
+  public JBehaveCoverageConfigurationEditor(Project project) {
+    super(project);
+  }
+
+  protected boolean isJre50Configured(JBehaveConfiguration configuration) {
+    return myVersionDetector
+        .isJre50Configured(configuration, configuration.ALTERNATIVE_JRE_PATH_ENABLED, configuration.ALTERNATIVE_JRE_PATH);
+  }
+}

Copied: trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/RunConfigurationField.java (from rev 776, trunk/plugins/intellij/src/org/jbehave/plugin/idea/RunConfigurationField.java) (0 => 777)

--- trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/RunConfigurationField.java	                        (rev 0)
+++ trunk/plugins/intellij/src/org/jbehave/plugin/idea/selena/RunConfigurationField.java	2007-08-04 01:57:52 UTC (rev 777)
@@ -0,0 +1,97 @@
+package org.jbehave.plugin.idea.selena;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.intellij.openapi.util.InvalidDataException;
+import org.jdom.Element;
+
+abstract public class RunConfigurationField
+{
+  private static Map<String, RunConfigurationField> fields = new HashMap<String, RunConfigurationField>();
+  private String name;
+
+  public RunConfigurationField(String name) {
+    this.name = name;
+    fields.put(name, this);
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  abstract public String getValue(ConfigurationData configuration);
+
+  abstract public void setValue(ConfigurationData configuration, String value);
+
+  public static RunConfigurationField getField(String fieldName) {
+    RunConfigurationField field = fields.get(fieldName);
+    return field == null ? NULL : field;
+  }
+
+  public static final RunConfigurationField NULL = new RunConfigurationField("")
+  {
+    public String getValue(ConfigurationData configuration) {
+      return "";
+    }
+
+    public void setValue(ConfigurationData configuration, String value) {
+    }
+  };
+
+  public static final RunConfigurationField CLASS_NAME = new RunConfigurationField("behaviorClass")
+  {
+    public String getValue(ConfigurationData configuration) {
+      return configuration.getBehaviorClass();
+    }
+
+    public void setValue(ConfigurationData configuration, String value) {
+      configuration.setBehaviorClass(value);
+    }
+  };
+
+  public static final RunConfigurationField METHOD_NAME = new RunConfigurationField("behaviorMethod")
+  {
+    public String getValue(ConfigurationData configuration) {
+      return configuration.getBehaviourMethod();
+    }
+
+    public void setValue(ConfigurationData configuration, String value) {
+      configuration.setBehaviorMethod(value);
+    }
+  };
+
+  public static final RunConfigurationField MODULE = new RunConfigurationField("moduleName")
+  {
+    public String getValue(ConfigurationData configuration) {
+      return configuration.getModuleName();
+    }
+
+    public void setValue(ConfigurationData configuration, String value) {
+      configuration.setModuleName(value);
+    }
+  };
+
+  public static void writeToElement(ConfigurationData data, Element parentNode) {
+    for (RunConfigurationField field : fields.values()) {
+      String value = field.getValue(data);
+      if (value.length() != 0) {
+        Element element = new Element("option");
+        parentNode.addContent(element);
+        element.setAttribute("name", field.getName());
+        element.setAttribute("value", value);
+      }
+    }
+  }
+
+  static void readFromElement(ConfigurationData data, Element element) throws InvalidDataException {
+    for (final Object o : element.getChildren("option")) {
+      Element e = (Element) o;
+      String fieldName = e.getAttributeValue("name");
+      if (fieldName == null) {
+        throw new InvalidDataException("element should have name attribute:" + element);
+      }
+      getField(fieldName).setValue(data, e.getAttributeValue("value"));
+    }
+  }
+}
\ No newline at end of file

To unsubscribe from this list please visit:

http://xircles.codehaus.org/manage_email

Reply via email to