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

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

@@ -1,4 +1,4 @@
-module Neo4j::ActiveNode::Labels
+module ActiveGraph::Node::Labels
   module Reloading
     extend ActiveSupport::Concern
 

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

@@ -1,4 +1,4 @@
-module Neo4j::ActiveNode
+module ActiveGraph::Node
   class NodeListFormatter
     def initialize(list, max_elements = 5)
       @list = list

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

@@ -1,8 +1,8 @@
 require 'active_support/inflector'
-require 'neo4j/core/node'
+require 'active_graph/core/node'
 
 wrapping_proc = proc do |node|
-  found_class = Neo4j::NodeWrapping.class_to_wrap(node.labels)
+  found_class = ActiveGraph::NodeWrapping.class_to_wrap(node.labels)
   next node if not found_class
 
   found_class.new.tap do |wrapped_node|
@@ -11,7 +11,7 @@ wrapping_proc = proc do |node|
 end
 Neo4j::Driver::Types::Node.wrapper_callback(wrapping_proc)
 
-module Neo4j
+module ActiveGraph
   module NodeWrapping
     # Only load classes once for performance
     CONSTANTS_FOR_LABELS_CACHE = {}
@@ -19,7 +19,7 @@ module Neo4j
     class << self
       def class_to_wrap(labels)
         load_classes_from_labels(labels)
-        Neo4j::ActiveNode::Labels.model_for_labels(labels).tap do |model_class|
+        ActiveGraph::Node::Labels.model_for_labels(labels).tap do |model_class|
           populate_constants_for_labels_cache(model_class, labels)
         end
       end
@@ -47,7 +47,7 @@ module Neo4j
       end
 
       def association_model_namespace
-        Neo4j::Config.association_model_namespace_string
+        ActiveGraph::Config.association_model_namespace_string
       end
     end
   end

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

@@ -1,7 +1,7 @@
 require 'orm_adapter'
 
-module Neo4j
-  module ActiveNode
+module ActiveGraph
+  module Node
     module ClassMethods
       include OrmAdapter::ToAdapter
     end

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

@@ -1,4 +1,4 @@
-module Neo4j::ActiveNode
+module ActiveGraph::Node
   module Persistence
     class RecordInvalidError < RuntimeError
       attr_reader :record
@@ -11,7 +11,7 @@ module Neo4j::ActiveNode
 
     extend ActiveSupport::Concern
     extend Forwardable
-    include Neo4j::Shared::Persistence
+    include ActiveGraph::Shared::Persistence
 
     # Saves the model.
     #
@@ -41,11 +41,11 @@ module Neo4j::ActiveNode
     # to #save!  Creates a new transaction.
     #
     # @raise a RecordInvalidError if there is a problem during save.
-    # @param (see Neo4j::Rails::Validations#save)
+    # @param (see ActiveGraph::Rails::Validations#save)
     # @return nil
     # @see #save
-    # @see Neo4j::Rails::Validations Neo4j::Rails::Validations - for the :validate parameter
-    # @see Neo4j::Rails::Callbacks Neo4j::Rails::Callbacks - for callbacks
+    # @see ActiveGraph::Rails::Validations ActiveGraph::Rails::Validations - for the :validate parameter
+    # @see ActiveGraph::Rails::Callbacks ActiveGraph::Rails::Callbacks - for callbacks
     def save!(*args)
       save(*args) or fail(RecordInvalidError, self) # rubocop:disable Style/AndOr
     end
@@ -64,7 +64,7 @@ module Neo4j::ActiveNode
     # Creates an unwrapped node in the database.
     # @param [Hash] node_props The type-converted properties to be added to the new node.
     # @param [Array] labels The labels to use for creating the new node.
-    # @return [Neo4j::Node] A CypherNode or EmbeddedNode
+    # @return [ActiveGraph::Node] A CypherNode or EmbeddedNode
     def _create_node(node_props, labels = labels_for_create)
       query = "CREATE (n:`#{Array(labels).join('`:`')}`) SET n = $props RETURN n"
       neo4j_query(query, {props: node_props}, wrap_level: :core_entity).to_a[0].n
@@ -162,7 +162,7 @@ module Neo4j::ActiveNode
       end
 
       def query_base_for(neo_id, var = :n)
-        Neo4j::ActiveBase.new_query.match(var).where(var => {neo_id: neo_id})
+        ActiveGraph::Base.new_query.match(var).where(var => {neo_id: neo_id})
       end
 
       private

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

@@ -1,11 +1,11 @@
-module Neo4j::ActiveNode
+module ActiveGraph::Node
   module Property
     extend ActiveSupport::Concern
-    include Neo4j::Shared::Property
+    include ActiveGraph::Shared::Property
 
     def initialize(attributes = nil)
       super(attributes)
-      @attributes ||= Neo4j::AttributeSet.new(self.class.attributes_nil_hash, self.class.attributes.keys)
+      @attributes ||= ActiveGraph::AttributeSet.new(self.class.attributes_nil_hash, self.class.attributes.keys)
     end
 
     module ClassMethods

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

@@ -1,6 +1,6 @@
-module Neo4j
-  module ActiveNode
-    # Helper methods to return Neo4j::Core::Query objects.  A query object can be used to successively build a cypher query
+module ActiveGraph
+  module Node
+    # Helper methods to return ActiveGraph::Core::Query objects.  A query object can be used to successively build a cypher query
     #
     #    person.query_as(:n).match('n-[:friend]-o').return(o: :name) # Return the names of all the person's friends
     #
@@ -14,7 +14,7 @@ module Neo4j
       #   mike.query_as(:mike).match('mike-[:friend]-friend').return(friend: :name)
       #
       # @param node_var [Symbol, String] The variable name to specify in the query
-      # @return [Neo4j::Core::Query]
+      # @return [ActiveGraph::Core::Query]
       def query_as(node_var)
         self.class.query_as(node_var, false).where("ID(#{node_var})" => self.neo_id)
       end
@@ -27,7 +27,7 @@ module Neo4j
       #   student.as(:s).lessons(:l)
       #
       # @param [String, Symbol] node_var The identifier to use within the QueryProxy object
-      # @return [Neo4j::ActiveNode::Query::QueryProxy]
+      # @return [ActiveGraph::Node::Query::QueryProxy]
       def as(node_var)
         self.class.query_proxy(node: node_var, source_object: self).match_to(self)
       end
@@ -42,19 +42,19 @@ module Neo4j
         # @param [Symbol, String] var The variable name to specify in the query
         # @param [Boolean] with_labels Should labels be used to build the match? There are situations (neo_id used to filter,
         # an early Cypher match has already filtered results) where including labels will degrade performance.
-        # @return [Neo4j::Core::Query]
+        # @return [ActiveGraph::Core::Query]
         def query_as(var, with_labels = true)
           query_proxy.query_as(var, with_labels)
         end
 
-        Neo4j::ActiveNode::Query::QueryProxy::METHODS.each do |method|
+        ActiveGraph::Node::Query::QueryProxy::METHODS.each do |method|
           define_method(method) do |*args|
             self.query_proxy.send(method, *args)
           end
         end
 
         def query_proxy(options = {})
-          Neo4j::ActiveNode::Query::QueryProxy.new(self, nil, options)
+          ActiveGraph::Node::Query::QueryProxy.new(self, nil, options)
         end
 
         # Start a new QueryProxy with the starting identifier set to the given argument.
@@ -66,7 +66,7 @@ module Neo4j
         #   Student.as(:s).lessons
         #
         # @param [String, Symbol] node_var A string or symbol to use as the starting identifier.
-        # @return [Neo4j::ActiveNode::Query::QueryProxy]
+        # @return [ActiveGraph::Node::Query::QueryProxy]
         def as(node_var)
           query_proxy(node: node_var, context: self.name)
         end

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

@@ -1,32 +1,32 @@
-module Neo4j
-  module ActiveNode
+module ActiveGraph
+  module Node
     module Query
       # rubocop:disable Metrics/ClassLength
       class QueryProxy
         # rubocop:enable Metrics/ClassLength
-        include Neo4j::ActiveNode::Query::QueryProxyEnumerable
-        include Neo4j::ActiveNode::Query::QueryProxyMethods
-        include Neo4j::ActiveNode::Query::QueryProxyMethodsOfMassUpdating
-        include Neo4j::ActiveNode::Query::QueryProxyFindInBatches
-        include Neo4j::ActiveNode::Query::QueryProxyEagerLoading
-        include Neo4j::ActiveNode::Dependent::QueryProxyMethods
+        include ActiveGraph::Node::Query::QueryProxyEnumerable
+        include ActiveGraph::Node::Query::QueryProxyMethods
+        include ActiveGraph::Node::Query::QueryProxyMethodsOfMassUpdating
+        include ActiveGraph::Node::Query::QueryProxyFindInBatches
+        include ActiveGraph::Node::Query::QueryProxyEagerLoading
+        include ActiveGraph::Node::Dependent::QueryProxyMethods
 
         # The most recent node to start a QueryProxy chain.
         # Will be nil when using QueryProxy chains on class methods.
         attr_reader :source_object, :association, :model, :starting_query
 
-        # QueryProxy is ActiveNode's Cypher DSL. While the name might imply that it creates queries in a general sense,
-        # it is actually referring to <tt>Neo4j::Core::Query</tt>, which is a pure Ruby Cypher DSL provided by the <tt>neo4j-core</tt> gem.
+        # QueryProxy is Node's Cypher DSL. While the name might imply that it creates queries in a general sense,
+        # it is actually referring to <tt>ActiveGraph::Core::Query</tt>, which is a pure Ruby Cypher DSL provided by the <tt>neo4j-core</tt> gem.
         # QueryProxy provides ActiveRecord-like methods for common patterns. When it's not handling CRUD for relationships and queries, it
-        # provides ActiveNode's association chaining (`student.lessons.teachers.where(age: 30).hobbies`) and enjoys long walks on the
+        # provides Node's association chaining (`student.lessons.teachers.where(age: 30).hobbies`) and enjoys long walks on the
         # beach.
         #
         # It should not ever be necessary to instantiate a new QueryProxy object directly, it always happens as a result of
         # calling a method that makes use of it.
         #
-        # @param [Constant] model The class which included ActiveNode (typically a model, hence the name) from which the query
+        # @param [Constant] model The class which included Node (typically a model, hence the name) from which the query
         # originated.
-        # @param [Neo4j::ActiveNode::HasN::Association] association The ActiveNode association (an object created by a <tt>has_one</tt> or
+        # @param [ActiveGraph::Node::HasN::Association] association The Node association (an object created by a <tt>has_one</tt> or
         # <tt>has_many</tt>) that created this object.
         # @param [Hash] options Additional options pertaining to the QueryProxy object. These may include:
         # @option options [String, Symbol] :node_var A string or symbol to be used by Cypher within its query string as an identifier
@@ -34,7 +34,7 @@ module Neo4j
         # @option options [Range, Integer, Symbol, Hash] :rel_length A Range, a Integer, a Hash or a Symbol to indicate the variable-length/fixed-length
         #   qualifier of the relationship. See http://neo4jrb.readthedocs.org/en/latest/Querying.html#variable-length-relationships.
         # @option options [Neo4j::Driver] :driver The driver to be used for this query
-        # @option options [Neo4j::ActiveNode] :source_object The node instance at the start of the QueryProxy chain
+        # @option options [ActiveGraph::Node] :source_object The node instance at the start of the QueryProxy chain
         # @option options [QueryProxy] :query_proxy An existing QueryProxy chain upon which this new object should be built
         #
         # QueryProxy objects are evaluated lazily.
@@ -56,7 +56,7 @@ module Neo4j
         end
 
         def inspect
-          formatted_nodes = Neo4j::ActiveNode::NodeListFormatter.new(to_a)
+          formatted_nodes = ActiveGraph::Node::NodeListFormatter.new(to_a)
           "#<QueryProxy #{@context} #{formatted_nodes.inspect}>"
         end
 
@@ -87,8 +87,8 @@ module Neo4j
           query_as(identity)
         end
 
-        # Build a Neo4j::Core::Query object for the QueryProxy. This is necessary when you want to take an existing QueryProxy chain
-        # and work with it from the more powerful (but less friendly) Neo4j::Core::Query.
+        # Build a ActiveGraph::Core::Query object for the QueryProxy. This is necessary when you want to take an existing QueryProxy chain
+        # and work with it from the more powerful (but less friendly) ActiveGraph::Core::Query.
         # @param [String,Symbol] var The identifier to use for node at this link of the QueryProxy chain.
         #
         # .. code-block:: ruby
@@ -205,7 +205,7 @@ module Neo4j
           fail 'Can only create relationships on associations' if !@association
           other_nodes = _nodeify!(*other_nodes)
 
-          Neo4j::ActiveBase.run_transaction do
+          ActiveGraph::Base.run_transaction do
             other_nodes.each do |other_node|
               if other_node.neo_id
                 other_node.try(:delete_reverse_has_one_core_rel, association)
@@ -310,7 +310,7 @@ module Neo4j
         end
 
         def _query
-          Neo4j::ActiveBase.new_query(context: @context)
+          ActiveGraph::Base.new_query(context: @context)
         end
 
         def _result_string(index = nil)

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

@@ -1,5 +1,5 @@
-module Neo4j
-  module ActiveNode
+module ActiveGraph
+  module Node
     module Query
       module QueryProxyEagerLoading
         class IdentityMap < Hash
@@ -59,7 +59,7 @@ module Neo4j
         def add_to_cache(rel, node, element)
           direction = element.association.direction
           node = cache_and_init(node, element)
-          if rel.is_a?(Neo4j::ActiveRel)
+          if rel.is_a?(ActiveGraph::Relationship)
             rel.instance_variable_set(direction == :in ? '@from_node' : '@to_node', node)
           end
           @_cache[direction == :out ? rel.start_node_neo_id : rel.end_node_neo_id]

data/lib/{neo4j/active_node → active_graph/node}/query/query_proxy_eager_loading/association_tree.rb

@@ -1,5 +1,5 @@
-module Neo4j
-  module ActiveNode
+module ActiveGraph
+  module Node
     module Query
       module QueryProxyEagerLoading
         class AssociationTree < Hash

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

@@ -1,5 +1,5 @@
-module Neo4j
-  module ActiveNode
+module ActiveGraph
+  module Node
     module Query
       # Methods related to returning nodes and rels from QueryProxy
       module QueryProxyEnumerable
@@ -69,7 +69,7 @@ module Neo4j
         def pluck(*args)
           transformable_attributes = (model ? model.attribute_names : []) + %w(uuid neo_id)
           arg_list = args.map do |arg|
-            arg = Neo4j::ActiveNode::Query::QueryProxy::Link.converted_key(model, arg)
+            arg = ActiveGraph::Node::Query::QueryProxy::Link.converted_key(model, arg)
             if transformable_attributes.include?(arg.to_s)
               {identity => arg}
             else
@@ -99,7 +99,7 @@ module Neo4j
           instance.each do |object|
             object.instance_variable_set('@source_query_proxy', self)
             object.instance_variable_set('@source_proxy_result_cache', instance)
-            if node && rel && object.last.is_a?(Neo4j::ActiveRel)
+            if node && rel && object.last.is_a?(ActiveGraph::Relationship)
               object.last.instance_variable_set(association.direction == :in ? '@from_node' : '@to_node', object.first)
             end
           end

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

@@ -1,5 +1,5 @@
-module Neo4j
-  module ActiveNode
+module ActiveGraph
+  module Node
     module Query
       module QueryProxyFindInBatches
         def find_in_batches(options = {})

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

@@ -1,5 +1,5 @@
-module Neo4j
-  module ActiveNode
+module ActiveGraph
+  module Node
     module Query
       class QueryProxy
         class Link
@@ -56,7 +56,7 @@ module Neo4j
 
               val = if !model
                       value
-                    elsif key == model.id_property_name && value.is_a?(Neo4j::ActiveNode)
+                    elsif key == model.id_property_name && value.is_a?(ActiveGraph::Node)
                       value.id
                     else
                       converted_value(model, key, value)

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

@@ -1,5 +1,5 @@
-module Neo4j
-  module ActiveNode
+module ActiveGraph
+  module Node
     module Query
       # rubocop:disable Metrics/ModuleLength
       module QueryProxyMethods
@@ -54,7 +54,7 @@ module Neo4j
         # @return [Integer] number of nodes of this class
         def count(distinct = nil, target = nil)
           return 0 if unpersisted_start_object?
-          fail(Neo4j::InvalidParameterError, ':count accepts the `:distinct` symbol or nil as a parameter') unless distinct.nil? || distinct == :distinct
+          fail(ActiveGraph::InvalidParameterError, ':count accepts the `:distinct` symbol or nil as a parameter') unless distinct.nil? || distinct == :distinct
           query_with_target(target) do |var|
             q = ensure_distinct(var, !distinct.nil?)
             limited_query = self.query.clause?(:limit) ? self.query.break.with(var) : self.query.reorder
@@ -71,7 +71,7 @@ module Neo4j
         # TODO: update this with public API methods if/when they are exposed
         def limit_value
           return unless self.query.clause?(:limit)
-          limit_clause = self.query.send(:clauses).find { |clause| clause.is_a?(Neo4j::Core::QueryClauses::LimitClause) }
+          limit_clause = self.query.send(:clauses).find { |clause| clause.is_a?(ActiveGraph::Core::QueryClauses::LimitClause) }
           limit_clause.instance_variable_get(:@arg)
         end
 
@@ -82,7 +82,7 @@ module Neo4j
 
         alias blank? empty?
 
-        # @param [Neo4j::ActiveNode, Neo4j::Node, String] other An instance of a Neo4j.rb model, a Neo4j-core node, or a string uuid
+        # @param [ActiveGraph::Node, ActiveGraph::Node, String] other An instance of a Neo4j.rb model, a Neo4j-core node, or a string uuid
         # @param [String, Symbol] target An identifier of a link in the Cypher chain
         # @return [Boolean]
         def include?(other, target = nil)
@@ -99,7 +99,7 @@ module Neo4j
 
         def exists?(node_condition = nil, target = nil)
           unless [Integer, String, Hash, NilClass].any? { |c| node_condition.is_a?(c) }
-            fail(Neo4j::InvalidParameterError, ':exists? only accepts ids or conditions')
+            fail(ActiveGraph::InvalidParameterError, ':exists? only accepts ids or conditions')
           end
           query_with_target(target) do |var|
             start_q = exists_query_start(node_condition, var)
@@ -109,12 +109,12 @@ module Neo4j
         end
 
         # Shorthand for `MATCH (start)-[r]-(other_node) WHERE ID(other_node) = #{other_node.neo_id}`
-        # The `node` param can be a persisted ActiveNode instance, any string or integer, or nil.
+        # The `node` param can be a persisted Node instance, any string or integer, or nil.
         # When it's a node, it'll use the object's neo_id, which is fastest. When not nil, it'll figure out the
         # primary key of that model. When nil, it uses `1 = 2` to prevent matching all records, which is the default
         # behavior when nil is passed to `where` in QueryProxy.
         # @param [#neo_id, String, Enumerable] node A node, a string representing a node's ID, or an enumerable of nodes or IDs.
-        # @return [Neo4j::ActiveNode::Query::QueryProxy] A QueryProxy object upon which you can build.
+        # @return [ActiveGraph::Node::Query::QueryProxy] A QueryProxy object upon which you can build.
         def match_to(node)
           first_node = node.is_a?(Array) ? node.first : node
           where_arg = if first_node.respond_to?(:neo_id)
@@ -133,7 +133,7 @@ module Neo4j
         # Gives you the first relationship between the last link of a QueryProxy chain and a given node
         # Shorthand for `MATCH (start)-[r]-(other_node) WHERE ID(other_node) = #{other_node.neo_id} RETURN r`
         # @param [#neo_id, String, Enumerable] node An object to be sent to `match_to`. See params for that method.
-        # @return A relationship (ActiveRel, CypherRelationship, EmbeddedRelationship) or nil.
+        # @return A relationship (Relationship, CypherRelationship, EmbeddedRelationship) or nil.
         def first_rel_to(node)
           self.match_to(node).limit(1).pluck(rel_var).first
         end
@@ -152,7 +152,7 @@ module Neo4j
           fail 'Method invalid when called on Class objects' unless source_object
           result = self.where(params).first
           return result unless result.nil?
-          Neo4j::ActiveBase.run_transaction do
+          ActiveGraph::Base.run_transaction do
             node = model.create(params)
             self << node
             return node
@@ -172,7 +172,7 @@ module Neo4j
           self.send(association, node_var, rel_var, optional: true)
         end
 
-        # Takes an Array of ActiveNode models and applies the appropriate WHERE clause
+        # Takes an Array of Node models and applies the appropriate WHERE clause
         # So for a `Teacher` model inheriting from a `Person` model and an `Article` model
         # if you called .as_models([Teacher, Article])
         # The where clause would look something like:
@@ -250,7 +250,7 @@ module Neo4j
         end
 
         def where_clause_params
-          query.clauses.select { |c| c.is_a?(Neo4j::Core::QueryClauses::WhereClause) && c.arg.is_a?(Hash) }
+          query.clauses.select { |c| c.is_a?(ActiveGraph::Core::QueryClauses::WhereClause) && c.arg.is_a?(Hash) }
                .map! { |e| e.arg[identity] }.compact.inject { |a, b| a.merge(b) } || {}
         end
 

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

@@ -1,5 +1,5 @@
-module Neo4j
-  module ActiveNode
+module ActiveGraph
+  module Node
     module Query
       module QueryProxyMethodsOfMassUpdating
         # Updates some attributes of a group of nodes within a QP chain.
@@ -7,7 +7,7 @@ module Neo4j
         # @param [Hash,String] updates An hash or a string of parameters to be updated.
         # @param [Hash] params An hash of parameters for the update string. It's ignored if `updates` is an Hash.
         def update_all(updates, params = {})
-          # Move this to ActiveNode module?
+          # Move this to Node module?
           update_all_with_query(identity, updates, params)
         end
 
@@ -27,7 +27,7 @@ module Neo4j
           query_with_target(identifier) do |target|
             begin
               self.query.with(target).optional_match("(#{target})-[#{target}_rel]-()").delete("#{target}, #{target}_rel").exec
-            rescue Neo4j::Core::CypherError # <=- Seems hacky
+            rescue ActiveGraph::Core::CypherError # <=- Seems hacky
               self.query.delete(target).exec
             end
             clear_source_object_cache