├── .classpath
├── .gitignore
├── .project
├── AndroidManifest.xml
├── LICENSE
├── README.md
├── assets
    └── tmpl
    │   ├── buildprop.html
    │   ├── features.html
    │   ├── index.html
    │   ├── jquery-1.11.2.min.js
    │   ├── layout.css
    │   ├── layout.tmpl
    │   ├── libraries.html
    │   ├── locales.html
    │   ├── logo.svg
    │   ├── main-menu.js
    │   └── paths.html
├── build.gradle
├── proguard-project.txt
├── project.properties
├── res
    ├── drawable-hdpi
    │   ├── ic_action_share.png
    │   └── ic_launcher.png
    ├── drawable-mdpi
    │   ├── ic_action_share.png
    │   └── ic_launcher.png
    ├── drawable-xhdpi
    │   ├── ic_action_share.png
    │   └── ic_launcher.png
    ├── drawable-xxhdpi
    │   ├── ic_action_share.png
    │   └── ic_launcher.png
    ├── layout
    │   └── activity_main.xml
    ├── menu
    │   └── main.xml
    ├── values-cs
    │   └── strings.xml
    ├── values-v11
    │   └── styles.xml
    ├── values-v14
    │   └── styles.xml
    ├── values-w820dp
    │   └── dimens.xml
    ├── values
    │   ├── dimens.xml
    │   ├── strings.xml
    │   └── styles.xml
    └── xml
    │   └── file_paths.xml
└── src
    ├── com
        └── floreysoft
        │   └── jmte
        │       ├── AnnotationProcessor.java
        │       ├── DefaultModelAdaptor.java
        │       ├── Engine.java
        │       ├── ErrorHandler.java
        │       ├── ModelAdaptor.java
        │       ├── ModelBuilder.java
        │       ├── NamedRenderer.java
        │       ├── ProcessListener.java
        │       ├── Processor.java
        │       ├── RenderFormatInfo.java
        │       ├── Renderer.java
        │       ├── RendererRegistry.java
        │       ├── ScopedMap.java
        │       ├── TemplateContext.java
        │       ├── encoder
        │           ├── Encoder.java
        │           └── XMLEncoder.java
        │       ├── message
        │           ├── AbstractErrorHandler.java
        │           ├── DefaultErrorHandler.java
        │           ├── InternalErrorHandler.java
        │           ├── Message.java
        │           ├── MessageException.java
        │           ├── NoLogErrorHandler.java
        │           ├── ParseException.java
        │           ├── ProductionErrorHandler.java
        │           ├── ResourceBundleMessage.java
        │           ├── SilentErrorHandler.java
        │           └── messages.properties
        │       ├── package.html
        │       ├── renderer
        │           ├── DefaultCollectionRenderer.java
        │           ├── DefaultIterableRenderer.java
        │           ├── DefaultMapRenderer.java
        │           ├── DefaultObjectRenderer.java
        │           ├── OptionRenderFormatInfo.java
        │           └── RawRenderer.java
        │       ├── template
        │           ├── AbstractCompiledTemplate.java
        │           ├── AbstractTemplate.java
        │           ├── InterpretedTemplate.java
        │           ├── Template.java
        │           └── TemplateCompiler.java
        │       ├── token
        │           ├── AbstractToken.java
        │           ├── AnnotationToken.java
        │           ├── ElseToken.java
        │           ├── EndToken.java
        │           ├── ExpressionToken.java
        │           ├── ForEachToken.java
        │           ├── IfCmpToken.java
        │           ├── IfToken.java
        │           ├── InvalidToken.java
        │           ├── Lexer.java
        │           ├── PlainTextToken.java
        │           ├── StringToken.java
        │           ├── Token.java
        │           └── TokenStream.java
        │       └── util
        │           ├── MiniParser.java
        │           ├── NestedParser.java
        │           ├── StartEndPair.java
        │           ├── Tool.java
        │           ├── UniqueNameGenerator.java
        │           └── Util.java
    └── de
        └── onyxbits
            └── droidentify
                ├── Devices.java
                ├── Interceptor.java
                ├── LocalBinder.java
                ├── MainActivity.java
                ├── MainService.java
                ├── ProxyReceiver.java
                ├── ReportProvider.java
                ├── ReporterTask.java
                ├── Tuple.java
                └── ZippedReportFilter.java


/.classpath:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <classpath>
 3 | 	<classpathentry kind="src" path="src"/>
 4 | 	<classpathentry kind="src" path="gen"/>
 5 | 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
 6 | 	<classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
 7 | 	<classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.DEPENDENCIES"/>
 8 | 	<classpathentry kind="output" path="bin/classes"/>
 9 | </classpath>
10 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.class
 2 | *~
 3 | DEADJOE
 4 | .#*
 5 | *.jar
 6 | *.zip
 7 | *.apk
 8 | bin/
 9 | gen/
10 | bin/*
11 | gen/*
12 | libs/
13 | libs/*
14 | compiled/
15 | compiled/*
16 | local.properties
17 | build.xml
18 | assets/build.properties
19 | .settings/
20 | .settings/*
21 | .gradle/
22 | local.properties
23 | .idea
24 | .idea/workspace.xml
25 | .idea/libraries
26 | .DS_Store
27 | build/
28 | build/*
29 | 


--------------------------------------------------------------------------------
/.project:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <projectDescription>
 3 | 	<name>Droidentify</name>
 4 | 	<comment></comment>
 5 | 	<projects>
 6 | 	</projects>
 7 | 	<buildSpec>
 8 | 		<buildCommand>
 9 | 			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
10 | 			<arguments>
11 | 			</arguments>
12 | 		</buildCommand>
13 | 		<buildCommand>
14 | 			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
15 | 			<arguments>
16 | 			</arguments>
17 | 		</buildCommand>
18 | 		<buildCommand>
19 | 			<name>org.eclipse.jdt.core.javabuilder</name>
20 | 			<arguments>
21 | 			</arguments>
22 | 		</buildCommand>
23 | 		<buildCommand>
24 | 			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
25 | 			<arguments>
26 | 			</arguments>
27 | 		</buildCommand>
28 | 	</buildSpec>
29 | 	<natures>
30 | 		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
31 | 		<nature>org.eclipse.jdt.core.javanature</nature>
32 | 	</natures>
33 | </projectDescription>
34 | 


--------------------------------------------------------------------------------
/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android"
 3 | 	package="de.onyxbits.droidentify"
 4 | 	android:versionCode="4"
 5 | 	android:versionName="1.3" >
 6 | 
 7 | 	<uses-sdk
 8 | 		android:minSdkVersion="9"
 9 | 		android:targetSdkVersion="21" />
10 | 
11 | 	<uses-permission android:name="android.permission.INTERNET" />
12 | 	<uses-permission android:name="android.permission.READ_PHONE_STATE" />
13 | 	<uses-permission android:name="com.google.android.providers.gsf.permission.READ_GSERVICES"/>
14 | 
15 | 	<application
16 | 		android:allowBackup="true"
17 | 		android:icon="@drawable/ic_launcher"
18 | 		android:label="@string/app_name"
19 | 		android:theme="@style/AppTheme" >
20 | 		<service android:name="de.onyxbits.droidentify.MainService" />
21 | 
22 | 		<activity
23 | 			android:name="de.onyxbits.droidentify.MainActivity"
24 | 			android:label="@string/app_name" >
25 | 			<intent-filter>
26 | 				<action android:name="android.intent.action.MAIN" />
27 | 
28 | 				<category android:name="android.intent.category.LAUNCHER" />
29 | 			</intent-filter>
30 | 		</activity>
31 | 
32 | 		<provider
33 | 			android:name="android.support.v4.content.FileProvider"
34 | 			android:authorities="de.onyxbits.fileprovider"
35 | 			android:exported="false"
36 | 			android:grantUriPermissions="true" >
37 | 			<meta-data
38 | 				android:name="android.support.FILE_PROVIDER_PATHS"
39 | 				android:resource="@xml/file_paths" />
40 | 		</provider>
41 | 	</application>
42 | 
43 | </manifest>


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | 
  2 |                                  Apache License
  3 |                            Version 2.0, January 2004
  4 |                         http://www.apache.org/licenses/
  5 | 
  6 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  7 | 
  8 |    1. Definitions.
  9 | 
 10 |       "License" shall mean the terms and conditions for use, reproduction,
 11 |       and distribution as defined by Sections 1 through 9 of this document.
 12 | 
 13 |       "Licensor" shall mean the copyright owner or entity authorized by
 14 |       the copyright owner that is granting the License.
 15 | 
 16 |       "Legal Entity" shall mean the union of the acting entity and all
 17 |       other entities that control, are controlled by, or are under common
 18 |       control with that entity. For the purposes of this definition,
 19 |       "control" means (i) the power, direct or indirect, to cause the
 20 |       direction or management of such entity, whether by contract or
 21 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 22 |       outstanding shares, or (iii) beneficial ownership of such entity.
 23 | 
 24 |       "You" (or "Your") shall mean an individual or Legal Entity
 25 |       exercising permissions granted by this License.
 26 | 
 27 |       "Source" form shall mean the preferred form for making modifications,
 28 |       including but not limited to software source code, documentation
 29 |       source, and configuration files.
 30 | 
 31 |       "Object" form shall mean any form resulting from mechanical
 32 |       transformation or translation of a Source form, including but
 33 |       not limited to compiled object code, generated documentation,
 34 |       and conversions to other media types.
 35 | 
 36 |       "Work" shall mean the work of authorship, whether in Source or
 37 |       Object form, made available under the License, as indicated by a
 38 |       copyright notice that is included in or attached to the work
 39 |       (an example is provided in the Appendix below).
 40 | 
 41 |       "Derivative Works" shall mean any work, whether in Source or Object
 42 |       form, that is based on (or derived from) the Work and for which the
 43 |       editorial revisions, annotations, elaborations, or other modifications
 44 |       represent, as a whole, an original work of authorship. For the purposes
 45 |       of this License, Derivative Works shall not include works that remain
 46 |       separable from, or merely link (or bind by name) to the interfaces of,
 47 |       the Work and Derivative Works thereof.
 48 | 
 49 |       "Contribution" shall mean any work of authorship, including
 50 |       the original version of the Work and any modifications or additions
 51 |       to that Work or Derivative Works thereof, that is intentionally
 52 |       submitted to Licensor for inclusion in the Work by the copyright owner
 53 |       or by an individual or Legal Entity authorized to submit on behalf of
 54 |       the copyright owner. For the purposes of this definition, "submitted"
 55 |       means any form of electronic, verbal, or written communication sent
 56 |       to the Licensor or its representatives, including but not limited to
 57 |       communication on electronic mailing lists, source code control systems,
 58 |       and issue tracking systems that are managed by, or on behalf of, the
 59 |       Licensor for the purpose of discussing and improving the Work, but
 60 |       excluding communication that is conspicuously marked or otherwise
 61 |       designated in writing by the copyright owner as "Not a Contribution."
 62 | 
 63 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 64 |       on behalf of whom a Contribution has been received by Licensor and
 65 |       subsequently incorporated within the Work.
 66 | 
 67 |    2. Grant of Copyright License. Subject to the terms and conditions of
 68 |       this License, each Contributor hereby grants to You a perpetual,
 69 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 70 |       copyright license to reproduce, prepare Derivative Works of,
 71 |       publicly display, publicly perform, sublicense, and distribute the
 72 |       Work and such Derivative Works in Source or Object form.
 73 | 
 74 |    3. Grant of Patent License. Subject to the terms and conditions of
 75 |       this License, each Contributor hereby grants to You a perpetual,
 76 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 77 |       (except as stated in this section) patent license to make, have made,
 78 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 79 |       where such license applies only to those patent claims licensable
 80 |       by such Contributor that are necessarily infringed by their
 81 |       Contribution(s) alone or by combination of their Contribution(s)
 82 |       with the Work to which such Contribution(s) was submitted. If You
 83 |       institute patent litigation against any entity (including a
 84 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 85 |       or a Contribution incorporated within the Work constitutes direct
 86 |       or contributory patent infringement, then any patent licenses
 87 |       granted to You under this License for that Work shall terminate
 88 |       as of the date such litigation is filed.
 89 | 
 90 |    4. Redistribution. You may reproduce and distribute copies of the
 91 |       Work or Derivative Works thereof in any medium, with or without
 92 |       modifications, and in Source or Object form, provided that You
 93 |       meet the following conditions:
 94 | 
 95 |       (a) You must give any other recipients of the Work or
 96 |           Derivative Works a copy of this License; and
 97 | 
 98 |       (b) You must cause any modified files to carry prominent notices
 99 |           stating that You changed the files; and
100 | 
101 |       (c) You must retain, in the Source form of any Derivative Works
102 |           that You distribute, all copyright, patent, trademark, and
103 |           attribution notices from the Source form of the Work,
104 |           excluding those notices that do not pertain to any part of
105 |           the Derivative Works; and
106 | 
107 |       (d) If the Work includes a "NOTICE" text file as part of its
108 |           distribution, then any Derivative Works that You distribute must
109 |           include a readable copy of the attribution notices contained
110 |           within such NOTICE file, excluding those notices that do not
111 |           pertain to any part of the Derivative Works, in at least one
112 |           of the following places: within a NOTICE text file distributed
113 |           as part of the Derivative Works; within the Source form or
114 |           documentation, if provided along with the Derivative Works; or,
115 |           within a display generated by the Derivative Works, if and
116 |           wherever such third-party notices normally appear. The contents
117 |           of the NOTICE file are for informational purposes only and
118 |           do not modify the License. You may add Your own attribution
119 |           notices within Derivative Works that You distribute, alongside
120 |           or as an addendum to the NOTICE text from the Work, provided
121 |           that such additional attribution notices cannot be construed
122 |           as modifying the License.
123 | 
124 |       You may add Your own copyright statement to Your modifications and
125 |       may provide additional or different license terms and conditions
126 |       for use, reproduction, or distribution of Your modifications, or
127 |       for any such Derivative Works as a whole, provided Your use,
128 |       reproduction, and distribution of the Work otherwise complies with
129 |       the conditions stated in this License.
130 | 
131 |    5. Submission of Contributions. Unless You explicitly state otherwise,
132 |       any Contribution intentionally submitted for inclusion in the Work
133 |       by You to the Licensor shall be under the terms and conditions of
134 |       this License, without any additional terms or conditions.
135 |       Notwithstanding the above, nothing herein shall supersede or modify
136 |       the terms of any separate license agreement you may have executed
137 |       with Licensor regarding such Contributions.
138 | 
139 |    6. Trademarks. This License does not grant permission to use the trade
140 |       names, trademarks, service marks, or product names of the Licensor,
141 |       except as required for reasonable and customary use in describing the
142 |       origin of the Work and reproducing the content of the NOTICE file.
143 | 
144 |    7. Disclaimer of Warranty. Unless required by applicable law or
145 |       agreed to in writing, Licensor provides the Work (and each
146 |       Contributor provides its Contributions) on an "AS IS" BASIS,
147 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
148 |       implied, including, without limitation, any warranties or conditions
149 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
150 |       PARTICULAR PURPOSE. You are solely responsible for determining the
151 |       appropriateness of using or redistributing the Work and assume any
152 |       risks associated with Your exercise of permissions under this License.
153 | 
154 |    8. Limitation of Liability. In no event and under no legal theory,
155 |       whether in tort (including negligence), contract, or otherwise,
156 |       unless required by applicable law (such as deliberate and grossly
157 |       negligent acts) or agreed to in writing, shall any Contributor be
158 |       liable to You for damages, including any direct, indirect, special,
159 |       incidental, or consequential damages of any character arising as a
160 |       result of this License or out of the use or inability to use the
161 |       Work (including but not limited to damages for loss of goodwill,
162 |       work stoppage, computer failure or malfunction, or any and all
163 |       other commercial damages or losses), even if such Contributor
164 |       has been advised of the possibility of such damages.
165 | 
166 |    9. Accepting Warranty or Additional Liability. While redistributing
167 |       the Work or Derivative Works thereof, You may choose to offer,
168 |       and charge a fee for, acceptance of support, warranty, indemnity,
169 |       or other liability obligations and/or rights consistent with this
170 |       License. However, in accepting such obligations, You may act only
171 |       on Your own behalf and on Your sole responsibility, not on behalf
172 |       of any other Contributor, and only if You agree to indemnify,
173 |       defend, and hold each Contributor harmless for any liability
174 |       incurred by, or claims asserted against, such Contributor by reason
175 |       of your accepting any such warranty or additional liability.
176 | 
177 |    END OF TERMS AND CONDITIONS
178 | 
179 |    APPENDIX: How to apply the Apache License to your work.
180 | 
181 |       To apply the Apache License to your work, attach the following
182 |       boilerplate notice, with the fields enclosed by brackets "[]"
183 |       replaced with your own identifying information. (Don't include
184 |       the brackets!)  The text should be enclosed in the appropriate
185 |       comment syntax for the file format. We also recommend that a
186 |       file or class name and description of purpose be included on the
187 |       same "printed page" as the copyright notice for easier
188 |       identification within third-party archives.
189 | 
190 |    Copyright [yyyy] [name of copyright owner]
191 | 
192 |    Licensed under the Apache License, Version 2.0 (the "License");
193 |    you may not use this file except in compliance with the License.
194 |    You may obtain a copy of the License at
195 | 
196 |        http://www.apache.org/licenses/LICENSE-2.0
197 | 
198 |    Unless required by applicable law or agreed to in writing, software
199 |    distributed under the License is distributed on an "AS IS" BASIS,
200 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
201 |    See the License for the specific language governing permissions and
202 |    limitations under the License.
203 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | Droidentify - Android spec sheet generator
2 | ------------------------------------------
3 | 
4 | Droidentify is an Android app that makes it easy for users to generate
5 | an HTML formated description of their device and transfer this report
6 | over to their desktop computer for further processing.


--------------------------------------------------------------------------------
/assets/tmpl/buildprop.html:
--------------------------------------------------------------------------------
1 | <h1 class="page-title">Build properties</h1>
2 | <code>
3 | 	<pre>
4 | ${BUILDPROP}
5 | 	</pre>
6 | </code>
7 | 


--------------------------------------------------------------------------------
/assets/tmpl/features.html:
--------------------------------------------------------------------------------
1 | <h1 class="page-title">System Features</h1>
2 | <code>
3 | ${foreach FEATURES FEATURE} ${FEATURE}<br>${end}
4 | </code>
5 | 


--------------------------------------------------------------------------------
/assets/tmpl/index.html:
--------------------------------------------------------------------------------
1 | <h1 class="page-title">General Information</h1>
2 | <table>
3 | 	${foreach IDENTIFIERS IDENTIFIER}<tr><td>${IDENTIFIER.key}</td><td>${IDENTIFIER.value}</td></tr> ${end}
4 | </table>
5 | 


--------------------------------------------------------------------------------
/assets/tmpl/layout.tmpl:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 	<head>
 3 | 		<meta http-equiv="content-type" content="text/html; charset=utf-8" />
 4 | 		<link rel="stylesheet" type="text/css" href="layout.css" />
 5 | 		<script type="text/javascript" src="jquery-1.11.2.min.js"></script>
 6 | 		<script type="text/javascript" src="main-menu.js"></script>
 7 | 	</head>
 8 | 	<body>
 9 | 		<div id="wrapper" style="max-width:${layoutWidth}px !important">
10 | 			<header id="header" class="clearfix">
11 | 				<h3 id="ledger-title">${PRODUCT}</h3>
12 | 				<div id="site-logo">
13 | 					<a href="index.html">
14 | 						<img src="logo.svg"/>
15 | 					</a>
16 | 				</div>
17 | 				<nav id="navigation" role="navigation">
18 | 					<div id="main-menu">
19 | 						<ul class="menu" id="nav">
20 | 							<li class="selected">
21 | 								<a href="index.html">General</a>
22 | 							</li>
23 | 							<li>
24 | 								<a href="buildprop.html">Build</a>
25 | 							</li>
26 | 							<li>
27 | 								<a href="features.html">Features</a>
28 | 							</li>
29 | 							<li>
30 | 								<a href="paths.html">Paths</a>
31 | 							</li>
32 | 							<li>
33 | 								<a href="locales.html">Locales</a>
34 | 							</li>
35 | 							<li>
36 | 								<a href="libraries.html">Libraries</a>
37 | 							</li>
38 | 							<li>
39 | 								<a href="http://www.onyxbits.de/droidentify" target="_blank">Help
40 | 								</a>
41 | 							</li>
42 | 						</ul>
43 | 					</div>
44 | 				</nav>
45 | 			</header>
46 | 
47 | 			<div id="main" class="clearfix">
48 | 				<div id="primary">
49 | 					<section id="content" role="main">
50 | 						<div id="content-wrap">
51 | 							${CONTENT}
52 | 						</div>
53 | 					</section>
54 | 				</div>
55 | 				<aside id="sidebar" role="complementary">
56 | 					<div class="block block-block">
57 | 						<h2>Files</h2>
58 | 						<div class="content">
59 | 							<ul>
60 | 								<li>
61 | 									<a href="fullreport.zip">fullreport.zip</a> (contains all files)
62 | 								</li>
63 | 								<li>
64 | 									<a href="build.prop">build.prop</a> (original version)
65 | 								</li>
66 | 								<li>
67 | 									<a href="build_extra.prop">build_extra.prop</a> (enhanced version for <a href="http://www.onyxbits.de/dummydroid">Dummy Droid</a>)
68 | 								</li>
69 | 							</ul>
70 | 						</div>
71 | 					</div>
72 | 				</aside>
73 | 			</div>
74 | 
75 | 			<footer id="footer-bottom">
76 | 				<div id="bottom" class="clearfix">
77 | 					<div class="copyright">Copyright &copy;
78 | 						2015,
79 | 						<a href="http://www.onyxbits.de">Onyxbits</a>
80 | 					</div>
81 | 					<div class="credit">
82 | 						<a href="http://www.onyxbits.de/droidentify">Droidentify</a> ${APPVERSION}
83 | 					</div>
84 | 				</div>
85 | 			</footer>
86 | 		</div>
87 | 		<a name="bottom" />
88 | 	</body>
89 | </html>
90 | 
91 | 


--------------------------------------------------------------------------------
/assets/tmpl/libraries.html:
--------------------------------------------------------------------------------
1 | <h1 class="page-title">Native libraries</h1>
2 | <code>
3 | ${foreach LIBRARIES LIB} ${LIB}<br>${end}
4 | </code>
5 | 


--------------------------------------------------------------------------------
/assets/tmpl/locales.html:
--------------------------------------------------------------------------------
1 | <h1 class="page-title">Supported Locales</h1>
2 | <code>
3 | ${foreach LOCALES LOCALE} ${LOCALE}<br>${end}
4 | </code>
5 | 


--------------------------------------------------------------------------------
/assets/tmpl/logo.svg:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?>
  2 | <!-- Created with Inkscape (http://www.inkscape.org/) -->
  3 | 
  4 | <svg
  5 |    xmlns:dc="http://purl.org/dc/elements/1.1/"
  6 |    xmlns:cc="http://creativecommons.org/ns#"
  7 |    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  8 |    xmlns:svg="http://www.w3.org/2000/svg"
  9 |    xmlns="http://www.w3.org/2000/svg"
 10 |    xmlns:xlink="http://www.w3.org/1999/xlink"
 11 |    xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
 12 |    xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
 13 |    width="250"
 14 |    height="50"
 15 |    id="svg2"
 16 |    version="1.1"
 17 |    inkscape:version="0.48.3.1 r9886"
 18 |    sodipodi:docname="logo.svg">
 19 |   <defs
 20 |      id="defs4">
 21 |     <linearGradient
 22 |        id="linearGradient3761">
 23 |       <stop
 24 |          style="stop-color:#767676;stop-opacity:1;"
 25 |          offset="0"
 26 |          id="stop3763" />
 27 |       <stop
 28 |          id="stop3769"
 29 |          offset="0.30046576"
 30 |          style="stop-color:#767676;stop-opacity:1;" />
 31 |       <stop
 32 |          style="stop-color:#eca418;stop-opacity:1;"
 33 |          offset="0.30046576"
 34 |          id="stop3771" />
 35 |       <stop
 36 |          style="stop-color:#eca418;stop-opacity:1;"
 37 |          offset="1"
 38 |          id="stop3765" />
 39 |     </linearGradient>
 40 |     <linearGradient
 41 |        inkscape:collect="always"
 42 |        xlink:href="#linearGradient3761"
 43 |        id="linearGradient3767"
 44 |        x1="149.73268"
 45 |        y1="406.62607"
 46 |        x2="399.48267"
 47 |        y2="406.62607"
 48 |        gradientUnits="userSpaceOnUse"
 49 |        gradientTransform="matrix(0.99299299,0,0,0.99299299,-147.68351,623.58535)" />
 50 |   </defs>
 51 |   <sodipodi:namedview
 52 |      id="base"
 53 |      pagecolor="#ffffff"
 54 |      bordercolor="#666666"
 55 |      borderopacity="1.0"
 56 |      inkscape:pageopacity="0.0"
 57 |      inkscape:pageshadow="2"
 58 |      inkscape:zoom="6.936"
 59 |      inkscape:cx="125"
 60 |      inkscape:cy="25"
 61 |      inkscape:document-units="px"
 62 |      inkscape:current-layer="layer1"
 63 |      showgrid="false"
 64 |      inkscape:window-width="1871"
 65 |      inkscape:window-height="1058"
 66 |      inkscape:window-x="49"
 67 |      inkscape:window-y="0"
 68 |      inkscape:window-maximized="1" />
 69 |   <metadata
 70 |      id="metadata7">
 71 |     <rdf:RDF>
 72 |       <cc:Work
 73 |          rdf:about="">
 74 |         <dc:format>image/svg+xml</dc:format>
 75 |         <dc:type
 76 |            rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
 77 |         <dc:title />
 78 |       </cc:Work>
 79 |     </rdf:RDF>
 80 |   </metadata>
 81 |   <g
 82 |      inkscape:label="Ebene 1"
 83 |      inkscape:groupmode="layer"
 84 |      id="layer1"
 85 |      transform="translate(0,-1002.3622)">
 86 |     <text
 87 |        xml:space="preserve"
 88 |        style="font-size:47.66366196px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:url(#linearGradient3767);fill-opacity:1;stroke:none;font-family:Droid Sans;-inkscape-font-specification:Droid Sans"
 89 |        x="-3.6313801"
 90 |        y="1039.8716"
 91 |        id="text2989"
 92 |        sodipodi:linespacing="125%"><tspan
 93 |          sodipodi:role="line"
 94 |          id="tspan2991"
 95 |          x="-3.6313801"
 96 |          y="1039.8716"
 97 |          style="fill:url(#linearGradient3767);fill-opacity:1">Droidentify</tspan></text>
 98 |   </g>
 99 | </svg>
100 | 


--------------------------------------------------------------------------------
/assets/tmpl/main-menu.js:
--------------------------------------------------------------------------------
 1 |  
 2 | /*! http://tinynav.viljamis.com v1.03 by @viljamis */
 3 | (function ($, window, i) {
 4 |   $.fn.tinyNav = function (options) {
 5 | 
 6 |     // Default settings
 7 |     var settings = $.extend({
 8 |       'active' : 'selected', // String: Set the "active" class
 9 |       'header' : false // Boolean: Show header instead of the active item
10 |     }, options);
11 | 
12 |     return this.each(function () {
13 | 
14 |       // Used for namespacing
15 |       i++;
16 | 
17 |       var $nav = $(this),
18 |         // Namespacing
19 |         namespace = 'tinynav',
20 |         namespace_i = namespace + i,
21 |         l_namespace_i = '.l_' + namespace_i,
22 |         $select = $('<select/>').addClass(namespace + ' ' + namespace_i);
23 | 
24 |       if ($nav.is('ul,ol')) {
25 | 
26 |         if (settings.header) {
27 |           $select.append(
28 |             $('<option/>').text('Navigation')
29 |           );
30 |         }
31 | 
32 |         // Build options
33 |         var options = '';
34 |         var indent = 0;
35 |         var indented = ["&nbsp;"];
36 |         for ( var i = 0; i < 10; i++) {
37 |           indented.push(indented[indented.length-1]+indented[indented.length-1]);
38 |         }
39 |         indented[0] = "";
40 |         $nav
41 |           .addClass('l_' + namespace_i)
42 |           .children('li')
43 |           .each(buildNavTree=function () {
44 |             var a = $(this).children('a').first();
45 |             
46 |             options +=
47 |               '<option value="' + a.attr('href') + '">' +
48 |               indented[indent] + a.text() +
49 |               '</option>';
50 |               indent++;
51 |               $(this).children('ul,ol').children('li').each(buildNavTree);
52 |               indent--;
53 |           });
54 | 
55 |         // Append options into a select
56 |         $select.append(options);
57 | 
58 |         // Select the active item
59 |         if (!settings.header) {
60 |           $select
61 |             .find(':eq(' + $(l_namespace_i + ' li')
62 |             .index($(l_namespace_i + ' li.' + settings.active)) + ')')
63 |             .attr('selected', true);
64 |         }
65 | 
66 |         // Change window location
67 |         $select.change(function () {
68 |           window.location.href = $(this).val();
69 |         });
70 | 
71 |         // Inject select
72 |         $(l_namespace_i).after($select);
73 | 
74 |       }
75 | 
76 | $('option[value="'+document.location+'"]').attr("selected","selected");
77 | 
78 |     });
79 | 
80 |   };
81 | })(jQuery, this, 0);
82 | 
83 | // Tinynav
84 | jQuery(function(){
85 |     // Main Menu
86 |     jQuery('#main-menu > ul.menu').tinyNav({
87 |         active: 'selected', // Set the "active" class
88 |     });
89 | });
90 | 


--------------------------------------------------------------------------------
/assets/tmpl/paths.html:
--------------------------------------------------------------------------------
1 | <h1 class="page-title">File System Paths</h1>
2 | <table>
3 | 	${foreach PATHS PATH}<tr><td>${PATH.key}</td><td>${PATH.value}</td></tr> ${end}
4 | </table>


--------------------------------------------------------------------------------
/build.gradle:
--------------------------------------------------------------------------------
 1 | buildscript {
 2 |     repositories {
 3 |         jcenter()
 4 | 	mavenCentral()
 5 |     }
 6 | 
 7 |     dependencies {
 8 |         classpath 'com.android.tools.build:gradle:1.1.3'
 9 | 
10 |     }
11 | }
12 | 
13 | 
14 | 
15 | apply plugin: 'com.android.application'
16 | 
17 | android {
18 |     compileSdkVersion 22
19 |     buildToolsVersion "19.1"
20 | 
21 |     sourceSets {
22 |         main {
23 |             manifest.srcFile 'AndroidManifest.xml'
24 |             java.srcDirs = ['src']
25 |             resources.srcDirs = ['src']
26 |             aidl.srcDirs = ['src']
27 |             renderscript.srcDirs = ['src']
28 |             res.srcDirs = ['res']
29 |             assets.srcDirs = ['assets']
30 |         }
31 | 	debug.setRoot('build-types/debug')
32 |         release.setRoot('build-types/release')
33 |     }
34 | 
35 |     signingConfigs {
36 |         release {
37 |           storeFile file(RELEASE_STORE_FILE)
38 |           storePassword RELEASE_STORE_PASSWORD
39 |           keyAlias RELEASE_KEY_ALIAS
40 |           keyPassword RELEASE_KEY_PASSWORD
41 |         }
42 |     }
43 |     buildTypes {
44 |         release {
45 |             signingConfig signingConfigs.release
46 |         }
47 |     }
48 | }
49 | 
50 | 
51 | dependencies {
52 | 	compile 'com.android.support:support-v4:22.1.0'
53 | 	compile 'com.android.support:appcompat-v7:22.1.0'
54 | }
55 | 


--------------------------------------------------------------------------------
/proguard-project.txt:
--------------------------------------------------------------------------------
 1 | # To enable ProGuard in your project, edit project.properties
 2 | # to define the proguard.config property as described in that file.
 3 | #
 4 | # Add project specific ProGuard rules here.
 5 | # By default, the flags in this file are appended to flags specified
 6 | # in ${sdk.dir}/tools/proguard/proguard-android.txt
 7 | # You can edit the include path and order by changing the ProGuard
 8 | # include property in project.properties.
 9 | #
10 | # For more details, see
11 | #   http://developer.android.com/guide/developing/tools/proguard.html
12 | 
13 | # Add any project specific keep options here:
14 | 
15 | # If your project uses WebView with JS, uncomment the following
16 | # and specify the fully qualified class name to the JavaScript interface
17 | # class:
18 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
19 | #   public *;
20 | #}
21 | 


--------------------------------------------------------------------------------
/project.properties:
--------------------------------------------------------------------------------
 1 | # This file is automatically generated by Android Tools.
 2 | # Do not modify this file -- YOUR CHANGES WILL BE ERASED!
 3 | #
 4 | # This file must be checked in Version Control Systems.
 5 | #
 6 | # To customize properties used by the Ant build system edit
 7 | # "ant.properties", and override values to adapt the script to your
 8 | # project structure.
 9 | #
10 | # To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
11 | #proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt
12 | 
13 | # Project target.
14 | target=android-22
15 | android.library.reference.1=../appcompat_v7
16 | 


--------------------------------------------------------------------------------
/res/drawable-hdpi/ic_action_share.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/onyxbits/Droidentify/75bbf0ed5ee45778a641e2f26fd4fb943d191ba5/res/drawable-hdpi/ic_action_share.png


--------------------------------------------------------------------------------
/res/drawable-hdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/onyxbits/Droidentify/75bbf0ed5ee45778a641e2f26fd4fb943d191ba5/res/drawable-hdpi/ic_launcher.png


--------------------------------------------------------------------------------
/res/drawable-mdpi/ic_action_share.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/onyxbits/Droidentify/75bbf0ed5ee45778a641e2f26fd4fb943d191ba5/res/drawable-mdpi/ic_action_share.png


--------------------------------------------------------------------------------
/res/drawable-mdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/onyxbits/Droidentify/75bbf0ed5ee45778a641e2f26fd4fb943d191ba5/res/drawable-mdpi/ic_launcher.png


--------------------------------------------------------------------------------
/res/drawable-xhdpi/ic_action_share.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/onyxbits/Droidentify/75bbf0ed5ee45778a641e2f26fd4fb943d191ba5/res/drawable-xhdpi/ic_action_share.png


--------------------------------------------------------------------------------
/res/drawable-xhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/onyxbits/Droidentify/75bbf0ed5ee45778a641e2f26fd4fb943d191ba5/res/drawable-xhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/res/drawable-xxhdpi/ic_action_share.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/onyxbits/Droidentify/75bbf0ed5ee45778a641e2f26fd4fb943d191ba5/res/drawable-xxhdpi/ic_action_share.png


--------------------------------------------------------------------------------
/res/drawable-xxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/onyxbits/Droidentify/75bbf0ed5ee45778a641e2f26fd4fb943d191ba5/res/drawable-xxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/res/layout/activity_main.xml:
--------------------------------------------------------------------------------
 1 | <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 2 | 	xmlns:tools="http://schemas.android.com/tools"
 3 | 	android:layout_width="match_parent"
 4 | 	android:layout_height="match_parent"
 5 | 	tools:context="de.onyxbits.droidentify.MainActivity" >
 6 | 
 7 | 	<WebView
 8 | 		android:id="@+id/webview"
 9 | 		android:layout_width="fill_parent"
10 | 		android:layout_height="fill_parent" />
11 | 
12 | </RelativeLayout>


--------------------------------------------------------------------------------
/res/menu/main.xml:
--------------------------------------------------------------------------------
1 | <menu xmlns:android="http://schemas.android.com/apk/res/android"
2 | 	xmlns:app="http://schemas.android.com/apk/res-auto"
3 | 	xmlns:tools="http://schemas.android.com/tools"
4 | 	tools:context="de.onyxbits.adentity.MainActivity" >
5 |     <item android:id="@+id/share" android:title="@string/share" android:icon="@drawable/ic_action_share"></item>
6 | 
7 | </menu>
8 | 


--------------------------------------------------------------------------------
/res/values-cs/strings.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <resources>
 3 | 
 4 | 	<string name="app_name">Droidentify</string>
 5 | 	<string name="share">Sdílet</string>
 6 | 	<string name="subjectline">Report Droidentify</string>
 7 | 	<string name="sharevia">Sdílet report přes</string>
 8 | 
 9 | </resources>
10 | 


--------------------------------------------------------------------------------
/res/values-v11/styles.xml:
--------------------------------------------------------------------------------
 1 | <resources>
 2 | 
 3 | 	<!--
 4 |         Base application theme for API 11+. This theme completely replaces
 5 |         AppBaseTheme from res/values/styles.xml on API 11+ devices.
 6 | 	-->
 7 | 	<style name="AppBaseTheme" parent="Theme.AppCompat.Light">
 8 | 		<!-- API 11 theme customizations can go here. -->
 9 | 	</style>
10 | 
11 | </resources>
12 | 


--------------------------------------------------------------------------------
/res/values-v14/styles.xml:
--------------------------------------------------------------------------------
 1 | <resources>
 2 | 
 3 | 	<!--
 4 |         Base application theme for API 14+. This theme completely replaces
 5 |         AppBaseTheme from BOTH res/values/styles.xml and
 6 |         res/values-v11/styles.xml on API 14+ devices.
 7 | 	-->
 8 | 	<style name="AppBaseTheme" parent="Theme.AppCompat.Light.DarkActionBar">
 9 | 		<!-- API 14 theme customizations can go here. -->
10 | 	</style>
11 | 
12 | </resources>
13 | 


--------------------------------------------------------------------------------
/res/values-w820dp/dimens.xml:
--------------------------------------------------------------------------------
 1 | <resources>
 2 | 
 3 | 	<!--
 4 |          Example customization of dimensions originally defined in res/values/dimens.xml
 5 |          (such as screen margins) for screens with more than 820dp of available width. This
 6 |          would include 7" and 10" devices in landscape (~960dp and ~1280dp respectively).
 7 | 	-->
 8 | 	<dimen name="activity_horizontal_margin">64dp</dimen>
 9 | 
10 | </resources>
11 | 


--------------------------------------------------------------------------------
/res/values/dimens.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 | 
3 | 	<!-- Default screen margins, per the Android Design guidelines. -->
4 | 	<dimen name="activity_horizontal_margin">16dp</dimen>
5 | 	<dimen name="activity_vertical_margin">16dp</dimen>
6 | 
7 | </resources>
8 | 


--------------------------------------------------------------------------------
/res/values/strings.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <resources>
 3 | 
 4 | 	<string name="app_name">Droidentify</string>
 5 | 	<string name="share">Share</string>
 6 | 	<string name="subjectline">Droidentify Report</string>
 7 | 	<string name="sharevia">Share report via</string>
 8 | 
 9 | </resources>
10 | 


--------------------------------------------------------------------------------
/res/values/styles.xml:
--------------------------------------------------------------------------------
 1 | <resources>
 2 | 
 3 | 	<!--
 4 |         Base application theme, dependent on API level. This theme is replaced
 5 |         by AppBaseTheme from res/values-vXX/styles.xml on newer devices.
 6 | 	-->
 7 | 	<style name="AppBaseTheme" parent="Theme.AppCompat.Light">
 8 | 		<!--
 9 |             Theme customizations available in newer API levels can go in
10 |             res/values-vXX/styles.xml, while customizations related to
11 |             backward-compatibility can go here.
12 | 		-->
13 | 	</style>
14 | 
15 | 	<!-- Application theme. -->
16 | 	<style name="AppTheme" parent="AppBaseTheme">
17 | 		<!-- All customizations that are NOT specific to a particular API-level can go here. -->
18 | 	</style>
19 | 
20 | </resources>
21 | 


--------------------------------------------------------------------------------
/res/xml/file_paths.xml:
--------------------------------------------------------------------------------
1 | <paths xmlns:android="http://schemas.android.com/apk/res/android">
2 |     <files-path name="docroot" path="htdocs/"/>
3 | </paths>


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/AnnotationProcessor.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte;
 2 | 
 3 | import com.floreysoft.jmte.token.AnnotationToken;
 4 | 
 5 | /**
 6 |  * Processor for an annotation, like ${@type String simple}.
 7 |  * 
 8 |  * @param <T>
 9 |  *            what the processor produces
10 |  */
11 | public interface AnnotationProcessor<T> {
12 | 
13 | 	String getType();
14 | 	/**
15 | 	 * Processes the annotation and possible returns a value.
16 | 	 * 
17 | 	 * @param token
18 | 	 *            the annotation token triggering this processor
19 | 	 * 
20 | 	 * @param context
21 | 	 *            current context during template evaluation
22 | 	 * @return the produced value
23 | 	 */
24 | 	T eval(AnnotationToken token, TemplateContext context);
25 | 
26 | }
27 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/DefaultModelAdaptor.java:
--------------------------------------------------------------------------------
  1 | package com.floreysoft.jmte;
  2 | 
  3 | import java.lang.reflect.Field;
  4 | import java.lang.reflect.Member;
  5 | import java.lang.reflect.Method;
  6 | import java.lang.reflect.Modifier;
  7 | import java.util.HashMap;
  8 | import java.util.List;
  9 | import java.util.Map;
 10 | import java.util.Map.Entry;
 11 | import java.util.concurrent.Callable;
 12 | 
 13 | import com.floreysoft.jmte.token.Token;
 14 | 
 15 | /**
 16 |  * Default implementation of the model adapter.
 17 |  * <p>
 18 |  * Does the object traversal using the "." operator. Resolved value will be
 19 |  * checked if it is either a {@link Processor} or a {@link Callable} in which
 20 |  * case the final resolved value is computed by calling those executable
 21 |  * objects.
 22 |  * </p>
 23 |  * 
 24 |  * <p>
 25 |  * Inherit from this adapter if you want a slight change of this behavior and
 26 |  * set your new adaptor on the engine
 27 |  * {@link Engine#setModelAdaptor(ModelAdaptor)} .
 28 |  * </p>
 29 |  */
 30 | public class DefaultModelAdaptor implements ModelAdaptor {
 31 | 
 32 | 	protected Map<Class<?>, Map<String, Member>> cache = new HashMap<Class<?>, Map<String, Member>>();
 33 | 
 34 | 	@Override
 35 | 	@SuppressWarnings("rawtypes")
 36 | 	public Object getValue(TemplateContext context, Token token,
 37 | 			List<String> segments, String expression) {
 38 | 		Object value = traverse(segments, context.model, context.errorHandler, token);
 39 | 		// if value implements both, we use the more specialized implementation
 40 | 		if (value instanceof Processor) {
 41 | 			value = ((Processor) value).eval(context);
 42 | 		} else if (value instanceof Callable) {
 43 | 			try {
 44 | 				value = ((Callable) value).call();
 45 | 			} catch (Exception e) {
 46 | 			}
 47 | 		}
 48 | 		return value;
 49 | 	}
 50 | 
 51 | 	protected Object traverse(List<String> segments, Map<String, Object> model,
 52 | 			ErrorHandler errorHandler, Token token) {
 53 | 		if (segments.size() == 0) {
 54 | 			return null;
 55 | 		}
 56 | 		String objectName = segments.get(0);
 57 | 		Object value = model.get(objectName);
 58 | 
 59 | 		value = traverse(value, segments, 1, errorHandler, token);
 60 | 		return value;
 61 | 	}
 62 | 
 63 | 	protected Object traverse(Object o, List<String> attributeNames, int index,
 64 | 			ErrorHandler errorHandler, Token token) {
 65 | 		Object result;
 66 | 		if (index >= attributeNames.size()) {
 67 | 			result = o;
 68 | 		} else {
 69 | 			if (o == null) {
 70 | 				return null;
 71 | 			}
 72 | 			String attributeName = attributeNames.get(index);
 73 | 			Object nextStep = nextStep(o, attributeName, errorHandler, token);
 74 | 			result = traverse(nextStep, attributeNames, index + 1,
 75 | 					errorHandler, token);
 76 | 		}
 77 | 		return result;
 78 | 	}
 79 | 
 80 | 	@SuppressWarnings("rawtypes")
 81 | 	protected Object nextStep(Object o, String attributeName,
 82 | 			ErrorHandler errorHandler, Token token) {
 83 | 		Object result;
 84 | 		if (o instanceof String) {
 85 | 			errorHandler.error("no-call-on-string", token, new ModelBuilder(
 86 | 					"receiver", o.toString()).build());
 87 | 			return o;
 88 | 		} else if (o instanceof Map) {
 89 | 			Map map = (Map) o;
 90 | 			result = map.get(attributeName);
 91 | 		} else {
 92 | 			try {
 93 | 				result = getPropertyValue(o, attributeName);
 94 | 			} catch (Exception e) {
 95 | 				errorHandler.error("property-access-error", token,
 96 | 						new ModelBuilder("property", attributeName, "object",
 97 | 								o, "exception", e).build());
 98 | 				result = "";
 99 | 			}
100 | 		}
101 | 		return result;
102 | 	}
103 | 
104 | 	@SuppressWarnings("rawtypes")
105 | 	protected Object getPropertyValue(Object o, String propertyName) {
106 | 		try {
107 | 			// XXX this is so strange, can not call invoke on key and value for
108 | 			// Map.Entry, so we have to get this done like this:
109 | 			if (o instanceof Map.Entry) {
110 | 				final Map.Entry entry = (Entry) o;
111 | 				if (propertyName.equals("key")) {
112 | 					final Object result = entry.getKey();
113 | 					return result;
114 | 				} else if (propertyName.equals("value")) {
115 | 					final Object result = entry.getValue();
116 | 					return result;
117 | 				}
118 | 
119 | 			}
120 | 			boolean valueSet = false;
121 | 			Object value = null;
122 | 			Member member = null;
123 | 			final Class<?> clazz = o.getClass();
124 | 			Map<String, Member> members = cache.get(clazz);
125 | 			if (members == null) {
126 | 				members = new HashMap<String, Member>();
127 | 				cache.put(clazz, members);
128 | 			} else {
129 | 				member = members.get(propertyName);
130 | 				if (member != null) {
131 | 					if (member.getClass() == Method.class)
132 | 						return ((Method) member).invoke(o);
133 | 					if (member.getClass() == Field.class)
134 | 						return ((Field) member).get(o);
135 | 				}
136 | 			}
137 | 
138 | 			final String suffix = Character.toUpperCase(propertyName.charAt(0))
139 | 					+ propertyName.substring(1);
140 | 			final Method[] declaredMethods = clazz.getMethods();
141 | 			for (Method method : declaredMethods) {
142 | 				if (Modifier.isPublic(method.getModifiers())
143 | 						&& (method.getName().equals("get" + suffix) || method
144 | 								.getName().equals("is" + suffix))) {
145 | 					value = method.invoke(o, (Object[]) null);
146 | 					valueSet = true;
147 | 					member = method;
148 | 					break;
149 | 
150 | 				}
151 | 			}
152 | 			if (!valueSet) {
153 | 				final Field field = clazz.getField(propertyName);
154 | 				if (Modifier.isPublic(field.getModifiers())) {
155 | 					value = field.get(o);
156 | 					member = field;
157 | 					valueSet = true;
158 | 				}
159 | 			}
160 | 			if (valueSet) {
161 | 				members.put(propertyName, member);
162 | 			}
163 | 			return value;
164 | 		} catch (Exception e) {
165 | 			throw new RuntimeException(e);
166 | 		}
167 | 	}
168 | }
169 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/Engine.java:
--------------------------------------------------------------------------------
  1 | package com.floreysoft.jmte;
  2 | 
  3 | import java.util.Collection;
  4 | import java.util.Collections;
  5 | import java.util.HashMap;
  6 | import java.util.HashSet;
  7 | import java.util.List;
  8 | import java.util.Locale;
  9 | import java.util.Map;
 10 | import java.util.Set;
 11 | 
 12 | import org.apache.http.MethodNotSupportedException;
 13 | 
 14 | import com.floreysoft.jmte.encoder.Encoder;
 15 | import com.floreysoft.jmte.message.DefaultErrorHandler;
 16 | import com.floreysoft.jmte.message.SilentErrorHandler;
 17 | import com.floreysoft.jmte.renderer.DefaultCollectionRenderer;
 18 | import com.floreysoft.jmte.renderer.DefaultIterableRenderer;
 19 | import com.floreysoft.jmte.renderer.DefaultMapRenderer;
 20 | import com.floreysoft.jmte.renderer.DefaultObjectRenderer;
 21 | import com.floreysoft.jmte.template.InterpretedTemplate;
 22 | import com.floreysoft.jmte.template.Template;
 23 | import com.floreysoft.jmte.template.TemplateCompiler;
 24 | import com.floreysoft.jmte.token.IfToken;
 25 | import com.floreysoft.jmte.token.Token;
 26 | import com.floreysoft.jmte.util.Tool;
 27 | import com.floreysoft.jmte.util.Util;
 28 | 
 29 | /**
 30 |  * <p>
 31 |  * The template engine - <b>THIS IS WHERE YOU START LOOKING</b>.
 32 |  * </p>
 33 |  * 
 34 |  * <p>
 35 |  * Usually this is the only class you need calling
 36 |  * {@link #transform(String, Map)}. Like this
 37 |  * </p>
 38 |  * 
 39 |  * <pre>
 40 |  * Engine engine = new Engine();
 41 |  * String transformed = engine.transform(input, model);
 42 |  * </pre>
 43 |  * 
 44 |  * <p>
 45 |  * You have to provide the template input written in the template language and a
 46 |  * model from String to Object. Maybe like this
 47 |  * </p>
 48 |  * 
 49 |  * <pre>
 50 |  * String input = &quot;${name}&quot;;
 51 |  * Map&lt;String, Object&gt; model = new HashMap&lt;String, Object&gt;();
 52 |  * model.put(&quot;name&quot;, &quot;Minimal Template Engine&quot;);
 53 |  * Engine engine = new Engine();
 54 |  * String transformed = engine.transform(input, model);
 55 |  * assert (transformed.equals(&quot;Minimal Template Engine&quot;));
 56 |  * </pre>
 57 |  * 
 58 |  * where <code>input</code> contains the template and <code>model</code> the
 59 |  * model. <br>
 60 |  * 
 61 |  * <p>
 62 |  * Use {@link #setUseCompilation(boolean)} to switch on compilation mode. This
 63 |  * will compile the template into Java byte code before execution. Especially
 64 |  * when the template is used often this will speed up the execution by a factor
 65 |  * between 2 and 10. However, each compiled template results in a new class
 66 |  * definition and a new globally cached singleton instance of it.
 67 |  * </p>
 68 |  * 
 69 |  * <p>
 70 |  * This class is thread safe.
 71 |  * </p>
 72 |  * 
 73 |  * @see ErrorHandler
 74 |  * @see Tool
 75 |  * @see Renderer
 76 |  * @see NamedRenderer
 77 |  * @see ModelAdaptor
 78 |  * @see ProcessListener
 79 |  */
 80 | public final class Engine implements RendererRegistry {
 81 | 
 82 | 	public final static String VERSION = "@version@";
 83 | 
 84 | 	public static Engine createCachingEngine() {
 85 | 		Engine engine = new Engine();
 86 | 		engine.setEnabledInterpretedTemplateCache(true);
 87 | 		return engine;
 88 | 	}
 89 | 
 90 | 	public static Engine createNonCachingEngine() {
 91 | 		Engine engine = new Engine();
 92 | 		engine.setEnabledInterpretedTemplateCache(false);
 93 | 		return engine;
 94 | 	}
 95 | 
 96 | 	public static Engine createCompilingEngine() {
 97 | 		Engine engine = new Engine();
 98 | 		engine.setUseCompilation(true);
 99 | 		return engine;
100 | 	}
101 | 
102 | 	public static Engine createDefaultEngine() {
103 | 		Engine engine = new Engine();
104 | 		return engine;
105 | 	}
106 | 
107 | 	private String exprStartToken = "${";
108 | 	private String exprEndToken = "}";
109 | 	private double expansionSizeFactor = 2;
110 | 	private ErrorHandler errorHandler = new DefaultErrorHandler();
111 | 	private boolean useCompilation = false;
112 | 	private boolean enabledInterpretedTemplateCache = true;
113 | 	private ModelAdaptor modelAdaptor = new DefaultModelAdaptor();
114 | 	private Encoder encoder = null;
115 | 
116 | 	// compiler plus all compiled classes live as long as this engine
117 | 	private TemplateCompiler compiler;
118 | 
119 | 	// compiled templates cache lives as long as this engine
120 | 	private final Map<String, Template> compiledTemplates = new HashMap<String, Template>();
121 | 
122 | 	// interpreted templates cache lives as long as this engine
123 | 	private final Map<String, Template> interpretedTemplates = new HashMap<String, Template>();
124 | 
125 | 	private final Map<Class<?>, Renderer<?>> renderers = new HashMap<Class<?>, Renderer<?>>();
126 | 	private final Map<Class<?>, Renderer<?>> resolvedRendererCache = new HashMap<Class<?>, Renderer<?>>();
127 | 
128 | 	private final Map<String, AnnotationProcessor<?>> annotationProcessors = new HashMap<String, AnnotationProcessor<?>>();
129 | 
130 | 	private final Map<String, NamedRenderer> namedRenderers = new HashMap<String, NamedRenderer>();
131 | 	private final Map<Class<?>, Set<NamedRenderer>> namedRenderersForClass = new HashMap<Class<?>, Set<NamedRenderer>>();
132 | 
133 | 	/**
134 | 	 * Creates a new engine having <code>${</code> and <code>}</code> as start
135 | 	 * and end strings for expressions.
136 | 	 */
137 | 	public Engine() {
138 | 		init();
139 | 	}
140 | 
141 | 	private void init() {
142 | 		registerRenderer(Object.class, new DefaultObjectRenderer());
143 | 		registerRenderer(Map.class, new DefaultMapRenderer());
144 | 		registerRenderer(Collection.class, new DefaultCollectionRenderer());
145 | 		registerRenderer(Iterable.class, new DefaultIterableRenderer());
146 | 	}
147 | 
148 | 	/**
149 | 	 * Checks if all given variables are there and if so, that they evaluate to true inside an if.
150 | 	 */
151 | 	public boolean variablesAvailable(Map<String, Object> model, String... vars) {
152 | 		final TemplateContext context = new TemplateContext(null, null, null, new ScopedMap(model), modelAdaptor, this,
153 | 				new SilentErrorHandler(), null);
154 | 		for (String var : vars) {
155 | 			final IfToken token = new IfToken(var, false);
156 | 			if (!(Boolean) token.evaluate(context)) {
157 | 				return false;
158 | 			}
159 | 		}
160 | 		return true;
161 | 	}
162 | 
163 | 	/**
164 | 	 * Transforms a template into an expanded output using the given model.
165 | 	 * 
166 | 	 * @param template
167 | 	 *            the template to expand
168 | 	 * @param locale
169 | 	 *            the locale being passed into renderers in
170 | 	 *            {@link TemplateContext}
171 | 	 * @param sourceName
172 | 	 *            the name of the current template (if there is anything like
173 | 	 *            that)
174 | 	 * @param model
175 | 	 *            the model used to evaluate expressions inside the template
176 | 	 * @return the expanded output
177 | 	 */
178 | 	public synchronized String transform(String template, Locale locale, String sourceName, Map<String, Object> model,
179 | 			ProcessListener processListener) {
180 | 		return transformInternal(template, locale, sourceName, model, getModelAdaptor(), processListener);
181 | 	}
182 | 
183 | 	public synchronized String transform(String template, String sourceName, Map<String, Object> model,
184 | 			ProcessListener processListener) {
185 | 		return transformInternal(template, sourceName, model, getModelAdaptor(), processListener);
186 | 	}
187 | 
188 | 	public synchronized String transform(String template, Locale locale, String sourceName, Map<String, Object> model) {
189 | 		return transformInternal(template, locale, sourceName, model, getModelAdaptor(), null);
190 | 	}
191 | 
192 | 	public synchronized String transform(String template, String sourceName, Map<String, Object> model) {
193 | 		return transformInternal(template, sourceName, model, getModelAdaptor(), null);
194 | 	}
195 | 
196 | 	public synchronized String transform(String template, Locale locale, Map<String, Object> model) {
197 | 		return transformInternal(template, locale, null, model, getModelAdaptor(), null);
198 | 	}
199 | 
200 | 	public synchronized String transform(String template, Map<String, Object> model) {
201 | 		return transformInternal(template, null, model, getModelAdaptor(), null);
202 | 	}
203 | 
204 | 	public synchronized String transform(String template, Map<String, Object> model, ProcessListener processListener) {
205 | 		return transformInternal(template, null, model, getModelAdaptor(), processListener);
206 | 	}
207 | 
208 | 	public synchronized String transform(String template, Locale locale, Map<String, Object> model,
209 | 			ProcessListener processListener) {
210 | 		return transformInternal(template, locale, null, model, getModelAdaptor(), processListener);
211 | 	}
212 | 
213 | 	String transformInternal(String template, String sourceName, Map<String, Object> model, ModelAdaptor modelAdaptor,
214 | 			ProcessListener processListener) {
215 | 		Locale locale = Locale.getDefault();
216 | 		return transformInternal(template, locale, sourceName, model, modelAdaptor, processListener);
217 | 	}
218 | 
219 | 	String transformInternal(String template, Locale locale, String sourceName, Map<String, Object> model,
220 | 			ModelAdaptor modelAdaptor, ProcessListener processListener) {
221 | 		Template templateImpl = getTemplate(template, sourceName);
222 | 		String output = templateImpl.transform(model, locale, modelAdaptor, processListener);
223 | 		return output;
224 | 	}
225 | 
226 | 	/**
227 | 	 * Replacement for {@link java.lang.String.format}. All arguments will be
228 | 	 * put into the model having their index starting from 1 as their name.
229 | 	 * 
230 | 	 * @param pattern
231 | 	 *            the template
232 | 	 * @param args
233 | 	 *            any number of arguments
234 | 	 * @return the expanded template
235 | 	 */
236 | 	public synchronized String format(final String pattern, final Object... args) {
237 | 		Map<String, Object> model = Collections.emptyMap();
238 | 		ModelAdaptor modelAdaptor = new ModelAdaptor() {
239 | 
240 | 			@Override
241 | 			public Object getValue(TemplateContext context, Token token, List<String> segments, String expression) {
242 | 				int index = Integer.parseInt(expression) - 1;
243 | 				return args[index];
244 | 			}
245 | 
246 | 		};
247 | 
248 | 		String output = transformInternal(pattern, null, model, modelAdaptor, null);
249 | 		return output;
250 | 	}
251 | 
252 | 	/**
253 | 	 * Gets all variables used in the given template.
254 | 	 */
255 | 	public synchronized Set<String> getUsedVariables(String template) {
256 | 		Template templateImpl = getTemplate(template, null);
257 | 		return templateImpl.getUsedVariables();
258 | 	}
259 | 
260 | 	@Override
261 | 	public synchronized Engine registerNamedRenderer(NamedRenderer renderer) {
262 | 		namedRenderers.put(renderer.getName(), renderer);
263 | 		Set<Class<?>> supportedClasses = Util.asSet(renderer.getSupportedClasses());
264 | 		for (Class<?> clazz : supportedClasses) {
265 | 			Class<?> classInHierarchy = clazz;
266 | 			while (classInHierarchy != null) {
267 | 				addSupportedRenderer(classInHierarchy, renderer);
268 | 				classInHierarchy = classInHierarchy.getSuperclass();
269 | 			}
270 | 		}
271 | 		return this;
272 | 	}
273 | 
274 | 	@Override
275 | 	public synchronized Engine deregisterNamedRenderer(NamedRenderer renderer) {
276 | 		namedRenderers.remove(renderer.getName());
277 | 		Set<Class<?>> supportedClasses = Util.asSet(renderer.getSupportedClasses());
278 | 		for (Class<?> clazz : supportedClasses) {
279 | 			Class<?> classInHierarchy = clazz;
280 | 			while (classInHierarchy != null) {
281 | 				Set<NamedRenderer> renderers = namedRenderersForClass.get(classInHierarchy);
282 | 				renderers.remove(renderer);
283 | 				classInHierarchy = classInHierarchy.getSuperclass();
284 | 			}
285 | 		}
286 | 		return this;
287 | 	}
288 | 
289 | 	private void addSupportedRenderer(Class<?> clazz, NamedRenderer renderer) {
290 | 		Collection<NamedRenderer> compatibleRenderers = getCompatibleRenderers(clazz);
291 | 		compatibleRenderers.add(renderer);
292 | 	}
293 | 
294 | 	@Override
295 | 	public synchronized Collection<NamedRenderer> getCompatibleRenderers(Class<?> inputType) {
296 | 		Set<NamedRenderer> renderers = namedRenderersForClass.get(inputType);
297 | 		if (renderers == null) {
298 | 			renderers = new HashSet<NamedRenderer>();
299 | 			namedRenderersForClass.put(inputType, renderers);
300 | 		}
301 | 		return renderers;
302 | 	}
303 | 
304 | 	@Override
305 | 	public synchronized Collection<NamedRenderer> getAllNamedRenderers() {
306 | 		Collection<NamedRenderer> values = namedRenderers.values();
307 | 		return values;
308 | 	}
309 | 
310 | 	@Override
311 | 	public NamedRenderer resolveNamedRenderer(String rendererName) {
312 | 		return namedRenderers.get(rendererName);
313 | 	}
314 | 
315 | 	public synchronized Engine registerAnnotationProcessor(AnnotationProcessor<?> annotationProcessor) {
316 | 		annotationProcessors.put(annotationProcessor.getType(), annotationProcessor);
317 | 		return this;
318 | 	}
319 | 
320 | 	public synchronized Engine deregisterAnnotationProcessor(AnnotationProcessor<?> annotationProcessor) {
321 | 		annotationProcessors.remove(annotationProcessor.getType());
322 | 		return this;
323 | 	}
324 | 
325 | 	AnnotationProcessor<?> resolveAnnotationProcessor(String type) {
326 | 		return annotationProcessors.get(type);
327 | 	}
328 | 
329 | 	@Override
330 | 	public synchronized <C> Engine registerRenderer(Class<C> clazz, Renderer<C> renderer) {
331 | 		renderers.put(clazz, renderer);
332 | 		resolvedRendererCache.clear();
333 | 		return this;
334 | 	}
335 | 
336 | 	@Override
337 | 	public synchronized Engine deregisterRenderer(Class<?> clazz) {
338 | 		renderers.remove(clazz);
339 | 		resolvedRendererCache.clear();
340 | 		return this;
341 | 	}
342 | 
343 | 	@SuppressWarnings({ "unchecked", "rawtypes" })
344 | 	@Override
345 | 	public <C> Renderer<C> resolveRendererForClass(Class<C> clazz) {
346 | 		Renderer resolvedRenderer = resolvedRendererCache.get(clazz);
347 | 		if (resolvedRenderer != null) {
348 | 			return resolvedRenderer;
349 | 		}
350 | 
351 | 		resolvedRenderer = renderers.get(clazz);
352 | 		if (resolvedRenderer == null) {
353 | 			Class<?>[] interfaces = clazz.getInterfaces();
354 | 			for (Class<?> interfaze : interfaces) {
355 | 				resolvedRenderer = resolveRendererForClass(interfaze);
356 | 				if (resolvedRenderer != null) {
357 | 					break;
358 | 				}
359 | 			}
360 | 		}
361 | 		if (resolvedRenderer == null) {
362 | 			Class<?> superclass = clazz.getSuperclass();
363 | 			if (superclass != null) {
364 | 				resolvedRenderer = resolveRendererForClass(superclass);
365 | 			}
366 | 		}
367 | 		if (resolvedRenderer != null) {
368 | 			resolvedRendererCache.put(clazz, resolvedRenderer);
369 | 		}
370 | 		return resolvedRenderer;
371 | 	}
372 | 
373 | 	public synchronized void setEncoder(Encoder encoder) {
374 | 		this.encoder = encoder;
375 | 	}
376 | 	
377 | 	public synchronized Encoder getEncoder() {
378 | 		return encoder;
379 | 	}
380 | 	
381 | 	public synchronized void setErrorHandler(ErrorHandler errorHandler) {
382 | 		this.errorHandler = errorHandler;
383 | 	}
384 | 
385 | 	public synchronized ErrorHandler getErrorHandler() {
386 | 		return errorHandler;
387 | 	}
388 | 
389 | 	public synchronized String getExprStartToken() {
390 | 		return exprStartToken;
391 | 	}
392 | 
393 | 	public synchronized String getExprEndToken() {
394 | 		return exprEndToken;
395 | 	}
396 | 
397 | 	public synchronized void setExprStartToken(String exprStartToken) {
398 | 		this.exprStartToken = exprStartToken;
399 | 	}
400 | 
401 | 	public synchronized void setExprEndToken(String exprEndToken) {
402 | 		this.exprEndToken = exprEndToken;
403 | 	}
404 | 
405 | 	public synchronized void setExpansionSizeFactor(double expansionSizeFactor) {
406 | 		this.expansionSizeFactor = expansionSizeFactor;
407 | 	}
408 | 
409 | 	public synchronized double getExpansionSizeFactor() {
410 | 		return expansionSizeFactor;
411 | 	}
412 | 
413 | 	public synchronized boolean isUseCompilation() {
414 | 		return useCompilation;
415 | 	}
416 | 
417 | 	public synchronized void setUseCompilation(boolean useCompilation) {
418 | 		throw new RuntimeException("This part has been removed to cut down dependencies!");
419 | 		//this.useCompilation = useCompilation;
420 | 	}
421 | 
422 | 	public synchronized void setModelAdaptor(ModelAdaptor modelAdaptor) {
423 | 		this.modelAdaptor = modelAdaptor;
424 | 	}
425 | 
426 | 	public synchronized ModelAdaptor getModelAdaptor() {
427 | 		return modelAdaptor;
428 | 	}
429 | 
430 | 	public synchronized boolean isEnabledInterpretedTemplateCache() {
431 | 		return enabledInterpretedTemplateCache;
432 | 	}
433 | 
434 | 	public synchronized void setEnabledInterpretedTemplateCache(boolean enabledInterpretedTemplateCache) {
435 | 		this.enabledInterpretedTemplateCache = enabledInterpretedTemplateCache;
436 | 	}
437 | 
438 | 	/**
439 | 	 * Gets a template for a certain source.
440 | 	 * 
441 | 	 * @param template
442 | 	 *            the template source
443 | 	 * @return the prepared template
444 | 	 */
445 | 	public Template getTemplate(String template) {
446 | 		return getTemplate(template, null);
447 | 	}
448 | 
449 | 	/**
450 | 	 * Gets a template for a certain source.
451 | 	 * 
452 | 	 * @param template
453 | 	 *            the template source
454 | 	 * @param sourceName
455 | 	 *            the template name
456 | 	 * @return the prepared template
457 | 	 */
458 | 	public Template getTemplate(String template, String sourceName) {
459 | 		Template templateImpl;
460 | 		if (useCompilation) {
461 | 			templateImpl = compiledTemplates.get(template);
462 | 			if (templateImpl == null) {
463 | 				templateImpl = compiler.compile(template, sourceName, this);
464 | 				compiledTemplates.put(template, templateImpl);
465 | 			}
466 | 			return templateImpl;
467 | 		} else {
468 | 			if (enabledInterpretedTemplateCache) {
469 | 				templateImpl = interpretedTemplates.get(template);
470 | 				if (templateImpl == null) {
471 | 					templateImpl = new InterpretedTemplate(template, sourceName, this);
472 | 					interpretedTemplates.put(template, templateImpl);
473 | 				}
474 | 			} else {
475 | 				templateImpl = new InterpretedTemplate(template, sourceName, this);
476 | 			}
477 | 		}
478 | 		return templateImpl;
479 | 	}
480 | 
481 | 	public void setCompiler(TemplateCompiler compiler) {
482 | 		this.compiler = compiler;
483 | 	}
484 | 
485 | 	public TemplateCompiler getCompiler() {
486 | 		return compiler;
487 | 	}
488 | }
489 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/ErrorHandler.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte;
 2 | 
 3 | import java.util.Map;
 4 | 
 5 | import com.floreysoft.jmte.message.ParseException;
 6 | import com.floreysoft.jmte.token.Lexer;
 7 | import com.floreysoft.jmte.token.Token;
 8 | 
 9 | /**
10 |  * Interface used to handle errors while expanding a template.
11 |  */
12 | public interface ErrorHandler {
13 | 
14 | 	/**
15 | 	 * Handles an error while interpreting a template in an appropriate way.
16 | 	 * This might contain logging the error or even throwing an exception.
17 | 	 * 
18 | 	 * @param messageKey
19 | 	 *            key for the error message
20 | 	 * @param token
21 | 	 *            the token this error occurred on
22 | 	 * @param parameters
23 | 	 *            additional parameters to be filled into message or
24 | 	 *            <code>null</<code> if you do not have additional parameters
25 | 	 */
26 | 	public void error(String messageKey, Token token,
27 | 			Map<String, Object> parameters) throws ParseException;
28 | 
29 | 	/**
30 | 	 * Handles an error while interpreting a template in an appropriate way.
31 | 	 * This might contain logging the error or even throwing an exception.
32 | 	 * 
33 | 	 * @param messageKey
34 | 	 *            key for the error message
35 | 	 * @param token
36 | 	 *            the token this error occurred on
37 | 	 */
38 | 	public void error(String messageKey, Token token) throws ParseException;
39 | 
40 | }
41 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/ModelAdaptor.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte;
 2 | 
 3 | import java.util.List;
 4 | 
 5 | import com.floreysoft.jmte.token.Token;
 6 | 
 7 | /**
 8 |  * Adaptor between engine and model.
 9 |  * 
10 |  */
11 | public interface ModelAdaptor {
12 | 	/**
13 | 	 * Gets a value from the model.
14 | 	 * 
15 | 	 * @param context
16 | 	 *            the current context including the scoped model
17 | 	 * @param token
18 | 	 *            the token that asks for this value (e.g. used for error
19 | 	 *            reporting)
20 | 	 * @param segments
21 | 	 *            an already split version of the expression for faster
22 | 	 *            processing
23 | 	 * @param expression
24 | 	 *            the expression describing the desired value
25 | 	 * @return the value
26 | 	 */
27 | 	public Object getValue(TemplateContext context, Token token,
28 | 			List<String> segments, String expression);
29 | }
30 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/ModelBuilder.java:
--------------------------------------------------------------------------------
  1 | package com.floreysoft.jmte;
  2 | 
  3 | import java.util.ArrayList;
  4 | import java.util.HashMap;
  5 | import java.util.List;
  6 | import java.util.Map;
  7 | 
  8 | /**
  9 |  * Convenience class for simple model creation.
 10 |  * 
 11 |  * <p>
 12 |  * Sample usage
 13 |  * 
 14 |  * <pre>
 15 |  * Map&lt;String, Object&gt; model = new ModelBuilder(&quot;1&quot;, &quot;arg1&quot;, &quot;2&quot;, &quot;arg2&quot;).build();
 16 |  * </pre>
 17 |  * 
 18 |  * </p>
 19 |  */
 20 | public final class ModelBuilder {
 21 | 	private final Map<String, Object> model = new HashMap<String, Object>();
 22 | 
 23 | 	public ModelBuilder(String name1, Object value1) {
 24 | 		model.put(name1, value1);
 25 | 	}
 26 | 
 27 | 	public ModelBuilder(String name1, Object value1, String name2, Object value2) {
 28 | 		model.put(name1, value1);
 29 | 		model.put(name2, value2);
 30 | 	}
 31 | 
 32 | 	public ModelBuilder(String name1, Object value1, String name2,
 33 | 			Object value2, String name3, Object value3) {
 34 | 		model.put(name1, value1);
 35 | 		model.put(name2, value2);
 36 | 		model.put(name3, value3);
 37 | 	}
 38 | 
 39 | 	public ModelBuilder(String name1, Object value1, String name2,
 40 | 			Object value2, String name3, Object value3, String name4,
 41 | 			Object value4) {
 42 | 		model.put(name1, value1);
 43 | 		model.put(name2, value2);
 44 | 		model.put(name3, value3);
 45 | 		model.put(name4, value4);
 46 | 	}
 47 | 
 48 | 	public ModelBuilder(String name1, Object value1, String name2,
 49 | 			Object value2, String name3, Object value3, String name4,
 50 | 			Object value4, String name5, Object value5) {
 51 | 		model.put(name1, value1);
 52 | 		model.put(name2, value2);
 53 | 		model.put(name3, value3);
 54 | 		model.put(name4, value4);
 55 | 		model.put(name5, value4);
 56 | 	}
 57 | 
 58 | 	/**
 59 | 	 * Transforms an array to a model using the index of the elements (starting
 60 | 	 * from 1) in the array and a prefix to form their names.
 61 | 	 * 
 62 | 	 * @param prefix
 63 | 	 *            the prefix to add to the index or <code>null</code> if none
 64 | 	 *            shall be applied
 65 | 	 * @param args
 66 | 	 *            the array to be transformed into the model
 67 | 	 * @return the model containing the arguments
 68 | 	 */
 69 | 	public ModelBuilder(String prefix, Object... args) {
 70 | 		if (prefix == null) {
 71 | 			prefix = "";
 72 | 		}
 73 | 		for (int i = 0; i < args.length; i++) {
 74 | 			Object value = args[i];
 75 | 			String name = prefix + (i + 1);
 76 | 			model.put(name, value);
 77 | 		}
 78 | 	}
 79 | 
 80 | 	/**
 81 | 	 * Merges any number of named lists into a single one containing their
 82 | 	 * combined values. Can be very handy in case of a servlet request which
 83 | 	 * might contain several lists of parameters that you want to iterate over
 84 | 	 * in a combined way.
 85 | 	 * 
 86 | 	 * @param names
 87 | 	 *            the names of the variables in the following lists
 88 | 	 * @param lists
 89 | 	 *            the lists containing the values for the named variables
 90 | 	 * @return a merge list containing the combined values of the lists
 91 | 	 */
 92 | 	public static List<Map<String, Object>> mergeLists(String[] names,
 93 | 			List<Object>... lists) {
 94 | 		List<Map<String, Object>> resultList = new ArrayList<Map<String, Object>>();
 95 | 		if (lists.length != 0) {
 96 | 
 97 | 			// first check if all looks good
 98 | 			int expectedSize = lists[0].size();
 99 | 			for (int i = 1; i < lists.length; i++) {
100 | 				List<Object> list = lists[i];
101 | 				if (list.size() != expectedSize) {
102 | 					throw new IllegalArgumentException(
103 | 							"All lists and array of names must have the same size!");
104 | 				}
105 | 			}
106 | 
107 | 			// yes, things are ok
108 | 			List<Object> masterList = lists[0];
109 | 			for (int i = 0; i < masterList.size(); i++) {
110 | 				Map<String, Object> map = new HashMap<String, Object>();
111 | 				for (int j = 0; j < lists.length; j++) {
112 | 					String name = names[j];
113 | 					List<Object> list = lists[j];
114 | 					Object value = list.get(i);
115 | 					map.put(name, value);
116 | 				}
117 | 				resultList.add(map);
118 | 			}
119 | 		}
120 | 		return resultList;
121 | 	}
122 | 
123 | 	public Map<String, Object> build() {
124 | 		return model;
125 | 	}
126 | }
127 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/NamedRenderer.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte;
 2 | 
 3 | import java.util.Locale;
 4 | 
 5 | 
 6 | /**
 7 |  * A renderer addressed by its name, not by its type.
 8 |  * 
 9 |  * @see Renderer
10 |  * @see RenderFormatInfo
11 |  */
12 | public interface NamedRenderer {
13 | 	/**
14 | 	 * Renders an object of a type supported by the renderer.
15 | 	 * 
16 | 	 * @param o
17 | 	 *            the object to render
18 | 	 * @param format
19 | 	 *            anything that tells the renderer how to do its work
20 | 	 * @param locale
21 | 	 *            the locale used in transformation
22 | 	 * @return the rendered object
23 | 	 */
24 | 	public String render(Object o, String format, Locale locale);
25 | 
26 | 	/**
27 | 	 * Gets the name of the renderer.
28 | 	 */
29 | 	public String getName();
30 | 
31 | 	/**
32 | 	 * Gives information about what can be passed as a format parameter to the
33 | 	 * {@link #render(Object, String)} method.
34 | 	 */
35 | 	public RenderFormatInfo getFormatInfo();
36 | 
37 | 	/**
38 | 	 * Returns which classes are support by this renderer, i.e. which ones you
39 | 	 * can pass to the {@link #render(Object, String)} method.
40 | 	 */
41 | 	public Class<?>[] getSupportedClasses();
42 | 
43 | }


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/ProcessListener.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte;
 2 | 
 3 | import com.floreysoft.jmte.token.Token;
 4 | 
 5 | /**
 6 |  * Callback for execution steps of the engine. Reports in interpreted mode only.
 7 |  * 
 8 |  */
 9 | public interface ProcessListener {
10 | 	public static enum Action {
11 | 		/**
12 | 		 * Expression being executed.
13 | 		 */
14 | 		EVAL,
15 | 		/**
16 | 		 * Expression being skipped.
17 | 		 */
18 | 		SKIP,
19 | 		/**
20 | 		 * End of control structure.
21 | 		 */
22 | 		END
23 | 	}
24 | 
25 | 	/**
26 | 	 * Reports a step executed by the engine
27 | 	 * 
28 | 	 * @param context
29 | 	 *            current context during template evaluation
30 | 	 * @param token
31 | 	 *            the token that is handled
32 | 	 * @param action
33 | 	 *            the action that is executed on the action
34 | 	 */
35 | 	void log(TemplateContext context, Token token, Action action);
36 | }
37 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/Processor.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte;
 2 | 
 3 | /**
 4 |  * Dynamic element to be placed into model.
 5 |  * 
 6 |  * @param <T>
 7 |  *            what the processor produces
 8 |  */
 9 | public interface Processor<T> {
10 | 
11 | 	/**
12 | 	 * Produces a value based on the given context.
13 | 	 * 
14 | 	 * @param context
15 | 	 *            current context during template evaluation
16 | 	 * @return the produced value
17 | 	 */
18 | 	T eval(TemplateContext context);
19 | 
20 | }
21 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/RenderFormatInfo.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte;
 2 | 
 3 | /**
 4 |  * Whatever a named renderer needs to describe its renderer format parameter.
 5 |  * 
 6 |  * @see NamedRenderer
 7 |  *
 8 |  */
 9 | public interface RenderFormatInfo {
10 | 
11 | }
12 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/Renderer.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte;
 2 | 
 3 | import java.util.Locale;
 4 | 
 5 | /**
 6 |  * Renderer for a certain type.
 7 |  * 
 8 |  * @param <T>
 9 |  *            the type that can be rendered
10 |  * 
11 |  * @see NamedRenderer
12 |  */
13 | public interface Renderer<T> {
14 | 	/**
15 | 	 * Renders an object of the type supported by the renderer.
16 | 	 * 
17 | 	 * @param o
18 | 	 *            the object to render
19 | 	 * @param locale
20 | 	 *            the locale used in transformation
21 | 	 *            
22 | 	 */
23 | 	public String render(T o,Locale locale);
24 | }


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/RendererRegistry.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte;
 2 | 
 3 | import java.util.Collection;
 4 | 
 5 | public interface RendererRegistry {
 6 | 
 7 | 	NamedRenderer resolveNamedRenderer(String rendererName);
 8 | 
 9 | 	Collection<NamedRenderer> getAllNamedRenderers();
10 | 
11 | 	Collection<NamedRenderer> getCompatibleRenderers(Class<?> inputType);
12 | 
13 | 	Engine deregisterNamedRenderer(NamedRenderer renderer);
14 | 
15 | 	Engine registerNamedRenderer(NamedRenderer renderer);
16 | 
17 | 	<C> Engine registerRenderer(Class<C> clazz, Renderer<C> renderer);
18 | 
19 | 	Engine deregisterRenderer(Class<?> clazz);
20 | 
21 | 	<C> Renderer<C> resolveRendererForClass(Class<C> clazz);
22 | 
23 | }
24 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/ScopedMap.java:
--------------------------------------------------------------------------------
  1 | package com.floreysoft.jmte;
  2 | 
  3 | import java.util.Collection;
  4 | import java.util.HashMap;
  5 | import java.util.Map;
  6 | import java.util.Set;
  7 | import java.util.Stack;
  8 | 
  9 | /**
 10 |  * A map implementation that serves as the internal model.
 11 |  * <p>
 12 |  * Special feature of this implementation are that you can open and close scopes
 13 |  * of local variables.
 14 |  * </p>
 15 |  * 
 16 |  */
 17 | public class ScopedMap implements Map<String, Object> {
 18 | 	private final Map<String, Object> rawModel;
 19 | 	private final Stack<Map<String, Object>> scopes = new Stack<Map<String, Object>>();
 20 | 
 21 | 	public void clear() {
 22 | 		throw new UnsupportedOperationException();
 23 | 	}
 24 | 
 25 | 	public boolean containsKey(Object key) {
 26 | 		return get(key) != null;
 27 | 	}
 28 | 
 29 | 	public boolean containsValue(Object value) {
 30 | 		throw new UnsupportedOperationException();
 31 | 	}
 32 | 
 33 | 	public Set<Entry<String, Object>> entrySet() {
 34 | 		throw new UnsupportedOperationException();
 35 | 	}
 36 | 
 37 | 	public Object get(Object key) {
 38 | 		for (int i = scopes.size() - 1; i >= 0; i--) {
 39 | 			Map<String, Object> map = scopes.get(i);
 40 | 			Object value = map.get(key);
 41 | 			if (value != null) {
 42 | 				return value;
 43 | 			}
 44 | 		}
 45 | 		return rawModel.get(key);
 46 | 	}
 47 | 
 48 | 	public boolean isEmpty() {
 49 | 		throw new UnsupportedOperationException();
 50 | 	}
 51 | 
 52 | 	public Set<String> keySet() {
 53 | 		throw new UnsupportedOperationException();
 54 | 	}
 55 | 
 56 | 	public Object put(String key, Object value) {
 57 | 		return getCurrentScope().put(key, value);
 58 | 	}
 59 | 
 60 | 	public void putAll(Map<? extends String, ? extends Object> m) {
 61 | 		throw new UnsupportedOperationException();
 62 | 	}
 63 | 
 64 | 	public Object remove(Object key) {
 65 | 		throw new UnsupportedOperationException();
 66 | 	}
 67 | 
 68 | 	public int size() {
 69 | 		throw new UnsupportedOperationException();
 70 | 	}
 71 | 
 72 | 	public Collection<Object> values() {
 73 | 		throw new UnsupportedOperationException();
 74 | 	}
 75 | 
 76 | 	/**
 77 | 	 * Creates a new scoped map.
 78 | 	 * 
 79 | 	 * @param rawModel
 80 | 	 *            the raw model backing this scoped map
 81 | 	 */
 82 | 	public ScopedMap(Map<String, Object> rawModel) {
 83 | 		if (rawModel == null) {
 84 | 			throw new IllegalArgumentException("Model must not be null");
 85 | 		}
 86 | 		this.rawModel = rawModel;
 87 | 	}
 88 | 
 89 | 	/**
 90 | 	 * Gets the raw model backing this scoped map
 91 | 	 * 
 92 | 	 * @return the raw model backing this scoped map
 93 | 	 */
 94 | 	public Map<String, Object> getRawModel() {
 95 | 		return rawModel;
 96 | 	}
 97 | 
 98 | 	/**
 99 | 	 * Checks if a given variable is local.
100 | 	 */
101 | 	public boolean isLocal(String variable) {
102 | 		return containsKey(variable) && !rawModel.containsKey(variable);
103 | 	}
104 | 
105 | 	/**
106 | 	 * Creates a new local scope and sets it as the current one.
107 | 	 */
108 | 	public void enterScope() {
109 | 		scopes.push(createScope());
110 | 	}
111 | 
112 | 	/**
113 | 	 * Discards the current local scope.
114 | 	 */
115 | 	public void exitScope() {
116 | 		if (scopes.size() == 0) {
117 | 			throw new IllegalStateException("There is no state to exit");
118 | 		}
119 | 		scopes.pop();
120 | 	}
121 | 
122 | 	protected Map<String, Object> getCurrentScope() {
123 | 		if (scopes.size() > 0) {
124 | 			return scopes.peek();
125 | 		} else {
126 | 			return rawModel;
127 | 		}
128 | 
129 | 	}
130 | 
131 | 	protected Map<String, Object> createScope() {
132 | 		return new HashMap<String, Object>();
133 | 	}
134 | 
135 | 	@Override
136 | 	public String toString() {
137 | 		return rawModel.toString() + scopes.toString();
138 | 	}
139 | 
140 | }


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/TemplateContext.java:
--------------------------------------------------------------------------------
  1 | package com.floreysoft.jmte;
  2 | 
  3 | import java.util.ArrayList;
  4 | import java.util.List;
  5 | import java.util.Locale;
  6 | 
  7 | import com.floreysoft.jmte.ProcessListener.Action;
  8 | import com.floreysoft.jmte.encoder.Encoder;
  9 | import com.floreysoft.jmte.token.Token;
 10 | 
 11 | /**
 12 |  * Holds the combined current state of a template during evaluation.
 13 |  * 
 14 |  * @author olli
 15 |  * 
 16 |  */
 17 | public class TemplateContext {
 18 | 
 19 | 	public final ScopedMap model;
 20 | 	/**
 21 | 	 * Stack like hierarchy of structure giving tokens (if and foreach)
 22 | 	 */
 23 | 	public final List<Token> scopes;
 24 | 	public final String template;
 25 | 	public final Engine engine;
 26 | 	public final String sourceName;
 27 | 	public final ModelAdaptor modelAdaptor;
 28 | 	public final Locale locale;
 29 | 	public final ErrorHandler errorHandler;
 30 | 	final ProcessListener processListener;
 31 | 
 32 | 	public TemplateContext(String template, Locale locale, String sourceName, ScopedMap model,
 33 | 			ModelAdaptor modelAdaptor, Engine engine, ErrorHandler errorHandler, ProcessListener processListener) {
 34 | 		this.model = model;
 35 | 		this.template = template;
 36 | 		this.locale = locale;
 37 | 		this.engine = engine;
 38 | 		this.scopes = new ArrayList<Token>();
 39 | 		this.sourceName = sourceName;
 40 | 		this.modelAdaptor = modelAdaptor;
 41 | 		this.errorHandler = errorHandler;
 42 | 		this.processListener = processListener;
 43 | 	}
 44 | 
 45 | 	/**
 46 | 	 * Pushes a token on the scope stack.
 47 | 	 */
 48 | 	public void push(Token token) {
 49 | 		scopes.add(token);
 50 | 	}
 51 | 
 52 | 	/**
 53 | 	 * Pops a token from the scope stack.
 54 | 	 */
 55 | 	public Token pop() {
 56 | 		if (scopes.isEmpty()) {
 57 | 			return null;
 58 | 		} else {
 59 | 			Token token = scopes.remove(scopes.size() - 1);
 60 | 			return token;
 61 | 		}
 62 | 	}
 63 | 
 64 | 	/**
 65 | 	 * Gets the top element from the stack without removing it.
 66 | 	 */
 67 | 	public Token peek() {
 68 | 		if (scopes.isEmpty()) {
 69 | 			return null;
 70 | 		} else {
 71 | 			Token token = scopes.get(scopes.size() - 1);
 72 | 			return token;
 73 | 		}
 74 | 	}
 75 | 
 76 | 	@SuppressWarnings("unchecked")
 77 | 	/**
 78 | 	 * Gets the first element of the given type from the stack without removing it.
 79 | 	 */
 80 | 	public <T extends Token> T peek(Class<T> type) {
 81 | 		for (int i = scopes.size() - 1; i >= 0; i--) {
 82 | 			Token token = scopes.get(i);
 83 | 			if (token.getClass().equals(type)) {
 84 | 				return (T) token;
 85 | 			}
 86 | 		}
 87 | 		return null;
 88 | 	}
 89 | 
 90 | 	/**
 91 | 	 * Allows you to send additional notifications of executed processing steps.
 92 | 	 * 
 93 | 	 * @param token
 94 | 	 *            the token that is handled
 95 | 	 * @param action
 96 | 	 *            the action that is executed on the action
 97 | 	 */
 98 | 	public void notifyProcessListener(Token token, Action action) {
 99 | 		if (processListener != null) {
100 | 			processListener.log(this, token, action);
101 | 		}
102 | 	}
103 | 
104 | 	public AnnotationProcessor<?> resolveAnnotationProcessor(String type) {
105 | 		return engine.resolveAnnotationProcessor(type);
106 | 	}
107 | 
108 | 	public <C> Renderer<C> resolveRendererForClass(Class<C> clazz) {
109 | 		return engine.resolveRendererForClass(clazz);
110 | 	}
111 | 
112 | 	public NamedRenderer resolveNamedRenderer(String rendererName) {
113 | 		return engine.resolveNamedRenderer(rendererName);
114 | 	}
115 | 	
116 | 	public Encoder getEncoder() {
117 | 		return engine.getEncoder();
118 | 	}
119 | 
120 | }
121 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/encoder/Encoder.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.encoder;
 2 | 
 3 | import com.floreysoft.jmte.Engine;
 4 | 
 5 | /**
 6 |  * An encoder from one string to another. Called on all rendered objects coming from
 7 |  * the model. Template remains unaffected. Useful e.g. for escaping special characters in output formats like XML or JSON.
 8 |  * 
 9 |  * @see XMLEncoder
10 |  * @see Engine#setEncoder()
11 |  */
12 | public interface Encoder {
13 | 	/**
14 | 	 * Encodes a string into another one.
15 | 	 * 
16 | 	 * @param the
17 | 	 *            string to encode
18 | 	 * @return the encoded string
19 | 	 */
20 | 	public String encode(String string);
21 | }
22 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/encoder/XMLEncoder.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.encoder;
 2 | 
 3 | /**
 4 |  * Encodes all XML special characters as described
 5 |  * <a href="http://stackoverflow.com/questions/1091945/where-can-i-get-a-list-of-the-xml-document-escape-characters">
 6 |  * http://stackoverflow.com/questions/1091945/where-can-i-get-a-list-of-the-xml-document-escape-characters</a>
 7 |  * 
 8 |  * @see http://stackoverflow.com/questions/1091945/where-can-i-get-a-list-of-the-xml-document-escape-characters
 9 |  *
10 |  */
11 | public class XMLEncoder implements Encoder {
12 | 
13 | 	@Override
14 | 	public String encode(String string) {
15 | 		StringBuilder sb = new StringBuilder((int) (string.length() * 1.2));
16 | 		for (int i = 0; i < string.length(); i++) {
17 | 			char c = string.charAt(i);
18 | 			switch (c) {
19 | 			case '&':
20 | 				sb.append("&amp;");
21 | 				break;
22 | 			case '"':
23 | 				sb.append("&quot;");
24 | 				break;
25 | 			case '\'':
26 | 				sb.append("&apos;");
27 | 				break;
28 | 			case '<':
29 | 				sb.append("&lt;");
30 | 				break;
31 | 			case '>':
32 | 				sb.append("&gt;");
33 | 				break;
34 | 			default:
35 | 				sb.append(c);
36 | 			}
37 | 		}
38 | 		return sb.toString();
39 | 	}
40 | }
41 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/message/AbstractErrorHandler.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.message;
 2 | 
 3 | import java.util.Locale;
 4 | import java.util.logging.Logger;
 5 | 
 6 | import com.floreysoft.jmte.ErrorHandler;
 7 | import com.floreysoft.jmte.token.Token;
 8 | 
 9 | public abstract class AbstractErrorHandler implements ErrorHandler {
10 | 	protected final Logger logger = Logger
11 | 			.getLogger(getClass().getName());
12 | 
13 | 	protected Locale locale = new Locale("en");
14 | 
15 | 	@Override
16 | 	public void error(String messageKey, Token token) throws ParseException {
17 | 		error(messageKey, token, null);
18 | 	}
19 | 
20 | 	public void setLocale(Locale locale) {
21 | 		this.locale = locale;
22 | 	}
23 | }
24 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/message/DefaultErrorHandler.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.message;
 2 | 
 3 | import java.util.Map;
 4 | 
 5 | import com.floreysoft.jmte.ErrorHandler;
 6 | import com.floreysoft.jmte.token.Token;
 7 | 
 8 | public class DefaultErrorHandler extends AbstractErrorHandler implements ErrorHandler {
 9 | 	/**
10 | 	 * {@inheritDoc}
11 | 	 */
12 | 	@Override
13 | 	public void error(String messageKey, Token token,
14 | 			Map<String, Object> parameters) throws ParseException {
15 | 		Message message = new ResourceBundleMessage(messageKey).withModel(
16 | 				parameters).onToken(token);
17 | 		logger.severe(message.format(locale));
18 | 		throw new ParseException(message);
19 | 	}
20 | }
21 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/message/InternalErrorHandler.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.message;
 2 | 
 3 | import java.util.Map;
 4 | 
 5 | import com.floreysoft.jmte.ErrorHandler;
 6 | import com.floreysoft.jmte.token.Token;
 7 | 
 8 | public class InternalErrorHandler extends AbstractErrorHandler implements
 9 | 		ErrorHandler {
10 | 	/**
11 | 	 * {@inheritDoc}
12 | 	 */
13 | 	@Override
14 | 	public void error(String messageKey, Token token,
15 | 			Map<String, Object> parameters) throws ParseException {
16 | 		logger.warning(String.format(
17 | 				"Internal error '%s' on '%s'(%d:%d) with parameters %s",
18 | 				messageKey, token.getText(), token.getLine(),
19 | 				token.getColumn(), parameters != null ? parameters.toString()
20 | 						: ""));
21 | 	}
22 | 
23 | }
24 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/message/Message.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.message;
 2 | 
 3 | import java.util.Locale;
 4 | 
 5 | public interface Message {
 6 | 	public String format();
 7 | 	public String format(Locale locale);
 8 | 	public String formatPlain();
 9 | 	public String formatPlain(Locale locale);
10 | }
11 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/message/MessageException.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.message;
 2 | 
 3 | @SuppressWarnings("serial")
 4 | public class MessageException extends RuntimeException {
 5 | 	private final Message message;
 6 | 
 7 | 	public MessageException(Message message) {
 8 | 		this.message = message;
 9 | 	}
10 | 	
11 | 	@Override
12 | 	public String getMessage() {
13 | 		return message.format();
14 | 	}
15 | }
16 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/message/NoLogErrorHandler.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.message;
 2 | 
 3 | import java.util.Map;
 4 | 
 5 | import com.floreysoft.jmte.ErrorHandler;
 6 | import com.floreysoft.jmte.token.Token;
 7 | 
 8 | public class NoLogErrorHandler extends AbstractErrorHandler implements ErrorHandler {
 9 | 
10 | 	/**
11 | 	 * {@inheritDoc}
12 | 	 */
13 | 	@Override
14 | 	public void error(String messageKey, Token token, Map<String, Object> parameters) throws ParseException {
15 | 		// Silent by design
16 | 		Message message = new ResourceBundleMessage(messageKey).withModel(parameters).onToken(token);
17 | 		throw new ParseException(message);
18 | 	}
19 | }
20 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/message/ParseException.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.message;
 2 | 
 3 | 
 4 | @SuppressWarnings("serial")
 5 | public class ParseException extends MessageException {
 6 | 	public ParseException(Message message) {
 7 | 		super(message);
 8 | 	}
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/message/ProductionErrorHandler.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.message;
 2 | 
 3 | import java.util.Map;
 4 | 
 5 | import com.floreysoft.jmte.ErrorHandler;
 6 | import com.floreysoft.jmte.token.Token;
 7 | 
 8 | public class ProductionErrorHandler extends AbstractErrorHandler implements
 9 | 		ErrorHandler {
10 | 
11 | 	/**
12 | 	 * {@inheritDoc}
13 | 	 */
14 | 	@Override
15 | 	public void error(String messageKey, Token token,
16 | 			Map<String, Object> parameters) throws ParseException {
17 | 		Message message = new ResourceBundleMessage(messageKey).withModel(
18 | 				parameters).onToken(token);
19 | 		logger.severe(message.format(locale));
20 | 	}
21 | }
22 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/message/ResourceBundleMessage.java:
--------------------------------------------------------------------------------
  1 | package com.floreysoft.jmte.message;
  2 | 
  3 | import java.util.HashMap;
  4 | import java.util.Locale;
  5 | import java.util.Map;
  6 | import java.util.ResourceBundle;
  7 | 
  8 | import com.floreysoft.jmte.Engine;
  9 | import com.floreysoft.jmte.token.Token;
 10 | 
 11 | public class ResourceBundleMessage implements Message {
 12 | 
 13 | 	protected static String getTemplate(ResourceBundle bundle, String key,
 14 | 			String fallback) {
 15 | 		return key != null && bundle.containsKey(key) ? bundle.getString(key)
 16 | 				: fallback;
 17 | 	}
 18 | 	
 19 | 	private final String messageCode;
 20 | 
 21 | 	public ResourceBundleMessage(String messageCode) {
 22 | 		this.messageCode = messageCode;
 23 | 	}
 24 | 
 25 | 	private String locationCode = "location";
 26 | 	private String prefixCode = "prefix";
 27 | 	private String frameCode = "frame";
 28 | 	private Map<String, Object> argumentModel = new HashMap<String, Object>();
 29 | 	private String baseName = "com.floreysoft.jmte.message.messages";
 30 | 
 31 | 	public ResourceBundleMessage useLocationCode(String locationCode) {
 32 | 		this.locationCode = locationCode;
 33 | 		return this;
 34 | 	}
 35 | 
 36 | 	public ResourceBundleMessage onToken(Token token) {
 37 | 		this.argumentModel.put("token", token);
 38 | 		return this;
 39 | 	}
 40 | 
 41 | 	public ResourceBundleMessage usePrefixCode(String prefixCode) {
 42 | 		this.prefixCode = prefixCode;
 43 | 		return this;
 44 | 	}
 45 | 
 46 | 	public ResourceBundleMessage useFrameCode(String frameCode) {
 47 | 		this.frameCode = frameCode;
 48 | 		return this;
 49 | 	}
 50 | 
 51 | 	public ResourceBundleMessage withModel(Map<String, Object> model) {
 52 | 		if (model != null) {
 53 | 			this.argumentModel.putAll(model);
 54 | 		}
 55 | 		return this;
 56 | 	}
 57 | 
 58 | 	public ResourceBundleMessage withBaseName(String baseName) {
 59 | 		this.baseName = baseName;
 60 | 		return this;
 61 | 	}
 62 | 
 63 | 	public String getMessageCode() {
 64 | 		return messageCode;
 65 | 	}
 66 | 
 67 | 	public String getLocationCode() {
 68 | 		return locationCode;
 69 | 	}
 70 | 
 71 | 	public String getPrefixCode() {
 72 | 		return prefixCode;
 73 | 	}
 74 | 
 75 | 	public String getFrameCode() {
 76 | 		return frameCode;
 77 | 	}
 78 | 
 79 | 	public Map<String, Object> getArgumentModel() {
 80 | 		return argumentModel;
 81 | 	}
 82 | 
 83 | 	public String getBaseName() {
 84 | 		return baseName;
 85 | 	}
 86 | 
 87 | 	@Override
 88 | 	public String format() {
 89 | 		return format(new Locale("en"));
 90 | 	}
 91 | 
 92 | 	@Override
 93 | 	public String format(Locale locale) {
 94 | 		final ResourceBundle messages = ResourceBundle.getBundle(baseName, locale);
 95 | 		final String frameTemplate = getTemplate(messages, frameCode, "${prefix} ${location}: ${message}");
 96 | 		final String prefixTemplate = getTemplate(messages, prefixCode, "");
 97 | 		final String locationTemplate = getTemplate(messages, locationCode, "");
 98 | 		final String messageTemplate = getTemplate(messages, messageCode, "");
 99 | 		
100 | 		Engine engine = new Engine();
101 | 		engine.setErrorHandler(new InternalErrorHandler());
102 | 		argumentModel.put("prefix", engine.transform(prefixTemplate, argumentModel));
103 | 		argumentModel.put("location", engine.transform(locationTemplate, argumentModel));
104 | 		argumentModel.put("message", engine.transform(messageTemplate, argumentModel));
105 | 		
106 | 		String transformed = engine.transform(frameTemplate, argumentModel);
107 | 		return transformed;
108 | 
109 | 	}
110 | 
111 | 	@Override
112 | 	public String formatPlain() {
113 | 		return formatPlain(new Locale("en"));
114 | 	}
115 | 
116 | 	@Override
117 | 	public String formatPlain(Locale locale) {
118 | 		final ResourceBundle messages = ResourceBundle.getBundle(baseName, locale);
119 | 		final String messageTemplate = getTemplate(messages, messageCode, "");
120 | 		
121 | 		Engine engine = new Engine();
122 | 		engine.setErrorHandler(new InternalErrorHandler());
123 | 		String transformed = engine.transform(messageTemplate, argumentModel);
124 | 		return transformed;
125 | 	}
126 | }
127 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/message/SilentErrorHandler.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.message;
 2 | 
 3 | import java.util.Map;
 4 | 
 5 | import com.floreysoft.jmte.ErrorHandler;
 6 | import com.floreysoft.jmte.token.Token;
 7 | 
 8 | public class SilentErrorHandler extends AbstractErrorHandler implements ErrorHandler {
 9 | 
10 | 	/**
11 | 	 * {@inheritDoc}
12 | 	 */
13 | 	@Override
14 | 	public void error(String messageKey, Token token, Map<String, Object> parameters) throws ParseException {
15 | 		// Silent by design
16 | 	}
17 | }
18 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/message/messages.properties:
--------------------------------------------------------------------------------
 1 | # General
 2 | 
 3 | location=at location ${token.sourceName}(${token.line}:${token.column})
 4 | frame=${prefix} ${location}: ${message}
 5 | prefix=Error while parsing '${token.text}'
 6 | 
 7 | # Errors
 8 | invalid-expression=Invalid expression!
 9 | no-call-on-string=You can not make property calls on string '${receiver}!'
10 | property-access-error=Property '${property}' on object '${object}' can not be accessed: "${if exception.message}${exception.message}${else}${exception.cause.message}${end}"!
11 | else-out-of-scope=Can't use else outside of if block!
12 | unmatched-end=Unmatched end
13 | missing-end=Missing end


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/package.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
 2 | <html>
 3 | <head>
 4 | </head>
 5 | <body>
 6 | 
 7 | <p>This is the main package of the Java Minimal Template Engine. The central class is this {@link com.floreysoft.jmte.Engine}. Most likely this is all you need. </p>
 8 | <p>For a more conceptual approach see the
 9 | <a href="../../../../index.html" target="_top">general documentation</a>
10 | .</p>
11 | 
12 | </body>
13 | </html>


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/renderer/DefaultCollectionRenderer.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.renderer;
 2 | 
 3 | import java.util.Collection;
 4 | import java.util.Locale;
 5 | 
 6 | import com.floreysoft.jmte.Renderer;
 7 | 
 8 | @SuppressWarnings("rawtypes")
 9 | public class DefaultCollectionRenderer implements Renderer<Collection> {
10 | 
11 | 	@Override
12 | 	public String render(Collection collection, Locale locale) {
13 | 		final String renderedResult;
14 | 
15 | 		if (collection.size() == 0) {
16 | 			renderedResult = "";
17 | 		} else if (collection.size() == 1) {
18 | 			renderedResult = collection.iterator().next().toString();
19 | 		} else {
20 | 			renderedResult = collection.toString();
21 | 		}
22 | 		return renderedResult;
23 | 
24 | 	}
25 | 
26 | }
27 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/renderer/DefaultIterableRenderer.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.renderer;
 2 | 
 3 | import java.util.Iterator;
 4 | import java.util.Locale;
 5 | 
 6 | import com.floreysoft.jmte.Renderer;
 7 | import com.floreysoft.jmte.TemplateContext;
 8 | 
 9 | 
10 | @SuppressWarnings("unchecked")
11 | public class DefaultIterableRenderer implements Renderer<Iterable> {
12 | 
13 | 	@Override
14 | 	public String render(Iterable iterable, Locale locale) {
15 | 		final String renderedResult;
16 | 
17 | 		final Iterator<?> iterator = iterable.iterator();
18 | 		renderedResult = iterator.hasNext() ? iterator.next().toString() : "";
19 | 		return renderedResult;
20 | 
21 | 	}
22 | 
23 | }
24 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/renderer/DefaultMapRenderer.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.renderer;
 2 | 
 3 | import java.util.Locale;
 4 | import java.util.Map;
 5 | 
 6 | import com.floreysoft.jmte.Renderer;
 7 | 
 8 | 
 9 | @SuppressWarnings("rawtypes")
10 | public class DefaultMapRenderer implements Renderer<Map> {
11 | 
12 | 	@Override
13 | 	public String render(Map map, Locale locale) {
14 | 		final String renderedResult;
15 | 
16 | 		if (map.size() == 0) {
17 | 			renderedResult = "";
18 | 		} else if (map.size() == 1) {
19 | 			renderedResult = map.values().iterator().next().toString();
20 | 		} else {
21 | 			renderedResult = map.toString();
22 | 		}
23 | 		return renderedResult;
24 | 
25 | 	}
26 | 
27 | }
28 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/renderer/DefaultObjectRenderer.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.renderer;
 2 | 
 3 | import java.util.List;
 4 | import java.util.Locale;
 5 | 
 6 | import com.floreysoft.jmte.Renderer;
 7 | import com.floreysoft.jmte.TemplateContext;
 8 | import com.floreysoft.jmte.util.Util;
 9 | 
10 | public class DefaultObjectRenderer implements Renderer<Object> {
11 | 
12 | 	@Override
13 | 	public String render(Object value, Locale locale) {
14 | 		final String renderedResult;
15 | 
16 | 		if (value instanceof String) {
17 | 			renderedResult = (String) value;
18 | 		} else {
19 | 			final List<Object> arrayAsList = Util.arrayAsList(value);
20 | 			if (arrayAsList != null) {
21 | 				renderedResult = arrayAsList.size() > 0 ? arrayAsList.get(0)
22 | 						.toString() : "";
23 | 			} else {
24 | 				renderedResult = value.toString();
25 | 			}
26 | 		}
27 | 		return renderedResult;
28 | 	}
29 | }
30 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/renderer/OptionRenderFormatInfo.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.renderer;
 2 | 
 3 | import com.floreysoft.jmte.RenderFormatInfo;
 4 | 
 5 | public class OptionRenderFormatInfo implements RenderFormatInfo {
 6 | 
 7 | 	private final String[] options;
 8 | 
 9 | 	public OptionRenderFormatInfo(String[] options) {
10 | 		this.options = options;
11 | 	}
12 | 
13 | 	public String[] getOptions() {
14 | 		return options;
15 | 	}
16 | 
17 | }
18 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/renderer/RawRenderer.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.renderer;
 2 | 
 3 | import com.floreysoft.jmte.NamedRenderer;
 4 | import com.floreysoft.jmte.encoder.Encoder;
 5 | 
 6 | /**
 7 |  * <p>Marker interface to indicate that the result of a renderer implementing this
 8 |  * interface shall not be encoded by any {@link Encoder} that might be
 9 |  * configured.</p>
10 |  * 
11 |  * Can be set on {@link Renderer} and {@link NamedRenderer}.
12 |  * 
13 |  * @see Encoder
14 |  * @see NamedRenderer
15 |  * @see Renderer
16 |  */
17 | public interface RawRenderer {
18 | 
19 | }
20 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/template/AbstractCompiledTemplate.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.template;
 2 | 
 3 | import java.util.Locale;
 4 | import java.util.Map;
 5 | import java.util.Set;
 6 | 
 7 | import com.floreysoft.jmte.Engine;
 8 | import com.floreysoft.jmte.ModelAdaptor;
 9 | import com.floreysoft.jmte.ProcessListener;
10 | import com.floreysoft.jmte.ScopedMap;
11 | import com.floreysoft.jmte.TemplateContext;
12 | import com.floreysoft.jmte.util.Util;
13 | 
14 | public abstract class AbstractCompiledTemplate extends AbstractTemplate {
15 | 
16 | 	public AbstractCompiledTemplate() {
17 | 	}
18 | 
19 | 	public AbstractCompiledTemplate(Engine engine) {
20 | 		this.engine = engine;
21 | 	}
22 | 
23 | 	@Override
24 | 	public Set<String> getUsedVariables() {
25 | 		return usedVariables;
26 | 	}
27 | 
28 | 	@Override
29 | 	public synchronized String transform(Map<String, Object> model, Locale locale, ModelAdaptor modelAdaptor, ProcessListener processListener) {
30 | 		TemplateContext context = new TemplateContext(template, locale, sourceName,
31 | 				new ScopedMap(model), modelAdaptor, engine, engine.getErrorHandler(), processListener);
32 | 
33 | 		String transformed = transformCompiled(context);
34 | 		return transformed;
35 | 
36 | 	}
37 | 
38 | 	protected abstract String transformCompiled(TemplateContext context);
39 | 
40 | 	public void setEngine(Engine engine) {
41 | 		this.engine = engine;
42 | 	}
43 | 
44 | 	public Engine getEngine() {
45 | 		return engine;
46 | 	}
47 | 
48 | 	public void setTemplate(String template) {
49 | 		this.template = template;
50 | 	}
51 | 
52 | 	public String getTemplate() {
53 | 		return template;
54 | 	}
55 | 
56 | 	public void setSourceName(String sourceName) {
57 | 		this.sourceName = sourceName;
58 | 	}
59 | 
60 | 	public String getSourceName() {
61 | 		return sourceName;
62 | 	}
63 | 
64 | 	@Override
65 | 	public String toString() {
66 | 		return template;
67 | 	}
68 | 
69 | }
70 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/template/AbstractTemplate.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.template;
 2 | 
 3 | import java.util.Locale;
 4 | import java.util.Map;
 5 | import java.util.Set;
 6 | 
 7 | import com.floreysoft.jmte.Engine;
 8 | import com.floreysoft.jmte.ModelAdaptor;
 9 | import com.floreysoft.jmte.ProcessListener;
10 | import com.floreysoft.jmte.token.ForEachToken;
11 | 
12 | public abstract class AbstractTemplate implements Template {
13 | 
14 | 	public static final String SPECIAL_ITERATOR_VARIABLE = "_it";
15 | 	public static final String ODD_PREFIX = "odd_";
16 | 	public static final String EVEN_PREFIX = "even_";
17 | 	public static final String LAST_PREFIX = "last_";
18 | 	public static final String FIRST_PREFIX = "first_";
19 | 	public static final String INDEX_PREFIX = "index_";
20 | 	
21 | 	protected Engine engine;
22 | 	protected String template;
23 | 	protected String sourceName;
24 | 	protected Set<String> usedVariables;
25 | 	
26 | 	protected void addSpecialVariables(ForEachToken feToken,
27 | 			Map<String, Object> model) {
28 | 		String suffix = feToken.getVarName();
29 | 		addSpecialVariables(feToken, model, suffix);
30 | 		
31 | 		// special _it variable as an alias for run variable in inner loop
32 | 		model.put(SPECIAL_ITERATOR_VARIABLE, model.get(feToken.getVarName()));
33 | 		addSpecialVariables(feToken, model, SPECIAL_ITERATOR_VARIABLE);
34 | 	}
35 | 
36 | 	private void addSpecialVariables(ForEachToken feToken, Map<String, Object> model, String suffix) {
37 | 		model.put(FIRST_PREFIX + suffix, feToken.isFirst());
38 | 		model.put(LAST_PREFIX + suffix, feToken.isLast());
39 | 		model.put(EVEN_PREFIX + suffix, feToken.getIndex() % 2 == 0);
40 | 		model.put(ODD_PREFIX + suffix, feToken.getIndex() % 2 == 1);
41 | 		model.put(INDEX_PREFIX + suffix, feToken.getIndex() + 1);
42 | 	}
43 | 
44 | 	/**
45 | 	 * Transforms a template into an expanded output using the given model.
46 | 	 * 
47 | 	 * @param model
48 | 	 *            the model used to evaluate expressions inside the template
49 | 	 * @param modelAdaptor
50 | 	 *            adaptor used for this transformation to look up values from
51 | 	 *            model
52 | 	 * @return the expanded output
53 | 	 */
54 | 	public abstract String transform(Map<String, Object> model, Locale locale,
55 | 			ModelAdaptor modelAdaptor, ProcessListener processListener);
56 | 
57 | 	/**
58 | 	 * Transforms a template into an expanded output using the given model.
59 | 	 * 
60 | 	 * @param model
61 | 	 *            the model used to evaluate expressions inside the template
62 | 	 * @return the expanded output
63 | 	 */
64 | 	public String transform(Map<String, Object> model, Locale locale,
65 | 			ProcessListener processListener) {
66 | 		return transform(model, locale, engine.getModelAdaptor(), processListener);
67 | 	}
68 | 	
69 | 	/**
70 | 	 * Transforms a template into an expanded output using the given model.
71 | 	 * 
72 | 	 * @param model
73 | 	 *            the model used to evaluate expressions inside the template
74 | 	 * @return the expanded output
75 | 	 */
76 | 	public String transform(Map<String, Object> model, Locale locale) {
77 | 		return transform(model, locale, engine.getModelAdaptor(), null);
78 | 	}
79 | 	
80 | 	public abstract Set<String> getUsedVariables();
81 | 
82 | }
83 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/template/InterpretedTemplate.java:
--------------------------------------------------------------------------------
  1 | package com.floreysoft.jmte.template;
  2 | 
  3 | import java.util.Collections;
  4 | import java.util.Locale;
  5 | import java.util.Map;
  6 | import java.util.Set;
  7 | import java.util.TreeSet;
  8 | 
  9 | import com.floreysoft.jmte.DefaultModelAdaptor;
 10 | import com.floreysoft.jmte.Engine;
 11 | import com.floreysoft.jmte.ModelAdaptor;
 12 | import com.floreysoft.jmte.ProcessListener;
 13 | import com.floreysoft.jmte.ProcessListener.Action;
 14 | import com.floreysoft.jmte.ScopedMap;
 15 | import com.floreysoft.jmte.TemplateContext;
 16 | import com.floreysoft.jmte.token.ElseToken;
 17 | import com.floreysoft.jmte.token.EndToken;
 18 | import com.floreysoft.jmte.token.ExpressionToken;
 19 | import com.floreysoft.jmte.token.ForEachToken;
 20 | import com.floreysoft.jmte.token.IfToken;
 21 | import com.floreysoft.jmte.token.InvalidToken;
 22 | import com.floreysoft.jmte.token.PlainTextToken;
 23 | import com.floreysoft.jmte.token.StringToken;
 24 | import com.floreysoft.jmte.token.Token;
 25 | import com.floreysoft.jmte.token.TokenStream;
 26 | 
 27 | public class InterpretedTemplate extends AbstractTemplate {
 28 | 
 29 | 	protected final TokenStream tokenStream;
 30 | 	protected transient StringBuilder output;
 31 | 	protected transient TemplateContext context;
 32 | 
 33 | 	public InterpretedTemplate(String template, String sourceName, Engine engine) {
 34 | 		this.template = template;
 35 | 		this.engine = engine;
 36 | 		this.sourceName = sourceName;
 37 | 		tokenStream = new TokenStream(sourceName, template, engine
 38 | 				.getExprStartToken(), engine.getExprEndToken());
 39 | 		tokenStream.prefill();
 40 | 	}
 41 | 
 42 | 	@Override
 43 | 	@SuppressWarnings("unchecked")
 44 | 	public synchronized Set<String> getUsedVariables() {
 45 | 		if (this.usedVariables != null) {
 46 | 			return this.usedVariables;
 47 | 		}
 48 | 
 49 | 		this.usedVariables = new TreeSet<String>();
 50 | 		final Engine engine = new Engine();
 51 | 		final ScopedMap scopedMap = new ScopedMap(Collections.EMPTY_MAP);
 52 | 
 53 | 		ProcessListener processListener = new ProcessListener() {
 54 | 
 55 | 			@Override
 56 | 			public void log(TemplateContext context, Token token, Action action) {
 57 | 				if (token instanceof ExpressionToken) {
 58 | 					String variable = ((ExpressionToken) token).getExpression();
 59 | 					if (!isLocal(variable)) {
 60 | 						usedVariables.add(variable);
 61 | 					}
 62 | 				}
 63 | 			}
 64 | 
 65 | 			// a variable is local if any enclosing foreach has it as a step
 66 | 			// variable
 67 | 			private boolean isLocal(String variable) {
 68 | 				for (Token token : context.scopes) {
 69 | 					if (token instanceof ForEachToken) {
 70 | 						String foreachVarName = ((ForEachToken) token)
 71 | 								.getVarName();
 72 | 						if (foreachVarName.equals(variable)) {
 73 | 							return true;
 74 | 						}
 75 | 					}
 76 | 				}
 77 | 				return false;
 78 | 
 79 | 			}
 80 | 
 81 | 		};
 82 | 		final Locale locale = Locale.getDefault();
 83 | 		context = new TemplateContext(template, locale, sourceName, scopedMap,
 84 | 				new DefaultModelAdaptor(), engine, engine.getErrorHandler(), processListener);
 85 | 
 86 | 		transformPure(context);
 87 | 		return usedVariables;
 88 | 	}
 89 | 
 90 | 	@Override
 91 | 	public synchronized String transform(Map<String, Object> model, Locale locale,
 92 | 			ModelAdaptor modelAdaptor, ProcessListener processListener) {
 93 | 		try {
 94 | 			context = new TemplateContext(template, locale, sourceName, new ScopedMap(
 95 | 					model), modelAdaptor, engine, engine.getErrorHandler(), processListener);
 96 | 			String transformed = transformPure(context);
 97 | 			return transformed;
 98 | 		} finally {
 99 | 			context = null;
100 | 			output = null;
101 | 		}
102 | 	}
103 | 
104 | 	protected String transformPure(TemplateContext context) {
105 | 		tokenStream.reset();
106 | 		output = new StringBuilder(
107 | 				(int) (context.template.length() * context.engine
108 | 						.getExpansionSizeFactor()));
109 | 		tokenStream.nextToken();
110 | 		while (tokenStream.currentToken() != null) {
111 | 			content(false);
112 | 		}
113 | 		return output.toString();
114 | 	}
115 | 
116 | 	@SuppressWarnings({ "unchecked", "rawtypes" })
117 | 	private void foreach(boolean inheritedSkip) {
118 | 		ForEachToken feToken = (ForEachToken) tokenStream.currentToken();
119 | 		Iterable iterable = (Iterable) feToken.evaluate(context);
120 | 		// begin a fresh iteration with a reset index
121 | 		feToken.setIterator(iterable.iterator());
122 | 		feToken.resetIndex();
123 | 		tokenStream.consume();
124 | 
125 | 		context.model.enterScope();
126 | 		context.push(feToken);
127 | 		try {
128 | 
129 | 			// in case we do not want to evaluate the body, we just do a quick
130 | 			// scan until the matching end
131 | 			if (inheritedSkip || !feToken.iterator().hasNext()) {
132 | 				Token contentToken;
133 | 				while ((contentToken = tokenStream.currentToken()) != null
134 | 						&& !(contentToken instanceof EndToken)) {
135 | 					content(true);
136 | 				}
137 | 				if (contentToken == null) {
138 | 					engine.getErrorHandler().error("missing-end", feToken);
139 | 				} else {
140 | 					tokenStream.consume();
141 | 					context.notifyProcessListener(contentToken, Action.END);
142 | 				}
143 | 			} else {
144 | 
145 | 				while (feToken.iterator().hasNext()) {
146 | 
147 | 					context.model.put(feToken.getVarName(), feToken.advance());
148 | 					addSpecialVariables(feToken, context.model);
149 | 
150 | 					// for each iteration we need to rewind to the beginning
151 | 					// of the for loop
152 | 					tokenStream.rewind(feToken);
153 | 					Token contentToken;
154 | 					while ((contentToken = tokenStream.currentToken()) != null
155 | 							&& !(contentToken instanceof EndToken)) {
156 | 						content(false);
157 | 					}
158 | 					if (contentToken == null) {
159 | 						engine.getErrorHandler().error("missing-end", feToken);
160 | 					} else {
161 | 						tokenStream.consume();
162 | 						context.notifyProcessListener(contentToken, Action.END);
163 | 					}
164 | 					if (!feToken.isLast()) {
165 | 						output.append(feToken.getSeparator());
166 | 					}
167 | 				}
168 | 			}
169 | 
170 | 		} finally {
171 | 			context.model.exitScope();
172 | 			context.pop();
173 | 		}
174 | 	}
175 | 
176 | 	private void condition(boolean inheritedSkip) {
177 | 		IfToken ifToken = (IfToken) tokenStream.currentToken();
178 | 		tokenStream.consume();
179 | 
180 | 		context.push(ifToken);
181 | 		try {
182 | 			boolean localSkip;
183 | 			if (inheritedSkip) {
184 | 				localSkip = true;
185 | 			} else {
186 | 				localSkip = !(Boolean) ifToken.evaluate(context);
187 | 			}
188 | 
189 | 			Token contentToken;
190 | 			while ((contentToken = tokenStream.currentToken()) != null
191 | 					&& !(contentToken instanceof EndToken)
192 | 					&& !(contentToken instanceof ElseToken)) {
193 | 				content(localSkip);
194 | 			}
195 | 
196 | 			if (contentToken instanceof ElseToken) {
197 | 				tokenStream.consume();
198 | 				// toggle for else branch
199 | 				if (!inheritedSkip) {
200 | 					localSkip = !localSkip;
201 | 				}
202 | 				context.notifyProcessListener(contentToken,
203 | 						inheritedSkip ? Action.SKIP : Action.EVAL);
204 | 
205 | 				while ((contentToken = tokenStream.currentToken()) != null
206 | 						&& !(contentToken instanceof EndToken)) {
207 | 					content(localSkip);
208 | 				}
209 | 
210 | 			}
211 | 
212 | 			if (contentToken == null) {
213 | 				engine.getErrorHandler().error("missing-end", ifToken);
214 | 			} else {
215 | 				tokenStream.consume();
216 | 				context.notifyProcessListener(contentToken, Action.END);
217 | 			}
218 | 		} finally {
219 | 			context.pop();
220 | 		}
221 | 	}
222 | 
223 | 	private void content(boolean skip) {
224 | 		Token token = tokenStream.currentToken();
225 | 		context.notifyProcessListener(token, skip ? Action.SKIP : Action.EVAL);
226 | 		if (token instanceof PlainTextToken) {
227 | 			tokenStream.consume();
228 | 			if (!skip) {
229 | 				output.append(token.getText());
230 | 			}
231 | 		} else if (token instanceof StringToken) {
232 | 			tokenStream.consume();
233 | 			if (!skip) {
234 | 				String expanded = (String) token.evaluate(context);
235 | 				output.append(expanded);
236 | 			}
237 | 		} else if (token instanceof ForEachToken) {
238 | 			foreach(skip);
239 | 		} else if (token instanceof IfToken) {
240 | 			condition(skip);
241 | 		} else if (token instanceof ElseToken) {
242 | 			tokenStream.consume();
243 | 			engine.getErrorHandler().error("else-out-of-scope", token);
244 | 		} else if (token instanceof EndToken) {
245 | 			tokenStream.consume();
246 | 			engine.getErrorHandler().error("unmatched-end", token);
247 | 		} else if (token instanceof InvalidToken) {
248 | 			tokenStream.consume();
249 | 			engine.getErrorHandler().error("invalid-expression", token);
250 | 		} else {
251 | 			tokenStream.consume();
252 | 			// what ever else there may be, we just evaluate it
253 | 			String evaluated = (String) token.evaluate(context);
254 | 			output.append(evaluated);
255 | 		}
256 | 
257 | 	}
258 | 
259 | 	@Override
260 | 	public String toString() {
261 | 		return template;
262 | 	}
263 | }
264 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/template/Template.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.template;
 2 | 
 3 | import java.util.Locale;
 4 | import java.util.Map;
 5 | import java.util.Set;
 6 | 
 7 | import com.floreysoft.jmte.ModelAdaptor;
 8 | import com.floreysoft.jmte.ProcessListener;
 9 | 
10 | public interface Template {
11 | 	/**
12 | 	 * Transforms a template into an expanded output using the given model.
13 | 	 * 
14 | 	 * @param model
15 | 	 *            the model used to evaluate expressions inside the template
16 | 	 * @param locale
17 | 	 *            the locale used to render this template
18 | 	 * @param modelAdaptor
19 | 	 *            adaptor used for this transformation to look up values from
20 | 	 *            model
21 | 	 * @return the expanded output
22 | 	 */
23 | 	public String transform(Map<String, Object> model, Locale locale,
24 | 			ModelAdaptor modelAdaptor, ProcessListener processListener);
25 | 
26 | 	/**
27 | 	 * Transforms a template into an expanded output using the given model.
28 | 	 * 
29 | 	 * @param model
30 | 	 *            the model used to evaluate expressions inside the template
31 | 	 * @param locale
32 | 	 *            the locale used to render this template
33 | 	 * @return the expanded output
34 | 	 */
35 | 	public String transform(Map<String, Object> model, Locale locale,
36 | 			ProcessListener processListener);
37 | 
38 | 	/**
39 | 	 * Transforms a template into an expanded output using the given model.
40 | 	 * 
41 | 	 * @param model
42 | 	 *            the model used to evaluate expressions inside the template
43 | 	 * @param locale
44 | 	 *            the locale used to render this template
45 | 	 * @return the expanded output
46 | 	 */
47 | 	public String transform(Map<String, Object> model, Locale locale);
48 | 
49 | 	public Set<String> getUsedVariables();
50 | 
51 | }
52 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/template/TemplateCompiler.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.template;
 2 | 
 3 | import com.floreysoft.jmte.Engine;
 4 | 
 5 | /**
 6 |  * Compiles template source to an executable template.
 7 |  * 
 8 |  */
 9 | public interface TemplateCompiler {
10 | 	public Template compile(String template, String sourceName, Engine engine);
11 | }
12 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/token/AbstractToken.java:
--------------------------------------------------------------------------------
  1 | package com.floreysoft.jmte.token;
  2 | 
  3 | public abstract class AbstractToken implements Token {
  4 | 
  5 | 	protected String text;
  6 | 	protected int line;
  7 | 	protected int column;
  8 | 	protected String sourceName;
  9 | 	private int tokenIndex;
 10 | 
 11 | 	public AbstractToken() {
 12 | 	}
 13 | 
 14 | 	public AbstractToken(AbstractToken token) {
 15 | 		this.text = token.text;
 16 | 		this.line = token.line;
 17 | 		this.column = token.column;
 18 | 		this.sourceName = token.sourceName;
 19 | 		this.setTokenIndex(token.getTokenIndex());
 20 | 	}
 21 | 
 22 | 	public AbstractToken(char[] buffer, int start, int end, int tokenIndex) {
 23 | 		this(null, buffer, start, end, tokenIndex);
 24 | 	}
 25 | 
 26 | 	public AbstractToken(String sourceName, char[] buffer, int start, int end,
 27 | 			int tokenIndex) {
 28 | 		this.setSourceName(sourceName);
 29 | 		setText(buffer, start, end);
 30 | 		setLine(buffer, start, end);
 31 | 		setColumn(buffer, start, end);
 32 | 		this.setTokenIndex(tokenIndex);
 33 | 	}
 34 | 
 35 | 	public String getText() {
 36 | 		return text;
 37 | 	}
 38 | 
 39 | 	public void setText(String text) {
 40 | 		this.text = text;
 41 | 	}
 42 | 
 43 | 	public int getLine() {
 44 | 		return line;
 45 | 	}
 46 | 
 47 | 	public void setLine(int line) {
 48 | 		this.line = line;
 49 | 	}
 50 | 
 51 | 	public int getColumn() {
 52 | 		return column;
 53 | 	}
 54 | 
 55 | 	public void setColumn(int column) {
 56 | 		this.column = column;
 57 | 	}
 58 | 
 59 | 	public void setText(char[] buffer, int start, int end) {
 60 | 		setText(new String(buffer, start, end - start));
 61 | 	}
 62 | 
 63 | 	public void setLine(char[] buffer, int start, int end) {
 64 | 		line = 1;
 65 | 		for (int i = 0; i < start; i++) {
 66 | 			if (buffer[i] == '\n') {
 67 | 				line++;
 68 | 			}
 69 | 		}
 70 | 	}
 71 | 
 72 | 	public void setColumn(char[] buffer, int start, int end) {
 73 | 		column = 0;
 74 | 		if (buffer.length != 0) {
 75 | 			for (int i = start; i >= 0; i--) {
 76 | 				if (buffer[i] == '\n') {
 77 | 					break;
 78 | 				} else {
 79 | 					column++;
 80 | 				}
 81 | 			}
 82 | 		}
 83 | 	}
 84 | 
 85 | 	@Override
 86 | 	public String toString() {
 87 | 		return getText();
 88 | 	}
 89 | 
 90 | 	@Override
 91 | 	public String emit() {
 92 | 		return getText();
 93 | 	}
 94 | 	
 95 | 	public void setSourceName(String sourceName) {
 96 | 		this.sourceName = sourceName;
 97 | 	}
 98 | 
 99 | 	@Override
100 | 	public String getSourceName() {
101 | 		return sourceName;
102 | 	}
103 | 	
104 | 	@Override
105 | 	public int getTokenIndex() {
106 | 		return tokenIndex;
107 | 	}
108 | 
109 | 	public void setTokenIndex(int tokenIndex) {
110 | 		this.tokenIndex = tokenIndex;
111 | 	}
112 | 	
113 | 	public Object clone() {
114 | 		try {
115 | 			return super.clone();
116 | 		} catch (CloneNotSupportedException e) {
117 | 			return null;
118 | 		}
119 | 	}
120 | }


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/token/AnnotationToken.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.token;
 2 | 
 3 | import com.floreysoft.jmte.AnnotationProcessor;
 4 | import com.floreysoft.jmte.TemplateContext;
 5 | 
 6 | public class AnnotationToken extends AbstractToken {
 7 | 	private final String receiver;
 8 | 	private final String arguments;
 9 | 
10 | 	public AnnotationToken(String receiver, String arguments) {
11 | 		super();
12 | 		this.receiver = receiver;
13 | 		this.arguments = arguments;
14 | 	}
15 | 
16 | 	public String getReceiver() {
17 | 		return receiver;
18 | 	}
19 | 
20 | 	public String getArguments() {
21 | 		return arguments;
22 | 	}
23 | 
24 | 	public Object evaluate(TemplateContext context) {
25 | 		AnnotationProcessor<?> annotationProcessor = context
26 | 				.resolveAnnotationProcessor(receiver);
27 | 		if (annotationProcessor != null) {
28 | 			Object value = annotationProcessor.eval(this, context);
29 | 			if (value != null) {
30 | 				return value;
31 | 			}
32 | 		}
33 | 		return "";
34 | 	}
35 | }
36 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/token/ElseToken.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.token;
 2 | 
 3 | import com.floreysoft.jmte.TemplateContext;
 4 | 
 5 | 
 6 | public class ElseToken extends AbstractToken {
 7 | 	public static final String ELSE = "else";
 8 | 
 9 | 	protected IfToken ifToken = null;
10 | 
11 | 	@Override
12 | 	public String getText() {
13 | 		if (text == null) {
14 | 			text = ELSE + getIfToken() != null ? "(" + getIfToken().getText()
15 | 					+ ")" : "";
16 | 		}
17 | 		return text;
18 | 	}
19 | 
20 | 	@Override
21 | 	public Object evaluate(TemplateContext context) {
22 | 		Boolean evaluated = !(Boolean) getIfToken().evaluate(context);
23 | 		return evaluated;
24 | 	}
25 | 
26 | 	public void setIfToken(IfToken ifToken) {
27 | 		this.ifToken = ifToken;
28 | 	}
29 | 
30 | 	public IfToken getIfToken() {
31 | 		if (ifToken == null) {
32 | 			throw new IllegalStateException(
33 | 					"An else token can only be evaluated using an associated if token - which is missing");
34 | 		}
35 | 		return ifToken;
36 | 	}
37 | 
38 | 	@Override
39 | 	public String emit() {
40 | 		return ELSE;
41 | 	}
42 | }
43 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/token/EndToken.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.token;
 2 | 
 3 | import com.floreysoft.jmte.TemplateContext;
 4 | 
 5 | 
 6 | public class EndToken extends AbstractToken {
 7 | 	public static final String END = "end";
 8 | 
 9 | 	@Override
10 | 	public String getText() {
11 | 		if (text == null) {
12 | 			text = END;
13 | 		}
14 | 		return text;
15 | 	}
16 | 
17 | 	@Override
18 | 	public Object evaluate(TemplateContext context) {
19 | 		return "";
20 | 	}
21 | }
22 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/token/ExpressionToken.java:
--------------------------------------------------------------------------------
  1 | package com.floreysoft.jmte.token;
  2 | 
  3 | import java.util.Collection;
  4 | import java.util.Iterator;
  5 | import java.util.List;
  6 | import java.util.Map;
  7 | import java.util.concurrent.Callable;
  8 | 
  9 | import com.floreysoft.jmte.TemplateContext;
 10 | import com.floreysoft.jmte.util.Util;
 11 | 
 12 | public abstract class ExpressionToken extends AbstractToken {
 13 | 
 14 | 	public final static String segmentsToString(List<String> segments,
 15 | 			int start, int end) {
 16 | 		if (start >= segments.size() || end > segments.size()) {
 17 | 			throw new IllegalArgumentException("Range is not inside segments");
 18 | 		}
 19 | 		StringBuilder builder = new StringBuilder();
 20 | 		for (int i = start; i < end; i++) {
 21 | 			String segment = segments.get(i);
 22 | 			builder.append(segment);
 23 | 			if (i < end - 1) {
 24 | 				builder.append(".");
 25 | 			}
 26 | 		}
 27 | 		return builder.toString();
 28 | 	}
 29 | 
 30 | 	private List<String> segments;
 31 | 	private String expression;
 32 | 
 33 | 	public ExpressionToken(String expression) {
 34 | 		if (expression == null) {
 35 | 			throw new IllegalArgumentException(
 36 | 					"Parameter expression must not be null");
 37 | 		}
 38 | 		this.setExpression(expression);
 39 | 	}
 40 | 
 41 | 	protected ExpressionToken(List<String> segments, String expression) {
 42 | 		this.segments = segments;
 43 | 		this.expression = expression;
 44 | 	}
 45 | 
 46 | 	public boolean isComposed() {
 47 | 		return getSegments().size() > 1;
 48 | 	}
 49 | 
 50 | 	public boolean isEmpty() {
 51 | 		return getSegments().size() == 0;
 52 | 	}
 53 | 
 54 | 	public List<String> getSegments() {
 55 | 		return segments;
 56 | 	}
 57 | 
 58 | 	public String getFirstSegment() {
 59 | 		if (isEmpty()) {
 60 | 			throw new IllegalStateException("There is no first segment");
 61 | 		}
 62 | 
 63 | 		return getSegments().get(0);
 64 | 	}
 65 | 
 66 | 	public String getLastSegment() {
 67 | 		if (isEmpty()) {
 68 | 			throw new IllegalStateException("There is no last segment");
 69 | 		}
 70 | 
 71 | 		return getSegments().get(getSegments().size() - 1);
 72 | 	}
 73 | 
 74 | 	public String getAllButLastSegment() {
 75 | 		if (isEmpty()) {
 76 | 			throw new IllegalStateException("There are no segments");
 77 | 		}
 78 | 
 79 | 		return segmentsToString(segments, 0, getSegments().size() - 1);
 80 | 	}
 81 | 
 82 | 	public String getAllButFirstSegment() {
 83 | 		if (isEmpty()) {
 84 | 			throw new IllegalStateException("There are no segments");
 85 | 		}
 86 | 
 87 | 		return segmentsToString(segments, 1, getSegments().size());
 88 | 	}
 89 | 
 90 | 	public void setExpression(String expression) {
 91 | 		this.text = null;
 92 | 		this.segments = Util.MINI_PARSER.split(expression, '.');
 93 | 		this.expression = Util.MINI_PARSER.unescape(expression);
 94 | 	}
 95 | 
 96 | 	public String getExpression() {
 97 | 		return expression;
 98 | 	}
 99 | 
100 | 	public void setSegments(List<String> segments) {
101 | 		this.segments = segments;
102 | 		this.expression = segmentsToString(segments, 0, segments.size());
103 | 		this.text = null;
104 | 	}
105 | 
106 | 	@Override
107 | 	public abstract Object evaluate(TemplateContext context);
108 | 
109 | 	protected Object evaluatePlain(TemplateContext context) {
110 | 		final Object value = context.modelAdaptor.getValue(context, this, getSegments(), getExpression());
111 | 		return value;
112 | 	}
113 | 
114 | }
115 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/token/ForEachToken.java:
--------------------------------------------------------------------------------
  1 | package com.floreysoft.jmte.token;
  2 | 
  3 | import java.util.Collections;
  4 | import java.util.Iterator;
  5 | import java.util.List;
  6 | import java.util.Map;
  7 | import java.util.concurrent.Callable;
  8 | 
  9 | import com.floreysoft.jmte.TemplateContext;
 10 | import com.floreysoft.jmte.util.Util;
 11 | 
 12 | public class ForEachToken extends ExpressionToken {
 13 | 	public static final String FOREACH = "foreach";
 14 | 
 15 | 	private final String varName;
 16 | 	private final String separator;
 17 | 
 18 | 	private transient Iterator<Object> iterator;
 19 | 	private transient int index;
 20 | 
 21 | 	public ForEachToken(String expression, String varName, String separator) {
 22 | 		super(expression);
 23 | 		this.varName = varName;
 24 | 		this.separator = separator != null ? separator : "";
 25 | 		this.index = -1;
 26 | 	}
 27 | 
 28 | 	public ForEachToken(List<String> segments, String expression, String varName, String separator) {
 29 | 		super(segments, expression);
 30 | 		this.varName = varName;
 31 | 		this.separator = separator != null ? separator : "";
 32 | 		this.index = -1;
 33 | 	}
 34 | 
 35 | 	@Override
 36 | 	public String getText() {
 37 | 		if (text == null) {
 38 | 			text = FOREACH + " " + getExpression() + " " + varName
 39 | 					+ ((separator == null || separator.isEmpty()) ? "" : " " + separator);
 40 | 		}
 41 | 		return text;
 42 | 	}
 43 | 
 44 | 	@Override
 45 | 	@SuppressWarnings("unchecked")
 46 | 	public Object evaluate(TemplateContext context) {
 47 | 		Object value = evaluatePlain(context);
 48 | 
 49 | 		final Iterable<Object> iterable;
 50 | 		if (value == null) {
 51 | 			iterable = Collections.emptyList();
 52 | 		} else if (value instanceof Map) {
 53 | 			iterable = ((Map) value).entrySet();
 54 | 		} else if (value instanceof Iterable) {
 55 | 			iterable = ((Iterable) value);
 56 | 		} else {
 57 | 			List<Object> arrayAsList = Util.arrayAsList(value);
 58 | 			if (arrayAsList != null) {
 59 | 				iterable = arrayAsList;
 60 | 			} else {
 61 | 				// we have a single value here and simply wrap it in a List
 62 | 				iterable = Collections.singletonList(value);
 63 | 			}
 64 | 		}
 65 | 
 66 | 		return iterable;
 67 | 	}
 68 | 
 69 | 	public Iterator<Object> iterator() {
 70 | 		return getIterator();
 71 | 	}
 72 | 
 73 | 	public String getVarName() {
 74 | 		return varName;
 75 | 	}
 76 | 
 77 | 	public String getSeparator() {
 78 | 		return separator;
 79 | 	}
 80 | 
 81 | 	public boolean isLast() {
 82 | 		return !iterator().hasNext();
 83 | 	}
 84 | 
 85 | 	public boolean isFirst() {
 86 | 		return index == 0;
 87 | 	}
 88 | 
 89 | 	public int getIndex() {
 90 | 		return index;
 91 | 	}
 92 | 
 93 | 	public void setIterable(Iterable<Object> iterable) {
 94 | 		this.iterator = iterable.iterator();
 95 | 	}
 96 | 
 97 | 	public void setIterator(Iterator<Object> iterator) {
 98 | 		this.iterator = iterator;
 99 | 	}
100 | 
101 | 	public Iterator<Object> getIterator() {
102 | 		return iterator;
103 | 	}
104 | 	
105 | 	public Object advance() {
106 | 		index++;
107 | 		return iterator.next();
108 | 	}
109 | 
110 | 	public void resetIndex() {
111 | 		index = -1;
112 | 	}
113 | }
114 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/token/IfCmpToken.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.token;
 2 | 
 3 | import java.util.List;
 4 | 
 5 | import com.floreysoft.jmte.TemplateContext;
 6 | 
 7 | 
 8 | public class IfCmpToken extends IfToken {
 9 | 	private final String operand;
10 | 
11 | 	public IfCmpToken(String expression, String operand, boolean negated) {
12 | 		super(expression, negated);
13 | 		this.operand = operand;
14 | 	}
15 | 
16 | 	public IfCmpToken(List<String> segments, String expression, String operand, boolean negated) {
17 | 		super(segments, expression, negated);
18 | 		this.operand = operand;
19 | 	}
20 | 
21 | 	public String getOperand() {
22 | 		return operand;
23 | 	}
24 | 
25 | 	@Override
26 | 	public String getText() {
27 | 		if (text == null) {
28 | 			text = String
29 | 					.format(IF + " %s='%s'", getExpression(), getOperand());
30 | 		}
31 | 		return text;
32 | 	}
33 | 
34 | 	@Override
35 | 	public Object evaluate(TemplateContext context) {
36 | 		final Object value = evaluatePlain(context);
37 | 		final boolean condition = getOperand().equals(value.toString());
38 | 		final Object evaluated = negated ? !condition : condition;
39 | 		return evaluated;
40 | 	}
41 | 
42 | }
43 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/token/IfToken.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.token;
 2 | 
 3 | import java.util.Collection;
 4 | import java.util.Iterator;
 5 | import java.util.List;
 6 | import java.util.Map;
 7 | 
 8 | import com.floreysoft.jmte.TemplateContext;
 9 | import com.floreysoft.jmte.util.Util;
10 | 
11 | public class IfToken extends ExpressionToken {
12 | 	public static final String IF = "if";
13 | 
14 | 	protected final boolean negated;
15 | 
16 | 	public IfToken(String expression, boolean negated) {
17 | 		super(expression);
18 | 		this.negated = negated;
19 | 	}
20 | 
21 | 	public IfToken(List<String> segments, String expression, boolean negated) {
22 | 		super(segments, expression);
23 | 		this.negated = negated;
24 | 	}
25 | 
26 | 	@Override
27 | 	public String getText() {
28 | 		if (text == null) {
29 | 			text = IF + " " + getExpression();
30 | 		}
31 | 		return text;
32 | 	}
33 | 
34 | 	public boolean isNegated() {
35 | 		return negated;
36 | 	}
37 | 
38 | 	@Override
39 | 	@SuppressWarnings("unchecked")
40 | 	public Object evaluate(TemplateContext context) {
41 | 		final Object value = evaluatePlain(context);
42 | 
43 | 		final boolean condition;
44 | 		if (value == null || value.toString().equals("")
45 | 				|| value.toString().equalsIgnoreCase("false")) {
46 | 			condition = false;
47 | 		} else if (value instanceof Boolean) {
48 | 			condition = (Boolean) value;
49 | 		} else if (value instanceof Map) {
50 | 			condition = !((Map) value).isEmpty();
51 | 		} else if (value instanceof Collection) {
52 | 			condition = !((Collection) value).isEmpty();
53 | 		} else if (value instanceof Iterable) {
54 | 			Iterator iterator = ((Iterable) value).iterator();
55 | 			condition = iterator.hasNext();
56 | 		} else {
57 | 			List list = Util.arrayAsList(value);
58 | 			// XXX looks strange, but is ok: list will be null if is
59 | 			// is not an array which results to true
60 | 			condition = list == null || !list.isEmpty();
61 | 		}
62 | 		boolean evaluated = negated ? !condition : condition;
63 | 
64 | 		return evaluated;
65 | 	}
66 | 
67 | 	@Override
68 | 	public String emit() {
69 | 		return getText();
70 | 	}
71 | }
72 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/token/InvalidToken.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.token;
 2 | 
 3 | import com.floreysoft.jmte.TemplateContext;
 4 | 
 5 | public class InvalidToken extends AbstractToken {
 6 | 	public Object evaluate(TemplateContext context) {
 7 | 		context.engine.getErrorHandler().error("invalid-expression", this);
 8 | 		return "";
 9 | 	}
10 | }
11 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/token/Lexer.java:
--------------------------------------------------------------------------------
  1 | package com.floreysoft.jmte.token;
  2 | 
  3 | import static com.floreysoft.jmte.util.NestedParser.*;
  4 | 
  5 | import java.util.List;
  6 | 
  7 | import com.floreysoft.jmte.util.Util;
  8 | 
  9 | public class Lexer {
 10 | 
 11 | 	public AbstractToken nextToken(final char[] template, final int start,
 12 | 			final int end) {
 13 | 		String input = new String(template, start, end - start);
 14 | 		if (input.startsWith("--")) {
 15 | 			// comment
 16 | 			return null;
 17 | 		}
 18 | 		AbstractToken token = innerNextToken(input);
 19 | 		token.setText(template, start, end);
 20 | 		token.setLine(template, start, end);
 21 | 		token.setColumn(template, start, end);
 22 | 		return token;
 23 | 	}
 24 | 	
 25 | 	private String unescapeAccess(List<? extends Object> arr,int index){
 26 | 		String val = access(arr,index);
 27 | 		if (val!=null && val.trim().length()>0){
 28 | 			val = Util.NO_QUOTE_MINI_PARSER.unescape(val); 
 29 | 		}
 30 | 		return val;
 31 | 	}
 32 | 
 33 | 	private AbstractToken innerNextToken(final String untrimmedInput) {
 34 | 		final String input = Util.trimFront(untrimmedInput);
 35 | 		// annotation
 36 | 		if (input.length() > 0 && input.charAt(0) == '@') {
 37 | 			final List<String> split = Util.RAW_MINI_PARSER.splitOnWhitespace(
 38 | 					input.substring(1), 2);
 39 | 			String receiver = access(split, 0);
 40 | 			String arguments = access(split, 1);
 41 | 			AnnotationToken annotationToken = new AnnotationToken(receiver,
 42 | 					arguments);
 43 | 			return annotationToken;
 44 | 		}
 45 | 
 46 | 		final List<String> split = Util.RAW_MINI_PARSER
 47 | 				.splitOnWhitespace(input);
 48 | 
 49 | 		// LENGTH 0
 50 | 		if (split.size() == 0) {
 51 | 			// empty expression like ${}
 52 | 			return new StringToken();
 53 | 		}
 54 | 
 55 | 		if (split.size() >= 2) {
 56 | 			// LENGTH 2..n
 57 | 
 58 | 			final String cmd = split.get(0);
 59 | 			final String objectExpression = split.get(1);
 60 | 
 61 | 			if (cmd.equalsIgnoreCase(IfToken.IF)) {
 62 | 				final boolean negated;
 63 | 				final String ifExpression;
 64 | 				// TODO: Both '!' and '=' work only if there are no white space
 65 | 				// separators
 66 | 				if (objectExpression.startsWith("!")) {
 67 | 					negated = true;
 68 | 					ifExpression = objectExpression.substring(1);
 69 | 				} else {
 70 | 					negated = false;
 71 | 					ifExpression = objectExpression;
 72 | 				}
 73 | 				if (!ifExpression.contains("=")) {
 74 | 					return new IfToken(ifExpression, negated);
 75 | 				} else {
 76 | 					final String[] ifSplit = ifExpression.split("=");
 77 | 					final String variable = ifSplit[0];
 78 | 					String operand = ifSplit[1];
 79 | 					// remove optional quotations
 80 | 					if (operand.startsWith("'") || operand.startsWith("\"")) {
 81 | 						operand = operand.substring(1, operand.length() - 1);
 82 | 					}
 83 | 					return new IfCmpToken(variable, operand, negated);
 84 | 				}
 85 | 			}
 86 | 			if (cmd.equalsIgnoreCase(ForEachToken.FOREACH)) {
 87 | 				final String varName = split.get(2);
 88 | 				// we might also have
 89 | 				// separator
 90 | 				// data
 91 | 				// but as the separator itself can contain
 92 | 				// spaces
 93 | 				// and the number of spaces between the previous
 94 | 				// parts is unknown, we need to do this smarter
 95 | 				int gapCount = 0;
 96 | 				int separatorBegin = 0;
 97 | 				while (separatorBegin < input.length()) {
 98 | 					char c = input.charAt(separatorBegin);
 99 | 					separatorBegin++;
100 | 					if (Character.isWhitespace(c)) {
101 | 						gapCount++;
102 | 						if (gapCount == 3) {
103 | 							break;
104 | 						} else {
105 | 							while (Character.isWhitespace(c = input
106 | 									.charAt(separatorBegin)))
107 | 								separatorBegin++;
108 | 						}
109 | 					}
110 | 				}
111 | 
112 | 				String separator = input.substring(separatorBegin);
113 | 				if (separator !=null){
114 | 					separator = Util.NO_QUOTE_MINI_PARSER.unescape(separator);
115 | 				}
116 | 				return new ForEachToken(objectExpression, varName, separator
117 | 						.length() != 0 ? separator : null);
118 | 			}
119 | 		}
120 | 
121 | 		final String objectExpression = split.get(0);
122 | 		// ${
123 | 		// } which might be used for silent line breaks
124 | 		if (objectExpression.equals("")) {
125 | 			return new StringToken();
126 | 		}
127 | 		final String cmd = objectExpression;
128 | 		if (cmd.equalsIgnoreCase(ElseToken.ELSE)) {
129 | 			return new ElseToken();
130 | 		}
131 | 		if (cmd.equalsIgnoreCase(EndToken.END)) {
132 | 			return new EndToken();
133 | 		}
134 | 
135 | 		// ${<h1>,address(NIX),</h1>;long(full)}
136 | 		String variableName = null; // address
137 | 		String defaultValue = null; // NIX
138 | 		String prefix = null; // <h1>
139 | 		String suffix = null; // </h1>
140 | 		String rendererName = null; // long
141 | 		String parameters = null; // full
142 | 
143 | 		// be sure to use the raw input as we might have to preserve
144 | 		// whitespace for prefix and postfix
145 | 		// only innermost parsers are allowed to unescape
146 | 		final List<String> strings = Util.RAW_OUTPUT_MINI_PARSER.split(
147 | 				untrimmedInput, ';', 2);
148 | 		// <h1>,address(NIX),</h1>
149 | 		final String complexVariable = strings.get(0);
150 | 		// only innermost parsers are allowed to unescape
151 | 		final List<String> wrappedStrings = Util.RAW_OUTPUT_MINI_PARSER.split(
152 | 				complexVariable, ',', 3);
153 | 		// <h1>
154 | 		prefix = wrappedStrings.size() == 3 ? unescapeAccess(wrappedStrings, 0) : null;
155 | 		// </h1>
156 | 		suffix = wrappedStrings.size() == 3 ? unescapeAccess(wrappedStrings, 2) : null;
157 | 
158 | 		// address(NIX)
159 | 		final String completeDefaultString = (wrappedStrings.size() == 3 ? unescapeAccess(
160 | 				wrappedStrings, 1)
161 | 				: complexVariable).trim();
162 | 		final List<String> defaultStrings = Util.MINI_PARSER.greedyScan(
163 | 				completeDefaultString, "(", ")");
164 | 		// address
165 | 		variableName = unescapeAccess(defaultStrings, 0);
166 | 		// NIX
167 | 		defaultValue = unescapeAccess(defaultStrings, 1);
168 | 
169 | 		// long(full)
170 | 		final String format = access(strings, 1);
171 | 		final List<String> scannedFormat = Util.MINI_PARSER.greedyScan(format,
172 | 				"(", ")");
173 | 		// long
174 | 		rendererName = access(scannedFormat, 0);
175 | 		// full
176 | 		parameters = access(scannedFormat, 1);
177 | 
178 | 		// this is not a well formed variable name
179 | 		if (variableName.contains(" ")) {
180 | 			return new InvalidToken();
181 | 		}
182 | 
183 | 		final StringToken stringToken = new StringToken(untrimmedInput,
184 | 				variableName, defaultValue, prefix, suffix, rendererName,
185 | 				parameters);
186 | 		return stringToken;
187 | 
188 | 	}
189 | 
190 | }
191 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/token/PlainTextToken.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.token;
 2 | 
 3 | import com.floreysoft.jmte.TemplateContext;
 4 | 
 5 | public class PlainTextToken extends AbstractToken {
 6 | 	public PlainTextToken(String text) {
 7 | 		setText(text);
 8 | 	}
 9 | 
10 | 	@Override
11 | 	public Object evaluate(TemplateContext context) {
12 | 		return getText();
13 | 	}
14 | 
15 | 	@Override
16 | 	public String emit() {
17 | 		return getText();
18 | 	}
19 | }
20 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/token/StringToken.java:
--------------------------------------------------------------------------------
  1 | package com.floreysoft.jmte.token;
  2 | 
  3 | import java.util.List;
  4 | 
  5 | import com.floreysoft.jmte.NamedRenderer;
  6 | import com.floreysoft.jmte.Renderer;
  7 | import com.floreysoft.jmte.TemplateContext;
  8 | import com.floreysoft.jmte.encoder.Encoder;
  9 | import com.floreysoft.jmte.renderer.RawRenderer;
 10 | 
 11 | public class StringToken extends ExpressionToken {
 12 | 	// ${<h1>,address(NIX),</h1>;long(full)}
 13 | 	private final String defaultValue; // NIX
 14 | 	private final String prefix; // <h1>
 15 | 	private final String suffix; // </h1>
 16 | 	private final String rendererName; // long
 17 | 	private final String parameters; // full
 18 | 
 19 | 	public StringToken() {
 20 | 		this("", "", null, null, null, null, null);
 21 | 	}
 22 | 
 23 | 	public StringToken(String text, String variableName, String defaultValue,
 24 | 			String prefix, String suffix, String rendererName, String parameters) {
 25 | 		super(variableName);
 26 | 		this.defaultValue = defaultValue;
 27 | 		this.prefix = prefix;
 28 | 		this.suffix = suffix;
 29 | 		this.rendererName = rendererName;
 30 | 		this.parameters = parameters;
 31 | 		setText(text);
 32 | 	}
 33 | 
 34 | 	public StringToken(String variableName) {
 35 | 		this(variableName, variableName, null, null, null, null, null);
 36 | 	}
 37 | 
 38 | 	public StringToken(String text, List<String> segments, String variableName,
 39 | 			String defaultValue, String prefix, String suffix,
 40 | 			String rendererName, String parameters) {
 41 | 		super(segments, variableName);
 42 | 		this.defaultValue = defaultValue;
 43 | 		this.prefix = prefix;
 44 | 		this.suffix = suffix;
 45 | 		this.rendererName = rendererName;
 46 | 		this.parameters = parameters;
 47 | 		setText(text);
 48 | 	}
 49 | 
 50 | 	public StringToken(List<String> segments, String variableName) {
 51 | 		super(segments, variableName);
 52 | 		this.defaultValue = null;
 53 | 		this.prefix = null;
 54 | 		this.suffix = null;
 55 | 		this.rendererName = null;
 56 | 		this.parameters = null;
 57 | 	}
 58 | 
 59 | 	public String getPrefix() {
 60 | 		return prefix;
 61 | 	}
 62 | 
 63 | 	public String getSuffix() {
 64 | 		return suffix;
 65 | 	}
 66 | 
 67 | 	public String getDefaultValue() {
 68 | 		return defaultValue;
 69 | 	}
 70 | 
 71 | 	@SuppressWarnings("unchecked")
 72 | 	@Override
 73 | 	public Object evaluate(TemplateContext context) {
 74 | 		boolean rawRendering = false;
 75 | 		final Object value = evaluatePlain(context);
 76 | 
 77 | 		final String renderedResult;
 78 | 		if (value == null || value.equals("")) {
 79 | 			renderedResult = defaultValue != null ? defaultValue : "";
 80 | 		} else {
 81 | 			String namedRendererResult = null;
 82 | 			if (rendererName != null && !rendererName.equals("")) {
 83 | 				final NamedRenderer rendererForName = context
 84 | 						.resolveNamedRenderer(rendererName);
 85 | 				if (rendererForName != null) {
 86 | 					if (rendererForName instanceof RawRenderer) {
 87 | 						rawRendering = true;
 88 | 					}
 89 | 					namedRendererResult = rendererForName.render(value, parameters, context.locale);
 90 | 				}
 91 | 			}
 92 | 			if (namedRendererResult != null) {
 93 | 				renderedResult = namedRendererResult;
 94 | 			} else {
 95 | 				final Renderer<Object> rendererForClass = (Renderer<Object>) context
 96 | 						.resolveRendererForClass(value.getClass());
 97 | 				if (rendererForClass != null) {
 98 | 					if (rendererForClass instanceof RawRenderer) {
 99 | 						rawRendering = true;
100 | 					}
101 | 					renderedResult = rendererForClass.render(value, context.locale);
102 | 				} else {
103 | 					renderedResult = value.toString();
104 | 				}
105 | 			}
106 | 		}
107 | 
108 | 		if (renderedResult == null || renderedResult.equals("")) {
109 | 			return renderedResult;
110 | 		} else {
111 | 			final String prefixedRenderedResult = (prefix != null ? prefix : "") + renderedResult + (suffix != null ? suffix : "");
112 | 			Encoder encoder = context.getEncoder();
113 | 			if (!rawRendering && encoder != null) {
114 | 				final String encodedPrefixedRenderedResult = encoder.encode(prefixedRenderedResult);
115 | 				return encodedPrefixedRenderedResult;
116 | 			} else {
117 | 				return prefixedRenderedResult;
118 | 			}
119 | 		}
120 | 	}
121 | 
122 | 	public String getRendererName() {
123 | 		return rendererName;
124 | 	}
125 | 
126 | 	public String getParameters() {
127 | 		return parameters;
128 | 	}
129 | 
130 |   @Override
131 |   public String emit() {
132 |     StringBuilder sb = new StringBuilder();
133 |     if ( prefix != null ) {
134 |       sb.append(prefix).append(',');
135 |     }
136 |     sb.append(getExpression());
137 |     if ( defaultValue != null ) {
138 |       sb.append('(').append(defaultValue).append(')');
139 |     }
140 |     if ( suffix != null ) {
141 |       sb.append(',').append(suffix);
142 |     }
143 |     if ( rendererName != null ) {
144 |       sb.append(';').append(rendererName);
145 |     }
146 |     if ( parameters != null ) {
147 |       sb.append('(').append(parameters).append(')');
148 |     }
149 |     return sb.toString();
150 |   }
151 | }
152 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/token/Token.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.token;
 2 | 
 3 | import com.floreysoft.jmte.Engine;
 4 | import com.floreysoft.jmte.TemplateContext;
 5 | 
 6 | 
 7 | /**
 8 |  * Internal structure returned by the {@link Lexer} passing parsed information
 9 |  * into the {@link Engine}.
10 |  */
11 | public interface Token extends Cloneable {
12 | 
13 | 	/**
14 | 	 * Returns the text of the token.
15 | 	 * 
16 | 	 * @return the text
17 | 	 */
18 | 	public String getText();
19 | 
20 | 	public int getLine();
21 | 
22 | 	public int getColumn();
23 | 
24 | 	public String getSourceName();
25 | 	
26 | 	public Object evaluate(TemplateContext context);
27 | 	
28 | 	public int getTokenIndex();
29 | 	
30 | 	public String emit();
31 | }
32 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/token/TokenStream.java:
--------------------------------------------------------------------------------
  1 | package com.floreysoft.jmte.token;
  2 | 
  3 | import java.util.ArrayList;
  4 | import java.util.List;
  5 | 
  6 | import com.floreysoft.jmte.util.StartEndPair;
  7 | import com.floreysoft.jmte.util.Util;
  8 | 
  9 | public class TokenStream {
 10 | 	private final Lexer lexer = new Lexer();
 11 | 	private final String sourceName;
 12 | 	private final String input;
 13 | 	private final List<StartEndPair> scan;
 14 | 	private final String splitStart;
 15 | 	private final String splitEnd;
 16 | 
 17 | 	private transient List<Token> tokens = null;
 18 | 	private transient int currentTokenIndex = -1;
 19 | 	private transient Token currentToken = null;
 20 | 
 21 | 	public TokenStream(String sourceName, String input, String splitStart,
 22 | 			String splitEnd) {
 23 | 		this.sourceName = sourceName;
 24 | 		this.input = input;
 25 | 		this.splitStart = splitStart;
 26 | 		this.splitEnd = splitEnd;
 27 | 		this.scan = Util.scan(input, splitStart, splitEnd, true);
 28 | 	}
 29 | 
 30 | 	private void fillTokens() {
 31 | 		this.tokens = new ArrayList<Token>();
 32 | 		final char[] inputChars = input.toCharArray();
 33 | 		int offset = 0;
 34 | 		int index = 0;
 35 | 		for (StartEndPair startEndPair : scan) {
 36 | 			int plainTextLengthBeforeNextToken = startEndPair.start
 37 | 					- splitStart.length() - offset;
 38 | 			if (plainTextLengthBeforeNextToken != 0) {
 39 | 				AbstractToken token = new PlainTextToken(Util.NO_QUOTE_MINI_PARSER.unescape(new String(inputChars,
 40 | 						offset, plainTextLengthBeforeNextToken)));
 41 | 				token.setTokenIndex(index++);
 42 | 				tokens.add(token);
 43 | 			}
 44 | 			offset = startEndPair.end + splitEnd.length();
 45 | 
 46 | 			AbstractToken token = lexer.nextToken(inputChars,
 47 | 					startEndPair.start, startEndPair.end);
 48 | 			// == null means this is a comment or other skipable stuff
 49 | 			if (token == null) {
 50 | 				continue;
 51 | 			}
 52 | 			token.setSourceName(sourceName);
 53 | 			token.setTokenIndex(index++);
 54 | 			tokens.add(token);
 55 | 		}
 56 | 
 57 | 		// do not forget to add the final chunk of pure text (might be the
 58 | 		// only
 59 | 		// chunk indeed)
 60 | 		int remainingChars = input.length() - offset;
 61 | 		if (remainingChars != 0) {
 62 | 			AbstractToken token = new PlainTextToken(Util.NO_QUOTE_MINI_PARSER.unescape(new String(inputChars,
 63 | 					offset, remainingChars)));
 64 | 			token.setTokenIndex(index++);
 65 | 			tokens.add(token);
 66 | 		}
 67 | 	}
 68 | 
 69 | 	private void initTokens() {
 70 | 		if (this.tokens == null) {
 71 | 			fillTokens();
 72 | 			this.currentTokenIndex = 0;
 73 | 		}
 74 | 	}
 75 | 
 76 | 	public Token nextToken() {
 77 | 		initTokens();
 78 | 		if (currentTokenIndex < tokens.size()) {
 79 | 			currentToken = tokens.get(currentTokenIndex++);
 80 | 		} else {
 81 | 			currentToken = null;
 82 | 		}
 83 | 		return currentToken;
 84 | 	}
 85 | 
 86 | 	public void consume() {
 87 | 		nextToken();
 88 | 	}
 89 | 
 90 | 	public Token currentToken() {
 91 | 		return currentToken;
 92 | 	}
 93 | 
 94 | 	public void rewind(Token tokenToRewindTo) {
 95 | 		initTokens();
 96 | 		this.currentTokenIndex = tokenToRewindTo.getTokenIndex() + 1;
 97 | 		consume();
 98 | 	}
 99 | 
100 | 	public List<Token> getAllTokens() {
101 | 		initTokens();
102 | 		return this.tokens;
103 | 	}
104 | 
105 | 	public void prefill() {
106 | 		initTokens();
107 | 	}
108 | 
109 | 	public void reset() {
110 | 		currentTokenIndex = 0;		
111 | 	}
112 | }
113 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/util/MiniParser.java:
--------------------------------------------------------------------------------
  1 | package com.floreysoft.jmte.util;
  2 | 
  3 | import java.util.ArrayList;
  4 | import java.util.List;
  5 | 
  6 | /**
  7 |  * Parser for embedded mini languages.
  8 |  * 
  9 |  * <p>
 10 |  * <ul>
 11 |  * <li>Solves Demarcation: Where does an embedded language begin and where does
 12 |  * it end
 13 |  * <ul>
 14 |  * <li>Escaping
 15 |  * <li>Quotation
 16 |  * <li>Graceful reaction to and recovery from invalid input
 17 |  * </ul>
 18 |  * </li>
 19 |  * <li>Lays ground for common patterns of mini langauge processing
 20 |  * <ul>
 21 |  * <li>all kinds of nested brackets
 22 |  * <li>segmentation of data
 23 |  * <li>not loosing context
 24 |  * <li>context sensitive parsing aka lexer modes/states
 25 |  * </ul>
 26 |  * </li>
 27 |  * </ul>
 28 |  * </p>
 29 |  * 
 30 |  * Not thread safe.
 31 |  * 
 32 |  * @author olli
 33 |  * 
 34 |  */
 35 | public final class MiniParser {
 36 | 
 37 | 	public final static char DEFAULT_ESCAPE_CHAR = '\\';
 38 | 	public final static char DEFAULT_QUOTE_CHAR = '"';
 39 | 
 40 | 	public static MiniParser defaultInstance() {
 41 | 		return new MiniParser(DEFAULT_ESCAPE_CHAR, DEFAULT_QUOTE_CHAR, false,
 42 | 				false, false);
 43 | 	}
 44 | 
 45 | 	public static MiniParser trimmedInstance() {
 46 | 		return new MiniParser(DEFAULT_ESCAPE_CHAR, DEFAULT_QUOTE_CHAR, false,
 47 | 				true, false);
 48 | 	}
 49 | 
 50 | 	public static MiniParser ignoreCaseInstance() {
 51 | 		return new MiniParser(DEFAULT_ESCAPE_CHAR, DEFAULT_QUOTE_CHAR, true,
 52 | 				false, false);
 53 | 	}
 54 | 
 55 | 	public static MiniParser fullRawInstance() {
 56 | 		return new MiniParser((char) -1, (char) -1, false, false, true);
 57 | 	}
 58 | 
 59 | 	public static MiniParser rawOutputInstance() {
 60 | 		return new MiniParser(DEFAULT_ESCAPE_CHAR, DEFAULT_QUOTE_CHAR, false,
 61 | 				false, true);
 62 | 	}
 63 | 
 64 | 	private final char escapeChar;
 65 | 	private final char quoteChar;
 66 | 	private final boolean ignoreCase;
 67 | 	private final boolean trim;
 68 | 	private final boolean rawOutput;
 69 | 
 70 | 	private transient boolean escaped = false;
 71 | 	private transient boolean quoted = false;
 72 | 
 73 | 	public MiniParser(final char escapeChar, final char quoteChar,
 74 | 			final boolean ignoreCase, final boolean trim,
 75 | 			final boolean rawOutput) {
 76 | 		this.escapeChar = escapeChar;
 77 | 		this.quoteChar = quoteChar;
 78 | 		this.ignoreCase = ignoreCase;
 79 | 		this.trim = trim;
 80 | 		this.rawOutput = rawOutput;
 81 | 	}
 82 | 
 83 | 	public String replace(final String input, final String oldString,
 84 | 			final String newString) {
 85 | 		try {
 86 | 			if (oldString == null || oldString.equals("")) {
 87 | 				return input;
 88 | 			}
 89 | 			StringBuilder buffer = new StringBuilder();
 90 | 			for (int index = 0; index < input.length(); index++) {
 91 | 				if (input.regionMatches(ignoreCase, index, oldString, 0,
 92 | 						oldString.length())) {
 93 | 					buffer.append(newString);
 94 | 					index += oldString.length() - 1;
 95 | 				} else {
 96 | 					char c = input.charAt(index);
 97 | 					append(buffer, c);
 98 | 				}
 99 | 			}
100 | 
101 | 			return buffer.toString();
102 | 		} finally {
103 | 			escaped = false;
104 | 			quoted = false;
105 | 		}
106 | 	}
107 | 
108 | 	public List<String> split(final String input, final char separator) {
109 | 		return split(input, separator, Integer.MAX_VALUE);
110 | 	}
111 | 
112 | 	public List<String> split(final String input, final char separator,
113 | 			final int maxSegments) {
114 | 		return splitInternal(input, false, separator, null, maxSegments);
115 | 	}
116 | 
117 | 	public List<String> split(final String input, final String separatorSet) {
118 | 		return split(input, separatorSet, Integer.MAX_VALUE);
119 | 	}
120 | 
121 | 	public List<String> split(final String input, final String separatorSet,
122 | 			final int maxSegments) {
123 | 		return splitInternal(input, false, (char) -1, separatorSet, maxSegments);
124 | 	}
125 | 
126 | 	public List<String> splitOnWhitespace(final String input,
127 | 			final int maxSegments) {
128 | 		return splitInternal(input, true, (char) -1, null, maxSegments);
129 | 	}
130 | 
131 | 	public List<String> splitOnWhitespace(final String input) {
132 | 		return splitOnWhitespace(input, Integer.MAX_VALUE);
133 | 	}
134 | 
135 | 	// Common implementation for single char separator and string set separator.
136 | 	// Has the benefit of shared code and caliper mini benchmarks showed no
137 | 	// measurable performance penalty for additional check which separator to
138 | 	// use
139 | 	private List<String> splitInternal(final String input,
140 | 			final boolean splitOnWhitespace, final char separator,
141 | 			final String separatorSet, final int maxSegments) {
142 | 		if (input == null) {
143 | 			return null;
144 | 		}
145 | 		try {
146 | 			final List<String> segments = new ArrayList<String>();
147 | 			StringBuilder buffer = new StringBuilder();
148 | 
149 | 			for (int index = 0; index < input.length(); index++) {
150 | 				final char c = input.charAt(index);
151 | 				boolean separatedByWhitespace = false;
152 | 				if (splitOnWhitespace) {
153 | 					for (; index < input.length()
154 | 							&& Character.isWhitespace(input.charAt(index)); index++) {
155 | 						separatedByWhitespace = true;
156 | 					}
157 | 					if (separatedByWhitespace) {
158 | 						index--;
159 | 					}
160 | 				}
161 | 
162 | 				final boolean separates = separatedByWhitespace
163 | 						|| (separatorSet != null ? separatorSet.indexOf(c) != -1
164 | 								: c == separator);
165 | 				// in case we are not already in the last segment and there is
166 | 				// an
167 | 				// unsecaped, unquoted separator, this segment is now done
168 | 				if (segments.size() != maxSegments - 1 && separates
169 | 						&& !isEscaped()) {
170 | 					finish(segments, buffer);
171 | 					buffer = new StringBuilder();
172 | 				} else {
173 | 					append(buffer, c);
174 | 				}
175 | 			}
176 | 			if (!splitOnWhitespace || buffer.length() != 0) {
177 | 				finish(segments, buffer);
178 | 			}
179 | 			return segments;
180 | 		} finally {
181 | 			escaped = false;
182 | 			quoted = false;
183 | 		}
184 | 	}
185 | 
186 | 	private void finish(final List<String> segments, StringBuilder buffer) {
187 | 		String string = buffer.toString();
188 | 		segments.add(trim ? string.trim() : string);
189 | 	}
190 | 
191 | 	public int lastIndexOf(final String input, final String substring) {
192 | 		return indexOfInternal(input, substring, true);
193 | 	}
194 | 
195 | 	public int indexOf(final String input, final String substring) {
196 | 		return indexOfInternal(input, substring, false);
197 | 	}
198 | 
199 | 	private int indexOfInternal(final String input, final String substring,
200 | 			boolean last) {
201 | 		int resultIndex = -1;
202 | 		for (int index = 0; index < input.length(); index++) {
203 | 			if (input.regionMatches(ignoreCase, index, substring, 0, substring
204 | 					.length())
205 | 					&& !isEscaped()) {
206 | 				resultIndex = index;
207 | 				if (!last) {
208 | 					break;
209 | 				}
210 | 			}
211 | 		}
212 | 		return resultIndex;
213 | 
214 | 	}
215 | 
216 | 	public List<String> scan(final String input, final String splitStart,
217 | 			final String splitEnd) {
218 | 		return scan(input, splitStart, splitEnd, false);
219 | 	}
220 | 
221 | 	public List<String> greedyScan(final String input, final String splitStart,
222 | 			final String splitEnd) {
223 | 		return scan(input, splitStart, splitEnd, true);
224 | 	}
225 | 
226 | 	public List<String> scan(final String input, final String splitStart,
227 | 			final String splitEnd, boolean greedy) {
228 | 		if (input == null) {
229 | 			return null;
230 | 		}
231 | 		try {
232 | 			final List<String> segments = new ArrayList<String>();
233 | 			StringBuilder buffer = new StringBuilder();
234 | 			boolean started = false;
235 | 			int lastIndexOfEnd = greedy ? lastIndexOfEnd = lastIndexOf(input,
236 | 					splitEnd) : -1;
237 | 			char c;
238 | 			int index = 0;
239 | 			while (index < input.length()) {
240 | 				c = input.charAt(index);
241 | 				final boolean greedyCond = !started || !greedy
242 | 						|| index == lastIndexOfEnd;
243 | 				final String separator = started ? splitEnd : splitStart;
244 | 				if (input.regionMatches(ignoreCase, index, separator, 0,
245 | 						separator.length())
246 | 						&& !isEscaped() && greedyCond) {
247 | 					finish(segments, buffer);
248 | 					buffer = new StringBuilder();
249 | 					started = !started;
250 | 					index += separator.length();
251 | 				} else {
252 | 					append(buffer, c);
253 | 					index++;
254 | 				}
255 | 			}
256 | 			// add trailing element to result
257 | 			if (buffer.length() != 0) {
258 | 				finish(segments, buffer);
259 | 			}
260 | 			return segments;
261 | 		} finally {
262 | 			escaped = false;
263 | 			quoted = false;
264 | 		}
265 | 	}
266 | 
267 | 	public String unescape(final String input) {
268 | 		final StringBuilder unescaped = new StringBuilder();
269 | 		for (int i = 0; i < input.length(); i++) {
270 | 			final char c = input.charAt(i);
271 | 			append(unescaped, c);
272 | 		}
273 | 		return unescaped.toString();
274 | 	}
275 | 
276 | 	// the heart of it all
277 | 	private void append(StringBuilder buffer, char c) {
278 | 
279 | 		// version manually simplified
280 | 		// final boolean shouldAppend = rawOutput || escaped
281 | 		// || (c != quoteChar && c != escapeChar);
282 | 		// final boolean newEscaped = c == escapeChar && !escaped;
283 | 		// final boolean newQuoted = (c == quoteChar && !escaped) ? !quoted
284 | 		// : quoted;
285 | 
286 | 		// side-effect free version directly extracted from if
287 | 
288 | 		// final boolean shouldAppend = (c == escapeChar && (escaped ||
289 | 		// rawOutput))
290 | 		// || (c == quoteChar && (escaped || rawOutput))
291 | 		// || !(c == quoteChar || c == escapeChar);
292 | 		// final boolean newEscaped = c == escapeChar ? !escaped
293 | 		// : (c == quoteChar ? false : false);
294 | 		// final boolean newQuoted = c == escapeChar ? quoted
295 | 		// : (c == quoteChar ? (!escaped ? !quoted : quoted) : quoted);
296 | 
297 | 		// if (shouldAppend) {
298 | 		// buffer.append(c);
299 | 		// }
300 | 		//
301 | 		// escaped = newEscaped;
302 | 		// quoted = newQuoted;
303 | 
304 | 		// original version
305 | 		// XXX needed to revert to this original version as micro benchmark
306 | 		// tests
307 | 		// showed a slow down of more than 100%
308 | 		if (c == escapeChar) {
309 | 			if (escaped || rawOutput) {
310 | 				buffer.append(c);
311 | 			}
312 | 			escaped = !escaped;
313 | 		} else if (c == quoteChar) {
314 | 			if (escaped) {
315 | 				buffer.append(c);
316 | 				escaped = false;
317 | 			} else {
318 | 				quoted = !quoted;
319 | 				if (rawOutput) {
320 | 					buffer.append(c);
321 | 				}
322 | 			}
323 | 		} else {
324 | 			buffer.append(c);
325 | 			escaped = false;
326 | 		}
327 | 	}
328 | 
329 | 	private boolean isEscaped() {
330 | 		return escaped || quoted;
331 | 	}
332 | }
333 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/util/NestedParser.java:
--------------------------------------------------------------------------------
  1 | package com.floreysoft.jmte.util;
  2 | 
  3 | import java.util.ArrayList;
  4 | import java.util.Arrays;
  5 | import java.util.Collections;
  6 | import java.util.List;
  7 | 
  8 | /**
  9 |  * Mini parser for mini DSL stuff. Use it when you do not want
 10 |  * <ul>
 11 |  * <li>a full parser, as it would be overkill
 12 |  * <li>to code by hand it in an ad-hoc way, as you have done this wrong too many
 13 |  * times (just think about escaping and quoting)
 14 |  * <li>built-in regexp , as it is too slow and you actually do not quite up to
 15 |  * it (true for me)
 16 |  * </ul>
 17 |  * 
 18 |  * <p>
 19 |  * This is a fast, simple parser that takes input and a single, global hierarchy
 20 |  * of operators and spits out "AST" implemented as nested Lists.
 21 |  * </p>
 22 |  * 
 23 |  * <pre>
 24 |  * String input = "string(maxLength=10, trim, uppercase)";
 25 |  * String[] operators = { "()", ",", "=" }; // in order of precedence, can be pair of start/end or single char separator
 26 |  * List<Object> parse = new NestedParser().parse(input, operators);
 27 |  * System.out.println(parse);
 28 |  * 
 29 |  * Output =>
 30 |  * 
 31 |  * [string, [[maxLength, 10], trim, uppercase]]
 32 |  * 
 33 |  * TODO: Possible extensions could be
 34 |  * <ul>
 35 |  * <li>a hierarchy of operators (not a list, but a tree) to parser even more complicated inputs
 36 |  * <li>Panic mode calling a user specified callback for further processing when either less or more segments as expected are found in a split
 37 |  * </ul>
 38 |  * 
 39 |  */
 40 | public final class NestedParser {
 41 | 	
 42 | 	private final static MiniParser MINI_PARSER = MiniParser.rawOutputInstance();
 43 | 	private final static MiniParser INNER_MINI_PARSER = MiniParser.trimmedInstance();
 44 | 
 45 | 	public static String access(final List<? extends Object> ast,
 46 | 			final int index) {
 47 | 		return access(ast, index, null);
 48 | 	}
 49 | 
 50 | 	public static String access(final List<? extends Object> ast,
 51 | 			final int index, final String defaultValue) {
 52 | 		if (ast == null) {
 53 | 			return defaultValue;
 54 | 		}
 55 | 
 56 | 		if (index < ast.size()) {
 57 | 			Object object = ast.get(index);
 58 | 			if (object instanceof String) {
 59 | 				return (String) object;
 60 | 			} else {
 61 | 				throw new IllegalArgumentException(
 62 | 						"You can only access scalar strings");
 63 | 			}
 64 | 		}
 65 | 		return defaultValue;
 66 | 	}
 67 | 
 68 | 	// TODO create a version that allows for multi character operators
 69 | 	public List<Object> parse(final String input, final List<String> operators) {
 70 | 		final List<Object> result = new ArrayList<Object>();
 71 | 		if (operators.size() != 0) {
 72 | 			final boolean innerLoop = operators.size() == 1;
 73 | 			final MiniParser currentParser = innerLoop ? INNER_MINI_PARSER
 74 | 					: MINI_PARSER;
 75 | 			final String operator = operators.get(0);
 76 | 			final List<String> segments;
 77 | 			if (operator.length() == 1) {
 78 | 				segments = currentParser.split(input, operator.charAt(0));
 79 | 			} else if (operator.length() == 2) {
 80 | 
 81 | 				List<String> allSegments = currentParser.scan(input, String
 82 | 						.valueOf(operator.charAt(0)), String.valueOf(operator
 83 | 						.charAt(1)), true);
 84 | 				if (allSegments.size() > 0) {
 85 | 					// the first part is not processed any further
 86 | 					result.add(allSegments.get(0));
 87 | 				}
 88 | 				if (allSegments.size() > 1) {
 89 | 					segments = allSegments.subList(1, allSegments.size());
 90 | 				} else {
 91 | 					segments = Collections.emptyList();
 92 | 				}
 93 | 
 94 | 			} else {
 95 | 				throw new IllegalArgumentException(
 96 | 						"Operators must either be start/end pairs or single characters");
 97 | 
 98 | 			}
 99 | 			if (innerLoop) {
100 | 				result.addAll(segments);
101 | 			} else {
102 | 				for (String segment : segments) {
103 | 					List<Object> parse = parse(segment, operators.subList(1,
104 | 							operators.size()));
105 | 					if (parse.size() == 1 && parse.get(0) instanceof String) {
106 | 						result.add(parse.get(0));
107 | 					} else {
108 | 						result.add(parse);
109 | 					}
110 | 				}
111 | 			}
112 | 		}
113 | 		return result;
114 | 	}
115 | 
116 | 	public List<Object> parse(final String input, final String[] operators) {
117 | 		return parse(input, Arrays.asList(operators));
118 | 	}
119 | 
120 | }
121 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/util/StartEndPair.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.util;
 2 | 
 3 | /**
 4 |  * Pairs of begin/end.
 5 |  * 
 6 |  */
 7 | public final class StartEndPair {
 8 | 	public final int start;
 9 | 	public final int end;
10 | 
11 | 	public StartEndPair(final int start, final int end) {
12 | 		this.start = start;
13 | 		this.end = end;
14 | 	}
15 | 
16 | 	@Override
17 | 	public String toString() {
18 | 		return "" + start + "-" + end;
19 | 	}
20 | }


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/util/Tool.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.util;
 2 | 
 3 | import java.io.File;
 4 | import java.io.FileInputStream;
 5 | import java.io.FileNotFoundException;
 6 | import java.io.IOException;
 7 | import java.io.UnsupportedEncodingException;
 8 | import java.util.Map;
 9 | import java.util.Properties;
10 | 
11 | import com.floreysoft.jmte.Engine;
12 | 
13 | 
14 | /**
15 |  * <p>Main class used as a command line tool. You pass at least two arguments</p>
16 |  * <ul>
17 |  * <li>file name of the template to use
18 |  * <li>property file containing flat name/value entries which will be used as the model
19 |  * <li>optionally the charset name used inside the template - default is ISO-8859-15
20 |  * </ul>
21 |  * 
22 |  */
23 | public final class Tool {
24 | 
25 | 	@SuppressWarnings("unchecked")
26 | 	public static String transform(File template, File propertiesFile,
27 | 			String charsetName) throws UnsupportedEncodingException,
28 | 			FileNotFoundException, IOException {
29 | 		if (!template.exists()) {
30 | 			throw new IllegalArgumentException(String.format(
31 | 					"Tempalte file '%s' does not exist", template
32 | 							.getCanonicalPath()));
33 | 		}
34 | 		if (!propertiesFile.exists()) {
35 | 			throw new IllegalArgumentException(String.format(
36 | 					"Properties file '%s' does not exist", propertiesFile
37 | 							.getCanonicalPath()));
38 | 		}
39 | 		FileInputStream stream = null;
40 | 		try {
41 | 			String input = Util.fileToString(template, charsetName);
42 | 			Engine engine = new Engine();
43 | 
44 | 			Properties properties = new Properties();
45 | 			stream = new FileInputStream(propertiesFile);
46 | 			properties.load(stream);
47 | 
48 | 			Map model = properties;
49 | 			String transformed = engine.transform(input, model);
50 | 			return transformed;
51 | 		} finally {
52 | 			try {
53 | 				stream.close();
54 | 			} catch (IOException e) {
55 | 			}
56 | 		}
57 | 	}
58 | 
59 | 	public static void main(String[] args) {
60 | 		try {
61 | 			String charsetName = "ISO-8859-15";
62 | 			if (args.length < 2) {
63 | 				System.err
64 | 						.println("We need at least template and properties file as input");
65 | 				System.exit(-1);
66 | 			}
67 | 			File template = new File(args[0]);
68 | 			File propertiesFile = new File(args[1]);
69 | 			if (args.length > 2) {
70 | 				charsetName = args[2];
71 | 			}
72 | 			String transformed = transform(template, propertiesFile,
73 | 					charsetName);
74 | 			System.out.println(transformed);
75 | 		} catch (Exception e) {
76 | 			System.err.println(e.getMessage());
77 | 			System.exit(-1);
78 | 		}
79 | 	}
80 | }
81 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/util/UniqueNameGenerator.java:
--------------------------------------------------------------------------------
 1 | package com.floreysoft.jmte.util;
 2 | 
 3 | import java.util.HashMap;
 4 | import java.util.Map;
 5 | 
 6 | public class UniqueNameGenerator<F, T> {
 7 | 
 8 | 	private final Map<F, T> translations = new HashMap<F, T>();
 9 | 
10 | 	private final String prefix;
11 | 	private long cnt;
12 | 
13 | 	public UniqueNameGenerator(String prefix, long startCnt) {
14 | 		this.prefix = prefix;
15 | 		this.cnt = startCnt;
16 | 	}
17 | 
18 | 	public UniqueNameGenerator(String prefix) {
19 | 		this(prefix, 0);
20 | 	}
21 | 
22 | 	public UniqueNameGenerator() {
23 | 		this("N", 0);
24 | 	}
25 | 
26 | 	public String nextUniqueName() {
27 | 		return prefix + ++cnt;
28 | 	}
29 | 
30 | 	public String currentUniqueName() {
31 | 		return prefix + cnt;
32 | 	}
33 | 	
34 | 	public void registerTranslation(F from, T to) {
35 | 		translations.put(from, to);
36 | 	}
37 | 
38 | 	public T lookupTranslation(F from) {
39 | 		return translations.get(from);
40 | 	}
41 | 
42 | 	public boolean hasTranslation(F from) {
43 | 		return translations.containsKey(from);
44 | 	}
45 | 
46 | }
47 | 


--------------------------------------------------------------------------------
/src/com/floreysoft/jmte/util/Util.java:
--------------------------------------------------------------------------------
  1 | package com.floreysoft.jmte.util;
  2 | 
  3 | import java.io.BufferedReader;
  4 | import java.io.ByteArrayOutputStream;
  5 | import java.io.File;
  6 | import java.io.FileInputStream;
  7 | import java.io.FileOutputStream;
  8 | import java.io.IOException;
  9 | import java.io.InputStream;
 10 | import java.io.InputStreamReader;
 11 | import java.io.OutputStreamWriter;
 12 | import java.io.Reader;
 13 | import java.io.Writer;
 14 | import java.util.ArrayList;
 15 | import java.util.Arrays;
 16 | import java.util.Collections;
 17 | import java.util.HashSet;
 18 | import java.util.List;
 19 | import java.util.Set;
 20 | 
 21 | /**
 22 |  * Assorted static utility methods.
 23 |  * 
 24 |  */
 25 | public class Util {
 26 | 
 27 | 	public final static MiniParser MINI_PARSER = MiniParser.defaultInstance();
 28 | 	public final static MiniParser RAW_MINI_PARSER = MiniParser
 29 | 			.fullRawInstance();
 30 | 	public final static MiniParser NO_QUOTE_MINI_PARSER = new MiniParser(
 31 | 			MiniParser.DEFAULT_ESCAPE_CHAR, (char) -1, false, false, false);
 32 | 	public final static MiniParser RAW_OUTPUT_MINI_PARSER = MiniParser
 33 | 			.rawOutputInstance();
 34 | 
 35 | 	/**
 36 | 	 * Writes a string into a file.
 37 | 	 * 
 38 | 	 * @param string
 39 | 	 *            the string
 40 | 	 * @param file
 41 | 	 *            the file
 42 | 	 * @param charsetName
 43 | 	 *            encoding of the file
 44 | 	 */
 45 | 	public static void stringToFile(String string, File file, String charsetName) {
 46 | 		FileOutputStream fos = null;
 47 | 		Writer writer = null;
 48 | 		try {
 49 | 			try {
 50 | 				fos = new FileOutputStream(file);
 51 | 				writer = new OutputStreamWriter(fos, charsetName);
 52 | 				writer.write(string);
 53 | 			} finally {
 54 | 				if (writer != null) {
 55 | 					writer.close();
 56 | 				} else if (fos != null) {
 57 | 					fos.close();
 58 | 				}
 59 | 			}
 60 | 		} catch (Exception e) {
 61 | 			throw new RuntimeException(e);
 62 | 		}
 63 | 	}
 64 | 
 65 | 	/**
 66 | 	 * Transforms a file into a string.
 67 | 	 * 
 68 | 	 * @param file
 69 | 	 *            the file to be transformed
 70 | 	 * @param charsetName
 71 | 	 *            encoding of the file
 72 | 	 * @return the string containing the content of the file
 73 | 	 */
 74 | 	public static String fileToString(File file, String charsetName) {
 75 | 		FileInputStream fileInputStream = null;
 76 | 		try {
 77 | 			try {
 78 | 				fileInputStream = new FileInputStream(file);
 79 | 				return streamToString(fileInputStream, charsetName);
 80 | 			} finally {
 81 | 				if (fileInputStream != null) {
 82 | 					fileInputStream.close();
 83 | 				}
 84 | 			}
 85 | 		} catch (Exception e) {
 86 | 			throw new RuntimeException(e);
 87 | 		}
 88 | 
 89 | 	}
 90 | 
 91 | 	/**
 92 | 	 * Transforms a file into a string.
 93 | 	 * 
 94 | 	 * @param fileName
 95 | 	 *            name of the file to be transformed
 96 | 	 * @param charsetName
 97 | 	 *            encoding of the file
 98 | 	 * @return the string containing the content of the file
 99 | 	 */
100 | 	public static String fileToString(String fileName, String charsetName) {
101 | 		return fileToString(new File(fileName), charsetName);
102 | 	}
103 | 
104 | 	/**
105 | 	 * Transforms a stream into a string.
106 | 	 * 
107 | 	 * @param is
108 | 	 *            the stream to be transformed
109 | 	 * @param charsetName
110 | 	 *            encoding of the file
111 | 	 * @return the string containing the content of the stream
112 | 	 */
113 | 	public static String streamToString(InputStream is, String charsetName) {
114 | 		try {
115 | 			Reader r = null;
116 | 			try {
117 | 				r = new BufferedReader(new InputStreamReader(is, charsetName));
118 | 				return readerToString(r);
119 | 			} finally {
120 | 				if (r != null) {
121 | 					try {
122 | 						r.close();
123 | 					} catch (IOException e) {
124 | 					}
125 | 				}
126 | 			}
127 | 		} catch (Exception e) {
128 | 			throw new RuntimeException(e);
129 | 		}
130 | 
131 | 	}
132 | 
133 | 	/**
134 | 	 * Loads a stream from the classpath and transforms it into a string.
135 | 	 * 
136 | 	 * @param resourceName
137 | 	 *            the name of the resource to be transformed
138 | 	 * @param charsetName
139 | 	 *            encoding of the resource
140 | 	 * @return the string containing the content of the resource
141 | 	 * @see ClassLoader#getResourceAsStream(String)
142 | 	 */
143 | 	public static String resourceToString(String resourceName,
144 | 			String charsetName) {
145 | 		InputStream templateStream = Thread.currentThread()
146 | 				.getContextClassLoader().getResourceAsStream(resourceName);
147 | 		String template = Util.streamToString(templateStream, "UTF-8");
148 | 		return template;
149 | 	}
150 | 
151 | 	/**
152 | 	 * Transforms a reader into a string.
153 | 	 * 
154 | 	 * @param reader
155 | 	 *            the reader to be transformed
156 | 	 * @return the string containing the content of the reader
157 | 	 */
158 | 	public static String readerToString(Reader reader) {
159 | 		try {
160 | 			StringBuilder sb = new StringBuilder();
161 | 			char[] buf = new char[1024];
162 | 			int numRead = 0;
163 | 			while ((numRead = reader.read(buf)) != -1) {
164 | 				sb.append(buf, 0, numRead);
165 | 			}
166 | 			return sb.toString();
167 | 		} catch (Exception e) {
168 | 			throw new RuntimeException(e);
169 | 		}
170 | 
171 | 	}
172 | 
173 | 	public static byte[] streamToBa(InputStream is) {
174 | 		try {
175 | 			ByteArrayOutputStream baos = new ByteArrayOutputStream();
176 | 			byte[] buf = new byte[1024];
177 | 			int numRead = 0;
178 | 			while ((numRead = is.read(buf)) != -1) {
179 | 				baos.write(buf, 0, numRead);
180 | 			}
181 | 			byte[] byteArray = baos.toByteArray();
182 | 			return byteArray;
183 | 		} catch (Exception e) {
184 | 			throw new RuntimeException(e);
185 | 		}
186 | 
187 | 	}
188 | 
189 | 	/**
190 | 	 * Transforms any array to a matching list
191 | 	 * 
192 | 	 * @param value
193 | 	 *            something that might be an array
194 | 	 * @return List representation if passed in value was an array,
195 | 	 *         <code>null</code> otherwise
196 | 	 */
197 | 	@SuppressWarnings({ "unchecked", "rawtypes" })
198 | 	public static List<Object> arrayAsList(Object value) {
199 | 		List list = null;
200 | 		if (value instanceof int[]) {
201 | 			list = new ArrayList();
202 | 			int[] array = (int[]) value;
203 | 			for (int i : array) {
204 | 				list.add(i);
205 | 			}
206 | 		} else if (value instanceof short[]) {
207 | 			list = new ArrayList();
208 | 			short[] array = (short[]) value;
209 | 			for (short i : array) {
210 | 				list.add(i);
211 | 			}
212 | 		} else if (value instanceof char[]) {
213 | 			list = new ArrayList();
214 | 			char[] array = (char[]) value;
215 | 			for (char i : array) {
216 | 				list.add(i);
217 | 			}
218 | 		} else if (value instanceof byte[]) {
219 | 			list = new ArrayList();
220 | 			byte[] array = (byte[]) value;
221 | 			for (byte i : array) {
222 | 				list.add(i);
223 | 			}
224 | 		} else if (value instanceof long[]) {
225 | 			list = new ArrayList();
226 | 			long[] array = (long[]) value;
227 | 			for (long i : array) {
228 | 				list.add(i);
229 | 			}
230 | 		} else if (value instanceof double[]) {
231 | 			list = new ArrayList();
232 | 			double[] array = (double[]) value;
233 | 			for (double i : array) {
234 | 				list.add(i);
235 | 			}
236 | 		} else if (value instanceof float[]) {
237 | 			list = new ArrayList();
238 | 			float[] array = (float[]) value;
239 | 			for (float i : array) {
240 | 				list.add(i);
241 | 			}
242 | 		} else if (value instanceof boolean[]) {
243 | 			list = new ArrayList();
244 | 			boolean[] array = (boolean[]) value;
245 | 			for (boolean i : array) {
246 | 				list.add(i);
247 | 			}
248 | 		} else if (value.getClass().isArray()) {
249 | 			Object[] array = (Object[]) value;
250 | 			list = Arrays.asList(array);
251 | 		}
252 | 		return list;
253 | 	}
254 | 
255 | 	/**
256 | 	 * Trims off white space from the beginning of a string.
257 | 	 * 
258 | 	 * @param input
259 | 	 *            the string to be trimmed
260 | 	 * @return the trimmed string
261 | 	 */
262 | 	public static String trimFront(String input) {
263 | 		int i = 0;
264 | 		while (i < input.length() && Character.isWhitespace(input.charAt(i)))
265 | 			i++;
266 | 		return input.substring(i);
267 | 	}
268 | 
269 | 	/**
270 | 	 * Scans the input and spits out begin/end pairs telling you where
271 | 	 * expressions can be found.
272 | 	 * 
273 | 	 * @param input
274 | 	 *            the input
275 | 	 * @return the begin/end pairs telling you where expressions can be found
276 | 	 */
277 | 	public static List<StartEndPair> scan(String input, String splitStart,
278 | 			String splitEnd, boolean useEscaping) {
279 | 		List<StartEndPair> result = new ArrayList<StartEndPair>();
280 | 		int fromIndex = 0;
281 | 		while (true) {
282 | 			int exprStart = input.indexOf(splitStart, fromIndex);
283 | 			if (exprStart == -1) {
284 | 				break;
285 | 			}
286 | 			if (useEscaping && Util.isEscaped(input, exprStart)) {
287 | 				fromIndex = exprStart + splitStart.length();
288 | 				continue;
289 | 			}
290 | 
291 | 			exprStart += splitStart.length();
292 | 			int exprEnd = input.indexOf(splitEnd, exprStart);
293 | 			if (exprEnd == -1) {
294 | 				break;
295 | 			}
296 | 			while (useEscaping && Util.isEscaped(input, exprEnd)) {
297 | 				exprEnd = input.indexOf(splitEnd, exprEnd + splitEnd.length());
298 | 			}
299 | 
300 | 			fromIndex = exprEnd + splitEnd.length();
301 | 
302 | 			StartEndPair startEndPair = new StartEndPair(exprStart, exprEnd);
303 | 			result.add(startEndPair);
304 | 		}
305 | 		return result;
306 | 	}
307 | 
308 | 	/**
309 | 	 * A character is escaped when it is preceded by an unescaped slash.
310 | 	 */
311 | 	static boolean isEscaped(String input, int index) {
312 | 		return isEscaped(input, index, MiniParser.DEFAULT_ESCAPE_CHAR);
313 | 	}
314 | 
315 | 	static boolean isEscaped(String input, int index, char escapeCharacter) {
316 | 		boolean escaped;
317 | 		int leftOfIndex = index - 1;
318 | 		if (leftOfIndex >= 0) {
319 | 			if (input.charAt(leftOfIndex) == escapeCharacter) {
320 | 				int leftOfleftOfIndex = leftOfIndex - 1;
321 | 				escaped = leftOfleftOfIndex < 0
322 | 						|| input.charAt(leftOfleftOfIndex) != escapeCharacter;
323 | 			} else {
324 | 				escaped = false;
325 | 			}
326 | 		} else {
327 | 			escaped = false;
328 | 		}
329 | 		return escaped;
330 | 	}
331 | 
332 | 	@SuppressWarnings("unchecked")
333 | 	public static <T> Set<T> asSet(T... a) {
334 | 		return a != null ? new HashSet(Arrays.asList(a)) : Collections
335 | 				.emptySet();
336 | 	}
337 | 
338 | 	public static String unifyNewlines(String source) {
339 | 		final String regex = "\\r?\\n";
340 | 		final String clearedSource = source.replaceAll(regex, "\n");
341 | 		return clearedSource;
342 | 	}
343 | 
344 | }
345 | 


--------------------------------------------------------------------------------
/src/de/onyxbits/droidentify/Interceptor.java:
--------------------------------------------------------------------------------
 1 | package de.onyxbits.droidentify;
 2 | 
 3 | import java.io.File;
 4 | import java.io.FileInputStream;
 5 | import java.net.URI;
 6 | 
 7 | import android.content.Context;
 8 | import android.content.Intent;
 9 | import android.net.Uri;
10 | import android.support.v4.content.FileProvider;
11 | import android.util.Log;
12 | import android.webkit.WebView;
13 | import android.webkit.WebViewClient;
14 | 
15 | public class Interceptor extends WebViewClient {
16 | 
17 | 	@Override
18 | 	public boolean shouldOverrideUrlLoading(WebView view, String url) {
19 | 		if (url.startsWith("http")) {
20 | 			Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
21 | 			view.getContext().startActivity(intent);
22 | 			return true;
23 | 		}
24 | 		if (url.endsWith("prop")) {
25 | 			try {
26 | 				FileInputStream fis = new FileInputStream(new File(new URI(url)));
27 | 				Intent intent = new Intent(Intent.ACTION_SEND);
28 | 				intent.setType("text/html");
29 | 				intent.putExtra(Intent.EXTRA_TEXT, MainService.readFile(fis));
30 | 				view.getContext().startActivity(intent);
31 | 			}
32 | 			catch (Exception e) {
33 | 				Log.d(getClass().getName(), e.getMessage());
34 | 			}
35 | 			return true;
36 | 		}
37 | 		if (url.endsWith("zip")) {
38 | 			shareReport(view.getContext());
39 | 			return true;
40 | 		}
41 | 		return false;
42 | 	}
43 | 
44 | 	public static void shareReport(Context ctx) {
45 | 		Intent intent = new Intent(Intent.ACTION_SEND);
46 | 		intent.setType("text/html");
47 | 		intent.putExtra(Intent.EXTRA_SUBJECT, ctx.getString(R.string.subjectline));
48 | 		intent.putExtra(
49 | 				Intent.EXTRA_STREAM,
50 | 				FileProvider.getUriForFile(ctx, "de.onyxbits.fileprovider",
51 | 						new File(new File(ctx.getFilesDir(), MainService.HTDOCS), ZippedReportFilter.NAME)));
52 | 		ctx.startActivity(Intent.createChooser(intent, ctx.getString(R.string.sharevia)));
53 | 	}
54 | }
55 | 


--------------------------------------------------------------------------------
/src/de/onyxbits/droidentify/LocalBinder.java:
--------------------------------------------------------------------------------
 1 | package de.onyxbits.droidentify;
 2 | 
 3 | import android.os.Binder;
 4 | 
 5 | public class LocalBinder extends Binder {
 6 | 
 7 | 	private MainService serverService;
 8 | 
 9 | 	public LocalBinder(MainService ss) {
10 | 		this.serverService = ss;
11 | 	}
12 | 	
13 | 	public MainService getService() {
14 | 		return serverService;
15 | 	}
16 | 
17 | }
18 | 


--------------------------------------------------------------------------------
/src/de/onyxbits/droidentify/MainActivity.java:
--------------------------------------------------------------------------------
 1 | package de.onyxbits.droidentify;
 2 | 
 3 | 
 4 | import android.support.v4.content.LocalBroadcastManager;
 5 | import android.support.v7.app.ActionBarActivity;
 6 | import android.annotation.SuppressLint;
 7 | import android.content.Intent;
 8 | import android.content.IntentFilter;
 9 | import android.os.Bundle;
10 | import android.view.Menu;
11 | import android.view.MenuItem;
12 | import android.webkit.WebView;
13 | 
14 | public class MainActivity extends ActionBarActivity {
15 | 
16 | 	private ProxyReceiver proxyReceiver;
17 | 
18 | 	@SuppressLint("SetJavaScriptEnabled")
19 | 	@Override
20 | 	protected void onCreate(Bundle savedInstanceState) {
21 | 		super.onCreate(savedInstanceState);
22 | 		setContentView(R.layout.activity_main);
23 | 		WebView wv = (WebView) findViewById(R.id.webview);
24 | 		wv.getSettings().setJavaScriptEnabled(true);
25 | 		wv.setWebViewClient(new Interceptor());
26 | 		IntentFilter filter = new IntentFilter(Intent.ACTION_VIEW);
27 | 		proxyReceiver = new ProxyReceiver(this);
28 | 		LocalBroadcastManager.getInstance(this).registerReceiver(proxyReceiver, filter);
29 | 		startService(new Intent(this, MainService.class));
30 | 	}
31 | 
32 | 	@Override
33 | 	protected void onDestroy() {
34 | 		LocalBroadcastManager.getInstance(this).unregisterReceiver(proxyReceiver);
35 | 		if (isFinishing()) {
36 | 			stopService(new Intent(this, MainService.class));
37 | 		}
38 | 		super.onDestroy();
39 | 	}
40 | 
41 | 	@Override
42 | 	public boolean onCreateOptionsMenu(Menu menu) {
43 | 		// Inflate the menu; this adds items to the action bar if it is present.
44 | 		getMenuInflater().inflate(R.menu.main, menu);
45 | 		return true;
46 | 	}
47 | 
48 | 	@Override
49 | 	public boolean onOptionsItemSelected(MenuItem item) {
50 | 		// Handle action bar item clicks here. The action bar will
51 | 		// automatically handle clicks on the Home/Up button, so long
52 | 		// as you specify a parent activity in AndroidManifest.xml.
53 | 		int id = item.getItemId();
54 | 		if (id == R.id.share) {
55 | 			Interceptor.shareReport(this);
56 | 			return true;
57 | 		}
58 | 		return super.onOptionsItemSelected(item);
59 | 	}
60 | }
61 | 


--------------------------------------------------------------------------------
/src/de/onyxbits/droidentify/MainService.java:
--------------------------------------------------------------------------------
  1 | package de.onyxbits.droidentify;
  2 | 
  3 | import java.io.BufferedInputStream;
  4 | import java.io.BufferedOutputStream;
  5 | import java.io.BufferedReader;
  6 | import java.io.File;
  7 | import java.io.FileInputStream;
  8 | import java.io.FileOutputStream;
  9 | import java.io.IOException;
 10 | import java.io.InputStream;
 11 | import java.io.InputStreamReader;
 12 | import java.io.OutputStream;
 13 | import java.io.PrintWriter;
 14 | import java.util.Arrays;
 15 | import java.util.HashMap;
 16 | import java.util.Locale;
 17 | import java.util.Map;
 18 | import java.util.Vector;
 19 | import java.util.zip.ZipEntry;
 20 | import java.util.zip.ZipOutputStream;
 21 | 
 22 | import com.floreysoft.jmte.Engine;
 23 | 
 24 | import android.app.Service;
 25 | import android.content.Intent;
 26 | import android.content.pm.FeatureInfo;
 27 | import android.content.pm.PackageManager.NameNotFoundException;
 28 | import android.database.Cursor;
 29 | import android.net.Uri;
 30 | import android.os.Build;
 31 | import android.os.Environment;
 32 | import android.os.IBinder;
 33 | import android.provider.Settings.Secure;
 34 | import android.support.v4.content.LocalBroadcastManager;
 35 | import android.telephony.TelephonyManager;
 36 | import android.util.DisplayMetrics;
 37 | import android.view.Display;
 38 | import android.view.WindowManager;
 39 | 
 40 | public class MainService extends Service {
 41 | 
 42 | 	public static final String TMPLDIR = "tmpl";
 43 | 	public static final String HTDOCS = "htdocs";
 44 | 	private static final int BUFFER = 1024 * 8;
 45 | 	private boolean running = false;
 46 | 
 47 | 	private IBinder binder;
 48 | 
 49 | 	@Override
 50 | 	public IBinder onBind(Intent intent) {
 51 | 		if (binder == null) {
 52 | 			binder = new LocalBinder(this);
 53 | 		}
 54 | 		return binder;
 55 | 	}
 56 | 
 57 | 	@Override
 58 | 	public int onStartCommand(Intent intent, int flags, int startId) {
 59 | 		if (!running) {
 60 | 			running = true;
 61 | 			new ReporterTask(this).execute(new Object());
 62 | 		}
 63 | 		else {
 64 | 			onReport(null);
 65 | 		}
 66 | 		return START_STICKY;
 67 | 	}
 68 | 
 69 | 	public void onDestroy() {
 70 | 	}
 71 | 
 72 | 	public File getDocDir() {
 73 | 		return new File(getFilesDir(), HTDOCS);
 74 | 	}
 75 | 
 76 | 	public void createReport() throws IOException {
 77 | 		// Target directory.
 78 | 		File dest = getDocDir();
 79 | 		dest.mkdirs();
 80 | 
 81 | 		// Copy build.prop to target
 82 | 		FileInputStream ins = new FileInputStream(new File("/system/build.prop"));
 83 | 		FileOutputStream out = new FileOutputStream(new File(dest, "build.prop"));
 84 | 		copyFile(ins, out);
 85 | 		ins.close();
 86 | 		out.close();
 87 | 
 88 | 		// Create the layout template
 89 | 		Map<String, Object> model = createModel();
 90 | 		InputStream li = getAssets().open(TMPLDIR + "/layout.tmpl");
 91 | 		String layout = readFile(li);
 92 | 		li.close();
 93 | 		Map<String, Object> layoutModel = new HashMap<String, Object>();
 94 | 		try {
 95 | 			layoutModel.put("APPVERSION", "v"
 96 | 					+ getPackageManager().getPackageInfo(getPackageName(), 0).versionName);
 97 | 		}
 98 | 		catch (NameNotFoundException e) {
 99 | 			e.printStackTrace();
100 | 		}
101 | 		layoutModel.put("PRODUCT", Devices.getDeviceName());
102 | 
103 | 		// Create the individual pages of the report from the layout template
104 | 		String[] files = getAssets().list(TMPLDIR);
105 | 		for (String file : files) {
106 | 			if (file.equals("layout.tmpl")) {
107 | 				continue;
108 | 			}
109 | 			InputStream inp = getAssets().open(TMPLDIR + "/" + file);
110 | 			if (file.endsWith("html")) {
111 | 				layoutModel.put("CONTENT", readFile(inp));
112 | 				String content = new Engine().transform(layout, layoutModel);
113 | 				PrintWriter pw = new PrintWriter(new File(dest, file));
114 | 				pw.write(new Engine().transform(content, model));
115 | 				pw.close();
116 | 			}
117 | 			else {
118 | 				out = new FileOutputStream(new File(dest, file));
119 | 				copyFile(inp, out);
120 | 				out.close();
121 | 			}
122 | 			inp.close();
123 | 		}
124 | 
125 | 		// Create an enhanced build.prop
126 | 		ins = new FileInputStream(new File("/system/build.prop"));
127 | 		StringBuilder bprop = new StringBuilder(readFile(ins));
128 | 		ins.close();
129 | 		bprop.append("\n\n# DummyDroid properties\n");
130 | 		bprop.append("dd.features=${foreach FEATURES FEATURE , }${FEATURE}${end}\n");
131 | 		bprop.append("dd.libraries=${foreach LIBRARIES LIBRARY , }${LIBRARY}${end}\n");
132 | 		PrintWriter pw = new PrintWriter(new File(dest, "build_extra.prop"));
133 | 		pw.write(new Engine().transform(bprop.toString(), model));
134 | 		pw.close();
135 | 
136 | 		// Zip the contents of the target directory.
137 | 		files = dest.list(new ZippedReportFilter());
138 | 		FileOutputStream zdest = new FileOutputStream(new File(dest, ZippedReportFilter.NAME));
139 | 		ZipOutputStream zout = new ZipOutputStream(new BufferedOutputStream(zdest));
140 | 		byte data[] = new byte[BUFFER];
141 | 		for (int i = 0; i < files.length; i++) {
142 | 			FileInputStream fi = new FileInputStream(new File(dest, files[i]));
143 | 			BufferedInputStream origin = new BufferedInputStream(fi, BUFFER);
144 | 			ZipEntry entry = new ZipEntry("/" + files[i]);
145 | 			zout.putNextEntry(entry);
146 | 			int count;
147 | 			while ((count = origin.read(data, 0, BUFFER)) != -1) {
148 | 				zout.write(data, 0, count);
149 | 			}
150 | 			origin.close();
151 | 		}
152 | 		zout.close();
153 | 		zdest.close();
154 | 	}
155 | 
156 | 	private Map<String, Object> createModel() throws IOException {
157 | 		Map<String, Object> model = new HashMap<String, Object>();
158 | 		InputStream ins = new FileInputStream(new File("/system/build.prop"));
159 | 		model.put("BUILDPROP", readFile(ins));
160 | 		ins.close();
161 | 
162 | 		Locale[] locales = Locale.getAvailableLocales();
163 | 		Vector<String> locs = new Vector<String>();
164 | 		for (Locale l : locales) {
165 | 			locs.add(l.toString());
166 | 		}
167 | 		model.put("LOCALES", locs);
168 | 
169 | 		Vector<String> features = new Vector<String>();
170 | 		FeatureInfo[] infos = getPackageManager().getSystemAvailableFeatures();
171 | 		for (FeatureInfo info : infos) {
172 | 			if (info.name == null) {
173 | 				// TODO: GL features
174 | 			}
175 | 			else {
176 | 				features.add(info.name);
177 | 			}
178 | 		}
179 | 		model.put("FEATURES", features);
180 | 
181 | 		model.put("LIBRARIES", Arrays.asList(getPackageManager().getSystemSharedLibraryNames()));
182 | 
183 | 		Vector<Tuple> ids = new Vector<Tuple>();
184 | 
185 | 		Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay();
186 | 		TelephonyManager tm = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
187 | 		DisplayMetrics dm = new DisplayMetrics();
188 | 		display.getMetrics(dm);
189 | 		ids.add(new Tuple("Display Size", dm.widthPixels + " x " + dm.heightPixels + " px"));
190 | 		if (Build.SERIAL != null) {
191 | 			ids.add(new Tuple("Serial number", Build.SERIAL));
192 | 		}
193 | 		ids.add(new Tuple("OS Release", Build.VERSION.RELEASE));
194 | 		if (getGsfAndroidId() != null) {
195 | 			ids.add(new Tuple("GSF ID", getGsfAndroidId()));
196 | 		}
197 | 
198 | 		ids.add(new Tuple("Android ID", Secure.getString(getContentResolver(), Secure.ANDROID_ID)));
199 | 
200 | 		if (tm.getDeviceId() != null) {
201 | 			ids.add(new Tuple("IMEI", tm.getDeviceId()));
202 | 			ids.add(new Tuple("IMSI", tm.getSubscriberId()));
203 | 			ids.add(new Tuple("SIM Operator", tm.getSimOperator() + " (" + tm.getSimOperatorName() + ")"));
204 | 			ids.add(new Tuple("SIM Serial", tm.getSimSerialNumber()));
205 | 			ids.add(new Tuple("Network Operator", tm.getNetworkOperator() + " ("
206 | 					+ tm.getNetworkOperatorName() + ")"));
207 | 			ids.add(new Tuple("Phone number", tm.getLine1Number()));
208 | 
209 | 		}
210 | 
211 | 		model.put("IDENTIFIERS", ids);
212 | 
213 | 		Vector<Tuple> paths = new Vector<Tuple>();
214 | 		paths.add(new Tuple("External Storage", Environment.getExternalStorageDirectory()
215 | 				.getAbsolutePath()));
216 | 		paths.add(new Tuple("Music", Environment.getExternalStoragePublicDirectory(
217 | 				Environment.DIRECTORY_MUSIC).getAbsolutePath()));
218 | 		paths.add(new Tuple("Podcasts", Environment.getExternalStoragePublicDirectory(
219 | 				Environment.DIRECTORY_PODCASTS).getAbsolutePath()));
220 | 		paths.add(new Tuple("Ringtones", Environment.getExternalStoragePublicDirectory(
221 | 				Environment.DIRECTORY_RINGTONES).getAbsolutePath()));
222 | 		paths.add(new Tuple("Alarms", Environment.getExternalStoragePublicDirectory(
223 | 				Environment.DIRECTORY_ALARMS).getAbsolutePath()));
224 | 		paths.add(new Tuple("Notifications", Environment.getExternalStoragePublicDirectory(
225 | 				Environment.DIRECTORY_NOTIFICATIONS).getAbsolutePath()));
226 | 		paths.add(new Tuple("Pictures", Environment.getExternalStoragePublicDirectory(
227 | 				Environment.DIRECTORY_PICTURES).getAbsolutePath()));
228 | 		paths.add(new Tuple("Movies", Environment.getExternalStoragePublicDirectory(
229 | 				Environment.DIRECTORY_MOVIES).getAbsolutePath()));
230 | 		paths.add(new Tuple("Downloads", Environment.getExternalStoragePublicDirectory(
231 | 				Environment.DIRECTORY_DOWNLOADS).getAbsolutePath()));
232 | 		paths.add(new Tuple("Dcim", Environment.getExternalStoragePublicDirectory(
233 | 				Environment.DIRECTORY_DCIM).getAbsolutePath()));
234 | 		model.put("PATHS", paths);
235 | 
236 | 		return model;
237 | 	}
238 | 
239 | 	private void copyFile(InputStream ins, OutputStream out) throws IOException {
240 | 		byte[] buffer = new byte[1024];
241 | 		int length;
242 | 		while ((length = ins.read(buffer)) > 0) {
243 | 			out.write(buffer, 0, length);
244 | 		}
245 | 	}
246 | 
247 | 	protected static String readFile(InputStream ins) throws IOException {
248 | 		StringBuilder sb = new StringBuilder();
249 | 		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(ins, "UTF-8"));
250 | 		String line = bufferedReader.readLine();
251 | 		while (line != null) {
252 | 			sb.append(line);
253 | 			sb.append('\n');
254 | 			line = bufferedReader.readLine();
255 | 		}
256 | 		return sb.toString();
257 | 	}
258 | 
259 | 	private String getGsfAndroidId() {
260 | 		try {
261 | 			Uri URI = Uri.parse("content://com.google.android.gsf.gservices");
262 | 			String ID_KEY = "android_id";
263 | 			String params[] = { ID_KEY };
264 | 			Cursor c = getContentResolver().query(URI, null, null, params, null);
265 | 			if (!c.moveToFirst() || c.getColumnCount() < 2)
266 | 				return Long.toHexString(Long.parseLong(c.getString(1)));
267 | 			c.close();
268 | 		}
269 | 		catch (Exception e) {
270 | 			return null;
271 | 		}
272 | 		return null;
273 | 	}
274 | 
275 | 	public void onReport(Exception e) {
276 | 		LocalBroadcastManager.getInstance(this).sendBroadcast(new Intent(Intent.ACTION_VIEW));
277 | 	}
278 | 
279 | }
280 | 


--------------------------------------------------------------------------------
/src/de/onyxbits/droidentify/ProxyReceiver.java:
--------------------------------------------------------------------------------
 1 | package de.onyxbits.droidentify;
 2 | 
 3 | import java.io.File;
 4 | 
 5 | import android.content.BroadcastReceiver;
 6 | import android.content.Context;
 7 | import android.content.Intent;
 8 | import android.webkit.WebView;
 9 | 
10 | class ProxyReceiver extends BroadcastReceiver {
11 | 
12 | 	private MainActivity mainActivity;
13 | 
14 | 	public ProxyReceiver(MainActivity m) {
15 | 		this.mainActivity = m;
16 | 	}
17 | 
18 | 	@Override
19 | 	public void onReceive(Context context, Intent intent) {
20 | 		WebView wv = (WebView) mainActivity.findViewById(R.id.webview);
21 | 		File target = new File(new File(mainActivity.getFilesDir(), MainService.HTDOCS),
22 | 				"index.html");
23 | 		wv.loadUrl(target.toURI().toString());
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------
/src/de/onyxbits/droidentify/ReportProvider.java:
--------------------------------------------------------------------------------
 1 | package de.onyxbits.droidentify;
 2 | 
 3 | import java.io.File;
 4 | import java.io.FileNotFoundException;
 5 | 
 6 | import android.content.ContentProvider;
 7 | import android.content.ContentValues;
 8 | import android.content.UriMatcher;
 9 | import android.database.Cursor;
10 | import android.net.Uri;
11 | import android.os.ParcelFileDescriptor;
12 | import android.util.Log;
13 | 
14 | public class ReportProvider extends ContentProvider {
15 | 
16 | 	private static final String CLASS_NAME = "ReportProvider";
17 | 
18 | 	// The authority is the symbolic name for the provider class
19 | 	public static final String AUTHORITY = "de.onyxbits.droidentify.provider";
20 | 
21 | 	// UriMatcher used to match against incoming requests
22 | 	private UriMatcher uriMatcher;
23 | 
24 | 	@Override
25 | 	public boolean onCreate() {
26 | 		uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
27 | 
28 | 		// Add a URI to the matcher which will match against the form
29 | 		// 'content://com.stephendnicholas.gmailattach.provider/*'
30 | 		// and return 1 in the case that the incoming Uri matches this pattern
31 | 		uriMatcher.addURI(AUTHORITY, "*", 1);
32 | 
33 | 		return true;
34 | 	}
35 | 
36 | 	@Override
37 | 	public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
38 | 
39 | 		String LOG_TAG = CLASS_NAME + " - openFile";
40 | 
41 | 		Log.v(LOG_TAG, "Called with uri: '" + uri + "'." + uri.getLastPathSegment());
42 | 
43 | 		// Check incoming Uri against the matcher
44 | 		switch (uriMatcher.match(uri)) {
45 | 
46 | 		// If it returns 1 - then it matches the Uri defined in onCreate
47 | 			case 1:
48 | 
49 | 				// The desired file name is specified by the last segment of the
50 | 				// path
51 | 				// E.g.
52 | 				// 'content://com.stephendnicholas.gmailattach.provider/Test.txt'
53 | 				// Take this and build the path to the file
54 | 				String fileLocation = getContext().getCacheDir() + File.separator
55 | 						+ uri.getLastPathSegment();
56 | 
57 | 				// Create & return a ParcelFileDescriptor pointing to the file
58 | 				// Note: I don't care what mode they ask for - they're only getting
59 | 				// read only
60 | 				ParcelFileDescriptor pfd = ParcelFileDescriptor.open(new File(fileLocation),
61 | 						ParcelFileDescriptor.MODE_READ_ONLY);
62 | 				return pfd;
63 | 
64 | 				// Otherwise unrecognised Uri
65 | 			default:
66 | 				Log.v(LOG_TAG, "Unsupported uri: '" + uri + "'.");
67 | 				throw new FileNotFoundException("Unsupported uri: " + uri.toString());
68 | 		}
69 | 	}
70 | 
71 | 	// //////////////////////////////////////////////////////////////
72 | 	// Not supported / used / required for this
73 | 	// //////////////////////////////////////////////////////////////
74 | 
75 | 	@Override
76 | 	public int update(Uri uri, ContentValues contentvalues, String s, String[] as) {
77 | 		return 0;
78 | 	}
79 | 
80 | 	@Override
81 | 	public int delete(Uri uri, String s, String[] as) {
82 | 		return 0;
83 | 	}
84 | 
85 | 	@Override
86 | 	public Uri insert(Uri uri, ContentValues contentvalues) {
87 | 		return null;
88 | 	}
89 | 
90 | 	@Override
91 | 	public String getType(Uri uri) {
92 | 		return null;
93 | 	}
94 | 
95 | 	@Override
96 | 	public Cursor query(Uri uri, String[] projection, String s, String[] as1, String s1) {
97 | 		return null;
98 | 	}
99 | }


--------------------------------------------------------------------------------
/src/de/onyxbits/droidentify/ReporterTask.java:
--------------------------------------------------------------------------------
 1 | package de.onyxbits.droidentify;
 2 | 
 3 | import android.os.AsyncTask;
 4 | 
 5 | public class ReporterTask extends AsyncTask<Object, Integer, Exception> {
 6 | 
 7 | 	private MainService serverService;
 8 | 
 9 | 	public ReporterTask(MainService ss) {
10 | 		this.serverService = ss;
11 | 	}
12 | 	@Override
13 | 	protected Exception doInBackground(Object... params) {
14 | 		try {
15 | 			serverService.createReport();
16 | 		}
17 | 		catch (Exception e) {
18 | 			return e;
19 | 		}
20 | 		return null;
21 | 	}
22 | 	
23 | 	@Override
24 | 	protected void onPostExecute(Exception e) {
25 | 		serverService.onReport(e);
26 | 	}
27 | 
28 | }
29 | 


--------------------------------------------------------------------------------
/src/de/onyxbits/droidentify/Tuple.java:
--------------------------------------------------------------------------------
 1 | package de.onyxbits.droidentify;
 2 | 
 3 | public class Tuple {
 4 | 
 5 | 	public String key, value;
 6 | 
 7 | 	public Tuple(String key, String value) {
 8 | 		this.key = key;
 9 | 		this.value = value;
10 | 	}
11 | }
12 | 


--------------------------------------------------------------------------------
/src/de/onyxbits/droidentify/ZippedReportFilter.java:
--------------------------------------------------------------------------------
 1 | package de.onyxbits.droidentify;
 2 | 
 3 | import java.io.File;
 4 | import java.io.FilenameFilter;
 5 | 
 6 | public class ZippedReportFilter implements FilenameFilter {
 7 | 
 8 | 	public static String NAME = "fullreport.zip";
 9 | 	
10 | 	@Override
11 | 	public boolean accept(File dir, String filename) {
12 | 		return !filename.equals(NAME);
13 | 	}
14 | 
15 | }
16 | 


--------------------------------------------------------------------------------