facets 1.4.5 → 1.7.0

data/snip/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