activegraph 10.0.0.pre.alpha.6

data/lib/neo4j/active_rel/rel_wrapper.rb

@@ -0,0 +1,31 @@
+require 'neo4j/core/relationship'
+
+wrapping_proc = proc do |relationship|
+  Neo4j::RelWrapping.wrapper(relationship)
+end
+Neo4j::Driver::Types::Relationship.wrapper_callback(wrapping_proc)
+
+module Neo4j
+  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
+          most_concrete_class.new
+        rescue NameError => e
+          raise e unless e.message =~ /(uninitialized|wrong) constant/
+
+          return rel
+        end.tap do |wrapped_rel|
+          wrapped_rel.init_on_load(rel, rel.start_node_id, rel.end_node_id, rel.type)
+        end
+      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
+      end
+    end
+  end
+end

data/lib/neo4j/active_rel/related_node.rb

@@ -0,0 +1,87 @@
+module Neo4j::ActiveRel
+  # A container for ActiveRel'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
+
+    # ActiveRel'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 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')
+    end
+
+    # Loads the node if needed, then conducts comparison.
+    def ==(other)
+      loaded if @node.is_a?(Integer)
+      @node == other
+    end
+
+    # Returns the neo_id of a given node without loading.
+    def neo_id
+      loaded? ? @node.neo_id : @node
+    end
+
+    # Loads a node from the database or returns the node if already laoded
+    def loaded
+      fail UnsetRelatedNodeError, 'Node not set, cannot load' if @node.nil?
+      @node = if @node.respond_to?(:neo_id)
+                @node
+              else
+                Neo4j::ActiveBase.new_query.match(:n).where(n: {neo_id: @node}).pluck(:n).first
+              end
+    end
+
+    # @param [String, Symbol, Array] clazz An alternate label to use in the event the node is not present or loaded
+    def cypher_representation(clazz)
+      case
+      when !set?
+        "(#{formatted_label_list(clazz)})"
+      when set? && !loaded?
+        "(Node with neo_id #{@node})"
+      else
+        node_class = self.class
+        id_name = node_class.id_property_name
+        labels = ':' + node_class.mapped_label_names.join(':')
+
+        "(#{labels} {#{id_name}: #{@node.id.inspect}})"
+      end
+    end
+
+    # @return [Boolean] indicates whether a node has or has not been fully loaded from the database
+    def loaded?
+      @node.respond_to?(:neo_id)
+    end
+
+    def set?
+      !@node.nil?
+    end
+
+    def method_missing(*args, &block)
+      loaded.send(*args, &block)
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      loaded if @node.is_a?(Numeric)
+      @node.respond_to?(method_name) ? true : super
+    end
+
+    def class
+      loaded.send(:class)
+    end
+
+    private
+
+    def formatted_label_list(list)
+      list.is_a?(Array) ? list.join(' || ') : list
+    end
+
+    def valid_node_param?(node)
+      node.nil? || node.is_a?(Integer) || node.respond_to?(:neo_id)
+    end
+  end
+end

data/lib/neo4j/active_rel/types.rb

@@ -0,0 +1,82 @@
+module Neo4j
+  module ActiveRel
+    # provides mapping of type to model name
+    module Types
+      extend ActiveSupport::Concern
+
+      # WRAPPED_CLASSES maps relationship types to ActiveRel 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.
+      #
+      # As an example, Chris often finds it easier to name models after the classes that use the relationship: `StudentLesson` instead of
+      # `EnrolledIn`, because it's easier to remember "A student has a relationship to lesson" than "the type of relationship between Student
+      # and Lesson is 'EnrolledIn'." After all, that is a big part of why we have models, right? To make our lives easier?
+      #
+      # A model is added to WRAPPED_CLASSES when it is initalized AND when the `type` class method is called within a model. This means that
+      # it's possible a model will be added twice: once with the rel_type version of the model name, again with the custom type. deal_with_it.gif.
+      WRAPPED_CLASSES = {}
+
+      included do
+        type self.namespaced_model_name, true
+      end
+
+      module ClassMethods
+        include Neo4j::Shared::RelTypeConverters
+
+        def inherited(subclass)
+          subclass.type subclass.namespaced_model_name, true
+        end
+
+        # When called without arguments, it will return the current setting or supply a default.
+        # When called with arguments, it will change the current setting.
+        # @param [String] given_type sets the relationship type when creating relationships via this class
+        # @param [Boolean] auto Should the given_type be changed in compliance with the gem's rel decorator setting?
+        def type(given_type = nil, auto = false)
+          case
+          when !given_type && rel_type?
+            @rel_type
+          when given_type
+            assign_type!(given_type, auto)
+          else
+            assign_type!(namespaced_model_name, true)
+          end
+        end
+        alias rel_type type
+        alias _type type # should be deprecated
+
+        def namespaced_model_name
+          case Neo4j::Config[:module_handling]
+          when :demodulize
+            self.name.demodulize
+          when Proc
+            Neo4j::Config[:module_handling].call(self.name)
+          else
+            self.name
+          end
+        end
+
+        def _wrapped_classes
+          WRAPPED_CLASSES
+        end
+
+        def add_wrapped_class(type)
+          # WRAPPED_CLASSES[type.to_sym.downcase] = self.name
+          _wrapped_classes[type.to_sym] = self.name
+        end
+
+        def rel_type?
+          !!@rel_type
+        end
+
+        private
+
+        def assign_type!(given_type, auto)
+          @rel_type = (auto ? decorated_rel_type(given_type) : given_type).tap do |type|
+            add_wrapped_class(type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_rel/validations.rb

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

data/lib/neo4j/ansi.rb

@@ -0,0 +1,14 @@
+module Neo4j
+  module ANSI
+    CLEAR = "\e[0m"
+    BOLD = "\e[1m"
+
+    RED = "\e[31m"
+    GREEN = "\e[32m"
+    YELLOW = "\e[33m"
+    BLUE = "\e[34m"
+    MAGENTA = "\e[35m"
+    CYAN = "\e[36m"
+    WHITE = "\e[37m"
+  end
+end

data/lib/neo4j/class_arguments.rb

@@ -0,0 +1,39 @@
+module Neo4j
+  module ClassArguments
+    class << self
+      INVALID_CLASS_ARGUMENT_ERROR = 'option must by String, Symbol, false, nil, or an Array of Symbols/Strings'
+
+      def valid_argument?(class_argument)
+        [NilClass, String, Symbol, FalseClass].include?(class_argument.class) ||
+          (class_argument.is_a?(Array) && class_argument.all? { |c| [Symbol, String].include?(c.class) })
+      end
+
+      def validate_argument!(class_argument, context)
+        return if valid_argument?(class_argument)
+
+        fail ArgumentError, "#{context} #{INVALID_CLASS_ARGUMENT_ERROR} (was #{class_argument.inspect})"
+      end
+
+      def active_node_model?(class_constant)
+        class_constant.included_modules.include?(Neo4j::ActiveNode)
+      end
+
+      def constantize_argument(class_argument)
+        case class_argument
+        when 'any', :any, false, nil
+          nil
+        when Array
+          class_argument.map(&method(:constantize_argument))
+        else
+          class_argument.to_s.constantize.tap do |class_constant|
+            if !active_node_model?(class_constant)
+              fail ArgumentError, "#{class_constant} is not an ActiveNode model"
+            end
+          end
+        end
+      rescue NameError
+        raise ArgumentError, "Could not find class: #{class_argument}"
+      end
+    end
+  end
+end

data/lib/neo4j/config.rb

@@ -0,0 +1,135 @@
+module Neo4j
+  # == Keeps configuration for neo4j
+  #
+  # == Configurations keys
+  class Config
+    DEFAULT_FILE = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'config', 'neo4j', 'config.yml'))
+
+    class << self
+      # In keeping with the Rails convention, this class writer lets you globally configure
+      # the incluse of timestamps on your nodes and rels. It defaults to false, requiring manual
+      # timestamp inclusion.
+      # @return [Boolean] the true/false value specified.
+
+      # @return [Integer] The location of the default configuration file.
+      def default_file
+        @default_file ||= DEFAULT_FILE
+      end
+
+      # Sets the location of the configuration YAML file and old deletes configurations.
+      # @param [String] file_path represent the path to the file.
+      def default_file=(file_path)
+        delete_all
+        @defaults = nil
+        @default_file = File.expand_path(file_path)
+      end
+
+      # @return [Hash] the default file loaded by yaml
+      def defaults
+        require 'yaml'
+        @defaults ||= ActiveSupport::HashWithIndifferentAccess.new(YAML.load_file(default_file))
+      end
+
+      # Reads from the default_file if configuration is not set already
+      # @return [Hash] the configuration
+      def configuration
+        return @configuration if @configuration
+
+        @configuration = ActiveSupport::HashWithIndifferentAccess.new
+        @configuration.merge!(defaults)
+        @configuration
+      end
+
+      # Yields the configuration
+      #
+      # @example
+      #   Neo4j::Config.use do |config|
+      #     config[:storage_path] = '/var/neo4j'
+      #   end
+      #
+      # @return nil
+      # @yield config
+      # @yieldparam [Neo4j::Config] config - this configuration class
+      def use
+        @configuration ||= ActiveSupport::HashWithIndifferentAccess.new
+        yield @configuration
+        nil
+      end
+
+      # Sets the value of a config entry.
+      #
+      # @param [Symbol] key the key to set the parameter for
+      # @param val the value of the parameter.
+      def []=(key, val)
+        configuration[key.to_s] = val
+      end
+
+      # @param [Symbol] key The key of the config entry value we want
+      # @return the the value of a config entry
+      def [](key)
+        configuration[key.to_s]
+      end
+
+      def fetch(key, default)
+        configuration.fetch(key, default)
+      end
+
+      # Remove the value of a config entry.
+      #
+      # @param [Symbol] key the key of the configuration entry to delete
+      # @return The value of the removed entry.
+      def delete(key)
+        configuration.delete(key)
+      end
+
+      # Remove all configuration. This can be useful for testing purpose.
+      #
+      # @return nil
+      def delete_all
+        @configuration = nil
+      end
+
+      # @return [Hash] The config as a hash.
+      def to_hash
+        configuration.to_hash
+      end
+
+      # @return [String] The config as a YAML
+      def to_yaml
+        configuration.to_yaml
+      end
+
+      def fail_on_pending_migrations
+        Neo4j::Config[:fail_on_pending_migrations].nil? ? true : Neo4j::Config[:fail_on_pending_migrations]
+      end
+
+      def include_root_in_json
+        # we use ternary because a simple || will always evaluate true
+        Neo4j::Config[:include_root_in_json].nil? ? true : Neo4j::Config[:include_root_in_json]
+      end
+
+      def module_handling
+        Neo4j::Config[:module_handling] || :none
+      end
+
+      # @return [Class] The configured timestamps type (e.g. Integer) or the default DateTime.
+      def timestamp_type
+        Neo4j::Config[:timestamp_type] || DateTime
+      end
+
+      def association_model_namespace
+        Neo4j::Config[:association_model_namespace] || nil
+      end
+
+      def association_model_namespace_string
+        namespace = Neo4j::Config[:association_model_namespace]
+        return nil if namespace.nil?
+        "::#{namespace}"
+      end
+
+      def enums_case_sensitive
+        Neo4j::Config[:enums_case_sensitive] || false
+      end
+    end
+  end
+end

data/lib/neo4j/core.rb

@@ -0,0 +1,14 @@
+require 'neo4j/transaction'
+require 'neo4j/core/instrumentable'
+require 'neo4j/core/query'
+require 'neo4j/core/driver'
+require 'neo4j/core/responses'
+
+require 'neo4j_ruby_driver'
+require 'neo4j/core/wrappable'
+require 'neo4j/core/node'
+require 'neo4j/core/relationship'
+
+Neo4j::Driver::Types::Entity.include Neo4j::Core::Wrappable
+Neo4j::Driver::Types::Node.prepend Neo4j::Core::Node
+Neo4j::Driver::Types::Relationship.include Neo4j::Core::Relationship

data/lib/neo4j/core/connection_failed_error.rb

@@ -0,0 +1,6 @@
+module Neo4j
+  module Core
+    class ConnectionFailedError < StandardError;
+    end
+  end
+end

data/lib/neo4j/core/cypher_error.rb

@@ -0,0 +1,37 @@
+module Neo4j
+  module Core
+    class CypherError < StandardError
+      attr_reader :code, :original_message, :stack_trace
+
+      def initialize(code = nil, original_message = nil, stack_trace = nil)
+        @code = code
+        @original_message = original_message
+        @stack_trace = stack_trace
+
+        msg = <<-ERROR
+  Cypher error:
+  #{ANSI::CYAN}#{code}#{ANSI::CLEAR}: #{original_message}
+  #{stack_trace}
+        ERROR
+        super(msg)
+      end
+
+      def self.new_from(code, message, stack_trace = nil)
+        error_class_from(code).new(code, message, stack_trace)
+      end
+
+      def self.error_class_from(code)
+        case code
+        when /(ConstraintValidationFailed|ConstraintViolation)/
+          SchemaErrors::ConstraintValidationFailedError
+        when /IndexAlreadyExists/
+          SchemaErrors::IndexAlreadyExistsError
+        when /ConstraintAlreadyExists/ # ?????
+          SchemaErrors::ConstraintAlreadyExistsError
+        else
+          CypherError
+        end
+      end
+    end
+  end
+end