graphiti-activegraph 1.3.1 → 1.3.3

data/lib/graphiti/active_graph/scoping/internal/path_descriptor.rb

@@ -1,94 +1,94 @@
-module Graphiti::ActiveGraph
-  module Scoping
-    module Internal
-      # Determine valid paths specified in filter and sort API params and normalize them for neo4j
-      class PathDescriptor
-        attr_reader :scope, :path, :attribute, :rel
-        delegate :relationship_class, to: :rel, allow_nil: true
-
-        def initialize(scope, rel)
-          self.scope = scope
-          self.path = []
-          self.attribute = :id
-          self.rel = rel
-          @has_next = true
-        end
-
-        def next?
-          @has_next
-        end
-
-        def increment(key)
-          raise Exception, 'no continuation on path possible' unless next?
-          if rel
-            increment_from_cache(key)
-          else
-            increment_from_scope(key)
-          end
-        end
-
-        def declared_property
-          (relationship_class || scope).attributes[attribute]
-        end
-
-        def self.parse(scope, path, rel = nil)
-          path_desc = new(scope, rel)
-          path_desc.increment(path.shift) while path_desc.next? && path.present?
-          path_desc if path.empty?
-        end
-
-        def self.association_for_relationship(associations, key)
-          key_class_name = key[:rel_name].classify
-          key_assoc_name = key[:rel_name].gsub('_rel', '')
-          assocs = associations.find_all { |_, value| value.relationship_class_name == key_class_name || value.name.to_s == key_assoc_name }
-          assocs.size == 1 ? assocs.first : nil
-        end
-
-        def path_relationships
-          path.map { |elm| elm[:rel_name].to_sym }
-        end
-
-        private
-
-        attr_writer :scope, :path, :attribute, :rel
-
-        def increment_from_cache(key)
-          rel_name = key[:rel_name]
-          if rel.target_class_names.map(&:demodulize).map(&:downcase).include?(rel_name)
-            self.rel = nil
-          else
-            final_attribute(rel_name)
-          end
-        end
-
-        def increment_from_scope(key)
-          associations = scope.associations
-          if associations.key?(key[:rel_name].to_sym)
-            advance(key)
-          else
-            increment_from_rel(self.class.association_for_relationship(associations, key), key)
-          end
-        end
-
-        def increment_from_rel(entry, key)
-          if entry
-            advance(rel_name: entry.first.to_s)
-            self.rel = entry.last
-          else
-            final_attribute(key[:rel_name])
-          end
-        end
-
-        def advance(key)
-          path << key
-          self.scope = scope.send(key[:rel_name], rel_length: key[:rel_length])
-        end
-
-        def final_attribute(key)
-          self.attribute = key
-          @has_next = false
-        end
-      end
-    end
-  end
-end
+module Graphiti::ActiveGraph
+  module Scoping
+    module Internal
+      # Determine valid paths specified in filter and sort API params and normalize them for neo4j
+      class PathDescriptor
+        attr_reader :scope, :path, :attribute, :rel
+        delegate :relationship_class, to: :rel, allow_nil: true
+
+        def initialize(scope, rel)
+          self.scope = scope
+          self.path = []
+          self.attribute = :id
+          self.rel = rel
+          @has_next = true
+        end
+
+        def next?
+          @has_next
+        end
+
+        def increment(key)
+          raise Exception, 'no continuation on path possible' unless next?
+          if rel
+            increment_from_cache(key)
+          else
+            increment_from_scope(key)
+          end
+        end
+
+        def declared_property
+          (relationship_class || scope).attributes[attribute]
+        end
+
+        def self.parse(scope, path, rel = nil)
+          path_desc = new(scope, rel)
+          path_desc.increment(path.shift) while path_desc.next? && path.present?
+          path_desc if path.empty?
+        end
+
+        def self.association_for_relationship(associations, key)
+          key_class_name = key[:rel_name].classify
+          key_assoc_name = key[:rel_name].gsub('_rel', '')
+          assocs = associations.find_all { |_, value| value.relationship_class_name == key_class_name || value.name.to_s == key_assoc_name }
+          assocs.size == 1 ? assocs.first : nil
+        end
+
+        def path_relationships
+          path.map { |elm| elm[:rel_name].to_sym }
+        end
+
+        private
+
+        attr_writer :scope, :path, :attribute, :rel
+
+        def increment_from_cache(key)
+          rel_name = key[:rel_name]
+          if rel.target_class_names.map(&:demodulize).map(&:downcase).include?(rel_name)
+            self.rel = nil
+          else
+            final_attribute(rel_name)
+          end
+        end
+
+        def increment_from_scope(key)
+          associations = scope.associations
+          if associations.key?(key[:rel_name].to_sym)
+            advance(key)
+          else
+            increment_from_rel(self.class.association_for_relationship(associations, key), key)
+          end
+        end
+
+        def increment_from_rel(entry, key)
+          if entry
+            advance(rel_name: entry.first.to_s)
+            self.rel = entry.last
+          else
+            final_attribute(key[:rel_name])
+          end
+        end
+
+        def advance(key)
+          path << key
+          self.scope = scope.send(key[:rel_name], rel_length: key[:rel_length])
+        end
+
+        def final_attribute(key)
+          self.attribute = key
+          @has_next = false
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/scoping/internal/sort_normalizer.rb

@@ -1,54 +1,54 @@
-module Graphiti::ActiveGraph
-  module Scoping
-    module Internal
-      class SortNormalizer
-        attr_reader :scope
-
-        def initialize(scope)
-          @scope = scope
-        end
-
-        def normalize(includes_hash, sorts, deep_sorts)
-          normalized_deep_sort = normalize_deep_sort(includes_hash, deep_sorts || [])
-          normalized_base_sort = normalize_base_sort(sorts)
-          normalized_deep_sort.merge(normalized_base_sort)
-        end
-
-        def normalize_base_sort(sorts)
-          sorts.present? ? { '' => sorts.map { |sort| "#{sort.keys.first} #{sort.values.first}" } } : {}
-        end
-
-        def normalize_deep_sort(includes_hash, sorts)
-          sorts
-            .map { |sort| sort(includes_hash, sort) }
-            .compact
-            .group_by(&:first)
-            .map { |key, value| combined_order_spec(key, value) }
-            .to_h
-        end
-
-        private
-
-        def combined_order_spec(key, value)
-          [key.join('.'), value.map(&:last)]
-        end
-
-        def sort(includes_hash, sort)
-          path = sort.keys.first.map { |key| { rel_name: key.to_s } }
-          return nil unless (descriptor = PathDescriptor.parse(scope, path))
-
-          sort_spec(descriptor, sort.values.first) if valid_sort?(includes_hash.deep_dup, descriptor.path_relationships)
-        end
-
-        def valid_sort?(hash, rels)
-          rels.empty? || rels.all? { |rel| hash = hash[rel] || hash[:"#{rel.to_s + '*'}"] }
-        end
-
-        def sort_spec(descriptor, direction)
-          sort_attr = [descriptor.attribute, direction].join(' ')
-          [descriptor.path_relationships, descriptor.rel.present? ? { rel: sort_attr } : sort_attr]
-        end
-      end
-    end
-  end
-end
+module Graphiti::ActiveGraph
+  module Scoping
+    module Internal
+      class SortNormalizer
+        attr_reader :scope
+
+        def initialize(scope)
+          @scope = scope
+        end
+
+        def normalize(includes_hash, sorts, deep_sorts)
+          normalized_deep_sort = normalize_deep_sort(includes_hash, deep_sorts || [])
+          normalized_base_sort = normalize_base_sort(sorts)
+          normalized_deep_sort.merge(normalized_base_sort)
+        end
+
+        def normalize_base_sort(sorts)
+          sorts.present? ? { '' => sorts.map { |sort| "#{sort.keys.first} #{sort.values.first}" } } : {}
+        end
+
+        def normalize_deep_sort(includes_hash, sorts)
+          sorts
+            .map { |sort| sort(includes_hash, sort) }
+            .compact
+            .group_by(&:first)
+            .map { |key, value| combined_order_spec(key, value) }
+            .to_h
+        end
+
+        private
+
+        def combined_order_spec(key, value)
+          [key.join('.'), value.map(&:last)]
+        end
+
+        def sort(includes_hash, sort)
+          path = sort.keys.first.map { |key| { rel_name: key.to_s } }
+          return nil unless (descriptor = PathDescriptor.parse(scope, path))
+
+          sort_spec(descriptor, sort.values.first) if valid_sort?(includes_hash, descriptor.path_relationships)
+        end
+
+        def valid_sort?(hash, rels)
+          rels.empty? || rels.all? { |rel| hash = hash[rel] || hash[:"#{rel.to_s + '*'}"] }
+        end
+
+        def sort_spec(descriptor, direction)
+          sort_attr = [descriptor.attribute, direction].join(' ')
+          [descriptor.path_relationships, descriptor.rel.present? ? { rel: sort_attr } : sort_attr]
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/scoping/internal/sorting_aliases.rb

@@ -1,35 +1,35 @@
-module Graphiti::ActiveGraph
-  module Scoping
-    module Internal
-      # Carrying forward valriables from neo4j procedure call to sort with include
-      module SortingAliases
-        def with_vars_for_sort
-          [] unless add_extra_vars_to_query?
-          (deep_sort_keys + sort_keys) & resource.extra_attributes.keys - graphiti_query_vars.map(&:to_sym)
-        end
-
-        def add_extra_vars_to_query?
-          resource.extra_attributes.present? && (query.sorts.present? || query.deep_sort.present?)
-        end
-
-        def deep_sort_keys
-          (query.deep_sort || []).collect { |sort| sort.keys.first.first }
-        end
-
-        def sort_keys
-          query.sorts.collect(&:keys).flatten
-        end
-
-        def query
-          @opts[:query_obj]
-        end
-
-        private
-
-        def graphiti_query_vars
-          Graphiti.context.fetch(:with_vars, [])
-        end
-      end
-    end
-  end
-end
+module Graphiti::ActiveGraph
+  module Scoping
+    module Internal
+      # Carrying forward valriables from neo4j procedure call to sort with include
+      module SortingAliases
+        def with_vars_for_sort
+          [] unless add_extra_vars_to_query?
+          (deep_sort_keys + sort_keys) & resource.extra_attributes.keys - graphiti_query_vars.map(&:to_sym)
+        end
+
+        def add_extra_vars_to_query?
+          resource.extra_attributes.present? && (query.sorts.present? || query.deep_sort.present?)
+        end
+
+        def deep_sort_keys
+          (query.deep_sort || []).collect { |sort| sort.keys.first.first }
+        end
+
+        def sort_keys
+          query.sorts.collect(&:keys).flatten
+        end
+
+        def query
+          @opts[:query_obj]
+        end
+
+        private
+
+        def graphiti_query_vars
+          Graphiti.context.fetch(:with_vars, [])
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/scoping/internal/sparse_fields_eagerloading.rb

@@ -1,28 +1,28 @@
-module Graphiti::ActiveGraph
-  module Scoping
-    module Internal
-      module SparseFieldsEagerloading
-        private
-
-        def add_relationships_from_sparse_fields(scope, includes_array)
-          return if @fields.blank?
-
-          related_fields(scope.model).each { |field_name| includes_array << process_field(field_name, scope) }
-        end
-
-        def process_field(field_name, _scope)
-          field_name
-        end
-
-        def resource_name_of(model)
-          model.model_name.plural.to_sym
-        end
-
-        def related_fields(model)
-          attr_and_rel_fields = @fields[resource_name_of(model)] || []
-          attr_and_rel_fields.select { |field_name| model.associations[field_name] }
-        end
-      end
-    end
-  end
-end
+module Graphiti::ActiveGraph
+  module Scoping
+    module Internal
+      module SparseFieldsEagerloading
+        private
+
+        def add_relationships_from_sparse_fields(scope, includes_array)
+          return if @fields.blank?
+
+          related_fields(scope.model).each { |field_name| includes_array << process_field(field_name, scope) }
+        end
+
+        def process_field(field_name, _scope)
+          field_name
+        end
+
+        def resource_name_of(model)
+          model.model_name.plural.to_sym
+        end
+
+        def related_fields(model)
+          attr_and_rel_fields = @fields[resource_name_of(model)] || []
+          attr_and_rel_fields.select { |field_name| model.associations[field_name] }
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/serializer.rb

@@ -1,15 +1,15 @@
-module Graphiti::ActiveGraph
-  module Serializer
-    def jsonapi_resource_class
-      if polymorphic?
-        "#{jsonapi_type.to_s.singularize.camelize}Resource".constantize
-      else
-        @resource.class
-      end
-    end
-
-    def resource_class_name
-      @_type.to_s.singularize.camelize
-    end
-  end
-end
+module Graphiti::ActiveGraph
+  module Serializer
+    def jsonapi_resource_class
+      if polymorphic?
+        "#{jsonapi_type.to_s.singularize.camelize}Resource".constantize
+      else
+        @resource.class
+      end
+    end
+
+    def resource_class_name
+      @_type.to_s.singularize.camelize
+    end
+  end
+end