classy_struct 0.2.0 → 0.3.0

data/.gitignore

@@ -20,3 +20,4 @@ pkg
 
 ## PROJECT::SPECIFIC
 tmp/
+/classy_struct.gemspec

data/README.rdoc

@@ -1,9 +1,41 @@
 = classy_struct
 
-Description goes here.
+A better-performing alternative to OpenStruct
+
+== Usage
+
+First, create a class instance of ClassyStruct:
+
+  require 'classy_struct'
+  Widget = ClassyStruct.new
+
+
+Next, create instances of that class the same as you would with any
+other class:
+
+  w1 = Widget.new
+
+
+These instances are open in much the same way that OpenStruct
+instances are open:
+
+  w1.foo = :bar
+  w1.foo  # => :bar
+
+However, generated accessors are applied to the class instance (in
+this case, Widget) instead of the object instance.  This means that
+accessors only need to be generated once for the class, and instances
+of that class get the accessors automatically.
+
+You can also pass a Hash to the constructor, to be recursively
+converted to ClassyStruct objects:
+
+  w1 = Widget.new(:foo => :bar, :baz => {:xyzzy => :thud})
+  w1.foo        # => :bar
+  w1.baz.xyzzy  # => :thud
 
 == Note on Patches/Pull Requests
- 
+
 * Fork the project.
 * Make your feature addition or bug fix.
 * Add tests for it. This is important so I don't break it in a
@@ -15,4 +47,4 @@ Description goes here.
 
 == Copyright
 
-Copyright (c) 2009 amikula. See LICENSE for details.
+Copyright (c) 2009 Alf Mikula. See LICENSE for details.

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/lib/classy_struct.rb

@@ -2,11 +2,12 @@ class ClassyStruct
   def self.new(&block)
     klass = Class.new(ClassyStructClass)
     klass.method_mapper = block
+    klass.attr_names = []
     klass
   end
 
   class ClassyStructClass
-    def initialize(hash=hil)
+    def initialize(hash=nil)
       if hash
         hash.each_pair do |k,v|
           k = self.class.method_mapper.call(k.to_s) if self.class.method_mapper
@@ -24,6 +25,7 @@ class ClassyStruct
 
     class << self
       attr_accessor :method_mapper
+      attr_accessor :attr_names
 
       def node_class(name)
         @__node_classes ||= {}
@@ -42,6 +44,32 @@ class ClassyStruct
       end
     end
 
+    def _attrs
+      self.class.attr_names.inject({}) do |retval, attr_name|
+        retval[attr_name] = send(attr_name)
+        retval
+      end
+    end
+
+    def inspect
+      to_hash.inspect
+    end
+
+    def to_hash
+      retval = _attrs
+
+      retval.each_pair do |key,val|
+        case val
+        when ClassyStruct::ClassyStructClass
+          retval[key] = val.to_hash
+        when Array
+          retval[key] = val.map{|e| e.is_a?(ClassyStruct::ClassyStructClass) ? e.to_hash : e}
+        end
+      end
+
+      retval
+    end
+
     def new_child(key)
       self.send("#{key}=", self.class.node_class(key).new)
     end
@@ -59,6 +87,8 @@ class ClassyStruct
         end
       EOF
 
+      self.class.attr_names << base.to_sym
+
       send(name, *args)
     end
   end

data/spec/classy_struct_spec.rb

@@ -46,11 +46,11 @@ describe ClassyStruct do
 
       o.bar = :baz
 
-      o.methods.should include('bar')
-      o.class.instance_methods.should include('bar')
+      o.methods.map { |m| m.to_s }.should include('bar')
+      o.class.instance_methods.map { |m| m.to_s }.should include('bar')
 
       p = @foo_struct.new
-      p.methods.should include('bar')
+      p.methods.map { |m| m.to_s }.should include('bar')
 
       p.should_not_receive(:method_missing)
       p.bar
@@ -60,8 +60,15 @@ describe ClassyStruct do
       o = @foo_struct.new
       o.bar = :baz
 
-      @foo_struct.instance_methods.should include('bar')
-      @bar_struct.instance_methods.should_not include('bar')
+      @foo_struct.instance_methods.map { |m| m.to_s }.should include('bar')
+      @bar_struct.instance_methods.map { |m| m.to_s }.should_not include('bar')
+    end
+
+    it 'adds attribute names to attr_names on the base class' do
+      o = @foo_struct.new
+      o.bar = :baz
+
+      @foo_struct.attr_names.should include(:bar)
     end
   end
 
@@ -178,5 +185,69 @@ describe ClassyStruct do
         o.new_child(:foo).should == o.foo
       end
     end
+
+    describe :_attrs do
+      it 'returns a hash with all the attribute names and values' do
+        instance = @foo_struct.new(:foo => :bar, :baz => :xyzzy)
+
+        instance._attrs.should == {:foo => :bar, :baz => :xyzzy}
+      end
+
+      it 'returns values which have been overridden since initialization' do
+        instance = @foo_struct.new(:foo => :bar, :baz => :xyzzy)
+        instance.foo = :thud
+
+        instance._attrs.should == {:foo => :thud, :baz => :xyzzy}
+      end
+
+      it 'returns nil for attribute values which have not been assigned for this instance' do
+        instance1 = @foo_struct.new(:foo => :bar, :baz => :xyzzy)
+        instance1.foo = :thud
+
+        instance2 = @foo_struct.new(:fizz => :buzz)
+        instance2._attrs[:fizz].should == :buzz
+
+        instance2._attrs.should have_key(:foo)
+        instance2._attrs[:foo].should be_nil
+
+        instance2._attrs.should have_key(:baz)
+        instance2._attrs[:baz].should be_nil
+      end
+
+      it 'does not convert nested ClassyStruct objects' do
+        instance = @foo_struct.new(:foo => :bar, :baz => {:xyzzy => :thud})
+
+        instance._attrs[:baz].should be_a(ClassyStruct::ClassyStructClass)
+      end
+    end
+
+    describe :to_hash do
+      it 'returns a hash with all the attribute names and values' do
+        instance = @foo_struct.new(:foo => :bar, :baz => :xyzzy)
+
+        instance.to_hash.should == {:foo => :bar, :baz => :xyzzy}
+      end
+
+      it 'recursively converts classy_struct children to hashes' do
+        instance = @foo_struct.new(:foo => :bar, :baz => {:xyzzy => :thud})
+
+        instance.to_hash.should == {:foo => :bar, :baz => {:xyzzy => :thud}}
+      end
+
+      it 'recursively converts classy_struct children in arrays to hashes' do
+        instance = @foo_struct.new(:foo => :bar, :baz => [{:xyzzy => :thud}])
+
+        instance.to_hash.should == {:foo => :bar, :baz => [{:xyzzy => :thud}]}
+      end
+    end
+
+    describe :inspect do
+      it 'returns to_hash.inspect' do
+        instance = @foo_struct.new
+        instance.should_receive(:to_hash).and_return(mock(:inspect => 'inspected!'))
+
+        instance.inspect.should == 'inspected!'
+      end
+    end
   end
 end

metadata

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