cadet 0.0.7-java → 0.0.8-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f052829fbaf2513fb3cefa7a3574c4ec8b96b0b8
-  data.tar.gz: 15d0bcc566e85c75282a7a24721beb0bd4069aeb
+  metadata.gz: a1efba14fa6c1668a60ffd431f8c37d17cf22027
+  data.tar.gz: 40606929349bf698a9a7fde8710d7bbc48dc97b2
 SHA512:
-  metadata.gz: 0d9520c3fad2f19c494e5bff35352f2df349c7c224969687af366a5b66f40613a17b8fabdcaf8651736a4284c6c6c7e74f85f0dfcb1935336cc8a62a51d378b0
-  data.tar.gz: 2d21fe45cbec47b08948aa72f6a12a89a7f84a87bdb46de4da828057f43efb58cd08de1127b152f50031b0b88463741de8944be85e23ddda5a3d8873e6d17d2c
+  metadata.gz: 234bfad83bb8ab3d621ef663c7f8ee2324b0f6ab2868de827f52b979fc117819d09cdf071c84f0176d40286bd7250205faeedbc4566f1dbf79554a6457f4ba06
+  data.tar.gz: 4ec3008adb3781e3b76ba70ed3c9038ad60da616218e9362d1602dcb257c4637212d1daa2a32a1b5a9179d3242843d113717d2a1383506bbee0d47af5ea21dc4

data/.travis.yml

@@ -0,0 +1,3 @@
+rvm:
+  - jruby
+

data/README.md

@@ -1,52 +1,29 @@
-- batchinsert mode ruby based index provider
-- support for batchinsert mode!
-just open the database with Cadet::BatchInserter::Session.open() instead of Cadet::Session.open()!
-this no-ops transaction, simply yielding to the supplied block.
+[![Build Status](https://travis-ci.org/karabijavad/cadet.png?branch=master)](https://travis-ci.org/karabijavad/cadet)
 
-super simple. you dont even need to download neo4j.
-
-1. Gemfile
-
-    ```ruby
-    gem 'cadet'
-    ```
-2. ``` bundle install ```
-3. cadet-example.rb
+Use neo4j via jruby! Nothing else needed, simply add this gem to get the power of embedded neo4j!
 
-    ```ruby
+* Batchinsert mode supported.
 
-    require 'cadet'
-    require 'yaml'
 
-    data = YAML.load_file('legislators-current.yaml')
-
-    #open the database, db is now used to interact with the database
-    db = Cadet::Session.open("neo4j-community-2.0.0/data/graph.db")
-
-    db.transaction do
-      ["Legislator", "Party", "Gender", "State"].each {|v| db.constraint v, "name"}
-    end
+super simple. you dont even need to download neo4j.
 
-    data.each do |leg|
-      #begin a transaction. the transaction will automatically finish at the end of the provided block
-      db.transaction do
 
-        #get_a_X_by_y(value) will get or create a node labeled 'X', with a property 'y' of value 'value'
-        l = db.get_a_Legislator_by_name leg["name"]["official_full"]
-        p = db.get_a_Party_by_name      leg["terms"].first["party"]
-        g = db.get_a_Gender_by_name     leg["bio"]["gender"]
-        s = db.get_a_State_by_name      leg["terms"].first["state"]
+```ruby
 
-        l.outgoing(:party)      << p
-        l.outgoing(:gender)     << g
-        l.outgoing(:represents) << s
-      end
-    end
+require 'cadet'
 
-    #close the database
-    db.close()
+#open the database
+db = Cadet::Session.open("neo4j-community-2.0.0/data/graph.db").dsl do
+  #begin a transaction. the transaction will automatically finish at the end of the provided block
+  transaction do
+    Person_by_name("Javad").lives_in_to City_by_name("Chicago")
+  end
+end
 
+#close the database
+db.close
 
+```
 
-    ```
-4. ```bundle exec ruby```
+Batch insert mode can be used by simply using Cadet::BatchInserter::Session instead of Cadet::Session!
+None of your code needs to change.

data/lib/cadet/batch_inserter/node.rb

@@ -1,18 +1,32 @@
 module Cadet
   module BatchInserter
     class Node < Cadet::Node
-      include_package "org.neo4j.graphdb"
 
       def create_outgoing(to, type, properties = {})
-        @db.createRelationship(@underlying, to.underlying, DynamicRelationshipType.withName(type), properties)
+        Relationship.new @db.createRelationship(@underlying, to.underlying, DynamicRelationshipType.withName(type), properties)
       end
 
       def []= (property, value)
-        @db.setNodeProperty @underlying, property.to_s, val
+        @db.setNodeProperty @underlying, property.to_java_string, value
       end
 
       def [] (property)
-        @db.getNodeProperties(@underlying)[property.to_s]
+        @db.getNodeProperties(@underlying)[property.to_java_string]
+      end
+
+      def == other_node
+        @underlying == other_node
+      end
+
+      def outgoing(type)
+        NodeTraverser.new(self, :outgoing, type)
+      end
+
+      def each_relationship(direction, type)
+        # not implemented in batch inserter mode. though, it could be done.
+        # the assumption is that this shouldnt be necessary, as batch inserter mode
+        # should be about inserting data, not querying data
+        raise NotImplementedError
       end
 
     end

data/lib/cadet/batch_inserter/session.rb

@@ -1,14 +1,10 @@
 module Cadet
   module BatchInserter
     class Session < Cadet::Session
-      include_package "org.neo4j.graphdb"
-      include_package "org.neo4j.unsafe.batchinsert"
-      include_package "org.neo4j.index.impl.lucene"
-      include_package "org.neo4j.helpers.collection"
 
       def initialize(db)
-        @db = db
-        @index_provider = Cadet::CadetIndex::IndexProvider.new(db)
+        @index_provider = CadetIndex::IndexProvider.new(db)
+        super db
       end
 
       def close
@@ -16,32 +12,33 @@ module Cadet
         super
       end
 
-      def self.open(location)
-        new BatchInserters.inserter(location)
-      end
-
-      def transaction
-        yield
+      def self.open(location, config = {})
+        new org.neo4j.unsafe.batchinsert.BatchInserters.inserter(location, config)
       end
 
       def constraint(label, property)
         @db.createDeferredConstraint(DynamicLabel.label(label))
-          .assertPropertyIsUnique(property.to_s)
+          .assertPropertyIsUnique(property)
           .create()
       end
 
       def find_node(label, property, value)
         index = @index_provider.nodeIndex(label)
 
-        ( node = IteratorUtil.firstOrNull(index.get(property, value)) ) ?
+        (node = index.get(property.to_sym, value).first) ?
           Node.new(node, @db) : nil
       end
 
-      def create_node(label, property, value)
-        Node.new(@db.createNode({property.to_s => value}, DynamicLabel.label(label)), @db).tap do |n|
-          index = @index_provider.nodeIndex(label).add(n.underlying, property, value)
+      def create_node(label, properties, indexing_property = nil)
+        Node.new(@db.createNode(properties.inject({}){|result,(k,v)| result[k.to_java_string] = v; result}, DynamicLabel.label(label)), @db).tap do |n|
+          @index_provider.nodeIndex(label).add(n.underlying, indexing_property.to_sym, properties[indexing_property]) if indexing_property
         end
       end
+
+      def get_transaction
+        Cadet::BatchInserter::Transaction.new(self)
+      end
+
     end
   end
 end

data/lib/cadet/batch_inserter/transaction.rb

@@ -0,0 +1,16 @@
+module Cadet
+  module BatchInserter
+    class Transaction < Cadet::Transaction
+
+      def initialize(session)
+        @session = session
+      end
+
+      def success
+      end
+
+      def close
+      end
+    end
+  end
+end

data/lib/cadet/cadet_index/index.rb

@@ -7,23 +7,27 @@ module Cadet
         @index = {}
         @lucene_index = lucene_index
       end
+
       def add(node, property, value)
         @index[property] ||= {}
         @index[property][value] = node
       end
+
       def get(property, value)
         @index[property] ||= {}
         [@index[property][value]]
       end
+
       def flush
         index = @lucene_index.nodeIndex(@name, @type)
 
         @index.each do |property, mappings|
           mappings.each do |value, node|
-            index.add(node, {property.to_s => value})
+            index.add(node, {property.to_java_string => value})
           end
         end
       end
+
     end
   end
 end

data/lib/cadet/cadet_index/index_provider.rb

@@ -1,14 +1,14 @@
 module Cadet
   module CadetIndex
     class IndexProvider
-      include_package "org.neo4j.index.impl.lucene"
+
       def initialize(db)
         @db = db
         @indexes = {}
-        @lucene_index = LuceneBatchInserterIndexProviderNewImpl.new(db)
+        @lucene_index = org.neo4j.index.impl.lucene.LuceneBatchInserterIndexProviderNewImpl.new(db)
       end
       def nodeIndex(name, type = {"type" => "exact"})
-        @indexes[name] ||= Cadet::CadetIndex::Index.new(@lucene_index, name, type)
+        @indexes[name.to_sym] ||= CadetIndex::Index.new(@lucene_index, name.to_sym, type)
       end
       def shutdown
         @indexes.each do |name, index|

data/lib/cadet/direction.rb

@@ -0,0 +1,6 @@
+module Cadet
+  Directions = {
+    outgoing: org.neo4j.graphdb.Direction::OUTGOING,
+    incoming: org.neo4j.graphdb.Direction::INCOMING
+  }
+end

data/lib/cadet/dsl.rb

@@ -0,0 +1,36 @@
+module Cadet
+  class DSL
+    def initialize(db)
+      @db = db
+    end
+
+    def method_missing(name, *args, &block)
+      case name
+        when /^([A-z_]*)_by_([A-z_]*)/
+          self.class.class_eval "
+            def #{name}(value)
+              @db.get_node :#{$1}, :#{$2}, value
+            end"
+          return self.send(name, *args, &block)
+
+        when /^create_([A-z_]*)_on_([A-z_]*)/.match(name)
+          self.class.class_eval "
+            def #{name}(value)
+              @db.create_node :#{$1}, value, :#{$2}
+            end"
+          return self.send(name, *args, &block)
+
+        when /^create_([A-z_]*)/
+          self.class.class_eval "
+            def #{name}(value = {})
+              @db.create_node :#{$1}, value
+            end"
+          return self.send(name, *args, &block)
+
+        else
+          return @db.send(name, *args, &block)
+      end
+    end
+
+  end
+end

data/lib/cadet/dynamic_label.rb

@@ -3,7 +3,7 @@ module Cadet
     @dynamic_labels = {}
 
     def self.label(name)
-      @dynamic_labels[name] ||= org.neo4j.graphdb.DynamicLabel.label(name.to_s)
+      @dynamic_labels[name.to_sym] ||= org.neo4j.graphdb.DynamicLabel.label(name)
     end
   end
-end
+end

data/lib/cadet/dynamic_relationshiptype.rb

@@ -3,7 +3,7 @@ module Cadet
     @dynamic_relationship_types = {}
 
     def self.withName(name)
-      @dynamic_relationship_types[name] ||= org.neo4j.graphdb.DynamicRelationshipType.withName(name.to_s)
+      @dynamic_relationship_types[name.to_sym] ||= org.neo4j.graphdb.DynamicRelationshipType.withName(name)
     end
   end
 end

data/lib/cadet/helpers.rb

@@ -0,0 +1,15 @@
+# This is to fix a (bug?) in jruby.
+# typically, when a ruby symbol is passed into a native java function,
+# it should be converted to a java string by jruby.
+# unfortunately, this conversion does not seem to take place when the native
+# java function is overloaded.
+# This method allows me to specify :symbol.to_java_string,
+# so that I do not need to create a Ruby string from a symbol,
+# just so that i can get a native java string
+
+class Symbol
+  JString = java.lang.String
+  def to_java_string
+    to_java(JString)
+  end
+end

data/lib/cadet/node.rb

@@ -1,7 +1,6 @@
 module Cadet
   class Node
     attr_accessor :underlying
-    include_package "org.neo4j.graphdb"
 
     def initialize(node, db = nil)
       @db = db
@@ -17,28 +16,50 @@ module Cadet
     end
 
     def []= (property, value)
-      @underlying.setProperty(property.to_s, value)
+      @underlying.setProperty(property.to_java_string, value)
     end
 
     def [] (property)
-      @underlying.getProperty(property.to_s)
+      @underlying.getProperty(property.to_java_string)
     end
 
-    def get_relationships(direction, type)
-      @underlying.getRelationships(direction, DynamicRelationshipType.withName(type))
+    def each_relationship(direction, type)
+      @underlying.getRelationships(Directions[direction], DynamicRelationshipType.withName(type)).each do |rel|
+        yield Relationship.new(rel)
+      end
     end
+
     def create_outgoing(to, type)
-      @underlying.createRelationshipTo(to.underlying, DynamicRelationshipType.withName(type))
+      Relationship.new @underlying.createRelationshipTo(to.underlying, DynamicRelationshipType.withName(type))
     end
     def outgoing(type)
-      Cadet::RelationshipTraverser.new(self, Direction::OUTGOING, type)
+      NodeTraverser.new(self, :outgoing, type)
     end
     def incoming(type)
-      Cadet::RelationshipTraverser.new(self, Direction::INCOMING, type)
+      NodeTraverser.new(self, :incoming, type)
+    end
+
+    def outgoing_rels(type)
+      NodeRelationships.new(self, :outgoing, type)
+    end
+    def incoming_rels(type)
+      NodeRelationships.new(self, :incoming, type)
     end
 
     def == other_node
       @underlying.getId == other_node.underlying.getId
     end
+
+    def method_missing(name, *args, &block)
+      if match = /([A-z_]*)_to$/.match(name)
+        self.class.class_eval "
+          def #{name}(value)
+            create_outgoing(value, :#{match.captures[0]})
+          end
+        "
+        self.send(name, *args, &block)
+      end
+    end
+
   end
 end

data/lib/cadet/node_relationships.rb

@@ -0,0 +1,20 @@
+module Cadet
+  class NodeRelationships
+    include Enumerable
+
+    def initialize(node, direction, type)
+      @node = node
+      @type = type
+      @direction = direction
+    end
+
+    def each &block
+      @node.each_relationship(@direction, @type, &block)
+    end
+
+    def ==(other)
+      self.to_a == other.to_a
+    end
+
+  end
+end

data/lib/cadet/node_traverser.rb

@@ -0,0 +1,33 @@
+module Cadet
+  class NodeTraverser
+    include Enumerable
+
+    def initialize(node, direction, type)
+      @node = node
+      @type = type
+      @direction = direction
+    end
+
+    def each
+      @node.each_relationship(@direction, @type) do |rel|
+        yield rel.get_other_node(@node)
+      end
+    end
+
+    def << (othernode)
+      @direction == :outgoing ? @node.create_outgoing(othernode, @type) : othernode.create_outgoing(@node, @type)
+    end
+
+    def outgoing(type)
+      PathTraverser.new to_a, :outgoing, type
+    end
+    def incoming(type)
+      PathTraverser.new to_a, :incoming, type
+    end
+
+    def ==(other)
+      self.to_a == other.to_a
+    end
+
+  end
+end

data/lib/cadet/path_traverser.rb

@@ -0,0 +1,38 @@
+module Cadet
+  class PathTraverser
+    include Enumerable
+
+    def initialize(nodes, direction, type)
+      @nodes = nodes
+      @direction = direction
+      @type = type
+    end
+
+    def each
+      if @direction == :outgoing
+        @nodes.each do |n|
+          n.outgoing(@type).each do |o|
+            yield o
+          end
+        end
+      else
+        @nodes.each do |n|
+          n.incoming(@type).each do |o|
+            yield o
+          end
+        end
+      end
+    end
+
+    def outgoing(type)
+      PathTraverser.new(to_a, :outgoing, type)
+    end
+    def incoming(type)
+      PathTraverser.new(to_a, :incoming, type)
+    end
+
+    def ==(other)
+      self.to_a == other.to_a
+    end
+  end
+end

data/lib/cadet/relationship.rb

@@ -0,0 +1,17 @@
+module Cadet
+  class Relationship
+    attr_accessor :underlying
+
+    def initialize(relationship)
+      @underlying = relationship
+    end
+
+    def == other_rel
+      @underlying.getId == other_rel.underlying.getId
+    end
+
+    def get_other_node(node)
+      Node.new @underlying.getOtherNode(node.underlying)
+    end
+  end
+end

data/lib/cadet/session.rb

@@ -1,39 +1,43 @@
 module Cadet
   class Session
-    include_package "org.neo4j.graphdb"
-    include_package "org.neo4j.graphdb.factory"
-    include_package "org.neo4j.unsafe.batchinsert"
-    include_package "org.neo4j.helpers.collection"
-
     def initialize(db)
       @db = db
     end
 
     def self.open(location)
-      new GraphDatabaseFactory.new.newEmbeddedDatabase(location)
+      new org.neo4j.graphdb.factory.GraphDatabaseFactory.new.newEmbeddedDatabase(location)
     end
     def close
       @db.shutdown
     end
 
-    def create_node(label, property, value)
+    def create_node(label, properties, indexing_property = nil)
       Node.new(@db.createNode).tap do |n|
         n.add_label label
-        n[property] = value
+        properties.each { |prop, val| n[prop] = val }
       end
     end
 
     def find_node(label, property, value)
-      ( node = IteratorUtil.firstOrNull(@db.findNodesByLabelAndProperty(DynamicLabel.label(label), property, value)) ) ?
+      ( node = org.neo4j.helpers.collection.IteratorUtil.firstOrNull(@db.findNodesByLabelAndProperty(DynamicLabel.label(label), property, value)) ) ?
         Node.new(node) : nil
     end
 
     def get_node(label, property, value)
-      find_node(label, property, value) || create_node(label, property, value)
+      find_node(label, property, value) || create_node(label, {property.to_sym => value}, property)
+    end
+
+    def get_transaction
+      Transaction.new(self)
+    end
+
+    def dsl(&block)
+      DSL.new(self).instance_exec(self, &block)
+      self
     end
 
     def transaction
-      tx = @db.beginTx
+      tx = get_transaction
       begin
         yield tx
         tx.success
@@ -45,15 +49,12 @@ module Cadet
     def constraint(label, property)
       @db.schema
         .constraintFor(DynamicLabel.label(label))
-        .assertPropertyIsUnique(property.to_s)
+        .assertPropertyIsUnique(property)
         .create()
     end
 
-    def method_missing(name, *args)
-      if match = /^get_a_([A-Z][A-Za-z]*)_by_([A-z]*)/.match(name)
-        return get_node match.captures[0], match.captures[1], args[0]
-      end
+    def begin_tx
+      @db.beginTx
     end
-
   end
 end

data/lib/cadet/test/session.rb

@@ -1,20 +1,9 @@
 module Cadet
   module Test
     class Session < Cadet::Session
-      include_package "org.neo4j.graphdb"
-      include_package "org.neo4j.unsafe.batchinsert"
-      include_package "org.neo4j.index.impl.lucene"
-      include_package "org.neo4j.helpers.collection"
-      include_package "org.neo4j.graphdb.GraphDatabaseService"
-      include_package "org.neo4j.graphdb.Node"
-      include_package "org.neo4j.graphdb.Transaction"
-      include_package "org.neo4j.graphdb.factory.GraphDatabaseSettings"
-      include_package "org.neo4j.test"
-
-
 
       def self.open
-        new TestGraphDatabaseFactory.new.newImpermanentDatabase
+        new org.neo4j.test.TestGraphDatabaseFactory.new.newImpermanentDatabase
       end
 
     end

data/lib/cadet/transaction.rb

@@ -0,0 +1,27 @@
+module Cadet
+  class Transaction
+    attr_accessor :underlying
+
+    def initialize(session)
+      @session = session
+      @underlying = @session.begin_tx
+    end
+
+    def method_missing(name, *args, &block)
+      # for the "dsl".
+      # the transaction block is instance_eval'd by this class,
+      # so any missing methods are then sent to the session
+      # essentially means that session.blah can then be writen blah
+      @session.send(name, *args, &block)
+
+    end
+
+    def success
+      @underlying.success
+    end
+    def close
+      @underlying.close
+    end
+
+  end
+end

data/lib/cadet/version.rb

@@ -1,3 +1,3 @@
 module Cadet
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/lib/cadet.rb

@@ -1,20 +1,29 @@
 require 'java'
 
-require "neo4j/concurrentlinkedhashmap-lru-1.3.1.jar"
-require "neo4j/lucene-core-3.6.2.jar"
-require "neo4j/neo4j-kernel-2.0.1-tests.jar"
-require "neo4j/neo4j-kernel-2.0.1.jar"
 require "neo4j/neo4j-lucene-index-2.0.1.jar"
 require "neo4j/neo4j-shell-2.0.1.jar"
 require "neo4j/neo4j-kernel-2.0.1-tests.jar"
 
+require 'cadet/helpers'
 require 'cadet/session'
 require 'cadet/node'
-require 'cadet/relationship_traverser'
+require 'cadet/relationship'
+require 'cadet/direction'
+require 'cadet/node_traverser'
+require 'cadet/path_traverser'
+require 'cadet/node_relationships'
+require 'cadet/transaction'
+
+require 'cadet/dsl'
+
 require 'cadet/batch_inserter/session'
 require 'cadet/batch_inserter/node'
+require 'cadet/batch_inserter/transaction'
+
+require 'cadet/test/session'
+
 require 'cadet/cadet_index/index_provider'
 require 'cadet/cadet_index/index'
+
 require 'cadet/dynamic_relationshiptype'
 require 'cadet/dynamic_label'
-require 'cadet/test/session'

data/spec/spec_helper.rb

@@ -1,9 +1,52 @@
 require 'cadet'
+require 'tmpdir'
 
-def quick_neo4j
-  db = Cadet::Test::Session.open
+def quick_test_neo4j
+  test_neo4j do |db|
     db.transaction do |tx|
       yield db, tx
     end
+  end
+end
+
+def test_neo4j
+  db = Cadet::Test::Session.open
+  yield db
   db.close
 end
+
+def quick_normal_neo4j(at = nil)
+  at ||= Dir.mktmpdir
+
+  normal_neo4j(at) do |db|
+    db.transaction do
+      yield db
+    end
+  end
+  at
+end
+
+def normal_neo4j(at)
+  db = Cadet::Session.open(at)
+  yield db
+  db.close
+end
+
+def quick_batch_neo4j(at = nil)
+  at ||= Dir.mktmpdir
+
+  batch_neo4j(at) do |db|
+    yield db
+  end
+  at
+end
+
+def batch_neo4j(at)
+  db = Cadet::BatchInserter::Session.open(at)
+  yield db
+  db.close
+end
+
+def quick_batch_dsl_neo4j
+  yield quick_batch_neo4j.dsl
+end

data/spec/unit/batch_insert_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+require 'tmpdir'
+
+describe Cadet::BatchInserter do
+  it "should set a nodes property" do
+    tmpdir = quick_batch_neo4j do |db|
+      javad = db.get_node(:Person, :name, "Javad")
+      javad[:age] = 25
+    end
+
+    quick_normal_neo4j(tmpdir) do |db|
+      javad = db.get_node(:Person, :name, "Javad")
+      javad[:age].should == 25
+    end
+  end
+
+  it "should create a relationship" do
+    tmpdir = quick_batch_neo4j do |db|
+      javad = db.get_node(:Person, :name, "Javad")
+      ellen = db.get_node(:Person, :name, "Ellen")
+
+      javad.outgoing(:knows) << ellen
+    end
+
+    quick_normal_neo4j(tmpdir) do |db|
+      javad = db.get_node(:Person, :name, "Javad")
+      ellen = db.get_node(:Person, :name, "Ellen")
+
+      javad.outgoing(:knows).should == [ellen]
+    end
+  end
+
+  it "should create a node with a set of properties, and index that node on a specified property" do
+    tmpdir = quick_batch_neo4j do |db|
+      javad = db.create_node(:Person, {name: "Javad", age: 25})
+    end
+
+    quick_normal_neo4j(tmpdir) do |db|
+      javad = db.get_node(:Person, :name, "Javad")
+
+      javad[:name].should == "Javad"
+      javad[:age].should == 25
+    end
+  end
+
+  it "should retrieve the same node, for the same label-key-value" do
+    tmpdir = quick_batch_neo4j do |db|
+      javad = db.get_node(:Person, :name, "Javad")
+      ellen = db.get_node(:Person, :name, "Ellen")
+
+      javad.outgoing(:lives_in) << db.get_node(:City, :name, "Chicago")
+      ellen.outgoing(:lives_in) << db.get_node(:City, :name, "Chicago")
+    end
+
+    quick_normal_neo4j(tmpdir) do |db|
+      javad = db.get_node(:Person, :name, "Javad")
+      ellen = db.get_node(:Person, :name, "Ellen")
+
+      javad.outgoing(:lives_in).should == ellen.outgoing(:lives_in)
+    end
+  end
+
+  it "should work" do
+    tmpdir = quick_batch_neo4j do |db|
+      javad       = db.get_node :Person,  :name, "Javad"
+      ellen       = db.get_node :Person,  :name, "Ellen"
+      trunkclub   = db.get_node :Company, :name, "Trunkclub"
+      chicago     = db.get_node :City,    :name, "Chicago"
+      us          = db.get_node :Country, :name, "United States"
+
+      javad.outgoing(:works_at) << trunkclub
+      trunkclub.outgoing(:located_in) << chicago
+      ellen.outgoing(:lives_in) << chicago
+      chicago.outgoing(:country) << us
+    end
+
+    quick_normal_neo4j(tmpdir) do |db|
+      javad       = db.get_node :Person,  :name, "Javad"
+      ellen       = db.get_node :Person,  :name, "Ellen"
+      trunkclub   = db.get_node :Company, :name, "Trunkclub"
+      chicago     = db.get_node :City,    :name, "Chicago"
+      us          = db.get_node :Country, :name, "United States"
+
+      javad.outgoing(:works_at).should == [trunkclub]
+    end
+
+  end
+
+  it "should work" do
+    tmpdir = quick_batch_neo4j do |db|
+      javad       = db.get_node :Person,  :name, "Javad"
+      ellen       = db.get_node :Person,  :name, "Ellen"
+      trunkclub   = db.get_node :Company, :name, "Trunkclub"
+      chicago     = db.get_node :City,    :name, "Chicago"
+      us          = db.get_node :Country, :name, "United States"
+
+      javad.outgoing(:lives_in) << chicago
+      ellen.outgoing(:lives_in) << chicago
+    end
+
+    quick_normal_neo4j(tmpdir) do |db|
+      javad       = db.get_node :Person,  :name, "Javad"
+      ellen       = db.get_node :Person,  :name, "Ellen"
+      trunkclub   = db.get_node :Company, :name, "Trunkclub"
+      chicago     = db.get_node :City,    :name, "Chicago"
+      us          = db.get_node :Country, :name, "United States"
+
+      javad.outgoing(:lives_in).should == [chicago]
+      ellen.outgoing(:lives_in).should == [chicago]
+    end
+  end
+
+  it "should not allow for get_relationships" do
+    tmpdir = quick_batch_neo4j do |db|
+      javad       = db.get_node :Person,  :name, "Javad"
+      ellen       = db.get_node :Person,  :name, "Ellen"
+      trunkclub   = db.get_node :Company, :name, "Trunkclub"
+      chicago     = db.get_node :City,    :name, "Chicago"
+      us          = db.get_node :Country, :name, "United States"
+
+      javad.outgoing(:lives_in) << chicago
+      chicago.outgoing(:country) << us
+
+      expect {javad.outgoing(:lives_in).outgoing(:country)}.to raise_error(NotImplementedError)
+    end
+  end
+
+  it "should accept database configs" do
+    db = Cadet::BatchInserter::Session.open(Dir.mktmpdir, {"use_memory_mapped_buffers" => "true"})
+    db.close
+  end
+
+  xit "should not allow for get_relationships" do
+    quick_batch_dsl_neo4j do
+      transaction do
+        Person_by_name("Javad").lives_in_to City_by_name("Chicago")
+
+        Person_by_name("Javad").outgoing(:lives_in).should == [City_by_name("Chicago")]
+      end
+    end
+  end
+
+
+end

data/spec/unit/cadet_spec.rb

@@ -1,31 +1,101 @@
 require 'spec_helper'
-require 'tmpdir'
 
 describe Cadet do
 
   it "should set a node's property" do
-    quick_neo4j do |db|
+    quick_normal_neo4j do |db|
         javad = db.get_node :Person, :name, "Javad"
         javad[:name].should == "Javad"
     end
   end
 
   it "should set a node's label" do
-    quick_neo4j do |db|
+    quick_normal_neo4j do |db|
         javad = db.get_node :Person, :name, "Javad"
-        javad.add_label "Member"
+        javad.add_label :Member
         javad.labels.should == ["Person", "Member"]
     end
   end
 
   it "should add outgoing relationship's to a node" do
-    quick_neo4j do |db|
+    quick_normal_neo4j do |db|
         javad = db.get_node :Person, :name, "Javad"
         ellen = db.get_node :Person, :name, "Ellen"
 
         javad.outgoing(:knows) << ellen
 
-        javad.outgoing(:knows).to_a.should == [ellen]
+        javad.outgoing(:knows).should == [ellen]
+    end
+  end
+
+  it "it should accept multiple relationships" do
+    quick_normal_neo4j do |db|
+      javad = db.get_node(:Person, :name, "Javad")
+      javad.outgoing(:lives_in) << db.get_node(:City, :name, "Chicago")
+      javad.outgoing(:lives_in) << db.get_node(:City, :name, "Houston")
+      javad.outgoing(:lives_in).should == [db.get_node(:City, :name, "Chicago"), db.get_node(:City, :name, "Houston")]
+    end
+  end
+
+  it "should allow for outgoing to be chained" do
+    quick_test_neo4j do |db|
+      db.dsl do |db|
+        javad       = Person_by_name  "Javad"
+        ellen       = Person_by_name  "Ellen"
+        trunkclub   = Company_by_name "Trunkclub"
+        chicago     = City_by_name    "Chicago"
+        us          = Country_by_name "United States"
+        springfield = City_by_name    "Springfield"
+
+
+        javad.outgoing(:works_at) << trunkclub
+        trunkclub.outgoing(:located_in) << chicago
+        javad.outgoing(:lives_in) << chicago
+        ellen.outgoing(:lives_in) << chicago
+        chicago.outgoing(:country) << us
+
+        javad.outgoing(:works_at).outgoing(:located_in).outgoing(:country).should == [us]
+        chicago.incoming(:located_in).incoming(:works_at).should == [javad]
+        javad.outgoing(:works_at).outgoing(:located_in).incoming(:lives_in).should == [javad, ellen]
+      end
+    end
+  end
+
+  it "should allow for node relationship's to be accessed" do
+    quick_test_neo4j do |db|
+      db.dsl do |db|
+        javad       = Person_by_name  "Javad"
+        ellen       = Person_by_name  "Ellen"
+        javad.outgoing(:knows) << ellen
+        javad.incoming(:also_knows) << ellen
+
+        javad.outgoing_rels(:knows).map{ |rel| rel.get_other_node(javad)}.should == [ellen]
+        javad.incoming_rels(:also_knows).map{ |rel| rel.get_other_node(javad)}.should == [ellen]
+      end
+    end
+  end
+
+
+  xit "should enforce unique constraints" do
+    test_neo4j do |db|
+      db.transaction do
+        db.constraint :Person, :name
+      end
+      db.transaction do
+        db.create_node :Person, :name, "Javad"
+
+        expect { db.create_node :Person, :name, "Javad" }.to raise_error(org.neo4j.graphdb.ConstraintViolationException)
+      end
+    end
+  end
+
+  it 'should have a working dsl' do
+    db = Cadet::Test::Session.open.dsl do
+      transaction do |tx|
+        Person_by_name("Javad").lives_in_to City_by_name("Chicago")
+
+        Person_by_name("Javad").outgoing(:lives_in).should == [City_by_name("Chicago")]
+      end
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cadet
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: java
 authors:
 - Javad Karabi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-02-21 00:00:00.000000000 Z
+date: 2014-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -45,6 +45,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - Gemfile.lock
 - README.md
@@ -53,14 +54,22 @@ files:
 - lib/cadet.rb
 - lib/cadet/batch_inserter/node.rb
 - lib/cadet/batch_inserter/session.rb
+- lib/cadet/batch_inserter/transaction.rb
 - lib/cadet/cadet_index/index.rb
 - lib/cadet/cadet_index/index_provider.rb
+- lib/cadet/direction.rb
+- lib/cadet/dsl.rb
 - lib/cadet/dynamic_label.rb
 - lib/cadet/dynamic_relationshiptype.rb
+- lib/cadet/helpers.rb
 - lib/cadet/node.rb
-- lib/cadet/relationship_traverser.rb
+- lib/cadet/node_relationships.rb
+- lib/cadet/node_traverser.rb
+- lib/cadet/path_traverser.rb
+- lib/cadet/relationship.rb
 - lib/cadet/session.rb
 - lib/cadet/test/session.rb
+- lib/cadet/transaction.rb
 - lib/cadet/version.rb
 - lib/neo4j/README.txt
 - lib/neo4j/concurrentlinkedhashmap-lru-1.3.1.jar
@@ -71,6 +80,7 @@ files:
 - lib/neo4j/neo4j-lucene-index-2.0.1.jar
 - lib/neo4j/neo4j-shell-2.0.1.jar
 - spec/spec_helper.rb
+- spec/unit/batch_insert_spec.rb
 - spec/unit/cadet_spec.rb
 homepage: https://github.com/karabijavad/cadet
 licenses:

data/lib/cadet/relationship_traverser.rb

@@ -1,22 +0,0 @@
-module Cadet
-  class RelationshipTraverser
-    include Enumerable
-    include_package "org.neo4j.graphdb"
-
-    def initialize(node, direction, type)
-      @node = node
-      @type = type
-      @direction = direction
-    end
-
-    def each
-      @node.get_relationships(@direction, @type).each do |rel|
-        yield Node.new(rel.getOtherNode(@node.underlying))
-      end
-    end
-
-    def << (othernode)
-      @direction == Direction::OUTGOING ? @node.create_outgoing(othernode, @type) : othernode.create_outgoing(@node, @type)
-    end
-  end
-end