hamlit 1.5.9 → 1.6.0

data/lib/hamlit/version.rb

@@ -1,3 +1,3 @@
 module Hamlit
-  VERSION = "1.5.9"
+  VERSION = "1.6.0"
 end

data/spec/hamlit/engine/indent_spec.rb

@@ -1,6 +1,6 @@
 describe Hamlit::Engine do
   describe 'tab indent' do
-    it 'accepts tab indentation', skipdoc: true do
+    it 'accepts tab indentation' do
       assert_render(<<-HAML, <<-HTML, compatible_only: :haml)
         %p
         \t%a

data/spec/hamlit/engine/new_attribute_spec.rb

@@ -16,8 +16,19 @@ describe Hamlit::Engine do
       HTML
     end
 
+    it 'renders multi-line attributes properly' do
+      assert_render(<<-HAML, <<-HTML, compatible_only: :faml)
+        %span(a=__LINE__
+         b=__LINE__)
+        = __LINE__
+      HAML
+        <span a='1' b='2'></span>
+        3
+      HTML
+    end
+
     describe 'html escape' do
-      it 'escapes attribute values on static attributes', skipdoc: true do
+      it 'escapes attribute values on static attributes' do
         assert_render(<<-'HAML', <<-HTML, compatible_only: :faml)
           %a(title="'")
           %a(title = "'\"")
@@ -29,7 +40,7 @@ describe Hamlit::Engine do
         HTML
       end
 
-      it 'escapes attribute values on dynamic attributes', skipdoc: true do
+      it 'escapes attribute values on dynamic attributes' do
         assert_render(<<-'HAML', <<-HTML, compatible_only: :faml)
           - title = "'\""
           - href  = '/search?foo=bar&hoge=<fuga>'

data/spec/hamlit/engine/old_attributes_spec.rb

@@ -121,7 +121,7 @@ describe Hamlit::Engine do
         HTML
       end
 
-      it 'joins attribute class and element class', skipdoc: true do
+      it 'joins attribute class and element class' do
         assert_render(<<-HAML, <<-HTML, compatible_only: :haml)
           .foo{ class: ['bar'] }
           .foo{ class: ['bar', nil] }
@@ -223,7 +223,7 @@ describe Hamlit::Engine do
     end
 
     describe 'html escape' do
-      it 'escapes attribute values on static attributes', skipdoc: true do
+      it 'escapes attribute values on static attributes' do
         assert_render(<<-'HAML', <<-HTML, compatible_only: :faml)
           %a{title: "'"}
           %a{title: "'\""}
@@ -235,7 +235,7 @@ describe Hamlit::Engine do
         HTML
       end
 
-      it 'escapes attribute values on dynamic attributes', skipdoc: true do
+      it 'escapes attribute values on dynamic attributes' do
         assert_render(<<-'HAML', <<-HTML, compatible_only: :faml)
           - title = "'\""
           - href  = '/search?foo=bar&hoge=<fuga>'
@@ -247,7 +247,7 @@ describe Hamlit::Engine do
         HTML
       end
 
-      it 'escapes attribute values on hash attributes', skipdoc: true do
+      it 'escapes attribute values on hash attributes' do
         assert_render(<<-'HAML', <<-HTML, compatible_only: :faml)
           - title = { title: "'\"" }
           - href  = { href:  '/search?foo=bar&hoge=<fuga>' }
@@ -270,7 +270,7 @@ describe Hamlit::Engine do
         HTML
       end
 
-      it 'renders true attributes', skipdoc: true do
+      it 'renders true attributes' do
         assert_render(<<-'HAML', <<-HTML, compatible_only: :haml)
           %span{ data: { disable: true } } bar
         HAML

data/spec/hamlit/engine/silent_script_spec.rb

@@ -76,7 +76,7 @@ describe Hamlit::Engine do
       HTML
     end
 
-    it 'renders empty elsif statement', skipdoc: true do
+    it 'renders empty elsif statement' do
       assert_render(<<-'HAML', <<-HTML, compatible_only: :haml, error_with: :faml)
         %span
           - if false
@@ -87,7 +87,7 @@ describe Hamlit::Engine do
       HTML
     end
 
-    it 'renders empty else statement', skipdoc: true do
+    it 'renders empty else statement' do
       assert_render(<<-'HAML', <<-HTML, compatible_only: :haml, error_with: :faml)
         %span
           - if false
@@ -99,7 +99,7 @@ describe Hamlit::Engine do
       HTML
     end
 
-    it 'renders empty when statement', skipdoc: true do
+    it 'renders empty when statement' do
       assert_render(<<-'HAML', <<-HTML, compatible_only: :haml, error_with: :faml)
         %span
           - case
@@ -187,7 +187,7 @@ describe Hamlit::Engine do
       HTML
     end
 
-    it 'joins a next line if a current line ends with ","', skipdoc: true do
+    it 'joins a next line if a current line ends with ","' do
       assert_render("- foo = [',  \n     ']\n= foo", <<-HTML, compatible_only: :haml)
         [&quot;, &quot;]
       HTML

data/spec/hamlit/engine/tag_spec.rb

@@ -267,6 +267,29 @@ describe Hamlit::Engine do
           <div class='foo'>bar1bar1bar1bar12</div>
         HTML
       end
+
+      it 'does not remove whitespace after string interpolation' do
+        assert_render(<<-'HAML', <<-HTML, compatible_only: :faml)
+          %div<
+            #{'hello'}
+            world
+        HAML
+          <div>hello
+          world</div>
+        HTML
+      end
+
+      it 'removes whitespace inside script inside silent script' do
+        assert_render(<<-HAML, <<-HTML, compatible_only: :faml)
+          .bar<
+            - 1.times do
+              = '1'
+              = '2'
+        HAML
+          <div class='bar'>1
+          2</div>
+        HTML
+      end
     end
   end
 end

data/spec/hamlit/engine/text_spec.rb

@@ -16,13 +16,17 @@ describe Hamlit::Engine do
       assert_render(<<-HAML, <<-HTML, compatible_only: [], error_with: :haml)
         .
         .*
+        ..
         #
         #+
+        ##
       HAML
         .
         .*
+        ..
         #
         #+
+        ##
       HTML
     end
 
@@ -112,15 +116,15 @@ describe Hamlit::Engine do
       end
 
       it 'renders !, & operator right before a non-space character' do
-        assert_render(<<-'HAML', <<-'HTML', compatible_only: :faml)
+        assert_render(<<-'HAML', <<-'HTML', compatible_only: :haml)
           &nbsp;
           \&nbsp;
           !hello
           \!hello
         HAML
-          nbsp;
           &nbsp;
-          hello
+          &nbsp;
+          !hello
           !hello
         HTML
       end

data/spec/spec_helper.rb

@@ -1,236 +1,10 @@
-require 'haml'
-require 'faml'
-require 'hamlit'
 require 'unindent'
-
-module HamlitSpecHelper
-  DEFAULT_OPTIONS = { ugly: true, escape_html: true }.freeze
-
-  def parse_string(str)
-    Hamlit::Parser.new.call(str)
-  end
-
-  def render_string(str, options = {})
-    eval Hamlit::Engine.new(options).call(str)
-  end
-
-  def assert_render(haml, html, options = {})
-    errs  = array_wrap(options.delete(:error_with) || [])
-    impls = array_wrap(options.delete(:compatible_only) || [:haml, :faml] - errs)
-    fails = [:haml, :faml] - impls - errs
-
-    test = TestCase.new
-    test.src_haml = haml.unindent
-    test.hamlit_html = html.unindent
-
-    expect(render_string(test.src_haml, options)).to eq(test.hamlit_html)
-    impls.each { |i| expect_compatibility(i, test, options) }
-    errs.each  { |i| expect_compatibility(i, test, options, type: :error) }
-    fails.each { |i| expect_compatibility(i, test, options, type: :failure) }
-
-    if TestCase.generate_docs? && (errs.any? || fails.any?)
-      write_caller!(test)
-      TestCase.register_test!(test)
-    end
-  end
-
-  def assert_parse(haml, &block)
-    haml = haml.unindent
-    ast  = block.call
-
-    expect(parse_string(haml)).to eq(ast)
-  end
-
-  def assert_compile(before, after)
-    result = described_class.new.call(before)
-    expect(result).to eq(after)
-  end
-
-  private
-
-  def write_caller!(test)
-    line = caller.find{ |l| l =~ %r{spec/hamlit} }
-    path, lineno = line.match(/^([^:]+):([0-9]+)/).to_a.last(2)
-    test.lineno = lineno.to_i - 1
-    test.dir, test.file = path.gsub(%r{^.+spec/hamlit/}, '').split('/')
-  end
-
-  def expect_compatibility(impl, test, options, type: :success)
-    case impl
-    when :haml
-      expect_haml(impl, test, options, type)
-    when :faml
-      expect_faml(impl, test, options, type)
-    end
-  end
-
-  def expect_haml(impl, test, options, type)
-    expect_implementation(impl, test, options, type) do |test, options|
-      options = DEFAULT_OPTIONS.merge(options)
-      Haml::Engine.new(test.src_haml, options).render(Object.new, {})
-    end
-  end
-
-  def expect_faml(impl, test, options, type)
-    expect_implementation(impl, test, options, type) do |test, options|
-      options = options.dup
-      options.delete(:escape_html)
-      eval Faml::Engine.new(options).call(test.src_haml)
-    end
-  end
-
-  def expect_implementation(impl, test, options, type, &block)
-    if type == :error
-      expect { block.call(test, options) }.to raise_error
-      begin
-        block.call(test, options)
-      rescue Exception => e
-        err = "#{e.class}: #{e.message}"
-        test.send(:"#{impl}_html=", err)
-      end
-      return
-    end
-
-    result = block.call(test, options)
-    test.send(:"#{impl}_html=", result)
-
-    case type
-    when :success
-      expect(test.hamlit_html).to eq(result)
-    when :failure
-      expect(test.hamlit_html).to_not eq(result)
-    end
-  end
-
-  def array_wrap(arr)
-    return arr if arr.is_a?(Array)
-    [arr]
-  end
-
-  def tests
-    @tests ||= []
-  end
-end
-
-# This is used to generate a document automatically.
-class TestCase < Struct.new(:file, :dir, :lineno, :src_haml, :haml_html, :faml_html, :hamlit_html)
-  class << self
-    def incompatibilities
-      @incompatibilities ||= []
-    end
-
-    def generate_docs!
-      prepare_dirs!
-      generate_toc!
-
-      incompatibilities.group_by(&:doc_path).each do |path, tests|
-        doc = tests.sort_by(&:lineno).map(&:document).join("\n")
-        full_path = File.join(doc_dir, path)
-        File.write(full_path, doc)
-      end
-    end
-
-    def generate_docs?
-      ENV['AUTODOC']
-    end
-
-    def register_test!(test)
-      incompatibilities << test unless @skipdoc
-    end
-
-    def skipdoc(&block)
-      @skipdoc = true
-      block.call
-    ensure
-      @skipdoc = false
-    end
-
-    private
-
-    def generate_toc!
-      table_of_contents = <<-TOC.unindent
-        # Hamlit incompatibilities
-
-        This is a document generated from RSpec test cases.  
-        Showing incompatibilities against [Haml](https://github.com/haml/haml) and [Faml](https://github.com/eagletmt/faml).
-      TOC
-
-      incompatibilities.group_by(&:dir).each do |dir, tests|
-        # TODO: Split incompatibility documents into haml and faml
-        # There are too many noisy documents now.
-        next if dir == 'filters'
-
-        table_of_contents << "\n## #{dir}\n"
-
-        tests.group_by(&:doc_path).each do |path, tests|
-          test = tests.first
-          file_path = File.join(test.dir, test.file)
-          table_of_contents << "\n- [#{escape_markdown(file_path)}](#{path})"
-        end
-        table_of_contents << "\n"
-      end
-
-      path = File.join(doc_dir, 'README.md')
-      File.write(path, table_of_contents)
-    end
-
-    def prepare_dirs!
-      system("rm -rf #{doc_dir}")
-      incompatibilities.map(&:dir).uniq.each do |dir|
-        system("mkdir -p #{doc_dir}/#{dir}")
-      end
-    end
-
-    def doc_dir
-      @doc_dir ||= File.expand_path('./doc')
-    end
-
-    def escape_markdown(text)
-      text.gsub(/_/, '\\_')
-    end
-  end
-
-  def document
-    base_path = '/spec/hamlit'
-    path = File.join(base_path, dir, file)
-    doc = <<-DOC
-# [#{escape_markdown("#{file}:#{lineno}")}](#{path}#L#{lineno})
-## Input
-```haml
-#{src_haml}
-```
-
-## Output
-    DOC
-
-    html_by_name = {
-      'Haml' => haml_html,
-      'Faml' => faml_html,
-      'Hamlit' => hamlit_html,
-    }
-    html_by_name.group_by(&:last).each do |html, pairs|
-      doc << "### #{pairs.map(&:first).join(', ')}\n"
-      doc << "```html\n"
-      doc << "#{html}\n"
-      doc << "```\n\n"
-    end
-
-    doc
-  end
-
-  def doc_path
-    File.join(dir, file.gsub(/_spec\.rb$/, '.md'))
-  end
-
-  private
-
-  def escape_markdown(text)
-    self.class.send(:escape_markdown, text)
-  end
-end
+require_relative 'spec_helper/document_generator'
+require_relative 'spec_helper/render_helper'
+require_relative 'spec_helper/test_case'
 
 RSpec.configure do |config|
-  config.include HamlitSpecHelper
+  config.include RenderHelper
 
   config.expect_with :rspec do |expectations|
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
@@ -247,6 +21,8 @@ RSpec.configure do |config|
   end
 
   config.after(:suite) do
-    TestCase.generate_docs! if TestCase.generate_docs?
+    if DocumentGenerator.generate_docs?
+      DocumentGenerator.generate_docs!
+    end
   end
 end

data/spec/spec_helper/document_generator.rb

@@ -0,0 +1,93 @@
+require 'singleton'
+
+class DocumentGenerator
+  class << self
+    def incompatibilities
+      @incompatibilities ||= []
+    end
+
+    def generate_docs!
+      prepare_dirs!
+
+      [nil, 'haml', 'faml'].each do |impl|
+        generate_toc!(impl)
+        generate_doc!(impl)
+      end
+    end
+
+    def generate_docs?
+      ENV['AUTODOC']
+    end
+
+    def register_test!(test)
+      incompatibilities << test unless @skipdoc
+    end
+
+    def skipdoc(&block)
+      @skipdoc = true
+      block.call
+    ensure
+      @skipdoc = false
+    end
+
+    private
+
+    def generate_doc!(impl)
+      incompatibilities_for(impl).group_by(&:doc_path).each do |path, tests|
+        doc = tests.sort_by(&:lineno).map { |t| t.document(impl) }.join("\n")
+        full_path = File.join(*[doc_dir, impl, path].compact)
+        File.write(full_path, doc)
+      end
+    end
+
+    def generate_toc!(impl = nil)
+      path = File.join(*[doc_dir, impl, 'README.md'].compact)
+      File.write(path, table_of_contents_for(impl))
+    end
+
+    def table_of_contents_for(impl = nil)
+      toc = "# Hamlit incompatibilities\nThis is a document generated from RSpec test cases.  "
+      toc << "\n#{target_description(impl)}"
+
+      incompatibilities_for(impl).group_by(&:dir).each do |dir, tests|
+        toc << "\n\n## #{dir}\n"
+        tests.map { |t| [t.spec_path, t.doc_path] }.uniq.each do |spec_path, doc_path|
+          toc << "- [#{spec_path}](#{doc_path})\n"
+        end
+      end
+      toc
+    end
+
+    def incompatibilities_for(impl)
+      return incompatibilities unless impl
+      incompatibilities.select { |t| t.send(:"#{impl}_html") != t.hamlit_html }
+    end
+
+    def target_description(impl)
+      case impl
+      when 'haml'
+        'Showing incompatibilities against [Haml](https://github.com/haml/haml).'
+      when 'faml'
+        'Showing incompatibilities against [Faml](https://github.com/eagletmt/faml).'
+      else
+        'Showing incompatibilities against [Haml](https://github.com/haml/haml) and [Faml](https://github.com/eagletmt/faml).'
+      end
+    end
+
+    def prepare_dirs!
+      system("rm -rf #{doc_dir}")
+      incompatibilities.map(&:dir).uniq.each do |dir|
+        system("mkdir -p #{File.join(doc_dir, dir)}")
+      end
+      %w[haml faml].each do |impl|
+        incompatibilities.map(&:dir).uniq.each do |dir|
+          system("mkdir -p #{File.join(doc_dir, impl, dir)}")
+        end
+      end
+    end
+
+    def doc_dir
+      @doc_dir ||= File.expand_path('./doc')
+    end
+  end
+end