active_remote 5.1.1 → 5.2.0.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d01c0d9e90a995d69eca7eb4fc5778033dc78b6c2a1a2ed1472f828833d1ffb
-  data.tar.gz: 3304e91fb6c6dbf24955f5f84bccf1f19e4fb2f9a9a16a8a58c0dc41416f9e18
+  metadata.gz: 1d8212d6102d24ca632d2f76449826bf4593b2a76a0d27269866a0d3533b4813
+  data.tar.gz: e648845212e9756304427bccfc60da60d2aaf2325e309639905cfeb163e234bb
 SHA512:
-  metadata.gz: 6ac0f959ee3b70f396917d360c8b1c28c663530dc0b4d1f8b890ce277e401663208a80da549917f204a7a6f628b60cdb8e278d348f884b33d87ea5bc17503e56
-  data.tar.gz: d5db551ce3a30686ebe5bc529e2511a8e1b20b669d7ffd2b4b666f24d94bcbfec3b06cbda7787f03f469d5c87ffc7f7ce53b100f401795aea5f18cfa450d5850
+  metadata.gz: 89eed8d66c19ddc8daecd21db103ff91d29a5d2b779770163e7962a85a33c32c4c2d41f64ae8e27d950e87ddfa563350058a3478aa56e4b6ce50618405b1582f
+  data.tar.gz: d137fab5f02b7f753be9122f6aabe18c9593456a740384e1da0b80aca8ac1d9eaaaf6e8c8ca5c7d5cd2dae58c971ac04e0f5c274301d90a71f3ae1f3215502f9

data/active_remote.gemspec

@@ -20,8 +20,8 @@ Gem::Specification.new do |s|
   ##
   # Dependencies
   #
-  s.add_dependency "activemodel", "~> 5.1.0"
-  s.add_dependency "activesupport", "~> 5.1.0"
+  s.add_dependency "activemodel", "~> 5.2"
+  s.add_dependency "activesupport", "~> 5.2"
   s.add_dependency "protobuf", ">= 3.0"
 
   ##

data/bin/benchmark

@@ -5,7 +5,14 @@ require "bundler/setup"
 require "active_remote"
 require "benchmark/ips"
 
-require "./spec/support/models/typecasted_author"
+class Author < ::ActiveRemote::Base
+  attribute :guid, :string
+  attribute :name, :string
+  attribute :age, :integer
+  attribute :birthday, :datetime
+  attribute :writes_fiction, :boolean
+  attribute :net_sales, :float
+end
 
 ATTRIBUTES = {
   :guid => "0c030733-3b78-4587-b94b-5e0cf26497c5",
@@ -19,18 +26,18 @@ ATTRIBUTES = {
 ::Benchmark.ips do |x|
   x.config(:time => 20, :warmup => 10)
   x.report("initialize") do
-    ::TypecastedAuthor.new(ATTRIBUTES)
+    ::Author.new(ATTRIBUTES)
   end
 
   x.report("instantiate") do
-    ::TypecastedAuthor.instantiate(ATTRIBUTES)
+    ::Author.instantiate(ATTRIBUTES)
   end
 
   x.report("init attributes") do
-    ::TypecastedAuthor.new(ATTRIBUTES).attributes
+    ::Author.new(ATTRIBUTES).attributes
   end
 
   x.report("inst attributes") do
-    ::TypecastedAuthor.instantiate(ATTRIBUTES).attributes
+    ::Author.instantiate(ATTRIBUTES).attributes
   end
 end

data/lib/active_remote/association.rb

@@ -8,8 +8,7 @@ module ActiveRemote
       # class must be loaded into memory already. A method will be defined
       # with the same name as the association. When invoked, the associated
       # remote model will issue a `search` for the :guid with the associated
-      # guid's attribute (e.g. read_attribute(:client_guid)) and return the first
-      # remote object from the result, or nil.
+      # guid attribute and return the first remote object from the result, or nil.
       #
       # A `belongs_to` association should be used when the associating remote
       # contains the guid to the associated model. For example, if a User model
@@ -37,8 +36,8 @@ module ActiveRemote
         perform_association(belongs_to_klass, options) do |klass, object|
           foreign_key = options.fetch(:foreign_key) { :"#{klass.name.demodulize.underscore}_guid" }
           search_hash = {}
-          search_hash[:guid] = object.read_attribute(foreign_key)
-          search_hash[options[:scope]] = object.read_attribute(options[:scope]) if options.key?(:scope)
+          search_hash[:guid] = object.send(foreign_key)
+          search_hash[options[:scope]] = object.send(options[:scope]) if options.key?(:scope)
 
           search_hash.values.any?(&:nil?) ? nil : klass.search(search_hash).first
         end
@@ -49,7 +48,7 @@ module ActiveRemote
       # class must be loaded into memory already. A method will be defined
       # with the same plural name as the association. When invoked, the associated
       # remote model will issue a `search` for the :guid with the associated
-      # guid's attribute (e.g. read_attribute(:client_guid)).
+      # guid attribute.
       #
       # A `has_many` association should be used when the associated model has
       # a field to identify the associating model, and there can be multiple
@@ -79,7 +78,7 @@ module ActiveRemote
           foreign_key = options.fetch(:foreign_key) { :"#{object.class.name.demodulize.underscore}_guid" }
           search_hash = {}
           search_hash[foreign_key] = object.guid
-          search_hash[options[:scope]] = object.read_attribute(options[:scope]) if options.key?(:scope)
+          search_hash[options[:scope]] = object.send(options[:scope]) if options.key?(:scope)
 
           search_hash.values.any?(&:nil?) ? [] : klass.search(search_hash)
         end
@@ -93,8 +92,7 @@ module ActiveRemote
       # class must be loaded into memory already. A method will be defined
       # with the same name as the association. When invoked, the associated
       # remote model will issue a `search` for the :guid with the associated
-      # guid's attribute (e.g. read_attribute(:client_guid)) and return the first
-      # remote object in the result, or nil.
+      # guid attribute and return the first remote object in the result, or nil.
       #
       # A `has_one` association should be used when the associated remote
       # contains the guid from the associating model. For example, if a User model
@@ -120,7 +118,7 @@ module ActiveRemote
           foreign_key = options.fetch(:foreign_key) { :"#{object.class.name.demodulize.underscore}_guid" }
           search_hash = {}
           search_hash[foreign_key] = object.guid
-          search_hash[options[:scope]] = object.read_attribute(options[:scope]) if options.key?(:scope)
+          search_hash[options[:scope]] = object.send(options[:scope]) if options.key?(:scope)
 
           search_hash.values.any?(&:nil?) ? nil : klass.search(search_hash).first
         end

data/lib/active_remote/attribute_methods.rb

@@ -0,0 +1,51 @@
+module ActiveRemote
+  module AttributeMethods
+    extend ::ActiveSupport::Concern
+
+    module ClassMethods
+      def attribute_names
+        @attribute_names ||= attribute_types.keys
+      end
+    end
+
+    def [](name)
+      attribute(name)
+    end
+
+    def []=(name, value)
+      write_attribute(name, value)
+    end
+
+    # Returns an <tt>#inspect</tt>-like string for the value of the
+    # attribute +attr_name+. String attributes are truncated up to 50
+    # characters, Date and Time attributes are returned in the
+    # <tt>:db</tt> format. Other attributes return the value of
+    # <tt>#inspect</tt> without modification.
+    #
+    #   person = Person.create!(name: 'David Heinemeier Hansson ' * 3)
+    #
+    #   person.attribute_for_inspect(:name)
+    #   # => "\"David Heinemeier Hansson David Heinemeier Hansson ...\""
+    #
+    #   person.attribute_for_inspect(:created_at)
+    #   # => "\"2012-10-22 00:15:07\""
+    #
+    #   person.attribute_for_inspect(:tag_ids)
+    #   # => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]"
+    def attribute_for_inspect(attr_name)
+      value = attribute(attr_name)
+
+      if value.is_a?(String) && value.length > 50
+        "#{value[0, 50]}...".inspect
+      elsif value.is_a?(Date) || value.is_a?(Time)
+        %("#{value.to_s(:db)}")
+      else
+        value.inspect
+      end
+    end
+
+    def attribute_names
+      @attributes.keys
+    end
+  end
+end

data/lib/active_remote/base.rb

@@ -1,8 +1,7 @@
 require "active_model/callbacks"
 
 require "active_remote/association"
-require "active_remote/attribute_definition"
-require "active_remote/attributes"
+require "active_remote/attribute_methods"
 require "active_remote/config"
 require "active_remote/dirty"
 require "active_remote/dsl"
@@ -21,14 +20,16 @@ module ActiveRemote
     extend ::ActiveModel::Callbacks
 
     include ::ActiveModel::Model
+    include ::ActiveModel::Attributes
 
     include ::ActiveRemote::Association
-    include ::ActiveRemote::Attributes
+    include ::ActiveRemote::AttributeMethods
     include ::ActiveRemote::DSL
     include ::ActiveRemote::Integration
+    include ::ActiveRemote::QueryAttributes
     include ::ActiveRemote::Persistence
     include ::ActiveRemote::PrimaryKey
-    include ::ActiveRemote::QueryAttributes
+
     include ::ActiveRemote::RPC
     include ::ActiveRemote::ScopeKeys
     include ::ActiveRemote::Search
@@ -45,10 +46,7 @@ module ActiveRemote
     define_model_callbacks :initialize, :only => :after
 
     def initialize(attributes = {})
-      @attributes = self.class.send(:default_attributes_hash).dup
-
-      assign_attributes(attributes) if attributes
-
+      super
       @new_record = true
 
       skip_dirty_tracking do
@@ -58,6 +56,41 @@ module ActiveRemote
       end
     end
 
+    # Returns true if +comparison_object+ is the same exact object, or +comparison_object+
+    # is of the same type and +self+ has an ID and it is equal to +comparison_object.id+.
+    #
+    # Note that new records are different from any other record by definition, unless the
+    # other record is the receiver itself. Besides, if you fetch existing records with
+    # +select+ and leave the ID out, you're on your own, this predicate will return false.
+    #
+    # Note also that destroying a record preserves its ID in the model instance, so deleted
+    # models are still comparable.
+    def ==(other)
+      super ||
+        other.instance_of?(self.class) &&
+          !send(primary_key).nil? &&
+          other.send(primary_key) == send(primary_key)
+    end
+    alias_method :eql?, :==
+
+    # Allows sort on objects
+    def <=>(other)
+      if other.is_a?(self.class)
+        to_key <=> other.to_key
+      else
+        super
+      end
+    end
+
+    def freeze
+      @attributes.freeze
+      self
+    end
+
+    def frozen?
+      @attributes.frozen?
+    end
+
     # Initialize an object with the attributes hash directly
     # When used with allocate, bypasses initialize
     def init_with(attributes)
@@ -69,15 +102,32 @@ module ActiveRemote
       self
     end
 
-    def freeze
-      @attributes.freeze
-      self
+    # Returns the contents of the record as a nicely formatted string.
+    def inspect
+      # We check defined?(@attributes) not to issue warnings if the object is
+      # allocated but not initialized.
+      inspection = if defined?(@attributes) && @attributes
+                     attribute_names.collect do |name, _|
+                       if attribute?(name)
+                         "#{name}: #{attribute_for_inspect(name)}"
+                       else
+                         name
+                       end
+                     end.compact.join(", ")
+                   else
+                     "not initialized"
+                   end
+
+      "#<#{self.class} #{inspection}>"
     end
 
-    def frozen?
-      @attributes.frozen?
+    # Returns a hash of the given methods with their names as keys and returned values as values.
+    def slice(*methods)
+      Hash[methods.flatten.map! { |method| [method, public_send(method)] }].with_indifferent_access
     end
   end
 
-  ActiveSupport.run_load_hooks(:active_remote, Base)
+  ::ActiveModel::Type.register(:value, ::ActiveModel::Type::Value)
+
+  ::ActiveSupport.run_load_hooks(:active_remote, Base)
 end

data/lib/active_remote/dirty.rb

@@ -24,8 +24,7 @@ module ActiveRemote
     #
     def reload(*)
       super.tap do
-        @previously_changed.try(:clear)
-        changed_attributes.clear
+        clear_changes_information
       end
     end
 
@@ -41,8 +40,7 @@ module ActiveRemote
     #
     def save(*)
       if (status = super)
-        @previously_changed = changes
-        changed_attributes.clear
+        changes_applied
       end
 
       status
@@ -52,8 +50,7 @@ module ActiveRemote
     #
     def save!(*)
       super.tap do
-        @previously_changed = changes
-        changed_attributes.clear
+        changes_applied
       end
     end
 
@@ -77,7 +74,7 @@ module ActiveRemote
     # ActiveModel::Dirty.
     #
     def attribute=(name, value)
-      __send__("#{name}_will_change!") if _active_remote_track_changes? && value != self[name]
+      send("#{name}_will_change!") if _active_remote_track_changes? && value != self[name]
       super
     end
 

data/lib/active_remote/integration.rb

@@ -3,48 +3,134 @@ module ActiveRemote
     extend ActiveSupport::Concern
 
     included do
-      unless singleton_methods.include?(:cache_timestamp_format)
-        ##
-        # :singleton-method:
-        # Indicates the format used to generate the timestamp format in the cache key.
-        # This is +:number+, by default.
-        #
-        def self.cache_timestamp_format
-          :number
-        end
-      end
+      ##
+      # :singleton-method:
+      # Indicates the format used to generate the timestamp in the cache key, if
+      # versioning is off. Accepts any of the symbols in <tt>Time::DATE_FORMATS</tt>.
+      #
+      # This is +:usec+, by default.
+      class_attribute :cache_timestamp_format, :instance_writer => false, :default => :usec
+
+      ##
+      # :singleton-method:
+      # Indicates whether to use a stable #cache_key method that is accompanied
+      # by a changing version in the #cache_version method.
+      #
+      # This is +false+, by default until Rails 6.0.
+      class_attribute :cache_versioning, :instance_writer => false, :default => false
     end
 
-    ##
-    # Returns a String, which can be used for constructing an URL to this
-    # object. The default implementation returns this record's guid as a String,
-    # or nil if this record's unsaved.
+    # Returns a +String+, which Action Pack uses for constructing a URL to this
+    # object. The default implementation returns this record's id as a +String+,
+    # or +nil+ if this record's unsaved.
+    #
+    # For example, suppose that you have a User model, and that you have a
+    # <tt>resources :users</tt> route. Normally, +user_path+ will
+    # construct a path with the user object's 'id' in it:
+    #
+    #   user = User.find_by(name: 'Phusion')
+    #   user_path(user)  # => "/users/1"
+    #
+    # You can override +to_param+ in your model to make +user_path+ construct
+    # a path using the user's name instead of the user's id:
     #
-    #   user = User.search(:name => 'Phusion')
-    #   user.to_param  # => "GUID-1"
+    #   class User < ActiveRecord::Base
+    #     def to_param  # overridden
+    #       name
+    #     end
+    #   end
+    #
+    #   user = User.find_by(name: 'Phusion')
+    #   user_path(user)  # => "/users/Phusion"
     #
     def to_param
-      self[:guid]&.to_s
+      key = send(primary_key)
+      key&.to_s
     end
 
-    ##
-    # Returns a cache key that can be used to identify this record.
-    #
-    # ==== Examples
+    # Returns a stable cache key that can be used to identify this record.
     #
     #   Product.new.cache_key     # => "products/new"
-    #   Person.search(:guid => "derp-5").cache_key  # => "people/derp-5-20071224150000" (include updated_at)
-    #   Product.search(:guid => "derp-5").cache_key # => "products/derp-5"
+    #   Product.find(5).cache_key # => "products/5"
+    #
+    # If ActiveRecord::Base.cache_versioning is turned off, as it was in Rails 5.1 and earlier,
+    # the cache key will also include a version.
+    #
+    #   Product.cache_versioning = false
+    #   Person.find(5).cache_key  # => "people/5-20071224150000" (updated_at available)
     #
     def cache_key
       case
       when new_record? then
-        "#{self.class.name.underscore}/new"
+        "#{model_name.cache_key}/new"
       when ::ActiveRemote.config.default_cache_key_updated_at? && (timestamp = self[:updated_at]) then
         timestamp = timestamp.utc.to_s(self.class.cache_timestamp_format)
-        "#{self.class.name.underscore}/#{self.to_param}-#{timestamp}"
+        "#{model_name.cache_key}/#{send(primary_key)}-#{timestamp}"
+      else
+        "#{model_name.cache_key}/#{send(primary_key)}"
+      end
+    end
+
+    # Returns a cache key along with the version.
+    def cache_key_with_version
+      if (version = cache_version)
+        "#{cache_key}-#{version}"
       else
-        "#{self.class.name.underscore}/#{self.to_param}"
+        cache_key
+      end
+    end
+
+    # Returns a cache version that can be used together with the cache key to form
+    # a recyclable caching scheme. By default, the #updated_at column is used for the
+    # cache_version, but this method can be overwritten to return something else.
+    #
+    # Note, this method will return nil if ActiveRecord::Base.cache_versioning is set to
+    # +false+ (which it is by default until Rails 6.0).
+    def cache_version
+      if cache_versioning && (timestamp = try(:updated_at))
+        timestamp.utc.to_s(:usec)
+      end
+    end
+
+    module ClassMethods
+      # Defines your model's +to_param+ method to generate "pretty" URLs
+      # using +method_name+, which can be any attribute or method that
+      # responds to +to_s+.
+      #
+      #   class User < ActiveRecord::Base
+      #     to_param :name
+      #   end
+      #
+      #   user = User.find_by(name: 'Fancy Pants')
+      #   user.id         # => 123
+      #   user_path(user) # => "/users/123-fancy-pants"
+      #
+      # Values longer than 20 characters will be truncated. The value
+      # is truncated word by word.
+      #
+      #   user = User.find_by(name: 'David Heinemeier Hansson')
+      #   user.id         # => 125
+      #   user_path(user) # => "/users/125-david-heinemeier"
+      #
+      # Because the generated param begins with the record's +id+, it is
+      # suitable for passing to +find+. In a controller, for example:
+      #
+      #   params[:id]               # => "123-fancy-pants"
+      #   User.find(params[:id]).id # => 123
+      def to_param(method_name = nil)
+        if method_name.nil?
+          super()
+        else
+          define_method :to_param do
+            if (default = super()) &&
+               (result = send(method_name).to_s).present? &&
+               (param = result.squish.parameterize.truncate(20, :separator => /-/, :omission => "")).present?
+              "#{default}-#{param}"
+            else
+              default
+            end
+          end
+        end
       end
     end
   end