activegraph 10.0.0.pre.alpha.11 → 10.0.0.pre.beta.1

data/lib/{neo4j/active_node → active_graph/node}/dependent/query_proxy_methods.rb

@@ -1,5 +1,5 @@
-module Neo4j
-  module ActiveNode
+module ActiveGraph
+  module Node
     module Dependent
       # methods used to resolve association dependencies
       module QueryProxyMethods
@@ -22,10 +22,10 @@ module Neo4j
 
         # This will match nodes who only have a single relationship of a given type.
         # It's used  by `dependent: :delete_orphans` and `dependent: :destroy_orphans` and may not have much utility otherwise.
-        # @param [Neo4j::ActiveNode::HasN::Association] association The Association object used throughout the match.
+        # @param [ActiveGraph::Node::HasN::Association] association The Association object used throughout the match.
         # @param [String, Symbol] other_node The identifier to use for the other end of the chain.
         # @param [String, Symbol] other_rel The identifier to use for the relationship in the optional match.
-        # @return [Neo4j::ActiveNode::Query::QueryProxy]
+        # @return [ActiveGraph::Node::Query::QueryProxy]
         def unique_nodes(association, self_identifer, other_node, other_rel, ids = [])
           fail 'Only supported by in QueryProxy chains started by an instance' unless source_object
           return false if send(association.name).empty?

data/lib/{neo4j/active_node → active_graph/node}/dependent_callbacks.rb

@@ -1,5 +1,5 @@
-module Neo4j
-  module ActiveNode
+module ActiveGraph
+  module Node
     module DependentCallbacks
       extend ActiveSupport::Concern
 
@@ -22,8 +22,8 @@ module Neo4j
         unique_query.each_for_destruction(self, &:destroy) if unique_query
       end
 
-      def callbacks_from_active_rel(active_rel, direction, other_node)
-        rel = active_rel_corresponding_rel(active_rel, direction, other_node.class).try(:last)
+      def callbacks_from_relationship(relationship, direction, other_node)
+        rel = relationship_corresponding_rel(relationship, direction, other_node.class).try(:last)
         public_send("dependent_#{rel.dependent}_callback", rel, [other_node.id]) if rel && rel.dependent
       end
     end

data/lib/{neo4j/active_node → active_graph/node}/enum.rb

@@ -1,14 +1,14 @@
-module Neo4j::ActiveNode
+module ActiveGraph::Node
   module Enum
     extend ActiveSupport::Concern
-    include Neo4j::Shared::Enum
+    include ActiveGraph::Shared::Enum
 
     module ClassMethods
       protected
 
       def define_property(property_name, *args)
         super
-        Neo4j::ModelSchema.add_required_index(self, property_name) unless args[1][:_index] == false
+        ActiveGraph::ModelSchema.add_required_index(self, property_name) unless args[1][:_index] == false
       end
 
       def define_enum_methods(property_name, enum_keys, options)

data/lib/{neo4j/active_node → active_graph/node}/has_n.rb

@@ -1,9 +1,9 @@
-module Neo4j::ActiveNode
+module ActiveGraph::Node
   module HasN
     extend ActiveSupport::Concern
 
-    class NonPersistedNodeError < Neo4j::Error; end
-    class HasOneConstraintError < Neo4j::Error; end
+    class NonPersistedNodeError < ActiveGraph::Error; end
+    class HasOneConstraintError < ActiveGraph::Error; end
     # Return this object from associations
     # It uses a QueryProxy to get results
     # But also caches results and can have results cached on it
@@ -23,7 +23,7 @@ module Neo4j::ActiveNode
       # States:
       # Default
       def inspect
-        formatted_nodes = ::Neo4j::ActiveNode::NodeListFormatter.new(result_nodes)
+        formatted_nodes = ::ActiveGraph::Node::NodeListFormatter.new(result_nodes)
         "#<AssociationProxy #{@query_proxy.context} #{formatted_nodes.inspect}>"
       end
 
@@ -87,7 +87,7 @@ module Neo4j::ActiveNode
 
       def result_ids
         result.map do |object|
-          object.is_a?(Neo4j::ActiveNode) ? object.id : object
+          object.is_a?(ActiveGraph::Node) ? object.id : object
         end
       end
 
@@ -151,8 +151,8 @@ module Neo4j::ActiveNode
         target = target_for_missing_method(method_name)
         super if target.nil?
 
-        cache_query_proxy_result if !cached? && !target.is_a?(Neo4j::ActiveNode::Query::QueryProxy)
-        clear_cache_result if target.is_a?(Neo4j::ActiveNode::Query::QueryProxy)
+        cache_query_proxy_result if !cached? && !target.is_a?(ActiveGraph::Node::Query::QueryProxy)
+        clear_cache_result if target.is_a?(ActiveGraph::Node::Query::QueryProxy)
 
         target.public_send(method_name, *args, &block)
       end
@@ -165,7 +165,7 @@ module Neo4j::ActiveNode
 
       def map_results_as_nodes(result)
         result.map do |object|
-          object.is_a?(Neo4j::ActiveNode) ? object : @query_proxy.model.find(object)
+          object.is_a?(ActiveGraph::Node) ? object : @query_proxy.model.find(object)
         end
       end
 
@@ -241,8 +241,8 @@ module Neo4j::ActiveNode
       reverse_assoc && reverse_assoc.last
     end
 
-    def delete_reverse_has_one_active_rel(active_rel, direction, other_node)
-      rel = active_rel_corresponding_rel(active_rel, direction, other_node.class)
+    def delete_reverse_has_one_relationship(relationship, direction, other_node)
+      rel = relationship_corresponding_rel(relationship, direction, other_node.class)
       delete_has_one_rel!(rel.last) if rel && rel.last.type == :has_one
     end
 
@@ -251,10 +251,10 @@ module Neo4j::ActiveNode
       association_proxy_cache.clear
     end
 
-    def active_rel_corresponding_rel(active_rel, direction, target_class)
+    def relationship_corresponding_rel(relationship, direction, target_class)
       self.class.associations.find do |_key, assoc|
-        assoc.relationship_class_name == active_rel.class.name ||
-          (assoc.relationship_type == active_rel.type.to_sym && assoc.target_class == target_class && assoc.direction == direction)
+        assoc.relationship_class_name == relationship.class.name ||
+          (assoc.relationship_type == relationship.type.to_sym && assoc.target_class == target_class && assoc.direction == direction)
       end
     end
 
@@ -377,11 +377,11 @@ module Neo4j::ActiveNode
       #         Post.has_one :in, :author, type: :has_author, model_class: :Person
       #
       #     *model_class*: The model class to which the association is referring.  Can be a
-      #       Symbol/String (or an ``Array`` of same) with the name of the `ActiveNode` class,
+      #       Symbol/String (or an ``Array`` of same) with the name of the `Node` class,
       #       `false` to specify any model, or nil to specify that it should be guessed.
       #
-      #     *rel_class*: The ``ActiveRel`` class to use for this association.  Can be either a
-      #       model object ``include`` ing ``ActiveRel`` or a Symbol/String (or an ``Array`` of same).
+      #     *rel_class*: The ``Relationship`` class to use for this association.  Can be either a
+      #       model object ``include`` ing ``Relationship`` or a Symbol/String (or an ``Array`` of same).
       #       **A Symbol or String is recommended** to avoid load-time issues
       #
       #     *dependent*: Enables deletion cascading.
@@ -402,7 +402,7 @@ module Neo4j::ActiveNode
       #
       # This would define the methods: ``#vehicle``, ``#vehicle=``, and ``.vehicle``.
       #
-      # See :ref:`#has_many <Neo4j/ActiveNode/HasN/ClassMethods#has_many>` for anything
+      # See :ref:`#has_many <Neo4j/Node/HasN/ClassMethods#has_many>` for anything
       # not specified here
       #
       def has_one(direction, name, options = {}) # rubocop:disable Naming/PredicateName
@@ -543,7 +543,7 @@ module Neo4j::ActiveNode
       def association_query_proxy(name, options = {})
         previous_query_proxy = options[:previous_query_proxy] || current_scope
         query_proxy = previous_query_proxy || default_association_query_proxy
-        Neo4j::ActiveNode::Query::QueryProxy.new(association_target_class(name),
+        ActiveGraph::Node::Query::QueryProxy.new(association_target_class(name),
                                                  associations[name],
                                                  {driver: neo4j_driver,
                                                   query_proxy: query_proxy,
@@ -577,13 +577,13 @@ module Neo4j::ActiveNode
       end
 
       def default_association_query_proxy
-        Neo4j::ActiveNode::Query::QueryProxy.new("::#{self.name}".constantize, nil,
+        ActiveGraph::Node::Query::QueryProxy.new("::#{self.name}".constantize, nil,
                                                  driver: neo4j_driver, query_proxy: nil, context: self.name.to_s)
       end
 
       def build_association(macro, direction, name, options)
         options[:model_class] = options[:model_class].name if options[:model_class] == self
-        Neo4j::ActiveNode::HasN::Association.new(macro, direction, name, options).tap do |association|
+        ActiveGraph::Node::HasN::Association.new(macro, direction, name, options).tap do |association|
           add_association(name, association)
           create_reflection(macro, name, association, self)
         end

data/lib/{neo4j/active_node → active_graph/node}/has_n/association.rb

@@ -1,13 +1,13 @@
 require 'active_support/inflector/inflections'
-require 'neo4j/class_arguments'
+require 'active_graph/class_arguments'
 
-module Neo4j
-  module ActiveNode
+module ActiveGraph
+  module Node
     module HasN
       class Association
-        include Neo4j::Shared::RelTypeConverters
-        include Neo4j::ActiveNode::Dependent::AssociationMethods
-        include Neo4j::ActiveNode::HasN::AssociationCypherMethods
+        include ActiveGraph::Shared::RelTypeConverters
+        include ActiveGraph::Node::Dependent::AssociationMethods
+        include ActiveGraph::Node::HasN::AssociationCypherMethods
 
         attr_reader :type, :name, :relationship, :direction, :dependent, :model_class
 
@@ -89,7 +89,7 @@ module Neo4j
 
         def discovered_model
           target_classes.select do |constant|
-            constant.ancestors.include?(::Neo4j::ActiveNode)
+            constant.ancestors.include?(::ActiveGraph::Node)
           end
         end
 
@@ -153,7 +153,7 @@ module Neo4j
         private
 
         def association_model_namespace
-          Neo4j::Config.association_model_namespace_string
+          ActiveGraph::Config.association_model_namespace_string
         end
 
         def get_direction(create, reverse = false)

data/lib/{neo4j/active_node → active_graph/node}/has_n/association/rel_factory.rb

@@ -1,4 +1,4 @@
-module Neo4j::ActiveNode::HasN
+module ActiveGraph::Node::HasN
   class Association
     class RelFactory
       [:start_object, :other_node_or_nodes, :properties, :association].tap do |accessors|
@@ -36,7 +36,7 @@ module Neo4j::ActiveNode::HasN
         Array(other_node_or_nodes).each do |other_node|
           wrapper = _rel_wrapper(properties)
           base = _match_query(other_node, wrapper)
-          factory = Neo4j::Shared::RelQueryFactory.new(wrapper, wrapper.rel_identifier)
+          factory = ActiveGraph::Shared::RelQueryFactory.new(wrapper, wrapper.rel_identifier)
           factory.base_query = base
           factory.query.exec
         end
@@ -44,7 +44,7 @@ module Neo4j::ActiveNode::HasN
 
       def _match_query(other_node, wrapper)
         nodes = _nodes_for_create(other_node, wrapper.from_node_identifier, wrapper.to_node_identifier)
-        Neo4j::ActiveBase.new_query.match_nodes(nodes)
+        ActiveGraph::Base.new_query.match_nodes(nodes)
       end
 
       def _nodes_for_create(other_node, from_node_id, to_node_id)
@@ -54,7 +54,7 @@ module Neo4j::ActiveNode::HasN
       end
 
       def _rel_wrapper(properties)
-        Neo4j::ActiveNode::HasN::Association::RelWrapper.new(association, properties)
+        ActiveGraph::Node::HasN::Association::RelWrapper.new(association, properties)
       end
     end
   end

data/lib/{neo4j/active_node → active_graph/node}/has_n/association/rel_wrapper.rb

@@ -1,8 +1,8 @@
-class Neo4j::ActiveNode::HasN::Association
-  # Provides the interface needed to interact with the ActiveRel query factory.
+class ActiveGraph::Node::HasN::Association
+  # Provides the interface needed to interact with the Relationship query factory.
   class RelWrapper
-    include Neo4j::Shared::Cypher::RelIdentifiers
-    include Neo4j::Shared::Cypher::CreateMethod
+    include ActiveGraph::Shared::Cypher::RelIdentifiers
+    include ActiveGraph::Shared::Cypher::CreateMethod
 
     attr_reader :type, :association
     attr_accessor :properties

data/lib/{neo4j/active_node → active_graph/node}/has_n/association_cypher_methods.rb

@@ -1,5 +1,5 @@
-module Neo4j
-  module ActiveNode
+module ActiveGraph
+  module Node
     module HasN
       module AssociationCypherMethods
         # Return cypher partial query string for the relationship part of a MATCH (arrow / relationship definition)

data/lib/{neo4j/active_node → active_graph/node}/id_property.rb

@@ -1,16 +1,16 @@
-module Neo4j::ActiveNode
+module ActiveGraph::Node
   # This module makes it possible to use other IDs than the build it neo4j id (neo_id)
   #
   # @example using generated UUIDs
   #   class Person
-  #     include Neo4j::ActiveNode
+  #     include ActiveGraph::Node
   #     # creates a 'secret' neo4j property my_uuid which will be used as primary key
   #     id_property :my_uuid, auto: :uuid
   #   end
   #
   # @example using user defined ids
   #   class Person
-  #     include Neo4j::ActiveNode
+  #     include ActiveGraph::Node
   #     property :title
   #     validates :title, :presence => true
   #     id_property :title_id, on: :title_to_url
@@ -22,7 +22,7 @@ module Neo4j::ActiveNode
   #
   # @example using already exsting ids that you don't want a constraint added to
   #   class Person
-  #     include Neo4j::ActiveNode
+  #     include ActiveGraph::Node
   #     property :title
   #     validates :title, :presence => true
   #     id_property :id, on: :id_builder, constraint: false
@@ -198,18 +198,18 @@ module Neo4j::ActiveNode
           return
         end
 
-        Neo4j::ModelSchema.add_defined_constraint(self, id_property_name)
+        ActiveGraph::ModelSchema.add_defined_constraint(self, id_property_name)
       end
 
       def warn_constraint_option_false!(id_property_name)
-        Neo4j::ActiveBase.logger.warn <<MSG
+        ActiveGraph::Base.logger.warn <<MSG
         WARNING: The constraint option for id_property is no longer supported (Used on #{self.name}.#{id_property_name}).
         Since you specified `constraint: false` this option can simply be removed.
 MSG
       end
 
       def id_property_name_type_value
-        name, type, value = Neo4j::Config.to_hash.values_at('id_property', 'id_property_type', 'id_property_type_value')
+        name, type, value = ActiveGraph::Config.to_hash.values_at('id_property', 'id_property_type', 'id_property_type_value')
 
         unless name == :neo_id || (name && type && value)
           name = :uuid

data/lib/{neo4j/active_node → active_graph/node}/id_property/accessor.rb

@@ -1,4 +1,4 @@
-module Neo4j::ActiveNode::IdProperty
+module ActiveGraph::Node::IdProperty
   # Provides get/set of the Id Property values.
   # Some methods
   module Accessor

data/lib/{neo4j/active_node → active_graph/node}/initialize.rb

@@ -1,11 +1,11 @@
-module Neo4j::ActiveNode::Initialize
+module ActiveGraph::Node::Initialize
   extend ActiveSupport::Concern
-  include Neo4j::Shared::Initialize
+  include ActiveGraph::Shared::Initialize
 
   attr_reader :called_by
 
   # called when loading the node from the database
-  # @param [Neo4j::Node] persisted_node the node this class wraps
+  # @param [ActiveGraph::Node] persisted_node the node this class wraps
   # @param [Hash] properties of the persisted node.
   def init_on_load(persisted_node, properties)
     self.class.extract_association_attributes!(properties)

data/lib/{neo4j/active_node → active_graph/node}/labels.rb

@@ -1,24 +1,24 @@
-require 'neo4j/core/label'
+require 'active_graph/core/label'
 
-module Neo4j
-  module ActiveNode
+module ActiveGraph
+  module Node
     # Provides a mapping between neo4j labels and Ruby classes
     module Labels
       extend ActiveSupport::Concern
-      include Neo4j::ActiveNode::Labels::Index
-      include Neo4j::ActiveNode::Labels::Reloading
+      include ActiveGraph::Node::Labels::Index
+      include ActiveGraph::Node::Labels::Reloading
 
       WRAPPED_CLASSES = []
       MODELS_FOR_LABELS_CACHE = {}
       MODELS_FOR_LABELS_CACHE.clear
 
       included do |model|
-        Neo4j::ActiveNode::Labels.clear_wrapped_models
+        ActiveGraph::Node::Labels.clear_wrapped_models
 
-        Neo4j::ActiveNode::Labels.add_wrapped_class(model) unless Neo4j::ActiveNode::Labels._wrapped_classes.include?(model)
+        ActiveGraph::Node::Labels.add_wrapped_class(model) unless ActiveGraph::Node::Labels._wrapped_classes.include?(model)
       end
 
-      class RecordNotFound < Neo4j::RecordNotFound; end
+      class RecordNotFound < ActiveGraph::RecordNotFound; end
 
       # @return the labels
       # @see Neo4j-core
@@ -76,11 +76,11 @@ module Neo4j
 
       def self.clear_wrapped_models
         MODELS_FOR_LABELS_CACHE.clear
-        Neo4j::NodeWrapping::CONSTANTS_FOR_LABELS_CACHE.clear
+        ActiveGraph::NodeWrapping::CONSTANTS_FOR_LABELS_CACHE.clear
       end
 
       module ClassMethods
-        include Neo4j::ActiveNode::QueryMethods
+        include ActiveGraph::Node::QueryMethods
 
         delegate :update_all, to: :all
 
@@ -129,14 +129,14 @@ module Neo4j
           @mapped_label_name || label_for_model
         end
 
-        # @return [Neo4j::Label] the label for this class
+        # @return [ActiveGraph::Label] the label for this class
         def mapped_label
-          Neo4j::Core::Label.new(mapped_label_name)
+          ActiveGraph::Core::Label.new(mapped_label_name)
         end
 
         def base_class
-          unless self < Neo4j::ActiveNode
-            fail "#{name} doesn't belong in a hierarchy descending from ActiveNode"
+          unless self < ActiveGraph::Node
+            fail "#{name} doesn't belong in a hierarchy descending from Node"
           end
 
           if superclass == Object
@@ -149,7 +149,7 @@ module Neo4j
         protected
 
         def mapped_labels
-          mapped_label_names.map { |label_name| Neo4j::Label.create(label_name) }
+          mapped_label_names.map { |label_name| ActiveGraph::Label.create(label_name) }
         end
 
         def mapped_label_name=(name)
@@ -176,7 +176,7 @@ module Neo4j
 
         def find_callbacks!(result)
           case result
-          when Neo4j::ActiveNode
+          when ActiveGraph::Node
             result.run_callbacks(:find)
           when Array
             result.each { |r| find_callbacks!(r) }
@@ -190,11 +190,11 @@ module Neo4j
         end
 
         def decorated_label_name
-          name =  case Neo4j::Config[:module_handling]
+          name =  case ActiveGraph::Config[:module_handling]
                   when :demodulize
                     self.name.demodulize
                   when Proc
-                    Neo4j::Config[:module_handling].call self.name
+                    ActiveGraph::Config[:module_handling].call self.name
                   else
                     self.name
                   end

data/lib/{neo4j/active_node → active_graph/node}/labels/index.rb

@@ -1,4 +1,4 @@
-module Neo4j::ActiveNode::Labels
+module ActiveGraph::Node::Labels
   module Index
     extend ActiveSupport::Concern
 
@@ -9,20 +9,20 @@ module Neo4j::ActiveNode::Labels
 
       # Creates a Neo4j index on given property
       #
-      # This can also be done on the property directly, see Neo4j::ActiveNode::Property::ClassMethods#property.
+      # This can also be done on the property directly, see ActiveGraph::Node::Property::ClassMethods#property.
       #
       # @param [Symbol] property the property we want a Neo4j index on
       #
       # @example
       #   class Person
-      #      include Neo4j::ActiveNode
+      #      include ActiveGraph::Node
       #      property :name
       #      index :name
       #    end
       def index(property)
-        return if Neo4j::ModelSchema.defined_constraint?(self, property)
+        return if ActiveGraph::ModelSchema.defined_constraint?(self, property)
 
-        Neo4j::ModelSchema.add_defined_index(self, property)
+        ActiveGraph::ModelSchema.add_defined_index(self, property)
       end
 
       # Creates a neo4j constraint on this class for given property
@@ -30,7 +30,7 @@ module Neo4j::ActiveNode::Labels
       # @example
       #   Person.constraint :name, type: :unique
       def constraint(property, _constraints = {type: :unique})
-        Neo4j::ModelSchema.add_defined_constraint(self, property)
+        ActiveGraph::ModelSchema.add_defined_constraint(self, property)
       end
     end
   end