active_remote 2.4.0 → 3.0.0.pre1

data/lib/active_remote/query_attributes.rb

@@ -0,0 +1,45 @@
+require "active_support/concern"
+require "active_support/core_ext/object/blank"
+
+module ActiveRemote
+  # QueryAttributes provides instance methods for querying attributes.
+  #
+  # @example Usage
+  #   class Person < ::ActiveRemote::Base
+  #     attribute :name
+  #   end
+  #
+  #   person = Person.new
+  #   person.name? #=> false
+  #   person.name = "Chris Griego"
+  #   person.name? #=> true
+  #
+  module QueryAttributes
+    extend ::ActiveSupport::Concern
+
+    included do
+      attribute_method_suffix "?"
+    end
+
+    # Test the presence of an attribute
+    #
+    # See {Typecasting::BooleanTypecaster.call} for more details.
+    #
+    # @example Query an attribute
+    #   person.query_attribute(:name)
+    #
+    def query_attribute(name)
+      if respond_to?("#{name}?")
+        send("#{name}?")
+      else
+        raise ::ActiveRemote::UnknownAttributeError, "unknown attribute: #{name}"
+      end
+    end
+
+  private
+
+    def attribute?(name)
+      ::ActiveRemote::Typecasting::BooleanTypecaster.call(read_attribute(name))
+    end
+  end
+end

data/lib/active_remote/rpc.rb

@@ -3,80 +3,30 @@ require 'active_remote/serializers/protobuf'
 
 module ActiveRemote
   module RPC
-    extend ActiveSupport::Concern
+    extend ::ActiveSupport::Concern
 
     included do
-      include Embedded
+      include ::ActiveRemote::Serializers::Protobuf
     end
 
-    module Embedded
-      extend ActiveSupport::Concern
-
-      included do
-        include Serializers::Protobuf
-      end
-
-      module ClassMethods
-        # :noapi:
-        def request(rpc_method, request_args)
-          warn "DEPRECATED Model.request is deprecated and will be removed in Active Remote 3.0. This is handled by the Protobuf RPC adpater now"
-
-          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
-
-        # :noapi:
-        def request_type(rpc_method)
-          warn "DEPRECATED Model.request_type is deprecated and will be removed in Active Remote 3.0. This is handled by the Protobuf RPC adpater now"
-
-          service_class.rpcs[rpc_method].request_type
-        end
-      end
-
-      # :noapi:
-      def execute(rpc_method, request_args)
-        warn "DEPRECATED Model#execute is deprecated and will be removed in Active Remote 3.0. Use Model#rpc.execute instead"
-
-        @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
+    module ClassMethods
+      # Builds an attribute hash that be assigned directly
+      # to an object from an rpc response
+      def build_from_rpc(new_attributes)
+        new_attributes = new_attributes.stringify_keys
+        constructed_attributes = {}
+        attributes.each do |name, definition|
+          if new_attributes[name].nil?
+            constructed_attributes[name] = nil
+          elsif definition[:typecaster]
+            constructed_attributes[name] = definition[:typecaster].call(new_attributes[name])
+          else
+            constructed_attributes[name] = new_attributes[name]
           end
         end
-
-        @last_response
-      end
-
-      # :noapi:
-      def remote_call(rpc_method, request_args)
-        warn "DEPRECATED Model#remote_call is deprecated and will be removed in Active Remote 3.0. Use Model#rpc.execute instead"
-
-        rpc.execute(rpc_method, request_args)
+        constructed_attributes
       end
 
-      private
-
-      # :noapi:
-      def request(rpc_method, attributes)
-        warn "DEPRECATED Model#request is deprecated and will be removed in Active Remote 3.0. This is handled by the Protobuf RPC adpater now"
-
-        self.class.request(rpc_method, attributes)
-      end
-    end
-
-    module ClassMethods
-
       # Execute an RPC call to the remote service and return the raw response.
       #
       def remote_call(rpc_method, request_args)
@@ -104,7 +54,7 @@ module ActiveRemote
         #
         # path_to_adapter.classify.constantize
 
-        RPCAdapters::ProtobufAdapter
+        ::ActiveRemote::RPCAdapters::ProtobufAdapter
       end
     end
 

data/lib/active_remote/search.rb

@@ -8,19 +8,9 @@ module ActiveRemote
     included do
       include Persistence
       include RPC
-
-      define_model_callbacks :search
     end
 
     module ClassMethods
-
-      # :noapi:
-      def _active_remote_search_args(args)
-        warn "DEPRECATED Model._active_remote_search_args is depracted and will be remoted in Active Remote 3.0."
-
-        validate_search_args!(args)
-      end
-
       # Tries to load the first record; if it fails, an exception is raised.
       #
       # ====Examples
@@ -102,7 +92,6 @@ module ActiveRemote
 
         if response.respond_to?(:records)
           records = serialize_records(response.records)
-          records.each { |record| record.run_callbacks :search }
         end
       end
 
@@ -122,15 +111,6 @@ module ActiveRemote
       end
     end
 
-    # :noapi:
-    def _active_remote_search(args)
-      warn "DEPRECATED Model#_active_remote_search is depracted and will be remoted in Active Remote 3.0."
-
-      run_callbacks :search do
-        rpc.execute(:search, args)
-      end
-    end
-
     # Reload this record from the remote service.
     #
     def reload

data/lib/active_remote/serialization.rb

@@ -1,11 +1,9 @@
-require 'active_remote/serializers/json'
-
 module ActiveRemote
   module Serialization
     extend ActiveSupport::Concern
 
     included do
-      include Serializers::JSON
+      include ::ActiveModel::Serializers::JSON
     end
 
     module ClassMethods
@@ -45,34 +43,5 @@ module ActiveRemote
         end
       end
     end
-
-    # Examine the given response and add any errors to our internal errors
-    # list.
-    #
-    # ====Examples
-    #
-    #   response = remote_call(:action_that_returns_errors, { :stuff => 'foo' })
-    #
-    #   add_errors_from_response(response)
-    #
-    def add_errors_from_response(response = nil)
-      unless response
-        warn 'DEPRECATED calling Model#add_errors_from_response without args is deprecated and will be removed in Active Remote 3.0.'
-        response = last_response
-      end
-
-      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 Model#serialize_records is deprecated and will be removed in Active Remote 3.0. Use Model.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/typecasting.rb

@@ -1,3 +1,5 @@
+require "active_support/core_ext/string/conversions"
+
 require "active_remote/typecasting/big_decimal_typecaster"
 require "active_remote/typecasting/boolean"
 require "active_remote/typecasting/boolean_typecaster"
@@ -28,23 +30,12 @@ module ActiveRemote
     def attribute=(name, value)
       return super if value.nil?
 
-      typecaster = _attribute_typecaster(name)
+      typecaster = self.class.attributes[name][:typecaster]
       return super unless typecaster
 
       super(name, typecaster.call(value))
     end
 
-    def _attribute_typecaster(attribute_name)
-      self.class.attributes[attribute_name][:typecaster] || _typecaster_for(attribute_name)
-    end
-
-    def _typecaster_for(attribute_name)
-      type = self.class.attributes[attribute_name][:type]
-      return nil unless type
-
-      TYPECASTER_MAP[type]
-    end
-
     module ClassMethods
       def inspect
         inspected_attributes = attribute_names.sort.map { |name| "#{name}: #{_attribute_type(name)}" }

data/lib/active_remote/version.rb

@@ -1,3 +1,3 @@
 module ActiveRemote
-  VERSION = "2.4.0"
+  VERSION = "3.0.0.pre1"
 end

data/lib/active_remote.rb

@@ -1,11 +1,9 @@
-require 'active_attr'
 require 'active_model'
 require 'active_support'
 require 'protobuf'
 
 require 'active_remote/base'
 require 'active_remote/config'
-require 'active_remote/core_ext'
 require 'active_remote/errors'
 require 'active_remote/version'
 

data/spec/lib/active_remote/association_spec.rb

@@ -102,6 +102,7 @@ describe ActiveRemote::Association do
     subject { Author.new(:guid => guid, :user_guid => user_guid) }
 
     it { is_expected.to respond_to(:posts) }
+    it { is_expected.to respond_to(:posts=) }
 
     it "searches the associated model for all associated records" do
       expect(Post).to receive(:search).with(:author_guid => subject.guid).and_return(records)
@@ -158,7 +159,7 @@ describe ActiveRemote::Association do
         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(::ActiveAttr::UnknownAttributeError)
+          expect {subject.user_posts}.to raise_error(::ActiveRemote::UnknownAttributeError)
         end
       end
 
@@ -170,6 +171,14 @@ describe ActiveRemote::Association do
         end
       end
     end
+
+    context "writer method" do
+      context "when new value is not an array" do
+        it "should raise error" do
+          expect { subject.posts = Post.new }.to raise_error(::RuntimeError, /New value must be an array/)
+        end
+      end
+    end
   end
 
   describe ".has_one" do
@@ -246,7 +255,7 @@ describe ActiveRemote::Association do
         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(::ActiveAttr::UnknownAttributeError)
+          expect {subject.chief_editor}.to raise_error(::ActiveRemote::UnknownAttributeError)
         end
       end
 

data/spec/lib/active_remote/attributes_spec.rb

@@ -0,0 +1,177 @@
+require "spec_helper"
+
+describe ::ActiveRemote::Attributes do
+  let(:model_class) do
+    ::Class.new do
+      include ::ActiveRemote::Attributes
+
+      attribute :name
+      attribute :address
+
+      def self.name
+        "TestClass"
+      end
+    end
+  end
+  subject { ::Author.new }
+
+  describe ".attribute" do
+    context "a dangerous attribute" do
+      it "raises an error" do
+        expect { model_class.attribute(:timeout) }.to raise_error(::ActiveRemote::DangerousAttributeError)
+      end
+    end
+
+    context "a harmless attribute" do
+      it "creates an attribute with no options" do
+        expect(model_class.attributes.values).to include(::ActiveRemote::AttributeDefinition.new(:name))
+      end
+
+      it "returns the attribute definition" do
+        expect(model_class.attribute(:name)).to eq(::ActiveRemote::AttributeDefinition.new(:name))
+      end
+
+      it "defines an attribute reader that calls #attribute" do
+        expect(subject).to receive(:attribute).with("name")
+        subject.name
+      end
+
+      it "defines an attribute writer that calls #attribute=" do
+        expect(subject).to receive(:attribute=).with("name", "test")
+        subject.name = "test"
+      end
+    end
+  end
+
+  describe ".attribute!" do
+    it "can create an attribute with no options" do
+      model_class.attribute!(:first_name)
+      expect(model_class.attributes.values).to include(::ActiveRemote::AttributeDefinition.new(:first_name))
+    end
+
+    it "returns the attribute definition" do
+      expect(model_class.attribute!(:address)).to eq(::ActiveRemote::AttributeDefinition.new(:address))
+    end
+  end
+
+  describe ".attributes" do
+    it "can access AttributeDefinition with a Symbol" do
+      expect(::Author.attributes[:name]).to eq(::ActiveRemote::AttributeDefinition.new(:name))
+    end
+
+    it "can access AttributeDefinition with a String" do
+      expect(::Author.attributes["name"]).to eq(::ActiveRemote::AttributeDefinition.new(:name))
+    end
+  end
+
+  describe ".inspect" do
+    it "renders the class name" do
+      expect(model_class.inspect).to match(/^TestClass\(.*\)$/)
+    end
+
+    it "renders the attribute names in alphabetical order" do
+      expect(model_class.inspect).to match("(address, name)")
+    end
+  end
+
+  describe "#==" do
+    it "returns true when all attributes are equal" do
+      expect(::Author.new(:guid => "test")).to eq(::Author.new(:guid => "test"))
+    end
+
+    it "returns false when compared to another type" do
+      expect(::Category.new(:guid => "test")).to_not eq(::Author.new(:name => "test"))
+    end
+  end
+
+  describe "#attributes" do
+    context "when no attributes are defined" do
+      it "returns an empty Hash" do
+        expect(::NoAttributes.new.attributes).to eq({})
+      end
+    end
+
+    context "when an attribute is defined" do
+      it "returns the key value pairs" do
+        subject.name = "test"
+        expect(subject.attributes).to include("name" => "test")
+      end
+
+      it "returns a new Hash " do
+        subject.attributes.merge!("foobar" => "foobar")
+        expect(subject.attributes).to_not include("foobar" => "foobar")
+      end
+
+      it "returns all attributes" do
+        expect(subject.attributes.keys).to eq(["guid", "name", "user_guid", "chief_editor_guid", "editor_guid", "category_guid"])
+      end
+    end
+  end
+
+  describe "#inspect" do
+    before { subject.name = "test" }
+
+    it "includes the class name and all attribute values in alphabetical order by attribute name" do
+      expect(subject.inspect).to eq(%{#<Author category_guid: nil, chief_editor_guid: nil, editor_guid: nil, guid: nil, name: "test", user_guid: nil>})
+    end
+
+    it "doesn't format the inspection string for attributes if the model does not have any" do
+      expect(::NoAttributes.new.inspect).to eq(%{#<NoAttributes>})
+    end
+  end
+
+  [:[], :read_attribute].each do |method|
+    describe "##{method}" do
+      context "when an attribute is not set" do
+        it "returns nil" do
+          expect(subject.send(method, :name)).to be_nil
+        end
+      end
+
+      context "when an attribute is set" do
+        before { subject.write_attribute(:name, "test") }
+
+        it "returns the attribute using a Symbol" do
+          expect(subject.send(method, :name)).to eq("test")
+        end
+
+        it "returns the attribute using a String" do
+          expect(subject.send(method, "name")).to eq("test")
+        end
+      end
+
+      it "raises when getting an undefined attribute" do
+        expect { subject.send(method, :foobar) }.to raise_error(::ActiveRemote::UnknownAttributeError)
+      end
+    end
+  end
+
+  [:[]=, :write_attribute].each do |method|
+    describe "##{method}" do
+      it "raises ArgumentError with one argument" do
+        expect { subject.send(method, :name) }.to raise_error(::ArgumentError)
+      end
+
+      it "raises ArgumentError with no arguments" do
+        expect { subject.send(method) }.to raise_error(::ArgumentError)
+      end
+
+      it "sets an attribute using a Symbol and value" do
+        expect { subject.send(method, :name, "test") }.to change { subject.attributes["name"] }.from(nil).to("test")
+      end
+
+      it "sets an attribute using a String and value" do
+        expect { subject.send(method, "name", "test") }.to change { subject.attributes["name"] }.from(nil).to("test")
+      end
+
+      it "is able to set an attribute to nil" do
+        subject.name = "test"
+        expect { subject.send(method, :name, nil) }.to change { subject.attributes["name"] }.from("test").to(nil)
+      end
+
+      it "raises when setting an undefined attribute" do
+        expect { subject.send(method, :foobar, "test") }.to raise_error(::ActiveRemote::UnknownAttributeError)
+      end
+    end
+  end
+end

data/spec/lib/active_remote/persistence_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
-describe ActiveRemote::Persistence do
-  let(:rpc) { Tag.new }
-  let(:response_without_errors) { HashWithIndifferentAccess.new(:errors => []) }
+describe ::ActiveRemote::Persistence do
+  let(:response_without_errors) { ::HashWithIndifferentAccess.new(:errors => []) }
+  let(:rpc) { ::ActiveRemote::RPCAdapters::ProtobufAdapter.new(::Tag.service_class) }
 
-  subject { Tag.new }
+  subject { ::Tag.new }
 
   before {
     allow(rpc).to receive(:execute).and_return(response_without_errors)
     allow(Tag).to receive(:rpc).and_return(rpc)
   }
-  after { allow(Tag).to receive(:rpc).and_call_original }
+  after { allow(::Tag).to receive(:rpc).and_call_original }
 
   describe ".create" do
     it "runs create callbacks" do
@@ -251,9 +251,6 @@ describe ActiveRemote::Persistence do
   end
 
   describe "#save!" do
-    before { allow(subject).to receive(:execute) }
-    after { allow(subject).to receive(:execute).and_call_original }
-
     context "when the record is saved" do
       it "returns true" do
         allow(subject).to receive(:save).and_return(true)
@@ -286,16 +283,13 @@ describe ActiveRemote::Persistence do
   describe "#update_attribute" do
     let(:tag) { Tag.allocate.instantiate({:guid => "123"}) }
 
-    before { allow(Tag.rpc).to receive(:execute).and_return(HashWithIndifferentAccess.new) }
-    after { allow(Tag.rpc).to receive(:execute).and_call_original }
-
     it "runs update callbacks" do
       expect(tag).to receive(:after_update_callback)
       tag.update_attribute(:name, "foo")
     end
 
     it "updates a remote record" do
-      expect(Tag.rpc).to receive(:execute).with(:update, {"name" => "foo", "guid" => "123"})
+      expect(rpc).to receive(:execute).with(:update, {"name" => "foo", "guid" => "123"})
       tag.update_attribute(:name, "foo")
     end
 
@@ -317,16 +311,13 @@ describe ActiveRemote::Persistence do
     let(:attributes) { HashWithIndifferentAccess.new(:name => 'bar') }
     let(:tag) { Tag.allocate.instantiate({:guid => "123"}) }
 
-    before { allow(Tag.rpc).to receive(:execute).and_return(HashWithIndifferentAccess.new) }
-    after { allow(Tag.rpc).to receive(:execute).and_call_original }
-
     it "runs update callbacks" do
       expect(tag).to receive(:after_update_callback)
       tag.update_attributes({})
     end
 
     it "updates a remote record" do
-      expect(Tag.rpc).to receive(:execute).with(:update, tag.scope_key_hash)
+      expect(rpc).to receive(:execute).with(:update, tag.scope_key_hash)
       tag.update_attributes({})
     end