Merge recent changes from the master branch into element_parser branch

hamlpy/__init__.py

@@ -1,4 +1 @@
-try:
-    import templatize
-except ImportError:
-    pass
+import templatize

hamlpy/attribute_dict_parser.py

@@ -7,24 +7,24 @@
 re_whitespace = re.compile(r'([ \t]+)')
 re_leading_spaces = re.compile(r'^\s+', re.MULTILINE)
 re_line = re.compile(r'.*')
-re_sq= re.compile(r'(.*?)(?<!\\)(?:\')')
-re_dq= re.compile(r'(.*?)(?<!\\)(?:")')
+re_sq = re.compile(r'\'([^\'\\]|\\.)*\'')
+re_dq = re.compile(r'\"([^\"\\]|\\.)*\"')
 
 class AttributeParser:
     """Parses comma-separated HamlPy attribute values"""
-    
+
     def __init__(self, data, terminator):
         self.terminator=terminator
         self.s = data.lstrip()
         self.length=len(self.s)
         # Index of current character being read
         self.ptr=1
 
-    
+
     def consume_whitespace(self, include_newlines=False):
         """Moves the pointer to the next non-whitespace character"""
         whitespace = (' ', '\t', '\r', '\n') if include_newlines else (' ', '\t')
-        
+
         while self.ptr<self.length and self.s[self.ptr] in whitespace:
             self.ptr+=1
         return self.ptr
@@ -34,7 +34,8 @@ def consume_end_of_value(self):
         self.consume_whitespace()
         if self.s[self.ptr] != self.terminator:
             if self.s[self.ptr] == ',':
-                self.ptr+=1
+                self.ptr += 1
+                self.consume_whitespace()
             else:
                 raise Exception("Expected comma for end of value (after ...%s), but got '%s' instead" % (self.s[max(self.ptr-10,0):self.ptr], self.s[self.ptr]))
 
@@ -51,16 +52,17 @@ def read_until_unescaped_character(self, closing):
         elif closing=='"':
             r=re_dq
         else:
-            r=re.compile(r'(.*?)(?<!\\)(?:%s)'%closing)
+            r = re.compile(r'%(c)s([^%(c)s\\]|\\.)*%(c)s' % dict(c=closing))
 
         m=r.match(self.s, pos=self.ptr)
         if m is None:
             raise Exception ("Closing character not found")
-
-        value = m.group(1)
-        self.ptr+=len(value)+1
 
-        return value.replace('\\'+closing,closing)
+        value = m.group(0)
+        self.ptr += len(value)
+
+        # Return all values in unicode
+        return eval('u' + value)
 
     def parse_value(self):
         self.consume_whitespace()
@@ -69,11 +71,10 @@ def parse_value(self):
         val=False
         if self.s[self.ptr]==self.terminator:
             return val
-        
+
         # String
         if self.s[self.ptr] in ("'",'"'):
             quote=self.s[self.ptr]
-            self.ptr += 1
             val = self.read_until_unescaped_character(quote)
         # Boolean Attributes
         elif self.s[self.ptr:self.ptr+4] in ['none','None']:
@@ -90,7 +91,7 @@ def parse_value(self):
             raise Exception("Failed to parse dictionary value beginning at: %s" % self.s[self.ptr:])
 
         self.consume_end_of_value()
-        
+
         return val
 
 
@@ -104,7 +105,7 @@ class AttributeDictParser(AttributeParser):
     def __init__(self, s):
         AttributeParser.__init__(self, s, '}')
         self.dict={}
-    
+
     def parse(self):
         while self.ptr<self.length-1:
             key = self.__parse_key()
@@ -126,19 +127,19 @@ def parse(self):
 
             self.dict[key]=val
         return self.dict
-    
+
     def __parse_haml(self):
         def whitespace_length():
             r = re_whitespace.match(self.s, pos=self.ptr)
             return len(r.group(0))
-        
+
         initial_indentation=whitespace_length()
         lines = []
         while whitespace_length() >= initial_indentation:
             line=re_line.match(self.s, pos=self.ptr).group(0)
             lines.append(line)
             self.ptr += len(line)+1
-        
+
         h=hamlpy.Compiler()
         html = h.process_lines(lines)
         return re.sub(re_leading_spaces, ' ', html).replace('\n', '').strip()
@@ -150,12 +151,11 @@ def __parse_key(self):
 
         if self.s[self.ptr] == ':':
             self.ptr+=1
-                    
+
         # Consume opening quote
         quote=None
         if self.s[self.ptr] in ("'",'"'):
             quote = self.s[self.ptr]
-            self.ptr += 1
 
         # Extract key
         if quote:
@@ -197,9 +197,9 @@ def parse(self):
                 lst.append(val)
 
         self.ptr +=1
-        
+
         if self.terminator==')':
             return tuple(lst)
         else:
             return lst
-        
+

hamlpy/elements.py

@@ -3,7 +3,7 @@
 
 class Element(object):
     """contains the pieces of an element and can populate itself from haml element text"""
-    
+
     self_closing_tags = ('meta', 'img', 'link', 'br', 'hr', 'input', 'source', 'track', 'area', 'base', 'col', 'command', 'embed', 'keygen', 'param', 'wbr')
 
     ELEMENT = '%'
@@ -20,11 +20,12 @@ class Element(object):
     (?P<selfclose>/)?
     (?P<django>=)?
     (?P<inline>[^\w\.#\{].*)?
-    """, re.X|re.MULTILINE|re.DOTALL)
+    """, re.X | re.MULTILINE | re.DOTALL | re.UNICODE)
 
 
-    def __init__(self, haml):
+    def __init__(self, haml, attr_wrapper="'"):
         self.haml = haml
+        self.attr_wrapper = attr_wrapper
         self.tag = None
         self.id = None
         self.classes = None
@@ -35,7 +36,10 @@ def __init__(self, haml):
         self.nuke_outer_whitespace = False
         self.inline_content = ''
         self._parse_haml()
-
+
+    def attr_wrap(self, value):
+        return '%s%s%s' % (self.attr_wrapper, value, self.attr_wrapper)
+
     def _parse_haml(self):
         split_tags = self.HAML_REGEX.search(self.haml).groupdict('')
 
@@ -46,7 +50,7 @@ def _parse_haml(self):
         self.id = self._parse_id(split_tags.get('id'))
         self.classes = self._parse_classes(split_tags.get('class'))
         self.self_close = split_tags.get('selfclose') or self.tag in self.self_closing_tags
-        
+
         self.attributes = self._render_attributes(self.attributes_dict, self.id, self.classes)
 
         self.nuke_inner_whitespace = split_tags.get('nuke_inner_whitespace') != ''
@@ -58,7 +62,7 @@ def _parse_classes(self, classes):
         tag_classes = classes.lstrip(self.CLASS).replace('.', ' ')
         dict_classes = self._parse_class_from_attributes_dict()
         return ('%s %s' % (tag_classes, dict_classes)).strip()
-        
+
     def _parse_class_from_attributes_dict(self):
         cla = self.attributes_dict.get('class', '')
         if isinstance(cla, list) or isinstance(cla, tuple):
@@ -73,7 +77,7 @@ def _parse_id(self, id_haml):
                 id_text += '_'
             id_text += self._parse_id_dict(self.attributes_dict['id'])
         return id_text
-    
+
     def _parse_id_dict(self, id_dict):
         id_dict = self.attributes_dict.get('id')
 
@@ -84,11 +88,11 @@ def _parse_id_dict(self, id_dict):
 
     def _render_attributes(self, dict, id, classes):
         attributes=[]
-        
+
         if len(id) > 0:
-            attributes.append("id='%s'" % self.id)
+            attributes.append("id=%s" % self.attr_wrap(self.id))
         if len(classes) > 0:
-            attributes.append("class='%s'" % self.classes)
+            attributes.append("class=%s" % self.attr_wrap(self.classes))
 
         for k, v in dict.items():
             if k != 'id' and k != 'class':
@@ -97,24 +101,23 @@ def _render_attributes(self, dict, id, classes):
                     attributes.append( "%s" % (k,))
                 else:
                     value = self._escape_attribute_quotes(v)
-                    attributes.append( "%s='%s'" % (k, value))
-                                       
+                    attributes.append( "%s=%s" % (k, self.attr_wrap(value)))
+
         return ' '.join(attributes)
-
-
-    def _escape_attribute_quotes(self,v):
+
+    def _escape_attribute_quotes(self, v):
         '''
-        Escapes single quotes with a backslash, except those inside a Django tag
+        Escapes quotes with a backslash, except those inside a Django tag
         '''
-        escaped=[]
+        escaped = []
         inside_tag = False
         for i, _ in enumerate(v):
-            if v[i:i+2] == '{%':
-                inside_tag=True
-            elif v[i:i+2] == '%}':
-                inside_tag=False
+            if v[i:i + 2] == '{%':
+                inside_tag = True
+            elif v[i:i + 2] == '%}':
+                inside_tag = False
 
-            if v[i]=="'" and not inside_tag:
+            if v[i] == self.attr_wrapper and not inside_tag:
                 escaped.append('\\')
 
             escaped.append(v[i])

hamlpy/ext.py

@@ -0,0 +1,42 @@
+# coding=utf-8
+try:
+    import jinja2.ext
+    _jinja2_available = True
+except ImportError, e:
+    _jinja2_available = False
+
+import hamlpy
+import os
+
+HAML_FILE_NAME_EXTENSIONS = ['haml', 'hamlpy']
+
+
+def clean_extension(file_ext):
+    if not isinstance(file_ext, basestring):
+        raise Exception('Wrong file extension format: %r' % file_ext)
+    if len(file_ext) > 1 and file_ext.startswith('.'):
+        file_ext = file_ext[1:]
+    return file_ext.lower().strip()
+
+
+def get_file_extension(file_path):
+    file_ext = os.path.splitext(file_path)[1]
+    return clean_extension(file_ext)
+
+
+def has_any_extension(file_path, extensions):
+    file_ext = get_file_extension(file_path)
+    return file_ext and extensions and file_ext in [clean_extension(e) for e in extensions]
+
+if _jinja2_available:
+    class HamlPyExtension(jinja2.ext.Extension):
+
+        def preprocess(self, source, name, filename=None):
+            if name and has_any_extension(name, HAML_FILE_NAME_EXTENSIONS):
+                compiler = hamlpy.Compiler()
+                try:
+                    return compiler.process(source)
+                except Exception as e:
+                    raise jinja2.TemplateSyntaxError(e, 1, name=name, filename=filename)
+            else:
+                return source

hamlpy/hamlpy.py

@@ -5,19 +5,25 @@
 VALID_EXTENSIONS=['haml', 'hamlpy']
 
 class Compiler:
-    def process(self, raw_text, options=None):
+
+    def __init__(self, options_dict=None):
+        options_dict = options_dict or {}
+        self.debug_tree = options_dict.pop('debug_tree', False)
+        self.options_dict = options_dict
+
+    def process(self, raw_text):
         split_text = raw_text.split('\n')
-        return self.process_lines(split_text, options)
+        return self.process_lines(split_text)
 
-    def process_lines(self, haml_lines, options=None):
-        root = RootNode()
+    def process_lines(self, haml_lines):
+        root = RootNode(**self.options_dict)
         line_iter = iter(haml_lines)
 
         haml_node=None
         for line_number, line in enumerate(line_iter):
             node_lines = line
 
-            if root.parent_of(HamlNode(line)).should_treat_children_as_multiline():
+            if not root.parent_of(HamlNode(line)).inside_filter_node():
                 if line.count('{') - line.count('}') == 1:
                     start_multiline=line_number # For exception handling
 
@@ -35,8 +41,8 @@ def process_lines(self, haml_lines, options=None):
                 haml_node = create_node(node_lines)
                 if haml_node:
                     root.add_node(haml_node)
-                
-        if options and options.debug_tree:
+
+        if self.options_dict and self.options_dict.get('debug_tree'):
             return root.debug_tree()
         else:
             return root.render()
@@ -45,19 +51,27 @@ def convert_files():
     import codecs
 
     parser = OptionParser()
-    parser.add_option("-d", "--debug-tree", dest="debug_tree",
-    action="store_true", help="Print the generated tree instead of the HTML")
+    parser.add_option(
+        "-d", "--debug-tree", dest="debug_tree",
+        action="store_true",
+        help="Print the generated tree instead of the HTML")
+    parser.add_option(
+        "--attr-wrapper", dest="attr_wrapper",
+        type="choice", choices=('"', "'"), default="'",
+        action="store",
+        help="The character that should wrap element attributes. "
+        "This defaults to ' (an apostrophe).")
     (options, args) = parser.parse_args()
 
     if len(args) < 1:
         print "Specify the input file as the first argument."
-    else: 
+    else:
         infile = args[0]
         haml_lines = codecs.open(infile, 'r', encoding='utf-8').read().splitlines()
 
-        compiler = Compiler()
-        output = compiler.process_lines(haml_lines, options=options)
-        
+        compiler = Compiler(options.__dict__)
+        output = compiler.process_lines(haml_lines)
+
         if len(args) == 2:
             outfile = codecs.open(args[1], 'w', encoding='utf-8')
             outfile.write(output)