modelish 0.1.3 → 0.2.0

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## 0.2.0 (2012-1-16)
+
+* Added support for mapping the same input property name to multiple outputs. This means that
+  Modelish::Base#translations is now a Hash instead of an Array.
+* Bug fix for Modelish::Base#to_hash to return typed property values
+
 ## 0.1.3 (2011-10-25)
 
 * Added configuration option to ignore unknown properties. The default behavior continues

data/lib/modelish/base.rb

@@ -1,10 +1,12 @@
 require 'hashie'
+require 'modelish/property_translations'
 require 'modelish/property_types'
 require 'modelish/validations'
 require 'modelish/configuration'
 
 module Modelish
-  class Base < Hashie::Trash
+  class Base < Hashie::Dash
+    include PropertyTranslations
     include PropertyTypes
     include Validations
     extend Configuration
@@ -36,6 +38,7 @@ module Modelish
       super
 
       add_property_type(name, options[:type]) if options[:type]
+      add_property_translation(options[:from], name) if options[:from]
 
       add_validator(name) { |val| validate_required(name => val).first } if options[:required]
       add_validator(name) { |val| validate_length(name, val, options[:max_length]) } if options[:max_length]
@@ -43,6 +46,26 @@ module Modelish
       add_validator(name) { |val| validate_type(name, val, options[:type]) } if options[:validate_type]
     end
 
+    # Convert this Modelish object into a vanilla Hash with stringified keys.
+    #
+    # @return [Hash] the hash of properties
+    def to_hash
+      out = {}
+      self.class.properties.each do |p|
+        val = self.send(p)
+        out[p.to_s] = val.respond_to?(:to_hash) ? val.to_hash : val
+      end
+      out
+    end
+
+    def []=(property, value)
+      if self.class.translations.keys.include?(property.to_sym)
+        send("#{property}=", value)
+      elsif property_exists?(property)
+        super
+      end
+    end
+
     private
     def property_exists?(property)
       if self.class.property?(property.to_sym)

data/lib/modelish/property_translations.rb

@@ -0,0 +1,81 @@
+module Modelish
+  # Mixin behavior for mapping one property name to another
+  module PropertyTranslations
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Adds a property translation to the model.
+      # This maps a mutator name to an existing property,
+      # so that whenever the from_name mutator is called on the
+      # model, the to_name property receives the value. If subsequent
+      # method calls add more destinations for the same source from_name,
+      # all destination properties will be updated.
+      #
+      # @example A one-to-one property translation
+      #    class MyClass
+      #      include Modelish::PropertyTranslations
+      #
+      #      attr_accessor :foo
+      #
+      #      add_property_translation(:camelFoo, :foo)
+      #    end
+      #
+      #    model = MyClass.new
+      #    model.camelFoo = 'some value'
+      #    model.foo
+      #    # => "some value"
+      #
+      # @example A one-to-many property translation
+      #    class
+      #      include ModelisH::PropertyTranslations
+      #
+      #      attr_accessor :foo, :bar
+      #
+      #      add_property_translation(:source, :foo)
+      #      add_property_translation(:source, :bar)
+      #    end
+      #
+      #    model = MyClass.new(:source => 'some value')
+      #    model.foo
+      #    # => "some value"
+      #    model.bar
+      #    # => "some value"
+      #
+      #    model.foo = 'some other value'
+      #    model.foo
+      #    # => "some other value"
+      #    model.bar
+      #    # => "some value"
+      #
+      #    model.source = 'new value'
+      #    model.foo
+      #    # => "new value"
+      #    model.bar
+      #    # => "new value"
+      #
+      # @param [Symbol,String] from_name the name of the source property
+      # @param [Symbol,String] to_name the name of the destination property
+      def add_property_translation(from_name, to_name)
+        self.translations[from_name.to_sym] ||= []
+        self.translations[from_name.to_sym] << to_name.to_sym
+
+        class_eval do
+          define_method("#{from_name}=") do |value|
+            self.class.translations[from_name.to_sym].each do |prop|
+              self.send("#{prop}=", value)
+            end
+          end
+        end
+      end
+
+      # A map of the translations that have already been configured, keyed on from_name.
+      #
+      # @return [Hash<Symbol,Array>] the key is the from_name, the value is an array to_names
+      def translations
+        @translations ||= {}
+      end
+    end
+  end
+end

data/lib/modelish/version.rb

@@ -1,3 +1,3 @@
 module Modelish
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/spec/modelish/base_spec.rb

@@ -47,6 +47,11 @@ describe Modelish::Base do
         end
       end
     end
+
+    describe "#to_hash" do
+      subject { model.to_hash }
+      it { should be_empty }
+    end
   end
 
   context "with simple property" do
@@ -57,6 +62,15 @@ describe Modelish::Base do
 
     it_should_behave_like 'a modelish property'
     it_should_behave_like 'a valid model'
+
+    describe "#to_hash" do
+      let(:init_options) { {property_name => property_value} }
+      subject { model.to_hash }
+
+      it { should have(1).key_pair }
+      it { should have_key(property_name.to_s) }
+      its(['simple_property']) { should == property_value }
+    end
   end
 
   context "with property default value" do
@@ -68,31 +82,159 @@ describe Modelish::Base do
 
     it_should_behave_like 'a modelish property'
     it_should_behave_like 'a valid model'
+
+    describe "#to_hash" do
+      subject { model.to_hash }
+
+      context "with default value" do
+        it { should have(1).key_pair }
+        it { should have_key(property_name.to_s) }
+        its(["default_property"]) { should == default_value }
+      end
+
+      context 'without default value' do
+        let(:init_options) { {property_name => property_value} }
+
+        it { should have(1).key_pair }
+        it { should have_key(property_name.to_s) }
+        its(["default_property"]) { should == property_value }
+      end
+    end
   end
 
   context "with translated property" do
-    before { model_class.property(property_name, :from => from_name) }
+    before { model_class.property(to_name, :from => from_name) }
 
-    subject { model }
-
-    let(:property_name) { :translated_property }
+    let(:to_name) { :translated_property }
     let(:from_name) { 'OldPropertyNAME' }
     let(:property_value) { 'new value' }
 
-    it_should_behave_like 'a modelish property'
+    subject { model }
+
+    context 'when there is one translation for the source property' do
+      it_should_behave_like 'a modelish property' do
+        let(:property_name) { to_name }
+      end
+
+      it { should_not respond_to(from_name) }
+      it { should respond_to("#{from_name}=") }
 
-    it { should_not respond_to(from_name) }
-    it { should respond_to("#{from_name}=") }
+      describe "translated mutator" do
+        subject { model.send("#{from_name}=", property_value) }
 
-    describe "original setter" do
-      subject { model.send("#{from_name}=", property_value) }
+        it "should change the property value" do
+          expect { subject }.to change{model.send(to_name)}.from(nil).to(property_value)
+        end
+      end
+
+      it_should_behave_like 'a valid model'
+
+      describe "#to_hash" do
+        subject { model.to_hash }
 
-      it "should change the property value" do
-        expect { subject }.to change{model.send(property_name)}.from(nil).to(property_value)
+        context "when set from untranslated property name" do
+          let(:init_options) { {to_name => property_value} }
+
+          it { should have(1).key_pair }
+          it { should have_key(to_name.to_s) }
+          its(['translated_property']) { should == property_value }
+        end
+
+        context "when set from the translation" do
+          let(:init_options) { {from_name => property_value} }
+
+          it { should have(1).key_pair }
+          it { should have_key(to_name.to_s) }
+          its(['translated_property']) { should == property_value }
+        end
       end
     end
 
-    it_should_behave_like 'a valid model'
+    context 'when there are multiple translations for the source property' do
+      before { model_class.property(other_to_name, :from => from_name) }
+      let(:other_to_name) { :my_other_prop }
+
+      it_should_behave_like 'a modelish property' do
+        let(:property_name) { other_to_name }
+      end
+
+      it_should_behave_like 'a modelish property' do
+        let(:property_name) { to_name }
+      end
+
+      it_should_behave_like 'a valid model'
+
+      it { should_not respond_to(from_name) }
+      it { should respond_to("#{from_name}=") }
+
+      describe "translated mutator" do
+        subject { model.send("#{from_name}=", property_value) }
+
+        it "should change the first property's value" do
+          expect { subject }.to change{model.send(to_name)}.from(nil).to(property_value)
+        end
+
+        it "should change the other property's value" do
+          expect { subject }.to change { model.send(other_to_name) }.from(nil).to(property_value)
+        end
+      end
+
+      describe "#to_hash" do
+        subject { model.to_hash }
+
+        context 'when initialized with first property' do
+          let(:init_options) { {to_name => property_value} }
+
+          it { should have(2).key_pairs }
+
+          it { should have_key(to_name.to_s) }
+          its(['translated_property']) { should == property_value }
+
+          it { should have_key(other_to_name.to_s) }
+          its(['my_other_prop']) { should be_nil }
+        end
+
+        context 'when initialized with second property' do
+          let(:init_options) { {other_to_name => property_value} }
+
+          it { should have(2).key_pairs }
+
+          it { should have_key(to_name.to_s) }
+          its(['translated_property']) { should be_nil }
+
+          it { should have_key(other_to_name.to_s) }
+          its(['my_other_prop']) { should == property_value }
+        end
+
+        context 'when initialized with translated property' do
+          let(:init_options) { {from_name => property_value} }
+
+          context 'when there are no individual property initializations' do
+
+            it { should have(2).key_pairs }
+
+            it { should have_key(to_name.to_s) }
+            its(['translated_property']) { should == property_value }
+
+            it { should have_key(other_to_name.to_s) } 
+            its(['my_other_prop']) { should == property_value }
+          end
+
+          context 'when one of the destination properties is independently initialized' do
+            before { init_options[to_name] = other_value }
+            let(:other_value) { 'and now for something completely different' }
+
+            it { should have(2).key_pairs }
+
+            it { should have_key(to_name.to_s) }
+            its(['translated_property']) { should == other_value }
+
+            it { should have_key(other_to_name.to_s) }
+            its(['my_other_prop']) { should == property_value }
+          end
+        end
+      end
+    end
   end
 
   context "with typed property" do
@@ -114,6 +256,14 @@ describe Modelish::Base do
       context "without init options" do
         it_should_behave_like 'a typed property', :my_int_property, Integer
         it_should_behave_like 'a valid model'
+
+        describe "#to_hash" do
+          subject { model.to_hash }
+
+          it { should have(1).key_pair }
+          it { should have_key(property_name.to_s) }
+          its(['my_int_property']) { should be_nil }
+        end
       end
 
       context "with init options" do
@@ -123,6 +273,14 @@ describe Modelish::Base do
         its(:raw_my_int_property) { should == valid_string }
 
         it_should_behave_like 'a valid model'
+
+        describe "#to_hash" do
+          subject { model.to_hash }
+
+          it { should have(1).key_pair }
+          it { should have_key(property_name.to_s) }
+          its(['my_int_property']) { should == valid_typed_value }
+        end
       end
     end
 
@@ -133,6 +291,14 @@ describe Modelish::Base do
       it_should_behave_like 'a typed property', :my_int_property, Integer
 
       it_should_behave_like 'a valid model'
+
+      describe "#to_hash" do
+        subject { model.to_hash }
+
+        it { should have(1).key_pair }
+        it { should have_key(property_name.to_s) }
+        its(['my_int_property']) { should == default_value }
+      end
     end
   end
 

data/spec/modelish/property_translations_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe Modelish::PropertyTranslations do
+  let(:model_class) do 
+    Class.new do 
+      include Modelish::PropertyTranslations
+
+      attr_accessor :foo_prop, :bar_prop
+    end
+  end
+
+  let(:model) { model_class.new }
+
+  subject { model_class }
+
+  describe '.translations' do
+    subject { model_class.translations }
+
+    it { should be_a Hash }
+    it { should be_empty }
+  end
+
+  describe '.add_property_translation' do
+    subject { add_translation }
+    let(:add_translation) { model_class.add_property_translation(from_name, to_name) }
+
+    context 'when there are no existing translations for the property' do
+      context 'with symbolic property names' do
+        let(:from_name) { :my_input_prop }
+        let(:to_name) { :foo_prop }
+
+        it 'should map the input property to the output property in the translations hash' do
+          expect { subject }.to change { model_class.translations[from_name] }.to([to_name])
+        end
+
+        describe "the generated model" do
+          before { add_translation }
+
+          subject { model }
+
+          it { should respond_to(to_name) }
+          it { should_not respond_to(from_name) }
+
+          it { should respond_to("#{to_name}=") }
+
+          let(:value) { 'blah' }
+
+          describe "non-translated mutator" do
+            subject { model.send("#{to_name}=", value) }
+
+            it 'should change the property value' do
+              expect { subject }.to change { model.send(to_name) }.from(nil).to(value)
+            end
+          end
+
+          it { should respond_to("#{from_name}=") }
+
+          describe "translated mutator" do
+            subject { model.send("#{from_name}=", value) }
+
+            it 'should change the property value' do
+              expect { subject }.to change { model.send(to_name) }.from(nil).to(value)
+            end
+          end
+        end
+      end
+
+      context 'with non-symbolic property names' do
+        let(:from_name) { 'my_input_prop' }
+        let(:to_name) { 'foo_prop' }
+
+        it 'should map the symbolic input property to the symbolic output property in the translations hash' do
+          expect { subject }.to change { model_class.translations[from_name.to_sym] }.from(nil).to([to_name.to_sym])
+        end
+      end
+    end
+
+    context 'when there is an existing translation for the property' do
+      before { model_class.add_property_translation(from_name, other_to_name) }
+      let(:other_to_name) { :bar_prop }
+      let(:from_name) { :input_prop }
+      let(:to_name) { :foo_prop }
+
+      it 'should add output property to the mapping for the input property' do
+        subject
+        model_class.translations[from_name].should include(to_name)
+        model_class.translations[from_name].should include(other_to_name)
+      end
+
+      describe 'generated model' do
+        before { add_translation }
+        subject { model }
+
+        it { should respond_to(other_to_name) }
+        it { should respond_to(to_name) }
+        it { should_not respond_to(from_name) }
+
+        it { should respond_to("#{other_to_name}=") }
+
+        let(:value) { 'blah' }
+
+        describe 'non-translated mutator for the existing property' do
+          subject { model.send("#{other_to_name}=", value) }
+
+          it 'should change the value for the existing property' do
+            expect { subject }.to change { model.send(other_to_name) }.to(value)
+          end
+
+          it 'should not change the value for the new property' do
+            expect { subject }.to_not change { model.send(to_name) }
+          end
+        end
+
+        it { should respond_to("#{to_name}=") }
+
+        describe 'non-translated mutator for the new property' do
+          subject { model.send("#{to_name}=", value) }
+
+          it 'should change the value for the new property' do
+            expect { subject }.to change { model.send(to_name) }.to(value)
+          end
+
+          it 'should not change the value for the existing property' do
+            expect { subject }.to_not change { model.send(other_to_name) }
+          end
+        end
+
+        it { should respond_to("#{from_name}=") }
+
+        describe 'translated mutator' do
+          subject { model.send("#{from_name}=", value) }
+
+          it 'should change the value for the existing property' do
+            expect { subject }.to change { model.send(other_to_name) }.to(value)
+          end
+
+          it 'should change the value for the new property' do
+            expect { subject }.to change { model.send(to_name) }.to(value)
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: modelish
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
-  - 3
-  version: 0.1.3
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Maeve Revels
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-25 00:00:00 -07:00
+date: 2012-01-16 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -101,12 +101,14 @@ files:
 - lib/modelish.rb
 - lib/modelish/base.rb
 - lib/modelish/configuration.rb
+- lib/modelish/property_translations.rb
 - lib/modelish/property_types.rb
 - lib/modelish/validations.rb
 - lib/modelish/version.rb
 - modelish.gemspec
 - spec/modelish/base_spec.rb
 - spec/modelish/configuration_spec.rb
+- spec/modelish/property_translations_spec.rb
 - spec/modelish/property_types_spec.rb
 - spec/modelish/validations_spec.rb
 - spec/modelish_spec.rb
@@ -152,6 +154,7 @@ summary: A lightweight pseudo-modeling not-quite-framework
 test_files: 
 - spec/modelish/base_spec.rb
 - spec/modelish/configuration_spec.rb
+- spec/modelish/property_translations_spec.rb
 - spec/modelish/property_types_spec.rb
 - spec/modelish/validations_spec.rb
 - spec/modelish_spec.rb