jsonapi-consumer 0.1.1 → 1.0.0

data/lib/jsonapi/consumer/formatter.rb

@@ -0,0 +1,145 @@
+# Taken form jsonapi_resources formatter
+
+require 'active_support/inflector'
+
+module JSONAPI::Consumer
+  class Formatter
+    class << self
+      def format(arg)
+        arg.to_s
+      end
+
+      def unformat(arg)
+         # We call to_s() here so that unformat consistently returns a string
+         # (instead of a symbol) regardless which Formatter subclass it is called on
+        arg.to_s
+      end
+
+      def formatter_for(format)
+        formatter_class_name = "JSONAPI::Consumer::#{format.to_s.camelize}Formatter"
+        formatter_class_name.safe_constantize
+      end
+    end
+  end
+
+  class KeyFormatter < Formatter
+    class << self
+      def format(key)
+        super
+      end
+
+      def format_keys(hash)
+        Hash[
+          hash.map do |key, value|
+            [format(key).to_sym, value]
+          end
+        ]
+      end
+
+      def unformat(formatted_key)
+        super
+      end
+    end
+  end
+
+  class RouteFormatter < Formatter
+    class << self
+      def format(route)
+        super
+      end
+
+      def unformat(formatted_route)
+        super
+      end
+    end
+  end
+
+  class ValueFormatter < Formatter
+    class << self
+      def format(raw_value)
+        super(raw_value)
+      end
+
+      def unformat(value)
+        super(value)
+      end
+
+      def value_formatter_for(type)
+        formatter_name = "#{type.to_s.camelize}Value"
+        formatter_for(formatter_name)
+      end
+    end
+  end
+
+  class UnderscoredKeyFormatter < KeyFormatter
+  end
+
+  class CamelizedKeyFormatter < KeyFormatter
+    class << self
+      def format(key)
+        super.camelize(:lower)
+      end
+
+      def unformat(formatted_key)
+        formatted_key.to_s.underscore
+      end
+    end
+  end
+
+  class DasherizedKeyFormatter < KeyFormatter
+    class << self
+      def format(key)
+        super.dasherize
+      end
+
+      def unformat(formatted_key)
+        formatted_key.to_s.underscore
+      end
+    end
+  end
+
+  class DefaultValueFormatter < ValueFormatter
+    class << self
+      def format(raw_value)
+        raw_value
+      end
+    end
+  end
+
+  class IdValueFormatter < ValueFormatter
+    class << self
+      def format(raw_value)
+        return if raw_value.nil?
+        raw_value.to_s
+      end
+    end
+  end
+
+  class UnderscoredRouteFormatter < RouteFormatter
+  end
+
+  class CamelizedRouteFormatter < RouteFormatter
+    class << self
+      def format(route)
+        super.camelize(:lower)
+      end
+
+      def unformat(formatted_route)
+        formatted_route.to_s.underscore
+      end
+    end
+  end
+
+  class DasherizedRouteFormatter < RouteFormatter
+    class << self
+      def format(route)
+        super.dasherize
+      end
+
+      def unformat(formatted_route)
+        formatted_route.to_s.underscore
+      end
+    end
+  end
+
+end

data/lib/jsonapi/consumer/helpers/callbacks.rb

@@ -0,0 +1,27 @@
+module JSONAPI::Consumer
+  module Helpers
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      included do
+        extend ActiveModel::Callbacks
+        define_model_callbacks :save, :destroy, :create, :update
+      end
+
+      def save
+        run_callbacks :save do
+          run_callbacks (persisted? ? :update : :create) do
+            super
+          end
+        end
+      end
+
+      def destroy
+        run_callbacks :destroy do
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/jsonapi/consumer/helpers/dirty.rb

@@ -0,0 +1,71 @@
+module JSONAPI::Consumer
+  module Helpers
+    module Dirty
+
+      def changed?
+        changed_attributes.present?
+      end
+
+      def changed
+        changed_attributes.keys
+      end
+
+      def changed_attributes
+        @changed_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      def clear_changes_information
+        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      def set_all_attributes_dirty
+        attributes.each do |k, v|
+          set_attribute_was(k, v)
+        end
+      end
+
+      def attribute_will_change!(attr)
+        return if attribute_changed?(attr)
+        set_attribute_was(attr, attributes[attr])
+      end
+
+      def set_attribute_was(attr, value)
+        begin
+          value = value.duplicable? ? value.clone : value
+          changed_attributes[attr] = value
+        rescue TypeError, NoMethodError
+        end
+      end
+
+      def attribute_was(attr) # :nodoc:
+        attribute_changed?(attr) ? changed_attributes[attr] : attributes[attr]
+      end
+
+      def attribute_changed?(attr)
+        changed.include?(attr.to_s)
+      end
+
+      def attribute_change(attr)
+        [changed_attributes[attr], attributes[attr]] if attribute_changed?(attr)
+      end
+
+      protected
+
+      def method_missing(method, *args, &block)
+        if method.to_s =~ /^(.*)_changed\?$/
+          has_attribute?($1) ? attribute_changed?($1) : nil
+        elsif method.to_s =~ /^(.*)_was$/
+          has_attribute?($1) ? attribute_was($1) : nil
+        else
+          super
+        end
+      end
+
+      def set_attribute(name, value)
+        attribute_will_change!(name) if value != attributes[name] || !attributes.has_key?(name)
+        super
+      end
+
+    end
+  end
+end

data/lib/jsonapi/consumer/helpers/dynamic_attributes.rb

@@ -0,0 +1,83 @@
+module JSONAPI::Consumer
+  module Helpers
+    module DynamicAttributes
+
+      def attributes
+        @attributes
+      end
+
+      def attributes=(attrs = {})
+        @attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+
+        return @attributes unless attrs.present?
+        attrs.each do |key, value|
+          send("#{key}=", value)
+        end
+      end
+
+      def [](key)
+        read_attribute(key)
+      end
+
+      def []=(key, value)
+        set_attribute(key, value)
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        if has_attribute?(method) || method.to_s.end_with?('=')
+          true
+        else
+          super
+        end
+      end
+
+      def has_attribute?(attr_name)
+        attributes.has_key?(attr_name)
+      end
+
+      protected
+
+      def method_missing(method, *args, &block)
+        if has_attribute?(method)
+          self.class.class_eval do
+            define_method(method) do
+              attributes[method]
+            end
+          end
+          return send(method)
+        end
+
+        normalized_method = safe_key_formatter.unformat(method.to_s)
+
+        if normalized_method.end_with?('=')
+          set_attribute(normalized_method[0..-2], args.first)
+        else
+          super
+        end
+      end
+
+      def read_attribute(name)
+        attributes.fetch(name, nil)
+      end
+
+      def set_attribute(name, value)
+        attributes[name] = value
+      end
+
+      def safe_key_formatter
+        @safe_key_formatter ||= (key_formatter || DefaultKeyFormatter.new)
+      end
+
+      def key_formatter
+        self.class.respond_to?(:key_formatter) && self.class.key_formatter
+      end
+
+      class DefaultKeyFormatter
+        def unformat(method)
+          method.to_s
+        end
+      end
+
+    end
+  end
+end

data/lib/jsonapi/consumer/helpers/uri.rb

@@ -0,0 +1,9 @@
+module JSONAPI::Consumer
+  module Helpers
+    module URI
+      def encode_part(part)
+        Addressable::URI.encode_component(part, Addressable::URI::CharacterClasses::UNRESERVED)
+      end
+    end
+  end
+end

data/lib/jsonapi/consumer/implementation.rb

@@ -0,0 +1,12 @@
+module JSONAPI::Consumer
+  class Implementation
+    attr_reader :version, :meta
+
+    def initialize(data)
+      # If the version member is not present, clients should assume the server implements at least version 1.0 of the specification.
+      @version = data.fetch("version", "1.0")
+
+      @meta = MetaData.new(data.fetch("meta", {}))
+    end
+  end
+end

data/lib/jsonapi/consumer/included_data.rb

@@ -0,0 +1,49 @@
+module JSONAPI::Consumer
+  class IncludedData
+    attr_reader :data
+
+    def initialize(result_set, data)
+      record_class = result_set.record_class
+      grouped_data = data.group_by{|datum| datum["type"]}
+      @data = grouped_data.inject({}) do |h, (type, records)|
+        klass = Utils.compute_type(record_class, record_class.key_formatter.unformat(type).singularize.classify)
+        h[type] = records.map do |datum|
+          params = klass.parser.parameters_from_resource(datum)
+          resource = klass.load(params)
+          resource.last_result_set = result_set
+          resource
+        end.index_by(&:id)
+        h
+      end
+    end
+
+    def data_for(method_name, definition)
+      # this method only returns an array. It's up to the caller to decide if it's going to return
+      # just the first element if it's a has_one relationship.
+      # If data is defined, pull the record from the included data
+      defined_data = definition["data"]
+      return nil unless defined_data
+      [defined_data].flatten.map do |link_def|
+        # should return a resource record of some type for this linked document
+        # even if there's no matching record included.
+        if data[link_def["type"]]
+          record_for(link_def)
+        else
+          # if there's no matching record in included then go and get it given the data
+          link_def["type"].underscore.classify.constantize.find(link_def["id"]).first
+        end
+      end
+    end
+
+    def has_link?(name)
+      data.has_key?(name.to_s)
+    end
+
+    private
+
+    # should return a resource record of some type for this linked document
+    def record_for(link_def)
+      data[link_def["type"]][link_def["id"]]
+    end
+  end
+end

data/lib/jsonapi/consumer/linking/links.rb

@@ -0,0 +1,22 @@
+module JSONAPI::Consumer
+  module Linking
+    class Links
+      include Helpers::DynamicAttributes
+
+      def initialize(links)
+        self.attributes = links
+      end
+
+      def present?
+        attributes.present?
+      end
+
+      protected
+
+      def set_attribute(name, value)
+        attributes[name] = value
+      end
+
+    end
+  end
+end

data/lib/jsonapi/consumer/linking/top_level_links.rb

@@ -0,0 +1,39 @@
+module JSONAPI::Consumer
+  module Linking
+    class TopLevelLinks
+
+      attr_reader :links, :record_class
+
+      def initialize(record_class, links)
+        @links = links
+        @record_class = record_class
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        links.has_key?(method.to_s) || super
+      end
+
+      def method_missing(method, *args)
+        if respond_to_missing?(method)
+          fetch_link(method)
+        else
+          super
+        end
+      end
+
+      def link_url_for(link_name)
+        link_definition = links.fetch(link_name.to_s)
+        if link_definition.is_a?(Hash)
+          link_definition["href"]
+        else
+          link_definition
+        end
+      end
+
+      def fetch_link(link_name)
+        return unless respond_to_missing?(link_name)
+        record_class.requestor.linked(link_url_for(link_name))
+      end
+    end
+  end
+end

data/lib/jsonapi/consumer/meta_data.rb

@@ -0,0 +1,19 @@
+module JSONAPI::Consumer
+  class MetaData
+    include Helpers::DynamicAttributes
+
+    attr_accessor :record_class
+
+    def initialize(data, record_class = nil)
+      self.record_class = record_class
+      self.attributes = data
+    end
+
+    protected
+
+    def key_formatter
+      record_class && record_class.key_formatter
+    end
+
+  end
+end

data/lib/jsonapi/consumer/middleware/json_request.rb

@@ -0,0 +1,26 @@
+module JSONAPI::Consumer
+  module Middleware
+    class JsonRequest < Faraday::Middleware
+      def call(environment)
+        accept_header = update_accept_header(environment[:request_headers])
+
+        environment[:request_headers]["Content-Type"] = 'application/vnd.api+json'
+        environment[:request_headers]["Accept"] = accept_header
+        @app.call(environment)
+      end
+
+      private
+
+      def update_accept_header(headers)
+        return 'application/vnd.api+json' if headers["Accept"].nil?
+        accept_params = headers["Accept"].split(",")
+
+        unless accept_params.include?('application/vnd.api+json')
+          accept_params.unshift('application/vnd.api+json')
+        end
+
+        accept_params.join(",")
+      end
+    end
+  end
+end

data/lib/jsonapi/consumer/middleware/parse_json.rb

@@ -1,32 +1,31 @@
-module JSONAPI::Consumer::Middleware
-  # Credit to chingor13/json_api_client for middleware.
-  #
-  class ParseJson < Faraday::Response::Middleware
+module JSONAPI::Consumer
+  module Middleware
+    class ParseJson < Faraday::Middleware
 
-    def call(environment)
-      @app.call(environment).on_complete do |env|
-        if process_response_type?(response_type(env))
-          env[:raw_body] = env[:body]
-          env[:body] = parse(env[:body])
+      def call(environment)
+        @app.call(environment).on_complete do |env|
+          if process_response_type?(response_type(env))
+            env[:raw_body] = env[:body]
+            env[:body] = parse(env[:body])
+          end
         end
       end
-    end
 
-  private
+      private
 
-    def parse(body)
-      ::JSON.parse(body) unless body.strip.empty?
-    end
+      def parse(body)
+        ::JSON.parse(body) unless body.strip.empty?
+      end
 
-    def response_type(env)
-      type = env[:response_headers]['Content-Type'].to_s
-      type = type.split(';', 2).first if type.index(';')
-      type
-    end
+      def response_type(env)
+        type = env[:response_headers]['Content-Type'].to_s
+        type = type.split(';', 2).first if type.index(';')
+        type
+      end
 
-    def process_response_type?(type)
-      !!type.match(/\bjson$/)
+      def process_response_type?(type)
+        !!type.match(/\bjson$/)
+      end
     end
   end
-end
-
+end

data/lib/jsonapi/consumer/middleware/status.rb

@@ -0,0 +1,41 @@
+module JSONAPI::Consumer
+  module Middleware
+    class Status < Faraday::Middleware
+      def call(environment)
+        @app.call(environment).on_complete do |env|
+          handle_status(env[:status], env)
+
+          # look for meta[:status]
+          if env[:body].is_a?(Hash)
+            code = env[:body].fetch("meta", {}).fetch("status", 200).to_i
+            handle_status(code, env)
+          end
+        end
+      rescue Faraday::ConnectionFailed, Faraday::TimeoutError
+        raise Errors::ConnectionError, environment
+      end
+
+      protected
+
+      def handle_status(code, env)
+        case code
+        when 200..399
+        when 401
+          raise Errors::NotAuthorized, env
+        when 403
+          raise Errors::AccessDenied, env
+        when 404
+          raise Errors::NotFound, env[:url]
+        when 409
+          raise Errors::Conflict, env
+        when 400..499
+          # some other error
+        when 500..599
+          raise Errors::ServerError, env
+        else
+          raise Errors::UnexpectedStatus.new(code, env[:url])
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/consumer/paginating/paginator.rb

@@ -0,0 +1,89 @@
+module JSONAPI::Consumer
+  module Paginating
+    class Paginator
+      class_attribute :page_param,
+                      :per_page_param
+
+      self.page_param = "page"
+      self.per_page_param = "per_page"
+
+      attr_reader :params, :result_set, :links
+
+      def initialize(result_set, data)
+        @params = params_for_uri(result_set.uri)
+        @result_set = result_set
+        @links = data["links"]
+      end
+
+      def next
+        result_set.links.fetch_link("next")
+      end
+
+      def prev
+        result_set.links.fetch_link("prev")
+      end
+
+      def first
+        result_set.links.fetch_link("first")
+      end
+
+      def last
+        result_set.links.fetch_link("last")
+      end
+
+      def total_pages
+        if links["last"]
+          uri = result_set.links.link_url_for("last")
+          last_params = params_for_uri(uri)
+          last_params.fetch(page_param) do
+            current_page
+          end.to_i
+        else
+          current_page
+        end
+      end
+
+      # this number may be off
+      def total_entries
+        per_page * total_pages
+      end
+      def total_count; total_entries; end
+
+      def offset
+        per_page * (current_page - 1)
+      end
+
+      def per_page
+        params.fetch(per_page_param) do
+          result_set.length
+        end.to_i
+      end
+
+      def current_page
+        params.fetch(page_param, 1).to_i
+      end
+
+      def out_of_bounds?
+        current_page > total_pages
+      end
+
+      def previous_page
+        current_page > 1 ? (current_page - 1) : nil
+      end
+
+      def next_page
+        current_page < total_pages ? (current_page + 1) : nil
+      end
+
+      alias limit_value per_page
+
+      protected
+
+      def params_for_uri(uri)
+        return {} unless uri
+        uri = Addressable::URI.parse(uri)
+        uri.query_values || {}
+      end
+    end
+  end
+end