jsonapi-consumer 0.1.1 → 1.0.0

data/lib/jsonapi/consumer/parsers/parser.rb

@@ -0,0 +1,113 @@
+module JSONAPI::Consumer
+  module Parsers
+    class Parser
+      class << self
+        def parse(klass, response)
+          data = response.body.present? ? response.body : {}
+
+          ResultSet.new.tap do |result_set|
+            result_set.record_class = klass
+            result_set.uri = response.env[:url]
+            handle_json_api(result_set, data)
+            handle_data(result_set, data)
+            handle_errors(result_set, data)
+            handle_meta(result_set, data)
+            handle_links(result_set, data)
+            handle_relationships(result_set, data)
+            handle_pagination(result_set, data)
+            handle_included(result_set, data)
+          end
+        end
+
+        #
+        # Given a resource hash, returns a Resource.new friendly hash
+        # which flattens the attributes in w/ id and type.
+        #
+        # Example:
+        #
+        # Given:
+        #  {
+        #    id: 1.
+        #    type: 'person',
+        #    attributes: {
+        #      first_name: 'Jeff',
+        #      last_name: 'Ching'
+        #    },
+        #    links: {...},
+        #    relationships: {...}
+        #  }
+        #
+        # Returns:
+        #  {
+        #    id: 1,
+        #    type: 'person',
+        #    first_name: 'Jeff',
+        #    last_name: 'Ching'
+        #    links: {...},
+        #    relationships: {...}
+        #  }
+        #
+        #
+        def parameters_from_resource(params)
+          attrs = params.slice('id', 'links', 'meta', 'type', 'relationships')
+          attrs.merge(params.fetch('attributes', {}))
+        end
+
+        private
+
+        def handle_json_api(result_set, data)
+          result_set.implementation = Implementation.new(data.fetch("jsonapi", {}))
+        end
+
+        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)
+          resources = results.compact.map do |res|
+            record_class = choose_model_for(result_set, res)
+            resource = record_class.load(parameters_from_resource(res))
+            resource.last_result_set = result_set
+            resource
+          end
+          result_set.concat(resources)
+        end
+
+        # Accept mixed-content from an endpoint.
+        #
+        # TODO: add ability to configure a model namespace
+        def choose_model_for(result_set, res)
+          return result_set.record_class unless res['type']
+
+          res_type_name = res['type'].underscore.classify
+          (res_type_name.safe_constantize) ? res_type_name.safe_constantize : result_set.record_class
+        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", {}), result_set.record_class)
+        end
+
+        def handle_links(result_set, data)
+          result_set.links = Linking::TopLevelLinks.new(result_set.record_class, data.fetch("links", {}))
+        end
+
+        def handle_relationships(result_set, data)
+          result_set.relationships = Relationships::TopLevelRelations.new(result_set.record_class, data.fetch("relationships", {}))
+        end
+
+        def handle_pagination(result_set, data)
+          result_set.pages = result_set.record_class.paginator.new(result_set, data)
+        end
+
+        def handle_included(result_set, data)
+          result_set.included = IncludedData.new(result_set, data.fetch("included", []))
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/consumer/query/builder.rb

@@ -0,0 +1,212 @@
+module JSONAPI::Consumer
+  module Query
+    class Builder
+
+      attr_reader :klass, :requestor
+      delegate :key_formatter, to: :klass
+
+      def initialize(klass, requestor = nil)
+        @klass = klass
+        @requestor = requestor || klass.requestor
+        @primary_key = nil
+        @pagination_params = {}
+        @path_params = {}
+        @additional_params = {}
+        @filters = {}
+        @includes = []
+        @orders = []
+        @fields = []
+      end
+
+      def where(conditions = {})
+        # pull out any path params here
+        @path_params.merge!(conditions.slice(*klass.prefix_params))
+        @filters.merge!(conditions.except(*klass.prefix_params))
+        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 += parse_fields(*fields)
+        self
+      end
+
+      def paginate(conditions = {})
+        scope = self
+        scope = scope.page(conditions[:page]) if conditions[:page]
+        scope = scope.per(conditions[:per_page]) if conditions[:per_page]
+        scope
+      end
+
+      def page(number)
+        @pagination_params[ klass.paginator.page_param ] = number
+        self
+      end
+
+      def per(size)
+        @pagination_params[ klass.paginator.per_page_param ] = size
+        self
+      end
+
+      def with_params(more_params)
+        @additional_params.merge!(more_params)
+        self
+      end
+
+      def first
+        paginate(page: 1, per_page: 1).to_a.first
+      end
+
+      def last
+        paginate(page: 1, per_page: 1).pages.last.to_a.last
+      end
+
+      def build
+        klass.new(params)
+      end
+
+      def params
+        filter_params
+          .merge(pagination_params)
+          .merge(includes_params)
+          .merge(order_params)
+          .merge(select_params)
+          .merge(primary_key_params)
+          .merge(path_params)
+          .merge(additional_params)
+      end
+
+      def to_a
+        @to_a ||= find
+      end
+      alias all to_a
+
+      def find(args = {})
+        case args
+        when Hash
+          where(args)
+        else
+          @primary_key = args
+        end
+
+        requestor.get(params)
+      end
+
+      def method_missing(method_name, *args, &block)
+        to_a.send(method_name, *args, &block)
+      end
+
+      private
+
+      def path_params
+        @path_params.empty? ? {} : {path: @path_params}
+      end
+
+      def additional_params
+        @additional_params
+      end
+
+      def primary_key_params
+        return {} unless @primary_key
+
+        @primary_key.is_a?(Array) ?
+          {klass.primary_key.to_s.pluralize.to_sym => @primary_key.join(",")} :
+          {klass.primary_key => @primary_key}
+      end
+
+      def pagination_params
+        @pagination_params.empty? ? {} : {page: @pagination_params}
+      end
+
+      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
+        if @fields.empty?
+          {}
+        else
+          field_result = Hash.new { |h,k| h[k] = [] }
+          @fields.each do |field|
+            if field.is_a? Hash
+              field.each do |k,v|
+                field_result[k.to_s] << v
+                field_result[k.to_s] = field_result[k.to_s].flatten
+              end
+            else
+              field_result[klass.table_name] << field
+            end
+          end
+          field_result.each { |k,v| field_result[k] = v.join(',') }
+          {fields: field_result}
+        end
+      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
+            key_formatter.format(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
+
+      def parse_fields(*fields)
+        fields = fields.split(',') if fields.is_a? String
+        fields.map do |field|
+          case field
+          when Hash
+            field.each do |k,v|
+              field[k] = parse_fields(v)
+            end
+            field
+          else
+            Array(field).flatten.map { |i| i.to_s.split(",") }.flatten.map(&:strip)
+          end
+        end.flatten
+      end
+
+    end
+  end
+end

data/lib/jsonapi/consumer/query/requestor.rb

@@ -0,0 +1,67 @@
+module JSONAPI::Consumer
+  module Query
+    class Requestor
+      extend Forwardable
+      include Helpers::URI
+
+      def initialize(klass, path = nil)
+        @klass = klass
+        @path = path
+      end
+
+      # expects a record
+      def create(record)
+        request(:post, klass.path(record.attributes), {
+          data: record.as_json_api
+        })
+      end
+
+      def update(record)
+        request(:patch, resource_path(record.attributes), {
+          data: record.as_json_api
+        })
+      end
+
+      def get(params = {})
+        path = resource_path(params)
+        params.delete(klass.primary_key)
+        request(:get, path, params)
+      end
+
+      def destroy(record)
+        request(:delete, resource_path(record.attributes), {})
+      end
+
+      def linked(path)
+        request(:get, path, {})
+      end
+
+      def custom(method_name, options, params)
+        path = resource_path(params)
+        params.delete(klass.primary_key)
+        path = File.join(path, method_name.to_s)
+
+        request(options.fetch(:request_method, :get), path, params)
+      end
+
+      protected
+
+      attr_reader :klass, :path
+      def_delegators :klass, :connection
+
+      def resource_path(parameters)
+        base_path = path || klass.path(parameters)
+        if resource_id = parameters[klass.primary_key]
+          File.join(base_path, encode_part(resource_id))
+        else
+          base_path
+        end
+      end
+
+      def request(type, path, params)
+        klass.parser.parse(klass, connection.run(type, path, params, klass.custom_headers))
+      end
+
+    end
+  end
+end

data/lib/jsonapi/consumer/relationships/relations.rb

@@ -0,0 +1,56 @@
+module JSONAPI::Consumer
+  module Relationships
+    class Relations
+      include Helpers::DynamicAttributes
+      include Helpers::Dirty
+      include ActiveModel::Serialization
+
+      attr_reader :record_class
+      delegate :key_formatter, to: :record_class
+
+      def initialize(record_class, relations)
+        @record_class = record_class
+        self.attributes = relations
+        clear_changes_information
+      end
+
+      def present?
+        attributes.present?
+      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 as_json
+        Hash[attributes.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)
+        value = case value
+        when JSONAPI::Consumer::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
+  end
+end

data/lib/jsonapi/consumer/relationships/top_level_relations.rb

@@ -0,0 +1,30 @@
+module JSONAPI::Consumer
+  module Relationships
+    class TopLevelRelations
+
+      attr_reader :relations, :record_class
+
+      def initialize(record_class, relations)
+        @relations = relations
+        @record_class = record_class
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        relations.has_key?(method.to_s) || super
+      end
+
+      def method_missing(method, *args)
+        if respond_to_missing?(method)
+          fetch_relation(method)
+        else
+          super
+        end
+      end
+
+      def fetch_relation(relation_name)
+        link_definition = relations.fetch(relation_name.to_s)
+        record_class.requestor.linked(link_definition)
+      end
+    end
+  end
+end