cadet 0.0.1-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: abffa401951196b50b8baa617c43be24ceb3c115
+  data.tar.gz: 7b9a1a911568427d585a7c6771ee1a8bd8bc9402
+SHA512:
+  metadata.gz: 1415ad1dfcd2023a62c3c16c677e0c2f56ae7c5fa923ddbcd939834c57b8f665c7da5993648e996bef4393ff32888670de2e7d42cd82cda22042382055d4ed18
+  data.tar.gz: 1b75ffe54d7e79b00746f8c4e1fed335c80bef6f9c0e9a5e56577a9cac3a4410a7a05568b09d570068017139e7cfb06c7bff940c3a2e66622582d8e573b17763

data/.gitignore

@@ -0,0 +1 @@
+.bundle

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    cadet (0.0.1-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.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  cadet!
+  rake
+  rspec

data/README.md

@@ -0,0 +1,59 @@
+new! support for batchinsert mode!
+just open the database with Cadet::BatchInserter::BatchInserter.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.
+
+1. Gemfile
+
+    ```ruby
+    gem 'cadet', git: 'https://github.com/karabijavad/cadet'
+    ```
+2. ``` bundle install ```
+3. cadet-example.rb
+
+    ```ruby
+
+    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
+      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
+    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
+    
+      end
+    end
+    
+    #close the database
+    db.close()
+
+
+
+    ```
+4. ```bundle exec ruby```

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec

data/cadet.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+require "cadet/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cadet"
+  s.version     = Cadet::VERSION
+  s.platform    = "java"
+  s.authors     = "Javad Karabi"
+  s.email       = "karabijavad@gmail.com"
+  s.homepage    = "https://github.com/karabijavad/cadet"
+  s.summary     = "ruby wrapper to Neo4j java API"
+  s.description = "ruby wrapper to Neo4j java API"
+  s.license     = 'MIT'
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+end

data/lib/cadet/batch_inserter/batch_inserter.rb

@@ -0,0 +1,50 @@
+module Cadet
+  module BatchInserter
+    class BatchInserter < Cadet::Session
+      include_package "org.neo4j.unsafe.batchinsert"
+      include_package "org.neo4j.index.impl.lucene"
+
+      def initialize(db)
+        @db = db
+        #@index_provider = LuceneBatchInserterIndexProviderNewImpl.new(db)
+        @index_provider = Cadet::IndexProvider.new(db)
+      end
+
+      def close
+        @index_provider.shutdown
+        super
+      end
+
+      def self.open(location)
+        new BatchInserters.inserter(location)
+      end
+
+      def transaction
+        yield
+      end
+
+      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)
+        index = @index_provider.nodeIndex label, {"type" => "exact"}
+        result = org.neo4j.helpers.collection.IteratorUtil.firstOrNull(index.get(property, value))
+        if result
+          return Cadet::BatchInserter::Node.new(@db, result)
+        else
+          return nil
+        end
+      end
+
+      def create_node_with(label, props={})
+        n = Cadet::BatchInserter::Node.make @db, props, label
+
+        index = @index_provider.nodeIndex label, {"type" => "exact"}
+        index.add(n.node, props)
+        n
+      end
+    end
+  end
+end

data/lib/cadet/batch_inserter/node.rb

@@ -0,0 +1,25 @@
+module Cadet
+  module BatchInserter
+    class Node < Cadet::Node
+      attr_accessor :node
+
+      def initialize(db, node)
+        @db = db
+        @node = node
+      end
+
+      def self.make(db, props = {}, label = '')
+        node = db.createNode props, org.neo4j.graphdb.DynamicLabel.label(label)
+        new db, node
+      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)
+      end
+    end
+  end
+end

data/lib/cadet/index_provider/index_provider.rb

@@ -0,0 +1,46 @@
+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/node.rb

@@ -0,0 +1,54 @@
+module Cadet
+  class Node
+    attr_accessor :node
+    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))
+    end
+    def add_label(label)
+      @node.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
+    end
+
+    def get_single_relationship(type, dir="both")
+      @node.getSingleRelationship DynamicRelationshipType.withName(type), @directions[dir]
+    end
+
+    def get_all_relationships
+      @node.getRelationships()
+    end
+    def get_all_relationships_of_type(type)
+      @node.getRelationships(DynamicRelationshipType.withName(type))
+    end
+    def get_all_relationships_of_type_and_dir(type, dir)
+      @node.getRelationships DynamicRelationshipType.withName(type), @directions[dir]
+    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
+    end
+  end
+end

data/lib/cadet/session.rb

@@ -0,0 +1,83 @@
+module Cadet
+  class Session
+    include_package "org.neo4j.graphdb"
+    include_package "org.neo4j.graphdb.factory"
+    include_package "org.neo4j.unsafe.batchinsert"
+
+    def initialize(db)
+      @db = db
+    end
+
+    def self.open(location)
+      new GraphDatabaseFactory.new.newEmbeddedDatabase(location)
+    end
+    def close
+      @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
+      n.add_label label
+      n.set_properties props
+      n
+    end
+
+    def get_node_by_id(id)
+      Cadet::Node.new @db.getNodeById(id)
+    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)
+      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
+    end
+
+    def transaction
+      tx = @db.beginTx
+      begin
+        yield tx
+        tx.success
+      ensure
+        tx.close
+      end
+    end
+
+    def constraint(label, property)
+      @db.schema
+        .constraintFor(DynamicLabel.label(label))
+        .assertPropertyIsUnique(property)
+        .create
+    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)
+      end
+      n
+    end
+
+    def traverser
+      Cadet::Traversal::Description.new @db.traversalDescription
+    end
+
+  end
+end

data/lib/cadet/traversal/description.rb

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,15 @@
+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

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

data/lib/cadet/version.rb

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

data/lib/cadet.rb

@@ -0,0 +1,30 @@
+require 'java'
+
+["concurrentlinkedhashmap-lru-1.3.1.jar",
+"geronimo-jta_1.1_spec-1.1.1.jar",
+"lucene-core-3.6.2.jar",
+"neo4j-cypher-2.0.0.jar",
+"neo4j-cypher-commons-2.0.0.jar",
+"neo4j-cypher-compiler-1.9-2.0.0.jar",
+"neo4j-cypher-compiler-2.0-2.0.0.jar",
+"neo4j-graph-algo-2.0.0.jar",
+"neo4j-graph-matching-2.0.0.jar",
+"neo4j-jmx-2.0.0.jar",
+"neo4j-kernel-2.0.0.jar",
+"neo4j-lucene-index-2.0.0.jar",
+"neo4j-shell-2.0.0.jar",
+"neo4j-udc-2.0.0.jar",
+"org.apache.servicemix.bundles.jline-0.9.94_1.jar",
+"parboiled-core-1.1.6.jar",
+"parboiled-scala_2.10-1.1.6.jar",
+"scala-library-2.10.3.jar",
+"server-api-2.0.0.jar"].each { |file| require "neo4j/#{file}" }
+
+require 'cadet/session'
+require 'cadet/node'
+require 'cadet/traversal/description'
+require 'cadet/traversal/evaluator'
+require 'cadet/traversal/path'
+require 'cadet/batch_inserter/batch_inserter'
+require 'cadet/batch_inserter/node'
+require 'cadet/index_provider/index_provider'

data/lib/neo4j/README.txt

@@ -0,0 +1,16 @@
+Neo4j Libraries
+=======================================
+
+Neo4j core java libraries. These can be used for embedded development,
+but are also required for operation of the server.
+
+Copy them, link them, or include them on the class path, but do **not**
+delete them, because that will make the server sad. 
+
+For more information, see the [component documentation](/doc/components.txt)
+
+References
+----------
+
+* [component documentation](/doc/components.txt) -- local documentation
+* [Neo4j Components](http://components.neo4j.org) -- comprehensive online docs

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'cadet'

data/spec/unit/cadet_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Cadet do
+
+  it "should create a node, (and also test that transaction works in the process)" do
+    db = Cadet::Session.open("./tmp")
+    db.transaction do
+      n = db.create_node
+    end
+    db.close
+  end
+
+  it "should _not_ create a node, as we are not in a transaction" do
+    db = Cadet::Session.open("./tmp")
+    expect { db.create_node }.to raise_error(org.neo4j.graphdb.NotInTransactionException)
+    db.close
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: cadet
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: java
+authors:
+- Javad Karabi
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-01-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+description: ruby wrapper to Neo4j java API
+email: karabijavad@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- cadet.gemspec
+- 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/node.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
+- lib/neo4j/geronimo-jta_1.1_spec-1.1.1.jar
+- lib/neo4j/lucene-core-3.6.2.jar
+- lib/neo4j/neo4j-cypher-2.0.0.jar
+- lib/neo4j/neo4j-cypher-commons-2.0.0.jar
+- lib/neo4j/neo4j-cypher-compiler-1.9-2.0.0.jar
+- lib/neo4j/neo4j-cypher-compiler-2.0-2.0.0.jar
+- lib/neo4j/neo4j-graph-algo-2.0.0.jar
+- lib/neo4j/neo4j-graph-matching-2.0.0.jar
+- lib/neo4j/neo4j-jmx-2.0.0.jar
+- lib/neo4j/neo4j-kernel-2.0.0.jar
+- lib/neo4j/neo4j-lucene-index-2.0.0.jar
+- lib/neo4j/neo4j-shell-2.0.0.jar
+- lib/neo4j/neo4j-udc-2.0.0.jar
+- lib/neo4j/org.apache.servicemix.bundles.jline-0.9.94_1.jar
+- lib/neo4j/parboiled-core-1.1.6.jar
+- lib/neo4j/parboiled-scala_2.10-1.1.6.jar
+- lib/neo4j/scala-library-2.10.3.jar
+- lib/neo4j/server-api-2.0.0.jar
+- spec/spec_helper.rb
+- spec/unit/cadet_spec.rb
+homepage: https://github.com/karabijavad/cadet
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.2.1
+signing_key:
+specification_version: 4
+summary: ruby wrapper to Neo4j java API
+test_files: []