hashie 1.2.0 → 2.0.0

data/lib/hashie/mash.rb

@@ -14,6 +14,7 @@ module Hashie
   # * Assignment (<tt>=</tt>): Sets the attribute of the given method name.
   # * Existence (<tt>?</tt>): Returns true or false depending on whether that key has been set.
   # * Bang (<tt>!</tt>): Forces the existence of this key, used for deep Mashes. Think of it as "touch" for mashes.
+  # * Under Bang (<tt>_</tt>): Like Bang, but returns a new Mash rather than creating a key.  Used to test existance in deep Mashes.
   #
   # == Basic Example
   #
@@ -42,7 +43,18 @@ module Hashie
   #   mash.author!.name = "Michael Bleigh"
   #   mash.author # => <Mash name="Michael Bleigh">
   #
-  class Mash < Hashie::Hash
+  # == Under Bang Example
+  #
+  #   mash = Mash.new
+  #   mash.author # => nil
+  #   mash.author_ # => <Mash>
+  #   mash.author_.name # => nil
+  #
+  #   mash = Mash.new
+  #   mash.author_.name = "Michael Bleigh"  (assigned to temp object)
+  #   mash.author # => <Mash>
+  #
+  class Mash < Hash
     include Hashie::PrettyInspect
     alias_method :to_s, :inspect
 
@@ -55,20 +67,18 @@ module Hashie
       default ? super(default) : super(&blk)
     end
 
-    class << self
-      alias [] new
-
-      def subkey_class
-        self
-      end
-    end
+    class << self; alias [] new; end
 
     def id #:nodoc:
-      key?("id") ? self["id"] : super
+      self["id"]
     end
 
     def type #:nodoc:
-      key?("type") ? self["type"] : super
+      self["type"]
+    end
+
+    def object_id #:nodoc:
+      self["object_id"]
     end
 
     alias_method :regular_reader, :[]
@@ -97,6 +107,21 @@ module Hashie
       regular_reader(ck)
     end
 
+    # This is the under bang method reader, it will return a temporary new Mash
+    # if there isn't a value already assigned to the key requested.
+    def underbang_reader(key)
+      ck = convert_key(key)
+      if key?(ck)
+        regular_reader(ck)
+      else
+        self.class.new
+      end
+    end
+
+    def fetch(key, default_value = nil)
+      self[key] || block_given? && yield(key) || default_value || super(key)
+    end
+
     def delete(key)
       super(convert_key(key))
     end
@@ -116,20 +141,22 @@ module Hashie
 
     # Performs a deep_update on a duplicate of the
     # current mash.
-    def deep_merge(other_hash)
-      dup.deep_update(other_hash)
+    def deep_merge(other_hash, &blk)
+      dup.deep_update(other_hash, &blk)
     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)
+    def deep_update(other_hash, &blk)
       other_hash.each_pair do |k,v|
         key = convert_key(k)
         if regular_reader(key).is_a?(Mash) and v.is_a?(::Hash)
-          regular_reader(key).deep_update(v)
+          regular_reader(key).deep_update(v, &blk)
         else
-          regular_writer(key, convert_value(v, true))
+          value = convert_value(v, true)
+          value = blk.call(key, self[k], value) if blk
+          regular_writer(key, value)
         end
       end
       self
@@ -161,7 +188,7 @@ module Hashie
 
    def method_missing(method_name, *args, &blk)
      return self.[](method_name, &blk) if key?(method_name)
-     match = method_name.to_s.match(/(.*?)([?=!]?)$/)
+     match = method_name.to_s.match(/(.*?)([?=!_]?)$/)
      case match[2]
      when "="
        self[match[1]] = args.first
@@ -169,6 +196,8 @@ module Hashie
        !!self[match[1]]
      when "!"
        initializing_reader(match[1])
+     when "_"
+       underbang_reader(match[1])
      else
        default(method_name, *args, &blk)
      end
@@ -184,9 +213,11 @@ module Hashie
       case val
         when self.class
           val.dup
+        when Hash
+          duping ? val.dup : val
         when ::Hash
           val = val.dup if duping
-          self.class.subkey_class.new.merge(val)
+          self.class.new(val)
         when Array
           val.collect{ |e| convert_value(e) }
         else

data/lib/hashie/trash.rb

@@ -7,23 +7,39 @@ module Hashie
   # Trashes are useful when you need to read data from another application,
   # such as a Java api, where the keys are named differently from how we would
   # in Ruby.
-  class Trash < Hashie::Dash
+  class Trash < Dash
 
     # Defines a property on the Trash. Options are as follows:
     #
     # * <tt>:default</tt> - Specify a default value for this property, to be
     # returned before a value is set on the property in a new Dash.
     # * <tt>:from</tt> - Specify the original key name that will be write only.
+    # * <tt>:with</tt> - Specify a lambda to be used to convert value.
+    # * <tt>:transform_with</tt> - Specify a lambda to be used to convert value
+    # without using the :from option. It transform the property itself.
     def self.property(property_name, options = {})
       super
 
       if options[:from]
+        if property_name.to_sym == options[:from].to_sym
+          raise ArgumentError, "Property name (#{property_name}) and :from option must not be the same"
+        end
         translations << options[:from].to_sym
-        class_eval <<-RUBY
-          def #{options[:from]}=(val)
-            self[:#{property_name}] = val
+        if options[:with].respond_to? :call
+          class_eval do
+            define_method "#{options[:from]}=" do |val|
+              self[property_name.to_sym] = options[:with].call(val)
+            end
           end
-        RUBY
+        else
+          class_eval <<-RUBY
+            def #{options[:from]}=(val)
+              self[:#{property_name}] = val
+            end
+          RUBY
+        end
+      elsif options[:transform_with].respond_to? :call
+        transforms[property_name.to_sym] = options[:transform_with]
       end
     end
 
@@ -32,6 +48,8 @@ module Hashie
     def []=(property, value)
       if self.class.translations.include? property.to_sym
         send("#{property}=", value)
+      elsif self.class.transforms.key? property.to_sym
+        super property, self.class.transforms[property.to_sym].call(value)
       elsif property_exists? property
         super
       end
@@ -43,6 +61,10 @@ module Hashie
       @translations ||= []
     end
 
+    def self.transforms
+      @transforms ||= {}
+    end
+
     # Raises an NoMethodError if the property doesn't exist
     #
     def property_exists?(property)
@@ -51,5 +73,19 @@ module Hashie
       end
       true
     end
+
+    private
+
+    # Deletes any keys that have a translation
+    def initialize_attributes(attributes)
+      return unless attributes
+      attributes_copy = attributes.dup.delete_if do |k,v|
+        if self.class.translations.include?(k.to_sym)
+          self[k] = v
+          true
+        end
+      end
+      super attributes_copy
+    end
   end
 end

data/lib/hashie/version.rb

@@ -1,3 +1,3 @@
 module Hashie
-  VERSION = '1.2.0'
+  VERSION = '2.0.0'
 end

data/spec/hashie/dash_spec.rb

@@ -22,6 +22,14 @@ class Subclassed < DashTest
   property :last_name, :required => true
 end
 
+class DashDefaultTest < Hashie::Dash
+  property :aliases, :default => ["Snake"]
+end
+
+class DeferredTest < Hashie::Dash
+  property :created_at, :default => Proc.new { Time.now }
+end
+
 describe DashTest do
 
   subject { DashTest.new(:first_name => 'Bob', :email => 'bob@example.com') }
@@ -96,6 +104,17 @@ describe DashTest do
     end
   end
 
+  context 'reading from deferred properties' do
+    it 'should evaluate proc after initial read' do
+      DeferredTest.new['created_at'].should be_instance_of(Time)
+    end
+
+    it "should not evalute proc after subsequent reads" do
+      deferred = DeferredTest.new
+      deferred['created_at'].object_id.should == deferred['created_at'].object_id
+    end
+  end
+
   describe '.new' do
     it 'fails with non-existent properties' do
       lambda { described_class.new(:bork => '') }.should raise_error(NoMethodError)
@@ -120,6 +139,12 @@ describe DashTest do
       expect { DashTest.new }.to raise_error(ArgumentError)
     end
 
+    it "does not overwrite default values" do
+      obj1 = DashDefaultTest.new
+      obj1.aliases << "El Rey"
+      obj2 = DashDefaultTest.new
+      obj2.aliases.should_not include "El Rey"
+    end
   end
 
   describe 'properties' do

data/spec/hashie/extensions/coercion_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Hashie::Extensions::Coercion do
+  class Initializable
+    def initialize(obj, coerced = false)
+      @coerced = coerced
+      @value = obj.class.to_s
+    end
+    def coerced?; @coerced end
+    attr_reader :value
+  end
+
+  class Coercable < Initializable
+    def self.coerce(obj)
+      new(obj, true)
+    end
+  end
+
+  before(:each) do
+    class ExampleCoercableHash < Hash
+      include Hashie::Extensions::Coercion
+      include Hashie::Extensions::MergeInitializer
+    end
+  end
+  subject { ExampleCoercableHash }
+  let(:instance){ subject.new }
+
+  describe '.coerce_key' do
+    it { subject.should be_respond_to(:coerce_key) }
+
+    it 'should run through coerce on a specified key' do
+      subject.coerce_key :foo, Coercable
+
+      instance[:foo] = "bar"
+      instance[:foo].should be_coerced
+    end
+
+    it "should support an array of keys" do
+      subject.coerce_keys :foo, :bar, Coercable
+
+      instance[:foo] = "bar"
+      instance[:bar] = "bax"
+      instance[:foo].should be_coerced
+      instance[:bar].should be_coerced
+    end
+
+    it 'should just call #new if no coerce method is available' do
+      subject.coerce_key :foo, Initializable
+
+      instance[:foo] = "bar"
+      instance[:foo].value.should == "String"
+      instance[:foo].should_not be_coerced
+    end
+
+    it "should coerce when the merge initializer is used" do
+      subject.coerce_key :foo, Coercable
+      instance = subject.new(:foo => "bar")
+
+      instance[:foo].should be_coerced
+    end
+  end
+
+  describe '.coerce_value' do
+    context 'with :strict => true' do
+      it 'should coerce any value of the exact right class' do
+        subject.coerce_value String, Coercable
+        
+        instance[:foo] = "bar"
+        instance[:bar] = "bax"
+        instance[:foo].should be_coerced
+        instance[:bar].should be_coerced
+      end
+
+      it 'should not coerce superclasses' do
+        klass = Class.new(String)
+        subject.coerce_value klass, Coercable
+
+        instance[:foo] = "bar"
+        instance[:foo].should_not be_kind_of(Coercable)
+        instance[:foo] = klass.new
+        instance[:foo].should be_kind_of(Coercable)
+      end
+    end
+  end
+
+  after(:each) do
+    Object.send(:remove_const, :ExampleCoercableHash)
+  end
+end

data/spec/hashie/extensions/deep_merge_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Hashie::Extensions::DeepMerge do
+  class DeepMergeHash < Hash; include Hashie::Extensions::DeepMerge end
+
+  subject{ DeepMergeHash }
+
+  let(:h1) { subject.new.merge(:a => "a", :b => "b", :c => { :c1 => "c1", :c2 => "c2", :c3 => { :d1 => "d1" } }) }
+  let(:h2) { { :a => 1, :c => { :c1 => 2, :c3 => { :d2 => "d2" } } } }
+  let(:expected_hash) { { :a => 1, :b => "b", :c => { :c1 => 2, :c2 => "c2", :c3 => { :d1 => "d1", :d2 => "d2" } } } }
+
+  it 'should deep merge two hashes' do
+    h1.deep_merge(h2).should == expected_hash
+  end
+
+  it 'should deep merge two hashes with bang method' do
+    h1.deep_merge!(h2)
+    h1.should == expected_hash
+  end
+end

data/spec/hashie/extensions/indifferent_access_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Hashie::Extensions::IndifferentAccess do
+  class IndifferentHash < Hash
+    include Hashie::Extensions::MergeInitializer
+    include Hashie::Extensions::IndifferentAccess
+  end
+  subject{ IndifferentHash }
+
+  it 'should be able to access via string or symbol' do
+    h = subject.new(:abc => 123)
+    h[:abc].should == 123
+    h['abc'].should == 123
+  end
+
+  describe '#values_at' do
+    it 'should indifferently find values' do
+      h = subject.new(:foo => 'bar', 'baz' => 'qux')
+      h.values_at('foo', :baz).should == %w(bar qux)
+    end
+  end
+
+  describe '#fetch' do
+    it 'should work like normal fetch, but indifferent' do
+      h = subject.new(:foo => 'bar')
+      h.fetch(:foo).should == h.fetch('foo')
+      h.fetch(:foo).should == 'bar'
+    end
+  end
+
+  describe '#delete' do
+    it 'should delete indifferently' do
+      h = subject.new(:foo => 'bar', 'baz' => 'qux')
+      h.delete('foo')
+      h.delete(:baz)
+      h.should be_empty
+    end
+  end
+
+  describe '#key?' do
+    let(:h) { subject.new(:foo => 'bar') }
+
+    it 'should find it indifferently' do
+      h.should be_key(:foo)
+      h.should be_key('foo')
+    end
+
+    %w(include? member? has_key?).each do |key_alias|
+      it "should be aliased as #{key_alias}" do
+        h.send(key_alias.to_sym, :foo).should be(true)
+        h.send(key_alias.to_sym, 'foo').should be(true)
+      end
+    end
+  end
+
+  describe '#update' do
+    subject{ IndifferentHash.new(:foo => 'bar') }
+    it 'should allow keys to be indifferent still' do
+      subject.update(:baz => 'qux')
+      subject['foo'].should == 'bar'
+      subject['baz'].should == 'qux'
+    end
+
+    it 'should recursively inject indifference into sub-hashes' do
+      subject.update(:baz => {:qux => 'abc'})
+      subject['baz']['qux'].should == 'abc'
+    end
+
+    it 'should not change the ancestors of the injected object class' do
+      subject.update(:baz => {:qux => 'abc'})
+      Hash.new.should_not be_respond_to(:indifferent_access?)
+    end
+  end
+end