hamlit 1.7.2 → 2.0.1

data/lib/hamlit/compilers/runtime_attribute.rb

@@ -1,58 +0,0 @@
-require 'hamlit/attribute'
-require 'hamlit/concerns/string_interpolation'
-
-# This module compiles :runtime sexp. It is a special version of
-# old-style attribute which is built on runtime.
-module Hamlit
-  module Compilers
-    module RuntimeAttribute
-      include Concerns::StringInterpolation
-
-      # This is used for compiling only runtime attribute in Compilers::Attribute.
-      def on_runtime(str)
-        compile_runtime_attribute(str)
-      end
-
-      # Given html attrs, merge classes and ids to :dynamic_attribute.
-      def merge_runtime_attributes(attrs)
-        merge_targets = filter_attrs(attrs, 'id', 'class')
-        dynamic_attr  = attrs.find { |exp, *args| exp == :runtime }
-
-        attrs -= merge_targets
-        attrs.delete(dynamic_attr)
-
-        base = decompile_temple_attrs(merge_targets)
-        [compile_runtime_attribute(dynamic_attr.last, base), *attrs]
-      end
-
-      private
-
-      def compile_runtime_attribute(str, base = nil)
-        str = str.gsub(/(\A\{|\}\Z)/, '')
-        quote = options[:attr_quote].inspect
-        code = "::Hamlit::Attribute.build(#{[quote, base, str].compact.join(', ')})"
-        [:dynamic, code]
-      end
-
-      def has_runtime_attribute?(attrs)
-        attrs.any? do |exp, *args|
-          exp == :runtime
-        end
-      end
-
-      # Given attrs in temple ast, return an attribute as hash literal.
-      def decompile_temple_attrs(attrs)
-        literal = '{'
-        attrs.each do |html, attr, name, (type, value)|
-          case type
-          when :static
-            literal += ":#{name}=>#{string_literal(value)},"
-          when :dynamic
-            literal += ":#{name}=>#{value},"
-          end
-        end
-        literal.gsub(/,\Z/, '') + '}'
-      end
-    end
-  end
-end

data/lib/hamlit/compilers/script.rb

@@ -1,31 +0,0 @@
-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

@@ -1,19 +0,0 @@
-require 'hamlit/concerns/whitespace'
-
-# This module is created to compile [:haml, :strip],
-# which is sexp for whitespace inner removal.module Hamlit
-module Hamlit
-  module Compilers
-    module Strip
-      include Concerns::Whitespace
-
-      def on_haml_strip(*exps)
-        exps = exps.dup
-        remove_first_space!(exps)
-        remove_last_space!(exps)
-
-        on_multi(*exps)
-      end
-    end
-  end
-end

data/lib/hamlit/compilers/text.rb

@@ -1,111 +0,0 @@
-require 'hamlit/concerns/error'
-require 'hamlit/concerns/escapable'
-require 'hamlit/concerns/included'
-require 'hamlit/concerns/lexable'
-require 'hamlit/concerns/string_interpolation'
-
-module Hamlit
-  module Compilers
-    module Text
-      extend Concerns::Included
-      include Concerns::Error
-      include Concerns::Lexable
-      include Concerns::StringInterpolation
-
-      included do
-        include Concerns::Escapable
-      end
-
-      # To ask ripper to consider a given text as string literal,
-      # I change "foo" to "%!foo!".
-      # This constant is the candidates for the literal surrounder.
-      STRING_MARKERS = %w[' " ! @ $ % ^ & * | =].freeze
-
-      # Return static and dynamic temple ast.
-      # It splits expression to optimize because string interpolation is slow.
-      def on_haml_text(exp, escape_html = true)
-        return syntax_error('Unbalanced brackets.') unless valid_interpolation?(exp)
-        return static_text(exp) unless contains_interpolation?(exp)
-
-        marker = find_string_marker(exp)
-        return [:dynamic, string_literal(exp)] unless marker
-
-        open_pos, close_pos = find_interpolation(exp, marker)
-        return static_text(exp) unless open_pos && close_pos
-
-        pre  = exp.byteslice(0...open_pos)
-        body = exp.byteslice((open_pos + 2)...close_pos)
-        post = exp.byteslice((close_pos + 1)...exp.bytesize)
-
-        body_ast = escape_html ? escape_html([:dynamic, body]) : [:dynamic, body]
-        [:multi, [:static, pre], body_ast, on_haml_text(post)]
-      end
-
-      def find_interpolation(exp, marker)
-        return unless contains_interpolation?(exp)
-
-        offset     = 2 # 2 is the length of '%' and marker
-        open_pos   = nil
-        open_count = 0
-        literal    = literalify_string(exp, marker)
-
-        Ripper.lex(literal).each do |(row, col), type, str|
-          case type
-          when :on_embexpr_beg
-            open_pos = shifted_position(exp, row, col, offset) if open_count == 0
-            open_count += 1
-          when :on_embexpr_end
-            open_count -= 1
-            return [open_pos, shifted_position(exp, row, col, offset)] if open_count == 0
-          end
-          open_count
-        end
-
-        nil
-      end
-
-      private
-
-      def valid_interpolation?(exp)
-        marker = find_string_marker(exp)
-        return true unless marker # give up checking
-
-        literal = literalify_string(exp, marker)
-        open_count = 0
-
-        Ripper.lex(literal).each do |_, type, str|
-          case type
-          when :on_embexpr_beg
-            open_count += 1
-          when :on_embexpr_end
-            open_count -= 1
-          end
-        end
-        open_count == 0
-      end
-
-      # :static can't treat backslash properly
-      def static_text(exp)
-        return [:dynamic, string_literal(exp)] if exp.include?('\\')
-        [:static, exp]
-      end
-
-      def find_string_marker(text)
-        STRING_MARKERS.each do |marker|
-          return marker unless text.include?(marker)
-        end
-        nil
-      end
-
-      def literalify_string(exp, marker)
-        "%#{marker}#{exp}#{marker}"
-      end
-
-      # In this compiler, only first line is shifted 2 chars.
-      def shifted_position(exp, row, col, offset)
-        return col - offset if row <= 1
-        convert_position(exp, row, col)
-      end
-    end
-  end
-end

data/lib/hamlit/concerns/attribute_builder.rb

@@ -1,22 +0,0 @@
-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|
-              k = k.to_s.gsub(/_/, '-')
-              flattened["#{key}-#{k}"] = v if v
-            end
-          else
-            flattened[key] = value if value
-          end
-        end
-        flattened
-      end
-    end
-  end
-end

data/lib/hamlit/concerns/balanceable.rb

@@ -1,68 +0,0 @@
-require 'ripper'
-require 'hamlit/concerns/lexable'
-
-module Hamlit
-  module Concerns
-    module Balanceable
-      include Lexable
-
-      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 fetch_balanced_embexprs(all_tokens, start_count: 0)
-        fetch_balanced_tokens(all_tokens, :on_embexpr_beg, :on_embexpr_end, start_count: start_count)
-      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
-
-      def balanced_embexprs_exist?(tokens, start_count: 0)
-        balanced_tokens_exist?(tokens, :on_embexpr_beg, :on_embexpr_end, start_count: start_count)
-      end
-
-      private
-
-      def fetch_balanced_tokens(all_tokens, open_token, close_token, start_count: 0)
-        tokens     = []
-        open_count = start_count
-
-        all_tokens.each_with_index do |token, index|
-          case type_of(token)
-          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, start_count: 0)
-        open_count = start_count
-
-        tokens.each do |token|
-          case type_of(token)
-          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

@@ -1,20 +0,0 @@
-# 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

@@ -1,31 +0,0 @@
-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 syntax_error!(message)
-        raise Hamlit::SyntaxError.new(message)
-      end
-
-      def copmile_error!(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

@@ -1,17 +0,0 @@
-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

@@ -1,28 +0,0 @@
-# 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

@@ -1,117 +0,0 @@
-require 'hamlit/concerns/error'
-
-module Hamlit
-  EOF = -1
-
-  module Concerns
-    module Indentable
-      include Concerns::Error
-
-      def reset_indent
-        @indent_logs    = []
-        @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
-        return 1 if !defined?(@indent_space) && fetch_indent(next_line).length > 0
-        count_indent(next_line)
-      end
-
-      def with_indented(&block)
-        @current_indent += 1
-        block.call
-      ensure
-        @current_indent -= 1
-      end
-
-      def count_indent(line)
-        return EOF unless line
-        return 0 if indent_rule == 0
-
-        line.match(/\A[ \t]+/).to_s.length / indent_rule
-      end
-
-      def same_indent?(line)
-        return false unless line
-        count_indent(line) == @current_indent
-      end
-
-      # Validate current line's indentation
-      def validate_indentation!(ast)
-        return true unless next_line
-
-        indent = fetch_indent(next_line)
-        if indent.include?(' ') && indent.include?("\t")
-          syntax_error!("Indentation can't use both tabs and spaces.")
-        end
-        @indent_logs << indent
-
-        if !defined?(@indent_space) && @indent_logs.last != ''
-          @indent_space = @indent_logs.last
-        end
-        validate_indentation_consistency!(indent)
-        reject_too_deep_indentation!
-
-        next_indent < @current_indent
-      end
-
-      def has_block?
-        return false unless next_line
-        return fetch_indent(next_line).length > 0 unless defined?(@indent_space)
-
-        next_indent > @current_indent
-      end
-
-      private
-
-      # Validate the template is using consitent indentation, 2 spaces or a tab.
-      def validate_indentation_consistency!(indent)
-        return false if indent.empty?
-        return false if !defined?(@indent_space) || @indent_space.empty?
-
-        unless acceptable_indent?(indent)
-          syntax_error!("Inconsistent indentation: #{indent_label(indent)} used for indentation, "\
-                        "but the rest of the document was indented using #{indent_label(@indent_space)}.")
-        end
-      end
-
-      def acceptable_indent?(indent)
-        indent = indent.dup
-        while indent.match(/^#{@indent_space}/)
-          indent.gsub!(/^#{@indent_space}/, '')
-        end
-        indent.empty?
-      end
-
-      def reject_too_deep_indentation!
-        return if next_indent <= @current_indent
-
-        if @indent_logs.length == 1
-          syntax_error!('Indenting at the beginning of the document is illegal.')
-        else
-          syntax_error!("The line was indented #{next_indent - count_indent(current_line)} levels deeper than the previous line.")
-        end
-      end
-
-      def indent_label(indent)
-        return %Q{"#{indent}"} if indent.include?(' ') && indent.include?("\t")
-
-        label  = indent.include?(' ') ? 'space' : 'tab'
-        length = indent.match(/[ \t]+/).to_s.length
-
-        "#{length} #{label}#{'s' if length > 1}"
-      end
-
-      def indent_rule
-        return 0 unless defined?(@indent_space)
-        @indent_space.length
-      end
-
-      def fetch_indent(str)
-        str.match(/^[ \t]+/).to_s
-      end
-    end
-  end
-end