public RunProfileState getState()

in src/java/org/jetbrains/plugins/clojure/runner/ClojureScriptRunConfiguration.java [181:276]
76 lines of code
12 McCabe index (conditional complexity)

  public RunProfileState getState(@NotNull Executor executor, @NotNull ExecutionEnvironment environment) throws ExecutionException {
    final Module module = getModule();
    if (module == null) {
      throw new ExecutionException("Module is not specified");
    }

    final ModuleRootManager rootManager = ModuleRootManager.getInstance(module);
    final Sdk sdk = rootManager.getSdk();
    if (sdk == null || !(sdk.getSdkType() instanceof JavaSdkType)) {
      throw CantRunException.noJdkForModule(getModule());
    }

    final Project project = module.getProject();
    if (!org.jetbrains.plugins.clojure.config.ClojureConfigUtil.isClojureConfigured(module)) {
      Messages.showErrorDialog(project,
          ClojureBundle.message("error.running.configuration.with.error.error.message", getName(),
              ClojureBundle.message("clojure.lib.is.not.attached")),
          ClojureBundle.message("run.error.message.title"));

      ModulesConfigurator.showDialog(project, module.getName(), ClasspathEditor.NAME);
      return null;
    }

    final ClojureConfigUtil.RunConfigurationParameters params =
        new ClojureConfigUtil.RunConfigurationParameters();

    final String namespace;

    if (runMainFunction) {
      final VirtualFile virtualFile = VfsUtil.findFileByIoFile(new File(scriptPath), true);
      if (virtualFile == null) {
        showCannotDetermineNamespaceError();
        return null;
      }

      final PsiFile file = PsiManager.getInstance(getProject()).findFile(virtualFile);
      if (!(file instanceof ClojureFile)) {
        showCannotDetermineNamespaceError();
        return null;
      }

      final String ns = ((ClojureFile) file).getNamespace();
      if (ns == null) {
        showCannotDetermineNamespaceError();
        return null;
      }

      namespace = ns;
    } else {
      namespace = null;
    }

    final JavaCommandLineState state = new JavaCommandLineState(environment) {
      protected JavaParameters createJavaParameters() throws ExecutionException {
        ProgramParametersUtil.configureConfiguration(params, ClojureScriptRunConfiguration.this);

        configureJavaParams(params, module);

        final ParametersList list = params.getProgramParametersList();

        if (runMainFunction) {
          configureMainFunction(list, namespace);
        } else {
          configureScript(list);
        }

        return params;
      }
    };

    final TextConsoleBuilderImpl builder = new TextConsoleBuilderImpl(project) {
      private final ArrayList<Filter> filters = new ArrayList<Filter>();

      @Override
      public ConsoleView getConsole() {
        final ConsoleViewImpl view = new ConsoleViewImpl(project, false);
        for (Filter filter : filters) {
          view.addMessageFilter(filter);
        }
        return view;
      }

      @Override
      public void addFilter(Filter filter) {
        filters.add(filter);
      }
    };

    state.setConsoleBuilder(builder);

    if (params.isDefaultClojureJarUsed()) {
      ClojureConfigUtil.warningDefaultClojureJar(module);
    }
    return state;

  }