graphiti 2.0.0.beta.10 → 2.0.0.beta.12

data/lib/graphiti/schema/check.rb

@@ -0,0 +1,69 @@
+module Graphiti
+  class Schema
+    class Check
+      attr_reader :path, :errors
+
+      def initialize(schema, path)
+        @path = path
+        @schema = schema
+        @generated = normalize(schema)
+        @committed = normalize(JSON.parse(File.read(path))) if File.exist?(path)
+        @errors = @committed ? SchemaDiff.new(@committed, @generated).compare : []
+      end
+
+      def missing?
+        @committed.nil?
+      end
+
+      def stale?
+        !missing? && @committed != @generated
+      end
+
+      def compatible?
+        errors.empty?
+      end
+
+      def ok?
+        !missing? && !stale? && compatible?
+      end
+
+      def write!
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, JSON.pretty_generate(@schema))
+        path
+      end
+
+      def message
+        return "Schema is up to date: #{path}" if ok?
+        return "#{missing_message}\n\n#{regenerate}" if missing?
+        return "#{incompatible_message}\n\n#{errors.join("\n")}" unless compatible?
+
+        "Schema file is outdated: #{path}\n\n#{regenerate}"
+      end
+
+      private
+
+      def normalize(schema)
+        JSON.parse(JSON.generate(schema))
+      end
+
+      def missing_message
+        "Schema file not found: #{path}"
+      end
+
+      def incompatible_message
+        <<~MSG.chomp
+          Found backwards-incompatibilities in schema: #{path}
+
+          Re-run with FORCE_SCHEMA=true to accept them and overwrite the file.
+
+          Incompatibilities:
+        MSG
+      end
+
+      def regenerate
+        "Run `rake graphiti:schema:generate` and commit the file."
+      end
+    end
+  end
+end

data/lib/graphiti/schema.rb

@@ -11,19 +11,18 @@ module Graphiti
       new(resources).generate
     end
 
-    def self.generate!(resources = nil)
-      schema = generate(resources)
+    def self.generate!(resources = nil, path: Graphiti.config.schema_path, force: ENV["FORCE_SCHEMA"] == "true")
+      result = check(resources, path: path)
+      return result.errors if !force && !result.compatible?
 
-      if ENV["FORCE_SCHEMA"] != "true" && File.exist?(Graphiti.config.schema_path)
-        old = JSON.parse(File.read(Graphiti.config.schema_path))
-        errors = Graphiti::SchemaDiff.new(old, schema).compare
-        return errors if errors.any?
-      end
-      FileUtils.mkdir_p(Graphiti.config.schema_path.to_s.gsub("/schema.json", ""))
-      File.write(Graphiti.config.schema_path, JSON.pretty_generate(schema))
+      result.write!
       []
     end
 
+    def self.check(resources = nil, path: Graphiti.config.schema_path)
+      Check.new(generate(resources), path)
+    end
+
     def initialize(resources)
       @resources = resources.sort_by(&:name)
       @remote_resources = @resources.select(&:remote?)

data/lib/graphiti/scope.rb

@@ -59,6 +59,9 @@ module Graphiti
       @query = query
       @opts = opts
 
+      @resolved_sideload_proxies = {}
+      @resolved_sideload_proxies_lock = Mutex.new
+
       @object = @resource.around_scoping(@object, @query.hash) { |scope|
         apply_scoping(scope, opts)
       }
@@ -67,7 +70,7 @@ module Graphiti
     def resolve(&blk)
       # The caller blocks on .value! either way, so concurrency only benefits parallel sideloads
       # See https://github.com/graphiti-api/graphiti/issues/505
-      if self.class.resolve_synchronously? || !applicable_sideloads?
+      if self.class.resolve_synchronously? || !overlapping_sideloads?
         sync_resolve(&blk)
       else
         future_resolve(&blk).value!
@@ -140,9 +143,6 @@ module Graphiti
 
     private
 
-    # Synchronous counterpart to #future_resolve, used when concurrency is off.
-    # Resolves the resource and its sideloads inline without any promise
-    # machinery. See #resolve.
     def sync_resolve(&blk)
       return [] if @query.zero_results?
 
@@ -151,14 +151,15 @@ module Graphiti
       resolved
     end
 
-    # Synchronous counterpart to #future_resolve_sideloads, used when
-    # concurrency is off. Resolves each sideload inline. See #resolve_sideloads.
     def sync_resolve_sideloads(results)
       return if results == []
 
-      each_applicable_sideload do |sideload, sideload_query|
+      reset_captured_sideload_proxies
+      each_applicable_sideload do |name, sideload, sideload_query|
         Graphiti.config.before_sideload&.call(Graphiti.context)
-        sideload.resolve(results, sideload_query, @resource)
+        sideload.sync_resolve(results, sideload_query, @resource) do |proxy|
+          capture_sideload_proxy(name, proxy)
+        end
       end
     end
 
@@ -176,7 +177,7 @@ module Graphiti
       assign_serializer(resolved)
       yield resolved if block_given?
       @opts[:after_resolve]&.call(resolved)
-      resolved
+      @resolved_records = resolved
     end
 
     # Must run before sideloads assign, so every include path populates the
@@ -198,6 +199,8 @@ module Graphiti
 
     # A customized sideload can load a record another path would not, so it keeps its own instances.
     def deduplicable?
+      return false unless @query.repeated_resource_classes.include?(@resource.class)
+
       sideload = @opts[:sideload]
       return true unless sideload
 
@@ -207,9 +210,15 @@ module Graphiti
         sideload.primary_key == :id
     end
 
-    # Nothing to post to the pool means the future would wrap work already done.
-    def applicable_sideloads?
-      each_applicable_sideload { return true }
+    # One sideload has nothing to run beside it, so the pool would hand the work
+    # to another thread and wait for it. A chain is one at every level. A
+    # polymorphic sideload counts as its children, which do run beside each other.
+    def overlapping_sideloads?
+      found = 0
+      each_applicable_sideload do |_, sideload, _|
+        found += sideload.respond_to?(:children) ? sideload.children.size : 1
+        return true if found > 1
+      end
       false
     end
 
@@ -218,18 +227,34 @@ module Graphiti
         sideload = @resource.class.sideload(name)
         next if sideload.nil? || sideload.shared_remote?
 
-        yield sideload, sideload_query
+        yield name, sideload, sideload_query
+      end
+    end
+
+    # The write path resolves sideloads twice on one scope, which would double every proxy in the cache key.
+    def reset_captured_sideload_proxies
+      @resolved_sideload_proxies_lock.synchronize { @resolved_sideload_proxies.clear }
+    end
+
+    # A proxy built while resolving is already resolved all the way down.
+    def capture_sideload_proxy(name, proxy)
+      @resolved_sideload_proxies_lock.synchronize do
+        captured = (@resolved_sideload_proxies[name] ||= [])
+        captured << proxy unless proxy.nil? || proxy == []
       end
     end
 
     def future_resolve_sideloads(results)
       return Concurrent::Promises.fulfilled_future(nil, self.class.global_thread_pool_executor) if results == []
 
+      reset_captured_sideload_proxies
       sideload_promises = []
-      each_applicable_sideload do |sideload, sideload_query|
+      each_applicable_sideload do |name, sideload, sideload_query|
         promise = future_with_context(results, sideload_query, @resource) do |parent_results, future_query, parent_resource|
           Graphiti.config.before_sideload&.call(Graphiti.context)
-          sideload.future_resolve(parent_results, future_query, parent_resource)
+          sideload.future_resolve(parent_results, future_query, parent_resource) do |proxy|
+            capture_sideload_proxy(name, proxy)
+          end
         end
         sideload_promises << promise.flat
       end
@@ -361,15 +386,19 @@ module Graphiti
 
     def sideload_resource_proxies
       @sideload_resource_proxies ||= begin
-        @object = @resource.before_resolve(@object, @query)
-        results = @resource.resolve(@object)
+        # Reached after the response resolved, where resolving again re-applies before_resolve to a mutated scope.
+        results = @resolved_records
+        if results.nil?
+          @object = @resource.before_resolve(@object, @query)
+          results = @resource.resolve(@object)
+        end
 
         [].tap do |proxies|
-          unless @query.sideloads.empty?
-            @query.sideloads.each_pair do |name, q|
-              sideload = @resource.class.sideload(name)
-              next if sideload.nil? || sideload.shared_remote?
-
+          each_applicable_sideload do |name, sideload, q|
+            captured = @resolved_sideload_proxies[name]
+            if captured
+              proxies.concat(captured)
+            else
               proxies << sideload.build_resource_proxy(results, q, parent_resource)
             end
           end

data/lib/graphiti/scoping/filter.rb

@@ -209,7 +209,7 @@ module Graphiti
     end
 
     def parse_string_null(filter, value)
-      return value unless filter[:blanks] == :as_nil
+      return value unless filter[:blanks] == :null
       return value.map { |item| (item == "null") ? nil : item } if value.is_a?(Array)
       return if value == "null"
 
@@ -217,7 +217,7 @@ module Graphiti
     end
 
     def check_blank_filters!(resource, filter, value)
-      return unless filter.values[0][:blanks] == :reject
+      return unless filter.values[0][:blanks] == :rejected
 
       if value.nil? || value.empty? || value == "null"
         raise Errors::InvalidFilterValue.new(resource, filter, "(empty)")

data/lib/graphiti/serializer.rb

@@ -1,7 +1,5 @@
 module Graphiti
   class Serializer < JSONAPI::Serializable::Resource
-    UNREQUESTED_LINKS = [false, nil, "false"].freeze
-
     include Graphiti::Extensions::BooleanAttribute
     include Graphiti::Extensions::ExtraAttribute
     include Graphiti::SerializableHash
@@ -26,6 +24,16 @@ module Graphiti
     self.relationship_condition_blocks ||= {}
     self.relationship_sideloads ||= {}
 
+    # Keyed on the sideloads hash itself, which is reassigned whenever a
+    # relationship is applied, so the answer is recomputed exactly then.
+    def self.on_demand_links?
+      sideloads = relationship_sideloads
+      return @on_demand_links.last if @on_demand_links&.first.equal?(sideloads)
+
+      @on_demand_links = [sideloads, sideloads.each_value.any? { |sideload| sideload.link_mode == :on_demand }]
+      @on_demand_links.last
+    end
+
     def self.inherited(klass)
       super
       klass.class_eval do
@@ -76,7 +84,7 @@ module Graphiti
 
     def as_jsonapi(kwargs = {})
       super(**kwargs).tap do |hash|
-        strip_relationships!(hash) if strip_relationships?
+        strip_relationships!(hash)
         add_links!(hash)
       end
     end
@@ -102,21 +110,29 @@ module Graphiti
       hash[:links] = @resource.links(@object) if @resource.links?
     end
 
-    # A relationship whose only content would be an unrequested on-demand link
-    # serializes as an empty stub, which JSON:API forbids.
+    # The meta: {included: false} stub is jsonapi-serializable's filler, not JSON:API.
     def strip_relationships!(hash)
+      placeholders = relationship_placeholders?
+      return if placeholders && !strip_on_demand_relationships?
+
       hash[:relationships]&.reject! do |name, payload|
         next false if payload.key?(:data) || payload.key?(:links)
+        next true unless placeholders
 
         self.class.relationship_sideloads[name]&.link_mode == :on_demand
       end
     end
 
-    def strip_relationships?
-      context = Graphiti.context[:object]
-      params = context.params if context.respond_to?(:params)
+    # A remote resource exposes a stand-in object rather than a Resource.
+    def relationship_placeholders?
+      resource_class = @resource.class
+      return Resource.relationship_placeholders unless resource_class.respond_to?(:relationship_placeholders)
+
+      resource_class.relationship_placeholders
+    end
 
-      UNREQUESTED_LINKS.include?(params && params[:links])
+    def strip_on_demand_relationships?
+      self.class.on_demand_links? && !@proxy&.query&.render_link?(:on_demand)
     end
   end
 end

data/lib/graphiti/sideload/polymorphic_belongs_to.rb

@@ -107,18 +107,18 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
     end
   end
 
-  def resolve(parents, query, graph_parent)
+  def resolve(parents, query, graph_parent, &proxy_block)
     if ::Graphiti::Scope.resolve_synchronously?
-      sync_resolve(parents, query, graph_parent)
+      sync_resolve(parents, query, graph_parent, &proxy_block)
     else
-      future_resolve(parents, query, graph_parent).value!
+      future_resolve(parents, query, graph_parent, &proxy_block).value!
     end
   end
 
-  def future_resolve(parents, query, graph_parent)
+  def future_resolve(parents, query, graph_parent, &proxy_block)
     promises = []
     each_resolvable_group(parents, query) do |child, group, child_query|
-      promises << child.future_resolve(group, child_query, graph_parent)
+      promises << child.future_resolve(group, child_query, graph_parent, &proxy_block)
     end
     return promises.first if promises.one?
 
@@ -130,14 +130,14 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
       end
   end
 
-  private
-
-  def sync_resolve(parents, query, graph_parent)
+  def sync_resolve(parents, query, graph_parent, &proxy_block)
     each_resolvable_group(parents, query) do |child, group, child_query|
-      child.resolve(group, child_query, graph_parent)
+      child.sync_resolve(group, child_query, graph_parent, &proxy_block)
     end
   end
 
+  private
+
   # Group parents by their polymorphic type and yield each group's child
   # sideload alongside a query pruned to the sideloads that child supports.
   def each_resolvable_group(parents, query)

data/lib/graphiti/sideload.rb

@@ -152,8 +152,12 @@ module Graphiti
       !!@polymorphic_as
     end
 
+    # Every check behind the blocker is static sideload configuration, and this
+    # is asked once per rendered record per relationship.
     def resource_ids_from_foreign_key?
-      resource_ids_blocker.nil?
+      return @resource_ids_from_foreign_key unless @resource_ids_from_foreign_key.nil?
+
+      @resource_ids_from_foreign_key = resource_ids_blocker.nil?
     end
 
     def resource_ids_blocker
@@ -285,14 +289,20 @@ module Graphiti
       proxy
     end
 
-    def load(parents, query, graph_parent)
+    def load(parents, query, graph_parent, &proxy_block)
       if Scope.resolve_synchronously?
-        build_resource_proxy(parents, query, graph_parent).to_a
+        sync_load(parents, query, graph_parent, &proxy_block)
       else
-        future_load(parents, query, graph_parent).value!
+        future_load(parents, query, graph_parent, &proxy_block).value!
       end
     end
 
+    def sync_load(parents, query, graph_parent, &proxy_block)
+      proxy = build_resource_proxy(parents, query, graph_parent)
+      proxy_block&.call(proxy)
+      proxy.to_a
+    end
+
     # Override in subclass
     def infer_foreign_key
       model = parent_resource_class.model
@@ -340,15 +350,30 @@ module Graphiti
       children.replace(associated) if track_associated
     end
 
-    def resolve(parents, query, graph_parent)
+    def resolve(parents, query, graph_parent, &proxy_block)
       if Scope.resolve_synchronously?
-        sync_resolve(parents, query, graph_parent)
+        sync_resolve(parents, query, graph_parent, &proxy_block)
+      else
+        future_resolve(parents, query, graph_parent, &proxy_block).value!
+      end
+    end
+
+    # Called by a scope that already decided to stay inline, so it must not consult the pool again.
+    # A scope_proc builds a Scope rather than a proxy, and that nested scope decides for itself.
+    def sync_resolve(parents, query, graph_parent, &proxy_block)
+      assert_singular!(parents)
+
+      if self.class.scope_proc
+        build_sideload_scope(parents, query, graph_parent).resolve do |sideload_results|
+          fire_assign(parents, sideload_results)
+        end
       else
-        future_resolve(parents, query, graph_parent).value!
+        sync_load(parents, query, graph_parent, &proxy_block)
       end
     end
 
-    def future_resolve(parents, query, graph_parent)
+    # A scope_proc builds a Scope rather than a proxy, and a Scope's cache key omits what a proxy's carries.
+    def future_resolve(parents, query, graph_parent, &proxy_block)
       assert_singular!(parents)
 
       if self.class.scope_proc
@@ -356,7 +381,7 @@ module Graphiti
           fire_assign(parents, sideload_results)
         end
       else
-        future_load(parents, query, graph_parent)
+        future_load(parents, query, graph_parent, &proxy_block)
       end
     end
 
@@ -420,21 +445,6 @@ module Graphiti
 
     private
 
-    # Synchronous counterpart to #future_resolve, used when concurrency is off.
-    # Resolves inline via the synchronous Scope#resolve / #load paths (no
-    # promises). See Scope#sync_resolve_sideloads.
-    def sync_resolve(parents, query, graph_parent)
-      assert_singular!(parents)
-
-      if self.class.scope_proc
-        build_sideload_scope(parents, query, graph_parent).resolve do |sideload_results|
-          fire_assign(parents, sideload_results)
-        end
-      else
-        load(parents, query, graph_parent)
-      end
-    end
-
     def assert_singular!(parents)
       if single? && parents.length > 1
         raise Errors::SingularSideload.new(self, parents.length)
@@ -451,8 +461,9 @@ module Graphiti
         default_paginate: false
     end
 
-    def future_load(parents, query, graph_parent)
+    def future_load(parents, query, graph_parent, &proxy_block)
       proxy = build_resource_proxy(parents, query, graph_parent)
+      proxy_block&.call(proxy)
       proxy.respond_to?(:future_resolve_data) ? proxy.future_resolve_data : Concurrent::Promises.fulfilled_future(proxy)
     end
 

data/lib/graphiti/spec_helpers/matchers.rb

@@ -186,7 +186,7 @@ module Graphiti
       # @param [Symbol] type
       #
       # @example expect(subject).to filter_attribute(:name, :string)
-      # @example expect(subject).to filter_attribute(:name, :string).with_options(blanks: :as_nil)
+      # @example expect(subject).to filter_attribute(:name, :string).with_options(blanks: :null)
       # @example expect(subject).not_to filter_attribute(:name, :string)
       def filter_attribute(attribute, type)
         FilterAttributeMatcher.new(attribute, type)

data/lib/graphiti/spec_helpers/rspec.rb

@@ -127,22 +127,14 @@ module Graphiti
         end
       end
 
-      def self.schema!(resources = nil)
+      def self.schema!(resources = nil, path: nil)
         ::RSpec.describe "Graphiti Schema" do
           it "generates a backwards-compatible schema" do
-            message = <<~MSG
-              Found backwards-incompatibilities in schema! Run with FORCE_SCHEMA=true to ignore.
+            check = Graphiti::Schema.check(resources, path: path || Graphiti.config.schema_path)
+            forced = ENV["FORCE_SCHEMA"] == "true"
+            check.write! if check.compatible? || forced
 
-              Incompatibilities:
-
-            MSG
-
-            errors = Graphiti::Schema.generate!(resources)
-            errors.each do |e|
-              message << "#{e}\n"
-            end
-
-            expect(errors.empty?).to eq(true), message
+            expect(check.compatible? || forced).to eq(true), check.message
           end
         end
       end

data/lib/graphiti/util/simple_errors.rb

@@ -6,6 +6,21 @@ module Graphiti
     class SimpleErrors
       include Enumerable
 
+      # Overridable under graphiti.errors.messages.
+      DEFAULT_MESSAGES = {
+        missing: "is missing",
+        invalid: "must be an object",
+        invalid_relationship: "is not a valid relationship",
+        unwritable_relationship: "cannot be written",
+        unknown_attribute: "is an unknown attribute",
+        unwritable_attribute: "cannot be written",
+        type_error: "should be type %{type}",
+        attribute_mismatch: "does not match the server endpoint"
+      }.freeze
+
+      # Joins an attribute to its message, like Rails' own errors.format.
+      DEFAULT_FORMAT = "%{attribute} %{message}"
+
       attr_reader :messages, :details
 
       def initialize(validation_target)
@@ -50,11 +65,9 @@ module Graphiti
       end
       alias_method :blank?, :empty?
 
-      def add(attribute, code, message: nil)
-        message ||= "is #{code.to_s.humanize.downcase}"
-
+      def add(attribute, code, message: nil, **interpolations)
         details[attribute.to_sym] << {error: code}
-        messages[attribute.to_sym] << message
+        messages[attribute.to_sym] << translate(code, message, **interpolations, attribute: attribute)
       end
 
       def added?(attribute, code)
@@ -73,11 +86,19 @@ module Graphiti
 
       def full_message(attribute, message)
         return message if attribute == :base
-        "#{attribute} #{message}"
+
+        translate(:format, DEFAULT_FORMAT, [:graphiti, :errors], attribute: attribute, message: message)
       end
 
       private
 
+      def translate(key, fallback, scope = [:graphiti, :errors, :messages], **interpolations)
+        fallback ||= DEFAULT_MESSAGES.fetch(key) { "is #{key.to_s.humanize.downcase}" }
+        return fallback % interpolations unless defined?(::I18n)
+
+        ::I18n.t(key, scope: scope, default: fallback, **interpolations)
+      end
+
       def apply_default_array(hash)
         hash.default_proc = proc { |h, key| h[key] = [] }
         hash

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "2.0.0.beta.10"
+  VERSION = "2.0.0.beta.12"
 end

data/lib/graphiti.rb

@@ -175,6 +175,7 @@ require "graphiti/audit"
 require "graphiti/audit/report"
 require "graphiti/schema"
 require "graphiti/schema_diff"
+require "graphiti/schema/check"
 require "graphiti/adapters/abstract"
 require "graphiti/resource/sideloading"
 require "graphiti/resource/links"

data/lib/tasks/graphiti.rake

@@ -16,6 +16,24 @@ namespace :graphiti do
     Graphiti::Debugger.flush if debug
   end
 
+  namespace :schema do
+    desc "Write the schema file. Refuses backwards-incompatible changes unless FORCE_SCHEMA=true. Takes an optional path, defaulting to Graphiti.config.schema_path."
+    task :generate, [:path] => [:environment] do |_, args|
+      check = Graphiti::Schema.check(path: helpers.schema_path(args[:path]))
+      abort check.message unless check.compatible? || ENV["FORCE_SCHEMA"] == "true"
+
+      puts "Schema written: #{check.write!}"
+    end
+
+    desc "Fail unless the committed schema file exists, is up to date, and is backwards-compatible. Takes an optional path, defaulting to Graphiti.config.schema_path."
+    task :check, [:path] => [:environment] do |_, args|
+      check = Graphiti::Schema.check(path: helpers.schema_path(args[:path]))
+      abort check.message unless check.ok?
+
+      puts check.message
+    end
+  end
+
   desc "Audit every relationship: what will raise, what loads to render ids, which render no ids, and which checks passed."
   task audit: [:environment] do
     helpers.setup_rails!

data/package.json

@@ -142,7 +142,7 @@
       [
         "@semantic-release/exec",
         {
-          "prepareCmd": "bundle exec ruby spec/performance/measure_releases.rb --pending v${nextRelease.version}"
+          "prepareCmd": "bundle exec ruby spec/performance/measure_releases.rb --promote v${nextRelease.version}"
         }
       ],
       [

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta.10
+  version: 2.0.0.beta.12
 platform: ruby
 authors:
 - Lee Richmond
@@ -287,6 +287,7 @@ files:
 - lib/generators/graphiti/api_test_generator.rb
 - lib/generators/graphiti/generator_mixin.rb
 - lib/generators/graphiti/install_generator.rb
+- lib/generators/graphiti/locale_generator.rb
 - lib/generators/graphiti/resource_generator.rb
 - lib/generators/graphiti/resource_test_generator.rb
 - lib/generators/graphiti/templates/application_resource.rb.erb
@@ -294,6 +295,7 @@ files:
 - lib/generators/graphiti/templates/create_request_spec.rb.erb
 - lib/generators/graphiti/templates/destroy_request_spec.rb.erb
 - lib/generators/graphiti/templates/index_request_spec.rb.erb
+- lib/generators/graphiti/templates/locale.yml.erb
 - lib/generators/graphiti/templates/resource.rb.erb
 - lib/generators/graphiti/templates/resource_reads_spec.rb.erb
 - lib/generators/graphiti/templates/resource_writes_spec.rb.erb
@@ -359,6 +361,7 @@ files:
 - lib/graphiti/responders.rb
 - lib/graphiti/runner.rb
 - lib/graphiti/schema.rb
+- lib/graphiti/schema/check.rb
 - lib/graphiti/schema_diff.rb
 - lib/graphiti/scope.rb
 - lib/graphiti/scoping/base.rb