opium 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3bbf318b07ca2a59bb917e4495abda45117aa588
-  data.tar.gz: c85609101238b4c6142df1d421a90e33e9fbf38a
+  metadata.gz: ecd9332e3c5b659bcb498c22bd08e109dab91b84
+  data.tar.gz: e9f1feaa43921e23339c2ea17905ed6f9470e796
 SHA512:
-  metadata.gz: 661189662f2ac5cdeb1b0dcb87d32ca291bdb4e888a108e7669153758160ced3f4aa06e961e625544e87c4e7d66a514e588607f0338f81793ee7029ee5266093
-  data.tar.gz: 76ef297dfd71c71a063140c88f11b48bfb6326b6ca31d333155ac9d6cdbb0917c181d337a7e67adb2038af6261cf4387644ed98211208e932d2e25d9346a3b47
+  metadata.gz: 4aa3f212aa8ab6d3a23994909f05d34df0aa7b7b767fb192946a7a2ed1f764758ad594b3ea199bf086296460cc2aeebda4864c62b1dd7911bcdcf7e5b8aeb1fb
+  data.tar.gz: ba8ccb1d384ead2549edfa4d58f9c8d852812a1081d20b301aee0c82ff742f28cbd2bec45f5a652e2474047ed3c4c8c333b235c70473d322953ba4b89839968e

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 1.2.1
+### New Features
+- Fieldable should now be refactored to be more readable and less cluttered; .field, in particular, has been split up into a set of algorithmic steps.
+- #45: If GlobalID is defined, it is automatically included into all models.
+
+### Resolved Issues
+- #46: Relations should now more gracefully handle conversions from nil and Array.
+
 ## 1.2.0
 ### New Features
 - #33: Model associations.

data/lib/opium/model/field.rb

@@ -17,6 +17,10 @@ module Opium
         end
       end
       
+      def contextual_default_value( context = nil)
+        type.to_ruby( default( context ) )
+      end
+      
       def readonly?
         self.readonly == true
       end

data/lib/opium/model/fieldable.rb

@@ -13,31 +13,10 @@ module Opium
       
       module ClassMethods
         def field( name, options = {} )
-          name = name.to_sym
-          fields[name] = Field.new( name, options[:type] || Object, options[:default], options[:readonly] || false, options[:as] )
-          ruby_canonical_field_names[name] = ruby_canonical_field_names[fields[name].name_to_parse] = name.to_s
-          parse_canonical_field_names[name] = parse_canonical_field_names[fields[name].name_to_parse] = fields[name].name_to_parse.to_s
-          class_eval do
-            define_attribute_methods [name]
-            define_method(name) do
-              self.attributes[name]
-            end
-          end
-          unless self.respond_to? "#{name}="
-            class_eval do
-              define_method("#{name}=") do |value|
-                converted = self.class.fields[name].type.to_ruby(value)
-                send( "#{name}_will_change!" ) unless self.attributes[name] == converted
-                if self.class.fields[name].relation?
-                  converted.owner ||= self 
-                  converted.metadata ||= self.class.relations[name]
-                end
-                self.attributes[name] = converted
-              end
-              send(:private, "#{name}=") if options[:readonly]
-            end
+          create_field_from( name.to_sym, options ).tap do |field|
+            create_field_getter_for( field )
+            create_field_setter_for( field )
           end
-          fields[name]
         end
         
         def has_field?( field_name )
@@ -47,19 +26,53 @@ module Opium
         alias_method :field?, :has_field?
         
         def fields
-          @fields ||= ActiveSupport::HashWithIndifferentAccess.new
+          @fields ||= {}.with_indifferent_access
         end
         
         def ruby_canonical_field_names
-          @ruby_canonical_field_names ||= ActiveSupport::HashWithIndifferentAccess.new
+          @ruby_canonical_field_names ||= {}.with_indifferent_access
         end
         
         def parse_canonical_field_names
-          @parse_canonical_field_names ||= ActiveSupport::HashWithIndifferentAccess.new
+          @parse_canonical_field_names ||= {}.with_indifferent_access
         end
         
         def default_attributes( context = nil )
-          fields.transform_values {|field| field.type.to_ruby field.default( context ) }.with_indifferent_access
+          fields.transform_values {|field| field.contextual_default_value( context ) }.with_indifferent_access
+        end
+        
+        private
+        
+        def create_field_from( name, options )
+          field = Field.new( name, options[:type] || Object, options[:default], options[:readonly] || false, options[:as] )
+          ruby_canonical_field_names[name] = ruby_canonical_field_names[field.name_to_parse] = name.to_s
+          parse_canonical_field_names[name] = parse_canonical_field_names[field.name_to_parse] = field.name_to_parse.to_s
+          fields[name] = field
+        end
+        
+        def create_field_getter_for( field )
+          class_eval do
+            define_attribute_methods [field.name]
+            define_method(field.name) do
+              self.attributes[field.name]
+            end
+          end
+        end
+        
+        def create_field_setter_for( field )
+          class_eval do
+            define_method("#{ field.name }=") do |value|
+              converted = field.type.to_ruby(value)
+              send( "#{ field.name }_will_change!" ) unless self.attributes[field.name] == converted
+              if field.relation?
+                converted = field.contextual_default_value( self ) unless converted
+                converted.owner ||= self 
+                converted.metadata ||= self.class.relations[field.name]
+              end
+              self.attributes[field.name] = converted
+            end
+            send(:private, "#{ field.name }=") if field.readonly?
+          end
         end
       end
     end

data/lib/opium/model/relation.rb

@@ -5,46 +5,55 @@ module Opium
       
       class << self
         def to_parse( object )
-          class_name =
-            case object
-            when Hash
-              fetch_hash_key_from( object, 'class_name' ) || fetch_hash_key_from( object, 'model_name' )
-            when String, Symbol
-              object
-            when is_descendant.curry[Opium::Model]
-              object.model_name
-            when self
-              object.class_name
-            else
-              fail ArgumentError, "could not convert #{ object.inspect } to a parse Relation hash"
-            end
+          class_name = determine_class_name_from( object, 'parse Relation hash' )
           fail ArgumentError, "could not determine class_name from #{ object.inspect }" unless class_name
           { __type: 'Relation', className: class_name }.with_indifferent_access
         end
         
         def to_ruby( object )
-          return if object.nil?
+          return if object.nil? || object == []
           return object if object.is_a? self
-          class_name = 
+          class_name = determine_class_name_from( object, self.name )
+          new( class_name ).tap do |relation|
             case object
-            when Hash
-              fetch_hash_key_from( object, 'class_name' ) || fetch_hash_key_from( object, 'model_name' )
-            when String, Symbol
-              object
+            when String
             when is_descendant.curry[Opium::Model]
-              object.model_name
-            else
-              fail ArgumentError, "could not convert #{ object.inspect } to a Opium::Model::Relation"
+              relation.push object
+            when contains_descendant.curry[Opium::Model]
+              object.select(&is_descendant.curry[Opium::Model]).each {|model| relation.push model}
             end
-          new( class_name )
+          end
         end
         
         private
         
+        def determine_class_name_from( object, context )
+          case object
+          when Hash
+            fetch_hash_key_from( object, 'class_name' ) || fetch_hash_key_from( object, 'model_name' )
+          when String, Symbol
+            object
+          when is_descendant.curry[Opium::Model]
+            object.model_name
+          when contains_descendant.curry[Opium::Model]
+            object.select(&is_descendant.curry[Opium::Model]).first.model_name
+          when self
+            object.class_name
+          else
+            fail ArgumentError, "could not convert #{ object.inspect } to a #{ context }"
+          end
+        end
+        
         def is_descendant
           @is_descendant ||= ->( expected_type, object ) { ( object.is_a?( Class ) ? object : object.class ) <= expected_type }
         end
         
+        def contains_descendant
+          @contains_descendant ||= ->( expected_type, object ) do 
+            object.is_a?( Enumerable ) ? object.any?( &is_descendant.curry[expected_type] ) : is_descendant.curry[expected_type]
+          end
+        end
+        
         def fetch_hash_key_from( hash, key )
           snake_case_key = key.to_s.underscore
           lower_camel_key = key.to_s.camelcase(:lower)

data/lib/opium/model.rb

@@ -40,6 +40,7 @@ module Opium
       include Inheritable
       include Batchable
       include Relatable
+      include GlobalID if defined?( GlobalID )
     end
     
     def initialize( attributes = {} )

data/lib/opium/version.rb

@@ -1,3 +1,3 @@
 module Opium
-  VERSION = "1.2.0"
+  VERSION = "1.2.1"
 end

data/spec/opium/model/relatable_spec.rb

@@ -161,6 +161,34 @@ describe Opium::Model::Relatable do
       it { expect( subject.comments ).to_not be_empty }
       it { expect( subject.comments.owner ).to eq subject }
     end
+    
+    context "when setting a model's relation" do
+      subject { Article.new id: 'abcd1234' }
+      let(:result) { subject.comments = new_value; subject.comments }
+      
+      context 'to nil' do
+        let(:new_value) { nil }
+        
+        it { expect { result }.to_not raise_exception }
+        it { expect( result ).to be_a Opium::Model::Relation }
+      end
+      
+      context 'to []' do
+        let(:new_value) { [] }
+        
+        it { expect { result }.to_not raise_exception }
+        it { expect( result ).to be_a Opium::Model::Relation }
+      end
+      
+      context 'to an array of models' do
+        let(:comment) { Comment.new }
+        let(:new_value) { [ comment ] }
+        
+        it { expect { result }.to_not raise_exception }
+        it { expect( result ).to be_a Opium::Model::Relation }
+        it { expect( result ).to include( comment ) }
+      end
+    end
   end
   
   describe '.has_one' do

data/spec/opium/model/relation_spec.rb

@@ -87,6 +87,22 @@ describe Opium::Model::Relation do
       it { expect( result ).to be_nil }
     end
     
+    context 'with an empty array' do
+      let(:convert_from) { [] }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_nil }
+    end
+    
+    context 'with an array of RelatedClass' do
+      let(:related_object) { RelatedClass.new title: 'a related object' }
+      let(:convert_from) { [ related_object ] }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_a described_class }
+      it { expect( result ).to include( related_object ) }
+    end
+    
     context 'with any unconvertable value' do
       let(:convert_from) { 42 }
       

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opium
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Joshua Bowers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-20 00:00:00.000000000 Z
+date: 2015-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler