replace hardcoded Strings with StringsInjector

* move hardcoded Strings in constants into StringsInjector builder have
its own strings collection
* adds ability to override strings collection per builder class

Author: pitr-ch

.rvmrc

@@ -1 +1 @@
-rvm use 1.9.2@hammer-builder --create
+rvm use 1.9.3@hammer-builder --create

lib/hammer_builder/abstract.rb

@@ -3,7 +3,7 @@
 require 'active_support/core_ext/string/inflections'
 
 require 'hammer_builder/dynamic_classes'
-require 'hammer_builder/strings'
+require 'hammer_builder/strings_injector'
 require 'hammer_builder/data'
 require 'hammer_builder/data/html5'
 require "hammer_builder/pool"
@@ -19,6 +19,26 @@ class Abstract
     require "hammer_builder/abstract/abstract_single_tag"
     require "hammer_builder/abstract/abstract_double_tag"
 
+    def self.strings_injector
+      @strings_injector ||= StringsInjector.new do
+        add :lt, '<'
+        add :gt, '>'
+        add :slash_lt, '</'
+        add :slash_gt, ' />'
+        add :underscore, '_'
+        add :space, ' '
+        add :spaces, Array.new(300) { |i| ('  ' * i).freeze }
+        add :newline, "\n"
+        add :quote, '"'
+        add :eql, '='
+        add :eql_quote, self[:eql] + self[:quote]
+        add :comment_start, '<!--'
+        add :comment_end, '-->'
+        add :cdata_start, '<![CDATA['
+        add :cdata_end, ']]>'
+      end
+    end
+
     # << faster then +
     # yield faster then block.call
     # accessing ivar and constant is faster then accesing hash or cvar
@@ -58,6 +78,9 @@ def initialize()
       @_output  = ""
       @_stack   = []
       @_current = nil
+
+      self.class.strings_injector.inject_to self
+
       # tag classes initialization
       tags.each do |klass|
         instance_variable_set(:"@_#{klass}", self.class.dynamic_classes[klass.camelize.to_sym].new(self))
@@ -79,13 +102,13 @@ def raw(text)
     # inserts +comment+
     def comment(comment)
       flush
-      @_output << Strings::COMMENT_START << comment.to_s << Strings::COMMENT_END
+      @_output << @_str_comment_start << comment.to_s << @_str_comment_end
     end
 
     # insersts CDATA with +content+
     def cdata(content)
       flush
-      @_output << Strings::CDATA_START << content.to_s << Strings::CDATA_END
+      @_output << @_str_cdata_start << content.to_s << @_str_cdata_end
     end
 
     # renders html5 doc type
@@ -186,13 +209,13 @@ def js(js, options = { })
     def join(collection, glue = nil, &it)
       # TODO as helper? two block method call #join(collection, &item).with(&glue)
       glue_block = case glue
-        when String
-          lambda { text glue }
-        when Proc
-          glue
-        else
-          lambda { }
-      end
+                     when String
+                       lambda { text glue }
+                     when Proc
+                       glue
+                     else
+                       lambda { }
+                   end
 
       collection.each_with_index do |obj, i|
         glue_block.call() if i > 0

lib/hammer_builder/abstract/abstract_double_tag.rb

@@ -5,55 +5,50 @@ class Abstract
       def_class :AbstractDoubleTag, :AbstractTag do ###import
         nil
 
-        # defined by class_eval because there is a error cased by super
-        # 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 <<-RUBY, __FILE__, __LINE__ + 1
-          # @api private
-          def initialize(builder)
-            super
-            @content = nil
-          end
+        # @api private
+        def initialize(builder)
+          super
+          @content = nil
+        end
 
-          # allows data-* attributes and id, classes by method_missing
-          def method_missing(method, *args, &block)
-            method = method.to_s
-            if method =~ METHOD_MISSING_REGEXP
-              if $1
-                self.rclass.add_attributes Data::Attribute.new(method.to_sym, :string)
-                self.send method, *args, &block
-              else
-                self.content(args[0]) if args[0]
-                self.__send__($3 == '!' ? :id : :class, $2, &block)
-              end
+        # allows data-* attributes and id, classes by method_missing
+        def method_missing(method, *args, &block)
+          method = method.to_s
+          if method =~ METHOD_MISSING_REGEXP
+            if $1
+              self.rclass.add_attributes Data::Attribute.new(method.to_sym, :string)
+              self.send method, *args, &block
             else
-              super(method, *args, &block)
+              self.content(args[0]) if args[0]
+              self.__send__($3 == '!' ? :id : :class, $2, &block)
             end
+          else
+            super(method, *args, &block)
           end
+        end
 
-          # @api private
-          def open(*args, &block)
-            attributes = if args.last.is_a?(Hash)
-              args.pop
-            end
-            content args[0]
-            super attributes
-            @stack << @tag_name
-            if block
-              with &block
-            else
-              self
-            end
+        # @api private
+        def open(*args, &block)
+          attributes = if args.last.is_a?(Hash)
+                         args.pop
+                       end
+          content args[0]
+          super attributes
+          @stack << @tag_name
+          if block
+            with &block
+          else
+            self
           end
-        RUBY
+        end
 
         # @api private
         # closes the tag
         def flush
           flush_classes
-          @output << Strings::GT
+          @output << @_str_gt
           @output << CGI.escapeHTML(@content) if @content
-          @output << Strings::SLASH_LT << @stack.pop << Strings::GT
+          @output << @_str_slash_lt << @stack.pop << @_str_gt
           @content = nil
         end
 
@@ -76,45 +71,43 @@ def content(content)
         #   end # => <div id="id">content</div>
         def with
           flush_classes
-          @output << Strings::GT
+          @output << @_str_gt
           @content         = nil
           @builder.current = nil
           yield
           #if (content = yield).is_a?(String)
           #  @output << EscapeUtils.escape_html(content)
           #end
           @builder.flush
-          @output << Strings::SLASH_LT << @stack.pop << Strings::GT
+          @output << @_str_slash_lt << @stack.pop << @_str_gt
           nil
         end
 
         alias_method :w, :with
 
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def mimic(obj, &block)
-            super(obj, &nil)
-            return with(&block) if block
-            self
-          end
+        def mimic(obj, &block)
+          super(obj, &nil)
+          return with(&block) if block
+          self
+        end
 
-          def data(hash, &block)
-            super(hash, &nil)
-            return with(&block) if block
-            self
-          end
+        def data(hash, &block)
+          super(hash, &nil)
+          return with(&block) if block
+          self
+        end
 
-          def attribute(name, value, &block)
-            super(name, value, &nil)
-            return with(&block) if block
-            self
-          end
+        def attribute(name, value, &block)
+          super(name, value, &nil)
+          return with(&block) if block
+          self
+        end
 
-          def attributes(attrs, &block)
-            super(attrs, &nil)
-            return with(&block) if block
-            self
-          end
-        RUBY
+        def attributes(attrs, &block)
+          super(attrs, &nil)
+          return with(&block) if block
+          self
+        end
 
         protected
 
@@ -125,20 +118,20 @@ def self.define_attribute_method(attribute)
 
           if instance_methods.include?(attribute.name)
             class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{name}(*args, &block)
-            super(*args, &nil)
-            return with(&block) if block
-            self
-          end
+              def #{name}(*args, &block)
+                super(*args, &nil)
+                return with(&block) if block
+                self
+              end
             RUBY
           else
             content_rendering = attribute_content_rendering(attribute)
             class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{name}(content#{' = true' if attribute.type == :boolean}, &block)
-            #{content_rendering}
-            return with(&block) if block
-            self
-          end
+              def #{name}(content#{' = true' if attribute.type == :boolean}, &block)
+                #{content_rendering}
+                return with(&block) if block
+                self
+              end
             RUBY
           end
         end

lib/hammer_builder/abstract/abstract_single_tag.rb

@@ -8,7 +8,7 @@ class Abstract
         # closes the tag
         def flush
           flush_classes
-          @output << Strings::SLASH_GT
+          @output << @_str_slash_gt
           nil
         end
       end ###import