undies 1.2.0 → 2.0.0

data/lib/undies/source.rb

@@ -1,26 +1,72 @@
+require 'undies/named_source'
+
 module Undies
   class Source
 
-    attr_reader :source, :data
+    attr_reader :source, :data, :layout
+
+    def initialize(*args, &block)
+      named = args.first.kind_of?(NamedSource) ? args.first : nil
+      args << block if block
+      self.args = named ? named.args.compact : args
+    end
 
-    def initialize(source=nil)
-      raise ArgumentError, "file or block required" if source.nil?
+    def file?
+      !@source.kind_of?(::Proc)
+    end
 
-      @source = source
-      if self.file? && !File.exists?(@source.to_s)
-        raise ArgumentError, "no template file '#{@source}'"
+    def layouts
+      if layout
+        [self.layout, self.layout.layouts].flatten.compact
+      else
+        []
       end
+    end
+
+    def layout_sources
+      self.layouts.collect{|l| l.source}
+    end
 
-      # load source data and prepare (uses binread to avoid encoding issues)
-      @data = if self.file?
-        File.send(File.respond_to?(:binread) ? :binread : :read, @source.to_s)
+    def ==(other_source)
+      self.source == other_source.source &&
+      self.layout_sources == other_source.layout_sources
+    end
+
+    def args=(values)
+      proc, opts, file = [
+        values.last.kind_of?(::Proc)   ? values.pop : nil,
+        values.last.kind_of?(::Hash)   ? values.pop : {},
+        values.last.kind_of?(::String) ? values.pop : nil
+      ]
+
+      self.source = file || proc
+      self.layout = opts[:layout]
+    end
+
+    def source=(value)
+      if value.nil?
+        raise ArgumentError, "source name, file, or block required"
+      end
+      @data = if value.kind_of?(::Proc)
+        value
       else
-        @source
+        raise ArgumentError, "no source file '#{value}'" if !File.exists?(value.to_s)
+        File.send(File.respond_to?(:binread) ? :binread : :read, value.to_s)
       end
+      @source = value
     end
 
-    def file?
-      !@source.kind_of?(::Proc)
+    def layout=(value)
+      @layout = case value
+      when Source, NilClass
+        value
+      when ::Proc
+        Source.new(&value)
+      when ::String, NamedSource
+        Source.new(value)
+      else
+        raise ArgumentError, "invalid layout"
+      end
     end
 
   end

data/lib/undies/source_stack.rb

@@ -0,0 +1,22 @@
+require "undies/source"
+
+module Undies
+  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

data/lib/undies/template.rb

@@ -1,47 +1,69 @@
-require 'undies/source'
-require 'undies/node'
-require 'undies/element'
+require 'undies/source_stack'
+require 'undies/output'
 
 module Undies
   class Template
 
-    # prefixing with a triple underscore to not pollut metaclass locals scope
+    # have as many methods to the class level as possilbe to keep from
+    # polluting the public instance methods, the instance scope, and to
+    # maximize the effectiveness of the Template#method_missing logic
 
-    attr_accessor :___nodes
+    def self.output(template)
+      template.instance_variable_get("@_undies_output")
+    end
+
+    def initialize(source, data, output)
+      # setup the source stack and output objects
+      raise ArgumentError, "please provide a Source object" if !source.kind_of?(Source)
+      @_undies_source_stack = SourceStack.new(source)
+      raise ArgumentError, "please provide an Output object" if !output.kind_of?(Output)
+      @_undies_output = output
+
+      # apply data to template scope
+      raise ArgumentError if !data.kind_of?(::Hash)
+      if (data.keys.map(&:to_s) & self.public_methods.map(&:to_s)).size > 0
+        raise ArgumentError, "data conflicts with template public methods."
+      end
+      metaclass = class << self; self; end
+      data.each {|key, value| metaclass.class_eval { define_method(key){value} }}
 
-    def initialize(*args, &block)
-      self.___nodes = NodeList.new
-      targs = self.___template_args(args.compact, block)
-      self.___locals, self.___io, self.___layout, self.___markup = targs
-      self.___stack = ElementStack.new(self, self.___io)
-      self.___compile { self.___render(self.___markup) if self.___layout }
+      # yield to recursivley render the source stack
+      self.__yield
+
+      # flush any remaining output to the stream
+      @_undies_output.flush
     end
 
-    def to_s(pp_indent=nil)
-      self.___nodes.to_s(0, pp_indent)
+    # call this to render template source
+    # use this method in layouts to insert a layout's content source
+    def __yield
+      return if @_undies_source_stack.nil? || (source = @_undies_source_stack.pop).nil?
+      if source.file?
+        instance_eval(source.data, source.source, 1)
+      else
+        instance_eval(&source.data)
+      end
     end
 
-    # Add a text node (data escaped) to the nodes of the current node
-    def _(data="")
-      self.__ self.escape_html(data.to_s)
+    # call this to render partial source embedded in a template
+    # partial source is rendered with its own scope/data but shares
+    # its parent template's output object
+    def __partial(source, data)
+      Undies::Template.new(source, data, @_undies_output)
     end
 
+    # Add a text node (data escaped) to the nodes of the current node
+    def _(data=""); self.__ self.escape_html(data.to_s); end
+
     # Add a text node with the data un-escaped
-    def __(data="")
-      node = Node.new(data.to_s)
-      self.___io << node.to_s if self.___io
-      self.___add(node)
-    end
+    def __(data=""); @_undies_output.node(data.to_s); end
 
     # Add an element to the nodes of the current node
-    def element(name, attrs={}, &block)
-      self.___add(Element.new(self.___stack, name, attrs, &block))
-    end
+    def element(*args, &block); @_undies_output.element(*args, &block); end
     alias_method :tag, :element
 
     # Element proxy methods ('_<element>'') ========================
     ELEM_METH_REGEX = /^_(.+)$/
-
     def method_missing(meth, *args, &block)
       if meth.to_s =~ ELEM_METH_REGEX
         element($1, *args, &block)
@@ -49,7 +71,6 @@ module Undies
         super
       end
     end
-
     def respond_to?(*args)
       if args.first.to_s =~ ELEM_METH_REGEX
         true
@@ -70,119 +91,11 @@ module Undies
       "/" => "&#x2F;"
     }
     ESCAPE_HTML_PATTERN = Regexp.union(*ESCAPE_HTML.keys)
-
     # Escape ampersands, brackets and quotes to their HTML/XML entities.
     def escape_html(string)
       string.to_s.gsub(ESCAPE_HTML_PATTERN){|c| ESCAPE_HTML[c] }
     end
     # end Rip from Rack v1.3.0 =====================================
 
-    protected
-
-    # prefixing non-public methods with a triple underscore to not pollute
-    # metaclass locals scope
-
-    def ___compile
-      self.___render(self.___layout || self.___markup)
-    end
-
-    def ___render(source)
-      if source.file?
-        instance_eval(source.data, source.source, 1)
-      else
-        instance_eval(&source.data)
-      end
-    end
-
-    def ___locals=(data)
-      if !data.kind_of?(::Hash)
-        raise ArgumentError
-      end
-      if invalid_locals?(data.keys)
-        raise ArgumentError, "locals conflict with template's public methods."
-      end
-      data.each do |key, value|
-        self.___metaclass do
-          define_method(key) { value }
-        end
-      end
-    end
-
-    def ___add(node)
-      self.___stack.last.___nodes.append(node)
-    end
-
-    def ___stack
-      @stack
-    end
-
-    def ___stack=(value)
-      raise ArgumentError if !value.respond_to?(:push) || !value.respond_to?(:pop)
-      @stack = value
-    end
-
-    def ___io
-      @io
-    end
-
-    def ___io=(value)
-      raise ArgumentError if value && !self.___is_a_stream?(value)
-      @io = value
-    end
-
-    def ___layout
-      @layout
-    end
-
-    def ___layout=(value)
-      if value && !(value.kind_of?(Source) && value.file?)
-        raise ArgumentError, "layout must be a file source"
-      end
-      @layout = value
-    end
-
-    def ___markup
-      @markup
-    end
-
-    def ___markup=(value)
-      raise ArgumentError if value && !value.kind_of?(Source)
-      @markup = value
-    end
-
-    def ___template_args(args, block)
-      [ args.last.kind_of?(::Hash) ? args.pop : {},
-        self.___is_a_stream?(args.last) ? args.pop : nil,
-        self.___layout_arg?(args, block) ? Source.new(args.pop) : nil,
-        Source.new(args.first || block)
-      ]
-    end
-
-    def ___metaclass(&block)
-      metaclass = class << self; self; end
-      metaclass.class_eval(&block)
-    end
-
-    def ___is_a_stream?(thing)
-      !thing.kind_of?(::String) && thing.respond_to?(:<<)
-    end
-
-    def ___layout_arg?(args, block)
-      if args.size >= 2
-        true
-      elsif args.size <= 0
-        false
-      else # args.size == 1
-        !block.nil?
-      end
-    end
-
-    private
-
-    # you can't define locals that conflict with the template's public methods
-    def invalid_locals?(keys)
-      (keys.collect(&:to_s) & self.public_methods.collect(&:to_s)).size > 0
-    end
-
   end
 end

data/lib/undies/version.rb

@@ -1,3 +1,3 @@
 module Undies
-  VERSION = "1.2.0"
+  VERSION = "2.0.0"
 end

data/lib/undies.rb

@@ -1,13 +1,3 @@
 require 'undies/template'
-require 'undies/partial'
 
-module Undies
-
-  # TODO: maybe implement this pattern??
-  # class << self
-  #   def new(&block)
-  #     Template.new(&block)
-  #   end
-  # end
-
-end
+module Undies; end

data/test/element_test.rb

@@ -1,116 +1,61 @@
-require "test_belt"
+require "assert"
 
 require "undies/element"
-require "undies/element_stack"
 require "undies/template"
 
 class Undies::Element
 
-
-
-  class BasicTest < Test::Unit::TestCase
-    include TestBelt
-
-    context 'an element'
-    before { @e = Undies::Element.new(Undies::ElementStack.new, :div) }
+  class BasicTests < Assert::Context
+    desc 'an element'
+    before do
+      @e = Undies::Element.new(:div)
+    end
     subject { @e }
-    should have_readers :___name, :___attrs
-    should have_accessor :___nodes
+
+    should have_class_methods :html_attrs, :content, :flush
+    should have_instance_method :to_str
 
     should "be a Node" do
       assert_kind_of Undies::Node, subject
     end
 
     should "store it's name as a string" do
-      assert_equal "div", subject.___name
+      assert_equal "div", subject.instance_variable_get("@name")
     end
 
-    should "have a NodeList as its nodes" do
-      assert_kind_of Undies::NodeList, subject.___nodes
-    end
-
-    should "have its nodes be its content" do
-      assert_equal subject.___nodes.object_id, subject.___content.object_id
-    end
-
-    should "have an element stack as its stack" do
-      assert_kind_of Undies::ElementStack, subject.send(:instance_variable_get, "@stack")
-    end
-
-    should "complain is not created with an ElementStack" do
-      assert_raises ArgumentError do
-        Undies::Element.new([], :div)
-      end
-    end
-
-  end
-
-
-
-  class EmptyTest < Test::Unit::TestCase
-    include TestBelt
-    context 'an empty element'
-    before { @e = Undies::Element.new(Undies::ElementStack.new, :br) }
-    subject { @e }
-
-    should "have no nodes" do
-      assert_equal([], subject.___nodes)
+    should "have no content itself" do
+      assert_nil subject.class.content(subject)
     end
 
   end
 
-
-
-  class HtmlAttrsTest < BasicTest
-    context "html_attrs util"
+  class HtmlAttrsTest < BasicTests
+    desc "the element class html_attrs util"
 
     should "convert an empty hash to html attrs" do
-      assert_equal('', subject.send(:html_attrs, {}))
+      assert_equal '', Undies::Element.html_attrs({})
     end
 
     should "convert a basic hash to html attrs" do
-      attrs = subject.send(:html_attrs, :class => "test", :id => "test_1")
+      attrs = Undies::Element.html_attrs(:class => "test", :id => "test_1")
       assert_match /^\s{1}/, attrs
       assert attrs.include?('class="test"')
       assert attrs.include?('id="test_1"')
     end
 
     should "convert a nested hash to html attrs" do
-      attrs = subject.send(:html_attrs, {
+      attrs = Undies::Element.html_attrs({
         :class => "testing", :id => "test_2",
         :nested => {:something => 'is_awesome'}
       })
       assert_match /^\s{1}/, attrs
-      assert attrs.include?('class="testing"')
-      assert attrs.include?('id="test_2"')
-      assert attrs.include?('nested="somethingis_awesome"')
+      assert_included 'class="testing"', attrs
+      assert_included 'id="test_2"', attrs
+      assert_included 'nested_something="is_awesome"', attrs
     end
   end
 
-
-
-  class SerializeTest < BasicTest
-    should "serialize with no child elements" do
-      element = Undies::Element.new(Undies::ElementStack.new, :br)
-      assert_equal "<br />", element.to_s
-    end
-
-    should "serialize with attrs" do
-      element = Undies::Element.new(Undies::ElementStack.new, :br, {:class => 'big'})
-      assert_equal '<br class="big" />', element.to_s
-    end
-
-    should "serialize with attrs and content" do
-      templ = Undies::Template.new do
-        element(:strong, {:class => 'big'}) { __ "Loud Noises!" }
-      end
-      assert_equal '<strong class="big">Loud Noises!</strong>', templ.to_s
-    end
-  end
-
-
-
-  class CSSProxyTest < BasicTest
+  class CSSProxyTests < BasicTests
 
     should "respond to any method ending in '!' as an id proxy" do
       assert subject.respond_to?(:asdgasdg!)
@@ -119,32 +64,25 @@ class Undies::Element
     should "proxy id attr with methods ending in '!'" do
       assert_equal({
         :id => 'thing1'
-      }, subject.thing1!.___attrs)
-    end
-
-    should "nest elements from proxy id call" do
-      templ = Undies::Template.new do
-        element(:div).thing1! { _ "stuff" }
-      end
-      assert_equal "<div id=\"thing1\">stuff</div>", templ.to_s
+      }, subject.thing1!.instance_variable_get("@attrs"))
     end
 
     should "proxy id attr with last method call ending in '!'" do
       assert_equal({
         :id => 'thing2'
-      }, subject.thing1!.thing2!.___attrs)
+      }, subject.thing1!.thing2!.instance_variable_get("@attrs"))
     end
 
     should "set id attr to explicit if called last " do
       assert_equal({
         :id => 'thing3'
-      }, subject.thing1!.thing2!(:id => 'thing3').___attrs)
+      }, subject.thing1!.thing2!(:id => 'thing3').instance_variable_get("@attrs"))
     end
 
     should "set id attr to proxy if called last" do
       assert_equal({
         :id => 'thing1'
-      }, subject.thing2!(:id => 'thing3').thing1!.___attrs)
+      }, subject.thing2!(:id => 'thing3').thing1!.instance_variable_get("@attrs"))
     end
 
     should "respond to any other method as a class proxy" do
@@ -154,32 +92,25 @@ class Undies::Element
     should "proxy single html class attr" do
       assert_equal({
         :class => 'thing'
-      }, subject.thing.___attrs)
-    end
-
-    should "nest elements from proxy class call" do
-      templ = Undies::Template.new do
-        element(:div).thing { _ "stuff" }
-      end
-      assert_equal "<div class=\"thing\">stuff</div>", templ.to_s
+      }, subject.thing.instance_variable_get("@attrs"))
     end
 
     should "proxy multi html class attrs" do
       assert_equal({
         :class => 'list thing awesome'
-      }, subject.list.thing.awesome.___attrs)
+      }, subject.list.thing.awesome.instance_variable_get("@attrs"))
     end
 
     should "set class attr with explicit if called last " do
       assert_equal({
         :class => 'list'
-      }, subject.thing.awesome(:class => "list").___attrs)
+      }, subject.thing.awesome(:class => "list").instance_variable_get("@attrs"))
     end
 
     should "update class attr with proxy if called last" do
       assert_equal({
         :class => 'list is good'
-      }, subject.thing.awesome(:class => "list is").good.___attrs)
+      }, subject.thing.awesome(:class => "list is").good.instance_variable_get("@attrs"))
     end
 
     should "proxy mixed class and id selector attrs" do
@@ -189,11 +120,87 @@ class Undies::Element
       }, subject.thing1!.awesome({
         :class => "list is",
         :id => "thing2"
-      }).good.thing3!.___attrs)
+      }).good.thing3!.instance_variable_get("@attrs"))
+    end
+
+    should "not proxy if private methods are called" do
+      assert_equal "<div />", subject.send(:start_tag)
+      assert_equal nil, subject.send(:end_tag)
     end
 
   end
 
+  class SerializeTests < BasicTests
+    before do
+      @output = Undies::Output.new(StringIO.new(@out = ""))
+    end
+
+    should "serialize with no child elements" do
+      src = Undies::Source.new do
+        element(:br)
+      end
+      templ = Undies::Template.new(src, {}, @output)
+      assert_equal "<br />", @out
+    end
+
+    should "serialize with attrs" do
+      src = Undies::Source.new do
+        element(:br, :class => 'big')
+      end
+      templ = Undies::Template.new(src, {}, @output)
+      assert_equal '<br class="big" />', @out
+    end
 
+    should "serialize with attrs and content" do
+      src = Undies::Source.new do
+        element(:strong, {:class => 'big'}) { __ "Loud Noises!" }
+      end
+      templ = Undies::Template.new(src, {}, @output)
+      assert_equal '<strong class="big">Loud Noises!</strong>', @out
+    end
+
+    should "serialize element proxy id call" do
+      src = Undies::Source.new do
+        element(:div).thing1! { _ "stuff" }
+      end
+      templ = Undies::Template.new(src, {}, @output)
+      assert_equal "<div id=\"thing1\">stuff</div>", @out
+    end
+
+    should "serialize element proxy class call" do
+      src = Undies::Source.new do
+        element(:div).thing { _ "stuff" }
+      end
+      templ = Undies::Template.new(src, {}, @output)
+      assert_equal "<div class=\"thing\">stuff</div>", @out
+    end
+
+    should "serialize content from separate content blocks" do
+      src = Undies::Source.new do
+        element(:div){ _ "stuff" }.thing1!{ _ " and more stuff" }
+      end
+      templ = Undies::Template.new(src, {}, @output)
+      assert_equal "<div id=\"thing1\">stuff and more stuff</div>", @out
+    end
+
+    should "serialize nested elements with pp" do
+      output = Undies::Output.new(StringIO.new(@out = ""), :pp => 4)
+      src = Undies::Source.new do
+        element(:div) {
+          element(:span) { _ "Content!" }
+          __ "Raw"
+          element(:span) { _ "More content" }
+        }
+      end
+      templ = Undies::Template.new(src, {}, output)
+      assert_equal "
+<div>
+    <span>Content!</span>
+    Raw
+    <span>More content</span>
+</div>", @out
+    end
+
+  end
 
 end

data/test/helper.rb

@@ -1,2 +1,4 @@
-# this file is automatically required in when you require 'test_belt'
-# put test helpers here
+# this file is automatically required in when you require 'assert' in your tests
+
+# add root dir to the load path
+$LOAD_PATH.unshift(File.expand_path("../..", __FILE__))

data/test/irb.rb

@@ -1,10 +1,9 @@
-require 'test_belt'
+require 'assert/setup'
 
 # this file is required in when the 'irb' rake test is run.
-# b/c 'test_belt' is required above, lib and test dirs will
-# be added to the LOAD_PATH and the test helper will be
+# b/c 'assert' is required above, the test helper will be
 # required in.
 
 # put any IRB setup code here
 
-require 'undies'
+require 'undies'