hammer_builder 0.1.2 → 0.2.0

data/lib/hammer_builder/rails.rb

@@ -0,0 +1,40 @@
+require 'hammer_builder/formatted'
+
+warn '"hammer_builder/rails" is very early experiment'
+
+module HammerBuilder::Rails
+  class AbstractBuilder
+    extend HammerBuilder::Helper
+
+    attr_reader :controller
+
+    def initialize(controller)
+      @controller = controller
+    end
+
+  end
+
+  ActionController::Renderers.add :hb do |klass_or_obj, options|
+    obj = case
+      when klass_or_obj.kind_of?(Class)
+        klass_or_obj.new(self)
+      when klass_or_obj.nil? || klass_or_obj == self
+        self.class.to_s.gsub(/Controller/, 'Builder').constantize.new(self)
+      else
+        klass_or_obj
+    end
+
+    $hammer_builder_pool ||= HammerBuilder::SynchronizedPool.new(HammerBuilder::Formatted) # FIXME
+
+    render(
+        :text   => $hammer_builder_pool.get.
+            go_in { render obj, "#{options[:method] || options[:template]}" }.to_html!,
+        :layout => true)
+  end
+
+
+end
+
+
+
+

data/lib/hammer_builder/standard.rb

@@ -0,0 +1,48 @@
+require 'hammer_builder/abstract'
+
+module HammerBuilder
+
+  # Builder implementation without formating (one line output)
+  class Standard < Abstract
+
+    dynamic_classes do
+      extend_class :AbstractTag do
+        # add global HTML5 attributes
+        self.add_attributes Data::HTML5.abstract_attributes
+      end
+
+      Data::HTML5.double_tags.each do |tag|
+        next if tag.name == :html
+
+        def_class tag.name.to_s.camelize.to_sym, :AbstractDoubleTag do
+          set_tag tag.name
+          self.add_attributes tag.attributes
+        end
+
+        base.define_tag(tag.name)
+      end
+
+      html_tag = Data::HTML5.double_tags.find { |t| t.name == :html }
+      def_class :Html, :AbstractDoubleTag do
+        set_tag html_tag.name
+        self.add_attributes html_tag.attributes
+
+        def default
+          attribute :xmlns ,'http://www.w3.org/1999/xhtml'
+        end
+      end
+      base.define_tag(html_tag.name)
+
+      Data::HTML5.single_tags.each do |tag|
+        def_class tag.name.to_s.camelize.to_sym, :AbstractSingleTag do
+          set_tag tag.name
+          self.add_attributes tag.attributes
+        end
+
+        base.define_tag(tag.name)
+      end
+    end
+
+  end
+end
+

data/lib/hammer_builder/strings.rb

@@ -0,0 +1,29 @@
+module HammerBuilder
+  module Strings
+    def self.add(name, value)
+      name = name.to_s.upcase
+      if const_defined?(name)
+        raise "values are different for const #{name}: #{[const_get(name), value].inspect}" if const_get(name) != value
+      else
+        const_set(name, value.freeze)
+      end
+    end
+
+    add :lt, '<'
+    add :gt, '>'
+    add :slash_lt, '</'
+    add :slash_gt, ' />'
+    add :underscore, '_'
+    add :space, ' '
+    add :max_levels, 300
+    add :spaces, Array.new(MAX_LEVELS) { |i| ('  ' * i).freeze }
+    add :newline, "\n"
+    add :quote, '"'
+    add :eql, '='
+    add :eql_quote, EQL + QUOTE
+    add :comment_start, '<!--'
+    add :comment_end, '-->'
+    add :cdata_start, '<![CDATA['
+    add :cdata_end, ']]>'
+  end
+end

data/spec/hammer_builder_spec.rb

@@ -1,185 +1,278 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
+require 'spec_helper'
 
 describe HammerBuilder do
-  def super_subject
-    self.class.ancestors[1].allocate.subject
+  shared_examples "pool" do
+    it('should return correct instance') { pool.get.should be_kind_of(HammerBuilder::Formatted) }
+    it "should return instance into pool" do
+      pool.get.release
+      pool.size.should == 1
+      pool.get.to_html!
+      pool.size.should == 1
+    end
+  end
+
+  describe HammerBuilder::Pool do
+    let(:pool) { HammerBuilder::Pool.new HammerBuilder::Formatted }
+    include_examples 'pool'
+  end
+
+  describe HammerBuilder::SynchronizedPool do
+    let(:pool) { HammerBuilder::SynchronizedPool.new HammerBuilder::Formatted }
+    include_examples 'pool'
   end
 
   describe 'object with HammerBuilder::Helper' do
-    class AObject
-      include HammerBuilder::Helper
+    let(:pool) { HammerBuilder::Pool.new HammerBuilder::Standard }
 
-      builder :render do |obj|
-        @obj = obj
-        div 'a'
-      end
-    end
+    class User
+      extend HammerBuilder::Helper
 
-    subject { AObject.new }
+      builder :detail do |_, arg|
+        div arg
+      end
 
-    describe 'methods' do
-      subject { super_subject.class.instance_methods }
-      it { should include(:render) }
+      def detail2(b, arg)
+        b.div { b.text arg }
+      end
     end
 
-    describe '#render(builder)' do
-      subject { super_subject.render(HammerBuilder::Standard.get).to_xhtml! }
-      it { should == "<div>a</div>"}
+    describe 'User.new' do
+      it { User.new.should be_respond_to(:detail) }
+      it "should render correctly" do
+        pool.get.dive(User.new) do |user|
+          render user, :detail, 'content'
+          render user, :detail2, 'content'
+        end.to_html!.should == "<div>content</div><div>content</div>"
+      end
     end
+
   end
 
-  pending 'RedefinableClassTree'
-
-  #  describe 'RedefinableClassTree' do
-  #    let :klass do
-  #      Class.new do
-  #        extend HammerBuilder::RedefinableClassTree
-  #      end
-  #    end
-  #
-  #    describe '.define_class' do
-  #      before do
-  #        klass.define_class(:AClass) do
-  #          def a_method
-  #          end
-  #        end
-  #      end
-  #
-  #      it {  }
-  #    end
-  #  end
+  describe HammerBuilder::DynamicClasses do
+    class Parent
+      extend HammerBuilder::DynamicClasses
+      dc do
+        def_class :LeftEye do
+          def to_s;
+            'left eye';
+          end
+        end
 
-  describe HammerBuilder::Standard do
-    describe 'Pool methods' do
-      describe '.get' do
-        it { HammerBuilder::Standard.get.should be_an_instance_of(HammerBuilder::Standard) }
-        it { HammerBuilder::Formated.get.should be_an_instance_of(HammerBuilder::Formated) }
+        def_class :RightEye, :LeftEye do
+          class_eval <<-RUBYCODE, __FILE__, __LINE__+1
+            def to_s; 'next to ' + super; end
+          RUBYCODE
+        end
       end
+    end
 
-      describe '#release!' do
-        before do
-          (@builder = HammerBuilder::Standard.get).release!
-        end
+    class AChild < Parent
+    end
 
-        it 'should be same object' do
-          @builder.should == HammerBuilder::Standard.get
+    class AMutant < Parent
+      dc do
+        extend_class :LeftEye do
+          def to_s;
+            'laser ' + super;
+          end
         end
       end
+    end
+
+    it '#to_s should print correct values' do
+      Parent.dc[:LeftEye].new.to_s.should == 'left eye'
+      Parent.dc[:RightEye].new.to_s.should == 'next to left eye'
+      AChild.dc[:LeftEye].new.to_s.should == 'left eye'
+      AChild.dc[:RightEye].new.to_s.should == 'next to left eye'
+      AMutant.dc[:LeftEye].new.to_s.should == 'laser left eye'
+      AMutant.dc[:RightEye].new.to_s.should == 'next to laser left eye'
+    end
+
+    it 'should create different classes for each carrying class' do
+      Parent.dc[:LeftEye].should_not == AChild.dc[:LeftEye]
+      Parent.dc[:LeftEye].should_not == AMutant.dc[:LeftEye]
+    end
 
-      describe 'pools does not mix' do
-        before { HammerBuilder::Standard.get.release! }
-        it { HammerBuilder::Standard.pool_size.should == 1 }
-        it { HammerBuilder::Formated.get.should be_an_instance_of(HammerBuilder::Formated) }
+    describe 'Parent.dc.class_names' do
+      it do
+        Parent.dc.class_names.should include(:LeftEye, :RightEye)
+        Parent.dc.class_names.should have(2).items
       end
     end
+  end
+
+  describe HammerBuilder::Standard do
+    let(:pool) { HammerBuilder::Pool.new HammerBuilder::Standard }
+    let(:builder) { pool.get }
+
+    def quick_render &block
+      builder.dive(&block).to_html!
+    end
+
+    it 'should render #content' do
+      quick_render { div 'content' }.should == '<div>content</div>'
+      quick_render { div.content 'content' }.should == '<div>content</div>'
+      quick_render { div :content => 'content' }.should == '<div>content</div>'
+      quick_render { div { text 'content' } }.should == '<div>content</div>'
+      quick_render { div.with { text 'content' } }.should == '<div>content</div>'
+    end
+
+    it 'should render #id' do
+      quick_render { div.id :an_id }.should == '<div id="an_id"></div>'
+      quick_render { div.an_id! }.should == '<div id="an_id"></div>'
+      quick_render { div.an_id! { text 'content' } }.should == '<div id="an_id">content</div>'
+      quick_render { div.an_id! 'content' }.should == '<div id="an_id">content</div>'
+      quick_render { div.an_id! }.should == '<div id="an_id"></div>'
+      quick_render { div :id => 12 }.should == '<div id="12"></div>'
+      quick_render { div 'asd', :id => 12 }.should == '<div id="12">asd</div>'
+      quick_render { hr.id 'an_id' }.should == '<hr id="an_id" />'
+      quick_render { hr.an_id! }.should == '<hr id="an_id" />'
+      quick_render { hr :id => 'an_id' }.should == '<hr id="an_id" />'
+
+      quick_render { hr.id 'an', 'id', nil, false }.should == '<hr id="an_id" />'
+      quick_render { div.id 'an', 'id', nil, false }.should == '<div id="an_id"></div>'
+    end
 
-    describe 'available methods' do
-      subject { HammerBuilder::Standard.instance_methods }
+    it 'should render #class' do
+      #noinspection RubyArgCount
+      quick_render { div.class 'an_class' }.should == '<div class="an_class"></div>'
+      quick_render { div.an_class }.should == '<div class="an_class"></div>'
+      quick_render { div :class => 'an_class' }.should == '<div class="an_class"></div>'
+      #noinspection RubyArgCount
+      quick_render { hr.class 'an_class' }.should == '<hr class="an_class" />'
+      quick_render { hr.an_class }.should == '<hr class="an_class" />'
+      quick_render { hr :class => 'an_class' }.should == '<hr class="an_class" />'
 
-      (HammerBuilder::DOUBLE_TAGS + HammerBuilder::EMPTY_TAGS).each do |tag|
-        it "should have method #{tag}" do
-          should include(tag.to_sym)
+      quick_render { div.an_class.another_class }.should == '<div class="an_class another_class"></div>'
+      #noinspection RubyArgCount
+      quick_render { div.class 'an_class', 'another_class' }.should == '<div class="an_class another_class"></div>'
+      quick_render { div :class => ['an_class', 'another_class'] }.should == '<div class="an_class another_class"></div>'
+      #noinspection RubyArgCount
+      quick_render { div.class(false, nil, 'an_class', true && 'another_class') }.should ==
+          '<div class="an_class another_class"></div>'
+    end
+
+    it "#attribute" do
+      quick_render { div.attribute 'xml:ns', 'gibris' }.should == '<div xml:ns="gibris"></div>'
+      quick_render { div.attribute(:class, 'a') { text 'asd' } }.should == '<div class="a">asd</div>'
+    end
+
+    it '#[]' do
+      obj = Object.new
+      quick_render { div[obj] }.should == %Q(<div id="object_#{obj.object_id}" class="object"></div>)
+
+      class AnObject
+        def self.hammer_builder_ref
+          "a"
         end
 
-        describe tag do
-          before { @builder = HammerBuilder::Standard.get }
-          after { @builder.release! }
-          subject { @builder.send(tag).methods }
-          it "should include its attribute methods" do
-            attrs = (HammerBuilder::GLOBAL_ATTRIBUTES + HammerBuilder::EXTRA_ATTRIBUTES[tag]).
-                map {|attr| attr.to_sym}
-            should include(*attrs)
-          end
+        def hammer_builder_ref
+          'b'
         end
       end
+      obj = AnObject.new
+      quick_render { div[obj] }.should == %Q(<div id="b" class="a"></div>)
 
+      obj = Object.new.extend(Module.new do
+        def id;
+          "an_id";
+        end
+      end)
+      quick_render { div[obj] }.should == %Q(<div id="object_an_id" class="object"></div>)
+      quick_render { div.mimic(obj) { text 'a' } }.should == %Q(<div id="object_an_id" class="object">a</div>)
     end
 
-    CONTENT = :'cc<>&cc'
-
-    describe 'rendering' do
-      describe '1' do
-        subject do
-          HammerBuilder::Formated.get.go_in do
-            xhtml5!
-            html do
-              head { title }
-              body do
-                div CONTENT
-                meta.http_equiv CONTENT
-                p.content CONTENT
-                div.id CONTENT
-                div.data_id CONTENT
-                div :id => CONTENT, :content => CONTENT
-                div.attributes :id => CONTENT, :content => CONTENT
-                div.attribute :newone, CONTENT
-                div { text CONTENT }
-                div[CONTENT].with { article CONTENT }
-                js 'var < 1;'
-                div do
-                  strong :content
-                  text :content
-                end
-              end
-            end
-          end.to_xhtml!.strip
-        end
+    it "#data-.*" do
+      quick_render { div('a').data_secret("I won't tell.") }.should == '<div data-secret="I won\'t tell.">a</div>'
+    end
+
+    it '#data' do
+      quick_render { hr.data(:secret => true) }.should == '<hr data-secret="true" />'
+      quick_render { div('a', :data => { :secret => "I won't tell." }) }.should ==
+          '<div data-secret="I won\'t tell.">a</div>'
+      quick_render { div('a').data(:secret => "I won't tell.") { text 'a' } }.should ==
+          '<div data-secret="I won\'t tell.">a</div>'
+    end
 
-        it { should_not match(/cc<>&cc/) }
-        it 'should render corectly' do
-          should == (<<STR).strip
-<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <title></title>
-  </head>
-  <body>
-    <div>cc&lt;&gt;&amp;cc</div>
-    <meta http-equiv="cc&lt;&gt;&amp;cc" />
-    <p>cc&lt;&gt;&amp;cc</p>
-    <div id="cc&lt;&gt;&amp;cc"></div>
-    <div data-id="cc&lt;&gt;&amp;cc"></div>
-    <div id="cc&lt;&gt;&amp;cc">cc&lt;&gt;&amp;cc</div>
-    <div id="cc&lt;&gt;&amp;cc">cc&lt;&gt;&amp;cc</div>
-    <div newone="cc&lt;&gt;&amp;cc"></div>
-    <div>cc&lt;&gt;&amp;cc
-    </div>
-    <div id="cc&lt;&gt;&amp;cc">
-      <article>cc&lt;&gt;&amp;cc</article>
-    </div>
-    <script type="text/javascript"><![CDATA[var < 1;]]>
-    </script>
-    <div>
-      <strong>content</strong>content
-    </div>
-  </body>
-</html>
-STR
+    it 'tags should have all the attributes' do
+      builder.tags.each do |tag|
+        builder.should be_respond_to(tag)
+        tag_instance = builder.send(tag)
+        (HammerBuilder::Data::HTML5.abstract_attributes.map(&:name) +
+            (HammerBuilder::Data::HTML5.single_tags + HammerBuilder::Data::HTML5.double_tags).
+                find { |t| t.name.to_s == tag }.attributes.map(&:name)).each do |attr|
+          tag_instance.should be_respond_to(attr)
         end
       end
-      describe '2' do
-        subject do
-          HammerBuilder::Formated.get.go_in do
-            html do
-              body do
-                comment CONTENT
-                cdata CONTENT
-              end
+    end
+
+    it "boolean attributes should render correctly" do
+      quick_render { input.readonly }.should == '<input readonly="readonly" />'
+      quick_render { option.selected { text 'asd' } }.should == '<option selected="selected">asd</option>'
+      quick_render { option.selected(true) }.should == '<option selected="selected"></option>'
+      quick_render { option.selected(1) }.should == '<option selected="selected"></option>'
+      quick_render { option.selected(false) }.should == '<option></option>'
+      quick_render { div.hidden('asd') }.should == '<div hidden="hidden"></div>'
+    end
+
+    it "should render correctly" do
+      quick_render do
+        html5
+        html do
+          head do
+            title.an_id! 'a_title'
+            meta.charset "utf-8"
+          end
+          body.id 'content' do
+            text 'asd'
+            div.left.style nil do
+              raw 'asd'
+              hr
             end
-          end.to_xhtml!.strip
+            br
+            div.left do
+              hr
+              js 'asd'
+              js 'asd', :cdata => true
+            end
+            comment 'asd'
+          end
+          comment 'asd'
         end
+      end.should == '<!DOCTYPE html>' + "\n" +
+          '<html xmlns="http://www.w3.org/1999/xhtml"><head><title id="an_id">a_title</title><meta charset="utf-8" />'+
+          '</head><body id="content">asd<div style="" class="left">asd<hr /></div><br /><div class="left"><hr />'+
+          '<script type="text/javascript">asd</script><script type="text/javascript"><![CDATA[asd]]></script>'+
+          '</div><!--asd--></body><!--asd--></html>'
+    end
 
-        it 'should render corectly' do
-          should == (<<STR).strip
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <body>
-    <!--cc<>&cc--><![CDATA[cc<>&cc]]>
-  </body>
-</html>
-STR
-        end
-      end
+    it "#set variables" do
+      r = builder.set_variables(:a => 'a') do |b|
+        b.dive { p @a }
+      end.to_html!
+
+      r.should == '<p>a</p>'
+      builder.instance_variable_get(:@a).should be_nil
+    end
+
+    it "#join" do
+      quick_render { join([1, 2]) { |n| text n } }.should == '12'
+      quick_render { join([1, 2], 'a') { |n| text n } }.should == '1a2'
+      quick_render { join([lambda { text 1 }, 2], 'a') { |n| text n } }.should == '1a2'
+      quick_render { join([lambda { text 1 }, 2], lambda { text 'a' }) { |n| text n } }.should == '1a2'
+    end
+  end
+
+  describe HammerBuilder::Formatted do
+    let(:pool) { HammerBuilder::Pool.new HammerBuilder::Formatted }
+    let(:builder) { pool.get }
+
+    def quick_render &block
+      builder.dive(&block).to_html!
+    end
+
+    it "should be formatted" do
+      quick_render { div { comment 'asd'; br }; p }.should == "\n<div>\n  <!--asd-->\n  <br />\n</div>\n<p></p>"
     end
   end
-end
+end