hamlit 1.7.2 → 2.0.1

data/hamlit.gemspec

@@ -4,40 +4,39 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'hamlit/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "hamlit"
+  spec.name          = 'hamlit'
   spec.version       = Hamlit::VERSION
-  spec.authors       = ["Takashi Kokubun"]
-  spec.email         = ["takashikkbn@gmail.com"]
+  spec.authors       = ['Takashi Kokubun']
+  spec.email         = ['takashikkbn@gmail.com']
+
   spec.summary       = %q{High Performance Haml Implementation}
   spec.description   = %q{High Performance Haml Implementation}
-  spec.homepage      = "https://github.com/k0kubun/hamlit"
-  spec.license       = "MIT"
+  spec.homepage      = 'https://github.com/k0kubun/hamlit'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|hamlit1|sample)/}) } + `git -C ext/hamlit/houdini ls-files -z`.split("\x0").map { |path| "ext/hamlit/houdini/#{path}" }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.extensions    = ['ext/hamlit/extconf.rb']
+  spec.require_paths = ['lib']
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 2.0.0"
+  spec.add_dependency 'escape_utils'
+  spec.add_dependency 'temple', '~> 0.7.6'
+  spec.add_dependency 'thor'
+  spec.add_dependency 'tilt'
 
-  spec.add_dependency "escape_utils"
-  spec.add_dependency "temple", "~> 0.7.6"
-  spec.add_dependency "thor"
-  spec.add_dependency "tilt"
-  spec.add_development_dependency "benchmark-ips"
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "coffee-script"
-  spec.add_development_dependency "coveralls"
-  spec.add_development_dependency "erubis"
-  spec.add_development_dependency "faml"
-  spec.add_development_dependency "haml"
-  spec.add_development_dependency "less"
-  spec.add_development_dependency "pry"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "redcarpet"
-  spec.add_development_dependency "rspec", ">= 3"
-  spec.add_development_dependency "sass"
-  spec.add_development_dependency "simplecov"
-  spec.add_development_dependency "slim"
-  spec.add_development_dependency "therubyracer"
-  spec.add_development_dependency "unindent"
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'coffee-script'
+  spec.add_development_dependency 'erubis'
+  spec.add_development_dependency 'faml'
+  spec.add_development_dependency 'less'
+  spec.add_development_dependency 'minitest-reporters', '~> 1.1'
+  spec.add_development_dependency 'rails', '>= 4.0.0'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake-compiler'
+  spec.add_development_dependency 'redcarpet'
+  spec.add_development_dependency 'sass'
+  spec.add_development_dependency 'slim'
+  spec.add_development_dependency 'therubyracer'
+  spec.add_development_dependency 'unindent'
 end

data/lib/hamlit.rb

@@ -1,8 +1,10 @@
 require 'hamlit/engine'
-require 'hamlit/template'
+require 'hamlit/error'
 require 'hamlit/version'
+require 'hamlit/template'
 
 begin
+  require 'rails'
   require 'hamlit/railtie'
 rescue LoadError
 end

data/lib/hamlit/attribute_builder.rb

@@ -0,0 +1,12 @@
+require 'hamlit/hamlit'
+require 'hamlit/object_ref'
+require 'hamlit/utils'
+
+module Hamlit::AttributeBuilder
+  BOOLEAN_ATTRIBUTES = %w[disabled readonly multiple checked autobuffer
+                       autoplay controls loop selected hidden scoped async
+                       defer reversed ismap seamless muted required
+                       autofocus novalidate formnovalidate open pubdate
+                       itemscope allowfullscreen default inert sortable
+                       truespeed typemustmatch].freeze
+end

data/lib/hamlit/cli.rb

@@ -3,80 +3,81 @@ require 'thor'
 
 module Hamlit
   class CLI < Thor
-    IGNORED_COMPILERS = ['HTML'].freeze
-
     desc 'render HAML', 'Render haml template'
     def render(file)
       code = generate_code(file)
       puts eval(code)
     end
 
-    desc 'compile HAML', 'Show generated rendering code'
+    desc 'compile HAML', 'Show compile result'
+    option :actionview, type: :boolean, default: false, aliases: %w[-a]
     def compile(file)
-      code = generate_code(file)
-      puts code
+      print_code generate_code(file)
     end
 
-    desc 'temple HAML', 'Show a compile result of hamlit AST'
+    desc 'temple HAML', 'Show temple intermediate expression'
     def temple(file)
-      pp generate_temple_ast(file)
+      pp generate_temple(file)
     end
 
     desc 'parse HAML', 'Show parse result'
     def parse(file)
-      pp generate_hamlit_ast(file)
+      pp generate_ast(file)
     end
 
     private
 
-    # 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 generate_code(file)
       template = File.read(file)
-      Hamlit::Engine.new.call(template)
-    end
-
-    def generate_temple_ast(file)
-      chain = Hamlit::Engine.chain.map(&:first).map(&:to_s)
-      compilers = chain.select do |compiler|
-        compiler =~ /\AHamlit::/ && !ignored_compilers.include?(compiler)
+      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)
+        source = <<-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.call(template)
       end
+    end
 
+    def generate_ast(file)
       template = File.read(file)
-      compilers.inject(template) do |exp, compiler|
-        Module.const_get(compiler).new.call(exp)
-      end
+      Hamlit::Parser.new(escape_html: true, escape_attrs: true, ugly: true).call(template)
     end
 
-    def generate_hamlit_ast(file)
-      template = File.read(file)
-      Hamlit::Parser.new.call(template)
+    def generate_temple(file)
+      ast = generate_ast(file)
+      Hamlit::Compiler.new.call(ast)
     end
 
-    # Enable colored pretty printing only for development environment.
-    # I don't think it is a good idea to add pry as runtime dependency
-    # just for debug color printing.
-    def pp(arg)
-      begin
-        require 'pry'
-        Pry::ColorPrinter.pp(arg)
-      rescue LoadError
-        require 'pp'
-        super(arg)
-      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 ignored_compilers
-      IGNORED_COMPILERS.map { |name| "Hamlit::#{name}" }
+    def print_code(code)
+      require 'pry'
+      puts Pry.Code(code).highlighted
+    rescue LoadError
+      puts code
     end
 
-    def symbolize_keys(hash)
-      {}.tap { |h| hash.each { |k, v| h[k.to_sym] = v } }
+    # Enable colored pretty printing only for development environment.
+    def pp(arg)
+      require 'pry'
+      Pry::ColorPrinter.pp(arg)
+    rescue LoadError
+      require 'pp'
+      super(arg)
     end
   end
 end

data/lib/hamlit/compiler.rb

@@ -1,20 +1,96 @@
-require 'hamlit/compilers/attributes'
-require 'hamlit/compilers/comment'
-require 'hamlit/compilers/doctype'
-require 'hamlit/compilers/filter'
-require 'hamlit/compilers/script'
-require 'hamlit/compilers/strip'
-require 'hamlit/compilers/text'
-require 'temple/html/filter'
+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 < Temple::HTML::Filter
-    include Compilers::Attributes
-    include Compilers::Comment
-    include Compilers::Doctype
-    include Compilers::Filter
-    include Compilers::Script
-    include Compilers::Strip
-    include Compilers::Text
+  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/attribute_compiler.rb

@@ -0,0 +1,148 @@
+require 'hamlit/attribute_builder'
+require 'hamlit/hash_parser'
+require 'hamlit/ruby_expression'
+require 'hamlit/static_analyzer'
+require 'hamlit/string_interpolation'
+
+module Hamlit
+  class Compiler
+    class AttributeCompiler
+      def initialize(identity, options)
+        @identity = identity
+        @quote  = options[:attr_quote]
+        @format = options[:format]
+        @escape_attrs = options[:escape_attrs]
+      end
+
+      def compile(node)
+        hashes = []
+        return runtime_compile(node) if node.value[:object_ref] != :nil
+        node.value[:attributes_hashes].each do |attribute_str|
+          hash = HashParser.parse(attribute_str)
+          return runtime_compile(node) unless hash
+          hashes << hash
+        end
+        static_compile(node.value[:attributes], hashes)
+      end
+
+      private
+
+      def runtime_compile(node)
+        attrs = node.value[:attributes_hashes]
+        attrs.unshift(node.value[:attributes].inspect) if node.value[:attributes] != {}
+
+        args = [@escape_attrs, @quote, @format].map(&:inspect).push(node.value[:object_ref]) + attrs
+        [:html, :attrs, [:dynamic, "::Hamlit::AttributeBuilder.build(#{args.join(', ')})"]]
+      end
+
+      def static_compile(static_hash, dynamic_hashes)
+        temple = [:html, :attrs]
+        keys = [*static_hash.keys, *dynamic_hashes.map(&:keys).flatten].uniq.sort
+        keys.each do |key|
+          values = [[:static, static_hash[key]], *dynamic_hashes.map { |h| [:dynamic, h[key]] }]
+          values.select! { |_, exp| exp != nil }
+
+          case key
+          when 'id'.freeze
+            compile_id!(temple, key, values)
+          when 'class'.freeze
+            compile_class!(temple, key, values)
+          when 'data'.freeze
+            compile_data!(temple, key, values)
+          when *AttributeBuilder::BOOLEAN_ATTRIBUTES, /\Adata-/
+            compile_boolean!(temple, key, values)
+          else
+            compile_common!(temple, key, values)
+          end
+        end
+        temple
+      end
+
+      def compile_id!(temple, key, values)
+        build_code = attribute_builder(:id, values)
+        if values.all? { |type, exp| type == :static || StaticAnalyzer.static?(exp) }
+          temple << [:html, :attr, key, [:static, eval(build_code)]]
+        else
+          temple << [:html, :attr, key, [:dynamic, build_code]]
+        end
+      end
+
+      def compile_class!(temple, key, values)
+        build_code = attribute_builder(:class, values)
+        if values.all? { |type, exp| type == :static || StaticAnalyzer.static?(exp) }
+          temple << [:html, :attr, key, [:static, eval(build_code)]]
+        else
+          temple << [:html, :attr, key, [:dynamic, build_code]]
+        end
+      end
+
+      def compile_data!(temple, key, values)
+        args = [@escape_attrs.inspect, @quote.inspect, values.map { |v| literal_for(v) }]
+        build_code = "::Hamlit::AttributeBuilder.build_data(#{args.join(', ')})"
+
+        if values.all? { |type, exp| type == :static || StaticAnalyzer.static?(exp) }
+          temple << [:static, eval(build_code)]
+        else
+          temple << [:dynamic, build_code]
+        end
+      end
+
+      def compile_boolean!(temple, key, values)
+        exp = literal_for(values.last)
+
+        if StaticAnalyzer.static?(exp)
+          value = eval(exp)
+          case value
+          when true then temple << [:html, :attr, key, @format == :xhtml ? [:static, key] : [:multi]]
+          when false, nil
+          else temple << [:html, :attr, key, [:escape, @escape_attrs, [:static, value]]]
+          end
+        else
+          var = @identity.generate
+          temple << [
+            :case, "(#{var} = (#{exp}))",
+            ['true', [:html, :attr, key, @format == :xhtml ? [:static, key] : [:multi]]],
+            ['false, nil', [:multi]],
+            [:else, [:multi, [:static, " #{key}=#{@quote}"], [:escape, @escape_attrs, [:dynamic, var]], [:static, @quote]]],
+          ]
+        end
+      end
+
+      def compile_common!(temple, key, values)
+        type, exp = values.last
+
+        case
+        when type == :dynamic && StaticAnalyzer.static?(exp)
+          temple << [:html, :attr, key, [:escape, @escape_attrs, [:static, eval(exp).to_s]]]
+        when type == :dynamic && RubyExpression.string_literal?(exp)
+          value_temple = [:multi]
+          StringInterpolation.compile(exp).each do |type, v|
+            case type
+            when :static
+              value_temple << [:escape, @escape_attrs, [:static, v]]
+            when :dynamic
+              if Hamlit::StaticAnalyzer.static?(v)
+                value_temple << [:escape, @escape_attrs, [:static, eval(v).to_s]]
+              else
+                value_temple << [:escape, @escape_attrs, [:dynamic, v]]
+              end
+            end
+          end
+          temple << [:html, :attr, key, value_temple]
+        else
+          temple << [:html, :attr, key, [:escape, @escape_attrs, [type, exp]]]
+        end
+      end
+
+      def attribute_builder(type, values)
+        args = [@escape_attrs.inspect, *values.map { |v| literal_for(v) }]
+        "::Hamlit::AttributeBuilder.build_#{type}(#{args.join(', ')})"
+      end
+
+      def literal_for(value)
+        type, exp = value
+        type == :static ? exp.inspect : exp
+      end
+    end
+  end
+end