hamlit 1.5.9 → 1.6.0

data/doc/haml/engine/tag.md

@@ -0,0 +1,48 @@
+# [tag\_spec.rb:271](/spec/hamlit/engine/tag_spec.rb#L271)
+## Input
+```haml
+%div<
+  #{'hello'}
+  world
+
+```
+
+## Output
+### Haml
+```html
+<div>helloworld</div>
+
+```
+
+### Hamlit
+```html
+<div>hello
+world</div>
+
+```
+
+
+# [tag\_spec.rb:282](/spec/hamlit/engine/tag_spec.rb#L282)
+## Input
+```haml
+.bar<
+  - 1.times do
+    = '1'
+    = '2'
+
+```
+
+## Output
+### Haml
+```html
+<div class='bar'>12</div>
+
+```
+
+### Hamlit
+```html
+<div class='bar'>1
+2</div>
+
+```
+

data/doc/haml/engine/text.md

@@ -0,0 +1,59 @@
+# [text\_spec.rb:15](/spec/hamlit/engine/text_spec.rb#L15)
+## Input
+```haml
+.
+.*
+..
+#
+#+
+##
+
+```
+
+## Output
+### Haml
+```html
+Haml::SyntaxError: Illegal element: classes and ids must have values.
+```
+
+### Hamlit
+```html
+.
+.*
+..
+#
+#+
+##
+
+```
+
+
+# [text\_spec.rb:118](/spec/hamlit/engine/text_spec.rb#L118)
+## Input
+```haml
+ 
+\ 
+!hello
+\!hello
+
+```
+
+## Output
+### Haml
+```html
+ 
+ 
+!hello
+!hello
+
+```
+
+### Hamlit
+```html
+nbsp;
+ 
+hello
+!hello
+
+```
+

data/doc/haml/filters/erb.md

@@ -0,0 +1,26 @@
+# [erb\_spec.rb:3](/spec/hamlit/filters/erb_spec.rb#L3)
+## Input
+```haml
+:erb
+  <% if true %>
+  ok
+  <% else %>
+  ng
+  <% end %>
+
+```
+
+## Output
+### Haml
+```html
+ok
+
+
+```
+
+### Hamlit
+```html
+ok
+
+```
+

data/doc/haml/filters/javascript.md

@@ -0,0 +1,76 @@
+# [javascript\_spec.rb:3](/spec/hamlit/filters/javascript_spec.rb#L3)
+## Input
+```haml
+before
+:javascript
+after
+
+```
+
+## Output
+### Haml
+```html
+before
+<script>
+  
+</script>
+after
+
+```
+
+### Hamlit
+```html
+before
+<script>
+
+</script>
+after
+
+```
+
+
+# [javascript\_spec.rb:32](/spec/hamlit/filters/javascript_spec.rb#L32)
+## Input
+```haml
+:javascript
+ if {
+  alert('hello');
+   }
+:javascript
+   if {
+    alert('hello');
+     }
+
+```
+
+## Output
+### Haml
+```html
+<script>
+  if {
+   alert('hello');
+    }
+</script>
+<script>
+    if {
+     alert('hello');
+      }
+</script>
+
+```
+
+### Hamlit
+```html
+<script>
+  if {
+   alert('hello');
+    }
+</script>
+<script>
+  if {
+   alert('hello');
+    }
+</script>
+
+```
+

data/doc/haml/filters/markdown.md

@@ -0,0 +1,31 @@
+# [markdown\_spec.rb:15](/spec/hamlit/filters/markdown_spec.rb#L15)
+## Input
+```haml
+- project = '<Hamlit>'
+:markdown
+  # #{project}
+  #{'<&>'}
+  Yet another haml implementation
+
+```
+
+## Output
+### Haml
+```html
+<h1><Hamlit></h1>
+
+<p>&lt;&amp;&gt;
+Yet another haml implementation</p>
+
+
+```
+
+### Hamlit
+```html
+<h1><Hamlit></h1>
+
+<p>&lt;&amp;&gt;
+Yet another haml implementation</p>
+
+```
+

data/lib/hamlit/compilers/attributes.rb

@@ -49,7 +49,7 @@ module Hamlit
         attrs = []
         exps.each do |exp|
           case exp
-          when /\A\(.+\)\Z/
+          when /\A\(.+\)\Z/m
             attrs += compile_new_attribute(exp)
           when /\A{.+}\Z/
             attrs += compile_old_attribute(exp)

data/lib/hamlit/compilers/new_attribute.rb

@@ -1,15 +1,15 @@
-require 'hamlit/concerns/ripperable'
+require 'hamlit/concerns/lexable'
 
 # This module compiles new-style attributes, which is
 # surrounded by parentheses.
 module Hamlit
   module Compilers
     module NewAttribute
-      include Concerns::Ripperable
+      include Concerns::Lexable
 
       def compile_new_attribute(str)
-        str    = str.gsub(/\A\(|\)\Z/, '')
-        attrs  = parse_new_attributes(str)
+        str   = str.gsub(/\A\(|\)\Z/, '')
+        attrs = parse_new_attributes(str)
         attrs.map do |key, value|
           next true_attribute(key) if value == 'true'
           [:html, :attr, key, [:dynamic, value]]
@@ -34,7 +34,7 @@ module Hamlit
           token = tokens.first
           break unless token
 
-          pos = token.first.last
+          pos = convert_position(str, *token.first)
           str = str[pos..-1]
         end
 
@@ -42,7 +42,7 @@ module Hamlit
       end
 
       def read_key!(tokens)
-        skip_tokens!(tokens, :on_sp)
+        skip_tokens!(tokens, :on_sp, :on_nl, :on_ignored_nl)
         (row, col), type, key = tokens.shift
         key
       end

data/lib/hamlit/compilers/old_attribute.rb

@@ -1,6 +1,6 @@
 require 'hamlit/concerns/attribute_builder'
 require 'hamlit/concerns/balanceable'
-require 'hamlit/concerns/ripperable'
+require 'hamlit/concerns/lexable'
 
 # This module compiles only old-style attribute, which is
 # surrounded by brackets.
@@ -13,7 +13,7 @@ module Hamlit
     module OldAttribute
       include Concerns::AttributeBuilder
       include Concerns::Balanceable
-      include Concerns::Ripperable
+      include Concerns::Lexable
 
       # Only data can be nested for performance.
       NESTABLE_ATTRIBUTES = %w[data].freeze

data/lib/hamlit/compilers/text.rb

@@ -1,6 +1,7 @@
 require 'hamlit/concerns/error'
 require 'hamlit/concerns/escapable'
 require 'hamlit/concerns/included'
+require 'hamlit/concerns/lexable'
 require 'hamlit/concerns/string_interpolation'
 
 module Hamlit
@@ -8,6 +9,7 @@ module Hamlit
     module Text
       extend Concerns::Included
       include Concerns::Error
+      include Concerns::Lexable
       include Concerns::StringInterpolation
 
       included do
@@ -51,11 +53,11 @@ module Hamlit
         Ripper.lex(literal).each do |(row, col), type, str|
           case type
           when :on_embexpr_beg
-            open_pos = calc_position(exp, row, col, offset) if open_count == 0
+            open_pos = shifted_position(exp, row, col, offset) if open_count == 0
             open_count += 1
           when :on_embexpr_end
             open_count -= 1
-            return [open_pos, calc_position(exp, row, col, offset)] if open_count == 0
+            return [open_pos, shifted_position(exp, row, col, offset)] if open_count == 0
           end
           open_count
         end
@@ -100,15 +102,10 @@ module Hamlit
         "%#{marker}#{exp}#{marker}"
       end
 
-      def calc_position(exp, row, col, offset)
+      # In this compiler, only first line is shifted 2 chars.
+      def shifted_position(exp, row, col, offset)
         return col - offset if row <= 1
-
-        pos   = col
-        lines = exp.split("\n")
-        (0..(row - 2)).each do |row_index|
-          pos += lines[row_index].bytesize + 1
-        end
-        pos
+        convert_position(exp, row, col)
       end
     end
   end

data/lib/hamlit/concerns/lexable.rb

@@ -0,0 +1,32 @@
+require 'ripper'
+
+module Hamlit
+  module Concerns
+    module Lexable
+      TYPE_POSITION = 1
+
+      def skip_tokens!(tokens, *types)
+        while types.include?(type_of(tokens.first))
+          tokens.shift
+        end
+      end
+
+      def type_of(token)
+        return nil unless token
+        token[TYPE_POSITION]
+      end
+
+      # Convert ripper's position to StringScanner's one.
+      def convert_position(text, row, col)
+        return col if row <= 1
+
+        pos   = col
+        lines = text.split("\n")
+        (0..(row - 2)).each do |row_index|
+          pos += lines[row_index].bytesize + 1
+        end
+        pos
+      end
+    end
+  end
+end

data/lib/hamlit/parser.rb

@@ -76,7 +76,7 @@ module Hamlit
         return ast if ast
       end
 
-      parse_inner_line(scanner)
+      parse_inner_line(scanner, inline: inline)
     end
 
     # Parse a line and return ast if it is acceptable outside an inline tag
@@ -100,20 +100,21 @@ module Hamlit
     end
 
     # Parse a line and return ast which is acceptable inside an inline tag
-    def parse_inner_line(scanner)
+    def parse_inner_line(scanner, inline: false)
       return parse_text(scanner, lstrip: true)                if scanner.scan(/==/)
-      return parse_text(scanner, lstrip: true, escape: false) if scanner.scan(/!==/)
-      return parse_text(scanner, lstrip: true, escape: true)  if scanner.scan(/&==/)
+      return parse_text(scanner, lstrip: true, escape: false) if scanner.scan(/! |!==/)
+      return parse_text(scanner, lstrip: true, escape: true)  if scanner.scan(/& |&==/)
       return parse_script(scanner, disable_escape: true)      if scanner.match?(/!=/)
       return parse_script(scanner, force_escape: true)        if scanner.match?(/&=/)
 
+      if inline
+        return parse_text(scanner, lstrip: true, escape: false) if scanner.scan(/!/)
+        return parse_text(scanner, lstrip: true, escape: true)  if scanner.scan(/&/)
+      end
+
       case scanner.peek(1)
       when '=', '~'
         parse_script(scanner)
-      when '!'
-        parse_text(scanner, lstrip: true, escape: false, scan: /!/)
-      when '&'
-        parse_text(scanner, lstrip: true, escape: true, scan: /&/)
       else
         parse_text(scanner)
       end

data/lib/hamlit/parsers/attribute.rb

@@ -1,10 +1,12 @@
 require 'ripper'
 require 'hamlit/concerns/balanceable'
+require 'hamlit/concerns/lexable'
 
 module Hamlit
   module Parsers
     module Attribute
       include Concerns::Balanceable
+      include Concerns::Lexable
 
       EMBEXPR_PREFIX = '"#'.freeze
 
@@ -45,13 +47,14 @@ module Hamlit
         until balanced_parens_exist?(tokens)
           @current_lineno += 1
           break unless @lines[@current_lineno]
-          scanner.concat(current_line)
+          scanner.concat("\n#{current_line}")
           tokens = Ripper.lex(scanner.rest)
         end
 
         tokens = fetch_balanced_parentheses(tokens)
-        scanner.pos += tokens.last.first.last + 1
-        [tokens.map(&:last).join]
+        text   = tokens.map(&:last).join
+        scanner.pos += convert_position(text, *tokens.last.first) + 1
+        [text]
       end
 
       # Ripper.lex and reject tokens whose row is 0 (invalid).