1/*
2 * Copyright (C) 2016 Google Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5 * use this file except in compliance with the License. You may obtain a copy of
6 * the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 * License for the specific language governing permissions and limitations under
14 * the License.
15 */
16
17package com.googlecode.android_scripting.interpreter;
18
19import com.googlecode.android_scripting.language.Language;
20import com.googlecode.android_scripting.language.SupportedLanguages;
21import com.googlecode.android_scripting.rpc.MethodDescriptor;
22
23import java.io.File;
24import java.util.ArrayList;
25import java.util.Collection;
26import java.util.HashMap;
27import java.util.List;
28import java.util.Map;
29
30/**
31 * Combines all the execution-related specs of a particular interpreter installed in the system.
32 * This class is instantiated through a map received from a concrete InterpreterProfider.
33 *
34 */
35public class Interpreter implements InterpreterPropertyNames {
36
37  private String mExtension;
38  private String mName;
39  private String mNiceName;
40  private String mInteractiveCommand;
41  private String mScriptExecutionCommand;
42  private File mBinary;
43  private boolean mHasInteractiveMode;
44  private final List<String> mArguments;
45  private final Map<String, String> mEnvironment;
46  private Language mLanguage;
47
48  public Interpreter() {
49    mArguments = new ArrayList<String>();
50    mEnvironment = new HashMap<String, String>();
51  }
52
53  public static Interpreter buildFromMaps(Map<String, String> data,
54      Map<String, String> environment_variables, Map<String, String> arguments) {
55    String extension = data.get(EXTENSION);
56    String name = data.get(NAME);
57    String niceName = data.get(NICE_NAME);
58    String binary = data.get(BINARY);
59    String interactiveCommand = data.get(INTERACTIVE_COMMAND);
60    String scriptCommand = data.get(SCRIPT_COMMAND);
61    Boolean hasInteractiveMode;
62    if (data.containsKey(HAS_INTERACTIVE_MODE)) {
63      hasInteractiveMode = Boolean.parseBoolean(data.get(HAS_INTERACTIVE_MODE));
64    } else {
65      // Default to true so that older interpreter APKs that don't have this value define still
66      // work.
67      hasInteractiveMode = true;
68    }
69    Interpreter interpreter = new Interpreter();
70    interpreter.setName(name);
71    interpreter.setNiceName(niceName);
72    interpreter.setExtension(extension);
73    interpreter.setBinary(new File(binary));
74    interpreter.setInteractiveCommand(interactiveCommand);
75    interpreter.setScriptCommand(scriptCommand);
76    interpreter.setHasInteractiveMode(hasInteractiveMode);
77    interpreter.setLanguage(SupportedLanguages.getLanguageByExtension(extension));
78    interpreter.putAllEnvironmentVariables(environment_variables);
79    interpreter.addAllArguments(arguments.values());
80    return interpreter;
81  }
82
83  // TODO(damonkohler): This should take a List<String> since order is important.
84  private void addAllArguments(Collection<String> arguments) {
85    mArguments.addAll(arguments);
86  }
87
88  List<String> getArguments() {
89    return mArguments;
90  }
91
92  private void putAllEnvironmentVariables(Map<String, String> environmentVariables) {
93    mEnvironment.putAll(environmentVariables);
94  }
95
96  public Map<String, String> getEnvironmentVariables() {
97    return mEnvironment;
98  }
99
100  protected void setScriptCommand(String executeParameters) {
101    mScriptExecutionCommand = executeParameters;
102  }
103
104  public String getScriptCommand() {
105    return mScriptExecutionCommand;
106  }
107
108  protected void setInteractiveCommand(String interactiveCommand) {
109    mInteractiveCommand = interactiveCommand;
110  }
111
112  public String getInteractiveCommand() {
113    return mInteractiveCommand;
114  }
115
116  protected void setBinary(File binary) {
117    if (!binary.exists()) {
118      throw new RuntimeException("Binary " + binary + " does not exist!");
119    }
120    mBinary = binary;
121  }
122
123  public File getBinary() {
124    return mBinary;
125  }
126
127  protected void setExtension(String extension) {
128    mExtension = extension;
129  }
130
131  protected void setHasInteractiveMode(boolean hasInteractiveMode) {
132    mHasInteractiveMode = hasInteractiveMode;
133  }
134
135  public boolean hasInteractiveMode() {
136    return mHasInteractiveMode;
137  }
138
139  public String getExtension() {
140    return mExtension;
141  }
142
143  protected void setName(String name) {
144    mName = name;
145  }
146
147  public String getName() {
148    return mName;
149  }
150
151  protected void setNiceName(String niceName) {
152    mNiceName = niceName;
153  }
154
155  public String getNiceName() {
156    return mNiceName;
157  }
158
159  public String getContentTemplate() {
160    return mLanguage.getContentTemplate();
161  }
162
163  protected void setLanguage(Language language) {
164    mLanguage = language;
165  }
166
167  public Language getLanguage() {
168    return mLanguage;
169  }
170
171  public String getRpcText(String content, MethodDescriptor rpc, String[] values) {
172    return mLanguage.getRpcText(content, rpc, values);
173  }
174
175  public boolean isInstalled() {
176    return mBinary.exists();
177  }
178
179  public boolean isUninstallable() {
180    return true;
181  }
182}