graphiti 1.0.rc.21 → 1.0.rc.22

data/lib/graphiti/sideload/belongs_to.rb

@@ -12,7 +12,7 @@ class Graphiti::Sideload::BelongsTo < Graphiti::Sideload
 
   def base_filter(parents)
     parent_ids = ids_for_parents(parents)
-    { primary_key => parent_ids.join(',') }
+    {primary_key => parent_ids.join(",")}
   end
 
   def ids_for_parents(parents)
@@ -28,7 +28,7 @@ class Graphiti::Sideload::BelongsTo < Graphiti::Sideload
     else
       model = resource.model
       namespace = namespace_for(model)
-      model_name = model.name.gsub("#{namespace}::", '')
+      model_name = model.name.gsub("#{namespace}::", "")
       :"#{model_name.underscore}_id"
     end
   end

data/lib/graphiti/sideload/has_many.rb

@@ -11,7 +11,7 @@ class Graphiti::Sideload::HasMany < Graphiti::Sideload
   end
 
   def base_filter(parents)
-    { foreign_key => ids_for_parents(parents).join(',') }
+    {foreign_key => ids_for_parents(parents).join(",")}
   end
 
   private

data/lib/graphiti/sideload/many_to_many.rb

@@ -12,17 +12,33 @@ class Graphiti::Sideload::ManyToMany < Graphiti::Sideload::HasMany
   end
 
   def base_filter(parents)
-    { true_foreign_key => ids_for_parents(parents).join(',') }
+    {true_foreign_key => ids_for_parents(parents).join(",")}
   end
 
   def infer_foreign_key
-    raise 'You must explicitly pass :foreign_key for many-to-many relationships, or override in subclass to return a hash.'
+    raise "You must explicitly pass :foreign_key for many-to-many relationships, or override in subclass to return a hash."
   end
 
   def performant_assign?
     false
   end
 
+  # Override in subclass
+  def polymorphic?
+    false
+  end
+
+  def apply_belongs_to_many_filter
+    self_ref = self
+    fk_type = parent_resource_class.attributes[:id][:type]
+    fk_type = :hash if polymorphic?
+    resource_class.filter true_foreign_key, fk_type do
+      eq do |scope, value|
+        self_ref.belongs_to_many_filter(scope, value)
+      end
+    end
+  end
+
   def assign_each(parent, children)
     children.select do |c|
       match = ->(ct) { ct.send(true_foreign_key) == parent.send(primary_key) }

data/lib/graphiti/sideload/polymorphic_belongs_to.rb

@@ -7,15 +7,21 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
       @calls = []
     end
 
+    # rubocop: disable Style/MethodMissingSuper
     def method_missing(name, *args, &blk)
       @calls << [name, args, blk]
     end
+    # rubocop: enable Style/MethodMissingSuper
+
+    def respond_to_missing?(*args)
+      true
+    end
   end
 
   class Grouper
     attr_reader :field_name
 
-    def initialize(field_name, opts={})
+    def initialize(field_name, opts = {})
       @field_name = field_name
       @groups = []
       @except = Array(opts[:except]).map(&:to_sym)
@@ -50,10 +56,10 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
           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?
+                      parent: sideload,
+                      group_name: group.name,
+                      polymorphic_child: true
+          unless sideload.resource.class.abstract_class?
             opts[:foreign_key] ||= sideload.foreign_key
             opts[:primary_key] ||= sideload.primary_key
           end
@@ -76,9 +82,9 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
     :"#{name}_id"
   end
 
-  def self.group_by(name, opts={}, &blk)
+  def self.group_by(name, opts = {}, &blk)
     self.grouper = Grouper.new(name, opts)
-    self.grouper.instance_eval(&blk)
+    grouper.instance_eval(&blk)
   end
 
   def initialize(name, opts)
@@ -98,7 +104,7 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
       next if group_name.nil? || grouper.ignore?(group_name)
 
       match = ->(c) { c.group_name == group_name.to_sym }
-      if sideload = children.values.find(&match)
+      if (sideload = children.values.find(&match))
         query = remove_invalid_sideloads(sideload.resource, query)
         sideload.resolve(group, query, graph_parent)
       else

data/lib/graphiti/stats/dsl.rb

@@ -30,7 +30,7 @@ module Graphiti
       # @param [Adapters::Abstract] adapter the Resource adapter
       # @param [Symbol, Hash] config example: +:total+ or +{ total: [:count] }+
       def initialize(adapter, config)
-        config = { config => [] } if config.is_a?(Symbol)
+        config = {config => []} if config.is_a?(Symbol)
 
         @adapter = adapter
         @calculations = {}
@@ -46,9 +46,15 @@ module Graphiti
       #
       # ...will hit +method_missing+ and store the proc for future reference.
       # @api private
+      # rubocop: disable Style/MethodMissingSuper
       def method_missing(meth, *args, &blk)
         @calculations[meth] = blk
       end
+      # rubocop: enable Style/MethodMissingSuper
+
+      def respond_to_missing?(*args)
+        true
+      end
 
       # Grab a calculation proc. Raises error if no corresponding stat
       # has been configured.

data/lib/graphiti/tasks.rb

@@ -10,25 +10,25 @@ namespace :graphiti do
   end
 
   def make_request(path, debug = false)
-    if path.split('/').length == 2
+    if path.split("/").length == 2
       path = "#{ApplicationResource.endpoint_namespace}#{path}"
     end
-    if path.include?('?')
-      path << '&cache=bust'
+    path << if path.include?("?")
+      "&cache=bust"
     else
-      path << '?cache=bust'
+      "?cache=bust"
     end
     path = "#{path}&debug=true" if debug
-    session.get("#{path}")
+    session.get(path.to_s)
     JSON.parse(session.response.body)
   end
 
   desc "Execute request without web server."
-  task :request, [:path,:debug] => [:environment] do |_, args|
+  task :request, [:path, :debug] => [:environment] do |_, args|
     setup_rails!
     Graphiti.logger = Graphiti.stdout_logger
     Graphiti::Debugger.preserve = true
-    require 'pp'
+    require "pp"
     path, debug = args[:path], args[:debug]
     puts "Graphiti Request: #{path}"
     json = make_request(path, debug)
@@ -37,13 +37,13 @@ namespace :graphiti do
   end
 
   desc "Execute benchmark without web server."
-  task :benchmark, [:path,:requests] => [:environment] do |_, args|
+  task :benchmark, [:path, :requests] => [:environment] do |_, args|
     setup_rails!
-    took = Benchmark.ms do
+    took = Benchmark.ms {
       args[:requests].to_i.times do
         make_request(args[:path])
       end
-    end
+    }
     puts "Took: #{(took / args[:requests].to_f).round(2)}ms"
   end
 end

data/lib/graphiti/types.rb

@@ -5,81 +5,81 @@ module Graphiti
       definition.constructor(&blk)
     end
 
-    WriteDateTime = create(::DateTime) do |input|
+    WriteDateTime = create(::DateTime) { |input|
       if input.is_a?(::Date) || input.is_a?(::Time)
         input = if input.respond_to?(:to_datetime)
-                  input.to_datetime
-                else
-                  ::DateTime.parse(input.to_s)
-                end
+          input.to_datetime
+        else
+          ::DateTime.parse(input.to_s)
+        end
       end
-      input = Dry::Types['json.date_time'][input]
-      Dry::Types['strict.date_time'][input] if input
-    end
+      input = Dry::Types["json.date_time"][input]
+      Dry::Types["strict.date_time"][input] if input
+    }
 
-    ReadDateTime = create(::DateTime) do |input|
+    ReadDateTime = create(::DateTime) { |input|
       if input.is_a?(::Date) || input.is_a?(::Time)
         input = if input.respond_to?(:to_datetime)
-                  input.to_datetime
-                else
-                  ::DateTime.parse(input.to_s)
-                end
+          input.to_datetime
+        else
+          ::DateTime.parse(input.to_s)
+        end
       end
-      input = Dry::Types['json.date_time'][input]
-      Dry::Types['strict.date_time'][input].iso8601 if input
-    end
+      input = Dry::Types["json.date_time"][input]
+      Dry::Types["strict.date_time"][input].iso8601 if input
+    }
 
-    PresentParamsDateTime = create(::DateTime) do |input|
-      input = Dry::Types['params.date_time'][input]
-      Dry::Types['strict.date_time'][input]
-    end
+    PresentParamsDateTime = create(::DateTime) { |input|
+      input = Dry::Types["params.date_time"][input]
+      Dry::Types["strict.date_time"][input]
+    }
 
-    Date = create(::Date) do |input|
+    Date = create(::Date) { |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
+      input = Dry::Types["json.date"][input]
+      Dry::Types["strict.date"][input] if input
+    }
 
-    PresentDate = create(::Date) do |input|
+    PresentDate = create(::Date) { |input|
       input = ::Date.parse(input.to_s) if input.is_a?(::Time)
-      input = Dry::Types['json.date'][input]
-      Dry::Types['strict.date'][input]
-    end
+      input = Dry::Types["json.date"][input]
+      Dry::Types["strict.date"][input]
+    }
 
-    Bool = create(nil) do |input|
-      input = Dry::Types['params.bool'][input]
-      Dry::Types['strict.bool'][input] unless input.nil?
-    end
+    Bool = create(nil) { |input|
+      input = Dry::Types["params.bool"][input]
+      Dry::Types["strict.bool"][input] unless input.nil?
+    }
 
-    PresentBool = create(nil) do |input|
-      input = Dry::Types['params.bool'][input]
-      Dry::Types['strict.bool'][input]
-    end
+    PresentBool = create(nil) { |input|
+      input = Dry::Types["params.bool"][input]
+      Dry::Types["strict.bool"][input]
+    }
 
-    Integer = create(::Integer) do |input|
-      Dry::Types['coercible.integer'][input] if input
-    end
+    Integer = create(::Integer) { |input|
+      Dry::Types["coercible.integer"][input] if input
+    }
 
     # The Float() check here is to ensure we have a number
     # Otherwise BigDecimal('foo') *will return a decimal*
-    ParamDecimal = create(::BigDecimal) do |input|
+    ParamDecimal = create(::BigDecimal) { |input|
       Float(input)
-      input = Dry::Types['coercible.decimal'][input]
-      Dry::Types['strict.decimal'][input]
-    end
+      input = Dry::Types["coercible.decimal"][input]
+      Dry::Types["strict.decimal"][input]
+    }
 
-    PresentInteger = create(::Integer) do |input|
-      Dry::Types['coercible.integer'][input]
-    end
+    PresentInteger = create(::Integer) { |input|
+      Dry::Types["coercible.integer"][input]
+    }
 
-    Float = create(::Float) do |input|
-      Dry::Types['coercible.float'][input] if input
-    end
+    Float = create(::Float) { |input|
+      Dry::Types["coercible.float"][input] if input
+    }
 
-    PresentParamsHash = create(::Hash) do |input|
+    PresentParamsHash = create(::Hash) { |input|
       input = JSON.parse(input) if input.is_a?(String)
-      Dry::Types['params.hash'][input]
-    end
+      Dry::Types["params.hash"][input]
+    }
 
     REQUIRED_KEYS = [:params, :read, :write, :kind, :description]
 
@@ -88,82 +88,82 @@ module Graphiti
         hash = {
           integer_id: {
             canonical_name: :integer,
-            params: Dry::Types['coercible.integer'],
-            read: Dry::Types['coercible.string'],
-            write: Dry::Types['coercible.integer'],
-            kind: 'scalar',
-            description: 'Base Type. Query/persist as integer, render as string.'
+            params: Dry::Types["coercible.integer"],
+            read: Dry::Types["coercible.string"],
+            write: Dry::Types["coercible.integer"],
+            kind: "scalar",
+            description: "Base Type. Query/persist as integer, render as string.",
           },
           uuid: {
-            params: Dry::Types['coercible.string'],
-            read: Dry::Types['coercible.string'],
-            write: Dry::Types['coercible.string'],
-            kind: 'scalar',
-            description: 'Base Type. Like a normal string, but by default only eq/!eq and case-sensitive.'
+            params: Dry::Types["coercible.string"],
+            read: Dry::Types["coercible.string"],
+            write: Dry::Types["coercible.string"],
+            kind: "scalar",
+            description: "Base Type. Like a normal string, but by default only eq/!eq and case-sensitive.",
           },
           string: {
-            params: Dry::Types['coercible.string'],
-            read: Dry::Types['coercible.string'],
-            write: Dry::Types['coercible.string'],
-            kind: 'scalar',
-            description: 'Base Type.'
+            params: Dry::Types["coercible.string"],
+            read: Dry::Types["coercible.string"],
+            write: Dry::Types["coercible.string"],
+            kind: "scalar",
+            description: "Base Type.",
           },
           integer: {
             params: PresentInteger,
             read: Integer,
             write: Integer,
-            kind: 'scalar',
-            description: 'Base Type.'
+            kind: "scalar",
+            description: "Base Type.",
           },
           big_decimal: {
             params: ParamDecimal,
-            read: Dry::Types['json.decimal'],
-            write: Dry::Types['json.decimal'],
-            kind: 'scalar',
-            description: 'Base Type.'
+            read: Dry::Types["json.decimal"],
+            write: Dry::Types["json.decimal"],
+            kind: "scalar",
+            description: "Base Type.",
           },
           float: {
-            params: Dry::Types['coercible.float'],
+            params: Dry::Types["coercible.float"],
             read: Float,
             write: Float,
-            kind: 'scalar',
-            description: 'Base Type.'
+            kind: "scalar",
+            description: "Base Type.",
           },
           boolean: {
             params: PresentBool,
             read: Bool,
             write: Bool,
-            kind: 'scalar',
-            description: 'Base Type.'
+            kind: "scalar",
+            description: "Base Type.",
           },
           date: {
             params: PresentDate,
             read: Date,
             write: Date,
-            kind: 'scalar',
-            description: 'Base Type.'
+            kind: "scalar",
+            description: "Base Type.",
           },
           datetime: {
             params: PresentParamsDateTime,
             read: ReadDateTime,
             write: WriteDateTime,
-            kind: 'scalar',
-            description: 'Base Type.'
+            kind: "scalar",
+            description: "Base Type.",
           },
           hash: {
             params: PresentParamsHash,
-            read: Dry::Types['strict.hash'],
-            write: Dry::Types['strict.hash'],
-            kind: 'record',
-            description: 'Base Type.'
+            read: Dry::Types["strict.hash"],
+            write: Dry::Types["strict.hash"],
+            kind: "record",
+            description: "Base Type.",
           },
           array: {
-            params: Dry::Types['strict.array'],
-            read: Dry::Types['strict.array'],
-            write: Dry::Types['strict.array'],
-            kind: 'array',
-            description: 'Base Type.'
-          }
+            params: Dry::Types["strict.array"],
+            read: Dry::Types["strict.array"],
+            write: Dry::Types["strict.array"],
+            kind: "array",
+            description: "Base Type.",
+          },
         }
 
         hash.each_pair do |k, v|
@@ -176,12 +176,12 @@ module Graphiti
 
           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]),
-            kind: 'array',
-            description: 'Base Type.'
+            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]),
+            kind: "array",
+            description: "Base Type.",
           }
         end
         hash.merge!(arrays)