classy_struct 0.1.0 → 0.2.0

data/README.rdoc

@@ -1,4 +1,4 @@
-= airystruct
+= classy_struct
 
 Description goes here.
 

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/classy_struct.rb

@@ -1,14 +1,20 @@
 class ClassyStruct
-  def self.new
-    Class.new(ClassyStructClass)
+  def self.new(&block)
+    klass = Class.new(ClassyStructClass)
+    klass.method_mapper = block
+    klass
   end
 
   class ClassyStructClass
     def initialize(hash=hil)
       if hash
         hash.each_pair do |k,v|
+          k = self.class.method_mapper.call(k.to_s) if self.class.method_mapper
+
           if v.is_a?(Hash)
             v = self.class.node_class(k).new(v)
+          elsif v.is_a?(Array)
+            v = self.class.map_array(k, v)
           end
 
           send("#{k}=", v)
@@ -16,9 +22,24 @@ class ClassyStruct
       end
     end
 
-    def self.node_class(name)
-      @__node_classes ||= {}
-      @__node_classes[name.to_sym] ||= ClassyStruct.new
+    class << self
+      attr_accessor :method_mapper
+
+      def node_class(name)
+        @__node_classes ||= {}
+        @__node_classes[name.to_sym] ||= ClassyStruct.new(&method_mapper)
+      end
+
+      def map_array(key, ary)
+        ary.map do |e|
+          case e
+          when Hash
+            node_class(key).new(e)
+          else
+            e
+          end
+        end
+      end
     end
 
     def new_child(key)

data/spec/classy_struct_spec.rb

@@ -14,6 +14,23 @@ describe ClassyStruct do
     it "returns something that inherits from ClassyStruct" do
       ClassyStruct.new.ancestors.should include(ClassyStruct::ClassyStructClass)
     end
+
+    it 'assigns a method mapper if a block is given' do
+      prok = Proc.new{'proc_out'}
+
+      ClassyStruct.new(&prok).method_mapper.should == prok
+    end
+
+    it 'maintains unique method mappers per instance' do
+      prok1 = Proc.new{'proc_out1'}
+      prok2 = Proc.new{'proc_out2'}
+
+      klass1 = ClassyStruct.new(&prok1)
+      klass2 = ClassyStruct.new(&prok2)
+
+      klass1.method_mapper.should == prok1
+      klass2.method_mapper.should == prok2
+    end
   end
 
   describe :method_missing do
@@ -55,17 +72,24 @@ describe ClassyStruct do
       end
 
       it 'creates child nodes whose class is the same regardless of the instance' do
-        klazz1 = @foo_struct.node_class(:bar)
-        klazz2 = @foo_struct.node_class(:bar)
+        klass1 = @foo_struct.node_class(:bar)
+        klass2 = @foo_struct.node_class(:bar)
 
-        klazz1.should == klazz2
+        klass1.should == klass2
       end
 
       it 'creates child nodes whose class is different for different ClassyStruct instances' do
-        klazz1 = @foo_struct.node_class(:bar)
-        klazz2 = @bar_struct.node_class(:bar)
+        klass1 = @foo_struct.node_class(:bar)
+        klass2 = @bar_struct.node_class(:bar)
+
+        klass1.should_not == klass2
+      end
+
+      it 'passes the method mapper to the child node class' do
+        prok = Proc.new{|m| m.downcase}
 
-        klazz1.should_not == klazz2
+        the_struct = ClassyStruct.new(&prok)
+        the_struct.node_class(:bar).method_mapper.should == prok
       end
     end
 
@@ -77,6 +101,23 @@ describe ClassyStruct do
         o.baz.should == :xyzzy
       end
 
+      it 'maps hash keys with the method mapper if provided' do
+        the_struct = ClassyStruct.new{|m| m.tr('bf', 'fb')}
+
+        o = the_struct.new(:foo => :bar, 'baz' => :xyzzy)
+
+        o.boo.should == :bar
+        o.faz.should == :xyzzy
+      end
+
+      it 'maps hash keys on nested hashes' do
+        the_struct = ClassyStruct.new{|m| m.tr('bf', 'fb')}
+
+        o = the_struct.new(:foo => {:bar => :xyzzy})
+
+        o.boo.far.should == :xyzzy
+      end
+
       it 'initializes sub-hashes by creating new ClassyStruct child nodes' do
         o = @foo_struct.new(:foo => :bar, 'baz' => {:xyzzy => 'something', 'thud' => 'splat'})
 
@@ -93,6 +134,35 @@ describe ClassyStruct do
         o.class.should     == p.class
         o.baz.class.should == p.baz.class
       end
+
+      it 'converts arrays' do
+        o = @foo_struct.new(:foo => [{:bar => :baz}, {:bar => :xyzzy}, {:bar => :thud}])
+
+        o.foo.collect{|f| f.bar}.should == [:baz, :xyzzy, :thud]
+      end
+
+      it 'uses the same class for each converted hash member of arrays' do
+        o = @foo_struct.new(:foo => [{:bar => :baz}, {:bar => :xyzzy}, {:bar => :thud}])
+
+        o.foo[0].class.should == o.foo[1].class
+        o.foo[0].class.should == o.foo[2].class
+      end
+
+      it 'creates new classes that do not match the object class when mapping arrays' do
+        o = @foo_struct.new(:foo => [{:bar => :baz}])
+
+        o.class.should_not == o.foo.first.class
+      end
+
+      it 'uses the method mapper for hash members of arrays' do
+        mstruct = ClassyStruct.new{|k| k.downcase}
+
+        o = mstruct.new('Bar' => [{'Baz' => :xyzzy}])
+
+        o.bar.should be_an(Array)
+        o.bar.length.should == 1
+        o.bar.first.baz.should == :xyzzy
+      end
     end
 
     describe :new_child do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: classy_struct
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - amikula
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-11 00:00:00 -08:00
+date: 2009-11-18 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency