hamlit 2.9.1-java

data/lib/hamlit/filters/coffee.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module Hamlit
+  class Filters
+    class Coffee < TiltBase
+      def compile(node)
+        require 'tilt/coffee' if explicit_require?('coffee')
+        temple = [:multi]
+        temple << [:static, "<script>\n"]
+        temple << compile_with_tilt(node, 'coffee', indent_width: 2)
+        temple << [:static, "</script>"]
+        temple
+      end
+    end
+
+    CoffeeScript = Coffee
+  end
+end

data/lib/hamlit/filters/css.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module Hamlit
+  class Filters
+    class Css < TextBase
+      def compile(node)
+        case @format
+        when :xhtml
+          compile_xhtml(node)
+        else
+          compile_html(node)
+        end
+      end
+
+      private
+
+      def compile_html(node)
+        temple = [:multi]
+        temple << [:static, "<style>\n"]
+        compile_text!(temple, node, '  ')
+        temple << [:static, "\n</style>"]
+        temple
+      end
+
+      def compile_xhtml(node)
+        temple = [:multi]
+        temple << [:static, "<style type='text/css'>\n  /*<![CDATA[*/\n"]
+        compile_text!(temple, node, '    ')
+        temple << [:static, "\n  /*]]>*/\n</style>"]
+        temple
+      end
+    end
+  end
+end

data/lib/hamlit/filters/erb.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module Hamlit
+  class Filters
+    class Erb < TiltBase
+      def compile(node)
+        compile_with_tilt(node, 'erb')
+      end
+    end
+  end
+end

data/lib/hamlit/filters/escaped.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Hamlit
+  class Filters
+    class Escaped < Base
+      def compile(node)
+        text = node.value[:text].rstrip
+        temple = compile_text(text)
+        [:escape, true, temple]
+      end
+
+      private
+
+      def compile_text(text)
+        if ::Hamlit::HamlUtil.contains_interpolation?(text)
+          [:dynamic, ::Hamlit::HamlUtil.slow_unescape_interpolation(text)]
+        else
+          [:static, text]
+        end
+      end
+    end
+  end
+end

data/lib/hamlit/filters/javascript.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module Hamlit
+  class Filters
+    class Javascript < TextBase
+      def compile(node)
+        case @format
+        when :xhtml
+          compile_xhtml(node)
+        else
+          compile_html(node)
+        end
+      end
+
+      private
+
+      def compile_html(node)
+        temple = [:multi]
+        temple << [:static, "<script>\n"]
+        compile_text!(temple, node, '  ')
+        temple << [:static, "\n</script>"]
+        temple
+      end
+
+      def compile_xhtml(node)
+        temple = [:multi]
+        temple << [:static, "<script type='text/javascript'>\n  //<![CDATA[\n"]
+        compile_text!(temple, node, '    ')
+        temple << [:static, "\n  //]]>\n</script>"]
+        temple
+      end
+    end
+  end
+end

data/lib/hamlit/filters/less.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# LESS support is deprecated since it requires therubyracer.gem,
+# which is hard to maintain.
+#
+# It's not supported in Sprockets 3.0+ too.
+# https://github.com/sstephenson/sprockets/pull/547
+module Hamlit
+  class Filters
+    class Less < TiltBase
+      def compile(node)
+        require 'tilt/less' if explicit_require?('less')
+        temple = [:multi]
+        temple << [:static, "<style>\n"]
+        temple << compile_with_tilt(node, 'less', indent_width: 2)
+        temple << [:static, '</style>']
+        temple
+      end
+    end
+  end
+end

data/lib/hamlit/filters/markdown.rb

@@ -0,0 +1,10 @@
+module Hamlit
+  class Filters
+    class Markdown < TiltBase
+      def compile(node)
+        require 'tilt/redcarpet' if explicit_require?('markdown')
+        compile_with_tilt(node, 'markdown')
+      end
+    end
+  end
+end

data/lib/hamlit/filters/plain.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'hamlit/string_splitter'
+
+module Hamlit
+  class Filters
+    class Plain < Base
+      def compile(node)
+        text = node.value[:text]
+        text = text.rstrip unless ::Hamlit::HamlUtil.contains_interpolation?(text) # for compatibility
+        [:multi, *compile_plain(text)]
+      end
+
+      private
+
+      def compile_plain(text)
+        string_literal = ::Hamlit::HamlUtil.unescape_interpolation(text)
+        StringSplitter.compile(string_literal).map do |temple|
+          type, str = temple
+          case type
+          when :dynamic
+            [:escape, false, [:dynamic, str]]
+          else
+            temple
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hamlit/filters/preserve.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Hamlit
+  class Filters
+    class Preserve < Base
+      def compile(node)
+        text = node.value[:text].rstrip + "\n"
+        text = text.gsub("\n", '&#x000A;')
+        compile_text(text)
+      end
+
+      private
+
+      def compile_text(text)
+        if ::Hamlit::HamlUtil.contains_interpolation?(text)
+          [:dynamic, ::Hamlit::HamlUtil.slow_unescape_interpolation(text)]
+        else
+          [:static, text]
+        end
+      end
+    end
+  end
+end

data/lib/hamlit/filters/ruby.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module Hamlit
+  class Filters
+    class Ruby < Base
+      def compile(node)
+        [:code, node.value[:text]]
+      end
+    end
+  end
+end

data/lib/hamlit/filters/sass.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Hamlit
+  class Filters
+    class Sass < TiltBase
+      def compile(node)
+        require 'tilt/sass' if explicit_require?('sass')
+        temple = [:multi]
+        temple << [:static, "<style>\n"]
+        temple << compile_with_tilt(node, 'sass', indent_width: 2)
+        temple << [:static, "</style>"]
+        temple
+      end
+    end
+  end
+end

data/lib/hamlit/filters/scss.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Hamlit
+  class Filters
+    class Scss < TiltBase
+      def compile(node)
+        require 'tilt/sass' if explicit_require?('scss')
+        temple = [:multi]
+        temple << [:static, "<style>\n"]
+        temple << compile_with_tilt(node, 'scss', indent_width: 2)
+        temple << [:static, "</style>"]
+        temple
+      end
+    end
+  end
+end

data/lib/hamlit/filters/text_base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+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,49 @@
+# frozen_string_literal: true
+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!(/^/, ' ' * indent_width)
+      end
+
+      def explicit_require?(needed_registration)
+        Gem::Version.new(Tilt::VERSION) >= Gem::Version.new('2.0.0') &&
+          !Tilt.registered?(needed_registration)
+      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/force_escapable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'hamlit/escapable'
+
+module Hamlit
+  # This module allows Temple::Filter to dispatch :fescape on `#compile`.
+  module FescapeDispathcer
+    def on_fescape(flag, exp)
+      [:fescape, flag, compile(exp)]
+    end
+  end
+  ::Temple::Filter.include FescapeDispathcer
+
+  # Unlike Hamlit::Escapable, this escapes value even if it's html_safe.
+  class ForceEscapable < Escapable
+    def initialize(opts = {})
+      super
+      @escape_code = options[:escape_code] || "::Hamlit::Utils.escape_html((%s))"
+      @escaper = eval("proc {|v| #{@escape_code % 'v'} }")
+    end
+
+    alias_method :on_fescape, :on_escape
+
+    # ForceEscapable doesn't touch :escape expression.
+    # This method is not used if it's inserted after Hamlit::Escapable.
+    def on_escape(flag, exp)
+      [:escape, flag, compile(exp)]
+    end
+  end
+end

data/lib/hamlit/helpers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Hamlit
+  module Helpers
+    extend self
+
+    # The same as original Haml::Helpers#preserve without block support.
+    def preserve(input)
+      # https://github.com/haml/haml/blob/4.1.0.beta.1/lib/haml/helpers.rb#L130-L133
+      s = input.to_s.chomp("\n")
+      s.gsub!(/\n/, '
')
+      s.delete!("\r")
+      s
+    end
+  end
+end

data/lib/hamlit/html.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Hamlit
+  class HTML < Temple::HTML::Fast
+    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,13 @@
+# frozen_string_literal: true
+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,30 @@
+# frozen_string_literal: true
+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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+# Hamlit::Parser uses original Haml::Parser to generate Haml AST.
+# hamlit/parser/haml_* are modules originally in haml gem.
+
+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'
+
+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 call(template)
+      template = Hamlit::HamlUtil.check_haml_encoding(template) do |msg, line|
+        raise Hamlit::Error.new(msg, line)
+      end
+      HamlParser.new(template, HamlOptions.new(@options)).parse
+    rescue ::Hamlit::HamlError => e
+      error_with_lineno(e)
+    end
+
+    private
+
+    def error_with_lineno(error)
+      return error if error.line
+
+      trace = error.backtrace.first
+      return error unless trace
+
+      line = trace.match(/\d+\z/).to_s.to_i
+      HamlSyntaxError.new(error.message, line)
+    end
+  end
+end