hashie-pre 2.0.0.beta

data/lib/hashie/trash.rb

@@ -0,0 +1,77 @@
+require 'hashie/dash'
+
+module Hashie
+  # A Trash is a 'translated' Dash where the keys can be remapped from a source
+  # hash.
+  #
+  # 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
+
+    # 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
+        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
+        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
+
+    # Set a value on the Dash in a Hash-like way. Only works
+    # on pre-existing properties.
+    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
+    end
+
+    private
+
+    def self.translations
+      @translations ||= []
+    end
+
+    def self.transforms
+      @transforms ||= {}
+    end
+
+    # Raises an NoMethodError if the property doesn't exist
+    #
+    def property_exists?(property)
+      unless self.class.property?(property.to_sym)
+        raise NoMethodError, "The property '#{property}' is not defined for this Trash."
+      end
+      true
+    end
+  end
+end

data/lib/hashie/version.rb

@@ -0,0 +1,3 @@
+module Hashie
+  VERSION = '2.0.0.beta'
+end

data/spec/hashie/clash_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Hashie::Clash do
+  before do
+    @c = Hashie::Clash.new
+  end
+  
+  it 'should be able to set an attribute via method_missing' do
+    @c.foo('bar')
+    @c[:foo].should == 'bar'
+  end
+  
+  it 'should be able to set multiple attributes' do
+    @c.foo('bar').baz('wok')
+    @c.should == {:foo => 'bar', :baz => 'wok'}
+  end
+  
+  it 'should convert multiple arguments into an array' do
+    @c.foo(1, 2, 3)
+    @c[:foo].should == [1,2,3]
+  end
+  
+  it 'should be able to use bang notation to create a new Clash on a key' do
+    @c.foo!
+    @c[:foo].should be_kind_of(Hashie::Clash)
+  end
+  
+  it 'should be able to chain onto the new Clash when using bang notation' do
+    @c.foo!.bar('abc').baz(123)
+    @c.should == {:foo => {:bar => 'abc', :baz => 123}}
+  end
+  
+  it 'should be able to jump back up to the parent in the chain with #_end!' do
+    @c.foo!.bar('abc')._end!.baz(123)
+    @c.should == {:foo => {:bar => 'abc'}, :baz => 123}
+  end
+  
+  it 'should merge rather than replace existing keys' do
+    @c.where(:abc => 'def').where(:hgi => 123)
+    @c.should == {:where => {:abc => 'def', :hgi => 123}}
+  end
+end

data/spec/hashie/dash_spec.rb

@@ -0,0 +1,215 @@
+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, :required => true
+  property :email
+  property :count, :default => 0
+end
+
+class DashNoRequiredTest < Hashie::Dash
+  property :first_name
+  property :email
+  property :count, :default => 0
+end
+
+class Subclassed < DashTest
+  property :last_name, :required => true
+end
+
+describe DashTest do
+
+  subject { DashTest.new(:first_name => 'Bob', :email => 'bob@example.com') }
+
+  it('subclasses Hashie::Hash') { should respond_to(:to_mash) }
+
+  its(:to_s) { should == '#<DashTest count=0 email="bob@example.com" first_name="Bob">' }
+
+  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
+
+  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
+
+  it 'errors out when attempting to set a required property to nil' do
+    lambda { subject.first_name = nil }.should raise_error(ArgumentError)
+  end
+
+  context 'writing to properties' do
+
+    it 'fails writing a required property to nil' do
+      lambda { subject.first_name = nil }.should raise_error(ArgumentError)
+    end
+
+    it 'fails writing a required property to nil using []=' do
+      lambda { subject['first_name'] = nil }.should raise_error(ArgumentError)
+    end
+
+    it 'fails writing to a non-existent property using []=' do
+      lambda { subject['nonexistent'] = 123 }.should raise_error(NoMethodError)
+    end
+
+    it 'works for an existing property using []=' do
+      subject['first_name'] = 'Bob'
+      subject['first_name'].should == 'Bob'
+      subject[:first_name].should == 'Bob'
+    end
+
+    it 'works for an existing property using a method call' do
+      subject.first_name = 'Franklin'
+      subject.first_name.should == 'Franklin'
+    end
+  end
+
+  context 'reading from properties' do
+    it 'fails reading from a non-existent property using []' do
+      lambda { subject['nonexistent'] }.should raise_error(NoMethodError)
+    end
+
+    it "should be able to retrieve properties through blocks" do
+      subject["first_name"] = "Aiden"
+      value = nil
+      subject.[]("first_name") { |v| value = v }
+      value.should == "Aiden"
+    end
+
+    it "should be able to retrieve properties through blocks with method calls" do
+      subject["first_name"] = "Frodo"
+      value = nil
+      subject.first_name { |v| value = v }
+      value.should == "Frodo"
+    end
+  end
+
+  describe '.new' do
+    it 'fails with non-existent properties' do
+      lambda { described_class.new(:bork => '') }.should raise_error(NoMethodError)
+    end
+
+    it 'should set properties that it is able to' do
+      obj = described_class.new :first_name => 'Michael'
+      obj.first_name.should == 'Michael'
+    end
+
+    it 'accepts nil' do
+      lambda { DashNoRequiredTest.new(nil) }.should_not raise_error
+    end
+
+    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
+
+    it "fails when required values are missing" do
+      expect { DashTest.new }.to raise_error(ArgumentError)
+    end
+
+  end
+
+  describe 'properties' do
+    it 'lists defined properties' do
+      described_class.properties.should == Set.new([:first_name, :email, :count])
+    end
+
+    it 'checks if a property exists' do
+      described_class.property?('first_name').should be_true
+      described_class.property?(:first_name).should be_true
+    end
+
+    it 'checks if a property is required' do
+      described_class.required?('first_name').should be_true
+      described_class.required?(:first_name).should be_true
+    end
+
+    it 'doesnt include property from subclass' do
+      described_class.property?(:last_name).should be_false
+    end
+
+    it 'lists declared defaults' do
+      described_class.defaults.should == { :count => 0 }
+    end
+  end
+end
+
+describe Hashie::Dash, 'inheritance' do
+  before do
+    @top = Class.new(Hashie::Dash)
+    @middle = Class.new(@top)
+    @bottom = Class.new(@middle)
+  end
+
+  it 'reports empty properties when nothing defined' do
+    @top.properties.should be_empty
+    @top.defaults.should be_empty
+  end
+
+  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
+
+  it 'should allow nil defaults' do
+    @bottom.property :echo, :default => nil
+    @bottom.new.should have_key('echo')
+  end
+
+end
+
+describe Subclassed do
+
+  subject { Subclassed.new(:first_name => 'Bob', :last_name => 'McNob', :email => 'bob@example.com') }
+
+  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/extensions/coercion_spec.rb

@@ -0,0 +1,70 @@
+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 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 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
+  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/indifferent_access_spec.rb

@@ -0,0 +1,66 @@
+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
+    it 'should find it indifferently' do
+      h = subject.new(:foo => 'bar')
+      h.should be_key(:foo)
+      h.should be_key('foo')
+    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