├── .hgignore
├── LICENSE
├── README.md
├── bin
    └── rapydml
├── rapydml
    ├── compiler.py
    ├── html_colors.txt
    ├── lib
    │   ├── common.pyml
    │   ├── django.pyml
    │   ├── jinja2.pyml
    │   ├── rails.pyml
    │   └── web2py.pyml
    ├── markup
    │   ├── any
    │   ├── html
    │   └── html5
    ├── markuploader.py
    └── util.py
└── setup.py


/.hgignore:
--------------------------------------------------------------------------------
1 | # use glob syntax
2 | syntax: glob
3 | 
4 | *.pyc
5 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | RapydML is a Pythonic abstraction of XML/HTML, adding more 
 2 | functionality, ability to easily integrate it with any HTML
 3 | templating framework, and create your own subset of XML whose
 4 | rules will be enforced through RapydML compiler.
 5 | Copyright (C) 2012  Alexander Tsepkov
 6 | 
 7 | This program is free software: you can redistribute it and/or modify
 8 | it under the terms of the GNU General Public License as published by
 9 | the Free Software Foundation, either version 3 of the License, or
10 | (at your option) any later version.
11 | 
12 | This program is distributed in the hope that it will be useful,
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 | GNU General Public License for more details.
16 | 
17 | You should have received a copy of the GNU General Public License
18 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # RapydML XML/HTML Abstraction Markup Language
  2 | 
  3 | What is RapydML?
  4 | ----------------
  5 | RapydML is a Pythonic abstraction for XML/HTML. The compiler generates HTML or HTML-like templates for Rails, Django, web2py or other frameworks (via templates) from indented, Python-like syntax. RapydML can also compile into arbitrary XML-like markup (such as SVG) based on a set of rules from user-defined template. These templates can have varying level of restrictions (compare the included lax HTML template against strict HTML5, for example).
  6 | 
  7 | Note that RapydML is still in beta. Some features and syntax could change in the future. Feel free to contact us with your own suggestions, if you have any.
  8 | 
  9 | 
 10 | Community
 11 | ---------
 12 | If you have questions, bug reports, or feature requests, feel free to post them on our mailing list:
 13 | <http://groups.google.com/group/rapydml>
 14 | 
 15 | 
 16 | Installation
 17 | ------------
 18 | You can download RapydML from the link at the top of the RapydML page on Pyjeon website (<http://pyjeon.com>) and extract it to a directory on your home computer. Alternatively, you can download it from our repository using the terminal directly (you will need Mercurial client installed):
 19 | 
 20 | 	hg clone https://pyjeon@bitbucket.org/pyjeon/rapydml
 21 | 
 22 | Afterwards, navigate to `rapydml` directory, and run the following command to perform the installation:
 23 | 
 24 | 	python setup.py install
 25 | 
 26 | This will install `rapydml` as a globally available command. Alternatively, you can also install RapydML using pip repository.
 27 | 
 28 | 
 29 | Compilation
 30 | -----------
 31 | Using RapydML is pretty straightforward. Assuming you have added an alias for it (or placed it in one of the directories covered by the system path), you can run it as follows:
 32 | 
 33 | 	rapydml <location of file>
 34 | 
 35 | RapydML also allows you to use alternative XML-like syntax. If you decide to do so, you can place your file in `markup` directory inside of RapydML and it will automatically be pulled into RapydML. You can then compile your file using a different markup:
 36 | 
 37 | 	rapydml --markupname <location of file>
 38 | 
 39 | RapydML already includes `HTML`, `HTML5`, and `ANY` markups you can use as examples. For more options and information, you can invoke rapydml's help:
 40 | 
 41 | 	rapydml -h
 42 | 
 43 | 
 44 | Getting Started
 45 | ---------------
 46 | RapydML is pre-parser that allows you to write HTML (or any other XML-like markup) in more readable, Python-like format. The parser then generates HTML for you, automatically closing/aligning different HTML tags (it can even be told to avoid closing tags for certain elements - like !DOCTYPE). It's similar to SASS/SCSS, but for HTML (similar concept to HAML). Like SASS/SCSS/HAML, RapydML generates the page before it's deployed, and not dynamically as it's being served, saving you CPU cycles. Take a look at the following HTML, for example:
 47 | 
 48 | 	<html>
 49 | 		<head>
 50 | 			<title>Welcome to my Web Page</title>
 51 | 		</head>
 52 | 		<body>
 53 | 			<div id="title">
 54 | 				<img src="banner.png" alt="My Banner" />
 55 | 			</div>
 56 | 			<div id="content">
 57 | 				I haven't yet put anything on this page
 58 | 			</div>
 59 | 			<div id="copyright">
 60 | 				Copyright 2012 by Me
 61 | 			</div>
 62 | 		</body>
 63 | 	</html>
 64 | 
 65 | We can rewrite the above using RapydML as follows:
 66 | 
 67 | 	html:
 68 | 		head:
 69 | 			title:
 70 | 				"Welcome to my Web Page"
 71 | 		body:
 72 | 			div(id="title"):
 73 | 				img(src="banner.png", alt="My Banner")
 74 | 			div(id="content"):
 75 | 				"I haven't yet put anything on this page"
 76 | 			div(id="copyright"):
 77 | 				"Copyright 2012 by Me"
 78 | 
 79 | 
 80 | Loops and Code Reuse
 81 | --------------------
 82 | We can pass in attributes as if they're arguments in a function call. We can already see that RapydML code is shorter and cleaner, but this becomes even more apparent in larger HTML files. Let us add a few images to our page to show that we support all major browsers, for example. We'll need to modify our content div as follows:
 83 | 
 84 | 	<div id="content">
 85 | 		I haven't yet put anything on this page
 86 | 		<p>
 87 | 			Compatible with all major browsers:
 88 | 			<img src="Firefox.jpg" alt="Firefox" />
 89 | 			<img src="Chrome.jpg" alt="Chrome" />
 90 | 			<img src="IE.jpg" alt="IE" />
 91 | 			<img src="Opera.jpg" alt="Opera" />
 92 | 			<img src="Safari.jpg" alt="Safari" />
 93 | 		</p>
 94 | 	</div>
 95 | 
 96 | In RapydML we can accomplish the same thing with less repeated code using a loop:
 97 | 
 98 | 	div(id="content"):
 99 | 		"I haven't yet put anything on this page"
100 | 		p:
101 | 			"Compatible with all major browsers:"
102 | 			for $browser in [Firefox, Chrome, IE, Opera, Safari]:
103 | 				img(src="$browser.jpg", alt="$browser")
104 | 
105 | But what if our alt attributes don't happen to match our image names? That can be remedied as well, by grouping variables via sub-arrays:
106 | 
107 | 	div(id="content"):
108 | 		"I haven't yet put anything on this page"
109 | 		p:
110 | 			"Compatible with all major browsers:"
111 | 			for $item in [[firefox, Firefox], [chrome, Chrome], [ie, Internet Explorer], [opera, Opera], [safari, Safari]]:
112 | 				img(src="$item[0].jpg", alt="$item[1]")
113 | 
114 | 
115 | Variables and Sequences
116 | -----------------------
117 | Notice how we declare variables in RapydML. All variables must be preceeded by $, like in perl. While awkward at first, this actually allows us to more easily distinguish variables from HTML tags, and allows us better syntax highlighting of variables, something Python doesn't have. The assignment operator is := instead of the typical = sign. This is to avoid clashing with HTML's = sign if it happens to be part of the variable's value, as shown in example below:
118 | 
119 | 	$src := src="smiley.gif", alt="A Smiley"
120 | 	for $i in [0:100]:
121 | 		img($src)
122 | 	
123 | We don't need to quote whatever we're assigning to the variable, the leading/lagging whitespace will automatically get stripped, the whitespace in the middle will get preserved. Note the use of a shorthand to create an array of 101 consecutive integers. This shorthand works similar to Python's range() function. The first argument specifies the minimum, the second specifies the maximum (not maximum+1 like Python's range()), the third argument is optional and represents the step size. Here are some examples:
124 | 
125 | 	[0:6]		-> [0,1,2,3,4,5,6]
126 | 	[1:8:2]		-> [1,3,5,7]
127 | 	[8:1:-1]	-> [8,7,6,5,4,3,2,1]
128 | 	[8:1]		-> []
129 | 
130 | 
131 | Methods and HTML Chunks
132 | -----------------------
133 | If you find yourself reusing the same HTML in multiple places, but not in sequential order (preventing you from using a loop), you can define a method, which you can then invoke. A RapydML method is a chunk of HTML, which then gets plugged in every time the method call occurs. For example, here is how we could create a navigation menu, reusing the same button logic:
134 | 
135 | 	def navbutton($text):
136 | 		div(class='nav-button'):
137 | 			img(src="$text.png", alt="Navigate to $text")
138 | 	
139 | 	div(id='nav-menu'):
140 | 		navbutton('Main')
141 | 		navbutton('Products')
142 | 		navbutton('Blog')
143 | 		navbutton('About')
144 | 
145 | There is another subtle, but extremely useful feature methods have. Method calls can have child elements. These children will get appended inside the last outer-level element declared inside the method. For example, if you're creating a page with multiple sections, and the content layout inside each section differs, you can do the following:
146 | 
147 | 	def subsection($title):
148 | 		div(class="sub-section"):
149 | 			$title
150 | 		div(class="section-content")
151 | 	
152 | 	div(id="main"):
153 | 		subsection('Foo'):
154 | 			'This is the foo section, it only has text'
155 | 		subsection('Bar'):
156 | 			img(src="image.png")
157 | 			div:
158 | 				'Bar section has images, and sub-children'
159 | 
160 | Both, Foo and Bar, will append the children inside of the `section-content` div. This is a very powerful feature, allowing method content not only to get dumped inside of your page, but also wrap around other content in your page - similar to Python decorators. There is even more to this feature, which you can read about in the `Advanced Usage` section.
161 | 
162 | 
163 | Math and String Manipulation
164 | ----------------------------
165 | Like many other abstraction languages, RapydML can do a lot of the common logic for you. It has no concept of unit conversion like SASS, but it can easily handle many other things, like string manipulation, arithmetic, and mixing colors.
166 | 
167 | 
168 | ### Arithmetic and Colors
169 | 
170 | RapydML can handle basic arithmetic and color computations for you. For example, let's rewrite the above logic such that our navigation buttons start with dark blue and get brighter with each button:
171 | 
172 | 	$color := #004
173 | 	def navbutton($text):
174 | 		div(class='nav-button', style="background: $color"):
175 | 			img(src="$text.png", alt="Navigate to $text")
176 | 	
177 | 	div(id='nav-menu'):
178 | 		for $i in ['Main', 'Products', 'Blog', 'About']:
179 | 			$color += #222
180 | 			navbutton($i)
181 | 
182 | Note that `$color` needs to be updated outside of a function. This is because RapydML shadows function variables, like Python. Moving `$color += #222` inside the function will update a local copy of `$color`, which gets discarded after the function terminates. RapydML is smart about colors. You can use the regular `#RRGGBB` format, shorthand `#RGB` form, or even html-accepted color name like `"Brown"`. When using html colors, it's important to use double-quotes around the color, otherwise it will be treated as a regular string. The color name itself, however, is not case sensitive, you can use "DarkBlue" or "darkblue", for example, or even "dArKbLuE". If no color with that name exists the string will be treated as a regular string. Mathematical computations are not limited to colors. You can also use them to compute dimensions of HTML elements, perform computations that get output on the page, or even concatenate strings:
183 | 
184 | 	$height := 100
185 | 	$padding := 2
186 | 	$total := $height + $padding + 1	# border width of 1
187 | 	
188 | 	$name := 'smiley'
189 | 	$imgurl := 'static/images/' + $name + '.png'
190 | 
191 | You probably noticed the use of `+=`, which is a shorthand for incrementing. Here are a few other ones:
192 | 
193 | 	$a += 2			# equivalent to: $a := $a + 2
194 | 	$a -= $b		# equivalent to: $a := $a - $b
195 | 	$a *= $b*2		# equivalent to: $a := $a * ($b*2)
196 | 	$a /= 5 + 2		# equivalent to: $a := $a / (5 + 2)
197 | 
198 | Lastly, there is a caveat about color arithmetic. While RapydML will limit min/max colors to be within allowed range, the color get converted to an integer when performing operations. This means that if you keep adding blue to a color that already reached maximum allowed amount of blue, RapydML will start adding green. This behavior could be modified in the future such that each channel is independent.
199 | 
200 | 
201 | ### Using Python Directly
202 | 
203 | RapydML will handle simple arithmetic and string concatenation for you, but what if you require more complex logic? RapydML has access to the full firepower of python (or at least its stdlib, you can't import Python modules). For example, let's say we wrote the following function to generate a button linking to one of the social media websites:
204 | 
205 | 	def socialMedia($name):
206 | 		div(class="social-media"):
207 | 			a(href="www.$name.com"):
208 | 				img(src="$name.png" alt="$name")
209 | 
210 | The only problem is that the content of `$name` has to be in lowercase for the link to work. You could rename your PNG image to be in lowercase as well, but the `alt` text in all lowercase would look bad. Fortunately, RapydML can invoke Python's native logic if you use `python` prefix. Let's rewrite the above logic to capitalize the displayed text:
211 | 
212 | 	def socialMedia($name):
213 | 		div(class="social-media"):
214 | 			a(href="www.$name.com"):
215 | 				img(src="$name.png" alt=python.str.capitalize("$name"))
216 | 
217 | Likewise, we could have instead used `python.str.lower()` if the `$name` was already capitalized before being passed into the function. RapydML compiler also auto-imports `math` module, allowing you to use logic like `python.math.sin(1)`. The `python.` prefix is not needed for Python methods that are nested inside other Python methods, like the following example:
218 | 
219 | 	python.math.sin(min(1, 2, 3, 4))
220 | 
221 | 
222 | Using Raw Text, HTML, or JavaScript
223 | -----------------------------------
224 | As you probably already noticed, none of the above features address the possibility of having non-XML-like data inside of your page. There are times, however, when you might want raw text on your page that doesn't get interpreted. For example, you might need to embed JavaScript or CSS directly inside of your HTML, or might want to insert a raw chunk of HTML inside a tag when you can't get the markup just right via RapydML.
225 | 
226 | 
227 | ### Verbatim Method
228 | 
229 | There were multiple alternatives I looked into for this, in the end I settled on one that seemed cleanest. RapydML introduces a verbatim() method, which if specified for the tag, will treat everything indented under the tag as raw text, putting it inside the HTML page as is. For example, let's add a Javascript tag. We can do it a couple different ways:
230 | 
231 | 	javascript = verbatim('<script type="text/javascript">','</script>')
232 | 
233 | The second way, since we already have a 'script' tag defined for us by default that works exactly like we need to, is to pass in an existing tag to use as a template:
234 | 
235 | 	javascript = verbatim(script(type="text/javascript"))
236 | 
237 | Now, should we choose to add raw JavaScript to our code, we can write it as follows:
238 | 
239 | 	body:
240 | 		h1:
241 | 			'Page Title'
242 | 		javascript:
243 | 			function factorial(n) {
244 | 				if (n === 0) {
245 | 					return 1;
246 | 				}
247 | 				return n * factorial(n - 1);
248 | 			}
249 | 		div:
250 | 			label:
251 | 				'Text goes here'
252 | 
253 | As soon as indentation resets to same level or higher as the verbatim tag, the raw JavaScript stops, and we start interpreting tags again. There is also verbatim_line() method available, that works the same way, but condenses the code into a single line by replacing `\n` with spaces and removing indentation. This is useful when you want to compress the chunk of raw code into a single line.
254 | 
255 | 
256 | ### Variables Inside of Verbatim Blocks
257 | 
258 | It would be nice if the logic inside verbatim blocks would never need access to outside information. In real life, however, that's not always the case. Imagine that we need to include a chunk of JavaScript for creating a JSON call inside of our page. The format of this JSON call is identical across all of our pages on the website, with the only difference being the name of the page requested. The RapydML for this might look something like this:
259 | 
260 | 	javascript:
261 | 		$(document).ready(function() {
262 | 				$.getJSON('call/json/get_docs/True?owner=pyjeon&repo=$page', function(html_docs) {
263 | 					$("div#documentation").append(html_docs);
264 | 				});
265 | 			}
266 | 
267 | The problem here, however, is that since `javascript` was defined as a verbatim tag, the variable `$page` will not get replaced. One work-around is to add this JavaScript to each page, modifying the value of `$page` individually for each use. Surely, there must be a better way. There is, RapydML allows you to specify which variables are to be replaced on per-tag basis. You can specify them as arguments for the verbatim tag:
268 | 
269 | 	javascript($page):
270 | 		$(document).ready(function() {
271 | 				$.getJSON('call/json/get_docs/True?owner=pyjeon&repo=$page', function(html_docs) {
272 | 					$("div#documentation").append(html_docs);
273 | 				});
274 | 			}
275 | 
276 | Now every occurence of `$page` within the verbatim tag will be replaced. Note that the variables only apply to the current instance of the tag, and that only the specified values will get replaced:
277 | 
278 | 	$foo := "one"
279 | 	$bar := "two"
280 | 	
281 | 	javascript:
282 | 		var a = $foo + $bar;	// var a = $foo + $bar;
283 | 	
284 | 	javascript($foo):
285 | 		var a = $foo + $bar;	// var a = "one" + $bar;
286 | 	
287 | 	javascript($bar):
288 | 		var a = $foo + $bar;	// var a = $foo + "two";
289 | 	
290 | 	javascript($foo, $bar):
291 | 		var a = $foo + $bar;	// var a = "one" + "two";
292 | 
293 | 
294 | ### Using Other Languages
295 | 
296 | Verbatim tag is convenient when you want to include raw JavaScript inside of your page. But what if you're using RapydScript, CoffeeScript, or something else for your JavaScript? The typical way to include those is by having the `<script>` tag link to the .js file directly instead of having the code inside. If it's just a few lines of code, however, it often makes sense to just implement it inside of the page itself. Still, it would be nice if you could write that snippet in your language of choice rather than JavaScript. And for cases like that, RapydML offers `code_block()` method.
297 | 
298 | `code_block` is `verbatim`'s big brother. It works almost the same way, except it passes the content through a sequence of shell commands of your choosing. The only requiremenet is that whatever the sequence of commands is, it must accept STDIN and return STDOUT (STDERR will be reported to you by RapydML at compile time so you can investigate the problem). For example, let's say we want to be able to use RapydScript directly inside our webpages. Assuming RapydScript is already installed on the computer, you can add the following line to your page to create a tag that will automatically convert RapydScript code:
299 | 
300 | 	rapydscript = code_block(script(type="text/javascript"), \
301 | 		' > /tmp/tempfile.pyj && rapydscript /tmp/tempfile.pyj && cat /tmp/tempfile.js')
302 | 
303 | The above command works around the fact that RapydScript doesn't work with STDIN by dumping the input to a file first, and works around it not returning STDOUT by using `cat` command. The command would work the same way on Windows, where instead of `cat` you could use `type`. Now, you can use `rapydscript` tag the same exact way we used `javascript` tag in previous section. Don't worry if you're not comfortable with the shell, the above command is already included in `lib/common` for your convenience. If you include the following line in your RapydML pages, you can automatically use `text`, `javascript`, and `rapydscript` tags:
304 | 
305 | 	import lib.common
306 | 
307 | 
308 | Using Django, web2py, Rails, etc.
309 | ---------------------------------
310 | RapydML easily extends to support any template engine your heart desires with just a few lines defining how to handle the given template. Take a look at the following example that adds support for Django's for loops:
311 | 
312 | 	django = TemplateEngine('<%% %s %%>')
313 | 	django.for = create('for %s in %s:', 'endfor')
314 | 
315 | We now can invoke a Django for loop as follows:
316 | 
317 | 	django.for(i, array):
318 | 
319 | Note that %s is used to specify the insertion of passed in arguments later, also note that %% is used to signify the actual percent sign character (like in Python, when using similar syntax). By passing a template to our TemplateEngine constructor, we tell it to wrap every call to django inside `<% %>` tags. Note also how a typical for loop gets declared. The fact that we called it `django.for` is just for convenience, we could have easily called it `django.loop` or any other keyword. What is important, however, is the arguments we pass to the creation method. The first argument represents the beginning of this block, the second represents the end of the block. In cases where the end block is irrelevant (such as `<%= item %>` tag), you can omit the second argument:
320 | 
321 | 	django.out = create('= %s ')
322 | 
323 | But how does RapydML handle more complex template elements, such as an if/then/else block? With append() method, we can assign elif/else methods to the same consturct as an if statement. The following 3-liner adds support for if/then/else statements of any complexity:
324 | 
325 | 	django.if = create('if %s:', 'endif')
326 | 	django.elif = django.if.append('elif %s:')
327 | 	django.else = django.if.append('else:')
328 | 
329 | Not bad, but what about more complex templating engines, such as web2py, that allow you to define functions inside of your view? Well, first of all, if you're defining functions inside of your view, you're probably doing something wrong (these should probably exist in the controller instead). But if you still desire to have them in your view, it's not that hard to accomplish. Let's take a look at the following chunk of code from Views chapter of the [web2py tutorial book](http://web2py.com/books/default/chapter/29/5):
330 | 
331 | 	{{def itemize1(link): return LI(A(link, _href="http://" + link))}}
332 | 	<ul>
333 | 	{{=itemize1('www.google.com')}}
334 | 	</ul>
335 | 
336 | Remember the verbatim() method we showed you earlier for including arbitrary chunks of JavaScript and HTML inside of your page? This same method can be used here as well, and even happens to make the above code cleaner. In this case we will be using verbatim_line() method, which works just like the normal verbatim(), except it replaces all '\n' characters with spaces, which condenses your chunk of code into a single line:
337 | 
338 | 	web2py.def = verbatim_line(web2py)
339 | 
340 | Now we can use the def method to define any methods we want inside our template. Let's rewrite the above chunk of code from web2py page:
341 | 
342 | 	web2py.def:
343 | 		def itemize1(link):
344 | 			return LI(A(link, _href="http://" + link))
345 | 
346 | 	ul:
347 | 		web2py.out(itemize1('www.google.com'))
348 | 
349 | While the code in this example isn't shorter than the original, you will probably agree that it is cleaner. That's fine, but if you had to include language template definitions in every HTML file you write, you would probably lose interest in RapydML pretty fast. To remedy this, you can use the `import` statement. Feel free to take all your Django/Web2py/Rails definitions and dump them into a separate file, naming it django.pyml, for example. Now add the following line to each one of your files that needs to use it:
350 | 
351 | 	import django
352 | 
353 | Now you can even share your Django definitions with other developers. To keep things clean, you can even move template definitions to a separate directory, and reference them the same way you would in Python. If we decided to move our django.pyml template to views/templates directory, for example, we can then import it as follows:
354 | 
355 | 	import views.templates.django
356 | 
357 | The notable difference here between Python and RapydML is the lack of namespaces. That means we would still reference the template engine by the same name as it's declared in the template file, rather than as we import it. So we would invoke the for loop as django.for(...) rather than views.templates.django.for(...). RapydML's import mechanism isn't as complex as Python's, we simply concatenate the contents of imported files into the main one, checking only that we don't import the same file multiple times.
358 | 
359 | To make it easier to write HTML, as well as create new templates, I have included templates for web2py, Django, and Rails, they're inside the `lib` directory. Feel free to use them to write your own web pages, as well as develop new templates for other engines. If you do plan to use a template engine, I suggest you also read the Advanced Usage section at the end. To add one of the included template engines to your project, simply add the following line at the top of your file:
360 | 
361 | 	import lib.web2py
362 | 
363 | 
364 | RapydML vs HAML
365 | ---------------
366 | Admittedly, I started this as an afternoon hobby project, while being too naive to check that something like HAML already exists. After looking at HAML, however, I quickly realized that I like my solution much more than HAML. HAML takes the Rails approach, where it assumes things for you, and if those assumptions are correct, 'magic' happens. If they're not, you will spend a lot of time banging your head against a wall. HAML assumes that most tags will be DIVs, for example, replacing forgotten tags with DIVs for you. This assumption probably will not hold in the future. HTML5 already added multiple new tags (header, footer, article, nav, etc.) to reduce the number of DIVs needed on a page, and more tags will likely follow. HAML also also assumes that you will be using it with Rails to generate .erb files, you're out of luck if you use it with Django or Web2py. Like Rails, it's very good for doing things it was designed to do, but not something the developers didn't account for.
367 | 
368 | RapydML takes a more Pythonic approach, being simple, extensible, and explicit. You can extend it as you see fit, and it makes very few assumptions for you. You will also notice that RapydML code, while slightly longer, is much more readable than HAML, taking the Python approach here as well. You spend a lot more time looking at the code than writing it, so why make the code hard to read?
369 | 
370 | Additionally, RapydML is more powerful than HAML, even allowing the use of Python logic directly within the page. But perhaps the biggest advantage of RapydML is how customizable it is. By default, RapydML compiles into HTML and is very lax about HTML version, supporting any tags and attributes from HTML1.0 up until HTML5. It also includes a stricter HTML5 template in the `markup` directory, which you can use to ensure your web page is HTML5-compliant. The later template not only checks that your tags are valid, but also that you're using supported HTML5 attributes for them (for example, HTML5 dropped `bgcolor` attribute for `body` tag, and HTML5 template will tell you about that). Similarly, you can create new templates, specifying desired tag names as well as control how strict the template is (refer to `markup/html5` to understand template layout). Once done, just place the template into the `markup` directory, and it will automatically get pulled in by RapydML's compiler. Note that template's filename will become the name of the flag to invoke it, so if you add a file named `svg1`, you will need to invoke the compiler as follows to use it:
371 | 
372 | 	rapydml --svg1 file.pyml
373 | 
374 | 
375 | Advanced Usage
376 | --------------
377 | If you decide to use RapydML as the main tool for building your HTML, you might want to be familiar with some advanced features and tricks. If that's the case, this section is for you.
378 | 
379 | 
380 | ### Nesting Content Inside Methods
381 | 
382 | In the section titled `Methods and HTML Chunks`, we mentioned the ability to append content to a pre-declared method by indenting logic underneath the method call. There is even more to this feature, however. The indentation restriction is dictated by the content of the method, not the method call itself. This means that your indentation doesn't need to be correct relative to the method call, but rather the HTML chunk inside the method, and will get parsed relative to the method content as well. For example, imagine that we declared the following method:
383 | 
384 | 	def content_box($title, $icon):
385 | 		div(class="content-box"):
386 | 			h1:
387 | 				$title
388 | 			div(class="content")
389 | 				img(src=$icon)
390 | 				div(class="content-text")
391 | 
392 | We now want to append content inside of the `content-text` div, but if we use the same way to append it as before, it will end up getting appended inside the main `content-box` div, as a sibling to `content` div and `h1` tag. Using the indentation trick we just discovered, however, we can control where to nest the content:
393 | 
394 | 	content_box('Important Info', 'exclamation.png'):
395 | 				'This text will get appended to the inner-most div of content_box'
396 | 
397 | Likewise, if we used 2 indentations instead of 3, the content would get appended to the `content` div, right after the `content-text` div. This gives us great control of when and how our logic will get appended to the method, almost like using a multi-line variable. Another useful example is when you have a template method generating the parts of the page you plan to reuse:
398 | 
399 | 	def template():
400 | 		html:
401 | 			head:
402 | 				...
403 | 			body:
404 | 				banner()
405 | 				div(id="content")
406 | 
407 | Without ability to control the indentation, you would be limited to placing your logic inside the outer-most tag, which is `html`. By using nested indentation, however, you can place content directly inside the `content` div, or just inside `body` itself (if it's a footer, for example).
408 | 
409 | 
410 | ### HTML Rendering Optimizations
411 | 
412 | If you're using web2py/Rails/Django or similar engine, you might have noticed that RapydML can handle some of the logic you previously relied on your templating engine for (things like combining content from multiple page templates/chunks, repeating portions of your HTML within the same page, etc.). You might be curious which solution is better. For that we'll need to understand what happens behind the scenes on your web server. Engines like web2py, Django, or Rails are useful for generating dynamic content that gets plugged into your HTML or even reducing the amount of repeated HTML markup between multiple web pages. They keep the code maintainable and ensure that you only need to make a change in one place to affect common logic on all of your your web pages.
413 | 
414 | Some of that niche, however, can be better addressed by RapydML. For example, you're probably familiar with the following line from Django (or its equivalent web2py or Rails):
415 | 
416 | 	{% extends basic.html %}
417 | 
418 | For those unfamiliar with it, the above line includes HTML from basic.html inside of the current page. This is a useful technique to avoid unnecessary copies of HTML that's common to multiple pages (this includes navigation menus, website logo, etc.). The above logic, however, can also be substituted with RapydML's `import` statement, importing RapydML logic from another page. For example, I can create a template.pyml file, declararing a function for generating a chunk of reusable HTML inside of it, and then invoke that function in every place I want that HTML to appear. Which solution is better?
419 | 
420 | If you're an experienced web developer, you probably know that on most hosting services storage space (especially for text/html) is relatively cheap compared to bandwidth and CPU usage. The bandwidth requirements in this case are the same, since both, template engine and RapydML logic happens before the page is served to the client. The main difference is that by using `extends`, you force your template engine to dynamically generate that HTML content before serving it to the client (using up CPU cycles, smart engines will probably cache this data), while by using `import` you make your compiler generate that HTML once and serve it repeatedly to your clients (using up a bit more storage space, which is not even significant when comparing it to storage taken up by images and other multimedia files). As a rule of thumb, I recommend using RapydML's logic over Django/Rails/web2py unless it's something that requires information that will not be available until runtime (i.e. news that you retrieve from the database, interactive form that deals with user input). It's not too different from preferring CSS over JavaScript for styling that doesn't change dynamically.
421 | 
422 | 
423 | ### Writing DRY HTML/XML
424 | 
425 | RapydML does not evaluate the logic inside a method until it actually runs (gets invoked by logic not wrapped in a method). This means that you can call methods from other methods before they're declared. While subtle, this is a very useful feature. You can use this to take the importing idea presented in previous section a step further and do some really neat things with your website. For example, if you have a `template.pyml` file that defines `header_html()` and `footer_html()` methods (where header will take care of `<head>` declaration as well as the banner), your `index.pyml` will probably look like this:
426 | 
427 | 	import template
428 | 	
429 | 	header_html():
430 | 		div(id="content"):
431 | 			'My page content'
432 | 			img(src="smiley.png")
433 | 		
434 | 		# resides inside header because header implements the <body> tag
435 | 		footer_html()
436 | 
437 | But you can do even better than that. Instead of implementing `header_html()` and `footer_html()`, let's write our `template.pyml` as follows:
438 | 
439 | 	def page():
440 | 		html:
441 | 			head:
442 | 				title:
443 | 					'Welcome to my website'
444 | 			body:
445 | 				div(id="header")
446 | 					img(src="banner.png")
447 | 					
448 | 				div(id="content"):
449 | 					content()
450 | 				
451 | 				div(id="footer")
452 | 					'Copyright info'
453 | 
454 | If you're observant, you probably noticed the undefined `content()` method. That method will be defined by our `index.pyml` (and any other page based on this template), along with a call to `page()`, which will wrap the content inside of our template and generate the actual page:
455 | 
456 | 	import template
457 | 	
458 | 	def content():
459 | 		'My page content'
460 | 		img(src="smiley.png")
461 | 	
462 | 	page()
463 | 
464 | The result is that our pages are very clean and all would-be repetitive content is in one place. In fact, pyjeon.com website is written using this technique.
465 | 
466 | 
467 | ### Nested Templates and Conditional Logic
468 | 
469 | RapydML does not have `if/else` statements, and for a good reason. RapydML is meant to make HTML cleaner, not more complicated. Adding more power than is needed to a language only makes it harder to read someone else's code. Since HTML is not meant to be dynamic, conditional logic would do more harm than good - especially when one developer does something fancy and another developer needs to make sense of it later.
470 | 
471 | However, there are valid cases when you need to generate pages with very similar layout, but not the same. Instead of having two very similar templates, you could use the latent method evaluation described in the previous section to create conditional logic within templates.
472 | 
473 | Similarly to calling an undeclared method inside another method, you can use an undeclared variable, as long as it gets defined by the time the method is called. Continuing from the example in previous section, let's say we have a `page()` method defined for drawing the generic page template. We now need to define a special set of pages based on that template, but sharing a sub-template as well. For example, let's say we're selling a product and the only things changing are its price, description, and name. We can create a new template called product_template:
474 | 
475 | 	import template
476 | 	
477 | 	def content():
478 | 		h3:
479 | 			$name
480 | 		$description
481 | 		'Buy now for ' + $price
482 | 	
483 | 	def product_page():
484 | 		page()
485 | 
486 | Now for each of our products, we simply need to specify `$name`, `$description`, and `$price`, and call `product_page()` like so:
487 | 
488 | 	import product_template
489 | 	
490 | 	$name := 'Coffee Mug'
491 | 	$description := 'A fancy coffee mug that keeps your coffee warm.'
492 | 	$price := '$8.99'
493 | 	
494 | 	product_page()
495 | 
496 | We can now invoke the same `product_page()` function, but the generated content will be unique for each product. We now have conditional templates without the messy `if/else` logic.
497 | 
498 | 
499 | ### Customizing Markup
500 | 
501 | RapydML is not limited to HTML. If you open up the `markup` directory, you will notice 3 files: `any`, `html`, and `html5`. `html` is the default markup RapydML assumes if you omit the markup modifier when compiling your `.pyml` file. This markup is designed to limit you to valid HTML tags, but does not enforce any attribute limitations or HTML versions. `html5` is much stricter, enforcing valid HTML5 tags as well as attributes. Finally, `any` is the most relaxed of the 3, allowing you to use any tag with any attributes. `any` markup assumes every tag which has not been explicitly defined as a method (via the use of `def` keyword inside of your `.pyml` file) to be a valid markup tag.
502 | 
503 | Using one of these as an example, you can create your own rules for any other *ML-like markup (SVG, XSLT, or XML that's custom to your project). The basic rules are very simple, but their combinations allow for very powerful customizations:
504 | 
505 | #### Rules
506 | 
507 | ##### Line Format
508 | Each line has to follow the following format (where whitespace can be one or more spaces or tabs, whitespace between attributes is not significant):
509 | 
510 | 	<tagname>	allowedattr1, allowedattr2, ...
511 | 
512 | ##### Example:
513 | 
514 | 	<canvas>	height, width
515 | 
516 | ##### Attribute Inheritance
517 | Indentation is used to define child nodes, child nodes inherit allowed attributes from their parents
518 | 
519 | ##### Example:
520 | 
521 | 	<col>	span
522 | 		<colgroup>
523 | 
524 | ##### Comments
525 | `#` Marks beginning of a comment
526 | 
527 | ##### Example:
528 | 
529 | 	# this is a comment
530 | 
531 | ##### Breaking Up Long Lines
532 | When used at the end of the line, concatenates next line with current line, removing leading whitespace from next line
533 | 
534 | ##### Example:
535 | 
536 | 	<.>		attr1, attr2, attr3, \
537 | 			attr4, attr5
538 | 
539 | ##### Internal/Meta Nodes
540 | `<.>` Marks an internal node/tag, this node can't be used directly, but passes a set of usable attributes to its child tags, this should not be a leaf node.
541 | 
542 | ##### Example:
543 | 
544 | 	<.>	disabled, form, name
545 | 		<input>
546 | 		<button>
547 | 
548 | ##### Wildcard Attributes
549 | `*` If used instead of attributes, removes any argument restrictions from this tag
550 | 
551 | ##### Example:
552 | 
553 | 	<a>	*
554 | 
555 | ##### Force Separate Close Tag
556 | `+` Force this element to never use shorthand close: <div> allows <div />, <div>+ always forces <div></div>
557 | 
558 | ##### Example:
559 | 
560 | 	<canvas>+
561 | 
562 | ##### Force No Close Tag
563 | `-` Force this element to never use close tag, note that adding children under this element in your .pyml file will trigger an error
564 | 
565 | ##### Example:
566 | 
567 | 	<!DOCTYPE>-
568 | 
569 | ##### Inheriting Attributes From Multiple Nodes
570 | You can repeat the same tag multiple times, this is typically useful when it reuses same attributes as multiple other tags, yet those other tags don't share attributes. Note that when using + or - tag modifiers, the first occurence of the tag will be used for deciding the element/tag modifier. The rest will be ignored.
571 | 
572 | ##### Example:
573 | 
574 | 	<canvas>	height, width
575 | 		<input>	alt, src
576 | 	<button>	disabled, type, value
577 | 		<input>
578 | 
579 | ##### Wildcard Elements/Tags
580 | `<*>` A special tag, its presence means that omitted tags are allowed in pyml as well (and will automatically be inferred to use <tag></tag> format. Without this tag, RapydML will complain about any tags not specifically mentioned in the markup file.
581 | 
582 | ##### Example:
583 | 
584 | 	<*> attr1, attr2	# allows any element name as long as only attr1 or attr2 attributes are used
585 | 
586 | Note that wildcard tag is independent of wilcard attribute character. You can do each of the following for example:
587 | 
588 | 	<*>		*		# places no restrictions on allowed elements or attributes 
589 | 					# (everything that wasn't explicitly declared as a method will 
590 | 					# be treated as an element tag)
591 | 	
592 | 	<foo>	*		# only allows `foo` element tag, but places no restrictions on 
593 | 					# usable attributes
594 | 	
595 | 	<*>		bar		# allows you to use any element tag name, but the only supported 
596 | 					# attribute for your elements is `bar`
597 | 	
598 | 	<foo>	bar		# only allows `foo` element tag, only allows `bar` attribute for it
599 | 	
600 | 	<*>				# places no restrictions on allowed elements, but does not allow 
601 | 					# any attributes (note that this only applies to elements that have
602 | 					# not been explicitly mentioned in the markup)
603 | 
604 | 


--------------------------------------------------------------------------------
/bin/rapydml:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | import os, sys
 4 | import argparse
 5 | 
 6 | from rapydml.markuploader import load
 7 | from rapydml.compiler import Parser, __file__ as rapydml_compiler_path
 8 | 
 9 | parser = argparse.ArgumentParser(description='Pre-Compiler for XML/HTML-like markup. \
10 | Simplifies writing new web pages and XML by making format more human-readable as well \
11 | as reducing redundant syntax.')
12 | 
13 | parser.add_argument('input', metavar='INPUT', type=file, 
14 | 					help='The RapydML file to compile')
15 | parser.add_argument('--no-acknowledgement', dest='no_ack', action='store_true', default=False,
16 | 					help="Avoid the string stating that page was generated using RapydML")
17 | 
18 | # add all available markup languages to the help menu
19 | rapydml_dir = os.path.abspath(os.path.dirname(rapydml_compiler_path))
20 | available_markup = os.listdir(os.path.join(rapydml_dir, 'markup'))
21 | group = parser.add_mutually_exclusive_group()
22 | for lang in available_markup:
23 | 	group.add_argument('--%s' % lang, action='store_true', default=False,
24 | 						help='Parse the file using %s markup syntax' % lang.upper())
25 | 
26 | args = parser.parse_args()
27 | 
28 | # figure out which markup the user selected, default to HTML if none specified
29 | markup = None
30 | for lang in available_markup:
31 | 	if getattr(args, lang):
32 | 		markup = lang
33 | if markup is None:
34 | 	markup = 'html'
35 | 
36 | # load correct markup template
37 | markup_lang = load(markup, rapydml_dir)
38 | 
39 | # begin markup
40 | html = Parser(markup_lang)
41 | filename = args.input.name.rsplit('.', 1)[0]
42 | with open(filename + '.html', 'w') as output:
43 | 	if not args.no_ack:
44 | 		output.write('<!-- This page has been auto-generated using RapydML (http://www.pyjeon.com) -->\n')
45 | 	output.write(html.parse(args.input.name))
46 | 


--------------------------------------------------------------------------------
/rapydml/compiler.py:
--------------------------------------------------------------------------------
   1 | import sys, re, os
   2 | import string
   3 | from util import IndentParser, ParserError, ShellError
   4 | from markuploader import NORMAL, SINGLE
   5 | from subprocess import Popen, PIPE
   6 | import pipes
   7 | 
   8 | # modules imported for convenience when using python.* within RapydML
   9 | import math
  10 | 
  11 | 
  12 | # change this to True to see additional output during compilation
  13 | DEBUG = False
  14 | 
  15 | 
  16 | # variables used by verbatim
  17 | VERBATIM = 1
  18 | MULTI_LINE = 0
  19 | SINGLE_LINE = 1
  20 | CODE_BLOCK = 2
  21 | GLOBAL_VARS = 0
  22 | METHOD_VARS = 1
  23 | 
  24 | # variables used by regex
  25 | REGEX_NESTED_PAREN = r'\([^()]*(?:\(.*?\))*[^()]*\)'
  26 | NOT_SINGLE_QUOTED = r'^(?:[^\']*([\'])[^\']*\1)*[^\']*'
  27 | 
  28 | # miscellaneous
  29 | EOF_MARKER = '!!!_E_O_F_!!!\n'
  30 | 
  31 | def is_number(s):
  32 | 	try:
  33 | 		float(s)
  34 | 		return True
  35 | 	except ValueError:
  36 | 		return False
  37 | 
  38 | def is_valid_name(s):
  39 | 	# returns true if name follows Pythonic standard
  40 | 	return not not re.match('^[a-zA-Z_][a-zA-Z0-9_]*$', s)
  41 | 
  42 | def expand_arrays(tag):
  43 | 	# expands shorthand arrays such as [1:5] into full-array [1,2,3,4,5]
  44 | 	# [0:6] 	-> [0,1,2,3,4,5,6]
  45 | 	# [1:8:2]	-> [1,3,5,7]
  46 | 	# [8:1:-1]	-> [8,7,6,5,4,3,2,1]
  47 | 	# [8:1]		-> []
  48 | 	matches = re.findall('(\[(-?\d+):(-?\d+)(:(-?\d+))*\])', tag)
  49 | 	for array in matches:
  50 | 		if array[-1] == '':
  51 | 			increment = 1
  52 | 		else:
  53 | 			increment = int(array[-1])
  54 | 		if increment > 0:
  55 | 			final = int(array[2])+1
  56 | 		else:
  57 | 			final = int(array[2])-1
  58 | 		tag = tag.replace(array[0], str(range(int(array[1]),final,increment)))
  59 | 	return tag
  60 | 	
  61 | attr_map = {'.' : 'class'}
  62 | def convert_attr(attr):
  63 | 	# converts attribute CSS-like shorthands to proper HTML
  64 | 	attr = attr.strip()
  65 | 	if attr[0] in attr_map.keys():
  66 | 		return '%s="%s"' % (attr_map[attr[0]], attr[1:])
  67 | 	elif attr.find('=') != -1 and is_number(attr.split('=')[1]):
  68 | 		pair = attr.split('=')
  69 | 		return '%s="%s"' % (pair[0].strip(), pair[1].strip())
  70 | 	else:
  71 | 		return attr
  72 | 
  73 | def get_attr(tag):
  74 | 	# retrieves all attributes in a given function call/definition tag
  75 | 	# this logic respects commas inside a string
  76 | 	attr_string = re.findall(r'\((.*)\)', tag)[0]
  77 | 	if attr_string == '':
  78 | 		return []
  79 | 	else:
  80 | 		attr_list = attr_string.split(',')
  81 | 		
  82 | 		buffer = ''
  83 | 		in_string = None
  84 | 		in_list = False
  85 | 		final_attr_list = []
  86 | 		for orig_attr in attr_list:
  87 | 			attr = orig_attr.strip()
  88 | 			if in_string or in_list:
  89 | 				# if we're inside a string, don't strip whitespace
  90 | 				buffer += ',' + orig_attr
  91 | 			else:
  92 | 				buffer = attr
  93 | 			
  94 | 			if in_string:
  95 | 				length = len(attr)
  96 | 				# check that last character is a quote
  97 | 				# and second to last is not an escape character
  98 | 				if length and attr[-1] == in_string:
  99 | 					if length > 1 and attr[-2] != '\\' or length == 1:
 100 | 						# string ended
 101 | 						in_string = None
 102 | 			else:
 103 | 				if	attr.count('"') % 2:
 104 | 					# double-quoted string started
 105 | 					in_string = '"'
 106 | 				elif attr.count("'") % 2:
 107 | 					# single-quoted string started
 108 | 					in_string = "'"
 109 | 			
 110 | 				if attr[0] == '[':
 111 | 					in_list = True
 112 | 				if attr[-1] == ']':
 113 | 					in_list = False
 114 | 			
 115 | 			if not in_string and not in_list:
 116 | 				final_attr_list.append(buffer.strip())
 117 | 		
 118 | 		for i in range(len(final_attr_list)):
 119 | 			final_attr_list[i] = convert_attr(final_attr_list[i])
 120 | 			if final_attr_list[i][0] in ('"', "'") \
 121 | 			and re.match(r'(["\'])[^"\']+\1\s*=.*', final_attr_list[i]):
 122 | 				# strip quotes from attribute name (because attr names with special chars
 123 | 				# require quotes, i.e. 'z-index'
 124 | 				final_attr_list[i] = final_attr_list[i].replace(final_attr_list[i][0], '', 2)
 125 | 		return final_attr_list
 126 | 	
 127 | def parse_definition(tag):
 128 | 	# parses DOM element or function definition
 129 | 	tag = tag.strip()
 130 | 	if tag.find('(') != -1:
 131 | 		element = tag.split('(')[0].rstrip()
 132 | 		attributes = get_attr(tag)
 133 | 	else:
 134 | 		element = tag.replace(':', '')
 135 | 		attributes = []
 136 | 	return element, attributes
 137 | 		
 138 | def replace_variables(code, var_hash, ignore_list=[]):
 139 | 	#plugs the variables into the line
 140 | 	vars = re.findall('(?<!\\\\)\$[A-Za-z_][A-Za-z0-9_]*', code)
 141 | 	
 142 | 	for var in ignore_list:
 143 | 		try:
 144 | 			vars.remove(var)
 145 | 		except ValueError:
 146 | 			pass # variable doesn't appear on this line
 147 | 	
 148 | 	for var in vars:
 149 | 		try:
 150 | 			# the first version will not replace 2nd occurence in strings like '$a$a'
 151 | 			#code = re.sub('(?<!(\\\\|[A-Za-z0-9_]))\%s(?![A-Za-z0-9_])' % var, var_hash[var], code)
 152 | 			code = re.sub('(?<!\\\\)\%s(?![A-Za-z0-9_])' % var, var_hash[var], code)
 153 | 		except KeyError:
 154 | 			raise ParserError("Variable '%s' used prior to definition" % var)
 155 | 	
 156 | 	if code.find('python.') != -1:
 157 | 		# use of python method
 158 | 		code = eval_python(code)		
 159 | 	
 160 | 	return code
 161 | 
 162 | def expand_assignment(tag):
 163 | 	# handles expansion of increment logic
 164 | 	result = tag.split('+=')[0].split('-=')[0].split('*=')[0].split('/=')[0].strip()
 165 | 	tag = tag.replace('+=', ':= %s + (' % result)\
 166 | 			.replace('-=', ':= %s - (' % result)\
 167 | 			.replace('*=', ':= %s * (' % result)\
 168 | 			.replace('/=', ':= %s / (' % result)
 169 | 	if tag.count('(') > tag.count(')'):
 170 | 		tag = tag.rstrip() + ')\n'
 171 | 	return result, tag
 172 | 
 173 | def do_arithmetic(operation):
 174 | 	# this function solves simple arithmetic such as +/-/*//
 175 | 	# if we detect # or non-numeric variable, that's not a method, try to run it through color converter
 176 | 	# valid color formats we expect are '#ffffff', '#000', or 'white' (note the quotes, we assume them necessary)
 177 | 	# what about style?
 178 | 	try:
 179 | 		result = eval(operation)
 180 | 		return repr(result)
 181 | 	except SyntaxError, NameError:
 182 | 		raise ParserError("Command '%s' is not a valid mathematical operation" % operation.strip())
 183 | 
 184 | def parse_array_part(array_part):
 185 | 	# helper method for scanning the passed in string backwards and returning a corresponding array
 186 | 	# it ignores whatever is to the left of the array
 187 | 	array = []
 188 | 	start_index = 0
 189 | 	buffer = ''
 190 | 	brackets = 0
 191 | 	in_single_quote = False
 192 | 	in_double_quote = False
 193 | 	for index in range(len(array_part))[::-1]:
 194 | 		if array_part[index] == ']' and not in_single_quote and not in_double_quote:
 195 | 			brackets += 1
 196 | 			if brackets > 1:
 197 | 				buffer = array_part[index] + buffer
 198 | 		elif array_part[index] == '[' and not in_single_quote and not in_double_quote:
 199 | 			brackets -= 1
 200 | 			if brackets >= 1:
 201 | 				buffer = array_part[index] + buffer
 202 | 		elif array_part[index] == '"' and not in_single_quote and array_part[index-1] != '\\':
 203 | 			in_double_quote = not in_double_quote
 204 | 			buffer = array_part[index] + buffer
 205 | 		elif array_part[index] == "'" and not in_double_quote and array_part[index-1] != '\\':
 206 | 			in_single_quote = not in_single_quote
 207 | 			buffer = array_part[index] + buffer
 208 | 		elif array_part[index] == ',' and not in_single_quote and not in_double_quote and brackets == 1:
 209 | 			array.append(buffer.strip())
 210 | 			buffer = ''
 211 | 		else:
 212 | 			buffer = array_part[index] + buffer
 213 | 		
 214 | 		if brackets == 0:
 215 | 			if buffer:
 216 | 				array.append(buffer.strip())
 217 | 			start_index = index
 218 | 			break
 219 | 	array.reverse()
 220 | 	return array, start_index
 221 | 
 222 | def parse_template_engine_method_declaration(line):
 223 | 	command_pair = line.split('=', 1)
 224 | 	if len(command_pair) != 2:
 225 | 		raise ParserError("Improper TemplateEngine method declaration, variable assigned to must follow format of TemplateEngine.MethodName")
 226 | 	method_pair = command_pair[0].rstrip().rsplit('.', 1)
 227 | 	method, attributes = parse_definition(command_pair[1])
 228 | 	return method_pair[0], method_pair[1], method, attributes
 229 | 
 230 | def create_tag(element, attributes):
 231 | 	attr_string = ' '.join(attributes)
 232 | 	if attr_string:
 233 | 		starttag = '<%s %s>\n' % (element, attr_string)
 234 | 	else:
 235 | 		starttag = '<%s>\n' % element
 236 | 	endtag = '</%s>\n' % element
 237 | 	return starttag, endtag
 238 | 
 239 | def eval_python(line):
 240 | 	substrings = re.findall(r'(\bpython\..*?%s)' % REGEX_NESTED_PAREN, line)
 241 | 	for substring in substrings:
 242 | 		mystr = repr(eval(substring[7:]))
 243 | 		line = line.replace(substring, mystr)
 244 | 	return line
 245 | 
 246 | class ColorConverter:
 247 | 	"""
 248 | 	Helper class for handling color conversion, so that we can perform math operations on it
 249 | 	"""
 250 | 
 251 | 	def __init__(self):
 252 | 		# create a map for html color names
 253 | 		self.color_map = {}
 254 | 		orig_dir = os.getcwd()
 255 | 		cur_dir = os.path.dirname(__file__)
 256 | 		os.chdir(os.path.abspath(cur_dir))
 257 | 		with open('html_colors.txt', 'r') as input:
 258 | 			for line in input:
 259 | 				pair = line.split(':')
 260 | 				self.color_map[pair[0]] = pair[1].rstrip()
 261 | 		os.chdir(orig_dir)
 262 | 	
 263 | 	def is_color(self, color_string):
 264 | 		return color_string in self.color_map.keys()
 265 | 	
 266 | 	def to_num(self, color):
 267 | 		# first we standardize colors to 6-digit hex format
 268 | 		color = color.lower()
 269 | 		if color in self.color_map.keys():
 270 | 			color = self.color_map[color]
 271 | 		elif len(color) == 3:
 272 | 			color = '%s%s%s%s%s%s' % (color[0], color[0], color[1], color[1], color[2], color[2])
 273 | 		elif len(color) != 6:
 274 | 			raise ParserError("Color '%s' is not a valid HTML color" % color)
 275 | 		
 276 | 		# now we return base 10 representation of the number
 277 | 		return int(color, 16)
 278 | 	
 279 | 	def to_color(self, num):
 280 | 		return hex(num)[2:].zfill(6)
 281 | 
 282 | class Method:
 283 | 	"""
 284 | 	Helper class for generating html-creating methods
 285 | 	"""
 286 | 	
 287 | 	def __init__(self, attributes, copy_heap, color_parser, name):
 288 | 		# create a new method that can be invoked later
 289 | 		# attributes: set of parameters this method will take in (this will be defined at function invocation)
 290 | 		# heap: the memory space this method sees
 291 | 		#	can be used to hide some vaiables from a method or 'shadow' global variables by passing copies
 292 | 		self.attributes = attributes
 293 | 		self.lines = []
 294 | 		self.color = color_parser
 295 | 		self.copy_heap = copy_heap
 296 | 		self.name = name
 297 | 		self.local_vars = []
 298 | 	
 299 | 	def add_line(self, line, verbatim=None, verbatim_vars=[]):
 300 | 		# this is where we handle replacing predefined variables
 301 | 		if verbatim is None:
 302 | 			line_type = NORMAL
 303 | 			trash, line = expand_assignment(line)
 304 | 			if line.find(':=') != -1:
 305 | 				operands = line.split(':=')
 306 | 				self.local_vars.append(operands[0].strip())
 307 | 		else:
 308 | 			line_type = VERBATIM
 309 | 		self.lines.append((line_type, line, verbatim_vars))
 310 | 	
 311 | 	def eval_chunk(self, part):
 312 | 		if re.search('[-+*/](?=(?:(?:[^"]*"){2})*[^"]*$)', part) and \
 313 | 		re.search("[-+*/](?=(?:(?:[^']*'){2})*[^']*$)", part):
 314 | 			
 315 | 			# check for potential colors:
 316 | 			# check for "blue" etc
 317 | 			# check for #fff etc
 318 | 			is_color_computation = False
 319 | 			possible_colors = re.findall('"[A-Za-z]+"(?=(?:(?:[^"]*"){2})*[^"]*$)', part)
 320 | 			possible_hex_colors = re.findall('#[A-Fa-f0-9]+(?=(?:(?:[^"]*"){2})*[^"]*$)', part)
 321 | 			for color in possible_colors:
 322 | 				color = color[1:-1]
 323 | 				if self.color.is_color(color):
 324 | 					is_color_computation = True
 325 | 					part = re.sub('"%s"' % color, str(self.color.to_num(color)), part)
 326 | 			for color in possible_hex_colors:
 327 | 				if len(color) == 4 or len(color) == 7:
 328 | 					is_color_computation = True
 329 | 					part = re.sub('%s' % color, str(self.color.to_num(color[1:])), part)
 330 | 			
 331 | 			# remove stuff before equal sign, by this time the variable shouldn't be quoted
 332 | 			var_val = re.findall('^([^\'"].*?)=(.*)$', part)
 333 | 			if var_val:
 334 | 				var_val = var_val[0]
 335 | 				part = var_val[0] + '=' + do_arithmetic(var_val[1])
 336 | 			else:
 337 | 				part = do_arithmetic(part)
 338 | 			
 339 | 			if is_color_computation:
 340 | 				part = max(min(int(part), 0xffffff), 0x000000)
 341 | 				part = '#%s' % self.color.to_color(part)
 342 | 		return part
 343 | 	
 344 | 	def eval_line(self, line):
 345 | 		# returns evaluated version of the line
 346 | 		line = replace_variables(line, self.heap)
 347 | 		
 348 | 		#TEMP: this tester is naive, it assumes the strings will not contain ' or " characters inside of them
 349 | 		#BUG: we need to resolve things like div(#tag-id,#f00+#001)
 350 | 		if re.search('^[A-Za-z_][A-Za-z0-9_]*[ ]*\(.*\)', line.strip()):
 351 | 			whitespace = line.split(line.strip()[0])[0]
 352 | 			element, attributes = parse_definition(line)
 353 | 			for i in range(len(attributes)):
 354 | 				attributes[i] = self.eval_chunk(attributes[i])
 355 | 			return '%s%s(%s)' % (whitespace, element, ','.join(attributes))
 356 | 		else:
 357 | 			line = self.eval_chunk(line)
 358 | 		return line
 359 | 	
 360 | 	def run_method(self, args, heap):
 361 | 		if self.copy_heap:
 362 | 			self.heap = heap.copy()
 363 | 		else:
 364 | 			self.heap = heap
 365 | 		#var_hash = {} #if we 'clutter' the global heap, it makes some logic easier and allows more Python-like reuse of variables after loop terminates
 366 | 		for i in range(len(self.attributes)):
 367 | 			#TEMP: the \ replacing is a temporary quickfix for misunderstood problem of Python interpreting the string when it shouldn't
 368 | 			#var_hash[self.attributes[i]] = args[i].replace('\\','\\\\')
 369 | 			try:
 370 | 				self.heap[self.attributes[i]] = args[i].replace('\\','\\\\')
 371 | 			except IndexError:
 372 | 				raise ParserError("Method '%s' expects %s attributes, %s given." % \
 373 | 									(self.name, len(self.attributes), len(args)))
 374 | 		for line in self.lines:
 375 | 			if line[0] == VERBATIM:
 376 | 				verbatim_line = line[1]
 377 | 				
 378 | 				# replace variables we specified
 379 | 				for variable in line[2]:
 380 | 					verbatim_line = re.sub(r'\%s(?![A-Za-z0-9_])' % variable, self.heap[variable], verbatim_line)
 381 | 				
 382 | 				yield verbatim_line		# don't run any logic on verbatim lines
 383 | 			else:
 384 | 				line = line[1]
 385 | 				
 386 | 				# this is where we handle replacing method arguments
 387 | 				assignments = line.count(':=')
 388 | 				if assignments == 1:
 389 | 					operands = line.split(':=')
 390 | 					self.heap[operands[0].strip()] = self.eval_line(operands[1].strip())
 391 | 					yield None # this line produces no output
 392 | 				elif assignments > 1:
 393 | 					raise "Multiple assignments on same line aren't allowed"
 394 | 				else:
 395 | 					yield self.eval_line(line)
 396 | 
 397 | class TemplateEngine:
 398 | 	"""
 399 | 	Helper class for generating HTML templates used by various templating engines such as Django,
 400 | 	web2py, or Rails
 401 | 	"""
 402 | 	
 403 | 	def __init__(self, tag_format):
 404 | 		# tag_format must include brackets and have %s for location of internal logic
 405 | 		self.tag_format = tag_format + '\n'
 406 | 		self.methods = {}
 407 | 		self.method_stack = []
 408 | 	
 409 | 	def handle_indent(self, indent, method_name):
 410 | 		# push to or pop from the stack, depending on indent
 411 | 		
 412 | 		# first method call
 413 | 		if self.method_stack:
 414 | 			indent_diff = indent-self.method_stack[-1][1]
 415 | 		else:
 416 | 			self.method_stack.append((method_name, indent))
 417 | 			return
 418 | 			
 419 | 		if self.is_submethod(method_name, indent): #indent_diff == 0 and method_name in self.methods[self.method_stack[-1][0]][3]:
 420 | 			# this is a submethod of current method
 421 | 			#self.method_stack.append((self.method_stack[-1][0], indent))
 422 | 			pass
 423 | 		elif indent_diff < 1: #pop
 424 | 			while indent_diff < 1:
 425 | 				self.method_stack.pop()
 426 | 				indent_diff += 1
 427 | 			self.method_stack.append((method_name, indent))
 428 | 		elif indent_diff > 1:
 429 | 			raise ParserError('Incorrect indentation')
 430 | 	
 431 | 	def add_method(self, name, start_format, end_format=None):
 432 | 		# add a method we can call later
 433 | 		num_vars = start_format.count('%s')
 434 | 		submethods = []
 435 | 		self.methods[name] = (start_format, num_vars, end_format, submethods)
 436 | 	
 437 | 	def enhance_method(self, original_method, sub_method):
 438 | 		# allows submethod to be assosciated with existing method, preventing the end_method from getting triggered
 439 | 		self.methods[original_method][3].append(sub_method)
 440 | 	
 441 | 	def is_submethod(self, method_name, indent):
 442 | 		# returns true if method_name is a submethod of previously invoked method
 443 | 		return self.method_stack and method_name in self.methods[self.method_stack[-1][0]][3] and indent == self.method_stack[-1][1]
 444 | 	
 445 | 	def call_method(self, method, vars, indent):
 446 | 		# this returns an actual template tag to use for this method call
 447 | 		if len(vars) != self.methods[method][1]:
 448 | 			raise ParserError("TemplateEngine method %s takes %d variables, %d given" % (method, self.methods[method][1], len(vars)))
 449 | 		
 450 | 		self.handle_indent(indent, method)
 451 | 		vars = tuple(vars)
 452 | 		contents = self.methods[method][0] % vars
 453 | 		return self.tag_format % contents
 454 | 	
 455 | 	def end_method(self, method, close=True):
 456 | 		# return the end method for 
 457 | 		if close and self.method_stack:
 458 | 			self.method_stack.pop()
 459 | 		if self.methods[method][2] is None:
 460 | 			return None
 461 | 		else:
 462 | 			return self.tag_format % self.methods[method][2]
 463 | 
 464 | class Parser:
 465 | 	"""
 466 | 	Usage:
 467 | 	html = Parser()
 468 | 	with open(output_file, 'w') as output:
 469 | 		output.write(html.parse(input_file))
 470 | 	"""
 471 | 	reserved_internal_methods = [
 472 | 		'create',
 473 | 		'append',
 474 | 		'verbatim',
 475 | 		'verbatim_line',
 476 | 		'code_block'
 477 | 	]
 478 | 	
 479 | 	def __init__(self, valid_tags):
 480 | 		self.valid_tags = valid_tags
 481 | 		self.tree = IndentParser()
 482 | 		self.element_stack = []
 483 | 		self.output = ''
 484 | 		self.last_opened_element = None
 485 | 		self.var_map = {}
 486 | 		
 487 | 		self.creating_method = None
 488 | 		self.method_map = {}
 489 | 		self.loop_stack = []
 490 | 		self.loop_index = 0
 491 | 		
 492 | 		self.template_engines = {}
 493 | 		self.color = ColorConverter()
 494 | 		self.imported_files = []
 495 | 		
 496 | 		self.verbatim = {}
 497 | 		self.current_verbatim = None
 498 | 		self.verbatim_indent = 0
 499 | 		self.verbatim_buffer = ''
 500 | 		self.verbatim_vars = ([], [])
 501 | 		self.need_to_remove_method_vars = False
 502 | 	
 503 | 	def get_debug_state(self):
 504 | 		# method used for debugging
 505 | 		print "vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv"
 506 | 		print "var_map", self.var_map
 507 | 		print "method_map", self.method_map.keys()
 508 | 		print "element_stack", self.element_stack
 509 | 		print "last_opened_element", self.last_opened_element
 510 | 		print "creating_method", self.creating_method
 511 | 		print "current_verbatim", self.current_verbatim
 512 | 		print "tree.indent", self.tree.indent
 513 | 		print "tree.no_stack", self.tree.no_stack
 514 | 		print "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"
 515 | 	
 516 | 	def write(self, line, overlap = 0):
 517 | 		# helper method for writing to file, all writes should be done through it to ensure a single point
 518 | 		# of entry
 519 | 		line = line.replace('\$', '$')
 520 | 		if overlap != 0:
 521 | 			self.output = self.output[:overlap] + line
 522 | 		else:
 523 | 			self.output += line
 524 | 	
 525 | 	def resolve_indexes(self, line):
 526 | 		# replace all indexes with corresponding values
 527 | 		while line.count(']['):
 528 | 			try:
 529 | 				parts = line.split('][')
 530 | 				array, start_index = parse_array_part(parts[0]+']')
 531 | 				index = parts[1].split(']')[0]	#this can trigger IndexError
 532 | 				num = int(index)				#this can trigger ValueError
 533 | 				line = line.replace(line[start_index:len('%s[%s]' % (parts[0],index))+1], array[num])
 534 | 			except ValueError:
 535 | 				# this occurs if we try something like array['abcd'] or array[3.5]
 536 | 				raise ParserError("Invalid index '%s', index must be an integer" % index)
 537 | 			except IndexError:
 538 | 				# this occurs if we try some improperly terminated line like array[ or ][
 539 | 				raise ParserError("Syntax error while trying to parse index")
 540 | 		
 541 | 		return line
 542 | 	
 543 | 	def close_last_element(self):
 544 | 		# closes last html tag
 545 | 		tag = self.element_stack.pop()
 546 | 			
 547 | 		if tag is None:
 548 | 			return # this is not an element that requires closing
 549 | 		
 550 | 		# in order to use short-hand <tag /> we need to make sure that tag is not a special tag, 
 551 | 		# and that the name matches as well as indent
 552 | 		if self.last_opened_element is None:
 553 | 			tag_type = -1
 554 | 		else:
 555 | 			try:
 556 | 				tag_type = self.valid_tags[self.last_opened_element][0]
 557 | 			except KeyError:
 558 | 				try:
 559 | 					tag_type = self.valid_tags['*'][0]
 560 | 				except KeyError:
 561 | 					# WE SHOULD NOT GET IN HERE UNLESS SOMETHING IS WRONG
 562 | 					print "This logic should not trigger, please inform RapydML developers, provide the contents of your .pyml file as well."
 563 | 					raise ParserError("'%s' is not a valid markup tag or method name." % self.last_opened_element)
 564 | 		
 565 | 		if tag_type == NORMAL \
 566 | 		and re.search('^%s</%s>' % (self.tree.indent_to(self.tree.indent), self.last_opened_element), tag):
 567 | 			self.write(' />\n', -2)
 568 | 		elif tag_type != SINGLE or self.last_opened_element is None:
 569 | 			self.write(tag)
 570 | 				
 571 | 	
 572 | 	def set_variable(self, tag):
 573 | 		# sets the variable(s) in the system
 574 | 		vars = tag.split(':=')
 575 | 		if len(vars) == 1:
 576 | 			raise ParserError("You're trying to declare variable %s without assignment" % vars[0].strip())
 577 | 			
 578 | 		text = vars[-1].lstrip()
 579 | 		for var in vars[:-1]:
 580 | 			if var[0] == '$':
 581 | 				self.var_map[var.rstrip()] = self.get_variables(text)
 582 | 			else:
 583 | 				raise ParserError("Illegal assignment to a constant '%s'" % var.rstrip())
 584 | 	
 585 | 	def get_variables(self, tag, ignore_list=[]):
 586 | 		# applies variables from the system to current line
 587 | 		tag = replace_variables(tag, self.var_map, ignore_list)
 588 | 		return self.resolve_indexes(tag) # this converts notation [item1, item2, item3, ...][1] to item2
 589 | 	
 590 | 	def create_method(self, line):
 591 | 		indent = self.tree.find_indent(line) #this should always be zero
 592 | 		if line[:4] == 'def ': # this prevents us from overlooking consecutively declared methods
 593 | 			self.tree.indent = indent
 594 | 			element, attributes = parse_definition(line[4:])
 595 | 			
 596 | 			if element[0] not in string.letters + '_' or not (element.replace('_','').isalnum()):
 597 | 				raise ParserError("Method name must be alphanumeric with underscores and start with a letter or underscore")
 598 | 			
 599 | 			if element in self.valid_tags.keys():
 600 | 				raise ParserError("Can't create method named '%s', it's a reserved markup element name" % element)
 601 | 			
 602 | 			self.creating_method = element
 603 | 			# methods access shadowed variables to prevent overwriting globals
 604 | 			self.method_map[element] = Method(attributes, True, self.color, element)
 605 | 				
 606 | 		else:	# regular line inside a method
 607 | 			if indent == 0:
 608 | 				self.creating_method = None
 609 | 				return True #finished
 610 | 			else:
 611 | 				# check if this is a loop:
 612 | 				if not self.current_verbatim and (self.loop_stack or line.strip()[:4] == 'for '):
 613 | 					self.create_loop(line[len(self.tree.indent_marker):])
 614 | 				else:
 615 | 					if self.need_to_remove_method_vars:
 616 | 						self.need_to_remove_method_vars = False
 617 | 						line = '%s%s(%s)' % (self.tree.indent_to(indent), self.current_verbatim, ', '.join(self.verbatim_vars[GLOBAL_VARS]))
 618 | 				
 619 | 					# add normal line to method sequence
 620 | 					self.method_map[self.creating_method].add_line(line[len(self.tree.indent_marker):], 
 621 | 																self.current_verbatim,
 622 | 																self.verbatim_vars[METHOD_VARS])
 623 | 		return False
 624 | 	
 625 | 	def unroll_loop(self):
 626 | 		loop_token = self.loop_stack.pop()
 627 | 		loop_name = loop_token[0]
 628 | 		loop_indent = loop_token[1]
 629 | 		loop_array = loop_token[2]
 630 | 		self.tree.indent = loop_indent
 631 | 		for arg in loop_array:
 632 | 			loop_call = '%s%s(%s)' % (self.tree.indent_to(loop_indent), loop_name, arg)
 633 | 			if self.creating_method:
 634 | 				self.method_map[self.creating_method].add_line(loop_call)
 635 | 			else:
 636 | 				self.handle_line(loop_call)
 637 | 	
 638 | 	def handle_indent(self, indent, method_name, no_end=False):
 639 | 		if not self.creating_method:
 640 | 			if no_end: 	# happens during template engine one-liners
 641 | 				def noop(arg):
 642 | 					pass
 643 | 				ending_logic = [noop , None]
 644 | 			else:
 645 | 				ending_logic = [self.element_stack.append, method_name]
 646 | 			self.tree.handle_indent(self.tree.indent_to(indent) + '|', \
 647 | 				[self.close_last_element], \
 648 | 				ending_logic)
 649 | 	
 650 | 	def create_loop(self, line):
 651 | 		# we can just piggy-back on create_method, since a loop is essentially a repeated function
 652 | 		# the only tricky part is that loops can be nested
 653 | 		tag = line.strip()
 654 | 		indent = self.tree.find_indent(line)
 655 | 		if tag[:4] == 'for ':	# new loop started (either within old loop, or outside)
 656 | 			self.handle_indent(indent, None)
 657 | 			var = tag.split()[1] #[for,$var,in,...]
 658 | 			if var in self.var_map.keys():
 659 | 				raise ParserError("Can't reuse previously defined variable %s as loop iterator" % var)
 660 | 			
 661 | 			#array = self.get_variables(tag.split('[')[1].split(']')[0]).split(',')
 662 | 			#iterator = re.findall('^for[ ]+(\$[a-zA-Z_][a-zA-Z0-9_]*)[ ]+in', tag)[0]
 663 | 			#array = self.get_variables(tag, [var]).split('[', 1)[1].rsplit(']', 1)[0].split(',')
 664 | 			array = get_attr('(%s)' % self.get_variables(tag, [var]).split('[', 1)[1].rsplit(']', 1)[0])
 665 | 			
 666 | 			for i in range(len(array)):
 667 | 				array[i] = array[i].strip()
 668 | 			loop_name = 'rapydml_loop_def_%s' % self.loop_index
 669 | 			self.loop_stack.append((loop_name, indent, array))
 670 | 			self.method_map[loop_name] = Method([var], False, self.color, loop_name) # loops see/access global var space
 671 | 			self.loop_index += 1
 672 | 		else:					# command inside the loop or outside (loop termination)
 673 | 			loop_name = self.loop_stack[-1][0]
 674 | 			loop_indent = self.loop_stack[-1][1]
 675 | 			indent_diff = indent-loop_indent
 676 | 			if indent_diff < 1:
 677 | 				# loop terminated, unroll it and execute this line as normal
 678 | 				self.unroll_loop()
 679 | 				self.handle_line(line)
 680 | 			else:
 681 | 				self.tree.indent = indent
 682 | 				self.method_map[loop_name].add_line(line[len(self.tree.indent_to(loop_indent+1)):])
 683 | 
 684 | 	def expand_assignment_ops(self, tag, perform=True):
 685 | 		# takes operation of form '$a += 3', converts it to '$a := $a + 3' and evaluates it, assigning new value to $a
 686 | 		result, tag = expand_assignment(tag)
 687 | 		pair = tag.split(':=')
 688 | 		if len(pair) > 2:
 689 | 			raise ParserError("Command '%s' has multiple assignment operators, invalid syntax" % tag)
 690 | 		self.var_map[result] = do_arithmetic(self.get_variables(pair[1].strip()))
 691 | 		return result
 692 | 	
 693 | 	def import_module(self, line):
 694 | 		tokens = line.split()
 695 | 		if len(tokens) != 2 or tokens[0] != 'import':
 696 | 			raise ParserError("Invalid import statement: %s" % line.strip())
 697 | 		
 698 | 		if tokens[1] not in self.imported_files:
 699 | 			try:
 700 | 				self.imported_files.append(tokens[1])
 701 | 				self.parse(tokens[1].replace('.', '/') +'.pyml', True)
 702 | 			except IOError:
 703 | 				# failed importing from working directory, try importing from rapydml directory
 704 | 				cur_dir = os.getcwd()
 705 | 				try:
 706 | 					# we have to rely on __file__, because cwd could be different if invoked by another script
 707 | 					os.chdir(os.path.dirname(__file__))
 708 | 					self.imported_files.append(tokens[1])
 709 | 					self.parse(tokens[1].replace('.', '/') +'.pyml', True)
 710 | 				except IOError:
 711 | 					raise ParserError("Can't import '%s', module doesn't exist" % tokens[1])
 712 | 				finally:
 713 | 					os.chdir(cur_dir)
 714 | 	
 715 | 	def create_template_engine(self, line):
 716 | 		# creates a new set of rules for a templating engine, such as Django, Web2py, or Rails
 717 | 		pair = line.split('=')
 718 | 		if len(pair) != 2:
 719 | 			raise ParserError("Improper TemplateEngine declaration")
 720 | 		elif pair[0].isalnum() and pair[0] not in string.letters:
 721 | 			raise ParserError("TemplateEngine must have alphanumeric name that starts with a letter")
 722 | 		template = pair[1][pair[1].find('(')+1:pair[1].rfind(')')-1].strip().strip("'").strip('"')
 723 | 		self.template_engines[pair[0].rstrip()] = TemplateEngine(template)
 724 | 	
 725 | 	def parse_template_engine_definition(self, line):
 726 | 		compressed = line.replace(' ','')
 727 | 		if compressed.find('create(') != -1:
 728 | 			# add a template to existing template engine
 729 | 			engine, template, method_call, attr = parse_template_engine_method_declaration(line)
 730 | 			try:
 731 | 				if len(attr) == 1:
 732 | 					self.template_engines[engine].add_method(template, attr[0][1:-1])
 733 | 				else:
 734 | 					self.template_engines[engine].add_method(template, attr[0][1:-1], attr[1][1:-1])
 735 | 			except KeyError:
 736 | 				raise ParserError("Attempting to add a method to a TemplateEngine prior to declaration")
 737 | 		else: # append()
 738 | 			# append additional logic to a template
 739 | 			engine, template, method_call, attr = parse_template_engine_method_declaration(line)
 740 | 			original_pair = method_call.split('.') # we only care about 1st 2 args
 741 | 			if len(original_pair) != 3:
 742 | 				raise ParserError("Method being appended to must follow TemplateEngine.MethodName format")
 743 | 			try:
 744 | 				self.template_engines[original_pair[0]].enhance_method(original_pair[1], template)
 745 | 			except KeyError:
 746 | 				raise ParserError("Attempting to append functionality to a non-existing method")
 747 | 			try:
 748 | 				self.template_engines[engine].add_method(template, attr[0][1:-1])
 749 | 			except KeyError:
 750 | 				raise ParserError("Attempting to add a method to a TemplateEngine prior to declaration")
 751 | 		
 752 | 		# helper method for checking if the line involves variable assignment and/or reassignment
 753 | 		if line.find(':=') != -1:
 754 | 			# variable declaration
 755 | 			self.set_variable(line)
 756 | 			return
 757 | 		elif line.find('+=') != -1 or line.find('-=') != -1 or line.find('*=') != -1 or line.find('/=') != -1:
 758 | 			# variable increment
 759 | 			res = self.expand_assignment_ops(line)
 760 | 			line = self.var_map[res]
 761 | 	
 762 | 	def parse_template_engine_call(self, line, indent):
 763 | 		compressed = line.replace(' ','')
 764 | 		try:
 765 | 			# invoke template engine method
 766 | 			if indent is None:
 767 | 				whitespace = ''
 768 | 			else:
 769 | 				whitespace = self.tree.indent_to(indent)
 770 | 			method_pair = line.split('(')[0].rstrip().rsplit('.', 1)
 771 | 			end_method = self.template_engines[method_pair[0]].end_method(method_pair[1])
 772 | 			if indent is not None:
 773 | 				if end_method:
 774 | 					# full-line declaration
 775 | 					ending_tag = whitespace + end_method
 776 | 				else:
 777 | 					# invocation that's a subset of the line
 778 | 					ending_tag = None
 779 | 				self.handle_indent(indent, ending_tag)
 780 | 			if not self.template_engines[method_pair[0]].is_submethod(method_pair[1], indent):
 781 | 				# this is a method created using 'create()'
 782 | 				#end_method = self.template_engines[method_pair[0]].end_method(method_pair[1])
 783 | 				if end_method is None:
 784 | 					if indent is not None:
 785 | 						self.tree.indent = indent
 786 | 				else:
 787 | 					if indent is None:
 788 | 						# this will happen when we try something like:
 789 | 						# div(src=django.for(a, b))
 790 | 						raise ParserError("'%s' method requires a closing tag, it can't be used as part of other logic on the line" % method_pair[1])
 791 | 					#self.handle_indent(indent, whitespace + end_method)
 792 | 			else:
 793 | 				if indent is None:
 794 | 					raise ParserError("Can't use '%s' as part of other logic on the line because it's a branch of an existing method" % method_pair[1])
 795 | 				# this is a sub-method of a verbatim method (i.e. 'else' is a submethod of 'if')
 796 | 				# submethods are created using 'append()'
 797 | 				#note the indent+1, we want to close inner logic, but not the method itself
 798 | 				endtag = self.template_engines[method_pair[0]].end_method(method_pair[1], False)
 799 | 				if endtag is None:
 800 | 					self.handle_indent(indent+1, None)
 801 | 					self.element_stack.pop()
 802 | 				else:
 803 | 					self.handle_indent(indent+1, whitespace + endtag)
 804 | 			attr = get_attr(line)
 805 | 			return whitespace + self.template_engines[method_pair[0]].call_method(method_pair[1], attr, indent)
 806 | 			#self.element_stack.append(whitespace + self.template_engines[method_pair[0]].end_method(method_pair[1]))
 807 | 		#except (KeyError, IndexError, TypeError):
 808 | 		except ParserError:
 809 | 			raise ParserError("Improper TemplateEngine method declaration or invocation")
 810 | 
 811 | 		# repeated from the definition method, rewrite to make the code more DRY
 812 | 		# helper method for checking if the line involves variable assignment and/or reassignment
 813 | 		if line.find(':=') != -1:
 814 | 			# variable declaration
 815 | 			self.set_variable(line)
 816 | 			return
 817 | 		elif line.find('+=') != -1 or line.find('-=') != -1 or line.find('*=') != -1 or line.find('/=') != -1:
 818 | 			# variable increment
 819 | 			res = self.expand_assignment_ops(line)
 820 | 			line = self.var_map[res]
 821 | 	
 822 | 	def handle_verbatim_declaration(self, tag):
 823 | 		assignment_pair = tag.split('=', 1)
 824 | 		newtag = assignment_pair[0].strip()
 825 | 		element, attributes = parse_definition(assignment_pair[1])
 826 | 		length = len(attributes)
 827 | 		
 828 | 		# code_block follows same format as verbatim, but always takes additional argument
 829 | 		if element == 'code_block':
 830 | 			length -= 1
 831 | 			sys_command = attributes.pop()[1:-1]
 832 | 		
 833 | 		if length == 0:
 834 | 			# no args were passed, this version has no outer tags wrapping the text
 835 | 			starttag = endtag = ''
 836 | 		elif length == 1:
 837 | 			# received 1 argument, it's a tag to use as a template
 838 | 			
 839 | 			# TODO: eventually we want this to also check declared methods, if available, first
 840 | 			#if attributes[0] in self.template_engines.keys():
 841 | 			#	endtag = self.template_engines[attributes[0]].tag_format %
 842 | 			#else:
 843 | 			#	endtag = '</%s>\n' % attributes[0]
 844 | 			
 845 | 			tagname, tagattr = parse_definition(attributes[0])
 846 | 			starttag, endtag = create_tag(tagname, tagattr)
 847 | 		elif length == 2:
 848 | 			# received 2 quoted arguments for beginning and end tags
 849 | 			starttag = attributes[0][1:-1] + '\n'
 850 | 			endtag = attributes[1][1:-1] + '\n'
 851 | 		else:
 852 | 			if element == 'code_block':
 853 | 				raise ParserError("Code Block definition takes 1, 2, or 3 arguments, %s arguments were given" % length)
 854 | 			else:
 855 | 				raise ParserError("Verbatim definition takes 0, 1, or 2 arguments, %s arguments were given" % length)
 856 | 		
 857 | 		# append to verbatim format in (start_tag, end_tag, type) format
 858 | 		if element == 'verbatim_line':
 859 | 			self.verbatim[newtag] = (starttag, endtag, SINGLE_LINE)
 860 | 		elif element == 'verbatim':
 861 | 			self.verbatim[newtag] = (starttag, endtag, MULTI_LINE)
 862 | 		else:
 863 | 			self.verbatim[newtag] = (starttag, endtag, CODE_BLOCK, sys_command)
 864 | 	
 865 | 	def handle_verbatim_call(self, line):
 866 | 		indent = self.tree.find_indent(line)
 867 | 		if self.current_verbatim is None:
 868 | 			# this is the first line of verbatim logic
 869 | 			
 870 | 			# set verbatim, get replaceable variables and check that they exist
 871 | 			self.current_verbatim, verbatim_vars = parse_definition(line.strip())
 872 | 			self.verbatim_vars = ([], [])
 873 | 			for variable in verbatim_vars:
 874 | 				try:
 875 | 					self.var_map[variable]
 876 | 					self.verbatim_vars[GLOBAL_VARS].append(variable)
 877 | 				except KeyError:
 878 | 					if self.creating_method \
 879 | 					and (variable in self.method_map[self.creating_method].attributes \
 880 | 					or variable in self.method_map[self.creating_method].local_vars):
 881 | 						self.verbatim_vars[METHOD_VARS].append(variable)
 882 | 						self.need_to_remove_method_vars = True
 883 | 						continue
 884 | 					raise ParserError("Variable '%s' used prior to declaration." % variable)
 885 | 			
 886 | 			self.verbatim_indent = self.tree.find_indent(line)
 887 | 			if not self.creating_method:
 888 | 				self.handle_indent(indent, None)
 889 | 				self.last_opened_element = None
 890 | 				self.element_stack.append(None)
 891 | 		else:
 892 | 			# we're continuing to parse existing verbatim logic
 893 | 			verbatim_properties = self.verbatim[self.current_verbatim]
 894 | 			if indent > self.verbatim_indent:
 895 | 				# still inside verbatim block
 896 | 				if not self.creating_method:
 897 | 					line = line[self.verbatim_indent+1:]
 898 | 				
 899 | 					# plug in the variables, if they appear on this line
 900 | 					for variable in self.verbatim_vars[GLOBAL_VARS]:
 901 | 						line = re.sub(r'\%s(?![A-Za-z0-9_])' % variable, self.var_map[variable], line)
 902 | 					
 903 | 					self.verbatim_buffer += line
 904 | 			else:
 905 | 				# end of verbatim logic
 906 | 				if not self.creating_method:
 907 | 					if verbatim_properties[2] == SINGLE_LINE:
 908 | 						self.verbatim_buffer = re.sub('\n[ 	]*', ' ', self.verbatim_buffer)
 909 | 						self.verbatim_buffer += '\n'
 910 | 					elif verbatim_properties[2] == CODE_BLOCK:
 911 | 						result = Popen('echo %s' % pipes.quote(self.verbatim_buffer) + verbatim_properties[3],
 912 | 										stdout=PIPE, stderr=PIPE, shell=True).communicate()
 913 | 						if result[1]:
 914 | 							raise ShellError("'%s' code_block tag triggered the following OS error: %s" %
 915 | 											(self.current_verbatim, result[1]))
 916 | 						self.verbatim_buffer = result[0] + '\n'
 917 | 					if verbatim_properties[1] != '':
 918 | 						vindent = self.tree.indent_to(self.verbatim_indent)
 919 | 						self.verbatim_buffer = '%s%s%s%s%s' % (\
 920 | 							vindent,
 921 | 							verbatim_properties[0],
 922 | 							self.verbatim_buffer,
 923 | 							vindent,
 924 | 							verbatim_properties[1])
 925 | 					self.write(self.verbatim_buffer)
 926 | 					self.verbatim_buffer = ''
 927 | 					self.close_last_element() # close verbatim element so it does not screw up the stack
 928 | 				self.current_verbatim = None
 929 | 				self.handle_line(line)
 930 | 				return True
 931 | 		return False
 932 | 	
 933 | 	def handle_line(self, line):
 934 | 		indent = self.tree.find_indent(line)
 935 | 		if DEBUG:
 936 | 			print self.element_stack, '|%s|' % self.creating_method, indent, repr(line)
 937 | 		whitespace = self.tree.indent_to(indent)
 938 | 		
 939 | 		#parse the tag
 940 | 		tag = line.strip()
 941 | 		
 942 | 		#if tag[0] == '$' and tag.find(':=') == -1:
 943 | 		#	tag = self.get_variables(tag)
 944 | 		
 945 | 		if self.current_verbatim is not None or \
 946 | 		tag.split('(')[0].strip(':') in self.verbatim.keys():
 947 | 			# verbatim call
 948 | 			if self.loop_stack and tag.split('(')[0].strip(':') in self.verbatim.keys():
 949 | 				# in case verbatim ended a loop, we want to handle that
 950 | 				# we can return right after, since the loop terminator will automatically
 951 | 				# call handle_line() again with verbatim tag
 952 | 				self.create_loop(line)
 953 | 				return
 954 | 			else:
 955 | 				# note: even comments inside verbatim block get treated verbatim
 956 | 				last_line_processed = self.handle_verbatim_call(line)
 957 | 			
 958 | 			# if we're inside method creation, we want to keep going, so this line gets added to
 959 | 			# the method
 960 | 			if not self.creating_method or last_line_processed:
 961 | 				return
 962 | 		elif not tag or tag[0] == '#':
 963 | 			# strip comments and blank lines
 964 | 			return
 965 | 		
 966 | 		line = expand_arrays(line)
 967 | 		tag = line.strip()
 968 | 		
 969 | 		# first check is a quick pre-qualifier to avoid expensive regex, second one avoids
 970 | 		# false positives like: this_is_not_verbatim_call()
 971 | 		if (tag.find('verbatim') != -1 or tag.find('code_block') != -1) \
 972 | 		and re.search(r'\b(verbatim(_line)?|code_block)\b', tag):
 973 | 			# verbatim/code_block declaration
 974 | 			self.handle_verbatim_declaration(tag)
 975 | 			return
 976 | 		elif self.creating_method is None and (self.loop_stack or tag[:4] == 'for '):
 977 | 			# loop
 978 | 			self.create_loop(line)
 979 | 			return
 980 | 		elif self.creating_method is not None or line[:4] == 'def ':
 981 | 			# method definition
 982 | 			finished = self.create_method(line)
 983 | 			if not finished:
 984 | 				return
 985 | 		if tag.find(':=') != -1:
 986 | 			# variable declaration
 987 | 			self.set_variable(tag)
 988 | 			return
 989 | 		elif line.find('+=') != -1 or line.find('-=') != -1 or line.find('*=') != -1 or line.find('/=') != -1:
 990 | 			# variable increment
 991 | 			res = self.expand_assignment_ops(line)
 992 | 			tag = self.var_map[res]
 993 | 		elif line[:7] == 'import ':
 994 | 			# import
 995 | 			self.import_module(line)
 996 | 			return
 997 | 		elif line.find('TemplateEngine') != -1:
 998 | 			# template class declaration
 999 | 			self.create_template_engine(tag)
1000 | 			return
1001 | 		elif tag.find('.') != -1:
1002 | 			if tag.find('python.') != -1:
1003 | 				# use of python method
1004 | 				line = eval_python(line)
1005 | 				tag = line.strip()
1006 | 			
1007 | 			# continue parsing, there could be other instances of '.'
1008 | 			if tag.find('.append(') != -1 or tag.find('create(') != -1:
1009 | 				# template engine declaration
1010 | 				self.parse_template_engine_definition(tag)
1011 | 				return
1012 | 			else:
1013 | 				# this regex will find all occurences of template engine calls in the form of:
1014 | 				# template_engine.template_method(.*)
1015 | 				# as long as the method is not in a string
1016 | 				# and matching the parentheses correctly even if items inside use parentheses, up to 1 level deep
1017 | 				substitutions = re.findall(r'(\b[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*\b%s)' % REGEX_NESTED_PAREN, tag)
1018 | 				if len(substitutions) == 1 and tag.find(substitutions[0][1]) == 0:
1019 | 					line = self.parse_template_engine_call(tag, indent)
1020 | 				else:
1021 | 					for item in substitutions:
1022 | 						pattern = item.replace('(', '\(').replace(')', '\)').replace('.', '\.')
1023 | 						if re.match(r'%s\b%s' % (NOT_SINGLE_QUOTED, pattern), tag) \
1024 | 								and item.split('.')[0] in self.template_engines:
1025 | 							# template method declaration or call
1026 | 							tag = tag.replace(item, self.parse_template_engine_call(item, None).strip('\n'))
1027 | 				
1028 | #				if substitutions:
1029 | #					self.write(line)
1030 | #					return
1031 | 		elif line == EOF_MARKER:
1032 | 			return
1033 | 		
1034 | 		tag = self.get_variables(tag)
1035 | 		
1036 | 		if tag[0] in ('"', "'"):
1037 | 			# handle quoted strings as plain-text
1038 | 			starttag = tag[1:-1] + '\n'
1039 | 			element = None
1040 | 			htmlend = None
1041 | 		else:
1042 | 			# test if this tag is a method call, if so execute it
1043 | 			element, attributes = parse_definition(tag)
1044 | 			if element in self.method_map.keys():
1045 | 				self.handle_indent(indent, None)
1046 | 				for method_line in self.method_map[element].run_method(attributes, self.var_map):
1047 | 					if method_line is not None:
1048 | 						self.handle_line(whitespace+method_line)
1049 | 				return
1050 | 			else:
1051 | 				# this is a regular tag, not a method, let's make sure the element and attributes are valid
1052 | 				try:
1053 | 					self.valid_tags[element]
1054 | 					hash_key = element
1055 | 				except KeyError:
1056 | 					try:
1057 | 						self.valid_tags['*'] # if we can't access this, wildcard element was not declared
1058 | 						hash_key = '*'
1059 | 					except KeyError:
1060 | 						raise ParserError("'%s' is not a valid markup tag or method name." % element)
1061 | 				
1062 | 				if self.valid_tags[hash_key][1] is not None:
1063 | 					for attr in attributes:
1064 | 						attr_name = attr.split('=', 1)[0]
1065 | 						if attr_name not in self.valid_tags[hash_key][1]:
1066 | 							raise ParserError("'%s' is not one of allowed attributes for '%s' element" % (attr_name, hash_key))
1067 | 		
1068 | 			starttag, endtag = create_tag(element, attributes)
1069 | 			htmlend = whitespace + endtag
1070 | 		
1071 | 		# check indent difference, close old tags if indent < 1
1072 | 		self.handle_indent(indent, htmlend)
1073 | 		
1074 | 		# update variables
1075 | 		self.last_opened_element = element
1076 | 		
1077 | 		# dump the current line to file
1078 | 		self.write(whitespace + starttag)
1079 | 	
1080 | 	def parse(self, filename, module=False):
1081 | 		# we assume here that the file is relatively small compared to our allowed buffer
1082 | 		if not module:
1083 | 			self.__init__(self.valid_tags) #reset
1084 | 			os.chdir(os.path.abspath(os.path.dirname(filename)))
1085 | 		line_num = 0
1086 | 		with open(filename, 'r') as source:
1087 | 			buffer = ''
1088 | 			for line in source:
1089 | 				line_num += 1
1090 | 				try:
1091 | 					#parse multi-lines together
1092 | 					#ignore extra spaces after '\' at the line end 
1093 | 					if line.rstrip()[-1:] == '\\':
1094 | 						if buffer:
1095 | 							line = ' ' + line.lstrip()
1096 | 						buffer += line.rstrip()[:-1]
1097 | 						continue
1098 | 					elif buffer:
1099 | 						line = buffer + ' ' + line.lstrip()
1100 | 						buffer = ''
1101 | 					
1102 | 					self.handle_line(line)
1103 | 				except (ParserError, ShellError) as error:
1104 | 					if DEBUG:
1105 | 						self.get_debug_state()
1106 | 						raise error
1107 | 					print "Error in %s: line %d: %s" % (filename, line_num, error.message)
1108 | 					print repr(line)
1109 | 					sys.exit()
1110 | 				except:
1111 | 					# on all other errors
1112 | 					if DEBUG:
1113 | 						self.get_debug_state()
1114 | 					print "Error in %s: line %d: %s" % (filename, line_num, "'%s' caused the following uncaught exception:" % line.strip())
1115 | 					print repr(line)
1116 | 					raise
1117 | 		
1118 | 		# terminate non-finished loops and pop off remaining elements, closing our HTML tags
1119 | 		if self.current_verbatim is not None:
1120 | 			self.handle_verbatim_call(EOF_MARKER)
1121 | 		if self.creating_method is not None:
1122 | 			self.create_method(EOF_MARKER)
1123 | 		while self.loop_stack:
1124 | 			self.unroll_loop()
1125 | 		while self.element_stack:
1126 | 			self.close_last_element()
1127 | 		return self.output
1128 | 


--------------------------------------------------------------------------------
/rapydml/html_colors.txt:
--------------------------------------------------------------------------------
  1 | aliceblue:f0f8ff
  2 | antiquewhite:faebd7
  3 | aqua:00ffff
  4 | aquamarine:7fffd4
  5 | azure:f0ffff
  6 | beige:f5f5dc
  7 | bisque:ffe4c4
  8 | black:000000
  9 | blanchedalmond:ffebcd
 10 | blue:0000ff
 11 | blueviolet:8a2be2
 12 | brown:a52a2a
 13 | burlywood:deb887
 14 | cadetblue:5f9ea0
 15 | chartreuse:7fff00
 16 | chocolate:d2691e
 17 | coral:ff7f50
 18 | cornflowerblue:6495ed
 19 | cornsilk:fff8dc
 20 | crimson:dc143c
 21 | cyan:00ffff
 22 | darkblue:00008b
 23 | darkcyan:008b8b
 24 | darkgoldenrod:b8860b
 25 | darkgray:a9a9a9
 26 | darkgrey:a9a9a9
 27 | darkgreen:006400
 28 | darkkhaki:bdb76b
 29 | darkmagenta:8b008b
 30 | darkolivegreen:556b2f
 31 | darkorange:ff8c00
 32 | darkorchid:9932cc
 33 | darkred:8b0000
 34 | darksalmon:e9967a
 35 | darkseagreen:8fbc8f
 36 | darkslateblue:483d8b
 37 | darkslategray:2f4f4f
 38 | darkslategrey:2f4f4f
 39 | darkturquoise:00ced1
 40 | darkviolet:9400d3
 41 | deeppink:ff1493
 42 | deepskyblue:00bfff
 43 | dimgray:696969
 44 | dimgrey:696969
 45 | dodgerblue:1e90ff
 46 | firebrick:b22222
 47 | floralwhite:fffaf0
 48 | forestgreen:228b22
 49 | fuchsia:ff00ff
 50 | gainsboro:dcdcdc
 51 | ghostwhite:f8f8ff
 52 | gold:ffd700
 53 | goldenrod:daa520
 54 | gray:808080
 55 | grey:808080
 56 | green:008000
 57 | greenyellow:adff2f
 58 | honeydew:f0fff0
 59 | hotpink:ff69b4
 60 | indianred:cd5c5c
 61 | indigo:4b0082
 62 | ivory:fffff0
 63 | khaki:f0e68c
 64 | lavender:e6e6fa
 65 | lavenderblush:fff0f5
 66 | lawngreen:7cfc00
 67 | lemonchiffon:fffacd
 68 | lightblue:add8e6
 69 | lightcoral:f08080
 70 | lightcyan:e0ffff
 71 | lightgoldenrodyellow:fafad2
 72 | lightgray:d3d3d3
 73 | lightgrey:d3d3d3
 74 | lightgreen:90ee90
 75 | lightpink:ffb6c1
 76 | lightsalmon:ffa07a
 77 | lightseagreen:20b2aa
 78 | lightskyblue:87cefa
 79 | lightslategray:778899
 80 | lightslategrey:778899
 81 | lightsteelblue:b0c4de
 82 | lightyellow:ffffe0
 83 | lime:00ff00
 84 | limegreen:32cd32
 85 | linen:faf0e6
 86 | magenta:ff00ff
 87 | maroon:800000
 88 | mediumaquamarine:66cdaa
 89 | mediumblue:0000cd
 90 | mediumorchid:ba55d3
 91 | mediumpurple:9370d8
 92 | mediumseagreen:3cb371
 93 | mediumslateblue:7b68ee
 94 | mediumspringgreen:00fa9a
 95 | mediumturquoise:48d1cc
 96 | mediumvioletred:c71585
 97 | midnightblue:191970
 98 | mintcream:f5fffa
 99 | mistyrose:ffe4e1
100 | moccasin:ffe4b5
101 | navajowhite:ffdead
102 | navy:000080
103 | oldlace:fdf5e6
104 | olive:808000
105 | olivedrab:6b8e23
106 | orange:ffa500
107 | orangered:ff4500
108 | orchid:da70d6
109 | palegoldenrod:eee8aa
110 | palegreen:98fb98
111 | paleturquoise:afeeee
112 | palevioletred:d87093
113 | papayawhip:ffefd5
114 | peachpuff:ffdab9
115 | peru:cd853f
116 | pink:ffc0cb
117 | plum:dda0dd
118 | powderblue:b0e0e6
119 | purple:800080
120 | red:ff0000
121 | rosybrown:bc8f8f
122 | royalblue:4169e1
123 | saddlebrown:8b4513
124 | salmon:fa8072
125 | sandybrown:f4a460
126 | seagreen:2e8b57
127 | seashell:fff5ee
128 | sienna:a0522d
129 | silver:c0c0c0
130 | skyblue:87ceeb
131 | slateblue:6a5acd
132 | slategray:708090
133 | slategrey:708090
134 | snow:fffafa
135 | springgreen:00ff7f
136 | steelblue:4682b4
137 | tan:d2b48c
138 | teal:008080
139 | thistle:d8bfd8
140 | tomato:ff6347
141 | turquoise:40e0d0
142 | violet:ee82ee
143 | wheat:f5deb3
144 | white:ffffff
145 | whitesmoke:f5f5f5
146 | yellow:ffff00
147 | yellowgreen:9acd32
148 | 


--------------------------------------------------------------------------------
/rapydml/lib/common.pyml:
--------------------------------------------------------------------------------
1 | text = verbatim_line(p)
2 | javascript = verbatim(script(type='text/javascript'))
3 | rapydscript = code_block(script(type='text/javascript'), ' > /tmp/tmpfile.pyj && rapydscript /tmp/tmpfile.pyj && cat /tmp/tmpfile.js')
4 | 


--------------------------------------------------------------------------------
/rapydml/lib/django.pyml:
--------------------------------------------------------------------------------
 1 | # DJANGO Template Engine
 2 | #
 3 | # This is a template engine for basic Django logic. A lot of the same logic can be reused to 
 4 | # create template engines for other markup.
 5 | 
 6 | django = TemplateEngine('{%s}')
 7 | 
 8 | # logic we didn't account for: django.do("items = ['a', 'b', 'c']") -> {% items = ['a', 'b', 'c'] %}
 9 | django.do = create('%% %s %%')
10 | 
11 | # basic
12 | # extend logic
13 | # variables: django.var(a) -> {{a}}
14 | # output: django.print(item) -> {%= item %}
15 | django.extend = create('%% extends %s %%')
16 | django.var = create('{%s}')
17 | django.print = create('%%= %s %%')
18 | 
19 | # loops
20 | django.for = create('%% for %s in %s %%', '% endfor %')
21 | django.while = create('%% while %s %%', '% endwhile %')
22 | 
23 | # if statements
24 | django.if = create('%% if %s %%', '% endif %')
25 | django.elif = django.if.append('%% elif %s %%')
26 | django.else = django.if.append('% else %')
27 | 
28 | # other
29 | django.block = create('%% block %s %%', '% endblock %')
30 | 


--------------------------------------------------------------------------------
/rapydml/lib/jinja2.pyml:
--------------------------------------------------------------------------------
1 | # JINJA2 Template Engine
2 | 
3 | jinja2 = TemplateEngine('{%s}')
4 | 
5 | jinja2.extends = create('%% extends %s %%')
6 | 
7 | jinja2.block = create('%% block %s %%', '% endblock %')
8 | 


--------------------------------------------------------------------------------
/rapydml/lib/rails.pyml:
--------------------------------------------------------------------------------
 1 | # Ruby on Rails Template Engine
 2 | #
 3 | # This is a template engine for basic rails logic. A lot of the same logic can be reused to 
 4 | # create template engines for other markup, such as Django and Rails
 5 | 
 6 | rails = TemplateEngine('<%%%s%%>')
 7 | 
 8 | # logic we didn't account for: rails.do("items = ['a', 'b', 'c']") -> <% items = ['a', 'b', 'c'] %>
 9 | rails.do = create(' %s ')
10 | 
11 | # basic
12 | # output: rails.print('item') -> <%= item %>
13 | # extend logic
14 | rails.print = create('= %s ')
15 | rails.render = create('= render %s ')
16 | 
17 | # loops
18 | rails.for = create(' for %s in %s ', ' end ')
19 | rails.while = create(' while %s ', ' end ')
20 | rails.each = create(' %s.each do |%s| ', ' end ')
21 | 
22 | # if statements
23 | rails.if = create(' if %s ', ' end ')
24 | rails.elif = rails.if.append(' elsif %s ')
25 | rails.else = rails.if.append(' else ')
26 | 
27 | 
28 | 


--------------------------------------------------------------------------------
/rapydml/lib/web2py.pyml:
--------------------------------------------------------------------------------
 1 | # WEB2PY Template Engine
 2 | #
 3 | # This is a template engine for basic web2py logic. A lot of the same logic can be reused to 
 4 | # create template engines for other markup, such as Django and Rails
 5 | 
 6 | web2py = TemplateEngine('{{%s}}')
 7 | 
 8 | # logic we didn't account for: web2py.do("items = ['a', 'b', 'c']") -> {{items = ['a', 'b', 'c']}}
 9 | web2py.do = create('%s')
10 | 
11 | # basic
12 | # output: web2py.print('item') -> {{=item}}
13 | # extend logic
14 | web2py.print = create('=%s')
15 | web2py.extend = create('extend %s')
16 | 
17 | # loops
18 | web2py.for = create('for %s in %s:', 'pass')
19 | web2py.while = create('while %s:', 'pass')
20 | 
21 | # if statements
22 | web2py.if = create('if %s:', 'pass')
23 | web2py.elif = web2py.if.append('elif %s:')
24 | web2py.else = web2py.if.append('else:')
25 | 
26 | # try blocks
27 | web2py.try = create('try:', 'pass')
28 | web2py.except = web2py.try.append('except %s:')
29 | 
30 | 


--------------------------------------------------------------------------------
/rapydml/markup/any:
--------------------------------------------------------------------------------
 1 | # Markup with no restrictions
 2 | #
 3 | # This markup allows you to use any elements/tags and any attributes. This template is meant for experimenting with your files and
 4 | # I don't recommend using it as your main template. Note that wildcard tag is independent of wilcard attribute character. You can
 5 | # do each of the following for example:
 6 | #
 7 | #	<*>		*		# places no restrictions on allowed elements or attributes (everything that wasn't explicitly declared as a
 8 | #					# method will be treated as an element tag)
 9 | #	<foo>	*		# only allows `foo` element tag, but places no restrictions on usable attributes
10 | #	<*>		bar		# allows you to use any element tag name, but the only supported attribute for your elements is `bar`
11 | #	<foo>	bar		# only allows `foo` element tag, only allows `bar` attribute for it 	
12 | #	<*>				# places no restrictions on allowed elements, but does not allow any attributes
13 | #
14 | # Read html5 markup file for more information on markup template layout
15 | 
16 | <*> *
17 | 


--------------------------------------------------------------------------------
/rapydml/markup/html:
--------------------------------------------------------------------------------
  1 | # HTML markup definitions
  2 | #
  3 | # This is a lax HTML markup, and should be able to parse any HTML page (regardless of version), it does not enforce
  4 | # any attributes on the element tags.
  5 | #
  6 | # Read html5 markup file for more information on markup template layout
  7 | 
  8 | <!doctype>- *
  9 | <!DOCTYPE>- *
 10 | <a>+ *
 11 | <abbr> *
 12 | <acronym> *
 13 | <address> *
 14 | <applet> *
 15 | <area> *
 16 | <article> *
 17 | <aside> *
 18 | <audio> *
 19 | <b> *
 20 | <base> *
 21 | <basefont> *
 22 | <bdi> *
 23 | <bdo> *
 24 | <big> *
 25 | <blockquote> *
 26 | <body> *
 27 | <br> *
 28 | <button> *
 29 | <canvas>+ *
 30 | <caption> *
 31 | <center> *
 32 | <cite> *
 33 | <code> *
 34 | <col> *
 35 | <colgroup> *
 36 | <command> *
 37 | <datalist> *
 38 | <dd> *
 39 | <del> *
 40 | <details> *
 41 | <dfn> *
 42 | <div>+ *
 43 | <dl> *
 44 | <dt> *
 45 | <em> *
 46 | <embed> *
 47 | <fieldset> *
 48 | <figcaption> *
 49 | <figure> *
 50 | <font> *
 51 | <footer> *
 52 | <form> *
 53 | <frame> *
 54 | <frameset> *
 55 | <h1> *
 56 | <h2> *
 57 | <h3> *
 58 | <h4> *
 59 | <h5> *
 60 | <h6> *
 61 | <head> *
 62 | <header> *
 63 | <hgroup> *
 64 | <hr> *
 65 | <html> *
 66 | <i> *
 67 | <iframe>+ *
 68 | <img> *
 69 | <input> *
 70 | <ins> *
 71 | <kbd> *
 72 | <keygen> *
 73 | <label> *
 74 | <legend> *
 75 | <li> *
 76 | <link> *
 77 | <map> *
 78 | <mark> *
 79 | <menu> *
 80 | <meta> *
 81 | <meter> *
 82 | <nav> *
 83 | <noscript> *
 84 | <object> *
 85 | <ol> *
 86 | <optgroup> *
 87 | <option> *
 88 | <output> *
 89 | <p> *
 90 | <param> *
 91 | <pre> *
 92 | <progress> *
 93 | <q> *
 94 | <rp> *
 95 | <rt> *
 96 | <ruby> *
 97 | <s> *
 98 | <samp> *
 99 | <script>+ *
100 | <section> *
101 | <select> *
102 | <small> *
103 | <source> *
104 | <span> *
105 | <strike> *
106 | <strong> *
107 | <style> *
108 | <sub> *
109 | <summary> *
110 | <sup> *
111 | <svg> *
112 | <table> *
113 | <tbody> *
114 | <td> *
115 | <textarea>+ *
116 | <tfoot> *
117 | <th> *
118 | <thead> *
119 | <time> *
120 | <title> *
121 | <tr> *
122 | <track> *
123 | <tt> *
124 | <u> *
125 | <ul>+ *
126 | <var> *
127 | <video> *
128 | <wbr> *
129 | 


--------------------------------------------------------------------------------
/rapydml/markup/html5:
--------------------------------------------------------------------------------
  1 | # HTML5 markup definitions
  2 | # 
  3 | # This template defines valid tags and attributes for HTML5, using similar structure you can create markup for other *ML as well,
  4 | # such as XML, SVG, etc. Note, there are tags and attributes that are valid HTML, but are not included in this document since 
  5 | # their support was dropped in HTML5. If you want to use them, I suggest creating a new file for HTML4. This is a strict HTML5
  6 | # markup, use 'markup/html' for more lax HTML markup. This grammar uses <*> for intermediate nodes, that's not a requirement, a 
  7 | # regular tag node does not need to be a leaf node, but this makes the attribute grouping less confusing.
  8 | # 
  9 | # Rules:
 10 | #	- each line has to follow the following format (where whitespace can be spaces or tabs):
 11 | #		<tagname>	allowedattr1, allowedattr2, ...
 12 | #		example:	<canvas>	height, width
 13 | #	- indentation is used to define child nodes, child nodes inherit allowed attributes from their parents
 14 | #		example:
 15 | #			<col>	span
 16 | #				<colgroup>
 17 | #	#	- marks beginning of a comment
 18 | #		example:	# this is a comment
 19 | #	\	- when used at the end of the line, concatenates next line with current line, removing leading whitespace from next line
 20 | #		example:
 21 | #			<*>		attr1, attr2, attr3, \
 22 | #					attr4, attr5
 23 | #	<.>	- marks an internal node/tag, this node can't be used directly, but passes a set of usable attributes to its child tags,
 24 | #		this should not be a leaf node.
 25 | #		example:	<.>	disabled, form, name
 26 | #						<input>
 27 | #						<button>
 28 | #	*	- if used instead of attributes, removes any argument restrictions from this tag
 29 | #		example:	<a>	*
 30 | #	+	- force this element to never use shorthand close: <div> allows <div />, <div>+ always forces <div></div>
 31 | #		example:	<canvas>+
 32 | #	-	- force this element to never use close tag, note that adding children under this element in your .pyml file will trigger an error
 33 | #		example:	<!DOCTYPE>-
 34 | #	- you can repeat the same tag multiple times, this is typically useful when it reuses same attributes as multiple other tags,
 35 | #	yet those other tags don't share attributes. Note that when using + or - tag modifiers, the first occurence of the tag will be used
 36 | #	for deciding the element/tag modifier. The rest will be ignored.
 37 | #		example:
 38 | #			<canvas>	height, width
 39 | #				<input>	alt, src
 40 | #			<button>	disabled, type, value
 41 | #				<input>
 42 | #	<*>	- a special tag, its presence means that omitted tags are allowed in pyml as well (and will automatically be inferred to
 43 | #		use <tag></tag> format. Without this tag, RapydML will complain about any tags not specifically mentioned in the markup
 44 | #		file.
 45 | #		example:	<*> attr1, attr2	# allows any element name as long as only attr1 or attr2 attributes are used
 46 | 
 47 | <!doctype>-	*
 48 | <!DOCTYPE>- *
 49 | # global attributes
 50 | <.>	accesskey, class, contenteditable, contextmenu, dir, draggable, dropzone, hidden, id, lang, spellcheck, style, tabindex, title
 51 | 	# global event attributes
 52 | 	<.>	onblur, onchange, oncontextmenu, onfocus, onformchange, onforminput, oninput, oninvalid, onselect, onsubmit, \
 53 | 		onkeydown, onkeypress, onkeyup, \
 54 | 		onclick, ondblclick, ondrag, ondragend, ondragenter, ondragleave, ondragover, ondragstart, ondrop, onmousedown, \
 55 | 		onmousemove, onmouseout, onmouseover, onmouseup, onmousewheel, onscroll, \
 56 | 		onabort, oncanplay, oncanplaythrough, ondurationchange, onemptied, onended, onerror, onloadeddata, onloadedmetadata, \
 57 | 		onloadstart, onpause, onplay, onplaying, onprogress, onratechange, \
 58 | 		onreadystatechange, onseeked, onseeking, onstalled, onsuspend, ontimeupdate, onvolumechange, onwaiting
 59 | 		<.> media, type
 60 | 			<.>	href, hreflang, rel, target
 61 | 				<a>+
 62 | 				<area>	alt, coords, shape
 63 | 				<link>	sizes
 64 | 			<source>	src
 65 | 			<style>		scoped
 66 | 		<abbr>
 67 | 		<address>
 68 | 		<article>
 69 | 		<aside>
 70 | 		<.>	autoplay, controls, loop, preload, src
 71 | 			<audio>
 72 | 			<video>		muted, poster
 73 | 		<b>
 74 | 		<bdi>
 75 | 		<bdo>			dir
 76 | 		<blockquote>	cite
 77 | 		<body>	onafterprint, onbeforeprtint, onbeforeunload, onerror, onhaschange, onload, onmessage, onoffline, ononline, \
 78 | 				onpagehide, onpageshow, onpopstate, onredo, onresize, onstorage, onundo, onunload
 79 | 		<br>
 80 | 		<.>	disabled, form, name
 81 | 			<.>	autofocus
 82 | 				<keygen>		challenge, keytype
 83 | 				<select>		multiple, size
 84 | 				<.>	formaction, formenctype, formmethod, formnovalidate, formtarget, type, value
 85 | 					<button>
 86 | 					<input>		accept, alt, autocomplete, checked, list, multiple, pattern, size, step
 87 | 				<.>	maxlength, placeholder, readonly, required
 88 | 					<input>
 89 | 					<textarea>+	cols, rows, wrap
 90 | 			<fieldset>
 91 | 		<.>	height, width
 92 | 			<canvas>+
 93 | 			<.>	src
 94 | 				<embed>		type
 95 | 				<iframe>+	name, sandbox, seamless, srcdoc
 96 | 				<img>		alt, crossorigin, ismap, usemap
 97 | 				<input>
 98 | 			<object>	data, form, name, type, usemap
 99 | 			<video>
100 | 		<caption>
101 | 		<cite>
102 | 		<code>
103 | 		<.>	span
104 | 			<col>
105 | 			<colgroup>
106 | 		<.>	disabled, label
107 | 			<command>	checked, icon, radiogroup, type
108 | 			<optgroup>
109 | 			<option>	selected, value
110 | 		<datalist>
111 | 		<dd>
112 | 		<.>	cite
113 | 			<.>	datetime
114 | 				<del>
115 | 				<ins>
116 | 			<q>
117 | 		<details>	open
118 | 		<dfn>
119 | 		<div>+
120 | 		<dl>
121 | 		<dt>
122 | 		<em>
123 | 		<figcaption>
124 | 		<figure>
125 | 		<footer>
126 | 		<form>		accept-charset, action, autocomplete, enctype, method, name, novalidate, target
127 | 		<h1>
128 | 		<h2>
129 | 		<h3>
130 | 		<h4>
131 | 		<h5>
132 | 		<h6>
133 | 		<header>
134 | 		<hgroup>
135 | 		<hr>
136 | 		<i>
137 | 		<.>	max, min
138 | 			<input>
139 | 			<meter>	form, high, low, optimum, value
140 | 		<kbd>
141 | 		<.>	for, form
142 | 			<label>
143 | 			<output>	name
144 | 		<legend>
145 | 		<li>		value
146 | 		<map>		name
147 | 		<mark>
148 | 		<menu>		label, type
149 | 		<nav>
150 | 		<ol>		reversed, start, type
151 | 		<p>
152 | 		<param>		name, value
153 | 		<pre>
154 | 		<progress>	max, value
155 | 		<rp>
156 | 		<rt>
157 | 		<ruby>
158 | 		<s>
159 | 		<samp>
160 | 		<script>+	async, charset, defer, src, type
161 | 		<section>
162 | 		<small>
163 | 		<span>
164 | 		<strong>
165 | 		<sub>
166 | 		<summary>
167 | 		<sup>
168 | 		<table>		border
169 | 		<tbody>
170 | 		<.>	colspan, headers, rowspan
171 | 			<td>
172 | 			<th>	scope
173 | 		<tfoot>
174 | 		<thead>
175 | 		<time>		datetime, pubdate
176 | 		<tr>
177 | 		<track>		default, kind, label, src, srclang
178 | 		<u>
179 | 		<ul>+
180 | 		<var>
181 | 		<wbr>
182 | 	<base>	href, target
183 | 	<head>
184 | 	<html>	manifest
185 | 	<meta>	charset, content, http-equiv, name
186 | 	<noscript>
187 | 	<title>
188 | 


--------------------------------------------------------------------------------
/rapydml/markuploader.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from util import IndentParser
  3 | 
  4 | 
  5 | # close tag flag
  6 | NORMAL	= 0
  7 | SEPARATE= 1
  8 | SINGLE	= 2
  9 | 
 10 | def flatten_list(l):
 11 | 	# takes a list of lists and returns a single list
 12 | 	return [item for sublist in l for item in sublist]
 13 | 
 14 | def uniq(l):
 15 | 	# remove duplicates from a list
 16 | 	seen = set()
 17 | 	seen_add = seen.add
 18 | 	return [item for item in l if item not in seen and not seen_add(item)]
 19 | 
 20 | class LineParser:
 21 | 	def __init__(self):
 22 | 		self.attr_stack = []
 23 | 		self.tree = IndentParser()
 24 | 	
 25 | 	def parse_line(self, line):
 26 | 		# takes a line in '' format and returns key, value pair, where the value is a tuple of flags and an
 27 | 		# array of allowed attributes
 28 | 		
 29 | 		# separate tag and attributes into a list (flattening out any intermediate lists)
 30 | 		# this will create the following list:
 31 | 		# ['<tag>', attr1, attr2, attr3]
 32 | 		key_val = flatten_list([item.strip(',').split(',') for item in line.strip().split()])
 33 | 		
 34 | 		# set correct flag and tag
 35 | 		element = key_val.pop(0)
 36 | 		modifier = element[-1]
 37 | 		if modifier == '-':
 38 | 			flag = SINGLE
 39 | 			element = element[1:-2]
 40 | 		elif modifier == '+':
 41 | 			flag = SEPARATE
 42 | 			element = element[1:-2]
 43 | 		else:
 44 | 			flag = NORMAL
 45 | 			element = element[1:-1]
 46 | 		
 47 | 		# push and pop from the stack as needed
 48 | 		self.tree.handle_indent(line, [self.attr_stack.pop], [self.attr_stack.append, key_val])
 49 | 		
 50 | 		if element == '.':	# meta-node, innacessible to the pyml file
 51 | 			return None, None
 52 | 		else:
 53 | 			attrs = uniq(flatten_list(self.attr_stack))
 54 | 			if '*' in attrs:
 55 | 				attrs = None
 56 | 			return element, (flag, attrs)
 57 | 		
 58 | 
 59 | def load(markup, location=None):
 60 | 	# take markup and open the relevant file, reading data from it
 61 | 	# returns a hash of tags and their allowed attributes
 62 | 	# each entry follows this format:
 63 | 	#	key	->	([flags], [attrlist])
 64 | 	#		attrlist is an empty list if no attributes are supported, attrlist is None if any attributes are supported
 65 | 	
 66 | 	# convert markup to filename
 67 | 	if location is None:
 68 | 		location = os.getcwd()
 69 | 	filename = os.path.join(location, 'markup', markup)
 70 | 	
 71 | 	# start scanning the rules
 72 | 	buffer = ''
 73 | 	html_tags = {}
 74 | 	parser = LineParser()
 75 | 	with open(filename, 'r') as lang_rules:
 76 | 		for line in lang_rules:
 77 | 			
 78 | 			# remove comments:
 79 | 			line = line.split('#')[0].rstrip()
 80 | 			
 81 | 			# ignore blank lines
 82 | 			if not line.strip():
 83 | 				continue
 84 | 			
 85 | 			# handle multi-lines
 86 | 			if buffer:
 87 | 				line = ' '+line.lstrip()
 88 | 			if line[-1] == '\\':
 89 | 				buffer += line[:-1]
 90 | 			else:
 91 | 				key, val = parser.parse_line(buffer + line)
 92 | 				if key is not None:
 93 | 					try:
 94 | 						html_tags[key][1].extend(val[1])
 95 | 					except KeyError:
 96 | 						html_tags[key] = val
 97 | 				buffer = ''
 98 | 	return html_tags
 99 | 			
100 | 


--------------------------------------------------------------------------------
/rapydml/util.py:
--------------------------------------------------------------------------------
 1 | class ParserError(Exception):
 2 | 	"""
 3 | 	Helper class for standardizing error messages
 4 | 	"""
 5 | 	
 6 | 	def __init__(self, message):
 7 | 		self.message = message
 8 | 	
 9 | 	def __str__(self):
10 | 		return self.message
11 | 
12 | class ShellError(ParserError):
13 | 	"""
14 | 	Helper class for OS-generated error messages when using code_block
15 | 	"""
16 | 	pass
17 | 
18 | class IndentParser:
19 | 	def __init__(self):
20 | 		self.indent = 0
21 | 		self.indent_marker = None
22 | 		self.no_stack = True
23 | 	
24 | 	def find_indent(self, line):
25 | 		# return the indentation level for current line
26 | 		if line[0] not in ('\t', ' '):
27 | 			return 0
28 | 		indent = line[:len(line)-len(line.lstrip())]
29 | 		
30 | 		# if this is the first time we see an indent, make this our template
31 | 		if self.indent_marker is None:
32 | 			self.indent_marker = indent
33 | 			return 1
34 | 		return len(indent)/len(self.indent_marker) # we assume uniform whitespace here
35 | 	
36 | 	def handle_indent(self, line, dedent_callback, indent_callback):
37 | 		# dedent_callback and indent_callback are in [funcptr, arg1, arg2, ...] format
38 | 		indent = self.find_indent(line)
39 | 		indent_diff = indent - self.indent
40 | 		# push to or pop from the stack, depending on indent
41 | 		if indent_diff < 1 and not self.no_stack: #pop
42 | 			while indent_diff < 1:
43 | 				dedent_callback[0](*dedent_callback[1:])
44 | 				indent_diff += 1
45 | 		elif indent_diff > 1:
46 | 			raise ParserError('Incorrect indentation')
47 | 		indent_callback[0](*indent_callback[1:])
48 | 		self.no_stack = False
49 | 		self.indent = indent
50 | 	
51 | 	def indent_to(self, num):
52 | 		# return indentation of requested size
53 | 		if num == 0:
54 | 			return ''
55 | 		else:
56 | 			return self.indent_marker * num
57 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | from setuptools import setup, find_packages
 2 | 
 3 | DESCRIPTION = 'Python-based XML/HTML Compiler'
 4 | 
 5 | LONG_DESCRIPTION = """
 6 | RapydML
 7 | ===========
 8 | 
 9 | RapydML is a Pythonic abstraction of XML/HTML, adding more 
10 | functionality, ability to easily integrate it with any HTML
11 | templating framework, and create your own subset of XML whose
12 | rules will be enforced through RapydML compiler.
13 | 
14 | 
15 | Installation
16 | ------------
17 | To install RapydML simply use easy_install or pip:
18 | 
19 |     pip install rapydml
20 | 
21 | or
22 | 
23 |     easy_install rapydml
24 | 
25 | 
26 | License
27 | -------
28 | The project is GPLv3, but the output is license free. 
29 | See http://www.gnu.org/licenses/gpl-faq.html#WhatCaseIsOutputGPL.
30 | 
31 | """
32 | 
33 | setup(name='rapydml',
34 |       version='0.0.1',
35 |       packages=['rapydml'],
36 |       package_data={'rapydml': ['*.txt', 'lib/*', 'markup/*']},
37 |       author='Alexander Tsepkov',
38 |       url='http://rapydml.pyjeon.com',
39 |       description=DESCRIPTION,
40 |       long_description=LONG_DESCRIPTION,
41 |       platforms=['any'],
42 |       license='GNU GPL3',
43 |       install_requires=[],
44 |       scripts=['bin/rapydml']
45 | )
46 | 
47 | 


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