htmless 0.4

data/lib/htmless/dynamic_classes.rb

@@ -0,0 +1,216 @@
+module Htmless
+
+# When extended into a class it enables easy defining and extending classes in the class.
+#
+#   class A
+#     extend DynamicClasses
+#     dynamic_classes do
+#       def_class :A do
+#         def to_s
+#           'a'
+#         end
+#       end
+#       def_class :B, :A do
+#         class_eval <<-RUBYCODE, __FILE__, __LINE__+1
+#           def to_s
+#             super + 'b'
+#           end
+#         RUBYCODE
+#       end
+#     end
+#   end
+#
+#   class B < A
+#   end
+#
+#   class C < A
+#     dynamic_classes do
+#       extend_class :A do
+#         def to_s
+#           'aa'
+#         end
+#       end
+#     end
+#   end
+#
+#   puts A.dc[:A] # => #<Class:0x00000001d449b8(A.dc[:A])>
+#   puts B.dc[:A] # => #<Class:0x00000001d42398(B.dc[:A])>
+#   puts B.dc[:A].new # => a
+#   puts B.dc[:B].new # => ab
+#   puts C.dc[:B].new # => aab
+#
+# 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
+
+    # 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
+        end
+
+        def to_s
+          super.gsub(/>$/, "(#{@_description})>")
+        end
+      end
+
+      def to_s
+        klass = respond_to?(:rclass) ? self.rclass : self.class
+        super.gsub(klass.original_to_s, klass.to_s)
+      end
+    end
+
+    class DescribableClass
+      include Describable
+    end
+
+    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
+
+      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 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
+
+      # 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
+
+      # @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
+
+        set_up_klass = lambda do |klass, description, block|
+          klass._description = description
+          klass.instance_variable_set :@dynamic_class_base, base
+          klass.singleton_class.send :attr_reader, :dynamic_class_base
+          klass.class_eval &block
+        end
+
+        klass = Class.new(superclass)
+        set_up_klass.call klass, "#{base}.dc[:#{klass_definition.name}]", klass_definition.definition
+
+        class_extensions(name).each do |klass_extension|
+          klass = Class.new klass
+          set_up_klass.call klass, "#{base}.dc[:#{klass_extension.name}]", klass_extension.definition
+        end
+
+        @classes[name] = klass
+      end
+
+      def class_names
+        ancestors.map(&:class_definitions).map(&:keys).flatten
+      end
+
+      private
+
+      def class_definition(name)
+        @class_definitions[name] or (ancestor.send :class_definition, name if ancestor)
+      end
+
+      def class_extensions(name)
+        ([*(ancestor.send :class_extensions, name if ancestor)] + [@class_extensions[name]]).compact
+      end
+
+      def ancestors
+        ([self] + [*(ancestor.ancestors if ancestor)]).compact
+      end
+
+      def ancestor
+        @base.superclass.dynamic_classes if @base.superclass.kind_of?(DynamicClasses)
+      end
+    end
+
+    # hook to create Classes instance
+    def self.extended(base)
+      base.send :create_dynamic_classes
+      super
+    end
+
+    # hook to create Classes instance in descendants
+    def inherited(base)
+      base.send :create_dynamic_classes
+      super
+    end
+
+    # 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
+
+    alias_method :dc, :dynamic_classes
+
+    private
+
+    def create_dynamic_classes
+      @dynamic_classes = Classes.new(self)
+    end
+  end
+end
+
+

data/lib/htmless/formatted.rb

@@ -0,0 +1,43 @@
+require 'htmless/standard'
+
+module Htmless
+  # 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 << @_str_newline << @_str_spaces.fetch(@stack.size, @_str_space) << @_str_lt << @tag_name
+          @builder.current = self
+          attributes(attributes)
+          default
+          self
+        end
+      end
+
+      extend_class :AbstractDoubleTag do
+        def with
+          flush_classes
+          @output << @_str_gt
+          @content         = nil
+          @builder.current = nil
+          yield
+          #if (content = yield).is_a?(String)
+          #  @output << EscapeUtils.escape_html(content, false)
+          #end
+          @builder.flush
+          @output << @_str_newline << @_str_spaces.fetch(@stack.size-1, @_str_space) << @_str_slash_lt <<
+              @stack.pop << @_str_gt
+          nil
+        end
+      end
+    end
+
+    def comment(comment)
+      flush
+      @_output << @_str_newline << @_str_spaces.fetch(@_stack.size, @_str_space) << @_str_comment_start <<
+          comment.to_s << @_str_comment_end
+    end
+  end
+end

data/lib/htmless/helper.rb

@@ -0,0 +1,24 @@
+module Htmless
+  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/htmless/pool.rb

@@ -0,0 +1,72 @@
+module Htmless
+
+  # 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

data/lib/htmless/rails.rb

@@ -0,0 +1,40 @@
+require 'htmless/formatted'
+
+warn '"htmless/rails" is very early experiment'
+
+module Htmless::Rails
+  class AbstractBuilder
+    extend Htmless::Helper
+
+    attr_reader :controller
+
+    def initialize(controller)
+      @controller = controller
+    end
+
+  end
+
+  ActionController::Renderers.add :hb do |klass_or_obj, options|
+    obj = case
+      when klass_or_obj.kind_of?(Class)
+        klass_or_obj.new(self)
+      when klass_or_obj.nil? || klass_or_obj == self
+        self.class.to_s.gsub(/Controller/, 'Builder').constantize.new(self)
+      else
+        klass_or_obj
+    end
+
+    $htmless_pool ||= Htmless::SynchronizedPool.new(Htmless::Formatted) # FIXME
+
+    render(
+        :text   => $htmless_pool.get.
+            go_in { render obj, "#{options[:method] || options[:template]}" }.to_html!,
+        :layout => true)
+  end
+
+
+end
+
+
+
+

data/lib/htmless/standard.rb

@@ -0,0 +1,48 @@
+require 'htmless/abstract'
+
+module Htmless
+
+  # Builder implementation without formating (one line output)
+  class Standard < Abstract
+
+    dynamic_classes do
+      extend_class :AbstractTag do
+        # add global HTML5 attributes
+        self.add_attributes Data::HTML5.abstract_attributes
+      end
+
+      Data::HTML5.double_tags.each do |tag|
+        next if tag.name == :html
+
+        def_class Abstract.camelize_string(tag.name.to_s).to_sym, :AbstractDoubleTag do
+          set_tag tag.name
+          self.add_attributes tag.attributes
+        end
+
+        base.define_tag(tag.name)
+      end
+
+      html_tag = Data::HTML5.double_tags.find { |t| t.name == :html }
+      def_class :Html, :AbstractDoubleTag do
+        set_tag html_tag.name
+        self.add_attributes html_tag.attributes
+
+        def default
+          attribute :xmlns ,'http://www.w3.org/1999/xhtml'
+        end
+      end
+      base.define_tag(html_tag.name)
+
+      Data::HTML5.single_tags.each do |tag|
+        def_class Abstract.camelize_string(tag.name.to_s).to_sym, :AbstractSingleTag do
+          set_tag tag.name
+          self.add_attributes tag.attributes
+        end
+
+        base.define_tag(tag.name)
+      end
+    end
+
+  end
+end
+

data/lib/htmless/strings_injector.rb

@@ -0,0 +1,43 @@
+module Htmless
+  class StringsInjector
+
+    attr_reader :strings, :objects_to_update
+
+    def initialize(&block)
+      @strings           = Hash.new {|hash, key| raise ArgumentError "missing key #{key}" }
+      @objects_to_update = []
+      instance_eval &block
+    end
+
+    def [](name)
+      strings[name]
+    end
+
+    def add(name, value)
+      name = name.to_sym
+      raise "string #{name} is already set to #{value}" if strings.has_key?(name) && self[name] != value
+      replace name, value
+    end
+
+    def replace(name, value)
+      name          = name.to_sym
+      strings[name] = value
+      update_objects name
+    end
+
+    def inject_to(obj)
+      @objects_to_update << obj
+      strings.keys.each { |name| update_object obj, name }
+    end
+
+    private
+
+    def update_objects(name)
+      objects_to_update.each { |obj| update_object obj, name }
+    end
+
+    def update_object(obj, name)
+      obj.instance_variable_set(:"@_str_#{name}", self[name])
+    end
+  end
+end

data/lib/htmless.rb

@@ -0,0 +1,3 @@
+require "htmless/formatted"
+
+

data/lib/js.rb

@@ -0,0 +1,176 @@
+path = File.expand_path(File.dirname(__FILE__))
+$: << path unless $:.include? path
+
+require "htmless"
+require 'v8'
+
+#cxt = V8::Context.new
+#p cxt.eval(<<-JS)
+#  var a = a || {};
+#  JSON.stringify(a)
+#JS
+
+# TODO escape " generated by builder
+
+class JSBuilder < Htmless::Standard
+  strings_injector.strings.each do |key, value|
+    if value =~ /"/
+      strings_injector.replace key, value.gsub('"', '\"')
+    end
+  end
+end
+
+POOL = Htmless::Pool.new(JSBuilder)
+
+class Injector # < BasicObject
+  def initialize(name)
+    @name, @methods = name, []
+  end
+
+  def [](key)
+    method_missing(key)
+  end
+
+  def method_missing(name, *args, &block)
+    @methods << name.to_s
+    self
+  end
+
+  def __reset__!
+    @methods.clear
+  end
+
+  def __name__
+    @name
+  end
+
+  def to_s
+    js = "{{#{@name}.#{@methods.join('.')}}}"
+    __reset__!
+    js
+  end
+
+  def to_str
+    to_s
+  end
+end
+
+module ToJs
+  include Htmless::Helper
+
+  def builder(name, &block)
+    JsRenderers.add_renderer self, name, &block
+    super name, &block
+  end
+
+  def as_json
+    { :class => self.class.to_s, :data => json_data }
+  end
+end
+
+class JsRenderersImpl
+  def initialize
+    @render_methods = { }
+    @templates      = { }
+  end
+
+  def add_renderer(klass, name, &block)
+    @render_methods[klass]       ||= { }
+    @render_methods[klass][name] = block
+  end
+
+  def renderer(klass, name)
+    @render_methods[klass][name]
+  end
+
+  def to_js
+    @render_methods.each do |klass, names|
+      @templates[klass] ||= { }
+      names.each do |name, block|
+        @templates[klass][name] = JsMethodBuilder.new(klass, name, block).build
+      end
+    end
+    @templates
+  end
+end
+
+class JsMethodBuilder
+  attr_reader :klass, :name, :block, :builder
+
+  def initialize(klass, name, block)
+    @klass, @name, @block = klass, name, block
+    @builder              = POOL.get
+    @injectors            = Array.new(block.arity) { |i| Injector.new("arg#{i}") }
+  end
+
+  def build
+    builder.raw head
+    builder.dive(*@injectors, &block)
+    builder.raw foot
+    builder.to_html!.gsub(/\{\{([^}]*)\}\}/, '"+\1+"')
+  ensure
+    @builder = nil
+  end
+
+  def head
+    <<-JS.chomp
+var templates = templates || {};
+templates["#{klass}"] = templates["#{klass}"] || {};
+templates["#{klass}"].#{name} = function (#{@injectors.map(&:__name__).join(', ')}) {
+  var _buf;
+  _buf = "
+    JS
+  end
+
+  def foot
+    %(";\n  return _buf;\n};\n)
+  end
+end
+
+JsRenderers = JsRenderersImpl.new
+
+A = Module.new
+class A::Record
+  extend ToJs
+
+  def name
+    'a_record'
+  end
+
+  def klass
+    'class'
+  end
+
+  def items
+    [{ :name => 'a' }, { :name => 'b' }]
+  end
+
+  def json_data
+    { :name  => name,
+      :klass => klass,
+      :items => items
+    }
+  end
+
+  builder :content do |r|
+    p :class => r.klass do
+      text r.name
+      #ul do
+      #  r.items.each do |item|
+      #    r.item self, item
+      #  end
+      #end
+    end
+  end
+
+  builder :item do |_, item|
+    li item[:name]
+  end
+end
+
+record = A::Record.new
+
+#puts POOL.get.render(record, :content).to_html!
+
+puts JsRenderers.to_js[A::Record][:content]
+puts JsRenderers.to_js[A::Record][:item]