jsonapi_compliable 0.11.34 → 1.0.alpha.2

data/lib/jsonapi_compliable/sideload/belongs_to.rb

@@ -0,0 +1,34 @@
+class JsonapiCompliable::Sideload::BelongsTo < JsonapiCompliable::Sideload
+  def type
+    :belongs_to
+  end
+
+  def load_params(parents, query)
+    query.to_hash.tap do |hash|
+      hash[:filter] ||= {}
+      hash[:filter][primary_key] = ids_for_parents(parents)
+    end
+  end
+
+  def assign_each(parent, children)
+    children.find { |c| c.send(primary_key) == parent.send(foreign_key) }
+  end
+
+  def ids_for_parents(parents)
+    parent_ids = parents.map(&foreign_key)
+    parent_ids.compact!
+    parent_ids.uniq!
+    parent_ids
+  end
+
+  def infer_foreign_key
+    if polymorphic_child?
+      parent.foreign_key
+    else
+      model = resource.model
+      namespace = namespace_for(model)
+      model_name = model.name.gsub("#{namespace}::", '')
+      :"#{model_name.underscore}_id"
+    end
+  end
+end

data/lib/jsonapi_compliable/sideload/has_many.rb

@@ -0,0 +1,16 @@
+class JsonapiCompliable::Sideload::HasMany < JsonapiCompliable::Sideload
+  def type
+    :has_many
+  end
+
+  def load_params(parents, query)
+    query.to_hash.tap do |hash|
+      hash[:filter] ||= {}
+      hash[:filter][foreign_key] = ids_for_parents(parents)
+    end
+  end
+
+  def assign_each(parent, children)
+    children.select { |c| c.send(foreign_key) == parent.send(primary_key) }
+  end
+end

data/lib/jsonapi_compliable/sideload/has_one.rb

@@ -0,0 +1,9 @@
+class JsonapiCompliable::Sideload::HasOne < JsonapiCompliable::Sideload::HasMany
+  def type
+    :has_one
+  end
+
+  def assign_each(parent, children)
+    children.find { |c| c.send(foreign_key) == parent.send(primary_key) }
+  end
+end

data/lib/jsonapi_compliable/sideload/many_to_many.rb

@@ -0,0 +1,24 @@
+class JsonapiCompliable::Sideload::ManyToMany < JsonapiCompliable::Sideload
+  def type
+    :many_to_many
+  end
+
+  def through
+    foreign_key.keys.first
+  end
+
+  def true_foreign_key
+    foreign_key.values.first
+  end
+
+  def infer_foreign_key
+    raise 'You must explicitly pass :foreign_key for many-to-many relaitonships, or override in subclass to return a hash.'
+  end
+
+  def assign_each(parent, children)
+    children.select do |c|
+      match = ->(ct) { ct.send(true_foreign_key) == parent.send(primary_key) }
+      c.send(through).any?(&match)
+    end
+  end
+end

data/lib/jsonapi_compliable/sideload/polymorphic_belongs_to.rb

@@ -0,0 +1,108 @@
+class JsonapiCompliable::Sideload::PolymorphicBelongsTo < JsonapiCompliable::Sideload::BelongsTo
+  class Group
+    attr_reader :name, :calls
+
+    def initialize(name)
+      @name = name
+      @calls = []
+    end
+
+    def method_missing(name, *args, &blk)
+      @calls << [name, args, blk]
+    end
+  end
+
+  class Grouper
+    attr_reader :column_name
+
+    def initialize(column_name)
+      @column_name = column_name
+      @groups = []
+    end
+
+    def on(name, &blk)
+      group = Group.new(name)
+      @groups << group
+      group.belongs_to(name.to_s.underscore.to_sym)
+      group
+    end
+
+    def apply(sideload, resource_class)
+      @groups.each do |group|
+        group.calls.each do |call|
+          args = call[1]
+          opts = args.extract_options!
+          opts.merge! as: sideload.name,
+            parent: sideload,
+            group_name: group.name,
+            polymorphic_child: true
+          if !sideload.resource.class.abstract_class?
+            opts[:foreign_key] ||= sideload.foreign_key
+            opts[:primary_key] ||= sideload.primary_key
+          end
+          args << opts
+          resource_class.send(call[0], *args, &call[2])
+        end
+      end
+    end
+  end
+
+  class_attribute :grouper
+  attr_accessor :children
+  self.grouper = Grouper.new(:default)
+
+  def type
+    :polymorphic_belongs_to
+  end
+
+  def infer_foreign_key
+    :"#{name}_id"
+  end
+
+  def self.group_by(name, &blk)
+    self.grouper = Grouper.new(name)
+    self.grouper.instance_eval(&blk)
+  end
+
+  def initialize(name, opts)
+    super
+    self.children = {}
+    grouper.apply(self, parent_resource_class)
+  end
+
+  def child_for_type(type)
+    children.values.find do |sideload|
+      sideload.resource.type == type
+    end
+  end
+
+  def resolve(parents, query)
+    parents.group_by(&grouper.column_name).each_pair do |group_name, group|
+      next if group_name.nil?
+
+      match = ->(name, sl) { sl.group_name == group_name.to_sym }
+      if child = children.find(&match)
+        sideload = child[1]
+        query = remove_invalid_sideloads(sideload.resource, query)
+        sideload.resolve(group, query)
+      else
+        err = ::JsonapiCompliable::Errors::PolymorphicChildNotFound
+        raise err.new(self, group_name)
+      end
+    end
+  end
+
+  private
+
+  # We may be requesting a relationship that some subclasses support,
+  # but not others. Remove anything we don't support.
+  def remove_invalid_sideloads(resource, query)
+    query = query.dup
+    query.sideloads.each_pair do |key, value|
+      unless resource.class.sideload(key)
+        query.sideloads.delete(key)
+      end
+    end
+    query
+  end
+end

data/lib/jsonapi_compliable/stats/payload.rb

@@ -14,12 +14,9 @@ module JsonapiCompliable
     #     meta: { stats: { total: { count: 100 } } }
     #   }
     class Payload
-      # @param [Resource] resource the resource instance
-      # @param [Hash] query_hash the Query#to_hash for the current resource
-      # @param scope the scope we are chaining/modifying
-      def initialize(resource, query_hash, scope)
+      def initialize(resource, query, scope)
         @resource   = resource
-        @query_hash = query_hash[:stats]
+        @query      = query
         @scope      = scope
       end
 
@@ -29,12 +26,11 @@ module JsonapiCompliable
       # @return [Hash] the generated payload
       def generate
         {}.tap do |stats|
-          @query_hash.each_pair do |name, calculation|
+          @query.stats.each_pair do |name, calculation|
             stats[name] = {}
 
             each_calculation(name, calculation) do |calc, function|
-              args = function.arity == 3 ? [@scope, name, @resource] : [@scope, name]
-              stats[name][calc] = function.call(*args)
+              stats[name][calc] = function.call(@scope, name)
             end
           end
         end

data/lib/jsonapi_compliable/types.rb

@@ -0,0 +1,172 @@
+module JsonapiCompliable
+  class Types
+    def self.create(primitive, &blk)
+      definition = Dry::Types::Definition.new(primitive)
+      definition.constructor(&blk)
+    end
+
+    WriteDateTime = create(::DateTime) do |input|
+      if input.is_a?(::Date) || input.is_a?(::Time)
+        input = ::DateTime.parse(input.to_s)
+      end
+      input = Dry::Types['json.date_time'][input]
+      Dry::Types['strict.date_time'][input] if input
+    end
+
+    ReadDateTime = create(::DateTime) do |input|
+      if input.is_a?(::Date) || input.is_a?(::Time)
+        input = ::DateTime.parse(input.to_s)
+      end
+      input = Dry::Types['json.date_time'][input]
+      Dry::Types['strict.date_time'][input].iso8601 if input
+    end
+
+    PresentParamsDateTime = create(::DateTime) do |input|
+      input = Dry::Types['params.date_time'][input]
+      Dry::Types['strict.date_time'][input]
+    end
+
+    Date = create(::Date) do |input|
+      input = ::Date.parse(input.to_s) if input.is_a?(::Time)
+      input = Dry::Types['json.date'][input]
+      Dry::Types['strict.date'][input] if input
+    end
+
+    PresentDate = create(::Date) do |input|
+      input = ::Date.parse(input.to_s) if input.is_a?(::Time)
+      input = Dry::Types['json.date'][input]
+      Dry::Types['strict.date'][input]
+    end
+
+    Bool = create(nil) do |input|
+      input = Dry::Types['params.bool'][input]
+      Dry::Types['strict.bool'][input] if input
+    end
+
+    PresentBool = create(nil) do |input|
+      input = Dry::Types['params.bool'][input]
+      Dry::Types['strict.bool'][input]
+    end
+
+    Integer = create(::Integer) do |input|
+      Dry::Types['coercible.integer'][input] if input
+    end
+
+    # The Float() check here is to ensure we have a number
+    # Otherwise BigDecimal('foo') *will return a decima;*
+    ParamDecimal = create(::BigDecimal) do |input|
+      Float(input)
+      input = Dry::Types['coercible.decimal'][input]
+      Dry::Types['strict.decimal'][input]
+    end
+
+    PresentInteger = create(::Integer) do |input|
+      Dry::Types['coercible.integer'][input]
+    end
+
+    Float = create(::Float) do |input|
+      Dry::Types['coercible.float'][input] if input
+    end
+
+    PresentParamsHash = create(::Hash) do |input|
+      Dry::Types['params.hash'][input].deep_symbolize_keys
+    end
+
+    def self.map
+      @map ||= begin
+        hash = {
+          integer_id: {
+            canonical_name: :integer,
+            params: Dry::Types['coercible.integer'],
+            read: Dry::Types['coercible.string'],
+            write: Dry::Types['coercible.integer']
+          },
+          string: {
+            params: Dry::Types['coercible.string'],
+            read: Dry::Types['coercible.string'],
+            write: Dry::Types['coercible.string']
+          },
+          integer: {
+            params: PresentInteger,
+            read: Integer,
+            write: Integer
+          },
+          decimal: {
+            params: ParamDecimal,
+            read: Dry::Types['json.decimal'],
+            write: Dry::Types['json.decimal']
+          },
+          float: {
+            params: Dry::Types['coercible.float'],
+            read: Float,
+            write: Float
+          },
+          boolean: {
+            params: PresentBool,
+            read: Bool,
+            write: Bool
+          },
+          date: {
+            params: PresentDate,
+            read: Date,
+            write: Date
+          },
+          datetime: {
+            params: PresentParamsDateTime,
+            read: ReadDateTime,
+            write: WriteDateTime
+          },
+          hash: {
+            params: PresentParamsHash,
+            read: Dry::Types['strict.hash'],
+            write: Dry::Types['strict.hash']
+          },
+          array: {
+            params: Dry::Types['strict.array'],
+            read: Dry::Types['strict.array'],
+            write: Dry::Types['strict.array']
+          }
+        }
+
+        hash.each_pair do |k, v|
+          hash[k][:canonical_name] ||= k
+        end
+
+        arrays = {}
+        hash.each_pair do |name, map|
+          arrays[:"array_of_#{name.to_s.pluralize}"] = {
+            canonical_name: name,
+            params: Dry::Types['strict.array'].of(map[:params]),
+            read: Dry::Types['strict.array'].of(map[:read]),
+            test: Dry::Types['strict.array'].of(map[:test]),
+            write: Dry::Types['strict.array'].of(map[:write])
+          }
+        end
+        hash.merge!(arrays)
+
+        hash
+      end
+    end
+
+    def self.[](key)
+      map[key.to_sym]
+    end
+
+    def self.[]=(key, value)
+      unless value.is_a?(Hash)
+        value = {
+          read: value,
+          params: value,
+          test: value
+        }
+      end
+      map[key.to_sym] = value
+    end
+
+    def self.name_for(key)
+      key = key.to_sym
+      type = map[key]
+      type[:canonical_name]
+    end
+  end
+end

data/lib/jsonapi_compliable/util/attribute_check.rb

@@ -0,0 +1,88 @@
+# Private, tested in resource specs
+module JsonapiCompliable
+  module Util
+    class AttributeCheck
+      attr_reader :resource, :name, :flag, :request, :raise_error
+
+      def self.run(resource, name, flag, request, raise_error)
+        new(resource, name, flag, request, raise_error).run
+      end
+
+      def initialize(resource, name, flag, request, raise_error)
+        @resource = resource
+        @name = name.to_sym
+        @flag = flag
+        @request = request
+        @raise_error = raise_error
+      end
+
+      def run
+        if attribute?
+          if supported?
+            if guarded?
+              if guard_passes?
+                attribute
+              else
+                maybe_raise(request: true, guard: attribute[flag])
+              end
+            else
+              attribute
+            end
+          else
+            maybe_raise(exists: true)
+          end
+        else
+          maybe_raise(exists: false)
+        end
+      end
+
+      def maybe_raise(opts = {})
+        default = { request: request, exists: true }
+        opts = default.merge(opts)
+        if raise_error?(opts[:exists])
+          raise error_class.new(resource, name, flag, opts)
+        else
+          false
+        end
+      end
+
+      def guard_passes?
+        !!resource.send(attribute[flag])
+      end
+
+      def guarded?
+        request? &&
+          attribute[flag].is_a?(Symbol) &&
+          attribute[flag] != :required
+      end
+
+      def error_class
+        Errors::AttributeError
+      end
+
+      def supported?
+        attribute[flag] != false
+      end
+
+      def attribute
+        resource.all_attributes[name]
+      end
+
+      def attribute?
+        !!attribute
+      end
+
+      def raise_error?(exists)
+        if raise_error == :only_unsupported
+          exists ? true : false
+        else
+          !!raise_error
+        end
+      end
+
+      def request?
+        !!request
+      end
+    end
+  end
+end