test_track_rails_client 0.9.7 → 0.9.8

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

@@ -0,0 +1,304 @@
+module Her
+  module Model
+    # This module handles all methods related to model attributes
+    module Attributes
+      extend ActiveSupport::Concern
+
+      ATTRIBUTE_BLACKLIST = [:attribute_changed_in_place?].to_set
+
+      # Initialize a new object with data
+      #
+      # @param [Hash] attributes The attributes to initialize the object with
+      # @option attributes [Hash,Array] :_metadata
+      # @option attributes [Hash,Array] :_errors
+      # @option attributes [Boolean] :_destroyed
+      #
+      # @example
+      #   class User
+      #     include Her::Model
+      #   end
+      #
+      #  User.new(name: "Tobias") # => #<User name="Tobias">
+      def initialize(attributes={})
+        attributes ||= {}
+        @metadata = attributes.delete(:_metadata) || {}
+        @response_errors = attributes.delete(:_errors) || {}
+        @destroyed = attributes.delete(:_destroyed) || false
+
+        attributes = self.class.default_scope.apply_to(attributes)
+        assign_attributes(attributes)
+        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)
+          # Extract the attribute
+          attribute = method.to_s.sub(/[?=]$/, '')
+
+          # Create a new `attribute` methods set
+          self.class.attributes(*attribute)
+
+          # Resend the method!
+          send(method, *args, &blk)
+        else
+          super
+        end
+      end
+
+      # @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
+      end
+
+      # Assign new attributes to a resource
+      #
+      # @example
+      #   class User
+      #     include Her::Model
+      #   end
+      #
+      #   user = User.find(1) # => #<User id=1 name="Tobias">
+      #   user.assign_attributes(name: "Lindsay")
+      #   user.changes # => { :name => ["Tobias", "Lindsay"] }
+      def assign_attributes(new_attributes)
+        @attributes ||= attributes
+        # Use setter methods first
+        unset_attributes = Her::Model::Attributes.use_setter_methods(self, new_attributes)
+
+        # Then translate attributes of associations into association instances
+        parsed_attributes = self.class.parse_associations(unset_attributes)
+
+        # Then merge the parsed_data into @attributes.
+        @attributes.merge!(parsed_attributes)
+      end
+      alias attributes= assign_attributes
+
+      def attributes
+        @attributes ||= HashWithIndifferentAccess.new
+      end
+
+      # Handles returning true for the accessible attributes
+      #
+      # @private
+      def has_attribute?(attribute_name)
+        @attributes.include?(attribute_name)
+      end
+
+      # Handles returning data for a specific attribute
+      #
+      # @private
+      def get_attribute(attribute_name)
+        @attributes[attribute_name]
+      end
+      alias attribute get_attribute
+
+      # Return the value of the model `primary_key` attribute
+      def id
+        @attributes[self.class.primary_key]
+      end
+
+      # 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
+      end
+
+      # Delegate to the == method
+      #
+      # @private
+      def eql?(other)
+        self == other
+      end
+
+      # Delegate to @attributes, allowing models to act correctly in code like:
+      #     [ Model.find(1), Model.find(1) ].uniq # => [ Model.find(1) ]
+      # @private
+      def hash
+        @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
+      end
+
+      # Check attribute value to be present (ActiveModel convention method).
+      #
+      # @private
+      def attribute?(attribute)
+        @attributes.include?(attribute) && @attributes[attribute].present?
+      end
+
+      module ClassMethods
+        # 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)
+        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])
+        end
+
+        # Define attribute method matchers to automatically define them using ActiveModel's define_attribute_methods.
+        #
+        # @private
+        def define_attribute_method_matchers
+          attribute_method_suffix '='
+          attribute_method_suffix '?'
+        end
+
+        # 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
+        end
+
+        # Define the attributes that will be used to track dirty attributes and validations
+        #
+        # @param [Array] attributes
+        # @example
+        #   class User
+        #     include Her::Model
+        #     attributes :name, :email
+        #   end
+        def attributes(*attributes)
+          attribute_methods_mutex.synchronize do
+            define_attribute_methods attributes
+          end
+        end
+
+        # Define the accessor in which the API response errors (obtained from the parsing middleware) will be stored
+        #
+        # @param [Symbol] store_response_errors
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     store_response_errors :server_errors
+        #   end
+        def store_response_errors(value = nil)
+          store_her_data(:response_errors, value)
+        end
+
+        # Define the accessor in which the API response metadata (obtained from the parsing middleware) will be stored
+        #
+        # @param [Symbol] store_metadata
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     store_metadata :server_data
+        #   end
+        def store_metadata(value = nil)
+          store_her_data(:metadata, value)
+        end
+
+        # @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
+          end
+        end
+
+        private
+        # @private
+        def store_her_data(name, value)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            if @_her_store_#{name} && value.present?
+              remove_method @_her_store_#{name}.to_sym
+              remove_method @_her_store_#{name}.to_s + '='
+            end
+
+            @_her_store_#{name} ||= begin
+              superclass.store_#{name} if superclass.respond_to?(:store_#{name})
+            end
+
+            return @_her_store_#{name} unless value
+            @_her_store_#{name} = value
+
+            define_method(value) { @#{name} }
+            define_method(value.to_s+'=') { |value| @#{name} = value }
+          RUBY
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Her
+  module Model
+    # This module includes basic functionnality to Her::Model
+    module Base
+      extend ActiveSupport::Concern
+
+      # Returns true if attribute_name is
+      # * in resource attributes
+      # * an association
+      #
+      # @private
+      def has_key?(attribute_name)
+        has_attribute?(attribute_name) ||
+        has_association?(attribute_name)
+      end
+
+      # Returns
+      # * the value of the attribute_name attribute if it's in orm data
+      # * the resource/collection corrsponding to attribute_name if it's an association
+      #
+      # @private
+      def [](attribute_name)
+        get_attribute(attribute_name) ||
+        get_association(attribute_name)
+      end
+
+      # @private
+      def singularized_resource_name
+        self.class.name.split('::').last.tableize.singularize
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Her
+  module Model
+    # @private
+    module DeprecatedMethods
+      extend ActiveSupport::Concern
+
+      def self.deprecate!(old, new, object, *args)
+        line = begin
+          raise StandardError
+        rescue StandardError => e
+          e.backtrace[2]
+        end
+
+        warn "#{line} - The `#{old}` method is deprecated and may be removed soon. Please update your code with `#{new}` instead."
+        object.send(new, *args)
+      end
+
+      def data(*args)
+        Her::Model::DeprecatedMethods.deprecate! :data, :attributes, self, *args
+      end
+
+      def data=(*args)
+        Her::Model::DeprecatedMethods.deprecate! :data=, :attributes=, self, *args
+      end
+
+      def update_attributes(*args)
+        Her::Model::DeprecatedMethods.deprecate! :update_attributes, :assign_attributes, self, *args
+      end
+
+      def assign_data(*args)
+        Her::Model::DeprecatedMethods.deprecate! :assign_data, :assign_attributes, self, *args
+      end
+
+      def has_data?(*args)
+        Her::Model::DeprecatedMethods.deprecate! :has_data?, :has_attribute?, self, *args
+      end
+
+      def get_data(*args)
+        Her::Model::DeprecatedMethods.deprecate! :get_data, :get_attribute, self, *args
+      end
+
+      module ClassMethods
+        def has_relationship?(*args)
+          Her::Model::DeprecatedMethods.deprecate! :has_relationship?, :has_association?, self, *args
+        end
+
+        def get_relationship(*args)
+          Her::Model::DeprecatedMethods.deprecate! :get_relationship, :get_association, self, *args
+        end
+
+        def relationships(*args)
+          Her::Model::DeprecatedMethods.deprecate! :relationships, :associations, self, *args
+        end
+
+        def her_api(*args)
+          Her::Model::DeprecatedMethods.deprecate! :her_api, :use_api, self, *args
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+module Her
+  module Model
+    # This module interacts with Her::API to fetch HTTP data
+    module HTTP
+      extend ActiveSupport::Concern
+      METHODS = [:get, :post, :put, :patch, :delete]
+
+      # For each HTTP method, define these class methods:
+      #
+      # - <method>(path, params)
+      # - <method>_raw(path, params, &block)
+      # - <method>_collection(path, params, &block)
+      # - <method>_resource(path, params, &block)
+      # - custom_<method>(*paths)
+      #
+      # @example
+      #   class User
+      #     include Her::Model
+      #     custom_get :active
+      #   end
+      #
+      #   User.get(:popular) # GET "/users/popular"
+      #   User.active # GET "/users/active"
+      module ClassMethods
+        # Change which API the model will use to make its HTTP requests
+        #
+        # @example
+        #   secondary_api = Her::API.new :url => "https://api.example" do |connection|
+        #     connection.use Faraday::Request::UrlEncoded
+        #     connection.use Her::Middleware::DefaultParseJSON
+        #   end
+        #
+        #   class User
+        #     include Her::Model
+        #     use_api secondary_api
+        #   end
+        def use_api(value = nil)
+          @_her_use_api ||= begin
+            superclass.use_api if superclass.respond_to?(:use_api)
+          end
+
+          unless value
+            return (@_her_use_api.respond_to? :call) ? @_her_use_api.call : @_her_use_api
+          end
+
+          @_her_use_api = value
+        end
+
+        alias her_api use_api
+        alias uses_api use_api
+
+        # Main request wrapper around Her::API. Used to make custom request to the API.
+        #
+        # @private
+        def request(params={})
+          request = her_api.request(params)
+          status = request[:response].status
+
+          raise Her::Errors::RemoteServerError.new("Request against #{self.name} returned a #{status}") if status >= 500
+
+          if block_given?
+            yield request[:parsed_data], request[:response]
+          else
+            { :parsed_data => request[:parsed_data], :response => request[:response] }
+          end
+        end
+
+        METHODS.each do |method|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method}(path, params={})
+              path = build_request_path_from_string_or_symbol(path, params)
+              params = to_params(params) unless #{method.to_sym.inspect} == :get
+              send(:'#{method}_raw', path, params) do |parsed_data, response|
+                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])
+                end
+              end
+            end
+
+            def #{method}_raw(path, params={}, &block)
+              path = build_request_path_from_string_or_symbol(path, params)
+              request(params.merge(:_method => #{method.to_sym.inspect}, :_path => path), &block)
+            end
+
+            def #{method}_collection(path, params={})
+              path = build_request_path_from_string_or_symbol(path, params)
+              send(:'#{method}_raw', build_request_path_from_string_or_symbol(path, params), params) do |parsed_data, response|
+                new_collection(parsed_data)
+              end
+            end
+
+            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])
+              end
+            end
+
+            def custom_#{method}(*paths)
+              metaclass = (class << self; self; end)
+              opts = paths.last.is_a?(Hash) ? paths.pop : Hash.new
+
+              paths.each do |path|
+                metaclass.send(:define_method, path) do |*params|
+                  params = params.first || Hash.new
+                  send(#{method.to_sym.inspect}, path, params)
+                end
+              end
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Her
+  module Model
+    module Introspection
+      extend ActiveSupport::Concern
+      # Inspect an element, returns it for introspection.
+      #
+      # @example
+      #   class User
+      #     include Her::Model
+      #   end
+      #
+      #   @user = User.find(1)
+      #   p @user # => #<User(/users/1) id=1 name="Tobias Fünke">
+      def inspect
+        resource_path = begin
+          request_path
+        rescue Her::Errors::PathError => e
+          "<unknown path, missing `#{e.missing_parameter}`>"
+        end
+
+        "#<#{self.class}(#{resource_path}) #{attributes.keys.map { |k| "#{k}=#{attribute_for_inspect(send(k))}" }.join(" ")}>"
+      end
+
+      private
+      def attribute_for_inspect(value)
+        if value.is_a?(String) && value.length > 50
+          "#{value[0..50]}...".inspect
+        elsif value.is_a?(Date) || value.is_a?(Time)
+          %("#{value}")
+        else
+          value.inspect
+        end
+      end
+
+      # @private
+      module ClassMethods
+        # Finds a class at the same level as this one or at the global level.
+        #
+        # @private
+        def her_nearby_class(name)
+          her_sibling_class(name) || name.constantize rescue nil
+        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
+            @_her_sibling_class ||= Hash.new { Hash.new }
+            @_her_sibling_class[mod][name] ||= "#{mod.name}::#{name}".constantize rescue nil
+          end
+        end
+
+        # If available, returns the containing Module for this class.
+        #
+        # @private
+        def her_containing_module
+          return unless self.name =~ /::/
+          self.name.split("::")[0..-2].join("::").constantize
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Her
+  module Model
+    module NestedAttributes
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Allow nested attributes for an association
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #
+        #     has_one :role
+        #     accepts_nested_attributes_for :role
+        #   end
+        #
+        #   class Role
+        #     include Her::Model
+        #   end
+        #
+        #   user = User.new(name: "Tobias", role_attributes: { title: "moderator" })
+        #   user.role # => #<Role title="moderator">
+        def accepts_nested_attributes_for(*associations)
+          allowed_association_names = association_names
+
+          associations.each do |association_name|
+            unless allowed_association_names.include?(association_name)
+              raise Her::Errors::AssociationUnknownError.new("Unknown association name :#{association_name}")
+            end
+
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              if method_defined?(:#{association_name}_attributes=)
+                remove_method(:#{association_name}_attributes=)
+              end
+
+              def #{association_name}_attributes=(attributes)
+                self.#{association_name}.assign_nested_attributes(attributes)
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end