neo4j-core 3.0.0.alpha.18 → 3.0.0.alpha.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 189f7b0b7187d44d8f5825e6747c033bdba18380
-  data.tar.gz: d6748e42f17f0cd18d20009378e2101164df7d5b
+  metadata.gz: 99c353a80ee0078fb684f74860c6b9adab86f81a
+  data.tar.gz: 5164eb9d290c70506f2e38c8e70952b59e058b0b
 SHA512:
-  metadata.gz: b35a530b4637e5732589a0689a4125f5727b7ece75e4d2ba4c5efe45b1f4526a824bd3578a5510745c748b6a20a17dd563a96fbec2f3cfc6d49ad9bf0e4b8135
-  data.tar.gz: 5127606c4d29c68fe05ad77f79f0614dd16aa3e4faad3c025c7c821a96c8e2f2e643dd6faf9301cf5515362f96619d56b969a639c78dc42e539996556e6476dc
+  metadata.gz: ff3c176237a7fe786532cee32b922fcf6e239c9493bf3a64b0da3adf38d4e73941948cad014bcb486aab6ddfb6ece763b11cc14e65e89b354504d520d9d513bf
+  data.tar.gz: c4a5a1e0b1597f5a0f12ad4a88d8b13f730429101552a778f99583efbe3eddabec83f6964fea15193084e1da7bbc5e7839a2e9e09df2539843bc3b9d017efcac

data/Gemfile

@@ -9,12 +9,13 @@ gem 'zip'
 
 group 'development' do
   gem 'yard'
+  gem 'simplecov'
 #  gem 'pry'
 end
 
 group 'test' do
   gem "rake", ">= 0.8.7"
-  gem "rspec", "~> 2.8"
+  gem "rspec", "~> 3.0"
   gem 'rspec-its'
 end
 

data/README.md

@@ -42,7 +42,7 @@ require 'neo4j/tasks/neo4j_server'
 
 Install and start neo4j by typing:
 ```
-rake neo4j:install[community-2.1.1]
+rake neo4j:install[community-2.1.3]
 rake neo4j:start
 ```
 
@@ -61,6 +61,7 @@ No need to start the server since it is embedded.
 * [Neo4j::Relationship](http://www.rubydoc.info/github/andreasronge/neo4j-core/Neo4j/Relationship)
 * [Neo4j::Session](http://www.rubydoc.info/github/andreasronge/neo4j-core/Neo4j/Session)
 * [Neo4j::Label](http://www.rubydoc.info/github/andreasronge/neo4j-core/Neo4j/Label)
+* [Neo4j::Transaction](http://www.rubydoc.info/github/andreasronge/neo4j-core/Neo4j/Transaction)
 * [Neo4j::Query](Neo4j/Query.html)
 
 See also [Neo4j Docs](http://docs.neo4j.org/)

data/lib/neo4j-core/query.rb

@@ -155,7 +155,7 @@ module Neo4j::Core
     def each
       response = self.response
       if response.is_a?(Neo4j::Server::CypherResponse)
-        self.response.to_node_enumeration
+        response.to_node_enumeration
       else
         Neo4j::Embedded::ResultWrapper.new(response, self.to_cypher)
       end.each {|object| yield object }

data/lib/neo4j-core/version.rb

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

data/lib/neo4j-core/version.rb~

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

data/lib/neo4j-embedded.rb

@@ -8,6 +8,7 @@ require 'neo4j-embedded/embedded_label'
 require 'neo4j-embedded/embedded_node'
 require 'neo4j-embedded/embedded_relationship'
 require 'neo4j-embedded/embedded_label'
+require 'neo4j-embedded/embedded_transaction'
 require 'neo4j-embedded/cypher_response'
 
 # TODO replace this with https://github.com/intridea/hashie gem

data/lib/neo4j-embedded/cypher_response.rb~

@@ -0,0 +1,85 @@
+module Neo4j::Embedded
+
+  # Wraps the Cypher query result.
+  # Loads the node and relationships wrapper if possible and use symbol as column keys.
+  # This is typically used in the native neo4j bindings since result does is not a Ruby enumerable with symbols as keys.
+  # @note The result is a once forward read only Enumerable, work if you need to read the result twice - use #to_a
+  #
+  class ResultWrapper
+    class ResultsAlreadyConsumedException < Exception;
+    end
+
+    include Enumerable
+
+    # @return the original result from the Neo4j Cypher Engine, once forward read only !
+    attr_reader :source
+
+    def initialize(source, map_return_procs, query)
+      @source = source
+      @unread = true
+      @map_return_procs = map_return_procs
+      @query = query
+    end
+
+    def to_s
+      @query
+    end
+
+    # @return [Array<Symbol>] the columns in the query result
+    def columns
+      @source.columns.map { |x| x.to_sym }
+    end
+
+    # for the Enumerable contract
+    def each(&block)
+      raise ResultsAlreadyConsumedException unless @unread
+
+      if (block)
+        case @map_return_procs
+          when NilClass then
+            each_no_mapping &block
+          when Hash then
+            each_multi_column_mapping &block
+          else
+            each_single_column_mapping &block
+        end
+      else
+        Enumerator.new(self)
+      end
+    end
+
+
+    private
+
+    def each_no_mapping
+      @source.each do |row|
+        hash = {}
+        row.each do |key, value|
+          out[key.to_sym] = value
+        end
+        yield hash
+      end
+    end
+
+    def each_multi_column_mapping
+      @source.each do |row|
+        hash = {}
+        row.each do |key, value|
+          k = key.to_sym
+          proc = @map_return_procs[k]
+          hash[k] = proc ? proc.call(value) : value
+        end
+        yield hash
+      end
+    end
+
+    def each_single_column_mapping
+      @source.each do |row|
+        result = @map_return_procs.call(row.values.first)
+        yield result
+      end
+    end
+
+  end
+end
+

data/lib/neo4j-embedded/embedded_node.rb~

@@ -0,0 +1,201 @@
+module Neo4j::Embedded
+  class RelsIterator
+    include Enumerable
+    extend Neo4j::Core::TxMethods
+
+    def initialize(node, match)
+      @node = node
+      @match = match
+    end
+
+    def inspect
+      "Enumerable<Neo4j::Relationship>"
+    end
+
+    def each(&block)
+      @node._rels(@match).each {|r| block.call(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 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 inspect
+            "EmbeddedNode neo_id: #{neo_id}"
+          end
+
+          def exist?
+            !!graph_database.get_node_by_id(neo_id)
+          rescue Java::OrgNeo4jGraphdb.NotFoundException
+            nil
+          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 { |r| r.del }
+            delete
+            nil
+          end
+          tx_methods :del
+
+          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 = 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::Node::Wrapper
+        end
+      end
+    end
+
+    extend_java_class(Java::OrgNeo4jKernelImplCore::NodeProxy)
+  end
+
+end

data/lib/neo4j-embedded/embedded_relationship.rb

@@ -26,6 +26,8 @@ module Neo4j::Embedded
             _start_node.wrapper
           end
           tx_methods :start_node
+          alias_method :_start_node_id, :start_node
+          tx_methods :_start_node_id
 
           def _start_node
             getStartNode
@@ -54,6 +56,8 @@ module Neo4j::Embedded
             _end_node.wrapper
           end
           tx_methods :end_node
+          alias_method :_end_node_id, :end_node
+          tx_methods :_end_node_id
 
           def _end_node
             getEndNode

data/lib/neo4j-embedded/embedded_relationship.rb~

@@ -0,0 +1,62 @@
+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
+          include Neo4j::Relationship::Wrapper
+          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
+            _start_node.wrapper
+          end
+          tx_methods :start_node
+
+          def _start_node
+            getStartNode
+          end
+
+          def rel_type
+            getType().name().to_sym
+          end
+
+          def del
+            delete
+          end
+          tx_methods :del
+
+          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
+
+          def _end_node
+            getEndNode
+          end
+
+        end
+      end
+    end
+
+    extend_java_class(Java::OrgNeo4jKernelImplCore::RelationshipProxy)
+
+  end
+
+
+end