neo4j-core 3.1.1 → 4.0.0

data/lib/neo4j-embedded/embedded_relationship.rb

@@ -1,9 +1,8 @@
-module Neo4j::Embedded
-  class EmbeddedRelationship
-    class << self
-      # This method is used to extend a Java Neo4j class so that it includes the same mixins as this class.
-      def extend_java_class(java_clazz)
-        java_clazz.class_eval do
+module Neo4j
+  module Embedded
+    class EmbeddedRelationship
+      class << self
+        Java::OrgNeo4jKernelImplCore::RelationshipProxy.class_eval do
           include Neo4j::Embedded::Property
           include Neo4j::EntityEquality
           include Neo4j::Relationship::Wrapper
@@ -39,7 +38,7 @@ module Neo4j::Embedded
           end
 
           def _rel_type
-            getType().name().to_sym
+            getType.name.to_sym
           end
           tx_methods :rel_type
 
@@ -67,14 +66,8 @@ module Neo4j::Embedded
           def _end_node
             getEndNode
           end
-
         end
       end
     end
-
-    extend_java_class(Java::OrgNeo4jKernelImplCore::RelationshipProxy)
-
   end
-
-
 end

data/lib/neo4j-embedded/embedded_session.rb

@@ -5,166 +5,162 @@ Neo4j::Session.register_db(:embedded_db) do |*args|
 end
 
 
-module Neo4j::Embedded
-  class EmbeddedSession < Neo4j::Session
-
-    class Error < StandardError
-    end
+module Neo4j
+  module Embedded
+    class EmbeddedSession < Neo4j::Session
+      class Error < StandardError
+      end
 
-    attr_reader :graph_db, :db_location, :properties_file
-    extend Forwardable
-    extend Neo4j::Core::TxMethods
-    def_delegator :@graph_db, :begin_tx
+      attr_reader :graph_db, :db_location, :properties_file
+      extend Forwardable
+      extend Neo4j::Core::TxMethods
+      def_delegator :@graph_db, :begin_tx
 
 
-    def initialize(db_location, config={})
-      @db_location     = db_location
-      @auto_commit     = !!config[:auto_commit]
-      @properties_file = config[:properties_file]
-      Neo4j::Session.register(self)
-    end
+      def initialize(db_location, config = {})
+        @db_location     = db_location
+        @auto_commit     = !!config[:auto_commit]
+        @properties_file = config[:properties_file]
+        Neo4j::Session.register(self)
+      end
 
-    def db_type
-      :embedded_db
-    end
+      def db_type
+        :embedded_db
+      end
 
-    def inspect
-      "#{self.class} db_location: '#{@db_location}', running: #{running?}"
-    end
+      def inspect
+        "#{self.class} db_location: '#{@db_location}', running: #{running?}"
+      end
 
-    def version
-      # Wow
-      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 version
+        # Wow
+        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
-      raise Error.new("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
-      @graph_db = db_service.newGraphDatabase()
-      Neo4j::Session._notify_listeners(:session_available, self)
-      @engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
-    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
+        @graph_db = db_service.newGraphDatabase
+        Neo4j::Session._notify_listeners(:session_available, self)
+        @engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
+      end
 
-    def factory_class
-      Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory
-      Java::OrgNeo4jTest::ImpermanentGraphDatabase
-    end
+      def factory_class
+        Java::OrgNeo4jTest::ImpermanentGraphDatabase
+      end
 
-    def begin_tx
-      if Neo4j::Transaction.current
-        # Handle nested transaction "placebo transaction"
-        Neo4j::Transaction.current.push_nested!
-      else
-        Neo4j::Embedded::EmbeddedTransaction.new(@graph_db.begin_tx)
+      def begin_tx
+        if Neo4j::Transaction.current
+          # Handle nested transaction "placebo transaction"
+          Neo4j::Transaction.current.push_nested!
+        else
+          Neo4j::Embedded::EmbeddedTransaction.new(@graph_db.begin_tx)
+        end
+        Neo4j::Transaction.current
       end
-      Neo4j::Transaction.current
-    end
 
-    def close
-      super
-      shutdown
-    end
+      def close
+        super
+        shutdown
+      end
 
-    def shutdown
-      graph_db && graph_db.shutdown
-      @graph_db = nil
-    end
+      def shutdown
+        graph_db && graph_db.shutdown
+        @graph_db = nil
+      end
 
-    def running?
-      !!graph_db
-    end
+      def running?
+        !!graph_db
+      end
 
-    def create_label(name)
-      EmbeddedLabel.new(self, name)
-    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_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)
+        _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 _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, String]].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))
+      def query(*args)
+        if [[String], [String, String]].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
-    end
 
 
-    def find_all_nodes(label)
-      EmbeddedLabel.new(self, label).find_nodes
-    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
+      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(q, params={})
-      @engine ||= Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
-      @engine.execute(q, Neo4j::Core::HashWithIndifferentAccess.new(params))
-    rescue Exception => e
-      raise Neo4j::Session::CypherError.new(e.message, e.class, 'cypher error')
-    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(q, params = {})
+        @engine ||= Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
+        @engine.execute(q, Neo4j::Core::HashWithIndifferentAccess.new(params))
+      rescue StandardError => e
+        raise Neo4j::Session::CypherError.new(e.message, e.class, 'cypher error')
+      end
 
-    def query_default_return(as)
-      " RETURN #{as}"
-    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 _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 search_result_to_enumerable(result)
+        result.map { |column| column['n'].wrapper }
+      end
 
-    def create_node(properties = nil, labels=[])
-      if labels.empty?
-        _java_node = graph_db.create_node
-      else
-        labels = EmbeddedLabel.as_java(labels)
-        _java_node = graph_db.create_node(labels)
+      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
-      properties.each_pair { |k, v| _java_node[k]=v } if properties
-      _java_node
+      tx_methods :create_node
     end
-    tx_methods :create_node
-
   end
-
-
-
 end

data/lib/neo4j-embedded/embedded_transaction.rb

@@ -1,35 +1,36 @@
-module Neo4j::Embedded
-  class EmbeddedTransaction
-    attr_reader :root_tx
-    include Neo4j::Transaction::Instance
-
-    def initialize(root_tx)
-      @root_tx = root_tx
-      register_instance
-    end
-
-    def acquire_read_lock(entity)
-      @root_tx.acquire_read_lock(entity)
+module Neo4j
+  module Embedded
+    class EmbeddedTransaction
+      attr_reader :root_tx
+      include Neo4j::Transaction::Instance
+
+      def initialize(root_tx)
+        @root_tx = root_tx
+        register_instance
+      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 inspect
+        "EmbeddedTransaction [nested: #{@pushed_nested} failed?: #{failure?} active: #{Neo4j::Transaction.current == self}]"
+      end
+
+      def _delete_tx
+        @root_tx.failure
+        @root_tx.close
+      end
+
+      def _commit_tx
+        @root_tx.success
+        @root_tx.close
+      end
     end
-
-    def acquire_write_lock(entity)
-      @root_tx.acquire_write_lock(entity)
-    end
-
-
-    def inspect
-      "EmbeddedTransaction [nested: #{@pushed_nested} failed?: #{failure?} active: #{Neo4j::Transaction.current == self}]"
-    end
-
-    def _delete_tx
-      @root_tx.failure
-      @root_tx.close
-    end
-
-    def _commit_tx
-      @root_tx.success
-      @root_tx.close
-    end
-
   end
-end
+end

data/lib/neo4j-embedded/property.rb

@@ -1,99 +1,106 @@
 
-# TODO code duplication with the Neo4j::PropertyContainer,
+# TODO: code duplication with the Neo4j::PropertyContainer,
 # This module should extend that module by adding transaction around methods
-module Neo4j::Embedded::Property
-  include Neo4j::PropertyValidator
-  include Neo4j::PropertyContainer
-  extend Neo4j::Core::TxMethods
+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 :[]=
+      # inherit the []= method but add auto transaction around it
+      tx_methods :[]=
 
-  def [](key)
-    return nil unless has_property?(key.to_s)
-    val = 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>Fixnum</tt>, <tt>Float</tt>, <tt>FalseClass</tt>, <tt>TrueClass</tt>) or 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,Fixnum,Float,true,false, Array] v to set
-  def []=(k, v)
-    to_java_property(k, v)
-  end
-  tx_methods :[]=
+      def [](key)
+        return nil unless has_property?(key.to_s)
 
-  def props
-    property_keys.inject({}) do |ret, key|
-      val = to_ruby_property(key)
-      ret[key.to_sym] = val
-      ret
-    end
-  end
-  tx_methods :props
+        to_ruby_property(key.to_s)
+      end
+      tx_methods :[]
 
-  def props=(hash)
-    property_keys.each do |key|
-      remove_property(key)
-    end
-    _update_props(hash)
-    hash
-  end
-  tx_methods :props=
+      # Sets the property of this node.
+      # Property keys are always strings. Valid property value types are the primitives:
+      # (<tt>String</tt>, <tt>Fixnum</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,Fixnum,Float,true,false, Array] v to set
+      def []=(k, v)
+        to_java_property(k, v)
+      end
+      tx_methods :[]=
 
-  def _update_props(hash)
-    hash.each_pair { |k,v| to_java_property(k, v) }
-    hash
-  end
+      def props
+        property_keys.each_with_object({}) do |key, ret|
+          ret[key.to_sym] = to_ruby_property(key)
+        end
+      end
+      tx_methods :props
 
-  def update_props(hash)
-    _update_props(hash)
-  end
-  tx_methods :update_props
+      def props=(hash)
+        property_keys.each do |key|
+          remove_property(key)
+        end
+        _update_props(hash)
+        hash
+      end
+      tx_methods :props=
 
-  def neo_id
-    get_id
-  end
+      def _update_props(hash)
+        hash.each { |k, v| to_java_property(k, v) }
+      end
 
-  def refresh
-    # nothing is needed in the embedded db since we always asks the database
-  end
+      def update_props(hash)
+        _update_props(hash)
+      end
+      tx_methods :update_props
 
-  private
+      def neo_id
+        get_id
+      end
 
-  def to_ruby_property(key)
-    val = get_property(key)
-    val.class.superclass == ArrayJavaProxy ? val.to_a : val
-  end
+      def refresh
+        # nothing is needed in the embedded db since we always asks the database
+      end
+
+      private
 
-  def to_java_property(k, v)
-    validate_property(v)
+      def to_ruby_property(key)
+        val = get_property(key)
+        val.class.superclass == ArrayJavaProxy ? val.to_a : val
+      end
 
-    k = k.to_s
-    if v.nil?
-      remove_property(k)
-    elsif (Array === v)
-      case v[0]
+      def to_java_property(k, v)
+        validate_property(v)
+
+        k = k.to_s
+        case v
+        when nil
+          remove_property(k)
+        when Array
+          type = java_type_from_value(v[0]) || fail("Not allowed to store array with value #{v[0]} type #{v[0].class}")
+          set_property(k, v.to_java(type))
+        else
+          set_property(k, v)
+        end
+      end
+
+      def java_type_from_value(value)
+        case value
         when String
-          set_property(k, v.to_java(:string))
+          :string
         when Float
-          set_property(k, v.to_java(:double))
+          :double
         when FalseClass, TrueClass
-          set_property(k, v.to_java(:boolean))
+          :boolean
         when Fixnum
-          set_property(k, v.to_java(:long))
-        else
-          raise "Not allowed to store array with value #{v[0]} type #{v[0].class}"
+          :long
+        end
       end
-    else
-      set_property(k, v)
     end
   end
-
 end