jig 0.1.0

data/test/test_xhtml.rb

@@ -0,0 +1,26 @@
+require 'jig'
+require 'test/unit'
+require 'test/jig'
+
+class TestXML < Test::Unit::TestCase
+  XH = Jig::XHTML
+  include Asserts
+
+  def test_eid
+    @div = %r{<div id="[^"]*">\n</div>\n}
+    @input = %r{<input id="\w*"/>}
+    @jig_div_id = XH.div_with_id
+    @jig_input = XH.input!
+    assert_match(@div, @jig_div_id.to_s)
+    assert_raise(RuntimeError,'eid reassignment') { @jig_div_id.eid = "foo" }
+    assert_match(@input, XH.input.to_s)
+    assert_not_equal(XH.li_with_id.to_s, XH.li_with_id.to_s)
+  end
+
+  def test_element_with_id
+    j = XH.element_with_id(:a, :href => "foo")
+    id, href = %Q{id="#{j.eid}"}, 'href="foo"'
+    assert_match(%r{<a (#{id} #{href}|#{href} #{id})></a>\n}, j.to_s)
+  end
+
+end

data/test/test_xml.rb

@@ -0,0 +1,148 @@
+require 'jig'
+require 'test/unit'
+require 'test/jig'
+
+class TestXML < Test::Unit::TestCase
+  X = Jig::XML
+  include Asserts
+  def setup
+    @div = X.element('div')
+    @gaps = [:___]
+  end
+
+  def test_comment
+    assert_as_string("<!--  -->\n", X.comment)
+    assert_equal(@gaps, X.comment.gaps)
+    assert_as_string("<!-- comment -->\n", X.comment('comment'))
+  end
+
+  def test_xml
+    assert_as_string(%Q{<?xml version="1.0" ?>\n}, X.xml)
+    v,e = %Q{version="1.0"}, %Q{encoding="UTF-8"}
+    assert_as_string(%Q{<?xml #{e} #{v} ?>\n}, X.xml(:encoding => "UTF-8"))
+  end
+
+  def test_hash
+    # Hash is OK
+    assert_nothing_raised(ArgumentError) {X.new('a' => 'b')}
+    assert_nothing_raised(ArgumentError) {X.new("a", 'c'=>'d')}
+
+    # Hash checks
+    assert_equal(%Q{ a="b"}, X.new('a' => 'b').to_s, 'create from Hash')
+    assert_equal(%Q{ a="b" c="d"}, X.new('a' => 'b', 'c' => 'd').to_s, 'create from Hash, 2 items')
+    assert_equal(%Q{ a="b"}, X.new(Jig::GAP, 'a' => 'b').to_s, 'hash and gap')
+    assert_equal("", X.new('a' => Jig::GAP).to_s, 'attribute suppression')
+
+    assert_nothing_raised(ArgumentError, 'hash OK with #new') { X.new(:div, "first", {'a' => 'b'}, "third") }
+    assert_equal(%Q{first a="b"third}, X.new(:div, "first", {'a' => 'b'}, "third").to_s)
+  end
+
+  def test_plug_hash
+    # plugging hashs
+    assert_equal(%Q{ a="b"}, X.new('a' => :alpha).plug(:alpha, "b").to_s, 'plugging an attribute')
+    assert_equal(%Q{ a="b"}, X.new('a' => :alpha).plug(:alpha, lambda { "b" }).to_s, 'plugging an attribute with a proc')
+    assert_equal(%Q{}, X.new('a' => :alpha).plug(:alpha, lambda { nil }).to_s, 'plugging an attribute with a proc returning nil')
+    assert_equal(%Q{}, X.new({'a',Jig::GAP}).plug(lambda { nil }).to_s, 'plugging an attribute with a proc returning nil')
+  end
+
+  def test_element
+    # element construction
+    @div = "<div>\n</div>\n"
+    assert_equal(@div, X.element.to_s, 'default element as "div"')
+
+    assert_equal(@div, X.element(:div).to_s)
+    assert_equal(@div, X.element(:div, Jig::GAP).to_s)
+    assert_equal(@div, X.element(:div, Jig::GAP).to_s)
+    assert_equal(@div, X.element(:div, X.new).to_s)
+
+    @div2 = "<div>\ninside</div>\n"
+    assert_equal(@div2, X.element(:div, "inside").to_s)
+    assert_equal(@div2, X.element(:div, "in", "side").to_s)
+
+    # element with attributes
+    @div_empty = "<div>\n</div>\n"
+    @div_1attr= %Q{<div a="b">\n</div>\n}
+    @div_1attrfilled= %Q{<div a="b">\ninside</div>\n}
+    @div_1attrfilled2= %Q{<div a="b">\ninsidealso</div>\n}
+    assert_not_equal(@div_empty, X.element(:div, 'a' => 'b').to_s)
+    assert_equal(@div_1attr, X.element(:div, 'a' => 'b').to_s)
+    assert_equal(@div_1attrfilled, X.element(:div, 'inside', {'a' => 'b'}).to_s)
+    assert_equal(@div_1attrfilled, X.element(:div, {'a' => 'b'}) { "inside" }.to_s)
+    assert_equal(@div_1attrfilled, X.element(:div, lambda { "inside" }, {'a' => 'b'} ).to_s)
+    assert_equal(@div_1attrfilled2, (X.element(:div, lambda { "inside" }, {'a' => 'b'} ) { "also" }).to_s)
+
+    #assert_raise(ArgumentError, 'hash only as first argument') { X.element(:div, "first", {'a' => 'b'}, "third") }
+  end
+
+  def test_method_missing
+    assert_equal(X.div, X.element(:div))
+    assert_equal(X.div(Jig::GAP), X.element(:div, Jig::GAP))
+    assert_equal(X.div(Jig::GAP), X.element(:div, Jig::GAP))
+    assert_equal(X.div(X.new), X.element(:div, X.new))
+
+    assert_equal(X.div_, X.div)
+
+    @div2 = "<div>\ninside</div>\n"
+    assert_equal(@div2, X.element(:div, "inside").to_s)
+    assert_equal(@div2, X.element(:div, "in", "side").to_s)
+
+    # element with block
+    assert_equal(@div2, (X.element(:div) {"inside"}).to_s)
+
+    assert_equal(@div2, X.div("inside").to_s)
+    assert_equal(@div2, X.div("in", "side").to_s)
+
+    # div with attributes
+    @div_empty = "<div>\n</div>\n"
+    @div_1attr= %Q{<div a="b">\n</div>\n}
+    @div_1attrfilled= %Q{<div a="b">\ninside</div>\n}
+    @div_1attrfilled2= %Q{<div a="b">\ninsidealso</div>\n}
+    assert_not_equal(@div_empty, X.div( 'a' => 'b').to_s)
+    assert_equal(@div_1attr, X.div( 'a' => 'b').to_s)
+    assert_equal(@div_1attrfilled, X.div( "inside", {'a' => 'b'} ).to_s)
+    assert_equal(@div_1attrfilled, X.div( {'a' => 'b'}) { "inside" }.to_s)
+    assert_equal(@div_1attrfilled, X.div(lambda { "inside" }, {'a' => 'b'} ).to_s)
+    assert_equal(@div_1attrfilled2, (X.div(lambda { "inside" },  {'a' => 'b'}) { "also" }).to_s)
+  end
+
+  def test_more_plugging
+    @div = "<div>\nabc</div>\n"
+    @jdiv = X.new("<div>\nabc</div>\n")
+    assert_equal(@div, @jdiv.to_s)
+    assert_match(@jdiv, X.div << "abc")
+    assert_match(@jdiv, X.div("abc"))
+    assert_match(@jdiv, X.div { "abc" })
+
+    @divp = "<div>\n<p>\n</p>\n</div>\n"
+    @pdiv = "<p>\n<div>\n</div>\n</p>\n"
+    @jdivp = X.new("<div>\n<p>\n</p>\n</div>\n")
+    @jpdiv = X.new("<p>\n<div>\n</div>\n</p>\n")
+    assert_equal(@divp, @jdivp.to_s)
+    assert_equal(@pdiv, @jpdiv.to_s)
+    assert_as_string(@jdivp, (X.div << X.p))
+    assert_as_string(@jpdiv, X.p << X.div)
+
+    @full = %Q{<div a="b">\ninside</div>\n}
+    @full_jig = X.new(%Q{<div a="b">\ninside</div>\n})
+    assert_equal(@full, @full_jig.to_s)
+    assert_match(@full_jig, X.div('a' => 'b') { "inside" })
+    assert_match(@full_jig, X.div("inside", {'a' => 'b'}))
+  end
+
+
+  def test_misc
+    #assert_raise(ArgumentError, 'attribute must be string') { X.div('a' => :gap) << X.p }
+    #assert_raise(ArgumentError) { ((X.div('a' => Jig::GAP) << X.p).to_s) }
+
+    assert_equal( "ab", (X.new(:alpha, :beta) << {:alpha => 'a', :beta => 'b'}).to_s)
+    assert_equal( "<div>\n</div>\n", (X.div).to_s)
+    assert_not_equal( "ab", X.div.plug("ab").to_s)
+    assert_equal( "<div>\nab</div>\n", X.div.plug("ab").to_s)
+
+    #assert_equal( %Q{<div a="b">ab</div>\n}, X.div("a" => "b").to_s)
+    assert_equal( %Q{<div a="b">\nfoo</div>\n}, X.div("a" => "b").plug("foo").to_s)
+
+    # test plug nil
+    # test plug with Hash
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: jig
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-05-17 00:00:00 -07:00
+summary: a data structure that supports construction and manipulation of strings with hierarchical structure
+require_paths: 
+- lib
+email: gwright@rubyforge.org
+homepage: http://jig.rubyforge.org
+rubyforge_project: jig
+description: "A jig is a data structure designed to facilitate construction and manipulation of strings with an inherent hierarchical syntax.  The idea is derived from the <bigwig> project (http://www.brics.dk/bigwig/) and in particular the XML templating constructs described in the paper: A Type System for Dynamic Web Documents (http://www.brics.dk/bigwig/publications/dyndoc.pdf).  The name is derived from woodworking where a jig is a template designed to guide other tools.  A jig is an ordered sequence of objects (usually strings) and named _gaps_.  When rendered as a string by Jig#to_s, the objects are rendered by calling #to_s on each object in order. The gaps are skipped.  A new jig may be constructed from an existing jig by 'plugging' one or more of the named gaps.  The new jig shares the objects and their ordering from the original jig but with the named gap replaced with the 'plug'.  Gaps may be plugged by any object or sequence of objects.  When a gap is plugged with another jig, the contents (including gaps) are incorporated into the new jig.  In addition to strings and gaps, a Jig may contain a proc object (or lambda or method). Procs within a jig are not evaluated until  the jig is rendered as a string by #to_s."
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Gary Wright
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/jig.rb
+- lib/jig/css.rb
+- lib/jig/xhtml.rb
+- lib/jig/xml.rb
+- test/test_css.rb
+- test/test_jig.rb
+- test/test_xhtml.rb
+- test/test_xml.rb
+test_files: 
+- test/test_css.rb
+- test/test_jig.rb
+- test/test_xhtml.rb
+- test/test_xml.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: