hamlit 0.1.0

data/lib/hamlit/compilers/doctype.rb

@@ -0,0 +1,39 @@
+module Hamlit
+  module Compilers
+    module Doctype
+      def on_haml_doctype(format, type)
+        if type == 'XML'
+          return xml_doctype_tag(format)
+        elsif type
+          return doctype_tag(type)
+        end
+
+        case format
+        when :html4
+          doctype_tag(:transitional)
+        when :html5
+          doctype_tag(:html)
+        when :xhtml
+          doctype_tag(:transitional)
+        else
+          doctype_tag(format)
+        end
+      end
+
+      private
+
+      def xml_doctype_tag(format)
+        case format
+        when :html4, :html5
+          [:multi]
+        else
+          [:multi, [:static, "<?xml version='1.0' encoding='utf-8' ?>"], [:static, "\n"]]
+        end
+      end
+
+      def doctype_tag(type)
+        [:multi, [:html, :doctype, type.to_s], [:static, "\n"]]
+      end
+    end
+  end
+end

data/lib/hamlit/compilers/dynamic.rb

@@ -0,0 +1,9 @@
+module Hamlit
+  module Compilers
+    module Dynamic
+      def on_dynamic(exp)
+        [:dynamic, "(#{exp}).to_s"]
+      end
+    end
+  end
+end

data/lib/hamlit/compilers/filter.rb

@@ -0,0 +1,53 @@
+require 'hamlit/concerns/included'
+require 'hamlit/concerns/registerable'
+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/plain'
+require 'hamlit/filters/preserve'
+require 'hamlit/filters/ruby'
+require 'hamlit/filters/sass'
+require 'hamlit/filters/markdown'
+require 'hamlit/filters/scss'
+
+module Hamlit
+  module Compilers
+    module Filter
+      extend Concerns::Included
+
+      included do
+        extend Concerns::Registerable
+
+        define_options :format
+
+        register :coffee,       Filters::Coffee
+        register :coffeescript, Filters::Coffee
+        register :css,          Filters::Css
+        register :erb,          Filters::Erb
+        register :escaped,      Filters::Escaped
+        register :javascript,   Filters::Javascript
+        register :less,         Filters::Less
+        register :markdown,     Filters::Markdown
+        register :plain,        Filters::Plain
+        register :preserve,     Filters::Preserve
+        register :ruby,         Filters::Ruby
+        register :sass,         Filters::Sass
+        register :scss,         Filters::Scss
+      end
+
+      def on_haml_filter(name, lines)
+        ast = compile_filter(name, lines)
+        compile(ast)
+      end
+
+      private
+
+      def compile_filter(name, exp)
+        self.class.find(name).new(options).compile(exp)
+      end
+    end
+  end
+end

data/lib/hamlit/compilers/new_attribute.rb

@@ -0,0 +1,107 @@
+require 'hamlit/concerns/ripperable'
+
+# This module compiles new-style attributes, which is
+# surrounded by parentheses.
+module Hamlit
+  module Compilers
+    module NewAttribute
+      include Concerns::Ripperable
+
+      def compile_new_attribute(str)
+        str    = str.gsub(/\A\(|\)\Z/, '')
+        attrs  = parse_new_attributes(str)
+        attrs.map do |key, value|
+          next true_attribute(key) if value == 'true'
+          [:html, :attr, key, [:dynamic, value]]
+        end
+      end
+
+      private
+
+      def parse_new_attributes(str)
+        attributes = {}
+
+        while str.length > 0
+          tokens = Ripper.lex(str)
+          key = read_key!(tokens)
+          val = read_value!(tokens)
+          if key && val
+            attributes[key] = val
+          elsif key
+            attributes[key] = 'true'
+          end
+
+          token = tokens.first
+          break unless token
+
+          pos = token.first.last
+          str = str[pos..-1]
+        end
+
+        attributes
+      end
+
+      def read_key!(tokens)
+        skip_tokens!(tokens, :on_sp)
+        (row, col), type, key = tokens.shift
+        key
+      end
+
+      def read_value!(tokens)
+        skip_tokens!(tokens, :on_sp)
+        (row, col), type, str = tokens.shift
+        return nil if str != '='
+
+        skip_tokens!(tokens, :on_sp)
+        return if tokens.empty?
+
+        case tokens.first[TYPE_POSITION]
+        when :on_tstring_beg
+          val = fetch_balanced_quotes(tokens)
+        else
+          val = fetch_until(tokens, :on_sp)
+        end
+        val.length.times { tokens.shift }
+        val.map(&:last).join
+      end
+
+      def fetch_balanced_quotes(all_tokens)
+        tokens     = []
+        open_count = 0
+
+        all_tokens.each do |token|
+          (row, col), type, str = token
+          case type
+          when :on_tstring_beg then open_count += 1
+          when :on_tstring_end then open_count -= 1
+          end
+
+          tokens << token
+          break if open_count == 0
+        end
+
+        tokens
+      end
+
+      def fetch_until(all_tokens, type)
+        tokens = []
+
+        all_tokens.each do |token|
+          break if token[TYPE_POSITION] == type
+          tokens << token
+        end
+
+        tokens
+      end
+
+      def true_attribute(key)
+        case options[:format]
+        when :xhtml
+          [:html, :attr, key, [:static, key]]
+        else
+          [:html, :attr, key, [:multi]]
+        end
+      end
+    end
+  end
+end

data/lib/hamlit/compilers/old_attribute.rb

@@ -0,0 +1,147 @@
+require 'hamlit/attribute'
+require 'hamlit/concerns/attribute_builder'
+require 'hamlit/concerns/balanceable'
+require 'hamlit/concerns/ripperable'
+
+# This module compiles only old-style attribute, which is
+# surrounded by brackets.
+module Hamlit
+  module Compilers
+    module OldAttribute
+      include Concerns::AttributeBuilder
+      include Concerns::Balanceable
+      include Concerns::Ripperable
+
+      def compile_old_attribute(str)
+        return runtime_build(str) unless Ripper.sexp(str)
+
+        attrs = parse_old_attributes(str)
+        flatten_attributes(attrs).map do |key, value|
+          next true_attribute(key) if value == 'true'
+          [:html, :attr, key, [:dynamic, value]]
+        end
+      end
+
+      private
+
+      # Parse brace-balanced string and return the result as hash
+      def parse_old_attributes(str)
+        attributes = {}
+
+        split_hash(str).each do |attr|
+          tokens = Ripper.lex("{#{attr}")
+          tokens = tokens.drop(1)
+
+          key = read_hash_key!(tokens)
+          val = tokens.map(&:last).join.strip
+
+          skip_tokens!(tokens, :on_sp)
+          if type_of(tokens.first) == :on_lbrace
+            val = parse_old_attributes(val)
+          end
+
+          attributes[key] = val if key
+        end
+
+        attributes
+      end
+
+      def read_hash_key!(tokens)
+        skip_tokens!(tokens, :on_sp)
+
+        (row, col), type, str = tokens.shift
+        case type
+        when :on_label
+          str.gsub!(/:\Z/, '')
+        when :on_symbeg
+          if %w[:" :'].include?(str)
+            str = read_string!(tokens)
+          else
+            (row, col), type, str = tokens.shift
+          end
+          assert_rocket!(tokens)
+        when :on_tstring_beg
+          str = read_string!(tokens)
+          assert_rocket!(tokens)
+        end
+        str
+      end
+
+      def read_string!(tokens)
+        (row, col), type, str = tokens.shift
+        return '' if type == :on_tstring_end
+
+        raise SyntaxError if type_of(tokens.shift) != :on_tstring_end
+        str
+      end
+
+      def assert_rocket!(tokens, *types)
+        skip_tokens!(tokens, :on_sp)
+        (row, col), type, str = tokens.shift
+
+        raise SyntaxError unless type == :on_op && str == '=>'
+      end
+
+      def runtime_build(str)
+        str = str.gsub(/(\A\{|\}\Z)/, '')
+        quote = options[:attr_quote].inspect
+        code = "::Hamlit::Attribute.build(#{quote}, #{str})"
+        [[:dynamic, code]]
+      end
+
+      def split_hash(str)
+        columns = HashParser.assoc_columns(str)
+        columns = reject_nested_columns(str, columns)
+
+        splitted  = []
+        start_pos = 1
+        columns.each do |end_pos|
+          splitted << str[start_pos..(end_pos - 1)]
+          start_pos = end_pos + 1
+        end
+
+        splitted
+      end
+
+      def reject_nested_columns(str, columns)
+        result     = []
+        open_count = 0
+
+        Ripper.lex(str).each do |(row, col), type, str|
+          if columns.include?(col) && open_count == 1
+            result << col
+          end
+
+          case type
+          when :on_lbrace
+            open_count += 1
+          when :on_rbrace
+            open_count -= 1
+          end
+        end
+        result
+      end
+
+      class HashParser < Ripper
+        attr_reader :columns
+
+        def self.assoc_columns(src)
+          parser = new(src)
+          parser.parse
+          parser.columns
+        end
+
+        def initialize(src)
+          super(src)
+          @columns = []
+        end
+
+        private
+
+        def on_assoc_new(*args)
+          @columns << column - 1
+        end
+      end
+    end
+  end
+end

data/lib/hamlit/compilers/preserve.rb

@@ -0,0 +1,10 @@
+module Hamlit
+  module Compilers
+    module Preserve
+      def on_haml_preserve(code)
+        code = "Hamlit::Helpers.find_and_preserve(#{code})"
+        [:dynamic, code]
+      end
+    end
+  end
+end

data/lib/hamlit/compilers/script.rb

@@ -0,0 +1,31 @@
+require 'hamlit/concerns/escapable'
+require 'hamlit/concerns/included'
+
+module Hamlit
+  module Compilers
+    module Script
+      extend Concerns::Included
+
+      included do
+        include Concerns::Escapable
+      end
+
+      def on_haml_script(code, options, *exps)
+        variable = result_identifier
+
+        assign = [:code, "#{variable} = #{code}"]
+        result = escape_html([:dynamic, variable], options[:force_escape])
+        result = [:dynamic, variable] if options[:disable_escape]
+        [:multi, assign, *exps.map { |exp| compile(exp) }, compile(result)]
+      end
+
+      private
+
+      def result_identifier
+        @id_auto_increment ||= -1
+        @id_auto_increment += 1
+        "_hamlit_compiler#{@id_auto_increment}"
+      end
+    end
+  end
+end

data/lib/hamlit/compilers/strip.rb

@@ -0,0 +1,30 @@
+module Hamlit
+  module Compilers
+    module Strip
+      def on_haml_strip(*exps)
+        stripped = strip_newline(exps)
+        on_multi(*stripped)
+      end
+
+      private
+
+      def strip_newline(content)
+        indexes = newline_indexes(content)
+        return content if indexes.length < 2
+
+        content = content.dup
+        content.delete_at(indexes.last)
+        content.delete_at(indexes.first)
+        content
+      end
+
+      def newline_indexes(exps)
+        indexes = []
+        exps.each_with_index do |exp, index|
+          indexes << index if exp == [:static, "\n"]
+        end
+        indexes
+      end
+    end
+  end
+end

data/lib/hamlit/compilers/text.rb

@@ -0,0 +1,15 @@
+require 'hamlit/concerns/string_interpolation'
+
+module Hamlit
+  module Compilers
+    module Text
+      include Concerns::StringInterpolation
+
+      def on_haml_text(exp)
+        return [:static, exp] unless contains_interpolation?(exp)
+
+        [:dynamic, string_literal(exp)]
+      end
+    end
+  end
+end

data/lib/hamlit/concerns/attribute_builder.rb

@@ -0,0 +1,21 @@
+module Hamlit
+  module Concerns
+    module AttributeBuilder
+      def flatten_attributes(attributes)
+        flattened = {}
+
+        attributes.each do |key, value|
+          case value
+          when Hash
+            flatten_attributes(value).each do |k, v|
+              flattened["#{key}-#{k}"] = v
+            end
+          else
+            flattened[key] = value
+          end
+        end
+        flattened
+      end
+    end
+  end
+end

data/lib/hamlit/concerns/balanceable.rb

@@ -0,0 +1,59 @@
+require 'ripper'
+
+module Hamlit
+  module Concerns
+    module Balanceable
+      def fetch_balanced_braces(all_tokens)
+        fetch_balanced_tokens(all_tokens, :on_lbrace, :on_rbrace)
+      end
+
+      def fetch_balanced_parentheses(all_tokens)
+        fetch_balanced_tokens(all_tokens, :on_lparen, :on_rparen)
+      end
+
+      def balanced_braces_exist?(tokens)
+        balanced_tokens_exist?(tokens, :on_lbrace, :on_rbrace)
+      end
+
+      def balanced_parens_exist?(tokens)
+        balanced_tokens_exist?(tokens, :on_lparen, :on_rparen)
+      end
+
+      private
+
+      def fetch_balanced_tokens(all_tokens, open_token, close_token)
+        tokens     = []
+        open_count = 0
+
+        all_tokens.each_with_index do |token, index|
+          (row, col), type, str = token
+          case type
+          when open_token  then open_count += 1
+          when close_token then open_count -= 1
+          end
+
+          tokens << token
+          break if open_count == 0
+        end
+
+        tokens
+      end
+
+      def balanced_tokens_exist?(tokens, open_token, close_token)
+        open_count = 0
+
+        tokens.each do |token|
+          (row, col), type, str = token
+          case type
+          when open_token  then open_count += 1
+          when close_token then open_count -= 1
+          end
+
+          break if open_count == 0
+        end
+
+        open_count == 0
+      end
+    end
+  end
+end

data/lib/hamlit/concerns/deprecation.rb

@@ -0,0 +1,20 @@
+# A module to suppress deprecation warnings by temple.
+# These deprecated options are specified in haml-spec.
+module Hamlit
+  module Concerns
+    module Deprecation
+      DEPCATED_OPTIONS = %i[html4 html5].freeze
+
+      def initialize(opts = {})
+        super rewrite_deprecated_options(opts)
+      end
+
+      # Temple's warning is noisy in haml-spec.
+      def rewrite_deprecated_options(options)
+        options = options.dup
+        options[:format] = :html if DEPCATED_OPTIONS.include?(options[:format])
+        options
+      end
+    end
+  end
+end

data/lib/hamlit/concerns/error.rb

@@ -0,0 +1,27 @@
+module Hamlit
+  class SyntaxError < StandardError; end
+  class CompileError < StandardError; end
+
+  module Concerns
+    module Error
+      # Template engine should raise Exception on runtime to
+      # show template's error backtrace.
+      def syntax_error(message)
+        code = %Q{raise Hamlit::SyntaxError.new(%q{#{message}})}
+        [:code, code]
+      end
+
+      def assert!(message)
+        raise CompileError.new(message)
+      end
+
+      def assert_scan!(scanner, regexp)
+        result = scanner.scan(regexp)
+        unless result
+          raise CompileError.new("Expected to scan #{regexp} but got nil")
+        end
+        result
+      end
+    end
+  end
+end

data/lib/hamlit/concerns/escapable.rb

@@ -0,0 +1,17 @@
+require 'hamlit/concerns/included'
+
+module Hamlit
+  module Concerns
+    module Escapable
+      extend Included
+
+      included do
+        define_options escape_html: false
+      end
+
+      def escape_html(exp, force_escape = false)
+        [:escape, force_escape || @options[:escape_html], exp]
+      end
+    end
+  end
+end

data/lib/hamlit/concerns/included.rb

@@ -0,0 +1,28 @@
+# Mini ActiveSupport::Concern
+module Hamlit
+  module Concerns
+    class MultipleIncludedBlocks < StandardError
+      def initialize
+        super "Cannot define multiple 'included' blocks for a Concern"
+      end
+    end
+
+    module Included
+      def self.extended(klass)
+        klass.class_eval do
+          def self.included(base = nil, &block)
+            if block_given?
+              raise MultipleIncludedBlocks if defined?(@_included_block)
+
+              @_included_block = block
+              return
+            end
+
+            base.instance_exec(&@_included_block) if defined?(@_included_block)
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hamlit/concerns/indentable.rb

@@ -0,0 +1,53 @@
+require 'hamlit/concerns/error'
+
+module Hamlit
+  EOF = -1
+
+  module Concerns
+    module Indentable
+      include Concerns::Error
+
+      def reset_indent
+        @current_indent = 0
+      end
+
+      # Return nearest line's indent level since next line. This method ignores
+      # empty line. It returns -1 if next_line does not exist.
+      def next_indent
+        count_indent(next_line)
+      end
+
+      def next_width
+        count_width(next_line)
+      end
+
+      def with_indented(&block)
+        @current_indent += 1
+        result = block.call
+        @current_indent -= 1
+
+        result
+      end
+
+      def count_indent(line, strict: false)
+        return EOF unless line
+        width = count_width(line)
+
+        return (width + 1) / 2 unless strict
+        assert!('Expected to count even-width indent') if width.odd?
+
+        width / 2
+      end
+
+      def count_width(line)
+        return EOF unless line
+        line[/\A +/].to_s.length
+      end
+
+      def same_indent?(line)
+        return false unless line
+        count_indent(line) == @current_indent
+      end
+    end
+  end
+end