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

hammer_builder 0.1.2 → 0.2.0

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