activegraph 11.0.0.beta.1-java

data/lib/active_graph/class_arguments.rb

@@ -0,0 +1,39 @@
+module ActiveGraph
+  module ClassArguments
+    class << self
+      INVALID_CLASS_ARGUMENT_ERROR = 'option must be 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 node_model?(class_constant)
+        class_constant.included_modules.include?(ActiveGraph::Node)
+      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 !node_model?(class_constant)
+              fail ArgumentError, "#{class_constant} is not an Node model"
+            end
+          end
+        end
+      rescue NameError
+        raise ArgumentError, "Could not find class: #{class_argument}"
+      end
+    end
+  end
+end

data/lib/active_graph/config.rb

@@ -0,0 +1,135 @@
+module ActiveGraph
+  # == 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
+      #   ActiveGraph::Config.use do |config|
+      #     config[:storage_path] = '/var/neo4j'
+      #   end
+      #
+      # @return nil
+      # @yield config
+      # @yieldparam [ActiveGraph::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
+        ActiveGraph::Config[:fail_on_pending_migrations].nil? ? true : ActiveGraph::Config[:fail_on_pending_migrations]
+      end
+
+      def include_root_in_json
+        # we use ternary because a simple || will always evaluate true
+        ActiveGraph::Config[:include_root_in_json].nil? ? true : ActiveGraph::Config[:include_root_in_json]
+      end
+
+      def module_handling
+        ActiveGraph::Config[:module_handling] || :none
+      end
+
+      # @return [Class] The configured timestamps type (e.g. Integer) or the default DateTime.
+      def timestamp_type
+        ActiveGraph::Config[:timestamp_type] || DateTime
+      end
+
+      def association_model_namespace
+        ActiveGraph::Config[:association_model_namespace] || nil
+      end
+
+      def association_model_namespace_string
+        namespace = ActiveGraph::Config[:association_model_namespace]
+        return nil if namespace.nil?
+        "::#{namespace}"
+      end
+
+      def enums_case_sensitive
+        ActiveGraph::Config[:enums_case_sensitive] || false
+      end
+    end
+  end
+end

data/lib/active_graph/core.rb

@@ -0,0 +1,14 @@
+require 'active_graph/core/instrumentable'
+require 'active_graph/core/entity'
+require 'active_graph/core/node'
+require 'active_graph/core/query'
+require 'active_graph/core/record'
+require 'active_graph/core/wrappable'
+require 'active_graph/transaction'
+require 'neo4j_ruby_driver'
+
+Neo4j::Driver::Types::Entity.include ActiveGraph::Core::Wrappable
+Neo4j::Driver::Types::Entity.prepend ActiveGraph::Core::Entity
+Neo4j::Driver::Types::Node.prepend ActiveGraph::Core::Node
+Neo4j::Driver::Result.prepend ActiveGraph::Core::Result
+Neo4j::Driver::Record.prepend ActiveGraph::Core::Record

data/lib/active_graph/core/connection_failed_error.rb

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

data/lib/active_graph/core/cypher_error.rb

@@ -0,0 +1,37 @@
+module ActiveGraph
+  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

data/lib/active_graph/core/entity.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveGraph
+  module Core
+    module Entity
+      def properties
+        @properties ||= super
+      end
+    end
+  end
+end

data/lib/active_graph/core/instrumentable.rb

@@ -0,0 +1,37 @@
+require 'active_support/concern'
+require 'active_support/notifications'
+require 'active_graph/ansi'
+require 'active_graph/core/logging'
+
+module ActiveGraph
+  module Core
+    module Instrumentable
+      extend ActiveSupport::Concern
+
+      EMPTY = ''
+      NEWLINE_W_SPACES = "\n  "
+
+      class_methods do
+        def subscribe_to_request
+          ActiveSupport::Notifications.subscribe('neo4j.core.bolt.request') do |_, start, finish, _id, _payload|
+            ms = (finish - start) * 1000
+            yield " #{ANSI::BLUE}BOLT:#{ANSI::CLEAR} #{ANSI::YELLOW}#{ms.round}ms#{ANSI::CLEAR}"
+          end
+        end
+
+        def subscribe_to_query
+          ActiveSupport::Notifications.subscribe('neo4j.core.cypher_query') do |_, _start, _finish, _id, payload|
+            query = payload[:query]
+            params_string = (query.parameters && !query.parameters.empty? ? "| #{query.parameters.inspect}" : EMPTY)
+            cypher = query.pretty_cypher ? (NEWLINE_W_SPACES if query.pretty_cypher.include?("\n")).to_s + query.pretty_cypher.gsub(/\n/, NEWLINE_W_SPACES) : query.cypher
+
+            source_line, line_number = Logging.first_external_path_and_line(caller_locations)
+
+            yield " #{ANSI::CYAN}#{query.context || 'CYPHER'}#{ANSI::CLEAR} #{cypher} #{params_string}" +
+              ("\n   ↳ #{source_line}:#{line_number}" if ActiveGraph::Config.fetch(:verbose_query_logs, false) && source_line).to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_graph/core/label.rb

@@ -0,0 +1,135 @@
+module ActiveGraph
+  module Core
+    class Label
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def create_index(property, options = {})
+        validate_index_options!(options)
+        properties = property.is_a?(Array) ? property.join(',') : property
+        schema_query("CREATE INDEX ON :`#{@name}`(#{properties})")
+      end
+
+      def drop_index(property, options = {})
+        validate_index_options!(options)
+        schema_query("DROP INDEX ON :`#{@name}`(#{property})")
+      end
+
+      # Creates a neo4j constraint on a property
+      # See http://docs.neo4j.org/chunked/stable/query-constraints.html
+      # @example
+      #   label = ActiveGraph::Label.create(:person)
+      #   label.create_constraint(:name, {type: :unique})
+      #
+      def create_constraint(property, constraints)
+        cypher = case constraints[:type]
+                 when :unique, :uniqueness
+                   "CREATE CONSTRAINT ON (n:`#{name}`) ASSERT n.`#{property}` IS UNIQUE"
+                 else
+                   fail "Not supported constraint #{constraints.inspect} for property #{property} (expected :type => :unique)"
+                 end
+        schema_query(cypher)
+      end
+
+      def create_uniqueness_constraint(property, options = {})
+        create_constraint(property, options.merge(type: :unique))
+      end
+
+      # Drops a neo4j constraint on a property
+      # See http://docs.neo4j.org/chunked/stable/query-constraints.html
+      # @example
+      #   label = ActiveGraph::Label.create(:person)
+      #   label.create_constraint(:name, {type: :unique})
+      #   label.drop_constraint(:name, {type: :unique})
+      #
+      def drop_constraint(property, constraint)
+        cypher = case constraint[:type]
+                 when :unique, :uniqueness
+                   "n.`#{property}` IS UNIQUE"
+                 when :exists
+                   "exists(n.`#{property}`)"
+                 else
+                   fail "Not supported constraint #{constraint.inspect}"
+                 end
+        schema_query("DROP CONSTRAINT ON (n:`#{name}`) ASSERT #{cypher}")
+      end
+
+      def drop_uniqueness_constraint(property, options = {})
+        drop_constraint(property, options.merge(type: :unique))
+      end
+
+      def indexes
+        self.class.indexes.select do |definition|
+          definition[:label] == @name.to_sym
+        end
+      end
+
+      def drop_indexes
+        self.class.drop_indexes
+      end
+
+      def index?(property)
+        indexes.any? { |definition| definition[:properties] == [property.to_sym] }
+      end
+
+      def constraints(_options = {})
+        ActiveGraph::Base.constraints.select do |definition|
+          definition[:label] == @name.to_sym
+        end
+      end
+
+      def uniqueness_constraints(_options = {})
+        constraints.select do |definition|
+          definition[:type] == :uniqueness
+        end
+      end
+
+      def constraint?(property)
+        constraints.any? { |definition| definition[:properties] == [property.to_sym] }
+      end
+
+      def uniqueness_constraint?(property)
+        uniqueness_constraints.include?([property])
+      end
+
+      private
+
+      class << self
+        def indexes
+          ActiveGraph::Base.indexes
+        end
+
+        def drop_indexes
+          indexes.each do |definition|
+            begin
+              ActiveGraph::Base.query("DROP INDEX ON :`#{definition[:label]}`(#{definition[:properties][0]})")
+            rescue Neo4j::Driver::Exceptions::DatabaseException
+              # This will error on each constraint. Ignore and continue.
+              next
+            end
+          end
+        end
+
+        def drop_constraints
+          ActiveGraph::Base.transaction do |tx|
+            tx.run('CALL db.constraints').each do |record|
+              tx.run("DROP #{record.keys.include?(:name) ? "CONSTRAINT #{record[:name]}" : record[:description]}")
+            end
+          end
+        end
+      end
+
+      def schema_query(cypher)
+        ActiveGraph::Base.query(cypher, {})
+      end
+
+      def validate_index_options!(options)
+        return unless options[:type] && options[:type] != :exact
+        fail "Type #{options[:type]} is not supported"
+      end
+    end
+  end
+end

data/lib/active_graph/core/logging.rb

@@ -0,0 +1,44 @@
+# Copied largely from activerecord/lib/active_record/log_subscriber.rb
+module ActiveGraph
+  module Core
+    module Logging
+      class << self
+        def first_external_path_and_line(callstack)
+          line = callstack.find do |frame|
+            frame.absolute_path && !ignored_callstack(frame.absolute_path)
+          end
+
+          offending_line = line || callstack.first
+
+          [offending_line.path,
+           offending_line.lineno]
+        end
+
+        NEO4J_CORE_GEM_ROOT = File.expand_path('../../..', __dir__) + '/'
+
+        def ignored_callstack(path)
+          paths_to_ignore.any?(&path.method(:start_with?))
+        end
+
+        def paths_to_ignore
+          @paths_to_ignore ||= [NEO4J_CORE_GEM_ROOT,
+                                RbConfig::CONFIG['rubylibdir'],
+                                neo4j_gem_path,
+                                active_support_gem_path].compact
+        end
+
+        def neo4j_gem_path
+          return if !defined?(::Rails.root)
+
+          @neo4j_gem_path ||= File.expand_path('../../..', ActiveGraph::Base.method(:driver).source_location[0])
+        end
+
+        def active_support_gem_path
+          return if !defined?(::ActiveSupport::Notifications)
+
+          @active_support_gem_path ||= File.expand_path('../../..', ActiveSupport::Notifications.method(:subscribe).source_location[0])
+        end
+      end
+    end
+  end
+end