hamlit 2.9.3

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,46 @@
+# frozen_string_literal: true
+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,102 @@
+# frozen_string_literal: true
+require 'temple/static_analyzer'
+require 'hamlit/ruby_expression'
+require 'hamlit/string_splitter'
+
+module Hamlit
+  class Compiler
+    class ScriptCompiler
+      def initialize(identity)
+        @identity = identity
+      end
+
+      def compile(node, &block)
+        no_children = node.children.empty?
+        case
+        when no_children && node.value[:escape_interpolation]
+          compile_interpolated_plain(node)
+        when no_children && RubyExpression.string_literal?(node.value[:text])
+          delegate_optimization(node)
+        when no_children && Temple::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
+      # because we have to escape only interpolated values.
+      def compile_interpolated_plain(node)
+        temple = [:multi]
+        StringSplitter.compile(node.value[:text]).each do |type, value|
+          case type
+          when :static
+            temple << [:static, value]
+          when :dynamic
+            temple << [:escape, node.value[:escape_interpolation], [:dynamic, value]]
+          end
+        end
+        temple << [:newline]
+      end
+
+      # :dynamic is optimized in other filter: StringSplitter
+      def delegate_optimization(node)
+        [:multi,
+         [:escape, node.value[:escape_html], [:dynamic, node.value[:text]]],
+         [:newline],
+        ]
+      end
+
+      def static_compile(node)
+        str = eval(node.value[:text]).to_s
+        if node.value[:escape_html]
+          str = Hamlit::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, ')'],
+          ]
+        else
+          [:multi,
+           [:block, "#{var} = #{node.value[:text]}",
+            [:multi, [:newline], yield(node)],
+           ],
+          ]
+        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"
+        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 @@
+# frozen_string_literal: true
+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)
+        [:multi,
+         [:block, node.value[:text],
+          [:multi, [:newline], yield(node)],
+         ],
+        ]
+      end
+    end
+  end
+end

data/lib/hamlit/compiler/tag_compiler.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+require 'hamlit/parser/haml_util'
+require 'hamlit/attribute_compiler'
+require 'hamlit/string_splitter'
+
+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_interpolated_plain(node) if node.value[:escape_interpolation]
+          return delegate_optimization(node) if RubyExpression.string_literal?(node.value[:value])
+          return delegate_optimization(node) if Temple::StaticAnalyzer.static?(node.value[:value])
+
+          var = @identity.generate
+          [:multi,
+           [:code, "#{var} = (#{node.value[:value]}"],
+           [:newline],
+           [:code, ')'],
+           [:escape, node.value[:escape_html], [:dynamic, var]]
+          ]
+        else
+          [:static, node.value[:value]]
+        end
+      end
+
+      # :dynamic is optimized in other filters: StringSplitter or StaticAnalyzer
+      def delegate_optimization(node)
+        [:multi,
+         [:escape, node.value[:escape_html], [:dynamic, node.value[:value]]],
+         [:newline],
+        ]
+      end
+
+      # We should handle interpolation here to escape only interpolated values.
+      def compile_interpolated_plain(node)
+        temple = [:multi]
+        StringSplitter.compile(node.value[:value]).each do |type, value|
+          case type
+          when :static
+            temple << [:static, value]
+          when :dynamic
+            temple << [:escape, node.value[:escape_interpolation], [:dynamic, value]]
+          end
+        end
+        temple << [:newline]
+      end
+
+      def self_closing?(node)
+        return true if @autoclose && @autoclose.include?(node.value[:name])
+        node.value[:self_closing]
+      end
+    end
+  end
+end

data/lib/hamlit/engine.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require 'temple'
+require 'hamlit/parser'
+require 'hamlit/compiler'
+require 'hamlit/escapable'
+require 'hamlit/force_escapable'
+require 'hamlit/html'
+require 'hamlit/string_splitter'
+
+module Hamlit
+  class Engine < Temple::Engine
+    define_options(
+      :buffer_class,
+      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
+    use StringSplitter
+    filter :StaticAnalyzer
+    use Escapable
+    use ForceEscapable
+    filter :ControlFlow
+    filter :MultiFlattener
+    filter :StaticMerger
+    use :Generator, -> { options[:generator] }
+  end
+end

data/lib/hamlit/error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+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,13 @@
+# frozen_string_literal: true
+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

data/lib/hamlit/filters.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require 'hamlit/filters/base'
+require 'hamlit/filters/text_base'
+require 'hamlit/filters/tilt_base'
+require 'hamlit/filters/coffee'
+require 'hamlit/filters/css'
+require 'hamlit/filters/erb'
+require 'hamlit/filters/escaped'
+require 'hamlit/filters/javascript'
+require 'hamlit/filters/less'
+require 'hamlit/filters/markdown'
+require 'hamlit/filters/plain'
+require 'hamlit/filters/preserve'
+require 'hamlit/filters/ruby'
+require 'hamlit/filters/sass'
+require 'hamlit/filters/scss'
+require 'hamlit/filters/cdata'
+
+module Hamlit
+  class Filters
+    @registered = {}
+
+    class << self
+      attr_reader :registered
+
+      def remove_filter(name)
+        registered.delete(name.to_s.downcase.to_sym)
+        if constants.map(&:to_s).include?(name.to_s)
+          remove_const name.to_sym
+        end
+      end
+
+      private
+
+      def register(name, compiler)
+        registered[name] = compiler
+      end
+    end
+
+    register :coffee,       Coffee
+    register :coffeescript, CoffeeScript
+    register :css,          Css
+    register :erb,          Erb
+    register :escaped,      Escaped
+    register :javascript,   Javascript
+    register :less,         Less
+    register :markdown,     Markdown
+    register :plain,        Plain
+    register :preserve,     Preserve
+    register :ruby,         Ruby
+    register :sass,         Sass
+    register :scss,         Scss
+    register :cdata,        Cdata
+
+    def initialize(options = {})
+      @options = options
+      @compilers = {}
+    end
+
+    def compile(node)
+      node.value[:text] ||= ''
+      find_compiler(node).compile(node)
+    end
+
+    private
+
+    def find_compiler(node)
+      name = node.value[:name].to_sym
+      compiler = Filters.registered[name]
+      raise FilterNotFound.new("FilterCompiler for '#{name}' was not found", node.line.to_i - 1) unless compiler
+
+      @compilers[name] ||= compiler.new(@options)
+    end
+  end
+end

data/lib/hamlit/filters/base.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require 'hamlit/parser/haml_util'
+
+module Hamlit
+  class Filters
+    class Base
+      def initialize(options = {})
+        @format = options[:format]
+      end
+    end
+  end
+end