undies 1.2.0 → 2.0.0

data/.gitignore

@@ -3,3 +3,5 @@ pkg/*
 *.gem
 *.log
 .rvmrc
+
+bench/*.txt

data/Gemfile

@@ -3,4 +3,5 @@ source "http://rubygems.org"
 # Specify dependencies in undies.gemspec
 gemspec
 
-gem 'rake', '~>0.9.2'
+gem 'rake', '~>0.9.2'
+gem 'ruby-prof'

data/Gemfile.lock

@@ -1,21 +1,26 @@
 PATH
   remote: .
   specs:
-    undies (1.2.0)
+    undies (2.0.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    leftright (0.9.1)
+    ansi (1.4.1)
+    assert (0.7.3)
+      assert-view (~> 0.5)
+    assert-view (0.5.0)
+      ansi (~> 1.3)
+      undies (~> 2.0)
     rake (0.9.2)
-    test-belt (2.0.0)
-      leftright (~> 0.9.0)
+    ruby-prof (0.10.8)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  assert (~> 0.7.3)
   bundler (~> 1.0)
   rake (~> 0.9.2)
-  test-belt (~> 2.0)
+  ruby-prof
   undies!

data/Rakefile

@@ -1,9 +1,7 @@
-include Rake::DSL
+require 'assert/rake_tasks'
+Assert::RakeTasks.for(:test)
 
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
-require 'test_belt/rake_tasks'
-TestBelt::RakeTasks.for :test
-
 task :default => :build

data/bench/large.html.rb

@@ -0,0 +1,32 @@
+_html {
+  _head {}
+  _body {
+
+    10.times do
+      _ "Yo"
+      _ "Yo"
+      _ "Yo"
+      _ "Yo"
+      _ "Yo"
+
+      __ "YoYo"
+      __ "YoYo"
+      __ "YoYo"
+      __ "YoYo"
+      __ "YoYo"
+
+      _br
+      _br
+      _br
+      _br
+      _br
+
+      _div { _ "Hi" }
+      _div { _ "Hi" }
+      _div { _ "Hi" }
+      _div { _ "Hi" }
+      _div { _ "Hi" }
+    end
+
+  }
+}

data/bench/procs.rb

@@ -0,0 +1,106 @@
+@small_proc = Proc.new do
+  _html {
+    _head {}
+    _body {
+
+      1.times do
+        _ "Yo"
+        _ "Yo"
+        _ "Yo"
+        _ "Yo"
+        _ "Yo"
+
+        __ "YoYo"
+        __ "YoYo"
+        __ "YoYo"
+        __ "YoYo"
+        __ "YoYo"
+
+        _br
+        _br
+        _br
+        _br
+        _br
+
+        _div { _ "Hi" }
+        _div { _ "Hi" }
+        _div { _ "Hi" }
+        _div { _ "Hi" }
+        _div { _ "Hi" }
+      end
+
+    }
+  }
+end
+
+
+@large_proc = Proc.new do
+  _html {
+    _head {}
+    _body {
+
+      10.times do
+        _ "Yo"
+        _ "Yo"
+        _ "Yo"
+        _ "Yo"
+        _ "Yo"
+
+        __ "YoYo"
+        __ "YoYo"
+        __ "YoYo"
+        __ "YoYo"
+        __ "YoYo"
+
+        _br
+        _br
+        _br
+        _br
+        _br
+
+        _div { _ "Hi" }
+        _div { _ "Hi" }
+        _div { _ "Hi" }
+        _div { _ "Hi" }
+        _div { _ "Hi" }
+      end
+
+    }
+  }
+end
+
+
+@verylarge_proc = Proc.new do
+  _html {
+    _head {}
+    _body {
+
+      1000.times do
+        _ "Yo"
+        _ "Yo"
+        _ "Yo"
+        _ "Yo"
+        _ "Yo"
+
+        __ "YoYo"
+        __ "YoYo"
+        __ "YoYo"
+        __ "YoYo"
+        __ "YoYo"
+
+        _br
+        _br
+        _br
+        _br
+        _br
+
+        _div { _ "Hi" }
+        _div { _ "Hi" }
+        _div { _ "Hi" }
+        _div { _ "Hi" }
+        _div { _ "Hi" }
+      end
+
+    }
+  }
+end

data/bench/profiler.rb

@@ -0,0 +1,25 @@
+require 'ruby-prof'
+require 'undies'
+require 'bench/procs'
+
+file = "bench/#{ARGV[0] || 'large'}.html.rb"
+proc = eval("@#{ARGV[0] || 'large'}_proc")
+result = nil
+
+File.open('bench/output.txt', 'a+') do |outstream|
+
+  output = Undies::Output.new(outstream, :pp => 2)
+
+  result = RubyProf.profile do
+    50.times do
+      Undies::Template.new(Undies::Source.new(File.expand_path(file)), {}, output)
+    end
+    50.times do
+      Undies::Template.new(Undies::Source.new(proc), {}, output)
+    end
+  end
+
+end
+
+printer = RubyProf::FlatPrinter.new(result).print(STDOUT, :min_percent => 1)
+# printer = RubyProf::GraphPrinter.new(result).print(STDOUT)

data/bench/small.html.rb

@@ -0,0 +1,32 @@
+_html {
+  _head {}
+  _body {
+
+    1.times do
+      _ "Yo"
+      _ "Yo"
+      _ "Yo"
+      _ "Yo"
+      _ "Yo"
+
+      __ "YoYo"
+      __ "YoYo"
+      __ "YoYo"
+      __ "YoYo"
+      __ "YoYo"
+
+      _br
+      _br
+      _br
+      _br
+      _br
+
+      _div { _ "Hi" }
+      _div { _ "Hi" }
+      _div { _ "Hi" }
+      _div { _ "Hi" }
+      _div { _ "Hi" }
+    end
+
+  }
+}

data/bench/verylarge.html.rb

@@ -0,0 +1,32 @@
+_html {
+  _head {}
+  _body {
+
+    1000.times do
+      _ "Yo"
+      _ "Yo"
+      _ "Yo"
+      _ "Yo"
+      _ "Yo"
+
+      __ "YoYo"
+      __ "YoYo"
+      __ "YoYo"
+      __ "YoYo"
+      __ "YoYo"
+
+      _br
+      _br
+      _br
+      _br
+      _br
+
+      _div { _ "Hi" }
+      _div { _ "Hi" }
+      _div { _ "Hi" }
+      _div { _ "Hi" }
+      _div { _ "Hi" }
+    end
+
+  }
+}

data/lib/undies/element.rb

@@ -1,34 +1,53 @@
 require 'undies/node'
-require 'undies/node_list'
-require 'undies/element_stack'
 
 module Undies
   class Element < Node
 
-    attr_reader :___name, :___attrs
-    attr_accessor :___nodes
+    # have as many methods to the class level as possilbe to keep from
+    # polluting the public instance methods and to maximize the effectiveness
+    # of the Element#method_missing logic
+
+    def self.html_attrs(attrs="", ns=nil)
+      if attrs.kind_of? ::Hash
+        attrs.empty? ? '' : (attrs.keys.map(&:to_s).sort.map(&:to_sym).inject('') do |html, key|
+          ak = ns ? "#{ns}_#{key}" : key.to_s
+          av = attrs[key]
+          html + (av.kind_of?(::Hash) ? html_attrs(av, ak) : " #{ak}=\"#{av}\"")
+        end)
+      else
+        attrs.to_s
+      end
+    end
 
-    def initialize(stack, name, attrs={}, &block)
-      if !stack.kind_of?(ElementStack)
-        raise ArgumentError, "stack must be an Undies::ElementStack"
+    def self.content(element)
+      nil
+    end
+
+    def self.flush(output, element)
+      output.pp_use_indent = true
+      output << element.instance_variable_get("@start_tag")
+      if (cbs = element.instance_variable_get("@content_blocks")).size > 0
+        output.pp_level += 1
+        output.pp_use_indent = false
+        cbs.each{ |content| content.call }
+        output.flush
+        output.pp_level -= 1
       end
+      output << element.instance_variable_get("@end_tag") if element.instance_variable_get("@end_tag")
+      output.pp_use_indent = true
+    end
+
+    def initialize(name, attrs={}, &block)
       if !attrs.kind_of?(::Hash)
         raise ArgumentError, "#{name.inspect} attrs must be provided as a Hash."
       end
-      super(@___nodes = NodeList.new)
-      @stack = stack
-      @content_writes = 0
-      @___name = name.to_s
-      @___attrs = attrs
-      self.___content = block
-    end
-
-    def start_tag
-      "<#{@___name}#{html_attrs(@___attrs)}" + (@content_writes > 0 ? ">" : " />")
-    end
 
-    def end_tag
-      @content_writes > 0 ? "</#{@___name}>" : nil
+      @name  = name.to_s
+      @attrs = attrs
+      @content_blocks = []
+      @content_blocks << block if block
+      @start_tag = start_tag
+      @end_tag = end_tag
     end
 
     # CSS proxy methods ============================================
@@ -37,9 +56,13 @@ module Undies
 
     def method_missing(meth, *args, &block)
       if meth.to_s =~ ID_METH_REGEX
-        proxy_id_attr($1, *args, &block)
+        proxy($1, args.first || {}, block) do |value|
+          @attrs.merge!(:id => value)
+        end
       elsif meth.to_s =~ CLASS_METH_REGEX
-        proxy_class_attr($1, *args, &block)
+        proxy($1, args.first || {}, block) do |value|
+          @attrs[:class] = [@attrs[:class], value].compact.join(' ')
+        end
       else
         super
       end
@@ -55,59 +78,36 @@ module Undies
     # ==============================================================
 
     def ==(other)
-      other.___name  == self.___name  &&
-      other.___attrs == self.___attrs &&
-      other.___nodes == self.___nodes
+      other.instance_variable_get("@name")  == @name  &&
+      other.instance_variable_get("@attrs") == @attrs &&
+      other.instance_variable_get("@nodes") == @nodes
     end
 
+    # overriding this because the base Node class defines a 'to_s' method that
+    # needs to be honored
     def to_str(*args)
       "Undies::Element:#{self.object_id} " +
-      "@name=#{self.___name.inspect}, @attrs=#{self.___attrs.inspect}, @nodes=#{self.___nodes.inspect}"
+      "@name=#{@name.inspect}, @attrs=#{@attrs.inspect}, @nodes=#{@nodes.inspect}"
     end
     alias_method :inspect, :to_str
 
-    def to_ary(*args)
-      self.___nodes
-    end
-
-    protected
-
-    def html_attrs(attrs={})
-      raise ArgumentError unless attrs.kind_of? ::Hash
-      if attrs.empty?
-        ''
-      else
-        ' '+attrs.
-        sort {|a,b|  a[0].to_s <=> b[0].to_s}.
-        collect {|k_v| "#{k_v[0]}=\"#{k_v[1]}\""}.
-        join(' ').
-        strip
-      end
-    end
-
     private
 
-    def proxy_id_attr(value, attrs={}, &block)
-      self.___attrs.merge!(:id => value)
-      self.___attrs.merge!(attrs)
-      self.___content = block
+    def proxy(value, attrs, content_block)
+      yield value if block_given?
+      @attrs.merge!(attrs)
+      @content_blocks << content_block if content_block
+      @start_tag = start_tag
+      @end_tag = end_tag
       self
     end
 
-    def proxy_class_attr(value, attrs={}, &block)
-      self.___attrs[:class] = [self.___attrs[:class], value].compact.join(' ')
-      self.___attrs.merge!(attrs)
-      self.___content = block
-      self
+    def start_tag
+      "<#{@name}#{self.class.html_attrs(@attrs)}" + (@content_blocks.size > 0 ? ">" : " />")
     end
 
-    def ___content=(block)
-      if block
-        @content_writes += 1
-        @stack.push(self)
-        block.call
-        @stack.pop
-      end
+    def end_tag
+      @content_blocks.size > 0 ? "</#{@name}>" : nil
     end
 
   end

data/lib/undies/named_source.rb

@@ -0,0 +1,54 @@
+module Undies
+
+  class Source; end
+
+  class NamedSource
+
+    attr_accessor :file, :opts, :proc
+
+    def initialize(*args, &block)
+      args << block if block
+      self.args = args
+    end
+
+    def ==(other_named_source)
+      self.file == other_named_source.file &&
+      self.opts == other_named_source.opts &&
+      self.proc == other_named_source.proc
+    end
+
+    def args=(values)
+      self.proc, self.opts, self.file = [
+        values.last.kind_of?(::Proc)   ? values.pop : nil,
+        values.last.kind_of?(::Hash)   ? values.pop : {},
+        values.last.kind_of?(::String) ? values.pop : nil
+      ]
+    end
+
+    def args
+      [self.file, self.opts, self.proc]
+    end
+
+  end
+
+  # singleton accessors for named sources
+
+  def self.named_sources
+    @@sources ||= {}
+  end
+
+  def self.named_source(name, *args, &block)
+    if args.empty? && block.nil?
+      self.named_sources[name]
+    else
+      self.named_sources[name] = Undies::NamedSource.new(*args, &block)
+    end
+  end
+
+  def self.source(name)
+    if ns = self.named_source(name)
+      Undies::Source.new(ns)
+    end
+  end
+
+end

data/lib/undies/node.rb

@@ -1,37 +1,29 @@
 module Undies
-  class Node
 
-    attr_reader :___content
+  class Node
 
-    def initialize(content)
-      @___content = content
-    end
+    # have as many methods to the class level as possilbe to keep from
+    # polluting the public instance methods and to maximize the effectiveness
+    # of the Element#method_missing logic
 
-    def start_tag
-      nil
+    def self.content(node)
+      node.instance_variable_get("@content")
     end
 
-    def end_tag
-      nil
+    def self.flush(output, node)
+      output << self.content(node)
     end
 
-    def to_s(pp_level=0, pp_indent=nil)
-      [ self.start_tag,
-        self.___content,
-        self.end_tag
-      ].compact.collect do |item|
-        pretty_print(item, pp_level, pp_indent)
-      end.join
+    def initialize(content)
+      @start_tag = nil
+      @end_tag = nil
+      @content = content
     end
 
-    private
-
-    def pretty_print(data, level, indent)
-      if data.kind_of? NodeList
-        data.to_s(level+1, indent)
-      else
-        indent ? "#{' '*level*indent}#{data}\n" : data
-      end
+    def ==(other_node)
+      self.class.content(self) == other_node.class.content(other_node) &&
+      self.instance_variable_get("@start_tag") == other_node.instance_variable_get("@start_tag") &&
+      self.instance_variable_get("@end_tag") == other_node.instance_variable_get("@end_tag")
     end
 
   end

data/lib/undies/node_buffer.rb

@@ -0,0 +1,35 @@
+module Undies
+
+  class NodeBuffer < ::Array
+
+    # a node buffer is a FIFO used to, well, buffer node data for output.
+    # nodes are pushed on the stack for processing and flushed to output
+    # when pulled.  empty the buffer by flushing it to output.
+
+    # the buffer allows for dynamic node handling while limiting memory
+    # bloat.  the Output handler ensures that only 1 node is buffered
+    # in memory at any given time by pulling the previous node to output
+    # before pushing the next node for processing.
+
+    def initialize(*args)
+      # always initialize empty
+      super()
+    end
+
+    def push(node)
+      super
+      node
+    end
+
+    def pull(output)
+      if (node = self.shift)
+        node.class.flush(output, node)
+      end
+    end
+
+    def flush(output)
+      self.pull(output) while self.size > 0
+    end
+
+  end
+end

data/lib/undies/output.rb

@@ -0,0 +1,64 @@
+require 'undies/node'
+require 'undies/element'
+require 'undies/node_buffer'
+
+module Undies
+  class Output
+
+    attr_reader :io, :options, :pp, :node_buffer
+
+    # the output class wraps an IO stream, gathers pretty printing options,
+    # and handles buffering nodes and pretty printing to the stream
+
+    def initialize(io, opts={})
+      @io = io
+      self.options = opts
+      @node_buffer = NodeBuffer.new
+    end
+
+    def options=(opts)
+      if !opts.kind_of?(::Hash)
+        raise ArgumentError, "please provide a hash to set options with"
+      end
+
+      # setup any pretty printing
+      @pp = opts[:pp]
+      self.pp_level = 0
+      self.pp_use_indent = true
+
+      @options = opts
+    end
+
+    def pp_level
+      @pp_level
+    end
+
+    def pp_level=(value)
+      @pp_indent = @pp ? "\n#{' '*value*@pp}" : ""
+      @pp_level  = value
+    end
+
+    def pp_use_indent=(value)
+      @pp_use_indent = value
+    end
+
+    def <<(data)
+      @io << (@pp_use_indent ? "#{@pp_indent}#{data}" : data.to_s)
+    end
+
+    def node(data="")
+      self.node_buffer.pull(self)
+      self.node_buffer.push(Node.new(data))
+    end
+
+    def element(name, attrs={}, &block)
+      self.node_buffer.pull(self)
+      self.node_buffer.push(Element.new(name, attrs, &block))
+    end
+
+    def flush
+      self.node_buffer.flush(self)
+    end
+
+  end
+end