opium 1.5.4 → 1.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5e532f3a073fd1b08d3b659faf9a2012b75de256
-  data.tar.gz: c4df755ca1dd1d8f3af4822740e8bb086197679b
+  metadata.gz: b53eb8b7bd8065147581a1ad93cc314190142304
+  data.tar.gz: 19898ad35c81040d44ba9765cf66319c1a4a6bc7
 SHA512:
-  metadata.gz: 1caaf649218ecbc0ac3e69ae32bc5d8f087b2189ff9280f3b335010ae4173ee5dc7d74b7c9df987607205a1a6d667dde62df44e11d51c115d71e8f4c2ca7e3f9
-  data.tar.gz: fa9d3fdf08b4c3c635fd579529540aade5b3c7bcb5ceea1cc4fb56ad8e27edf5825aa37cfa767313625c31646baa7ae91f6414bba93711c92c0a97bdeaf5ed96
+  metadata.gz: b3979d70c2107f4865da5804cddf925c7731c098f6f0dfab6180cc2388d598021937d6d441752f7a2fb8d795855357f9fe0c0b4a50bd937cd6d1bc5fb3c4114c
+  data.tar.gz: 1351e6632df54fdf436c0c1358387d24629022fe47e00afcfd9c5efed9958c252a041cc61058ea05cdb5054dda64c205dfd72de69f57271614c737200a9cba5f

data/.travis.yml

@@ -6,6 +6,7 @@ rvm:
   - 2.2.3
   - 2.2.4
   - 2.3.1
+  - 2.3.4
 
 before_install:
   - gem update bundler

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 1.5.5
+### Resolved Issues
+- Attributable no longer stores unknown fields within the attributes hash of the object; rather, a new accessor is created on the fly for the class to store that data. This should prevent serialization from breaking on unknown fields with more recent versions of ActiveModel.
+- User should not be storing any data other than its known fields. This was primarily an issue with the find by session token endpoint, which is now mysteriously embedding `__type` and `className` into the results.
+
 ## 1.5.4
 ### Resolved Issues
 - #55: Opium::Installation was not properly using the master key for performing queries. Parse requires the presence of the master key to perform any sort of non-id query on installations.

data/README.md

@@ -465,10 +465,22 @@ player.high_scores.include?( score3 )   # true, as the above setter updates play
 
 ### Querying data
 
+Models can be searched for via one of two different methods: by their associated `id` field value, or by criteria defining the attributes a model must have to be part of a match set.
+
 #### Find by id
 
+IDs in Parse should be unique within a given model class. As such, finding by id always returns, at most, one result: the model instance associated with the provided id.
+
+`Opium::Model` provides a single class method, `find` for performing an id search. It accepts a single parameter, `id`, being a string representing the id to look for. Should a matching model exist, it will be the return value of the method; otherwise, an exception is raised. Any class which mixes in `Opium::Model` has access to this method.
+
+```ruby
+score = HighScore.find( 'd3ADb3Ef' )
+```
+
 #### Criteria & Scopes
 
+While `find` is useful if a model id is already available, it is more often desirable to perform a query across more and varied content stored within the model. This is where criteria come into play.
+
 #### Kaminari support
 
 Opium comes with support for [Kaminari](https://rubygems.org/gems/kaminari). To ensure that Opium loads itself correctly, please specify it _after_ Kaminari within your Gemfile:
@@ -507,6 +519,18 @@ Note that note all of these data are supported on all platforms.
 
 Once the push has be configured as desired, it can be sent out by triggering the `create` method, which will either raise an error on failure or return true on success. Note that a truthy return value does not necessarily indicate that Parse has successfully sent any notifications; rather it merely indicates that Parse has successfully received the push request and did not find anything egregious in it.
 
+In the following example, a push is scheduled for a day in the future which targets some channels.
+
+```ruby
+p = Opium::Push.new(
+  alert: 'Be sure to watch our eSports tournament on Twitch!',
+  push_at: 1.day.from_now,
+  expiration_interval: 1.day,
+  channels: %w[ Gaming eSports Tournaments ]
+)
+p.create
+```
+
 ### Advanced Targeting
 
 ## Contributing

data/lib/opium/model/attributable.rb

@@ -2,40 +2,39 @@ module Opium
   module Model
     module Attributable
       extend ActiveSupport::Concern
-      
+
       included do
         include ActiveModel::ForbiddenAttributesProtection
       end
-      
+
       def initialize( attributes = {} )
         super( self.class.default_attributes( self ).merge attributes )
       end
-      
+
       def attributes
         @attributes ||= {}.with_indifferent_access
       end
-      
+
       def attributes=(values)
         sanitize_for_mass_assignment( rubyize_field_names( values ) ).each do |k, v|
           field_info, setter = self.class.fields[k], :"#{k}="
-          if field_info.present? || self.respond_to?( setter )
-            send( setter, v )
-          else
-            attributes[k] = v
+          unless field_info.present? || self.respond_to?( setter )
+            self.class.send(:attr_accessor, k)
           end
+          send( setter, v )
         end
       end
-      
+
       def attributes_to_parse( options = {} )
         options[:except] ||= self.class.fields.values.select {|f| f.readonly? || f.virtual? }.map {|f| f.name} if options[:not_readonly]
         Hash[*self.as_json( options ).flat_map {|k, v| [self.class.fields[k].name_to_parse, self.class.fields[k].type.to_parse(v)]}]
       end
-      
+
       private
-      
+
       def rubyize_field_names( hash )
         hash.transform_keys {|k| self.class.ruby_canonical_field_names[k] || k}
       end
     end
   end
-end
+end

data/lib/opium/user.rb

@@ -1,17 +1,17 @@
 module Opium
   class User
     include Opium::Model
-    
+
     field :username, type: String
     field :password, type: String
     field :email, type: String
     field :email_verified, type: Boolean, readonly: true
     field :session_token, type: String, readonly: true
-    
+
     no_object_prefix!
     requires_heightened_privileges!
     add_header_to [:put, :delete], :x_parse_session_token, :session_token.to_proc
-    
+
     class << self
       # Note that this will eat any ParseErrors which get raised, and not perform any logging.
       def authenticate( username, password )
@@ -19,26 +19,27 @@ module Opium
       rescue Opium::Model::Connectable::ParseError => e
         nil
       end
-    
+
       def authenticate!( username, password )
         new( as_resource('login') { http_get query: { username: username, password: password } } )
       end
-      
+
       def find_by_session_token( token )
-        new( http_get id: 'me', headers: { x_parse_session_token: token } )
+        data = http_get id: 'me', headers: { x_parse_session_token: token }
+        new( data.slice( *fields.keys ) )
       end
     end
-    
+
     def reset_password
       reset_password!
     rescue => e
       self.errors.add( :email, e.to_s )
       false
     end
-    
+
     def reset_password!
       fail KeyError, 'an email address is required to reset password' unless email
       self.class.as_resource('requestPasswordReset') { self.class.http_post data: email }.empty?
     end
   end
-end
+end

data/lib/opium/version.rb

@@ -1,3 +1,3 @@
 module Opium
-  VERSION = "1.5.4"
+  VERSION = "1.5.5"
 end

data/spec/opium/model/attributable_spec.rb

@@ -10,41 +10,48 @@ describe Opium::Model::Attributable do
         attr_accessor :not_a_field
       end )
     end
-    
+
     subject { Book.new( title: 'Little Brother', id: 'abc123', created_at: Time.now, genre: :sci_fi ) }
-    
+
     describe '#attributes_to_parse' do
       context 'when called with no parameters' do
         it 'has all fields present, with names and values converted to parse' do
           expect( subject.attributes_to_parse ).to eq( 'objectId' => 'abc123', 'title' => 'Little Brother', 'genre' => 'sci_fi', 'createdAt' => subject.created_at.to_parse, 'updatedAt' => nil )
         end
       end
-      
+
       context 'when called with except' do
         it 'excludes the excepted fields' do
           expect( subject.attributes_to_parse( except: [:id, :updated_at] ) ).to eq( 'title' => 'Little Brother', 'genre' => 'sci_fi', 'createdAt' => subject.created_at.to_parse )
         end
       end
-      
+
       context 'when called with not_readonly' do
         it 'excludes all readonly fields' do
           expect( subject.attributes_to_parse( not_readonly: true ) ).to eq( 'title' => 'Little Brother', 'genre' => 'sci_fi' )
         end
       end
     end
-    
+
     describe '#attributes=' do
-      it 'stores unrecognized fields in the attributes hash' do
+      it 'does not store unrecognized fields in the attributes hash' do
         expect { subject.attributes = { unknownField: 42 } }.to_not raise_exception
-        expect( subject.attributes ).to have_key('unknownField')
-        expect( subject.attributes['unknownField'] ).to eq 42
+        expect( subject.attributes ).to_not have_key('unknownField')
+        expect( subject.attributes['unknownField'] ).to_not eq 42
       end
-      
+
       it 'calls relevant setters rather for non fields if they exist' do
         expect { subject.attributes = { not_a_field: 42 } }.to_not raise_exception
         expect( subject.not_a_field ).to eq 42
         expect( subject.attributes ).to_not have_key('not_a_field')
       end
+
+      it 'creates an accessor for unknown fields' do
+        expect { subject.attributes = { unknown: 42 } }.to_not raise_exception
+        expect( subject ).to respond_to( :unknown, :unknown= )
+        expect( subject.unknown ).to eq 42
+        expect( subject.attributes ).to_not have_key('unknown')
+      end
     end
   end
-end
+end

data/spec/opium/model/serialization_spec.rb

@@ -8,12 +8,12 @@ describe Opium::Model::Serialization do
       field :price
     end
   end
-  
+
   it { model.should respond_to( :include_root_in_json ) }
   it "include_root_in_json should default to false" do
     model.include_root_in_json.should == false
   end
-  
+
   describe "instance" do
     describe "with no data" do
       let( :params ) { { "id" => nil, "created_at" => nil, "updated_at" => nil, "name" => nil, "price" => nil } }
@@ -25,7 +25,7 @@ describe Opium::Model::Serialization do
         end
       end
     end
-    
+
     describe "with partial data" do
       let( :params ) { { "name" => "test", "price" => nil } }
       subject { model.new( name: "test" ) }
@@ -36,7 +36,7 @@ describe Opium::Model::Serialization do
         end
       end
     end
-    
+
     describe "with full data" do
       let( :params ) { { "name" => "test", "price" => 75.0 } }
       subject { model.new( params ) }
@@ -47,5 +47,20 @@ describe Opium::Model::Serialization do
         end
       end
     end
+
+    describe 'with non field data' do
+      let( :params ) { {'name' => 'test', 'price' => 75.0, 'extra' => true} }
+      subject { model.new( params ) }
+      it { expect { subject.as_json }.to_not raise_exception }
+
+      describe '#to_json' do
+        let(:result) { JSON.parse(subject.to_json) }
+
+        it 'only has field values' do
+          expect( result ).to include( 'name', 'price' )
+          expect( result ).to_not include( 'extra' )
+        end
+      end
+    end
   end
-end
+end

data/spec/opium/user_spec.rb

@@ -3,17 +3,17 @@ require 'spec_helper'
 describe Opium::User do
   before do
     stub_request(:get, 'https://api.parse.com/1/login?password=swordfish&username=username').to_return(
-      status: 200, 
-      body: { 
-        username: 'username', 
-        createdAt: '2014-11-01T12:00:30Z', 
+      status: 200,
+      body: {
+        username: 'username',
+        createdAt: '2014-11-01T12:00:30Z',
         updatedAt: '2015-02-10T16:37:23Z',
         objectId: 'abcd1234',
         sessionToken: 'super-secret-session-id'
       }.to_json,
       headers: { 'Content-Type' => 'application/json' }
     )
-    
+
     stub_request(:get, 'https://api.parse.com/1/login?password=deadbeef&username=username').to_return(
       status: 404,
       body: {
@@ -22,145 +22,148 @@ describe Opium::User do
       }.to_json,
       headers: { 'Content-Type' => 'application/json' }
     )
-    
+
     stub_request(:post, "https://api.parse.com/1/requestPasswordReset").with(
       body: "{\"data\":\"user@email.com\"}",
       headers: { 'Content-Type'=>'application/json' }
     ).to_return(
       status: 200,
-      body: "{}", 
+      body: "{}",
       headers: {'Content-Type' => 'application/json'}
     )
-    
+
     stub_request(:get, "https://api.parse.com/1/users/me").
       with( headers: {'X-Parse-Session-Token'=>'super-secret-session-id'} ).
       to_return(
-        :status => 200, 
+        :status => 200,
         :body => {
-          username: 'username', 
-          createdAt: '2014-11-01T12:00:30Z', 
+          username: 'username',
+          createdAt: '2014-11-01T12:00:30Z',
           updatedAt: '2015-02-10T16:37:23Z',
-          objectId: 'abcd1234'
-        }.to_json, 
+          objectId: 'abcd1234',
+          __type: 'Object',
+          className: '_User'
+        }.to_json,
         headers: { 'Content-Type' => 'application/json' }
       )
-      
+
     stub_request(:get, "https://api.parse.com/1/users/me").
       with( headers: {'X-Parse-Session-Token'=>'never-been-given-out'}).
       to_return(
-        status: 404, 
+        status: 404,
         body: {
           code: 101,
           error: 'invalid session'
-        }.to_json, 
+        }.to_json,
         headers: { 'Content-Type' => 'application/json' }
       )
   end
-  
+
   it { described_class.should respond_to( :authenticate, :authenticate! ).with(2).arguments }
   it { described_class.should respond_to( :find_by_session_token ).with(1).argument }
   it { described_class.should respond_to( :object_prefix ) }
-  
+
   it { should be_an( Opium::Model ) }
-  
+
   [:username, :password, :email, :email_verified, :session_token].each do |field_name|
     it { described_class.fields.should have_key( field_name ) }
   end
-  
+
   it { described_class.fields[:session_token].should be_readonly }
   it { expect( described_class.fields[:email_verified] ).to be_readonly }
   it { described_class.object_prefix.should be_empty }
   it { described_class.resource_name.should == 'users' }
   it { expect( described_class.requires_heightened_privileges? ).to be_truthy }
-  
+
   describe '.authenticate' do
     context 'with a good login' do
       it 'should return an Opium::User matching the credentials' do
         expect { described_class.authenticate( 'username', 'swordfish' ) }.to_not raise_exception
-        
+
         login = described_class.authenticate( 'username', 'swordfish' )
-        
-        login.should_not be_nil 
-        login.should be_a( described_class ) 
-        login.username.should == 'username' 
+
+        login.should_not be_nil
+        login.should be_a( described_class )
+        login.username.should == 'username'
         login.session_token.should_not be_nil
       end
 
     end
-    
+
     context 'with a bad login' do
       let(:login) { described_class.authenticate( 'username', 'deadbeef' ) }
-      
+
       it { expect { login }.to_not raise_exception }
       it { login.should be_nil }
     end
   end
-  
+
   describe '.authenticate!' do
     context 'with a good login' do
       it { expect { described_class.authenticate!( 'username', 'swordfish' ) }.to_not raise_exception }
     end
-    
+
     context 'with a bad login' do
       it { expect { described_class.authenticate!( 'username', 'deadbeef' ) }.to raise_exception }
     end
   end
-  
+
   describe '.find_by_session_token' do
     context 'without a token' do
       it { expect { described_class.find_by_session_token( nil ) }.to raise_exception }
     end
-    
+
     context 'with a valid token' do
       let(:current_user) { described_class.find_by_session_token( 'super-secret-session-id' ) }
-      
+
       it { expect { current_user }.to_not raise_exception }
       it { current_user.should be_a( described_class ) }
+      it { expect( current_user ).to_not respond_to( :__type, :className ) }
     end
-    
+
     context 'with an invalid token' do
       it { expect { described_class.find_by_session_token( 'never-been-given-out' ) }.to raise_exception(Opium::Model::Connectable::ParseError) }
     end
   end
-  
+
   context 'with a logged in user' do
     subject { Opium::User.new( id: 'abcd1234', session_token: 'super-secret-session-id', usernmae: 'user', email: 'user@email.com' ) }
-    
+
     it { should respond_to( :reset_password, :reset_password! ) }
-    
+
     describe '#reset_password' do
       context 'without an email' do
         before { subject.email = nil }
         after { subject.email = 'user@example.com' }
-        
+
         it { expect { subject.reset_password }.to_not raise_exception }
-        it do 
+        it do
           subject.reset_password.should == false
           subject.errors.should_not be_empty
         end
       end
-      
+
       context 'with an email' do
         it { expect { subject.reset_password }.to_not raise_exception }
         it { subject.reset_password.should == true }
       end
     end
-    
+
     describe '#reset_password!' do
       describe 'without an email' do
         before { subject.email = nil }
         after { subject.email = 'user@example.com' }
-        
+
         it { expect { subject.reset_password! }.to raise_exception }
       end
-      
+
       context 'with an email' do
         it { expect { subject.reset_password! }.to_not raise_exception }
         it { subject.reset_password!.should == true }
       end
     end
   end
-  
+
   shared_examples_for 'a varying privileges user' do |method, header_target|
     describe "##{method}" do
       let( :request ) { subject.send( method, sent_headers: true ) }
@@ -168,47 +171,47 @@ describe Opium::User do
         request
         subject.send( :sent_headers )
       end
-      
+
       context 'with a session token' do
         subject { Opium::User.new( id: 'abcd1234', session_token: 'super-secret-session-id', usernmae: 'user', email: 'user@email.com' ) }
-        
+
         it { expect( Opium::User.get_header_for( *header_target, subject ) ).to_not be_empty }
-      
+
         it { expect( sent_headers ).to be_a( Hash ) }
         it { expect( sent_headers.keys ).to include( 'X-Parse-Application-Id', 'X-Parse-Rest-Api-Key', 'X-Parse-Session-Token' ) }
         it { expect( sent_headers.keys ).to_not include( 'X-Parse-Master-Key' ) }
       end
-      
+
       context 'without a session token' do
         subject { Opium::User.new( id: 'abcd1234', session_token: nil, username: 'user', email: 'user@email.com' ) }
-        
+
         it { expect( Opium::User.get_header_for( *header_target, subject ) ).to be_empty }
-      
+
         it { expect( sent_headers ).to be_a( Hash ) }
         it { expect( sent_headers.keys ).to include( 'X-Parse-Application-Id', 'X-Parse-Master-Key' ) }
         it { expect( sent_headers.keys ).to_not include( 'X-Parse-Rest-Api-Key, X-Parse-Session-Token' ) }
       end
     end
   end
-  
+
   it_behaves_like 'a varying privileges user', :save, [:put, :update]
   it_behaves_like 'a varying privileges user', :delete, [:delete, :delete]
-  
+
   context 'within a subclass' do
     before do
       stub_const( 'SpecialUser', Class.new(Opium::User) do
         field :has_web_access, type: Opium::Boolean
       end )
     end
-    
+
     subject { SpecialUser }
-    
+
     it { is_expected.to be <= Opium::User }
     it { is_expected.to respond_to( :field, :fields ) }
     it { expect( subject.fields.keys ).to include( 'username', 'password', 'email', 'has_web_access' ) }
-    
+
     it { expect( subject ).to have_heightened_privileges }
     it { expect( subject.object_prefix ).to be_empty }
     it { expect( subject.resource_name ).to eq 'users' }
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opium
 version: !ruby/object:Gem::Version
-  version: 1.5.4
+  version: 1.5.5
 platform: ruby
 authors:
 - Joshua Bowers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-01 00:00:00.000000000 Z
+date: 2017-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -375,7 +375,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: An Object Parse.com Mapping technology for defining models.