neo4j-core 3.0.0.alpha.1

data/lib/neo4j-core/helpers.rb

@@ -0,0 +1,25 @@
+module Neo4j::Core
+# wrapps Neo4j ResourceIterator, automatically close it
+
+  module ArgumentHelper
+
+    def self.session(args)
+      args.last.kind_of?(Neo4j::Session) ? args.pop : Neo4j::Session.current
+    end
+  end
+
+  module TxMethods
+    def tx_methods(*methods)
+      methods.each do |method|
+        tx_method = "#{method}_in_tx"
+        send(:alias_method, tx_method, method)
+        send(:define_method, method) do |*args, &block|
+          session = ArgumentHelper.session(args)
+          Neo4j::Transaction.run(session.auto_commit?) { send(tx_method, *args, &block) }
+        end
+      end
+    end
+  end
+
+
+end

data/lib/neo4j-core/label.rb

@@ -0,0 +1,8 @@
+module Neo4j::Core
+  class Label
+    def labels
+      get_labels.map{|x| Label.new(x.name) }
+    end
+  end
+
+end

data/lib/neo4j-core/version.rb

@@ -0,0 +1,5 @@
+module Neo4j
+  module Core
+    VERSION = "3.0.0.alpha.1"
+  end
+end

data/lib/neo4j-embedded.rb

@@ -0,0 +1,18 @@
+require 'java'
+
+# TODO: release neo4j-community jar 2.0
+# Load Neo4j Jars for the jars folder
+jar_folder = File.expand_path('../neo4j/jars', __FILE__)
+jars = Dir.new(jar_folder).entries.find_all { |x| x =~ /\.jar$/ }
+jars.each { |jar| require File.expand_path(jar, jar_folder) }
+
+require 'neo4j-embedded/to_java'
+require 'neo4j-embedded/property'
+require 'neo4j-embedded/embedded_session'
+require 'neo4j-embedded/embedded_label'
+require 'neo4j-embedded/embedded_node'
+require 'neo4j-embedded/embedded_relationship'
+require 'neo4j-embedded/embedded_label'
+
+# TODO replace this with https://github.com/intridea/hashie gem
+require 'neo4j-core/hash_with_indifferent_access'

data/lib/neo4j-embedded/embedded_database.rb

@@ -0,0 +1,29 @@
+module Neo4j::Embedded
+  class EmbeddedDatabase
+
+    class Error < StandardError
+    end
+
+    class << self
+      def connect(db_location, config={})
+        if Neo4j::Session.current.respond_to?(:db_location) && Neo4j::Session.current.db_location == db_location
+          return Neo4j::Session.current
+        else
+          EmbeddedSession.new(db_location, config)
+        end
+      end
+
+      def create_db(db_location)
+        puts "Start embedded Neo4j db at #{db_location}"
+        factory = Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory.new
+        factory.newEmbeddedDatabase(db_location)
+      end
+
+      def factory_class
+        Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory
+        Java::OrgNeo4jTest::ImpermanentGraphDatabase
+      end
+
+    end
+  end
+end

data/lib/neo4j-embedded/embedded_label.rb

@@ -0,0 +1,80 @@
+module Neo4j::Embedded
+  class EmbeddedLabel
+    extend Neo4j::Core::TxMethods
+    attr_reader :name
+    JAVA_CLASS = Java::OrgNeo4jGraphdb::DynamicLabel
+
+    def initialize(session, name)
+      @name = name.to_sym
+      @session = session
+    end
+
+    def to_s
+      @name
+    end
+
+    def find_nodes(key=nil, value=nil)
+       begin
+        iterator = _find_nodes(key,value)
+        iterator.to_a.map{|n| n.wrapper}
+      ensure
+        iterator && iterator.close
+      end
+    end
+    tx_methods :find_nodes
+
+    def _find_nodes(key=nil, value=nil)
+      if (key)
+        @session.graph_db.find_nodes_by_label_and_property(as_java, key, value).iterator
+      else
+        ggo = Java::OrgNeo4jTooling::GlobalGraphOperations.at(@session.graph_db)
+        ggo.getAllNodesWithLabel(as_java).iterator
+      end
+
+    end
+
+    def as_java
+      self.class.as_java(@name.to_s)
+    end
+
+    def create_index(*properties)
+        index_creator = @session.graph_db.schema.index_for(as_java)
+      # we can also use the PropertyConstraintCreator here
+      properties.inject(index_creator) {|creator, key| creator.on(key.to_s)}.create
+    end
+    tx_methods :create_index
+
+    def indexes()
+      {
+          property_keys: @session.graph_db.schema.indexes(as_java).map do |index_def|
+            index_def.property_keys.map{|x| x.to_sym}
+          end
+      }
+    end
+    tx_methods :indexes
+
+    def drop_index(*properties)
+      @session.graph_db.schema.indexes(as_java).each do |index_def|
+        # at least one match, TODO
+        keys = index_def.property_keys.map{|x| x.to_sym}
+        index_def.drop if (properties - keys).count < properties.count
+      end
+
+    end
+    tx_methods :drop_index
+
+    class << self
+
+      def as_java(labels)
+        if labels.is_a?(Array)
+          return nil if labels.empty?
+          labels.inject([]) { |result, label| result << JAVA_CLASS.label(label.to_s) }.to_java(JAVA_CLASS)
+        else
+          JAVA_CLASS.label(labels.to_s)
+        end
+      end
+    end
+  end
+
+end
+

data/lib/neo4j-embedded/embedded_node.rb

@@ -0,0 +1,163 @@
+module Neo4j::Embedded
+  class RelsIterator
+    include Enumerable
+    extend Neo4j::Core::TxMethods
+
+    def initialize(node, match)
+      @node = node
+      @match = match
+    end
+
+    def each(&block)
+      @node._rels(@match).each {|r| block.call(r)}
+    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 each(&block)
+      @node._rels(@match).each {|r| block.call(r.other_node(@node))}
+    end
+    tx_methods :each
+
+    def empty?
+      first == nil
+    end
+
+  end
+
+  class EmbeddedNode
+    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
+          include Neo4j::Embedded::Property
+          include Neo4j::EntityEquality
+          extend Neo4j::Core::TxMethods
+
+          def exist?
+            !!graph_database.get_node_by_id(neo_id)
+          rescue Java::OrgNeo4jGraphdb.NotFoundException
+            nil
+          end
+          tx_methods :exist?
+
+          def labels
+            iterator = _labels.iterator
+            iterator.to_a.map{|x| x.name.to_sym}
+          ensure
+            iterator && iterator.close
+          end
+          tx_methods :labels
+
+          alias_method :_labels, :getLabels
+
+          def del
+            _rels.each { |r| r.del }
+            delete
+            nil
+          end
+          tx_methods :del
+
+          def create_rel(type, other_node, props = nil)
+            rel = create_relationship_to(other_node, 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)
+          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 = match[:dir] || :both
+            rel_type = match[:type]
+
+            rel = if rel_type
+                     get_single_relationship(ToJava.type_to_java(rel_type), ToJava.dir_to_java(dir))
+                  else
+                     iter = get_relationships(ToJava.dir_to_java(dir)).iterator
+                     if (iter.has_next)
+                       first = iter.next
+                       raise "Expected to only find one relationship from node #{neo_id} matching #{match.inspect}" if iter.has_next
+                       first
+                     end
+                   end
+
+            between_id = match[:between] && match[:between].neo_id
+
+            if (rel && between_id)
+              rel.other_node(self).neo_id == between_id ? rel : nil
+            else
+              rel
+            end
+          end
+
+          def _rels(match={})
+            dir = match[:dir] || :both
+            rel_type = match[:type]
+
+            rels = if rel_type
+              get_relationships(ToJava.type_to_java(rel_type), ToJava.dir_to_java(dir)).iterator
+            else
+              get_relationships(ToJava.dir_to_java(dir)).iterator
+            end
+
+            between_id = match[:between] && match[:between].neo_id
+
+            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 class
+            Neo4j::Node
+          end
+          #include Neo4j::Core::Label
+          include Neo4j::Wrapper
+        end
+      end
+    end
+
+    extend_java_class(Java::OrgNeo4jKernelImplCore::NodeProxy)
+  end
+
+end

data/lib/neo4j-embedded/embedded_relationship.rb

@@ -0,0 +1,44 @@
+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
+          include Neo4j::Embedded::Property
+          include Neo4j::EntityEquality
+          extend Neo4j::Core::TxMethods
+
+          alias_method :other_node, :getOtherNode
+
+          def exist?
+            !!graph_database.get_relationship_by_id(neo_id)
+          rescue Java::OrgNeo4jGraphdb.NotFoundException
+            nil
+          end
+          tx_methods :exist?
+
+          def start_node
+            getStartNode
+          end
+          tx_methods :start_node
+
+          def del
+            delete
+          end
+          tx_methods :del
+
+          def end_node
+            getEndNode
+          end
+          tx_methods :end_node
+
+        end
+      end
+    end
+
+    extend_java_class(Java::OrgNeo4jKernelImplCore::RelationshipProxy)
+
+  end
+
+
+end

data/lib/neo4j-embedded/embedded_session.rb

@@ -0,0 +1,151 @@
+# Plugin
+
+Neo4j::Session.register_db(:embedded_db) do |*args|
+  Neo4j::Embedded::EmbeddedSession.new(*args)
+end
+
+Neo4j::Session.register_db(:impermanent_db) do |*args|
+  Neo4j::Embedded::EmbeddedImpermanentSession.new(*args)
+end
+
+module Neo4j::Embedded
+  class EmbeddedSession < Neo4j::Session
+
+    class Error < StandardError
+    end
+
+    attr_reader :graph_db, :db_location
+    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]
+      Neo4j::Session.register(self)
+    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
+      @graph_db = factory.newEmbeddedDatabase(db_location)
+    end
+
+    def factory_class
+      Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory
+      Java::OrgNeo4jTest::ImpermanentGraphDatabase
+    end
+
+    def close
+      super
+      shutdown
+    end
+
+    def shutdown
+      graph_db && graph_db.shutdown
+      @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(*params, &query_dsl)
+      begin
+        result = super
+        raise CypherError.new(result.error_msg, result.error_code, result.error_status) if result.respond_to?(:error?) && result.error?
+        # TODO ugly, the server database must convert the result
+        result.respond_to?(:to_hash_enumeration) ? result.to_hash_enumeration : result.to_a
+      rescue Exception => e
+        raise CypherError.new(e,nil,nil)
+      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(q, params={})
+      engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
+      result = engine.execute(q, Neo4j::Core::HashWithIndifferentAccess.new(params))
+      Neo4j::Cypher::ResultWrapper.new(result)
+    end
+
+    def query_default_return
+      " RETURN n"
+    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']}
+    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)
+      end
+      properties.each_pair { |k, v| _java_node[k]=v } if properties
+      _java_node
+    end
+    tx_methods :create_node
+
+  end
+
+  class EmbeddedImpermanentSession < EmbeddedSession
+    def start
+      raise Error.new("Embedded Neo4j db is already running") if running?
+      #puts "Start test impermanent embedded Neo4j db at #{db_location}"
+      @graph_db = Java::OrgNeo4jTest::TestGraphDatabaseFactory.new.newImpermanentDatabase()
+    end
+  end
+
+
+
+end