hamlit 1.7.2 → 2.0.1

data/lib/hamlit/concerns/lexable.rb

@@ -1,32 +0,0 @@
-require 'ripper'
-
-module Hamlit
-  module Concerns
-    module Lexable
-      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
-
-      # Convert ripper's position to StringScanner's one.
-      def convert_position(text, row, col)
-        return col if row <= 1
-
-        pos   = col
-        lines = text.split("\n")
-        (0..(row - 2)).each do |row_index|
-          pos += lines[row_index].bytesize + 1
-        end
-        pos
-      end
-    end
-  end
-end

data/lib/hamlit/concerns/line_reader.rb

@@ -1,62 +0,0 @@
-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 = line.rest if line.respond_to?(:rest)
-        line =~ /\A *\Z/
-      end
-
-      def skip_lines
-        while next_line && 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 false unless next_line
-        return true if next_line.index(/^#{@indent_logs.last}[ \t]/)
-
-        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

@@ -1,24 +0,0 @@
-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/string_interpolation.rb

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

data/lib/hamlit/concerns/whitespace.rb

@@ -1,91 +0,0 @@
-require 'set'
-
-# Hamlit::Concerns::Whitespace cares about "whitespace removal",
-# which is achieved by '<' or '>' after html tag.
-# NOTE: Whitespace means [:static, "\n"] because it is rendered
-# as whitespace on browsers.
-module Hamlit
-  module Concerns
-    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
-
-      # `<` removes spaces inside script or silent script recursively.
-      def remove_first_space!(exps)
-        deleted = false
-
-        exps.delete_if do |exp|
-          name, *args = exp
-          case name
-          when :static
-            break if args != ["\n"]
-            deleted = true
-            next true
-          when :code
-            next false
-          when :newline
-            next false
-          when :haml
-            # recursive call for script
-            remove_last_space!(exp) if args.first == :script
-          when :multi
-            break if exp == :multi
-            # to flatten multi
-            remove_last_space!(exp)
-          end
-          break
-        end
-
-        # recursive call for silent script
-        remove_last_space!(exps) if deleted
-      end
-
-      def remove_last_space!(exps)
-        exps.reverse!
-        remove_first_space!(exps)
-      ensure
-        exps.reverse!
-        exps
-      end
-
-      private
-
-      def reset_outer_removal
-        @outer_removal = Set.new
-        @tag_indent    = 0
-      end
-
-      def with_tag_nested(&block)
-        @tag_indent += 1
-        with_indented { block.call }
-      ensure
-        @outer_removal.delete(@tag_indent)
-        @tag_indent -= 1
-      end
-
-      def parse_inner_removal(scanner)
-        scanner.scan(/</)
-      end
-
-      def parse_outer_removal(scanner)
-        if scanner.scan(/>/)
-          @outer_removal.add(@tag_indent)
-        else
-          @outer_removal.delete(@tag_indent)
-        end
-      end
-
-      def outer_remove?
-        @outer_removal.include?(@tag_indent)
-      end
-    end
-  end
-end

data/lib/hamlit/filters/tilt.rb

@@ -1,41 +0,0 @@
-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/parsers/attribute.rb

@@ -1,71 +0,0 @@
-require 'ripper'
-require 'hamlit/concerns/balanceable'
-require 'hamlit/concerns/lexable'
-
-module Hamlit
-  module Parsers
-    module Attribute
-      include Concerns::Balanceable
-      include Concerns::Lexable
-
-      ATTRIBUTE_BEGIN     = '{'.freeze
-      METHOD_CALL_PREFIX  = 'a('.freeze
-      BALANCE_START_COUNT = 1
-
-      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
-
-      # NOTE: Old attributes are not valid as Ruby expression.
-      # So Ripper is broken if you give an original expression to it.
-      # This method bypasses it by changing expression to method call.
-      # Ideally you should implement an original lexer for haml old attributes.
-      def parse_old_attributes(scanner)
-        return [] unless scanner.match?(/{/)
-
-        tokens = try_lex(scanner.rest.sub(ATTRIBUTE_BEGIN, METHOD_CALL_PREFIX))
-        until balanced_embexprs_exist?(tokens, start_count: BALANCE_START_COUNT)
-          @current_lineno += 1
-          break unless @lines[@current_lineno]
-          scanner.concat(current_line)
-          tokens = try_lex(scanner.rest.sub(ATTRIBUTE_BEGIN, METHOD_CALL_PREFIX))
-        end
-
-        tokens = fetch_balanced_embexprs(tokens, start_count: BALANCE_START_COUNT)
-        scanner.pos += tokens.last.first.last
-        [tokens.map(&:last).join.sub(METHOD_CALL_PREFIX, ATTRIBUTE_BEGIN)]
-      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("\n#{current_line}")
-          tokens = Ripper.lex(scanner.rest)
-        end
-
-        tokens = fetch_balanced_parentheses(tokens)
-        text   = tokens.map(&:last).join
-        scanner.pos += convert_position(text, *tokens.last.first) + 1
-        [text]
-      end
-
-      # Ripper.lex pulls invalid tokens first.
-      # This method rejects these invalid tokens.
-      def try_lex(str)
-        Ripper.lex(str).reject do |(row, col), type, str|
-          row == 0
-        end
-      end
-    end
-  end
-end

data/lib/hamlit/parsers/comment.rb

@@ -1,30 +0,0 @@
-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(/\[.*\]/)
-          if has_block?
-            syntax_error!('Illegal nesting: nesting within a tag that already has content is illegal.')
-          end
-          return ast << [:static, " #{text} "]
-        end
-
-        content = with_indented { parse_lines }
-        [:haml, :comment, text, content]
-      end
-    end
-  end
-end

data/lib/hamlit/parsers/doctype.rb

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

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