public ProgramCommandLine makeProgramCommandLine()

in rake-runner-agent/src/jetbrains/buildServer/agent/rakerunner/RakeTasksBuildService.java [45:182]
81 lines of code
16 McCabe index (conditional complexity)

  public ProgramCommandLine makeProgramCommandLine() throws RunBuildException {
    RVMPathsSettings.getInstanceEx().initialize(getBuildParameters().getEnvironmentVariables());
    RbEnvPathsSettings.getInstance().initialize(getBuildParameters().getEnvironmentVariables());

    final List<String> arguments = new ArrayList<String>();
    final BuildRunnerContext context = getRunnerContext();
    final ModifiableRunnerContext mc = new ModifiableRunnerContext(context);

    // runParams - all server-ui options
    // buildParams - system properties (system.*), environment vars (env.*)
    final Map<String, String> runParams = mc.getRunnerParameters();
    final Map<String, String> buildParams = mc.getBuildParameters();
    final EnvironmentPatchableMap env = mc.getEnvParameters();

    // apply options converter
    SupportedTestFramework.convertOptionsIfNecessary(runParams);

    final File buildFile = getBuildFile(runParams);

    final RakeRunnerUtils.RubyConfigMode interpreterConfigMode = RakeRunnerUtils.getRubyInterpreterConfigMode(runParams);
    final SharedParams shared = SharedParams.fromRunParameters(runParams);
    final boolean rubyEnvAlreadyConfigured = shared.isSetted(); // Do not inline!!!


    try {
      validateRunnerParams(interpreterConfigMode, runParams, shared);
      // configure params in terms of "shared params"
      configureRunnerParams(interpreterConfigMode, runParams, shared);

      shared.applyToParameters(runParams);

      // Sdk
      final RubySdk sdk = RubySDKUtil.createAndSetupSdk(runParams, context);


      if (!(interpreterConfigMode == RakeRunnerUtils.RubyConfigMode.DEFAULT && rubyEnvAlreadyConfigured)) {
        // 1. default, but build feature wasn't configured
        // 2. rvm or interpreter path

        // Inspect env, warn about any problems
        // (if defaults were set by smb else we cannot check them)
        RVMSupportUtil.inspectCurrentEnvironment(env, sdk, getBuild().getBuildLogger());

        if (SdkUtil.isRvmSdk(sdk)) {
          // Patch env for RVM
          RVMSupportUtil.patchEnvForRVMIfNecessary(sdk, env);

          if (sdk.isSystem()) {
            // Also Patch path for fake RVM
            RubySDKUtil.patchPathEnvForNonRvmOrSystemRvmSdk(sdk, mc);
          }
        } else {
          if (interpreterConfigMode == RakeRunnerUtils.RubyConfigMode.INTERPRETER_PATH) {
            // non-rvm sdk
            RubySDKUtil.patchPathEnvForNonRvmOrSystemRvmSdk(sdk, mc);
          }
        }
      }

      // loadpath patch for test runners
      addTestRunnerPatchFiles(sdk, mc);

      // attached frameworks info
      if (SupportedTestFramework.isAnyFrameworkActivated(runParams)) {
        env.put(RAKERUNNER_USED_FRAMEWORKS_KEY, SupportedTestFramework.getActivatedFrameworksConfig(runParams));
      }

      // track invoke/execute stages
      if (ConfigurationParamsUtil.isTraceStagesOptionEnabled(runParams)) {
        env.put(RAKE_TRACE_INVOKE_EXEC_STAGES_ENABLED_KEY, Boolean.TRUE.toString());
      }

      // Interpreter parameters
      final String additionalInterpreterParams = runParams.get(SERVER_UI_RUBY_INTERPRETER_ADDITIONAL_PARAMS);
      if (!TextUtil.isEmptyOrWhitespaced(additionalInterpreterParams)) {
        addCmdlineArguments(arguments, additionalInterpreterParams);
      }

      // Rake runner script
      final String rakeRunnerPath;
      final String customRakeRunnerScript = buildParams.get(CUSTOM_RAKERUNNER_SCRIPT);
      if (!StringUtil.isEmpty(customRakeRunnerScript)) {
        // use custom runner
        rakeRunnerPath = customRakeRunnerScript;
      } else {
        // default one
        rakeRunnerPath = RubyProjectSourcesUtil.getRakeRunnerPath();
      }
      arguments.add(rakeRunnerPath);

      // Rake gem version
      addGemVersionAttribute(arguments, RAKE_GEM_VERSION_PROPERTY, buildParams);

      // Rake options
      // Custom Rakefile if specified
      if (buildFile != null) {
        arguments.add(RAKE_CMDLINE_OPTIONS_RAKEFILE);
        arguments.add(buildFile.getAbsolutePath());
      }

      // Other arguments
      final String userDefinedArgs = runParams.get(SERVER_UI_RAKE_ADDITIONAL_CMD_PARAMS_PROPERTY);
      if (!TextUtil.isEmptyOrWhitespaced(userDefinedArgs)) {
        addCmdlineArguments(arguments, userDefinedArgs);
      }

      // Tasks names
      final String tasks_names = runParams.get(SERVER_UI_RAKE_TASKS_PROPERTY);
      if (!PropertiesUtil.isEmptyOrNull(tasks_names)) {
        addCmdlineArguments(arguments, tasks_names);
      }

      // rspec
      env.putAll(attachRSpecFormatterIfNeeded(runParams));

      // cucumber
      env.putAll(attachCucumberFormatterIfNeeded(runParams));

      // Bundle exec emulation:
      // (do not do it before RVM Env patch!!!!!!)
      BundlerUtil.enableBundleExecEmulationIfNeeded(sdk, mc);


      // Result:
      final HashMap<String, String> ret = new HashMap<String, String>();
      for (Map.Entry<String, String> entry : env.getPatched().entrySet()) {
        if (!StringUtil.isEmptyOrSpaces(entry.getValue())) {
          ret.put(entry.getKey(), entry.getValue());
        }
      }
      return new SimpleProgramCommandLine(ret,
        getWorkingDirectory().getAbsolutePath(),
        sdk.getRubyExecutable().getAbsolutePath(),
        arguments);
    } catch (MyBuildFailureException e) {
      throw new RunBuildException(e.getMessage(), e);
    }
  }