undies 2.2.0 → 2.2.1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    undies (2.2.0)
+    undies (2.2.1)
 
 GEM
   remote: http://rubygems.org/
@@ -15,6 +15,8 @@ GEM
     erubis (2.7.0)
     rake (0.9.2)
     ruby-prof (0.10.8)
+    whysoslow (0.0.2)
+      ansi (~> 1.4)
 
 PLATFORMS
   ruby
@@ -27,3 +29,4 @@ DEPENDENCIES
   rake (~> 0.9.2)
   ruby-prof
   undies!
+  whysoslow (~> 0.0)

data/README.rdoc

@@ -153,9 +153,30 @@ Now just interact with the Undies API directly.
 *Note:* there is one extra caveat to be aware of using this approach.  You need to be sure and flush the template when content processing is complete.  Just pass the template to the Undies::Template#flush method:
 
     # ensures all content is streamed to the template's output stream
-    # this is only necessary using the "builder approach"
+    # this is necessary when not using the source approach above
     Undies::Template.flush(template)
 
+=== Manual approach
+
+There is another method you can use to render output: the Manual approach.  Like the Builder approach, this method is ideal when you don't know the source until render time.  The key difference is that blocks are not used to imply nesting relationships.  Using this approach, you manually 'push' and 'pop' to move up and down nesting relationship contexts.  So a push on an element would move the template context to the element pushed.  A pop would move back to the current context's parent element.  As you would expect, pop'ing on the root of a template has no effect on the context and pushing a non-element node has no effect on the context.
+
+To render using this approach, create a Template as you would with the Builder approach.  Interact with the Undies API directly.  Use the Template#push and Template#pop class methods to change the template scope.
+
+    # this is the equivalent to the Builder approach example above
+
+    template = Undies::Template.new(Undies::Output.new(@io))
+    something = "Some Thing!"
+    current = template._div.something!
+
+    template.__push(current)
+    template._ something.to_s
+    template.__pop
+
+    # alternate method for flushing a template
+    template.__flush
+
+*Note:* as with the Builder approach, you must flush the template when content processing is complete.
+
 == License
 
 Copyright (c) 2011-Present Kelly Redding

data/bench/bench_runner.rb

@@ -1,118 +1,99 @@
-require 'benchmark'
+require 'whysoslow'
 require 'stringio'
-require 'ansi'
 
-require 'undies'
 require 'erb'
 require 'erubis'
+require 'undies'
 
-class BenchResults
+class UndiesBenchResults
 
-  attr_reader :user, :system, :total, :real
-  attr_accessor :name, :ext, :size, :out, :outstream
+  attr_accessor :name, :ext, :size
 
-  def initialize(name, ext, size)
+  def initialize(name, ext, size, build)
     @name = name.to_s
     @ext = ext.to_s
     @size = size.to_s
-    @user, @system, @total, @real = 0
-    @outstream = StringIO.new(@out = "")
+    @build = build
+
+    @printer = Whysoslow::DefaultPrinter.new({
+      :title => "#{@name}, #{@size}",
+      :verbose => true
+    })
+    @runner = Whysoslow::Runner.new(@printer)
   end
 
   def file
     File.expand_path("bench/#{@size}.html#{@ext}")
   end
 
-  def user=(value_in_secs);   @user   = value_in_secs.to_f * 1000; end
-  def system=(value_in_secs); @system = value_in_secs.to_f * 1000; end
-  def total=(value_in_secs);  @total  = value_in_secs.to_f * 1000; end
-  def real=(value_in_secs);   @real   = value_in_secs.to_f * 1000; end
-
-  def to_s(meas=:real, basis=nil)
-    "#{name_s} (#{size_s}):  #{time_s(meas)} ms  #{"(#{basis_s(meas, basis)})" if basis}"
+  def run
+    @runner.run &@build
   end
 
-  protected
-
-  def measure(&block)
-    Benchmark.measure(&block).to_s.strip.gsub(/[^\s|0-9|\.]/, '').split(/\s+/).tap do |values|
-      self.user, self.system, self.total, self.real = values
-    end
-  end
+end
 
-  def name_s; @name.ljust(6); end
-  def size_s; @size.to_s; end
-  def time_s(meas); self.send(meas).to_s.rjust(7); end
-
-  def basis_s(meas, time)
-    diff = (time - self.send(meas))
-    perc = ((diff / time) * 100).round
-    if diff >= 0
-      ANSI.green + "+#{diff} ms, +#{perc}%" + ANSI.reset
-    else
-      ANSI.red + "#{diff} ms, #{perc}%" + ANSI.reset
-    end
-  end
 
-end
 
-class UndiesResults < BenchResults
+class UndiesResults < UndiesBenchResults
 
   def initialize(size='large')
-    super(:undies, '.rb', size)
-    measure do
+    @outstream = StringIO.new(@out = "")
+    super(:undies, '.rb', size, Proc.new do
       Undies::Template.new(
         Undies::Source.new(self.file),
         {},
-        Undies::Output.new(self.outstream, :pp => 2)
+        Undies::Output.new(@outstream, :pp => 2)
       )
-    end
+    end)
   end
 
 end
 
-class ErbResults < BenchResults
+class ErbResults < UndiesBenchResults
 
   def initialize(size='large')
-    super(:erb, '.erb', size)
-    measure do
-      self.out = ERB.new(File.read(self.file), 0, "%<>").result(binding)
-    end
+    @out = ""
+    super(:erb, '.erb', size, Proc.new do
+      @out = ERB.new(File.read(self.file), 0, "%<>").result(binding)
+    end)
   end
 
 end
 
-class ErubisResults < BenchResults
+class ErubisResults < UndiesBenchResults
 
   def initialize(size='large')
-    super(:erubis, '.erb', size)
-    measure do
-      self.out = Erubis::Eruby.new(File.read(self.file)).result(binding)
-    end
+    @out = ""
+    super(:erubis, '.erb', size, Proc.new do
+      @out = Erubis::Eruby.new(File.read(self.file)).result(binding)
+    end)
   end
 
 end
 
+
+
 class UndiesBenchRunner
 
   SIZES = {
-    :small => "~20 nodes",
-    :large => "~2000 nodes",
+    # :small     => "~20 nodes",
+    # :large     => "~2000 nodes",
     :verylarge => "~20000 nodes"
   }
 
+
   def initialize
     puts "Benchmark Results:"
     puts
-    [:small, :large, :verylarge].each do |size|
-      puts "#{size.to_s.upcase} (#{SIZES[size]})"
-      puts '-'*(size.to_s.length+3+SIZES[size].length)
-      basis = UndiesResults.new(size)
-      puts basis.to_s(:real)
-      puts ErbResults.new(size).to_s(:real, basis.real)
-      puts ErubisResults.new(size).to_s(:real, basis.real)
+    SIZES.each do |size, desc|
+      ErbResults.new(size).run
+      puts
+      ErubisResults.new(size).run
+      puts
+      UndiesResults.new(size).run
       puts
     end
+    puts
   end
 
 end

data/lib/undies/element.rb

@@ -29,35 +29,59 @@ module Undies
         gsub('"', '"')
     end
 
-    def self.content(element)
-      nil
+    def self.set_children(element, value)
+      element.instance_variable_set("@children", value)
     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
+    def self.children(element)
+      element.instance_variable_get("@children")
+    end
+
+    def self.prefix(element, meth, level, indent)
+      "".tap do |value|
+        if indent > 0
+          if meth == 'start_tag'
+            value << "#{level > 0 ? "\n": ''}#{' '*level*indent}"
+          elsif meth == 'end_tag'
+            value << "\n#{' '*level*indent}" if children(element)
+          end
+        end
       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)
+    def self.set_start_tag(element)
+      element.instance_variable_set(
+        "@start_tag",
+        "<#{node_name(element)}#{hash_attrs(attrs(element))}" + (builds(element).size > 0 ? ">" : " />")
+      )
+    end
+
+    def self.set_end_tag(element)
+      element.instance_variable_set(
+        "@end_tag",
+        builds(element).size > 0 ? "</#{node_name(element)}>" : nil
+      )
+    end
+
+    def initialize(name, attrs={}, &build)
+      super(nil)
+      @start_tag = ""
+      @end_tag = ""
+      @content = nil
+      @builds = []
+      @children = false
+
       if !attrs.kind_of?(::Hash)
         raise ArgumentError, "#{name.inspect} attrs must be provided as a Hash."
       end
 
       @name  = name.to_s
       @attrs = attrs
-      @content_blocks = []
-      @content_blocks << block if block
-      @start_tag = start_tag
-      @end_tag = end_tag
+      @builds << build if build
+
+      # cache in an instance variable for fast access with flush and pop
+      self.class.set_start_tag(self)
+      self.class.set_end_tag(self)
     end
 
     # CSS proxy methods ============================================
@@ -89,35 +113,30 @@ module Undies
 
     def ==(other)
       other.instance_variable_get("@name")  == @name  &&
-      other.instance_variable_get("@attrs") == @attrs &&
-      other.instance_variable_get("@nodes") == @nodes
+      other.instance_variable_get("@attrs") == @attrs
     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=#{@name.inspect}, @attrs=#{@attrs.inspect}, @nodes=#{@nodes.inspect}"
+      "@name=#{@name.inspect}, @attrs=#{@attrs.inspect}"
     end
     alias_method :inspect, :to_str
 
     private
 
-    def proxy(value, attrs, content_block)
+    def proxy(value, attrs, build)
       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
+      @builds << build if build
 
-    def start_tag
-      "<#{@name}#{self.class.hash_attrs(@attrs)}" + (@content_blocks.size > 0 ? ">" : " />")
-    end
+      # cache in an instance variable for fast access with flush and pop
+      self.class.set_start_tag(self)
+      self.class.set_end_tag(self)
 
-    def end_tag
-      @content_blocks.size > 0 ? "</#{@name}>" : nil
+      # return self so you can chain proxy method calls
+      self
     end
 
   end

data/lib/undies/node.rb

@@ -2,28 +2,79 @@ module Undies
 
   class Node
 
-    # have as many methods to the class level as possilbe to keep from
+    # have as many methods to the class level as possible to keep from
     # polluting the public instance methods and to maximize the effectiveness
     # of the Element#method_missing logic
 
+    def self.start_tag(node)
+      node.instance_variable_get("@start_tag") || ""
+    end
+
+    def self.end_tag(node)
+      node.instance_variable_get("@end_tag") || ""
+    end
+
+    def self.set_start_tag(node); end
+    def self.set_end_tag(node); end
+
+    def self.builds(node)
+      node.instance_variable_get("@builds") || []
+    end
+
+    def self.add_build(node, build_block)
+      node.instance_variable_set("@builds", builds(node) + [build_block])
+    end
+
+    def self.children(node)
+      node.instance_variable_get("@children")
+    end
+
+    def self.set_children(node, value)
+      node.instance_variable_set("@children", value)
+    end
+
+    def self.attrs(element)
+      element.instance_variable_get("@attrs")
+    end
+
+    def self.merge_attrs(element, value={})
+      attrs(element).merge(value).tap do |a|
+        element.instance_variable_set("@attrs", a)
+      end
+    end
+
+    def self.node_name(node)
+      node.instance_variable_get("@name") || ""
+    end
+
     def self.content(node)
-      node.instance_variable_get("@content")
+      node.instance_variable_get("@content") || ""
+    end
+
+    def self.mode(node)
+      node.instance_variable_get("@mode") || :inline
     end
 
-    def self.flush(output, node)
-      output.pp_use_indent = true if node.force_pp?
-      output << self.content(node)
+    def self.prefix(node, meth, level, indent)
+      "".tap do |value|
+        if mode(node) != :inline && indent > 0
+          if meth == 'start_tag'
+            value << "#{level > 0 ? "\n": ''}#{' '*level*indent}"
+          elsif meth == 'end_tag'
+            value << "\n#{' '*(level > 0 ? level-1 : level)*indent}"
+          end
+        end
+      end
     end
 
-    def initialize(content, opts={})
+    def initialize(content, mode=:inline)
       @start_tag = nil
       @end_tag = nil
-      @force_pp = opts[:force_pp]
       @content = content
-    end
-
-    def force_pp?
-      !!@force_pp
+      @builds = []
+      @attrs = {}
+      @children = false
+      @mode = mode
     end
 
     def ==(other_node)

data/lib/undies/node_stack.rb

@@ -0,0 +1,111 @@
+module Undies
+  class NodeStack
+
+    # the node stack handles caching nodes for processing, running node
+    # builds, and buffering node output for writing. I want to treat this
+    # as a stack of nodes for the template API to reference.  I need to push
+    # a node onto the stack, reference it using the 'current' method,
+    # and pop it off the stack when I'm done.
+
+    # the stack first caches new nodes before pushing them onto the stack
+    # and node output is buffered as new nodes are pushed
+
+    def self.create(output)
+      output.kind_of?(NodeStack) ? output : NodeStack.new(output)
+    end
+
+    attr_reader :stack, :output, :buffer
+    attr_accessor :cached_node
+
+    def initialize(output)
+      @stack = []
+      @cached_node = nil
+      @output = output
+      @written_level = 0
+    end
+
+    def empty?; @stack.empty?; end
+    def size;   @stack.size;   end
+    def first;  @stack.first;  end
+    def last;   @stack.last;   end
+
+    alias_method :current, :last
+    alias_method :level, :size
+
+    def push(node)
+      if current
+        current.class.set_children(current, node.kind_of?(Element))
+      end
+      if @written_level < level
+        open(current)
+      end
+      @stack.push(node)
+    end
+
+    def pop(*args)
+      if !empty?
+        node = if @written_level < level
+          @stack.pop.tap { |node| write(node) }
+        else
+          @stack.pop.tap { |node| close(node) }
+        end
+      end
+    end
+
+    def node(node)
+      clear_cached
+      self.cached_node = node
+    end
+
+    def flush
+      clear_cached
+    end
+
+    def clear_cached
+      node_to_push, self.cached_node = self.cached_node, nil
+      if node_to_push
+        push(node_to_push)
+        node_to_push.class.builds(node_to_push).each { |build| build.call }
+        clear_cached
+        pop
+      end
+    end
+
+    private
+
+    def open(node)
+      start_tag(node, @written_level)
+      @written_level += 1
+      content(node, @written_level)
+    end
+
+    def write(node)
+      start_tag(node, @written_level)
+      content(node, @written_level+1)
+      end_tag(node, @written_level)
+    end
+
+    def close(node)
+      @written_level -= 1
+      end_tag(node, @written_level)
+    end
+
+    # TODO: Fill up an output write buffer with arg arrays
+    # then empty it
+
+    def start_tag(node, level)
+      @output.write(node, 'start_tag', level)
+    end
+
+    def content(node, level)
+      @output.write(node, 'content', level)
+    end
+
+    def end_tag(node, level)
+      @output.write(node, 'end_tag', level)
+    end
+
+  end
+
+
+end

data/lib/undies/output.rb

@@ -1,18 +1,15 @@
-require 'undies/node_buffer'
-
 module Undies
   class Output
 
-    attr_reader :io, :options, :pp, :node_buffer
-    attr_accessor :pp_use_indent
-
     # the output class wraps an IO stream, gathers pretty printing options,
-    # and handles buffering nodes and pretty printing to the stream
+    # and handles writing out buffered node stack items
+
+    attr_reader :io, :pp
+    attr_accessor :pp_level
 
     def initialize(io, opts={})
       @io = io
       self.options = opts
-      @node_buffer = NodeBuffer.new
     end
 
     def options=(opts)
@@ -21,33 +18,13 @@ module Undies
       end
 
       # setup any pretty printing
-      @pp = opts[:pp]
-      self.pp_level = opts[: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 <<(data)
-      @io << (@pp_use_indent ? "#{@pp_indent}#{data}" : data.to_s)
-    end
-
-    def node(obj)
-      self.node_buffer.pull(self)
-      self.node_buffer.push(obj)
+      @pp = opts[:pp] || 0
+      @pp_level = opts[:pp_level] || 0
     end
 
-    def flush
-      self.node_buffer.flush(self)
+    def write(node, meth, level)
+      @io << node.class.prefix(node, meth, level+@pp_level, @pp)
+      @io << node.class.send(meth, node)
     end
 
   end