json_api_client 0.9.6 → 1.0.0.beta

data/lib/json_api_client/connection.rb

@@ -6,7 +6,7 @@ module JsonApiClient
     def initialize(options = {})
       site = options.fetch(:site)
       @faraday = Faraday.new(site) do |builder|
-        builder.request :url_encoded
+        builder.request :json
         builder.use Middleware::JsonRequest
         builder.use Middleware::Status
         builder.use Middleware::ParseJson
@@ -15,7 +15,7 @@ module JsonApiClient
       yield(self) if block_given?
     end
 
-    # insert middleware before ParseJson - middleware executed in reverse order - 
+    # 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?
@@ -26,9 +26,9 @@ module JsonApiClient
       faraday.builder.delete(middleware)
     end
 
-    def execute(query)
-      faraday.send(query.request_method, query.path, query.params, query.headers)
+    def run(request_method, path, params = {}, headers = {})
+      faraday.send(request_method, path, params, headers)
     end
 
   end
-end
+end

data/lib/json_api_client/error_collector.rb

@@ -0,0 +1,29 @@
+module JsonApiClient
+  class ErrorCollector
+    class Error
+      include Helpers::DynamicAttributes
+
+      def initialize(attrs = {})
+        attrs = {
+          title: attrs
+        } if attrs.is_a?(String)
+        self.attributes = attrs
+      end
+    end
+
+    attr_reader :errors
+    extend Forwardable
+    def_delegators :errors, :length, :present?
+
+    def initialize(error_data)
+      @errors = Array(error_data).map do |datum|
+        Error.new(datum)
+      end
+    end
+
+    def full_messages
+      errors.map(&:title)
+    end
+
+  end
+end

data/lib/json_api_client/errors.rb

@@ -10,13 +10,15 @@ module JsonApiClient
     class ClientError < ApiError
     end
 
+    class AccessDenied < ClientError
+    end
+
+    class ConnectionError < ApiError
+    end
+
     class ServerError < ApiError
-      attr_reader :uri
-      def initialize(uri)
-        @uri = uri
-      end
       def message
-        "Internal server error at: #{uri.to_s}"
+        "Internal server error"
       end
     end
 

data/lib/json_api_client/helpers.rb

@@ -3,10 +3,13 @@ module JsonApiClient
     autoload :Associable, 'json_api_client/helpers/associable'
     autoload :Attributable, 'json_api_client/helpers/attributable'
     autoload :CustomEndpoints, 'json_api_client/helpers/custom_endpoints'
+    autoload :DynamicAttributes, 'json_api_client/helpers/dynamic_attributes'
     autoload :Initializable, 'json_api_client/helpers/initializable'
     autoload :Linkable, 'json_api_client/helpers/linkable'
+    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

data/lib/json_api_client/helpers/associable.rb

@@ -30,11 +30,12 @@ module JsonApiClient
         def path(params = nil)
           parts = [table_name]
           if params
-            slurp = params.symbolize_keys.slice(*prefix_params)
+            filters = params.fetch(:filter, params)
+            slurp = filters.slice(*prefix_params)
             prefix_params.each do |param|
-              params.delete(param)
+              filters.delete(param)
             end
-            parts.unshift(prefix_path % slurp)
+            parts.unshift(prefix_path % slurp.symbolize_keys)
           else
             parts.unshift(prefix_path)
           end

data/lib/json_api_client/helpers/attributable.rb

@@ -4,19 +4,22 @@ module JsonApiClient
       extend ActiveSupport::Concern
 
       included do
-        attr_reader :attributes
+        include DynamicAttributes
         attr_accessor :errors
         initializer do |obj, params|
-          obj.attributes = params
+          obj.attributes = params.merge(obj.class.default_attributes)
         end
       end
 
-      def attributes=(attrs = {})
-        @attributes ||= {}.with_indifferent_access
+      module ClassMethods
+        def load(params)
+          new(params).tap do |resource|
+            resource.mark_as_persisted!
+          end
+        end
 
-        return @attributes unless attrs.present?
-        attrs.each do |key, value|
-          set_attribute(key, value)
+        def default_attributes
+          {type: table_name}
         end
       end
 
@@ -25,8 +28,12 @@ module JsonApiClient
         save
       end
 
+      def mark_as_persisted!
+        @persisted = true
+      end
+
       def persisted?
-        attributes[primary_key].present?
+        !!@persisted && has_attribute?(primary_key)
       end
 
       def query_params
@@ -37,46 +44,8 @@ module JsonApiClient
         attributes.fetch(primary_key, "").to_s
       end
 
-      def [](key)
-        read_attribute(key)
-      end
-
-      def []=(key, value)
-        set_attribute(key, value)
-      end
-
-      def respond_to?(method, include_private = false)
-        if (method.to_s =~ /^(.*)=$/) || has_attribute?(method)
-          true
-        else
-          super
-        end
-      end
-
       protected
 
-      def method_missing(method, *args, &block)
-        if method.to_s =~ /^(.*)=$/
-          set_attribute($1, args.first)
-        elsif has_attribute?(method)
-          attributes[method]
-        else
-          super
-        end
-      end
-
-      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
-
       def ==(other)
         self.class == other.class && attributes == other.attributes
       end

data/lib/json_api_client/helpers/custom_endpoints.rb

@@ -18,11 +18,8 @@ module JsonApiClient
           end
           metaclass.instance_eval do
             define_method(name) do |*params|
-              input = {
-                name: name,
-                params: request_params = params.first || {}
-              }.merge(options)
-              run_request(Query::Custom.new(self, input))
+              request_params = params.first || {}
+              requestor.custom(name, options, request_params)
             end
           end
         end
@@ -31,11 +28,7 @@ module JsonApiClient
           define_method name do |*params|
             request_params = params.first || {}
             request_params[self.class.primary_key] = attributes.fetch(primary_key)
-            input = {
-              name: name, 
-              params: request_params
-            }.merge(options)
-            run_request(Query::Custom.new(self.class, input))
+            self.class.requestor.custom(name, options, request_params)
           end
         end
       end

data/lib/json_api_client/helpers/dynamic_attributes.rb

@@ -0,0 +1,61 @@
+module JsonApiClient
+  module Helpers
+    module DynamicAttributes
+      extend ActiveSupport::Concern
+
+      def attributes
+        @attributes
+      end
+
+      def attributes=(attrs = {})
+        @attributes ||= {}.with_indifferent_access
+
+        return @attributes unless attrs.present?
+        attrs.each do |key, value|
+          set_attribute(key, value)
+        end
+      end
+
+      def [](key)
+        read_attribute(key)
+      end
+
+      def []=(key, value)
+        set_attribute(key, value)
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        if (method.to_s =~ /^(.*)=$/) || has_attribute?(method)
+          true
+        else
+          super
+        end
+      end
+
+      def has_attribute?(attr_name)
+        attributes.has_key?(attr_name)
+      end
+
+      protected
+
+      def method_missing(method, *args, &block)
+        if method.to_s =~ /^(.*)=$/
+          set_attribute($1, args.first)
+        elsif has_attribute?(method)
+          attributes[method]
+        else
+          super
+        end
+      end
+
+      def read_attribute(name)
+        attributes.fetch(name, nil)
+      end
+
+      def set_attribute(name, value)
+        attributes[name] = value
+      end
+
+    end
+  end
+end

data/lib/json_api_client/helpers/linkable.rb

@@ -4,35 +4,45 @@ module JsonApiClient
       extend ActiveSupport::Concern
 
       included do
-        attr_accessor :links,
-                      :linked_data
+        class_attribute :linker
+        self.linker = Linking::Links
+
+        # the links for this resource
+        attr_accessor :links
+
+        # reference to all of the preloaded data
+        attr_accessor :linked_data
 
         initializer do |obj, params|
-          if params && links = params.delete("links")
-            obj.links = links
-          end
+          links = params && params.delete("links")
+          links ||= {}
+          obj.links = obj.linker.new(links)
         end
       end
 
-      def method_missing(method, *args)
-        return super unless has_link?(method)
-
-        linked_data.data_for(method, links[method.to_s])
+      def as_link
+        {
+          :type => self.class.table_name,
+          primary_key => self[primary_key]
+        }
       end
 
-      def respond_to?(symbol, include_all = false)
-        return true if has_link?(symbol)
-        super
+      def attributes
+        super.tap do |attrs|
+          attrs.merge!(links: links.attributes) if links.present?
+        end
       end
 
-      private
+      def method_missing(method, *args)
+        return super unless links && links.has_attribute?(method)
+        linked_data.data_for(method, links[method])
+      end
 
-      def has_link?(symbol)
-        links && 
-          links.has_key?(symbol.to_s) &&
-          linked_data && 
-          linked_data.has_link?(symbol.to_s)
+      def respond_to_missing?(symbol, include_all = false)
+        return true if links && links.has_attribute?(symbol)
+        super
       end
+
     end
   end
 end

data/lib/json_api_client/helpers/paginatable.rb

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

data/lib/json_api_client/helpers/parsable.rb

@@ -5,7 +5,7 @@ module JsonApiClient
 
       included do
         class_attribute :parser
-        self.parser = Parser
+        self.parser = Parsers::Parser
       end
 
       module ClassMethods

data/lib/json_api_client/helpers/queryable.rb

@@ -6,16 +6,17 @@ module JsonApiClient
       included do
         class << self
           extend Forwardable
-          def_delegators :new_scope, :where, :order, :includes, :all, :paginate, :page, :first
+          def_delegators :new_scope, :where, :order, :includes, :select, :all, :paginate, :page, :first
         end
-        class_attribute :connection_class, :connection_object, :connection_options
+        class_attribute :connection_class, :connection_object, :connection_options, :query_builder
         self.connection_class = Connection
         self.connection_options = {}
+        self.query_builder = Query::Builder
       end
 
       module ClassMethods
         def new_scope
-          Scope.new(self)
+          query_builder.new(self)
         end
 
         def connection(&block)

data/lib/json_api_client/helpers/requestable.rb

@@ -0,0 +1,60 @@
+module JsonApiClient
+  module Helpers
+    module Requestable
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :last_result_set, :errors
+        class_attribute :requestor_class
+        self.requestor_class = Query::Requestor
+      end
+
+      module ClassMethods
+        def find(conditions)
+          requestor.find(conditions)
+        end
+
+        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
+
+        if last_result_set.has_errors?
+          self.errors = last_result_set.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