opium 1.3.1 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 41273455a1d59fc4ccd1bfe03f43f2cdce23384d
-  data.tar.gz: 221b878aba20e3acbc3201986bc0fe0f73c314d6
+  metadata.gz: b0f70beb198984ac00eabd7d1846b019aaac4b88
+  data.tar.gz: a3c498197bab34dfdf975896ca7433d27c9674f8
 SHA512:
-  metadata.gz: 559adc15de59342f0bb01d4ac5c20a4d6453a2c9211b66b71db2dc324196ae06b87a2db363845a35b2c6589cc3b860814e9c621ab9f985d17bf77ecdee851d6d
-  data.tar.gz: 9ac14b003d4822f3cb0933a41948588febb6165f88215607dfcce491c3c757a4719280089a6ac8faa22168cbf12136a923163fea421048eb498bd10733dff694
+  metadata.gz: e19ebe57797de055860c1e4a0007bb65857a9fa2a84e25bc0cd506859b7397c98578b98f4cdb10105cdc37156b9fed1c163992959d251e1bfaa51695d83d6c94
+  data.tar.gz: a7426e0281a31ea40c4c24615bf9e37eba51b1409fd7025847868f2670bff81588af480b53648e3cf635102186e3c33fb3a466a324a36496adabcb530769a3bc

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 1.3.2
+### Resolved Issues
+- #51: Queryable#translate_to_parse now attempts to ensure that constraint values
+are converted to the associated field type.
+
 ## 1.3.1
 ### Resolved Issues
 - #50: Model::Dirty#save! now overridden to apply dirty changes when invoked.

data/lib/opium/model/queryable.rb

@@ -2,79 +2,79 @@ module Opium
   module Model
     module Queryable
       extend ActiveSupport::Concern
-      
+
       module ClassMethods
         delegate :count, :total_count, to: :criteria
-        
+
         def all( constraints = nil )
           constraints ? imbued_where( arrayize( constraints ), '$all' ) : criteria
         end
-        
+
         alias_method :all_in, :all
-        
+
         def between( constraints )
           start = constraints.map {|key, range| [key, range.begin]}
           inclusive = constraints.reject {|_, range| range.exclude_end?}.map {|key, range| [key, range.end]}
           exclusive = constraints.select {|_, range| range.exclude_end?}.map {|key, range| [key, range.end]}
           gte( start ).lte( inclusive ).lt( exclusive )
         end
-        
+
         def exists( constraints )
-          imbued_where( constraints.map {|key, value| [key, value.to_bool] }, '$exists' )
+          imbued_where( constraints.map {|key, value| [key, value.to_bool.freeze] }, '$exists' )
         end
-        
+
         def gt( constraints )
           imbued_where( constraints, '$gt' )
         end
-        
+
         def gte( constraints )
           imbued_where( constraints, '$gte' )
         end
-        
+
         def lt( constraints )
           imbued_where( constraints, '$lt' )
         end
-        
+
         def lte( constraints )
           imbued_where( constraints, '$lte' )
         end
-        
+
         def in( constraints )
           imbued_where( arrayize( constraints ), '$in' )
         end
-        
+
         alias_method :any_in, :in
-        
+
         def nin( constraints )
           imbued_where( arrayize( constraints ), '$nin' )
         end
-        
+
         def ne( constraints )
           imbued_where( constraints, '$ne' )
         end
-        
+
         def or( *subqueries )
-          where( '$or' => subqueries )
+          where( '$or' => subqueries.map {|query| translate_to_parse( query )}.freeze )
         end
-        
+
         def select( constraints )
           imbued_where( constraints, '$select' )
         end
-        
+
         def dont_select( constraints )
           imbued_where( constraints, '$dontSelect' )
         end
-        
+
         def keys( *field_names )
           validate_fields_exist( field_names )
           criteria.update_constraint( :keys, field_names.map(&method(:translate_name)).join(',') )
         end
-        
-        # Should be noted that pluck is an immediate query execution, so doesn't play well with further chainable criteria        
+
+        # Should be noted that pluck is an immediate query execution, so doesn't play well with further chainable criteria
         def pluck( field_name )
 
         end
-        
+
         def order( options )
           validate_fields_exist( options )
           previous = criteria.constraints[:order]
@@ -83,40 +83,40 @@ module Opium
             ).join(',')
           criteria.update_constraint( :order, ordering )
         end
-        
+
         def limit( value )
           criteria.update_constraint( :limit, value )
         end
-        
+
         def skip( value )
           criteria.update_constraint( :skip, value )
         end
-        
+
         def where( constraints )
           validate_fields_exist( constraints )
           criteria.update_constraint( :where, translate_to_parse( constraints ) )
         end
-        
+
         alias_method :and, :where
-        
+
         def cache
           criteria.update_variable( :cache, true )
         end
-        
+
         def uncache
           criteria.update_variable( :cache, false )
         end
-        
+
         def cached?
           criteria.variables[:cache]
         end
-        
+
         private
-        
+
         def model
           self
         end
-        
+
         def validate_fields_exist( field_names )
           field_names = field_names.keys if field_names.respond_to? :keys
           unless field_names.all? {|field_name| model.fields.key?( field_name ) || field_name =~ /^\$/ }
@@ -124,27 +124,41 @@ module Opium
             raise ArgumentError, "#{not_fields.join(', ')} #{not_fields.length > 1 ? 'are not fields' : 'is not a field'} on this model"
           end
         end
-        
+
         def translate_name( field_name )
           field_name =~ /^\$/ ? field_name : model.parse_canonical_field_names[ field_name ]
         end
-        
+
         def translate_to_parse( constraints )
-          Hash[ *constraints.flat_map {|key, value| [translate_name( key ), value.to_parse]} ]
+          Hash[ *constraints.flat_map {|key, value| [translate_name( key ), convert_to_field_type( key, value )]} ]
         end
-        
+
+        def convert_to_field_type( field_name, value )
+          return value if value.frozen?
+          case value
+          when Array
+            value.map {|i| convert_to_field_type( field_name, i)}
+          when Hash
+            Hash[ *value.flat_map {|k, v| [translate_name( k ), convert_to_field_type( field_name, v)]} ]
+          when Criteria, Pointer, Model
+            value.to_parse
+          else
+            model.fields[field_name].type.to_parse value
+          end
+        end
+
         def arrayize( constraints )
           constraints.map {|key, value| [key, value.to_a]}
         end
-        
+
         def imbued_where( constraints, operator )
           where( imbue_field_constraints_with_operator( constraints, operator ) )
         end
-        
+
         def imbue_field_constraints_with_operator( constraints, operator )
           Hash[ *constraints.flat_map {|key, value| [key, { operator => value }]} ]
         end
       end
     end
   end
-end
+end

data/lib/opium/version.rb

@@ -1,3 +1,3 @@
 module Opium
-  VERSION = "1.3.1"
+  VERSION = "1.3.2"
 end

data/opium.gemspec

@@ -25,16 +25,16 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec-nc"
   spec.add_development_dependency "rspec-its"
   spec.add_development_dependency "webmock"
-  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard", "2.12.5"
   spec.add_development_dependency "guard-rspec"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "pry-remote"
   spec.add_development_dependency "pry-nav"
   spec.add_development_dependency "coveralls"
-  
+
   # spec.add_development_dependency "rails"
   # spec.add_development_dependency "kaminari"
-  
+
   spec.add_dependency "activemodel", "~> 4.0"
   spec.add_dependency "faraday", "~> 0.9"
   spec.add_dependency "faraday_middleware", "~> 0.9"

data/spec/opium/model/queryable_spec.rb

@@ -5,7 +5,7 @@ describe Opium::Model::Queryable do
 
   context 'when included in a class' do
     subject { model }
-    
+
     it { is_expected.to respond_to( :all, :all_in ).with(1).argument }
     it { is_expected.to respond_to( :and ).with(1).argument }
     it { is_expected.to respond_to( :between ).with(1).argument }
@@ -23,62 +23,68 @@ describe Opium::Model::Queryable do
     it { is_expected.to respond_to( :cache, :uncache, :cached? ) }
     it { is_expected.to respond_to( :count, :total_count ) }
   end
-  
+
   context 'within a model' do
     before do
       stub_const( 'Game', Class.new do
         include Opium::Model
         field :title, type: String
         field :price, type: Float
-        
+
         stub(:model_name).and_return( 'Game' )
-        
+
         default_scope order( title: :asc )
       end )
     end
-    
+
     after do
       Opium::Model::Criteria.models.clear
     end
-    
+
     subject { Game }
-    
+
     describe '.where' do
       it 'returns a criteria' do
         subject.where( price: { '$lte' => 5 } ).should be_a( Opium::Model::Criteria )
       end
-      
+
       it 'sets the "where" constraint to the provided value' do
         subject.where( price: { '$lte' => 5 } ).tap do |criteria|
           criteria.constraints.should have_key( 'where' )
           criteria.constraints['where'].should =~ { 'price' => { '$lte' => 5 } }
         end
       end
-      
+
       it 'deep merges the "where" constraint on successive calls' do
         subject.where( price: { '$lte' => 5 } ).where( price: { '$gte' => 1 } ).tap do |criteria|
           criteria.constraints['where'].should =~ { 'price' => { '$lte' => 5, '$gte' => 1 } }
         end
       end
-      
+
       it 'ensures that specified fields exist on the model' do
         expect { subject.where( does_not_exist: true ) }.to raise_exception
       end
-      
+
       it 'maps ruby names to parse names and ruby values to parse values' do
         time = Time.now - 1000
         subject.where( created_at: { '$gte' => time } ).tap do |criteria|
           criteria.constraints['where'].should =~ { 'createdAt' => { '$gte' => time.to_parse } }
         end
       end
+
+      it 'converts constraint values to the field type' do
+        subject.where( price: '14.99' ).tap do |criteria|
+          expect( criteria.constraints['where']['price'] ).to eq 14.99
+        end
+      end
     end
-        
+
     shared_examples_for 'a chainable criteria clause' do |method|
       describe ".#{method}" do
         it 'should return a criteria' do
           subject.send( method, price: 5, title: 'Skyrim' ).should be_a( Opium::Model::Criteria )
         end
-      
+
         it "should add a \"$#{method}\" clause to the where constraint for each member of the hash" do
           subject.send( method, price: 5, title: 'Skyrim' ).tap do |criteria|
             criteria.constraints.should have_key( 'where' )
@@ -87,19 +93,19 @@ describe Opium::Model::Queryable do
         end
       end
     end
-    
+
     it_should_behave_like 'a chainable criteria clause', :gte
     it_should_behave_like 'a chainable criteria clause', :lte
     it_should_behave_like 'a chainable criteria clause', :gt
     it_should_behave_like 'a chainable criteria clause', :lt
     it_should_behave_like 'a chainable criteria clause', :ne
-    
+
     shared_examples_for 'a chainable array-valued criteria clause' do |method|
       describe ":#{method}" do
         it 'should return a criteria' do
           subject.send( method, price: [1, 2, 3, 4] ).should be_a( Opium::Model::Criteria )
         end
-        
+
         it "should add a \"$#{method}\" clause to the where constraint for each member of the hash, converting pair values to arrays" do
           subject.send( method, price: 1..4, title: ['Skyrim', 'Oblivion'] ).tap do |criteria|
             criteria.constraints.should have_key( 'where' )
@@ -108,7 +114,7 @@ describe Opium::Model::Queryable do
         end
       end
     end
-    
+
     it_should_behave_like 'a chainable array-valued criteria clause', :all
     it_should_behave_like 'a chainable array-valued criteria clause', :in
     it_should_behave_like 'a chainable array-valued criteria clause', :nin
@@ -120,26 +126,26 @@ describe Opium::Model::Queryable do
         end
       end
     end
-    
+
     it_should_behave_like 'an aliased method', :and, :where
     it_should_behave_like 'an aliased method', :all_in, :all
     it_should_behave_like 'an aliased method', :any_in, :in
-    
+
     describe '.all' do
       context 'when no parameter is given' do
         let(:result) { subject.all }
-        
+
         it { expect { result }.to_not raise_exception }
         it { expect( result ).to be_a Opium::Model::Criteria }
         it { expect( result ).to eq subject.criteria }
       end
     end
-        
+
     describe ':exists' do
       it 'should return a criteria' do
         subject.exists( price: true ).should be_a( Opium::Model::Criteria )
       end
-      
+
       it 'should add a "$exist" clause for each hash pair, set to the truthiness of the pair value' do
         subject.exists( price: true, title: 'no' ).tap do |criteria|
           criteria.constraints.should have_key( 'where' )
@@ -147,61 +153,61 @@ describe Opium::Model::Queryable do
         end
       end
     end
-    
+
     describe '#between' do
       context 'with a inclusive range' do
         subject { Game.between( price: 5..10 ) }
-        
+
         it { is_expected.to be_an( Opium::Model::Criteria ) }
-        
+
         it { expect( subject.criteria.constraints ).to include(:where) }
-        
+
         it 'adds a clause on the key' do
           expect( subject.criteria.constraints[:where] ).to include(:price)
         end
-        
+
         it 'adds a "$gte" clause to the key' do
           expect( subject.criteria.constraints[:where][:price] ).to include( '$gte' => 5 )
         end
-        
+
         it 'adds an "$lte" clause to the key' do
           expect( subject.criteria.constraints[:where][:price] ).to include( '$lte' => 10 )
         end
-        
+
         it 'does not add an "$lt" clause to the key' do
           expect( subject.criteria.constraints[:where][:price].keys ).to_not include( '$lt' )
         end
       end
-      
+
       context 'with an exclusive range' do
         subject { Game.between( price: 5...10 ) }
-        
+
         it 'adds a "$gte" clause to the key' do
           expect( subject.criteria.constraints[:where][:price] ).to include( '$gte' => 5 )
         end
-        
+
         it 'adds an "$lt" clause to the key' do
           expect( subject.criteria.constraints[:where][:price] ).to include( '$lt' => 10 )
         end
-        
+
         it 'does not add an "$lte" clause to the key' do
           expect( subject.criteria.constraints[:where][:price].keys ).to_not include( '$lte' )
         end
       end
     end
-    
+
     describe ':select' do
       it 'should return a criteria' do
         subject.select( title: subject.between( price: 5..10 ).keys( :title ) ).should be_a( Opium::Model::Criteria )
       end
-      
+
       it 'should add a "$select" clause for each hash key, setting the value to a query expression based off the pair-value criteria' do
         subject.select( title: subject.between( price: 5..10 ).keys( :title ) ).tap do |criteria|
           criteria.constraints.should have_key( 'where' )
           criteria.constraints['where'].should =~ {
-            'title' => { '$select' => { 
-              'query' => { 'className' => 'Game', 'where' => { 'price' => { '$gte' => 5, '$lte' => 10 } } }, 
-              'key' => 'title' 
+            'title' => { '$select' => {
+              'query' => { 'className' => 'Game', 'where' => { 'price' => { '$gte' => 5, '$lte' => 10 } } },
+              'key' => 'title'
               } }
           }
         end
@@ -212,25 +218,25 @@ describe Opium::Model::Queryable do
       it 'should return a criteria' do
         subject.dont_select( title: subject.between( price: 5..10 ).keys( :title ) ).should be_a( Opium::Model::Criteria )
       end
-      
+
       it 'should add a "$donSelect" clause for each hash key, setting the value to a query expression based off the pair-value criteria' do
         subject.dont_select( title: subject.between( price: 5..10 ).keys( :title ) ).tap do |criteria|
           criteria.constraints.should have_key( 'where' )
           criteria.constraints['where'].should =~ {
-            'title' => { '$dontSelect' => { 
-              'query' => { 'className' => 'Game', 'where' => { 'price' => { '$gte' => 5, '$lte' => 10 } } }, 
-              'key' => 'title' 
+            'title' => { '$dontSelect' => {
+              'query' => { 'className' => 'Game', 'where' => { 'price' => { '$gte' => 5, '$lte' => 10 } } },
+              'key' => 'title'
               } }
           }
         end
       end
     end
-    
+
     describe ':or' do
       it 'should return a criteria' do
         subject.or( { title: 'Skyrim' }, { title: 'Oblivion' } ).should be_a( Opium::Model::Criteria )
       end
-      
+
       it 'should add an "$or" clause to the "where" constraint, whose contents are an array of all specified subqueries' do
         subject.or( { title: 'Skyrim' }, { title: 'Oblivion' } ).tap do |criteria|
           criteria.constraints.should have_key( 'where' )
@@ -240,29 +246,29 @@ describe Opium::Model::Queryable do
         end
       end
     end
-    
+
     describe ':keys' do
       it 'should return a criteria' do
         subject.keys( :price ).should be_a( Opium::Model::Criteria )
       end
-      
+
       it 'should set the "keys" constraint to the provided set of fields, whose names should be parsized' do
         subject.keys( :price, :updated_at ).tap do |criteria|
           criteria.constraints.should have_key( 'keys' )
           criteria.constraints['keys'].should == 'price,updatedAt'
         end
       end
-      
+
       it 'should raise if a specified field does not exist' do
         expect { subject.keys( :does_not_exist ) }.to raise_exception
       end
     end
-        
+
     describe ':limit' do
       it 'should return a criteria' do
         subject.limit( 5 ).should be_a( Opium::Model::Criteria )
       end
-      
+
       it 'should set the "limit" constraint to the provided value' do
         subject.limit( 100 ).tap do |criteria|
           criteria.constraints.should have_key( 'limit' )
@@ -270,12 +276,12 @@ describe Opium::Model::Queryable do
         end
       end
     end
-    
+
     describe ':skip' do
       it 'should return a criteria' do
         subject.skip( 5 ).should be_a( Opium::Model::Criteria )
       end
-      
+
       it 'should set the "skip" constraint to the provided value' do
         subject.skip( 100 ).tap do |criteria|
           criteria.constraints.should have_key( 'skip' )
@@ -283,19 +289,19 @@ describe Opium::Model::Queryable do
         end
       end
     end
-    
+
     describe ':order' do
       it 'should return a criteria' do
         subject.order( title: :asc ).should be_a( Opium::Model::Criteria )
       end
-      
+
       it 'should set the "order" constraint to a string' do
         subject.unscoped.order( title: :asc ).tap do |criteria|
           criteria.constraints.should have_key( 'order' )
           criteria.constraints['order'].should == 'title'
         end
       end
-      
+
       it 'should negate the field if given something which evaluates to "desc", "-1", or "-"' do
         [:desc, -1, '-'].each do |direction|
           subject.unscoped.order( title: direction ).tap do |criteria|
@@ -303,46 +309,46 @@ describe Opium::Model::Queryable do
           end
         end
       end
-      
+
       it 'should combine multiple orderings via a comma' do
         subject.unscoped.order( title: 1, price: -1 ).tap do |criteria|
           criteria.constraints['order'].should == 'title,-price'
         end
       end
-      
+
       it 'should concatenate successive orderings' do
         subject.unscoped.order( title: 1 ).order( price: -1 ).tap do |criteria|
           criteria.constraints['order'].should == 'title,-price'
         end
       end
     end
-    
+
     describe ':cached?' do
       it 'should be false on a non-cached criteria' do
         Game.criteria.cached?.should be_falsey
       end
     end
-    
+
     describe ':cache' do
       after { subject.uncache }
-      
+
       it 'should return a criteria' do
         subject.cache.should be_an( Opium::Model::Criteria )
       end
-      
+
       it 'should cause :cached? to return true' do
         subject.cache.cached?.should == true
       end
     end
-    
+
     describe ':uncache' do
       it 'should return a criteria' do
         subject.uncache.should be_an( Opium::Model::Criteria )
       end
-      
+
       it 'should cause :cached? to return false' do
         subject.uncache.cached?.should == false
       end
     end
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opium
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.3.2
 platform: ruby
 authors:
 - Joshua Bowers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-13 00:00:00.000000000 Z
+date: 2016-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -98,16 +98,16 @@ dependencies:
   name: guard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.12.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.12.5
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   requirement: !ruby/object:Gem::Requirement