json_api_client 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f5db14498ef10dc6d6aaa4bcb65b0a6c5bdcb300
+  data.tar.gz: 75c000bfceb5104a78ab2929f0c160254ce129e5
+SHA512:
+  metadata.gz: f5eae53897bbd0f37a524e979b3c81374ba74607ee4f8e3594d6c581230ad4cca41fb9b355d306ca7da6ef222e9af37613c19e9b4856545908f66a28a16dde2c
+  data.tar.gz: de3bcf1db477b01d2f89bd9744b5c94eeb7bdd1644752335f44ea667e9b6c0c0ccca3e042a54e6a3e540cb4c1ed63db41c1caa5f2d1ab4232c84eff8350be4fa

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) {{year}} {{fullname}}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,118 @@
+# JsonApiClient [![Build Status](https://travis-ci.org/chingor13/json_api_client.png)](https://travis-ci.org/chingor13/json_api_client)
+
+This gem is meant to help you build an API client for interacting with REST APIs as laid out by [http://jsonapi.org](http://jsonapi.org). It attempts to give you a query building framework that is easy to understand (it is similar to ActiveRecord scopes).
+
+*Note: This is still a work in progress.*
+
+## Usage
+
+```
+module MyApi
+  class User < JsonApiClient::Resource
+    has_many :accounts
+  end
+  
+  class Account < JsonApiClient::Resource
+  	belongs_to :user
+  end
+end
+
+MyApi::User.all
+MyApi::User.where(account_id: 1).find(1)
+MyApi::User.where(account_id: 1).all
+
+MyApi::User.where(name: "foo").order("created_at desc").includes(:preferences, :cars).all
+
+u = MyApi::User.new(foo: "bar", bar: "foo")
+u.save
+
+u = MyApi::User.find(1).first
+u.update_attributes(
+  a: "b",
+  c: "d"
+)
+
+u = MyApi::User.create(
+  a: "b",
+  c: "d"
+)
+
+u = MyApi::User.find(1).first
+u.accounts
+=> MyApi::Account.where(user_id: u.id).all
+```
+
+## Connection options
+
+You can configure your connection using Faraday middleware. In general, you'll want 
+to do this in a base model that all your resources inherit from:
+
+```
+MyApi::Base.connection do |connection|
+  # set OAuth2 headers
+  connection.use Faraday::Request::Oauth2, 'MYTOKEN'
+
+  # log responses
+  connection.use Faraday::Response::Logger
+
+  connection.use MyCustomMiddleware
+end
+
+module MyApi
+  class User < Base
+    # will use the customized connection
+  end
+end
+```
+
+## Custom Parser
+
+You can configure your API client to use a custom parser that implements the `parse` class method.  It should return a `JsonApiClient::ResultSet` instance. You can use it by setting the parser attribute on your model:
+
+```
+class MyCustomParser
+  def self.parse(klass, response)
+  	…
+  	# returns some ResultSet object
+  end
+end
+
+class MyApi::Base < JsonApiClient::Resource
+  self.parser = MyCustomParser
+end
+```
+
+## Handling Validation Errors
+
+```
+User.create(name: "Bob", email_address: "invalid email")
+=> false
+
+user = User.new(name: "Bob", email_address: "invalid email")
+user.save
+=> false
+user.errors
+=> ["Email address is invalid"]
+
+user = User.find(1)
+user.update_attributes(email_address: "invalid email")
+=> false
+user.errors
+=> ["Email address is invalid"]
+user.email_address
+=> "invalid email"
+```
+
+## Nested Resources
+
+You can force nested resource paths for your models by using a `belongs_to` association.
+
+```
+module MyApi
+  class Account < JsonApiClient::Resource
+  	belongs_to :user
+  end
+end
+
+
+```

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/associations/base_association.rb

@@ -0,0 +1,18 @@
+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
+    end
+  end
+end

data/lib/json_api_client/associations/belongs_to.rb

@@ -0,0 +1,28 @@
+module JsonApiClient
+  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
+        def parse(params)
+          params ? association_class.new(params) : nil
+        end
+
+        def param
+          :"#{attr_name}_id"
+        end
+
+        def to_prefix_path
+          "#{attr_name.to_s.pluralize}/%{#{param}}"
+        end
+      end
+    end
+  end
+end

data/lib/json_api_client/associations/has_many.rb

@@ -0,0 +1,19 @@
+module JsonApiClient
+  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 parse(param)
+          [param].flatten.map{|data| association_class.new(data) }
+        end
+      end
+    end
+  end
+end

data/lib/json_api_client/associations/has_one.rb

@@ -0,0 +1,20 @@
+module JsonApiClient
+  module Associations
+    module HasOne
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def has_one(attr_name, options = {})
+          # self.associations = self.associations + [HasOne::Association.new(attr_name, self, options)]
+          self.associations += [HasOne::Association.new(attr_name, self, options)]
+        end
+      end
+
+      class Association < BaseAssociation
+        def parse(params)
+          params ? association_class.new(params) : nil
+        end
+      end
+    end
+  end
+end

data/lib/json_api_client/associations.rb

@@ -0,0 +1,63 @@
+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'
+
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :associations
+      self.associations = []
+
+      include BelongsTo
+      include HasMany
+      include HasOne
+
+      initialize :load_associations
+    end
+
+    module ClassMethods
+      def belongs_to_associations
+        associations.select{|association| association.is_a?(BelongsTo::Association) }
+      end
+
+      def prefix_params
+        belongs_to_associations.map(&:param)
+      end
+
+      def prefix_path
+        belongs_to_associations.map(&:to_prefix_path).join("/")
+      end
+
+      def path(params = nil)
+        parts = [table_name]
+        if params
+          slurp = params.slice(*prefix_params)
+          prefix_params.each do |param|
+            params.delete(param)
+          end
+          parts.unshift(prefix_path % slurp)
+        else
+          parts.unshift(prefix_path)
+        end
+        parts.reject!{|part| part == "" }
+        File.join(*parts)
+      rescue KeyError
+        raise ArgumentError, "Not all prefix parameters specified"
+      end
+    end
+
+    protected
+
+    def load_associations(params)
+      associations.each do |association|
+        if params.has_key?(association.attr_name.to_s)
+          set_attribute(association.attr_name, association.parse(params[association.attr_name.to_s]))
+        end
+      end
+    end
+
+  end
+end

data/lib/json_api_client/attributes.rb

@@ -0,0 +1,59 @@
+module JsonApiClient
+  module Attributes
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :attributes
+      initialize do |obj, params|
+        obj.attributes = params
+      end
+    end
+
+    def attributes=(attrs = {})
+      @attributes ||= {}.with_indifferent_access
+      @attributes.merge!(attrs)
+    end
+
+    def update_attributes(attrs = {})
+      self.attributes = attrs
+      save
+    end
+
+    def method_missing(method, *args, &block)
+      if match = method.to_s.match(/^(.*)=$/)
+        set_attribute(match[1], args.first)
+      elsif has_attribute?(method)
+        attributes[method]
+      else
+        nil
+      end
+    end
+
+    def persisted?
+      attributes.has_key?(primary_key)
+    end
+
+    def query_params
+      attributes.except(primary_key)
+    end
+
+    def to_param
+      attributes.fetch(primary_key, "").to_s
+    end
+
+    protected
+
+    def read_attribute(name)
+      attributes.fetch(name, nil)
+    end
+
+    def set_attribute(name, value)
+      attributes[name] = value
+    end
+
+    def has_attribute?(attr_name)
+      attributes.has_key?(attr_name)
+    end
+
+  end
+end

data/lib/json_api_client/connection.rb

@@ -0,0 +1,32 @@
+module JsonApiClient
+  class Connection
+
+    attr_reader :faraday
+
+    def initialize(site)
+      @faraday = Faraday.new(site) do |builder|
+        builder.request :url_encoded
+        builder.use Middleware::JsonRequest
+        builder.use Middleware::Status
+        builder.use FaradayMiddleware::ParseJson, content_type: /\bjson$/
+        builder.adapter Faraday.default_adapter
+      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)
+      faraday.builder.insert_before(FaradayMiddleware::ParseJson, middleware, *args, &block)
+    end
+
+    def delete(middleware)
+      faraday.builder.delete(middleware)
+    end
+
+    def execute(query)
+      faraday.send(query.request_method, query.path, query.params, query.headers)
+    end
+
+  end
+end

data/lib/json_api_client/errors.rb

@@ -0,0 +1,41 @@
+module JsonApiClient
+  module Errors
+    class ApiError < Exception
+      attr_reader :env
+      def initialize(env)
+        @env = env
+      end
+    end
+
+    class ClientError < ApiError
+    end
+
+    class ServerError < ApiError
+      def message
+        "Internal server error"
+      end
+    end
+
+    class NotFound < ServerError
+      attr_reader :uri
+      def initialize(uri)
+        @uri = uri
+      end
+      def message
+        "Couldn't find resource at: #{uri.to_s}"
+      end
+    end
+
+    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
+end

data/lib/json_api_client/links.rb

@@ -0,0 +1,14 @@
+module JsonApiClient
+  module Links
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :links
+
+      initialize do |obj, params|
+        links = params.delete(:links)
+        obj.links = links if links
+      end
+    end
+  end
+end

data/lib/json_api_client/middleware/json_request.rb

@@ -0,0 +1,12 @@
+module JsonApiClient
+  module Middleware
+    class JsonRequest < Faraday::Middleware
+      def call(environment)
+        environment[:request_headers]["Accept"] = "application/json,*/*"
+        uri = environment[:url]
+        uri.path = uri.path + ".json" unless uri.path.match(/\.json$/) 
+        @app.call(environment)
+      end
+    end
+  end
+end

data/lib/json_api_client/middleware/status.rb

@@ -0,0 +1,28 @@
+module JsonApiClient
+  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
+      end
+
+      protected
+
+      def handle_status(code, env)
+        case code
+        when 404
+          raise Errors::NotFound, env[:uri]
+        when 500..599
+          raise Errors::ServerError, env
+        end
+      end
+    end
+  end
+end

data/lib/json_api_client/middleware.rb

@@ -0,0 +1,6 @@
+module JsonApiClient
+  module Middleware
+    autoload :JsonRequest, 'json_api_client/middleware/json_request'
+    autoload :Status, 'json_api_client/middleware/status'
+  end
+end

data/lib/json_api_client/parser.rb

@@ -0,0 +1,42 @@
+module JsonApiClient
+  class Parser
+
+    class << self
+      def parse(klass, response)
+        data = response.body
+        ResultSet.build(klass, data) do |result_set|
+          handle_pagination(result_set, data)
+          handle_errors(result_set, data)
+        end
+      end
+
+      private
+
+      def handle_pagination(result_set, data)
+        meta = data.fetch("meta", {})
+        result_set.per_page = meta.fetch("per_page") do
+          result_set.length
+        end
+        result_set.total_entries = meta.fetch("total_entries") do
+          result_set.length
+        end
+        result_set.current_page = meta.fetch("current_page", 1)
+
+        # can fall back to calculating via total entries and per_page
+        result_set.total_pages = meta.fetch("total_pages") do
+          (1.0 * result_set.total_entries / result_set.per_page).ceil rescue 1
+        end
+
+        # can fall back to calculating via per_page and current_page
+        result_set.offset = meta.fetch("offset") do
+          result_set.per_page * (result_set.current_page - 1)
+        end
+      end
+
+      def handle_errors(result_set, data)
+        result_set.errors = data.fetch("meta", {}).fetch("errors", [])
+      end
+    end
+
+  end
+end

data/lib/json_api_client/query/base.rb

@@ -0,0 +1,27 @@
+module JsonApiClient
+  module Query
+    class Base
+      class_attribute :request_method
+      attr_reader :klass, :headers, :path, :params
+
+      def initialize(klass, args)
+        @klass = klass
+        build_params(args)
+        @headers = klass.default_headers.dup
+
+        @path = begin
+          p = klass.path(@params)
+          if @params.has_key?(klass.primary_key) && !@params[klass.primary_key].is_a?(Array)
+            p = File.join(p, @params.delete(klass.primary_key).to_s)
+          end
+          p
+        end
+      end
+
+      def build_params(args)
+        @params = args
+      end
+
+    end
+  end
+end

data/lib/json_api_client/query/create.rb

@@ -0,0 +1,12 @@
+module JsonApiClient
+  module Query
+    class Create < Base
+      self.request_method = :post
+
+      def build_params(args)
+        @params = {klass.resource_name => args.except(klass.primary_key)}
+      end
+
+    end
+  end
+end

data/lib/json_api_client/query/destroy.rb

@@ -0,0 +1,12 @@
+module JsonApiClient
+  module Query
+    class Destroy < Base
+      self.request_method = :delete
+
+      def params
+        nil
+      end
+
+    end
+  end
+end

data/lib/json_api_client/query/find.rb

@@ -0,0 +1,19 @@
+module JsonApiClient
+  module Query
+    class Find < Base
+      self.request_method = :get
+
+      def build_params(args)
+        @params = case args
+        when Hash
+          args
+        when Array
+          {klass.primary_key.to_s.pluralize.to_sym => args.join(",")}
+        else
+          {klass.primary_key => args}
+        end
+      end
+
+    end
+  end
+end

data/lib/json_api_client/query/update.rb

@@ -0,0 +1,12 @@
+module JsonApiClient
+  module Query
+    class Update < Base
+      self.request_method = :put
+
+      def build_params(args)
+        @params = {klass.primary_key => args.delete(klass.primary_key), klass.resource_name => args}
+      end
+
+    end
+  end
+end

data/lib/json_api_client/query.rb

@@ -0,0 +1,9 @@
+module JsonApiClient
+  module Query
+    autoload :Base, 'json_api_client/query/base'
+    autoload :Create, 'json_api_client/query/create'
+    autoload :Destroy, 'json_api_client/query/destroy'
+    autoload :Find, 'json_api_client/query/find'
+    autoload :Update, 'json_api_client/query/update'
+  end
+end

data/lib/json_api_client/resource.rb

@@ -0,0 +1,119 @@
+require 'forwardable'
+require 'active_support/concern'
+require 'active_support/inflector'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/class/attribute'
+
+module JsonApiClient
+  class Resource
+    class_attribute :site, :primary_key, :link_style, :default_headers, :initializers, :parser
+
+    self.primary_key = :id
+    self.link_style = :id # or :url
+    self.default_headers = {}
+    self.initializers = []
+    self.parser = Parser
+
+    class << self
+      # first 'scope' should build a new scope object
+      extend Forwardable
+      def_delegators :new_scope, :where, :order, :includes, :all, :paginate, :page, :first
+
+      # base URL for this resource
+      def resource
+        File.join(site, path)
+      end
+
+      def table_name
+        resource_name.pluralize
+      end
+
+      def resource_name
+        name.demodulize.underscore
+      end
+
+      def find(conditions)
+        run_request(Query::Find.new(self, conditions))
+      end
+
+      def create(conditions = {})
+        result = run_request(Query::Create.new(self, conditions))
+        return nil if result.errors.length > 0
+        result.first
+      end
+
+      def connection
+        @connection ||= begin
+          super
+        rescue
+          build_connection
+        end
+        yield(@connection) if block_given?
+        @connection
+      end
+
+      def run_request(query)
+        parse(connection.execute(query))
+      end
+
+      private
+
+      def new_scope
+        Scope.new(self)
+      end
+
+      def parse(data)
+        parser.parse(self, data)
+      end
+
+      def build_connection
+        Connection.new(site)
+      end
+
+      def initialize(method = nil, &block)
+        self.initializers.push(method || block)
+      end
+    end
+
+    include Attributes
+    include Associations
+    include Links
+
+    attr_accessor :errors
+    def initialize(params = {})
+      initializers.each do |initializer|
+        if initializer.respond_to?(:call)
+          initializer.call(self, params)
+        else
+          self.send(initializer, params)
+        end
+      end
+    end
+
+    def save
+      query = persisted? ? 
+        Query::Update.new(self.class, attributes) :
+        Query::Create.new(self.class, attributes)
+
+      run_request(query)
+    end
+
+    def destroy
+      run_request(Query::Destroy.new(self.class, attributes))
+    end
+
+    protected
+
+    def run_request(query)
+      response = self.class.run_request(query)
+      self.errors = response.errors
+      if updated = response.first
+        self.attributes = updated.attributes
+      else
+        self.attributes = {}
+      end
+      return errors.length == 0
+    end
+
+  end
+end

data/lib/json_api_client/result_set.rb

@@ -0,0 +1,13 @@
+module JsonApiClient
+  class ResultSet < Array
+
+    attr_accessor :total_pages, :total_entries, :offset, :per_page, :current_page, :errors
+
+    def self.build(klass, data)
+      result_data = data.fetch(klass.table_name, [])
+      new(result_data.map {|attributes| klass.new(attributes) }).tap do |result_set|
+        yield(result_set) if block_given?
+      end
+    end
+  end
+end

data/lib/json_api_client/scope.rb

@@ -0,0 +1,48 @@
+module JsonApiClient
+  class Scope
+    attr_reader :klass, :params
+
+    def initialize(klass)
+      @klass = klass
+      @params = {}
+    end
+
+    def where(conditions = {})
+      @params.merge!(conditions)
+      self
+    end
+    alias paginate where
+
+    def order(conditions)
+      where(order: conditions)
+    end
+
+    def includes(*tables)
+      @params[:includes] ||= []
+      @params[:includes] += tables.flatten
+      self
+    end
+
+    def page(number)
+      where(page: number)
+    end
+
+    def first
+      paginate(page: 1, per_page: 1).to_a.first
+    end
+
+    def build
+      klass.new(params)
+    end
+
+    def to_a
+      @to_a ||= klass.find(params)
+    end
+    alias all to_a
+
+    def method_missing(method_name, *args, &block)
+      to_a.send(method_name, *args, &block)
+    end
+
+  end
+end

data/lib/json_api_client/utils.rb

@@ -0,0 +1,28 @@
+module JsonApiClient
+  module Utils
+
+    def self.compute_type(klass, type_name)
+      # If the type is prefixed with a scope operator then we assume that
+      # the type_name is an absolute reference.
+      return type_name.constantize if type_name.match(/^::/)
+
+      # Build a list of candidates to search for
+      candidates = []
+      klass.name.scan(/::|$/) { candidates.unshift "#{$`}::#{type_name}" }
+      candidates << type_name
+
+      candidates.each do |candidate|
+        begin
+          constant = candidate.constantize
+          return constant if candidate == constant.to_s
+        rescue NameError => e
+          # We don't want to swallow NoMethodError < NameError errors
+          raise e unless e.instance_of?(NameError)
+        end
+      end
+
+      raise NameError, "uninitialized constant #{candidates.first}"
+    end
+
+  end
+end

data/lib/json_api_client/version.rb

@@ -0,0 +1,3 @@
+module JsonApiClient
+  VERSION = "0.0.3"
+end

data/lib/json_api_client.rb

@@ -0,0 +1,18 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'json'
+
+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 :Links, 'json_api_client/links'
+  autoload :Middleware, 'json_api_client/middleware'
+  autoload :Parser, 'json_api_client/parser'
+  autoload :Query, 'json_api_client/query'
+  autoload :Resource, 'json_api_client/resource'
+  autoload :ResultSet, 'json_api_client/result_set'
+  autoload :Scope, 'json_api_client/scope'
+  autoload :Utils, 'json_api_client/utils'
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: json_api_client
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Jeff Ching
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Build client libraries compliant with specification defined by jsonapi.org
+email: ching.jeff@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/json_api_client/associations/base_association.rb
+- lib/json_api_client/associations/belongs_to.rb
+- lib/json_api_client/associations/has_many.rb
+- lib/json_api_client/associations/has_one.rb
+- lib/json_api_client/associations.rb
+- lib/json_api_client/attributes.rb
+- lib/json_api_client/connection.rb
+- lib/json_api_client/errors.rb
+- lib/json_api_client/links.rb
+- lib/json_api_client/middleware/json_request.rb
+- lib/json_api_client/middleware/status.rb
+- lib/json_api_client/middleware.rb
+- lib/json_api_client/parser.rb
+- lib/json_api_client/query/base.rb
+- lib/json_api_client/query/create.rb
+- lib/json_api_client/query/destroy.rb
+- lib/json_api_client/query/find.rb
+- lib/json_api_client/query/update.rb
+- lib/json_api_client/query.rb
+- lib/json_api_client/resource.rb
+- lib/json_api_client/result_set.rb
+- lib/json_api_client/scope.rb
+- lib/json_api_client/utils.rb
+- lib/json_api_client/version.rb
+- lib/json_api_client.rb
+- LICENSE
+- Rakefile
+- README.md
+homepage: http://github.com/chingor13/json_api_client
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Build client libraries compliant with specification defined by jsonapi.org
+test_files: []