jig 0.1.0 → 0.1.2

data/History.txt

@@ -1,5 +1,18 @@
-== 0.1.0 / 2007-05-17
+== 0.1.1 / 2008-02-28
+
+* Jig#syntax to help with jig comparison
+* Jig#terse_inspect to help with nested inspect and gaps with processing
+* testing of Jig#parse
+* to_yaml of jigs with procs
+* Callable objects are now rendered to strings via to_yaml
+* Attribute gaps have their own class now instead of being adhoc gap filters.
+* Gap#== checks classes
+* Gap with filter was being replaced by a plain gap.
+  Ignore filling if filling is the same gap.
+* Jig#parse correction
+* cleanup up some documentation typos
+* reimplemented Jig.parse with StringScanner, fixed bugs
+
+== 0.1.0 / 2007-05-11
+
 * Initial Release
-  * basic jig support
-  * XML, XHMTL support
-  * CSS support (experimental)

data/Manifest.txt

@@ -1,3 +1,4 @@
+.DS_Store
 History.txt
 Manifest.txt
 README.txt
@@ -6,7 +7,11 @@ lib/jig.rb
 lib/jig/css.rb
 lib/jig/xhtml.rb
 lib/jig/xml.rb
+test/jig.rb
+test/jig_spec.rb
 test/test_css.rb
 test/test_jig.rb
+test/test_parse.rb
 test/test_xhtml.rb
 test/test_xml.rb
+todo

data/README.txt

@@ -1,9 +1,9 @@
 Jig
     by Gary R. Wright
-    (jig.rubyforge.org)
+    http://jig.rubyforge.org
 
 == 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/)
@@ -15,7 +15,7 @@ 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.
+rendered 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
@@ -24,14 +24,10 @@ 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.
-
 Several subclasses (Jig::XML, Jig::XHTML, Jig::CSS) are defined to
 help in the construction of XML, XHTML, and CSS documents.
 
-This is a jig with a single gap named <tt>:alpha</tt>
+This is a jig with a single gap named :alpha.
   Jig.new(:alpha)                         # => <#Jig: [:alpha]>
 This is a jig with two objects, 'before' and 'after' separated by
 a gap named :middle.
@@ -42,44 +38,32 @@ This operation doesn't change j.  It can be used again:
   j.plug(:middle, " and ")                # => #<Jig: ["before", " and ", "after"]>
 There is a destructive version of plug that modifies
 the jig in place:
-  j.plug!(:middle, "filled")              # => #<Jig: ["before", "filled", "after"]>
-  j                                       # => #<Jig: ["before", "filled", "after"]>
+  j.plug!(:middle, "filled")          # => #<Jig: ["before", "filled", "after"]>
+  j                                   # => #<Jig: ["before", "filled", "after"]>
 There are a number of ways to construct a Jig and many of
 them insert an implicit gap into the Jig.  This gap is
-identified as <tt>:___</tt> and is used as the default gap
+identified as :___ and is used as the default gap
 for plug operations when one isn't provided:
 
-  puts Jig.new("A", :___, "C").plug("B")  # => ABC
-  puts Jig.new.plug('filled')             # => filled
-
-The % operator is an alias for Jig#plug
+  puts Jig.new("A", :___, "C").plug("B")   # => ABC
 
-  name = Jig.new(:last, ", ", :first)
-  data = {:first => 'Gary', :last => 'Wright')
-  puts name % data                         # => Wright, Gary
+In order to make Jig's more useful for HTML generation,
+the Jig::XHTML class supports a variety of convenience methods;
 
-In order to make Jig's more useful for XML generation,
-the Jig::XML class supports a variety of convenience methods;
-
-  X = Jig::XML
-  puts b = X.element("body")              # => <body></body>
-  puts b.plug("text")                     # => <body>text</body>
+  HT = Jig::XHTML
+  puts b = HT.element("body")     # => <body></body>
+  puts b.plug("text")             # => <body>text</body>
 
 Method missing makes this even simpler:
 
   b = HT.span
-  puts b.plug("text")                     # => <span>text</span>
+  puts b.plug("text")             # => <span>text</span>
 
 Attributes can be specified with a hash:
 
-  summary = X.p(:class => "summary")
+  summary = HT.p(:class => "summary")
   puts summary.plug("This is a summary") # => <p class="summary">This is a summary</p>
 
-See the Jig::XML for more information about attributes and gaps.
-The Jig::XHTML class has a variety of convenience methods for
-constructing XHTML documents.  The Jig::CSS class generates jigs
-that represent CSS rules.
-
 == REQUIREMENTS:
 
 * Ruby 1.8

data/Rakefile

@@ -7,12 +7,12 @@ require './lib/jig.rb'
 
 Hoe.new('jig', Jig::VERSION) do |p|
   p.rubyforge_name = 'jig'
-  p.author = ["Gary Wright"]
-  p.email = 'gwright@rubyforge.org'
-  p.summary = 'a data structure that supports construction and manipulation of strings with hierarchical structure'
+  p.summary = 'A Jig is a data structure that supports construction and manipulation of strings with hierarchical structure.'
   p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
-  p.url = "http://jig.rubyforge.org"
   p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.author = "Gary R. Wright"
+  p.email = "gwright@rubyforge.org"
+  p.url = "http://jig.rubyforge.org"
 end
 
 task :spec do
@@ -31,7 +31,7 @@ RCOV = "rcov"
 desc "generate a unit test coverage report in coverage/unit; see coverage/unit/index.html afterwards"
 task :rcov do
   tests = FileList['test/test_*.rb']
-  sh "#{RCOV} --xref -Ilib #{tests}"
+  sh "#{RCOV} -Ilib #{tests}"
 end
 
 

data/lib/jig.rb

@@ -1,3 +1,4 @@
+require 'strscan'
 
 =begin rdoc
 A jig is an ordered sequence of objects and named gaps. During construction,
@@ -39,7 +40,7 @@ replaced with the same sequence of objects.
   puts j.plug(:separator, '/')                  # => "first/middle/last"
 =end
 class Jig
-  VERSION = '0.1.0'
+  VERSION = '0.1.2'
   autoload :XML, "jig/xml"
   autoload :XHTML, "jig/xhtml"
   autoload :CSS, "jig/css"
@@ -52,7 +53,6 @@ class Jig
   class Gap
     ATTRS = :__a
     GAP = :___
-
     # the name associated with the gap
     attr :name    
 
@@ -67,7 +67,11 @@ class Jig
     end
 
     def inspect
-      "#<Gap: [#{name}, #{filter.inspect}]>"
+      "#<#{self.class.name}: [#{name}, #{filter.inspect}]>"
+    end
+
+    def terse_inspect
+      filter && "#{name}{}".to_sym || name
     end
 
     # Pass the replacement items through the filter.
@@ -78,7 +82,9 @@ class Jig
     # Two gaps are equal if they have the same name and
     # use the same filter.
     def ==(other)
-      name == other.name && filter == other.filter
+      self.class == other.class &&
+      name == other.name && 
+      filter == other.filter
     end
 
     # Change the name of the gap.
@@ -107,11 +113,10 @@ class Jig
     # If _open_ is provided, a single line of text will be wrapped with the _open_
     # and _close_ strings but multiple lines of text will be formatted as a block
     # comment.  If _close_ is not provided it is taken to be the <i>open.reverse</i>.
-    #   Jig[Jig::Gap.comment]                      # text reformated to 72 columns
-    #   Jig[Jig::Gap.comment("# ")]                # text reformated as Ruby comments
-    #   Jig[Jig::Gap.comment("// ")]               # text reformated as Javascript comments
-    #   Jig[Jig::Gap.comment(" *", "/* ")]         # text reformated as C comments
-    #   Jig[Jig::Gap.comment(" ", "<-- ", " -->")] # text reformated as XML comments
+    #   Jig[Jig::Gap.comment]                       # text reformated to 72 columns
+    #   Jig[Jig::Gap.comment("# ")]                 # text reformated as Ruby comments
+    #   Jig[Jig::Gap.comment("// ")]                # text reformated as Javascript comments
+    #   Jig[Jig::Gap.comment(" *", "/* ")]          # text reformated as C comments
     #
     # If the default gap name isn't appropriate you must fill in all the arguments:
     #   Jig[Jig::Gap.comment("# ", nil, nil, 72, :alternate)]    # alternate gap name
@@ -192,24 +197,44 @@ class Jig
     #
     #   A.new.secret          # NoMethodError
     #   A.new.to_jig.to_s     # secret: xyzzy
+
+    Before = /[^%]*/
+    Replace = /%\{(.?)(.+)\1\}/
+
     def parse(string=nil, context=nil)
       wrapper = context || Module.new.class_eval { binding }
-      raw = string.scan(/(.*?)(%\{(.)(.*?)\3\}|\z)/).inject([]) { |list, (before, quoted, delim, stripped)|
-        list << before unless before.empty?
-        case delim
-        when ':'
-          list << stripped.to_sym
-        when '!'
-          list << eval("lambda {#{stripped}}", wrapper)
-        when nil,''
-          list
+      scanner = StringScanner.new(string)
+      raw = []
+      while !scanner.eos?
+        if before = scanner.scan(Before)
+          if replace = scanner.scan(Replace)
+            raw << before
+            raw << interpolate(replace, wrapper)
+          else
+            raw << before
+            raw << scanner.getch unless scanner.eos?
+          end
         else
-          list << parse_other(delim, stripped)
+          raw << scanner.rest
+          scanner.terminate
         end
-      }
+      end
       Jig.new(*raw)
     end
 
+    def interpolate(replace, context)
+      all, delimiter, content = *(replace.match(Replace))
+
+      case delimiter
+      when ':'
+        content.to_sym
+      when '!', ''
+        eval("lambda {#{content}}", context)
+      else
+        parse_other(delimiter, content)
+      end
+    end
+
     def parse_other(delim, stripped)
       raise ArgumentError, "invalid delimiter: \"#{delim}\""
     end
@@ -233,7 +258,7 @@ class Jig
   #   puts j                        # => "i is 1"
   # 
   # If no arguments are given and no block is given, the jig is constructed
-  # with a single default gap named <tt>:___</tt> (also known as Jig::GAP).
+  # with a single default gap named <tt>:\___</tt> (also known as Jig::GAP).
   #   one_gap = Jig.new
   #   one_gap.gaps           # => [:___]
   def initialize(*items, &block)
@@ -286,6 +311,12 @@ class Jig
     contents.zip(rawgaps).flatten.eql?(rhs.contents.zip(rhs.rawgaps).flatten)
   end
 
+  # Construct and array that represents the syntax of the jig including its
+  # gaps. Gaps are only distinguished by their name and not their semantics.
+  def syntax
+    contents.zip(gaps).flatten
+  end
+
   # Returns true if +rhs+ is an instance of Jig or one of Jig's subclasses and
   # the two jigs have equal gap lists and contents (via Array#==).
   # Procs are not evaluated by Jig#==.
@@ -309,7 +340,7 @@ class Jig
   end
 
   # Returns true if the string representation of the jig matches the
-  # </tt>rhs.to_str</tt> using String#===. Procs are evaluated by Jig#====.
+  # +rhs.to_str+ using String#=~. Procs are evaluated by Jig#===.
   def ===(rhs)
     to_s =~ rhs.to_str
   end
@@ -324,7 +355,7 @@ class Jig
   #   Jig.new(1,:a,2).inspect                             # => #<Jig: [1, :a, 2]>
   #   Jig.new(Gap.new(:example) { |x| x.to_s.reverse })  # => #<Jig: [:example{}]>
   def inspect
-    info = rawgaps.map {|g| g.filter && "#{g.name}{}".to_sym || g.name }
+    info = rawgaps.map {|g| g.terse_inspect }
     "#<Jig: #{contents.zip(info).flatten[0..-2].inspect}>"
   end
 
@@ -602,12 +633,12 @@ class Jig
     dup.after!(*args)
   end
 
-  # call-seq
+  # call-seq:
   #   split(pattern=$;, [limit])
   #
   # With no arguments, the jig is split at the gap positions into an 
-  # array of strings.  If arguments are provided, the entire string is
-  # rendered to a string and the result of String#split (with the
+  # array of strings.  If arguments are provided, the jig is
+  # rendered to a string by #to_s and the result of String#split (with the
   # arguments) is returned.
   def split(*args)
     if args.empty?
@@ -672,6 +703,7 @@ class Jig
             alias inspect :to_s
             undef to_s
             def to_s; call.to_s; end
+            def to_yaml(opts={}); call.to_yaml(opts); end
             #:startdoc:
           }
           contents.last << i
@@ -804,8 +836,10 @@ class Jig
     gaps.each_with_index do |gap, index|
       match = index + adjust
       items = block_given? && yield(gap)
-      fill = rawgaps.at(match).fill(items)
-      adjust += plug_gap!(match, fill) - 1
+      if items != gap
+        fill = rawgaps.at(match).fill(items)
+        adjust += plug_gap!(match, fill) - 1
+      end
     end
     self
   end
@@ -829,8 +863,8 @@ class Jig
   end
 
   # :stopdoc:
-  # This method alters the current jig by replacing a gap with a 
-  # (possibly empty) sequence of objects. The contents and rawgap arrays
+  # This method alters the current jig by replacing a gap with a (possibly
+  # empty) sequence of objects. The contents and rawgap arrays
   # are modified such that the named gap is removed and the sequence of
   # objects are put in the logical position of the former gap.
   #

data/lib/jig/css.rb

@@ -229,9 +229,6 @@ class Jig
       end
     end
 
-    # Returns a standard jig representation of the CSS jig.  Gaps that are
-    # used internally by the CSS class are closed.  #to_jig should be used before
-    # combining one or more CSS jigs.
     def to_jig
       Jig.new(plug( :__s => nil, :__de => nil, :__ds => nil ))
     end

data/lib/jig/xhtml.rb

@@ -2,8 +2,8 @@ require 'jig'
 require 'jig/xml'
 
 class Jig
-  # Jig::XHTML is a subclass of Jig::XML and is designed to assist in the
-  # construction of XHTML documents.
+	# Jig::XHTML is a subclass of Jig::XML and is designed to assist in the
+	# construction of XHTML documents.
   class XHTML < XML
     attr_accessor :extra
     protected :extra
@@ -35,8 +35,8 @@ class Jig
     class <<self
       # Construct a jig for an XHTML element with _tag as the tag and include
       # an ID attribute with a guaranteed unique value.
-      # Example:
-      #      puts Jig::XHTML.element_with_id('div')    # <div id="x2354322">\n</div> 
+			# Example:
+			#			puts Jig::XHTML.element_with_id('div')		# <div id="x2354322">\n</div> 
       def element_with_id(tag, *args)
         attrs = { 'id' => :id }
         attrs = attrs.merge!(args.pop) if args.last.respond_to?(:fetch)
@@ -49,11 +49,11 @@ class Jig
 
       # Construct a jig for an emtpy XHTML element with _tag as the tag and include
       # an ID attribute with a guaranteed unique value.  The selected id is
-      # accessible via the eid attribute.
-      # Example:
-      #      j = Jig::XHTML.element_with_id('input', :name=>'login')
-      #      puts j          # <input name="login" id="x2354328"/>
-      #      puts j.eid      # x2354328
+			# accessible via the eid attribute.
+			# Example:
+			#			j = Jig::XHTML.element_with_id('input', :name=>'login')
+			#			puts j					# <input name="login" id="x2354328"/>
+			#			puts j.eid			# x2354328
       def element_with_id!(tag, *args)
         attrs = { 'id' => :id }
         attrs = attrs.merge!(args.pop) if args.last.respond_to?(:fetch)
@@ -64,10 +64,10 @@ class Jig
         jig.plug!(:id, jig.eid)
       end
 
-      # Construct an element based on the method name.  If the method name
-      # ends in '_with_id' or '_with_id!', the element is constructed with
-      # a unique XML id attribute otherwise the Jig::XML element construction
-      # rules apply.
+			# Construct an element based on the method name.  If the method name
+			# ends in '_with_id' or '_with_id!', the element is constructed with
+			# a unique XML id attribute otherwise the Jig::XML element construction
+			# rules apply.
       def method_missing(sym, *args, &block)
         text = sym.to_s
         if text.to_s =~ /_with_id!*$/
@@ -83,43 +83,26 @@ class Jig
         :frameset, %{"-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd"}
       }
 
-      # Construct an XHTML DOCTYPE declaration. The first argument, _dtype_, specifies
-      # the type of document: :strict, :transitional, or :frameset.  Any additional
-      # arguments are rendered after the DOCTYPE declaration.  A default gap is *not*
-      # inserted if their are no arguments. Examples:
-      #
-      #  puts X.doctype(:strict)  
-      #    # => <!DOCTYPE html PUBLIC -//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd>
-      #  puts X.doctype(:strict).gaps.size    # 0
+			# Construct an XHTML DOCTYPE declaration. The first argument, _dtype_, specifies
+			# the type of document: :strict, :transitional, or :frameset.  Any additional
+			# arguments are rendered after the DOCTYPE declaration.  A default gap is *not*
+			# inserted if their are no arguments. Examples:
+			#
+			#	puts X.doctype(:strict)	# <!DOCTYPE html PUBLIC -//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd>
+			# puts X.doctype(:strict).gaps.size    # 0
       def doctype(dtype, *args, &block)
         new(%{<!DOCTYPE html PUBLIC #{DOCTYPES.fetch(dtype)}>\n}, *args, &block)
       end
 
-      # call-seq:
-      #   xhtml([attributes]) -> a_jig
-      #   xhtml(doctype, [attributes]) -> a_jig
-      #   xhtml(doctype, *items, [attributes]) -> a_jig
-      #   xhtml(*items, [attributes]) -> a_jig
-      # Construct a generic XHTML document.  With no arguments, a transitional
-      # document with three gaps, <tt>:title</tt>, <tt>:head</tt>, and <tt>:___</tt>
-      # is generated.  The default gap represents the contents of the body element.
-      #
-      # With a single symbol argument, <i>doctype</i>, an XHTMl document is generated
-      # with a corresponding DOCTYPE declaration (see #doctype).
-      #
-      # If any arguments are provided other than a doctype, the additional arguments
-      # are used as the contents of the HTML element.
-      #
-      # A trailing hash argument is assumed to represent additional XML attributes for
-      # the html element.
-      #   X.xhtml                 # transitional document with :title, :head, and :___
-      #   X.xhtml :strict         # strict document with :title, :head, and :___
-      #   X.xhtml(:strict, head, body)  # strict document with explicit head & body
-      #   X.xhtml(head, body)     # transitional document with explicit head & body
-      #   X.xhtml :lang => 'jp'   # transition document with HTML attributes merged
+			# Construct a generic XHTML document.  If the first argument is a symbol it is
+			# used to look up a matching DOCTYPE declaration (see #doctype).
+			# X.xhtml						# transitional document with :title, :head, and :___
+			# X.xhtml :strict		# strict document with :title, :head, and :___
+			# X.xhtml :lang => 'jp'  # transition document with HTML attributes merged
+			# X.xhtml(head, body)		 # transitional document with explicit head & body
       def xhtml(dtype=:transitional, *args, &block)
-         unless Symbol === dtype
-          dtype,args = :transitional,args.unshift(dtype)
+        if dtype.respond_to?(:fetch)
+          dtype,*args = :transitional,dtype
         end
         attrs = {:lang=>'en', "xml:lang"=>'en', :xmlns=>'http://www.w3.org/1999/xhtml'}
         attrs.merge!(args.pop) if args.last.respond_to?(:fetch) 
@@ -129,11 +112,11 @@ class Jig
         doctype(dtype,html(*args))
       end
 
-      # A convenience method for constructing an XHTML element with a named
-      # CSS class and an unique XHTML element ID.
-      # 
-      #   X.container('span', 'urgent', 'This is urgent!')
-      #      => <span class="urgent" id="x2337852"></span>
+			# A convenience method for constructing an XHTML element with a named
+			# CSS class and an unique XHTML element ID.
+			# 
+			#   X.container('span', 'urgent', 'This is urgent!')
+			#			=> <span class="urgent" id="x2337852"></span>
       def container(tag, css, *args)
         args.push(Proc.new) if block_given?
         args.push(:class => css)
@@ -142,26 +125,26 @@ class Jig
         jig
       end
 
-      # An even shorter way to construct a div container
-      #
-      #   X.divc('urgent', 'This is urgent!')
-      #      => <div class="urgent" id="x2337852"></div>
+			# An even shorter way to construct a div container
+			#
+			#   X.divc('urgent', 'This is urgent!')
+			#			=> <div class="urgent" id="x2337852"></div>
       def divc(css_class, *args, &block)
         container(:div, css_class, *args, &block)
       end
 
-      # Generate a link element for a favicon. Extra attributes
-      # may be specified via the optional argument, _extra_.
-      #
-      #   X.link_favicon
-      #      => <link src="/favicon.ico" type="image/x-icon" rel="icon"/>
+			# Generate a link element for a favicon. Extra attributes
+			# may be specified via the optional argument, _extra_.
+			#
+			#   X.link_favicon
+			#			=> <link src="/favicon.ico" type="image/x-icon" rel="icon"/>
       def link_favicon(extra={})
         attrs = {:type=>"image/x-icon", :rel=>"icon", :src=>'/favicon.ico'}
         attrs.merge! extra
         link!(attrs)
       end
 
-      # XXX: is this no longer needed?
+			# XXX: is this no longer needed?
       def normalize_args(args, attrs={}) # :nodoc"
         attrs.merge!(args.pop) if args.last.respond_to?(:fetch)
         args.push(Proc.new) if block_given?
@@ -169,18 +152,18 @@ class Jig
         return args, attrs
       end
 
-      # Generate a CSS style sheet element. If a 'src' attribute
-      # is provided the contents is empty.  Without a 'src' attribute
-      # a CDATA block wraps the contents of the element.
-      #
-      #   j = Jig::XHTML.style
-      #   puts j.plug('/* CSS style sheet */')
-      #
-      #   <style media="all" type="text/css">
-      #   <![CDATA[
-      #   /* CSS style sheet */
-      #    ]]>
-      #   </style>
+			# Generate a CSS style sheet element. If a 'src' attribute
+			# is provided the contents is empty.  Without a 'src' attribute
+			# a CDATA block wraps the contents of the element.
+			#
+			#   j = Jig::XHTML.style
+			#   puts j.plug('/* CSS style sheet */')
+			#
+			#   <style media="all" type="text/css">
+			#   <![CDATA[
+			#   /* CSS style sheet */
+			#    ]]>
+			#   </style>
       def style(*args, &block)
         attrs = {:type=>"text/css", :media=>"all"}
         attrs.merge!(args.pop) if args.last.respond_to?(:fetch) 
@@ -197,16 +180,16 @@ class Jig
         link!('rel' => 'stylesheet', 'type' => 'text/css', 'href' => src)
       end
 
-      # Generate a script element.  XXX
-      #
-      #   j = Jig::XHTML.script
-      #   puts j.plug(cdata("# the script"))
-      #
-      #   <script type=">
-      #   <![CDATA[
-      #   # the script
-      #    ]]>
-      #   </script>
+			# Generate a script element.  XXX
+			#
+			#   j = Jig::XHTML.script
+			#   puts j.plug(cdata("# the script"))
+			#
+			#   <script type=">
+			#   <![CDATA[
+			#   # the script
+			#    ]]>
+			#   </script>
       def script(*args, &block)
         attrs = args.pop if args.last.respond_to?(:fetch) 
         args.push(Proc.new) if block_given?
@@ -233,12 +216,12 @@ class Jig
         new(a({:href=>"#", :onclick => "toggle(#{body.eid})"}, '(details)'), body)
       end
 
-      # Generate a Javascript comment.
-      #
-      #   j = Jig::XHTML.js_comment
-      #   puts j.plug("comment")
-      #
-      #    /* comment */
+			# Generate a Javascript comment.
+			#
+			#   j = Jig::XHTML.js_comment
+			#   puts j.plug("comment")
+			#
+			#		/* comment */
       def js_comment(*args, &block)
         gap = Jig::Gap.new(:comment) { |*filling| 
           filling.map {|item| 
@@ -248,30 +231,30 @@ class Jig
         new(gap, "\n").plug(:comment, *args)
       end
 
-      # Generate a multiline Javascript comment.
-      #
-      #   j = Jig::XHTML.js_comments
-      #   puts j.plug("line 1\nline 2")
-      #
-      #    /*
-      #   line 1
-      #   line 2
-      #    */
+			# Generate a multiline Javascript comment.
+			#
+			#   j = Jig::XHTML.js_comments
+			#   puts j.plug("line 1\nline 2")
+			#
+			#		/*
+			#   line 1
+			#   line 2
+			#    */
       def js_mlcomment(*args, &block)
         new("/*\n", new(*args, &block), "\n */\n")
       end
 
-      # Generate an inline script element for javascript.
-      # The body of the script is wrapped in a CDATA block.
-      #
-      #   j = Jig::XHTML.javascript
-      #   puts j.plug("// the script")
-      #
-      #   <script type="text/javascript" language="JavaScript">
-      #   <![CDATA[
-      #   // the script
-      #    ]]>
-      #   </script>
+			# Generate an inline script element for javascript.
+			# The body of the script is wrapped in a CDATA block.
+			#
+			#   j = Jig::XHTML.javascript
+			#   puts j.plug("// the script")
+			#
+			#   <script type="text/javascript" language="JavaScript">
+			#   <![CDATA[
+			#   // the script
+			#    ]]>
+			#   </script>
       def javascript(*args, &block)
         attrs = {:type=>"text/javascript", :language=>"JavaScript"}
         attrs.merge!(args.pop) if args.last.respond_to?(:fetch) 

data/lib/jig/xml.rb

@@ -78,6 +78,26 @@ class Jig
    j = X.div('inner', :style=> color)           # => <div style="color: red">inner</div>
    j.to_s                                       # => <div style="color: green">inner</div>
 =end
+
+  class ALGap < Gap
+    def fill(h)
+      h && h.map { |k,v| Jig::XML.attribute(k, v) }
+    end
+  end
+
+  class AGap < Gap
+    attr_accessor :aname
+
+    def initialize(name, aname)
+      super(name)
+      self.aname = aname
+    end
+
+    def fill(fill)
+      Jig::XML.attribute(aname, fill)
+    end
+  end
+
   class XML < Jig
     # Converts _hash_ into attribute value pairs and pushes them
     # on the end of the jig.
@@ -117,7 +137,8 @@ class Jig
         when nil, false
           ""
         when Symbol
-          Gap.new(value) { |fill| attribute(aname, fill) }
+          AGap.new(value, aname)
+          #Gap.new(value) { |fill| attribute(aname, fill) }
         when Gap
           value
         when Proc, Method
@@ -157,7 +178,8 @@ class Jig
       private :parse_other
 
       ATTRS = Gap::ATTRS # :nodoc:
-      ATTRS_GAP = Gap.new(ATTRS) { |h| h && h.map { |k,v| Jig::XML.attribute(k, v) } } # :nodoc:
+      ATTRS_GAP = Jig::ALGap.new(ATTRS)
+      #ATTRS_GAP = Gap.new(ATTRS) { |h| h && h.map { |k,v| Jig::XML.attribute(k, v) } } # :nodoc:
 
       Element_Cache = {} # :nodoc:
       # Construct a generic XML element with two gaps:
@@ -295,17 +317,19 @@ class Jig
       # 
       #   \<!-- This is a comment -->
       def comment(*args)
+        #:stopdoc:
         args.push(lambda{|*x| yield(*x) }) if block_given?
         args.push GAP if args.empty?
         jig = (Cache[:comment] ||= new("<!-- ".freeze, GAP, " -->\n".freeze).freeze)
         jig.plug(GAP, *args)
+        #:startdoc:
       end
 
       # Construct a multiline XML comment element.
       #
       #   Jig::XML.comment("first line\nsecond line")
       #   
-      #   <!-- 
+      #   \<!-- 
       #   first line
       #   second line
       #   -->

data/test/jig.rb

@@ -0,0 +1,14 @@
+
+module Asserts
+  def assert_as_string(expected, jig, message='')
+    case expected
+    when String
+      assert_equal(expected, jig.to_s, message)
+    when Regexp
+      assert_match(expected, jig.to_s, message)
+    end
+  end
+	def assert_not_similar(a, b, mess="")
+		assert_not_match(a, b, mess)
+  end
+end

data/test/jig_spec.rb

@@ -0,0 +1,110 @@
+# A Rspec file for Jig
+#
+#
+require File.dirname(__FILE__) + '/../lib/jig'
+
+context "A null jig" do
+	setup do
+		@jig = Jig.null
+	end
+	specify "should be an instance of Jig" do
+		@jig.should_be_an_instance_of Jig
+	end
+	specify "should be full" do
+		@jig.should_be_full
+	end
+	specify "should serialize as the null string" do
+		@jig.to_s.should == ""
+	end
+	specify "should test as null" do
+		@jig.should_be_null
+	end
+end
+
+context "A new jig" do
+	setup do
+		@jig = Jig.new
+	end
+	specify "should be an instance of Jig" do
+		@jig.should_be_an_instance_of Jig
+	end
+	specify "should have a default gap" do
+		@jig.should_have_gap :___
+	end
+	specify "should have only one gap" do
+		@jig.gap_count.should == 1
+	end
+	specify "should serialize as the null string" do
+		@jig.to_s.should == ""
+	end
+	specify "should not have a default gap after plug(:alpha)" do
+		@jig.plug(Jig::Gap.new(:alpha)).should_not_have_gap :___
+	end
+end
+
+context "A jig with a single gap named :alpha" do
+	setup do
+		@jig = Jig.new(:alpha)
+	end
+	specify 'should have one gap named :alpha' do
+		@jig.gap_list.should == [:alpha]
+	end
+	specify 'should serialize as the null string' do
+		@jig.to_s.should == ""
+	end
+	specify 'should match "beta" when you plug gap :alpha with "beta"' do
+		@jig.plug(:alpha, "beta").to_s.should == "beta"
+	end
+end
+
+context "A jig with two gaps named :alpha" do
+	setup do
+		@jig = Jig.new(:alpha, :alpha)
+	end
+	specify 'should have two gaps named :alpha' do
+		@jig.gap_list.should == [:alpha, :alpha]
+	end
+	specify 'should match "hoho" when you plug gap :alpha with "ho"' do
+		@jig.plug(:alpha, "ho").to_s.should == "hoho"
+	end
+end
+
+context "A jig with two gaps named :alpha and :beta" do
+	setup do
+		@jig = Jig.new(:alpha, :beta)
+	end
+	specify 'should have two gaps named :alpha, :beta' do
+		@jig.gap_list.should == [:alpha, :beta]
+	end
+end
+
+context "A jig constructed by parsing 'a<:alpha:>b'" do
+	setup do
+		@jig = Jig.parse "a<:alpha:>b"
+	end
+	specify 'should have one gap named :alpha' do
+		@jig.gap_list.should == [:alpha]
+	end
+	specify 'should match "ab"' do
+		@jig.should_match "ab"
+	end
+end
+
+context "A jig constructed by parsing 'a<:alpha,beta:>b'" do
+	setup do
+		Xjig = Class.new(Jig)
+		Xjig.enable :xml
+		@jig = Xjig.parse "a<:alpha,beta:>b"
+	end
+	specify 'should have one gap named :beta' do
+		@jig.gap_list.should == [:beta]
+	end
+	specify 'should match "ab"' do
+		@jig.should_match "ab"
+	end
+	specify 'should match "aalpha=1b" after plug :beta with 1' do
+		@jig.plug(:beta, 1).should_match "aalpha=1b"
+	end
+end
+
+# vim: syntax=Ruby

data/test/test_jig.rb

@@ -432,6 +432,13 @@ class MultipleGaps < Test::Unit::TestCase
     assert_equal("<form onsubmit=\"ab\">\n</form>\n", j2.plug(:gap1, "X").to_s)
   end
 
+  def xtest_depth
+    a = X.new
+    b = X.new(:"a/b")
+    assert_equal(0, a[Jig::GAP].depth)
+    assert_equal(1, b[:"a/b"].depth)
+  end
+
   def test_escape
     ok = 'a'
     bad = '<'

data/test/test_parse.rb

@@ -0,0 +1,88 @@
+
+require 'jig'
+require 'test/jig'
+require 'test/unit'
+
+class TestParse < Test::Unit::TestCase
+  J = Jig
+  include Asserts
+  def test_string
+    source = "chunky bacon"
+    j = Jig.parse(source)
+    assert_equal(source, j.to_s)
+  end
+
+  def test_with_newline 
+    source = "before %{:alpha:} after\n"
+    j = Jig.parse(source)
+    assert_equal([:alpha], j.gaps)
+    assert_equal("before ", j[0].to_s)
+    assert_equal(" after\n", j[2].to_s)
+  end
+
+  def test_gap
+    source = "chunky %{:adjective:} bacon"
+    j = Jig.parse(source)
+    assert_equal([:adjective], j.gaps)
+    assert_equal("chunky ", j[0].to_s)
+    assert_equal(" bacon", j[2].to_s)
+  end
+
+  def test_agap
+    source = "<input%{=type,itype=} />"
+    j = Jig::XML.parse(source)
+    assert_equal([:itype], j.gaps)
+    assert_equal("<input", j[0].to_s)
+    assert_equal(" />", j[2].to_s)
+    jp = j.plug(:itype => 'password')
+    assert_equal("<input type=\"password\" />", jp.to_s)
+  end
+
+  def test_agap_error
+    source = "<input%{=type=} />"
+    assert_raise(ArgumentError) { Jig::XHTML.parse(source) }
+  end
+
+  def test_jig_agap_error
+    source = "<input%{=type,itype=} />"
+    assert_raise(ArgumentError) { Jig.parse(source) }
+  end
+
+  def test_syntax_error
+    source = "%{ , # invalid syntax }"
+    assert_raise(ArgumentError) { Jig.parse(source) }
+  end
+
+  def test_lgap
+    a = 2
+    j = Jig.parse("%{!a + 1!}", binding)
+    assert_equal("3", j.to_s)
+  end
+
+  def test_lgap_error
+    j = Jig.parse("%{!b + 1!}")
+    assert_raise(NameError) { j.to_s }
+  end
+
+  def test_yield
+    j = Jig.parse("%{!yield + 1!}") { 5 }
+    assert_equal("6", j.to_s)
+  end
+
+  def test_instance_binding
+    klass = Class.new {
+      def to_jig
+        Jig.parse("secret: %{!secret!}", binding)
+      end
+      def secret
+         "xyzzy"
+      end
+      private :secret
+    }
+    
+    instance = klass.new
+    assert_raise(NoMethodError) { instance.secret }
+    assert_equal("secret: xyzzy", instance.to_jig.to_s)
+  end
+end
+

data/todo

@@ -0,0 +1,7 @@
+
+Extend Jig#fill to take a list of gaps to consider instead of
+iterating over all the gaps.  This will permit a shortcut for
+the special case of plugging a single gap.
+
+When plugging gaps via a proc, the proc should only be called
+once for each gap name.

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.4
 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
+  version: 0.1.2
+date: 2008-02-28 00:00:00 -05:00
+summary: A Jig is 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."
+description: "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 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.  Several subclasses (Jig::XML, Jig::XHTML, Jig::CSS) are defined to help in the construction of XML, XHTML, and CSS documents.  This is a jig with a single gap named :alpha. Jig.new(:alpha)                         # => <#Jig: [:alpha]> This is a jig with two objects, 'before' and 'after' separated by a gap named :middle. j = Jig.new('before', :middle, 'after)  # => #<Jig: [\"before\", :middle, \"after\"]> The plug operation derives a new jig from the old jig. j.plug(:middle, \", during, and\")        # => #<Jig: [\"before\", \", during, and \", \"after\"]> This operation doesn't change j.  It can be used again: j.plug(:middle, \" and \")                # => #<Jig: [\"before\", \" and \", \"after\"]> There is a destructive version of plug that modifies the jig in place: j.plug!(:middle, \"filled\")          # => #<Jig: [\"before\", \"filled\", \"after\"]> j                                   # => #<Jig: [\"before\", \"filled\", \"after\"]> There are a number of ways to construct a Jig and many of them insert an implicit gap into the Jig.  This gap is identified as :___ and is used as the default gap for plug operations when one isn't provided:"
 autorequire: 
 default_executable: 
 bindir: bin
@@ -25,9 +25,11 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
-- Gary Wright
+- Gary R. Wright
 files: 
+- .DS_Store
 - History.txt
 - Manifest.txt
 - README.txt
@@ -36,19 +38,27 @@ files:
 - lib/jig/css.rb
 - lib/jig/xhtml.rb
 - lib/jig/xml.rb
+- test/jig.rb
+- test/jig_spec.rb
 - test/test_css.rb
 - test/test_jig.rb
+- test/test_parse.rb
 - test/test_xhtml.rb
 - test/test_xml.rb
+- todo
 test_files: 
 - test/test_css.rb
 - test/test_jig.rb
+- test/test_parse.rb
 - test/test_xhtml.rb
 - test/test_xml.rb
-rdoc_options: []
-
-extra_rdoc_files: []
-
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
 executables: []
 
 extensions: []
@@ -63,5 +73,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.2.0
+        version: 1.4.0
     version: