KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > velocity > convert > WebMacro


1 package org.apache.velocity.convert;
2
3 /*
4  * Copyright 2001,2004 The Apache Software Foundation.
5  *
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */

18
19 import java.io.File JavaDoc;
20 import java.io.FileWriter JavaDoc;
21
22 import org.apache.oro.text.perl.Perl5Util;
23 import org.apache.velocity.util.StringUtils;
24 import org.apache.tools.ant.DirectoryScanner;
25
26 /**
27  * This class will convert a WebMacro template to
28  * a Velocity template. Uses the ORO Regexp package to do the
29  * rewrites. Note, it isn't 100% perfect, but will definitely get
30  * you about 99.99% of the way to a converted system. Please
31  * see the website documentation for more information on how to use
32  * this class.
33  *
34  * @author <a HREF="mailto:jvanzyl@apache.org">Jason van Zyl</a>
35  * @author <a HREF="mailto:dlr@finemaltcoding.com">Daniel Rall</a>
36  * @version $Id: WebMacro.java,v 1.20.8.1 2004/03/03 23:22:54 geirm Exp $
37  */

38 public class WebMacro
39 {
40     protected static final String JavaDoc VM_EXT = ".vm";
41     protected static final String JavaDoc WM_EXT = ".wm";
42
43     /**
44      * The regexes to use for line by line substition. The regexes
45      * come in pairs. The first is the string to match, the second is
46      * the substitution to make.
47      */

48     protected static String JavaDoc[] perLineREs =
49     {
50         // Make #if directive match the Velocity directive style.
51
"#if\\s*[(]\\s*(.*\\S)\\s*[)]\\s*(#begin|{)[ \\t]?",
52         "#if( $1 )",
53
54         // Remove the WM #end #else #begin usage.
55
"[ \\t]?(#end|})[ \\t]*\n(\\s*)#else\\s*(#begin|{)[ \\t]?(\\w)",
56         "$2#else#**#$4", // avoid touching followup word with embedded comment
57
"[ \\t]?(#end|})[ \\t]*\n(\\s*)#else\\s*(#begin|{)[ \\t]?",
58         "$2#else",
59         "(#end|})(\\s*#else)\\s*(#begin|{)[ \\t]?",
60         "$1\n$2",
61
62         // Convert WM style #foreach to Velocity directive style.
63
"#foreach\\s+(\\$\\w+)\\s+in\\s+(\\$[^\\s#]+)\\s*(#begin|{)[ \\t]?",
64         "#foreach( $1 in $2 )",
65
66         // Convert WM style #set to Velocity directive style.
67
"#set\\s+(\\$[^\\s=]+)\\s*=\\s*([\\S \\t]+)",
68         "#set( $1 = $2 )",
69         "(##[# \\t\\w]*)\\)", // fix comments included at end of line
70
")$1",
71
72         // Convert WM style #parse to Velocity directive style.
73
"#parse\\s+([^\\s#]+)[ \\t]?",
74         "#parse( $1 )",
75
76         // Convert WM style #include to Velocity directive style.
77
"#include\\s+([^\\s#]+)[ \\t]?",
78         "#include( $1 )",
79
80         // Convert WM formal reference to VTL syntax.
81
"\\$\\(([^\\)]+)\\)",
82         "${$1}",
83         "\\${([^}\\(]+)\\(([^}]+)}\\)", // fix encapsulated brakets: {(})
84
"${$1($2)}",
85
86         // Velocity currently does not permit leading underscore.
87
"\\$_",
88         "$l_",
89         "\\${(_[^}]+)}", // within a formal reference
90
"${l$1}",
91
92         // Eat semi-colons in (converted) VTL #set directives.
93
"(#set\\s*\\([^;]+);(\\s*\\))",
94         "$1$2",
95
96         // Convert explicitly terminated WM statements to VTL syntax.
97
"(^|[^\\\\])\\$(\\w[^=\n;'\"]*);",
98         "$1${$2}",
99
100         // Change extensions when seen.
101
"\\.wm",
102         ".vm"
103     };
104     
105     /**
106      * Iterate through the set of find/replace regexes
107      * that will convert a given WM template to a VM template
108      */

109     public void convert(String JavaDoc target)
110     {
111         File JavaDoc file = new File JavaDoc(target);
112         
113         if (!file.exists())
114         {
115             System.err.println
116                 ("The specified template or directory does not exist");
117             System.exit(1);
118         }
119         
120         if (file.isDirectory())
121         {
122             String JavaDoc basedir = file.getAbsolutePath();
123             String JavaDoc newBasedir = basedir + VM_EXT;
124
125             DirectoryScanner ds = new DirectoryScanner();
126             ds.setBasedir(basedir);
127             ds.addDefaultExcludes();
128             ds.scan();
129             String JavaDoc[] files = ds.getIncludedFiles();
130             
131             for (int i = 0; i < files.length; i++)
132             {
133                 writeTemplate(files[i], basedir, newBasedir);
134             }
135         }
136         else
137         {
138             writeTemplate(file.getAbsolutePath(), "", "");
139         }
140     }
141
142     /**
143      * Write out the converted template to the given named file
144      * and base directory.
145      */

146     private boolean writeTemplate(String JavaDoc file, String JavaDoc basedir,
147                                   String JavaDoc newBasedir)
148     {
149         if (file.indexOf(WM_EXT) < 0)
150         {
151             return false;
152         }
153     
154         System.out.println("Converting " + file + "...");
155         
156         String JavaDoc template;
157         String JavaDoc templateDir;
158         String JavaDoc newTemplate;
159         File JavaDoc outputDirectory;
160         
161         if (basedir.length() == 0)
162         {
163             template = file;
164             templateDir = "";
165             newTemplate = convertName(file);
166         }
167         else
168         {
169             template = basedir + File.separator + file;
170             templateDir = newBasedir + extractPath(file);
171
172             outputDirectory = new File JavaDoc(templateDir);
173                 
174             if (! outputDirectory.exists())
175             {
176                 outputDirectory.mkdirs();
177             }
178                 
179             newTemplate = newBasedir + File.separator + convertName(file);
180         }
181         
182         String JavaDoc convertedTemplate = convertTemplate(template);
183                     
184         try
185         {
186             FileWriter JavaDoc fw = new FileWriter JavaDoc(newTemplate);
187             fw.write(convertedTemplate);
188             fw.close();
189         }
190         catch (Exception JavaDoc e)
191         {
192             e.printStackTrace();
193         }
194     
195         return true;
196     }
197
198     /**
199      * Gets the path segment of the full path to a file (i.e. one
200      * which originally included the file name).
201      */

202     private final String JavaDoc extractPath(String JavaDoc file)
203     {
204         int lastSepPos = file.lastIndexOf(File.separator);
205         return (lastSepPos == -1 ? "" :
206                 File.separator + file.substring(0, lastSepPos));
207     }
208
209     /**
210      * Simple extension conversion of .wm to .vm
211      */

212     private String JavaDoc convertName(String JavaDoc name)
213     {
214         if (name.indexOf(WM_EXT) > 0)
215         {
216             return name.substring(0, name.indexOf(WM_EXT)) + VM_EXT;
217         }
218         else
219         {
220             return name;
221         }
222     }
223
224     /**
225      * How to use this little puppy :-)
226      */

227     private static final void usage()
228     {
229         System.err.println("Usage: convert-wm <template.wm | directory>");
230         System.exit(1);
231     }
232
233     /**
234      * Apply find/replace regexes to our WM template
235      */

236     public String JavaDoc convertTemplate(String JavaDoc template)
237     {
238         String JavaDoc contents = StringUtils.fileContentsToString(template);
239
240         // Overcome Velocity 0.71 limitation.
241
// HELP: Is this still necessary?
242
if (!contents.endsWith("\n"))
243         {
244             contents += "\n";
245         }
246
247         // Convert most markup.
248
Perl5Util perl = new Perl5Util();
249         for (int i = 0; i < perLineREs.length; i += 2)
250         {
251             contents = perl.substitute(makeSubstRE(i), contents);
252         }
253
254         // Convert closing curlies.
255
if (perl.match("m/javascript/i", contents))
256         {
257             // ASSUMPTION: JavaScript is indented, WM is not.
258
contents = perl.substitute("s/\n}/\n#end/g", contents);
259         }
260         else
261         {
262             contents = perl.substitute("s/(\n\\s*)}/$1#end/g", contents);
263             contents = perl.substitute("s/#end\\s*\n\\s*#else/#else/g",
264                                        contents);
265         }
266
267         return contents;
268     }
269
270     /**
271      * Makes a Perl 5 regular expression for use by ORO.
272      */

273     private final String JavaDoc makeSubstRE(int i)
274     {
275         return ("s/" + perLineREs[i] + '/' + perLineREs[i + 1] + "/g");
276     }
277
278     /**
279      * Main hook for the conversion process.
280      */

281     public static void main(String JavaDoc[] args)
282     {
283         if (args.length > 0)
284         {
285             for (int x=0; x < args.length; x++)
286             {
287                 WebMacro converter = new WebMacro();
288                 converter.convert(args[x]);
289             }
290         }
291         else
292         {
293             usage();
294         }
295     }
296 }
297
Popular Tags