active_remote 2.4.0 → 3.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7f95e9d97b5f04b0f9cfb65f1fa67b1c28610494
-  data.tar.gz: 20ab489954edb8912d271122b5c153a84029328e
+  metadata.gz: a6501c9a34d84239729afd215a01cea574af7a5c
+  data.tar.gz: 55a6b558a7fa1fba40a415266743f7e01fc31fc9
 SHA512:
-  metadata.gz: 0766023e587197504ce97037fbcb771354ed3b99144707765bb5d924ebc35e96701f008a90278938b91457da216e1da49e13f7d71b76ae51af818e56820d10de
-  data.tar.gz: 929d191533ec354c95449201ef31f9f5043c603d18e6316c83b09196ef3203f8552597afd8aef354793fdfd25871ddecb63718e475b4da810379e3e3166a09d4
+  metadata.gz: 57f951cd6dc0f19d37942880c2da4066d9cd7773c1ee16def3c0068cfb337d68aa4f596b80fe679ef1e8f83bf5685a5f5396b8a9204293ca273f0db24428ef78
+  data.tar.gz: f861f24788ce54b8dfaa0693ee236cc5aad887945bba35670687b9a8fb57f56f4eb06ec9e090ce052eef1c8f4242d6c026910d92f607dd79c5f1b07d700e11dc

data/.travis.yml

@@ -0,0 +1,5 @@
+---
+language: ruby
+rvm:
+  - 2.2
+  - jruby

data/CHANGES.md

@@ -0,0 +1,22 @@
+# ActiveRemote Changes
+
+3.0.0
+----------
+
+- Remove dependency on ActiveAttr [#48]
+- Remove core exts [#49]
+- Remove deprecated rpc methods `.request`, `.request_type`, #execute`, `#remote_call`
+  These methods are handled by the rpc adater now. [#49]
+- Remove deprecated method `._active_remote_search_args` [#49]
+- Remove deprecated `.parse_records` method [#49]
+- Remove publication, `#publishable_hash` method [#49]
+- Drop support for Rails 3 mass assignment protection.  Add support for strong param
+  enforcement for Rails 4+. [#50]
+- Improve performance of many methods including `respond_to?` and `new`. [#50]
+- Refactor of attribute storage internals [#50]
+- Remove a method was was doign dirty tracking twice [#52]
+- Extracted bulk methods to active_remote-bulk [#54]
+- Removed search callbacks [#55]
+- Refactor of instantiate from rpc codepath [#56]
+- Change to internals of typecasting.  Declaring `attribute :name, :type => Integer`
+  will no longer affect performance negatively. [#56]

data/README.md

@@ -1,3 +1,5 @@
+[![Build Status](https://travis-ci.org/liveh2o/active_remote.svg?branch=master)](https://travis-ci.org/liveh2o/active_remote)
+
 # Active Remote
 
 Active Remote provides [Active Record](https://github.com/rails/rails/tree/master/activerecord)-like object-relational mapping over RPC. Think of it as Active Record for your platform: within a service, use Active Record to persist objects and between services, use Active Remote.

data/active_remote.gemspec

@@ -19,8 +19,8 @@ Gem::Specification.new do |s|
   ##
   # Dependencies
   #
-  s.add_dependency "active_attr", ">= 0.8"
-  s.add_dependency "activesupport", ">= 3.2"
+  s.add_dependency "activemodel", ">= 4.0"
+  s.add_dependency "activesupport", ">= 4.0"
   s.add_dependency "protobuf", ">= 3.0"
 
   ##

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "active_remote"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "pry"
+Pry.start

data/lib/active_remote/association.rb

@@ -83,6 +83,9 @@ module ActiveRemote
 
           search_hash.values.any?(&:nil?) ? [] : klass.search(search_hash)
         end
+
+        options.merge!(:has_many => true)
+        create_setter_method(has_many_class, options)
       end
 
       # Create a `has_one` association for a given remote resource.
@@ -135,6 +138,7 @@ module ActiveRemote
       def create_setter_method(associated_klass, options={})
         writer_method = "#{associated_klass}=".to_sym
         define_method(writer_method) do |new_value|
+          raise "New value must be an array" if options[:has_many] == true && new_value.class != Array
           klass_name = options.fetch(:class_name){ associated_klass }
           klass = klass_name.to_s.classify.constantize
 

data/lib/active_remote/attribute_assignment.rb

@@ -0,0 +1,53 @@
+require "active_support/core_ext/hash/keys"
+
+# Added ActiveModel AttributeAssignment to support Rails 4.
+# In Rails 5 this is built in to ActiveModel, but our behavior
+# in ActiveRemote is different.
+module ActiveRemote
+  module AttributeAssignment
+    include ::ActiveModel::ForbiddenAttributesProtection
+
+    # Allows you to set all the attributes by passing in a hash of attributes with
+    # keys matching the attribute names.
+    #
+    # If the passed hash responds to <tt>permitted?</tt> method and the return value
+    # of this method is +false+ an <tt>ActiveModel::ForbiddenAttributesError</tt>
+    # exception is raised.
+    #
+    #   class Cat
+    #     include ActiveModel::AttributeAssignment
+    #     attr_accessor :name, :status
+    #   end
+    #
+    #   cat = Cat.new
+    #   cat.assign_attributes(name: "Gorby", status: "yawning")
+    #   cat.name # => 'Gorby'
+    #   cat.status => 'yawning'
+    #   cat.assign_attributes(status: "sleeping")
+    #   cat.name # => 'Gorby'
+    #   cat.status => 'sleeping'
+    def assign_attributes(new_attributes)
+      if !new_attributes.respond_to?(:stringify_keys)
+        raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
+      end
+      return if new_attributes.nil? || new_attributes.empty?
+
+      attributes = new_attributes.stringify_keys
+      _assign_attributes(sanitize_for_mass_assignment(attributes))
+    end
+
+    private
+
+    def _assign_attributes(attributes)
+      attributes.each do |name, value|
+        _assign_attribute(name, value)
+      end
+    end
+
+    # ActiveRemote silently ignores unknown attributes, unlike ActiveModel
+    # Consider changing ActiveRemote to behave the same
+    def _assign_attribute(name, value)
+      public_send("#{name}=", value) if respond_to?("#{name}=")
+    end
+  end
+end

data/lib/active_remote/attribute_definition.rb

@@ -0,0 +1,106 @@
+module ActiveRemote
+  # Represents an attribute for reflection
+  #
+  # @example Usage
+  #   AttributeDefinition.new(:amount)
+  #
+  # @since 0.2.0
+  class AttributeDefinition
+    include Comparable
+
+    # The attribute name
+    # @since 0.2.0
+    attr_reader :name
+
+    # Compare attribute definitions
+    #
+    # @example
+    #   attribute_definition <=> other
+    #
+    # @param [ActiveAttr::AttributeDefinition, Object] other The other
+    #   attribute definition to compare with.
+    #
+    # @return [-1, 0, 1, nil]
+    #
+    # @since 0.2.1
+    def <=>(other)
+      return nil unless other.instance_of? self.class
+      return nil if name == other.name && options != other.options
+      self.name.to_s <=> other.name.to_s
+    end
+
+    # Read an attribute option
+    #
+    # @example
+    #   attribute_definition[:type]
+    #
+    # @param [Symbol] key The option key
+    #
+    # @since 0.5.0
+    def [](key)
+      @options[key]
+    end
+
+    # Creates a new AttributeDefinition
+    #
+    # @example Create an attribute defintion
+    #   AttributeDefinition.new(:amount)
+    #
+    # @param [Symbol, String, #to_sym] name attribute name
+    # @param [Hash{Symbol => Object}] options attribute options
+    #
+    # @return [ActiveAttr::AttributeDefinition]
+    #
+    # @since 0.2.0
+    def initialize(name, options={})
+      raise TypeError, "can't convert #{name.class} into Symbol" unless name.respond_to? :to_sym
+      @name = name.to_sym
+      @options = options
+
+      if @options[:type]
+        typecaster = ::ActiveRemote::Typecasting::TYPECASTER_MAP[@options[:type]]
+        fail ::ActiveRemote::UnknownType unless typecaster
+        @options[:typecaster] = typecaster
+      end
+    end
+
+    # Returns the code that would generate the attribute definition
+    #
+    # @example Inspect the attribute definition
+    #   attribute.inspect
+    #
+    # @return [String] Human-readable presentation of the attribute
+    #   definition
+    #
+    # @since 0.6.0
+    def inspect
+      options_description = options.map { |key, value| "#{key.inspect} => #{value.inspect}" }.sort.join(", ")
+      inspected_options = ", #{options_description}" unless options_description.empty?
+      "attribute :#{name}#{inspected_options}"
+    end
+
+    # The attribute name
+    #
+    # @return [String] the attribute name
+    #
+    # @since 0.2.0
+    def to_s
+      name.to_s
+    end
+
+    # The attribute name
+    #
+    # @return [Symbol] the attribute name
+    #
+    # @since 0.2.1
+    def to_sym
+      name
+    end
+
+    protected
+
+    # The attribute options
+    # @since 0.5.0
+    attr_reader :options
+  end
+end

data/lib/active_remote/attributes.rb

@@ -1,22 +1,47 @@
 module ActiveRemote
   module Attributes
+    extend ::ActiveSupport::Concern
+    include ::ActiveModel::AttributeMethods
+
+    included do
+      attribute_method_suffix "="
+    end
+
+    # Performs equality checking on the result of attributes and its type.
+    #
+    # @example Compare for equality.
+    #   model == other
+    #
+    def ==(other)
+      return false unless other.instance_of?(self.class)
+      attributes == other.attributes
+    end
+
+    # Returns a copy of our attributes hash
     def attributes
-      @attributes ||= begin
-        attribute_names = self.class.attribute_names
-        Hash[attribute_names.map { |key| [key, send(key)] }]
-      end
       @attributes.dup
     end
 
+    # Returns the class name plus its attributes
+    #
+    # @example Inspect the model.
+    #   person.inspect
+    #
+    def inspect
+      attribute_descriptions = attributes.sort.map { |key, value| "#{key}: #{value.inspect}" }.join(", ")
+      separator = " " unless attribute_descriptions.empty?
+      "#<#{self.class.name}#{separator}#{attribute_descriptions}>"
+    end
+
     # Read attribute from the attributes hash
     #
     def read_attribute(name)
       name = name.to_s
 
-      if respond_to? name
+      if respond_to?(name)
         attribute(name)
       else
-        raise ActiveAttr::UnknownAttributeError, "unknown attribute: #{name}"
+        raise ::ActiveRemote::UnknownAttributeError, "unknown attribute: #{name}"
       end
     end
     alias_method :[], :read_attribute
@@ -26,12 +51,144 @@ module ActiveRemote
     def write_attribute(name, value)
       name = name.to_s
 
-      if respond_to? "#{name}="
+      if respond_to?("#{name}=")
         __send__("attribute=", name, value)
       else
-        raise ActiveAttr::UnknownAttributeError, "unknown attribute: #{name}"
+        raise ::ActiveRemote::UnknownAttributeError, "unknown attribute: #{name}"
       end
     end
     alias_method :[]=, :write_attribute
+
+    # Read an attribute from the attributes hash
+    #
+    def attribute(name)
+      @attributes[name]
+    end
+
+    # Write an attribute to the attributes hash
+    #
+    def attribute=(name, value)
+      @attributes[name] = value
+    end
+
+    def attribute_method?(attr_name)
+      # Check if @attributes is defined because dangerous_attribute? method
+      # can check allocate.respond_to? before actaully calling initialize
+      defined?(@attributes) && @attributes.key?(attr_name)
+    end
+
+    module ClassMethods
+      # Defines an attribute
+      #
+      # For each attribute that is defined, a getter and setter will be
+      # added as an instance method to the model. An
+      # {AttributeDefinition} instance will be added to result of the
+      # attributes class method.
+      #
+      # @example Define an attribute.
+      #   attribute :name
+      #
+      def attribute(name, options={})
+        if dangerous_attribute_method_name = dangerous_attribute?(name)
+          raise ::ActiveRemote::DangerousAttributeError, %{an attribute method named "#{dangerous_attribute_method_name}" would conflict with an existing method}
+        else
+          attribute!(name, options)
+        end
+      end
+
+      # Defines an attribute without checking for conflicts
+      #
+      # Allows you to define an attribute whose methods will conflict
+      # with an existing method. For example, Ruby's Timeout library
+      # adds a timeout method to Object. Attempting to define a timeout
+      # attribute using .attribute will raise a
+      # {DangerousAttributeError}, but .attribute! will not.
+      #
+      # @example Define a dangerous attribute.
+      #   attribute! :timeout
+      #
+      def attribute!(name, options={})
+        ::ActiveRemote::AttributeDefinition.new(name, options).tap do |attribute_definition|
+          attribute_name = attribute_definition.name.to_s
+          # Force active model to generate attribute methods
+          remove_instance_variable("@attribute_methods_generated") if instance_variable_defined?("@attribute_methods_generated")
+          define_attribute_methods([attribute_definition.name]) unless attribute_names.include?(attribute_name)
+          attributes[attribute_name] = attribute_definition
+        end
+      end
+
+      # Returns an Array of attribute names as Strings
+      #
+      # @example Get attribute names
+      #   Person.attribute_names
+      #
+      def attribute_names
+        attributes.keys
+      end
+
+      # Returns a Hash of AttributeDefinition instances
+      #
+      # @example Get attribute definitions
+      #   Person.attributes
+      #
+      def attributes
+        @attributes ||= ::ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      # Determine if a given attribute name is dangerous
+      #
+      # Some attribute names can cause conflicts with existing methods
+      # on an object. For example, an attribute named "timeout" would
+      # conflict with the timeout method that Ruby's Timeout library
+      # mixes into Object.
+      #
+      # @example Testing a harmless attribute
+      #   Person.dangerous_attribute? :name #=> false
+      #
+      # @example Testing a dangerous attribute
+      #   Person.dangerous_attribute? :timeout #=> "timeout"
+      #
+      def dangerous_attribute?(name)
+        return false if attribute_names.include?(name.to_s)
+
+        attribute_methods(name).detect do |method_name|
+          allocate.respond_to?(method_name, true)
+        end
+      end
+
+      # Returns the class name plus its attribute names
+      #
+      # @example Inspect the model's definition.
+      #   Person.inspect
+      #
+      def inspect
+        inspected_attributes = attribute_names.sort
+        attributes_list = "(#{inspected_attributes.join(", ")})" unless inspected_attributes.empty?
+        "#{name}#{attributes_list}"
+      end
+
+    protected
+
+      # Assign a set of attribute definitions, used when subclassing models
+      #
+      def attributes=(attributes)
+        @attributes = attributes
+      end
+
+    private
+
+      # Expand an attribute name into its generated methods names
+      #
+      def attribute_methods(name)
+        attribute_method_matchers.map { |matcher| matcher.method_name(name) }
+      end
+
+      # Ruby inherited hook to assign superclass attributes to subclasses
+      #
+      def inherited(subclass)
+        super
+        subclass.attributes = attributes.dup
+      end
+    end
   end
 end

data/lib/active_remote/base.rb

@@ -1,17 +1,16 @@
 require 'active_model/callbacks'
-require 'active_attr/model'
 
 require 'active_remote/association'
-require 'active_remote/attribute_defaults'
+require 'active_remote/attribute_assignment'
+require 'active_remote/attribute_definition'
 require 'active_remote/attributes'
-require 'active_remote/bulk'
 require 'active_remote/config'
 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/query_attributes'
 require 'active_remote/rpc'
 require 'active_remote/scope_keys'
 require 'active_remote/search'
@@ -21,60 +20,66 @@ require 'active_remote/validations'
 
 module ActiveRemote
   class Base
-    extend ActiveModel::Callbacks
-
-    include ActiveAttr::BasicModel
-    include ActiveAttr::Attributes
-    include ActiveAttr::BlockInitialization
-    include ActiveAttr::ChainableInitialization
-    include ActiveAttr::Logger
-    include ActiveAttr::MassAssignment
-    include ActiveAttr::AttributeDefaults
-    include ActiveAttr::QueryAttributes
-    include ActiveAttr::Serialization
-
-    include Association
-    include AttributeDefaults
-    include Attributes
-    include Bulk
-    include DSL
-    include Integration
-    include Persistence
-    include PrimaryKey
-    include Publication
-    include RPC
-    include ScopeKeys
-    include Search
-    include Serialization
-    include Typecasting
+    extend ::ActiveModel::Callbacks
+    extend ::ActiveModel::Naming
+
+    include ::ActiveModel::Conversion
+    include ::ActiveModel::Validations
+
+    include ::ActiveRemote::Association
+    include ::ActiveRemote::AttributeAssignment
+    include ::ActiveRemote::Attributes
+    include ::ActiveRemote::DSL
+    include ::ActiveRemote::Integration
+    include ::ActiveRemote::Persistence
+    include ::ActiveRemote::PrimaryKey
+    include ::ActiveRemote::QueryAttributes
+    include ::ActiveRemote::RPC
+    include ::ActiveRemote::ScopeKeys
+    include ::ActiveRemote::Search
+    include ::ActiveRemote::Serialization
+    include ::ActiveRemote::Typecasting
 
     # Overrides some methods, providing support for dirty tracking,
     # so it needs to be included last.
-    include Dirty
+    include ::ActiveRemote::Dirty
 
     # Overrides persistence methods, so it must included after
-    include Validations
-    include ActiveModel::Validations::Callbacks
+    include ::ActiveRemote::Validations
+    include ::ActiveModel::Validations::Callbacks
 
     attr_reader :last_request, :last_response
 
     define_model_callbacks :initialize, :only => :after
 
-    def initialize(*)
+    def initialize(attributes = {})
       @attributes ||= begin
         attribute_names = self.class.attribute_names
-        Hash[attribute_names.map { |key| [key, send(key)] }]
+        Hash[attribute_names.map { |key| [key, nil] }]
       end
 
+      assign_attributes(attributes) if attributes
+
       @new_record = true
 
       skip_dirty_tracking do
         run_callbacks :initialize do
-          super
+          yield self if block_given?
         end
       end
     end
 
+    # Initialize an object with the attributes hash directly
+    # When used with allocate, bypasses initialize
+    def init_with(attributes)
+      @attributes = attributes
+      @new_record = false
+
+      run_callbacks :initialize
+
+      self
+    end
+
     def freeze
       @attributes.freeze; self
     end

data/lib/active_remote/dirty.rb

@@ -57,15 +57,6 @@ module ActiveRemote
       enable_dirty_tracking
     end
 
-    # Override #write_attribute (along with #[]=) so we can provide support for
-    # ActiveModel::Dirty.
-    #
-    def write_attribute(name, value)
-      __send__("#{name}_will_change!") if _active_remote_track_changes? && value != self[name]
-      super
-    end
-    alias_method :[]=, :write_attribute
-
   private
 
     # Wether or not changes are currently being tracked for this class.

data/lib/active_remote/errors.rb

@@ -5,6 +5,9 @@ module ActiveRemote
   class ActiveRemoteError < StandardError
   end
 
+  class DangerousAttributeError < ActiveRemoteError
+  end
+
   # Raised by ActiveRemove::Base.save when the remote record is readonly.
   class ReadOnlyRemoteRecord < ActiveRemoteError
   end
@@ -41,4 +44,7 @@ module ActiveRemote
   # when remote record cannot be saved because it is invalid.
   class RemoteRecordNotSaved < ActiveRemoteError
   end
+
+  class UnknownAttributeError < ActiveRemoteError
+  end
 end

data/lib/active_remote/persistence.rb

@@ -49,8 +49,9 @@ module ActiveRemote
       # Instantiate a record with the given remote attributes. Generally used
       # when retrieving records that already exist, so @new_record is set to false.
       #
-      def instantiate(attributes, options = {})
-        new_object = self.new.instantiate(attributes)
+      def instantiate(new_attributes, options = {})
+        attributes = self.build_from_rpc(new_attributes)
+        new_object = self.allocate.init_with(attributes)
         new_object.readonly! if options[:readonly]
 
         new_object
@@ -78,7 +79,7 @@ module ActiveRemote
       raise ReadOnlyRemoteRecord if readonly?
       response = rpc.execute(:delete, scope_key_hash)
 
-      add_errors_from_response(response)
+      add_errors(response.errors) if response.respond_to?(:errors)
 
       return success? ? freeze : false
     end
@@ -103,7 +104,7 @@ module ActiveRemote
       raise ReadOnlyRemoteRecord if readonly?
       response = rpc.execute(:destroy, scope_key_hash)
 
-      add_errors_from_response(response)
+      add_errors(response.errors) if response.respond_to?(:errors)
 
       return success? ? freeze : false
     end
@@ -127,19 +128,9 @@ module ActiveRemote
     # Instantiate a record with the given remote attributes. Generally used
     # when retrieving records that already exist, so @new_record is set to false.
     #
-    def instantiate(record)
-      skip_dirty_tracking do
-        assign_attributes(record, :without_protection => true)
-      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
-      self
+    def instantiate(new_attributes)
+      new_attributes = self.class.build_from_rpc(new_attributes)
+      init_with(new_attributes)
     end
 
     # Returns true if the remote record hasn't been saved yet; otherwise,
@@ -252,7 +243,7 @@ module ActiveRemote
         response = rpc.execute(:create, new_attributes)
 
         assign_attributes(response.to_hash)
-        add_errors_from_response(response)
+        add_errors(response.errors) if response.respond_to?(:errors)
 
         @new_record = has_errors?
         success?
@@ -282,7 +273,7 @@ module ActiveRemote
         response = rpc.execute(:update, updated_attributes)
 
         assign_attributes(response.to_hash)
-        add_errors_from_response(response)
+        add_errors(response.errors) if response.respond_to?(:errors)
 
         success?
       end