hamlit 1.7.2 → 2.0.1

data/lib/hamlit/compiler/children_compiler.rb

@@ -0,0 +1,111 @@
+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].freeze.include?(node.value[:name])
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/hamlit/compiler/comment_compiler.rb

@@ -0,0 +1,36 @@
+module Hamlit
+  class Compiler
+    class CommentCompiler
+      def compile(node, &block)
+        if node.value[:conditional]
+          compile_conditional_comment(node, &block)
+        else
+          compile_html_comment(node, &block)
+        end
+      end
+
+      private
+
+      def compile_html_comment(node, &block)
+        if node.children.empty?
+          [:html, :comment, [:static, " #{node.value[:text]} "]]
+        else
+          [:html, :comment, yield(node)]
+        end
+      end
+
+      def compile_conditional_comment(node, &block)
+        condition = node.value[:conditional]
+        if node.value[:conditional] =~ /\A\[(\[*[^\[\]]+\]*)\]/
+          condition = $1
+        end
+
+        if node.children.empty?
+          [:html, :condcomment, condition, [:static, " #{node.value[:text]} "]]
+        else
+          [:html, :condcomment, condition, yield(node)]
+        end
+      end
+    end
+  end
+end

data/lib/hamlit/compiler/doctype_compiler.rb

@@ -0,0 +1,45 @@
+module Hamlit
+  class Compiler
+    class DoctypeCompiler
+      def initialize(options = {})
+        @format = options[:format]
+      end
+
+      def compile(node)
+        case node.value[:type]
+        when 'xml'
+          xml_doctype
+        when ''
+          html_doctype(node)
+        else
+          [:html, :doctype, node.value[:type]]
+        end
+      end
+
+      private
+
+      def html_doctype(node)
+        version = node.value[:version] || :transitional
+        case @format
+        when :xhtml
+          [:html, :doctype, version]
+        when :html4
+          [:html, :doctype, :transitional]
+        when :html5
+          [:html, :doctype, :html]
+        else
+          [:html, :doctype, @format]
+        end
+      end
+
+      def xml_doctype
+        case @format
+        when :xhtml
+          [:static, "<?xml version='1.0' encoding='utf-8' ?>\n"]
+        else
+          [:multi]
+        end
+      end
+    end
+  end
+end

data/lib/hamlit/compiler/script_compiler.rb

@@ -0,0 +1,97 @@
+require 'hamlit/ruby_expression'
+require 'hamlit/static_analyzer'
+require 'hamlit/string_interpolation'
+
+module Hamlit
+  class Compiler
+    class ScriptCompiler
+      def initialize(identity)
+        @identity = identity
+      end
+
+      def compile(node, &block)
+        case
+        when node.children.empty? && RubyExpression.string_literal?(node.value[:text])
+          string_compile(node)
+        when node.children.empty? && StaticAnalyzer.static?(node.value[:text])
+          static_compile(node)
+        else
+          dynamic_compile(node, &block)
+        end
+      end
+
+      private
+
+      # String-interpolated plain text must be compiled with this method
+      def string_compile(node)
+        temple = [:multi]
+        StringInterpolation.compile(node.value[:text]).each do |type, value|
+          case type
+          when :static
+            value = Temple::Utils.escape_html(value) if node.value[:escape_html]
+            temple << [:static, value]
+          when :dynamic
+            if Hamlit::StaticAnalyzer.static?(value)
+              value = eval(value).to_s
+              value = Temple::Utils.escape_html(value) if node.value[:escape_html] || node.value[:escape_interpolation]
+              temple << [:static, value]
+            else
+              temple << [:escape, node.value[:escape_html] || node.value[:escape_interpolation], [:dynamic, value]]
+            end
+          end
+        end
+        temple << [:newline]
+      end
+
+      def static_compile(node)
+        str = eval("(#{node.value[:text]}).to_s")
+        if node.value[:escape_html]
+          str = Temple::Utils.escape_html(str)
+        elsif node.value[:preserve]
+          str = ::Hamlit::HamlHelpers.find_and_preserve(str, %w(textarea pre code))
+        end
+        [:multi, [:static, str], [:newline]]
+      end
+
+      def dynamic_compile(node, &block)
+        var = @identity.generate
+        temple = compile_script_assign(var, node, &block)
+        temple << compile_script_result(var, node)
+      end
+
+      def compile_script_assign(var, node, &block)
+        if node.children.empty?
+          [:multi,
+           [:code, "#{var} = (#{node.value[:text]}"],
+           [:newline],
+           [:code, ')'.freeze],
+          ]
+        else
+          [:multi,
+           [:code, "#{var} = #{node.value[:text]}"],
+           [:newline],
+           yield(node),
+           [:code, 'end'.freeze],
+          ]
+        end
+      end
+
+      def compile_script_result(result, node)
+        if !node.value[:escape_html] && node.value[:preserve]
+          result = find_and_preserve(result)
+        else
+          result = '(' << result << ').to_s'.freeze
+        end
+        [:escape, node.value[:escape_html], [:dynamic, result]]
+      end
+
+      def find_and_preserve(code)
+        %Q[::Hamlit::HamlHelpers.find_and_preserve(#{code}, %w(textarea pre code))]
+      end
+
+      def escape_html(temple)
+        [:escape, true, temple]
+      end
+    end
+  end
+end

data/lib/hamlit/compiler/silent_script_compiler.rb

@@ -0,0 +1,24 @@
+module Hamlit
+  class Compiler
+    class SilentScriptCompiler
+      def compile(node, &block)
+        if node.children.empty?
+          [:multi, [:code, node.value[:text]], [:newline]]
+        else
+          compile_with_children(node, &block)
+        end
+      end
+
+      private
+
+      def compile_with_children(node, &block)
+        temple = [:multi]
+        temple << [:code, node.value[:text]]
+        temple << [:newline]
+        temple << yield(node)
+        temple << [:code, 'end']
+        temple
+      end
+    end
+  end
+end

data/lib/hamlit/compiler/tag_compiler.rb

@@ -0,0 +1,69 @@
+require 'hamlit/parser/haml_util'
+require 'hamlit/compiler/attribute_compiler'
+require 'hamlit/string_interpolation'
+
+module Hamlit
+  class Compiler
+    class TagCompiler
+      def initialize(identity, options)
+        @autoclose = options[:autoclose]
+        @identity  = identity
+        @attribute_compiler = AttributeCompiler.new(identity, options)
+      end
+
+      def compile(node, &block)
+        attrs    = @attribute_compiler.compile(node)
+        contents = compile_contents(node, &block)
+        [:html, :tag, node.value[:name], attrs, contents]
+      end
+
+      private
+
+      def compile_contents(node, &block)
+        case
+        when !node.children.empty?
+          yield(node)
+        when node.value[:value].nil? && self_closing?(node)
+          nil
+        when node.value[:parse]
+          return compile_string(node) if RubyExpression.string_literal?(node.value[:value])
+
+          var = @identity.generate
+          [:multi,
+           [:code, "#{var} = (#{node.value[:value]}"],
+           [:newline],
+           [:code, ')'.freeze],
+           [:escape, node.value[:escape_html], [:dynamic, var]]
+          ]
+        else
+          [:static, node.value[:value]]
+        end
+      end
+
+      def compile_string(node)
+        temple = [:multi]
+        StringInterpolation.compile(node.value[:value]).each do |type, value|
+          case type
+          when :static
+            value = Temple::Utils.escape_html(value) if node.value[:escape_html]
+            temple << [:static, value]
+          when :dynamic
+            if Hamlit::StaticAnalyzer.static?(value)
+              value = eval(value).to_s
+              value = Temple::Utils.escape_html(value) if node.value[:escape_html] || node.value[:escape_interpolation]
+              temple << [:static, value]
+            else
+              temple << [:escape, node.value[:escape_html] || node.value[:escape_interpolation], [:dynamic, value]]
+            end
+          end
+        end
+        temple << [:newline]
+      end
+
+      def self_closing?(node)
+        return true if @autoclose.include?(node.value[:name])
+        node.value[:self_closing]
+      end
+    end
+  end
+end

data/lib/hamlit/engine.rb

@@ -1,22 +1,27 @@
 require 'temple'
+require 'hamlit/parser'
 require 'hamlit/compiler'
+require 'hamlit/escapable'
 require 'hamlit/html'
-require 'hamlit/parser'
-require 'hamlit/temple'
 
 module Hamlit
   class Engine < Temple::Engine
     define_options(
-      generator:   Temple::Generators::ArrayBuffer,
-      format:      :html,
-      attr_quote:  "'",
-      escape_html: true,
+      generator:    Temple::Generators::ArrayBuffer,
+      format:       :html,
+      attr_quote:   "'",
+      escape_html:  true,
+      escape_attrs: true,
+      autoclose:    %w(area base basefont br col command embed frame
+                       hr img input isindex keygen link menuitem meta
+                       param source track wbr),
+      filename:     "",
     )
 
     use Parser
     use Compiler
     use HTML
-    filter :Escapable
+    use Escapable
     filter :ControlFlow
     filter :MultiFlattener
     filter :StaticMerger

data/lib/hamlit/error.rb

@@ -0,0 +1,14 @@
+module Hamlit
+  class Error < StandardError
+    attr_reader :line
+
+    def initialize(message = nil, line = nil)
+      super(message)
+      @line = line
+    end
+  end
+
+  class SyntaxError < Error; end
+  class InternalError < Error; end
+  class FilterNotFound < Error; end
+end

data/lib/hamlit/escapable.rb

@@ -0,0 +1,12 @@
+require 'hamlit/utils'
+
+module Hamlit
+  class Escapable < Temple::Filters::Escapable
+    def initialize(opts = {})
+      super
+      @escape_code = options[:escape_code] ||
+        "::Hamlit::Utils.escape_html#{options[:use_html_safe] ? '_safe' : ''}((%s))"
+      @escaper = eval("proc {|v| #{@escape_code % 'v'} }")
+    end
+  end
+end