hashie 0.3.1 → 0.4.0

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/hashie.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{hashie}
-  s.version = "0.3.1"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Michael Bleigh"]
-  s.date = %q{2010-08-19}
+  s.date = %q{2010-08-31}
   s.description = %q{Hashie is a small collection of tools that make hashes more powerful. Currently includes Mash (Mocking Hash) and Dash (Discrete Hash).}
   s.email = %q{michael@intridea.com}
   s.extra_rdoc_files = [

data/lib/hashie/dash.rb

@@ -1,7 +1,7 @@
 require 'hashie/hash'
+require 'set'
 
 module Hashie
-  include Hashie::PrettyInspect
   # A Dash is a 'defined' or 'discrete' Hash, that is, a Hash
   # that has a set of defined keys that are accessible (with
   # optional defaults) and only those keys may be set or read.
@@ -26,56 +26,55 @@ module Hashie
     def self.property(property_name, options = {})
       property_name = property_name.to_sym
 
-      (@properties ||= []) << property_name
-      (@defaults ||= {})[property_name] = options.delete(:default)
+      self.properties << property_name
 
-      class_eval <<-RUBY
-        def #{property_name}
-          self[:#{property_name}]
-        end
+      if options[:default] or self.defaults[property_name]
+        self.defaults[property_name] = options[:default] 
+      end
 
-        def #{property_name}=(val)
-          self[:#{property_name}] = val
-        end
-      RUBY
-    end
+      unless instance_methods.map { |m| m.to_s }.include?("#{property_name}=")
+        class_eval <<-ACCESSORS
+          def #{property_name}
+            _regular_reader(#{property_name.to_s.inspect})
+          end
 
-    # Get a String array of the currently defined
-    # properties on this Dash.
-    def self.properties
-      properties = []
-      ancestors.each do |elder|
-        if elder.instance_variable_defined?("@properties")
-          properties << elder.instance_variable_get("@properties")
-        end
+          def #{property_name}=(value)
+            _regular_writer(#{property_name.to_s.inspect}, value)
+          end
+        ACCESSORS
       end
 
-      properties.flatten.map{|p| p.to_s}
+      if defined? @subclasses
+        @subclasses.each { |klass| klass.property(property_name, options) }
+      end
     end
 
-    # Check to see if the specified property has already been
-    # defined.
-    def self.property?(prop)
-      properties.include?(prop.to_s)
+    class << self
+      attr_reader :properties, :defaults
     end
+    instance_variable_set('@properties', Set.new)
+    instance_variable_set('@defaults', {})
 
-    # The default values that have been set for this Dash
-    def self.defaults
-      properties = {}
-      ancestors.each do |elder|
-        if elder.instance_variable_defined?("@defaults")
-          properties.merge! elder.instance_variable_get("@defaults")
-        end
-      end
+    def self.inherited(klass)
+      super
+      (@subclasses ||= Set.new) << klass
+      klass.instance_variable_set('@properties', self.properties.dup)
+      klass.instance_variable_set('@defaults', self.defaults.dup)
+    end
 
-      properties
+    # Check to see if the specified property has already been
+    # defined.
+    def self.property?(name)
+      properties.include? name.to_sym
     end
 
     # You may initialize a Dash with an attributes hash
     # just like you would many other kinds of data objects.
-    def initialize(attributes = {})
-      self.class.properties.each do |prop|
-        self.send("#{prop}=", self.class.defaults[prop.to_sym])
+    def initialize(attributes = {}, &block)
+      super(&block)
+
+      self.class.defaults.each_pair do |prop, value|
+        self.send("#{prop}=", value)
       end
 
       attributes.each_pair do |att, value|
@@ -83,26 +82,30 @@ module Hashie
       end if attributes
     end
 
+    alias_method :_regular_reader, :[]
+    alias_method :_regular_writer, :[]=
+    private :_regular_reader, :_regular_writer
+
     # Retrieve a value from the Dash (will return the
     # property's default value if it hasn't been set).
     def [](property)
-      super(property.to_sym) if property_exists? property
+      assert_property_exists! property
+      super(property.to_s)
     end
 
     # Set a value on the Dash in a Hash-like way. Only works
     # on pre-existing properties.
     def []=(property, value)
-      super if property_exists? property
+      assert_property_exists! property
+      super(property.to_s, value)
     end
 
     private
-      # Raises an NoMethodError if the property doesn't exist
-      #
-      def property_exists?(property)
-        unless self.class.property?(property.to_sym)
+
+      def assert_property_exists!(property)
+        unless self.class.property?(property)
           raise NoMethodError, "The property '#{property}' is not defined for this Dash."
         end
-        true
       end
   end
 end

data/lib/hashie/hash.rb

@@ -1,3 +1,5 @@
+require 'hashie/hash_extensions'
+
 module Hashie
   # A Hashie Hash is simply a Hash that has convenience
   # functions baked in such as stringify_keys that may

data/lib/hashie/mash.rb

@@ -1,3 +1,5 @@
+require 'hashie/hash'
+
 module Hashie
   # Mash allows you to create pseudo-objects that have method-like
   # accessors for hash keys. This is useful for such implementations
@@ -79,7 +81,7 @@ module Hashie
     # if there isn't a value already assigned to the key requested.
     def initializing_reader(key)
       ck = convert_key(key)
-      regular_writer(ck, Hashie::Mash.new) unless key?(ck)
+      regular_writer(ck, self.class.new) unless key?(ck)
       regular_reader(ck)
     end
 
@@ -96,14 +98,20 @@ module Hashie
     # Performs a deep_update on a duplicate of the
     # current mash.
     def deep_merge(other_hash)
-      dup.deep_merge!(other_hash)
+      dup.deep_update(other_hash)
     end
+    alias_method :merge, :deep_merge
 
     # Recursively merges this mash with the passed
     # in hash, merging each hash in the hierarchy.
     def deep_update(other_hash)
       other_hash.each_pair do |k,v|
-        regular_writer(convert_key(k), convert_value(other_hash[k], true))
+        key = convert_key(k)
+        if regular_reader(key).is_a?(Mash) and v.is_a?(::Hash)
+          regular_reader(key).deep_update(v)
+        else
+          regular_writer(key, convert_value(v, true))
+        end
       end
       self
     end
@@ -111,6 +119,20 @@ module Hashie
     alias_method :update, :deep_update
     alias_method :merge!, :update
 
+    # Performs a shallow_update on a duplicate of the current mash
+    def shallow_merge(other_hash)
+      dup.shallow_update(other_hash)
+    end
+
+    # Merges (non-recursively) the hash from the argument,
+    # changing the receiving hash
+    def shallow_update(other_hash)
+      other_hash.each_pair do |k,v|
+        regular_writer(convert_key(k), convert_value(v, true))
+      end
+      self
+    end
+
    # Will return true if the Mash has had a key
    # set in addition to normal respond_to? functionality.
    def respond_to?(method_name)
@@ -141,7 +163,7 @@ module Hashie
 
     def convert_value(val, duping=false) #:nodoc:
       case val
-        when ::Hashie::Mash
+        when self.class
           val.dup
         when ::Hash
           val = val.dup if duping

data/spec/hashie/dash_spec.rb

@@ -1,5 +1,11 @@
 require 'spec_helper'
 
+Hashie::Hash.class_eval do
+  def self.inherited(klass)
+    klass.instance_variable_set('@inheritance_test', true)
+  end
+end
+
 class DashTest < Hashie::Dash
   property :first_name
   property :email
@@ -10,100 +16,141 @@ class Subclassed < DashTest
   property :last_name
 end
 
-describe Hashie::Dash do
-  it 'should be a subclass of Hashie::Hash' do
-    (Hashie::Dash < Hash).should be_true
+describe DashTest do
+  
+  it('subclasses Hashie::Hash') { should respond_to(:to_mash) }
+  
+  its(:to_s) { should == '<#DashTest count=0>' }
+  
+  it 'lists all set properties in inspect' do
+    subject.first_name = 'Bob'
+    subject.email = 'bob@example.com'
+    subject.inspect.should == '<#DashTest count=0 email="bob@example.com" first_name="Bob">'
   end
-
-  it '#inspect should be ok!' do
-    dash = DashTest.new
-    dash.email = "abd@abc.com"
-    dash.inspect.should == "<#DashTest count=0 email=\"abd@abc.com\" first_name=nil>"
+  
+  its(:count) { should be_zero }
+
+  it { should respond_to(:first_name) }
+  it { should respond_to(:first_name=) }
+  it { should_not respond_to(:nonexistent) }
+  
+  it 'errors out for a non-existent property' do
+    lambda { subject['nonexistent'] }.should raise_error(NoMethodError)
   end
 
-  describe ' creating properties' do
-    it 'should add the property to the list' do
-      DashTest.property :not_an_att
-      DashTest.properties.include?('not_an_att').should be_true
+  context 'writing to properties' do
+    it 'fails writing to a non-existent property using []=' do
+      lambda { subject['nonexistent'] = 123 }.should raise_error(NoMethodError)
     end
 
-    it 'should create a method for reading the property' do
-      DashTest.new.respond_to?(:first_name).should be_true
+    it 'works for an existing property using []=' do
+      subject['first_name'] = 'Bob'
+      subject['first_name'].should == 'Bob'
+      subject[:first_name].should == 'Bob'
     end
 
-    it 'should create a method for writing the property' do
-      DashTest.new.respond_to?(:first_name=).should be_true
+    it 'works for an existing property using a method call' do
+      subject.first_name = 'Franklin'
+      subject.first_name.should == 'Franklin'
     end
   end
 
-  describe 'reading properties' do
-    it 'should raise an error when reading a non-existent property' do
-      lambda{@dash['abc']}.should raise_error(NoMethodError)
-    end
-  end
-
-  describe ' writing to properties' do
-    before do
-      @dash = DashTest.new
+  describe '.new' do
+    it 'fails with non-existent properties' do
+      lambda { described_class.new(:bork => '') }.should raise_error(NoMethodError)
     end
 
-    it 'should not be able to write to a non-existent property using []=' do
-      lambda{@dash['abc'] = 123}.should raise_error(NoMethodError)
+    it 'should set properties that it is able to' do
+      obj = described_class.new :first_name => 'Michael'
+      obj.first_name.should == 'Michael'
     end
-
-    it 'should be able to write to an existing property using []=' do
-      lambda{@dash['first_name'] = 'Bob'}.should_not raise_error
+    
+    it 'accepts nil' do
+      lambda { described_class.new(nil) }.should_not raise_error
     end
-
-    it 'should be able to read/write to an existing property using a method call' do
-      @dash.first_name = 'Franklin'
-      @dash.first_name.should == 'Franklin'
+    
+    it 'accepts block to define a global default' do
+      obj = described_class.new { |hash, key| key.to_s.upcase }
+      obj.first_name.should == 'FIRST_NAME'
+      obj.count.should be_zero
     end
   end
-
-  describe ' initializing with a Hash' do
-    it 'should not be able to initialize non-existent properties' do
-      lambda{DashTest.new(:bork => 'abc')}.should raise_error(NoMethodError)
-    end
-
-    it 'should set properties that it is able to' do
-      DashTest.new(:first_name => 'Michael').first_name.should == 'Michael'
+  
+  describe 'properties' do
+    it 'lists defined properties' do
+      described_class.properties.should == Set.new([:first_name, :email, :count])
     end
-  end
-
-  describe 'initializing with a nil' do
-    it 'accepts nil' do
-      lambda { DashTest.new(nil) }.should_not raise_error
+    
+    it 'checks if a property exists' do
+      described_class.property?('first_name').should be_true
+      described_class.property?(:first_name).should be_true
     end
-  end
-
-  describe ' defaults' do
-    before do
-      @dash = DashTest.new
+    
+    it 'doesnt include property from subclass' do
+      described_class.property?(:last_name).should be_false
     end
-
-    it 'should return the default value for defaulted' do
-      DashTest.property :defaulted, :default => 'abc'
-      DashTest.new.defaulted.should == 'abc'
+    
+    it 'lists declared defaults' do
+      described_class.defaults.should == { :count => 0 }
     end
   end
 end
 
-describe Subclassed do
-  it "should inherit all properties from DashTest" do
-    Subclassed.properties.size.should == 6
+describe Hashie::Dash, 'inheritance' do
+  before do
+    @top = Class.new(Hashie::Dash)
+    @middle = Class.new(@top)
+    @bottom = Class.new(@middle)
   end
-
-  it "should inherit all defaults from DashTest" do
-    Subclassed.defaults.size.should == 6
+  
+  it 'reports empty properties when nothing defined' do
+    @top.properties.should be_empty
+    @top.defaults.should be_empty
   end
-
-  it "should init without raising" do
-    lambda { Subclassed.new }.should_not raise_error
-    lambda { Subclassed.new(:first_name => 'Michael') }.should_not raise_error
+  
+  it 'inherits properties downwards' do
+    @top.property :echo
+    @middle.properties.should include(:echo)
+    @bottom.properties.should include(:echo)
+  end
+  
+  it 'doesnt inherit properties upwards' do
+    @middle.property :echo
+    @top.properties.should_not include(:echo)
+    @bottom.properties.should include(:echo)
+  end
+  
+  it 'allows overriding a default on an existing property' do
+    @top.property :echo
+    @middle.property :echo, :default => 123
+    @bottom.properties.to_a.should == [:echo]
+    @bottom.new.echo.should == 123
+  end
+  
+  it 'allows clearing an existing default' do
+    @top.property :echo
+    @middle.property :echo, :default => 123
+    @bottom.property :echo
+    @bottom.properties.to_a.should == [:echo]
+    @bottom.new.echo.should be_nil
   end
+end
 
-  it "should share defaults from DashTest" do
-    Subclassed.new.count.should == 0
+describe Subclassed do
+  
+  its(:count) { should be_zero }
+
+  it { should respond_to(:first_name) }
+  it { should respond_to(:first_name=) }
+  it { should respond_to(:last_name) }
+  it { should respond_to(:last_name=) }
+  
+  it 'has one additional property' do
+    described_class.property?(:last_name).should be_true
+  end
+  
+  it "didn't override superclass inheritance logic" do
+    described_class.instance_variable_get('@inheritance_test').should be_true
   end
+  
 end

data/spec/hashie/mash_spec.rb

@@ -67,12 +67,67 @@ describe Hashie::Mash do
     @mash.author.website.should == Hashie::Mash.new(:url => "http://www.mbleigh.com/")
   end
 
-  it "#deep_update should recursively Hashie::Mash Hashie::Mashes and hashes together" do
-    @mash.first_name = "Michael"
-    @mash.last_name = "Bleigh"
-    @mash.details = Hashie::Hash[:email => "michael@asf.com"].to_mash
-    @mash.deep_update({:details => {:email => "michael@intridea.com"}})
-    @mash.details.email.should == "michael@intridea.com"
+  context "updating" do
+    subject {
+      described_class.new :first_name => "Michael", :last_name => "Bleigh",
+        :details => {:email => "michael@asf.com", :address => "Nowhere road"}
+    }
+
+    describe "#deep_update" do
+      it "should recursively Hashie::Mash Hashie::Mashes and hashes together" do
+        subject.deep_update(:details => {:email => "michael@intridea.com", :city => "Imagineton"})
+        subject.first_name.should == "Michael"
+        subject.details.email.should == "michael@intridea.com"
+        subject.details.address.should == "Nowhere road"
+        subject.details.city.should == "Imagineton"
+      end
+  
+      it "should make #update deep by default" do
+        subject.update(:details => {:address => "Fake street"}).should eql(subject)
+        subject.details.address.should == "Fake street"
+        subject.details.email.should == "michael@asf.com"
+      end
+    
+      it "should clone before a #deep_merge" do
+        duped = subject.deep_merge(:details => {:address => "Fake street"})
+        duped.should_not eql(subject)
+        duped.details.address.should == "Fake street"
+        subject.details.address.should == "Nowhere road"
+        duped.details.email.should == "michael@asf.com"
+      end
+    
+      it "regular #merge should be deep" do
+        duped = subject.merge(:details => {:email => "michael@intridea.com"})
+        duped.should_not eql(subject)
+        duped.details.email.should == "michael@intridea.com"
+        duped.details.address.should == "Nowhere road"
+      end
+    end
+
+    describe "shallow update" do
+      it "should shallowly Hashie::Mash Hashie::Mashes and hashes together" do
+        subject.shallow_update(:details => {
+          :email => "michael@intridea.com", :city => "Imagineton"
+        }).should eql(subject)
+        
+        subject.first_name.should == "Michael"
+        subject.details.email.should == "michael@intridea.com"
+        subject.details.address.should be_nil
+        subject.details.city.should == "Imagineton"
+      end
+  
+      it "should clone before a #regular_merge" do
+        duped = subject.shallow_merge(:details => {:address => "Fake street"})
+        duped.should_not eql(subject)
+      end
+    
+      it "regular merge should be shallow" do
+        duped = subject.shallow_merge(:details => {:address => "Fake street"})
+        duped.details.address.should == "Fake street"
+        subject.details.address.should == "Nowhere road"
+        duped.details.email.should be_nil
+      end
+    end
   end
 
   it "should convert hash assignments into Hashie::Mashes" do
@@ -100,6 +155,30 @@ describe Hashie::Mash do
     record['submash'].should be_kind_of(SubMash)
   end
   
+  it "should respect the class when passed a bang method for a non-existent key" do
+    record = Hashie::Mash.new
+    record.non_existent!.should be_kind_of(Hashie::Mash)
+    
+    class SubMash < Hashie::Mash
+    end
+    
+    son = SubMash.new
+    son.non_existent!.should be_kind_of(SubMash)
+  end
+  
+  it "should respect the class when converting the value" do
+    record = Hashie::Mash.new
+    record.details = Hashie::Mash.new({:email => "randy@asf.com"})
+    record.details.should be_kind_of(Hashie::Mash)
+    
+    class SubMash < Hashie::Mash
+    end
+    
+    son = SubMash.new
+    son.details = Hashie::Mash.new({:email => "randyjr@asf.com"})
+    son.details.should be_kind_of(SubMash)
+  end
+  
   describe '#respond_to?' do
     it 'should respond to a normal method' do
       Hashie::Mash.new.should be_respond_to(:key?)

data/spec/hashie/trash_spec.rb

@@ -9,8 +9,7 @@ describe Hashie::Trash do
 
   describe 'translating properties' do
     it 'adds the property to the list' do
-      TrashTest.property :not_an_att, :from => :notAnAtt
-      TrashTest.properties.should include('not_an_att')
+      TrashTest.properties.should include(:first_name)
     end
 
     it 'creates a method for reading the property' do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: hashie
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 1
-  version: 0.3.1
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Michael Bleigh
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-19 00:00:00 -05:00
+date: 2010-08-31 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency