RubyGems - hammer_builder - Versions diffs - 0.1.0 - Mend

hammer_builder 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

data/LICENSE +19 -0
data/README.md +133 -0
data/lib/hammer_builder.rb +726 -0
data/spec/hammer_builder_spec.rb +185 -0
data/spec/spec_helper.rb +5 -0
metadata +143 -0

data/LICENSE ADDED Viewed

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Petr Chalupa
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md ADDED Viewed

@@ -0,0 +1,133 @@
+# HammerBuilder
+[`HammerBuilder`](https://github.com/ruby-hammer/hammer-builder)
+is a xhtml5 builder written in Ruby 1.9.2. It does not introduce anything special, you just
+use Ruby to get your xhtml. [`HammerBuilder`](https://github.com/ruby-hammer/hammer-builder)
+has been written with three objectives:
+* Speed
+* Rich API
+* Extensibility
+## Links
+* Introduction:
+[http://hammer.pitr.ch/2011/05/11/HammerBuilder-introduction/](http://hammer.pitr.ch/2011/05/11/HammerBuilder-introduction/)
+* Yardoc: [http://hammer.pitr.ch/hammer-builder/](http://hammer.pitr.ch/hammer-builder/)
+* Issues: [https://github.com/ruby-hammer/hammer-builder/issues](https://github.com/ruby-hammer/hammer-builder/issues)
+* Changelog: [http://hammer.pitr.ch/hammer-builder/file.CHANGELOG.html](http://hammer.pitr.ch/hammer-builder/file.CHANGELOG.html)
+## Syntax
+    HammerBuilder::Formated.get.go_in do
+      xhtml5!
+      html do
+        head { title 'a title' }
+        body do
+          div.id('menu').class('left') do
+            ul do
+              li 'home'
+              li 'contacts', :class => 'active'
+            end
+          end
+          div.id('content') do
+            article.id 'article1' do
+              h1 'header'
+              p('some text').class('centered')
+              div(:class => 'like').class('hide').with do
+                text 'like on '
+                strong 'Facebook'
+              end
+            end
+          end
+        end
+      end
+    end.to_xhtml!
+    #=>
+    #<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html>
+    #<html xmlns="http://www.w3.org/1999/xhtml">
+    #  <head>
+    #    <title>a title</title>
+    #  </head>
+    #  <body>
+    #    <div id="menu" class="left">
+    #      <ul>
+    #        <li>home</li>
+    #        <li class="active">contacts</li>
+    #      </ul>
+    #    </div>
+    #    <div id="content">
+    #      <article id="article1">
+    #        <h1>header</h1>
+    #        <p class="centered">some text</p>
+    #        <div class="like hide">like on
+    #          <strong>Facebook</strong>
+    #        </div>
+    #      </article>
+    #    </div>
+    #  </body>
+    #</html>
+## Benchmark
+### Synthetic
+                                  user     system      total        real
+    render                    4.380000   0.000000   4.380000 (  4.394127)
+    render3                   4.990000   0.000000   4.990000 (  5.017267)
+    HammerBuilder::Standard   5.590000   0.000000   5.590000 (  5.929775)
+    HammerBuilder::Formated   5.520000   0.000000   5.520000 (  5.511297)
+    erubis                    7.340000   0.000000   7.340000 (  7.345410)
+    erubis-reuse              4.670000   0.000000   4.670000 (  4.666334)
+    fasterubis                7.700000   0.000000   7.700000 (  7.689792)
+    fasterubis-reuse          4.650000   0.000000   4.650000 (  4.648017)
+    tenjin                   11.810000   0.280000  12.090000 ( 12.084124)
+    tenjin-reuse              3.170000   0.010000   3.180000 (  3.183110)
+    erector                  12.100000   0.000000  12.100000 ( 12.103520)
+    markaby                  20.750000   0.030000  20.780000 ( 21.371292)
+    tagz                     73.200000   0.140000  73.340000 ( 73.306450)
+### In Rails 3
+    BenchTest#test_erubis_partials (3.34 sec warmup)
+               wall_time: 3.56 sec
+                  memory: 0.00 KB
+                 objects: 0
+                 gc_runs: 15
+                 gc_time: 0.53 ms
+    BenchTest#test_erubis_single (552 ms warmup)
+               wall_time: 544 ms
+                  memory: 0.00 KB
+                 objects: 0
+                 gc_runs: 4
+                 gc_time: 0.12 ms
+    BenchTest#test_hammer_builder (2.33 sec warmup)
+               wall_time: 847 ms
+                  memory: 0.00 KB
+                 objects: 0
+                 gc_runs: 5
+                 gc_time: 0.17 ms
+    BenchTest#test_tenjin_partial (942 ms warmup)
+               wall_time: 1.21 sec
+                  memory: 0.00 KB
+                 objects: 0
+                 gc_runs: 7
+                 gc_time: 0.25 ms
+    BenchTest#test_tenjin_single (531 ms warmup)
+               wall_time: 532 ms
+                  memory: 0.00 KB
+                 objects: 0
+                 gc_runs: 6
+                 gc_time: 0.20 ms
+### Conclusion
+Template engines are slightly faster than [`HammerBuilder`](https://github.com/ruby-hammer/hammer-builder)
+when template does not content a lot of inserting or partials.
+On the other hand when partials are used, [`HammerBuilder`](https://github.com/ruby-hammer/hammer-builder)
+beats template engines.
+There is no overhead for partials in [`HammerBuilder`](https://github.com/ruby-hammer/hammer-builder)
+compared to using partials in template engine. The difference is significant for `Erubis`, `Tenjin` is
+not so bad, but I did not find any easy way to use `Tenjin` in Rails 3 (I did some hacking).

data/lib/hammer_builder.rb ADDED Viewed

@@ -0,0 +1,726 @@
+require 'cgi'
+require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/core_ext/string/inflections'
+module HammerBuilder
+  EXTRA_ATTRIBUTES = {
+    "a" => ["href", "target", "ping", "rel", "media", "hreflang", "type"],
+    "abbr" => [],
+    "address" => [],
+    "area" => ["alt", "coords", "shape", "href", "target", "ping", "rel", "media", "hreflang", "type"],
+    "article" => [],
+    "aside" => [],
+    "audio" => ["src", "preload", "autoplay", "mediagroup", "loop", "controls"],
+    "b" => [],
+    "base" => ["href", "target"],
+    "bdi" => [],
+    "bdo" => [],
+    "blockquote" => ["cite"],
+    "body" => ["onafterprint", "onbeforeprint", "onbeforeunload", "onblur", "onerror", "onfocus", "onhashchange",
+      "onload", "onmessage", "onoffline", "ononline", "onpagehide", "onpageshow", "onpopstate", "onredo", "onresize",
+      "onscroll", "onstorage", "onundo", "onunload"],
+    "br" => [],
+    "button" => ["autofocus", "disabled", "form", "formaction", "formenctype", "formmethod", "formnovalidate",
+      "formtarget", "name", "type", "value"],
+    "canvas" => ["width", "height"],
+    "caption" => [],
+    "cite" => [],
+    "code" => [],
+    "col" => ["span"],
+    "colgroup" => ["span"],
+    "command" => ["type", "label", "icon", "disabled", "checked", "radiogroup"],
+    "datalist" => ["option"],
+    "dd" => [],
+    "del" => ["cite", "datetime"],
+    "details" => ["open"],
+    "dfn" => [],
+    "div" => [],
+    "dl" => [],
+    "dt" => [],
+    "em" => [],
+    "embed" => ["src", "type", "width", "height"],
+    "fieldset" => ["disabled", "form", "name"],
+    "figcaption" => [],
+    "figure" => [],
+    "footer" => [],
+    "form" => ["action", "autocomplete", "enctype", "method", "name", "novalidate", "target", 'accept_charset'],
+    "h1" => [],
+    "h2" => [],
+    "h3" => [],
+    "h4" => [],
+    "h5" => [],
+    "h6" => [],
+    "head" => [],
+    "header" => [],
+    "hgroup" => [],
+    "hr" => [],
+    "html" => ["manifest"],
+    "i" => [],
+    "iframe" => ["src", "srcdoc", "name", "sandbox", "seamless", "width", "height"],
+    "img" => ["alt", "src", "usemap", "ismap", "width", "height"],
+    "input" => ["accept", "alt", "autocomplete", "autofocus", "checked", "dirname", "disabled", "form", "formaction",
+      "formenctype", "formmethod", "formnovalidate", "formtarget", "height", "list", "max", "maxlength", "min",
+      "multiple", "name", "pattern", "placeholder", "readonly", "required", "size", "src", "step", "type", "value",
+      "width"],
+    "ins" => ["cite", "datetime"],
+    "kbd" => [],
+    "keygen" => ["autofocus", "challenge", "disabled", "form", "keytype", "name"],
+    "label" => ["form", "for"],
+    "legend" => [],
+    "li" => ["value"],
+    "link" => ["href", "rel", "media", "hreflang", "type", "sizes"],
+    "map" => ["name"],
+    "mark" => [],
+    "menu" => ["type", "label"],
+    "meta" => ["name", "content", "charset", "http_equiv"],
+    "meter" => ["value", "min", "max", "low", "high", "optimum", "form"],
+    "nav" => [],
+    "noscript" => [],
+    "object" => ["data", "type", "name", "usemap", "form", "width", "height"],
+    "ol" => ["reversed", "start"],
+    "optgroup" => ["disabled", "label"],
+    "option" => ["disabled", "label", "selected", "value"],
+    "output" => ["for", "form", "name"],
+    "p" => [],
+    "param" => ["name", "value"],
+    "pre" => [],
+    "progress" => ["value", "max", "form"],
+    "q" => ["cite"],
+    "rp" => [],
+    "rt" => [],
+    "ruby" => [],
+    "s" => [],
+    "samp" => [],
+    "script" => ["src", "async", "defer", "type", "charset"],
+    "section" => [],
+    "select" => ["autofocus", "disabled", "form", "multiple", "name", "required", "size"],
+    "small" => [],
+    "source" => ["src", "type", "media"],
+    "span" => [],
+    "strong" => [],
+    "style" => ["media", "type", "scoped"],
+    "sub" => [],
+    "summary" => [],
+    "sup" => [],
+    "table" => ["border"],
+    "tbody" => [],
+    "td" => ["colspan", "rowspan", "headers"],
+    "textarea" => ["autofocus", "cols", "disabled", "form", "maxlength", "name", "placeholder", "readonly",
+      "required", "rows", "wrap"],
+    "tfoot" => [],
+    "th" => ["colspan", "rowspan", "headers", "scope"],
+    "thead" => [],
+    "time" => ["datetime", "pubdate"],
+    "title" => [],
+    "tr" => [],
+    "track" => ["default", "kind", "label", "src", "srclang"],
+    "u" => [],
+    "ul" => [],
+    "var" => [],
+    "video" => ["src", "poster", "preload", "autoplay", "mediagroup", "loop", "controls", "width", "height"],
+    "wbr" => []
+  }
+  GLOBAL_ATTRIBUTES = [
+    'accesskey','class','contenteditable','contextmenu','dir','draggable','dropzone','hidden','id','lang',
+    'spellcheck','style','tabindex','title','onabort','onblur','oncanplay','oncanplaythrough','onchange',
+    'onclick','oncontextmenu','oncuechange','ondblclick','ondrag','ondragend','ondragenter','ondragleave',
+    'ondragover','ondragstart','ondrop','ondurationchange','onemptied','onended','onerror','onfocus','oninput',
+    'oninvalid','onkeydown','onkeypress','onkeyup','onload','onloadeddata','onloadedmetadata','onloadstart',
+    'onmousedown','onmousemove','onmouseout','onmouseover','onmouseup','onmousewheel','onpause','onplay',
+    'onplaying','onprogress','onratechange','onreadystatechange','onreset','onscroll','onseeked','onseeking',
+    'onselect','onshow','onstalled','onsubmit','onsuspend','ontimeupdate','onvolumechange','onwaiting'
+  ]
+  DOUBLE_TAGS = [
+    'a', 'abbr',  'article', 'aside', 'audio', 'address',
+    'b', 'bdo', 'blockquote', 'body', 'button',
+    'canvas', 'caption', 'cite', 'code', 'colgroup', 'command',
+    'datalist', 'dd', 'del', 'details', 'dfn', 'div', 'dl', 'dt',
+    'em',
+    'fieldset', 'figure', 'footer', 'form',
+    'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'html', 'i',
+    'iframe', 'ins', 'keygen', 'kbd', 'label', 'legend', 'li',
+    'map', 'mark', 'meter',
+    'nav', 'noscript',
+    'object', 'ol', 'optgroup', 'option',
+    'p', 'pre', 'progress',
+    'q', 'ruby', 'rt', 'rp', 's',
+    'samp', 'script', 'section', 'select', 'small', 'source', 'span',
+    'strong', 'style', 'sub', 'sup',
+    'table', 'tbody', 'td', 'textarea', 'tfoot',
+    'th', 'thead', 'time', 'title', 'tr',
+    'u', 'ul',
+    'var', 'video'
+  ]
+  EMPTY_TAGS = [
+    'area', 'base', 'br', 'col', 'embed',
+    'hr', 'img', 'input', 'link', 'meta', 'param'
+  ]
+  LT = '<'.freeze
+  GT = '>'.freeze
+  SLASH_LT = '</'.freeze
+  SLASH_GT = ' />'.freeze
+  SPACE = ' '.freeze
+  MAX_LEVELS = 300
+  SPACES = Array.new(MAX_LEVELS) {|i| ('  ' * i).freeze }
+  NEWLINE = "\n".freeze
+  QUOTE = '"'.freeze
+  EQL = '='.freeze
+  EQL_QUOTE = EQL + QUOTE
+  COMMENT_START = '<!--'.freeze
+  COMMENT_END = '-->'.freeze
+  CDATA_START = '<![CDATA['.freeze
+  CDATA_END = ']]>'.freeze
+  module Helper
+    def self.included(base)
+      super
+      base.extend ClassMethods
+      base.class_inheritable_array :builder_methods, :instance_writer => false, :instance_reader => false
+    end
+    module ClassMethods
+      # adds instance method to the class. Method accepts any instance of builder and returns it after rendering.
+      # @param [Symbol] method_name
+      # @yield [self] builder_block is evaluated inside builder and accepts instance of a rendered object as parameter
+      # @example
+      #   class User
+      #   # ...
+      #     include HammerBuilder::Helper
+      #
+      #     builder :menu do |user|
+      #       li user.name
+      #     end
+      #   end
+      #
+      #   User.new.menu(HammerBuilder::Standard.get).to_xhtml! #=> "<li>Name</li>"
+      def builder(method_name, &builder_block)
+        self.builder_methods = [method_name.to_sym]
+        define_method(method_name) do |builder, *args|
+          builder.go_in(self, *args, &builder_block)
+        end
+      end
+    end
+  end
+  module RedefinableClassTree
+    # defines new class
+    # @param [Symbol] class_name
+    # @param [Symbol] superclass_name e.g. :AbstractEmptyTag
+    # @yield definition block which is evaluated inside the new class, doing so defining the class's methods etc.
+    def define_class(class_name, superclass_name = nil, &definition)
+      class_name = class_name(class_name)
+      superclass_name = class_name(superclass_name) if superclass_name
+      raise "class: '#{class_name}' already defined" if  respond_to? method_class(class_name)
+      define_singleton_method method_class(class_name) do |builder|
+        builder.instance_variable_get("@#{method_class(class_name)}") || begin
+          klass = builder.send(method_class_definition(class_name), builder)
+          builder.const_set class_name, klass
+          builder.instance_variable_set("@#{method_class(class_name)}", klass)
+        end
+      end
+      define_singleton_method method_class_definition(class_name) do |builder|
+        superclass = if superclass_name
+          builder.send method_class(superclass_name), builder
+        else
+          Object
+        end
+        Class.new(superclass, &definition)
+      end
+    end
+    # extends existing class
+    # @param [Symbol] class_name
+    # @yield definition block which is evaluated inside the new class, doing so extending the class's methods etc.
+    def extend_class(class_name, &definition)
+      raise "class: '#{class_name}' not defined" unless respond_to? method_class(class_name)
+      define_singleton_method method_class_definition(class_name) do |builder|
+        ancestor = super(builder)
+        count = 1; count += 1 while builder.const_defined? "#{class_name}Super#{count}"
+        builder.const_set "#{class_name}Super#{count}", ancestor
+        Class.new(ancestor, &definition)
+      end
+    end
+    private
+    def class_name(klass)
+      klass.to_s.camelize
+    end
+    def method_class(klass)
+      "#{klass.to_s.underscore}_class"
+    end
+    def method_class_definition(klass)
+      "#{method_class(klass)}_definition"
+    end
+  end
+  # Creating builder instances is expensive, therefore you can use Pool to go around that
+  module Pool
+    def self.included(base)
+      super
+      base.extend ClassMethods
+    end
+    module ClassMethods
+      # This the preferred way of getting new Builder. If you forget to release it, it does not matter -
+      # builder gets GCed after you lose reference
+      # @return [Standard, Formated]
+      def get
+        mutex.synchronize do
+          if free_builders.empty?
+            new
+          else
+            free_builders.pop
+          end
+        end
+      end
+      # returns +builder+ back into pool *DONT* forget to lose the reference to the +builder+
+      # @param [Standard, Formated]
+      def release(builder)
+        builder.reset
+        mutex.synchronize do
+          free_builders.push builder
+        end
+        nil
+      end
+      # @return [Fixnum] size of free builders
+      def pool_size
+        free_builders.size
+      end
+      private
+      def mutex
+        @mutex ||= Mutex.new
+      end
+      def free_builders
+        @free_builders ||= []
+      end
+    end
+    # instance version of ClassMethods.release
+    # @see ClassMethods.release
+    def release!
+      self.class.release(self)
+    end
+  end
+  # Abstract implementation of Builder
+  class Abstract
+    extend RedefinableClassTree
+    include Pool
+    # << faster then +
+    # yield faster then block.call
+    # accessing ivar and constant is faster then accesing hash or cvar
+    # class_eval faster then define_method
+    # beware of strings in methods -> creates a lot of garbage
+    define_class :AbstractTag do
+      def initialize(builder)
+        @builder = builder
+        @output = builder.instance_eval { @output }
+        @stack = builder.instance_eval { @stack }
+        @classes = []
+        set_tag
+      end
+      def open(attributes = nil)
+        @output << LT << @tag
+        @builder.current = self
+        attributes(attributes)
+        default
+        self
+      end
+      # @example
+      # div.attributes :id => 'id' # => <div id="id"></div>
+      def attributes(attrs)
+        return self unless attrs
+        attrs.each do |attr, value|
+          __send__(attr, *value)
+        end
+        self
+      end
+      # @example
+      # div.attribute :id, 'id' # => <div id="id"></div>
+      def attribute(attribute, content)
+        @output << SPACE << attribute.to_s << EQL_QUOTE << CGI.escapeHTML(content.to_s) << QUOTE
+      end
+      alias_method(:rclass, :class)
+      class_inheritable_array :_attributes, :instance_writer => false, :instance_reader => false
+      def self.attributes
+        self._attributes
+      end
+      # allows data-* attributes
+      def method_missing(method, *args, &block)
+        if method.to_s =~ /data_([a-z_]+)/
+          self.rclass.attributes = [method.to_s]
+          self.send method, *args, &block
+        else
+          super
+        end
+      end
+      protected
+      # sets the right tag in descendants
+      def self.set_tag(tag)
+        class_eval <<-RUBYCODE, __FILE__, __LINE__ + 1
+          def set_tag
+            @tag = '#{tag}'.freeze
+          end
+        RUBYCODE
+      end
+      # this method is called on each tag opening, useful for default attributes
+      # @example html tag uses this to add xmlns attr.
+      #   html # => <html xmlns="http://www.w3.org/1999/xhtml"></html>
+      def default
+      end
+      # defines dynamically methods for attributes
+      def self.define_attributes
+        attributes.each do |attr|
+          next if instance_methods.include?(attr.to_sym)
+          class_eval <<-RUBYCODE, __FILE__, __LINE__ + 1
+            def #{attr}(content)
+              @output << ATTR_#{attr.upcase} << CGI.escapeHTML(content.to_s) << QUOTE
+              self
+            end
+          RUBYCODE
+        end
+        define_attribute_constants
+      end
+      # defines constant strings not to make garbage
+      def self.define_attribute_constants
+        attributes.each do |attr|
+          const = "attr_#{attr}".upcase
+          HammerBuilder.const_set const, " #{attr.gsub('_', '-')}=\"".freeze unless HammerBuilder.const_defined?(const)
+        end
+      end
+      # adds attribute to class, triggers dynamical creation of needed instance methods etc.
+      def self.attributes=(attributes)
+        self._attributes = attributes
+        define_attributes
+      end
+      # flushes classes to output
+      def flush_classes
+        unless @classes.empty?
+          @output << ATTR_CLASS << CGI.escapeHTML(@classes.join(SPACE)) << QUOTE
+          @classes.clear
+        end
+      end
+      def set_tag
+        @tag = 'abstract'
+      end
+      public
+      # global HTML5 attributes
+      self.attributes = GLOBAL_ATTRIBUTES
+      alias :[] :id
+      class_eval <<-RUBYCODE, __FILE__, __LINE__ + 1
+        def class(*classes)
+          @classes.push(*classes)
+          self
+        end
+      RUBYCODE
+    end
+    define_class :AbstractEmptyTag, :AbstractTag do
+      def flush
+        flush_classes
+        @output << SLASH_GT
+        nil
+      end
+    end
+    define_class :AbstractDoubleTag, :AbstractTag do
+      # defined by class_eval because there is a super calling, causing error:
+      #  super from singleton method that is defined to multiple classes is not supported;
+      #  this will be fixed in 1.9.3 or later (NotImplementedError)
+      class_eval <<-RUBYCODE, __FILE__, __LINE__ + 1
+        def initialize(builder)
+          super
+          @content = nil
+        end
+        def open(*args, &block)
+          attributes = if args.last.is_a?(Hash)
+            args.pop
+          end
+          content args[0]
+          super attributes
+          @stack << @tag
+          if block
+            with &block
+          else
+            self
+          end
+        end
+      RUBYCODE
+      def flush
+        flush_classes
+        @output << GT
+        @output << CGI.escapeHTML(@content) if @content
+        @output << SLASH_LT << @stack.pop << GT
+        @content = nil
+      end
+      # sets content of the double tag
+      def content(content)
+        @content = content.to_s
+        self
+      end
+      # renders content of the double tag with block
+      def with
+        flush_classes
+        @output << GT
+        @content = nil
+        @builder.current = nil
+        yield
+        #        if (content = yield).is_a?(String)
+        #          @output << CGI.escapeHTML(content)
+        #        end
+        @builder.flush
+        @output << SLASH_LT << @stack.pop << GT
+        nil
+      end
+      protected
+      def self.define_attributes
+        attributes.each do |attr|
+          next if instance_methods(false).include?(attr.to_sym)
+          if instance_methods.include?(attr.to_sym)
+            class_eval <<-RUBYCODE, __FILE__, __LINE__ + 1
+              def #{attr}(*args, &block)
+                super(*args, &nil)
+                return with(&block) if block
+                self
+              end
+            RUBYCODE
+          else
+            class_eval <<-RUBYCODE, __FILE__, __LINE__ + 1
+              def #{attr}(content, &block)
+                @output << ATTR_#{attr.upcase} << CGI.escapeHTML(content.to_s) << QUOTE
+                return with(&block) if block
+                self
+              end
+            RUBYCODE
+          end
+        end
+        define_attribute_constants
+      end
+    end
+    class_inheritable_accessor :tags, :instance_writer => false
+    self.tags = {}
+    protected
+    # defines instance method for +tag+ in builder
+    def self.define_tag(tag)
+      class_eval <<-RUBYCODE, __FILE__, __LINE__ + 1
+        def #{tag}(*args, &block)
+          flush
+          @#{tag}.open(*args, &block)
+        end
+      RUBYCODE
+      self.tags[tag] = tag
+    end
+    public
+    attr_accessor :current
+    def initialize()
+      @output = ""
+      @stack = []
+      @current = nil
+      # tag classes initialization
+      tags.values.each do |klass|
+        instance_variable_set(:"@#{klass}", self.class.send("#{klass}_class", self.class).new(self))
+      end
+    end
+    # escapes +text+ to output
+    def text(text)
+      flush
+      @output << CGI.escapeHTML(text.to_s)
+    end
+    # unescaped +text+ to output
+    def raw(text)
+      flush
+      @output << text.to_s
+    end
+    # inserts +comment+
+    def comment(comment)
+      flush
+      @output << COMMENT_START << comment.to_s << COMMENT_END
+    end
+    # insersts CDATA with +content+
+    def cdata(content)
+      flush
+      @output << CDATA_START << content.to_s << CDATA_END
+    end
+    def xml_version(version = '1.0', encoding = 'UTF-8')
+      flush
+      @output << "<?xml version=\"#{version}\" encoding=\"#{encoding}\"?>"
+    end
+    def doctype
+      flush
+      @output << "<!DOCTYPE html>"
+    end
+    # inserts xhtml5 header
+    def xhtml5!
+      xml_version
+      doctype
+    end
+    # resets the builder to the state after creation - much faster then creating a new one
+    def reset
+      flush
+      @output.clear
+      @stack.clear
+      self
+    end
+    # enables you to evaluate +block+ inside the builder with +variables+
+    # @example
+    #  HammerBuilder::Formated.get.freeze.go_in('asd') do |string|
+    #    div string
+    #  end.to_html! #=> "<div>asd</div>"
+    #
+    def go_in(*variables, &block)
+      instance_exec *variables, &block
+      self
+    end
+    # @return [String] output
+    def to_xhtml()
+      flush
+      @output.clone
+    end
+    # @return [String] output and releases the builder to pool
+    def to_xhtml!
+      r = to_xhtml
+      release!
+      r
+    end
+    def flush
+      if @current
+        @current.flush
+        @current = nil
+      end
+    end
+  end
+  # Builder implementation without formating (one line)
+  class Standard < Abstract
+    (DOUBLE_TAGS - ['html']).each do |tag|
+      define_class tag.camelize , :AbstractDoubleTag do
+        set_tag tag
+        self.attributes = EXTRA_ATTRIBUTES[tag]
+      end
+      define_tag(tag)
+    end
+    define_class :Html, :AbstractDoubleTag do
+      set_tag 'html'
+      self.attributes = ['xmlns'] + EXTRA_ATTRIBUTES['html']
+      def default
+        xmlns('http://www.w3.org/1999/xhtml')
+      end
+    end
+    define_tag('html')
+    def js(js , options = {})
+      script({:type => "text/javascript"}.merge(options)) { cdata js }
+    end
+    EMPTY_TAGS.each do |tag|
+      define_class tag.camelize, :AbstractEmptyTag do
+        set_tag tag
+        self.attributes = EXTRA_ATTRIBUTES[tag]
+      end
+      define_tag(tag)
+    end
+  end
+  # Builder implementation with formating (indented by '  ')
+  # Slow down is less then 1%
+  class Formated < Standard
+    extend_class :AbstractTag do
+      def open(attributes = nil)
+        @output << NEWLINE << SPACES.fetch(@stack.size, SPACE) << LT << @tag
+        @builder.current = self
+        attributes(attributes)
+        default
+        self
+      end
+    end
+    extend_class :AbstractDoubleTag do
+      def with
+        flush_classes
+        @output << GT
+        @content = nil
+        @builder.current = nil
+        yield
+        #        if (content = yield).is_a?(String)
+        #          @output << CGI.escapeHTML(content)
+        #        end
+        @builder.flush
+        @output << NEWLINE << SPACES.fetch(@stack.size-1, SPACE) << SLASH_LT << @stack.pop << GT
+        nil
+      end
+    end
+    def comment(comment)
+      @output << NEWLINE << SPACES.fetch(@stack.size, SPACE) << COMMENT_START << comment.to_s << COMMENT_END
+    end
+  end
+end

data/spec/hammer_builder_spec.rb ADDED Viewed

@@ -0,0 +1,185 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+describe HammerBuilder do
+  def super_subject
+    self.class.ancestors[1].allocate.subject
+  end
+  describe 'object with HammerBuilder::Helper' do
+    class AObject
+      include HammerBuilder::Helper
+      builder :render do |obj|
+        @obj = obj
+        div 'a'
+      end
+    end
+    subject { AObject.new }
+    describe 'methods' do
+      subject { super_subject.class.instance_methods }
+      it { should include(:render) }
+    end
+    describe '#render(builder)' do
+      subject { super_subject.render(HammerBuilder::Standard.get).to_xhtml! }
+      it { should == "<div>a</div>"}
+    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::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) }
+      end
+      describe '#release!' do
+        before do
+          (@builder = HammerBuilder::Standard.get).release!
+        end
+        it 'should be same object' do
+          @builder.should == HammerBuilder::Standard.get
+        end
+      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) }
+      end
+    end
+    describe 'available methods' do
+      subject { HammerBuilder::Standard.instance_methods }
+      (HammerBuilder::DOUBLE_TAGS + HammerBuilder::EMPTY_TAGS).each do |tag|
+        it "should have method #{tag}" do
+          should include(tag.to_sym)
+        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
+        end
+      end
+    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 { 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
+        end
+      end
+      describe '2' do
+        subject do
+          HammerBuilder::Formated.get.go_in do
+            html do
+              body do
+                comment CONTENT
+                cdata CONTENT
+              end
+            end
+          end.to_xhtml!.strip
+        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
+    end
+  end
+end

data/spec/spec_helper.rb ADDED Viewed

@@ -0,0 +1,5 @@
+require "#{File.dirname(__FILE__)}/../lib/hammer_builder"
+#RSpec.configure do |config|
+#  config.mock_with :rspec
+#end

metadata ADDED Viewed

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: hammer_builder
+version: !ruby/object:Gem::Version
+  prerelease: false
+  segments:
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors:
+- Petr Chalupa
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2011-05-11 00:00:00 +02:00
+default_executable:
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        segments:
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        segments:
+        - 2
+        - 5
+        - 0
+        version: 2.5.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency
+  name: yard
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        segments:
+        - 0
+        - 6
+        version: "0.6"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency
+  name: bluecloth
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        segments:
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        segments:
+        - 1
+        - 6
+        version: "1.6"
+  type: :development
+  version_requirements: *id005
+description: |-
+  is a xhtml5 builder written in Ruby. It does not introduce anything special, you just
+  use Ruby to get your xhtml. HammerBuilder has been written with three objectives: Speed, Rich API, Extensibility
+email: email@pitr.ch
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- lib/hammer_builder.rb
+- LICENSE
+- README.md
+- spec/hammer_builder_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/ruby-hammer/hammer-builder
+licenses:
+- MIT
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      version: "0"
+requirements:
+- Ruby 1.9.2
+rubyforge_project:
+rubygems_version: 1.3.7
+signing_key:
+specification_version: 3
+summary: fast ruby xhtml5 builder
+test_files:
+- spec/hammer_builder_spec.rb
+- spec/spec_helper.rb