RubyGems - ahoward-tagz - Versions diffs - 5.1.0 - Mend

ahoward-tagz 5.1.0

Files changed (16) hide show

data/samples/a.rb ADDED Viewed

@@ -0,0 +1,15 @@
+#
+# in the simplest case tagz generates html using a syntax which safely mixes
+# in to any object
+#
+require 'tagz'
+include Tagz.globally
+class GiraffeModel
+  def link
+    a_(:href => "/giraffe/neck/42"){ "whack!" }
+  end
+end
+puts GiraffeModel.new.link

data/samples/b.rb ADDED Viewed

@@ -0,0 +1,36 @@
+#
+# tagz.rb mixes quite easily with your favourite templating engine, avoiding
+# the need for '<% rows.each do |row| %> ... <% row.each do |cell| %> '
+# madness and other types of logic to be coded in the templating language,
+# leaving templating to template engines and logic and looping to ruby -
+# unencumbered by extra funky syntax.  in rails tagz will automatically be
+# available in your erb templates.
+#
+require 'tagz'
+include Tagz.globally
+require 'erb'
+rows = %w( a b c ), %w( 1 2 3 )
+template = ERB.new <<-ERB
+  <html>
+    <body>
+      <%=
+        table_{
+          rows.each do |row|
+            tr_{
+              row.each do |cell|
+                td_{ cell }
+              end
+            }
+          end
+        }
+      %>
+    </body>
+  </html>
+ERB
+puts template.result(binding)

data/samples/c.rb ADDED Viewed

@@ -0,0 +1,15 @@
+#
+# once you've learned to generate html using tagz you're primed to generate
+# xml too
+#
+require 'tagz'
+include Tagz.globally
+doc =
+  xml_{
+    giraffe_{ 'large' }
+    ninja_{ 'small' }
+  }
+puts doc

data/samples/d.rb ADDED Viewed

@@ -0,0 +1,28 @@
+#
+# tagz.rb doesn't cramp your style, allowing even invalid html to be
+# generated.  note the use of the 'tagz' method, which can be used both to
+# capture output and to append content to the top of the stack.
+#
+require 'tagz'
+include Tagz.globally
+def header
+  tagz{
+    html_
+      body_(:class => 'ninja-like', :id => 'giraffe-slayer')
+      __ "<!-- this is the header -->"
+  }
+end
+def footer
+  tagz{
+    __ "<!-- this is the footer -->"
+      _body
+    _html
+  }
+end
+puts header, footer

data/samples/e.rb ADDED Viewed

@@ -0,0 +1,21 @@
+#
+# tagz.rb allows a safer method of mixin which requires any tagz methods to be
+# insider a tagz block - tagz generating methods outside a tagz block with
+# raise an error if tagz is included this way.  also notice that the error is
+# reported from where it was raised - not from the bowels of the the tagz.rb
+# lib.
+#
+require 'tagz'
+include Tagz
+puts tagz{
+ html_{ 'works only in here' }
+}
+begin
+  html_{ 'not out here' }
+rescue Object => e
+  p :backtrace => e.backtrace
+end

data/samples/f.rb ADDED Viewed

@@ -0,0 +1,22 @@
+#
+# tagz.rb can generate really compact html.  this is great to save bandwidth
+# but can sometimes make reading the generated html a bit rough.  of course
+# using tidy or the dom inspector in firebug obviates the issue; nevertheless
+# it's sometime nice to break things up a little.  you can use 'tagz << "\n"'
+# or the special shorthand '__' or '___' to accomplish this
+#
+require 'tagz'
+include Tagz.globally
+html =
+  div_{
+    span_{ true }
+    __
+    span_{ false }  # hey ryan, i fixed this ;-)
+    ___
+    ___ 'foo & escaped bar'
+  }
+puts html

data/samples/g.rb ADDED Viewed

@@ -0,0 +1,19 @@
+# tagz gives you low-level control of the output and makes even dashersized
+# xml tagz easy enough to work with
+#
+require 'tagz'
+include Tagz.globally
+xml =
+  root_{
+    tagz__('foo-bar', :key => 'foo&bar'){ 'content' }
+    tagz__('bar-foo')
+    tagz.concat 'content'
+    tagz.concat tagz.escape('foo&bar')
+    __tagz('bar-foo')
+  }
+puts xml

data/tagz-5.1.0.gem ADDED Viewed

Binary file

data/tagz.gemspec ADDED Viewed

@@ -0,0 +1,25 @@
+  Gem::Specification::new do |spec|
+    spec.name = "tagz"
+    spec.version = "5.1.0"
+    spec.platform = Gem::Platform::RUBY
+    spec.summary = "tagz"
+    spec.files = ["gen_readme.rb", "install.rb", "lib", "lib/tagz.rb", "README", "README.tmpl", "samples", "samples/a.rb", "samples/b.rb", "samples/c.rb", "samples/d.rb", "samples/e.rb", "samples/f.rb", "samples/g.rb", "tagz-5.1.0.gem", "tagz.gemspec", "test", "test/tagz.rb"]
+    spec.executables = []
+    spec.require_path = "lib"
+    spec.has_rdoc = true
+    spec.test_files = "test/tagz.rb"
+    #spec.add_dependency 'lib', '>= version'
+    #spec.add_dependency 'fattr'
+    spec.extensions.push(*[])
+    spec.rubyforge_project = 'codeforpeople'
+    spec.author = "Ara T. Howard"
+    spec.email = "ara.t.howard@gmail.com"
+    spec.homepage = "http://github.com/ahoward/tagz/tree/master"
+  end

data/test/tagz.rb ADDED Viewed

@@ -0,0 +1,671 @@
+#! /usr/bin/env ruby
+require 'test/unit'
+$VERBOSE = 2
+STDOUT.sync = true
+$:.unshift 'lib'
+$:.unshift '../lib'
+$:.unshift '.'
+require 'tagz'
+class TagzTest < Test::Unit::TestCase
+  include Tagz
+  class ::String
+    Equal = instance_method '=='
+    remove_method '=='
+    def == other
+      Equal.bind(self.delete(' ')).call other.to_s.delete(' ')
+    end
+  end
+  def test_000
+    expected = '<foo  ></foo>'
+    actual = tagz{
+      foo_
+      _foo
+    }
+    assert_equal expected, actual
+  end
+  def test_010
+    expected = '<foo  ><bar  ></bar></foo>'
+    actual = tagz{
+      foo_
+        bar_
+        _bar
+      _foo
+    }
+    assert_equal expected, actual
+  end
+  def test_020
+    expected = '<foo  ><bar  /></foo>'
+    actual = tagz{
+      foo_
+        bar_{}
+      _foo
+    }
+    assert_equal expected, actual
+  end
+  def test_030
+    expected = '<foo  ><bar /></foo>'
+    actual = tagz{
+      foo_{
+        bar_{}
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_040
+    expected = '<foo  >bar</foo>'
+    actual = tagz{
+      foo_{ 'bar' }
+    }
+    assert_equal expected, actual
+  end
+  def test_050
+    expected = '<foo  ><bar  >foobar</bar></foo>'
+    actual = tagz{
+      foo_{
+        bar_{ 'foobar' }
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_060
+    expected = '<foo key="value"  ><bar a="b"  >foobar</bar></foo>'
+    actual = tagz{
+      foo_('key' => 'value'){
+        bar_(:a => :b){ 'foobar' }
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_070
+    expected = '<foo  /><bar  />'
+    actual = tagz{
+      foo_{} + bar_{}
+    }
+    assert_equal expected, actual
+  end
+=begin
+  def test_080
+    assert_raises(Tagz::NotOpen) do
+      foo_{ _bar }
+    end
+  end
+  def test_090
+    assert_raises(Tagz::NotOpen) do
+      _foo
+    end
+  end
+  def test_100
+    assert_nothing_raised do
+      foo_
+      _foo
+    end
+  end
+=end
+  def test_110
+    expected = '<foo  ><bar  >foobar</bar></foo>'
+    actual = tagz{
+      foo_{
+        bar_{ 'foobar' }
+        'this content is ignored because the block added content'
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_120
+    expected = '<foo  ><bar  >foobar</bar><baz  >barfoo</baz></foo>'
+    actual = tagz{
+      foo_{
+        bar_{ 'foobar' }
+        baz_{ 'barfoo' }
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_121
+    expected = '<foo  ><bar  >foobar</bar><baz  >barfoo</baz></foo>'
+    actual = tagz{
+      foo_{
+        bar_{ 'foobar' }
+        baz_{ 'barfoo' }
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_130
+    expected = '<foo  >a<bar  >foobar</bar>b<baz  >barfoo</baz></foo>'
+    actual = tagz{
+      foo_{ |t|
+        t << 'a'
+        bar_{ 'foobar' }
+        t << 'b'
+        baz_{ 'barfoo' }
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_140
+    expected = '<foo  ><bar  >baz</bar></foo>'
+    actual = tagz{
+      foo_{
+        bar_ << 'baz'
+        _bar
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_150
+    expected = '<foo  ><bar  >bar<baz  >baz</baz></bar></foo>'
+    actual = tagz{
+      foo_{
+        bar_ << 'bar'
+          tag = baz_
+          tag << 'baz'
+          _baz
+        _bar
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_160
+    expected = '<foo  >a<bar  >b</bar></foo>'
+    actual = tagz{
+      foo_{ |foo|
+        foo << 'a'
+        bar_{ |bar|
+          bar << 'b'
+        }
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_170
+    expected = '<html  ><body  ><ul  ><li  >a</li><li  >b</li><li  >c</li></ul></body></html>'
+    @list = %w( a b c )
+    actual = tagz{
+      html_{
+        body_{
+          ul_{
+            @list.each{|elem| li_{ elem } }
+          }
+        }
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_180
+    expected = '<html  ><body  >42</body></html>'
+    actual = tagz{
+      html_{
+        b = body_
+          b << 42
+        _body
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_190
+    expected = '<html  ><body  >42</body></html>'
+    actual = tagz{
+      html_{
+        body_
+          tagz << 42 ### tagz is always the current tag!
+        _body
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_200
+    expected = '<html  ><body  >42</body></html>'
+    actual = tagz{
+      html_{
+        body_{
+          tagz << 42 ### tagz is always the current tag!
+        }
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_210
+    expected = '<html  ><body  >42</body></html>'
+    actual = tagz{
+      html_{
+        body_{ |body|
+          body << 42
+        }
+      }
+    }
+    assert_equal expected, actual
+  end
+=begin
+  def test_220
+    expected = '<html  ><body  >42</body></html>'
+    actual = tagz{
+      'html'.tag do
+       'body'.tag do
+          42
+        end
+      end
+    }
+    assert_equal expected, actual
+  end
+=end
+  def test_230
+    expected = '<html  ><body  ><div k="v"  >content</div></body></html>'
+    actual = tagz{
+      html_{
+        body_{
+          div_(:k => :v){ "content" }
+        }
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_240
+    expected = '<html  ><body  ><div k="v"  >content</div></body></html>'
+    actual = tagz{
+      html_{
+        body_{
+          div_ "content", :k => :v
+        }
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_241
+    expected = '<html  ><body  ><div k="v"  >content</div></div></body></html>'
+    actual = tagz{
+      html_{
+        body_{
+          div_ "content", :k => :v
+          _div
+        }
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_250
+    expected = '<html  ><body  ><div k="v"  >content and more content</div></body></html>'
+    actual = tagz{
+      html_{
+        body_{
+          div_("content", :k => :v){ ' and more content' }
+        }
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_260
+    expected = '<html  ><body  ><div k="v"  >content</div></body></html>'
+    actual = tagz{
+      html_{
+        body_{
+          div_ :k => :v
+          tagz << "content"
+          _div
+        }
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_270
+    expected = '<html  ><body  ><div k="v"  >content</div></body></html>'
+    actual = tagz{
+      html_{
+        body_{
+          div_ :k => :v
+          tagz << "content"
+          _div
+        }
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_280
+    expected = 'content'
+    actual = tagz{
+      tagz << "content"
+    }
+    assert_equal expected, actual
+  end
+  def test_290
+    expected = 'foobar'
+    actual = tagz{
+      tagz {
+        tagz << 'foo' << 'bar'
+      }
+    }
+    assert_equal expected, actual
+  end
+=begin
+  def test_300
+    expected = 'foobar'
+    actual = tagz{
+      tagz{ tagz 'foo', 'bar' }
+    }
+    assert_equal expected, actual
+  end
+=end
+  def test_310
+    expected = '<html  ><body  ><div k="v"  >foobar</div></body></html>'
+    actual = tagz{
+      html_{
+        body_{
+          div_! "foo", "bar", :k => :v
+        }
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_320
+    expected = '<html  ><body  ><a href="a"  >a</a><span  >|</span><a href="b"  >b</a><span  >|</span><a href="c"  >c</a></body></html>'
+    links = %w( a b c )
+    actual = tagz{
+      html_{
+        body_{
+          tagz.write links.map{|link| e(:a, :href => link){ link }}.join(e(:span){ '|' })
+        }
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_330
+    expected = '<a  ><b  ><c  >'
+    actual = tagz{
+      tagz {
+        a_
+        b_
+        c_
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_340
+    expected = '<a  ><b  ><c  ></a>'
+    actual = tagz{
+      a_ {
+        b_
+        c_
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_350
+    expected = '<a  ><b  ><c  >content</c></a>'
+    actual = tagz{
+      a_ {
+        b_
+        c_ "content"
+      }
+    }
+    assert_equal expected, actual
+  end
+  def test_360
+    expected = '<a  ><b  >content</b><c  ><d  >more content</d></a>'
+    actual = tagz{
+      a_ {
+        b_ "content"
+        c_
+        d_ "more content"
+      }
+    }
+    assert_equal expected, actual
+  end
+=begin
+  def test_370
+    expected = 'ab'
+    actual = tagz{
+      re = 'a'
+      re << tagz{'b'}
+      re
+    }
+    assert_equal expected, actual
+  end
+=end
+  def test_380
+    expected = 'ab'
+    actual = tagz{
+      tagz{ 'a' } + tagz{ 'b' }
+    }
+    assert_equal expected, actual
+  end
+  def test_390
+    expected = '<div class="bar&amp;foo&gt;">foo&amp;bar&gt;</div>'
+    # actual = tagz{ div_(:class => 'bar&foo>'){|t| t.h('foo&bar>') } }
+    actual = tagz{ div_(:class => 'bar&foo>'){ 'foo&bar>' } }
+    assert_equal expected, actual
+    expected = %|<div class="bar&amp;foo&gt;">#{ expected }</div>|
+    actual = tagz{ div_(:class => 'bar&foo>'){ actual } }
+    assert_equal expected, actual
+  end
+  def test_400
+    expected = '<div><span>foo&amp;bar</span></div>'
+    actual = tagz{ div_{ span_{ 'foo&bar' } } }
+    assert_equal expected, actual
+  end
+  def test_410
+    expected = '<div>false</div>'
+    actual = tagz{ div_{ false } }
+    assert_equal expected, actual
+  end
+  def test_420
+    expected = "<div>\n<span>foobar</span>\nfoobar\n</div>"
+    actual = tagz{ div_{ __; span_{ :foobar }; ___('foobar'); } }
+    assert_equal expected, actual
+  end
+  def test_430
+    c = Class.new{
+      include Tagz.globally
+      def foobar() div_{ 'foobar' } end
+    }.new
+    actual=nil
+    assert_nothing_raised{ actual=c.foobar }
+    expected = '<div>foobar</div>'
+    assert_equal expected, actual
+=begin
+    e = nil
+    assert_raises(NoMethodError){ begin; c.missing; ensure; e=$!; end }
+    assert e
+    messages = e.backtrace.map{|line| line.split(%r/:/, 3).last}
+    assert messages.all?{|message| message !~ /tagz/}
+=end
+  end
+  def test_440
+    c = Class.new{
+      include Tagz
+      def foobar() tagz{ div_{ 'foobar' } } end
+      def barfoo() div_{ 'barfoo' } end
+    }.new
+    actual=nil
+    assert_nothing_raised{ actual=c.foobar }
+    expected = '<div>foobar</div>'
+    assert_equal expected, actual
+    assert_raises(NoMethodError){ c.barfoo }
+  end
+  def test_450
+    c = Class.new{
+      include Tagz.globally
+      def a() tagz{ a_{ b(tagz); nil } } end
+      def b(doc=nil) tagz(doc){ b_{ 'content' } } end
+    }.new
+    actual=nil
+    assert_nothing_raised{ actual=c.a }
+    expected = '<a><b>content</b></a>'
+    assert_equal expected, actual
+    assert_nothing_raised{ c.b }
+  end
+  def test_460
+    c = Class.new{
+      include Tagz.globally
+      def a
+        div_( 'a>b' => 'a>b' ){ 'content' }
+      end
+    }.new
+    actual = nil
+    assert_nothing_raised{ actual=c.a}
+    expected = %(<div a&gt;b="a&gt;b">content</div>)
+    assert_equal expected, actual
+    original = Tagz.escape_attribute! false
+    assert original
+    actual = nil
+    assert_nothing_raised{ actual=c.a}
+    expected = %(<div a>b="a>b">content</div>)
+    assert_equal expected, actual
+    Tagz.escape_attribute! original
+    actual = nil
+    assert_nothing_raised{ actual=c.a}
+    expected = %(<div a&gt;b="a&gt;b">content</div>)
+    assert_equal expected, actual
+    upcased = Tagz.escape_attribute! lambda{|value| original.call(value).upcase}
+    assert upcased
+    actual = nil
+    assert_nothing_raised{ actual=c.a}
+    expected = %(<div A&GT;B="A&GT;B">content</div>)
+    assert_equal expected, actual
+    Tagz.escape_attributes! lambda{|value| upcased.call(value).downcase}
+    actual = nil
+    assert_nothing_raised{ actual=c.a}
+    expected = %(<div a&gt;b="a&gt;b">content</div>)
+    assert_equal expected, actual
+  ensure
+    Tagz.escape_attributes!(original)
+  end
+  def test_470
+    c = Class.new{
+      include Tagz.globally
+      def a
+        div_( ){ 'a>b' }
+      end
+    }.new
+    actual = nil
+    assert_nothing_raised{ actual=c.a}
+    expected = %(<div>a&gt;b</div>)
+    assert_equal expected, actual
+    original = Tagz.escape_content! false
+    assert original
+    actual = nil
+    assert_nothing_raised{ actual=c.a}
+    expected = %(<div>a>b</div>)
+    assert_equal expected, actual
+    upcased = Tagz.escape_content! lambda{|value| original.call(value).upcase}
+    assert upcased
+    actual = nil
+    assert_nothing_raised{ actual=c.a}
+    expected = %(<div>A&GT;B</div>)
+    assert_equal expected, actual
+    Tagz.escape_content! original
+    actual = nil
+    assert_nothing_raised{ actual=c.a}
+    expected = %(<div>a&gt;b</div>)
+    assert_equal expected, actual
+  ensure
+    Tagz.escape_content!(original)
+  end
+  def test_480
+    c = Class.new{
+      include Tagz.globally
+      def a
+        div_( 'a>b' => '<>'){ 'a>b' }
+      end
+    }.new
+    Tagz.i_know_what_the_hell_i_am_doing!
+    actual = nil
+    assert_nothing_raised{ actual=c.a}
+    expected = %(<div a>b="<>">a>b</div>)
+    assert_equal expected, actual
+  ensure
+    Tagz.i_do_not_know_what_the_hell_i_am_doing!
+  end
+  def test_490
+    c = Class.new{
+      include Tagz.globally
+      def a
+        div_{
+          __
+          tagz.concat 'a>b'
+          __
+          tagz.write 'c>d'
+          __
+          tagz << 'e>f'
+          __
+          tagz.push 'g>h'
+        }
+      end
+    }.new
+    actual = nil
+    assert_nothing_raised{ actual=c.a}
+    expected = "<div>\na&gt;b\nc>d\ne&gt;f\ng>h</div>"
+    assert_equal expected, actual
+  end
+end