hamlit 0.1.0

data/lib/hamlit/concerns/line_reader.rb

@@ -0,0 +1,60 @@
+module Hamlit
+  module Concerns
+    module LineReader
+      def reset_lines(lines)
+        @lines = lines
+        @current_lineno = -1
+      end
+
+      def current_line
+        @lines[@current_lineno]
+      end
+
+      # Return nearest line ignoring empty lines.
+      def next_line
+        lineno = @current_lineno + 1
+        while @lines[lineno] && empty_line?(@lines[lineno])
+          lineno += 1
+        end
+        @lines[lineno]
+      end
+
+      def empty_line?(line)
+        line =~ /\A *\Z/
+      end
+
+      def skip_lines
+        while next_indent >= @current_indent
+          @current_lineno += 1
+        end
+      end
+
+      def read_lines
+        lines = []
+        while read_line?
+          lines << @lines[@current_lineno + 1]
+          @current_lineno += 1
+        end
+        trim_lines(lines)
+      end
+
+      private
+
+      def trim_lines(lines)
+        size = (lines.first || '').index(/[^\s]/) || 0
+        lines.map { |line| line.gsub(/\A {#{size}}/, '') }
+      end
+
+      def read_line?
+        return true if count_indent(next_line, strict: false) >= @current_indent
+
+        line = @lines[@current_lineno + 1]
+        return false unless line
+
+        # NOTE: preserve filter also requires an empty line
+        line.gsub(/ /, '').length == 0
+      end
+    end
+  end
+end
+

data/lib/hamlit/concerns/registerable.rb

@@ -0,0 +1,24 @@
+module Hamlit
+  class NotFound < StandardError
+    def initialize(name)
+      super(%Q{Filter "#{name}" is not defined.})
+    end
+  end
+
+  module Concerns
+    module Registerable
+      def registered
+        @registered ||= {}
+      end
+
+      def register(name, compiler)
+        registered[name.to_sym] = compiler
+      end
+
+      def find(name)
+        raise NotFound.new(name) unless registered[name.to_sym]
+        registered[name.to_sym]
+      end
+    end
+  end
+end

data/lib/hamlit/concerns/ripperable.rb

@@ -0,0 +1,20 @@
+require 'ripper'
+
+module Hamlit
+  module Concerns
+    module Ripperable
+      TYPE_POSITION = 1
+
+      def skip_tokens!(tokens, *types)
+        while types.include?(type_of(tokens.first))
+          tokens.shift
+        end
+      end
+
+      def type_of(token)
+        return nil unless token
+        token[TYPE_POSITION]
+      end
+    end
+  end
+end

data/lib/hamlit/concerns/string_interpolation.rb

@@ -0,0 +1,48 @@
+module Hamlit
+  module Concerns
+    module StringInterpolation
+      def string_literal(str)
+        unescape_interpolation(str)
+      end
+
+      def contains_interpolation?(str)
+        /#[\{$@]/ === str
+      end
+
+      private
+
+      def unescape_interpolation(str)
+        res = ''
+        rest = handle_interpolation(str.inspect) do |scan|
+          escapes = (scan[2].size - 1) / 2
+          res << scan.matched[0...-3 - escapes]
+          if escapes % 2 == 1
+            res << '#{'
+          else
+            content = eval('"' + balance(scan, ?{, ?}, 1)[0][0...-1] + '"')
+            res << '#{' + content + '}'
+          end
+        end
+        res + rest
+      end
+
+      def handle_interpolation(str)
+        scan = StringScanner.new(str)
+        yield scan while scan.scan(/(.*?)(\\*)\#\{/)
+        scan.rest
+      end
+
+      def balance(scanner, start, finish, count = 0)
+        str = ''
+        scanner = StringScanner.new(scanner) unless scanner.is_a? StringScanner
+        regexp = Regexp.new("(.*?)[\\#{start.chr}\\#{finish.chr}]", Regexp::MULTILINE)
+        while scanner.scan(regexp)
+          str << scanner.matched
+          count += 1 if scanner.matched[-1] == start
+          count -= 1 if scanner.matched[-1] == finish
+          return [str.strip, scanner.rest] if count == 0
+        end
+      end
+    end
+  end
+end

data/lib/hamlit/engine.rb

@@ -0,0 +1,42 @@
+require 'temple'
+require 'hamlit/compiler'
+require 'hamlit/html/pretty'
+require 'hamlit/html/ugly'
+require 'hamlit/parser'
+
+module Hamlit
+  class Engine < Temple::Engine
+    define_options(
+      generator:  Temple::Generators::ArrayBuffer,
+      format:     :html,
+      attr_quote: "'",
+      ugly:       true,
+    )
+
+    use Parser
+    use Compiler
+    use :Html, -> { create(html_compiler) }
+    filter :Escapable
+    filter :ControlFlow
+    filter :MultiFlattener
+    filter :StaticMerger
+    use :Generator, -> { create(options[:generator]) }
+
+    private
+
+    def create(klass)
+      valid_options = options.to_hash.select do |key, value|
+        klass.options.valid_key?(key)
+      end
+      klass.new(valid_options)
+    end
+
+    def html_compiler
+      if options[:ugly]
+        HTML::Ugly
+      else
+        HTML::Pretty
+      end
+    end
+  end
+end

data/lib/hamlit/filters/base.rb

@@ -0,0 +1,44 @@
+module Hamlit
+  module Filters
+    class Base
+      attr_reader :options
+
+      def self.indent_source(source, indent_width: 0)
+        lines = source.split("\n")
+        self.new.compile_lines(lines, indent_width: indent_width)
+      end
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def compile(lines)
+        raise NotImplementedError
+      end
+
+      def compile_lines(lines, indent_width: 0)
+        base  = (lines.first || '').index(/[^\s]/) || 0
+        width = indent_width - base
+        width = 0 if width < 0
+
+        lines = strip_last(lines).map do |line|
+          ' ' * width + line
+        end
+
+        text = lines.join("\n") + "\n"
+        text
+      end
+
+      private
+
+      # NOTE: empty line is reserved for preserve filter.
+      def strip_last(lines)
+        lines = lines.dup
+        while lines.last && lines.last.length == 0
+          lines.delete_at(-1)
+        end
+        lines
+      end
+    end
+  end
+end

data/lib/hamlit/filters/coffee.rb

@@ -0,0 +1,12 @@
+require 'hamlit/filters/tilt'
+
+module Hamlit
+  module Filters
+    class Coffee < Filters::Tilt
+      def compile(lines)
+        ast = [:html, :tag, 'script', [:html, :attrs]]
+        compile_with_tilt('coffee', lines.join("\n"), ast)
+      end
+    end
+  end
+end

data/lib/hamlit/filters/css.rb

@@ -0,0 +1,34 @@
+require 'hamlit/filters/base'
+
+module Hamlit
+  module Filters
+    class Css < Base
+      def compile(lines)
+        return compile_xhtml(lines) if options[:format] == :xhtml
+
+        compile_html(lines)
+      end
+
+      private
+
+      def compile_html(lines)
+        ast = [:haml, :text, compile_lines(lines, indent_width: 2)]
+        ast = [:multi, [:static, "\n"], ast]
+        ast = [:html, :tag, 'style', [:html, :attrs], ast]
+        ast
+      end
+
+      def compile_xhtml(lines)
+        attr  = [:html, :attr, 'type', [:static, 'text/css']]
+        attrs = [:html, :attrs, attr]
+
+        multi = [:multi, [:static, "\n"]]
+        multi << [:static, "  /*<![CDATA[*/\n"]
+        multi << [:haml, :text, compile_lines(lines, indent_width: 4)]
+        multi << [:static, "  /*]]>*/\n"]
+
+        [:html, :tag, 'style', attrs, multi]
+      end
+    end
+  end
+end

data/lib/hamlit/filters/erb.rb

@@ -0,0 +1,11 @@
+require 'hamlit/filters/tilt'
+
+module Hamlit
+  module Filters
+    class Erb < Filters::Tilt
+      def compile(lines)
+        compile_with_tilt('erb', lines.join("\n"), [], indent_width: 0)
+      end
+    end
+  end
+end

data/lib/hamlit/filters/escaped.rb

@@ -0,0 +1,19 @@
+require 'hamlit/filters/base'
+
+module Hamlit
+  module Filters
+    class Escaped < Base
+      def compile(lines)
+        ast = [:haml, :text, lines.join("\n")]
+        ast = [:multi, escape_html(ast)]
+        ast
+      end
+
+      private
+
+      def escape_html(ast)
+        [:escape, true, ast]
+      end
+    end
+  end
+end

data/lib/hamlit/filters/javascript.rb

@@ -0,0 +1,34 @@
+require 'hamlit/filters/base'
+
+module Hamlit
+  module Filters
+    class Javascript < Base
+      def compile(lines)
+        return compile_xhtml(lines) if options[:format] == :xhtml
+
+        compile_html(lines)
+      end
+
+      private
+
+      def compile_html(lines)
+        ast = [:haml, :text, compile_lines(lines, indent_width: 2)]
+        ast = [:multi, [:static, "\n"], ast]
+        ast = [:html, :tag, 'script', [:html, :attrs], ast]
+        ast
+      end
+
+      def compile_xhtml(lines)
+        attr  = [:html, :attr, 'type', [:static, 'text/javascript']]
+        attrs = [:html, :attrs, attr]
+
+        multi = [:multi, [:static, "\n"]]
+        multi << [:static, "  //<![CDATA[\n"]
+        multi << [:haml, :text, compile_lines(lines, indent_width: 4)]
+        multi << [:static, "  //]]>\n"]
+
+        [:html, :tag, 'script', attrs, multi]
+      end
+    end
+  end
+end

data/lib/hamlit/filters/less.rb

@@ -0,0 +1,12 @@
+require 'hamlit/filters/tilt'
+
+module Hamlit
+  module Filters
+    class Less < Filters::Tilt
+      def compile(lines)
+        ast = [:html, :tag, 'style', [:html, :attrs]]
+        compile_with_tilt('less', lines.join("\n"), ast)
+      end
+    end
+  end
+end

data/lib/hamlit/filters/markdown.rb

@@ -0,0 +1,11 @@
+require 'hamlit/filters/tilt'
+
+module Hamlit
+  module Filters
+    class Markdown < Filters::Tilt
+      def compile(lines)
+        compile_with_tilt('markdown', lines.join("\n"), [], indent_width: 0)
+      end
+    end
+  end
+end

data/lib/hamlit/filters/plain.rb

@@ -0,0 +1,21 @@
+require 'hamlit/filters/base'
+
+module Hamlit
+  module Filters
+    class Plain < Base
+      def compile(lines)
+        ast = [:multi]
+        text = compile_lines(lines)
+        text.gsub!(/\n\Z/, '') unless string_interpolated?(text)
+        ast << [:haml, :text, text]
+        ast
+      end
+
+      private
+
+      def string_interpolated?(text)
+        text =~ /\#{[^\#{}]*}/
+      end
+    end
+  end
+end

data/lib/hamlit/filters/preserve.rb

@@ -0,0 +1,11 @@
+require 'hamlit/filters/base'
+
+module Hamlit
+  module Filters
+    class Preserve < Base
+      def compile(lines)
+        [:multi, [:haml, :text, lines.join('&#x000A;')]]
+      end
+    end
+  end
+end

data/lib/hamlit/filters/ruby.rb

@@ -0,0 +1,11 @@
+require 'hamlit/filters/base'
+
+module Hamlit
+  module Filters
+    class Ruby < Base
+      def compile(lines)
+        [:multi, [:code, lines.join("\n")]]
+      end
+    end
+  end
+end

data/lib/hamlit/filters/sass.rb

@@ -0,0 +1,12 @@
+require 'hamlit/filters/tilt'
+
+module Hamlit
+  module Filters
+    class Sass < Filters::Tilt
+      def compile(lines)
+        ast = [:html, :tag, 'style', [:html, :attrs]]
+        compile_with_tilt('sass', lines.join("\n"), ast)
+      end
+    end
+  end
+end

data/lib/hamlit/filters/scss.rb

@@ -0,0 +1,12 @@
+require 'hamlit/filters/tilt'
+
+module Hamlit
+  module Filters
+    class Scss < Filters::Tilt
+      def compile(lines)
+        ast = [:html, :tag, 'style', [:html, :attrs]]
+        compile_with_tilt('scss', lines.join("\n"), ast)
+      end
+    end
+  end
+end

data/lib/hamlit/filters/tilt.rb

@@ -0,0 +1,41 @@
+require 'tilt'
+require 'hamlit/concerns/string_interpolation'
+require 'hamlit/filters/base'
+
+module Hamlit
+  module Filters
+    class Tilt < Filters::Base
+      include Concerns::StringInterpolation
+
+      def self.render(name, source, indent_width: 2)
+        result = ::Tilt["t.#{name}"].new { source }.render
+        indent_source(result, indent_width: indent_width)
+      end
+
+      private
+
+      def compile_with_tilt(name, source, ast, indent_width: 2)
+        if contains_interpolation?(source)
+          return runtime_compile(name, source, ast, indent_width: indent_width)
+        end
+
+        content = [:static, Filters::Tilt.render(name, source, indent_width: indent_width)]
+        build_ast(ast, content)
+      end
+
+      def runtime_compile(name, source, ast, indent_width: 2)
+        literal = string_literal(source)
+        code    = "::Hamlit::Filters::Tilt.render(#{name.inspect}, #{literal}, indent_width: #{indent_width})"
+        content = [:dynamic, code]
+        build_ast(ast, content)
+      end
+
+      def build_ast(ast, content)
+        return content if ast.empty?
+
+        content = [:multi, [:static, "\n"], content]
+        ast << content
+      end
+    end
+  end
+end

data/lib/hamlit/helpers.rb

@@ -0,0 +1,38 @@
+# This is a module compatible with Haml::Helpers.
+# It is included by ActionView in initializer.
+module Hamlit
+  module Helpers
+    extend self
+
+    DEFAULT_PRESERVE_TAGS = %w[textarea pre code].freeze
+
+    def find_and_preserve(input = nil, tags = DEFAULT_PRESERVE_TAGS, &block)
+      return find_and_preserve(capture_haml(&block), input || tags) if block
+
+      tags = tags.each_with_object('') do |t, s|
+        s << '|' unless s.empty?
+        s << Regexp.escape(t)
+      end
+
+      re = /<(#{tags})([^>]*)>(.*?)(<\/\1>)/im
+      input.to_s.gsub(re) do |s|
+        s =~ re # Can't rely on $1, etc. existing since Rails' SafeBuffer#gsub is incompatible
+        "<#{$1}#{$2}>#{preserve($3)}</#{$1}>"
+      end
+    end
+
+    def preserve(input = nil, &block)
+      return preserve(capture_haml(&block)) if block
+      s = input.to_s.chomp("\n")
+      s.gsub!(/\n/, '&#x000A;')
+      s.delete!("\r")
+      s
+    end
+
+    # NOTE: currently Hamlit::Helpers is enabled by default on only
+    # Rails environment. Thus you can use capture.
+    def capture_haml(*args, &block)
+      capture(*args, &block)
+    end
+  end
+end

data/lib/hamlit/html/pretty.rb

@@ -0,0 +1,49 @@
+require 'hamlit/concerns/deprecation'
+require 'temple/html/pretty'
+
+# NOTE: This does not work and disabled by default.
+# Actually on_static is just a workaround. This should be totally rewritten.
+# Because pretty mode is not used on production and not so important,
+# it is not done for now.
+module Hamlit
+  module HTML
+    class Pretty < Temple::HTML::Pretty
+      include Concerns::Deprecation
+
+      def call(exp)
+        result = super(exp)
+        result << [:static, "\n"] if @added_newline
+        result
+      end
+
+      def on_static(exp)
+        if exp == "\n"
+          @added_newline = true
+          [:static, '']
+        else
+          [:static, exp]
+        end
+      end
+
+      def on_html_tag(name, attrs, content = nil)
+        if content.is_a?(Array) && content.first != :multi
+          return parse_oneline_tag(name, attrs, content)
+        end
+
+        super
+      end
+
+      private
+
+      def parse_oneline_tag(name, attrs, content)
+        name = name.to_s
+        closed = !content || (empty_exp?(content) && (@format == :xml || options[:autoclose].include?(name)))
+        result = [:multi, [:static, "<#{name}"], compile(attrs)]
+        result << [:static, (closed && @format != :html ? ' /' : '') + '>']
+        result << compile(content) if content
+        result << [:static, "</#{name}>"] if !closed
+        result
+      end
+    end
+  end
+end

data/lib/hamlit/html/ugly.rb

@@ -0,0 +1,10 @@
+require 'hamlit/concerns/deprecation'
+require 'temple/html/fast'
+
+module Hamlit
+  module HTML
+    class Ugly < Temple::HTML::Fast
+      include Concerns::Deprecation
+    end
+  end
+end