undies 2.2.1 → 3.0.0.rc.1

data/lib/undies/element.rb

@@ -1,88 +1,48 @@
-require 'undies/node'
-
 module Undies
-  class Element < Node
 
-    # 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
+
+
+  module Element
 
     def self.hash_attrs(attrs="", ns=nil)
       return attrs.to_s if !attrs.kind_of?(::Hash)
 
-      {}.tap do |a|
-        attrs.each { |k, v| a[ns ? "#{ns}_#{k}" : k.to_s] = v }
-      end.sort.inject('') do |html, k_v|
-        html + if k_v.last.kind_of?(::Hash)
+      attrs.collect do |k_v|
+        [ns ? "#{ns}_#{k_v.first}" : k_v.first.to_s, k_v.last]
+      end.sort.collect do |k_v|
+        if k_v.last.kind_of?(::Hash)
           hash_attrs(k_v.last, k_v.first)
+        elsif k_v.last.kind_of?(::Array)
+          " #{k_v.first}=\"#{escape_attr_value(k_v.last.join(' '))}\""
         else
           " #{k_v.first}=\"#{escape_attr_value(k_v.last)}\""
         end
-      end
+      end.join
     end
 
+    ESCAPE_ATTRS = {
+      "&" => "&amp;",
+      "<" => "&lt;",
+      '"' => "&quot;"
+    }
+    ESCAPE_ATTRS_PATTERN = Regexp.union(*ESCAPE_ATTRS.keys)
     def self.escape_attr_value(value)
-      value.
-        to_s.
-        gsub('&', '&amp;').
-        gsub('<', '&lt;').
-        gsub('"', '&quot;')
-    end
-
-    def self.set_children(element, value)
-      element.instance_variable_set("@children", value)
-    end
-
-    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
+      value.to_s.gsub(ESCAPE_ATTRS_PATTERN){|c| ESCAPE_ATTRS[c] }
     end
 
-    def self.set_start_tag(element)
-      element.instance_variable_set(
-        "@start_tag",
-        "<#{node_name(element)}#{hash_attrs(attrs(element))}" + (builds(element).size > 0 ? ">" : " />")
-      )
+    def self.open(*args, &build)
+      Open.new(*args, &build)
     end
 
-    def self.set_end_tag(element)
-      element.instance_variable_set(
-        "@end_tag",
-        builds(element).size > 0 ? "</#{node_name(element)}>" : nil
-      )
+    def self.closed(*args, &build)
+      Closed.new(*args, &build)
     end
 
-    def initialize(name, attrs={}, &build)
-      super(nil)
-      @start_tag = ""
-      @end_tag = ""
-      @content = nil
-      @builds = []
-      @children = false
+  end
 
-      if !attrs.kind_of?(::Hash)
-        raise ArgumentError, "#{name.inspect} attrs must be provided as a Hash."
-      end
 
-      @name  = name.to_s
-      @attrs = attrs
-      @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
+  module CSSProxy
 
     # CSS proxy methods ============================================
     ID_METH_REGEX = /^([^_].+)!$/
@@ -90,13 +50,11 @@ module Undies
 
     def method_missing(meth, *args, &block)
       if meth.to_s =~ ID_METH_REGEX
-        proxy($1, args.first || {}, block) do |value|
-          @attrs.merge!(:id => value)
-        end
+        @attrs[:id] = $1
+        proxy(args, block)
       elsif meth.to_s =~ CLASS_METH_REGEX
-        proxy($1, args.first || {}, block) do |value|
-          @attrs[:class] = [@attrs[:class], value].compact.join(' ')
-        end
+        @attrs[:class] = [@attrs[:class], $1].compact.join(' ')
+        proxy(args, block)
       else
         super
       end
@@ -111,6 +69,133 @@ module Undies
     end
     # ==============================================================
 
+  end
+
+
+
+  module MergeAttrs
+
+    def __attrs(attrs_hash=nil)
+      return @attrs if attrs_hash.nil?
+      @attrs.merge!(attrs_hash)
+    end
+
+  end
+
+
+
+  class Raw < ::String
+
+    # A Raw string is one that is impervious to String#gsub and returns itself
+    # when `to_s` is called.
+
+    def gsub(*args, &block)
+      self
+    end
+
+    def gsub!(*args, &block)
+      nil
+    end
+
+    def to_s
+      self
+    end
+
+  end
+
+
+
+  class Element::Open
+    include CSSProxy
+    include MergeAttrs
+
+    def initialize(name, *args, &build)
+      @name    = name.to_s
+      @attrs   = {}
+      @content = []
+      @build   = nil
+
+      proxy(args, build)
+    end
+
+    def __start_tag
+      "<#{@name}#{Element.hash_attrs(@attrs)}>"
+    end
+
+    def __content
+      @content.collect{ |c| Template.escape_html(c) }.join
+    end
+
+    def __build
+      @build.call if @build
+    end
+
+    def __end_tag
+      "</#{@name}>"
+    end
+
+    def to_s
+      "#{__start_tag}#{__content}#{__end_tag}"
+    end
+
+    def ==(other)
+      other.instance_variable_get("@name")    == @name    &&
+      other.instance_variable_get("@attrs")   == @attrs   &&
+      other.instance_variable_get("@content") == @content
+    end
+
+    # overriding this because the base Node class defines a 'to_s' method that
+    # needs to be honored
+    def to_str(*args)
+      "Undies::Element::Open:#{self.object_id} " +
+      "@name=#{@name.inspect}, @attrs=#{@attrs.inspect}, @content=#{@content.inspect}"
+    end
+    alias_method :inspect, :to_str
+
+    private
+
+    def proxy(args, build)
+      if args.last.kind_of?(Hash)
+        @attrs.merge!(args.pop)
+      end
+
+      @content.push *args
+      @build = build
+
+      self
+    end
+
+  end
+
+
+
+  class Element::Closed
+    include CSSProxy
+    include MergeAttrs
+
+    def initialize(name, attrs={})
+      @name    = name.to_s
+      @attrs   = {}
+      proxy([attrs])
+    end
+
+    def __start_tag
+      "<#{@name}#{Element.hash_attrs(@attrs)} />"
+    end
+
+    # closed elements have no content
+    def __content; ''; end
+
+    # closed elements should have no build so do nothing
+    def __build; end
+
+    # closed elements have no end tag
+    def __end_tag; ''; end
+
+    def to_s
+      "#{__start_tag}"
+    end
+
     def ==(other)
       other.instance_variable_get("@name")  == @name  &&
       other.instance_variable_get("@attrs") == @attrs
@@ -119,25 +204,20 @@ module Undies
     # 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} " +
+      "Undies::Element::Closed:#{self.object_id} " +
       "@name=#{@name.inspect}, @attrs=#{@attrs.inspect}"
     end
     alias_method :inspect, :to_str
 
     private
 
-    def proxy(value, attrs, build)
-      yield value if block_given?
-      @attrs.merge!(attrs)
-      @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)
-
-      # return self so you can chain proxy method calls
+    def proxy(args, build=nil)
+      @attrs.merge!(args.last || {})
       self
     end
 
   end
+
+
+
 end

data/lib/undies/element_node.rb

@@ -0,0 +1,116 @@
+module Undies
+
+  class ElementAPIError < RuntimeError; end
+
+  class ElementNode
+
+    # Used internally to implement the markup tree nodes.  Each node caches and
+    # processes nested markup and elements.  At each node level in the markup
+    # tree, nodes/markup are cached until the next sibling node or raw markup
+    # is defined, or until the node is flushed.  This keeps nodes from bloating
+    # memory on large documents and allows for output streaming.
+
+    # ElementNode is specifically used to handle nested element markup.
+
+    attr_reader :io, :element, :cached
+
+    def initialize(io, element)
+      @io = io
+      @cached = nil
+      @element = element
+
+      @start_tag_written = false
+    end
+
+    def attrs(*args, &block)
+      @element.__attrs(*args, &block)
+    end
+
+    def text(raw)
+      raise ElementAPIError, "can't insert text markup in an element build block - pass in as a content argument instead"
+    end
+
+    def element_node(element_node)
+      if !@start_tag_written
+        # with newline
+        # -1 level offset b/c we are operating on the element build one deep
+        write_start_tag(@io.newline, -1)
+      end
+      write_cached
+      @cached = element_node
+    end
+
+    def partial(partial)
+      element_node(partial)
+    end
+
+    def flush
+      write_cached
+      @cached = nil
+      self
+    end
+
+    def push
+      @io.push(@cached)
+      @cached = nil
+    end
+
+    def pop
+      flush
+      @io.pop
+      write_end_tag
+    end
+
+    def to_s
+      @io.push(self)
+
+      @element.__build
+      flush
+
+      @io.pop
+      write_end_tag
+
+      # needed so the `write_cached` calls on ElementNode and RootNode won't add
+      # anything else to the IO
+      return ""
+    end
+
+    def ==(other)
+      other.instance_variable_get("@io") == @io &&
+      other.instance_variable_get("@element") == @element
+    end
+
+    # overriding this because the base Node class defines a 'to_s' method that
+    # needs to be honored
+    def to_str(*args)
+      "Undies::ElementNode:#{self.object_id} @element=#{@element.inspect}"
+    end
+    alias_method :inspect, :to_str
+
+    private
+
+    def write_cached
+      @io << @cached.to_s
+    end
+
+    def write_start_tag(newline='', level_offset=0)
+      @io << "#{@io.line_indent(level_offset)}#{@element.__start_tag}#{newline}"
+      @start_tag_written = true
+    end
+
+    def write_content
+      @io << @element.__content
+    end
+
+    def write_end_tag(level_offset=0)
+      if !@start_tag_written
+        write_start_tag('', level_offset)
+        write_content
+        @io << "#{@element.__end_tag}#{@io.newline}"
+      else
+        @io << "#{@io.line_indent(level_offset)}#{@element.__end_tag}#{@io.newline}"
+      end
+    end
+
+  end
+end

data/lib/undies/io.rb

@@ -0,0 +1,43 @@
+module Undies
+  class IO
+
+    # the IO class wraps a stream (anything that responds to '<<' and
+    # gathers streaming options options.  handles writing markup to the
+    # stream.
+
+    attr_reader :stream, :indent, :newline, :node_stack
+    attr_accessor :level
+
+    def initialize(stream, opts={})
+      @stream = stream
+      @node_stack = []
+      self.options = opts
+    end
+
+    def options=(opts)
+      if !opts.kind_of?(::Hash)
+        raise ArgumentError, "please provide a hash to set IO options"
+      end
+
+      @indent = opts[:pp] || 0
+      @newline = opts[:pp].nil? ? "" : "\n"
+      @level = opts[:level] || 0
+    end
+
+    def line_indent(relative_level=0)
+      "#{' '*(@level+relative_level)*@indent}"
+    end
+
+    # TODO: threaded/forked writing for performance improvement
+    def <<(markup)
+      @stream << markup
+    end
+
+    def push(scope); @level += 1; push!(scope); end
+    def push!(scope); @node_stack.push(scope); end
+    def pop; @level -= 1; @node_stack.pop; end
+    def current; @node_stack.last; end
+    def empty?; @node_stack.empty? end
+
+  end
+end

data/lib/undies/root_node.rb

@@ -0,0 +1,62 @@
+module Undies
+
+  class RootAPIError < RuntimeError; end
+
+  class RootNode
+
+    # Used internally to implement the markup tree nodes.  Each node caches and
+    # processes nested markup and elements.  At each node level in the markup
+    # tree, nodes/markup are cached until the next sibling node or raw markup
+    # is defined, or until the node is flushed.  This keeps nodes from bloating
+    # memory on large documents and allows for output streaming.
+
+    # RootNode is specifically used to handle root document markup.
+
+    attr_reader :io, :cached
+
+    def initialize(io)
+      @io = io
+      @cached = nil
+    end
+
+    def attrs(*args, &block)
+      raise RootAPIError, "can't call '__attrs' at the root node level"
+    end
+
+    def text(raw)
+      write_cached
+      @cached = "#{@io.line_indent}#{raw.to_s}#{@io.newline}"
+    end
+
+    def element_node(element_node)
+      write_cached
+      @cached = element_node
+    end
+
+    def partial(partial)
+      text(partial)
+    end
+
+    def flush
+      write_cached
+      @cached = nil
+      self
+    end
+
+    def push
+      @io.push(@cached)
+      @cached = nil
+    end
+
+    def pop
+      flush
+    end
+
+    private
+
+    def write_cached
+      @io << @cached.to_s
+    end
+
+  end
+end

data/lib/undies/source.rb

@@ -1,6 +1,7 @@
-require 'undies/named_source'
-
 module Undies
+
+
+
   class Source
 
     attr_reader :source, :data, :layout
@@ -70,4 +71,79 @@ module Undies
     end
 
   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
+
+
+
+  class SourceStack < ::Array
+
+    # a source stack is used to manage which sources and any deeply nested
+    # layouts they are in.  initialize this object with a content source obj
+    # and get a stack where the the top source is the outer most layout and
+    # the bottom source is the source used to initialize the stack (the content
+    # source).  naturally any sources in between are the intermediate layouts
+    # for the content source
+
+    def initialize(source)
+      super([source, source.layouts].flatten.compact)
+    end
+
+    def pop
+      super
+    end
+
+  end
+
+
+
 end