hammer_builder 0.1.2 → 0.2.0

data/lib/hammer_builder/dynamic_classes.rb

@@ -1,16 +1,18 @@
 require 'active_support/core_ext/object/try'
 
-# When extended into a class it enables easy defining and extending classes in extended class.
-# 
+module HammerBuilder
+
+# When extended into a class it enables easy defining and extending classes in the class.
+#
 #   class A
 #     extend DynamicClasses
-#     dc do
-#       define :A do
+#     dynamic_classes do
+#       def_class :A do
 #         def to_s
 #           'a'
 #         end
 #       end
-#       define :B, :A do
+#       def_class :B, :A do
 #         class_eval <<-RUBYCODE, __FILE__, __LINE__+1
 #           def to_s
 #             super + 'b'
@@ -24,8 +26,8 @@ require 'active_support/core_ext/object/try'
 #   end
 #
 #   class C < A
-#     dc do
-#       extend :A do
+#     dynamic_classes do
+#       extend_class :A do
 #         def to_s
 #           'aa'
 #         end
@@ -41,165 +43,169 @@ require 'active_support/core_ext/object/try'
 #
 # Last example is the most interesting. It prints 'aab' not 'ab' because of the extension in class C. Class :B has
 # as ancestor extended class :A from C therefore the two 'a'.
-module DynamicClasses
+  module DynamicClasses
 
-  # Adds ability to describe itself when class is defined without constant
-  module Describable
-    def self.included(base)
-      base.singleton_class.send :alias_method, :original_to_s, :to_s
-      base.extend ClassMethods
-    end
+    # Adds ability to describe itself when class is defined without constant
+    module Describable
+      def self.included(base)
+        base.singleton_class.send :alias_method, :original_to_s, :to_s
+        base.extend ClassMethods
+      end
 
-    module ClassMethods
-      # sets +description+
-      # @param [String] description
-      def _description=(description)
-        @_description = description
+      module ClassMethods
+        # sets +description+
+        # @param [String] description
+        def _description=(description)
+          @_description = description
+        end
+
+        def to_s
+          super.gsub(/>$/, "(#{@_description})>")
+        end
       end
 
       def to_s
-        super.gsub(/>$/, "(#{@_description})>")
+        klass = respond_to?(:rclass) ? self.rclass : self.class
+        super.gsub(klass.original_to_s, klass.to_s)
       end
     end
 
-    def to_s
-      klass = respond_to?(:rclass) ? self.rclass : self.class
-      super.gsub(klass.original_to_s, klass.to_s)
+    class DescribableClass
+      include Describable
     end
-  end
-
-  class DescribableClass
-    include Describable
-  end
 
-  ClassDefinition = Struct.new(:name, :base, :superclass_or_name, :definition)
-  ClassExtension = Struct.new(:name, :base, :definition)
+    ClassDefinition = Struct.new(:name, :base, :superclass_or_name, :definition)
+    ClassExtension  = Struct.new(:name, :base, :definition)
 
-  class Classes
-    attr_reader :base, :class_definitions, :classes, :class_extensions
+    class Classes
+      attr_reader :base, :class_definitions, :classes, :class_extensions
 
-    def initialize(base)
-      raise unless base.is_a? Class
-      @base = base
-      @class_definitions = {}
-      @class_extensions = {}
-      @classes = {}
-    end
+      def initialize(base)
+        raise unless base.is_a? Class
+        @base              = base
+        @class_definitions = { }
+        @class_extensions  = { }
+        @classes           = { }
+      end
 
-    # define a class
-    # @param [Symbol] name
-    # @param [Symbol, Class, nil] superclass_or_name
-    # when Symbol then dynamic class is found
-    # when Class then this class is used
-    # when nil then Object is used
-    # @yield definition block is evaluated inside the class defining it
-    def define(name, superclass_or_name = nil, &definition)
-      raise ArgumentError, "name is not a Symbol" unless name.is_a?(Symbol)
-      unless superclass_or_name.is_a?(Symbol) || superclass_or_name.is_a?(Class) || superclass_or_name.nil?
-        raise ArgumentError, "superclass_or_name is not a Symbol, Class or nil"
+      # define a class
+      # @param [Symbol] name
+      # @param [Symbol, Class, nil] superclass_or_name
+      # when Symbol then dynamic class is found
+      # when Class then this class is used
+      # when nil then Object is used
+      # @yield definition block is evaluated inside the class defining it
+      def def_class(name, superclass_or_name = nil, &definition)
+        raise ArgumentError, "name is not a Symbol" unless name.is_a?(Symbol)
+        unless superclass_or_name.is_a?(Symbol) || superclass_or_name.is_a?(Class) || superclass_or_name.nil?
+          raise ArgumentError, "superclass_or_name is not a Symbol, Class or nil"
+        end
+        raise ArgumentError, "definition is nil" unless definition
+        raise ArgumentError, "Class #{name} already defined" if class_definition(name)
+        @class_definitions[name] = ClassDefinition.new(name, base, superclass_or_name, definition)
       end
-      raise ArgumentError, "definition is nil" unless definition
-      raise ArgumentError, "Class #{name} already defined" if class_definition(name)
-      @class_definitions[name] = ClassDefinition.new(name, base, superclass_or_name, definition)
-    end
 
-    # extends already defined class by adding a child,
-    # @param [Symbol] name
-    # @yield definition block is evaluated inside the class extending it
-    def extend(name, &definition)
-      raise ArgumentError, "name is not a Symbol" unless name.is_a?(Symbol)
-      raise ArgumentError, "definition is nil" unless definition
-      raise ArgumentError, "Class #{name} not defined" unless class_definition(name)
-      @class_extensions[name] = ClassExtension.new(name, base, definition)
-    end
+      # extends already defined class by adding a child,
+      # @param [Symbol] name
+      # @yield definition block is evaluated inside the class extending it
+      def extend_class(name, &definition)
+        raise ArgumentError, "name is not a Symbol" unless name.is_a?(Symbol)
+        raise ArgumentError, "definition is nil" unless definition
+        raise ArgumentError, "Class #{name} not defined" unless class_definition(name)
+        @class_extensions[name] = ClassExtension.new(name, base, definition)
+      end
 
-    # triggers loading of all defined classes
-    def load!
-      class_names.each {|name| self[name] }
-    end
+      # triggers loading of all defined classes
+      def load!
+        class_names.each { |name| self[name] }
+      end
 
-    # @return [Class] defined class
-    def [](name)
-      return @classes[name] if @classes[name]
-      return nil unless klass_definition = class_definition(name)
-
-      superclass = case klass_definition.superclass_or_name
-      when Symbol then self[klass_definition.superclass_or_name]
-      when Class then
-        klass = Class.new(klass_definition.superclass_or_name)
-        klass.send :include, Describable
-        klass._description = "Describable#{klass_definition.superclass_or_name}"
-        klass
-      when nil then DescribableClass
+      # @return [Class] defined class
+      def [](name)
+        return @classes[name] if @classes[name]
+        return nil unless klass_definition = class_definition(name)
+
+        superclass = case klass_definition.superclass_or_name
+                       when Symbol then
+                         self[klass_definition.superclass_or_name]
+                       when Class then
+                         klass = Class.new(klass_definition.superclass_or_name)
+                         klass.send :include, Describable
+                         klass._description = "Describable#{klass_definition.superclass_or_name}"
+                         klass
+                       when nil then
+                         DescribableClass
+                     end
+
+        klass              = Class.new(superclass, &klass_definition.definition)
+        klass._description = "#{base}.dc[:#{klass_definition.name}]"
+
+        class_extensions(name).each do |klass_extension|
+          klass              = Class.new(klass, &klass_extension.definition)
+          klass._description = "#{base}.dc[:#{klass_extension.name}]"
+        end
+
+        @classes[name] = klass
       end
-      klass = Class.new(superclass, &klass_definition.definition)
-      klass._description = "#{base}.dc[:#{klass_definition.name}]"
 
-      class_extensions(name).each do |klass_extension|
-        klass = Class.new(klass, &klass_extension.definition)
-        klass._description = "#{base}.dc[:#{klass_extension.name}]"
+      def class_names
+        ancestors.map(&:class_definitions).map(&:keys).flatten
       end
 
-      @classes[name] = klass
-    end
+      private
 
-    private
+      def class_definition(name)
+        @class_definitions[name] || ancestor.try(:class_definition, name)
+      end
 
-    def class_names
-      ancestors.map(&:class_definitions).map(&:keys).flatten
-    end
+      def class_extensions(name)
+        ([*ancestor.try(:class_extensions, name)] + [@class_extensions[name]]).compact
+      end
 
-    def class_definition(name)
-      @class_definitions[name] || ancestor.try(:class_definition, name)
+      def ancestors
+        ([self] + [*ancestor.try(:ancestors)]).compact
+      end
+
+      def ancestor
+        @base.superclass.dynamic_classes if @base.superclass.kind_of?(DynamicClasses)
+      end
     end
 
-    def class_extensions(name)
-      ( [*ancestor.try(:class_extensions, name)] + [@class_extensions[name]] ).compact
+    # hook to create Classes instance
+    def self.extended(base)
+      base.send :create_dynamic_classes
+      super
     end
 
-    def ancestors
-      ( [self] + [*ancestor.try(:ancestors)] ).compact
+    # hook to create Classes instance in descendants
+    def inherited(base)
+      base.send :create_dynamic_classes
+      super
     end
 
-    def ancestor
-      @base.superclass.dynamic_classes if @base.superclass.kind_of?(DynamicClasses)
+    # call this to get access to Classes instance to define/extend classes inside +definition+
+    # calls Classes#load! to preload defined classes
+    # @yield [Proc, nil] definition
+    # a Proc enables writing class definitions/extensions
+    # @return [Classes] when definition is nil
+    def dynamic_classes(&definition)
+      if definition
+        @dynamic_classes.instance_eval &definition
+        # @dynamic_classes.load!
+        nil
+      else
+        @dynamic_classes
+      end
     end
-  end
 
-  # hook to create Classes instance
-  def self.extended(base)
-    base.send :create_dynamic_classes
-    super
-  end
+    alias_method :dc, :dynamic_classes
 
-  # hook to create Classes instance in descendants
-  def inherited(base)
-    base.send :create_dynamic_classes
-    super
-  end
+    private
 
-  # call this to get access to Classes instance to define/extend classes inside +definition+
-  # calls Classes#load! to preload defined classes
-  # @yield [Proc, nil] definition
-  # a Proc enables writing class definitions/extensions
-  # @return [Classes] when definition is nil
-  def dynamic_classes(&definition)
-    if definition
-      @dynamic_classes.instance_eval &definition
-      @dynamic_classes.load!
-      nil
-    else
-      @dynamic_classes
+    def create_dynamic_classes
+      @dynamic_classes = Classes.new(self)
     end
   end
-  
-  alias :dc :dynamic_classes
-
-  private
-
-  def create_dynamic_classes
-    @dynamic_classes = Classes.new(self)
-  end
 end
 
 

data/lib/hammer_builder/formatted.rb

@@ -0,0 +1,43 @@
+require 'hammer_builder/standard'
+
+module HammerBuilder
+  # Builder implementation with formatting (indented by '  ')
+  # Slow down is less then 1%
+  class Formatted < Standard
+
+    dynamic_classes do
+      extend_class :AbstractTag do
+        def open(attributes = nil)
+          @output << Strings::NEWLINE << Strings::SPACES.fetch(@stack.size, Strings::SPACE) << Strings::LT << @tag_name
+          @builder.current = self
+          attributes(attributes)
+          default
+          self
+        end
+      end
+
+      extend_class :AbstractDoubleTag do
+        def with
+          flush_classes
+          @output << Strings::GT
+          @content         = nil
+          @builder.current = nil
+          yield
+          #if (content = yield).is_a?(String)
+          #  @output << EscapeUtils.escape_html(content, false)
+          #end
+          @builder.flush
+          @output << Strings::NEWLINE << Strings::SPACES.fetch(@stack.size-1, Strings::SPACE) << Strings::SLASH_LT <<
+              @stack.pop << Strings::GT
+          nil
+        end
+      end
+    end
+
+    def comment(comment)
+      flush
+      @_output << Strings::NEWLINE << Strings::SPACES.fetch(@_stack.size, Strings::SPACE) << Strings::COMMENT_START <<
+          comment.to_s << Strings::COMMENT_END
+    end
+  end
+end

data/lib/hammer_builder/helper.rb

@@ -0,0 +1,24 @@
+module HammerBuilder
+  module Helper
+
+    # 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_html! #=> "<li>Name</li>"
+    def builder(method_name, &builder_block)
+      define_method(method_name) do |builder, *args|
+        builder.dive(self, *args, &builder_block)
+      end
+    end
+  end
+end

data/lib/hammer_builder/pool.rb

@@ -0,0 +1,72 @@
+module HammerBuilder
+
+  # Creating builder instances is expensive, therefore you can use Pool to go around that
+  # @example
+  #   pool = Pool.new Formatted
+  #   pool.get.go_in do
+  #     # some rendering
+  #   end.to_xhtml! # => output and releases the builder to pool
+  class Pool
+
+    module Helper
+      def release
+        @_origin.release self
+      end
+
+      # @return [String] output and releases the builder to pool
+      def to_html!
+        to_html
+      ensure
+        release
+      end
+    end
+
+    attr_reader :klass
+
+    def initialize(klass)
+      @klass = klass
+      @pool  = []
+      klass.send :include, Helper
+    end
+
+    # 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 [Abstract]
+    def get
+      if @pool.empty?
+        @klass.new.instance_exec(self) { |origin| @_origin = origin; self }
+      else
+        @pool.pop
+      end
+    end
+
+    # returns +builder+ back into pool *DONT* forget to lose the reference to the +builder+
+    # @param [Abstract]
+    def release(builder)
+      raise TypeError unless builder.is_a? @klass
+      builder.reset
+      @pool.push builder
+      nil
+    end
+
+    def size
+      @pool.size
+    end
+  end
+
+  class SynchronizedPool < Pool
+    def initialize(klass)
+      super(klass)
+      @mutex = Mutex.new
+    end
+
+    def get
+      @mutex.synchronize { super }
+    end
+
+    def release(builder)
+      @mutex.synchronize { super(builder) }
+    end
+
+  end
+end