neo4j-core 8.1.4 → 9.0.0.alpha.1

data/lib/neo4j/property_container.rb

@@ -1,17 +0,0 @@
-module Neo4j
-  module PropertyContainer
-    include Neo4j::PropertyValidator
-
-    # Returns the Neo4j Property of given key
-    def [](key)
-      get_property(key)
-    end
-
-    # Sets the neo4j property
-    def []=(key, value)
-      validate_property!(value)
-
-      set_property(key, value)
-    end
-  end
-end

data/lib/neo4j/property_validator.rb

@@ -1,22 +0,0 @@
-module Neo4j
-  module PropertyValidator
-    require 'set'
-    class InvalidPropertyException < Exception
-    end
-
-    # the valid values on a property, and arrays of those.
-    VALID_PROPERTY_VALUE_CLASSES = Set.new([Array, NilClass, String, Float, TrueClass, FalseClass, Integer])
-
-    # @param [Object] value the value we want to check if it's a valid neo4j property value
-    # @return [True, False] A false means it can't be persisted.
-    def valid_property?(value)
-      VALID_PROPERTY_VALUE_CLASSES.any? { |c| value.is_a?(c) }
-    end
-
-    def validate_property!(value)
-      return if valid_property?(value)
-
-      fail Neo4j::PropertyValidator::InvalidPropertyException, "Not valid Neo4j Property value #{value.class}, valid: #{Neo4j::Node::VALID_PROPERTY_VALUE_CLASSES.to_a.join(', ')}"
-    end
-  end
-end

data/lib/neo4j/relationship.rb

@@ -1,161 +0,0 @@
-module Neo4j
-  # A relationship between two nodes in the graph. A relationship has a start node, an end node and a type.
-  # You can attach properties to relationships like Neo4j::Node.
-  #
-  # The fact that the relationship API gives meaning to start and end nodes implicitly means that all relationships have a direction.
-  # In the example above, rel would be directed from node to otherNode.
-  # A relationship's start node and end node and their relation to outgoing and incoming are defined so that the assertions in the following code are true:
-  #
-  # Furthermore, Neo4j guarantees that a relationship is never "hanging freely,"
-  # i.e. start_node, end_node and other_node are guaranteed to always return valid, non-nil nodes.
-  class Relationship
-    # A module that allows plugins to register wrappers around Neo4j::Node objects
-    module Wrapper
-      # Used by Neo4j::NodeMixin to wrap nodes
-      def wrapper
-        self
-      end
-
-      def neo4j_obj
-        self
-      end
-    end
-
-    include PropertyContainer
-    include EntityEquality
-    include Wrapper
-    include EntityMarshal
-
-    # @return [Hash<Symbol,Object>] all properties of the relationship
-    def props
-      fail 'not implemented'
-    end
-
-    # replace all properties with new properties
-    # @param [Hash] properties a hash of properties the relationship should have
-    def props=(properties)
-      fail 'not implemented'
-    end
-
-    # Updates the properties, keeps old properties
-    # @param [Hash<Symbol,Object>] properties hash of properties that should be updated on the relationship
-    def update_props(properties)
-      fail 'not implemented'
-    end
-
-    # Directly remove the property on the relationship (low level method, may need transaction)
-    def remove_property(key)
-      fail 'not implemented'
-    end
-
-    # Directly set the property on the relationship (low level method, may need transaction)
-    # @param [Hash, String] key
-    # @param value see Neo4j::PropertyValidator::VALID_PROPERTY_VALUE_CLASSES for valid values
-    def set_property(key, value)
-      fail 'not implemented'
-    end
-
-    # Directly get the property on the relationship (low level method, may need transaction)
-    # @param [Hash, String] key
-    # @return the value of the key
-    def get_property(key, value)
-      fail 'not implemented'
-    end
-
-    # Returns the start node of this relationship.
-    # @return [Neo4j::Node,Object] the node or wrapped node
-    def start_node
-      _start_node.wrapper
-    end
-
-    # Same as #start_node but does not wrap the node
-    # @return [Neo4j::Node]
-    def _start_node
-      fail 'not implemented'
-    end
-
-    # Returns the end node of this relationship.
-    # @return [Neo4j::Node,Object] the node or wrapped node
-    def end_node
-      _end_node.wrapper
-    end
-
-    # Same as #end_node but does not wrap the node
-    # @return [Neo4j::Node]
-    def _end_node
-      fail 'not implemented'
-    end
-
-    # @abstract
-    def del
-      fail 'not implemented'
-    end
-
-    # The unique neo4j id
-    # @abstract
-    def neo_id
-      fail 'not implemented'
-    end
-
-    # @return [true, false] if the relationship exists
-    # @abstract
-    def exist?
-      fail 'not implemented'
-    end
-
-    # Returns the relationship name
-    #
-    # @example
-    #   a = Neo4j::Node.new
-    #   a.create_rel(:friends, node_b)
-    #   a.rels.first.rel_type # => :friends
-    # @return [Symbol] the type of the relationship
-    def rel_type
-      fail 'not implemented'
-    end
-
-    # A convenience operation that, given a node that is attached to this relationship, returns the other node.
-    # For example if node is a start node, the end node will be returned, and vice versa.
-    # This is a very convenient operation when you're manually traversing the node space by invoking one of the #rels
-    # method on a node. For example, to get the node "at the other end" of a relationship, use the following:
-    #
-    # @example
-    #   end_node = node.rels.first.other_node(node)
-    #
-    # @raise This operation will throw a runtime exception if node is neither this relationship's start node nor its end node.
-    #
-    # @param [Neo4j::Node] node the node that we don't want to return
-    # @return [Neo4j::Node] the other node wrapper
-    # @see #_other_node
-    def other_node(node)
-      _other_node(node.neo4j_obj).wrapper
-    end
-
-    # Same as #other_node but can return a none wrapped node
-    def _other_node(node)
-      if node == _start_node
-        _end_node
-      elsif node == _end_node
-        _start_node
-      else
-        fail "Node #{node.inspect} is neither start nor end node"
-      end
-    end
-
-
-    class << self
-      def create(rel_type, from_node, other_node, props = {})
-        from_node.neo4j_obj.create_rel(rel_type, other_node, props)
-      end
-
-      def load(neo_id, session = Neo4j::Session.current)
-        rel = _load(neo_id, session)
-        rel && rel.wrapper
-      end
-
-      def _load(neo_id, session = Neo4j::Session.current)
-        session.load_relationship(neo_id)
-      end
-    end
-  end
-end

data/lib/neo4j/session.rb

@@ -1,222 +0,0 @@
-module Neo4j
-  class Session
-    @@current_session = nil
-    @@all_sessions = {}
-    @@factories = {}
-
-    # @abstract
-    def close
-      self.class.unregister(self)
-    end
-
-    # Only for embedded database
-    # @abstract
-    def start
-      fail 'not impl.'
-    end
-
-    # Only for embedded database
-    # @abstract
-    def shutdown
-      fail 'not impl.'
-    end
-
-    # Only for embedded database
-    # @abstract
-    def running
-      fail 'not impl.'
-    end
-
-    # @return [:embedded_db | :server_db]
-    def db_type
-      fail 'not impl.'
-    end
-
-    def auto_commit?
-      true # TODO
-    end
-
-    class CypherError < StandardError
-      attr_reader :error_msg, :error_status, :error_code
-      def initialize(error_msg, error_code, error_status)
-        super(error_msg)
-        @error_msg = error_msg
-        @error_status = error_status
-      end
-    end
-
-    class InitializationError < RuntimeError; end
-
-    # Performs a cypher query.  See {Neo4j::Core::Query} for more details, but basic usage looks like:
-    #
-    # @example Using cypher DSL
-    #   Neo4j::Session.query.match("(c:person)-[:friends]->(p:person)").where(c: {name: 'andreas'}).pluck(:p).first[:name]
-    #
-    # @example Show the generated Cypher
-    #   Neo4j::Session.query..match("(c:person)-[:friends]->(p:person)").where(c: {name: 'andreas'}).return(:p).to_cypher
-    #
-    # @example Use Cypher string instead of the cypher DSL
-    #   Neo4j::Session.query("MATCH (c:person)-[:friends]->(p:person) WHERE c.name = \"andreas\" RETURN p").first[:p][:name]
-    #
-    # @return [Neo4j::Core::Query, Enumerable] return a Query object for DSL or a Enumerable if using raw cypher strings
-    # @see http://docs.neo4j.org/chunked/milestone/cypher-query-lang.html The Cypher Query Language Documentation
-    #
-    def query(options = {})
-      fail 'not implemented, abstract'
-    end
-
-    # Same as #query but does not accept an DSL and returns the raw result from the database.
-    # Notice, it might return different values depending on which database is used, embedded or server.
-    # @abstract
-    def _query(*params)
-      fail 'not implemented'
-    end
-
-    def transaction_class
-      self.class.transaction_class
-    end
-
-    class << self
-      # Creates a new session to Neo4j.
-      # This will be the default session to be used unless there is already a session created (see #current and #set_current)
-      #
-      # @example A Neo4j Server session
-      #   Neo4j::Session.open(:server_db, 'http://localhost:7474', {basic_auth: {username: 'foo', password: 'bar'}})
-      #
-      # @example Using a user defined Faraday HTTP connection
-      #   connection = Faraday.new do |b|
-      #     # faraday config
-      #   end
-      #   Neo4j::Session.open(:server_db, 'http://localhost:7474', connection: connection)
-      #
-      # @example A embedded Neo4j session
-      #   Neo4j::Session.open(:embedded_db, 'path/to/db')
-      #
-      # @see also Neo4j::Server::CypherSession#open for :server_db params
-      # @param db_type the type of database, e.g. :embedded_db, or :server_db
-      # @param [String] endpoint_url The path to the server, either a URL or path to embedded DB
-      # @param [Hash] params Additional configuration options
-      def open(db_type = :server_db, endpoint_url = nil, params = {})
-        case db_type
-        when :server_db then require 'neo4j-server'
-        when :embedded_db then require 'neo4j-embedded'
-        end
-
-        validate_session_num!(db_type)
-        name = params[:name]
-        default = params[:default]
-        %i[name default].each { |k| params.delete(k) }
-        register(create_session(db_type, endpoint_url, params), name, default)
-      end
-
-      # @private
-      def validate_session_num!(db_type)
-        return unless current && db_type == :embedded_db
-        fail InitializationError, 'Multiple sessions are not supported by Neo4j Embedded.'
-      end
-      private :validate_session_num!
-
-      # @private
-      def create_session(db_type, endpoint_url, params = {})
-        unless @@factories[db_type]
-          fail InitializationError, "Can't connect to database '#{db_type}', available #{@@factories.keys.join(',')}"
-        end
-        @@factories[db_type].call(endpoint_url, params)
-      end
-
-      # @return [Neo4j::Session] the current session
-      def current
-        @@current_session
-      end
-
-      # Returns the current session or raise an exception if no session is available
-      def current!
-        fail 'No session, please create a session first with Neo4j::Session.open(:server_db) or :embedded_db' unless current
-        current
-      end
-
-      # @see Neo4j::Session#query
-      def query(*args)
-        current!.query(*args)
-      end
-
-      # Returns a session with given name or else raise an exception
-      def named(name)
-        @@all_sessions[name] || fail("No session named #{name}.")
-      end
-
-      # Sets the session to be used as default
-      # @param [Neo4j::Session] session the session to use
-      def set_current(session)
-        @@current_session = session
-      end
-
-      # Registers a callback which will be called immediately if session is already available,
-      # or called when it later becomes available.
-      def on_next_session_available
-        return yield(Neo4j::Session.current) if Neo4j::Session.current
-
-        add_listener do |event, data|
-          yield data if event == :session_available
-        end
-      end
-
-      def user_agent_string
-        gem, version = if defined?(::Neo4j::ActiveNode)
-                         ['neo4j', ::Neo4j::VERSION]
-                       else
-                         ['neo4j-core', ::Neo4j::Core::VERSION]
-                       end
-
-
-        "#{gem}-gem/#{version} (https://github.com/neo4jrb/#{gem})"
-      end
-
-      def clear_listeners
-        @@listeners = []
-      end
-
-      # @private
-      def add_listener(&listener)
-        _listeners << listener
-      end
-
-      # @private
-      def _listeners
-        @@listeners ||= []
-        @@listeners
-      end
-
-      # @private
-      def _notify_listeners(event, data)
-        _listeners.shift.call(event, data) until _listeners.empty?
-      end
-
-      # @private
-      def register(session, name = nil, default = nil)
-        if default == true
-          set_current(session)
-        elsif default.nil?
-          set_current(session) unless @@current_session
-        end
-        @@all_sessions[name] = session if name
-        session
-      end
-
-      # @private
-      def unregister(session)
-        @@current_session = nil if @@current_session == session
-      end
-
-      def inspect
-        "Neo4j::Session available: #{@@factories && @@factories.keys}"
-      end
-
-      # @private
-      def register_db(db, &session_factory)
-        puts "replace factory for #{db}" if @@factories[db]
-        @@factories[db] = session_factory
-      end
-    end
-  end
-end