mostash 0.0.2 → 0.0.3

data/.gitignore

@@ -0,0 +1,2 @@
+pkg/*
+*.gemspec

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/mostash.rb

@@ -1,6 +1,7 @@
 require 'ostruct'
 
 require File.join(File.dirname(__FILE__), "mostash", "mostash")
+MoStash = Mostash
 
 def dbg( msg )
   file, line, method_raw = caller[0].split('/').last.split(':')

data/lib/mostash/mostash.rb

@@ -1,12 +1,14 @@
-class MoStash < OpenStruct
+class Mostash < OpenStruct
   def initialize(init={})
     super({})
     __init__ init
   end
 
-  def method_missing(method_name, *args)
-    #dbg "#{method_name} was sent #{args.inspect}"
-    if __is_setter__( method_name )
+  def method_missing(method_name, *args, &block)
+    #dbg "#{method_name} was sent #{args.inspect}, and block #{block.inspect}"
+    if @table.respond_to? method_name
+      @table.send method_name, *args, &block
+    elsif __is_setter__( method_name )
       super method_name, __adjusted_value__( args.first )
     else
       super
@@ -23,13 +25,13 @@ class MoStash < OpenStruct
 
   def merge(new_hash)
     new_mo = @table.merge( new_hash ) do |key, oldval, newval|
-      if oldval.class == MoStash
+      if oldval.class == Mostash
         oldval.merge newval
       else
         newval
       end
     end
-    MoStash.new( new_mo )
+    Mostash.new( new_mo )
   end
 
   #TODO: HACK!!!!!
@@ -41,7 +43,7 @@ class MoStash < OpenStruct
   def to_hash
     hash = {}
     @table.each_pair do |key, value|
-      hash[key] = if value.class == MoStash
+      hash[key] = if value.class == Mostash
                     value.to_hash
                   else
                     value
@@ -60,7 +62,7 @@ class MoStash < OpenStruct
 
   def __adjusted_value__(value)
     case value
-    when Hash then MoStash.new( value )
+    when Hash then Mostash.new( value )
     when Array then value.map{ |v| __adjusted_value__( v ) }
     else value
     end

data/spec/as_hash_spec.rb

@@ -1,61 +1,120 @@
 require 'spec_helper'
 
 describe 'MoStash as Hash' do
-  it "should support merge when single level" do
-    mo = MoStash.new :foo => 'bar', :hello => 'world'
-    
-    new_mo = mo.merge( :hello => 'tester' )
 
-    new_mo[:foo].should == 'bar'
-    new_mo[:hello].should == 'tester'
-  end
+  context 'to_hash' do
+    it "should be able to return a hash for single level" do
+      mo = MoStash.new( :foo => 'bar' )
+
+      mo.to_hash.should == { :foo => 'bar' }
+    end
 
-  it "should support merge of single level when multi leveled" do
-    mo = MoStash.new( { :foo => 'bar', :nested => { :hello => 'world' }} )
-    
-    new_mo = mo.merge( :foo => 'baz' )
+    it "should be able to return a hash for multi level" do
+      mo = MoStash.new( :foo => 'bar', :nested => { :hello => 'world' } )
 
-    new_mo[:foo].should == 'baz'
-    new_mo[:nested][:hello].should == 'world'
+      mo.to_hash.should == { :foo => 'bar', :nested => { :hello => 'world' } }
+    end
   end
 
-  it "should support merge of multi levels when is multi leveled" do
-    mo = MoStash.new( { :foo => 'bar', :nested => { :hello => 'world' }} )
-    
-    new_mo = mo.merge( :nested => { :hello => 'tester' } )
+  context 'hash functions' do
 
-    new_mo[:foo].should == 'bar'
-    new_mo[:nested][:hello].should == 'tester'
-    new_mo[:nested].class.should == MoStash
-  end
+    it "should respond to empty?" do
+      mo = Mostash.new
+      mo.empty?.should == true
+    end
 
-  it "should support merge!" do
-    mo = MoStash.new( :foo => 'bar' )
+    it "should be able to delete a key/value" do
+      mo = Mostash.new :a => 100, :b => 200
 
-    mo.merge!( :foo => 'baz' )
-    mo.foo.should == 'baz'
-  end
+      mo.delete :a
+      mo.size.should == 1
+      mo[:a].should be_nil
+    end
 
-  it "should support multi level merge!" do
-    mo = MoStash.new( { :foo => 'bar', :nested => { :hello => 'world' }} )
-    
-    mo.merge!( :nested => { :hello => 'tester' } )
+    it "should be clearable" do
+      mo = Mostash.new :a => 100, :b => 200
 
-    mo[:foo].should == 'bar'
-    mo[:nested][:hello].should == 'tester'
-    mo[:nested].class.should == MoStash
-  end
+      mo.clear
+      mo.size.should == 0
+    end
 
-  it "should be able to return a hash for single level" do
-    mo = MoStash.new( :foo => 'bar' )
+    it "should be able to iterable via each_pair" do
+      mo = Mostash.new :a => 100, :b => 200
+      vals = []
+      mo.each_pair { |key, value| vals << "#{key} = #{value}" }
 
-    mo.to_hash.should == { :foo => 'bar' }
-  end
+      vals.size.should == 2
+      vals[0].should == "a = 100"
+      vals[1].should == "b = 200"
+    end
+
+    it "should be able to iterable via each_value" do
+      mo = Mostash.new :a => 100, :b => 200
+      vals = []
+      mo.each_value { |value| vals << value }
+
+      vals.size.should == 2
+      vals[0].should == 100
+      vals[1].should == 200
+    end
+
+    it "should be iterable via each_key" do
+      mo = Mostash.new :a => 100, :b => 200
+      vals = []
+      mo.each_key { |key| vals << key }
+
+      vals.size.should == 2
+      vals[0].should == :a
+      vals[1].should == :b
+    end
+
+    context 'merge' do
+      it "should support merge when single level" do
+        mo = MoStash.new :foo => 'bar', :hello => 'world'
+
+        new_mo = mo.merge( :hello => 'tester' )
+
+        new_mo[:foo].should == 'bar'
+        new_mo[:hello].should == 'tester'
+      end
 
-  it "should be able to return a hash for multi level" do
-    mo = MoStash.new( :foo => 'bar', :nested => { :hello => 'world' } )
+      it "should support merge of single level when multi leveled" do
+        mo = MoStash.new( { :foo => 'bar', :nested => { :hello => 'world' }} )
+
+        new_mo = mo.merge( :foo => 'baz' )
+
+        new_mo[:foo].should == 'baz'
+        new_mo[:nested][:hello].should == 'world'
+      end
+
+      it "should support merge of multi levels when is multi leveled" do
+        mo = MoStash.new( { :foo => 'bar', :nested => { :hello => 'world' }} )
+
+        new_mo = mo.merge( :nested => { :hello => 'tester' } )
+
+        new_mo[:foo].should == 'bar'
+        new_mo[:nested][:hello].should == 'tester'
+        new_mo[:nested].class.should == MoStash
+      end
+
+      it "should support merge!" do
+        mo = MoStash.new( :foo => 'bar' )
+
+        mo.merge!( :foo => 'baz' )
+        mo.foo.should == 'baz'
+      end
+
+      it "should support multi level merge!" do
+        mo = MoStash.new( { :foo => 'bar', :nested => { :hello => 'world' }} )
+
+        mo.merge!( :nested => { :hello => 'tester' } )
+
+        mo[:foo].should == 'bar'
+        mo[:nested][:hello].should == 'tester'
+        mo[:nested].class.should == MoStash
+      end
+    end
 
-    mo.to_hash.should == { :foo => 'bar', :nested => { :hello => 'world' } }
   end
-end
 
+end

data/spec/mostash_spec.rb

@@ -54,10 +54,10 @@ describe MoStash do
   end
 
   it "should create method when new method called" do
-    mo = MoStash.new
+    mo = Mostash.new
     mo.foo = "bar"
 
-    mo.methods.should include("foo")
+    mo.methods.should include(:foo)
   end
 
 end

metadata

@@ -1,34 +1,37 @@
 --- !ruby/object:Gem::Specification 
 name: mostash
 version: !ruby/object:Gem::Version 
+  hash: 25
   prerelease: false
   segments: 
-    - 0
-    - 0
-    - 2
-  version: 0.0.2
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
-  - Joel Friedman
+- Joel Friedman
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-05-05 00:00:00 -05:00
+date: 2010-07-08 00:00:00 -05:00
 default_executable: 
 dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: rspec
-    prerelease: false
-    requirement: &id001 !ruby/object:Gem::Requirement 
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            segments: 
-              - 0
-            version: "0"
-    type: :development
-    version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
 description: You can treat an object as either a hash or as an OpenStruct. In additon to this you can create them nested, unlike OpenStruct
 email: asher.friedman@gmail.com
 executables: []
@@ -36,47 +39,52 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-  - README.markdown
+- README.markdown
 files: 
-  - README.markdown
-  - Rakefile
-  - VERSION
-  - lib/mostash.rb
-  - lib/mostash/mostash.rb
-  - spec/as_hash_spec.rb
-  - spec/mostash_spec.rb
-  - spec/spec_helper.rb
+- .gitignore
+- README.markdown
+- Rakefile
+- VERSION
+- lib/mostash.rb
+- lib/mostash/mostash.rb
+- spec/as_hash_spec.rb
+- spec/mostash_spec.rb
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: 
 licenses: []
 
 post_install_message: 
 rdoc_options: 
-  - --charset=UTF-8
+- --charset=UTF-8
 require_paths: 
-  - lib
+- lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-          - 0
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-          - 0
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: A combo of OpenStruct and a ruby hash
 test_files: 
-  - spec/as_hash_spec.rb
-  - spec/mostash_spec.rb
-  - spec/spec_helper.rb
+- spec/as_hash_spec.rb
+- spec/mostash_spec.rb
+- spec/spec_helper.rb