RubyGems - undies - Versions diffs - 2.2.1 → 3.0.0.rc.1 - Mend

undies 2.2.1 → 3.0.0.rc.1

Files changed (54) hide show

data/ARCH.md +116 -0
data/Gemfile +3 -0
data/Gemfile.lock +20 -4
data/LICENSE +22 -0
data/README.md +343 -0
data/Rakefile +25 -17
data/bench/bench_runner.rb +132 -12
data/bench/large.html.erb +9 -13
data/bench/large.html.haml +11 -0
data/bench/large.html.rb +8 -12
data/bench/profiler +1 -1
data/bench/profiler_runner.rb +2 -5
data/bench/small.html.erb +9 -13
data/bench/small.html.haml +11 -0
data/bench/small.html.rb +8 -12
data/bench/verylarge.html.erb +9 -13
data/bench/verylarge.html.haml +11 -0
data/bench/verylarge.html.rb +8 -12
data/lib/undies/api.rb +163 -0
data/lib/undies/element.rb +160 -80
data/lib/undies/element_node.rb +116 -0
data/lib/undies/io.rb +43 -0
data/lib/undies/root_node.rb +62 -0
data/lib/undies/source.rb +78 -2
data/lib/undies/template.rb +17 -131
data/lib/undies/version.rb +1 -1
data/lib/undies.rb +3 -2
data/test/element_closed_test.rb +69 -0
data/test/element_node_test.rb +274 -0
data/test/element_open_test.rb +101 -0
data/test/element_test.rb +23 -196
data/test/fixtures/write_thing.rb +4 -4
data/test/helper.rb +84 -0
data/test/io_test.rb +104 -0
data/test/named_source_test.rb +1 -1
data/test/raw_test.rb +25 -0
data/test/root_node_test.rb +108 -0
data/test/source_stack_test.rb +1 -1
data/test/template_builder_render_test.rb +4 -9
data/test/template_source_render_test.rb +16 -20
data/test/template_test.rb +87 -80
data/test/templates/content.html.rb +1 -1
data/test/templates/test.html.rb +1 -1
data/undies.gemspec +1 -0
metadata +52 -23
data/README.rdoc +0 -203
data/lib/undies/named_source.rb +0 -54
data/lib/undies/node.rb +0 -87
data/lib/undies/node_stack.rb +0 -111
data/lib/undies/output.rb +0 -31
data/lib/undies/source_stack.rb +0 -22
data/test/node_stack_test.rb +0 -109
data/test/node_test.rb +0 -91
data/test/output_test.rb +0 -69

data/README.rdoc DELETED Viewed

@@ -1,203 +0,0 @@
-= Undies
-A pure-Ruby DSL for streaming templated HTML, XML, or plain text.  Named for its gratuitous use of the underscore.
-== Installation
-    $ gem install undies
-== DSL
-Undies uses an underscore-based DSL for rendering content.  It can render plain text, html-escaped text, xml, and html.
-=== Plain text
-Escaped (xml / html) text:
-    _ "this will be escaped & streamed"
-    # => "this will be escaped &amp; streamed"
-Raw (un-escaped) text:
-    __ "this will <em>not</em> be escaped"
-    # => "this will <em>not</em> be escaped"
-=== XML
-Empty node:
-    _thing # => "<thing />"
-Node with content:
-    _thing {
-      _ "Some Content"
-      _ "More Content "
-    } # => "<thing>Some ContentMore Content</thing>"
-Node with attributes:
-    _thing(:one => 1, 'a' => "Aye")
-    # => "<thing one=\"1\" a=\"Aye\" />"
-Nested nodes:
-    _thing {
-      _Something {
-        _ "Some Content"
-      }
-    } # => "<thing><Something>Some Content</Something></thing>"
-Namespaces / Doctype stuff:
-    __ "<?xml version="1.0" encoding="UTF-8"?>"
-    _thing('xmlns:ss="urn:some-cool-namespace"') {
-        send("_ss:Value", {'ss:some_attr' => "some attr value"}) {
-            _ "Some Content"
-        }
-    } # => "<thing xmlns:ss=\"urn:some-cool-namespace\"><ss:Value ss:some_attr=\"some attr value\">Some Content</ss:Value>"
-Comments:
-    __ "<!-- some comment -->"
-    # => "<!-- some comment -->"
-=== HTML
-Same stuff applies:
-    __ "<!DOCTYPE html>"
-    _div(:style => "border-top: 1px") {
-      _h1 { _ "Hello World" }
-      _p  { _ "blah blah"   }
-    } # => "<div style=\"border-top: 1px\"><h1>Hello World</h1><p>blah blah</p></div>"
-id attribute helper:
-    _h1.header!
-    # => "<h1 id=\"header\" />"
-    _h1.header!.title!
-    # => "<h1 id=\"title\" />"
-class attributes helper:
-    _h1.header.awesome
-    # => "<h1 class=\"header awesome\" />"
-use in combo:
-    _h1.header!.awesome
-    # => "<h1 class=\"awesome\" id=\"header\" />
-== Streamed Output
-Undies works by streaming content defined by using its DSL to a given output stream.  Any call to Template#_, Template#__, or Tempate#_<node> will stream its output (or you can write helpers you mix in that use these base api methods).  This has a number of advantages:
-* content is written out immediately
-* maintain a relatively low memory profile while rendering
-* can process large templates with linear performance impact
-However, because content is streamed then forgotten as it is being rendered, Undies templates cannot be self-referrential.  No one element may refer to other previously rendered elements.
-== Rendering
-To render using Undies, create a Template instance, providing the template source, data, and output information.
-    source = Undies::Source.new("/path/to/sourcefile")
-    data = { :two_plus_two => 4 }
-    output = Undies::Output.new(@some_io_stream)
-    Undies::Template.new(source, {}, output)
-=== Source
-You specify Undies source using the Undies::Source object.  You can create source either form a block or a file.  Source content (either block or file) will be evaluated in context of the template.
-=== Data
-Undies renders source content in isolated scope (the context of the template).  This means that content has access to only the data it is given or the Undies API itself.  When you define a template for rendering, you provide not only the template source, but any data that source should be rendered with.  Data is given in the form of a Hash.  The string form of the hash keys are exposed as local methods that return their corresponding values.
-=== Output
-As said before, Undies streams to a given output stream.  You specify a Template's output by creating an Undies::Output object.  These objects take an io stream and a hash of options:
-* :pp (pretty-print) : set to a Fixnum to tab-space indent pretty print the output.
-=== Examples
-    # file source, no local data, no pretty printing
-    source = Undies::Source.new("/path/to/source")
-    Undies::Template.new(source, {}, Undies::Output.new(@io))
-    # proc source, simple local data, no pretty printing
-    source = Undies::Source.new(Proc.new do
-      _div {
-        _ content.to_s
-      }
-    end)
-    Undies::Template.new(source, {:content => "Some Content!!" }, Undies::Output.new(@io))
-    # pretty printing (4 space tab indentation)
-    source = Undies::Source.new("/path/to/source")
-    Undies::Template.new(source, {}, Undies::Output.new(@io, :pp => 4))
-=== Builder approach
-The above examples use the "source rendering" approach.  This works great when you know your source content before render time and create a source object from it (ie rendering a view template).  However, in some cases, you may not know the source until render time and/or want to use a more declarative style to specify render output.  Undies content can be specified programmatically using the "builder rendering" approach.
-To render using this approach, create a Template instance passing it data and output info as above.  However, don't pass in any source info, only pass in any local data if you like, and save off the created template:
-    # choosing not to use any local data in this example
-    template = Undies::Template.new(Undies::Output.new(@io))
-Now just interact with the Undies API directly.
-    # notice that it becomes less important to bind any local data to the Template using this approach
-    something = "Some Thing!"
-    template._div.something! {
-      template._ something.to_s
-    }
-*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 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
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.

data/lib/undies/named_source.rb DELETED Viewed

@@ -1,54 +0,0 @@
-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 DELETED Viewed

@@ -1,87 +0,0 @@
-module Undies
-  class Node
-    # 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") || ""
-    end
-    def self.mode(node)
-      node.instance_variable_get("@mode") || :inline
-    end
-    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, mode=:inline)
-      @start_tag = nil
-      @end_tag = nil
-      @content = content
-      @builds = []
-      @attrs = {}
-      @children = false
-      @mode = mode
-    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
-end

data/lib/undies/node_stack.rb DELETED Viewed

@@ -1,111 +0,0 @@
-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 DELETED Viewed

@@ -1,31 +0,0 @@
-module Undies
-  class Output
-    # the output class wraps an IO stream, gathers pretty printing options,
-    # 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
-    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] || 0
-      @pp_level = opts[:pp_level] || 0
-    end
-    def write(node, meth, level)
-      @io << node.class.prefix(node, meth, level+@pp_level, @pp)
-      @io << node.class.send(meth, node)
-    end
-  end
-end

data/lib/undies/source_stack.rb DELETED Viewed

@@ -1,22 +0,0 @@
-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/test/node_stack_test.rb DELETED Viewed

@@ -1,109 +0,0 @@
-require 'assert'
-require 'undies/node'
-require 'undies/element'
-require 'test/fixtures/write_thing'
-require 'undies/node_stack'
-module Undies
-  class NodeStackTests < Assert::Context
-    desc "a NodeStack"
-    before do
-      @hello = Node.new "hello"
-      @something = Node.new "something else"
-      @hi  = Node.new("hi")
-      @br  = Element.new :br
-      @div = Element.new(:div) {}
-      @outstream = StringIO.new(@out = "")
-      @stream_test_output = Output.new(@outstream)
-      @ns = NodeStack.new @stream_test_output
-    end
-    subject { @ns }
-    should have_class_method :create
-    should have_readers :stack, :cached_node, :output
-    should have_instance_methods :current, :size, :level, :empty?, :first, :last
-    should have_instance_methods :push, :pop, :node, :flush
-    should have_instance_methods :clear_cached
-    should "be empty by default" do
-      assert_empty subject
-    end
-    should "have an empty cache by default" do
-      assert_nil subject.cached_node
-    end
-  end
-  class StackTests < NodeStackTests
-    should "push nodes onto the stack" do
-      assert_nothing_raised do
-        subject.push(@hello)
-        subject.push(@something)
-      end
-      assert_equal 2, subject.size
-    end
-    should "know its level (should be one less than the array's size)" do
-      assert_equal 0, subject.level
-      subject.push(@hello)
-      assert_equal 1, subject.level
-    end
-    should "fetch the last item in the array with the current method" do
-      subject.push(@hello)
-      subject.push(@something)
-      assert_same @something, subject.current
-    end
-    should "remove the last item in the array with the pop method" do
-      subject.push(@hello)
-      subject.push(@something)
-      assert_equal 2, subject.size
-      node = subject.pop
-      assert_same @something, node
-      assert_equal 1, subject.size
-    end
-  end
-  class CacheTests < NodeStackTests
-    should "add nodes to its cache using the #node method" do
-      subject.node(@hi)
-      assert_equal @hi, subject.cached_node
-    end
-    should "push the current cached node onto the stack when caching a new node" do
-      subject.node(@br)
-      assert_equal @br, subject.cached_node
-      assert_equal 0, subject.size
-      subject.node(@div)
-      assert_equal @div, subject.cached_node
-    end
-    should "call the node's builds when flushed from cache" do
-      build = "build"
-      subject.node(Element.new(:div) { build += " called" })
-      subject.flush
-      assert_equal "build called", build
-    end
-  end
-end