hamlit 1.7.2 → 2.0.1

data/spec/hamlit/engine/text_spec.rb

@@ -1,239 +0,0 @@
-describe Hamlit::Engine do
-  describe 'text' do
-    it 'renders string interpolation' do
-      assert_render(<<-'HAML', <<-HTML)
-        #{ "a#{3}a" }a" #{["1", 2]} b " !
-        a#{{ a: 3 }}
-        <ht#{2}ml>
-      HAML
-        a3aa" [&quot;1&quot;, 2] b " !
-        a{:a=&gt;3}
-        <ht2ml>
-      HTML
-    end
-
-    it 'renders . or # which is not continued by tag name' do
-      assert_render(<<-HAML, <<-HTML, error_with: [:haml, :faml])
-        .
-        .*
-        ..
-        #
-        #+
-        ##
-      HAML
-        .
-        .*
-        ..
-        #
-        #+
-        ##
-      HTML
-    end
-
-    it 'escapes all operators by backslash' do
-      assert_render(<<-'HAML', <<-HTML)
-        = 'a'
-        -
-        \= 'a'
-        \-
-      HAML
-        a
-        = 'a'
-        -
-      HTML
-    end
-
-    it 'renders == operator' do
-      assert_render(<<-'HAML', <<-HTML)
-        ===
-        == =
-        == <a>
-        == #{'<a>'}
-      HAML
-        =
-        =
-        <a>
-        &lt;a&gt;
-      HTML
-    end
-
-    it 'renders !== operator' do
-      assert_render(<<-'HAML', <<-HTML)
-        == #{'<a>'}
-        !== #{'<a>'}
-        !===
-        !== =
-      HAML
-        &lt;a&gt;
-        <a>
-        =
-        =
-      HTML
-    end
-
-    it 'leaves empty spaces after backslash' do
-      expect(render_string('\       a')).to eq("       a\n")
-    end
-
-    it 'renders spaced - properly' do
-      assert_render(<<-HAML, <<-'HTML')
-        %div
-          foo
-          .test - bar
-          .test - baz
-      HAML
-        <div>
-        foo
-        <div class='test'>- bar</div>
-        <div class='test'>- baz</div>
-        </div>
-      HTML
-    end
-
-    describe 'inline operator' do
-      it 'renders ! operator' do
-        assert_render(<<-'HAML', <<-'HTML')
-          %span!#{'<nyaa>'}
-          %span! #{'<nyaa>'}
-          ! #{'<nyaa>'}
-        HAML
-          <span><nyaa></span>
-          <span><nyaa></span>
-          <nyaa>
-        HTML
-      end
-
-      it 'renders & operator' do
-        assert_render(<<-'HAML', <<-'HTML')
-          %span& #{'<nyaa>'}
-          %span&#{'<nyaa>'}
-          & #{'<nyaa>'}
-        HAML
-          <span>&lt;nyaa&gt;</span>
-          <span>&lt;nyaa&gt;</span>
-          &lt;nyaa&gt;
-        HTML
-      end
-
-      it 'renders !, & operator right before a non-space character' do
-        assert_render(<<-'HAML', <<-'HTML', compatible_only: :haml)
-          &nbsp;
-          \&nbsp;
-          !hello
-          \!hello
-        HAML
-          &nbsp;
-          &nbsp;
-          !hello
-          !hello
-        HTML
-      end
-
-      it 'renders &, ! operator inside a tag' do
-        assert_render(<<-HAML, <<-HTML)
-          %span &nbsp;
-          %span&nbsp;
-          %span& nbsp;
-          %span !hello
-          %span!hello
-          %span! hello
-        HAML
-          <span>&nbsp;</span>
-          <span>nbsp;</span>
-          <span>nbsp;</span>
-          <span>!hello</span>
-          <span>hello</span>
-          <span>hello</span>
-        HTML
-      end
-
-      it 'does not accept backslash operator' do
-        assert_render(<<-'HAML', <<-'HTML')
-          %span\    foo
-        HAML
-          <span>\    foo</span>
-        HTML
-      end
-
-      it 'renders != operator' do
-        assert_render(<<-'HAML', <<-'HTML')
-          %span!= '<nyaa>'
-        HAML
-          <span><nyaa></span>
-        HTML
-      end
-
-      it 'renders !== operator' do
-        assert_render(<<-'HAML', <<-'HTML')
-          %span!==#{'<nyaa>'}
-          %span!== #{'<nyaa>'}
-          !==#{'<nyaa>'}
-          !== #{'<nyaa>'}
-        HAML
-          <span><nyaa></span>
-          <span><nyaa></span>
-          <nyaa>
-          <nyaa>
-        HTML
-      end
-
-      it 'renders &= operator' do
-        assert_render(<<-'HAML', <<-'HTML', escape_html: false)
-          %span&= '<nyaa>'
-        HAML
-          <span>&lt;nyaa&gt;</span>
-        HTML
-      end
-
-      it 'renders &== operator' do
-        assert_render(<<-'HAML', <<-'HTML')
-          &===
-          &== =
-          &== #{'<p>'}
-        HAML
-          =
-          =
-          &lt;p&gt;
-        HTML
-      end
-
-      it 'renders ~ operator' do
-        assert_render(<<-HAML, <<-HTML, escape_html: false)
-          %span~ 1
-        HAML
-          <span>1</span>
-        HTML
-      end
-    end
-
-    describe 'string interpolation' do
-      specify { assert_render('#{}', "\n") }
-      specify { assert_render('1#{}', "1\n") }
-      specify { assert_render('1#{2}', "12\n") }
-      specify { assert_render('}#{1}', "}1\n") }
-      specify { assert_render('#{1}2', "12\n") }
-      specify { assert_render('1#{ "2#{3}4" }5', "12345\n") }
-      specify { assert_render('#{1}2#{3}4#{5}6#{7}8#{9}', "123456789\n") }
-      specify { assert_render(%q{'"!@$%^&*|=#{1}1#{1}2}, %Q{'"!@$%^&*|=1112\n}) }
-      specify { assert_render('あ#{1}', "あ1\n") }
-      specify { assert_render('あ#{"い"}う', "あいう\n") }
-      specify { assert_render('a#{"<b>"}c', "a&lt;b&gt;c\n") }
-    end
-
-    describe 'illegal inputs' do
-      it 'rejects an invalid tag' do
-        expect { render_string(<<-HAML.unindent) }.
-          % a
-        HAML
-          to raise_error(Hamlit::SyntaxError, 'Invalid tag: "% a".')
-      end
-
-      it 'rejects an invalid tag' do
-        expect { render_string(<<-HAML.unindent) }.
-          %.foo
-        HAML
-          to raise_error(Hamlit::SyntaxError, 'Invalid tag: "%.foo".')
-      end
-    end
-  end
-end

data/spec/hamlit/engine_spec.rb

@@ -1,58 +0,0 @@
-describe Hamlit::Engine do
-  describe '.new' do
-    subject { described_class.new(options) }
-
-    let(:buffer)  { '_a' }
-    let(:options) do
-      {
-        buffer:    buffer,
-        generator: Temple::Generators::ArrayBuffer,
-      }
-    end
-
-    it 'accepts generator valid options' do
-      expect(subject.call('')).to eq(
-        "#{buffer} = []; ; #{buffer} = #{buffer}.join",
-      )
-    end
-  end
-
-  describe '#call' do
-    let(:haml) do
-      <<-HAML.unindent
-        !!! html
-
-        %html
-          %head
-            %title Simple Haml
-          %body
-            %h1= 'header'
-            - unless false
-              %ul
-                - for i in [1, 2, 3]
-                  - if i
-                    %li
-                      %strong= 'hello'
-                  - else
-                    %li
-                      %a{:href => i}= i
-            - else
-              %p last line
-      HAML
-    end
-    let(:engine) { described_class.new }
-
-    it 'generates code with the same lineno as a template' do
-      lines = engine.call(haml).split("\n")
-      expect(lines[0]).to include('DOCTYPE')
-      expect(lines[6]).to include('header')
-      expect(lines[7]).to include('unless')
-      expect(lines[9]).to include('for i in')
-      expect(lines[10]).to include('if i')
-      expect(lines[12]).to include('hello')
-      expect(lines[13]).to include('else')
-      expect(lines[16]).to include('else')
-      expect(lines[17]).to include('last line')
-    end
-  end
-end

data/spec/hamlit/filters/coffee_spec.rb

@@ -1,60 +0,0 @@
-describe Hamlit::Filters::Coffee do
-  describe '#compile' do
-    it 'renders coffee filter' do
-      assert_render(<<-HAML, <<-HTML)
-        :coffee
-          foo = ->
-            alert('hello')
-      HAML
-        <script>
-          (function() {
-            var foo;
-          
-            foo = function() {
-              return alert('hello');
-            };
-          
-          }).call(this);
-        </script>
-      HTML
-    end
-
-    it 'renders coffeescript filter' do
-      assert_render(<<-HAML, <<-HTML)
-        :coffee
-          foo = ->
-            alert('hello')
-      HAML
-        <script>
-          (function() {
-            var foo;
-          
-            foo = function() {
-              return alert('hello');
-            };
-          
-          }).call(this);
-        </script>
-      HTML
-    end
-
-    it 'renders coffeescript filter' do
-      assert_render(<<-'HAML', <<-HTML)
-        :coffee
-          foo = ->
-            alert("#{'<&>'}")
-      HAML
-        <script>
-          (function() {
-            var foo;
-          
-            foo = function() {
-              return alert("<&>");
-            };
-          
-          }).call(this);
-        </script>
-      HTML
-    end
-  end
-end

data/spec/hamlit/filters/css_spec.rb

@@ -1,33 +0,0 @@
-describe Hamlit::Filters::Css do
-  describe '#compile' do
-    it 'renders css' do
-      assert_render(<<-HAML, <<-HTML)
-        :css
-          .foo {
-            width: 100px;
-          }
-      HAML
-        <style>
-          .foo {
-            width: 100px;
-          }
-        </style>
-      HTML
-    end
-
-    it 'parses string interpolation' do
-      assert_render(<<-'HAML', <<-HTML)
-        :css
-          .foo {
-            content: "#{'<&>'}";
-          }
-      HAML
-        <style>
-          .foo {
-            content: "<&>";
-          }
-        </style>
-      HTML
-    end
-  end
-end

data/spec/hamlit/filters/erb_spec.rb

@@ -1,16 +0,0 @@
-describe Hamlit::Filters::Erb do
-  describe '#compile' do
-    it 'renders erb filter' do
-      assert_render(<<-HAML, <<-HTML, compatible_only: [], error_with: :faml)
-        :erb
-          <% if true %>
-          ok
-          <% else %>
-          ng
-          <% end %>
-      HAML
-        ok
-      HTML
-    end
-  end
-end

data/spec/hamlit/filters/javascript_spec.rb

@@ -1,82 +0,0 @@
-describe Hamlit::Filters::Javascript do
-  describe '#compile' do
-    it 'just renders script tag for empty filter' do
-      assert_render(<<-HAML, <<-HTML, compatible_only: [])
-        before
-        :javascript
-        after
-      HAML
-        before
-        <script>
-
-        </script>
-        after
-      HTML
-    end
-
-    it 'compiles javascript filter' do
-      assert_render(<<-HAML, <<-HTML)
-        before
-        :javascript
-          alert('hello');
-        after
-      HAML
-        before
-        <script>
-          alert('hello');
-        </script>
-        after
-      HTML
-    end
-
-    it 'accepts illegal indentation' do
-      assert_render(<<-HAML, <<-HTML, compatible_only: :faml)
-        :javascript
-         if {
-          alert('hello');
-           }
-        :javascript
-           if {
-            alert('hello');
-             }
-      HAML
-        <script>
-          if {
-           alert('hello');
-            }
-        </script>
-        <script>
-          if {
-           alert('hello');
-            }
-        </script>
-      HTML
-    end
-
-    it 'accepts illegal indentation' do
-      assert_render(<<-HAML, <<-HTML)
-        :javascript
-           if {
-            alert('a');
-           }
-      HAML
-        <script>
-          if {
-           alert('a');
-          }
-        </script>
-      HTML
-    end
-
-    it 'parses string interpolation' do
-      assert_render(<<-'HAML', <<-HTML)
-        :javascript
-          var a = "#{'<&>'}";
-      HAML
-        <script>
-          var a = "<&>";
-        </script>
-      HTML
-    end
-  end
-end