active_remote 2.0.2 → 2.1.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8da0d6b9a19c100a7c36a11ef650e1d788f4b493
-  data.tar.gz: 1da175673f70cbd2eed8686fb27447d19c51b222
+  metadata.gz: 0dd96c99847eae8cf17cec819377a356b0c9fe51
+  data.tar.gz: 97353c96fb186aaa0c509b882bb860389656c2c0
 SHA512:
-  metadata.gz: 864b2fa737f45a1a8988b40aaace637c8ded669f4012f0a49d892fb325cbf42cb1acfbef159d3b09443de7328082b342f950ea37abc7f375d2a83ede46a5b77f
-  data.tar.gz: 7120238fbe22ca117d738b76f95625eb78c91e1cb52070d6d2c7a41933ce4c952deaaa61c0968352ae3f645807f559e8ff1a97f1087a660b5da1db2c8bff2e7c
+  metadata.gz: ad36c87d5dd76cd1663e82f43b92dde4b9780b60033f2cc59ee9d925ad0a87d67b375ed840755e03791a6c7136c47641d94ef5cf611ab6f3e0cfc82725c872c6
+  data.tar.gz: 432cd9f0811511f39d4f82e4ffb074dc0511e244efb2d0575cc3f99f8945f3bc1f8a5e5a45869d72fb13704f6d05bcf0f26c4365010b3d2ca34e427f5ca3d1fb

data/lib/active_remote/base.rb

@@ -9,8 +9,10 @@ require 'active_remote/dirty'
 require 'active_remote/dsl'
 require 'active_remote/integration'
 require 'active_remote/persistence'
+require 'active_remote/primary_key'
 require 'active_remote/publication'
 require 'active_remote/rpc'
+require 'active_remote/scope_keys'
 require 'active_remote/search'
 require 'active_remote/serialization'
 
@@ -26,8 +28,10 @@ module ActiveRemote
     include DSL
     include Integration
     include Persistence
+    include PrimaryKey
     include Publication
     include RPC
+    include ScopeKeys
     include Search
     include Serialization
 

data/lib/active_remote/bulk.rb

@@ -32,9 +32,8 @@ module ActiveRemote
       #   Tag.create_all(Generic::Remote::Tags.new(:records => [ Generic::Remote::Tag.new(:name => 'foo') ])
       #
       def create_all(*records)
-        remote = self.new
-        remote.execute(:create_all, parse_records(records))
-        remote.serialize_records
+        response = rpc.execute(:create_all, parse_records(records))
+        serialize_records(response.records) if response.respond_to?(:records)
       end
 
       # Delete multiple records at the same time. Returns a collection of active
@@ -59,9 +58,8 @@ module ActiveRemote
       #   Tag.delete_all(Generic::Remote::Tags.new(:records => [ Generic::Remote::Tag.new(:guid => 'foo') ])
       #
       def delete_all(*records)
-        remote = self.new
-        remote.execute(:delete_all, parse_records(records))
-        remote.serialize_records
+        response = rpc.execute(:delete_all, parse_records(records))
+        serialize_records(response.records) if response.respond_to?(:records)
       end
 
       # Destroy multiple records at the same time. Returns a collection of active
@@ -86,9 +84,8 @@ module ActiveRemote
       #   Tag.destroy_all(Generic::Remote::Tags.new(:records => [ Generic::Remote::Tag.new(:guid => 'foo') ])
       #
       def destroy_all(*records)
-        remote = self.new
-        remote.execute(:destroy_all, parse_records(records))
-        remote.serialize_records
+        response = rpc.execute(:destroy_all, parse_records(records))
+        serialize_records(response.records) if response.respond_to?(:records)
       end
 
       # Parse given records to get them ready to be built into a request.
@@ -135,9 +132,8 @@ module ActiveRemote
       #   Tag.update_all(Generic::Remote::Tags.new(:records => [ Generic::Remote::Tag.new(:guid => 'foo', :name => 'baz') ])
       #
       def update_all(*records)
-        remote = self.new
-        remote.execute(:update_all, parse_records(records))
-        remote.serialize_records
+        response = rpc.execute(:update_all, parse_records(records))
+        serialize_records(response.records) if response.respond_to?(:records)
       end
     end
   end

data/lib/active_remote/persistence.rb

@@ -76,7 +76,10 @@ module ActiveRemote
     #
     def delete
       raise ReadOnlyRemoteRecord if readonly?
-      execute(:delete, "guid" => read_attribute("guid"))
+      response = rpc.execute(:delete, scope_key_hash)
+
+      # TODO: add errors here so success? actually does something...
+      # add_errors(response)
 
       return success? ? freeze : false
     end
@@ -99,7 +102,10 @@ module ActiveRemote
     #
     def destroy
       raise ReadOnlyRemoteRecord if readonly?
-      execute(:destroy, "guid" => read_attribute("guid"))
+      response = execute(:destroy, scope_key_hash)
+
+      # TODO: add errors here so success? actually does something...
+      # add_errors(response)
 
       return success? ? freeze : false
     end
@@ -128,6 +134,10 @@ module ActiveRemote
         assign_attributes(record)
       end
 
+      # TODO: figure out how to safely run after_find/search callbacks here
+      # currently, several functions use this code path, so an alternate path
+      # may need to be added
+
       run_callbacks :initialize
 
       @new_record = false
@@ -221,12 +231,12 @@ module ActiveRemote
       run_callbacks :create do
         # Use the getter here so we get the type casting.
         new_attributes = attributes
-        new_attributes.delete("guid")
+        new_attributes.delete(primary_key.to_s)
 
-        execute(:create, new_attributes)
+        response = rpc.execute(:create, new_attributes)
 
-        assign_attributes(last_response.to_hash)
-        add_errors_from_response
+        assign_attributes(response.to_hash)
+        add_errors(response)
 
         @new_record = has_errors?
         success?
@@ -251,12 +261,12 @@ module ActiveRemote
         # Use the getter here so we get the type casting.
         updated_attributes = attributes
         updated_attributes.slice!(*attribute_names)
-        updated_attributes.merge!("guid" => self[:guid])
+        updated_attributes.merge!(scope_key_hash)
 
-        execute(:update, updated_attributes)
+        response = rpc.execute(:update, updated_attributes)
 
-        assign_attributes(last_response.to_hash)
-        add_errors_from_response
+        assign_attributes(response.to_hash)
+        add_errors(response)
 
         success?
       end

data/lib/active_remote/primary_key.rb

@@ -0,0 +1,37 @@
+module ActiveRemote
+  module PrimaryKey
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      ##
+      # The default_primary_key is used to define what attribute is used
+      # as a primary key for your global code base. If you use a primary
+      # key other than this, you'll want to set it using the primary_key
+      # method listed below
+      #
+      def default_primary_key
+        :guid
+      end
+
+      ##
+      # In the event that you use a different primary key than the default
+      # primary key listed above (like :uuid, or :id), you'll use this method
+      # to change that primary key. This will be used when making remote
+      # calls to persist or refresh data.
+      #
+      def primary_key(value = nil)
+        @primary_key = value if value
+        @primary_key || default_primary_key
+      end
+    end
+
+    ##
+    # Instance level access to either the default primary key, or whatever
+    # you configured the class level primary key to be.
+    #
+    def primary_key
+      self.class.primary_key
+    end
+  end
+end

data/lib/active_remote/rpc.rb

@@ -1,3 +1,4 @@
+require 'active_remote/rpc_adapters/protobuf_adapter'
 require 'active_remote/serializers/protobuf'
 
 module ActiveRemote
@@ -5,68 +6,118 @@ module ActiveRemote
     extend ActiveSupport::Concern
 
     included do
-      include Serializers::Protobuf
+      include Embedded
     end
 
-    module ClassMethods
+    # TODO: Deprecate this pattern of executing RPC calls
+    #
+    module Embedded
+      extend ActiveSupport::Concern
 
-      # Execute an RPC call to the remote service and return the raw response.
-      #
-      def remote_call(rpc_method, request_args)
-        remote = self.new
-        remote.execute(rpc_method, request_args)
-        remote.last_response
+      included do
+        include Serializers::Protobuf
       end
 
-      # Return a protobuf request object for the given rpc request.
-      #
-      def request(rpc_method, request_args)
-        return request_args unless request_args.is_a?(Hash)
+      module ClassMethods
+        # Return a protobuf request object for the given rpc request.
+        #
+        # TODO: Add deprecation warning
+        #
+        def request(rpc_method, request_args)
+          return request_args unless request_args.is_a?(Hash)
+
+          message_class = request_type(rpc_method)
+          fields = fields_from_attributes(message_class, request_args)
+          message_class.new(fields)
+        end
 
-        message_class = request_type(rpc_method)
-        fields = fields_from_attributes(message_class, request_args)
-        message_class.new(fields)
+        # Return the class applicable to the request for the given rpc method.
+        #
+        # TODO: Add deprecation warning
+        #
+        def request_type(rpc_method)
+          service_class.rpcs[rpc_method].request_type
+        end
       end
 
-      # Return the class applicable to the request for the given rpc method.
+      # Invoke an RPC call to the service for the given rpc method.
       #
-      def request_type(rpc_method)
-        service_class.rpcs[rpc_method].request_type
-      end
-    end
+      # TODO: Add deprecation warning
+      #
+      def execute(rpc_method, request_args)
+        @last_request = request(rpc_method, request_args)
 
-    # Invoke an RPC call to the service for the given rpc method.
-    #
-    def execute(rpc_method, request_args)
-      @last_request = request(rpc_method, request_args)
+        _service_class.client.__send__(rpc_method, @last_request) do |c|
 
-      _service_class.client.__send__(rpc_method, @last_request) do |c|
+          # In the event of service failure, raise the error.
+          c.on_failure do |error|
+            raise ActiveRemoteError, error.message
+          end
 
-        # In the event of service failure, raise the error.
-        c.on_failure do |error|
-          raise ActiveRemoteError, error.message
+          # In the event of service success, assign the response.
+          c.on_success do |response|
+            @last_response = response
+          end
         end
 
-        # In the event of service success, assign the response.
-        c.on_success do |response|
-          @last_response = response
-        end
+        @last_response
       end
-    end
 
-    # Execute an RPC call to the remote service and return the raw response.
-    #
-    def remote_call(rpc_method, request_args)
-      self.execute(rpc_method, request_args)
-      self.last_response
+
+      # Execute an RPC call to the remote service and return the raw response.
+      #
+      # TODO: Add deprecation warning
+      #
+      def remote_call(rpc_method, request_args)
+        rpc.execute(rpc_method, request_args)
+      end
+
+      private
+
+      # Return a protobuf request object for the given rpc call.
+      #
+      # TODO: Add deprecation warning
+      #
+      def request(rpc_method, attributes)
+        self.class.request(rpc_method, attributes)
+      end
     end
 
-  private
+    module ClassMethods
 
-    # Return a protobuf request object for the given rpc call.
-    #
-    def request(rpc_method, attributes)
-      self.class.request(rpc_method, attributes)
+      # Execute an RPC call to the remote service and return the raw response.
+      #
+      def remote_call(rpc_method, request_args)
+        rpc.execute(rpc_method, request_args)
+      end
+
+      def rpc
+        @rpc ||= rpc_adapter.new(service_class)
+      end
+
+      def rpc_adapter
+        # TODO: Make this pluggable
+        #
+        # raise(AdapterNotSpecified, "configuration does not specify adapter") unless adapter.present?
+        #
+        # path_to_adapter = "active_remote/rpc_adapters/#{adapter}_adapter"
+        #
+        # begin
+        #   require path_to_adapter
+        # rescue Gem::LoadError => e
+        #   raise Gem::LoadError, "Specified '#{adapter]}' for RPC adapter, but the gem is not loaded. Add `gem '#{e.name}'` to your Gemfile (and ensure its version is at the minimum required by ActiveRemote)."
+        # rescue LoadError => e
+        #   raise LoadError, "Could not load '#{path_to_adapter}'. Make sure that the adapter is valid. If you use an adapter other than 'protobuf' add the necessary adapter gem to the Gemfile.", e.backtrace
+        # end
+        #
+        # path_to_adapter.classify.constantize
+
+        RPCAdapters::ProtobufAdapter
+      end
+    end
+
+    def rpc
+      self.class.rpc
     end
   end
 end

data/lib/active_remote/rpc_adapters/protobuf_adapter.rb

@@ -0,0 +1,56 @@
+require 'active_remote/serializers/protobuf'
+
+module ActiveRemote
+  module RPCAdapters
+    class ProtobufAdapter
+      include Serializers::Protobuf
+
+      attr_reader :last_request, :last_response, :service_class
+
+      ##
+      # Constructor!
+      #
+      def initialize(service_class)
+        @service_class = service_class
+      end
+
+      # Invoke an RPC call to the service for the given rpc method.
+      #
+      def execute(rpc_method, request_args)
+        @last_request = request(rpc_method, request_args)
+
+        service_class.client.__send__(rpc_method, @last_request) do |c|
+          # In the event of service failure, raise the error.
+          c.on_failure do |error|
+            raise ActiveRemoteError, error.message
+          end
+
+          # In the event of service success, assign the response.
+          c.on_success do |response|
+            @last_response = response
+          end
+        end
+
+        @last_response
+      end
+
+      private
+
+      # Return a protobuf request object for the given rpc request.
+      #
+      def request(rpc_method, request_args)
+        return request_args unless request_args.is_a?(Hash)
+
+        message_class = request_type(rpc_method)
+        fields = fields_from_attributes(message_class, request_args)
+        message_class.new(fields)
+      end
+
+      # Return the class applicable to the request for the given rpc method.
+      #
+      def request_type(rpc_method)
+        service_class.rpcs[rpc_method].request_type
+      end
+    end
+  end
+end

data/lib/active_remote/scope_keys.rb

@@ -0,0 +1,66 @@
+module ActiveRemote
+  module ScopeKeys
+    extend ActiveSupport::Concern
+
+    included do
+      include PrimaryKey
+
+      class_attribute :_scope_keys
+      self._scope_keys = []
+    end
+
+    module ClassMethods
+
+      ##
+      # Allows you to define, at a class level, what keys should be
+      # used as identifiers when making remote calls. For instance,
+      #
+      # class Tag < ActiveRemote::Base
+      #   scope_key :user_guid
+      # end
+      #
+      # When #scope_keys is called on Tag, it will return the primary
+      # key in addition to :user_guid as the scope keys.
+      #
+      def scope_key(*keys)
+        self._scope_keys += keys.map(&:to_s)
+      end
+
+      ##
+      # Used to define what keys are required when making remote
+      # persistence or refresh calls.
+      #
+      def scope_keys
+        [ primary_key.to_s ] + _scope_keys
+      end
+    end
+
+    ##
+    # Instance level access to the scope key of the current class
+    #
+    def scope_keys
+      @scope_keys ||= self.class.scope_keys
+    end
+
+    ##
+    # Instance level hash of scope keys and their corresponding
+    # values. For instance,
+    #
+    # class Tag < ActiveRemote::Base
+    #   scope_key :user_guid
+    # end
+    #
+    # would return this hash:
+    #
+    # {
+    #   :guid      => tag[:guid],
+    #   :user_guid => tag[:user_guid]
+    # }
+    #
+    # This hash is used when accessing or modifying a remote object
+    # like when calling #update in the persistence module, for example.
+    def scope_key_hash
+      attributes.slice(*scope_keys)
+    end
+  end
+end

data/lib/active_remote/search.rb

@@ -91,9 +91,12 @@ module ActiveRemote
       def search(args)
         args = _active_remote_search_args(args)
 
-        remote = self.new
-        remote._active_remote_search(args)
-        remote.serialize_records
+        response = rpc.execute(:search, args)
+
+        if response.respond_to?(:records)
+          records = serialize_records(response.records)
+          records.each { |record| record.run_callbacks :search }
+        end
       end
 
       # :noapi:
@@ -116,16 +119,16 @@ module ActiveRemote
     #
     def _active_remote_search(args)
       run_callbacks :search do
-        execute(:search, args)
+        rpc.execute(:search, args)
       end
     end
 
     # Reload this record from the remote service.
     #
     def reload
-      _active_remote_search(:guid => self.guid)
+      response = self.class.find(scope_key_hash)
 
-      fresh_object = self.class.new(last_response.to_hash)
+      fresh_object = self.class.instantiate(response.to_hash)
       @attributes.update(fresh_object.instance_variable_get('@attributes'))
     end
   end

data/lib/active_remote/serialization.rb

@@ -8,34 +8,60 @@ module ActiveRemote
       include Serializers::JSON
     end
 
+    module ClassMethods
+      # Serialize the given records into Active Remote objects.
+      #
+      # ====Examples
+      #
+      #   records = [ Generic::Remote::TagRequest.new(:name => 'foo') ]
+      #
+      #   Tag.serialize_records(records) # => [ Tag#{:name => 'foo'} ]
+      #
+      def serialize_records(records)
+        records.map { |record| instantiate(record.to_hash) }
+      end
+    end
+
     # Examine the given response and add any errors to our internal errors
-    # list. If no response is given, use the last response.
+    # list.
     #
-    def add_errors_from_response(response=self.last_response)
-      return unless response.respond_to?(:errors)
-
-      response.errors.each do |error|
+    # ====Examples
+    #
+    #   response = remote_call(:action_that_returns_errors, { :stuff => 'foo' })
+    #
+    #   add_errors(response.errors)
+    #
+    def add_errors(errors)
+      errors.each do |error|
         if error.respond_to?(:message)
-          errors.add(error.field, error.message)
+          self.errors.add(error.field, error.message)
         elsif error.respond_to?(:messages)
           error.messages.each do |message|
-            errors.add(error.field, message)
+            self.errors.add(error.field, message)
           end
         end
       end
     end
 
-    # Examine the last response and serialize any records returned into Active
-    # Remote objects.
+    # DEPRECATED – Use :add_errors instead
     #
-    def serialize_records
-      return nil unless last_response.respond_to?(:records)
+    def add_errors_from_response(response = nil)
+      warn 'DEPRECATED :add_errors_from_response is deprecated and will be removed in Active Remote 3.0. Use :add_errors instead'
 
-      last_response.records.map do |remote_record|
-        record = self.class.allocate
-        record.instantiate(remote_record.to_hash)
-        record
-      end
+      response ||= last_response
+
+      add_errors(response.errors) if response.respond_to?(:errors)
+    end
+
+    # DEPRECATED – Use the class-level :serialize_errors instead
+    #
+    def serialize_records(records = nil)
+      warn 'DEPRECATED Calling :serialize_records on an instance is deprecated and will be removed in Active Remote 3.0. Use the class-level :serialize_records instead'
+
+      records ||= last_response.records if last_response.respond_to?(:records)
+      return if records.nil?
+
+      self.class.serialize_records(records)
     end
   end
 end

data/lib/active_remote/serializers/json.rb

@@ -5,7 +5,7 @@ module ActiveRemote
       #
       def as_json(options = {})
         options ||= {}
-        
+
         default_options = { :only => _publishable_json_attributes, :methods => _publishable_json_methods }
         default_options.merge!(options)
 

data/lib/active_remote/version.rb

@@ -1,3 +1,3 @@
 module ActiveRemote
-  VERSION = "2.0.2"
+  VERSION = "2.1.0.beta1"
 end

data/spec/lib/active_remote/bulk_spec.rb

@@ -5,37 +5,28 @@ describe ActiveRemote::Bulk do
   let(:serialized_records) { double(:serialized_records) }
 
   describe ".create_all" do
-    before {
-      Tag.stub(:parse_records).and_return(records)
-      Tag.any_instance.stub(:serialize_records).and_return(serialized_records)
-    }
+    before { Tag.better_stub(:parse_records).and_return(records) }
 
     it "creates remote records" do
-      Tag.any_instance.should_receive(:execute).with(:create_all, records)
+      Tag.rpc.better_receive(:execute).with(:create_all, records)
       Tag.create_all(records)
     end
   end
 
   describe ".delete_all" do
-    before {
-      Tag.stub(:parse_records).and_return(records)
-      Tag.any_instance.stub(:serialize_records).and_return(serialized_records)
-    }
+    before { Tag.better_stub(:parse_records).and_return(records) }
 
     it "deletes remote records" do
-      Tag.any_instance.should_receive(:execute).with(:delete_all, records)
+      Tag.rpc.better_receive(:execute).with(:delete_all, records)
       Tag.delete_all(records)
     end
   end
 
   describe ".destroy_all" do
-    before {
-      Tag.stub(:parse_records).and_return(records)
-      Tag.any_instance.stub(:serialize_records).and_return(serialized_records)
-    }
+    before { Tag.better_stub(:parse_records).and_return(records) }
 
     it "destroys remote records" do
-      Tag.any_instance.should_receive(:execute).with(:destroy_all, records)
+      Tag.rpc.better_receive(:execute).with(:destroy_all, records)
       Tag.destroy_all(records)
     end
   end
@@ -78,13 +69,10 @@ describe ActiveRemote::Bulk do
   end
 
   describe ".update_all" do
-    before {
-      Tag.stub(:parse_records).and_return(records)
-      Tag.any_instance.stub(:serialize_records).and_return(serialized_records)
-    }
+    before { Tag.stub(:parse_records).and_return(records) }
 
     it "updates remote records" do
-      Tag.any_instance.should_receive(:execute).with(:update_all, records)
+      Tag.rpc.better_receive(:execute).with(:update_all, records)
       Tag.update_all(records)
     end
   end

data/spec/lib/active_remote/dirty_spec.rb

@@ -47,8 +47,7 @@ describe ActiveRemote::Dirty do
     subject { Post.new(:name => 'foo') }
 
     before {
-      subject.stub(:last_response).and_return({})
-      subject.stub(:execute)
+      Post.stub(:find).and_return({})
       subject.reload
     }
 
@@ -83,23 +82,18 @@ describe ActiveRemote::Dirty do
     its(:changes) { should be_empty }
   end
 
-  describe "#serialize_records" do
+  describe "#instantiate" do
     let(:post) { Post.new }
     let(:record) { ::Generic::Remote::Post.new(:name => 'foo') }
-    let(:response) { double(:response, :records => [ record ]) }
-
-    before {
-      post.stub(:last_response).and_return(response)
-    }
 
     it "clears previous changes" do
-      records = post.serialize_records
-      records.first.previous_changes.should be_nil
+      new_record = post.instantiate(record.to_hash)
+      new_record.previous_changes.should be_nil
     end
 
     it "clears changes" do
-      records = post.serialize_records
-      records.first.changes.should be_empty
+      new_record = post.instantiate(record.to_hash)
+      new_record.changes.should be_empty
     end
   end
 end

data/spec/lib/active_remote/persistence_spec.rb

@@ -1,20 +1,22 @@
 require 'spec_helper'
 
 describe ActiveRemote::Persistence do
+  let(:rpc) { Tag.new }
+
   subject { Tag.new }
 
-  before { Tag.any_instance.stub(:last_response).and_return(HashWithIndifferentAccess.new) }
+  before {
+    rpc.better_stub(:execute).and_return(HashWithIndifferentAccess.new)
+    Tag.better_stub(:rpc).and_return(rpc)
+  }
+  after { Tag.unstub(:rpc) }
 
   describe ".create" do
-    before { Tag.any_instance.stub(:execute) }
-    after { Tag.any_instance.unstub(:execute) }
-
     it "runs create callbacks" do
       Tag.any_instance.should_receive(:after_create_callback)
       Tag.create(:name => 'foo')
     end
 
-
     it "initializes and saves a new record" do
       Tag.any_instance.should_receive(:save)
       Tag.create(:name => 'foo')
@@ -27,9 +29,6 @@ describe ActiveRemote::Persistence do
   end
 
   describe ".create!" do
-    before { Tag.any_instance.stub(:execute) }
-    after { Tag.any_instance.unstub(:execute) }
-
     it "initializes and saves a new record" do
       Tag.any_instance.should_receive(:save!)
       Tag.create!(:name => 'foo')
@@ -45,11 +44,8 @@ describe ActiveRemote::Persistence do
   end
 
   describe "#delete" do
-    before { subject.stub(:execute) }
-    after { subject.unstub(:execute) }
-
     it "deletes a remote record" do
-      subject.should_receive(:execute).with(:delete, subject.attributes.slice("guid"))
+      rpc.should_receive(:execute).with(:delete, subject.scope_key_hash)
       subject.delete
     end
 
@@ -60,31 +56,35 @@ describe ActiveRemote::Persistence do
       end
     end
 
-    context "when the record has errors" do
-      before { subject.stub(:has_errors?).and_return(true) }
-
-      it "returns false" do
-        subject.delete.should be_false
-      end
-    end
+    # TODO: This spec passes, but the implementation does not actually work.
+    # Uncomment it once the implementation is correct.
+    #
+    # context "when the record has errors" do
+    #   before { subject.stub(:has_errors?).and_return(true) }
+    #
+    #   it "returns false" do
+    #     subject.delete.should be_false
+    #   end
+    # end
   end
 
   describe "#delete!" do
-    before { subject.stub(:execute) }
-    after { subject.unstub(:execute) }
-
     it "deletes a remote record" do
-      subject.should_receive(:execute).with(:delete, subject.attributes.slice("guid"))
+      rpc.should_receive(:execute).with(:delete, subject.scope_key_hash)
       subject.delete!
     end
 
-    context "when an error occurs" do
-      before { subject.stub(:execute).and_raise(ActiveRemote::ActiveRemoteError) }
-
-      it "raises an exception" do
-        expect { subject.delete! }.to raise_error(ActiveRemote::ActiveRemoteError)
-      end
-    end
+    # FIXME: This spec tests that excute raises an execption, not that an
+    # exception is raised when an error is returned (as it should).
+    # Uncomment it once the implementation is correct.
+    #
+    # context "when an error occurs" do
+    #   before { rpc.stub(:execute).and_raise(ActiveRemote::ActiveRemoteError) }
+    #
+    #   it "raises an exception" do
+    #     expect { subject.delete! }.to raise_error(ActiveRemote::ActiveRemoteError)
+    #   end
+    # end
   end
 
   describe "#destroy" do
@@ -92,7 +92,7 @@ describe ActiveRemote::Persistence do
     after { subject.unstub(:execute) }
 
     it "destroys a remote record" do
-      subject.should_receive(:execute).with(:destroy, subject.attributes.slice("guid"))
+      subject.should_receive(:execute).with(:destroy, subject.scope_key_hash)
       subject.destroy
     end
 
@@ -103,31 +103,35 @@ describe ActiveRemote::Persistence do
       end
     end
 
-    context "when the record has errors" do
-      before { subject.stub(:has_errors?).and_return(true) }
-
-      it "returns false" do
-        subject.destroy.should be_false
-      end
-    end
+    # TODO: This spec passes, but the implementation does not actually work.
+    # Uncomment it once the implementation is correct.
+    #
+    # context "when the record has errors" do
+    #   before { subject.stub(:has_errors?).and_return(true) }
+    #
+    #   it "returns false" do
+    #     subject.destroy.should be_false
+    #   end
+    # end
   end
 
   describe "#destroy!" do
-    before { subject.stub(:execute) }
-    after { subject.unstub(:execute) }
-
     it "destroys a remote record" do
       subject.should_receive(:execute).with(:destroy, subject.attributes.slice("guid"))
       subject.destroy!
     end
 
-    context "when an error occurs" do
-      before { subject.stub(:execute).and_raise(ActiveRemote::ActiveRemoteError) }
-
-      it "raises an exception" do
-        expect { subject.destroy! }.to raise_error(ActiveRemote::ActiveRemoteError)
-      end
-    end
+    # FIXME: This spec tests that excute raises an execption, not that an
+    # exception is raised when an error is returned (as it should).
+    # Uncomment it once the implementation is correct.
+    #
+    # context "when an error occurs" do
+    #   before { subject.stub(:execute).and_raise(ActiveRemote::ActiveRemoteError) }
+    #
+    #   it "raises an exception" do
+    #     expect { subject.destroy! }.to raise_error(ActiveRemote::ActiveRemoteError)
+    #   end
+    # end
   end
 
   describe "#readonly?" do
@@ -188,9 +192,6 @@ describe ActiveRemote::Persistence do
   end
 
   describe "#save" do
-    before { subject.stub(:execute) }
-    after { subject.unstub(:execute) }
-
     it "runs save callbacks" do
       subject.should_receive(:run_callbacks).with(:save)
       subject.save
@@ -201,7 +202,7 @@ describe ActiveRemote::Persistence do
 
       it "creates the record" do
         expected_attributes = subject.attributes.reject { |key, value| key == "guid" }
-        subject.should_receive(:execute).with(:create, expected_attributes)
+        rpc.should_receive(:execute).with(:create, expected_attributes)
         subject.save
       end
     end
@@ -212,7 +213,7 @@ describe ActiveRemote::Persistence do
       subject { Tag.allocate.instantiate(attributes) }
 
       it "updates the record" do
-        subject.should_receive(:execute).with(:update, attributes)
+        rpc.should_receive(:execute).with(:update, attributes)
         subject.save
       end
     end
@@ -277,16 +278,21 @@ describe ActiveRemote::Persistence do
 
   describe "#update_attributes" do
     let(:attributes) { HashWithIndifferentAccess.new(:name => 'bar') }
+    let(:tag) { Tag.allocate.instantiate({:guid => "123"}) }
 
-    before { Tag.any_instance.stub(:execute) }
-    after { Tag.any_instance.unstub(:execute) }
+    before { Tag.rpc.stub(:execute).and_return(HashWithIndifferentAccess.new) }
+    after { Tag.rpc.unstub(:execute) }
 
     it "runs update callbacks" do
-      tag = Tag.allocate.instantiate({:guid => "123"})
       tag.should_receive(:after_update_callback)
       tag.update_attributes({})
     end
 
+    it "updates a remote record" do
+      Tag.rpc.should_receive(:execute).with(:update, tag.scope_key_hash)
+      tag.update_attributes({})
+    end
+
     before { subject.stub(:save) }
     after { subject.unstub(:save) }
 

data/spec/lib/active_remote/primary_key_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe ActiveRemote::PrimaryKey do
+  let(:tag) { Tag.new(:id => '1234', :guid => 'TAG-123', :user_guid => 'USR-123') }
+
+  after { Tag.instance_variable_set :@primary_key, nil }
+
+  describe ".default_primary_key" do
+    it 'returns array of :guid' do
+      Tag.default_primary_key.should eq(:guid)
+    end
+  end
+
+  describe "primary_key" do
+    context "when no arguments are passed" do
+      it "returns default primary key" do
+        Tag.primary_key.should eq(:guid)
+      end
+    end
+
+    context "when arguments are passed" do
+      let(:specified_primary_key) { :name }
+
+      it "returns the given primary key" do
+        Tag.primary_key(specified_primary_key).should eq(specified_primary_key)
+      end
+    end
+  end
+
+  describe "#primary_key" do
+    it "returns the primary key for the class" do
+      Tag.new.primary_key.should eq Tag.primary_key
+    end
+  end
+end

data/spec/lib/active_remote/rpc_spec.rb

@@ -7,15 +7,15 @@ describe ActiveRemote::RPC do
     let(:args) { double(:args) }
     let(:response) { double(:response) }
 
-    before { Tag.any_instance.stub(:execute) }
+    before { Tag.rpc.stub(:execute) }
 
     it "calls the given RPC method" do
-      Tag.any_instance.should_receive(:execute).with(:remote_method, args)
+      Tag.rpc.should_receive(:execute).with(:remote_method, args)
       Tag.remote_call(:remote_method, args)
     end
 
     it "returns the response" do
-      Tag.any_instance.stub(:last_response).and_return(response)
+      Tag.rpc.stub(:execute).and_return(response)
       Tag.remote_call(:remote_method, args).should eq response
     end
   end

data/spec/lib/active_remote/scope_keys_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe ActiveRemote::ScopeKeys do
+  let(:key) { :user_guid }
+  let(:_scope_keys) { [ 'user_guid' ] }
+  let(:scope_keys) { [ 'guid' ] + _scope_keys }
+  let(:tag) { Tag.new(tag_hash) }
+  let(:tag_hash) { { :guid => 'TAG-123', :user_guid => 'USR-123', :name => 'teh tag' } }
+
+  describe ".scope_key" do
+    after { Tag._scope_keys = [] }
+
+    it 'adds scope_key to _scope_keys' do
+      Tag.scope_key(key)
+      Tag._scope_keys.should eq(_scope_keys)
+    end
+  end
+
+  describe ".scope_keys" do
+    before { Tag.better_stub(:_scope_keys).and_return(_scope_keys) }
+
+    it "combines primary key with _scope_keys" do
+      Tag.scope_keys.should eq(['guid'] + _scope_keys)
+    end
+  end
+
+  describe "#scope_keys" do
+    it "returns the scope keys for the class" do
+      Tag.new.scope_keys.should eq Tag.scope_keys
+    end
+  end
+
+  describe "#scope_key_hash" do
+    let(:scope_key_hash) { { 'guid' => 'TAG-123', 'user_guid' => 'USR-123' } }
+
+    before { tag.better_stub(:scope_keys).and_return(scope_keys) }
+
+    it "returns a attribute hash of scope_keys" do
+      tag.scope_key_hash.should eq(scope_key_hash)
+    end
+  end
+end

data/spec/lib/active_remote/search_spec.rb

@@ -1,6 +1,10 @@
 require 'spec_helper'
 
 describe ActiveRemote::Search do
+  let(:records) { [ Generic::Remote::Tag.new ] }
+  let(:response) { Generic::Remote::Tags.new(:records => records) }
+  let(:rpc) { double(:rpc) }
+
   describe ".find" do
     let(:args) { Hash.new }
     let(:record) { double(:record) }
@@ -33,23 +37,20 @@ describe ActiveRemote::Search do
   end
 
   describe ".search" do
+    let(:serialized_records) { [ Tag.new ] }
+
     context "given args that respond to :to_hash" do
       let(:args) { Hash.new }
 
-      before {
-        Tag.any_instance.stub(:_active_remote_search)
-      }
+      before { Tag.rpc.stub(:execute).and_return(response) }
 
       it "searches with the given args" do
-        Tag.any_instance.should_receive(:_active_remote_search).with(args)
+        Tag.rpc.should_receive(:execute).with(:search, args)
         Tag.search(args)
       end
 
       it "returns records" do
-        records = double(:records)
-
-        Tag.any_instance.stub(:serialize_records).and_return(records)
-        Tag.search(args).should eq records
+        Tag.search(args).should eq serialized_records
       end
     end
 
@@ -67,30 +68,32 @@ describe ActiveRemote::Search do
 
     subject { Tag.new }
 
+    before {
+      rpc.stub(:execute).and_return(response)
+      Tag.better_stub(:rpc).and_return(rpc)
+    }
+
     it "runs callbacks" do
       subject.should_receive(:run_callbacks).with(:search)
       subject._active_remote_search(args)
     end
 
     it "executes the search" do
-      subject.should_receive(:execute).with(:search, args)
+      rpc.should_receive(:execute).with(:search, args)
       subject._active_remote_search(args)
     end
   end
 
   describe "#reload" do
-    let(:args) { { :guid => 'foo' } }
-    let(:attributes) { HashWithIndifferentAccess.new(:guid => 'foo', :name => 'bar', :updated_at => nil) }
+    let(:args) { attributes.slice('guid', 'user_guid') }
+    let(:attributes) { HashWithIndifferentAccess.new(:guid => 'foo', :name => 'bar', :updated_at => nil, :user_guid => 'baz') }
 
     subject { Tag.new(args) }
 
-    before {
-      subject.stub(:_active_remote_search)
-      subject.stub(:last_response).and_return(attributes)
-    }
+    before { Tag.better_stub(:find).and_return(attributes) }
 
     it "reloads the record" do
-      subject.should_receive(:_active_remote_search).with(args)
+      Tag.better_receive(:find).with(subject.scope_key_hash)
       subject.reload
     end
 

data/spec/lib/active_remote/serialization_spec.rb

@@ -1,64 +1,32 @@
 require 'spec_helper'
 
 describe ActiveRemote::Serialization do
-  describe "#add_errors_from_response" do
-    let(:error) { Generic::Error.new(:field => 'name', :message => 'Boom!') }
-    let(:response) {
-      tag = Generic::Remote::Tag.new
-      tag.errors << error
-      tag
-    }    
+  describe ".serialize_records" do
+    let(:records) { [ { :foo => 'bar' } ] }
 
     subject { Tag.new }
 
-    context "when the response has errors" do
-      it "adds the errors to the active remote object" do
-        subject.add_errors_from_response(response)
-        subject.errors[:name].should =~ ['Boom!']
-      end
-    end
-
-    context "when the response doesn't respond to errors" do
-      let(:response) { Generic::Remote::Tag.new }
-
-      it "doesn't add errors" do
-        subject.add_errors_from_response(response)
-        subject.errors.empty?.should be_true
-      end
-    end
-
-    context "when no response is given" do
-      before { subject.stub(:last_response).and_return(response) }
-
-      it "uses the last response" do
-        subject.add_errors_from_response
-        subject.errors[:name].should =~ ['Boom!']
+    it "serializes records into active remote objects" do
+      Tag.serialize_records(records).each do |record|
+        record.should be_a Tag
       end
     end
   end
 
-  describe "#serialize_records" do
-    let(:last_response) {
-      MessageWithOptions.new(:records => records)
+  describe "#add_errors" do
+    let(:error) { Generic::Error.new(:field => 'name', :message => 'Boom!') }
+    let(:response) {
+      tag = Generic::Remote::Tag.new
+      tag.errors << error
+      tag
     }
-    let(:records) { [ { :foo => 'bar' } ] }
 
     subject { Tag.new }
 
-    context "when the last response has records" do
-
-      before { subject.stub(:last_response).and_return(last_response) }
-
-      it "serializes records into active remote objects" do
-        subject.serialize_records.each do |record|
-          record.should be_a Tag
-        end
-      end
-    end
-
-    context "when the last response doesn't respond to records" do
-      it "returns nil" do
-        subject.serialize_records.should be_nil
+    context "when the response has errors" do
+      it "adds the errors to the active remote object" do
+        subject.add_errors(response.errors)
+        subject.errors[:name].should =~ ['Boom!']
       end
     end
   end

data/spec/lib/active_remote/serializers/json_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe ActiveRemote::Serializers::JSON do
   describe "#as_json" do
-    let(:attributes) { { :guid => 'foo', :name => 'bar', :updated_at => nil } }
+    let(:attributes) { { :guid => 'foo', :name => 'bar', :updated_at => nil, :user_guid => 'baz' } }
     let(:serializable_attributes) { { "tag" => attributes.stringify_keys } }
 
     subject { Tag.new(attributes) }

data/spec/support/models/tag.rb

@@ -9,6 +9,7 @@ class Tag < ::ActiveRemote::Base
   attribute :guid
   attribute :name
   attribute :updated_at
+  attribute :user_guid
 
   after_update :after_update_callback
   after_create :after_create_callback

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_remote
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.0.beta1
 platform: ruby
 authors:
 - Adam Hutchison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-08 00:00:00.000000000 Z
+date: 2014-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_attr
@@ -181,9 +181,12 @@ files:
 - lib/active_remote/errors.rb
 - lib/active_remote/integration.rb
 - lib/active_remote/persistence.rb
+- lib/active_remote/primary_key.rb
 - lib/active_remote/publication.rb
 - lib/active_remote/railtie.rb
 - lib/active_remote/rpc.rb
+- lib/active_remote/rpc_adapters/protobuf_adapter.rb
+- lib/active_remote/scope_keys.rb
 - lib/active_remote/search.rb
 - lib/active_remote/serialization.rb
 - lib/active_remote/serializers/json.rb
@@ -197,8 +200,10 @@ files:
 - spec/lib/active_remote/dsl_spec.rb
 - spec/lib/active_remote/integration_spec.rb
 - spec/lib/active_remote/persistence_spec.rb
+- spec/lib/active_remote/primary_key_spec.rb
 - spec/lib/active_remote/publication_spec.rb
 - spec/lib/active_remote/rpc_spec.rb
+- spec/lib/active_remote/scope_keys_spec.rb
 - spec/lib/active_remote/search_spec.rb
 - spec/lib/active_remote/serialization_spec.rb
 - spec/lib/active_remote/serializers/json_spec.rb
@@ -238,9 +243,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.1
@@ -256,8 +261,10 @@ test_files:
 - spec/lib/active_remote/dsl_spec.rb
 - spec/lib/active_remote/integration_spec.rb
 - spec/lib/active_remote/persistence_spec.rb
+- spec/lib/active_remote/primary_key_spec.rb
 - spec/lib/active_remote/publication_spec.rb
 - spec/lib/active_remote/rpc_spec.rb
+- spec/lib/active_remote/scope_keys_spec.rb
 - spec/lib/active_remote/search_spec.rb
 - spec/lib/active_remote/serialization_spec.rb
 - spec/lib/active_remote/serializers/json_spec.rb