neo4j-core 8.1.4 → 9.0.0.alpha.1

data/lib/neo4j-embedded/embedded_node.rb

@@ -1,206 +0,0 @@
-module Neo4j
-  module Embedded
-    class RelsIterator
-      include Enumerable
-      extend Neo4j::Core::TxMethods
-
-      MARSHAL_INSTANCE_VARIABLES = %i[@node @match]
-
-      def initialize(node, match)
-        @node = node
-        ::Neo4j::Node.validate_match!(match)
-        @match = match
-      end
-
-      def inspect
-        'Enumerable<Neo4j::Relationship>'
-      end
-
-      def each
-        @node._rels(@match).each { |r| yield(r.wrapper) }
-      end
-      tx_methods :each
-
-      def empty?
-        first.nil?
-      end
-    end
-
-    class NodesIterator
-      include Enumerable
-      extend Neo4j::Core::TxMethods
-
-      def initialize(node, match)
-        @node = node
-        @match = match
-      end
-
-      def inspect
-        'Enumerable<Neo4j::Node>'
-      end
-
-      def each
-        @node._rels(@match).each { |r| yield(r.other_node(@node)) }
-      end
-      tx_methods :each
-
-      def empty?
-        first.nil?
-      end
-    end
-
-    class EmbeddedNode < Neo4j::Node
-      class << self
-        if !Neo4j::Core::Config.using_new_session?
-          # This method is used to extend a Java Neo4j class so that it includes the same mixins as this class.
-          Java::OrgNeo4jKernelImplCore::NodeProxy.class_eval do
-            include Neo4j::Embedded::Property
-            include Neo4j::EntityEquality
-            include Neo4j::Core::ActiveEntity
-            extend Neo4j::Core::TxMethods
-
-            def inspect
-              "EmbeddedNode neo_id: #{neo_id}"
-            end
-
-            def exist?
-              !!graph_database.get_node_by_id(neo_id)
-            rescue Java::OrgNeo4jGraphdb.NotFoundException
-              false
-            end
-            tx_methods :exist?
-
-            def labels
-              _labels.iterator.map { |x| x.name.to_sym }
-            end
-            tx_methods :labels
-
-            alias_method :_labels, :getLabels
-
-            def _java_label(label_name)
-              Java::OrgNeo4jGraphdb.DynamicLabel.label(label_name)
-            end
-
-            def _add_label(*label_name)
-              label_name.each do |name|
-                addLabel(_java_label(name))
-              end
-            end
-
-            alias_method :add_label, :_add_label
-            tx_methods :add_label
-
-            def _remove_label(*label_name)
-              label_name.each do |name|
-                removeLabel(_java_label(name))
-              end
-            end
-
-            alias_method :remove_label, :_remove_label
-            tx_methods :remove_label
-
-            def set_label(*label_names)
-              label_as_symbols = label_names.map(&:to_sym)
-              to_keep = labels & label_as_symbols
-              to_remove = labels - to_keep
-              _remove_label(*to_remove)
-              to_add = label_as_symbols - to_keep
-              _add_label(*to_add)
-            end
-            tx_methods :set_label
-
-            def del
-              _rels.each(&:del)
-              delete
-              nil
-            end
-            tx_methods :del
-            tx_methods :delete
-
-            alias_method :destroy, :del
-            tx_methods :destroy
-
-            def create_rel(type, other_node, props = nil)
-              rel = create_relationship_to(other_node.neo4j_obj, ToJava.type_to_java(type))
-              props.each_pair { |k, v| rel[k] = v } if props
-              rel
-            end
-            tx_methods :create_rel
-
-
-            def rels(match = {})
-              RelsIterator.new(self, match)
-            end
-
-            def nodes(match = {})
-              NodesIterator.new(self, match)
-            end
-
-            def node(match = {})
-              rel = _rel(match)
-              rel && rel.other_node(self).wrapper
-            end
-            tx_methods :node
-
-            def rel?(match = {})
-              _rels(match).has_next
-            end
-            tx_methods :rel?
-
-            def rel(match = {})
-              _rel(match)
-            end
-            tx_methods :rel
-
-            def _rel(match = {})
-              dir, rel_type, between_id = _parse_match(match)
-
-              rel = if rel_type
-                      get_single_relationship(rel_type, dir)
-                    else
-                      _get_single_relationship_by_dir(dir)
-                    end
-
-              rel if !(rel && between_id) || rel.other_node(self).neo_id == between_id
-            end
-
-            def _get_single_relationship_by_dir(dir)
-              iter = get_relationships(dir).iterator
-
-              return nil if not iter.has_next
-
-              first = iter.next
-              fail ArgumentError, "Expected to only find one relationship from node #{neo_id} matching" if iter.has_next
-              first
-            end
-
-            def _rels(match = {})
-              dir, rel_type, between_id = _parse_match(match)
-
-              args = rel_type ? [rel_type, dir] : [dir]
-              rels = get_relationships(*args).iterator
-
-              if between_id
-                rels.find_all { |r| r.end_node.neo_id == between_id || r.start_node.neo_id == between_id }
-              else
-                rels
-              end
-            end
-
-            def _parse_match(match)
-              ::Neo4j::Node.validate_match!(match)
-
-              [
-                ToJava.dir_to_java(match[:dir] || :both),
-                ToJava.type_to_java(match[:type]),
-                match[:between] && match[:between].neo_id
-              ]
-            end
-
-            include Neo4j::Node::Wrapper
-          end
-        end
-      end
-    end
-  end
-end

data/lib/neo4j-embedded/embedded_relationship.rb

@@ -1,77 +0,0 @@
-module Neo4j
-  module Embedded
-    class EmbeddedRelationship
-      MARSHAL_INSTANCE_VARIABLES = []
-
-      class << self
-        if !Neo4j::Core::Config.using_new_session?
-          Java::OrgNeo4jKernelImplCore::RelationshipProxy.class_eval do
-            include Neo4j::Embedded::Property
-            include Neo4j::EntityEquality
-            include Neo4j::Relationship::Wrapper
-            include Neo4j::Core::ActiveEntity
-            extend Neo4j::Core::TxMethods
-
-            alias_method :_other_node, :getOtherNode
-
-            def exist?
-              !!graph_database.get_relationship_by_id(neo_id)
-            rescue Java::OrgNeo4jGraphdb.NotFoundException
-              false
-            end
-            tx_methods :exist?
-
-            def inspect
-              "EmbeddedRelationship neo_id: #{neo_id}"
-            end
-
-            def start_node
-              _start_node.wrapper
-            end
-            tx_methods :start_node
-            alias_method :_start_node_id, :start_node
-            tx_methods :_start_node_id
-
-            def _start_node
-              getStartNode
-            end
-
-            def rel_type
-              @_rel_type ||= _rel_type
-            end
-
-            def _rel_type
-              getType.name.to_sym
-            end
-            tx_methods :rel_type
-
-            def del
-              delete
-            end
-            tx_methods :del
-            tx_methods :delete
-
-            alias_method :destroy, :del
-            tx_methods :destroy
-
-            def other_node(n)
-              _other_node(n.neo4j_obj).wrapper
-            end
-            tx_methods :other_node
-
-            def end_node
-              _end_node.wrapper
-            end
-            tx_methods :end_node
-            alias_method :_end_node_id, :end_node
-            tx_methods :_end_node_id
-
-            def _end_node
-              getEndNode
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/neo4j-embedded/embedded_session.rb

@@ -1,203 +0,0 @@
-# Plugin
-
-Neo4j::Session.register_db(:embedded_db) do |*args|
-  Neo4j::Embedded::EmbeddedSession.new(*args)
-end
-
-module Neo4j
-  module Embedded
-    class EmbeddedSession < Neo4j::Session
-      class Error < StandardError
-      end
-
-      attr_reader :graph_db, :db_location, :properties_file, :properties_map
-      extend Forwardable
-      extend Neo4j::Core::TxMethods
-      def_delegator :@graph_db, :begin_tx
-
-      def initialize(db_location, config = {})
-        @config          = config
-        @db_location     = db_location
-        @auto_commit     = !!@config[:auto_commit]
-        @properties_file = @config[:properties_file]
-        Neo4j::Session.register(self)
-      end
-
-      def properties_map
-        return @properties_map if @properties_map
-
-        props = if @config[:properties_map].is_a?(Hash)
-                  @config[:properties_map].each_with_object({}) do |(k, v), m|
-                    m[k.to_s.to_java] = v.to_s.to_java
-                  end
-                else
-                  {}
-                end
-        @properties_map = java.util.HashMap.new(props)
-      end
-
-      def db_type
-        :embedded_db
-      end
-
-      def inspect
-        "#{self.class} db_location: '#{@db_location}', running: #{running?}"
-      end
-
-      def version
-        # Wow
-        # Yeah, agreed...
-        version_string = @graph_db.to_java(Java::OrgNeo4jKernel::GraphDatabaseAPI).getDependencyResolver.resolveDependency(Java::OrgNeo4jKernel::KernelData.java_class).version.to_s
-        version_string.split(' ')[-1]
-      end
-
-      def start
-        fail Error, 'Embedded Neo4j db is already running' if running?
-        puts "Start embedded Neo4j db at #{db_location}"
-        factory    = Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory.new
-        db_service = factory.newEmbeddedDatabaseBuilder(db_location)
-        db_service.loadPropertiesFromFile(properties_file) if properties_file
-        db_service.setConfig(properties_map)               if properties_map
-
-        @graph_db = db_service.newGraphDatabase
-        Neo4j::Session._notify_listeners(:session_available, self)
-        @engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
-      end
-
-      def factory_class
-        Java::OrgNeo4jTest::ImpermanentGraphDatabase
-      end
-
-      def close
-        super
-        shutdown
-      end
-
-      def self.transaction_class
-        Neo4j::Embedded::EmbeddedTransaction
-      end
-
-      # Duplicate of CypherSession::Adaptor::Base#transaction
-      def transaction
-        return self.class.transaction_class.new(self) if !block_given?
-
-        begin
-          tx = transaction
-
-          yield tx
-        rescue Exception => e # rubocop:disable Lint/RescueException
-          tx.mark_failed
-
-          raise e
-        ensure
-          tx.close
-        end
-      end
-
-      def shutdown
-        @graph_db && @graph_db.shutdown
-
-        Neo4j::Session.clear_listeners
-        @graph_db = nil
-      end
-
-      def running?
-        !!@graph_db
-      end
-
-      def create_label(name)
-        EmbeddedLabel.new(self, name)
-      end
-
-      def load_node(neo_id)
-        _load_node(neo_id)
-      end
-      tx_methods :load_node
-
-      # Same as load but does not return the node as a wrapped Ruby object.
-      #
-      def _load_node(neo_id)
-        return nil if neo_id.nil?
-        @graph_db.get_node_by_id(neo_id.to_i)
-      rescue Java::OrgNeo4jGraphdb.NotFoundException
-        nil
-      end
-
-      def load_relationship(neo_id)
-        _load_relationship(neo_id)
-      end
-      tx_methods :load_relationship
-
-      def _load_relationship(neo_id)
-        return nil if neo_id.nil?
-        @graph_db.get_relationship_by_id(neo_id.to_i)
-      rescue Java::OrgNeo4jGraphdb.NotFoundException
-        nil
-      end
-
-      def query(*args)
-        if [[String], [String, Hash]].include?(args.map(&:class))
-          query, params = args[0, 2]
-          Neo4j::Embedded::ResultWrapper.new(_query(query, params), query)
-        else
-          options = args[0] || {}
-          Neo4j::Core::Query.new(options.merge(session: self))
-        end
-      end
-
-
-      def find_all_nodes(label)
-        EmbeddedLabel.new(self, label).find_nodes
-      end
-
-      def find_nodes(label, key, value)
-        EmbeddedLabel.new(self, label).find_nodes(key, value)
-      end
-
-      # Performs a cypher query with given string.
-      # Remember that you should close the resource iterator.
-      # @param [String] q the cypher query as a String
-      # @return (see #query)
-      def _query(query, params = {}, options = {})
-        ActiveSupport::Notifications.instrument('neo4j.cypher_query', params: params, context: options[:context],
-                                                                      cypher: query, pretty_cypher: options[:pretty_cypher], params: params) do
-          @engine ||= Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
-          @engine.execute(query, indifferent_params(params))
-        end
-      rescue StandardError => e
-        raise Neo4j::Session::CypherError.new(e.message, e.class, 'cypher error')
-      end
-
-      def indifferent_params(params)
-        return {} unless params
-        params.each { |k, v| params[k] = HashWithIndifferentAccess.new(params[k]) if v.is_a?(Hash) && !v.respond_to?(:nested_under_indifferent_access) }
-        HashWithIndifferentAccess.new(params)
-      end
-
-      def query_default_return(as)
-        " RETURN #{as}"
-      end
-
-      def _query_or_fail(q)
-        @engine ||= Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
-        @engine.execute(q)
-      end
-
-      def search_result_to_enumerable(result)
-        result.map { |column| column['n'].wrapper }
-      end
-
-      def create_node(properties = nil, labels = [])
-        if labels.empty?
-          @graph_db.create_node
-        else
-          labels = EmbeddedLabel.as_java(labels)
-          @graph_db.create_node(labels)
-        end.tap do |java_node|
-          properties.each_pair { |k, v| java_node[k] = v } if properties
-        end
-      end
-      tx_methods :create_node
-    end
-  end
-end