carwow-json_api_client 1.19.0

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'JsonApiClient'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/json_api_client.rb

@@ -0,0 +1,30 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'json'
+require 'addressable/uri'
+require 'json_api_client/formatter'
+
+module JsonApiClient
+  autoload :Associations, 'json_api_client/associations'
+  autoload :Attributes, 'json_api_client/attributes'
+  autoload :Connection, 'json_api_client/connection'
+  autoload :Errors, 'json_api_client/errors'
+  autoload :ErrorCollector, 'json_api_client/error_collector'
+  autoload :Helpers, 'json_api_client/helpers'
+  autoload :Implementation, 'json_api_client/implementation'
+  autoload :IncludedData, 'json_api_client/included_data'
+  autoload :Linking, 'json_api_client/linking'
+  autoload :Relationships, 'json_api_client/relationships'
+  autoload :LinkDefinition, 'json_api_client/link_definition'
+  autoload :MetaData, 'json_api_client/meta_data'
+  autoload :Middleware, 'json_api_client/middleware'
+  autoload :Paginating, 'json_api_client/paginating'
+  autoload :Parsers, 'json_api_client/parsers'
+  autoload :Query, 'json_api_client/query'
+  autoload :RequestParams, 'json_api_client/request_params'
+  autoload :Resource, 'json_api_client/resource'
+  autoload :ResultSet, 'json_api_client/result_set'
+  autoload :Schema, 'json_api_client/schema'
+  autoload :Utils, 'json_api_client/utils'
+  autoload :VERSION, 'json_api_client/version'
+end

data/lib/json_api_client/associations.rb

@@ -0,0 +1,8 @@
+module JsonApiClient
+  module Associations
+    autoload :BaseAssociation, 'json_api_client/associations/base_association'
+    autoload :BelongsTo, 'json_api_client/associations/belongs_to'
+    autoload :HasMany, 'json_api_client/associations/has_many'
+    autoload :HasOne, 'json_api_client/associations/has_one'
+  end
+end

data/lib/json_api_client/associations/base_association.rb

@@ -0,0 +1,33 @@
+module JsonApiClient
+  module Associations
+    class BaseAssociation
+      attr_reader :attr_name, :klass, :options
+      def initialize(attr_name, klass, options = {})
+        @attr_name = attr_name
+        @klass = klass
+        @options = options
+      end
+
+      def association_class
+        @association_class ||= Utils.compute_type(klass, options.fetch(:class_name) do
+          attr_name.to_s.classify
+        end)
+      end
+
+      def data(url)
+        from_result_set(association_class.requestor.linked(url))
+      end
+
+      def from_result_set(result_set)
+        result_set.to_a
+      end
+
+      def load_records(data)
+        data.map do |d|
+          record_class = Utils.compute_type(klass, klass.key_formatter.unformat(d["type"]).classify)
+          record_class.load id: d["id"]
+        end
+      end
+    end
+  end
+end

data/lib/json_api_client/associations/belongs_to.rb

@@ -0,0 +1,31 @@
+module JsonApiClient
+  module Associations
+    module BelongsTo
+      class Association < BaseAssociation
+        include Helpers::URI
+
+        attr_reader :param
+
+        def initialize(attr_name, klass, options = {})
+          super
+          @param = options.fetch(:param, :"#{attr_name}_id").to_sym
+          @shallow_path = options.fetch(:shallow_path, false)
+        end
+
+        def shallow_path?
+          @shallow_path
+        end
+
+        def to_prefix_path(formatter)
+          "#{formatter.format(attr_name.to_s.pluralize)}/%{#{param}}"
+        end
+
+        def set_prefix_path(attrs, formatter)
+          return if shallow_path? && !attrs[param]
+          attrs[param] = encode_part(attrs[param]) if attrs.key?(param)
+          to_prefix_path(formatter) % attrs
+        end
+      end
+    end
+  end
+end

data/lib/json_api_client/associations/has_many.rb

@@ -0,0 +1,8 @@
+module JsonApiClient
+  module Associations
+    module HasMany
+      class Association < BaseAssociation
+      end
+    end
+  end
+end

data/lib/json_api_client/associations/has_one.rb

@@ -0,0 +1,16 @@
+module JsonApiClient
+  module Associations
+    module HasOne
+      class Association < BaseAssociation
+        def from_result_set(result_set)
+          result_set.first
+        end
+
+        def load_records(data)
+          record_class = Utils.compute_type(klass, klass.key_formatter.unformat(data["type"]).classify)
+          record_class.load id: data["id"]
+        end
+      end
+    end
+  end
+end

data/lib/json_api_client/connection.rb

@@ -0,0 +1,41 @@
+module JsonApiClient
+  class Connection
+
+    attr_reader :faraday
+
+    def initialize(options = {})
+      site = options.fetch(:site)
+      connection_options = options.slice(:proxy, :ssl, :request, :headers, :params)
+      adapter_options = Array(options.fetch(:adapter, Faraday.default_adapter))
+      status_middleware_options = {}
+      status_middleware_options[:custom_handlers] = options[:status_handlers] if options[:status_handlers].present?
+      @faraday = Faraday.new(site, connection_options) do |builder|
+        builder.request :json
+        builder.use Middleware::JsonRequest
+        builder.use Middleware::Status, status_middleware_options
+        builder.use Middleware::ParseJson
+        builder.use ::FaradayMiddleware::Gzip
+        builder.adapter(*adapter_options)
+      end
+      yield(self) if block_given?
+    end
+
+    # insert middleware before ParseJson - middleware executed in reverse order -
+    #   inserted middleware will run after json parsed
+    def use(middleware, *args, &block)
+      return if faraday.builder.locked?
+      faraday.builder.insert_before(Middleware::ParseJson, middleware, *args, &block)
+    end
+
+    def delete(middleware)
+      faraday.builder.delete(middleware)
+    end
+
+    def run(request_method, path, params: nil, headers: {}, body: nil)
+      faraday.run_request(request_method, path, body, headers) do |request|
+        request.params.update(params) if params
+      end
+    end
+
+  end
+end

data/lib/json_api_client/error_collector.rb

@@ -0,0 +1,91 @@
+module JsonApiClient
+  class ErrorCollector < Array
+    class Error
+      delegate :[], to: :attrs
+
+      def initialize(attrs = {})
+        @attrs = (attrs || {}).with_indifferent_access
+      end
+
+      def id
+        attrs[:id]
+      end
+
+      def about
+        res = attrs.fetch(:links, {})
+        res ? res[:about] : {}
+      end
+
+      def status
+        attrs[:status]
+      end
+
+      def code
+        attrs[:code]
+      end
+
+      def title
+        attrs[:title]
+      end
+
+      def detail
+        attrs[:detail]
+      end
+
+      def source_parameter
+        source[:parameter]
+      end
+
+      def source_pointer
+        source[:pointer]
+      end
+
+      def error_key
+        if source_pointer && source_pointer != "/data"
+          source_pointer.split("/").last
+        else
+          "base"
+        end
+      end
+
+      def error_msg
+        msg = title || detail || "invalid"
+        if source_parameter
+          "#{source_parameter} #{msg}"
+        else
+          msg
+        end
+      end
+
+      def source
+        res = attrs.fetch(:source, {})
+        res ? res : {}
+      end
+
+      def meta
+        MetaData.new(attrs.fetch(:meta, {}))
+      end
+
+      protected
+
+      attr_reader :attrs
+    end
+
+    def initialize(error_data)
+      super(error_data.map do |data|
+        Error.new(data)
+      end)
+    end
+
+    def full_messages
+      map(&:title)
+    end
+
+    def [](source)
+      map do |error|
+        error.error_key == source
+      end
+    end
+
+  end
+end

data/lib/json_api_client/errors.rb

@@ -0,0 +1,107 @@
+require 'rack'
+
+module JsonApiClient
+  module Errors
+    class ApiError < StandardError
+      attr_reader :env
+
+      def initialize(env, msg = nil)
+        @env = env
+        # Try to fetch json_api errors from response
+        msg = track_json_api_errors(msg)
+
+        super msg
+      end
+
+      private
+
+      # Try to fetch json_api errors from response
+      def track_json_api_errors(msg)
+        return msg unless env.try(:body).kind_of?(Hash) || env.body.key?('errors')
+
+        errors_msg = env.body['errors'].map { |e| e['title'] }.compact.join('; ').presence
+        return msg unless errors_msg
+
+        msg.nil? ? errors_msg : "#{msg} (#{errors_msg})"
+        # Just to be sure that it is back compatible
+      rescue StandardError
+        msg
+      end
+    end
+
+    class ClientError < ApiError
+    end
+
+    class ResourceImmutableError < StandardError
+      def initialize(msg = 'Resource immutable')
+        super msg
+      end
+    end
+
+    class AccessDenied < ClientError
+    end
+
+    class NotAuthorized < ClientError
+    end
+
+    class NotFound < ClientError
+      attr_reader :uri
+      def initialize(uri)
+        @uri = uri
+
+        msg = "Couldn't find resource at: #{uri.to_s}"
+        super nil, msg
+      end
+    end
+
+    class RequestTimeout < ClientError
+    end
+
+    class Conflict < ClientError
+      def initialize(env, msg = 'Resource already exists')
+        super env, msg
+      end
+    end
+
+    class TooManyRequests < ClientError
+    end
+
+    class ConnectionError < ApiError
+    end
+
+    class ServerError < ApiError
+      def initialize(env, msg = nil)
+        msg ||= begin
+          status = env.status
+          message = ::Rack::Utils::HTTP_STATUS_CODES[status]
+          "#{status} #{message}"
+        end
+
+        super env, msg
+      end
+    end
+
+    class InternalServerError < ServerError
+    end
+
+    class BadGateway < ServerError
+    end
+
+    class ServiceUnavailable < ServerError
+    end
+
+    class GatewayTimeout < ServerError
+    end
+
+    class UnexpectedStatus < ServerError
+      attr_reader :code, :uri
+      def initialize(code, uri)
+        @code = code
+        @uri = uri
+
+        msg = "Unexpected response status: #{code} from: #{uri.to_s}"
+        super nil, msg
+      end
+    end
+  end
+end

data/lib/json_api_client/formatter.rb

@@ -0,0 +1,145 @@
+# Taken form jsonapi_resources formatter
+
+require 'active_support/inflector'
+
+module JsonApiClient
+  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 = "JsonApiClient::#{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