RubyGems - hammer_builder - Versions diffs - 0.1.2 → 0.2.0 - Mend

hammer_builder 0.1.2 → 0.2.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 (20) hide show

data/CHANGELOG.md +4 -0
data/README.md +24 -41
data/lib/hammer_builder.rb +3 -699
data/lib/hammer_builder/abstract.rb +205 -0
data/lib/hammer_builder/abstract/abstract_double_tag.rb +148 -0
data/lib/hammer_builder/abstract/abstract_single_tag.rb +18 -0
data/lib/hammer_builder/abstract/abstract_tag.rb +233 -0
data/lib/hammer_builder/data.rb +11 -0
data/lib/hammer_builder/data/html5.rb +179 -0
data/lib/hammer_builder/doc.rb +385 -0
data/lib/hammer_builder/dynamic_classes.rb +136 -130
data/lib/hammer_builder/formatted.rb +43 -0
data/lib/hammer_builder/helper.rb +24 -0
data/lib/hammer_builder/pool.rb +72 -0
data/lib/hammer_builder/rails.rb +40 -0
data/lib/hammer_builder/standard.rb +48 -0
data/lib/hammer_builder/strings.rb +29 -0
data/spec/hammer_builder_spec.rb +239 -146
data/spec/spec_helper.rb +3 -1
metadata +264 -96

data/lib/hammer_builder/abstract.rb ADDED Viewed

@@ -0,0 +1,205 @@
+require 'cgi'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/string/inflections'
+require 'hammer_builder/dynamic_classes'
+require 'hammer_builder/strings'
+require 'hammer_builder/data'
+require 'hammer_builder/data/html5'
+require "hammer_builder/pool"
+require "hammer_builder/helper"
+module HammerBuilder
+# Abstract implementation of Builder
+  class Abstract
+    extend DynamicClasses
+    require "hammer_builder/abstract/abstract_tag"
+    require "hammer_builder/abstract/abstract_single_tag"
+    require "hammer_builder/abstract/abstract_double_tag"
+    # << 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
+    class_attribute :tags, :instance_writer => false
+    self.tags = []
+    protected
+    # defines instance method for +tag+ in builder
+    def self.define_tag(tag)
+      tag = tag.to_s
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{tag}(*args, &block)
+          flush
+          @_#{tag}.open(*args, &block)
+        end
+      RUBY
+      self.tags += [tag]
+    end
+    public
+    # current tag being builded
+    attr_accessor :_current
+    alias_method :current, :_current
+    alias_method :current=, :_current=
+    # creates a new builder
+    # This is quite expensive, HammerBuilder::Pool should be used
+    def initialize()
+      @_output  = ""
+      @_stack   = []
+      @_current = nil
+      # tag classes initialization
+      tags.each do |klass|
+        instance_variable_set(:"@_#{klass}", self.class.dynamic_classes[klass.camelize.to_sym].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 << Strings::COMMENT_START << comment.to_s << Strings::COMMENT_END
+    end
+    # insersts CDATA with +content+
+    def cdata(content)
+      flush
+      @_output << Strings::CDATA_START << content.to_s << Strings::CDATA_END
+    end
+    # renders html5 doc type
+    # @example
+    #   html5 # => <!DOCTYPE html>
+    def html5
+      raw "<!DOCTYPE html>\n"
+    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
+    #def capture
+    #  flush
+    #  _output = @_output.clone
+    #  _stack  = @_stack.clone
+    #  @_output.clear
+    #  @_stack.clear
+    #  yield
+    #  to_html
+    #ensure
+    #  @_output.replace _output
+    #  @_stack.replace _stack
+    #end
+    # enables you to evaluate +block+ inside the builder with +variables+
+    # @example
+    #  HammerBuilder::Formatted.new.go_in('asd') do |string|
+    #    div string
+    #  end.to_html! #=> "<div>asd</div>"
+    #
+    def go_in(*variables, &block)
+      instance_exec *variables, &block
+      self
+    end
+    alias_method :dive, :go_in
+    # sets instance variables when block is yielded
+    # @param [Hash{String => Object}] instance_variables hash of names and values to set
+    # @yield block when variables are set, variables are cleaned up afterwards
+    def set_variables(instance_variables)
+      instance_variables.each { |name, value| instance_variable_set("@#{name}", value) }
+      yield(self)
+      instance_variables.each { |name, _| remove_instance_variable("@#{name}") }
+      self
+    end
+    # @return [String] output
+    def to_html()
+      flush
+      @_output.clone
+    end
+    # flushes open tag
+    # @api private
+    def flush
+      if @_current
+        @_current.flush
+        @_current = nil
+      end
+    end
+    # renders +object+ with +method+
+    # @param [Object] object an object to render
+    # @param [Symbol] method a method name which is used for rendering
+    # @param args arguments passed to rendering method
+    # @yield block passed to rendering method
+    def render(object, method, *args, &block)
+      object.__send__ method, self, *args, &block
+      self
+    end
+    alias_method :r, :render
+    # renders js
+    # @option options [Boolean] :cdata (false) should cdata be used?
+    # @example
+    #   js 'a_js_function();' #=> <script type="text/javascript">a_js_function();</script>
+    def js(js, options = { })
+      use_cdata = options.delete(:cdata) || false
+      script({ :type => "text/javascript" }.merge(options)) { use_cdata ? cdata(js) : text(js) }
+    end
+    # joins and renders +collection+ with +glue+
+    # @param [Array<Proc, Object>] collection of objects or lambdas
+    # @param [Proc, String] glue can be String which is rendered with #text or block to render
+    # @yield how to render objects from +collection+, Proc in collection does not use this block
+    # @example
+    #   join([1, 1.2], lambda { text ', ' }) {|o| text o }        # => "1, 1.2"
+    #   join([1, 1.2], ', ') {|o| text o }                        # => "1, 1.2"
+    #   join([->{ text 1 }, 1.2], ', ') {|o| text o }             # => "1, 1.2"
+    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
+      collection.each_with_index do |obj, i|
+        glue_block.call() if i > 0
+        obj.is_a?(Proc) ? obj.call : it.call(obj)
+      end
+    end
+  end
+end

data/lib/hammer_builder/abstract/abstract_double_tag.rb ADDED Viewed

@@ -0,0 +1,148 @@
+module HammerBuilder
+  class Abstract
+    dynamic_classes do
+      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
+          # 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
+            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
+          end
+        RUBY
+        # @api private
+        # closes the tag
+        def flush
+          flush_classes
+          @output << Strings::GT
+          @output << CGI.escapeHTML(@content) if @content
+          @output << Strings::SLASH_LT << @stack.pop << Strings::GT
+          @content = nil
+        end
+        # sets content of the double tag
+        # @example
+        #   div 'content' # => <div>content</div>
+        #   div.content 'content' # => <div>content</div>
+        #   div :content => 'content' # => <div>content</div>
+        def content(content)
+          @content = content.to_s
+          self
+        end
+        # renders content of the double tag with block
+        # @yield content of the tag
+        # @example
+        #   div { text 'content' } # => <div>content</div>
+        #   div :id => 'id' do
+        #     text 'content'
+        #   end # => <div id="id">content</div>
+        def with
+          flush_classes
+          @output << Strings::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
+          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 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 attributes(attrs, &block)
+            super(attrs, &nil)
+            return with(&block) if block
+            self
+          end
+        RUBY
+        protected
+        # @api private
+        def self.define_attribute_method(attribute)
+          return if instance_methods(false).include?(attribute.name)
+          name = attribute.name.to_s
+          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
+            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
+            RUBY
+          end
+        end
+      end ###import
+    end
+  end
+end

data/lib/hammer_builder/abstract/abstract_single_tag.rb ADDED Viewed

@@ -0,0 +1,18 @@
+module HammerBuilder
+  class Abstract
+    dynamic_classes do
+      def_class :AbstractSingleTag, :AbstractTag do ###import
+        nil
+        # @api private
+        # closes the tag
+        def flush
+          flush_classes
+          @output << Strings::SLASH_GT
+          nil
+        end
+      end ###import
+    end
+  end
+end

data/lib/hammer_builder/abstract/abstract_tag.rb ADDED Viewed

@@ -0,0 +1,233 @@
+module HammerBuilder
+  class Abstract
+    dynamic_classes do
+      def_class :AbstractTag do ###import
+        class_attribute :_attributes, :instance_writer => false, :instance_reader => false
+        self._attributes = []
+        # @return [Array<String>] array of available attributes for the tag
+        def self.attributes
+          _attributes
+        end
+        # @return [String] tag's name
+        def self.tag_name
+          @tag || superclass.tag_name
+        end
+        protected
+        # sets the tag's name
+        # @api private
+        def self.set_tag(tag)
+          @tag = tag.to_s.freeze
+        end
+        set_tag 'abstract'
+        # defines dynamically methods for attributes
+        # @api private
+        def self.define_attribute_methods
+          attributes.each { |attr| define_attribute_method(attr) }
+        end
+        def self.inherited(base)
+          base.define_attribute_methods
+        end
+        # defines dynamically method for +attribute+
+        # @param [Data::Attribute] attribute
+        # @api private
+        def self.define_attribute_method(attribute)
+          return if instance_methods.include?(attribute.name)
+          name              = attribute.name.to_s
+          content_rendering = attribute_content_rendering(attribute)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}(content#{' = true' if attribute.type == :boolean})
+              #{content_rendering}
+              self
+            end
+          RUBY
+        end
+        # @api private
+        # @param [Data::Attribute] attribute
+        # @returns Ruby code as string
+        def self.attribute_content_rendering(attribute)
+          name = attribute.name.to_s
+          case attribute.type
+            when :string
+              Strings.add "attr_#{name}", " #{name.gsub('_', '-')}=\""
+              "@output << Strings::ATTR_#{name.upcase} << CGI.escapeHTML(content.to_s) << Strings::QUOTE"
+            when :boolean
+              Strings.add "attr_#{name}", " #{name.gsub('_', '-')}=\"#{name}\""
+              "@output << Strings::ATTR_#{name.upcase} if content"
+          end
+        end
+        # adds attribute to class, triggers dynamical creation of needed instance methods etc.
+        # @param [Array<Data::Attribute>] attributes
+        # @api private
+        def self.add_attributes(attributes)
+          attributes = [attributes] unless attributes.is_a? Array
+          raise ArgumentError, attributes.inspect unless attributes.all? { |v| v.is_a? Data::Attribute }
+          self.send :_attributes=, _attributes + attributes
+          define_attribute_methods
+        end
+        public
+        attr_reader :builder
+        # @api private
+        def initialize(builder)
+          @builder  = builder
+          @output   = builder.instance_eval { @_output }
+          @stack    = builder.instance_eval { @_stack }
+          @classes  = []
+          @tag_name = self.rclass.tag_name
+        end
+        # @api private
+        def open(attributes = nil)
+          @output << Strings::LT << @tag_name
+          @builder.current = self
+          attributes(attributes)
+          default
+          self
+        end
+        # it renders attribute using defined attribute method or by rendering attribute directly
+        # @param [String, Symbol] name
+        # @param [#to_s] value
+        def attribute(name, value)
+          return __send__(name, value) if respond_to?(name)
+          @output << Strings::SPACE << name.to_s << Strings::EQL_QUOTE << CGI.escapeHTML(value.to_s) << Strings::QUOTE
+          self
+        end
+        # @example
+        #   div.attributes :id => 'id' # => <div id="id"></div>
+        #   div :id => 'id', :class => %w{left right} # => <div id="id" class="left right"></div>
+        #   img :src => 'path' # => <img src="path"></div>
+        # attribute`s methods are called on background (in this case #id is called)
+        def attributes(attrs)
+          return self unless attrs
+          attrs.each do |attr, value|
+            if value.kind_of?(Array)
+              __send__(attr, *value)
+            else
+              __send__(attr, value)
+            end
+          end
+          self
+        end
+        # original Ruby method for class, class is used for html classes
+        alias_method(:rclass, :class)
+        id_class       = /^([\w]+)(!|)$/
+        data_attribute = /^data_([a-z_]+)$/
+        METHOD_MISSING_REGEXP = /#{data_attribute}|#{id_class}/ unless defined? METHOD_MISSING_REGEXP
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          # 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, :string)
+                self.send method, *args
+              else
+                self.__send__($3 == '!' ? :id : :class, $2)
+              end
+            else
+              super(method, *args, &block)
+            end
+          end
+          #def respond_to?(symbol, include_private = false)
+          #  symbol.to_s =~ METHOD_MISSING_REGEXP || super(symbol, include_private)
+          #end
+        RUBY
+        Strings.add "attr_class", " class=\""
+        # adds classes to the tag by joining +classes+ with ' ' and skipping non-true classes
+        # @param [Array<#to_s>] classes
+        # @example
+        #   class(!visible? && 'hidden', 'left') #=> class="hidden left" or class="left"
+        def class(*classes)
+          @classes.push(*classes.select { |c| c })
+          self
+        end
+        Strings.add "attr_id", " id=\""
+        # adds id to the tag by joining +values+ with '_'
+        # @param [Array<#to_s>] values
+        # @example
+        #   id('user', 12) #=> id="user_15"
+        def id(*values)
+          @output << Strings::ATTR_ID << CGI.escapeHTML(values.select { |v| v }.join(Strings::UNDERSCORE)) <<
+              Strings::QUOTE
+          self
+        end
+        # adds id and class to a tag by an object
+        # @param [Object] obj
+        # To determine the class it looks for .hammer_builder_ref or
+        # it uses class.to_s.underscore.tr('/', '-').
+        # To determine id it looks for #hammer_builder_ref or it takes class and #id or #object_id.
+        # @example
+        #   div[AUser.new].with { text 'a' } # => <div id="a_user_1" class="a_user">a</div>
+        def mimic(obj)
+          klass = if obj.class.respond_to? :hammer_builder_ref
+            obj.class.hammer_builder_ref
+          else
+            ActiveSupport::Inflector.underscore(obj.class.to_s).tr('/', '-')
+          end
+          id = case
+            when obj.respond_to?(:hammer_builder_ref)
+              obj.hammer_builder_ref
+            when obj.respond_to?(:id)
+              [klass, obj.id]
+            else
+              [klass, obj.object_id]
+          end
+          #noinspection RubyArgCount
+          self.class(klass).id(id)
+        end
+        alias_method :[], :mimic
+        # renders data-* attributes by +hash+
+        # @param [Hash] hash
+        # @example
+        #   div.data(:remote => true, :id => 'an_id') # => <div data-remote="true" data-id="an_id"></div>
+        def data(hash)
+          hash.each { |k, v| __send__ "data_#{k}", v }
+          self
+        end
+        protected
+        # 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
+        # flushes classes to output
+        # @api private
+        def flush_classes
+          unless @classes.empty?
+            @output << Strings::ATTR_CLASS << CGI.escapeHTML(@classes.join(Strings::SPACE)) << Strings::QUOTE
+            @classes.clear
+          end
+        end
+      end ###import
+    end
+  end
+end