json_api_client 1.0.0.beta5 → 1.0.0.beta6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf70c1b87181f83e74d93e6711ff52d3ba70cf49
-  data.tar.gz: 065d5cf0d8559fbe051f312643763f0b508dd351
+  metadata.gz: c39c70dd7ca6c162a658718790120555ac010083
+  data.tar.gz: 83eaa82464904a5761933f4b2f41576f280a281a
 SHA512:
-  metadata.gz: 8bf495991e43b1e034a4e23c915af9b18130c9a58fe1882927f5ffa9aac3b33ecd1b66c658c3f8ece03164579adcc46234356487a3e1e2aa15871ff280892577
-  data.tar.gz: e588c5bec7188484fa1f215660187cc69acd23dc5c8431d34bf58fc4d54a0aafd75748318f8c1bb06291bdddad73a97388317c24c0a9cca75911c4d3f980fb4c
+  metadata.gz: 36612db285d7249f01b5cfbff6594297ed3c838faee90b5d646ad9c51767b6cbd1bc4511063416691f19db92e06fecf54d60aa47c1d0fa23701ca43eaced2b92
+  data.tar.gz: ad590905aa3c8921ccd199525ad367465acfd048e3516da9722f364c39bdcbd0dbf01d5f4c84a12b9e43c3e9e68cebee16eb73c67436c69ac7ea014d7d270e42

data/lib/json_api_client/helpers/callbacks.rb

@@ -0,0 +1,27 @@
+module JsonApiClient
+  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/json_api_client/helpers/dirty.rb

@@ -0,0 +1,71 @@
+module JsonApiClient
+  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]
+        super
+      end
+
+    end
+  end
+end

data/lib/json_api_client/helpers/dynamic_attributes.rb

@@ -7,7 +7,7 @@ module JsonApiClient
       end
 
       def attributes=(attrs = {})
-        @attributes ||= {}.with_indifferent_access
+        @attributes ||= ActiveSupport::HashWithIndifferentAccess.new
 
         return @attributes unless attrs.present?
         attrs.each do |key, value|

data/lib/json_api_client/helpers.rb

@@ -1,18 +1,7 @@
 module JsonApiClient
   module Helpers
-    autoload :Associable, 'json_api_client/helpers/associable'
-    autoload :Attributable, 'json_api_client/helpers/attributable'
-    autoload :CustomEndpoints, 'json_api_client/helpers/custom_endpoints'
-    autoload :CustomHeaders, 'json_api_client/helpers/custom_headers'
+    autoload :Callbacks, 'json_api_client/helpers/callbacks'
+    autoload :Dirty, 'json_api_client/helpers/dirty'
     autoload :DynamicAttributes, 'json_api_client/helpers/dynamic_attributes'
-    autoload :Initializable, 'json_api_client/helpers/initializable'
-    autoload :Linkable, 'json_api_client/helpers/linkable'
-    autoload :Relatable, 'json_api_client/helpers/relatable'
-    autoload :Paginatable, 'json_api_client/helpers/paginatable'
-    autoload :Parsable, 'json_api_client/helpers/parsable'
-    autoload :Queryable, 'json_api_client/helpers/queryable'
-    autoload :Requestable, 'json_api_client/helpers/requestable'
-    autoload :Schemable, 'json_api_client/helpers/schemable'
-    autoload :Serializable, 'json_api_client/helpers/serializable'
   end
 end

data/lib/json_api_client/included_data.rb

@@ -10,7 +10,7 @@ module JsonApiClient
         h[type] = records.map do |datum|
           params = klass.parser.parameters_from_resource(datum)
           resource = klass.load(params)
-          resource.result_set = result_set
+          resource.last_result_set = result_set
           resource
         end.index_by(&:id)
         h

data/lib/json_api_client/parsers/parser.rb

@@ -3,7 +3,8 @@ module JsonApiClient
     class Parser
       class << self
         def parse(klass, response)
-          data = response.body
+          data = response.body.present? ? response.body : {}
+
           ResultSet.new.tap do |result_set|
             result_set.record_class = klass
             result_set.uri = response.env[:url]
@@ -66,7 +67,7 @@ module JsonApiClient
           results = [results] unless results.is_a?(Array)
           resources = results.map do |res|
             resource = result_set.record_class.load(parameters_from_resource(res))
-            resource.result_set = result_set
+            resource.last_result_set = result_set
             resource
           end
           result_set.concat(resources)

data/lib/json_api_client/query/requestor.rb

@@ -10,13 +10,13 @@ module JsonApiClient
       # expects a record
       def create(record)
         request(:post, klass.path(record.attributes), {
-          data: record.serializable_hash
+          data: record.as_json_api
         })
       end
 
       def update(record)
         request(:patch, resource_path(record.attributes), {
-          data: record.serializable_hash
+          data: record.as_json_api
         })
       end
 
@@ -60,7 +60,7 @@ module JsonApiClient
       end
 
       def request(type, path, params)
-        klass.parse(connection.run(type, path, params, klass.custom_headers))
+        klass.parser.parse(klass, connection.run(type, path, params, klass.custom_headers))
       end
 
     end

data/lib/json_api_client/relationships/relations.rb

@@ -2,32 +2,43 @@ module JsonApiClient
   module Relationships
     class Relations
       include Helpers::DynamicAttributes
+      include Helpers::Dirty
+      include ActiveModel::Serialization
 
       def initialize(relations)
         self.attributes = relations
+        clear_changes_information
       end
 
       def present?
         attributes.present?
       end
 
-      def serializable_hash
-        Hash[attributes.map do |k, v|
-          [k, v.slice("data")]
-        end]
+      def as_json_api
+        Hash[attributes_for_serialization.map do |k, v|
+               [k, v.slice("data")]  if v.has_key?("data")
+             end.compact]
+      end
+
+      def attributes_for_serialization
+        attributes.slice(*changed)
       end
 
       protected
 
       def set_attribute(name, value)
-        attributes[name] = case value
+        value = case value
         when JsonApiClient::Resource
           {data: value.as_relation}
         when Array
           {data: value.map(&:as_relation)}
+        when NilClass
+          {data: nil}
         else
           value
         end
+        attribute_will_change!(name) if value != attributes[name]
+        attributes[name] = value
       end
 
     end

data/lib/json_api_client/resource.rb

@@ -1,40 +1,413 @@
 require 'forwardable'
 require 'active_support/all'
+require 'active_model'
 
 module JsonApiClient
   class Resource
-    attr_accessor :result_set
-    class_attribute :site, :primary_key
-    self.primary_key = :id
+    extend ActiveModel::Naming
+    extend ActiveModel::Translation
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+    include ActiveModel::Serialization
+
+    include Helpers::DynamicAttributes
+    include Helpers::Dirty
+
+    attr_accessor :last_result_set,
+                  :links,
+                  :relationships
+    class_attribute :site,
+                    :primary_key,
+                    :parser,
+                    :paginator,
+                    :connection_class,
+                    :connection_object,
+                    :connection_options,
+                    :query_builder,
+                    :linker,
+                    :relationship_linker,
+                    :read_only_attributes,
+                    :requestor_class,
+                    :associations,
+                    instance_accessor: false
+    self.primary_key          = :id
+    self.parser               = Parsers::Parser
+    self.paginator            = Paginating::Paginator
+    self.connection_class     = Connection
+    self.connection_options   = {}
+    self.query_builder        = Query::Builder
+    self.linker               = Linking::Links
+    self.relationship_linker  = Relationships::Relations
+    self.read_only_attributes = [:id, :type, :links, :meta, :relationships]
+    self.requestor_class      = Query::Requestor
+    self.associations         = []
+
+    include Associations::BelongsTo
+    include Associations::HasMany
+    include Associations::HasOne
 
     class << self
-      # base URL for this resource
-      def resource
-        File.join(site, path)
-      end
+      extend Forwardable
+      def_delegators :_new_scope, :where, :order, :includes, :select, :all, :paginate, :page, :first, :find
 
+      # The table name for this resource. i.e. Article -> articles, Person -> people
+      #
+      # @return [String] The table name for this resource
       def table_name
         resource_name.pluralize
       end
 
+      # The name of a single resource. i.e. Article -> article, Person -> person
+      #
+      # @return [String]
       def resource_name
         name.demodulize.underscore
       end
+
+      # Load a resource object from attributes and consider it persisted
+      #
+      # @return [Resource] Persisted resource object
+      def load(params)
+        new(params).tap do |resource|
+          resource.mark_as_persisted!
+          resource.clear_changes_information
+        end
+      end
+
+      # Return/build a connection object
+      #
+      # @return [Connection] The connection to the json api server
+      def connection(rebuild = false, &block)
+        _build_connection(&block)
+        connection_object
+      end
+
+      # Param names that will be considered path params. They will be used
+      # to build the resource path rather than treated as attributes
+      #
+      # @return [Array] Param name symbols of parameters that will be treated as path parameters
+      def prefix_params
+        _belongs_to_associations.map(&:param)
+      end
+
+      # Return the path or path pattern for this resource
+      def path(params = nil)
+        parts = [table_name]
+        if params
+          path_params = params.delete(:path) || params
+          parts.unshift(_prefix_path % path_params.symbolize_keys)
+        else
+          parts.unshift(_prefix_path)
+        end
+        parts.reject!{|part| part == "" }
+        File.join(*parts)
+      rescue KeyError
+        raise ArgumentError, "Not all prefix parameters specified"
+      end
+
+      # Create a new instance of this resource class
+      #
+      # @param attributes [Hash] The attributes to create this resource with
+      # @return [Resource] The instance you tried to create. You will have to check the persisted state or errors on this object to see success/failure.
+      def create(attributes = {})
+        new(attributes).tap do |resource|
+          resource.save
+        end
+      end
+
+      # Within the given block, add these headers to all requests made by
+      # the resource class
+      #
+      # @param headers [Hash] The headers to send along
+      # @param block [Block] The block where headers will be set for
+      def with_headers(headers)
+        self._custom_headers = headers
+        yield
+      ensure
+        self._custom_headers = {}
+      end
+
+      # The current custom headers to send with any request made by this
+      # resource class
+      #
+      # @return [Hash] Headers
+      def custom_headers
+        _header_store.to_h
+      end
+
+      # Returns the requestor for this resource class
+      #
+      # @return [Requestor] The requestor for this resource class
+      def requestor
+        @requestor ||= requestor_class.new(self)
+      end
+
+      # Default attributes that every instance of this resource should be
+      # intialized with. Optionally, override this method in a subclass.
+      #
+      # @return [Hash] Default attributes
+      def default_attributes
+        {type: table_name}
+      end
+
+      # Returns the schema for this resource class
+      #
+      # @return [Schema] The schema for this resource class
+      def schema
+        @schema ||= Schema.new
+      end
+
+      protected
+
+      # Declares a new class/instance method that acts on the collection/member
+      #
+      # @param name [Symbol] the name of the endpoint
+      # @param options [Hash] endpoint options
+      # @option [Symbol] :on One of [:collection or :member] to decide whether it's a collect or member method
+      # @option [Symbol] :request_method The request method (:get, :post, etc)
+      def custom_endpoint(name, options = {})
+        if :collection == options.delete(:on)
+          collection_endpoint(name, options)
+        else
+          member_endpoint(name, options)
+        end
+      end
+
+      # Declares a new class method that acts on the collection
+      #
+      # @param name [Symbol] the name of the endpoint and the method name
+      # @param options [Hash] endpoint options
+      # @option options [Symbol] :request_method The request method (:get, :post, etc)
+      def collection_endpoint(name, options = {})
+        metaclass = class << self
+          self
+        end
+        metaclass.instance_eval do
+          define_method(name) do |*params|
+            request_params = params.first || {}
+            requestor.custom(name, options, request_params)
+          end
+        end
+      end
+
+      # Declares a new instance method that acts on the member object
+      #
+      # @param name [Symbol] the name of the endpoint and the method name
+      # @param options [Hash] endpoint options
+      # @option options [Symbol] :request_method The request method (:get, :post, etc)
+      def member_endpoint(name, options = {})
+        define_method name do |*params|
+          request_params = params.first || {}
+          request_params[self.class.primary_key] = attributes.fetch(self.class.primary_key)
+          self.class.requestor.custom(name, options, request_params)
+        end
+      end
+
+      # Declares a new property by name
+      #
+      # @param name [Symbol] the name of the property
+      # @param options [Hash] property options
+      # @option options [Symbol] :type The property type
+      # @option options [Symbol] :default The default value for the property
+      def property(name, options = {})
+        schema.add(name, options)
+      end
+
+      # Declare multiple properties with the same optional options
+      #
+      # @param [Array<Symbol>] names
+      # @param options [Hash] property options
+      # @option options [Symbol] :type The property type
+      # @option options [Symbol] :default The default value for the property
+      def properties(*names)
+        options = names.last.is_a?(Hash) ? names.pop : {}
+        names.each do |name|
+          property name, options
+        end
+      end
+
+      def _belongs_to_associations
+        associations.select{|association| association.is_a?(Associations::BelongsTo::Association) }
+      end
+
+      def _prefix_path
+        _belongs_to_associations.map(&:to_prefix_path).join("/")
+      end
+
+      def _new_scope
+        query_builder.new(self)
+      end
+
+      def _custom_headers=(headers)
+        _header_store.replace(headers)
+      end
+
+      def _header_store
+        Thread.current["json_api_client-#{resource_name}"] ||= {}
+      end
+
+      def _build_connection(rebuild = false)
+        return connection_object unless connection_object.nil? || rebuild
+        self.connection_object = connection_class.new(connection_options.merge(site: site)).tap do |conn|
+          yield(conn) if block_given?
+        end
+      end
+    end
+
+    # Instantiate a new resource object
+    #
+    # @param params [Hash] Attributes, links, and relationships
+    def initialize(params = {})
+      self.links = self.class.linker.new(params.delete("links") || {})
+      self.relationships = self.class.relationship_linker.new(params.delete("relationships") || {})
+      self.class.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
+      self.attributes = params.merge(self.class.default_attributes)
+      self.class.schema.each_property do |property|
+        attributes[property.name] = property.default unless attributes.has_key?(property.name)
+      end
+    end
+
+    # Set the current attributes and try to save them
+    #
+    # @param attrs [Hash] Attributes to update
+    # @return [Boolean] Whether the update succeeded or not
+    def update_attributes(attrs = {})
+      self.attributes = attrs
+      save
+    end
+
+    # Mark the record as persisted
+    def mark_as_persisted!
+      @persisted = true
+    end
+
+    # Whether or not this record has been persisted to the database previously
+    #
+    # @return [Boolean]
+    def persisted?
+      !!@persisted && has_attribute?(self.class.primary_key)
     end
 
-    include Helpers::Initializable
-    include Helpers::Attributable
-    include Helpers::Associable
-    include Helpers::Parsable
-    include Helpers::Queryable
-    include Helpers::Serializable
-    include Helpers::Linkable
-    include Helpers::Relatable
-    include Helpers::CustomEndpoints
-    include Helpers::Schemable
-    include Helpers::Paginatable
-    include Helpers::Requestable
-    include Helpers::CustomHeaders
+    # Returns true if this is a new record (never persisted to the database)
+    #
+    # @return [Boolean]
+    def new_record?
+      !persisted?
+    end
+
+    # When we represent this resource as a relationship, we do so with id & type
+    #
+    # @return [Hash] Representation of this object as a relation
+    def as_relation
+      attributes.slice(:type, self.class.primary_key)
+    end
+
+    # When we represent this resource for serialization (create/update), we do so
+    # with this implementation
+    #
+    # @return [Hash] Representation of this object as JSONAPI object
+    def as_json_api(*)
+      attributes.slice(:id, :type).tap do |h|
+        relationships_for_serialization.tap do |r|
+          h[:relationships] = r unless r.empty?
+        end
+        h[:attributes] = attributes_for_serialization
+      end
+    end
+
+    # Mark all attributes for this record as dirty
+    def set_all_dirty!
+      set_all_attributes_dirty
+      relationships.set_all_attributes_dirty if relationships
+    end
+
+    # Commit the current changes to the resource to the remote server.
+    # If the resource was previously loaded from the server, we will
+    # try to update the record. Otherwise if it's a new record, then
+    # we will try to create it
+    #
+    # @return [Boolean] Whether or not the save succeeded
+    def save
+      return false unless valid?
+
+      self.last_result_set = if persisted?
+        self.class.requestor.update(self)
+      else
+        self.class.requestor.create(self)
+      end
 
+      if last_result_set.has_errors?
+        last_result_set.errors.each do |error|
+          if error.source_parameter
+            errors.add(error.source_parameter, error.title)
+          else
+            errors.add(:base, error.title)
+          end
+        end
+        false
+      else
+        self.errors.clear if self.errors
+        mark_as_persisted!
+        if updated = last_result_set.first
+          self.attributes = updated.attributes
+        end
+        true
+      end
+    end
+
+    # Try to destroy this resource
+    #
+    # @return [Boolean] Whether or not the destroy succeeded
+    def destroy
+      self.last_result_set = self.class.requestor.destroy(self)
+      if !last_result_set.has_errors?
+        self.attributes.clear
+        true
+      else
+        false
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name}:@attributes=#{attributes.inspect}>"
+    end
+
+    protected
+
+    def method_missing(method, *args)
+      return super unless relationships && relationships.has_attribute?(method) && last_result_set.included
+      last_result_set.included.data_for(method, relationships[method])
+    end
+
+    def respond_to_missing?(symbol, include_all = false)
+      return true if relationships && relationships.has_attribute?(symbol)
+      super
+    end
+
+    def set_attribute(name, value)
+      property = property_for(name)
+      value = property.cast(value) if property
+      super(name, value)
+    end
+
+    def has_attribute?(attr_name)
+      !!property_for(attr_name) || super
+    end
+
+    def property_for(name)
+      self.class.schema.find(name)
+    end
+
+    def attributes_for_serialization
+      attributes.except(*self.class.read_only_attributes).slice(*changed)
+    end
+
+    def relationships_for_serialization
+      relationships.as_json_api
+    end
   end
 end

data/lib/json_api_client/version.rb

@@ -1,3 +1,3 @@
 module JsonApiClient
-  VERSION = "1.0.0.beta5"
+  VERSION = "1.0.0.beta6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_api_client
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta5
+  version: 1.0.0.beta6
 platform: ruby
 authors:
 - Jeff Ching
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-13 00:00:00.000000000 Z
+date: 2015-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -113,20 +127,9 @@ files:
 - lib/json_api_client/error_collector.rb
 - lib/json_api_client/errors.rb
 - lib/json_api_client/helpers.rb
-- lib/json_api_client/helpers/associable.rb
-- lib/json_api_client/helpers/attributable.rb
-- lib/json_api_client/helpers/custom_endpoints.rb
-- lib/json_api_client/helpers/custom_headers.rb
+- lib/json_api_client/helpers/callbacks.rb
+- lib/json_api_client/helpers/dirty.rb
 - lib/json_api_client/helpers/dynamic_attributes.rb
-- lib/json_api_client/helpers/initializable.rb
-- lib/json_api_client/helpers/linkable.rb
-- lib/json_api_client/helpers/paginatable.rb
-- lib/json_api_client/helpers/parsable.rb
-- lib/json_api_client/helpers/queryable.rb
-- lib/json_api_client/helpers/relatable.rb
-- lib/json_api_client/helpers/requestable.rb
-- lib/json_api_client/helpers/schemable.rb
-- lib/json_api_client/helpers/serializable.rb
 - lib/json_api_client/implementation.rb
 - lib/json_api_client/included_data.rb
 - lib/json_api_client/linking.rb
@@ -172,9 +175,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Build client libraries compliant with specification defined by jsonapi.org
 test_files: []
-has_rdoc: 

data/lib/json_api_client/helpers/associable.rb

@@ -1,57 +0,0 @@
-module JsonApiClient
-  module Helpers
-    module Associable
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :associations, instance_accessor: false
-        self.associations = []
-
-        include Associations::BelongsTo
-        include Associations::HasMany
-        include Associations::HasOne
-
-        initializer :load_associations
-      end
-
-      module ClassMethods
-        def belongs_to_associations
-          associations.select{|association| association.is_a?(Associations::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
-            path_params = params.delete(:path) || params
-            parts.unshift(prefix_path % path_params.symbolize_keys)
-          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)
-        self.class.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
-end

data/lib/json_api_client/helpers/attributable.rb

@@ -1,55 +0,0 @@
-module JsonApiClient
-  module Helpers
-    module Attributable
-      extend ActiveSupport::Concern
-
-      included do
-        include DynamicAttributes
-        attr_accessor :errors
-        initializer do |obj, params|
-          obj.attributes = params.merge(obj.class.default_attributes)
-        end
-      end
-
-      module ClassMethods
-        def load(params)
-          new(params).tap do |resource|
-            resource.mark_as_persisted!
-          end
-        end
-
-        def default_attributes
-          {type: table_name}
-        end
-      end
-
-      def update_attributes(attrs = {})
-        self.attributes = attrs
-        save
-      end
-
-      def mark_as_persisted!
-        @persisted = true
-      end
-
-      def persisted?
-        !!@persisted && has_attribute?(primary_key)
-      end
-
-      def query_params
-        attributes.except(primary_key)
-      end
-
-      def to_param
-        attributes.fetch(primary_key, "").to_s
-      end
-
-      protected
-
-      def ==(other)
-        self.class == other.class && attributes == other.attributes
-      end
-
-    end
-  end
-end

data/lib/json_api_client/helpers/custom_endpoints.rb

@@ -1,37 +0,0 @@
-module JsonApiClient
-  module Helpers
-    module CustomEndpoints
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        def custom_endpoint(name, options = {})
-          if :collection == options.delete(:on)
-            collection_endpoint(name, options)
-          else
-            member_endpoint(name, options)
-          end
-        end
-
-        def collection_endpoint(name, options = {})
-          metaclass = class << self
-            self
-          end
-          metaclass.instance_eval do
-            define_method(name) do |*params|
-              request_params = params.first || {}
-              requestor.custom(name, options, request_params)
-            end
-          end
-        end
-
-        def member_endpoint(name, options = {})
-          define_method name do |*params|
-            request_params = params.first || {}
-            request_params[self.class.primary_key] = attributes.fetch(primary_key)
-            self.class.requestor.custom(name, options, request_params)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/json_api_client/helpers/custom_headers.rb

@@ -1,31 +0,0 @@
-module JsonApiClient
-  module Helpers
-    module CustomHeaders
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        def with_headers(headers)
-          self.custom_headers = headers
-          yield
-        ensure
-          self.custom_headers = {}
-        end
-
-        def custom_headers
-          header_store
-        end
-
-        def custom_headers=(headers)
-          header_store.replace(headers)
-        end
-
-        protected
-
-        def header_store
-          Thread.current["json_api_client-#{resource_name}"] ||= {}
-        end
-      end
-
-    end
-  end
-end

data/lib/json_api_client/helpers/initializable.rb

@@ -1,28 +0,0 @@
-module JsonApiClient
-  module Helpers
-    module Initializable
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :initializers, instance_accessor: false
-        self.initializers = []
-      end
-
-      module ClassMethods
-        def initializer(method = nil, &block)
-          self.initializers.push(method || block)
-        end
-      end
-
-      def initialize(params = {})
-        self.class.initializers.each do |initializer|
-          if initializer.respond_to?(:call)
-            initializer.call(self, params)
-          else
-            self.send(initializer, params)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/json_api_client/helpers/linkable.rb

@@ -1,22 +0,0 @@
-module JsonApiClient
-  module Helpers
-    module Linkable
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :linker, instance_accessor: false
-        self.linker = Linking::Links
-
-        # the links for this resource
-        attr_accessor :links
-
-        initializer do |obj, params|
-          links = params && params.delete("links")
-          links ||= {}
-          obj.links = obj.class.linker.new(links)
-        end
-      end
-
-    end
-  end
-end

data/lib/json_api_client/helpers/paginatable.rb

@@ -1,14 +0,0 @@
-module JsonApiClient
-  module Helpers
-    module Paginatable
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :paginator, instance_accessor: false
-        self.paginator = Paginating::Paginator
-      end
-
-    end
-  end
-end
-

data/lib/json_api_client/helpers/parsable.rb

@@ -1,19 +0,0 @@
-module JsonApiClient
-  module Helpers
-    module Parsable
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :parser, instance_accessor: false
-        self.parser = Parsers::Parser
-      end
-
-      module ClassMethods
-        def parse(data)
-          parser.parse(self, data)
-        end
-      end
-
-    end
-  end
-end

data/lib/json_api_client/helpers/queryable.rb

@@ -1,37 +0,0 @@
-module JsonApiClient
-  module Helpers
-    module Queryable
-      extend ActiveSupport::Concern
-
-      included do
-        class << self
-          extend Forwardable
-          def_delegators :new_scope, :where, :order, :includes, :select, :all, :paginate, :page, :first, :find
-        end
-        class_attribute :connection_class, :connection_object, :connection_options, :query_builder, instance_accessor: false
-        self.connection_class = Connection
-        self.connection_options = {}
-        self.query_builder = Query::Builder
-      end
-
-      module ClassMethods
-        def new_scope
-          query_builder.new(self)
-        end
-
-        def connection(&block)
-          build_connection(&block)
-          connection_object
-        end
-
-        def build_connection
-          return connection_object unless connection_object.nil?
-          self.connection_object = connection_class.new(connection_options.merge(site: site)).tap do |conn|
-            yield(conn) if block_given?
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/json_api_client/helpers/relatable.rb

@@ -1,39 +0,0 @@
-module JsonApiClient
-  module Helpers
-    module Relatable
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :relationship_linker, instance_accessor: false
-        self.relationship_linker = Relationships::Relations
-
-        # the relationships for this resource
-        attr_accessor :relationships
-
-        initializer do |obj, params|
-          relationships = params && params.delete("relationships")
-          relationships ||= {}
-          obj.relationships = obj.class.relationship_linker.new(relationships)
-        end
-      end
-
-      def as_relation
-        {
-          :type => self.class.table_name,
-          primary_key => self[primary_key]
-        }
-      end
-
-      def method_missing(method, *args)
-        return super unless relationships and relationships.has_attribute?(method) and result_set.included
-        result_set.included.data_for(method, relationships[method])
-      end
-
-      def respond_to_missing?(symbol, include_all = false)
-        return true if relationships && relationships.has_attribute?(symbol)
-        super
-      end
-
-    end
-  end
-end

data/lib/json_api_client/helpers/requestable.rb

@@ -1,56 +0,0 @@
-module JsonApiClient
-  module Helpers
-    module Requestable
-      extend ActiveSupport::Concern
-
-      included do
-        attr_accessor :last_result_set, :errors
-        class_attribute :requestor_class, instance_accessor: false
-        self.requestor_class = Query::Requestor
-      end
-
-      module ClassMethods
-        def create(conditions = {})
-          new(conditions).tap do |resource|
-            resource.save
-          end
-        end
-
-        def requestor
-          @requestor ||= requestor_class.new(self)
-        end
-      end
-
-      def save
-        self.last_result_set = if persisted?
-          self.class.requestor.update(self)
-        else
-          self.class.requestor.create(self)
-        end
-
-        self.errors = last_result_set.errors
-        if last_result_set.has_errors?
-          false
-        else
-          self.errors.clear if self.errors
-          mark_as_persisted!
-          if updated = last_result_set.first
-            self.attributes = updated.attributes
-          end
-          true
-        end
-      end
-
-      def destroy
-        self.last_result_set = self.class.requestor.destroy(self)
-        if !last_result_set.has_errors?
-          self.attributes.clear
-          true
-        else
-          false
-        end
-      end
-
-    end
-  end
-end

data/lib/json_api_client/helpers/schemable.rb

@@ -1,68 +0,0 @@
-module JsonApiClient
-  module Helpers
-    module Schemable
-      extend ActiveSupport::Concern
-
-      included do
-        initializer do |obj, params|
-          obj.send(:set_default_values)
-        end
-      end
-
-      module ClassMethods
-        # Returns the schema for this resource class
-        #
-        # @return [Schema] the schema for this resource class
-        def schema
-          @schema ||= Schema.new
-        end
-
-        # Declares a new property by name
-        #
-        # @param name [Symbol] the name of the property
-        # @param options [Hash] property options
-        # @option options [Symbol] :type The property type
-        # @option options [Symbol] :default The default value for the property
-        def property(name, options = {})
-          schema.add(name, options)
-        end
-
-        # Declare multiple properties with the same optional options
-        #
-        # @param [Array<Symbol>] names
-        # @param options [Hash] property options
-        # @option options [Symbol] :type The property type
-        # @option options [Symbol] :default The default value for the property
-        def properties(*names)
-          options = names.last.is_a?(Hash) ? names.pop : {}
-          names.each do |name|
-            property name, options
-          end
-        end
-      end
-
-      protected
-
-      def set_attribute(name, value)
-        property = property_for(name)
-        value = property.cast(value) if property
-        super(name, value)
-      end
-
-      def has_attribute?(attr_name)
-        !!property_for(attr_name) || super
-      end
-
-      def set_default_values
-        self.class.schema.each_property do |property|
-          attributes[property.name] = property.default unless attributes.has_key?(property.name)
-        end
-      end
-
-      def property_for(name)
-        self.class.schema.find(name)
-      end
-
-    end
-  end
-end

data/lib/json_api_client/helpers/serializable.rb

@@ -1,28 +0,0 @@
-module JsonApiClient
-  module Helpers
-    module Serializable
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :read_only_attributes, instance_accessor: false
-        self.read_only_attributes = ['id', 'type', 'links', 'meta', 'relationships']
-      end
-
-      def serializable_hash
-        attributes.slice('id', 'type').tap do |h|
-          relationships.serializable_hash.tap do |r|
-            h['relationships'] = r unless r.empty?
-          end
-          h['attributes'] = attributes_for_serialization
-        end
-      end
-
-      protected
-
-      def attributes_for_serialization
-        attributes.except(*self.class.read_only_attributes)
-      end
-
-    end
-  end
-end