neo4j-core 8.1.4 → 9.0.0.alpha.1

data/lib/neo4j-embedded/embedded_transaction.rb

@@ -1,30 +0,0 @@
-module Neo4j
-  module Embedded
-    class EmbeddedTransaction < Neo4j::Transaction::Base
-      attr_reader :root_tx
-
-      def initialize(session)
-        super
-        @root_tx = @session.begin_tx
-      end
-
-      def acquire_read_lock(entity)
-        @root_tx.acquire_read_lock(entity)
-      end
-
-      def acquire_write_lock(entity)
-        @root_tx.acquire_write_lock(entity)
-      end
-
-      def delete
-        @root_tx.failure
-        @root_tx.close
-      end
-
-      def commit
-        @root_tx.success
-        @root_tx.close
-      end
-    end
-  end
-end

data/lib/neo4j-embedded/label.rb

@@ -1,66 +0,0 @@
-module Neo4j
-  class Label
-    class << self
-      def indexes
-        schema_query(:get_indexes)
-      end
-
-      def constraints
-        schema_query(:get_constraints)
-      end
-
-      def index?(label, property)
-        schema_index_operation(label, property, :indexes)
-      end
-
-      def constraint?(label, property)
-        schema_index_operation(label, property, :constraints)
-      end
-
-      def drop_all_indexes
-        Neo4j::Transaction.run do
-          schema.get_indexes.to_a.each do |i|
-            begin
-              i.drop
-            rescue Java::JavaLang::IllegalStateException
-            end
-          end
-        end
-      end
-
-      def drop_all_constraints
-        Neo4j::Transaction.run do
-          schema.get_constraints.to_a.each(&:drop)
-        end
-      end
-
-      private
-
-      def schema_query(query_method)
-        [].tap do |index_array|
-          Neo4j::Transaction.run do
-            schema.send(query_method).to_a.each { |i| index_array << index_hash(i) }
-          end
-        end
-      end
-
-      def schema_index_operation(label, property, schema_method)
-        label = label.to_s
-        property = property.to_s
-        !send(schema_method).select { |i| matched_index(i, label, property) }.empty?
-      end
-
-      def index_hash(java_index)
-        {property_keys: java_index.get_property_keys.to_a, label: java_index.get_label.name}
-      end
-
-      def matched_index(java_index, label, property)
-        java_index[:property_keys].first == property && java_index[:label] == label
-      end
-
-      def schema
-        Neo4j::Session.current.graph_db.schema
-      end
-    end
-  end
-end

data/lib/neo4j-embedded/property.rb

@@ -1,106 +0,0 @@
-
-# TODO: code duplication with the Neo4j::PropertyContainer,
-# This module should extend that module by adding transaction around methods
-module Neo4j
-  module Embedded
-    module Property
-      include Neo4j::PropertyValidator
-      include Neo4j::PropertyContainer
-      extend Neo4j::Core::TxMethods
-
-      # inherit the []= method but add auto transaction around it
-      tx_methods :[]=
-
-      def [](key)
-        return nil unless has_property?(key.to_s)
-
-        to_ruby_property(key.to_s)
-      end
-      tx_methods :[]
-
-      # Sets the property of this node.
-      # Property keys are always strings. Valid property value types are the primitives:
-      # (<tt>String</tt>, <tt>Integer</tt>, <tt>Float</tt>, <tt>FalseClass</tt>, <tt>TrueClass</tt>)
-      # or an array of those primitives.
-      #
-      # ==== Gotchas
-      # * Values in the array must be of the same type.
-      # * You can *not* delete or add one item in the array (e.g. person.phones.delete('123')) but instead you must create a new array instead.
-      #
-      # @param [String, Symbol] k of the property to set
-      # @param [String,Integer,Float,true,false, Array] v to set
-      def []=(k, v)
-        to_java_property(k, v)
-      end
-      tx_methods :[]=
-
-      def props
-        property_keys.each_with_object({}) do |key, ret|
-          ret[key.to_sym] = to_ruby_property(key)
-        end
-      end
-      tx_methods :props
-
-      def props=(hash)
-        property_keys.each do |key|
-          remove_property(key)
-        end
-        _update_props(hash)
-        hash
-      end
-      tx_methods :props=
-
-      def _update_props(hash)
-        hash.each { |k, v| to_java_property(k, v) }
-      end
-
-      def update_props(hash)
-        _update_props(hash)
-      end
-      tx_methods :update_props
-
-      def neo_id
-        get_id
-      end
-
-      def refresh
-        # nothing is needed in the embedded db since we always asks the database
-      end
-
-      private
-
-      def to_ruby_property(key)
-        val = get_property(key)
-        val.class.superclass == ArrayJavaProxy ? val.to_a : val
-      end
-
-      def to_java_property(k, v)
-        validate_property!(v)
-
-        k = k.to_s
-        case v
-        when nil then remove_property(k)
-        when Array
-          set_property(k, v.to_java(java_type_from_value(v[0])))
-        else
-          set_property(k, v)
-        end
-      end
-
-      def java_type_from_value(value)
-        case value
-        when String
-          :string
-        when Float
-          :double
-        when FalseClass, TrueClass
-          :boolean
-        when Integer
-          :long
-        else
-          fail "Not allowed to store array with value #{value.inspect} type #{value.class}"
-        end
-      end
-    end
-  end
-end

data/lib/neo4j-embedded/to_java.rb

@@ -1,44 +0,0 @@
-module Neo4j
-  module Embedded
-    # A Utility class for translating Ruby object to Neo4j Java types
-    # @private
-    module ToJava
-      def type_to_java(type)
-        type && Java::OrgNeo4jGraphdb::DynamicRelationshipType.withName(type.to_s)
-      end
-
-      module_function :type_to_java
-
-      def types_to_java(types)
-        types.inject([]) { |result, type| result << type_to_java(type) }.to_java(Java::OrgNeo4jGraphdb::RelationshipType)
-      end
-
-      module_function :types_to_java
-
-
-      def dir_from_java(dir)
-        case dir
-        when Java::OrgNeo4jGraphdb::Direction::OUTGOING then :outgoing
-        when Java::OrgNeo4jGraphdb::Direction::BOTH then :both
-        when Java::OrgNeo4jGraphdb::Direction::INCOMING then :incoming
-        else
-          fail "unknown direction '#{dir} / #{dir.class}'"
-        end
-      end
-
-      module_function :dir_from_java
-
-      def dir_to_java(dir)
-        case dir
-        when :outgoing then Java::OrgNeo4jGraphdb::Direction::OUTGOING
-        when :both then Java::OrgNeo4jGraphdb::Direction::BOTH
-        when :incoming then Java::OrgNeo4jGraphdb::Direction::INCOMING
-        else
-          fail "unknown direction '#{dir}', expects argument: outgoing, :incoming or :both"
-        end
-      end
-
-      module_function :dir_to_java
-    end
-  end
-end

data/lib/neo4j-server.rb

@@ -1,12 +0,0 @@
-require 'json'
-require 'faraday'
-require 'faraday_middleware'
-require 'faraday_middleware/multi_json'
-require 'neo4j-server/resource'
-require 'neo4j-server/cypher_node'
-require 'neo4j-server/cypher_label'
-require 'neo4j-server/label'
-require 'neo4j-server/cypher_session'
-require 'neo4j-server/cypher_relationship'
-require 'neo4j-server/cypher_response'
-require 'neo4j-server/cypher_transaction'

data/lib/neo4j-server/cypher_label.rb

@@ -1,35 +0,0 @@
-module Neo4j
-  module Server
-    class CypherLabel < Neo4j::Label
-      extend Forwardable
-      def_delegator :@session, :query_cypher_for
-      attr_reader :name
-
-      def initialize(session, name)
-        @name = name
-        @session = session
-      end
-
-      def create_index(property, options = {}, session = Neo4j::Session.current)
-        validate_index_options!(options)
-        properties = property.is_a?(Array) ? property.join(',') : property
-        response = session._query("CREATE INDEX ON :`#{@name}`(#{properties})")
-        response.raise_error if response.error?
-      end
-
-      def drop_index(property, options = {}, session = Neo4j::Session.current)
-        validate_index_options!(options)
-        response = session._query("DROP INDEX ON :`#{@name}`(#{property})")
-        response.raise_error if response.error? && !response.error_msg.match(/No such INDEX ON/)
-      end
-
-      def indexes
-        @session.indexes(@name)
-      end
-
-      def uniqueness_constraints
-        @session.uniqueness_constraints(@name)
-      end
-    end
-  end
-end

data/lib/neo4j-server/cypher_node.rb

@@ -1,221 +0,0 @@
-module Neo4j
-  module Server
-    class CypherNode < Neo4j::Node
-      include Neo4j::Server::Resource
-      include Neo4j::Core::ActiveEntity
-
-      MARSHAL_INSTANCE_VARIABLES = %i[@props @labels @neo_id]
-
-      def initialize(session, value)
-        @session = session
-
-        @neo_id = if value.is_a?(Hash)
-                    @props = value[:data]
-                    @labels = value[:metadata][:labels].map!(&:to_sym) if value[:metadata]
-                    value[:id]
-                  else
-                    value
-                  end
-      end
-
-      attr_reader :neo_id
-
-      def inspect
-        "CypherNode #{neo_id} (#{object_id})"
-      end
-
-      # TODO, needed by neo4j-cypher
-      def _java_node
-        self
-      end
-
-      # (see Neo4j::Node#create_rel)
-      def create_rel(type, other_node, props = nil)
-        q = @session.query.match(:a, :b).where(a: {neo_id: neo_id}, b: {neo_id: other_node.neo_id})
-                    .create("(a)-[r:`#{type}`]->(b)").break.set(r: props).return(r: :neo_id)
-
-        id = @session._query_or_fail(q, true)
-
-        CypherRelationship.new(@session, type: type, data: props, start: neo_id, end: other_node.neo_id, id: id)
-      end
-
-      # (see Neo4j::Node#props)
-      def props
-        if @props
-          @props
-        else
-          hash = @session._query_entity_data(match_start_query.return(:n), nil)
-          @props = Hash[hash[:data].to_a]
-        end
-      end
-
-      def refresh
-        @props = nil
-      end
-
-      # (see Neo4j::Node#remove_property)
-      def remove_property(key)
-        refresh
-        @session._query_or_fail(match_start_query.remove(n: key), false)
-      end
-
-      # (see Neo4j::Node#set_property)
-      def set_property(key, value)
-        refresh
-        @session._query_or_fail(match_start_query.set(n: {key => value}), false)
-      end
-
-      # (see Neo4j::Node#props=)
-      def props=(properties)
-        refresh
-        @session._query_or_fail(match_start_query.set_props(n: properties), false)
-        properties
-      end
-
-      def remove_properties(properties)
-        return if properties.empty?
-
-        refresh
-        @session._query_or_fail(match_start_query.remove(n: properties), false, neo_id: neo_id)
-      end
-
-      # (see Neo4j::Node#update_props)
-      def update_props(properties)
-        refresh
-        return if properties.empty?
-
-        @session._query_or_fail(match_start_query.set(n: properties), false)
-
-        properties
-      end
-
-      # (see Neo4j::Node#get_property)
-      def get_property(key)
-        @props ? @props[key.to_sym] : @session._query_or_fail(match_start_query.return(n: key), true)
-      end
-
-      # (see Neo4j::Node#labels)
-      def labels
-        @labels ||= @session._query_or_fail(match_start_query.return('labels(n) AS labels'), true).map(&:to_sym)
-      end
-
-      def _cypher_label_list(labels_list)
-        ':' + labels_list.map { |label| "`#{label}`" }.join(':')
-      end
-
-      def add_label(*new_labels)
-        @session._query_or_fail(match_start_query.set(n: new_labels), false)
-        new_labels.each { |label| labels << label }
-      end
-
-      def remove_label(*target_labels)
-        @session._query_or_fail(match_start_query.remove(n: target_labels), false)
-        target_labels.each { |label| labels.delete(label) } unless labels.nil?
-      end
-
-      def set_label(*label_names)
-        labels_to_add = label_names.map(&:to_sym).uniq
-        labels_to_remove = labels - label_names
-
-        common_labels = labels & labels_to_add
-        labels_to_add -= common_labels
-        labels_to_remove -= common_labels
-
-        query = _set_label_query(labels_to_add, labels_to_remove)
-        @session._query_or_fail(query, false) unless (labels_to_add + labels_to_remove).empty?
-      end
-
-      def _set_label_query(labels_to_add, labels_to_remove)
-        query = match_start_query
-        query = query.remove(n: labels_to_remove) unless labels_to_remove.empty?
-        query = query.set(n: labels_to_add) unless labels_to_add.empty?
-        query
-      end
-
-      # (see Neo4j::Node#del)
-      def del
-        query = match_start_query.optional_match('(n)-[r]-()').delete(:n, :r)
-        @session._query_or_fail(query, false)
-      end
-
-      alias delete del
-      alias destroy del
-
-      # (see Neo4j::Node#exist?)
-      def exist?
-        !@session._query(match_start_query.return(n: :neo_id)).data.empty?
-      end
-
-      # (see Neo4j::Node#node)
-      def node(match = {})
-        ensure_single_relationship { match(CypherNode, 'p as result LIMIT 2', match) }
-      end
-
-      # (see Neo4j::Node#rel)
-      def rel(match = {})
-        ensure_single_relationship { match(CypherRelationship, 'r as result LIMIT 2', match) }
-      end
-
-      # (see Neo4j::Node#rel?)
-      def rel?(match = {})
-        result = match(CypherRelationship, 'r as result', match)
-        !!result.first
-      end
-
-      # (see Neo4j::Node#nodes)
-      def nodes(match = {})
-        match(CypherNode, 'p as result', match)
-      end
-
-      # (see Neo4j::Node#rels)
-      def rels(match = {dir: :both})
-        match(CypherRelationship, 'r as result', match)
-      end
-
-      # @private
-      def match(clazz, returns, match = {})
-        ::Neo4j::Node.validate_match!(match)
-
-        query = self.query
-
-        query = query.match(:p).where(p: {neo_id: match[:between].neo_id}) if match[:between]
-
-        r = query.match("(n)#{relationship_arrow(match)}(p)").return(returns).response
-
-        r.raise_error if r.error?
-
-        r.to_node_enumeration.map(&:result)
-      end
-
-      def query(identifier = :n)
-        @session.query.match(identifier).where(identifier => {neo_id: neo_id})
-      end
-
-      private
-
-      DEFAULT_RELATIONSHIP_ARROW_DIRECTION = :both
-      def relationship_arrow(match)
-        rel_spec = match[:type] ? "[r:`#{match[:type]}`]" : '[r]'
-
-        case match[:dir] || DEFAULT_RELATIONSHIP_ARROW_DIRECTION
-        when :outgoing then "-#{rel_spec}->"
-        when :incoming then "<-#{rel_spec}-"
-        when :both then "-#{rel_spec}-"
-        else
-          fail "Invalid value for relationship_arrow direction: #{match[:dir].inspect}"
-        end
-      end
-
-      def ensure_single_relationship
-        fail 'Expected a block' unless block_given?
-        result = yield
-        fail "Expected to only find one relationship from node #{neo_id} matching #{match.inspect} but found #{result.count}" if result.count > 1
-        result.first
-      end
-
-      def match_start_query(identifier = :n)
-        @session.query.match(identifier).where(identifier => {neo_id: neo_id}).with(identifier)
-      end
-    end
-  end
-end