grayswx-dynastruct 0.0.3 → 0.0.4

data/Rakefile

@@ -1,5 +1,10 @@
-%w'dynastruct rubygems rake/clean rake/testtask
-   rake/gempackagetask'.each {|w| require w }
+%w'
+lib/dynastruct
+rubygems
+rake/clean
+rake/testtask   
+rake/gempackagetask
+'.each {|w| require w }
 
 task :default => [:test]
 
@@ -9,20 +14,19 @@ end
 
 spec = Gem::Specification.new do |s|
   s.name = 'dynastruct'
-  s.version = '0.0.3'
-  s.summary = 'Structs that can change their shape on the fly.'
+  s.version = '0.0.4'
+  s.summary = 'Structs that change based upon their contents.'
   s.author = 'grayswx'
   s.homepage = 'http://github.com/grayswx/dynastruct/tree/master'
   s.rubyforge_project = 'n/a'
   s.email = 'grayswx@gmail.com'
-  s.files = FileList['[A-Z]*', '*.rb', '{lib,test}/**/*']
-  s.require_paths = ['.', 'lib']
+  s.files = FileList['[A-Z]*', '{lib,test}/**/*']
   s.has_rdoc = true
 end
 
 Rake::GemPackageTask.new spec do |pkg|
-#  pkg.need_tar = true
-#  pkg.need_zip = true
+  pkg.need_tar = true
+  pkg.need_zip = true
 end
 
 desc "Generate a gemspec file for GitHub"

data/lib/dynastruct.rb

@@ -0,0 +1,16 @@
+$:.unshift $_ unless $:.include?($_ = File.dirname(__FILE__))
+
+module Dynastruct
+
+  class NoProcError < StandardError; end
+  class ValidationError < StandardError; end
+  class KeyError < StandardError; end
+
+end
+
+%w'
+dynastruct/field.rb
+dynastruct/key.rb
+dynastruct/struct.rb
+'.each {|l| require l }
+

data/lib/dynastruct/field.rb

@@ -0,0 +1,78 @@
+module Dynastruct
+  class Field
+
+    # Creates a new kind of Field with the given validators.
+    def initialize( *validators )
+      @validators = validators or []
+    end
+
+    ##### Usage Methods
+
+    # Tests whether or not the given object is a valid object for this field
+    def valid?( target )
+      @validators.all? {|v| v[target]}
+    end
+
+    # Reads an object of this field type from an IO stream.
+    def read( ios )
+      raise NoProcError, "Field type cannot read." unless @reader
+      @reader[ios]
+    end
+
+    # Writes an object to an IO stream.
+    def write( object, ios )
+      raise NoProcError, "Field type cannot write." unless @writer
+      @writer[object, ios]
+    end
+
+    ##### Creation Methods
+
+    # Adds a validator to the object.
+    def add_validator( &validator )
+      @validators << validator
+    end
+
+    # Sets the reader for this field.
+    def reader( &proc )
+      @reader = proc
+    end
+
+    # Sets the writer for this field.
+    def writer( &proc )
+      @writer = proc
+    end
+
+    ##### Shortcut creation methods.
+
+    # Makes a shortcut field creator of the given type.
+    def self.make_shortcut( name, test, validator )
+      temp, $bypass = $bypass, [name, test, validator]
+      class << self
+        make_shortcut(*$bypass)
+      end
+      $bypass = temp
+    end
+    class << self
+      def self.make_shortcut( name, test, validator )
+        define_method "of_#{name}".to_sym do |type|
+          fieldvar = "@fields_of_#{name}".to_sym
+          intern_hash = instance_variable_get fieldvar
+          unless intern_hash
+            intern_hash = {}
+            instance_variable_set fieldvar, intern_hash
+          end
+          raise ArgumentError, 'Wrong type provided.' unless test[type]
+          intern_hash[type] ||= self.new(lambda {|o| validator[type, o]})
+        end
+      end
+    end
+
+    make_shortcut('class',
+                  lambda {|t| t.kind_of? Class },
+                  lambda {|t,o| o.kind_of? t })
+    make_shortcut('method',
+                  lambda {|t| t.kind_of? Symbol },
+                  lambda {|t,o| o.respond_to? t })
+
+  end
+end

data/lib/dynastruct/key.rb

@@ -0,0 +1,164 @@
+module Dynastruct
+  class Key < Field
+
+    Tuple = ::Struct.new :index, :hooks, :type
+
+    # Creates a new Key.
+    # Fields is a list of fields which trigger the test.
+    def initialize( parent = nil, *fields, &test )
+
+      super(lambda do |struct|
+              struct.key.ancestor? self
+            end)
+      reader do |ios|
+        struct = Struct.new self
+        # Must do a manual loop here because size can change on the fly.
+        index = 0
+        while index < struct.key.size do
+          struct[index] = struct.key[index].read ios
+          index += 1
+        end
+      end
+      writer do |struct, ios|
+        struct.each_index do |i|
+          struct.key[i].write struct[i], ios
+        end
+      end
+
+      @fields = {}
+      @fields_i = []
+      @children = []
+      if parent then
+        @size = parent.size
+        @parent = parent
+        @test = test
+        parent.add_child self
+        parent.add_hooks fields, self
+      else
+        raise ArgumentError, "Cannot transform with no parent." if test or not fields.empty?
+        @size = 0
+        @parent = nil
+      end
+    end
+
+    ##### Usage Methods
+
+    attr_reader :size, :parent
+
+    # Returns the index of a field name or index.
+    # Also makes sure that the field exists.
+    def index( name )
+      # If an index.
+      if name.kind_of? Integer then
+        raise KeyError, 'Key out of bounds.' unless name >= 0 and name < size
+        return name
+      end
+      # If a String or Symbol.
+      name = name.to_sym
+      field = @fields[name]
+      return field.index if field
+      return @parent.index(name) if @parent
+      raise KeyError, 'Key does not exist.'
+    end
+
+    # Returns a hash of names to field types.
+    def fields()
+      base = @parent ? @parent.fields : {}
+      @fields.each do |key, val|
+        base[key] = val.type
+      end
+      base
+    end
+
+    # Returns the field with the given index or name.
+    def field( field )
+      field = index_to_field field if field.kind_of? Integer
+      @fields[field.to_sym].type
+    end
+    alias :[] :field
+
+    # Returns the children of this key.
+    def children()
+      @children.dup
+    end
+
+    # Returns whether or not the given key is an ancestor.
+    def ancestor?( key )
+      return true if self == key
+      return @parent.ancestor? key if @parent
+      false
+    end
+
+    # Returns the new key that results from assigning
+    # a given value to a given field.
+    # A ValidationError occurs if the assignment is not valid.
+    def update( struct, field, value )
+      field = index_to_field field if field.kind_of? Integer
+      field = field.to_sym
+      raise KeyError, 'Key not present' unless @fields.key? field
+      field = @fields[field]
+      if field.type.valid? value then
+        yield field.index
+        return catch(:hook_match) do
+          field.hooks.each do |key|
+            throw :hook_match, key if key.test_hook struct
+          end
+          self
+        end
+      end
+      raise ValidationError, 'Value not valid.'
+    end
+
+    ##### Helper Methods
+
+    # Converts an index to a field name.
+    def index_to_field( index )
+      raise KeyError, 'Key out of bounds' if index < 0 or index >= size
+      psize = @parent ? @parent.size : 0
+      return @parent.index_to_field index if index < psize
+      @fields_i[index - psize]
+    end
+    
+    # Increments this and child keys' indices by 1.
+    def increment_indices() 
+      @size += 1
+      @fields.each do |key, tuple|
+        tuple.index += 1
+      end
+      @children.each do |child|
+        child.increment_indices
+      end
+    end
+
+    # Tests if the struct meets the specified criteria for 
+    # transforming to this key.
+    def test_hook( struct )
+      @test[struct]
+    end
+
+    ##### Creation Methods
+
+    # Registers a field with a name.
+    def register( name, field )
+      name = name.to_sym
+      @fields[name] = Tuple.new @size, [], field
+      @fields_i[@size] = name
+      @size += 1
+      @children.each {|c| c.increment_indices }
+    end
+
+    # Adds a child to this key.
+    def add_child( child )
+      @children << child
+    end
+
+    # Adds hooks to this key.
+    def add_hooks( hooks, key )
+      hooks.each do |hook|
+        @fields[hook.to_sym].hooks << key
+      end
+    end
+
+  end
+end
+

data/lib/dynastruct/struct.rb

@@ -0,0 +1,32 @@
+module Dynastruct
+  class Struct
+
+    def initialize( key )
+      @key = key
+      @data = []
+    end
+
+    attr_reader :key
+
+    # Gets the element of the struct.
+    def []( field )
+      @data[@key.index field]
+    end
+
+    # Assigns the element of the struct.
+    def []=( field, value )
+      @key = @key.update self, field, value do |i|
+        @data[i] = value
+      end
+    end
+
+    def each( &proc )
+      @data.each &proc
+    end
+
+    def each_index( &proc )
+      @data.each_index &proc
+    end
+
+  end
+end

data/test/dynastruct/field_test.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), '../test_helper')
+module Dynastruct
+  class FieldTest < Test::Unit::TestCase
+
+    context 'A new Field' do
+
+      setup do
+        @field = Field.new
+      end
+      should 'validate anything' do
+        @field.valid?(nil).should be true
+        @field.valid?(42).should be true
+      end
+      should 'not be able to read' do
+        lambda{@field.read(StringIO.new)}.should raise_error NoProcError
+      end
+      should 'not be able to write' do
+        lambda{@field.write('', StringIO.new)}.should raise_error NoProcError
+      end
+
+      context 'with a direct writer' do 
+        setup do
+          @field.writer {|v,o| o.write v }
+        end
+        should 'write out "abc"' do
+          ios = StringIO.new
+          @field.write 'abc', ios
+          ios.string.should be 'abc'
+        end
+      end
+
+      context 'with a direct word reader' do
+        setup do
+          @field.reader {|i| i.gets(' ').strip }
+        end
+        should 'read in "abc"' do
+          ios = StringIO.new 'abc'
+          @field.read(ios).should be 'abc'
+        end
+      end
+
+    end
+    
+    context 'A new Field of class Integer' do
+      setup do
+        @field = Field.of_class Integer
+      end
+      should "validate Integers." do
+        @field.valid?(42).should be true
+        @field.valid?(0).should be true
+      end
+      should "not validate non Integers." do
+        @field.valid?('hello').should be false
+        @field.valid?(45.5).should be false
+      end
+      should 'intern' do
+        @field.should be Field.of_class Integer
+      end
+    end
+
+    context 'A new Field of method :to_str' do
+      setup do
+        @field = Field.of_method :to_str
+      end
+      should 'validate Strings.' do
+        @field.valid?('hello').should be true
+        @field.valid?('').should be true
+      end 
+      should 'not validate Numerics.' do
+        @field.valid?(42).should be false
+        @field.valid?(1.5).should be false
+      end
+      should 'intern' do
+        @field.should be Field.of_method :to_str
+      end
+    end
+
+  end
+end

data/test/dynastruct/key_test.rb

@@ -0,0 +1,167 @@
+#!/usr/bin/env ruby
+### XXX Test the read / write actions.  Maybe in Struct?
+require File.join(File.dirname(__FILE__), '../test_helper')
+module Dynastruct
+  class DKeyTest < Test::Unit::TestCase
+
+    context 'A new Key' do
+      
+      setup { @key = Key.new }
+      
+      should 'have no children' do
+        @key.children.empty?.should be true
+      end
+      should 'have no parent' do
+        @key.parent.should be nil
+      end
+      should 'have 0 elements' do
+        @key.size.should be 0
+      end
+      should 'have no fields' do 
+        @key.fields.empty?.should be true
+      end
+      should 'have itself as an ancestor' do
+        @key.ancestor?(@key).should be true
+      end
+      should 'raise a KeyError when trying to update' do
+        lambda{@key.update(nil,:aoe,42)}.should raise_error KeyError
+      end
+      should 'raise a KeyError when trying to find a field' do
+        lambda{@key.field(0)}.should raise_error KeyError
+      end
+      should 'raise a KeyError when accessing a non-existant index' do
+        lambda{@key.index(:c)}.should raise_error KeyError
+        lambda{@key.index(15)}.should raise_error KeyError
+      end
+
+      context 'with a child' do
+
+        setup { @child = Key.new @key }
+
+        should 'have 1 child' do
+          @key.children.size.should be 1
+        end
+        
+        context 'and a grandchild' do
+          
+          setup { @grand = Key.new @child }
+
+          should 'have the correct ancestors' do
+            @grand.ancestor?(@key).should be true
+            @grand.ancestor?(@child).should be true
+            @child.ancestor?(@key).should be true
+            @key.ancestor?(@child).should be false
+            @key.ancestor?(@grand).should be false
+          end
+
+          should 'correctly validate Structs' do
+            @k_s = Struct.new @key
+            @c_s = Struct.new @child
+            @g_s = Struct.new @grand
+            @key.valid?(@k_s).should be true
+            @key.valid?(@c_s).should be true
+            @key.valid?(@g_s).should be true
+            @child.valid?(@k_s).should be false
+            @child.valid?(@g_s).should be true
+            @grand.valid?(@c_s).should be false
+          end
+        end
+      end
+      
+    end
+
+    context 'A Key with two strict fields' do
+      
+      setup do
+        @key = Key.new
+        @str_field = Field.of_class String
+        @int_field = Field.of_class Integer
+        @key.register 'str', @str_field
+        @key.register :int, @int_field
+      end
+
+      should 'have the correct fields' do
+        @key.fields.should be(
+                              {:str => @str_field, :int => @int_field})
+      end
+
+      should 'return the correct fields' do
+        @key.field(0).should be @str_field
+        @key.field(1).should be @int_field
+        @key.field(:str).should be @str_field
+        @key.field('int').should be @int_field
+      end
+
+      should 'have the correct indices' do
+        @key.index(:str).should be 0
+        @key.index('int').should be 1
+        @key.index(1).should be 1
+      end
+
+      should 'return itself when updated correctly' do
+        @key.update(nil, 'str', 'abc'){}.should be @key
+        @key.update(nil, 'int', 12345){}.should be @key
+      end
+
+      should 'raise a ValidationError when updated incorrectly' do
+        lambda{@key.update(nil, :str, 123){}}.should raise_error ValidationError
+        lambda{@key.update(nil, :int, 'p'){}}.should raise_error ValidationError
+      end
+
+      context 'and a child with 1 field.' do 
+
+        setup {
+          @child = Key.new @key
+          @child.register :i2, @int_field
+        }
+
+        context 'The child' do
+          should 'have the correct size' do
+            @child.size.should be 3
+          end
+          should 'have the correct indices' do
+            @child.index(:int).should be 1
+            @child.index('i2').should be 2
+          end
+          should 'have the correct fields' do
+            @child.fields.should be(
+                                    {:str => @str_field, :int => @int_field, :i2 => @int_field})
+          end
+        end
+
+        context 'The parent' do
+          should 'have the correct fields' do
+            @key.fields.should be(
+                                  {:str => @str_field, :int => @int_field})
+          end
+
+          should 'have the correct indices' do
+            @key.index('str').should be 0
+            @key.index(:int).should be 1
+          end
+        end
+        
+        context 'When the parent is updated. The child' do
+          
+          setup { @key.register :s2, @str_field }
+
+          should 'update its fields' do
+            @child.fields.should be(
+                                    {:str => @str_field, :int => @int_field,
+                                      :s2  => @str_field,  :i2 => @int_field})
+          end
+
+          should 'update its indices' do
+            @child.index(:s2).should be 2
+            @child.index(:i2).should be 3
+          end
+
+          should 'update its size' do
+            @child.size.should be 4
+          end
+
+        end
+      end
+    end
+  end
+end

data/test/dynastruct/struct_test.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), '../test_helper')
+module Dynastruct
+  class StructTest < Test::Unit::TestCase
+    
+    context 'A new Struct of a 1 element key' do
+
+      setup do
+        @field = Field.of_class Integer
+        @key = Key.new
+        @key.register :a, @field
+        @struct = Struct.new @key
+      end
+
+      should 'raise a KeyError when a non-existant field is accessed or assigned' do
+        lambda{@struct['b']}.should raise_error KeyError
+        lambda{@struct[:x] = 42}.should raise_error KeyError
+      end
+
+      should 'correctly store data' do
+        @struct[:a].should be nil
+        @struct['a'] = 42
+        @struct['a'].should be 42
+      end
+
+      should 'raise a ValidationError when incorrectly assigned' do
+        lambda{@struct['a'] = 'abc'}.should raise_error ValidationError
+      end
+
+    end
+
+    context 'A transforming struct' do
+      
+      setup do
+        @f_str = Field.of_class String
+        @f_sym = Field.of_class Symbol
+        @f_int = Field.of_class Integer
+        @k_base = Key.new
+        @k_base.register :type, @f_sym
+        @k_base.register :typ2, @f_sym
+
+        @k_date = Key.new(@k_base, :type) do |s|
+          s[:type] == :date
+        end
+        @k_date.register :date, @f_str
+
+        @k_nums = Key.new(@k_base, :type, :typ2) do |s|
+          s[:type] == :num and s[:typ2] == :s
+        end
+        @k_nums.register :num1, @f_int
+        @k_nums.register :num2, @f_int
+        @k_nums.register :num3, @f_int
+
+        @k_same = Key.new(@k_base, :typ2) do |s|
+          s[:type] == s[:typ2]
+        end
+
+        @struct = Struct.new @k_base
+      end      
+      
+      should 'be able to start as a child' do
+        a = Struct.new @k_date
+        a[:date] = 'today'
+      end
+
+      should 'transform into the date structure' do
+        @struct[:type] = :date
+        @struct.key.should be @k_date
+      end
+
+      should 'transform into the nums structure' do
+        @struct[:type] = :num
+        @struct[:typ2] = :a
+        @struct.key.should be @k_base
+        @struct[:typ2] = :s
+        @struct.key.should be @k_nums
+      end
+
+      should 'only transform when the selected key is changed' do
+        @struct[:typ2] = :a
+        @struct[:type] = :a
+        @struct.key.should be @k_base
+        @struct[:typ2] = :a
+        @struct.key.should be @k_same
+      end
+
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -1,2 +1,2 @@
-require File.join(File.dirname(__FILE__), '../dynastruct')
-%w'rubygems shoulda matchy stringio'.each {|w| require w }
+require File.join(File.dirname(__FILE__), '../lib/dynastruct')
+%w'rubygems shoulda matchy'.each {|w| require w }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: grayswx-dynastruct
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - grayswx
@@ -24,23 +24,22 @@ extra_rdoc_files: []
 files: 
 - README
 - Rakefile
-- te.rb
-- dynastruct.rb
-- lib/d_key.rb
-- lib/d_exceptions.rb
-- lib/d_struct.rb
-- lib/d_field.rb
-- test/d_struct_test.rb
-- test/d_key_test.rb
+- lib/dynastruct
+- lib/dynastruct/struct.rb
+- lib/dynastruct/key.rb
+- lib/dynastruct/field.rb
+- lib/dynastruct.rb
+- test/dynastruct
+- test/dynastruct/key_test.rb
+- test/dynastruct/field_test.rb
+- test/dynastruct/struct_test.rb
 - test/test_helper.rb
-- test/d_field_test.rb
 has_rdoc: true
 homepage: http://github.com/grayswx/dynastruct/tree/master
 post_install_message: 
 rdoc_options: []
 
 require_paths: 
-- .
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
@@ -60,6 +59,6 @@ rubyforge_project: n/a
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
-summary: Structs that can change their shape on the fly.
+summary: Structs that change based upon their contents.
 test_files: []
 

data/dynastruct.rb

@@ -1,3 +0,0 @@
-path = File.join(File.dirname(File.expand_path(__FILE__)), 'lib')
-$:.unshift path unless $:.include? path
-require 'd_struct'

data/lib/d_exceptions.rb

@@ -1,5 +0,0 @@
-class NoProcError < StandardError; end
-class ValidationError < StandardError; end
-class KeyError < StandardError; end
-
-

data/lib/d_field.rb

@@ -1,78 +0,0 @@
-require 'd_exceptions'
-
-class DField
-
-  # Creates a new kind of DField.
-  def initialize( *validators )
-    @validators = validators or []
-  end
-
-##### Usage Methods
-
-  # Tests whether or not the given object is a valid object for this field
-  def valid?( target )
-    @validators.all? {|v| v[target]}
-  end
-
-  # Reads an object of this field type from an IO stream.
-  def read( ios )
-    raise NoProcError, "Field type cannot read." unless @reader
-    @reader[ios]
-  end
-
-  # Writes an object to an IO stream.
-  def write( object, ios )
-    raise NoProcError, "Field type cannot write." unless @writer
-    @writer[object, ios]
-  end
-
-##### Creation Methods
-
-  # Adds a validator to the object.
-  def add_validator( &validator )
-    @validators << validator
-  end
-
-  # Sets the reader for this field.
-  def reader( &proc )
-    @reader = proc
-  end
-
-  # Sets the writer for this field.
-  def writer( &proc )
-    @writer = proc
-  end
-
-##### Shortcut creation methods.
-
-  # Makes a shortcut field creator of the given type.
-  def self.make_shortcut( name, test, validator )
-    temp, $bypass = $bypass, [name, test, validator]
-    class << self
-      make_shortcut(*$bypass)
-    end
-    $bypass = temp
-  end
-  class << self
-    def self.make_shortcut( name, test, validator )
-      define_method "of_#{name}".to_sym do |type|
-        fieldvar = "@fields_of_#{name}".to_sym
-        intern_hash = instance_variable_get fieldvar
-        unless intern_hash
-          intern_hash = {}
-          instance_variable_set fieldvar, intern_hash
-        end
-        raise ArgumentError, 'Wrong type provided.' unless test[type]
-        intern_hash[type] ||= self.new(lambda {|o| validator[type, o]})
-      end
-    end
-  end
-
-  make_shortcut('class',
-                lambda {|t| t.kind_of? Class },
-                lambda {|t,o| o.kind_of? t })
-  make_shortcut('method',
-                lambda {|t| t.kind_of? Symbol },
-                lambda {|t,o| o.respond_to? t })
-
-end

data/lib/d_key.rb

@@ -1,165 +0,0 @@
-require 'd_field'
-
-class DKey < DField
-
-  Tuple = Struct.new :index, :hooks, :type
-
-  # Creates a new DKey.
-  # Fields is a list of fields which trigger the test.
-  def initialize( parent = nil, *fields, &test )
-
-    super(lambda do |struct|
-            struct.key.ancestor? self
-          end)
-    reader do |ios|
-      struct = DStruct.new self
-      # Must do a manual loop here because size can change on the fly.
-      index = 0
-      while index < struct.key.size do
-        struct[index] = struct.key[index].read ios
-        index += 1
-      end
-    end
-    writer do |struct, ios|
-      struct.each_index do |i|
-        struct.key[i].write struct[i], ios
-      end
-    end
-
-    @fields = {}
-    @fields_i = []
-    @children = []
-    if parent then
-      @size = parent.size
-      @parent = parent
-      @test = test
-      parent.add_child self
-      parent.add_hooks fields, self
-    else
-      raise ArgumentError, "Cannot transform with no parent." \
-          if test or not fields.empty?
-      @size = 0
-      @parent = nil
-    end
-
-  end
-
-##### Usage Methods
-
-  attr_reader :size, :parent
-
-  # Returns the index of a field name or index.
-  # Also makes sure that the field exists.
-  def index( name )
-    # If an index.
-    if name.kind_of? Integer then
-      raise KeyError, 'Key out of bounds.' unless name >= 0 and name < size
-      return name
-    end
-    # If a String or Symbol.
-    name = name.to_sym
-    field = @fields[name]
-    return field.index if field
-    return @parent.index(name) if @parent
-    raise KeyError, 'Key does not exist.'
-  end
-
-  # Returns a hash of names to field types.
-  def fields()
-    base = @parent ? @parent.fields : {}
-    @fields.each do |key, val|
-      base[key] = val.type
-    end
-    base
-  end
-
-  # Returns the field with the given index or name.
-  def field( field )
-    field = index_to_field field if field.kind_of? Integer
-    @fields[field.to_sym].type
-  end
-  alias :[] :field
-
-  # Returns the children of this key.
-  def children()
-    @children.dup
-  end
-
-  # Returns whether or not the given key is an ancestor.
-  def ancestor?( key )
-    return true if self == key
-    return @parent.ancestor? key if @parent
-    false
-  end
-
-  # Returns the new key that results from assigning
-  # a given value to a given field.
-  # A ValidationError occurs if the assignment is not valid.
-  def update( struct, field, value )
-    field = index_to_field field if field.kind_of? Integer
-    field = field.to_sym
-    raise KeyError, 'Key not present' unless @fields.key? field
-    field = @fields[field]
-    if field.type.valid? value then
-      yield field.index
-      return catch(:hook_match) do
-        field.hooks.each do |key|
-          throw :hook_match, key if key.test_hook struct
-        end
-        self
-      end
-    end
-    raise ValidationError, 'Value not valid.'
-  end
-
-##### Helper Methods
-
-  # Converts an index to a field name.
-  def index_to_field( index )
-    raise KeyError, 'Key out of bounds' if index < 0 or index >= size
-    psize = @parent ? @parent.size : 0
-    return @parent.index_to_field index if index < psize
-    @fields_i[index - psize]
-  end
-      
-  # Increments this and child keys' indices by 1.
-  def increment_indices() 
-    @size += 1
-    @fields.each do |key, tuple|
-      tuple.index += 1
-    end
-    @children.each do |child|
-      child.increment_indices
-    end
-  end
-
-  # Tests if the struct meets the specified criteria for 
-  # transforming to this key.
-  def test_hook( struct )
-    @test[struct]
-  end
-
-##### Creation Methods
-
-  # Registers a field with a name.
-  def register( name, field )
-    name = name.to_sym
-    @fields[name] = Tuple.new @size, [], field
-    @fields_i[@size] = name
-    @size += 1
-    @children.each {|c| c.increment_indices }
-  end
-
-  # Adds a child to this key.
-  def add_child( child )
-    @children << child
-  end
-
-  # Adds hooks to this key.
-  def add_hooks( hooks, key )
-    hooks.each do |hook|
-      @fields[hook.to_sym].hooks << key
-    end
-  end
-
-end

data/lib/d_struct.rb

@@ -1,36 +0,0 @@
-require 'd_key'
-
-class DStruct
-
-  def initialize( key )
-    @key = key
-    @data = []
-  end
-
-  attr_reader :key
-
-##### Usage Methods.
-  
-  # Gets the element of the struct.
-  def []( field )
-    @data[@key.index field]
-  end
-
-  # Assigns the element of the struct.
-  def []=( field, value )
-    @key = @key.update self, field, value do |i|
-      @data[i] = value
-    end
-  end
-
-  def each( &proc )
-    @data.each &proc
-  end
-
-  def each_index( &proc )
-    @data.each_index &proc
-  end
-
-##### Helper Methods.
-
-end

data/test/d_field_test.rb

@@ -1,78 +0,0 @@
-#! /usr/bin/ruby
-require File.join(File.dirname(__FILE__), 'test_helper')
-class DFieldTest < Test::Unit::TestCase
-
-  context 'A new DField' do
-
-    setup do
-      @field = DField.new
-    end
-    should 'validate anything' do
-      @field.valid?(nil).should be true
-      @field.valid?(42).should be true
-    end
-    should 'not be able to read' do
-      lambda{@field.read(StringIO.new)}.should raise_error NoProcError
-    end
-    should 'not be able to write' do
-      lambda{@field.write('', StringIO.new)}.should raise_error NoProcError
-    end
-
-    context 'with a direct writer' do 
-      setup do
-        @field.writer {|v,o| o.write v }
-      end
-      should 'write out "abc"' do
-        ios = StringIO.new
-        @field.write 'abc', ios
-        ios.string.should be 'abc'
-      end
-    end
-
-    context 'with a direct word reader' do
-      setup do
-        @field.reader {|i| i.gets(' ').strip }
-      end
-      should 'read in "abc"' do
-        ios = StringIO.new 'abc'
-        @field.read(ios).should be 'abc'
-      end
-    end
-
-  end
-  
-  context 'A new DField of class Integer' do
-    setup do
-      @field = DField.of_class Integer
-    end
-    should "validate Integers." do
-      @field.valid?(42).should be true
-      @field.valid?(0).should be true
-    end
-    should "not validate non Integers." do
-      @field.valid?('hello').should be false
-      @field.valid?(45.5).should be false
-    end
-    should 'intern' do
-      @field.should be DField.of_class Integer
-    end
-  end
-
-  context 'A new DField of method :to_str' do
-    setup do
-      @field = DField.of_method :to_str
-    end
-    should 'validate Strings.' do
-      @field.valid?('hello').should be true
-      @field.valid?('').should be true
-    end 
-    should 'not validate Numerics.' do
-      @field.valid?(42).should be false
-      @field.valid?(1.5).should be false
-    end
-    should 'intern' do
-      @field.should be DField.of_method :to_str
-    end
-  end
-
-end

data/test/d_key_test.rb

@@ -1,167 +0,0 @@
-#! /usr/bin/ruby
-### XXX Test the read / write actions.  Maybe in Struct?
-
-
-require File.join(File.dirname(__FILE__), 'test_helper')
-class DKeyTest < Test::Unit::TestCase
-
-  context 'A new DKey' do
-    
-    setup { @key = DKey.new }
-    
-    should 'have no children' do
-      @key.children.empty?.should be true
-    end
-    should 'have no parent' do
-      @key.parent.should be nil
-    end
-    should 'have 0 elements' do
-      @key.size.should be 0
-    end
-    should 'have no fields' do 
-      @key.fields.empty?.should be true
-    end
-    should 'have itself as an ancestor' do
-      @key.ancestor?(@key).should be true
-    end
-    should 'raise a KeyError when trying to update' do
-      lambda{@key.update(nil,:aoe,42)}.should raise_error KeyError
-    end
-    should 'raise a KeyError when trying to find a field' do
-      lambda{@key.field(0)}.should raise_error KeyError
-    end
-    should 'raise a KeyError when accessing a non-existant index' do
-      lambda{@key.index(:c)}.should raise_error KeyError
-      lambda{@key.index(15)}.should raise_error KeyError
-    end
-
-    context 'with a child' do
-
-      setup { @child = DKey.new @key }
-
-      should 'have 1 child' do
-        @key.children.size.should be 1
-      end
-      
-      context 'and a grandchild' do
-        
-        setup { @grand = DKey.new @child }
-
-        should 'have the correct ancestors' do
-          @grand.ancestor?(@key).should be true
-          @grand.ancestor?(@child).should be true
-          @child.ancestor?(@key).should be true
-          @key.ancestor?(@child).should be false
-          @key.ancestor?(@grand).should be false
-        end
-
-        should 'correctly validate DStructs' do
-          @k_s = DStruct.new @key
-          @c_s = DStruct.new @child
-          @g_s = DStruct.new @grand
-          @key.valid?(@k_s).should be true
-          @key.valid?(@c_s).should be true
-          @key.valid?(@g_s).should be true
-          @child.valid?(@k_s).should be false
-          @child.valid?(@g_s).should be true
-          @grand.valid?(@c_s).should be false
-        end
-      end
-    end
-  
-  end
-
-  context 'A DKey with two strict fields' do
-    
-    setup do
-      @key = DKey.new
-      @str_field = DField.of_class String
-      @int_field = DField.of_class Integer
-      @key.register 'str', @str_field
-      @key.register :int, @int_field
-    end
-
-    should 'have the correct fields' do
-      @key.fields.should be(
-          {:str => @str_field, :int => @int_field})
-    end
-
-    should 'return the correct fields' do
-      @key.field(0).should be @str_field
-      @key.field(1).should be @int_field
-      @key.field(:str).should be @str_field
-      @key.field('int').should be @int_field
-    end
-
-    should 'have the correct indices' do
-      @key.index(:str).should be 0
-      @key.index('int').should be 1
-      @key.index(1).should be 1
-    end
-
-    should 'return itself when updated correctly' do
-      @key.update(nil, 'str', 'abc'){}.should be @key
-      @key.update(nil, 'int', 12345){}.should be @key
-    end
-
-    should 'raise a ValidationError when updated incorrectly' do
-      lambda{@key.update(nil, :str, 123){}}.should raise_error ValidationError
-      lambda{@key.update(nil, :int, 'p'){}}.should raise_error ValidationError
-    end
-
-    context 'and a child with 1 field.' do 
-
-      setup {
-        @child = DKey.new @key
-        @child.register :i2, @int_field
-      }
-
-      context 'The child' do
-        should 'have the correct size' do
-          @child.size.should be 3
-        end
-        should 'have the correct indices' do
-          @child.index(:int).should be 1
-          @child.index('i2').should be 2
-        end
-        should 'have the correct fields' do
-          @child.fields.should be(
-              {:str => @str_field, :int => @int_field, :i2 => @int_field})
-        end
-      end
-
-      context 'The parent' do
-        should 'have the correct fields' do
-          @key.fields.should be(
-              {:str => @str_field, :int => @int_field})
-        end
-
-        should 'have the correct indices' do
-          @key.index('str').should be 0
-          @key.index(:int).should be 1
-        end
-      end
-      
-      context 'When the parent is updated. The child' do
-        
-        setup { @key.register :s2, @str_field }
-
-        should 'update its fields' do
-          @child.fields.should be(
-              {:str => @str_field, :int => @int_field,
-               :s2  => @str_field,  :i2 => @int_field})
-        end
-
-        should 'update its indices' do
-          @child.index(:s2).should be 2
-          @child.index(:i2).should be 3
-        end
-
-        should 'update its size' do
-          @child.size.should be 4
-        end
-
-      end
-    end
-  end
-end

data/test/d_struct_test.rb

@@ -1,88 +0,0 @@
-#! /usr/bin/ruby
-require File.join(File.dirname(__FILE__), 'test_helper')
-class DStructTest < Test::Unit::TestCase
-  
-  context 'A new DStruct of a 1 element key' do
-
-    setup do
-      @field = DField.of_class Integer
-      @key = DKey.new
-      @key.register :a, @field
-      @struct = DStruct.new @key
-    end
-
-    should 'raise a KeyError when a non-existant field is accessed or assigned' do
-      lambda{@struct['b']}.should raise_error KeyError
-      lambda{@struct[:x] = 42}.should raise_error KeyError
-    end
-
-    should 'correctly store data' do
-      @struct[:a].should be nil
-      @struct['a'] = 42
-      @struct['a'].should be 42
-    end
-
-    should 'raise a ValidationError when incorrectly assigned' do
-      lambda{@struct['a'] = 'abc'}.should raise_error ValidationError
-    end
-
-  end
-
-  context 'A transforming struct' do
-    
-    setup do
-      @f_str = DField.of_class String
-      @f_sym = DField.of_class Symbol
-      @f_int = DField.of_class Integer
-      @k_base = DKey.new
-      @k_base.register :type, @f_sym
-      @k_base.register :typ2, @f_sym
-
-      @k_date = DKey.new(@k_base, :type) do |s|
-        s[:type] == :date
-      end
-      @k_date.register :date, @f_str
-
-      @k_nums = DKey.new(@k_base, :type, :typ2) do |s|
-        s[:type] == :num and s[:typ2] == :s
-      end
-      @k_nums.register :num1, @f_int
-      @k_nums.register :num2, @f_int
-      @k_nums.register :num3, @f_int
-
-      @k_same = DKey.new(@k_base, :typ2) do |s|
-        s[:type] == s[:typ2]
-      end
-
-      @struct = DStruct.new @k_base
-    end      
-    
-    should 'be able to start as a child' do
-      a = DStruct.new @k_date
-      a[:date] = 'today'
-    end
-
-    should 'transform into the date structure' do
-      @struct[:type] = :date
-      @struct.key.should be @k_date
-    end
-
-    should 'transform into the nums structure' do
-      @struct[:type] = :num
-      @struct[:typ2] = :a
-      @struct.key.should be @k_base
-      @struct[:typ2] = :s
-      @struct.key.should be @k_nums
-    end
-
-    should 'only transform when the selected key is changed' do
-      @struct[:typ2] = :a
-      @struct[:type] = :a
-      @struct.key.should be @k_base
-      @struct[:typ2] = :a
-      @struct.key.should be @k_same
-    end
-
-  end
-
-end