RubyGems - undies - Versions diffs - 3.0.0.rc.3 → 3.0.0 - Mend

undies 3.0.0.rc.3 → 3.0.0

Files changed (37) hide show

data/.gitignore +17 -3
data/Gemfile +7 -4
data/{LICENSE → LICENSE.txt} +0 -0
data/README.md +107 -105
data/Rakefile +1 -8
data/lib/undies/api.rb +2 -1
data/lib/undies/element.rb +43 -81
data/lib/undies/element_node.rb +6 -5
data/lib/undies/io.rb +0 -1
data/lib/undies/raw.rb +15 -0
data/lib/undies/source.rb +0 -8
data/lib/undies/version.rb +1 -1
data/lib/undies.rb +4 -2
data/test/helper.rb +5 -85
data/test/support/element.rb +79 -0
data/test/{templates → support/templates}/content.html.rb +0 -0
data/test/{templates → support/templates}/index.html.rb +0 -0
data/test/{templates → support/templates}/layout.html.rb +0 -0
data/test/{templates → support/templates}/test.html.rb +0 -0
data/test/{element_closed_test.rb → unit/element_closed_tests.rb} +2 -6
data/test/{element_node_test.rb → unit/element_node_tests.rb} +5 -11
data/test/{element_open_test.rb → unit/element_open_tests.rb} +2 -5
data/test/{element_test.rb → unit/element_tests.rb} +1 -2
data/test/{io_test.rb → unit/io_tests.rb} +3 -8
data/test/{named_source_test.rb → unit/named_source_tests.rb} +4 -5
data/test/{raw_test.rb → unit/raw_tests.rb} +6 -5
data/test/{root_node_test.rb → unit/root_node_tests.rb} +4 -3
data/test/{source_stack_test.rb → unit/source_stack_tests.rb} +2 -3
data/test/{source_test.rb → unit/source_tests.rb} +5 -6
data/test/{template_builder_render_test.rb → unit/template_builder_render_tests.rb} +3 -0
data/test/{template_source_render_test.rb → unit/template_source_render_tests.rb} +5 -10
data/test/{template_test.rb → unit/template_tests.rb} +12 -30
data/undies.gemspec +16 -18
metadata +58 -111
data/Gemfile.lock +0 -48
data/test/fixtures/write_thing.rb +0 -21
data/test/irb.rb +0 -9

data/.gitignore CHANGED Viewed

@@ -1,7 +1,21 @@
-pkg/*
-.bundle
 *.gem
 *.log
-.rvmrc
+*.rbc
+.rbx/
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
 bench/*.txt

data/Gemfile CHANGED Viewed

@@ -1,12 +1,15 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
-# Specify dependencies in undies.gemspec
 gemspec
-gem 'rake', '~>0.9.2'
+gem 'rake'
+gem 'pry'
 gem 'ruby-prof'
+gem 'whysoslow'
+gem 'ansi'
 gem 'erubis'
 gem 'haml'
 gem 'markaby'
 gem 'erector'
-gem 'ansi'

data/{LICENSE → LICENSE.txt} RENAMED Viewed

File without changes

data/README.md CHANGED Viewed

@@ -18,47 +18,49 @@ Or install it yourself as:
 ## Usage
 ```ruby
+_ raw "<!DOCTYPE html>"
 _html {
   _head {
     _title "Hello World"
   }
   body {
     _h1.main!.big "Hi There!"
-    _p "this is an ", em("Undies"), " usage example."
+    _p "this is a hello world & ", em("Undies"), " usage example."
   }
 }
 ```
 Will stream out
-```
+``` html
+<!DOCTYPE html>
 <html>
   <head>
     <title>Hello World</title>
   </head>
   <body>
     <h1 class="big" id="main">Hi There!</h1>
-    <p>this is an <em>Undies</em> usage example.</p>
+    <p>this is a hello world &amp; <em>Undies</em> usage example.</p>
   </body>
 </html>
 ```
-## DSL
+## Captured Output
 ### Plain text
 All text is escaped by default.
 ```ruby
-    Undies::Template.escape_html("ab&<>'\"/yz")
-    # => "ab&amp;&lt;&gt;&#x27;&quot;&#x2F;yz"
+Undies::Template.escape_html("ab&<>'\"/yz")
+# => "ab&amp;&lt;&gt;&#x27;&quot;&#x2F;yz"
 ```
 Capture raw (un-escaped) text using the `raw` method
 ```ruby
-    raw "this will <em>not</em> be escaped"
-    # => "this will <em>not</em> be escaped"
+raw "this will <em>not</em> be escaped"
+# => "this will <em>not</em> be escaped"
 ```
 ### XML
@@ -66,48 +68,48 @@ Capture raw (un-escaped) text using the `raw` method
 Capture an empty element:
 ```ruby
-    element(:thing) # => "<thing />"
-    tag('ns:thing') # => "<ns:thing />"
+element(:thing) # => "<thing />"
+# use `tag` as an alias to `element`
+tag('ns:thing') # => "<ns:thing />"
 ```
 Capture an element with content:
 ```ruby
-    # basic content
-    element(:thing, "some content")
-    # => "<thing>some content</thing>"
-    # all content is escaped by default
+# basic content
-    element(:thing, "&<>")
-    # => "<thing>&amp;&lt;&gt;</thing>"
+element(:thing, "some content")
+# => "<thing>some content</thing>"
-    # you can force raw content using the `raw` method
+# all content is escaped by default
+element(:thing, "&<>")
+# => "<thing>&amp;&lt;&gt;</thing>"
-    element(:thing, raw("<raw>text</raw>"))
-    # => "<thing><raw>text</raw></thing>"
+# you can force raw content using the `raw` method
+element(:thing, raw("<raw>text</raw>"))
+# => "<thing><raw>text</raw></thing>"
-    # you can pass in as many pieces of content as you like
-    element(:thing, "1 < 2", raw("<raw>text</raw>"), " & 4 > 3")
-    # => "<thing>1 &lt; 2<raw>text</raw>&amp; 4 &gt; 3</thing>"
+# you can pass in as many pieces of content as you like
+element(:thing, "1 < 2", raw("<raw>text</raw>"), " & 4 > 3")
+# => "<thing>1 &lt; 2<raw>text</raw>&amp; 4 &gt; 3</thing>"
 ```
 Capture an element with attributes:
 ```ruby
-    element(:thing, "some content", :one => 1, 'a' => "Aye")
-    # => "<thing one=\"1\" a=\"Aye\">some content</thing>"
+element(:thing, "some content", :one => 1, 'a' => "Aye")
+# => "<thing one=\"1\" a=\"Aye\">some content</thing>"
 ```
 Capture nested elements:
 ```ruby
-    element(:thing) {
-      element('Something', "Some Content")
-      element('AnotherThing', "more content")
-    } # => "<thing><Something>Some Content</Something><AnotherThing>more content</AnotherThing></thing>"
+element(
+  :thing,
+  element('Something', "Some Content"),
+  element('AnotherThing', "more content")
+) # => "<thing><Something>Some Content</Something><AnotherThing>more content</AnotherThing></thing>"
 ```
 ### HTML
@@ -115,54 +117,52 @@ Capture nested elements:
 In general, all the same stuff applies.  However, you can call specific methods for all non-deprecated elements from the HTML 4.0.1 spec.
 ```ruby
-    br
-    # => "<br />"
+br
+# => "<br />"
-    span "something"
-    # => "<span>something</span>"
+span "something"
+# => "<span>something</span>"
-    div "something", :style => "color: red"
-    # => "<div style=\"color: red\">somthing</div"
+div "something", :style => "color: red"
+# => "<div style=\"color: red\">somthing</div"
-    html {
-      head { title "Hello World" }
-      body {
-        h1 "Hi There!"
-      }
-    } # => "<html><head><title>Hello World</title></head><body<h1>Hi There!</h1></body></html>"
+html(
+  head(title("Hello World")),
+  body(h1("Hi There!"))
+) # => "<html><head><title>Hello World</title></head><body<h1>Hi There!</h1></body></html>"
 ```
-You can't mix content and nested elements.  If you specify content in the element arguments, any nested element blocks will be ignored
+You can't specify content blocks when capturing element output.  Any content blocks will be ignored.
 ```ruby
-    div("contents") {
-      span "more content"
-    }
-    # => "<div>contents</div>"
+div("contents") {
+  span "more content"
+}
+# => "<div>contents</div>"
 ```
 Use bang (!) method calls to set id attributes
 ```ruby
-    h1.header!
-    # => "<h1 id=\"header\" />"
+h1.header!
+# => "<h1 id=\"header\" />"
-    h1.header!.title!
-    # => "<h1 id=\"title\" />"
+h1.header!.title!
+# => "<h1 id=\"title\" />"
 ```
 Use general method calls to add class attributes
 ```ruby
-    _h1.header.awesome
-    # => "<h1 class=\"header awesome\" />"
+_h1.header.awesome
+# => "<h1 class=\"header awesome\" />"
 ```
 Use both in combination
 ```ruby
-    h1.header!.awesome
-    # => "<h1 class=\"awesome\" id=\"header\" />
+h1.header!.awesome
+# => "<h1 class=\"awesome\" id=\"header\" />
 ```
 ## Streamed Output
@@ -179,19 +179,19 @@ Stream plain text
 *note*: this is only valid at the root of the view.  to add plain text to an element, pass it in as an argument.  it will get streamed out as the element is streamed.
 ```ruby
-    _ "this will be escaped"
+_ "this will be escaped"
-    _ raw("this will not be escaped")
-    ```
+_ raw("this will not be escaped")
+```
 ### XML
 Stream xml element markup.  Call the element and tag methods with two leading underscores.
 ```ruby
-    __element(:thing)
+__element(:thing)
-    __tag('ns:thing')
+__tag('ns:thing')
 ```
 All other element handling is the same.
@@ -201,18 +201,18 @@ All other element handling is the same.
 Stream html markup.  Call the html element methods with a leading underscore.
 ```ruby
-    _br
+_br
-    _span "something"
+_span "something"
-    _div "something", :style => "color: red"
+_div "something", :style => "color: red"
-    _html {
-      _head { _title "Hello World" }
-      _body {
-        _h1 "Hi There!"
-      }
-    }
+_html {
+  _head { _title "Hello World" }
+  _body {
+    _h1 "Hi There!"
+  }
+}
 ```
 All other element handling is the same.
@@ -230,11 +230,13 @@ All other element handling is the same.
 To render using Undies, create a Template instance, providing the template source, data, and io information.
-    source = Undies::Source.new("/path/to/sourcefile")
-    data   = { :two_plus_two => 4 }
-    io     = Undies::IO.new(@some_io_stream)
+```ruby
+source = Undies::Source.new("/path/to/sourcefile")
+data   = { :two_plus_two => 4 }
+io     = Undies::IO.new(@some_io_stream)
-    Undies::Template.new(source, {}, io)
+Undies::Template.new(source, data, io)
+```
 ### Source
@@ -256,26 +258,26 @@ As said before, Undies streams to a given io stream.  You specify a Template's i
 file source, no local data, no pretty printing
 ```ruby
-    source = Undies::Source.new("/path/to/source")
-    Undies::Template.new(source, {}, Undies::IO.new(@io))
+source = Undies::Source.new("/path/to/source")
+Undies::Template.new(source, {}, Undies::IO.new(@io))
 ```
 proc source, simple local data, no pretty printing
 ```ruby
-    source = Undies::Source.new(Proc.new do
-      _div {
-        _ @content.to_s
-      }
-    end)
-    Undies::Template.new(source, {:content => "Some Content!!" }, Undies::IO.new(@io))
+source = Undies::Source.new(Proc.new do
+  _div {
+    _ @content.to_s
+  }
+end)
+Undies::Template.new(source, {:content => "Some Content!!" }, Undies::IO.new(@io))
 ```
 pretty printing (4 space tab indentation)
 ```ruby
-    source = Undies::Source.new("/path/to/source")
-    Undies::Template.new(source, {}, Undies::IO.new(@io, :pp => 4))
+source = Undies::Source.new("/path/to/source")
+Undies::Template.new(source, {}, Undies::IO.new(@io, :pp => 4))
 ```
 ### Builder approach
@@ -285,28 +287,28 @@ The above examples use the "source rendering" approach.  This works great when y
 To render using this approach, create a Template instance passing it data and io 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:
 ```ruby
-    # choosing not to use any local data in this example
-    template = Undies::Template.new(Undies::IO.new(@io))
+# choosing not to use any local data in this example
+template = Undies::Template.new(Undies::IO.new(@io))
 ```
 Now just interact with the Undies API directly.
 ```ruby
-    # 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
+# 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
-    template._div {
-      template._span "hi"
-    }
+template._div {
+  template._span "hi"
+}
 ```
 *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:
 ```ruby
-    # ensures all content is streamed to the template's io stream
-    # this is necessary when not using the source approach above
-    Undies::Template.flush(template)
+# ensures all content is streamed to the template's io stream
+# this is necessary when not using the source approach above
+Undies::Template.flush(template)
 ```
 ### Manual approach
@@ -316,20 +318,20 @@ There is another method you can use to render output: the manual approach.  Like
 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 methods to change the template scope.
 ```ruby
-    # this is the equivalent to the Builder approach example above
+# this is the equivalent to the Builder approach example above
-    template = Undies::Template.new(Undies::IO.new(@io))
+template = Undies::Template.new(Undies::IO.new(@io))
-    something = "Some Thing!"
-    template._div.something! something.to_s
+something = "Some Thing!"
+template._div.something! something.to_s
-    template._div
-    template.__push
-    template._span "hi"
-    template.__pop
+template._div
+template.__push
+template._span "hi"
+template.__pop
-    # alternate method for flushing a template
-    template.__flush
+# alternate method for flushing a template
+template.__flush
 ```
 *Note:* as with the Builder approach, you must flush the template when content processing is complete.

data/Rakefile CHANGED Viewed

@@ -1,10 +1,4 @@
-require 'assert/rake_tasks'
-Assert::RakeTasks.for(:test)
-require 'bundler'
-Bundler::GemHelper.install_tasks
-task :default => :build
+require "bundler/gem_tasks"
 namespace :bench do
@@ -34,4 +28,3 @@ end
 task :bench do
   Rake::Task['bench:run'].invoke
 end

data/lib/undies/api.rb CHANGED Viewed

@@ -1,5 +1,6 @@
 require 'undies/element_node'
 require 'undies/element'
+require 'undies/raw'
 module Undies
@@ -71,7 +72,7 @@ module Undies
     # streaming methods
-    # Add a text node (data escaped) to the nodes of the current node
+    # Add a text node (data escaped) to the current node
     def _(data="")
       @_undies_io.current.text(self.class.escape_html(data.to_s))
     end

data/lib/undies/element.rb CHANGED Viewed

@@ -1,49 +1,46 @@
-module Undies
-  module Element
-    def self.hash_attrs(attrs="", ns=nil)
-      return attrs.to_s if !attrs.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.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(ESCAPE_ATTRS_PATTERN){|c| ESCAPE_ATTRS[c] }
-    end
-    def self.open(*args, &build)
-      Open.new(*args, &build)
-    end
+require 'undies/raw'
+require 'undies/template'
+module Undies; end
+module Undies::Element
+  def self.hash_attrs(attrs="", ns=nil)
+    return attrs.to_s if !attrs.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.join
+  end
-    def self.closed(*args, &build)
-      Closed.new(*args, &build)
-    end
+  ESCAPE_ATTRS = {
+    "&" => "&amp;",
+    "<" => "&lt;",
+    '"' => "&quot;"
+  }
+  ESCAPE_ATTRS_PATTERN = Regexp.union(*ESCAPE_ATTRS.keys)
+  def self.escape_attr_value(value)
+    value.to_s.gsub(ESCAPE_ATTRS_PATTERN){|c| ESCAPE_ATTRS[c] }
+  end
+  def self.open(*args, &build)
+    Open.new(*args, &build)
   end
+  def self.closed(*args, &build)
+    Closed.new(*args, &build)
+  end
+  ## Utility Classes
   module CSSProxy
     ID_METH_REGEX = /^([^_].+)!$/
     CLASS_METH_REGEX = /^([^_].+)$/
@@ -66,45 +63,16 @@ module Undies
         super
       end
     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.  Used to circumvent
-    # the default html escaping of markup
-    def gsub(*args)
-      self
-    end
-    def gsub!(*args)
-      nil
-    end
-    def to_s
-      self
-    end
-  end
-  class Element::Open
+  class Open
     include CSSProxy
     include MergeAttrs
@@ -118,11 +86,11 @@ module Undies
     end
     def __start_tag
-      "<#{@name}#{Element.hash_attrs(@attrs)}>"
+      "<#{@name}#{Undies::Element.hash_attrs(@attrs)}>"
     end
     def __content
-      @content.collect{ |c| Template.escape_html(c) }.join
+      @content.collect{ |c| Undies::Template.escape_html(c) }.join
     end
     def __build
@@ -134,7 +102,7 @@ module Undies
     end
     def to_s
-      Raw.new("#{__start_tag}#{__content}#{__end_tag}")
+      Undies::Raw.new("#{__start_tag}#{__content}#{__end_tag}")
     end
     def ==(other)
@@ -163,12 +131,9 @@ module Undies
       self
     end
   end
-  class Element::Closed
+  class Closed
     include CSSProxy
     include MergeAttrs
@@ -179,7 +144,7 @@ module Undies
     end
     def __start_tag
-      "<#{@name}#{Element.hash_attrs(@attrs)} />"
+      "<#{@name}#{Undies::Element.hash_attrs(@attrs)} />"
     end
     # closed elements have no content
@@ -192,7 +157,7 @@ module Undies
     def __end_tag; ''; end
     def to_s
-      Raw.new("#{__start_tag}")
+      Undies::Raw.new("#{__start_tag}")
     end
     def ==(other)
@@ -214,9 +179,6 @@ module Undies
       @attrs.merge!(args.last || {})
       self
     end
   end
 end

data/lib/undies/element_node.rb CHANGED Viewed

@@ -4,11 +4,11 @@ module Undies
   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.
+    # ElemmentNode is 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.
@@ -113,4 +113,5 @@ module Undies
     end
   end
 end