facets 1.8.49 → 1.8.51

data/work/more/range.rb

@@ -1,383 +0,0 @@
-=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

@@ -1,48 +0,0 @@
-# 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

@@ -1,735 +0,0 @@
-#--
-# 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