cadet 0.0.9-java → 0.1.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 48585f123ff37c132231028e3b809f8c62fb4a20
-  data.tar.gz: 4ab3b61f8e25f66e474d6ff9f85dd3e26a9b6d15
+  metadata.gz: 44c6bd53bbc5065234be58f9851fb93fb8b35030
+  data.tar.gz: e07f2a4322395961deea2586f5dcb18f3bdddd35
 SHA512:
-  metadata.gz: 96d7b7ae5abf90756b78199c6252076b04a3fbc854cbcf3a8303876fc0fed0180fa9c37307574d9286c0a43d876b736cebd3e4900d845a7ac8abb6b050f6bf59
-  data.tar.gz: 4f0f675789e21386936bb56524e4b6bc93845b04cfde66be3e50372a1993286b083070d59d4e3b7fe50a2ed2d84bc2a4a9ca9f811cdb255cf34b04c666597711
+  metadata.gz: e213c75cca7e02ed89f2369b6c63e60c56a8d976601239b8963d8faf80ec741c6da071d293f0573e339ca6ab2dfb9797f4f7949e6409ac20756de0fdb9339974
+  data.tar.gz: 9053afd936989c658a6bc230f71c81864585312b9c1453e4dfb41e5f7263fc7e241d4806d2983d17a48a3451dd410a0e1e69618d11efc1fb28353a389d840ecd

data/.gitignore

@@ -1 +1,2 @@
 .bundle
+Gemfile.lock

data/README.md

@@ -12,18 +12,47 @@ super simple. you dont even need to download neo4j.
 
 require 'cadet'
 
-#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
+Cadet::Session.open "path/to/graph.db/" do
   transaction do
     Person_by_name("Javad").lives_in_to City_by_name("Chicago")
   end
 end
 
-#close the database
-db.close
 
 ```
 
+## Getting/creating a node, using label-property-value
+A node can be retrieved (and implicitly created if it does not exist) via the following syntax:
+```ruby
+javad = Person_by_name("Javad")
+```
+This will search for a node with the label "Person", and with the a "name" property set to "Javad".
+If a "Person" node with "name" "Javad" is not found, it will create the node, add the label "Person", and set the "name" to "javad".
+
+## Setting / retrieving a nodes properties
+A node's properties can be accessed and modified just as if the node was a hash:
+```ruby
+javad[:age] = 25
+puts javad[:age] # 25
+```
+
+## Creating a relationship between 2 nodes
+A relationship can be added between 2 nodes via the following syntax:
+```ruby
+javad.lives_in_to City_by_name("Chicago")
+```
+This returns a Cadet#Relationship object, which can then have its properties set just like a hash:
+```ruby
+new_relationship = javad.lives_in_to City_by_name("Chicago")
+new_relationship[:from] = "2012"
+new_relationship[:to]   = "ongoing"
+```
+
+Relationship creation can also be chained:
+```ruby
+Person_by_name("Javad").lives_in_to(City_by_name("Chicago")).city_of_to(State_by_name("Illinois")).state_of_to(Country_by_name("United States"))
+```
+
+
 Batch insert mode can be used by simply using Cadet::BatchInserter::Session instead of Cadet::Session!
 None of your code needs to change.

data/circle.yml

@@ -0,0 +1,3 @@
+machine:
+  ruby:
+    version: jruby

data/lib/cadet/batch_inserter/cadet_index/index.rb

@@ -0,0 +1,38 @@
+module Cadet
+  module BatchInserter
+    module CadetIndex
+      class Index
+        def initialize(lucene_index, name, type)
+          @name = name.to_sym
+          @type = type
+          @property_index = {}
+          @lucene_index = lucene_index
+        end
+
+        def add(node, property, value)
+          @property_index[property.to_sym] ||= {}
+          @property_index[property.to_sym][value] ||= []
+          @property_index[property.to_sym][value] << node
+        end
+
+        def get(property, value)
+          @property_index[property.to_sym] ||= {}
+          @property_index[property.to_sym][value] || []
+        end
+
+        def flush
+          lucene_node_index = @lucene_index.nodeIndex(@name, @type)
+
+          @property_index.each do |property, propval_to_node_mappings|
+            propval_to_node_mappings.each do |value, nodes|
+              nodes.each do |node|
+                lucene_node_index.add(node, {property.to_java_string => value})
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/cadet/batch_inserter/cadet_index/index_provider.rb

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

data/lib/cadet/batch_inserter/session.rb

@@ -4,7 +4,7 @@ module Cadet
 
       def initialize(db)
         @index_provider = CadetIndex::IndexProvider.new(db)
-        super db
+        @db = db
       end
 
       def close
@@ -12,8 +12,13 @@ module Cadet
         super
       end
 
-      def self.open(location, config = {})
-        new org.neo4j.unsafe.batchinsert.BatchInserters.inserter(location, config)
+      def self.open(location, &block)
+        new(org.neo4j.unsafe.batchinsert.BatchInserters.inserter(location)).tap do |session|
+          if block_given?
+            session.instance_exec(session, &block)
+            session.close
+          end
+        end
       end
 
       def constraint(label, property)
@@ -36,7 +41,7 @@ module Cadet
       end
 
       def get_transaction
-        Cadet::BatchInserter::Transaction.new(self)
+        Transaction.new(self)
       end
 
     end

data/lib/cadet/node.rb

@@ -51,13 +51,16 @@ module Cadet
     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)
+      case name
+        when /([A-z_]*)_to$/
+          self.class.class_eval "
+            def #{name}(value)
+              create_outgoing(value, :#{$1})
+            end
+          "
+          self.send(name, *args, &block)
+        else
+          raise NotImplementedError
       end
     end
 

data/lib/cadet/node_traverser.rb

@@ -29,5 +29,9 @@ module Cadet
       self.to_a == other.to_a
     end
 
+    def =~(other)
+      self.to_a.sort_by {|n| n.underlying.getId} == other.to_a.sort_by {|n| n.underlying.getId}
+    end
+
   end
 end

data/lib/cadet/path_traverser.rb

@@ -9,18 +9,8 @@ module Cadet
     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
+      @nodes.each do |n|
+        n.send(@direction, @type).each { |o| yield o }
       end
     end
 

data/lib/cadet/relationship.rb

@@ -10,8 +10,39 @@ module Cadet
       @underlying.getId == other_rel.underlying.getId
     end
 
+    def []= (property, value)
+      @underlying.setProperty(property.to_java_string, value)
+    end
+
+    def [] (property)
+      @underlying.getProperty(property.to_java_string)
+    end
+
     def get_other_node(node)
       Node.new @underlying.getOtherNode(node.underlying)
     end
+
+    def start_node
+      Node.new @underlying.getStartNode
+    end
+
+    def end_node
+      Node.new @underlying.getEndNode
+    end
+
+    def method_missing(name, *args, &block)
+      case name
+        when /([A-z_]*)_to$/
+          self.class.class_eval "
+            def #{name}(value)
+              end_node.create_outgoing(value, :#{$1})
+            end
+          "
+          self.send(name, *args, &block)
+        else
+          raise NotImplementedError
+      end
+    end
+
   end
 end

data/lib/cadet/session.rb

@@ -4,9 +4,18 @@ module Cadet
       @db = db
     end
 
-    def self.open(location)
-      new org.neo4j.graphdb.factory.GraphDatabaseFactory.new.newEmbeddedDatabase(location)
+    def self.open(location = nil, &block)
+      (location ?
+        new(org.neo4j.graphdb.factory.GraphDatabaseFactory.new.newEmbeddedDatabase(location)) :
+        new(org.neo4j.test.TestGraphDatabaseFactory.new.newImpermanentDatabase))
+      .tap do |session|
+        if block_given?
+          session.instance_exec(session, &block)
+          session.close
+        end
+      end
     end
+
     def close
       @db.shutdown
     end
@@ -31,11 +40,6 @@ module Cadet
       Transaction.new(self)
     end
 
-    def dsl(&block)
-      DSL.new(self).instance_exec(self, &block)
-      self
-    end
-
     def transaction
       tx = get_transaction
       begin
@@ -56,5 +60,26 @@ module Cadet
     def begin_tx
       @db.beginTx
     end
+
+    def method_missing(name, *args, &block)
+      case name
+        when /^([A-z_]*)_by_([A-z_]*)$/
+            self.class.class_eval "
+              def #{name}(value)
+                get_node :#{$1}, :#{$2}, value
+              end"
+            return self.send(name, *args, &block)
+
+        when /^create_([A-z_]*)$/
+          self.class.class_eval "
+            def #{name}(value, indexing_property = nil)
+              create_node :#{$1}, value, indexing_property
+            end"
+          return self.send(name, *args, &block)
+        else
+          raise NotImplementedError
+      end
+    end
+
   end
 end

data/lib/cadet/transaction.rb

@@ -7,21 +7,11 @@ module Cadet
       @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.9"
+  VERSION = "0.1.0"
 end

data/lib/cadet.rb

@@ -14,16 +14,12 @@ 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/batch_inserter/cadet_index/index_provider'
+require 'cadet/batch_inserter/cadet_index/index'
 
 require 'cadet/dynamic_relationshiptype'
 require 'cadet/dynamic_label'

data/spec/spec_helper.rb

@@ -1,52 +1 @@
 require 'cadet'
-require 'tmpdir'
-
-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

@@ -2,143 +2,31 @@ 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
+  it "should create an instance of cadet session, for test and normal sessions" do
+    Cadet::BatchInserter::Session.open(Dir.mktmpdir).class.should == Cadet::BatchInserter::Session
   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")
+  it "it should accept multiple relationships" do
+    at = Dir.mktmpdir
+    Cadet::BatchInserter::Session.open(at) do
+      self.class.should == Cadet::BatchInserter::Session
 
-      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
+      transaction do
+        javad   = Person_by_name("Javad")
+        chicago = City_by_name("Chicago")
+        houston = City_by_name("Houston")
 
-      expect {javad.outgoing(:lives_in).outgoing(:country)}.to raise_error(NotImplementedError)
+        javad.lives_in_to chicago
+        javad.lives_in_to houston
+      end
     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
+    Cadet::Session.open(at) 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")]
+        Person_by_name("Javad").outgoing(:lives_in).should =~ [City_by_name("Houston"), City_by_name("Chicago")]
+        Person_by_name("Javad").outgoing(:lives_in).should =~ [City_by_name("Chicago"), City_by_name("Houston")]
       end
     end
   end
-
-
 end

data/spec/unit/cadet_spec.rb

@@ -1,45 +1,103 @@
 require 'spec_helper'
+require 'tmpdir'
 
 describe Cadet do
 
-  it "should set a node's property" do
-    quick_normal_neo4j do |db|
-        javad = db.get_node :Person, :name, "Javad"
-        javad[:name].should == "Javad"
+  it "should create an instance of cadet session, for test and normal sessions" do
+    Cadet::Session.open(Dir.mktmpdir).class.should == Cadet::Session
+    Cadet::Session.open.class.should               == Cadet::Session #test session
+  end
+
+  it "should create an instance of cadet session, for test and normal sessions" do
+    Cadet::Session.open do |session|
+      self.should == session
+      self.class.should == Cadet::Session
+    end
+  end
+
+  it "should yield to transactions" do
+    has_block_ran = false
+    Cadet::Session.open do
+      transaction do
+        has_block_ran = true
+      end
+    end
+    has_block_ran.should == true
+  end
+
+  it "should return the same result between get_node and Label_by_prop" do
+    Cadet::Session.open do
+      transaction do
+        get_node(:Person, :name, "Javad").should == Person_by_name("Javad")
+      end
+    end
+  end
+
+  it "should set a node's label" do
+    Cadet::Session.open do
+      transaction do
+        javad = Person_by_name("Javad")
+        javad[:age] = 25
+
+        javad[:age].should == 25
+      end
     end
   end
 
   it "should set a node's label" do
-    quick_normal_neo4j do |db|
-        javad = db.get_node :Person, :name, "Javad"
+    Cadet::Session.open do
+      transaction do
+        javad = Person_by_name("Javad")
         javad.add_label :Member
+
         javad.labels.should == ["Person", "Member"]
+      end
     end
   end
 
   it "should add outgoing relationship's to a node" do
-    quick_normal_neo4j do |db|
-        javad = db.get_node :Person, :name, "Javad"
-        ellen = db.get_node :Person, :name, "Ellen"
+    Cadet::Session.open do
+      transaction do
+        javad = Person_by_name("Javad")
+        ellen = Person_by_name("Ellen")
 
         javad.outgoing(:knows) << ellen
 
         javad.outgoing(:knows).should == [ellen]
+      end
+    end
+  end
+
+  it "should add outgoing relationship's to a node" do
+    Cadet::Session.open do
+      transaction do
+        javad = Person_by_name("Javad")
+        ellen = Person_by_name("Ellen")
+
+        javad.knows_to ellen
+
+        javad.outgoing(:knows).should == [ellen]
+      end
     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")]
+    Cadet::Session.open do
+      transaction do
+        javad   = Person_by_name("Javad")
+        chicago = City_by_name("Chicago")
+        houston = City_by_name("Houston")
+
+        javad.lives_in_to chicago
+        javad.lives_in_to houston
+        javad.outgoing(:lives_in).should == [chicago, houston]
+      end
     end
   end
 
   it "should allow for outgoing to be chained" do
-    quick_test_neo4j do |db|
-      db.dsl do |db|
+    Cadet::Session.open do
+      transaction do
         javad       = Person_by_name  "Javad"
         ellen       = Person_by_name  "Ellen"
         trunkclub   = Company_by_name "Trunkclub"
@@ -48,11 +106,11 @@ describe Cadet do
         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.works_at_to       trunkclub
+        trunkclub.located_in_to chicago
+        javad.lives_in_to       chicago
+        ellen.lives_in_to       chicago
+        chicago.country_to      us
 
         javad.outgoing(:works_at).outgoing(:located_in).outgoing(:country).should == [us]
         chicago.incoming(:located_in).incoming(:works_at).should == [javad]
@@ -62,12 +120,12 @@ describe Cadet do
   end
 
   it "should allow for node relationship's to be accessed" do
-    quick_test_neo4j do |db|
-      db.dsl do |db|
+    Cadet::Session.open do
+      transaction do
         javad       = Person_by_name  "Javad"
         ellen       = Person_by_name  "Ellen"
-        javad.outgoing(:knows) << ellen
-        javad.incoming(:also_knows) << ellen
+        javad.knows_to      ellen
+        ellen.also_knows_to javad
 
         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]
@@ -75,28 +133,92 @@ describe Cadet do
     end
   end
 
+  # when using an impermanent database, neo4j is writing to disk in this test (it shouldnt).
+  # so using a tmp dir instead
+  it "should enforce unique constraints" do
+    expect {
+      Cadet::Session.open(Dir.mktmpdir) do
+        transaction do
+          constraint :Person, :name
+        end
+        transaction do
+          create_node(:Person, {name: "Javad"})
+          create_node(:Person, {name: "Javad"})
+        end
+      end
+    }.to raise_error(org.neo4j.graphdb.ConstraintViolationException)
+  end
+
+  it "it should allow =~ to compare a set of nodes to a NodeRelationships, indifferent to order" do
+    Cadet::Session.open do
+      transaction do
+        javad   = Person_by_name "Javad"
+        chicago = City_by_name   "Chicago"
+        houston = City_by_name   "Houston"
+        memphis = City_by_name   "Memphis"
+
+        javad.lives_in_to chicago
+        javad.lives_in_to houston
+
+        javad.outgoing(:lives_in).send("=~", [houston, chicago]).should              == true
+        javad.outgoing(:lives_in).send("=~", [chicago, houston]).should              == true
+        javad.outgoing(:lives_in).send("=~", [chicago, houston, memphis]).should_not == true
+
+        javad.outgoing(:lives_in).should     =~ [chicago, houston]
+        javad.outgoing(:lives_in).should     =~ [houston, chicago]
+        javad.outgoing(:lives_in).should_not =~ [houston, chicago, memphis]
+
+        javad.outgoing(:lives_in).should     == [chicago, houston]
+        javad.outgoing(:lives_in).should_not == [houston, chicago]
+      end
+    end
+  end
+
+  it "should return the relationship created when ..._to is called on a node" do
+    Cadet::Session.open do
+      transaction do
+        javad   = Person_by_name "Javad"
+        houston = City_by_name   "Houston"
+
+        rel = javad.home_city_to(houston)
+
+        rel.class.should == Cadet::Relationship
 
-  xit "should enforce unique constraints" do
-    test_neo4j do |db|
-      db.transaction do
-        db.constraint :Person, :name
+        rel.start_node.should == javad
+        rel.end_node.should == houston
+
+        javad.outgoing(:home_city).should == [houston]
       end
-      db.transaction do
-        db.create_node :Person, :name, "Javad"
+    end
+  end
 
-        expect { db.create_node :Person, :name, "Javad" }.to raise_error(org.neo4j.graphdb.ConstraintViolationException)
+  it "should allow chaining of relationship creation" do
+    Cadet::Session.open do
+      transaction do
+        javad   = Person_by_name "Javad"
+        houston = City_by_name   "Houston"
+        texas   = State_by_name  "Texas"
+
+        javad.home_city_to(houston).city_of_to(texas)
+
+        javad.outgoing(:home_city).should == [houston]
+        houston.outgoing(:city_of).should == [texas]
       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")
+  it "should return the relationship created when ..._to is called on a node" do
+    Cadet::Session.open do
+      transaction do
+        javad   = Person_by_name "Javad"
+        houston = City_by_name   "Houston"
 
-        Person_by_name("Javad").outgoing(:lives_in).should == [City_by_name("Chicago")]
+        rel = javad.home_city_to(houston)
+        rel[:birth_year]        =  1988
+        rel[:birth_year].should == 1988
       end
     end
   end
 
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cadet
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
 platform: java
 authors:
 - Javad Karabi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-03-01 00:00:00.000000000 Z
+date: 2014-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -47,18 +47,17 @@ files:
 - .gitignore
 - .travis.yml
 - Gemfile
-- Gemfile.lock
 - README.md
 - Rakefile
 - cadet.gemspec
+- circle.yml
 - lib/cadet.rb
+- lib/cadet/batch_inserter/cadet_index/index.rb
+- lib/cadet/batch_inserter/cadet_index/index_provider.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
@@ -68,7 +67,6 @@ files:
 - 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

data/Gemfile.lock

@@ -1,26 +0,0 @@
-PATH
-  remote: .
-  specs:
-    cadet (0.0.8-java)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    diff-lcs (1.2.5)
-    rake (10.1.1)
-    rspec (2.14.1)
-      rspec-core (~> 2.14.0)
-      rspec-expectations (~> 2.14.0)
-      rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.7)
-    rspec-expectations (2.14.5)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.6)
-
-PLATFORMS
-  java
-
-DEPENDENCIES
-  cadet!
-  rake
-  rspec

data/lib/cadet/cadet_index/index.rb

@@ -1,33 +0,0 @@
-module Cadet
-  module CadetIndex
-    class Index
-      def initialize(lucene_index, name, type)
-        @name = name
-        @type = type
-        @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_java_string => value})
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/cadet/cadet_index/index_provider.rb

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

data/lib/cadet/dsl.rb

@@ -1,28 +0,0 @@
-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_]*)$/
-          self.class.class_eval "
-            def #{name}(value, indexing_property = nil)
-              @db.create_node :#{$1}, value, indexing_property
-            end"
-          return self.send(name, *args, &block)
-        else
-          return @db.send(name, *args, &block)
-      end
-    end
-
-  end
-end

data/lib/cadet/test/session.rb

@@ -1,11 +0,0 @@
-module Cadet
-  module Test
-    class Session < Cadet::Session
-
-      def self.open
-        new org.neo4j.test.TestGraphDatabaseFactory.new.newImpermanentDatabase
-      end
-
-    end
-  end
-end