1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46 package groovy.lang;
47
48 import org.codehaus.groovy.ast.expr.ArgumentListExpression;
49 import org.codehaus.groovy.control.CompilationFailedException;
50 import org.codehaus.groovy.runtime.InvokerHelper;
51
52 import java.io.File;
53 import java.io.IOException;
54
55 /***
56 * This object represents a Groovy script
57 *
58 * @author <a href="mailto:james@coredevelopers.net">James Strachan</a>
59 * @author Guillaume Laforge
60 * @version $Revision: 1.21 $
61 */
62 public abstract class Script extends GroovyObjectSupport {
63 private Binding binding = new Binding();
64
65 protected Script() {
66 }
67
68 protected Script(Binding binding) {
69 this.binding = binding;
70 }
71
72 public Binding getBinding() {
73 return binding;
74 }
75
76 public void setBinding(Binding binding) {
77 this.binding = binding;
78 }
79
80 public Object getProperty(String property) {
81
82 try {
83 return binding.getVariable(property);
84 } catch (MissingPropertyException e) {
85 return super.getProperty(property);
86 }
87 }
88
89 public void setProperty(String property, Object newValue) {
90
91 binding.setVariable(property, newValue);
92
93 }
94
95 /***
96 * Invoke a method (or closure in the binding) defined.
97 *
98 * @param name method to call
99 * @param args arguments to pass to the method
100 * @return value
101 */
102 public Object invokeMethod(String name, Object args) {
103 try {
104 return super.invokeMethod(name, args);
105 }
106
107
108 catch (MissingMethodException mme) {
109 try {
110 if (name.equals(mme.getMethod())) {
111 Object boundClosure = binding.getVariable(name);
112 if (boundClosure != null && boundClosure instanceof Closure) {
113 return ((Closure) boundClosure).call((Object[])args);
114 } else {
115 throw mme;
116 }
117 } else {
118 throw mme;
119 }
120 } catch (MissingPropertyException mpe) {
121 throw mme;
122 }
123 }
124 }
125
126 /***
127 * The main instance method of a script which has variables in scope
128 * as defined by the current {@link Binding} instance.
129 *
130 * @return
131 */
132 public abstract Object run();
133
134
135
136 /***
137 * Prints a newline to the current 'out' variable which should be a PrintWriter
138 * or at least have a println() method defined on it.
139 * If there is no 'out' property then print to standard out.
140 */
141 public void println() {
142 Object object;
143
144 try {
145 object = getProperty("out");
146 } catch (MissingPropertyException e) {
147 System.out.println();
148 return;
149 }
150
151 InvokerHelper.invokeMethod(object, "println", ArgumentListExpression.EMPTY_ARRAY);
152 }
153
154 /***
155 * Prints the value to the current 'out' variable which should be a PrintWriter
156 * or at least have a print() method defined on it.
157 * If there is no 'out' property then print to standard out.
158 */
159 public void print(Object value) {
160 Object object;
161
162 try {
163 object = getProperty("out");
164 } catch (MissingPropertyException e) {
165 System.out.print(value);
166 return;
167 }
168
169 InvokerHelper.invokeMethod(object, "print", new Object[]{value});
170 }
171
172 /***
173 * Prints the value and a newline to the current 'out' variable which should be a PrintWriter
174 * or at least have a println() method defined on it.
175 * If there is no 'out' property then print to standard out.
176 */
177 public void println(Object value) {
178 Object object;
179
180 try {
181 object = getProperty("out");
182 } catch (MissingPropertyException e) {
183 System.out.println(value);
184 return;
185 }
186
187 InvokerHelper.invokeMethod(object, "println", new Object[]{value});
188 }
189
190 /***
191 * A helper method to allow the dynamic evaluation of groovy expressions using this
192 * scripts binding as the variable scope
193 *
194 * @param expression is the Groovy script expression to evaluate
195 */
196 public Object evaluate(String expression) throws CompilationFailedException, IOException {
197 GroovyShell shell = new GroovyShell(binding);
198 return shell.evaluate(expression);
199 }
200
201 /***
202 * A helper method to allow the dynamic evaluation of groovy expressions using this
203 * scripts binding as the variable scope
204 *
205 * @param file is the Groovy script to evaluate
206 */
207 public Object evaluate(File file) throws CompilationFailedException, IOException {
208 GroovyShell shell = new GroovyShell(binding);
209 return shell.evaluate(file);
210 }
211
212 /***
213 * A helper method to allow scripts to be run taking command line arguments
214 */
215 public void run(File file, String[] arguments) throws CompilationFailedException, IOException {
216 GroovyShell shell = new GroovyShell(binding);
217 shell.run(file, arguments);
218 }
219 }