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

data/lib/{neo4j/active_rel → active_graph/relationship}/rel_wrapper.rb

@@ -1,18 +1,18 @@
-require 'neo4j/core/relationship'
+require 'active_graph/core/relationship'
 
 wrapping_proc = proc do |relationship|
-  Neo4j::RelWrapping.wrapper(relationship)
+  ActiveGraph::RelWrapping.wrapper(relationship)
 end
 Neo4j::Driver::Types::Relationship.wrapper_callback(wrapping_proc)
 
-module Neo4j
+module ActiveGraph
   module RelWrapping
     class << self
       def wrapper(rel)
         rel.props.symbolize_keys!
         begin
           most_concrete_class = class_from_type(rel.rel_type).constantize
-          return rel unless most_concrete_class < Neo4j::ActiveRel
+          return rel unless most_concrete_class < ActiveGraph::Relationship
           most_concrete_class.new
         rescue NameError => e
           raise e unless e.message =~ /(uninitialized|wrong) constant/
@@ -24,7 +24,7 @@ module Neo4j
       end
 
       def class_from_type(rel_type)
-        Neo4j::ActiveRel::Types::WRAPPED_CLASSES[rel_type] || Neo4j::ActiveRel::Types::WRAPPED_CLASSES[rel_type] = rel_type.to_s.downcase.camelize
+        ActiveGraph::Relationship::Types::WRAPPED_CLASSES[rel_type] || ActiveGraph::Relationship::Types::WRAPPED_CLASSES[rel_type] = rel_type.to_s.downcase.camelize
       end
     end
   end

data/lib/{neo4j/active_rel → active_graph/relationship}/related_node.rb

@@ -1,18 +1,18 @@
-module Neo4j::ActiveRel
-  # A container for ActiveRel's :inbound and :outbound methods. It provides lazy loading of nodes.
+module ActiveGraph::Relationship
+  # A container for Relationship's :inbound and :outbound methods. It provides lazy loading of nodes.
   # It's important (or maybe not really IMPORTANT, but at least worth mentioning) that calling method_missing
   # will result in a query to load the node if the node is not already loaded.
   class RelatedNode
-    class UnsetRelatedNodeError < Neo4j::Error; end
+    class UnsetRelatedNodeError < ActiveGraph::Error; end
 
-    # ActiveRel's related nodes can be initialized with nothing, an integer, or a fully wrapped node.
+    # Relationship's related nodes can be initialized with nothing, an integer, or a fully wrapped node.
     #
-    # Initialization with nothing happens when a new, non-persisted ActiveRel object is first initialized.
+    # Initialization with nothing happens when a new, non-persisted Relationship object is first initialized.
     #
     # Initialization with an integer happens when a relationship is loaded from the database. It loads using the ID
     # because that is provided by the Cypher response and does not require an extra query.
     def initialize(node = nil)
-      @node = valid_node_param?(node) ? node : (fail Neo4j::InvalidParameterError, 'RelatedNode must be initialized with either a node ID or node')
+      @node = valid_node_param?(node) ? node : (fail ActiveGraph::InvalidParameterError, 'RelatedNode must be initialized with either a node ID or node')
     end
 
     # Loads the node if needed, then conducts comparison.
@@ -32,7 +32,7 @@ module Neo4j::ActiveRel
       @node = if @node.respond_to?(:neo_id)
                 @node
               else
-                Neo4j::ActiveBase.new_query.match(:n).where(n: {neo_id: @node}).pluck(:n).first
+                ActiveGraph::Base.new_query.match(:n).where(n: {neo_id: @node}).pluck(:n).first
               end
     end
 

data/lib/{neo4j/active_rel → active_graph/relationship}/types.rb

@@ -1,10 +1,10 @@
-module Neo4j
-  module ActiveRel
+module ActiveGraph
+  module Relationship
     # provides mapping of type to model name
     module Types
       extend ActiveSupport::Concern
 
-      # WRAPPED_CLASSES maps relationship types to ActiveRel models.
+      # WRAPPED_CLASSES maps relationship types to Relationship models.
       #
       # Typically, it's a 1:1 relationship, with a type having a model of the same name. Sometimes, someone needs to be a precious
       # snowflake and have a model name that doesn't match the rel type, so this comes in handy.
@@ -22,7 +22,7 @@ module Neo4j
       end
 
       module ClassMethods
-        include Neo4j::Shared::RelTypeConverters
+        include ActiveGraph::Shared::RelTypeConverters
 
         def inherited(subclass)
           subclass.type subclass.namespaced_model_name, true
@@ -46,11 +46,11 @@ module Neo4j
         alias _type type # should be deprecated
 
         def namespaced_model_name
-          case Neo4j::Config[:module_handling]
+          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/active_graph/relationship/validations.rb

@@ -0,0 +1,8 @@
+module ActiveGraph
+  module Relationship
+    module Validations
+      extend ActiveSupport::Concern
+      include ActiveGraph::Shared::Validations
+    end
+  end
+end

data/lib/{neo4j → active_graph}/schema/operation.rb

@@ -1,13 +1,13 @@
-module Neo4j
+module ActiveGraph
   module Schema
     class Operation
       attr_reader :label, :property, :options
 
       def initialize(label, property, options = default_options)
-        @label = if label.is_a?(Neo4j::Core::Label)
+        @label = if label.is_a?(ActiveGraph::Core::Label)
                    label
                  else
-                   Neo4j::Core::Label.new(label)
+                   ActiveGraph::Core::Label.new(label)
                  end
 
         @property = property.to_sym
@@ -62,7 +62,7 @@ module Neo4j
       end
     end
 
-    class ExactIndexOperation < Neo4j::Schema::Operation
+    class ExactIndexOperation < ActiveGraph::Schema::Operation
       def self.incompatible_operation_classes
         [UniqueConstraintOperation]
       end
@@ -76,7 +76,7 @@ module Neo4j
       end
     end
 
-    class UniqueConstraintOperation < Neo4j::Schema::Operation
+    class UniqueConstraintOperation < ActiveGraph::Schema::Operation
       def self.incompatible_operation_classes
         [ExactIndexOperation]
       end

data/lib/{neo4j → active_graph}/shared.rb

@@ -1,4 +1,4 @@
-module Neo4j
+module ActiveGraph
   module Shared
     extend ActiveSupport::Concern
     extend ActiveModel::Naming
@@ -14,28 +14,28 @@ module Neo4j
 
       # remove?
       def neo4j_driver
-        Neo4j::ActiveBase.current_driver
+        ActiveGraph::Base.current_driver
       end
 
       # remove?
       def current_transaction
-        Neo4j::ActiveBase.current_transaction
+        ActiveGraph::Base.current_transaction
       end
 
       # This should be used everywhere.  Should make it easy
       # to support a driver-per-model system
       def neo4j_query(*args)
-        Neo4j::ActiveBase.query(*args)
+        ActiveGraph::Base.query(*args)
       end
 
       def new_query
-        Neo4j::ActiveBase.new_query
+        ActiveGraph::Base.new_query
       end
     end
 
     included do
-      self.include_root_in_json = Neo4j::Config.include_root_in_json
-      @_declared_properties ||= Neo4j::Shared::DeclaredProperties.new(self)
+      self.include_root_in_json = ActiveGraph::Config.include_root_in_json
+      @_declared_properties ||= ActiveGraph::Shared::DeclaredProperties.new(self)
 
       def self.i18n_scope
         :neo4j

data/lib/{neo4j → active_graph}/shared/attributes.rb

@@ -1,10 +1,10 @@
-module Neo4j::Shared
+module ActiveGraph::Shared
   # Attributes provides a set of class methods for defining an attributes
   # schema and instance methods for reading and writing attributes.
   #
   # @example Usage
   #   class Person
-  #     include Neo4j::Shared::Attributes
+  #     include ActiveGraph::Shared::Attributes
   #     attribute :name
   #   end
   #
@@ -61,14 +61,14 @@ module Neo4j::Shared
     #
     # @raise [UnknownAttributeError] if the attribute is unknown
     def write_attribute(name, value)
-      fail Neo4j::UnknownAttributeError, "unknown attribute: #{name}" if !respond_to? "#{name}="
+      fail ActiveGraph::UnknownAttributeError, "unknown attribute: #{name}" if !respond_to? "#{name}="
 
       send "#{name}=", value
     end
     alias []= write_attribute
 
     def query_attribute(name)
-      fail Neo4j::UnknownAttributeError, "unknown attribute: #{name}" if !respond_to? "#{name}?"
+      fail ActiveGraph::UnknownAttributeError, "unknown attribute: #{name}" if !respond_to? "#{name}?"
 
       send "#{name}?"
     end
@@ -77,13 +77,13 @@ module Neo4j::Shared
 
     # Read an attribute from the attributes hash
     def attribute(name)
-      @attributes ||= Neo4j::AttributeSet.new({}, self.class.attributes.keys)
+      @attributes ||= ActiveGraph::AttributeSet.new({}, self.class.attributes.keys)
       @attributes.fetch_value(name.to_s)
     end
 
     # Write an attribute to the attributes hash
     def attribute=(name, value)
-      @attributes ||= Neo4j::AttributeSet.new({}, self.class.attributes.keys)
+      @attributes ||= ActiveGraph::AttributeSet.new({}, self.class.attributes.keys)
       @attributes.write_cast_value(name, value)
       value
     end
@@ -102,7 +102,7 @@ module Neo4j::Shared
     end
 
     def attribute?(name)
-      Neo4j::Shared::TypeConverters::BooleanConverter.to_ruby(read_attribute(name))
+      ActiveGraph::Shared::TypeConverters::BooleanConverter.to_ruby(read_attribute(name))
     end
 
     module ClassMethods
@@ -123,7 +123,7 @@ module Neo4j::Shared
       #
       # @return [AttributeDefinition] Attribute's definition
       def attribute(name)
-        fail Neo4j::DangerousAttributeError, %(an attribute method named "#{name}" would conflict with an existing method) if dangerous_attribute?(name)
+        fail ActiveGraph::DangerousAttributeError, %(an attribute method named "#{name}" would conflict with an existing method) if dangerous_attribute?(name)
 
         attribute!(name)
       end
@@ -143,7 +143,7 @@ module Neo4j::Shared
       # @example Get attribute definitions
       #   Person.attributes
       #
-      # @return [ActiveSupport::HashWithIndifferentAccess{String => Neo4j::Shared::AttributeDefinition}]
+      # @return [ActiveSupport::HashWithIndifferentAccess{String => ActiveGraph::Shared::AttributeDefinition}]
       #   The Hash of AttributeDefinition instances
       def attributes
         @attributes ||= ActiveSupport::HashWithIndifferentAccess.new
@@ -189,7 +189,7 @@ module Neo4j::Shared
 
       # Assign a set of attribute definitions, used when subclassing models
       #
-      # @param [Array<Neo4j::Shared::DeclaredProperties>] The Array of
+      # @param [Array<ActiveGraph::Shared::DeclaredProperties>] The Array of
       #   AttributeDefinition instances
       def attributes=(attributes)
         @attributes = attributes

data/lib/{neo4j → active_graph}/shared/callbacks.rb

@@ -1,4 +1,4 @@
-module Neo4j
+module ActiveGraph
   module Shared
     module Callbacks #:nodoc:
       extend ActiveSupport::Concern
@@ -9,7 +9,7 @@ module Neo4j
 
       included do
         include ActiveModel::Validations::Callbacks
-        # after_find is triggered by the `find` method defined in lib/neo4j/active_node/id_property.rb
+        # after_find is triggered by the `find` method defined in lib/neo4j/node/id_property.rb
         define_model_callbacks :initialize, :find, only: :after
         define_model_callbacks :create_commit, :update_commit, :destroy_commit, only: :after
         define_model_callbacks :save, :create, :update, :destroy, :touch
@@ -20,7 +20,7 @@ module Neo4j
       end
 
       def destroy #:nodoc:
-        tx = Neo4j::ActiveBase.new_transaction
+        tx = ActiveGraph::Base.new_transaction
         tx.root.after_commit { run_callbacks(:destroy_commit) {} }
         run_callbacks(:destroy) { super }
       rescue

data/lib/{neo4j → active_graph}/shared/cypher.rb

@@ -1,4 +1,4 @@
-module Neo4j::Shared
+module ActiveGraph::Shared
   module Cypher
     module CreateMethod
       def create_method

data/lib/{neo4j → active_graph}/shared/declared_properties.rb

@@ -1,17 +1,17 @@
-module Neo4j::Shared
+module ActiveGraph::Shared
   # The DeclaredPropertyuManager holds details about objects created as a result of calling the #property
-  # class method on a class that includes Neo4j::ActiveNode or Neo4j::ActiveRel. There are many options
+  # class method on a class that includes ActiveGraph::Node or ActiveGraph::Relationship. There are many options
   # that are referenced frequently, particularly during load and save, so this provides easy access and
   # a way of separating behavior from the general Active{obj} modules.
   #
-  # See Neo4j::Shared::DeclaredProperty for definitions of the property objects themselves.
+  # See ActiveGraph::Shared::DeclaredProperty for definitions of the property objects themselves.
   class DeclaredProperties
-    include Neo4j::Shared::TypeConverters
+    include ActiveGraph::Shared::TypeConverters
 
     attr_reader :klass
     delegate :each, :each_pair, :each_key, :each_value, to: :registered_properties
 
-    # Each class that includes Neo4j::ActiveNode or Neo4j::ActiveRel gets one instance of this class.
+    # Each class that includes ActiveGraph::Node or ActiveGraph::Relationship gets one instance of this class.
     # @param [#declared_properties] klass An object that has the #declared_properties method.
     def initialize(klass)
       @klass = klass
@@ -25,8 +25,8 @@ module Neo4j::Shared
       registered_properties.key?(key.to_sym)
     end
 
-    # @param [Neo4j::Shared::DeclaredProperty] property An instance of DeclaredProperty, created as the result of calling
-    # #property on an ActiveNode or ActiveRel class. The DeclaredProperty has specifics about the property, but registration
+    # @param [ActiveGraph::Shared::DeclaredProperty] property An instance of DeclaredProperty, created as the result of calling
+    # #property on an Node or Relationship class. The DeclaredProperty has specifics about the property, but registration
     # makes the management object aware of it. This is necessary for type conversion, defaults, and inclusion in the nil and string hashes.
     def register(property)
       @_attributes_nil_hash = nil
@@ -48,7 +48,7 @@ module Neo4j::Shared
       registered_properties[key].constraint!(type)
     end
 
-    # The :default option in Neo4j::ActiveNode#property class method allows for setting a default value instead of
+    # The :default option in ActiveGraph::Node#property class method allows for setting a default value instead of
     # nil on declared properties. This holds those values.
     def declared_property_defaults
       @_default_property_values ||= {}

data/lib/{neo4j → active_graph}/shared/declared_property.rb

@@ -1,10 +1,10 @@
-module Neo4j::Shared
+module ActiveGraph::Shared
   # Contains methods related to the management
   class DeclaredProperty
     include Comparable
 
-    class IllegalPropertyError < Neo4j::Error; end
-    include Neo4j::Shared::DeclaredProperty::Index
+    class IllegalPropertyError < ActiveGraph::Error; end
+    include ActiveGraph::Shared::DeclaredProperty::Index
 
     ILLEGAL_PROPS = %w(from_node to_node start_node end_node)
     attr_reader :name, :name_string, :name_sym, :options, :magic_typecaster, :type, :typecaster, :default_value
@@ -27,7 +27,7 @@ module Neo4j::Shared
     # @example
     #   attribute_definition <=> other
     #
-    # @param [Neo4j::Shared::DeclaredProperty, Object] other The other
+    # @param [ActiveGraph::Shared::DeclaredProperty, Object] other The other
     #   attribute definition to compare with.
     #
     # @return [-1, 0, 1, nil]
@@ -62,7 +62,7 @@ module Neo4j::Shared
     def fail_invalid_options!
       case
       when index?(:exact) && constraint?(:unique)
-        fail Neo4j::InvalidPropertyOptionsError,
+        fail ActiveGraph::InvalidPropertyOptionsError,
              "#Uniqueness constraints also provide exact indexes, cannot set both options on property #{name}"
       end
     end
@@ -80,7 +80,7 @@ module Neo4j::Shared
 
     # Tweaks properties
     def register_magic_properties
-      @type ||= Neo4j::Config.timestamp_type if timestamp_prop?
+      @type ||= ActiveGraph::Config.timestamp_type if timestamp_prop?
 
       register_magic_typecaster
       register_type_converter
@@ -91,7 +91,7 @@ module Neo4j::Shared
     end
 
     def register_magic_typecaster
-      found_typecaster = Neo4j::Shared::TypeConverters.typecaster_for(type)
+      found_typecaster = ActiveGraph::Shared::TypeConverters.typecaster_for(type)
       return unless found_typecaster && found_typecaster.respond_to?(:primitive_type)
       @typecaster = found_typecaster
       @magic_typecaster = type
@@ -102,8 +102,8 @@ module Neo4j::Shared
       converter = options[:serializer]
       return unless converter
       @type        = converter.convert_type
-      @typecaster  = Neo4j::Shared::TypeConverters::ObjectConverter
-      Neo4j::Shared::TypeConverters.register_converter(converter)
+      @typecaster  = ActiveGraph::Shared::TypeConverters::ObjectConverter
+      ActiveGraph::Shared::TypeConverters.register_converter(converter)
     end
   end
 end

data/lib/{neo4j → active_graph}/shared/declared_property/index.rb

@@ -1,4 +1,4 @@
-module Neo4j::Shared
+module ActiveGraph::Shared
   class DeclaredProperty
     # None of these methods interact with the database. They only keep track of property settings in models.
     # It could (should?) handle the actual indexing/constraining, but that's TBD.
@@ -16,12 +16,12 @@ module Neo4j::Shared
       end
 
       def index!(type = :exact)
-        fail Neo4j::InvalidPropertyOptionsError, "Can't set index on constrainted property #{name} (constraints get indexes automatically)" if constraint?(:unique)
+        fail ActiveGraph::InvalidPropertyOptionsError, "Can't set index on constrainted property #{name} (constraints get indexes automatically)" if constraint?(:unique)
         options[:index] = type
       end
 
       def constraint!(type = :unique)
-        fail Neo4j::InvalidPropertyOptionsError, "Can't set constraint on indexed property #{name} (constraints get indexes automatically)" if index?(:exact)
+        fail ActiveGraph::InvalidPropertyOptionsError, "Can't set constraint on indexed property #{name} (constraints get indexes automatically)" if index?(:exact)
         options[:constraint] = type
       end
 

data/lib/{neo4j → active_graph}/shared/enum.rb

@@ -1,9 +1,9 @@
-module Neo4j::Shared
+module ActiveGraph::Shared
   module Enum
     extend ActiveSupport::Concern
 
-    class ConflictingEnumMethodError < Neo4j::Error; end
-    class InvalidEnumValueError < Neo4j::InvalidParameterError; end
+    class ConflictingEnumMethodError < ActiveGraph::Error; end
+    class InvalidEnumValueError < ActiveGraph::InvalidParameterError; end
 
     module ClassMethods
       attr_reader :neo4j_enum_data
@@ -13,7 +13,7 @@ module Neo4j::Shared
       #
       # @example Base example
       #   class Media
-      #     include Neo4j::ActiveNode
+      #     include ActiveGraph::Node
       #     enum type: [:image, :video, :unknown]
       #   end
       #   Media.types # => { :images => 0, :video => 1, :unknown => 2 }
@@ -55,7 +55,7 @@ module Neo4j::Shared
       protected
 
       def normalize_key_list(enum_keys, options)
-        case_sensitive = options.fetch(:_case_sensitive, Neo4j::Config.enums_case_sensitive)
+        case_sensitive = options.fetch(:_case_sensitive, ActiveGraph::Config.enums_case_sensitive)
 
         case enum_keys
         when Hash
@@ -92,7 +92,7 @@ module Neo4j::Shared
 
       def define_property(property_name, enum_keys, options)
         property property_name, build_property_options(enum_keys, options)
-        serialize property_name, Neo4j::Shared::TypeConverters::EnumConverter.new(enum_keys, build_enum_options(enum_keys, options))
+        serialize property_name, ActiveGraph::Shared::TypeConverters::EnumConverter.new(enum_keys, build_enum_options(enum_keys, options))
 
         # If class has already been inherited, make sure subclasses fully inherit enum
         subclasses.each do |klass|