jsonapi-consumer 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0279cf38de5603887f2d3f092240e8e687321ca9
-  data.tar.gz: 7b34f561d00437e45054114cc6f1b81177e30129
+SHA256:
+  metadata.gz: 1dada35491a8ef6e7c3128cb4636bb126a903f5d2081998719033486b6252246
+  data.tar.gz: 16ea1a557a08f41f8581edae35e5fd83820ea0b3915a719121ddf0e14b45a5a7
 SHA512:
-  metadata.gz: 598a4b6321e2e7d742f8d781b095fb9f9eb2ade74eadf1035b110c8cbbef244d7a34c256a6a50e15850e3d3177038b5bb0d6549ce5eb81a4239a2f2d17754833
-  data.tar.gz: e1068ea2f333ca27a0f536628e2c3165f2af473703a71331553d579b62994045d7d6533bc30b9f841d59c987e290a0224d6ed168b1d88fa1ced9dffbd81ae4b7
+  metadata.gz: 39d0ca8e2933a7e73f005bcd95d45fb43ffa0d193f41017cc768cb5721c15a3ce36eed77c734a9e0c9fe800f4a31038d65aa97dfc566daf4ae46531eb73e02f8
+  data.tar.gz: 2f4985cc2d24da2721699a752938b7c2a78238e6cf786c16c708a71e8af9091bb5f50b2f043480c9558c8ad68cb7289aae9440eafc53d5d6ac61605e67e92aa5

data/.circleci/config.yml

@@ -0,0 +1,27 @@
+# Ruby CircleCI 2.0 configuration file
+#
+# Check https://circleci.com/docs/2.0/language-ruby/ for more details
+#
+version: 2
+jobs:
+  build:
+    docker:
+      # specify the version you desire here
+      - image: circleci/ruby:2.5
+    working_directory: ~/jsonapi_consumer
+
+    steps:
+      - checkout
+
+      - run:
+          name: install dependencies
+          command: |
+            bundle install --jobs=4 --retry=3 --path vendor/bundle
+
+      - run:
+          command: env CI=true bundle exec rake test
+          when: always
+
+      # collect reports
+      - store_test_results:
+          path: /tmp/reports

data/.gitignore

@@ -1,4 +1,5 @@
 /.bundle/
+/.ruby-version
 /.yardoc
 /Gemfile.lock
 /_yardoc/

data/Gemfile

@@ -1,7 +1,9 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
-# Specify your gem's dependencies in jsonapi-consumer.gemspec
 gemspec
 
-gem 'fsevent'
-gem 'guard-rspec', require: false
+gem 'rake'
+gem 'minitest-ci'
+gem 'pry'

data/README.md

@@ -2,33 +2,30 @@
 
 An ActiveModel-compliant consumer framework for communicating with JSONAPI-based APIs.
 
-[![Build Status](https://travis-ci.org/jsmestad/jsonapi-consumer.svg?branch=master)](https://travis-ci.org/jsmestad/jsonapi-consumer)
+[![CircleCI](https://circleci.com/gh/jsmestad/jsonapi-consumer.svg?style=svg)](https://circleci.com/gh/jsmestad/jsonapi-consumer)
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'jsonapi-consumer'
+gem 'jsonapi-consumer', '~> 1.0'
 ```
 
 And then execute:
 
     $ bundle
 
-Or install it yourself as:
-
-    $ gem install jsonapi-consumer
-
 ## Usage
 
 It's suggested to create a base resource for the whole API that you can re-use.
 
 ```ruby
-class Base
-  include JSONAPI::Consumer::Resource
-
-  self.host = 'http://localhost:3000/api/'
+class Base < JSONAPI::Consumer::Resource
+  # self.connection_options = {} # Faraday connection options
+  # self.json_key_format = :dasherized_key # (default: underscored_key)
+  # self.route_format = :dasherized_route # (default: underscored_route)
+  self.site = 'http://localhost:3000/api/'
 end
 ```
 
@@ -36,7 +33,6 @@ Then inherit from that Base class for each resource defined in your API.
 
 ```ruby
 module Blog
-
   class Author < Base
     has_many :posts, class_name: 'Blog::Post'
   end
@@ -53,36 +49,9 @@ module Blog
   class Comment < Base
 
   end
-
 end
 ```
 
-#### Additional Features
-
-##### Dynamic Objects
-
-By default calling `.new` or `.build` on a resource will give you an empty
-object with no attributes defined. This is less than ideal when building forms
-with something like Rails' FormBuilder.
-
-We suggest setting up your model to do a `GET /{resource_name}/new` if your
-server supports it and using `.build` instead of `.new`. This will populate the
-object with defaults set by the server response.
-
-```ruby
-class User
-  include JSONAPI::Consumer::Resource
-
-  self.request_new_object_on_build = true
-
-  # .build will now call GET /users/new
-end
-```
-
-#### Testing
-
-We suggest [Webmock](https://github.com/bblimke/webmock) at this stage in
-development. We plan to add test helpers before the first major release.
 
 ## Contributing
 
@@ -95,3 +64,5 @@ development. We plan to add test helpers before the first major release.
 ## Copyright & License
 
 JSONAPI::Consumer is distributed under the Apache 2.0 License. See LICENSE.txt file for more information.
+
+Version v1 is a rewrite is based on the excellent work by [json_api_client](https://github.com/chingor13/json_api_client) [v1.5.3](https://github.com/chingor13/json_api_client/tree/v1.5.3).

data/Rakefile

@@ -1,12 +1,23 @@
 require "bundler/gem_tasks"
 
-begin
-  require 'rspec/core/rake_task'
+require 'rdoc/task'
 
-  RSpec::Core::RakeTask.new(:spec)
+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
+
+
+require 'rake/testtask'
 
-  task default: :spec
-rescue LoadError
-  # no rspec available
+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/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mikasa_client"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start(__FILE__)
+
+# require "irb"
+# IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/jsonapi-consumer.gemspec

@@ -13,20 +13,19 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/jsmestad/jsonapi-consumer"
   spec.license       = "Apache-2.0"
 
-  spec.files         = `git ls-files -z`.split("\x0") - ['Guardfile', '.travis.yml']
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "activemodel"
-  spec.add_runtime_dependency "activesupport"
-  spec.add_runtime_dependency "faraday", "~> 0.9.0"
+  spec.add_runtime_dependency "activesupport", '>= 3.2'
+  spec.add_runtime_dependency "faraday", '>= 0.9'
   spec.add_runtime_dependency "faraday_middleware"
+  spec.add_runtime_dependency "addressable", '~> 2.5.2'
+  spec.add_runtime_dependency "activemodel", '>= 3.2'
 
-  spec.add_development_dependency "bundler", "~> 1.6"
-  spec.add_development_dependency "factory_girl"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "rspec-its"
   spec.add_development_dependency "webmock"
+  spec.add_development_dependency "mocha"
 end

data/lib/jsonapi/consumer/associations/base_association.rb

@@ -0,0 +1,26 @@
+module JSONAPI::Consumer
+  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
+    end
+  end
+end

data/lib/jsonapi/consumer/associations/belongs_to.rb

@@ -0,0 +1,30 @@
+module JSONAPI::Consumer
+  module Associations
+    module BelongsTo
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def belongs_to(attr_name, options = {})
+          # self.associations = self.associations + [HasOne::Association.new(attr_name, self, options)]
+          self.associations += [BelongsTo::Association.new(attr_name, self, options)]
+        end
+      end
+
+      class Association < BaseAssociation
+        include Helpers::URI
+        def param
+          :"#{attr_name}_id"
+        end
+
+        def to_prefix_path(formatter)
+          "#{formatter.format(attr_name.to_s.pluralize)}/%{#{param}}"
+        end
+
+        def set_prefix_path(attrs, formatter)
+          attrs[param] = encode_part(attrs[param]) if attrs.key?(param)
+          to_prefix_path(formatter) % attrs
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/consumer/associations/has_many.rb

@@ -0,0 +1,26 @@
+module JSONAPI::Consumer
+  module Associations
+    module HasMany
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def has_many(attr_name, options = {})
+          self.associations = self.associations + [HasMany::Association.new(attr_name, self, options)]
+        end
+      end
+
+      class Association < BaseAssociation
+        def query_builder(url)
+          association_class.query_builder.new(
+            association_class,
+            association_class.requestor_class.new(association_class, url)
+          )
+        end
+
+        def data(url)
+          query_builder(url)
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/consumer/associations/has_one.rb

@@ -0,0 +1,19 @@
+module JSONAPI::Consumer
+  module Associations
+    module HasOne
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def has_one(attr_name, options = {})
+          self.associations += [HasOne::Association.new(attr_name, self, options)]
+        end
+      end
+
+      class Association < BaseAssociation
+        def from_result_set(result_set)
+          result_set.first
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/consumer/connection.rb

@@ -0,0 +1,36 @@
+module JSONAPI::Consumer
+  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))
+      @faraday = Faraday.new(site, connection_options) do |builder|
+        builder.request :json
+        builder.use Middleware::JsonRequest
+        builder.use Middleware::Status
+        builder.use Middleware::ParseJson
+        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 = {}, headers = {})
+      faraday.send(request_method, path, params, headers)
+    end
+
+  end
+end

data/lib/jsonapi/consumer/error_collector.rb

@@ -0,0 +1,91 @@
+module JSONAPI::Consumer
+  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/jsonapi/consumer/errors.rb

@@ -1,98 +1,56 @@
-# JSONAPI::Consumer::Errors is responsible for wrapping API errors into a consistent
-# form. Handling or Rescuing from these errors is left up to the client, but
-# a possible way to do this is detailed below.
-#
-#  # lib/errors/rescue_error.rb
-#  module Errors
-#    module RescueError
-#
-#      def self.included(base)
-#        base.rescue_from Errors::ResponseError do |e|
-#          render "public/#{e.code}", :status => e.code
-#        end
-#      end
-#
-#    end
-#  end
-#
 module JSONAPI::Consumer
   module Errors
-    class ConnectionNotConfigured < StandardError; end
-    class RecordNotSaved < StandardError; end
-
-    class ServerNotResponding < StandardError
-      def message
-        'Server did not respond in a timely fashion. Is it running?'
+    class ApiError < StandardError
+      attr_reader :env
+      def initialize(env)
+        @env = env
       end
     end
 
-    # Error constants
-    BAD_REQUEST                     = 400
-    NOT_AUTHORIZED                  = 401
-    FORBIDDEN                       = 403
-    NOT_FOUND                       = 404
-    METHOD_NOT_ALLOWED              = 405
-    BAD_FORMAT                      = 406
-    REQUESTED_RANGE_NOT_SATISFIABLE = 416
-    UNPROCESSABLE_ENTITY            = 422
-    INTERNAL_SERVER_ERROR           = 500
+    class ClientError < ApiError
+    end
 
-    # Base subclass for all response errors
-    class ResponseError < StandardError
-      attr_accessor :response
+    class AccessDenied < ClientError
+    end
 
-      def initialize(message=nil, response=nil)
-        super(message)
-        self.response = response
-      end
+    class NotAuthorized < ClientError
+    end
 
-      def errors
-        response[:body].fetch('errors', [])
-      end
+    class ConnectionError < ApiError
+    end
 
-      def response_body
-        response[:body]
+    class ServerError < ApiError
+      def message
+        "Internal server error"
       end
     end
 
-    class << self
-
-      # Returns a hash of error names to response codes.
-      def error_constants
-        constants.each_with_object({}) do |name, hash|
-          # Ignore any class constants
-          next if (code = Errors.const_get(name)).is_a?(Class)
-          hash[name] = code
-        end
+    class Conflict < ServerError
+      def message
+        "Resource already exists"
       end
+    end
 
-      # Returns a class name from a constant name.
-      def class_name_for_error_name(name)
-        name.to_s.titleize.gsub(' ', '')
+    class NotFound < ServerError
+      attr_reader :uri
+      def initialize(uri)
+        @uri = uri
       end
-
-      # Returns the error class for a given constant name.
-      # Default to InternalServerError.
-      def class_for_error_name(name)
-        class_name = class_name_for_error_name(name)
-        const_defined?(class_name) ? Errors.const_get(class_name) : Errors::InternalServerError
+      def message
+        "Couldn't find resource at: #{uri.to_s}"
       end
+    end
 
-      # Returns the error class for a given error code.
-      # Default to InternalServerError.
-      def class_for_error_code(code)
-        name = error_constants.select { |k, v| v == code }.keys.first
-        name.present? ? class_for_error_name(name) : Errors::InternalServerError
+    class UnexpectedStatus < ServerError
+      attr_reader :code, :uri
+      def initialize(code, uri)
+        @code = code
+        @uri = uri
+      end
+      def message
+        "Unexpected response status: #{code} from: #{uri.to_s}"
       end
     end
-  end
 
-  # Dynamically creates a subclass of ResponseError for each error constant.
-  # Adds a code method to return the correct response code.
-  # Adds the new class to the constants in the Errors module.
-  Errors.error_constants.each do |name, code|
-    klass = Class.new(Errors::ResponseError)
-    klass.send(:define_method, :code) { code }
-    Errors.const_set(Errors.class_name_for_error_name(name), klass)
   end
 end