facets 1.7.46 → 1.8.0

data/work/more/range.rb

@@ -0,0 +1,383 @@
+=begin rdoc
+
+= Descrete Range Class
+
+This is the Range class slightly modified to be truly desecrete in nature.
+Use the Interval class (see interval.rb) for a truly continuious range class.
+
+== Synopsis
+
+The following code uses class +Xs+, which is defined in the
+class-level documentation.
+
+  require 'trix/range'
+
+  range = Xs.new(1)..Xs.new(10)
+  range.step(2) {|x| puts x}
+  range.step(3) {|x| puts x}
+
+_produces:_
+
+  1 x
+  3 xxx
+  5 xxxxx
+  7 xxxxxxx
+  9 xxxxxxxxx
+  1 x
+  4 xxxx
+  7 xxxxxxx
+  10 xxxxxxxxxx
+
+== Notes
+
+Range is not quite have descrete behavior becasue it also performs 
+double-duty as a continious interval class. Its just a bit too overloaded
+and this limits its full potential. To remedy, a separate Interval class
+has been created to handle true interval functionality. And here we 
+adjust Range to be truely discrete.
+ 
+Range originally dependened on two methods: #succ and #<=>. If numeric
+ranges were the only concern, those could just as well be #+ and #<=>,
+but esoteric forms make that unfeasible --the obvious example being a 
+String range. To properly handle this, Range fully seperates and extends
+the parallel methods: #succ for #+, #cmp for #<=> ( in the future we may
+add #pred for #- ). It also adds the option of #distance to properly
+calculate the difference between the sentinals. This is neccessary
+to ensure congruent bahavior. For instance, presently String Range's
+can give bad results because #<=> does not measure order in the same
+manner that #succ generates order.
+
+== Todo List
+
+* Add skip parameter, to allow skip-ranges, i.e. skipping successive iterations.
+
+== Author
+
+* Thomas Sawyer
+
+=end
+
+require 'carat/infinity'
+require 'carat/interval'
+
+
+class Range
+
+  alias_method :initialize_simple, :initialize
+  private :initialize_simple
+
+  def initialize( first, halt, exclude_last=false, &succ )
+    @first = first
+    @last = halt.kind_of?(Proc) ? nil : halt
+    @halt = @last ? nil : halt
+    #@exclude_first = exclude_first
+    @exclude_last = exclude_last
+    @direction = (@last <=> @first)
+    #@direction = 1 if @direction == 0
+    @succ = succ || nil #@first.method(:succ).to_proc
+    #@halt = nil #exclude_last? ? proc{ |x| x.cmp(@last) != -1 } : proc{ |x| x.cmp(@last) == 1 }
+    initialize_simple(@first, @last, @exclude_last)
+  end
+
+  def succ ; @succ ; end
+  
+  def succ!(s)
+   if @succ
+     @succ.call(s)
+   else
+     s.succ
+   end
+  end
+  
+  def succ=(succ_proc)
+    raise ArgumentError unless Proc === succ_proc
+    @succ = succ_proc
+  end
+  
+  def halt ; @halt ; end
+  
+  def halt?(s)
+    if @halt
+      @halt.call(s)
+    else
+     if @exclude_last
+       s.cmp(@last) != -1
+     else
+       s.cmp(@last) == 1
+     end
+    end
+  end
+  
+  def halt=(halt_proc)
+    raise ArgumentError unless Proc === halt_proc
+    @halt = halt_proc
+  end
+  
+  #def first ; @first ; end
+  #def last ; @last ; end    
+  #def exclude_first? ; @exclude_first ; end
+  #def exclude_last? ; @exclude_last ; end
+  alias exclude_last? exclude_end?
+  
+  def direction
+   @direction ||= (@last <=> @first)
+  end
+  
+  # poor names
+  #undef_method :begin
+  #undef_method :end
+  #undef_method :exclude_end?
+  
+  def -@ ;  Range.new( @first, @last, true, &@succ ) ; end
+  
+  def distance
+    return @last.distance(@first) if @last and @last.respond_to?(:distance)
+    self.to_a.length # should it just be nil instead?
+  end
+  alias_method( :length, :distance )
+  alias_method( :size, :distance )
+      
+  def min
+    (@first.cmp(@last) == -1) ? @first : @last
+  end
+  
+  def max
+    (@first.cmp(@last) == 1) ? @first : @last
+  end
+  
+  # +between?+ simply tests whether the given value falls
+  # between the sentinels by comparison. It does not 
+  # verify that the value is acutally in the range's sequence.
+  def between?(x)
+    #tf = exclude_first? ? 1 : 0
+    tl = exclude_last? ? -1 : 0
+    # if other classes handled Infinity in their <=> method
+    # (which probably they should) this clause would not be required
+    if first.kind_of?(InfinityClass)
+      ft = ((first <=> x) <= tf)
+    else
+      ft = (x <=> first) >= tf
+    end
+    if last.kind_of?(InfinityClass)
+      fl = ((last <=> x) >= tl)
+    else
+      fl = (x <=> last) <= tl
+    end
+    ft && fl
+  end
+  
+  # Is this proper alias of +===+?
+  alias_method( :===, :between? )
+  
+  # +include?+ is an alias for +member?+. It is like between
+  # but makes sure that the value is in the range sequence.
+  alias_method( :include?, :member? )
+
+  # Compares two ranges to see if they are equal
+  def eql?(other)
+    return false unless @first == other.first
+    other_last = other.exclude_last? ? other.last : other.last
+    if self.exclude_last? and not other.exclude_last?
+      return false unless self.last == other.last.succ
+    elsif other.exclude_last? and not self.exclude_last?
+      return false unless self.last.succ == other.last
+    else
+      return false unless @last == other.last
+    end
+    true
+  end
+
+  alias each_succ each
+  def each( &blk )
+    return each_succ( &blk ) unless @succ or @halt
+    if @halt
+      halt_proc = @halt
+    else
+      halt_proc = exclude_last? ? proc{ |x| x.cmp(@last) != -1 } : proc{ |x| x.cmp(@last) == 1 }
+    end   
+    #t = exclude_last? ? -1 : 0
+    s = @first
+    if @succ
+      #while (s <=> @last) == -1 or (s <=> @last) == t
+      until halt_proc.call(s)
+        yield(s)
+        @succ.call(s)
+      end
+    else
+      #while (s <=> @last) == -1 or (s <=> @last) == t
+      until halt_proc.call(s)
+        yield(s)
+        s.succ
+      end      
+    end
+  end
+  
+#   # each(n) where n is steps, if n is negative it is nth
+#   # I know, it's a neg num trick :( but I think it's
+#   # better then having another method like #each_nth,
+#   # cause then you'd need #to_a_nth, too, etc.
+#   def each(n=1)  # :yield:
+#     n = (length / n.abs) if n < 0
+#     n = n * direction
+#     i = first; i.succ(n) if exclude_first?
+#     t = exclude_last? ? -1 : 0
+#     while (i <=> last) == -1 or (i <=> last) == t
+#       yield(i)
+#       i.succ(n)
+#     end
+#   end
+    
+#   # each(n) where n is steps, if n is negative it is nth
+#   # I know, it's a neg num trick :( but I think it's
+#   # better then having another method like #each_nth,
+#   # cause then you'd need #to_a_nth, too, etc.
+#   def reverse_each(n=1)  # :yield:
+#     n = (length / n.abs) if n < 0
+#     n = n * direction
+#     i = last; i -= n if exclude_first?
+#     t = exclude_first? ? 1 : 0
+#     while (i <=> first) == 1 or (i <=> first) == t
+#       yield(i)
+#       i += n
+#     end
+#   end
+    
+#   def to_a(n=1)
+#     a=[]; each(n){|e| a << e}
+#     a
+#   end
+    
+    # Is this even desirable at this point?
+    # Sequences depend on #succ rather then #+
+    # so don't expect the same results from each!
+  # def to_seq
+  #   seed = exclude_first? ? first.succ : first
+  #   halt = exclude_last? ? proc{|x| (x <=> last) >= 0} : proc{|x| (x <=> last) > 0}
+  #   Sequence.new( seed, &halt )
+  # end
+    
+end
+
+
+
+=begin test
+
+
+  require 'test/unit'
+
+  class GeneralTest < Test::Unit::TestCase
+
+    def test_include_001
+      a = Range.new(1,10)
+      assert_equal(false, a.include?(0))
+      assert_equal(true, a.include?(1))
+      assert_equal(true, a.include?(2))
+      assert_equal(true, a.include?(9))
+      assert_equal(true, a.include?(10))
+      assert_equal(false, a.include?(11))
+    end
+
+    def test_include_002
+      a = Range.new(1,10,false,true)
+      assert_equal(false, a.include?(0))
+      assert_equal(true, a.include?(1))
+      assert_equal(true, a.include?(2))
+      assert_equal(true, a.include?(9))
+      assert_equal(false, a.include?(10))
+      assert_equal(false, a.include?(11))
+    end
+
+    def test_include_003
+      a = Range.new(1,10,true,false)
+      assert_equal(false, a.include?(0))
+      assert_equal(false, a.include?(1))
+      assert_equal(true, a.include?(2))
+      assert_equal(true, a.include?(9))
+      assert_equal(true, a.include?(10))
+      assert_equal(false, a.include?(11))
+    end
+
+    def test_include_004
+      a = Range.new(1,10,true,true)
+      assert_equal(false, a.include?(0))
+      assert_equal(false, a.include?(1))
+      assert_equal(true, a.include?(2))
+      assert_equal(true, a.include?(9))
+      assert_equal(false, a.include?(10))
+      assert_equal(false, a.include?(11))
+    end
+
+  end
+  
+  class LrgNumericTest < Test::Unit::TestCase
+    def test_include
+      a = Range.new(0,100000000)
+      assert_equal(true, a.include?(0))
+      assert_equal(true, a.include?(1000))
+      assert_equal(true, a.include?(1000000))
+      assert_equal(true, a.include?(100000000))
+      assert_equal(false, a.include?(INFINITY))
+    end
+    def test_include_with_step
+      a = Range.new(0,100000000)
+      assert_equal(true, a.include?(0))
+      assert_equal(true, a.include?(5))
+      assert_equal(true, a.include?(70007))
+      assert_equal(true, a.include?(5000005))
+      assert_equal(false, a.include?(INFINITY))
+    end
+  end
+  
+  class InfTest < Test::Unit::TestCase
+    def test_include?
+      a = Range.new(-INFINITY,-3)
+      assert_equal(true, a.include?(-INFINITY))
+      assert_equal(true, a.include?(-4))
+      assert_equal(true, a.include?(-3))
+      assert_equal(false, a.include?(-2))
+      assert_equal(false, a.include?(INFINITY))
+      a = Range.new(-INFINITY,-3,false,true)
+      assert_equal(true, a.include?(-INFINITY))
+      assert_equal(true, a.include?(-4))
+      assert_equal(false, a.include?(-3))
+      assert_equal(false, a.include?(-2))
+      assert_equal(false, a.include?(INFINITY))
+      a = Range.new(-3,INFINITY)
+      assert_equal(false, a.include?(-INFINITY))
+      assert_equal(false, a.include?(-4))
+      assert_equal(true, a.include?(-3))
+      assert_equal(true, a.include?(-2))
+      assert_equal(true, a.include?(INFINITY))
+      a = Range.new(-INFINITY,INFINITY)
+      assert_equal(true, a.include?(-INFINITY))
+      assert_equal(true, a.include?(-4))
+      assert_equal(true, a.include?(-3))
+      assert_equal(true, a.include?(-2))
+      assert_equal(true, a.include?(INFINITY))
+      a = Range.new(-3,-2)
+      assert_equal(false, a.include?(-INFINITY))
+      assert_equal(false, a.include?(-4))
+      assert_equal(true, a.include?(-3))
+      assert_equal(true, a.include?(-2))
+      assert_equal(false, a.include?(INFINITY))
+    end
+  end 
+  
+  class OrdinalTest < Test::Unit::TestCase
+    def test_include
+      a = Range.new('a','g')
+      #assert_equal(false, a.include?(-INFINITY))
+      assert_equal(true, a.include?('a'))
+      assert_equal(true, a.include?('c'))
+      assert_equal(false, a.include?('z'))
+      #assert_equal(false, a.include?(INFINITY))
+    end
+    #def test_error
+    #  assert_raises(ArgumentError) {
+    #    a = (-INFINITY..'z')
+    #  }
+    #end
+  end
+
+=end
+

data/work/more/sanitize.rb

@@ -0,0 +1,48 @@
+# Code from rubyonrails project (http://www.rubyonrails.com)
+# Temporarily here.
+
+require 'html/tokenizer'
+require 'html/node'
+
+VERBOTEN_TAGS = %w(form script) unless defined?(VERBOTEN_TAGS)
+VERBOTEN_ATTRS = /^on/i unless defined?(VERBOTEN_ATTRS)
+
+class String
+  # Sanitizes the given HTML by making form and script tags into regular
+  # text, and removing all "onxxx" attributes (so that arbitrary Javascript
+  # cannot be executed). Also removes href attributes that start with
+  # "javascript:".
+  #
+  # Returns the sanitized text.
+  def self.sanitize(html)
+    # only do this if absolutely necessary
+    if html.index("<")
+      tokenizer = HTML::Tokenizer.new(html)
+      new_text = ""
+
+      while token = tokenizer.next
+        node = HTML::Node.parse(nil, 0, 0, token, false)
+        new_text << case node
+          when HTML::Tag
+            if VERBOTEN_TAGS.include?(node.name)
+              node.to_s.gsub(/</, "&lt;")
+            else
+              if node.closing != :close
+                node.attributes.delete_if { |attr,v| attr =~ VERBOTEN_ATTRS }
+                if node.attributes["href"] =~ /^javascript:/i
+                  node.attributes.delete "href"
+                end
+              end
+              node.to_s
+            end
+          else
+            node.to_s.gsub(/</, "&lt;")
+        end
+      end
+
+      html = new_text
+    end
+
+    html
+  end
+end

data/work/more/superstruct.rb

@@ -0,0 +1,735 @@
+#--
+# SuperStruct
+# Copyright (c) 2005 Hal Fulton
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+#++
+
+# = SuperStruct
+#
+# This is an easy way to create Struct-like classes; it converts easily
+# between hashes and arrays, and it allows OpenStruct-like dynamic naming
+# of members.
+#
+# Unlike Struct, it creates a "real" class, and it has real instance variables 
+# with predictable names.
+#
+# A basic limitation is that the hash keys must be legal method names (unless
+# used with send()).
+#
+# Basically, ss["alpha"], ss[:alpha], ss[0], and ss.alpha all mean the same.
+#
+# == What It's Like
+#
+# It's like a Struct...
+#   - you can pass in a list of symbols for accessors
+#   - it will create a class for you
+# but...
+#   - you don't have to pass in the class name
+#   - it returns a "real" class
+#     . instance variables have the expected names
+#     . you can reopen and add methods
+#   - it doesn't go into the Struct:: namespace
+#   - it preserves the order of the fields
+#   - you can use Strings instead of Symbols for the names
+#
+# It's like an Array...
+#  - you can access the items by [number] and [number]=
+# but...
+#  - you can also access the items by ["name"] and ["name"]=
+#  - you can access the items by accessors
+#
+# It's like an OpenStruct...
+#  - (if you use .open instead of .new) you can add fields
+#    automatically with x.field or x.field=val
+# but...
+#  - you can initialize it like a Struct
+#  - it preserves the order of the fields
+#
+# It's like a Hash...
+#  - data can be accessed by ["name"]
+# but...
+#  - order (of entry or creation) is preserved
+#  - arbitrary objects are not allowed (it does obj.to_str or obj.to_s)
+#  - strings must be valid method names
+#
+# It's like Ara Howard's Named Array...
+#  - we can access elements by ["name"] or ["name"]=
+# but...
+#  - you can access the items by accessors
+#  - strings must be valid method names
+#
+# It's like Florian Gross's Keyed List...
+#  (to be done)
+# but...
+#  - it preserves the order of the fields
+#
+# == Usage
+#
+#   # Need not assign to existing fields (default to nil)
+#   myStruct = SuperStruct.new(:alpha)
+#   x = myStruct.new
+#   x.alpha  # nil
+#
+#   # A value assigned at construction may be retrieved
+#   myStruct = SuperStruct.new(:alpha)
+#   x = myStruct.new(234)
+#   x.alpha  # 234
+#
+#   # Unassigned fields are nil
+#   myStruct = SuperStruct.new(:alpha,:beta)
+#   x = myStruct.new(234)
+#   x.beta  # nil
+#
+#   # An open structure may not construct with nonexistent fields
+#   myStruct = SuperStruct.open
+#   x = myStruct.new(234)  # error
+#
+#   # An open structure may assign fields not previously existing
+#   myStruct = SuperStruct.open
+#   x = myStruct.new
+#   x.foo = 123
+#   x.bar = 456
+#
+#   # The act of retrieving a nonexistent field from an open struct will
+#   # create that field
+#   myStruct = SuperStruct.open
+#   x = myStruct.new
+#   x.foo   # nil
+#
+#   # A field (in an open struct) that is unassigned will be nil
+#   myStruct = SuperStruct.open
+#   x = myStruct.new
+#   y = x.foobar
+#
+#   # A struct created with new rather than open cannot reference nonexistent
+#   # fields
+#   myStruct = SuperStruct.new
+#   x = myStruct.new
+#   x.foo  # error
+#
+#   # Adding a field to a struct will create a writer and reader for that field
+#
+#   # An open struct will also create a writer and a reader together
+#
+#   # A field has a real writer and reader corresponding to it
+#
+#   # A string will work as well as a symbol
+#   myStruct = SuperStruct.new("alpha")
+#
+#   # to_a will return an array of values
+#   myStruct = SuperStruct.new("alpha","beta","gamma")
+#   x = myStruct.new(7,8,9)
+#   assert(x.to_a == [7,8,9])
+#
+#   # Instance method 'members' will return a list of members (as strings)
+#   myStruct = SuperStruct.new(:alpha,"beta")
+#   x = myStruct.new
+#   assert_equal(["alpha","beta"],x.members)
+#
+#   # Class method 'members' will return a list of members (as strings)
+#   myStruct = SuperStruct.new(:alpha,"beta")
+#   assert_equal(["alpha","beta"],myStruct.members)
+#
+#   # to_ary will allow a struct to be treated like an array in
+#   # multiple assignment
+#   myStruct = SuperStruct.new("alpha","beta","gamma")
+#   x = myStruct.new(7,8,9)
+#   a,b,c = x
+#   assert(b == 8)
+#
+#   # to_ary will allow a struct to be treated like an array in
+#   # passed parameters
+#   myStruct = SuperStruct.new("alpha","beta","gamma")
+#   x = myStruct.new(7,8,9)
+#   b = meth(*x)
+#
+#   # to_hash will return a hash with fields as keys
+#   myStruct = SuperStruct.new("alpha","beta","gamma")
+#   x = myStruct.new(7,8,9)
+#   h = x.to_hash
+#   assert_equal({"alpha"=>7,"beta"=>8,"gamma"=>9},h)
+#
+#   # A field name (String) may be used in a hash-like notation
+#   myStruct = SuperStruct.new("alpha","beta","gamma")
+#   x = myStruct.new(7,8,9)
+#   y = x["beta"]
+#
+#   # A field name (Symbol) may be used in a hash-like notation
+#   myStruct = SuperStruct.new("alpha","beta","gamma")
+#   x = myStruct.new(7,8,9)
+#   y = x[:beta]
+#
+#   # [offset,length] may be used as for arrays
+#   myStruct = SuperStruct.new("alpha","beta","gamma")
+#   x = myStruct.new(7,8,9)
+#   y = x[0,2]
+#
+#   # Ranges may be used as for arrays
+#   myStruct = SuperStruct.new("alpha","beta","gamma")
+#   x = myStruct.new(7,8,9)
+#   y = x[1..2]
+#
+#   # Adding a field to an open struct adds it to the instance
+#   myStruct = SuperStruct.open(:alpha)
+#   x = myStruct.new
+#   x.beta = 5
+#
+#   # Adding a field to an open struct adds it to the class also
+#   myStruct = SuperStruct.open(:alpha)
+#   x = myStruct.new
+#   x.beta = 5
+#
+#   # An array passed to SuperStruct.new need not be starred
+#   myStruct = SuperStruct.new(%w[alpha beta gamma])
+#   x = myStruct.new
+#
+#   # A hash passed to #set will set multiple values at once
+#   myStruct = SuperStruct.new(%w[alpha beta gamma])
+#   x = myStruct.new
+#   hash = {"alpha"=>234,"beta"=>345,"gamma"=>456}
+#   x.set(hash)
+#
+#   # ||= works properly
+#   x = SuperStruct.open.new
+#   x.foo ||= 333
+#   x.bar = x.bar || 444
+#
+#   # attr_tester will create a ?-method
+#   myStruct = SuperStruct.new(:alive)
+#   myStruct.attr_tester :alive
+#   x = myStruct.new(true)
+#   x.alive?  # true
+#
+#
+# == Author(s)
+#
+# * Hal Fulton
+#
+
+class SuperStruct
+
+  def SuperStruct.new(*args)
+    @table = []
+    @setsyms = []        # Setter symbols
+    klass = Class.new
+    if (args.size == 1) && (args[0].is_a? Array)
+      args = args[0]
+    end
+    strs = args.map {|x| x.to_s }
+    args.each_with_index do |k,i|
+      case
+      when (! [String,Symbol].include? k.class)
+        raise ArgumentError, "Need a String or Symbol"
+      when (strs[i] !~ /[_a-zA-Z][_a-zA-Z0-9]*/)
+        raise ArgumentError, "Illegal character"
+      end
+      k = k.intern if k.is_a? String
+      @table << k
+      @setsyms << (k.to_s + "=").intern
+      klass.instance_eval { attr_accessor k }
+    end
+
+    setsyms = @setsyms
+    table   = @table
+    vals    = @vals
+    klass.class_eval do
+      attr_reader :singleton
+      define_method(:initialize) do |*vals|
+        n = vals.size
+        m = table.size
+        case
+        when n < m
+          # raise ArgumentError, "Too few arguments (#{n} for #{m})"
+          # Never mind... extra variables will just be nil
+        when n > m
+          raise ArgumentError, "Too many arguments (#{n} for #{m})"
+        end
+        setsyms.each_with_index do |var,i|
+          self.send(var,vals[i])
+        end
+      end
+      define_method(:pretty_print) do |q|  # pp.rb support
+        q.object_group(self) do
+          q.seplist(self.members, proc { q.text "," }) do |member|
+#           self.members.each do |member|
+#           q.text ","  # unless q.first?
+            q.breakable
+            q.text member.to_s
+            q.text '='
+            q.group(1) do
+              q.breakable ''
+              q.pp self[member]
+            end
+          end
+        end
+      end
+      define_method(:inspect) do
+        str = "#<#{self.class}:"
+        table.each {|item| str << " #{item}=#{self.send(item)}" }
+        str + ">"
+      end
+      define_method(:[]) do |*index|
+        case index.map {|x| x.class }
+        when [Fixnum]
+          self.send(table[*index])
+        when [Fixnum,Fixnum], [Range]
+          table[*index].map {|x| self.send(x)}
+        when [String]
+          self.send(index[0].intern)
+        when [Symbol]
+          self.send(index[0])
+        else
+          raise ArgumentError,"Illegal index"
+        end
+      end
+      define_method(:[]=) do |*index|
+        value = index[-1]
+        index = index[0..-2]
+        case index.map {|x| x.class }
+          when [Fixnum]
+            self.send(table[*index])
+          when [Fixnum,Fixnum], [Range]
+            setsyms[*index].map {|x| self.send(x,value) }
+          when [String]
+            self.send(index[0].intern,value)
+          when [Symbol]
+            self.send(index[0],value)
+        else
+          raise ArgumentError,"Illegal index"
+        end
+      end
+      define_method(:to_a)    { table.map {|x| eval("@"+x.to_s) } }
+      define_method(:to_ary)  { to_a }
+      define_method(:members) { table.map {|x| x.to_s } }
+      define_method(:to_struct) do
+        mems = table
+        Struct.new("TEMP",*mems)
+        # Struct::TEMP.new(*vals) # Why doesn't this work??
+        data = mems.map {|x| self.send(x) }
+        Struct::TEMP.new(*data)
+      end
+      define_method(:to_hash) do
+        hash = {}
+        table.each do |mem|
+          mem = mem.to_s
+          hash.update(mem => self.send(mem))
+        end
+        hash
+      end
+      define_method(:set) {|h| h.each_pair {|k,v| send(k.to_s+"=",v) } }
+
+      # Class methods...
+
+      @singleton = class << self
+        self
+      end
+
+      @singleton.instance_eval do
+        define_method(:members) do
+          table.map {|x| x.to_s }
+        end
+        me = self
+        define_method(:attr_tester) do |*syms| 
+          syms.each {|sym| alias_method(sym.to_s+"?",sym) }
+        end
+      end
+
+    end
+    klass
+  end
+
+
+  def SuperStruct.open(*args)
+    klass = SuperStruct.new(*args)
+    table = @table
+    setsyms = @setsyms
+    table = @table
+    klass.class_eval do
+      define_method(:method_missing) do |meth, *args|
+        mname = meth.id2name
+        if mname =~ /=$/
+          getter = mname.chop
+          setter = mname
+        elsif mname =~ /\?$/
+          raise NoMethodError  # ?-methods are not created automatically
+        else
+          getter = mname
+          setter = mname + "="
+        end
+        gsym = getter.intern
+        ssym = setter.intern
+        ivar = "@" + getter
+        setsyms << setter
+        table << getter
+        len = args.length
+        if mname == getter
+          klass.class_eval do                 # getter
+            define_method(getter) do
+              instance_variable_get(ivar)
+            end
+          end
+        else
+          klass.class_eval do                 # setter
+            define_method(setter) do |*args|
+              if len != 1
+                raise ArgumentError, "Wrong # of arguments (#{len} for 1)", caller(1)
+              end
+              instance_variable_set(ivar,args[0])
+              instance_variable_get(ivar)
+            end
+          end
+        end
+        if mname == setter
+          self.send(setter,*args)
+        else
+          if len == 0
+            self.send(getter)
+          else
+            raise NoMethodError, "Undefined method '#{mname}' for #{self}", caller(1)
+          end
+        end
+      end
+    end
+    klass
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+#
+# SuperStruct test code
+# Hal Fulton
+# Version 1.0.1 (in sync with library code)
+# License: The Ruby License
+#
+
+require "test/unit"
+
+class Tester < Test::Unit::TestCase
+
+  def test001
+    # Must pass in String or Symbol
+    assert_raises(ArgumentError) { SuperStruct.new(0) }
+  end
+
+  def test002
+    # Must pass in valid name(s)
+    assert_raises(ArgumentError) { SuperStruct.new("###") }
+  end
+
+  def test003
+    # Can't assign to nonexistent fields
+    myStruct = SuperStruct.new
+    assert_raises(ArgumentError) { myStruct.new(345) }
+  end
+
+  def test004
+    # Need not assign to existing fields (default to nil)
+    myStruct = SuperStruct.new(:alpha)
+    assert_nothing_raised(ArgumentError) { myStruct.new }
+  end
+
+  def test005
+    # A value assigned at construction may be retrieved
+    myStruct = SuperStruct.new(:alpha)
+    x = myStruct.new(234)
+    assert(x.alpha == 234)
+  end
+
+  def test006
+    # Unassigned fields are nil
+    myStruct = SuperStruct.new(:alpha,:beta)
+    x = myStruct.new(234)
+    assert(x.beta == nil)
+  end
+
+  def test007
+    # An open structure still may not construct with nonexistent fields
+    myStruct = SuperStruct.open
+    assert_raises(ArgumentError) { x = myStruct.new(234) }
+  end
+
+  def test008
+    # An open structure may assign fields not previously existing
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    assert_nothing_raised { x.foobar = 123 }
+  end
+
+  def test009
+    # A field assigned to an open struct after its construction may be retrieved
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    x.foobar = 123
+    assert(x.foobar == 123)
+  end
+
+  def test010
+    # The act of retrieving a nonexistent field from an open struct will
+    # create that field
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    assert_nothing_raised { y = x.foobar }
+  end
+
+  def test011
+    # A field (in an open struct) that is unassigned will be nil
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    y = x.foobar
+    assert(y == nil)
+  end
+
+  def test012
+    # A struct created with new rather than open cannot reference nonexistent
+    # fields
+    myStruct = SuperStruct.new
+    x = myStruct.new
+    assert_raises(NoMethodError) { y = x.foobar }
+  end
+
+  def test013
+    # Adding a field to a struct will create a writer and reader for that field
+    myStruct = SuperStruct.new(:alpha)
+    x = myStruct.new
+    x.send(:alpha=,1)
+    assert(x.alpha == 1)
+  end
+
+  def test014
+    # Only a single value may be passed to a writer (for code coverage)
+    myStruct = SuperStruct.new(:alpha)
+    x = myStruct.new
+    assert_raises(ArgumentError) { x.send(:alpha=,1,2) }
+  end
+
+  def test015
+    # An open struct will also create a writer and a reader together
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    x.send(:alpha=,1)
+    assert(x.alpha == 1)
+  end
+
+  def test016
+    # Only a single value may be passed to a writer (for code coverage)
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    assert_raises(ArgumentError) { x.send(:alpha=,1,2) }
+  end
+
+  def test017
+    # A field has a real writer and reader corresponding to it
+    myStruct = SuperStruct.new(:alpha)
+    x = myStruct.new
+    assert(myStruct.instance_methods.include?("alpha"))
+    assert(myStruct.instance_methods.include?("alpha="))
+  end
+
+  def test018
+    # Creating a field by retrieval in an open struct will NOT create a writer 
+    # (This behavior has changed!)
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    y = x.alpha
+    assert(myStruct.instance_methods.include?("alpha"))
+    assert(!myStruct.instance_methods.include?("alpha="))
+  end
+
+  def test019
+    # Creating a field by writing in an open struct will NOT create a reader
+    # (This behavior has changed!)
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    x.alpha = 5
+    assert(myStruct.instance_methods.include?("alpha="))
+    assert(!myStruct.instance_methods.include?("alpha"))
+  end
+
+  def test020
+    # A string will work as well as a symbol
+    myStruct = SuperStruct.new("alpha")
+    x = myStruct.new
+    assert(myStruct.instance_methods.include?("alpha"))
+    assert(myStruct.instance_methods.include?("alpha="))
+  end
+
+  def test021
+    # to_a will return an array of values
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    assert(x.to_a == [7,8,9])
+  end
+
+  def test022
+    # Instance method 'members' will return a list of members (as strings)
+    myStruct = SuperStruct.new(:alpha,"beta")
+    x = myStruct.new
+    assert_equal(["alpha","beta"],x.members)
+  end
+
+  def test023
+    # Class method 'members' will return a list of members (as strings)
+    myStruct = SuperStruct.new(:alpha,"beta")
+    assert_equal(["alpha","beta"],myStruct.members)
+  end
+
+  def test024
+    # to_ary will allow a struct to be treated like an array in
+    # multiple assignment
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    a,b,c = x
+    assert(b == 8)
+  end
+
+     def aux025(*arr)  # Just used in test 25
+       arr[1]
+     end
+
+  def test025
+    # to_ary will allow a struct to be treated like an array in
+    # passed parameters
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    b = aux025(*x)
+    assert(b == 8)
+  end
+
+  def test026
+    # to_hash will return a hash with fields as keys
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    h = x.to_hash
+    assert_equal({"alpha"=>7,"beta"=>8,"gamma"=>9},h)
+  end
+
+  def test027
+    # A field name (String) may be used in a hash-like notation
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    y = x["beta"]
+    assert(8,y)
+  end
+
+  def test028
+    # A field name (Symbol) may be used in a hash-like notation
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    y = x[:beta]
+    assert(8,y)
+  end
+
+  def test029
+    # [offset,length] may be used as for arrays
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    y = x[0,2]
+    assert([7,8],y)
+  end
+
+  def test030
+    # Ranges may be used as for arrays
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    y = x[1..2]
+    assert([8,9],y)
+  end
+  
+  def test031
+    # Adding a field to an open struct adds it to the instance
+    myStruct = SuperStruct.open(:alpha)
+    x = myStruct.new
+    x.beta = 5
+    assert_equal(["alpha","beta"],x.members)
+  end
+  
+  def test032
+    # Adding a field to an open struct adds it to the class also
+    myStruct = SuperStruct.open(:alpha)
+    x = myStruct.new
+    x.beta = 5
+    assert_equal(["alpha","beta"],myStruct.members)
+  end
+  
+  def test033
+    # An array passed to SuperStruct.new need not be starred
+    myStruct = SuperStruct.new(%w[alpha beta gamma])
+    x = myStruct.new
+    assert_equal(%w[alpha beta gamma],x.members)
+  end
+
+  def xtest034
+    # A hash passed to SuperStruct.new will initialize the values
+    # (but order will not be predictable!)
+    assert false, "Not implemented yet."
+  end
+
+  def test035
+    # A hash passed to #set will set multiple values at once
+    myStruct = SuperStruct.new(%w[alpha beta gamma])
+    x = myStruct.new
+    hash = {"alpha"=>234,"beta"=>345,"gamma"=>456}
+    x.set(hash)
+    assert_equal([234,345,456], x.to_a)
+  end
+
+  def test036
+    # Make sure ||= works properly
+    x = SuperStruct.open.new
+    x.foo ||= 333
+    x.bar = x.bar || 444
+    assert_equal(333,x.foo)
+    assert_equal(444,x.bar)
+  end
+
+  def test037
+    # A simple array index works ok
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    assert_equal(7,x[0])
+    assert_equal(8,x[1])
+    assert_equal(9,x[2])
+  end
+
+  def test038
+    # attr_tester will create a ?-method
+    klass = SuperStruct.new(:alpha,:beta,:gamma)
+    klass.attr_tester :alpha, :gamma
+    x = klass.new(22,33,nil)
+    assert(x.alpha?)
+    assert_raises(NoMethodError) { x.beta? }
+    assert(! x.gamma?)
+  end
+
+  def test039
+    # attr_tester works with open() (?-methods not created)
+    klass = SuperStruct.open(:alpha,:beta,:gamma)
+    klass.attr_tester :alpha, :gamma
+    x = klass.new(22,33,nil)
+    assert(x.alpha?)
+    assert_raises(NoMethodError) { x.beta? }  # ?-methods are not automatic
+    assert(! x.gamma?)
+  end
+
+end
+
+=end