tiny 0.2.0

data/lib/tiny/erubis.rb

@@ -0,0 +1,63 @@
+require 'erubis'
+require 'tilt/erb'
+
+module Tiny
+  # Support for emitting explicitly the result of calls to methods that
+  # take blocks. Based on the Rails ERB hack.
+  #
+  #   <%= my_method do %>
+  #     ...
+  #   <% end %>
+  #
+  # It overrides Tilt default Template classes for Erubis.
+  #
+  module Erubis
+    # @see Erubis
+    class ::String
+      def append= obj
+        self << obj.to_s
+      end
+
+      def append_escaped= obj
+        self << Tiny::Helpers.sanitize(obj.to_s)
+      end
+    end
+
+    # @see Erubis
+    module ErubyExtensions
+      def add_expr_literal src, code
+        src << "_buf.append= #{code};"
+      end
+
+      def add_expr_escaped src, code
+        src << "_buf.append_escaped= #{code};"
+      end
+    end
+
+    # @see Erubis
+    class Eruby < ::Erubis::Eruby
+      include ErubyExtensions
+    end
+
+    # @see Erubis
+    class EscapedEruby < ::Erubis::EscapedEruby
+      include ErubyExtensions
+    end
+
+    # @see Erubis
+    class ErubisTemplate < ::Tilt::ErubisTemplate
+      def prepare
+        engine_class = options.delete(:engine_class) || Eruby
+        engine_class = EscapedEruby if options.delete(:escape_html)
+        options.merge!(:engine_class => engine_class)
+        super
+      end
+
+      def precompiled_preamble locals
+        [super, "__in_erb_template=true"].join("\n")
+      end
+    end
+
+    Tilt.register ErubisTemplate, 'erb', 'rhtml', 'erubis'
+  end
+end

data/lib/tiny/html.rb

@@ -0,0 +1,177 @@
+module Tiny
+  module HTML
+    @content_tags = []
+    @void_tags    = []
+
+    class << self
+      # Void tag names.
+      # Tags that should have no content.
+      # @return [Array]
+      def content_tags
+        @content_tags
+      end
+
+      # Content tag names.
+      # Tags that can have content.
+      # @return [Array]
+      def void_tags
+        @void_tags
+      end
+
+      private
+      # @macro tag_def
+      #  @method $1(attrs_or_content = {}, attrs = nil, &block)
+      #  Shortcut for {Markup#html_tag html_tag}(:$1)
+      #
+      #  @param attrs_or_content [Hash, String] Tag's attributes or content.
+      #  @param attrs [Hash] Tag's attributes if content string passed.
+      #  @yield Content block.
+      #  @return [String] HTML markup
+      #
+      #  @see Markup#html_tag
+      #
+      def tag_def tag_name, void_tag = false
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def #{tag_name} *args, &block
+            html_tag "#{tag_name}", *args, &block
+          end
+        RUBY
+        void_tag ? @void_tags.push(tag_name) : @content_tags.push(tag_name)
+      end
+    end
+
+    tag_def 'area',  :void
+    tag_def 'base',  :void
+    tag_def 'br',    :void
+    tag_def 'col',   :void
+    tag_def 'hr',    :void
+    tag_def 'img',   :void
+    tag_def 'input', :void
+    tag_def 'link',  :void
+    tag_def 'meta',  :void
+    tag_def 'param', :void
+
+    # html 5 tags
+    tag_def 'embed', :void
+    tag_def 'article'
+    tag_def 'aside'
+    tag_def 'audio'
+    tag_def 'bdi'
+    tag_def 'canvas'
+    tag_def 'command'
+    tag_def 'datalist'
+    tag_def 'details'
+    tag_def 'figcaption'
+    tag_def 'figure'
+    tag_def 'header'
+    tag_def 'hgroup'
+    tag_def 'keygen'
+    tag_def 'mark'
+    tag_def 'meter'
+    tag_def 'nav'
+    tag_def 'output'
+    tag_def 'progress'
+    tag_def 'section'
+    tag_def 'source'
+    tag_def 'summary'
+    tag_def 'track'
+    tag_def 'video'
+    tag_def 'wbr'
+
+    # common tags
+    tag_def 'a'
+    tag_def 'abbr'
+    tag_def 'address'
+
+    tag_def 'b'
+    tag_def 'bdo'
+    tag_def 'big'
+    tag_def 'blockquote'
+    tag_def 'body'
+    tag_def 'button'
+
+    tag_def 'caption'
+    tag_def 'cite'
+    tag_def 'code'
+    tag_def 'colgroup'
+
+    tag_def 'dd'
+    tag_def 'del'
+    tag_def 'dfn'
+    tag_def 'div'
+    tag_def 'dl'
+    tag_def 'dt'
+
+    tag_def 'em'
+
+    tag_def 'fieldset'
+    tag_def 'footer'
+    tag_def 'form'
+
+    tag_def 'h1'
+    tag_def 'h2'
+    tag_def 'h3'
+    tag_def 'h4'
+    tag_def 'h5'
+    tag_def 'h6'
+    tag_def 'head'
+    tag_def 'html'
+
+    tag_def 'i'
+    tag_def 'iframe'
+    tag_def 'ins'
+
+    tag_def 'kbd'
+
+    tag_def 'label'
+    tag_def 'legend'
+    tag_def 'li'
+
+    tag_def 'map'
+
+    tag_def 'noscript'
+
+    tag_def 'object'
+    tag_def 'ol'
+    tag_def 'optgroup'
+    tag_def 'option'
+
+    tag_def 'p'
+    tag_def 'pre'
+
+    tag_def 'q'
+
+    tag_def 'rp'
+    tag_def 'rt'
+    tag_def 'ruby'
+
+    tag_def 's'
+    tag_def 'samp'
+    tag_def 'script'
+    tag_def 'select'
+    tag_def 'small'
+    tag_def 'span'
+    tag_def 'strike'
+    tag_def 'strong'
+    tag_def 'style'
+    tag_def 'sub'
+    tag_def 'sup'
+
+    tag_def 'table'
+    tag_def 'tbody'
+    tag_def 'td'
+    tag_def 'textarea'
+    tag_def 'tfoot'
+    tag_def 'th'
+    tag_def 'thead'
+    tag_def 'time'
+    tag_def 'title'
+    tag_def 'tr'
+    tag_def 'tt'
+
+    tag_def 'u'
+    tag_def 'ul'
+
+    tag_def 'var'
+  end
+end

data/lib/tiny/safe_string.rb

@@ -0,0 +1,16 @@
+module Tiny
+  # A {SafeString} will not be HTML-escaped when appended to {Tag} or
+  # {Widget} content, whereas a String will be.
+  # @see Buffering#raw
+  # @see Buffering#concat!
+  # @see Buffering#concat
+  #
+  class SafeString < String
+    def html_safe?; true end
+
+    def concat string
+      return super unless String === string
+      super Helpers.sanitize string
+    end
+  end
+end

data/lib/tiny/tag.rb

@@ -0,0 +1,47 @@
+module Tiny
+  # @see Markup#html_tag
+  class Tag
+    attr_reader :tag_name, :attrs
+    def initialize tag_name, aoc = {}, attrs = nil
+      @attrs, @content =
+         Hash === aoc && attrs.nil?? [aoc] : [attrs || {}, aoc]
+      @content  = Helpers.sanitize(@content) if @content
+      @tag_name = tag_name
+    end
+
+    def tag_attributes
+      tag_attrs = attrs.map do |name, val|
+        next if val.nil? || val == []
+        next name if val == true
+
+        vals = [*val].map do |value|
+          EscapeUtils.escape_html value.to_s, false
+        end
+
+        %{#{name}="#{vals.join(' ')}"}
+      end.compact.join(' ')
+
+      " #{tag_attrs}" unless tag_attrs.empty?
+    end
+
+    def render &block
+      if void_tag?
+        "<#{tag_name}#{tag_attributes} />"
+      else
+        content = @content
+        if block_given?
+          context = eval('self', block.binding)
+          content = context.with_buffer(&block)
+          content.gsub!(/^(?!\s*$)/, "  ")
+          content.gsub!(/\A(?!$)|(?<!^|\n)\z/, "\n")
+        end
+
+        "<#{tag_name}#{tag_attributes}>#{content}</#{tag_name}>"
+      end
+    end
+
+    def void_tag?
+      HTML.void_tags.include? tag_name
+    end
+  end
+end

data/lib/tiny/version.rb

@@ -0,0 +1,3 @@
+module Tiny
+  VERSION = "0.2.0"
+end

data/spec/erubis_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe 'markup helpers' do
+  it "should register tiny erubis templates for '.erubis' files" do
+    Tilt['erubis'].should == Tiny::Erubis::ErubisTemplate
+    Tilt['erb'].should == Tiny::Erubis::ErubisTemplate
+  end
+
+  it 'should default to tiny erubis engine' do
+    engine = Tilt['erb'].new{}.instance_variable_get(:@engine)
+    engine.should be_a Tiny::Erubis::Eruby
+  end
+
+  it 'should use tiny escaped erubis engine for escaping html' do
+    engine = Tilt['erb'].new(nil, :escape_html => true){}.instance_variable_get(:@engine)
+    engine.should be_a Tiny::Erubis::EscapedEruby
+  end
+
+  it 'should escape html when passing :escape_html => true option' do
+    template = Tilt['erb'].new(nil, :escape_html => true) { %(<%= "<p>Hello World!</p>" %>) }
+    template.render.should == "&lt;p&gt;Hello World!&lt;&#47;p&gt;"
+  end
+
+  it 'should not escape htmle when passing :escape_html => false option' do
+    template = Tilt['erb'].new(nil, :escape_html => false) { %(<%= "<p>Hello World!</p>" %>) }
+    template.render.should == "<p>Hello World!</p>"
+  end
+
+  it 'should allow block with explicit output' do
+    template = Tilt['erb'].new do
+      <<-ERB
+      <%= [1,2].each do |i| %>
+      <% end %>
+      ERB
+    end
+    template.render.should include "[1, 2]"
+  end
+
+  it 'should allow block with explicit output' do
+    template = Tilt['erb'].new nil, :escape_html => true do
+      <<-ERB
+      <%= [1,2].each do |i| %>
+      <% end %>
+      ERB
+    end
+    template.render.should include "[1, 2]"
+  end
+end

data/spec/fixtures/erb_list.erb

@@ -0,0 +1,20 @@
+<%= html_tag(:ul) do %>
+  <li>
+    <%= html_tag(:a) do %>
+      A
+      <span>1</span>
+    <% end %>
+  </li>
+  <%= html_tag(:li) do %>
+    <%= html_tag(:a) do %>
+      B
+      <span>2</span>
+    <% end %>
+  <% end %>
+  <%= html_tag(:li) do %>
+    <%= html_tag(:a) do %>
+      C
+      <span>3</span>
+    <% end %>
+  <% end %>
+<% end %>

data/spec/fixtures/erb_list_with_helpers.erb

@@ -0,0 +1,5 @@
+<%= list do %>
+  <%= item_content(1) %>
+  <%= item_content(2) %>
+  <%= item_content(3) %>
+<% end %>

data/spec/fixtures/haml_list.haml

@@ -0,0 +1,16 @@
+= html_tag(:ul) do
+  = html_tag(:li) do
+    = html_tag(:a) do
+      A
+      = html_tag(:span) do
+        1
+  = html_tag(:li) do
+    = html_tag(:a) do
+      B
+      = html_tag(:span) do
+        2
+  = html_tag(:li) do
+    = html_tag(:a) do
+      C
+      = html_tag(:span) do
+        3

data/spec/fixtures/haml_list_with_helpers.haml

@@ -0,0 +1,4 @@
+= list do |element|
+  = item_content(1)
+  = item_content(2)
+  = item_content(3)

data/spec/helpers_spec.rb

@@ -0,0 +1,303 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'markup helpers' do
+  include Tiny::Helpers
+
+  let(:output) do
+    Capybara::Node::Simple.new(@output)
+  end
+
+  describe 'tag' do
+    describe 'basic' do
+      describe 'attributes and content' do
+        before do
+          @output = tag(:li, :class => 'item', :id => 'hello') { text 'Hello' }
+        end
+        it { output.should have_css 'li', :count => 1 }
+        it { output.should have_css 'li', :text => "Hello" }
+        it { output.should have_css 'li.item' }
+        it { output.should have_css 'li#hello' }
+      end
+
+      it 'should not use blank attribute values' do
+        output = tag(:li, :class => [], :id => nil)
+        output.should == "<li></li>"
+      end
+
+      it 'should not emit value for an atribute value of true' do
+        output = tag(:li, 'data-something' => true)
+        output.should == "<li data-something></li>"
+      end
+
+      it 'should not allow passing text without #text' do
+        output = tag(:li) { 'Hello' }
+        output.should == '<li></li>'
+      end
+
+      it 'should output multiple classes passing an array' do
+        output = tag(:li, :class => %w(item in-stock))
+        output.should == '<li class="item in-stock"></li>'
+      end
+
+      it 'should allow passing content as string' do
+        tag(:h1, "Hello").should == "<h1>Hello</h1>"
+        tag(:h1, "Hello", :class => 'main').should == %{<h1 class="main">Hello</h1>}
+      end
+
+      it 'should escape attribute html' do
+        tag(:a, :href => '<script>').should == '<a href="&lt;script&gt;"></a>'
+        tag(:a, :href => 'art&copy').should == '<a href="art&amp;copy"></a>'
+      end
+    end
+
+    describe 'blocks' do
+      describe 'shallow blocks' do
+        before do
+          @output = tag(:div) { tag(:a) { text 'Hello' } }
+        end
+        it { output.should have_css 'div', :count => 1 }
+        it { output.should have_css 'a',   :count => 1 }
+        it { output.should have_css 'div > a', :text => 'Hello' }
+      end
+
+      describe 'deeper blocks' do
+        before do
+          @output = tag(:div) do
+            tag(:a) do
+              text 'Hello'
+              tag(:img)
+            end
+          end
+        end
+        it { output.should have_css 'div',     :count => 1 }
+        it { output.should have_css 'a',       :count => 1 }
+        it { output.should have_css 'div > a' }
+        it { output.should have_css 'div > a', :text => 'Hello' }
+        it { output.should have_css 'img',     :count => 1 }
+        it { output.should have_css 'div > a > img' }
+      end
+    end
+
+    describe 'buffering' do
+      describe 'tag concatenation' do
+        before do
+          @output = tag(:ul) do
+            tag(:li)
+            tag(:li)
+            tag(:li)
+          end
+        end
+
+        it { output.should have_css 'ul',      :count => 1 }
+        it { output.should have_css 'li',      :count => 3 }
+        it { output.should have_css 'ul > li', :count => 3 }
+      end
+
+      describe 'concatenation with text' do
+        before do
+          @output = tag(:ul) do
+            tag(:li) { text 'One' }
+            tag(:li) { text 'Two' }
+            tag(:li) { text 'Three' }
+          end
+        end
+
+        it { output.should have_css 'ul',      :count => 1 }
+        it { output.should have_css 'li',      :count => 3 }
+        it { output.should have_css 'ul > li', :count => 3 }
+        it { output.should have_css 'ul > li', :text => 'One' }
+        it { output.should have_css 'ul > li', :text => 'Two' }
+        it { output.should have_css 'ul > li', :text => 'Three' }
+      end
+
+      describe 'nested' do
+        before do
+          @output = tag(:ul) do
+            tag(:li) { tag(:a) { text 'One' } }
+            tag(:li) { tag(:a) { text 'Two' } }
+            tag(:li) { tag(:a) { text 'Three' } }
+          end
+        end
+
+        it { output.should have_css 'ul',          :count => 1 }
+        it { output.should have_css 'li',          :count => 3 }
+        it { output.should have_css 'ul > li',     :count => 3 }
+        it { output.should have_css 'a',           :count => 3 }
+        it { output.should have_css 'ul > li > a', :text => 'One' }
+        it { output.should have_css 'ul > li > a', :text => 'Two' }
+        it { output.should have_css 'ul > li > a', :text => 'Three' }
+      end
+
+      describe 'outside content block' do
+        it 'should not buffer contiguous tags' do
+          tag(:span)
+          tag(:a).should == '<a></a>'
+        end
+      end
+    end
+
+    describe 'text' do
+      it 'should escape text' do
+        @output = tag(:li){ text '&<>' }
+        @output.should =~ /&amp;&lt;&gt;/
+      end
+
+      it 'should allow not scaped text' do
+        @output = tag(:li){ append! '&<>' }
+        @output.should =~ /&<>/
+      end
+    end
+
+    describe 'formatting' do
+      it 'should buffer with newlines and indentation' do
+        output = tag(:ul) do
+          tag :li
+          tag :li
+        end
+        output.should == "<ul>\n  <li></li>\n  <li></li>\n</ul>"
+      end
+
+      it 'should buffer with newlines after text' do
+        output = tag(:ul) do
+          tag (:li) do
+            text 'Hi'
+            append! 'Hi'
+          end
+        end
+        output.should == "<ul>\n  <li>\n    Hi\n    Hi\n  </li>\n</ul>"
+      end
+    end
+  end
+
+  describe 'special nodes' do
+    describe 'comments' do
+      it 'should emit comment' do
+        comment('Hello').should == "<!-- Hello -->"
+        comment('Hello -- world').should == "<!-- Hello - - world -->"
+        comment('Hello -- -- world').should == "<!-- Hello - - - - world -->"
+      end
+
+      it 'should buffer comments' do
+        tag(:div) do
+          comment 'foo'
+          comment 'bar'
+        end.should == "<div>\n  <!-- foo -->\n  <!-- bar -->\n</div>"
+      end
+    end
+
+    describe 'cdata' do
+      it 'should emit cdata' do
+        cdata('Hello').should == "<![CDATA[Hello]]>"
+      end
+
+      it 'should buffer cdata' do
+        tag(:div) do
+          cdata('foo')
+          cdata('bar')
+        end.should == "<div>\n  <![CDATA[foo]]>\n  <![CDATA[bar]]>\n</div>"
+      end
+
+      it 'should not "escape" cdata terminator' do
+        cdata(']]>').should == "<![CDATA[]]]]><![CDATA[>]]>"
+      end
+    end
+
+    describe 'doctype' do
+      it 'should emit html5 doctype' do
+        doctype.should == '<!DOCTYPE html>'
+      end
+
+      it 'should buffer doctype' do
+        output = with_buffer{ doctype and tag(:html) }
+        output.should == "<!DOCTYPE html>\n<html></html>\n"
+
+      end
+    end
+  end
+
+  describe 'tag closing' do
+    describe 'void tags' do
+      it 'should define void tags' do
+        Tiny::HTML.void_tags.should == %w(area base br col hr img input link meta param embed)
+      end
+
+      Tiny::HTML.void_tags.each do |tag_name|
+        describe tag_name do
+          it 'sould autoclose' do
+            tag(tag_name).should == "<#{tag_name} />"
+          end
+
+          it 'should omit content' do
+            tag(tag_name){ text 'hi' }.should == "<#{tag_name} />"
+          end
+        end
+      end
+    end
+
+    describe 'content tags' do
+      it 'should define content tags' do
+        tags  = %w(
+          article aside audio bdi canvas command datalist details
+          figcaption figure header hgroup keygen mark meter nav output progress
+          section source summary track video wbr a abbr address b bdo big
+          blockquote body button caption cite code colgroup dd del dfn div dl dt
+          em fieldset footer form h1 h2 h3 h4 h5 h6 head html i iframe ins kbd
+          label legend li map noscript object ol optgroup option p pre q rp rt
+          ruby s samp script select small span strike strong style sub sup table
+          tbody td textarea tfoot th thead time title tr tt u ul var
+        )
+        Tiny::HTML.content_tags.should == tags
+      end
+
+      Tiny::HTML.content_tags.each do |tag_name|
+        it "should not autoclose #{tag_name} if not empty" do
+          tag(tag_name).should == "<#{tag_name}></#{tag_name}>"
+        end
+      end
+    end
+  end
+
+  describe 'with_buffer' do
+    before do
+      @output = with_buffer do
+        tag(:head) { tag(:title, "Tiny Page!") }
+        tag(:body) { tag(:h1, "Hello Tiny!") }
+      end
+    end
+
+    it { output.should have_css 'head', :count => 1 }
+    it { output.should have_css 'head > title', :text => "Tiny Page!", :count => 1 }
+    it { output.should have_css 'body', :count => 1 }
+    it { output.should have_css 'body > h1', :text => "Hello Tiny!", :count => 1 }
+  end
+
+  describe 'dsl' do
+    include Tiny::HTML
+
+    describe 'void tags' do
+      Tiny::HTML.void_tags.each do |tag_name|
+        it "should render '#{tag_name}'" do
+          self.send(tag_name).should == "<#{tag_name} />"
+        end
+      end
+
+      it "should render attributes" do
+        link(:href => "some.css").should == '<link href="some.css" />'
+      end
+    end
+
+    describe 'content tags' do
+      Tiny::HTML.content_tags.each do |tag_name|
+        it "should render '#{tag_name}'" do
+          self.send(tag_name).should == "<#{tag_name}></#{tag_name}>"
+        end
+      end
+
+      it "should render content and attributes" do
+        h1(:class => 'main') { text "Hello" }.should == %{<h1 class="main">\n  Hello\n</h1>}
+        h1("Hello", :class => 'main').should == %{<h1 class="main">Hello</h1>}
+      end
+    end
+  end
+end