active_remote 2.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f3b021e02d82dd94367950f76e8601d35dd47c28
-  data.tar.gz: 23885a9b4e9a3166c7096fc983b6ede7c692f874
+  metadata.gz: ad233ac94027246310c94addc5e595b1cb6d25fb
+  data.tar.gz: 0a1985fd4e52f98fb757fccdb04ccd097ee4abd4
 SHA512:
-  metadata.gz: 755211aa1e0e8db43d1eaf5c590f625edac7b56b73d2a91267b6473453774d2ddac17822c17f8456f90d3df549704f8995e5955bc63f135add6ade14bab1a49e
-  data.tar.gz: f0c44e8adb7043d79b172b9745b0d089a1824ed0ff4a8f3d94d24fde9e3740208db5805e5817158ed81c7f3a3133908cd97359bc44460ecaf28ad652f8987a32
+  metadata.gz: 7dabce988979749626a43fa3ddcfbaa2df930f8c70e57c172e6a89c7390d9ab11e47def151c2b7773cf486572b719affcb41e329e0aca7e40a00a16389c6172c
+  data.tar.gz: 9c57148a75afc5dd51f5ec5a6d31e96c446888153099c38cc970a2d04a57431a194022fcd88a21d057c319e11f5d20d6e6563b4b5f87cf8b4fef2af1a72202ca

data/active_remote.gemspec

@@ -29,8 +29,9 @@ Gem::Specification.new do |s|
   s.add_development_dependency "better_receive"
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec"
+  s.add_development_dependency "rspec-its"
   s.add_development_dependency "rspec-pride"
-  s.add_development_dependency "pry-nav"
+  s.add_development_dependency "pry"
   s.add_development_dependency "protobuf-rspec", ">= 1.0"
   s.add_development_dependency "simplecov"
 end

data/lib/active_remote/base.rb

@@ -15,6 +15,7 @@ require 'active_remote/rpc'
 require 'active_remote/scope_keys'
 require 'active_remote/search'
 require 'active_remote/serialization'
+require 'active_remote/validations'
 
 module ActiveRemote
   class Base
@@ -39,6 +40,10 @@ module ActiveRemote
     # so it needs to be included last.
     include Dirty
 
+    # Overrides persistence methods, so it must included after
+    include Validations
+    include ActiveModel::Validations::Callbacks
+
     attr_reader :last_request, :last_response
 
     define_model_callbacks :initialize, :only => :after

data/lib/active_remote/errors.rb

@@ -9,6 +9,17 @@ module ActiveRemote
   class ReadOnlyRemoteRecord < ActiveRemoteError
   end
 
+  # Raised by ActiveRemote::Validations when save is called on an invalid record.
+  class RemoteRecordInvalid < ActiveRemoteError
+    attr_reader :record
+
+    def initialize(record)
+      @record = record
+      errors = @record.errors.full_messages.join(', ')
+      super(errors)
+    end
+  end
+
   # Raised by ActiveRemove::Base.find when remote record is not found when
   # searching with the given arguments.
   class RemoteRecordNotFound < ActiveRemoteError

data/lib/active_remote/persistence.rb

@@ -176,9 +176,9 @@ module ActiveRemote
     #
     # Also runs any before/after save callbacks that are defined.
     #
-    def save
+    def save(*args)
       run_callbacks :save do
-        create_or_update
+        create_or_update(*args)
       end
     end
 
@@ -192,8 +192,8 @@ module ActiveRemote
     #
     # Also runs any before/after save callbacks that are defined.
     #
-    def save!
-      save || raise(RemoteRecordNotSaved)
+    def save!(*args)
+      save(*args) || raise(RemoteRecordNotSaved)
     end
 
     # Returns true if the record doesn't have errors; otherwise, returns false.
@@ -245,9 +245,9 @@ module ActiveRemote
     # are created, existing records are updated. If the record is marked as
     # readonly, an ActiveRemote::ReadOnlyRemoteRecord is raised.
     #
-    def create_or_update
+    def create_or_update(*args)
       raise ReadOnlyRemoteRecord if readonly?
-      new_record? ? create : update
+      new_record? ? create : update(*args)
     end
 
     # Handles updating a remote object and serializing it's attributes and

data/lib/active_remote/validations.rb

@@ -0,0 +1,64 @@
+module ActiveRemote
+  module Validations
+    extend ActiveSupport::Concern
+
+    # Attempts to save the record like Persistence, but will run
+    # validations and return false if the record is invalid
+    #
+    # Validations can be skipped by passing :validate => false
+    #
+    # example Save a record
+    #   post.save
+    #
+    # example Save a record, skip validations
+    #  post.save(:validate => false)
+    #
+    def save(options = {})
+      perform_validations(options) ? super : false
+    end
+
+    # Attempts to save the record like Persistence, but will raise
+    # ActiveRemote::RemoteRecordInvalid if the record is not valid
+    #
+    # Validations can be skipped by passing :validate => false
+    #
+    # example Save a record, raise and error if invalid
+    #   post.save!
+    #
+    # example Save a record, skip validations
+    #  post.save!(:validate => false)
+    #
+    def save!(options = {})
+      perform_validations(options) ? super : raise_validation_error
+    end
+
+    # Runs all the validations within the specified context. Returns true if
+    # no errors are found, false otherwise.
+    #
+    # Aliased as validate.
+    #
+    # example Is the record valid?
+    #   post.valid?
+    #
+    # example Is the record valid for creation?
+    #   post.valid?(:create)
+    #
+    def valid?(context = nil)
+      context ||= (new_record? ? :create : :update)
+      output = super(context)
+      errors.empty? && output
+    end
+
+    alias_method :validate, :valid?
+
+  protected
+
+    def raise_validation_error
+      fail(::ActiveRemote::RemoteRecordInvalid.new(self))
+    end
+
+    def perform_validations(options = {})
+      options[:validate] == false || valid?(options[:context])
+    end
+  end
+end

data/lib/active_remote/version.rb

@@ -1,3 +1,3 @@
 module ActiveRemote
-  VERSION = "2.1.1"
+  VERSION = "2.2.0"
 end

data/spec/lib/active_remote/association_spec.rb

@@ -11,43 +11,43 @@ describe ActiveRemote::Association do
       let(:default_category_guid) { "CAT-123" }
       subject { Post.new(:author_guid => author_guid, :user_guid => user_guid) }
 
-      it { should respond_to(:author) }
+      it { is_expected.to respond_to(:author) }
 
       it "searches the associated model for a single record" do
-        Author.should_receive(:search).with(:guid => subject.author_guid).and_return(records)
-        subject.author.should eq record
+        expect(Author).to receive(:search).with(:guid => subject.author_guid).and_return(records)
+        expect(subject.author).to eq record
       end
 
       it "memoizes the result record" do
-        Author.should_receive(:search).once.with(:guid => subject.author_guid).and_return(records)
-        3.times { subject.author.should eq record }
+        expect(Author).to receive(:search).once.with(:guid => subject.author_guid).and_return(records)
+        3.times { expect(subject.author).to eq record }
       end
 
       context "when guid is nil" do
         subject { Post.new }
 
         it "returns nil" do
-          subject.author.should be_nil
+          expect(subject.author).to be_nil
         end
       end
 
       context "when the search is empty" do
         it "returns a nil" do
-          Author.should_receive(:search).with(:guid => subject.author_guid).and_return([])
-          subject.author.should be_nil
+          expect(Author).to receive(:search).with(:guid => subject.author_guid).and_return([])
+          expect(subject.author).to be_nil
         end
       end
 
       context 'scoped field' do
-        it { should respond_to(:user) }
+        it { is_expected.to respond_to(:user) }
 
         it "searches the associated model for multiple records" do
-          Author.should_receive(:search).with(:guid => subject.author_guid, :user_guid => subject.user_guid).and_return(records)
-          subject.user.should eq(record)
+          expect(Author).to receive(:search).with(:guid => subject.author_guid, :user_guid => subject.user_guid).and_return(records)
+          expect(subject.user).to eq(record)
         end
 
         context 'when user_guid doesnt exist on model 'do
-          before { subject.stub(:respond_to?).with("user_guid").and_return(false) }
+          before { allow(subject).to receive(:respond_to?).with("user_guid").and_return(false) }
 
           it 'raises an error' do
             expect {subject.user}.to raise_error
@@ -69,11 +69,11 @@ describe ActiveRemote::Association do
       let(:author_guid) { "AUT-456" }
 
       subject { Post.new(:author_guid => author_guid) }
-      it { should respond_to(:coauthor) }
+      it { is_expected.to respond_to(:coauthor) }
 
       it "searches the associated model for a single record" do
-        Author.should_receive(:search).with(:guid => subject.author_guid).and_return(records)
-        subject.coauthor.should eq record
+        expect(Author).to receive(:search).with(:guid => subject.author_guid).and_return(records)
+        expect(subject.coauthor).to eq record
       end
     end
 
@@ -81,11 +81,11 @@ describe ActiveRemote::Association do
       let(:author_guid) { "AUT-456" }
 
       subject { Post.new(:bestseller_guid => author_guid) }
-      it { should respond_to(:bestseller) }
+      it { is_expected.to respond_to(:bestseller) }
 
       it "searches the associated model for a single record" do
-        Author.should_receive(:search).with(:guid => subject.bestseller_guid).and_return(records)
-        subject.bestseller.should eq record
+        expect(Author).to receive(:search).with(:guid => subject.bestseller_guid).and_return(records)
+        expect(subject.bestseller).to eq record
       end
     end
   end
@@ -97,61 +97,61 @@ describe ActiveRemote::Association do
 
     subject { Author.new(:guid => guid, :user_guid => user_guid) }
 
-    it { should respond_to(:posts) }
+    it { is_expected.to respond_to(:posts) }
 
     it "searches the associated model for all associated records" do
-      Post.should_receive(:search).with(:author_guid => subject.guid).and_return(records)
-      subject.posts.should eq records
+      expect(Post).to receive(:search).with(:author_guid => subject.guid).and_return(records)
+      expect(subject.posts).to eq records
     end
 
     it "memoizes the result record" do
-      Post.should_receive(:search).once.with(:author_guid => subject.guid).and_return(records)
-      3.times { subject.posts.should eq records }
+      expect(Post).to receive(:search).once.with(:author_guid => subject.guid).and_return(records)
+      3.times { expect(subject.posts).to eq records }
     end
 
     context "when guid is nil" do
       subject { Author.new }
 
       it "returns []" do
-        subject.posts.should eq []
+        expect(subject.posts).to eq []
       end
     end
 
     context "when the search is empty" do
       it "returns the empty set" do
-        Post.should_receive(:search).with(:author_guid => subject.guid).and_return([])
-        subject.posts.should be_empty
+        expect(Post).to receive(:search).with(:author_guid => subject.guid).and_return([])
+        expect(subject.posts).to be_empty
       end
     end
 
     context "specific association with class name" do
-      it { should respond_to(:flagged_posts) }
+      it { is_expected.to respond_to(:flagged_posts) }
 
       it "searches the associated model for a single record" do
-        Post.should_receive(:search).with(:author_guid => subject.guid).and_return([])
-        subject.flagged_posts.should be_empty
+        expect(Post).to receive(:search).with(:author_guid => subject.guid).and_return([])
+        expect(subject.flagged_posts).to be_empty
       end
     end
 
     context "specific association with class name and foreign_key" do
-      it { should respond_to(:bestseller_posts) }
+      it { is_expected.to respond_to(:bestseller_posts) }
 
       it "searches the associated model for multiple record" do
-        Post.should_receive(:search).with(:bestseller_guid => subject.guid).and_return(records)
-        subject.bestseller_posts.should eq(records)
+        expect(Post).to receive(:search).with(:bestseller_guid => subject.guid).and_return(records)
+        expect(subject.bestseller_posts).to eq(records)
       end
     end
 
     context 'scoped field' do
-      it { should respond_to(:user_posts) }
+      it { is_expected.to respond_to(:user_posts) }
 
       it "searches the associated model for multiple records" do
-        Post.should_receive(:search).with(:author_guid => subject.guid, :user_guid => subject.user_guid).and_return(records)
-        subject.user_posts.should eq(records)
+        expect(Post).to receive(:search).with(:author_guid => subject.guid, :user_guid => subject.user_guid).and_return(records)
+        expect(subject.user_posts).to eq(records)
       end
 
       context 'when user_guid doesnt exist on model 'do
-        before { subject.stub(:respond_to?).with("user_guid").and_return(false) }
+        before { allow(subject).to receive(:respond_to?).with("user_guid").and_return(false) }
 
         it 'raises an error' do
           expect {subject.user_posts}.to raise_error
@@ -180,61 +180,61 @@ describe ActiveRemote::Association do
 
     subject { Category.new(category_attributes) }
 
-    it { should respond_to(:author) }
+    it { is_expected.to respond_to(:author) }
 
     it "searches the associated model for all associated records" do
-      Author.should_receive(:search).with(:category_guid => subject.guid).and_return(records)
-      subject.author.should eq record
+      expect(Author).to receive(:search).with(:category_guid => subject.guid).and_return(records)
+      expect(subject.author).to eq record
     end
 
     it "memoizes the result record" do
-      Author.should_receive(:search).once.with(:category_guid => subject.guid).and_return(records)
-      3.times { subject.author.should eq record }
+      expect(Author).to receive(:search).once.with(:category_guid => subject.guid).and_return(records)
+      3.times { expect(subject.author).to eq record }
     end
 
     context "when guid is nil" do
       subject { Category.new }
 
       it "returns nil" do
-        subject.author.should be_nil
+        expect(subject.author).to be_nil
       end
     end
 
     context "when the search is empty" do
       it "returns a nil value" do
-        Author.should_receive(:search).with(:category_guid => subject.guid).and_return([])
-        subject.author.should be_nil
+        expect(Author).to receive(:search).with(:category_guid => subject.guid).and_return([])
+        expect(subject.author).to be_nil
       end
     end
 
     context "specific association with class name" do
-      it { should respond_to(:senior_author) }
+      it { is_expected.to respond_to(:senior_author) }
 
       it "searches the associated model for a single record" do
-        Author.should_receive(:search).with(:category_guid => subject.guid).and_return(records)
-        subject.senior_author.should eq record
+        expect(Author).to receive(:search).with(:category_guid => subject.guid).and_return(records)
+        expect(subject.senior_author).to eq record
       end
     end
 
     context "specific association with class name and foreign_key" do
-      it { should respond_to(:primary_editor) }
+      it { is_expected.to respond_to(:primary_editor) }
 
       it "searches the associated model for a single record" do
-        Author.should_receive(:search).with(:editor_guid => subject.guid).and_return(records)
-        subject.primary_editor.should eq record
+        expect(Author).to receive(:search).with(:editor_guid => subject.guid).and_return(records)
+        expect(subject.primary_editor).to eq record
       end
     end
 
     context 'scoped field' do
-      it { should respond_to(:chief_editor) }
+      it { is_expected.to respond_to(:chief_editor) }
 
       it "searches the associated model for multiple records" do
-        Author.should_receive(:search).with(:chief_editor_guid => subject.guid, :user_guid => subject.user_guid).and_return(records)
-        subject.chief_editor.should eq(record)
+        expect(Author).to receive(:search).with(:chief_editor_guid => subject.guid, :user_guid => subject.user_guid).and_return(records)
+        expect(subject.chief_editor).to eq(record)
       end
 
       context 'when user_guid doesnt exist on model 'do
-        before { subject.stub(:respond_to?).with("user_guid").and_return(false) }
+        before { allow(subject).to receive(:respond_to?).with("user_guid").and_return(false) }
 
         it 'raises an error' do
           expect {subject.chief_editor}.to raise_error

data/spec/lib/active_remote/base_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe ActiveRemote::Base do
   describe "#initialize" do
     it "runs callbacks" do
-      described_class.any_instance.should_receive(:run_callbacks).with(:initialize)
+      expect_any_instance_of(described_class).to receive(:run_callbacks).with(:initialize)
       described_class.new
     end
   end

data/spec/lib/active_remote/dirty_spec.rb

@@ -12,13 +12,13 @@ describe ActiveRemote::Dirty do
     context "when the value changes" do
       before { subject.name = 'bar' }
 
-      its(:name_changed?) { should be_true }
+      its(:name_changed?) { should be_truthy }
     end
 
     context "when the value doesn't change" do
       before { subject.name = 'foo' }
 
-      its(:name_changed?) { should be_false }
+      its(:name_changed?) { should be_falsey }
     end
   end
 
@@ -33,13 +33,13 @@ describe ActiveRemote::Dirty do
     context "when the value changes" do
       before { subject[:name] = 'bar' }
 
-      its(:name_changed?) { should be_true }
+      its(:name_changed?) { should be_truthy }
     end
 
     context "when the value doesn't change" do
       before { subject[:name] = 'foo' }
 
-      its(:name_changed?) { should be_false }
+      its(:name_changed?) { should be_falsey }
     end
   end
 
@@ -47,7 +47,7 @@ describe ActiveRemote::Dirty do
     subject { Post.new(:name => 'foo') }
 
     before {
-      Post.stub(:find).and_return({})
+      allow(Post).to receive(:find).and_return({})
       subject.reload
     }
 
@@ -60,7 +60,7 @@ describe ActiveRemote::Dirty do
     subject { Post.new(:name => 'foo') }
 
     before {
-      subject.stub(:create_or_update).and_return(true)
+      allow(subject).to receive(:create_or_update).and_return(true)
       subject.save
     }
 
@@ -74,7 +74,7 @@ describe ActiveRemote::Dirty do
     subject { Post.new(:name => 'foo') }
 
     before {
-      subject.stub(:save).and_return(true)
+      allow(subject).to receive(:save).and_return(true)
       subject.save!
     }
 
@@ -88,12 +88,12 @@ describe ActiveRemote::Dirty do
 
     it "clears previous changes" do
       new_record = post.instantiate(record.to_hash)
-      new_record.previous_changes.should be_nil
+      expect(new_record.previous_changes).to eq({})
     end
 
     it "clears changes" do
       new_record = post.instantiate(record.to_hash)
-      new_record.changes.should be_empty
+      expect(new_record.changes).to be_empty
     end
   end
 end