test_track_rails_client 0.9.7 → 0.9.8

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

@@ -0,0 +1,219 @@
+module Her
+  module Model
+    # This module adds ORM-like capabilities to the model
+    module ORM
+      extend ActiveSupport::Concern
+
+      # Return `true` if a resource was not saved yet
+      def new?
+        id.nil?
+      end
+      alias new_record? new?
+
+      # Return `true` if a resource is not `#new?`
+      def persisted?
+        !new?
+      end
+
+      # Return whether the object has been destroyed
+      def destroyed?
+        @destroyed == true
+      end
+
+      # Save a resource and return `false` if the response is not a successful one or
+      # if there are errors in the resource. Otherwise, return the newly updated resource
+      #
+      # @example Save a resource after fetching it
+      #   @user = User.find(1)
+      #   # Fetched via GET "/users/1"
+      #   @user.fullname = "Tobias Fünke"
+      #   @user.save
+      #   # Called via PUT "/users/1"
+      #
+      # @example Save a new resource by creating it
+      #   @user = User.new({ :fullname => "Tobias Fünke" })
+      #   @user.save
+      #   # Called via POST "/users"
+      def save
+        callback = new? ? :create : :update
+        method = self.class.method_for(callback)
+
+        run_callbacks callback do
+          run_callbacks :save do
+            params = to_params
+            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)
+
+              return false if !response.success? || @response_errors.any?
+              if self.changed_attributes.present?
+                @previously_changed = self.changed_attributes.clone
+                self.changed_attributes.clear
+              end
+            end
+          end
+        end
+
+        true
+      end
+
+      # Similar to save(), except that ResourceInvalid is raised if the save fails
+      def save!
+        if !self.save
+          raise Her::Errors::ResponseError.for(status_code).new("Remote validation of #{self.class.name} failed with a #{status_code}: #{full_error_messages}")
+        end
+        true
+      end
+
+      # Destroy a resource
+      #
+      # @example
+      #   @user = User.find(1)
+      #   @user.destroy
+      #   # Called via DELETE "/users/1"
+      def destroy
+        method = self.class.method_for(:destroy)
+        run_callbacks :destroy do
+          self.class.request(:_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]
+            @destroyed = true
+          end
+        end
+        self
+      end
+
+      def full_error_messages
+          self.response_errors.map do |field, messages|
+            "#{field} #{messages.join(', ')}"
+          end.join('. ')
+      end
+
+      module ClassMethods
+        # Create a new chainable scope
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #
+        #     scope :admins, lambda { where(:admin => 1) }
+        #     scope :page, lambda { |page| where(:page => page) }
+        #   enc
+        #
+        #   User.admins # Called via GET "/users?admin=1"
+        #   User.page(2).all # Called via GET "/users?page=2"
+        def scope(name, code)
+          # Add the scope method to the class
+          (class << self; self end).send(:define_method, name) do |*args|
+            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
+        end
+
+        # @private
+        def scoped
+          @_her_default_scope || blank_relation
+        end
+
+        # Define the default scope for the model
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #
+        #     default_scope lambda { where(:admin => 1) }
+        #   enc
+        #
+        #   User.all # Called via GET "/users?admin=1"
+        #   User.new.admin # => 1
+        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, :build, :find, :find_by, :first, :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)
+            end
+          RUBY
+        end
+
+        delegate :with_request_headers, :request_headers, :with_request_options, :request_options, to: :scoped
+
+        # Save an existing resource and return it
+        #
+        # @example
+        #   @user = User.save_existing(1, { :fullname => "Tobias Fünke" })
+        #   # Called via PUT "/users/1"
+        def save_existing(id, params, headers = {}, options = {})
+          resource = new(params.merge(primary_key => id))
+          resource.request_headers = headers
+          resource.request_options = options
+          resource.save
+          resource
+        end
+
+        # Destroy an existing resource
+        #
+        # @example
+        #   User.destroy_existing(1)
+        #   # Called via DELETE "/users/1"
+        def destroy_existing(id, params = {}, headers = {}, options = {})
+          request(params.merge(:_method => method_for(:destroy), :_headers => headers, :_options => options, :_path => build_request_path(params.merge(primary_key => id)))) do |parsed_data, response|
+            raise Her::Errors::ResponseError.for(response.status).new("Request against #{name} returned a #{response.status}") if response.status >= 400
+            new(parse(parsed_data[:data]).merge(:_destroyed => true))
+          end
+        end
+
+        # Return or change the HTTP method used to create or update records
+        #
+        # @param [Symbol, String] action The behavior in question (`:create` or `:update`)
+        # @param [Symbol, String] method The HTTP method to use (`'PUT'`, `:post`, etc.)
+        def method_for(action = nil, method = nil)
+          @method_for ||= (superclass.respond_to?(:method_for) ? superclass.method_for : {})
+          return @method_for if action.nil?
+
+          action = action.to_s.downcase.to_sym
+
+          return @method_for[action] if method.nil?
+          @method_for[action] = method.to_s.downcase.to_sym
+        end
+
+        # Build a new resource with the given attributes.
+        # 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?
+
+          path = self.build_request_path(params.merge(self.primary_key => 'new'))
+          method = self.method_for(:new)
+
+          resource = nil
+          self.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)
+            end
+          end
+          resource
+        end
+
+        private
+        # @private
+        def blank_relation
+          @blank_relation ||= Relation.new(self)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,215 @@
+module Her
+  module Model
+    # This module handles resource data parsing at the model level (after the parsing middleware)
+    module Parse
+      extend ActiveSupport::Concern
+
+      # Convert into a hash of request parameters, based on `include_root_in_json`.
+      #
+      # @example
+      #   @user.to_params
+      #   # => { :id => 1, :name => 'John Smith' }
+      def to_params
+        self.class.to_params(self.attributes, self.changes)
+      end
+
+      module ClassMethods
+        # Parse data before assigning it to a resource, based on `parse_root_in_json`.
+        #
+        # @param [Hash] data
+        # @private
+        def parse(data)
+          if parse_root_in_json? && root_element_included?(data)
+            if json_api_format?
+              data.fetch(parsed_root_element).first
+            else
+              data.fetch(parsed_root_element) { data }
+            end
+          else
+            data
+          end
+        end
+
+        # @private
+        def to_params(attributes, changes={})
+          filtered_attributes = attributes.dup.symbolize_keys
+          filtered_attributes.merge!(embeded_params(attributes))
+          if her_api.options[:send_only_modified_attributes]
+            filtered_attributes = changes.symbolize_keys.keys.inject({}) do |hash, attribute|
+              hash[attribute] = filtered_attributes[attribute]
+              hash
+            end
+          end
+
+          if include_root_in_json?
+            if json_api_format?
+              { included_root_element => [filtered_attributes] }
+            else
+              { included_root_element => filtered_attributes }
+            end
+          else
+            filtered_attributes
+          end
+        end
+
+
+        # @private
+        # TODO: Handle has_one
+        def embeded_params(attributes)
+          associations[:has_many].select { |a| attributes.include?(a[:data_key])}.compact.inject({}) do |hash, association|
+            params = attributes[association[:data_key]].map(&:to_params)
+            if association[:class_name].constantize.include_root_in_json?
+              root = association[:class_name].constantize.root_element
+              hash[association[:data_key]] = params.map { |n| n[root] }
+            else
+              hash[association[:data_key]] = params
+            end
+            hash
+          end
+        end
+
+        # Return or change the value of `include_root_in_json`
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     include_root_in_json true
+        #   end
+        def include_root_in_json(value, options = {})
+          @_her_include_root_in_json = value
+          @_her_include_root_in_json_format = options[:format]
+        end
+
+        # Return or change the value of `parse_root_in_json`
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     parse_root_in_json true
+        #   end
+        #
+        #   class User
+        #     include Her::Model
+        #     parse_root_in_json true, format: :active_model_serializers
+        #   end
+        #
+        #   class User
+        #     include Her::Model
+        #     parse_root_in_json true, format: :json_api
+        #   end
+        def parse_root_in_json(value, options = {})
+          @_her_parse_root_in_json = value
+          @_her_parse_root_in_json_format = options[:format]
+        end
+
+        # Return or change the value of `request_new_object_on_build`
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     request_new_object_on_build true
+        #   end
+        def request_new_object_on_build(value = nil)
+          @_her_request_new_object_on_build = value
+        end
+
+        # Return or change the value of `root_element`. Always defaults to the base name of the class.
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     parse_root_in_json true
+        #     root_element :huh
+        #   end
+        #
+        #   user = User.find(1) # { :huh => { :id => 1, :name => "Tobias" } }
+        #   user.name # => "Tobias"
+        def root_element(value = nil)
+          if value.nil?
+            if json_api_format?
+              @_her_root_element ||= self.name.split("::").last.pluralize.underscore.to_sym
+            else
+              @_her_root_element ||= self.name.split("::").last.underscore.to_sym
+            end
+          else
+            @_her_root_element = value.to_sym
+          end
+        end
+
+        # @private
+        def root_element_included?(data)
+          data.keys.to_s.include? @_her_root_element.to_s
+        end
+
+        # @private
+        def included_root_element
+          include_root_in_json? == true ? root_element : include_root_in_json?
+        end
+
+        # Extract an array from the request data
+        #
+        # @example
+        #   # with parse_root_in_json true, :format => :active_model_serializers
+        #   class User
+        #     include Her::Model
+        #     parse_root_in_json true, :format => :active_model_serializers
+        #   end
+        #
+        #   users = User.all # { :users => [ { :id => 1, :name => "Tobias" } ] }
+        #   users.first.name # => "Tobias"
+        #
+        #   # without parse_root_in_json
+        #   class User
+        #     include Her::Model
+        #   end
+        #
+        #   users = User.all # [ { :id => 1, :name => "Tobias" } ]
+        #   users.first.name # => "Tobias"
+        #
+        # @private
+        def extract_array(request_data)
+          if request_data[:data].is_a?(Hash) && (active_model_serializers_format? || json_api_format?)
+            request_data[:data][pluralized_parsed_root_element]
+          else
+            request_data[:data]
+          end
+        end
+
+        # @private
+        def pluralized_parsed_root_element
+          parsed_root_element.to_s.pluralize.to_sym
+        end
+
+        # @private
+        def parsed_root_element
+          parse_root_in_json? == true ? root_element : parse_root_in_json?
+        end
+
+        # @private
+        def active_model_serializers_format?
+          @_her_parse_root_in_json_format == :active_model_serializers || (superclass.respond_to?(:active_model_serializers_format?) && superclass.active_model_serializers_format?)
+        end
+
+        # @private
+        def json_api_format?
+          @_her_parse_root_in_json_format == :json_api || (superclass.respond_to?(:json_api_format?) && superclass.json_api_format?)
+        end
+
+        # @private
+        def request_new_object_on_build?
+          @_her_request_new_object_on_build || (superclass.respond_to?(:request_new_object_on_build?) && superclass.request_new_object_on_build?)
+        end
+
+        # @private
+        def include_root_in_json?
+          @_her_include_root_in_json || (superclass.respond_to?(:include_root_in_json?) && superclass.include_root_in_json?)
+        end
+
+        # @private
+        def parse_root_in_json?
+          @_her_parse_root_in_json || (superclass.respond_to?(:parse_root_in_json?) && superclass.parse_root_in_json?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+module Her
+  module Model
+    module Paths
+      extend ActiveSupport::Concern
+      # Return a path based on the collection path and a resource data
+      #
+      # @example
+      #   class User
+      #     include Her::Model
+      #     collection_path "/utilisateurs"
+      #   end
+      #
+      #   User.find(1) # Fetched via GET /utilisateurs/1
+      #
+      # @param [Hash] params An optional set of additional parameters for
+      #   path construction. These will not override attributes of the resource.
+      def request_path(params = {})
+        self.class.build_request_path(params.merge(attributes.dup))
+      end
+
+      module ClassMethods
+
+        # Define the primary key field that will be used to find and save records
+        #
+        # @example
+        #  class User
+        #    include Her::Model
+        #    primary_key 'UserId'
+        #  end
+        #
+        # @param [Symbol] value
+        def primary_key(value = nil)
+          @_her_primary_key ||= begin
+            superclass.primary_key if superclass.respond_to?(:primary_key)
+          end
+
+          return @_her_primary_key unless value
+          @_her_primary_key = value.to_sym
+        end
+
+        # Defines a custom collection path for the resource
+        #
+        # @example
+        #  class User
+        #    include Her::Model
+        #    collection_path "/users"
+        #  end
+        def collection_path(path = nil)
+          if path.nil?
+            @_her_collection_path ||= root_element.to_s.pluralize
+          else
+            @_her_collection_path = path
+            @_her_resource_path = "#{path}/:id"
+          end
+        end
+
+        # Defines a custom resource path for the resource
+        #
+        # @example
+        #  class User
+        #    include Her::Model
+        #    resource_path "/users/:id"
+        #  end
+        #
+        # Note that, if used in combination with resource_path, you may specify
+        # either the real primary key or the string ':id'. For example:
+        #
+        # @example
+        #  class User
+        #    include Her::Model
+        #    primary_key 'user_id'
+        #
+        #    # This works because we'll have a user_id attribute
+        #    resource_path '/users/:user_id'
+        #
+        #    # This works because we replace :id with :user_id
+        #    resource_path '/users/:id'
+        #  end
+        #
+        def resource_path(path = nil)
+          if path.nil?
+            @_her_resource_path ||= "#{root_element.to_s.pluralize}/:id"
+          else
+            @_her_resource_path = path
+          end
+        end
+
+        # Return a custom path based on the collection path and variable parameters
+        #
+        # @private
+        def build_request_path(path=nil, parameters={})
+          parameters = parameters.try(:with_indifferent_access)
+
+          unless path.is_a?(String)
+            parameters = path.try(:with_indifferent_access) || parameters
+            path =
+              if parameters.include?(primary_key) && parameters[primary_key] && !parameters[primary_key].kind_of?(Array)
+                resource_path.dup
+              else
+                collection_path.dup
+              end
+
+            # Replace :id with our actual primary key
+            path.gsub!(/(\A|\/):id(\Z|\/)/, "\\1:#{primary_key}\\2")
+          end
+
+          path.gsub(/:([\w_]+)/) do
+            # Look for :key or :_key, otherwise raise an exception
+            key = $1.to_sym
+            value = parameters.delete(key) || parameters.delete(:"_#{key}")
+            if value
+              Faraday::Utils.escape value
+            else
+              raise(Her::Errors::PathError.new("Missing :_#{$1} parameter to build the request path. Path is `#{path}`. Parameters are `#{parameters.symbolize_keys.inspect}`.", $1))
+            end
+          end
+        end
+
+        # @private
+        def build_request_path_from_string_or_symbol(path, params={})
+          path.is_a?(Symbol) ? "#{build_request_path(params)}/#{path}" : path
+        end
+      end
+    end
+  end
+end