json_api_client 0.9.6 → 1.0.0.beta

data/lib/json_api_client/linking.rb

@@ -0,0 +1,7 @@
+module JsonApiClient
+  module Linking
+    autoload :IncludedData, "json_api_client/linking/included_data"
+    autoload :Links, "json_api_client/linking/links"
+    autoload :TopLevelLinks, "json_api_client/linking/top_level_links"
+  end
+end

data/lib/json_api_client/linking/included_data.rb

@@ -0,0 +1,40 @@
+module JsonApiClient
+  module Linking
+    class IncludedData
+      attr_reader :data
+
+      def initialize(record_class, data)
+        grouped_data = data.group_by{|datum| datum["type"]}
+        @data = grouped_data.inject({}) do |h, (type, records)|
+          klass = Utils.compute_type(record_class, type.singularize.classify)
+          h[type] = records.map{|datum| klass.new(datum)}.index_by(&:id)
+          h
+        end
+      end
+
+      def data_for(method_name, definition)
+        linkage = definition["linkage"]
+        if linkage.is_a?(Array)
+          # has_many link
+          linkage.map do |link_def|
+            record_for(link_def)
+          end
+        else
+          # has_one link
+          record_for(linkage)
+        end
+      end
+
+      def has_link?(name)
+        data.has_key?(name)
+      end
+
+      private
+
+      # should return a resource record of some type for this linked document
+      def record_for(link_def)
+        data[link_def["type"]][link_def["id"]]
+      end
+    end
+  end
+end

data/lib/json_api_client/linking/links.rb

@@ -0,0 +1,29 @@
+module JsonApiClient
+  module Linking
+    class Links
+      include Helpers::DynamicAttributes
+
+      def initialize(links)
+        self.attributes = links
+      end
+
+      def present?
+        attributes.present?
+      end
+
+      protected
+
+      def set_attribute(name, value)
+        attributes[name] = case value
+        when JsonApiClient::Resource
+          {linkage: value.as_link}
+        when Array
+          {linkage: value.map(&:as_link)}
+        else
+          value
+        end
+      end
+
+    end
+  end
+end

data/lib/json_api_client/linking/top_level_links.rb

@@ -0,0 +1,30 @@
+module JsonApiClient
+  module Linking
+    class TopLevelLinks
+
+      attr_reader :links, :record_class
+
+      def initialize(record_class, links)
+        @links = links
+        @record_class = record_class
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        links.has_key?(method.to_s) || super
+      end
+
+      def method_missing(method, *args)
+        if respond_to_missing?(method)
+          fetch_link(method)
+        else
+          super
+        end
+      end
+
+      def fetch_link(link_name)
+        link_definition = links.fetch(link_name.to_s)
+        record_class.requestor.linked(link_definition)
+      end
+    end
+  end
+end

data/lib/json_api_client/meta_data.rb

@@ -0,0 +1,10 @@
+module JsonApiClient
+  class MetaData
+    include Helpers::DynamicAttributes
+
+    def initialize(data)
+      self.attributes = data
+    end
+
+  end
+end

data/lib/json_api_client/middleware/json_request.rb

@@ -2,11 +2,10 @@ 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$/) 
+        environment[:request_headers]["Content-Type"] = 'application/vnd.api+json'
+        environment[:request_headers]["Accept"] = 'application/vnd.api+json'
         @app.call(environment)
       end
     end
   end
-end
+end

data/lib/json_api_client/middleware/status.rb

@@ -11,16 +11,25 @@ module JsonApiClient
             handle_status(code, env)
           end
         end
+      rescue Faraday::ConnectionFailed, Faraday::TimeoutError
+        raise Errors::ConnectionError, environment
       end
 
       protected
 
       def handle_status(code, env)
         case code
+        when 200..399
+        when 403
+          raise Errors::AccessDenied, env
         when 404
           raise Errors::NotFound, env[:url]
+        when 400..499
+          # some other error
         when 500..599
-          raise Errors::ServerError, env[:url]
+          raise Errors::ServerError, env
+        else
+          raise Errors::UnexpectedStatus.new(code, env[:url])
         end
       end
     end

data/lib/json_api_client/paginating.rb

@@ -0,0 +1,5 @@
+module JsonApiClient
+  module Paginating
+    autoload :Paginator, 'json_api_client/paginating/paginator'
+  end
+end

data/lib/json_api_client/paginating/paginator.rb

@@ -0,0 +1,80 @@
+module JsonApiClient
+  module Paginating
+    class Paginator
+      attr_reader :params, :result_set, :links
+      def initialize(result_set, links)
+        @params = params_for_uri(result_set.uri)
+        @result_set = result_set
+        @links = links
+      end
+
+      def next
+        result_set.links.fetch_link("next")
+      end
+
+      def prev
+        result_set.links.fetch_link("next")
+      end
+
+      def first
+        result_set.links.fetch_link("first")
+      end
+
+      def last
+        result_set.links.fetch_link("last")
+      end
+
+      def total_pages
+        if links["last"]
+          last_params = params_for_uri(links["last"])
+          last_params.fetch("page") do
+            current_page
+          end.to_i
+        else
+          current_page
+        end
+      end
+
+      # this number may be off
+      def total_entries
+        per_page * total_pages
+      end
+
+      def offset
+        per_page * (current_page - 1)
+      end
+
+      def per_page
+        params.fetch("per_page") do
+          result_set.length
+        end.to_i
+      end
+
+      def current_page
+        params.fetch("page", 1).to_i
+      end
+
+      def out_of_bounds?
+        current_page > total_pages
+      end
+
+      def previous_page
+        current_page > 1 ? (current_page - 1) : nil
+      end
+
+      def next_page
+        current_page < total_pages ? (current_page + 1) : nil
+      end
+
+      alias limit_value per_page
+
+      protected
+
+      def params_for_uri(uri)
+        return {} unless uri
+        uri = Addressable::URI.parse(uri)
+        uri.query_values || {}
+      end
+    end
+  end
+end

data/lib/json_api_client/parsers.rb

@@ -0,0 +1,5 @@
+module JsonApiClient
+  module Parsers
+    autoload :Parser, 'json_api_client/parsers/parser'
+  end
+end

data/lib/json_api_client/parsers/parser.rb

@@ -0,0 +1,55 @@
+module JsonApiClient
+  module Parsers
+    class Parser
+      class << self
+        def parse(klass, response)
+          data = response.body
+          ResultSet.new.tap do |result_set|
+            result_set.record_class = klass
+            result_set.uri = response.env[:url]
+            handle_data(result_set, data)
+            handle_errors(result_set, data)
+            handle_meta(result_set, data)
+            handle_links(result_set, data)
+            handle_pagination(result_set, data)
+            handle_included(result_set, data)
+          end
+        end
+
+        private
+
+        def handle_data(result_set, data)
+          # all data lives under the "data" attribute
+          results = data.fetch("data", [])
+
+          # we will treat everything as an Array
+          results = [results] unless results.is_a?(Array)
+          result_set.concat(results.map{|res| result_set.record_class.load(res)})
+        end
+
+        def handle_errors(result_set, data)
+          result_set.errors = ErrorCollector.new(data.fetch("errors", []))
+        end
+
+        def handle_meta(result_set, data)
+          result_set.meta = MetaData.new(data.fetch("meta", {}))
+        end
+
+        def handle_links(result_set, data)
+          result_set.links = Linking::TopLevelLinks.new(result_set.record_class, data.fetch("links", {}))
+        end
+
+        def handle_pagination(result_set, data)
+          result_set.pages = result_set.record_class.paginator.new(result_set, data.fetch("links", {}))
+        end
+
+        def handle_included(result_set, data)
+          included = Linking::IncludedData.new(result_set.record_class, data.fetch("included", []))
+          result_set.each do |res|
+            res.linked_data = included
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_api_client/query.rb

@@ -1,11 +1,6 @@
 module JsonApiClient
   module Query
-    autoload :Base, 'json_api_client/query/base'
-    autoload :Create, 'json_api_client/query/create'
-    autoload :Custom, 'json_api_client/query/custom'
-    autoload :Destroy, 'json_api_client/query/destroy'
-    autoload :Find, 'json_api_client/query/find'
-    autoload :Update, 'json_api_client/query/update'
-    autoload :Linked, 'json_api_client/query/linked'
+    autoload :Builder, 'json_api_client/query/builder'
+    autoload :Requestor, 'json_api_client/query/requestor'
   end
 end

data/lib/json_api_client/query/builder.rb

@@ -0,0 +1,126 @@
+module JsonApiClient
+  module Query
+    class Builder
+
+      attr_reader :klass
+
+      def initialize(klass)
+        @klass = klass
+        @pagination_params = {}
+        @filters = {}
+        @includes = []
+        @orders = []
+        @fields = []
+      end
+
+      def where(conditions = {})
+        @filters.merge!(conditions)
+        self
+      end
+
+      def order(*args)
+        @orders += parse_orders(*args)
+        self
+      end
+
+      def includes(*tables)
+        @includes += parse_related_links(*tables)
+        self
+      end
+
+      def select(fields)
+        @fields += fields.split(",").map(&:strip)
+        self
+      end
+
+      def paginate(conditions = {})
+        @pagination_params.merge!(conditions.slice(:page, :per_page))
+        self
+      end
+
+      def page(number)
+        @pagination_params[:page] = number
+        self
+      end
+
+      def first
+        paginate(page: 1, per_page: 1).to_a.first
+      end
+
+      def build
+        klass.new(params)
+      end
+
+      def params
+        filter_params
+          .merge(pagination_params)
+          .merge(includes_params)
+          .merge(order_params)
+          .merge(select_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
+
+      private
+
+      attr_reader :pagination_params
+
+      def includes_params
+        @includes.empty? ? {} : {include: @includes.join(",")}
+      end
+
+      def filter_params
+        @filters.empty? ? {} : {filter: @filters}
+      end
+
+      def order_params
+        @orders.empty? ? {} : {sort: @orders.join(",")}
+      end
+
+      def select_params
+        @fields.empty? ? {} : {fields: {klass.table_name => @fields.join(",")}}
+      end
+
+      def parse_related_links(*tables)
+        tables.map do |table|
+          case table
+          when Hash
+            table.map do |k, v|
+              parse_related_links(*v).map do |sub|
+                "#{k}.#{sub}"
+              end
+            end
+          when Array
+            table.map do |v|
+              parse_related_links(*v)
+            end
+          else
+            table
+          end
+        end.flatten
+      end
+
+      def parse_orders(*args)
+        args.map do |arg|
+          case arg
+          when Hash
+            arg.map do |k, v|
+              operator = (v == :desc ? "-" : "+")
+              "#{operator}#{k}"
+            end
+          else
+            "+#{arg}"
+          end
+        end.flatten
+      end
+
+    end
+  end
+end