hamlit 1.7.2 → 2.0.1

data/lib/hamlit/parsers/multiline.rb

@@ -1,58 +0,0 @@
-require 'hamlit/concerns/line_reader'
-
-module Hamlit
-  module Parsers
-    module Multiline
-      include Concerns::LineReader
-
-      SPACED_BLOCK_REGEXP = /do +\| *[^\|]+ *\|\Z/
-
-      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
-        return false if line =~ SPACED_BLOCK_REGEXP
-
-        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.map { |l| "#{l} "}.join
-      end
-    end
-  end
-end

data/lib/hamlit/parsers/script.rb

@@ -1,126 +0,0 @@
-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 rescue ensure when].freeze
-      DEFAULT_SCRIPT_OPTIONS = { force_escape: false, disable_escape: false }.freeze
-      PREFIX_BY_STATEMENT    = {
-        'when'   => 'case',
-        'rescue' => 'begin',
-      }.freeze
-
-      included do
-        include Concerns::Escapable
-      end
-
-      def parse_script(scanner, options = {})
-        assert_scan!(scanner, /=|&=|!=|~/)
-        options = DEFAULT_SCRIPT_OPTIONS.merge(options)
-
-        code, with_comment = scan_code(scanner, comment_check: true)
-        return syntax_error("There's no Ruby code for = to evaluate.") if code.empty? && !with_comment
-        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_silent_script(scanner)
-        assert_scan!(scanner, /-/)
-        if scanner.scan(/#/)
-          with_indented { skip_lines }
-          return [:multi]
-        end
-
-        code = scan_code(scanner)
-        ast = [:multi, [:code, code]]
-        unless has_block?
-          if internal_statement?(code) && !statement_continuing?
-            ast << [:code, 'end']
-          end
-          return ast
-        end
-
-        ast += with_indented { parse_lines }
-        unless statement_continuing?
-          ast << [:code, 'end']
-        end
-        ast
-      end
-
-      private
-
-      def scan_code(scanner, comment_check: false)
-        code = ''
-        loop do
-          code += (scanner.scan(/.+/) || '').strip
-          break unless code =~ /,\Z/
-
-          @current_lineno += 1
-          scanner = StringScanner.new(current_line)
-          code += ' '
-        end
-        remove_comment(code, comment_check: comment_check)
-      end
-
-      def remove_comment(code, comment_check: false)
-        result       = ''
-        with_comment = false
-        prefix       = find_prefix(code)
-        code         = "#{prefix}#{code}"
-
-        Ripper.lex(code).each do |_, type, str|
-          if type == :on_comment
-            with_comment = true
-            next
-          end
-          result += str
-        end
-        result = result.gsub(/\A#{prefix}/, '') if prefix
-
-        return [result, with_comment] if comment_check
-        result
-      end
-
-      # Code starting with `when` can't be properly understood by Ripper.lex.
-      # This method returns `case;` to fix that.
-      def find_prefix(code)
-        PREFIX_BY_STATEMENT.each do |statement, prefix|
-          return "#{prefix};" if code =~ /\A#{statement} /
-        end
-        nil
-      end
-
-      def statement_continuing?
-        same_indent?(next_line) && internal_statement?(next_line, silent_script: true)
-      end
-
-      def internal_statement?(line, silent_script: false)
-        return false unless line
-
-        scanner = StringScanner.new(line)
-        scanner.scan(/ +/)
-        if silent_script
-          return false unless scanner.scan(/-/)
-        end
-
-        scanner.scan(/ +/)
-        statement = scanner.scan(/[^ ]+/)
-        INTERNAL_STATEMENTS.include?(statement)
-      end
-    end
-  end
-end

data/lib/hamlit/parsers/tag.rb

@@ -1,83 +0,0 @@
-require 'hamlit/concerns/error'
-require 'hamlit/concerns/indentable'
-require 'hamlit/concerns/whitespace'
-require 'hamlit/helpers'
-
-module Hamlit
-  module Parsers
-    module Tag
-      include Concerns::Error
-      include Concerns::Indentable
-      include Concerns::Whitespace
-
-      TAG_ID_CLASS_REGEXP = /[a-zA-Z0-9_-]+/
-      TAG_REGEXP  = /[a-zA-Z0-9\-_:]+/
-      DEFAULT_TAG = 'div'
-
-      def parse_tag(scanner)
-        if scanner.scan(/%/)
-          tag = scanner.scan(TAG_REGEXP)
-          unless tag
-            syntax_error!(%Q{Invalid tag: "#{scanner.string}".})
-          end
-        end
-        tag ||= DEFAULT_TAG
-
-        attrs = [:haml, :attrs]
-        attrs += parse_tag_id_and_class(scanner)
-        attrs += parse_attributes(scanner)
-
-        ast = [:html, :tag, tag, attrs]
-        inner_removal = parse_whitespace_removal(scanner)
-
-        if !has_block? || scanner.match?(/=|&=|!=/)
-          return syntax_error("Self-closing tags can't have content.") if scanner.scan(/\/ *[^ ]/)
-          return ast if scanner.scan(/\//)
-          return ast << parse_line(scanner, inline: true)
-        elsif scanner.match?(/\//)
-          return syntax_error("Illegal nesting: nesting within a self-closing tag is illegal.")
-        end
-        validate_content_existence!(tag, scanner)
-
-        content = [:multi, [:static, "\n"]]
-        if inner_removal || Helpers::DEFAULT_PRESERVE_TAGS.include?(tag)
-          content[0, 1] = [:haml, :strip]
-        end
-        content += with_tag_nested { 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 |attr, values|
-          ast << [:html, :attr, attr, [:static, values.join(' ')]]
-        end
-        ast
-      end
-
-      def validate_content_existence!(tag, scanner)
-        scanner.scan(/ */)
-
-        if scanner.match?(/[^ ]/)
-          syntax_error!("Illegal nesting: content can't be both given on the same line as %#{tag} and nested within it.")
-        end
-      end
-    end
-  end
-end

data/lib/hamlit/parsers/text.rb

@@ -1,28 +0,0 @@
-require 'hamlit/concerns/error'
-
-module Hamlit
-  module Parsers
-    module Text
-      include Concerns::Error
-
-      def parse_text(scanner, lstrip: false, escape: true, scan: nil, inline: true)
-        reject_text_nesting! unless inline
-
-        scanner.scan(scan) if scan
-        text = (scanner.scan(/.+/) || '')
-        text = text.lstrip if lstrip
-        [:haml, :text, text, escape]
-      end
-
-      private
-
-      def reject_text_nesting!
-        return unless next_line
-
-        if next_indent > @current_indent
-          syntax_error!('Illegal nesting: nesting within plain text is illegal.')
-        end
-      end
-    end
-  end
-end

data/lib/hamlit/temple.rb

@@ -1,9 +0,0 @@
-module Hamlit
-  module TempleUtilsExtension
-    def escape_html_safe(html)
-      super(html.to_s)
-    end
-  end
-end
-
-Temple::Utils.send(:extend, Hamlit::TempleUtilsExtension)

data/release

@@ -1,6 +0,0 @@
-#!/bin/bash
-
-set -e
-
-source ./test
-bundle exec rake release

data/spec/Rakefile

@@ -1,72 +0,0 @@
-$:.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 with ecape_html" do
-      DEFAULT_OPTIONS = { ugly: true, escape_html: true }.freeze
-
-      def assert_haml(haml, locals, options)
-        engine  = Haml::Engine.new(haml, DEFAULT_OPTIONS.merge(options))
-        hamlit  = Hamlit::Template.new(options) { haml }
-        expect(hamlit.render(Object.new, locals)).to eq(engine.render(Object.new, locals))
-      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/haml_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_haml(haml, locals, options)
-    end
-  SPEC
-end
-
-desc 'Convert tests.json into ugly rspec tests'
-task :ugly do
-  generate_spec(:ugly)
-end
-
-task default: :ugly

data/spec/hamlit/engine/comment_spec.rb

@@ -1,56 +0,0 @@
-describe Hamlit::Parser do
-  describe 'comment' do
-    it 'renders html comment' do
-      assert_render(<<-HAML, <<-HTML)
-        / comments
-      HAML
-        <!-- comments -->
-      HTML
-    end
-
-    it 'strips html comment ignoring around spcaes' do
-      assert_render('/   comments    ', <<-HTML)
-        <!-- comments -->
-      HTML
-    end
-
-    it 'accepts backslash-only line in a comment' do
-      assert_render(<<-'HAML', <<-HTML)
-        /
-          \
-      HAML
-        <!--
-
-        -->
-      HTML
-    end
-
-    it 'renders a deeply indented comment starting with backslash' do
-      assert_render(<<-'HAML', <<-HTML)
-        /
-          \       a
-        /
-          a
-      HAML
-        <!--
-               a
-        -->
-        <!--
-        a
-        -->
-      HTML
-    end
-
-    it 'ignores multiline comment' do
-      assert_render(<<-'HAML', <<-HTML)
-        -# if true
-          - raise 'ng'
-            = invalid script
-                too deep indent
-        ok
-      HAML
-        ok
-      HTML
-    end
-  end
-end