grayswx-dynastruct 0.0.1

data/Rakefile

@@ -0,0 +1,33 @@
+%w'dynastruct rubygems rake/clean rake/testtask
+   rake/gempackagetask'.each {|w| require w }
+
+task :default => [:test]
+
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+spec = Gem::Specification.new do |s|
+  s.name = 'dynastruct'
+  s.version = '0.0.1'
+  s.summary = 'Structs that can change their shape on the fly.'
+  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.has_rdoc = true
+end
+
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+  pkg.need_zip = true
+end
+
+desc "Generate a gemspec file for GitHub"
+task :gemspec do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+end

data/dynastruct.rb

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

data/lib/d_exceptions.rb

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

data/lib/d_field.rb

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

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

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

@@ -0,0 +1,78 @@
+#! /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

@@ -0,0 +1,167 @@
+#! /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

@@ -0,0 +1,88 @@
+#! /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

data/test/test_helper.rb

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

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: grayswx-dynastruct
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- grayswx
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-23 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: grayswx@gmail.com
+executables: []
+
+extensions: []
+
+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
+- 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: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: n/a
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Structs that can change their shape on the fly.
+test_files: []
+