blaze-java/src/com/google/idea/blaze/java/run/BlazeCommandRunConfiguration.java - intellij - Git at Google

 /*
  * Copyright 2016 The Bazel Authors. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.google.idea.blaze.java.run;

 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Strings;
 import com.google.common.collect.ImmutableList;
 import com.google.idea.blaze.base.command.BlazeCommandName;
 import com.google.idea.blaze.base.model.primitives.Label;
 import com.google.idea.blaze.base.model.primitives.TargetExpression;
 import com.google.idea.blaze.base.run.BlazeRunConfiguration;
 import com.google.idea.blaze.base.settings.Blaze;
 import com.google.idea.blaze.base.ui.UiUtil;
 import com.intellij.execution.ExecutionException;
 import com.intellij.execution.Executor;
 import com.intellij.execution.configurations.ConfigurationFactory;
 import com.intellij.execution.configurations.LocatableConfigurationBase;
 import com.intellij.execution.configurations.RuntimeConfigurationError;
 import com.intellij.execution.configurations.RuntimeConfigurationException;
 import com.intellij.execution.executors.DefaultDebugExecutor;
 import com.intellij.execution.runners.ExecutionEnvironment;
 import com.intellij.openapi.options.ConfigurationException;
 import com.intellij.openapi.options.SettingsEditor;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.ComboBox;
 import com.intellij.openapi.util.InvalidDataException;
 import com.intellij.openapi.util.WriteExternalException;
 import com.intellij.util.execution.ParametersListUtil;
 import org.jdom.Element;

 import javax.annotation.Nullable;
 import javax.swing.*;
 import java.util.List;

 /**
  * A run configuration which executes Blaze commands.
  */
 public class BlazeCommandRunConfiguration extends LocatableConfigurationBase implements BlazeRunConfiguration {
   private static final String TARGET_TAG = "blaze-target";
   private static final String COMMAND_ATTR = "blaze-command";
   private static final String USER_BLAZE_FLAG_TAG = "blaze-user-flag";
   private static final String USER_EXE_FLAG_TAG = "blaze-user-exe-flag";

   protected final String buildSystemName;

   @Nullable private TargetExpression target;
   @Nullable private BlazeCommandName command;
   private ImmutableList<String> blazeFlags = ImmutableList.of();
   private ImmutableList<String> exeFlags = ImmutableList.of();

   public BlazeCommandRunConfiguration(Project project,
                                       ConfigurationFactory factory,
                                       String name) {
     super(project, factory, name);
     buildSystemName = Blaze.buildSystemName(project);
   }

   @Override
   @Nullable
   public TargetExpression getTarget() {
     return target;
   }

   @Nullable
   public BlazeCommandName getCommand() {
     return command;
   }

   /**
    * @return The list of blaze flags that the user specified manually.
    */
   protected List<String> getBlazeFlags() {
     return blazeFlags;
   }

   /**
    * @return The list of executable flags the user specified manually.
    */
   protected List<String> getExeFlags() {
     return exeFlags;
   }

   /**
    * @return The list of all flags to be used on the Blaze command line for blaze. Subclasses should override this method to add flags for
    * higher-level settings (e.g. "run locally").
    */
   public List<String> getAllBlazeFlags() {
     return getBlazeFlags();
   }

   /**
    * @return The list of all flags to be used for the executable on the Blaze command line. Subclasses should override this method to add
    * flags if desired.
    */
   public List<String> getAllExeFlags() {
     return getExeFlags();
   }

   public void setTarget(@Nullable TargetExpression target) {
     this.target = target;
   }

   public void setCommand(@Nullable BlazeCommandName command) {
     this.command = command;
   }

   public final void setBlazeFlags(List<String> flags) {
     this.blazeFlags = ImmutableList.copyOf(flags);
   }

   public final void setExeFlags(List<String> flags) {
     this.exeFlags = ImmutableList.copyOf(flags);
   }

   @Override
   public void checkConfiguration() throws RuntimeConfigurationException {
     if (target == null) {
       throw new RuntimeConfigurationError(String.format("You must specify a %s target expression.", buildSystemName));
     }
     if (command == null) {
       throw new RuntimeConfigurationError(String.format("You must specify a command.", buildSystemName));
     }
   }

   @Override
   public void readExternal(Element element) throws InvalidDataException {
     super.readExternal(element);
     // Target is persisted as a tag to permit multiple targets in the future.
     Element targetElement = element.getChild(TARGET_TAG);
     if (targetElement != null && !Strings.isNullOrEmpty(targetElement.getTextTrim())) {
       target = TargetExpression.fromString(targetElement.getTextTrim());
     }
     else {
       target = null;
     }
     String commandString = element.getAttributeValue(COMMAND_ATTR);
     command = Strings.isNullOrEmpty(commandString) ?
               null : BlazeCommandName.fromString(commandString);
     blazeFlags = loadUserFlags(element, USER_BLAZE_FLAG_TAG);
     exeFlags = loadUserFlags(element, USER_EXE_FLAG_TAG);
   }

   private static ImmutableList<String> loadUserFlags(Element root, String tag) {
     ImmutableList.Builder<String> flagsBuilder = ImmutableList.builder();
     for (Element e : root.getChildren(tag)) {
       String flag = e.getTextTrim();
       if (flag != null && !flag.isEmpty()) {
         flagsBuilder.add(flag);
       }
     }
     return flagsBuilder.build();
   }

   @Override
   public void writeExternal(Element element) throws WriteExternalException {
     super.writeExternal(element);
     if (target != null) {
       // Target is persisted as a tag to permit multiple targets in the future.
       Element targetElement = new Element(TARGET_TAG);
       targetElement.setText(target.toString());
       element.addContent(targetElement);
     }
     if (command != null) {
       element.setAttribute(COMMAND_ATTR, command.toString());
     }
     saveUserFlags(element, blazeFlags, USER_BLAZE_FLAG_TAG);
     saveUserFlags(element, exeFlags, USER_EXE_FLAG_TAG);
   }

   private static void saveUserFlags(Element root, List<String> flags, String tag) {
     for (String flag : flags) {
       Element child = new Element(tag);
       child.setText(flag);
       root.addContent(child);
     }
   }

   @Override
   public BlazeCommandRunConfiguration clone() {
     final BlazeCommandRunConfiguration configuration = (BlazeCommandRunConfiguration)super.clone();
     configuration.target = target;
     configuration.command = command;
     configuration.blazeFlags = blazeFlags;
     configuration.exeFlags = exeFlags;
     return configuration;
   }

   @Override
   @Nullable
   public String suggestedName() {
     TargetExpression target = getTarget();
     if (!(target instanceof Label)) {
       return null;
     }
     return String.format("%s %s: %s", buildSystemName, command.toString(), ((Label)target).ruleName().toString());
   }


   @Nullable
   @Override
   public BlazeCommandRunProfileState getState(Executor executor,
                                               ExecutionEnvironment environment) throws ExecutionException {
     return new BlazeCommandRunProfileState(environment, executor instanceof DefaultDebugExecutor);
   }

   @Override
   public SettingsEditor<? extends BlazeCommandRunConfiguration> getConfigurationEditor() {
     return new BlazeCommandRunConfigurationSettingsEditor(buildSystemName);
   }

   @VisibleForTesting
   static class BlazeCommandRunConfigurationSettingsEditor extends SettingsEditor<BlazeCommandRunConfiguration> {
     private final String buildSystemName;
     private final JTextField targetField = new JTextField();
     private final ComboBox commandCombo;
     private final JTextArea blazeFlagsField = new JTextArea(5, 0);
     private final JTextArea exeFlagsField = new JTextArea(5, 0);

     public BlazeCommandRunConfigurationSettingsEditor(String buildSystemName) {
       this.buildSystemName = buildSystemName;
       commandCombo = new ComboBox(
         new DefaultComboBoxModel(BlazeCommandName.knownCommands().toArray()));
       // Allow the user to manually specify an unlisted command.
       commandCombo.setEditable(true);
     }

     @VisibleForTesting
     @Override
     public void resetEditorFrom(BlazeCommandRunConfiguration s) {
       targetField.setText(s.target == null ? null : s.target.toString());
       commandCombo.setSelectedItem(s.command);
       blazeFlagsField.setText(ParametersListUtil.join(s.blazeFlags));
       exeFlagsField.setText(ParametersListUtil.join(s.exeFlags));
     }

     @VisibleForTesting
     @Override
     public void applyEditorTo(BlazeCommandRunConfiguration s) throws ConfigurationException {
       String targetString = targetField.getText();
       s.target = Strings.isNullOrEmpty(targetString) ?
                  null : TargetExpression.fromString(targetString);
       Object selectedCommand = commandCombo.getSelectedItem();
       if (selectedCommand instanceof BlazeCommandName) {
         s.command = (BlazeCommandName)selectedCommand;
       }
       else {
         s.command = Strings.isNullOrEmpty((String)selectedCommand) ?
                     null : BlazeCommandName.fromString(selectedCommand.toString());
       }
       s.blazeFlags = ImmutableList.copyOf(ParametersListUtil.parse(Strings.nullToEmpty(blazeFlagsField.getText())));
       s.exeFlags = ImmutableList.copyOf(ParametersListUtil.parse(Strings.nullToEmpty(exeFlagsField.getText())));
     }

     @Override
     protected JComponent createEditor() {
       return UiUtil.createBox(
         new JLabel("Target expression:"),
         targetField,
         new JLabel(buildSystemName + " command:"),
         commandCombo,
         new JLabel(buildSystemName +" flags:"),
         blazeFlagsField,
         new JLabel("Executable flags:"),
         exeFlagsField
       );
     }
   }
 }
	/*
	* Copyright 2016 The Bazel Authors. All rights reserved.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.google.idea.blaze.java.run;

	import com.google.common.annotations.VisibleForTesting;
	import com.google.common.base.Strings;
	import com.google.common.collect.ImmutableList;
	import com.google.idea.blaze.base.command.BlazeCommandName;
	import com.google.idea.blaze.base.model.primitives.Label;
	import com.google.idea.blaze.base.model.primitives.TargetExpression;
	import com.google.idea.blaze.base.run.BlazeRunConfiguration;
	import com.google.idea.blaze.base.settings.Blaze;
	import com.google.idea.blaze.base.ui.UiUtil;
	import com.intellij.execution.ExecutionException;
	import com.intellij.execution.Executor;
	import com.intellij.execution.configurations.ConfigurationFactory;
	import com.intellij.execution.configurations.LocatableConfigurationBase;
	import com.intellij.execution.configurations.RuntimeConfigurationError;
	import com.intellij.execution.configurations.RuntimeConfigurationException;
	import com.intellij.execution.executors.DefaultDebugExecutor;
	import com.intellij.execution.runners.ExecutionEnvironment;
	import com.intellij.openapi.options.ConfigurationException;
	import com.intellij.openapi.options.SettingsEditor;
	import com.intellij.openapi.project.Project;
	import com.intellij.openapi.ui.ComboBox;
	import com.intellij.openapi.util.InvalidDataException;
	import com.intellij.openapi.util.WriteExternalException;
	import com.intellij.util.execution.ParametersListUtil;
	import org.jdom.Element;

	import javax.annotation.Nullable;
	import javax.swing.*;
	import java.util.List;

	/**
	* A run configuration which executes Blaze commands.
	*/
	public class BlazeCommandRunConfiguration extends LocatableConfigurationBase implements BlazeRunConfiguration {
	private static final String TARGET_TAG = "blaze-target";
	private static final String COMMAND_ATTR = "blaze-command";
	private static final String USER_BLAZE_FLAG_TAG = "blaze-user-flag";
	private static final String USER_EXE_FLAG_TAG = "blaze-user-exe-flag";

	protected final String buildSystemName;

	@Nullable private TargetExpression target;
	@Nullable private BlazeCommandName command;
	private ImmutableList<String> blazeFlags = ImmutableList.of();
	private ImmutableList<String> exeFlags = ImmutableList.of();

	public BlazeCommandRunConfiguration(Project project,
	ConfigurationFactory factory,
	String name) {
	super(project, factory, name);
	buildSystemName = Blaze.buildSystemName(project);
	}

	@Override
	@Nullable
	public TargetExpression getTarget() {
	return target;
	}

	@Nullable
	public BlazeCommandName getCommand() {
	return command;
	}

	/**
	* @return The list of blaze flags that the user specified manually.
	*/
	protected List<String> getBlazeFlags() {
	return blazeFlags;
	}

	/**
	* @return The list of executable flags the user specified manually.
	*/
	protected List<String> getExeFlags() {
	return exeFlags;
	}

	/**
	* @return The list of all flags to be used on the Blaze command line for blaze. Subclasses should override this method to add flags for
	* higher-level settings (e.g. "run locally").
	*/
	public List<String> getAllBlazeFlags() {
	return getBlazeFlags();
	}

	/**
	* @return The list of all flags to be used for the executable on the Blaze command line. Subclasses should override this method to add
	* flags if desired.
	*/
	public List<String> getAllExeFlags() {
	return getExeFlags();
	}

	public void setTarget(@Nullable TargetExpression target) {
	this.target = target;
	}

	public void setCommand(@Nullable BlazeCommandName command) {
	this.command = command;
	}

	public final void setBlazeFlags(List<String> flags) {
	this.blazeFlags = ImmutableList.copyOf(flags);
	}

	public final void setExeFlags(List<String> flags) {
	this.exeFlags = ImmutableList.copyOf(flags);
	}

	@Override
	public void checkConfiguration() throws RuntimeConfigurationException {
	if (target == null) {
	throw new RuntimeConfigurationError(String.format("You must specify a %s target expression.", buildSystemName));
	}
	if (command == null) {
	throw new RuntimeConfigurationError(String.format("You must specify a command.", buildSystemName));
	}
	}

	@Override
	public void readExternal(Element element) throws InvalidDataException {
	super.readExternal(element);
	// Target is persisted as a tag to permit multiple targets in the future.
	Element targetElement = element.getChild(TARGET_TAG);
	if (targetElement != null && !Strings.isNullOrEmpty(targetElement.getTextTrim())) {
	target = TargetExpression.fromString(targetElement.getTextTrim());
	}
	else {
	target = null;
	}
	String commandString = element.getAttributeValue(COMMAND_ATTR);
	command = Strings.isNullOrEmpty(commandString) ?
	null : BlazeCommandName.fromString(commandString);
	blazeFlags = loadUserFlags(element, USER_BLAZE_FLAG_TAG);
	exeFlags = loadUserFlags(element, USER_EXE_FLAG_TAG);
	}

	private static ImmutableList<String> loadUserFlags(Element root, String tag) {
	ImmutableList.Builder<String> flagsBuilder = ImmutableList.builder();
	for (Element e : root.getChildren(tag)) {
	String flag = e.getTextTrim();
	if (flag != null && !flag.isEmpty()) {
	flagsBuilder.add(flag);
	}
	}
	return flagsBuilder.build();
	}

	@Override
	public void writeExternal(Element element) throws WriteExternalException {
	super.writeExternal(element);
	if (target != null) {
	// Target is persisted as a tag to permit multiple targets in the future.
	Element targetElement = new Element(TARGET_TAG);
	targetElement.setText(target.toString());
	element.addContent(targetElement);
	}
	if (command != null) {
	element.setAttribute(COMMAND_ATTR, command.toString());
	}
	saveUserFlags(element, blazeFlags, USER_BLAZE_FLAG_TAG);
	saveUserFlags(element, exeFlags, USER_EXE_FLAG_TAG);
	}

	private static void saveUserFlags(Element root, List<String> flags, String tag) {
	for (String flag : flags) {
	Element child = new Element(tag);
	child.setText(flag);
	root.addContent(child);
	}
	}

	@Override
	public BlazeCommandRunConfiguration clone() {
	final BlazeCommandRunConfiguration configuration = (BlazeCommandRunConfiguration)super.clone();
	configuration.target = target;
	configuration.command = command;
	configuration.blazeFlags = blazeFlags;
	configuration.exeFlags = exeFlags;
	return configuration;
	}

	@Override
	@Nullable
	public String suggestedName() {
	TargetExpression target = getTarget();
	if (!(target instanceof Label)) {
	return null;
	}
	return String.format("%s %s: %s", buildSystemName, command.toString(), ((Label)target).ruleName().toString());
	}


	@Nullable
	@Override
	public BlazeCommandRunProfileState getState(Executor executor,
	ExecutionEnvironment environment) throws ExecutionException {
	return new BlazeCommandRunProfileState(environment, executor instanceof DefaultDebugExecutor);
	}

	@Override
	public SettingsEditor<? extends BlazeCommandRunConfiguration> getConfigurationEditor() {
	return new BlazeCommandRunConfigurationSettingsEditor(buildSystemName);
	}

	@VisibleForTesting
	static class BlazeCommandRunConfigurationSettingsEditor extends SettingsEditor<BlazeCommandRunConfiguration> {
	private final String buildSystemName;
	private final JTextField targetField = new JTextField();
	private final ComboBox commandCombo;
	private final JTextArea blazeFlagsField = new JTextArea(5, 0);
	private final JTextArea exeFlagsField = new JTextArea(5, 0);

	public BlazeCommandRunConfigurationSettingsEditor(String buildSystemName) {
	this.buildSystemName = buildSystemName;
	commandCombo = new ComboBox(
	new DefaultComboBoxModel(BlazeCommandName.knownCommands().toArray()));
	// Allow the user to manually specify an unlisted command.
	commandCombo.setEditable(true);
	}

	@VisibleForTesting
	@Override
	public void resetEditorFrom(BlazeCommandRunConfiguration s) {
	targetField.setText(s.target == null ? null : s.target.toString());
	commandCombo.setSelectedItem(s.command);
	blazeFlagsField.setText(ParametersListUtil.join(s.blazeFlags));
	exeFlagsField.setText(ParametersListUtil.join(s.exeFlags));
	}

	@VisibleForTesting
	@Override
	public void applyEditorTo(BlazeCommandRunConfiguration s) throws ConfigurationException {
	String targetString = targetField.getText();
	s.target = Strings.isNullOrEmpty(targetString) ?
	null : TargetExpression.fromString(targetString);
	Object selectedCommand = commandCombo.getSelectedItem();
	if (selectedCommand instanceof BlazeCommandName) {
	s.command = (BlazeCommandName)selectedCommand;
	}
	else {
	s.command = Strings.isNullOrEmpty((String)selectedCommand) ?
	null : BlazeCommandName.fromString(selectedCommand.toString());
	}
	s.blazeFlags = ImmutableList.copyOf(ParametersListUtil.parse(Strings.nullToEmpty(blazeFlagsField.getText())));
	s.exeFlags = ImmutableList.copyOf(ParametersListUtil.parse(Strings.nullToEmpty(exeFlagsField.getText())));
	}

	@Override
	protected JComponent createEditor() {
	return UiUtil.createBox(
	new JLabel("Target expression:"),
	targetField,
	new JLabel(buildSystemName + " command:"),
	commandCombo,
	new JLabel(buildSystemName +" flags:"),
	blazeFlagsField,
	new JLabel("Executable flags:"),
	exeFlagsField
	);
	}
	}
	}