cadet 0.0.1-java → 0.0.2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: abffa401951196b50b8baa617c43be24ceb3c115
-  data.tar.gz: 7b9a1a911568427d585a7c6771ee1a8bd8bc9402
+  metadata.gz: 8c1be93b0e3ce909a38fe4bf95a091ed785e906a
+  data.tar.gz: ea7e2b5cc5fbb322d711cb48c8173fa5e9ff1699
 SHA512:
-  metadata.gz: 1415ad1dfcd2023a62c3c16c677e0c2f56ae7c5fa923ddbcd939834c57b8f665c7da5993648e996bef4393ff32888670de2e7d42cd82cda22042382055d4ed18
-  data.tar.gz: 1b75ffe54d7e79b00746f8c4e1fed335c80bef6f9c0e9a5e56577a9cac3a4410a7a05568b09d570068017139e7cfb06c7bff940c3a2e66622582d8e573b17763
+  metadata.gz: e7af7bb435086ef5d0aac9cfea1a0359e820f6fbdf0d865eec104d8a84526ccfd7d382eed6812f9569266f01a7aefffa2c44a5bfdef5c541648d020c3daf31e8
+  data.tar.gz: da1b888cb8d74039123fae49821bddd657ea4eb0c90146eee25d4e1572a49a2c37d05e4fc267fdf2037ab709ddf441e3a81691fa0b4b53940ac3716477bf3504

data/README.md

@@ -1,5 +1,6 @@
-new! support for batchinsert mode!
-just open the database with Cadet::BatchInserter::BatchInserter.open() instead of Cadet::Session.open()!
+- 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.
 
 super simple. you dont even need to download neo4j.
@@ -7,7 +8,7 @@ super simple. you dont even need to download neo4j.
 1. Gemfile
 
     ```ruby
-    gem 'cadet', git: 'https://github.com/karabijavad/cadet'
+    gem 'cadet'
     ```
 2. ``` bundle install ```
 3. cadet-example.rb
@@ -16,40 +17,32 @@ super simple. you dont even need to download neo4j.
 
     require 'cadet'
     require 'yaml'
-    
+
     data = YAML.load_file('legislators-current.yaml')
 
-    #open the database, db is now used to interact with the database    
+    #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
-      begin
-        #create unique constrains on each of these Labels' 'name' property
-        ["Legislator", "Party", "Gender", "State"].each {|v| db.constraint v, "name"}
-      rescue Exception => e # ignore, probably just saying the constraint already exists
-      end
+      ["Legislator", "Party", "Gender", "State"].each {|v| db.constraint v, "name"}
     end
-    
-    
+
     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(property, value) will find a node labeled 'X', with a property of key 'property', and value 'value'
-        #if the node is not found, it will create it and return it.
-        l = db.get_a_Legislator "name", leg["name"]["official_full"] || "no name"
-        p = db.get_a_Party "name", leg["terms"].first["party"]
-        g = db.get_a_Gender "name", leg["bio"]["gender"]
-        s = db.get_a_State "name", leg["terms"].first["state"]
-    
-        # automatically create relationships, where the relationship type is the method's name
-        l.party_to p
-        l.gender_to g
-        l.represents_to s
-    
+        #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"]
+
+        l.outgoing(:party)      << p
+        l.outgoing(:gender)     << g
+        l.outgoing(:represents) << s
       end
     end
-    
+
     #close the database
     db.close()
 

data/lib/cadet/batch_inserter/batch_inserter.rb

@@ -1,13 +1,14 @@
 module Cadet
   module BatchInserter
-    class BatchInserter < Cadet::Session
+    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 = LuceneBatchInserterIndexProviderNewImpl.new(db)
-        @index_provider = Cadet::IndexProvider.new(db)
+        @index_provider = Cadet::CadetIndex::IndexProvider.new(db)
       end
 
       def close
@@ -25,24 +26,24 @@ module Cadet
 
       def constraint(label, property)
         index = @index_provider.nodeIndex label, {"type" => "exact"}
-        index.setCacheCapacity property, 100000
       end
 
-      def find_node_by_label_and_property(label, property, value)
+      def find_node(label, property, value)
         index = @index_provider.nodeIndex label, {"type" => "exact"}
-        result = org.neo4j.helpers.collection.IteratorUtil.firstOrNull(index.get(property, value))
+        result = IteratorUtil.firstOrNull(index.get(property, value))
         if result
-          return Cadet::BatchInserter::Node.new(@db, result)
+          return Node.new(result, @db)
         else
           return nil
         end
       end
 
-      def create_node_with(label, props={})
-        n = Cadet::BatchInserter::Node.make @db, props, label
+      def create_node(label, prop, value)
+        node = @db.createNode props, DynamicLabel.label(label)
+        n = Node.new node, @db
 
         index = @index_provider.nodeIndex label, {"type" => "exact"}
-        index.add(n.node, props)
+        index.add(n.underlying, prop, value)
         n
       end
     end

data/lib/cadet/batch_inserter/node.rb

@@ -1,24 +1,17 @@
 module Cadet
   module BatchInserter
     class Node < Cadet::Node
-      attr_accessor :node
-
-      def initialize(db, node)
-        @db = db
-        @node = node
+      include_package "org.neo4j.graphdb"
+      def create_outgoing(to, type, properties = {})
+        rel_type = DynamicRelationshipType.withName(type)
+        @db.createRelationship(@underlying, to.underlying, rel_type, properties)
       end
 
-      def self.make(db, props = {}, label = '')
-        node = db.createNode props, org.neo4j.graphdb.DynamicLabel.label(label)
-        new db, node
+      def set_property(prop, val)
+        @db.setNodeProperties @underlying, {prop => val}
       end
 
-      def create_outgoing(to, type, properties = {})
-        rel_type = org.neo4j.graphdb.DynamicRelationshipType.withName(type)
-        @db.createRelationship(@node, to.node, rel_type, properties)
-      end
-      def set_properties(props)
-        @db.setNodeProperties(@node, props)
+      def get_relationships(direction, type)
       end
     end
   end

data/lib/cadet/cadet_index/index.rb

@@ -0,0 +1,28 @@
+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, prop, value)
+        @index[prop] ||= {}
+        @index[prop][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 => value})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cadet/cadet_index/index_provider.rb

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

data/lib/cadet/node.rb

@@ -1,54 +1,37 @@
 module Cadet
-  class Node
-    attr_accessor :node
+  class Node < PropertyContainer
+    attr_accessor :underlying
     include_package "org.neo4j.graphdb"
 
-    directions = {
-      "in"   => Direction[0],
-      "out"  => Direction[1],
-      "both" => Direction[2]
-    }
-
-    def initialize(node)
-      @node = node
-    end
-    def create_outgoing(to, type)
-      @node.createRelationshipTo(to.node, DynamicRelationshipType.withName(type))
+    def initialize(node, db = nil)
+      @db = db
+      @underlying = node
     end
+
     def add_label(label)
-      @node.addLabel(DynamicLabel.label(label))
+      @underlying.addLabel(DynamicLabel.label(label))
       self
     end
 
-    def method_missing(name, *args)
-      if name.to_s.end_with? "="
-        set_property name.to_s.gsub(/=$/, ''), args[0]
-      elsif name.to_s.end_with? "_to"
-        create_outgoing args[0], name.to_s.gsub(/_to$/, '')
-      end
+    def set_property(property, value)
+      @underlying.setProperty(property, value)
     end
-
-    def get_single_relationship(type, dir="both")
-      @node.getSingleRelationship DynamicRelationshipType.withName(type), @directions[dir]
+    def get_property(property)
+      @underlying.getProperty(property)
     end
 
-    def get_all_relationships
-      @node.getRelationships()
+    def get_relationships(direction, type)
+      @underlying.getRelationships(direction, type)
     end
-    def get_all_relationships_of_type(type)
-      @node.getRelationships(DynamicRelationshipType.withName(type))
+    def create_outgoing(to, type)
+      @underlying.createRelationshipTo(to.underlying, DynamicRelationshipType.withName(type))
     end
-    def get_all_relationships_of_type_and_dir(type, dir)
-      @node.getRelationships DynamicRelationshipType.withName(type), @directions[dir]
+    def outgoing(type)
+      Cadet::RelationshipTraverser.new(self, Direction::OUTGOING, type)
     end
-
-    def set_property(property, value)
-      @node.setProperty(property, value)
-    end
-    def set_properties(props)
-      props.each do |k,v|
-        set_property(k.to_s, v)
-      end
+    def incoming(type)
+      Cadet::RelationshipTraverser.new(self, Direction::INCOMING, type)
     end
+
   end
 end

data/lib/cadet/property_container.rb

@@ -0,0 +1,13 @@
+module Cadet
+  class PropertyContainer #subclasses must implement set_property, get_property
+
+    def []= (property, value)
+      set_property property, value
+    end
+
+    def [] (property)
+      get_property property
+    end
+
+  end
+end

data/lib/cadet/relationship_traverser.rb

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

data/lib/cadet/session.rb

@@ -3,6 +3,7 @@ module Cadet
     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
@@ -15,31 +16,25 @@ module Cadet
       @db.shutdown
     end
 
-    def create_empty_node
-      Cadet::Node.new @db.createNode
-    end
-
-    def create_node_with(label, props = {})
-      n = Cadet::Node.new @db.createNode
+    def create_node(label, property, value)
+      n = Node.new @db.createNode
       n.add_label label
-      n.set_properties props
+      n.set_property property, value
       n
     end
 
-    def get_node_by_id(id)
-      Cadet::Node.new @db.getNodeById(id)
+    def find_node(label, key, value)
+      node = IteratorUtil.firstOrNull @db.findNodesByLabelAndProperty(DynamicLabel.label(label), key, value)
+      node ? Node.new(node) : null
     end
 
-    def find_nodes_by_label_and_property(label, key, value)
-      result = []
-      @db.findNodesByLabelAndProperty(DynamicLabel.label(label), key, value).each do |node|
-        result << Cadet::Node.new(node)
+    def goc_node(label, property, value)
+      n = find_node label, property, value
+      if n.nil?
+        n = create_node label, property, value
+        n[property] = value
       end
-      result
-    end
-    def find_node_by_label_and_property(label, key, value)
-      node = org.neo4j.helpers.collection.IteratorUtil.firstOrNull @db.findNodesByLabelAndProperty(DynamicLabel.label(label), key, value)
-      node ? Cadet::Node.new(node) : null
+      n
     end
 
     def transaction
@@ -60,23 +55,9 @@ module Cadet
     end
 
     def method_missing(name, *args)
-      if match = /get_a_([A-Z][A-Za-z]*)$/.match(name.to_s)
-        return get_a_node match.captures.first, args[0], args[1]
-      end
-    end
-
-    def get_a_node(label, property, value, default_values = {})
-      n = find_node_by_label_and_property(label, property, value)
-      if n.nil?
-        h = {}
-        h[property] = value
-        n = create_node_with label, h.merge(default_values)
+      if match = /^get_a_([A-Z][A-Za-z]*)_by_([A-z]*)/.match(name)
+        return goc_node match.captures[0], match.captures[1], args[0]
       end
-      n
-    end
-
-    def traverser
-      Cadet::Traversal::Description.new @db.traversalDescription
     end
 
   end

data/lib/cadet/version.rb

@@ -1,3 +1,3 @@
 module Cadet
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/cadet.rb

@@ -21,10 +21,10 @@ require 'java'
 "server-api-2.0.0.jar"].each { |file| require "neo4j/#{file}" }
 
 require 'cadet/session'
+require 'cadet/property_container'
 require 'cadet/node'
-require 'cadet/traversal/description'
-require 'cadet/traversal/evaluator'
-require 'cadet/traversal/path'
+require 'cadet/relationship_traverser'
 require 'cadet/batch_inserter/batch_inserter'
 require 'cadet/batch_inserter/node'
-require 'cadet/index_provider/index_provider'
+require 'cadet/cadet_index/index_provider'
+require 'cadet/cadet_index/index'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cadet
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: java
 authors:
 - Javad Karabi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-01-30 00:00:00.000000000 Z
+date: 2014-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -53,12 +53,12 @@ files:
 - lib/cadet.rb
 - lib/cadet/batch_inserter/batch_inserter.rb
 - lib/cadet/batch_inserter/node.rb
-- lib/cadet/index_provider/index_provider.rb
+- lib/cadet/cadet_index/index.rb
+- lib/cadet/cadet_index/index_provider.rb
 - lib/cadet/node.rb
+- lib/cadet/property_container.rb
+- lib/cadet/relationship_traverser.rb
 - lib/cadet/session.rb
-- lib/cadet/traversal/description.rb
-- lib/cadet/traversal/evaluator.rb
-- lib/cadet/traversal/path.rb
 - lib/cadet/version.rb
 - lib/neo4j/README.txt
 - lib/neo4j/concurrentlinkedhashmap-lru-1.3.1.jar
@@ -102,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.2.1
+rubygems_version: 2.2.0
 signing_key:
 specification_version: 4
 summary: ruby wrapper to Neo4j java API

data/lib/cadet/index_provider/index_provider.rb

@@ -1,46 +0,0 @@
-module Cadet
-  class IndexProvider
-    def initialize(db)
-      @db = db
-      @indexes = {}
-      @lucene_index = org.neo4j.index.impl.lucene.LuceneBatchInserterIndexProviderNewImpl.new(db)
-    end
-    def nodeIndex(name, type)
-      @indexes[name] ||= Cadet::Index.new(@lucene_index, name, type)
-    end
-    def shutdown
-      @indexes.each do |name, index|
-        index.flush
-      end
-    end
-  end
-end
-
-module Cadet
-  class Index
-    def initialize(lucene_index, name, type)
-      @name = name
-      @type = type
-      @index = {}
-      @lucene_index = lucene_index
-    end
-    def setCacheCapacity(property, capacity)
-    end
-    def add(node, prop)
-      @index[prop.first[0]] ||= {}
-      @index[prop.first[0]][prop.first[1]] = 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 => value})
-        end
-      end
-    end
-  end
-end

data/lib/cadet/traversal/description.rb

@@ -1,30 +0,0 @@
-module Cadet
-  module Traversal
-    class Description
-      include_package "org.neo4j.graphdb"
-
-      def initialize(description)
-        @description = description
-        self
-      end
-
-      def relationships(relationship_names)
-        relationship_names.each do |rel_name|
-          @description = @description.relationships DynamicRelationshipType.withName(rel_name)
-        end
-        self
-      end
-
-      def evaluator(evaluator)
-        @description = @description.evaluator evaluator.evaluator
-        self
-      end
-
-      def traverse(start_node)
-        @description.traverse(start_node.node).map do |path|
-          Cadet::Traversal::Path.new path
-        end
-      end
-    end
-  end
-end

data/lib/cadet/traversal/evaluator.rb

@@ -1,15 +0,0 @@
-module Cadet
-  module Traversal
-    class Evaluator
-      include_package "org.neo4j.graphdb.traversal"
-
-      def initialize
-        @evaluator = Evaluators.toDepth(2)
-      end
-
-      def evaluator
-        @evaluator
-      end
-    end
-  end
-end

data/lib/cadet/traversal/path.rb

@@ -1,12 +0,0 @@
-module Cadet
-  module Traversal
-    class Path
-      def initialize(path)
-        @path = path
-      end
-      def path
-        @path
-      end
-    end
-  end
-end