hamlit 2.10.0

data/lib/hamlit/attribute_parser.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+require 'hamlit/ruby_expression'
+
+module Hamlit
+  class AttributeParser
+    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 { |t| t[2] }.join.strip
+      end
+      hash
+    rescue ParseSkip
+      nil
+    end
+
+    private
+
+    def wrap_bracket(text)
+      text = text.strip
+      return text if text[0] == '{'
+      "{#{text}}"
+    end
+
+    def parse_key!(tokens)
+      _, type, str = tokens.shift
+      case type
+      when :on_sp
+        parse_key!(tokens)
+      when :on_label
+        str.tr(':', '')
+      when :on_symbeg
+        _, _, key = tokens.shift
+        assert_type!(tokens.shift, :on_tstring_end) if str != ':'
+        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 == '=>'
+      end
+    end
+
+    def each_attr(tokens)
+      attr_tokens = []
+      open_tokens = Hash.new { |h, k| h[k] = 0 }
+
+      tokens.each do |token|
+        _, type, _ = token
+        case type
+        when :on_comma
+          if open_tokens.values.all?(&:zero?)
+            yield(attr_tokens)
+            attr_tokens = []
+            next
+          end
+        when :on_lbracket
+          open_tokens[:array] += 1
+        when :on_rbracket
+          open_tokens[:array] -= 1
+        when :on_lbrace
+          open_tokens[:block] += 1
+        when :on_rbrace
+          open_tokens[:block] -= 1
+        when :on_lparen
+          open_tokens[:paren] += 1
+        when :on_rparen
+          open_tokens[:paren] -= 1
+        when :on_embexpr_beg
+          open_tokens[:embexpr] += 1
+        when :on_embexpr_end
+          open_tokens[:embexpr] -= 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/cli.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+require 'hamlit'
+require 'thor'
+
+module Hamlit
+  class CLI < Thor
+    class_option :escape_html, type: :boolean, default: true
+    class_option :escape_attrs, type: :boolean, default: true
+
+    desc 'render HAML', 'Render haml template'
+    option :load_path, type: :string, aliases: %w[-I]
+    option :require, type: :string, aliases: %w[-r]
+    def render(file)
+      process_load_options
+      code = generate_code(file)
+      puts eval(code)
+    end
+
+    desc 'compile HAML', 'Show compile result'
+    option :actionview, type: :boolean, default: false, aliases: %w[-a]
+    option :color, type: :boolean, default: false, aliases: %w[-c]
+    def compile(file)
+      code = generate_code(file)
+      puts_code(code, color: options[:color])
+    end
+
+    desc 'temple HAML', 'Show temple intermediate expression'
+    option :color, type: :boolean, default: false, aliases: %w[-c]
+    def temple(file)
+      pp_object(generate_temple(file), color: options[:color])
+    end
+
+    desc 'parse HAML', 'Show parse result'
+    option :color, type: :boolean, default: false, aliases: %w[-c]
+    def parse(file)
+      pp_object(generate_ast(file), color: options[:color])
+    end
+
+    desc 'version', 'Show the used hamlit version'
+    def version
+      puts Hamlit::VERSION
+    end
+
+    private
+
+    def process_load_options
+      if options[:load_path]
+        options[:load_path].split(':').each do |dir|
+          $LOAD_PATH.unshift(dir) unless $LOAD_PATH.include?(dir)
+        end
+      end
+
+      if options[:require]
+        require options[:require]
+      end
+    end
+
+    def read_file(file)
+      if file == '-'
+        STDIN.read
+      else
+        File.read(file)
+      end
+    end
+
+    def generate_code(file)
+      template = read_file(file)
+      if options[:actionview]
+        require 'action_view'
+        require 'action_view/base'
+        require 'hamlit/rails_template'
+        handler = Hamlit::RailsTemplate.new
+        template = ActionView::Template.new(template, 'inline template', handler, { locals: [] })
+        code = handler.call(template)
+        <<-end_src
+          def _inline_template___2144273726781623612_70327218547300(local_assigns, output_buffer)
+            _old_virtual_path, @virtual_path = @virtual_path, nil;_old_output_buffer = @output_buffer;;#{code}
+          ensure
+            @virtual_path, @output_buffer = _old_virtual_path, _old_output_buffer
+          end
+        end_src
+      else
+        Hamlit::Engine.new(engine_options).call(template)
+      end
+    end
+
+    def generate_ast(file)
+      template = read_file(file)
+      Hamlit::Parser.new(engine_options).call(template)
+    end
+
+    def generate_temple(file)
+      ast = generate_ast(file)
+      Hamlit::Compiler.new(engine_options).call(ast)
+    end
+
+    def engine_options
+      Hamlit::Engine.options.to_h.merge(
+        escape_attrs: options[:escape_attrs],
+        escape_html:  options[:escape_html],
+      )
+    end
+
+    # Flexible default_task, compatible with haml's CLI
+    def method_missing(*args)
+      return super(*args) if args.length > 1
+      render(args.first.to_s)
+    end
+
+    def puts_code(code, color: false)
+      if color
+        require 'pry'
+        puts Pry.Code(code).highlighted
+      else
+        puts code
+      end
+    end
+
+    # Enable colored pretty printing only for development environment.
+    def pp_object(arg, color: false)
+      if color
+        require 'pry'
+        Pry::ColorPrinter.pp(arg)
+      else
+        require 'pp'
+        pp(arg)
+      end
+    end
+  end
+end

data/lib/hamlit/compiler.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+require 'hamlit/compiler/children_compiler'
+require 'hamlit/compiler/comment_compiler'
+require 'hamlit/compiler/doctype_compiler'
+require 'hamlit/compiler/script_compiler'
+require 'hamlit/compiler/silent_script_compiler'
+require 'hamlit/compiler/tag_compiler'
+require 'hamlit/filters'
+require 'hamlit/identity'
+
+module Hamlit
+  class Compiler
+    def initialize(options = {})
+      identity                = Identity.new
+      @children_compiler      = ChildrenCompiler.new
+      @comment_compiler       = CommentCompiler.new
+      @doctype_compiler       = DoctypeCompiler.new(options)
+      @filter_compiler        = Filters.new(options)
+      @script_compiler        = ScriptCompiler.new(identity)
+      @silent_script_compiler = SilentScriptCompiler.new
+      @tag_compiler           = TagCompiler.new(identity, options)
+    end
+
+    def call(ast)
+      return runtime_error(ast) if ast.is_a?(HamlError)
+      compile(ast)
+    rescue Error => e
+      runtime_error(e)
+    end
+
+    private
+
+    def compile(node)
+      case node.type
+      when :root
+        compile_children(node)
+      when :comment
+        compile_comment(node)
+      when :doctype
+        compile_doctype(node)
+      when :filter
+        compile_filter(node)
+      when :plain
+        compile_plain(node)
+      when :script
+        compile_script(node)
+      when :silent_script
+        compile_silent_script(node)
+      when :tag
+        compile_tag(node)
+      when :haml_comment
+        [:multi]
+      else
+        raise InternalError.new("Unexpected node type: #{node.type}")
+      end
+    end
+
+    def compile_children(node)
+      @children_compiler.compile(node) { |n| compile(n) }
+    end
+
+    def compile_comment(node)
+      @comment_compiler.compile(node) { |n| compile_children(n) }
+    end
+
+    def compile_doctype(node)
+      @doctype_compiler.compile(node)
+    end
+
+    def compile_filter(node)
+      @filter_compiler.compile(node)
+    end
+
+    def compile_plain(node)
+      [:static, node.value[:text]]
+    end
+
+    def compile_script(node)
+      @script_compiler.compile(node) { |n| compile_children(n) }
+    end
+
+    def compile_silent_script(node)
+      @silent_script_compiler.compile(node) { |n| compile_children(n) }
+    end
+
+    def compile_tag(node)
+      @tag_compiler.compile(node) { |n| compile_children(n) }
+    end
+
+    def runtime_error(error)
+      [:multi].tap do |temple|
+        error.line.times { temple << [:newline] } if error.line
+        temple << [:code, %Q[raise #{error.class}.new(%q[#{error.message}], #{error.line.inspect})]]
+      end
+    end
+  end
+end

data/lib/hamlit/compiler/children_compiler.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+module Hamlit
+  class Compiler
+    class ChildrenCompiler
+      def initialize
+        @lineno = 1
+      end
+
+      def compile(node, &block)
+        temple = [:multi]
+        return temple if node.children.empty?
+
+        temple << :whitespace if prepend_whitespace?(node)
+        node.children.each do |n|
+          rstrip_whitespace!(temple) if nuke_prev_whitespace?(n)
+          insert_newlines!(temple, n)
+          temple << yield(n)
+          temple << :whitespace if insert_whitespace?(n)
+        end
+        rstrip_whitespace!(temple) if nuke_inner_whitespace?(node)
+        confirm_whitespace(temple)
+      end
+
+      private
+
+      def insert_newlines!(temple, node)
+        (node.line - @lineno).times do
+          temple << [:newline]
+        end
+        @lineno = node.line
+
+        case node.type
+        when :script, :silent_script
+          @lineno += 1
+        when :filter
+          @lineno += (node.value[:text] || '').split("\n").size
+        when :tag
+          node.value[:attributes_hashes].each do |attribute_hash|
+            @lineno += attribute_hash.count("\n")
+          end
+          @lineno += 1 if node.children.empty? && node.value[:parse]
+        end
+      end
+
+      def confirm_whitespace(temple)
+        temple.map do |exp|
+          case exp
+          when :whitespace
+            [:static, "\n"]
+          else
+            exp
+          end
+        end
+      end
+
+      def prepend_whitespace?(node)
+        return false unless %i[comment tag].include?(node.type)
+        !nuke_inner_whitespace?(node)
+      end
+
+      def nuke_inner_whitespace?(node)
+        case
+        when node.type == :tag
+          node.value[:nuke_inner_whitespace]
+        when node.parent.nil?
+          false
+        else
+          nuke_inner_whitespace?(node.parent)
+        end
+      end
+
+      def nuke_prev_whitespace?(node)
+        case node.type
+        when :tag
+          node.value[:nuke_outer_whitespace]
+        when :silent_script
+          !node.children.empty? && nuke_prev_whitespace?(node.children.first)
+        else
+          false
+        end
+      end
+
+      def nuke_outer_whitespace?(node)
+        return false if node.type != :tag
+        node.value[:nuke_outer_whitespace]
+      end
+
+      def rstrip_whitespace!(temple)
+        if temple[-1] == :whitespace
+          temple.delete_at(-1)
+        end
+      end
+
+      def insert_whitespace?(node)
+        return false if nuke_outer_whitespace?(node)
+
+        case node.type
+        when :doctype
+          node.value[:type] != 'xml'
+        when :comment, :plain, :tag
+          true
+        when :script
+          node.children.empty? && !nuke_inner_whitespace?(node)
+        when :filter
+          !%w[ruby].include?(node.value[:name])
+        else
+          false
+        end
+      end
+    end
+  end
+end