active_remote 2.4.0 → 3.0.0.pre1

data/lib/active_remote/bulk.rb

@@ -1,168 +0,0 @@
-require 'active_remote/persistence'
-
-module ActiveRemote
-  module Bulk
-    extend ActiveSupport::Concern
-
-    included do
-      include Persistence
-    end
-
-    module ClassMethods
-
-      # Create multiple records at the same time. Returns a collection of active
-      # remote objects from the passed records. Records that were not created
-      # are returned with error messages indicating what went wrong.
-      #
-      # ====Examples
-      #
-      #   # A single hash
-      #   Tag.create_all({ :name => 'foo' })
-      #
-      #   # Hashes
-      #   Tag.create_all({ :name => 'foo' }, { :name => 'bar' })
-      #
-      #   # Active remote objects
-      #   Tag.create_all(Tag.new(:name => 'foo'), Tag.new(:name => 'bar'))
-      #
-      #   # Protobuf objects
-      #   Tag.create_all(Generic::Remote::Tag.new(:name => 'foo'), Generic::Remote::Tag.new(:name => 'bar'))
-      #
-      #   # Bulk protobuf object
-      #   Tag.create_all(Generic::Remote::Tags.new(:records => [ Generic::Remote::Tag.new(:name => 'foo') ])
-      #
-      def create_all(*records)
-        response = rpc.execute(:create_all, _parse_records(records))
-
-        if response.respond_to?(:records)
-          serialize_records(response.records)
-        else
-          warn "DEPRECATED responses to bulk methods must respond to :records. In Active Remote 3.0, bulk responses that don't respond to :records will raise an exception"
-        end
-      end
-
-      # Delete multiple records at the same time. Returns a collection of active
-      # remote objects from the passed records. Records that were not deleted
-      # are returned with error messages indicating what went wrong.
-      #
-      # ====Examples
-      #
-      #   # A single hash
-      #   Tag.delete_all({ :guid => 'foo' })
-      #
-      #   # Hashes
-      #   Tag.delete_all({ :guid => 'foo' }, { :guid => 'bar' })
-      #
-      #   # Active remote objects
-      #   Tag.delete_all(Tag.new(:guid => 'foo'), Tag.new(:guid => 'bar'))
-      #
-      #   # Protobuf objects
-      #   Tag.delete_all(Generic::Remote::Tag.new(:guid => 'foo'), Generic::Remote::Tag.new(:guid => 'bar'))
-      #
-      #   # Bulk protobuf object
-      #   Tag.delete_all(Generic::Remote::Tags.new(:records => [ Generic::Remote::Tag.new(:guid => 'foo') ])
-      #
-      def delete_all(*records)
-        response = rpc.execute(:delete_all, _parse_records(records))
-
-        if response.respond_to?(:records)
-          serialize_records(response.records)
-        else
-          warn "DEPRECATED responses to bulk methods must respond to :records. In Active Remote 3.0, bulk responses that don't respond to :records will raise an exception"
-        end
-      end
-
-      # Destroy multiple records at the same time. Returns a collection of active
-      # remote objects from the passed records. Records that were not destroyed
-      # are returned with error messages indicating what went wrong.
-      #
-      # ====Examples
-      #
-      #   # A single hash
-      #   Tag.destroy_all({ :guid => 'foo' })
-      #
-      #   # Hashes
-      #   Tag.destroy_all({ :guid => 'foo' }, { :guid => 'bar' })
-      #
-      #   # Active remote objects
-      #   Tag.destroy_all(Tag.new(:guid => 'foo'), Tag.new(:guid => 'bar'))
-      #
-      #   # Protobuf objects
-      #   Tag.destroy_all(Generic::Remote::Tag.new(:guid => 'foo'), Generic::Remote::Tag.new(:guid => 'bar'))
-      #
-      #   # Bulk protobuf object
-      #   Tag.destroy_all(Generic::Remote::Tags.new(:records => [ Generic::Remote::Tag.new(:guid => 'foo') ])
-      #
-      def destroy_all(*records)
-        response = rpc.execute(:destroy_all, _parse_records(records))
-
-        if response.respond_to?(:records)
-          serialize_records(response.records)
-        else
-          warn "DEPRECATED responses to bulk methods must respond to :records. In Active Remote 3.0, bulk responses that don't respond to :records will raise an exception"
-        end
-      end
-
-      # Parse given records to get them ready to be built into a request.
-      #
-      # It handles any object that responds to +to_hash+, so protobuf messages
-      # and active remote objects will work just like hashes.
-      #
-      # Returns +{ :records => records }+.
-      #
-      def parse_records(*records)
-        warn "DEPRECATED Model.parse_records is deprecated. It will be removed in Active Remove 3.0"
-
-        _parse_records(*records)
-      end
-
-      # Update multiple records at the same time. Returns a collection of active
-      # remote objects from the passed records. Records that were not updated
-      # are returned with error messages indicating what went wrong.
-      #
-      # ====Examples
-      #
-      #   # A single hash
-      #   Tag.update_all({ :guid => 'foo', :name => 'baz' })
-      #
-      #   # Hashes
-      #   Tag.update_all({ :guid => 'foo', :name => 'baz' }, { :guid => 'bar', :name => 'qux' })
-      #
-      #   # Active remote objects
-      #   Tag.update_all(Tag.new(:guid => 'foo', :name => 'baz'), Tag.new(:guid => 'bar', :name => 'qux'))
-      #
-      #   # Protobuf objects
-      #   Tag.update_all(Generic::Remote::Tag.new(:guid => 'foo', :name => 'baz'), Generic::Remote::Tag.new(:guid => 'bar', :name => 'qux'))
-      #
-      #   # Bulk protobuf object
-      #   Tag.update_all(Generic::Remote::Tags.new(:records => [ Generic::Remote::Tag.new(:guid => 'foo', :name => 'baz') ])
-      #
-      def update_all(*records)
-        response = rpc.execute(:update_all, _parse_records(records))
-
-        if response.respond_to?(:records)
-          serialize_records(response.records)
-        else
-          warn "DEPRECATED responses to bulk methods must respond to :records. In Active Remote 3.0, bulk responses that don't respond to :records will raise an exception"
-        end
-      end
-
-      private
-
-      def _parse_records(*records)
-        records.flatten!
-
-        if records.first.respond_to?(:attributes)
-          records.collect!(&:attributes)
-        else
-          records.collect!(&:to_hash)
-        end
-
-        return records.first if records.first && records.first.has_key?(:records)
-
-        # If we made it this far, build a bulk-formatted hash.
-        return { :records => records }
-      end
-    end
-  end
-end

data/lib/active_remote/core_ext/date.rb

@@ -1,7 +0,0 @@
-Date.class_eval do
-  unless instance_methods.include?(:to_i)
-    def to_i
-      to_time.to_i
-    end
-  end
-end

data/lib/active_remote/core_ext/date_time.rb

@@ -1,7 +0,0 @@
-DateTime.class_eval do
-  unless instance_methods.include?(:to_i)
-    def to_i
-      to_time.to_i
-    end
-  end
-end

data/lib/active_remote/core_ext/integer.rb

@@ -1,19 +0,0 @@
-Integer.class_eval do
-  unless instance_methods.include?(:to_date)
-    def to_date
-      to_time.to_date
-    end
-  end
-  
-  unless instance_methods.include?(:to_datetime)
-    def to_datetime
-      to_time.to_datetime
-    end
-  end
-
-  unless instance_methods.include?(:to_time)
-    def to_time
-      Time.at(self)
-    end
-  end
-end

data/lib/active_remote/core_ext.rb

@@ -1,3 +0,0 @@
-require 'active_remote/core_ext/date_time'
-require 'active_remote/core_ext/date'
-require 'active_remote/core_ext/integer'

data/lib/active_remote/publication.rb

@@ -1,54 +0,0 @@
-module ActiveRemote
-  module Publication
-    # Returns a hash of publishable attributes.
-    #
-    def publishable_hash
-      keys = _publishable_attributes_or_attribute_keys
-
-      attributes_hash = keys.inject({}) do |publishable_hash, key|
-        value = respond_to?(key) ? __send__(key) : read_attribute(key)
-
-        publishable_hash[key] = case
-                                when value.respond_to?(:map) then
-                                  _map_value(value)
-                                when value.respond_to?(:publishable_hash) then
-                                  value.publishable_hash
-                                when value.respond_to?(:to_hash) then
-                                  value.to_hash
-                                else
-                                  value
-                                end
-
-        publishable_hash
-      end
-
-      attributes_hash
-    end
-
-    def _publishable_json_attributes
-      _publishable_attributes_or_attribute_keys - _publishable_json_methods
-    end
-
-    def _publishable_json_methods
-      _publishable_attributes_or_attribute_keys.reject { |attribute| @attributes.key?(attribute) }
-    end
-
-  private
-
-    def _map_value(value)
-      case
-      when value.any? { |obj| obj.respond_to?(:publishable_hash) } then
-        value.map(&:publishable_hash)
-      when value.any? { |obj| obj.respond_to?(:to_hash) } then
-        value.map(&:to_hash)
-      else
-        value
-      end
-    end
-
-    def _publishable_attributes_or_attribute_keys
-      @_publishable_attributes_or_attribute_keys = _publishable_attributes
-      @_publishable_attributes_or_attribute_keys ||= @attributes.keys
-    end
-  end
-end

data/lib/active_remote/serializers/json.rb

@@ -1,16 +0,0 @@
-module ActiveRemote
-  module Serializers
-    module JSON
-      # Returns a json representation of the whitelisted publishable attributes.
-      #
-      def as_json(options = {})
-        options ||= {}
-
-        default_options = { :only => _publishable_json_attributes, :methods => _publishable_json_methods }
-        default_options.merge!(options)
-
-        super(default_options)
-      end
-    end
-  end
-end

data/spec/core_ext/date_time_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe DateTime do
-  describe "#to_i" do
-    it "does not raise errors bj" do
-      expect { subject.to_i }.to_not raise_error
-    end
-  end
-end

data/spec/lib/active_remote/attribute_defaults_spec.rb

@@ -1,26 +0,0 @@
-require "spec_helper"
-
-describe "attribute defailts" do
-  let(:test_class) { ::DefaultAuthor }
-
-  describe "string" do
-    it "defaults to a string" do
-      record = test_class.new
-      expect(record.name).to eq("John Doe")
-    end
-  end
-
-  describe "lambda" do
-    it "calls the lambda" do
-      record = test_class.new
-      expect(record.guid).to eq(100)
-    end
-  end
-
-  describe "array" do
-    it "defaults to an array" do
-      record = test_class.new
-      expect(record.books).to eq([])
-    end
-  end
-end

data/spec/lib/active_remote/bulk_spec.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-
-describe ActiveRemote::Bulk do
-  shared_examples_for "a bulk method" do |bulk_method|
-    let(:records) { [ Hash.new ] }
-    let(:response) { double(:response, :records => []) }
-    let(:rpc) { ::ActiveRemote::RPCAdapters::ProtobufAdapter.new(::Tag.service_class) }
-
-    before { allow(rpc).to receive(:execute).and_return(response) }
-    before { allow(::Tag).to receive(:rpc).and_return(rpc) }
-
-    context "given an empty array" do
-      let(:parsed_records) { { :records => records } }
-      let(:records) { [] }
-
-      it "calls #{bulk_method} with parsed records" do
-        expect(rpc).to receive(:execute).with(bulk_method, parsed_records)
-        Tag.__send__(bulk_method, records)
-      end
-    end
-
-    context "given an array of record hashes" do
-      let(:hash_record){ double(:record, :to_hash => {}) }
-      let(:parsed_records) { { :records => records.map(&:to_hash) } }
-      let(:records) { [ hash_record ] }
-
-      it "calls #{bulk_method} with parsed records" do
-        expect(rpc).to receive(:execute).with(bulk_method, parsed_records)
-        Tag.__send__(bulk_method, records)
-      end
-    end
-
-    context "given an array of remote records" do
-      let(:parsed_records) { { :records => records.map(&:attributes) } }
-      let(:records) { [ remote_record ] }
-      let(:remote_record) { double(:remote, :attributes => {}) }
-
-      it "calls #{bulk_method} with parsed records" do
-        expect(rpc).to receive(:execute).with(bulk_method, parsed_records)
-        Tag.__send__(bulk_method, records)
-      end
-    end
-
-    context "given a bulk message" do
-      let(:parsed_records) { { :records => records.map(&:to_hash) } }
-      let(:tag) { Generic::Remote::Tag.new }
-      let(:tags) { Generic::Remote::Tags.new(:records => [ tag ]) }
-
-      it "calls #{bulk_method} with parsed records" do
-        expect(rpc).to receive(:execute).with(bulk_method, parsed_records)
-        Tag.__send__(bulk_method, tags)
-      end
-    end
-
-    context "response with errors" do
-      let(:record_with_errors) { double(:record, :errors => [double(:error, :messages => ["whine"], :field => "wat")], :to_hash => {}) }
-      let(:response) { double(:response, :records => [record_with_errors]) }
-      let(:tag) { Generic::Remote::Tag.new }
-      let(:tags) { Generic::Remote::Tags.new(:records => [ tag ]) }
-
-      it "sets the errors on the inflated ActiveRemote objects" do
-        records = Tag.__send__(bulk_method, tags)
-        expect(records.first.errors["wat"]).to eq(["whine"])
-      end
-    end
-  end
-
-  describe ".create_all" do
-    it_behaves_like "a bulk method", :create_all
-  end
-
-  describe ".delete_all" do
-    it_behaves_like "a bulk method", :delete_all
-  end
-
-  describe ".destroy_all" do
-    it_behaves_like "a bulk method", :destroy_all
-  end
-
-  describe ".update_all" do
-    it_behaves_like "a bulk method", :update_all
-  end
-end

data/spec/lib/active_remote/publication_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe ActiveRemote::Publication do
-  let(:attributes) { { :guid => 'foo', :name => 'bar' } }
-
-  subject { Tag.new(attributes) }
-
-  context "with publishable attributes defined" do
-    let(:expected_hash) { attributes.slice(:name) }
-
-    before { Tag.attr_publishable :name }
-    after { reset_publishable_attributes(Tag) }
-
-    it "serializes to a hash with only the publishable attributes" do
-      expect(subject.publishable_hash).to eq expected_hash
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-describe ActiveRemote::Serializers::JSON do
-  describe "#as_json" do
-    let(:attributes) { { :guid => 'foo', :name => 'bar', :updated_at => nil, :user_guid => 'baz' } }
-    let(:serializable_attributes) { { "tag" => attributes.stringify_keys } }
-
-    subject { Tag.new(attributes) }
-
-    context "with roots in json" do
-      context "when options are nil" do
-        it "substitutes an empty hash" do
-          expect(subject.as_json(nil)).to eq serializable_attributes
-        end
-      end
-
-      it "accepts standard JSON options" do
-        expect(subject.as_json(:root => false)).to eq attributes.stringify_keys
-      end
-
-      context "with publishable attributes defined" do
-        let(:expected_json) { { :tag => attributes.slice(:name) }.to_json }
-
-        before { Tag.attr_publishable :name }
-        after { reset_publishable_attributes(Tag) }
-
-        it "serializes to JSON with only the publishable attributes" do
-          expect(subject.to_json).to eq expected_json
-        end
-      end
-
-      context "without publishable attributes defined" do
-        let(:expected_json) { { :tag => attributes }.to_json }
-
-        it "serializes to JSON" do
-          expect(subject.to_json).to eq expected_json
-        end
-      end
-    end
-
-    context "without roots in json" do
-      let(:serializable_attributes) { attributes.stringify_keys }
-
-      before(:each) do
-        ::ActiveRemote.config.include_root_in_json = false
-      end
-
-      after(:each) do
-        ::ActiveRemote.config.include_root_in_json = true
-      end
-
-      context "when options are nil" do
-        it "substitutes an empty hash" do
-          expect(subject.as_json(nil)).to eq serializable_attributes
-        end
-      end
-
-      context "with publishable attributes defined" do
-        let(:expected_json) { attributes.slice(:name).to_json }
-
-        before { Tag.attr_publishable :name }
-        after { reset_publishable_attributes(Tag) }
-
-        it "serializes to JSON with only the publishable attributes" do
-          expect(subject.to_json).to eq expected_json
-        end
-      end
-
-      context "without publishable attributes defined" do
-        let(:expected_json) { attributes.to_json }
-
-        it "serializes to JSON" do
-          expect(subject.to_json).to eq expected_json
-        end
-      end
-    end
-  end
-end