hamlit 1.7.2 → 2.0.1

data/lib/hamlit/filters/text_base.rb

@@ -0,0 +1,24 @@
+module Hamlit
+  class Filters
+    class TextBase < Base
+      def compile_text!(temple, node, prefix)
+        text = node.value[:text].rstrip.gsub(/^/, prefix)
+        if ::Hamlit::HamlUtil.contains_interpolation?(node.value[:text])
+          # original: Haml::Filters#compile
+          text = ::Hamlit::HamlUtil.slow_unescape_interpolation(text).gsub(/(\\+)n/) do |s|
+            escapes = $1.size
+            next s if escapes % 2 == 0
+            "#{'\\' * (escapes - 1)}\n"
+          end
+          text.prepend("\n")
+          temple << [:dynamic, text]
+        else
+          node.value[:text].split("\n").size.times do
+            temple << [:newline]
+          end
+          temple << [:static, text]
+        end
+      end
+    end
+  end
+end

data/lib/hamlit/filters/tilt_base.rb

@@ -0,0 +1,47 @@
+require 'tilt'
+
+module Hamlit
+  class Filters
+    class TiltBase < Base
+      def self.render(name, source, indent_width: 0)
+        text = ::Tilt["t.#{name}"].new { source }.render
+        return text if indent_width == 0
+        text.gsub!(/^/, ' '.freeze * indent_width)
+      end
+
+      def explicit_require?
+        Gem::Version.new(Tilt::VERSION) >= Gem::Version.new('2.0.0')
+      end
+
+      private
+
+      def compile_with_tilt(node, name, indent_width: 0)
+        if ::Hamlit::HamlUtil.contains_interpolation?(node.value[:text])
+          dynamic_compile(node, name, indent_width: indent_width)
+        else
+          static_compile(node, name, indent_width: indent_width)
+        end
+      end
+
+      def static_compile(node, name, indent_width: 0)
+        temple = [:multi, [:static, TiltBase.render(name, node.value[:text], indent_width: indent_width)]]
+        node.value[:text].split("\n").size.times do
+          temple << [:newline]
+        end
+        temple
+      end
+
+      def dynamic_compile(node, name, indent_width: 0)
+        # original: Haml::Filters#compile
+        text = ::Hamlit::HamlUtil.slow_unescape_interpolation(node.value[:text]).gsub(/(\\+)n/) do |s|
+          escapes = $1.size
+          next s if escapes % 2 == 0
+          "#{'\\' * (escapes - 1)}\n"
+        end
+        text.prepend("\n").sub!(/\n"\z/, '"')
+
+        [:dynamic, "::Hamlit::Filters::TiltBase.render('#{name}', #{text}, indent_width: #{indent_width})"]
+      end
+    end
+  end
+end

data/lib/hamlit/hash_parser.rb

@@ -0,0 +1,107 @@
+require 'hamlit/ruby_expression'
+
+module Hamlit
+  class HashParser
+    class ParseSkip < StandardError
+    end
+
+    def self.parse(text)
+      self.new.parse(text)
+    end
+
+    def parse(text)
+      exp = wrap_bracket(text)
+      return if RubyExpression.syntax_error?(exp)
+
+      hash = {}
+      tokens = Ripper.lex(exp)[1..-2] || []
+      each_attr(tokens) do |attr_tokens|
+        key = parse_key!(attr_tokens)
+        hash[key] = attr_tokens.map(&:last).join.strip
+      end
+      hash
+    rescue ParseSkip
+      nil
+    end
+
+    private
+
+    def wrap_bracket(text)
+      text = text.strip
+      return text if text[0] == '{'.freeze
+      '{' << text << '}'.freeze
+    end
+
+    def parse_key!(tokens)
+      _, type, str = tokens.shift
+      case type
+      when :on_sp
+        parse_key!(tokens)
+      when :on_label
+        str.tr(':'.freeze, ''.freeze)
+      when :on_symbeg
+        _, _, key = tokens.shift
+        assert_type!(tokens.shift, :on_tstring_end) if str != ':'.freeze
+        skip_until_hash_rocket!(tokens)
+        key
+      when :on_tstring_beg
+        _, _, key = tokens.shift
+        next_token = tokens.shift
+        unless next_token[1] == :on_label_end
+          assert_type!(next_token, :on_tstring_end)
+          skip_until_hash_rocket!(tokens)
+        end
+        key
+      else
+        raise ParseSkip
+      end
+    end
+
+    def assert_type!(token, type)
+      raise ParseSkip if token[1] != type
+    end
+
+    def skip_until_hash_rocket!(tokens)
+      until tokens.empty?
+        _, type, str = tokens.shift
+        break if type == :on_op && str == '=>'.freeze
+      end
+    end
+
+    def each_attr(tokens)
+      attr_tokens = []
+      array_open  = 0
+      brace_open  = 0
+      paren_open  = 0
+
+      tokens.each do |token|
+        (row, col), type, str = token
+        case type
+        when :on_comma
+          if array_open == 0 && brace_open == 0 && paren_open == 0
+            yield(attr_tokens)
+            attr_tokens = []
+            next
+          end
+        when :on_lbracket
+          array_open += 1
+        when :on_rbracket
+          array_open -= 1
+        when :on_lbrace
+          brace_open += 1
+        when :on_rbrace
+          brace_open -= 1
+        when :on_lparen
+          paren_open += 1
+        when :on_rparen
+          paren_open -= 1
+        when :on_sp
+          next if attr_tokens.empty?
+        end
+
+        attr_tokens << token
+      end
+      yield(attr_tokens) unless attr_tokens.empty?
+    end
+  end
+end

data/lib/hamlit/html.rb

@@ -1,10 +1,13 @@
-require 'hamlit/concerns/deprecation'
-require 'temple/html/fast'
-
-# This is created to be compatible with Haml's ugly mode.
-# Currently pretty mode is not supported.
 module Hamlit
   class HTML < Temple::HTML::Fast
-    include Concerns::Deprecation
+    DEPRECATED_FORMATS = %i[html4 html5].freeze
+
+    def initialize(opts = {})
+      if DEPRECATED_FORMATS.include?(opts[:format])
+        opts = opts.dup
+        opts[:format] = :html
+      end
+      super(opts)
+    end
   end
 end

data/lib/hamlit/identity.rb

@@ -0,0 +1,12 @@
+module Hamlit
+  class Identity
+    def initialize
+      @unique_id = 0
+    end
+
+    def generate
+      @unique_id += 1
+      "_hamlit_compiler#{@unique_id}"
+    end
+  end
+end

data/lib/hamlit/object_ref.rb

@@ -0,0 +1,29 @@
+module Hamlit
+  module ObjectRef
+    class << self
+      def parse(args)
+        object, prefix = args
+        return {} unless object
+
+        suffix = underscore(object.class)
+        {
+          'class' => [prefix, suffix].compact.join('_'),
+          'id'    => [prefix, suffix, object.id || 'new'].compact.join('_'),
+        }
+      end
+
+      private
+
+      # Haml::Buffer.underscore
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!(/::/, '_')
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+        word.tr!('-', '_')
+        word.downcase!
+        word
+      end
+    end
+  end
+end

data/lib/hamlit/parser.rb

@@ -1,150 +1,33 @@
-require 'strscan'
-require 'temple'
-require 'hamlit/parsers/attribute'
-require 'hamlit/parsers/comment'
-require 'hamlit/parsers/doctype'
-require 'hamlit/parsers/filter'
-require 'hamlit/parsers/multiline'
-require 'hamlit/parsers/script'
-require 'hamlit/parsers/tag'
-require 'hamlit/parsers/text'
+# Hamlit::Parser uses original Haml::Parser to generate Haml AST.
+# hamlit/parser/haml_* are modules originally in haml gem.
 
-module Hamlit
-  class Parser < Temple::Parser
-    include Parsers::Attribute
-    include Parsers::Comment
-    include Parsers::Doctype
-    include Parsers::Filter
-    include Parsers::Multiline
-    include Parsers::Script
-    include Parsers::Tag
-    include Parsers::Text
-
-    SKIP_NEWLINE_EXPS    = %i[newline code multi].freeze
-    SKIP_NEWLINE_FILTERS = %w[ruby markdown erb].freeze
-
-    define_options :format
-
-    def call(template)
-      reset(template)
-
-      ast = [:multi]
-      ast += parse_lines
-      ast
-    end
-
-    private
-
-    # Reset the parser state.
-    def reset(template)
-      validate_indentation_consistency!(template)
-      template = preprocess_multilines(template)
-
-      reset_lines(template.split("\n"))
-      reset_indent
-      reset_outer_removal
-    end
-
-    # Parse lines in current_indent and return ASTs.
-    def parse_lines
-      ast = []
-      loop do
-        break if validate_indentation!(ast)
-
-        @current_lineno += 1
-        node = parse_line(current_line)
-        remove_last_space!(ast) if outer_remove?
-
-        ast << [:newline] if @current_indent > 0
-        ast << node
-        ast << [:newline] if @current_indent == 0
-        ast << [:static, "\n"] unless skip_newline?(node)
-      end
-      ast
-    rescue => e
-      ast << [:newline]
-      ast << syntax_error(e.message)
-      ast
-    end
-
-    # Parse current line and return AST.
-    def parse_line(line, inline: false)
-      return [:multi] if empty_line?(line)
-
-      scanner = wrap_scanner(line)
-      unless inline
-        scanner.scan(/[ \t]+/)
-        ast = parse_outer_line(scanner)
-        return ast if ast
-      end
+require 'hamlit/parser/haml_error'
+require 'hamlit/parser/haml_util'
+require 'hamlit/parser/haml_buffer'
+require 'hamlit/parser/haml_compiler'
+require 'hamlit/parser/haml_parser'
+require 'hamlit/parser/haml_helpers'
+require 'hamlit/parser/haml_options'
 
-      parse_inner_line(scanner, inline: inline)
-    end
-
-    # Parse a line and return ast if it is acceptable outside an inline tag
-    def parse_outer_line(scanner)
-      return parse_text(scanner)    if scanner.match?(/\#{/)
-      return parse_text(scanner)    if scanner.match?(/[.#]($|[^a-zA-Z0-9_-])/)
-      return parse_doctype(scanner) if scanner.match?(/!!!/)
-
-      case scanner.peek(1)
-      when '%', '.', '#'
-        parse_tag(scanner)
-      when '\\'
-        parse_text(scanner, scan: /\\/)
-      when '/'
-        parse_comment(scanner)
-      when '-'
-        parse_silent_script(scanner)
-      when ':'
-        parse_filter(scanner)
-      end
-    end
-
-    # Parse a line and return ast which is acceptable inside an inline tag
-    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_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)
-      else
-        parse_text(scanner, lstrip: true, inline: inline)
+module Hamlit
+  class Parser
+    AVAILABLE_OPTIONS = %i[
+      autoclose
+      escape_html
+      escape_attrs
+    ].freeze
+
+    def initialize(options = {})
+      @options = HamlOptions.defaults.dup
+      AVAILABLE_OPTIONS.each do |key|
+        @options[key] = options[key]
       end
     end
 
-    def skip_newline?(ast)
-      SKIP_NEWLINE_EXPS.include?(ast.first) ||
-        newline_skip_filter?(ast) ||
-        doctype?(ast) ||
-        block_script?(ast) ||
-        outer_remove?
-    end
-
-    def newline_skip_filter?(ast)
-      ast[0..1] == [:haml, :filter] && SKIP_NEWLINE_FILTERS.include?(ast[2])
-    end
-
-    def wrap_scanner(str)
-      return str if str.is_a?(StringScanner)
-      StringScanner.new(str)
-    end
-
-    def doctype?(ast)
-      ast[0..1] == [:haml, :doctype]
-    end
-
-    def block_script?(ast)
-      ast[0..1] == [:haml, :script]
+    def call(template)
+      HamlParser.new(template, HamlOptions.new(@options)).parse
+    rescue ::Hamlit::HamlError => e
+      e
     end
   end
 end

data/lib/hamlit/parser/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006-2009 Hampton Catlin and Natalie Weizenbaum
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/hamlit/parser/README.md

@@ -0,0 +1,28 @@
+# lib/hamlit/parser/haml\_\*.rb
+
+Hamlit::HamlFoo is originally Haml::Foo in haml gem.
+
+## License
+
+lib/hamlit/parser/haml\_\*.rb is:
+
+Copyright (c) 2006-2009 Hampton Catlin and Natalie Weizenbaum
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.