test_track_rails_client 4.0.0.alpha12 → 4.0.0.alpha13

data/vendor/gems/her/lib/her/model/attributes.rb

@@ -18,8 +18,14 @@ module Her
       #     include Her::Model
       #   end
       #
-      #  User.new(name: "Tobias") # => #<User name="Tobias">
-      def initialize(attributes={})
+      #   User.new(name: "Tobias")
+      #   # => #<User name="Tobias">
+      #
+      #   User.new do |u|
+      #     u.name = "Tobias"
+      #   end
+      #   # => #<User name="Tobias">
+      def initialize(attributes = {})
         attributes ||= {}
         @metadata = attributes.delete(:_metadata) || {}
         @response_errors = attributes.delete(:_errors) || {}
@@ -27,70 +33,16 @@ module Her
 
         attributes = self.class.default_scope.apply_to(attributes)
         assign_attributes(attributes)
+        yield self if block_given?
         run_callbacks :initialize
       end
 
-      # Initialize a collection of resources
-      #
-      # @private
-      def self.initialize_collection(klass, parsed_data={})
-        unless parsed_data[:errors].present?
-          initialize_resource_collection(klass, parsed_data)
-        else
-          initialize_error_collection(parsed_data)
-        end
-      end
-
-      def self.initialize_resource_collection(klass, parsed_data={})
-        collection_data = klass.extract_array(parsed_data).map do |item_data|
-          if item_data.kind_of?(klass)
-            resource = item_data
-          else
-            resource = klass.new(klass.parse(item_data))
-            resource.instance_variable_set(:@changed_attributes, {})
-            resource.run_callbacks :find
-          end
-          resource
-        end
-        Her::Collection.new(collection_data, parsed_data[:metadata], parsed_data[:errors])
-      end
-
-      # Initialize an error collection
-      #
-      # @private
-      def self.initialize_error_collection(parsed_data={})
-        Her::ErrorCollection.new(parsed_data[:metadata], parsed_data[:errors])
-      end
-
-      # Use setter methods of model for each key / value pair in params
-      # Return key / value pairs for which no setter method was defined on the model
-      #
-      # @private
-      def self.use_setter_methods(model, params)
-        params ||= {}
-
-        reserved_keys = [:id, model.class.primary_key] + model.class.association_keys
-        model.class.attributes *params.keys.reject { |k| reserved_keys.include?(k) || reserved_keys.map(&:to_s).include?(k) }
-
-        setter_method_names = model.class.setter_method_names
-        params.inject({}) do |memo, (key, value)|
-          setter_method = key.to_s + '='
-          if setter_method_names.include?(setter_method)
-            model.send(setter_method, value)
-          else
-            key = key.to_sym if key.is_a?(String)
-            memo[key] = value
-          end
-          memo
-        end
-      end
-
       # Handles missing methods
       #
       # @private
       def method_missing(method, *args, &blk)
         return super if ATTRIBUTE_BLACKLIST.include?(method)
-        if method.to_s =~ /[?=]$/ || @attributes.include?(method)
+        if method.to_s =~ /[?=]$/ || attributes.include?(method)
           # Extract the attribute
           attribute = method.to_s.sub(/[?=]$/, '')
 
@@ -107,7 +59,7 @@ module Her
       # @private
       def respond_to_missing?(method, include_private = false)
         return super if ATTRIBUTE_BLACKLIST.include?(method)
-        method.to_s.end_with?('=') || method.to_s.end_with?('?') || attributes.include?(method) || super
+        method.to_s =~ /[?=]$/ || attributes.include?(method) || super
       end
 
       # Assign new attributes to a resource
@@ -121,47 +73,55 @@ module Her
       #   user.assign_attributes(name: "Lindsay")
       #   user.changes # => { :name => ["Tobias", "Lindsay"] }
       def assign_attributes(new_attributes)
-        @attributes ||= attributes
+        @_her_attributes ||= attributes
         # Use setter methods first
-        unset_attributes = Her::Model::Attributes.use_setter_methods(self, new_attributes)
+        unset_attributes = self.class.use_setter_methods(self, new_attributes)
 
         # Then translate attributes of associations into association instances
-        parsed_attributes = self.class.parse_associations(unset_attributes)
+        associations = self.class.parse_associations(unset_attributes)
 
-        # Then merge the parsed_data into @attributes.
-        @attributes.merge!(parsed_attributes)
+        # Then merge the associations into @_her_attributes.
+        @_her_attributes.merge!(associations)
       end
       alias attributes= assign_attributes
 
       def attributes
-        @attributes ||= HashWithIndifferentAccess.new
+        # The natural choice of instance variable naming here would be
+        # `@attributes`. Unfortunately that causes a naming clash when
+        # used with `ActiveModel` version >= 5.2.0.
+        # As of v5.2.0 `ActiveModel` checks to see if `ActiveRecord`
+        # attributes exist, and assumes that if the instance variable
+        # `@attributes` exists on the instance, it is because they are
+        # `ActiveRecord` attributes.
+        @_her_attributes ||= HashWithIndifferentAccess.new
       end
 
       # Handles returning true for the accessible attributes
       #
       # @private
       def has_attribute?(attribute_name)
-        @attributes.include?(attribute_name)
+        @_her_attributes.include?(attribute_name)
       end
 
       # Handles returning data for a specific attribute
       #
       # @private
       def get_attribute(attribute_name)
-        @attributes[attribute_name]
+        @_her_attributes[attribute_name]
       end
       alias attribute get_attribute
 
       # Return the value of the model `primary_key` attribute
       def id
-        @attributes[self.class.primary_key]
+        @_her_attributes[self.class.primary_key]
       end
 
-      # Return `true` if the other object is also a Her::Model and has matching data
+      # Return `true` if the other object is also a Her::Model and has matching
+      # data
       #
       # @private
       def ==(other)
-        other.is_a?(Her::Model) && @attributes == other.attributes
+        other.is_a?(Her::Model) && @_her_attributes == other.attributes
       end
 
       # Delegate to the == method
@@ -171,47 +131,108 @@ module Her
         self == other
       end
 
-      # Delegate to @attributes, allowing models to act correctly in code like:
+      # Delegate to @_her_attributes, allowing models to act correctly in code like:
       #     [ Model.find(1), Model.find(1) ].uniq # => [ Model.find(1) ]
       # @private
       def hash
-        @attributes.hash
+        @_her_attributes.hash
       end
 
       # Assign attribute value (ActiveModel convention method).
       #
       # @private
       def attribute=(attribute, value)
-        @attributes[attribute] = nil unless @attributes.include?(attribute)
-        self.send(:"#{attribute}_will_change!") if @attributes[attribute] != value
-        @attributes[attribute] = value
+        @_her_attributes[attribute] = nil unless @_her_attributes.include?(attribute)
+        send("#{attribute}_will_change!") unless value == @_her_attributes[attribute]
+        @_her_attributes[attribute] = value
       end
 
       # Check attribute value to be present (ActiveModel convention method).
       #
       # @private
       def attribute?(attribute)
-        @attributes.include?(attribute) && @attributes[attribute].present?
+        @_her_attributes.include?(attribute) && @_her_attributes[attribute].present?
       end
 
       module ClassMethods
+        # Initialize a single resource
+        #
+        # @private
+        def instantiate_record(klass, parsed_data)
+          if (record = parsed_data[:data]) && record.is_a?(klass)
+            record
+          else
+            attributes = klass.parse(record).merge(_metadata: parsed_data[:metadata],
+                                                   _errors: parsed_data[:errors])
+            klass.new(attributes).tap do |record_instance|
+              record_instance.send :clear_changes_information
+              record_instance.run_callbacks :find
+            end
+          end
+        end
+
+        # Initialize a collection of resources
+        #
+        # @private
+        def instantiate_collection(klass, parsed_data = {})
+          unless parsed_data[:errors].present?
+            instantiate_resource_collection(klass, parsed_data)
+          else
+            instantiate_error_collection(parsed_data)
+          end
+        end
+
+        def instantiate_resource_collection(klass, parsed_data = {})
+          records = klass.extract_array(parsed_data).map do |record|
+            instantiate_record(klass, data: record)
+          end
+          Her::Collection.new(records, parsed_data[:metadata], parsed_data[:errors])
+        end
+
+        # Initialize an error collection
+        #
+        # @private
+        def instantiate_error_collection(parsed_data={})
+          Her::ErrorCollection.new(parsed_data[:metadata], parsed_data[:errors])
+        end
+
         # Initialize a collection of resources with raw data from an HTTP request
         #
         # @param [Array] parsed_data
         # @private
         def new_collection(parsed_data)
-          Her::Model::Attributes.initialize_collection(self, parsed_data)
+          instantiate_collection(self, parsed_data)
         end
 
         # Initialize a new object with the "raw" parsed_data from the parsing middleware
         #
         # @private
         def new_from_parsed_data(parsed_data)
-          parsed_data = parsed_data.with_indifferent_access
-          new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:metadata], :_errors => parsed_data[:errors])
+          instantiate_record(self, parsed_data)
+        end
+
+        # Use setter methods of model for each key / value pair in params
+        # Return key / value pairs for which no setter method was defined on the
+        # model
+        #
+        # @private
+        def use_setter_methods(model, params = {})
+          reserved = [:id, model.class.primary_key, *model.class.association_keys]
+          model.class.attributes *params.keys.reject { |k| reserved.include?(k) }
+
+          setter_method_names = model.class.setter_method_names
+          params.each_with_object({}) do |(key, value), memo|
+            setter_method = "#{key}="
+            if setter_method_names.include?(setter_method)
+              model.send setter_method, value
+            else
+              memo[key.to_sym] = value
+            end
+          end
         end
 
-        # Define attribute method matchers to automatically define them using ActiveModel's define_attribute_methods.
+        # Define attribute method matchers to automatically define them using
+        # ActiveModel's define_attribute_methods.
         #
         # @private
         def define_attribute_method_matchers
@@ -219,18 +240,22 @@ module Her
           attribute_method_suffix '?'
         end
 
-        # Create a mutex for dynamically generated attribute methods or use one defined by ActiveModel.
+        # Create a mutex for dynamically generated attribute methods or use one
+        # defined by ActiveModel.
         #
         # @private
         def attribute_methods_mutex
-          @attribute_methods_mutex ||= if generated_attribute_methods.respond_to? :mu_synchronize
-                                         generated_attribute_methods
-                                       else
-                                         Mutex.new
-                                       end
+          @attribute_methods_mutex ||= begin
+            if generated_attribute_methods.respond_to? :mu_synchronize
+              generated_attribute_methods
+            else
+              Mutex.new
+            end
+          end
         end
 
-        # Define the attributes that will be used to track dirty attributes and validations
+        # Define the attributes that will be used to track dirty attributes and
+        # validations
         #
         # @param [Array] attributes
         # @example
@@ -244,7 +269,8 @@ module Her
           end
         end
 
-        # Define the accessor in which the API response errors (obtained from the parsing middleware) will be stored
+        # Define the accessor in which the API response errors (obtained from
+        # the parsing middleware) will be stored
         #
         # @param [Symbol] store_response_errors
         #
@@ -257,7 +283,8 @@ module Her
           store_her_data(:response_errors, value)
         end
 
-        # Define the accessor in which the API response metadata (obtained from the parsing middleware) will be stored
+        # Define the accessor in which the API response metadata (obtained from
+        # the parsing middleware) will be stored
         #
         # @param [Symbol] store_metadata
         #
@@ -272,13 +299,15 @@ module Her
 
         # @private
         def setter_method_names
-          @_her_setter_method_names ||= instance_methods.inject(Set.new) do |memo, method_name|
-            memo << method_name.to_s if method_name.to_s.end_with?('=')
-            memo
+          @_her_setter_method_names ||= begin
+            instance_methods.each_with_object(Set.new) do |method, memo|
+              memo << method.to_s if method.to_s.end_with?('=')
+            end
           end
         end
 
         private
+
         # @private
         def store_her_data(name, value)
           class_eval <<-RUBY, __FILE__, __LINE__ + 1

data/vendor/gems/her/lib/her/model/base.rb

@@ -11,7 +11,7 @@ module Her
       # @private
       def has_key?(attribute_name)
         has_attribute?(attribute_name) ||
-        has_association?(attribute_name)
+          has_association?(attribute_name)
       end
 
       # Returns
@@ -21,7 +21,7 @@ module Her
       # @private
       def [](attribute_name)
         get_attribute(attribute_name) ||
-        get_association(attribute_name)
+          get_association(attribute_name)
       end
 
       # @private

data/vendor/gems/her/lib/her/model/http.rb

@@ -3,7 +3,7 @@ module Her
     # This module interacts with Her::API to fetch HTTP data
     module HTTP
       extend ActiveSupport::Concern
-      METHODS = [:get, :post, :put, :patch, :delete]
+      METHODS = [:get, :post, :put, :patch, :delete, :options]
 
       # For each HTTP method, define these class methods:
       #
@@ -52,7 +52,7 @@ module Her
         # Main request wrapper around Her::API. Used to make custom request to the API.
         #
         # @private
-        def request(params={})
+        def request(params = {})
           request = her_api.request(params)
           status = request[:response].status
 
@@ -74,7 +74,7 @@ module Her
                 if parsed_data[:data].is_a?(Array) || active_model_serializers_format? || json_api_format?
                   new_collection(parsed_data)
                 else
-                  new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:metadata], :_errors => parsed_data[:errors])
+                  new_from_parsed_data(parsed_data)
                 end
               end
             end
@@ -94,7 +94,7 @@ module Her
             def #{method}_resource(path, params={})
               path = build_request_path_from_string_or_symbol(path, params)
               send(:"#{method}_raw", path, params) do |parsed_data, response|
-                new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:metadata], :_errors => parsed_data[:errors])
+                new_from_parsed_data(parsed_data)
               end
             end
 

data/vendor/gems/her/lib/her/model/introspection.rb

@@ -22,6 +22,7 @@ module Her
       end
 
       private
+
       def attribute_for_inspect(value)
         if value.is_a?(String) && value.length > 50
           "#{value[0..50]}...".inspect
@@ -38,15 +39,16 @@ module Her
         #
         # @private
         def her_nearby_class(name)
-          her_sibling_class(name) || name.constantize rescue nil
+          her_sibling_class(name) || name.constantize
         end
 
         protected
+
         # Looks for a class at the same level as this one with the given name.
         #
         # @private
         def her_sibling_class(name)
-          if mod = self.her_containing_module
+          if mod = her_containing_module
             @_her_sibling_class ||= Hash.new { Hash.new }
             @_her_sibling_class[mod][name] ||= "#{mod.name}::#{name}".constantize rescue nil
           end
@@ -56,8 +58,8 @@ module Her
         #
         # @private
         def her_containing_module
-          return unless self.name =~ /::/
-          self.name.split("::")[0..-2].join("::").constantize
+          return unless name =~ /::/
+          name.split("::")[0..-2].join("::").constantize
         end
       end
     end

data/vendor/gems/her/lib/her/model/nested_attributes.rb

@@ -25,7 +25,7 @@ module Her
 
           associations.each do |association_name|
             unless allowed_association_names.include?(association_name)
-              raise Her::Errors::AssociationUnknownError.new("Unknown association name :#{association_name}")
+              raise Her::Errors::AssociationUnknownError, "Unknown association name :#{association_name}"
             end
 
             class_eval <<-RUBY, __FILE__, __LINE__ + 1

data/vendor/gems/her/lib/her/model/orm.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+
 module Her
   module Model
     # This module adds ORM-like capabilities to the model
@@ -40,20 +41,13 @@ module Her
           callback = new? ? :create : :update
           method = self.class.method_for(callback)
 
-          run_callbacks callback do
-            run_callbacks :save do
-              params = to_params
+          run_callbacks :save do
+            run_callbacks callback do
               self.class.request(to_params.merge(:_method => method, :_path => request_path, :_headers => request_headers, :_options => request_options)) do |parsed_data, response|
-                assign_attributes(self.class.parse(parsed_data[:data])) if parsed_data[:data].any?
-                @metadata = parsed_data[:metadata]
-                @response_errors = parsed_data[:errors]
-                self.assign_attributes(status_code: response.status)
-
+                load_from_parsed_data(parsed_data)
+                assign_attributes(status_code: response.status)
                 return false if !response.success? || @response_errors.any?
-                if self.changed_attributes.present?
-                  @previously_changed = self.changed_attributes.clone
-                  self.changed_attributes.clear
-                end
+                changes_applied
               end
             end
           end
@@ -87,9 +81,7 @@ module Her
         run_callbacks :destroy do
           self.class.request(params.merge(:_method => method, :_path => request_path, :_headers => request_headers, :_options => request_options)) do |parsed_data, response|
             raise Her::Errors::ResponseError.for(response.status).new("Request against #{self.class} returned a #{response.status}") if response.status >= 400
-            assign_attributes(self.class.parse(parsed_data[:data])) if parsed_data[:data].any?
-            @metadata = parsed_data[:metadata]
-            @response_errors = parsed_data[:errors]
+            load_from_parsed_data(parsed_data)
             @destroyed = response.success?
           end
         end
@@ -97,11 +89,90 @@ module Her
       end
 
       def full_error_messages
-        self.response_errors.map do |field, messages|
+        response_errors.map do |field, messages|
           "#{field} #{messages.join(', ')}"
         end.join('. ')
       end
 
+      # Initializes +attribute+ to zero if +nil+ and adds the value passed as
+      # +by+ (default is 1). The increment is performed directly on the
+      # underlying attribute, no setter is invoked. Only makes sense for
+      # number-based attributes. Returns +self+.
+      def increment(attribute, by = 1)
+        attributes[attribute] ||= 0
+        attributes[attribute] += by
+        self
+      end
+
+      # Wrapper around #increment that saves the resource. Saving is subjected
+      # to validation checks. Returns +self+.
+      def increment!(attribute, by = 1)
+        increment(attribute, by) && save
+        self
+      end
+
+      # Initializes +attribute+ to zero if +nil+ and substracts the value passed as
+      # +by+ (default is 1). The decrement is performed directly on the
+      # underlying attribute, no setter is invoked. Only makes sense for
+      # number-based attributes. Returns +self+.
+      def decrement(attribute, by = 1)
+        increment(attribute, -by)
+      end
+
+      # Wrapper around #decrement that saves the resource. Saving is subjected
+      # to validation checks. Returns +self+.
+      def decrement!(attribute, by = 1)
+        increment!(attribute, -by)
+      end
+
+      # Assigns to +attribute+ the boolean opposite of <tt>attribute?</tt>. So
+      # if the predicate returns +true+ the attribute will become +false+. This
+      # method toggles directly the underlying value without calling any setter.
+      # Returns +self+.
+      #
+      # @example
+      #   user = User.first
+      #   user.admin? # => false
+      #   user.toggle(:admin)
+      #   user.admin? # => true
+      def toggle(attribute)
+        attributes[attribute] = !public_send("#{attribute}?")
+        self
+      end
+
+      # Wrapper around #toggle that saves the resource. Saving is subjected to
+      # validation checks. Returns +true+ if the record could be saved.
+      def toggle!(attribute)
+        toggle(attribute) && save
+      end
+
+      # Refetches the resource
+      #
+      # This method finds the resource by its primary key (which could be
+      # assigned manually) and modifies the object in-place.
+      #
+      # @example
+      #   user = User.find(1)
+      #   # => #<User(users/1) id=1 name="Tobias Fünke">
+      #   user.name = "Oops"
+      #   user.reload # Fetched again via GET "/users/1"
+      #   # => #<User(users/1) id=1 name="Tobias Fünke">
+      def reload(options = nil)
+        fresh_object = self.class.find(id)
+        assign_attributes(fresh_object.attributes)
+        self
+      end
+
+      # Uses parsed response to assign attributes and metadata
+      #
+      # @private
+      def load_from_parsed_data(parsed_data)
+        data = parsed_data[:data]
+        assign_attributes(self.class.parse(data)) if data.any?
+        @metadata = parsed_data[:metadata]
+        @response_errors = parsed_data[:errors]
+      end
+
       module ClassMethods
         # Create a new chainable scope
         #
@@ -121,10 +192,8 @@ module Her
             instance_exec(*args, &code)
           end
 
-          # Add the scope method to the Relation class
-          Relation.instance_eval do
-            define_method(name) { |*args| instance_exec(*args, &code) }
-          end
+          # Add the scope method to the default/blank relation
+          scoped.define_singleton_method(name) { |*args| instance_exec(*args, &code) }
         end
 
         # @private
@@ -143,14 +212,15 @@ module Her
         #
         #   User.all # Called via GET "/users?admin=1"
         #   User.new.admin # => 1
-        def default_scope(block=nil)
+        def default_scope(block = nil)
           @_her_default_scope ||= (!respond_to?(:default_scope) && superclass.respond_to?(:default_scope)) ? superclass.default_scope : scoped
           @_her_default_scope = @_her_default_scope.instance_exec(&block) unless block.nil?
           @_her_default_scope
         end
 
         # Delegate the following methods to `scoped`
-        [:all, :where, :create, :create!, :build, :find, :find_by, :first, :first_or_create, :first_or_initialize].each do |method|
+        [:all, :where, :create, :create!, :build, :find, :find_by, :first, :find_or_create_by,
+         :find_or_initialize_by, :first_or_create, :first_or_initialize].each do |method|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{method}(*params)
               scoped.send(#{method.to_sym.inspect}, *params)
@@ -184,7 +254,9 @@ module Her
             data = parse(parsed_data[:data])
             metadata = parsed_data[:metadata]
             response_errors = parsed_data[:errors]
-            new(data.merge(:_destroyed => response.success?, :metadata => metadata, :response_errors => response_errors))
+            record = new(data.merge(:_destroyed => response.success?, :metadata => metadata))
+            record.response_errors = response_errors
+            record
           end
         end
 
@@ -206,23 +278,23 @@ module Her
         # If the request_new_object_on_build flag is set, the new object is requested via API.
         def build(attributes = {})
           params = attributes
-          return self.new(params) unless self.request_new_object_on_build?
+          return new(params) unless request_new_object_on_build?
 
-          path = self.build_request_path(params.merge(self.primary_key => 'new'))
-          method = self.method_for(:new)
+          path = build_request_path(params.merge(primary_key => 'new'))
+          method = method_for(:new)
 
           resource = nil
-          self.request(params.merge(:_method => method, :_path => path, :_headers => request_headers)) do |parsed_data, response|
+          request(params.merge(:_method => method, :_path => path, :_headers => request_headers)) do |parsed_data, response|
             if response.success?
-              resource = self.new_from_parsed_data(parsed_data)
+              resource = new_from_parsed_data(parsed_data)
             end
           end
           resource
         end
 
-        private
         # @private
         def blank_relation
+          @blank_relation ||= superclass.blank_relation.clone.tap { |r| r.parent = self } if superclass.respond_to?(:blank_relation)
           @blank_relation ||= Relation.new(self)
         end
       end