hamlit 0.1.0

data/lib/hamlit/parser.rb

@@ -0,0 +1,123 @@
+require 'strscan'
+require 'temple'
+require 'hamlit/parsers/attribute'
+require 'hamlit/parsers/comment'
+require 'hamlit/parsers/doctype'
+require 'hamlit/parsers/filter'
+require 'hamlit/parsers/multiline'
+require 'hamlit/parsers/script'
+require 'hamlit/parsers/tag'
+require 'hamlit/parsers/text'
+require 'hamlit/parsers/whitespace'
+
+module Hamlit
+  class Parser < Temple::Parser
+    include Parsers::Attribute
+    include Parsers::Comment
+    include Parsers::Doctype
+    include Parsers::Filter
+    include Parsers::Multiline
+    include Parsers::Script
+    include Parsers::Tag
+    include Parsers::Text
+    include Parsers::Whitespace
+
+    SKIP_NEWLINE_EXPS    = %i[newline code multi].freeze
+    SKIP_NEWLINE_FILTERS = %w[ruby markdown erb].freeze
+
+    define_options :format
+
+    def call(template)
+      reset(template)
+
+      ast = [:multi]
+      ast += parse_lines
+      ast
+    end
+
+    private
+
+    # Reset the parser state.
+    def reset(template)
+      template = preprocess_multilines(template)
+      reset_lines(template.split("\n"))
+      reset_indent
+      reset_outer_removal
+    end
+
+    # Parse lines in current_indent and return ASTs.
+    def parse_lines
+      ast = []
+      loop do
+        width = next_width
+        if width != @current_indent * 2
+          if width != Hamlit::EOF && (width > @current_indent * 2 || width.odd?)
+            ast << [:multi, [:newline], [:newline]]
+            ast << syntax_error(
+              "inconsistent indentation: #{2 * @current_indent} spaces used for indentation, "\
+              "but the rest of the document was indented using #{width} spaces"
+            )
+          end
+          break
+        end
+
+        @current_lineno += 1
+        node = parse_line(current_line)
+        if @outer_removal.include?(@current_indent) && ast.last == [:static, "\n"]
+          ast.delete_at(-1)
+        end
+        ast << node
+        ast << [:newline]
+        ast << [:static, "\n"] unless skip_newline?(node)
+      end
+      ast
+    end
+
+    # Parse current line and return AST.
+    def parse_line(line)
+      return [:multi] if empty_line?(line)
+
+      scanner = StringScanner.new(line)
+      scanner.scan(/ +/)
+      if scanner.match?(/\#{/)
+        return parse_text(scanner)
+      elsif scanner.match?(/&=/)
+        return parse_script(scanner, force_escape: true)
+      elsif scanner.match?(/!=/)
+        return parse_script(scanner, disable_escape: true)
+      elsif scanner.match?(/[.#](\Z|[^a-zA-Z0-9_-])/)
+        return parse_text(scanner)
+      end
+
+      case scanner.peek(1)
+      when '!'
+        parse_doctype(scanner)
+      when '%', '.', '#'
+        parse_tag(scanner)
+      when '='
+        parse_script(scanner)
+      when '~'
+        parse_preserve(scanner)
+      when '-'
+        parse_silent_script(scanner)
+      when '/'
+        parse_comment(scanner)
+      when ':'
+        parse_filter(scanner)
+      else
+        parse_text(scanner)
+      end
+    end
+
+    def skip_newline?(ast)
+      SKIP_NEWLINE_EXPS.include?(ast.first) ||
+        (ast[0..1] == [:haml, :doctype]) ||
+        newline_skip_filter?(ast) ||
+        @outer_removal.include?(@current_indent)
+    end
+
+    def newline_skip_filter?(ast)
+      ast[0..1] == [:haml, :filter] && SKIP_NEWLINE_FILTERS.include?(ast[2])
+    end
+  end
+end

data/lib/hamlit/parsers/attribute.rb

@@ -0,0 +1,52 @@
+require 'ripper'
+require 'hamlit/concerns/balanceable'
+
+module Hamlit
+  module Parsers
+    module Attribute
+      include Concerns::Balanceable
+
+      def parse_attributes(scanner)
+        if scanner.match?(/{/)
+          parse_old_attributes(scanner) + parse_new_attributes(scanner)
+        else
+          parse_new_attributes(scanner) + parse_old_attributes(scanner)
+        end
+      end
+
+      private
+
+      def parse_old_attributes(scanner)
+        return [] unless scanner.match?(/{/)
+
+        tokens = Ripper.lex(scanner.rest)
+        until balanced_braces_exist?(tokens)
+          @current_lineno += 1
+          break unless @lines[@current_lineno]
+          scanner.concat(current_line)
+          tokens = Ripper.lex(scanner.rest)
+        end
+
+        tokens = fetch_balanced_braces(tokens)
+        scanner.pos += tokens.last.first.last + 1
+        [tokens.map(&:last).join]
+      end
+
+      def parse_new_attributes(scanner)
+        return [] unless scanner.match?(/\(/)
+
+        tokens = Ripper.lex(scanner.rest)
+        until balanced_parens_exist?(tokens)
+          @current_lineno += 1
+          break unless @lines[@current_lineno]
+          scanner.concat(current_line)
+          tokens = Ripper.lex(scanner.rest)
+        end
+
+        tokens = fetch_balanced_parentheses(tokens)
+        scanner.pos += tokens.last.first.last + 1
+        [tokens.map(&:last).join]
+      end
+    end
+  end
+end

data/lib/hamlit/parsers/comment.rb

@@ -0,0 +1,27 @@
+require 'hamlit/concerns/error'
+require 'hamlit/concerns/indentable'
+
+module Hamlit
+  module Parsers
+    module Comment
+      include Concerns::Indentable
+
+      def parse_comment(scanner)
+        assert_scan!(scanner, /\//)
+
+        ast = [:html, :comment]
+        text = (scanner.scan(/.+/) || '').strip
+
+        if text.empty?
+          content = with_indented { parse_lines }
+          return ast << [:multi, [:static, "\n"], *content]
+        elsif !text.match(/\[.*\]/)
+          return ast << [:static, " #{text} "]
+        end
+
+        content = with_indented { parse_lines }
+        [:haml, :comment, text, content]
+      end
+    end
+  end
+end

data/lib/hamlit/parsers/doctype.rb

@@ -0,0 +1,18 @@
+require 'hamlit/concerns/error'
+
+module Hamlit
+  module Parsers
+    module Doctype
+      def parse_doctype(scanner)
+        assert_scan!(scanner, /!!!/)
+
+        type = nil
+        if scanner.scan(/ +/) && scanner.rest?
+          type = scanner.rest.strip
+        end
+
+        [:haml, :doctype, options[:format], type]
+      end
+    end
+  end
+end

data/lib/hamlit/parsers/filter.rb

@@ -0,0 +1,18 @@
+require 'hamlit/concerns/error'
+require 'hamlit/concerns/indentable'
+
+module Hamlit
+  module Parsers
+    module Filter
+      include Concerns::Indentable
+
+      def parse_filter(scanner)
+        assert_scan!(scanner, /:/)
+
+        name = scanner.scan(/.+/).strip
+        lines = with_indented { read_lines }
+        [:haml, :filter, name, lines]
+      end
+    end
+  end
+end

data/lib/hamlit/parsers/multiline.rb

@@ -0,0 +1,54 @@
+require 'hamlit/concerns/line_reader'
+
+module Hamlit
+  module Parsers
+    module Multiline
+      include Concerns::LineReader
+
+      def preprocess_multilines(template)
+        reset_lines(template.split("\n"))
+        result = []
+
+        while @lines[@current_lineno + 1]
+          @current_lineno += 1
+
+          unless end_with_pipe?(current_line)
+            result << current_line
+            next
+          end
+
+          prefix = current_line[/\A */]
+          lines  = scan_multilines
+
+          result << prefix + build_multiline(lines)
+          (lines.length - 1).times { result << '' }
+        end
+        result.map { |line| "#{line}\n" }.join
+      end
+
+      private
+
+      def end_with_pipe?(line)
+        return false unless line
+        line.strip =~ / \|\Z/
+      end
+
+      def scan_multilines
+        lines = []
+        while end_with_pipe?(current_line)
+          lines << current_line
+          @current_lineno += 1
+        end
+        @current_lineno -= 1
+        lines
+      end
+
+      def build_multiline(lines)
+        lines = lines.map do |line|
+          line.strip.gsub(/ *\|\Z/, '')
+        end
+        lines.join(' ')
+      end
+    end
+  end
+end

data/lib/hamlit/parsers/script.rb

@@ -0,0 +1,93 @@
+require 'hamlit/concerns/escapable'
+require 'hamlit/concerns/error'
+require 'hamlit/concerns/included'
+require 'hamlit/concerns/indentable'
+
+module Hamlit
+  module Parsers
+    module Script
+      extend Concerns::Included
+      include Concerns::Error
+      include Concerns::Indentable
+
+      INTERNAL_STATEMENTS    = %w[else elsif when].freeze
+      DEFAULT_SCRIPT_OPTIONS = { force_escape: false, disable_escape: false }.freeze
+
+      included do
+        include Concerns::Escapable
+      end
+
+      def parse_script(scanner, options = {})
+        assert_scan!(scanner, /=|&=|!=/)
+        options = DEFAULT_SCRIPT_OPTIONS.merge(options)
+
+        code = scan_code(scanner)
+        return syntax_error("There's no Ruby code for = to evaluate.") if code.empty?
+        unless has_block?
+          return [:dynamic, code] if options[:disable_escape]
+          return escape_html([:dynamic, code], options[:force_escape])
+        end
+
+        ast = [:haml, :script, code, options]
+        ast += with_indented { parse_lines }
+        ast << [:code, 'end']
+        ast
+      end
+
+      def parse_preserve(scanner)
+        assert_scan!(scanner, /~/)
+
+        code = scan_code(scanner)
+        escape_html([:haml, :preserve, code])
+      end
+
+      def parse_silent_script(scanner)
+        assert_scan!(scanner, /-/)
+        if scanner.scan(/#/)
+          with_indented { skip_lines }
+          return [:multi]
+        end
+
+        ast = [:code]
+        ast << scan_code(scanner)
+        return ast unless has_block?
+
+        ast = [:multi, ast]
+        ast += with_indented { parse_lines }
+        ast << [:code, 'end'] unless same_indent?(next_line) && internal_statement?(next_line)
+        ast
+      end
+
+      private
+
+      def scan_code(scanner)
+        code = ''
+        loop do
+          code += (scanner.scan(/.+/) || '').strip
+          break unless code =~ /,\Z/
+
+          @current_lineno += 1
+          scanner = StringScanner.new(current_line)
+          code += ' '
+        end
+        code
+      end
+
+      def has_block?
+        next_indent == @current_indent + 1
+      end
+
+      def internal_statement?(line)
+        return false unless line
+
+        scanner = StringScanner.new(line)
+        scanner.scan(/ +/)
+        return false unless scanner.scan(/-/)
+
+        scanner.scan(/ +/)
+        statement = scanner.scan(/[^ ]+/)
+        INTERNAL_STATEMENTS.include?(statement)
+      end
+    end
+  end
+end

data/lib/hamlit/parsers/tag.rb

@@ -0,0 +1,71 @@
+require 'hamlit/concerns/error'
+require 'hamlit/concerns/indentable'
+require 'hamlit/helpers'
+
+module Hamlit
+  module Parsers
+    module Tag
+      include Concerns::Error
+      include Concerns::Indentable
+
+      TAG_ID_CLASS_REGEXP = /[a-zA-Z0-9_-]+/
+      TAG_REGEXP  = /[a-zA-Z0-9\-_:]+/
+      DEFAULT_TAG = 'div'
+
+      def parse_tag(scanner)
+        tag = DEFAULT_TAG
+        tag = scanner.scan(TAG_REGEXP) if scanner.scan(/%/)
+
+        attrs = [:haml, :attrs]
+        attrs += parse_tag_id_and_class(scanner)
+        attrs += parse_attributes(scanner)
+
+        inner_removal = parse_whitespace_removal(scanner)
+        ast = [:html, :tag, tag, attrs]
+
+        if scanner.match?(/=/)
+          ast << parse_script(scanner)
+          return ast
+        elsif scanner.scan(/\//)
+          return ast
+        elsif scanner.rest.match(/[^ ]/)
+          ast << parse_text(scanner)
+          return ast
+        elsif next_indent <= @current_indent
+          return ast << [:multi]
+        end
+
+        content = [:multi, [:static, "\n"]]
+        if inner_removal || Helpers::DEFAULT_PRESERVE_TAGS.include?(tag)
+          content[0, 1] = [:haml, :strip]
+        end
+        content += with_indented { parse_lines }
+        ast << content
+        ast
+      end
+
+      private
+
+      def parse_tag_id_and_class(scanner)
+        attributes = Hash.new { |h, k| h[k] = [] }
+
+        while prefix = scanner.scan(/[#.]/)
+          name = assert_scan!(scanner, TAG_ID_CLASS_REGEXP)
+
+          case prefix
+          when '#'
+            attributes['id'] = [name]
+          when '.'
+            attributes['class'] << name
+          end
+        end
+
+        ast = []
+        attributes.each do |name, values|
+          ast << [:html, :attr, name, [:static, values.join(' ')]]
+        end
+        ast
+      end
+    end
+  end
+end

data/lib/hamlit/parsers/text.rb

@@ -0,0 +1,11 @@
+module Hamlit
+  module Parsers
+    module Text
+      def parse_text(scanner)
+        ast = [:haml, :text]
+        ast << scanner.scan(/.+/).strip
+        ast
+      end
+    end
+  end
+end

data/lib/hamlit/parsers/whitespace.rb

@@ -0,0 +1,38 @@
+require 'set'
+
+# Hamlit::Parsers::Whitespace cares about "whitespace removal",
+# which is achieved by '<' or '>' after html tag.
+module Hamlit
+  module Parsers
+    module Whitespace
+      def parse_whitespace_removal(scanner)
+        if scanner.match?(/</)
+          inner_removal = parse_inner_removal(scanner)
+          parse_outer_removal(scanner)
+        else
+          parse_outer_removal(scanner)
+          inner_removal = parse_inner_removal(scanner)
+        end
+        inner_removal
+      end
+
+      private
+
+      def reset_outer_removal
+        @outer_removal = Set.new
+      end
+
+      def parse_inner_removal(scanner)
+        scanner.scan(/</)
+      end
+
+      def parse_outer_removal(scanner)
+        if scanner.scan(/>/)
+          @outer_removal.add(@current_indent)
+        else
+          @outer_removal.delete(@current_indent)
+        end
+      end
+    end
+  end
+end

data/lib/hamlit/railtie.rb

@@ -0,0 +1,21 @@
+require 'rails'
+require 'temple'
+
+module Hamlit
+  class Railtie < ::Rails::Railtie
+    initializer :hamlit do |app|
+      Hamlit::RailsTemplate = Temple::Templates::Rails.create(
+        Hamlit::Engine,
+        generator:   Temple::Generators::RailsOutputBuffer,
+        register_as: :haml,
+        escape_html: true,
+        streaming:   true,
+        ugly:        true,
+      )
+
+      # Haml extends Haml::Helpers in ActionView each time.
+      # It costs much, so Hamlit includes a compatible module at first.
+      ActionView::Base.send :include, Hamlit::Helpers
+    end
+  end
+end

data/lib/hamlit/template.rb

@@ -0,0 +1,9 @@
+require 'temple'
+require 'hamlit/engine'
+
+module Hamlit
+  Template = Temple::Templates::Tilt.create(
+    Hamlit::Engine,
+    register_as: :haml,
+  )
+end

data/lib/hamlit/version.rb

@@ -0,0 +1,3 @@
+module Hamlit
+  VERSION = "0.1.0"
+end

data/lib/hamlit.rb

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

data/spec/Rakefile

@@ -0,0 +1,79 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'json'
+require 'unindent'
+require 'open-uri'
+
+def generate_spec(mode)
+  spec = <<-SPEC.unindent
+    require "haml"
+
+    # This is a spec converted by haml-spec.
+    # See: https://github.com/haml/haml-spec
+    describe "haml #{mode} mode" do
+      def assert_pretty(haml, locals, options)
+        engine = Haml::Engine.new(haml, options)
+        hamlit = Hamlit::Template.new(options) { haml }
+        expect(hamlit.render(Object.new, locals)).to eq(engine.render(Object.new, locals))
+      end
+
+      def assert_ugly(haml, locals, options)
+        assert_pretty(haml, locals, { ugly: true }.merge(options))
+      end
+
+  SPEC
+
+  url = 'https://raw.githubusercontent.com/haml/haml-spec/master/tests.json'
+  contexts = JSON.parse(open(url).read)
+  contexts.each_with_index do |context, index|
+    spec += "\n" if index != 0
+    spec += "  context \"#{context[0]}\" do\n"
+
+    tests = []
+    context[1].each do |name, test|
+      tests << {
+        name: name,
+        html: test['html'],
+        haml: test['haml'],
+        locals: test['locals'],
+        config: test['config'],
+      }
+    end
+
+    spec += tests.map { |test|
+      locals  = Hash[(test[:locals] || {}).map {|x, y| [x.to_sym, y]}]
+      options = Hash[(test[:config] || {}).map {|x, y| [x.to_sym, y]}]
+      options[:format] = options[:format].to_sym if options[:format]
+
+      generate_specify(test, locals, options, mode)
+    }.join("\n")
+    spec += "  end\n"
+  end
+
+  spec += "end\n"
+  File.write("hamlit/#{mode}_spec.rb", spec)
+end
+
+def generate_specify(test, locals, options, mode)
+  <<-SPEC
+    specify \"#{test[:name]}\" do
+      haml    = %q{#{test[:haml]}}
+      html    = %q{#{test[:html]}}
+      locals  = #{locals}
+      options = #{options}
+      assert_#{mode}(haml, locals, options)
+    end
+  SPEC
+end
+
+desc 'Convert tests.json into ugly rspec tests'
+task :ugly do
+  generate_spec(:ugly)
+end
+
+desc 'Convert tests.json into pretty rspec tests'
+task :pretty do
+  generate_spec(:pretty)
+end
+
+task default: [:ugly, :pretty]

data/spec/hamlit/compilers/script_spec.rb

@@ -0,0 +1,46 @@
+describe Hamlit::Compiler do
+  describe 'script' do
+    let(:options) do
+      { force_escape: false, disable_escape: false }
+    end
+
+    it 'compiles hamlit script ast into assigning' do
+      assert_compile(
+        [:haml,
+         :script,
+         'link_to user_path do',
+         options,
+         [:static, 'user']],
+        [:multi,
+         [:code, "_hamlit_compiler0 = link_to user_path do"],
+         [:static, "user"],
+         [:escape, false, [:dynamic, "(_hamlit_compiler0).to_s"]]],
+      )
+    end
+
+    it 'compiles multiple hamlit scripts' do
+      assert_compile(
+        [:multi,
+         [:haml,
+          :script,
+          'link_to user_path do',
+          options,
+          [:static, 'user']],
+         [:haml,
+          :script,
+          'link_to repo_path do',
+          options,
+          [:static, 'repo']]],
+        [:multi,
+         [:multi,
+          [:code, "_hamlit_compiler0 = link_to user_path do"],
+          [:static, "user"],
+          [:escape, false, [:dynamic, "(_hamlit_compiler0).to_s"]]],
+         [:multi,
+          [:code, "_hamlit_compiler1 = link_to repo_path do"],
+          [:static, "repo"],
+          [:escape, false, [:dynamic, "(_hamlit_compiler1).to_s"]]]],
+      )
+    end
+  end
+end