her5 0.8.1

data/lib/her/json_api/model.rb

@@ -0,0 +1,57 @@
+module Her
+  module JsonApi
+    module Model
+      
+      def self.included(klass)
+        klass.class_eval do
+          include Her::Model
+
+          # [:parse_root_in_json, :include_root_in_json, :root_element, :primary_key].each do |method|
+          #   define_method method do |*args|
+          #     raise NoMethodError, "Her::JsonApi::Model does not support the #{method} configuration option"
+          #   end
+          # end
+
+          method_for :update, :patch
+
+          @type = name.demodulize.tableize
+          
+          def self.parse(data)
+            begin
+              if data.has_key?(:attributes)
+                data.fetch(:attributes).merge(data.slice(:id))
+              else
+                data
+              end
+            rescue
+              nil
+            end
+          end
+
+
+          # For now our APIs are able to deliver jsonapi but not to digest it. We reply with standard rails parameters.
+          #
+          # def self.to_params(attributes, changes={})
+          #   request_data = { type: @type }.tap { |request_body|
+          #     attrs = attributes.dup.symbolize_keys.tap { |filtered_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
+          #     }
+          #     request_body[:id] = attrs.delete(:id) if attrs[:id]
+          #     request_body[:attributes] = attrs
+          #   }
+          #   { data: request_data }
+          # end
+
+          def self.type(type_name)
+            @type = type_name.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/her/middleware.rb

@@ -0,0 +1,12 @@
+require "her/middleware/parse_json"
+require "her/middleware/first_level_parse_json"
+require "her/middleware/second_level_parse_json"
+require "her/middleware/accept_json"
+
+module Her
+  module Middleware
+    DefaultParseJSON = FirstLevelParseJSON
+
+    autoload :JsonApiParser,   'her/middleware/json_api_parser'
+  end
+end

data/lib/her/middleware/accept_json.rb

@@ -0,0 +1,17 @@
+module Her
+  module Middleware
+    # This middleware adds a "Accept: application/json" HTTP header
+    class AcceptJSON < Faraday::Middleware
+      # @private
+      def add_header(headers)
+        headers.merge! "Accept" => "application/json"
+      end
+
+      # @private
+      def call(env)
+        add_header(env[:request_headers])
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/her/middleware/first_level_parse_json.rb

@@ -0,0 +1,36 @@
+module Her
+  module Middleware
+    # This middleware treat the received first-level JSON structure as the resource data.
+    class FirstLevelParseJSON < ParseJSON
+      # Parse the response body
+      #
+      # @param [String] body The response body
+      # @return [Mixed] the parsed response
+      # @private
+      def parse(body)
+        json = parse_json(body)
+        errors = json.delete(:errors) || {}
+        metadata = json.delete(:metadata) || {}
+        {
+          :data => json,
+          :errors => errors,
+          :metadata => metadata
+        }
+      end
+
+      # This method is triggered when the response has been received. It modifies
+      # the value of `env[:body]`.
+      #
+      # @param [Hash] env The response environment
+      # @private
+      def on_complete(env)
+        env[:body] = case env[:status]
+        when 204
+          parse('{}')
+        else
+          parse(env[:body])
+        end
+      end
+    end
+  end
+end

data/lib/her/middleware/json_api_parser.rb

@@ -0,0 +1,68 @@
+module Her
+  module Middleware
+    # This middleware requires the resource/collection
+    # data to be contained in the `data` key of the JSON object
+    class JsonApiParser < ParseJSON
+      # Parse the response body
+      #
+      # @param [String] body The response body
+      # @return [Mixed] the parsed response
+      # @private
+      def parse(body)
+        json = parse_json(body)
+
+        included = json.fetch(:included, [])
+        primary_data = json.fetch(:data, {})
+        resources = Array.wrap(primary_data)
+        resources.each do |resource|
+          if resource[:attributes]
+            resource.fetch(:attributes).merge!(build_relationships(resource, included))
+          end
+        end
+
+        {
+          :data => primary_data || {},
+          :errors => json[:errors] || [],
+          :metadata => json[:meta] || {},
+        }
+      end
+
+      def build_relationships(resource, included)
+        relationships = resource.fetch(:relationships, {})
+        {}.tap do |built|
+          relationships.each do |rel_name, linkage|
+            if linkage_data = linkage.fetch(:data, {})
+              built_relationship = if linkage_data.is_a? Array
+                linkage_data.map { |l| included.detect { |i| i && i.values_at(:id, :type) == l.values_at(:id, :type) } }
+              else
+                included.detect { |i| i && i.values_at(:id, :type) == linkage_data.values_at(:id, :type) }
+              end
+
+              built[rel_name] = built_relationship if built_relationship
+            end
+          end
+        end
+      end
+
+      # This method is triggered when the response has been received. It modifies
+      # the value of `env[:body]`.
+      #
+      # @param [Hash] env The response environment
+      # @private
+      def on_complete(env)
+        assert_response_ok(env[:status], env[:body])
+        env[:body] = case env[:status]
+        when 204
+          {
+            :data => {},
+            :errors => [],
+            :metadata => {},
+          }
+        else
+          parse(env[:body])
+        end
+      end
+      
+    end
+  end
+end

data/lib/her/middleware/parse_json.rb

@@ -0,0 +1,28 @@
+module Her
+  module Middleware
+    class ParseJSON < Faraday::Response::Middleware
+      # @private
+      def parse_json(body = nil)
+        body = '{}' if body.blank?
+        message = "Response from the API must behave like a Hash or an Array (last JSON response was #{body.inspect})"
+
+        json = begin
+          MultiJson.load(body, :symbolize_keys => true)
+        rescue MultiJson::LoadError
+          raise Her::Errors::ParseError, message
+        end
+
+        raise Her::Errors::ParseError, message unless json.is_a?(Hash) or json.is_a?(Array)
+
+        json
+      end
+      
+      def assert_response_ok(status, message)
+        if exception_class = Her::Errors.exception_class_for_status(status)
+          raise exception_class, message
+        end
+      end
+      
+    end
+  end
+end

data/lib/her/middleware/second_level_parse_json.rb

@@ -0,0 +1,36 @@
+module Her
+  module Middleware
+    # This middleware expects the resource/collection data to be contained in the `data`
+    # key of the JSON object
+    class SecondLevelParseJSON < ParseJSON
+      # Parse the response body
+      #
+      # @param [String] body The response body
+      # @return [Mixed] the parsed response
+      # @private
+      def parse(body)
+        json = parse_json(body)
+
+        {
+          :data => json[:data],
+          :errors => json[:errors],
+          :metadata => json[:metadata]
+        }
+      end
+
+      # This method is triggered when the response has been received. It modifies
+      # the value of `env[:body]`.
+      #
+      # @param [Hash] env The response environment
+      # @private
+      def on_complete(env)
+        env[:body] = case env[:status]
+        when 204
+          parse('{}')
+        else
+          parse(env[:body])
+        end
+      end
+    end
+  end
+end

data/lib/her/model.rb

@@ -0,0 +1,75 @@
+require "her/model/base"
+require "her/model/deprecated_methods"
+require "her/model/http"
+require "her/model/attributes"
+require "her/model/relation"
+require "her/model/orm"
+require "her/model/parse"
+require "her/model/associations"
+require "her/model/introspection"
+require "her/model/paths"
+require "her/model/nested_attributes"
+require "active_model"
+
+module Her
+  # This module is the main element of Her. After creating a Her::API object,
+  # include this module in your models to get a few magic methods defined in them.
+  #
+  # @example
+  #   class User
+  #     include Her::Model
+  #   end
+  #
+  #   @user = User.new(:name => "Rémi")
+  #   @user.save
+  module Model
+    extend ActiveSupport::Concern
+
+    # Her modules
+    include Her::Model::Base
+    include Her::Model::DeprecatedMethods
+    include Her::Model::Attributes
+    include Her::Model::ORM
+    include Her::Model::HTTP
+    include Her::Model::Parse
+    include Her::Model::Introspection
+    include Her::Model::Paths
+    include Her::Model::Associations
+    include Her::Model::NestedAttributes
+
+    # Supported ActiveModel modules
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Validations
+    include ActiveModel::Validations::Callbacks
+    include ActiveModel::Conversion
+    include ActiveModel::Dirty
+
+    # Class methods
+    included do
+      # Assign the default API
+      use_api Her::API.default_api
+      method_for :create, :post
+      method_for :update, :put
+      method_for :find, :get
+      method_for :destroy, :delete
+      method_for :new, :get
+
+      # Define the default primary key
+      primary_key :id
+
+      # Define default storage accessors for errors and metadata
+      store_response_errors :response_errors
+      store_metadata :metadata
+
+      # Include ActiveModel naming methods
+      extend ActiveModel::Translation
+
+      # Configure ActiveModel callbacks
+      extend ActiveModel::Callbacks
+      define_model_callbacks :create, :update, :save, :find, :destroy, :initialize
+
+      # Define matchers for attr? and attr= methods
+      define_attribute_method_matchers
+    end
+  end
+end

data/lib/her/model/associations.rb

@@ -0,0 +1,141 @@
+require "her/model/associations/association"
+require "her/model/associations/association_proxy"
+require "her/model/associations/belongs_to_association"
+require "her/model/associations/has_many_association"
+require "her/model/associations/has_one_association"
+
+module Her
+  module Model
+    # This module adds associations to models
+    module Associations
+      extend ActiveSupport::Concern
+
+      # Returns true if the model has a association_name association, false otherwise.
+      #
+      # @private
+      def has_association?(association_name)
+        associations = self.class.associations.values.flatten.map { |r| r[:name] }
+        associations.include?(association_name)
+      end
+
+      # Returns the resource/collection corresponding to the association_name association.
+      #
+      # @private
+      def get_association(association_name)
+        send(association_name) if has_association?(association_name)
+      end
+
+      module ClassMethods
+        # Return @_her_associations, lazily initialized with copy of the
+        # superclass' her_associations, or an empty hash.
+        #
+        # @private
+        def associations
+          @_her_associations ||= begin
+            superclass.respond_to?(:associations) ? superclass.associations.dup : Hash.new { |h,k| h[k] = [] }
+          end
+        end
+
+        # @private
+        def association_names
+          associations.inject([]) { |memo, (name, details)| memo << details }.flatten.map { |a| a[:name] }
+        end
+
+        # @private
+        def association_keys
+          associations.inject([]) { |memo, (name, details)| memo << details }.flatten.map { |a| a[:data_key] }
+        end
+
+        # Parse associations data after initializing a new object
+        #
+        # @private
+        def parse_associations(data)
+          associations.each_pair do |type, definitions|
+            definitions.each do |association|
+              association_class = "her/model/associations/#{type}_association".classify.constantize
+              data.merge! association_class.parse(association, self, data)
+            end
+          end
+
+          data
+        end
+
+        # Define an *has_many* association.
+        #
+        # @param [Symbol] name The name of the method added to resources
+        # @param [Hash] opts Options
+        # @option opts [String] :class_name The name of the class to map objects to
+        # @option opts [Symbol] :data_key The attribute where the data is stored
+        # @option opts [Path] :path The relative path where to fetch the data (defaults to `/{name}`)
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     has_many :articles
+        #   end
+        #
+        #   class Article
+        #     include Her::Model
+        #   end
+        #
+        #   @user = User.find(1)
+        #   @user.articles # => [#<Article(articles/2) id=2 title="Hello world.">]
+        #   # Fetched via GET "/users/1/articles"
+        def has_many(name, opts={})
+          Her::Model::Associations::HasManyAssociation.attach(self, name, opts)
+        end
+
+        # Define an *has_one* association.
+        #
+        # @param [Symbol] name The name of the method added to resources
+        # @param [Hash] opts Options
+        # @option opts [String] :class_name The name of the class to map objects to
+        # @option opts [Symbol] :data_key The attribute where the data is stored
+        # @option opts [Path] :path The relative path where to fetch the data (defaults to `/{name}`)
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     has_one :organization
+        #   end
+        #
+        #   class Organization
+        #     include Her::Model
+        #   end
+        #
+        #   @user = User.find(1)
+        #   @user.organization # => #<Organization(organizations/2) id=2 name="Foobar Inc.">
+        #   # Fetched via GET "/users/1/organization"
+        def has_one(name, opts={})
+          Her::Model::Associations::HasOneAssociation.attach(self, name, opts)
+        end
+
+        # Define a *belongs_to* association.
+        #
+        # @param [Symbol] name The name of the method added to resources
+        # @param [Hash] opts Options
+        # @option opts [String] :class_name The name of the class to map objects to
+        # @option opts [Symbol] :data_key The attribute where the data is stored
+        # @option opts [Path] :path The relative path where to fetch the data (defaults to `/{class_name}.pluralize/{id}`)
+        # @option opts [Symbol] :foreign_key The foreign key used to build the `:id` part of the path (defaults to `{name}_id`)
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     belongs_to :team, :class_name => "Group"
+        #   end
+        #
+        #   class Group
+        #     include Her::Model
+        #   end
+        #
+        #   @user = User.find(1) # => #<User(users/1) id=1 team_id=2 name="Tobias">
+        #   @user.team # => #<Team(teams/2) id=2 name="Developers">
+        #   # Fetched via GET "/teams/2"
+        def belongs_to(name, opts={})
+          Her::Model::Associations::BelongsToAssociation.attach(self, name, opts)
+        end
+      end
+    end
+  end
+end