pacer 0.9.1.1-java → 1.0.0-java

data/.autotest

@@ -1,4 +1,7 @@
-require 'autotest/bundler'
+require 'autotest/growl'
+
+Autotest::Growl::clear_terminal = false
+
 Autotest.add_hook(:initialize) {|at|
   at.add_exception %r{\.git}  # ignore Version Control System
   at.add_exception %r{/\.}  # ignore any file that starts with a . (dot)

data/.gitignore

@@ -11,6 +11,7 @@ doc
 # bundler
 .bundle
 Gemfile.lock
+Gemfile
 
 # jeweler generated
 pkg
@@ -24,3 +25,6 @@ tmp
 lib/*.jar
 jdex.log
 bin
+.jitcache
+coverage/*
+dex.log

data/.rspec

@@ -1 +1 @@
-#--format d
+--format d

data/Gemfile-dev

@@ -0,0 +1,33 @@
+# A sample Gemfile
+source "http://rubygems.org"
+
+gemspec
+
+group :development do
+  gem 'rspec', '~> 2.10.0'
+  gem 'rr', '~> 1.0'
+  gem 'simplecov'
+  gem 'yard'
+  gem 'rake'
+
+  # pacer-* gems are required for testing pacer.
+  # If you have the gem repos cloned locally, we'll use them.
+  #
+  libs = [
+    ['pacer-neo4j', '2.0.0.pre'],
+    ['pacer-orient', '2.0.0.pre'],
+    ['pacer-dex', '2.0.0.pre']
+  ] 
+  libs.each do |lib, version|
+    if File.directory? "../#{lib}"
+      gem lib, :path => "../#{lib}" 
+    end
+  end
+
+   
+  gem 'autotest-standalone'
+  gem 'autotest-growl'
+  gem 'pry'
+  gem 'awesome_print', '0.4.0'
+end
+

data/Gemfile-release

@@ -0,0 +1,4 @@
+# A sample Gemfile
+source "http://rubygems.org"
+
+gemspec

data/README.md

@@ -2,9 +2,18 @@
 
 Pacer is a JRuby library that enables very expressive graph traversals.
 
-It currently supports 2 major graph database: [Neo4j](http://neo4j.org) and [Dex](http://www.sparsity-technologies.com/dex) using the [Tinkerpop](http://tinkerpop.com) graphdb stack. Plus there's a very convenient in-memory graph called TinkerGraph which is part of [Blueprints](http://blueprints.tinkerpop.com).
-
-Pacer allows you to create, modify and traverse graphs using very fast and memory efficient stream processing thanks to the very cool [Pipes](http://pipes.tinkerpop.com) library. That also means that almost all processing is done in pure Java, so when it comes the usual Ruby expressiveness vs. speed problem, you can have your cake and eat it too, it's very fast!
+It currently supports 2 major graph database: [Neo4j](http://neo4j.org)
+and [Dex](http://www.sparsity-technologies.com/dex) using the
+[Tinkerpop](http://tinkerpop.com) graphdb stack. Plus there's a very
+convenient in-memory graph called TinkerGraph which is part of
+[Blueprints](http://blueprints.tinkerpop.com).
+
+Pacer allows you to create, modify and traverse graphs using very fast
+and memory efficient stream processing thanks to the very cool
+[Pipes](http://pipes.tinkerpop.com) library. That also means that almost
+all processing is done in pure Java, so when it comes the usual Ruby
+expressiveness vs. speed problem, you can have your cake and eat it too,
+it's very fast!
 
 ## Mailing List
 
@@ -22,6 +31,14 @@ If you like, you can also use the documentation locally via
   gem install yard
   yard server
 
+## JRuby 1.7 Required
+
+As of Pacer 1.0.0, [JRuby](http://jruby.org/) 1.7 is required because it is both faster and
+fixes some problems that I previously had to work around in Pacer.
+
+The easiest way (ie. the way I do it) to get the most recent version of
+JRuby is to use [RVM](https://rvm.io/)
+
 ## Installation
 
 The easiest way to get Pacer is `gem install pacer`.
@@ -29,12 +46,9 @@ The easiest way to get Pacer is `gem install pacer`.
 If you want to hack on Pacer, you'll need to have
 [maven](http://maven.apache.org/) installed (I recommend `brew install
 maven`), then use `rake jar` to set up maven's pom.xml file and run the
-maven build script.
-
-*Note* Pacer currently relies on some features that are not yet in the
-main Pipes repo. You will need to build the `develop` branch of [my pipes
-repo](https://github.com/pangloss/pipes) by cloning it and running `mvn
-clean install`.
+maven build script. Then `rake gemfile_devel` to set up a default
+Gemfile that you can customize as needed to include dependencies
+to the various pacer-... graphs you want the test suite to run against.
 
 ## Graph Database Support
 
@@ -185,3 +199,7 @@ A great introduction to the underlying concept of pipes can be found in Marko Ro
 ## Test Coverage
 
 I'm aiming for 100% test coverage in Pacer and am currently nearly there in the core classes, but there is a way to go with the filter, transform and side effect route modules. Open coverage/index.html to see the current state of test coverage. And of course contributions would be much apreciated.
+
+## Style Guide
+
+Please follow Github's [Ruby style guide](https://github.com/styleguide/ruby) when contributing to make your patches more likely to be accepted!

data/Rakefile

@@ -6,16 +6,10 @@ require 'rspec/core/rake_task'
 require 'yard'
 
 RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.rspec_path = 'bin/rspec'
   spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
-RSpec::Core::RakeTask.new(:rcov) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.ruby_opts = '--debug'
-  spec.rcov = true
-  spec.rcov_opts = %w{--exclude generator_internal,jsignal_internal,gems\/,spec\/}
-end
-
 task :default => :spec
 
 desc 'Generate documentation'
@@ -24,6 +18,7 @@ YARD::Rake::YardocTask.new do |t|
   t.options = ['--no-private']
 end
 
+desc 'update pom.xml with current versions from lib/pacer/version.rb'
 file 'pom.xml' => 'lib/pacer/version.rb' do
   pom = File.read 'pom.xml'
   when_writing('Update pom.xml version number') do
@@ -32,6 +27,7 @@ file 'pom.xml' => 'lib/pacer/version.rb' do
         line.sub!(%r{<gem.version>.*</gem.version>}, "<gem.version>#{ Pacer::VERSION }</gem.version>")
         line.sub!(%r{<blueprints.version>.*</blueprints.version>}, "<blueprints.version>#{ Pacer::BLUEPRINTS_VERSION }</blueprints.version>")
         line.sub!(%r{<pipes.version>.*</pipes.version>}, "<pipes.version>#{ Pacer::PIPES_VERSION }</pipes.version>")
+        line.sub!(%r{<gremlin.version>.*</gremlin.version>}, "<gremlin.version>#{ Pacer::GREMLIN_VERSION }</gremlin.version>")
         f << line
       end
     end
@@ -40,10 +36,32 @@ end
 
 file Pacer::JAR_PATH => 'pom.xml' do
   when_writing("Execute 'mvn package' task") do
-    system('mvn clean package')
+    system 'mvn', 'clean'
+    system 'mvn', 'package'
+  end
+end
+
+task :check_18_mode do
+  if RUBY_VERSION !~ /1\.8/
+    warn 'Releasing gems in 1.9 mode does not work as of JRuby 1.6.5'
+    raise 'Nooooooo!'
   end
 end
 
+task :gemfile_devel do
+  File.delete 'Gemfile' if File.exists? 'Gemfile'
+  File.symlink 'Gemfile-dev', 'Gemfile'
+end
+
+desc 'Touch version.rb so that the jar rebuilds'
+task :touch do
+  system 'touch', 'lib/pacer/version.rb'
+end
+
+desc "build the JAR at #{ Pacer::JAR_PATH }"
 task :jar => Pacer::JAR_PATH
+
+# Add dependency to bundler default tasks:
 task :build => Pacer::JAR_PATH
 task :install => Pacer::JAR_PATH
+task :release => Pacer::JAR_PATH

data/bin/autotest

@@ -13,4 +13,4 @@ ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
 require 'rubygems'
 require 'bundler/setup'
 
-load Gem.bin_path('ZenTest', 'autotest')
+load Gem.bin_path('autotest-standalone', 'autotest')

data/lib/pacer/blueprints/multi_graph.rb

@@ -1,9 +1,11 @@
 module Pacer
   class MultiGraph < RubyGraph
-    def element_class
-      RubyElement
+    def self.blank
+      PacerGraph.new SimpleEncoder, proc { MultiGraph.new }
     end
 
+    protected
+
     def vertex_class
       MultiVertex
     end
@@ -15,7 +17,7 @@ module Pacer
 
 
   class MultiVertex < RubyVertex
-    import com.tinkerpop.pipes.util.MultiIterator
+    import com.tinkerpop.pipes.util.iterators.MultiIterator
 
     def initialize(*args)
       super
@@ -82,24 +84,12 @@ module Pacer
       super
     end
 
-    def getOutEdges(*labels)
-      vs = vertices
-      if vs.any?
-        labels = extract_varargs_strings(labels)
-        p = Pacer::Pipes::IdentityPipe.new
-        p.setStarts(MultiIterator.new super(*labels), *vs.map { |v| v.getOutEdges(*labels).iterator })
-        p
-      else
-        super
-      end
-    end
-
-    def getInEdges(*labels)
+    def getEdges(direction, *labels)
       vs = vertices
       if vs.any?
         labels = extract_varargs_strings(labels)
         p = Pacer::Pipes::IdentityPipe.new
-        p.setStarts MultiIterator.new super(*labels), *vs.map { |v| v.getInEdges(*labels).iterator }
+        p.setStarts(MultiIterator.new super, *vs.map { |v| v.getEdges(direction, *labels).iterator })
         p
       else
         super
@@ -115,7 +105,5 @@ module Pacer
     def to_s
       "m[#{ element_id }]"
     end
-
-    include VertexExtensions
   end
 end

data/lib/pacer/blueprints/ruby_graph.rb

@@ -1,24 +1,48 @@
 module Pacer
   class RubyGraph
-    import com.tinkerpop.blueprints.pgm.Element
-    import com.tinkerpop.blueprints.pgm.Graph
+    import com.tinkerpop.blueprints.Element
+    import com.tinkerpop.blueprints.Graph
+    import com.tinkerpop.blueprints.Features
 
     include Graph
 
-    def initialize
-      clear
-    end
-
-    def element_class
-      RubyElement
-    end
-
-    def vertex_class
-      RubyVertex
+    FEATURES = Features.new.tap do |features|
+      features.supportsDuplicateEdges = true
+      features.supportsSelfLoops = true
+      features.supportsSerializableObjectProperty = true
+      features.supportsBooleanProperty = true
+      features.supportsDoubleProperty = true
+      features.supportsFloatProperty = true
+      features.supportsIntegerProperty = true
+      features.supportsPrimitiveArrayProperty = true
+      features.supportsUniformListProperty = true
+      features.supportsMixedListProperty = true
+      features.supportsLongProperty = true
+      features.supportsMapProperty = true
+      features.supportsStringProperty = true
+
+      features.ignoresSuppliedIds = false
+      features.isPersistent = false
+      features.isRDFModel = false
+      features.isWrapper = false
+
+      features.supportsIndices = false
+      features.supportsKeyIndices = false
+      features.supportsVertexKeyIndex = false
+      features.supportsEdgeKeyIndex = false
+      features.supportsVertexIndex = false
+      features.supportsEdgeIndex = false
+      features.supportsTransactions = false
+      features.supportsVertexIteration = true
+      features.supportsEdgeIteration = true
+      features.supportsEdgeRetrieval = true
+      features.supportsVertexProperties = true
+      features.supportsEdgeProperties = true
+      features.supportsThreadedTransactions = false
     end
 
-    def edge_class
-      RubyEdge
+    def initialize
+      clear
     end
 
     def addVertex(id)
@@ -36,11 +60,14 @@ module Pacer
     end
 
     def removeVertex(vertex)
+      vertex.getEdges(Pacer::Pipes::BOTH).each do |e|
+        removeEdge e
+      end
       @vertices.delete vertex.element_id
     end
 
     def getVertices
-      Pacer::Pipes::EnumerablePipe.new @vertices.values
+      @vertices.values.to_iterable
     end
 
     def addEdge(id, outVertex, inVertex, label)
@@ -58,7 +85,7 @@ module Pacer
     end
 
     def getEdges
-      Pacer::Pipes::EnumerablePipe.new @edges.values
+      @edges.values.to_iterable
     end
 
     def clear
@@ -75,25 +102,19 @@ module Pacer
       other.equal? self
     end
 
-    def supports_custom_element_ids?
-      true
+    def features
+      FEATURES
     end
 
-    def supports_automatic_indices?
-      false
-    end
+    protected
 
-    def supports_manual_indices?
-      false
+    def vertex_class
+      RubyVertex
     end
 
-    def supports_edge_indices?
-      false
+    def edge_class
+      RubyEdge
     end
-    
-    include GraphExtensions
-
-    protected
 
     def next_id
       @next_id += 1
@@ -101,10 +122,10 @@ module Pacer
   end
 
   class RubyElement
-    include com.tinkerpop.blueprints.pgm.Element
+    include com.tinkerpop.blueprints.Element
 
-    def initialize(graph, element_id)
-      @graph = graph
+    def initialize(raw_graph, element_id)
+      @raw_graph = raw_graph
       @element_id = element_id
       @properties = {}
     end
@@ -136,6 +157,8 @@ module Pacer
 
     protected
 
+    attr_reader :raw_graph
+
     def extract_varargs_strings(labels)
       if labels.first.is_a? ArrayJavaProxy
         labels.first.map { |l| l.to_s }
@@ -147,32 +170,36 @@ module Pacer
 
 
   class RubyVertex < RubyElement
-    include com.tinkerpop.blueprints.pgm.Vertex
+    include com.tinkerpop.blueprints.Vertex
+    import com.tinkerpop.blueprints.util.VerticesFromEdgesIterable
 
     def getRawVertex
       self
     end
 
-    def getInEdges(*labels)
-      labels = extract_varargs_strings(labels)
-      edges = graph.getEdges.select { |e| e.getInVertex == self and (labels.empty? or labels.include? e.getLabel) }
-      Pacer::Pipes::EnumerablePipe.new edges
+    def getVertices(direction, *labels)
+      VerticesFromEdgesIterable.new self, direction, *labels
     end
 
-    def getOutEdges(*labels)
+    def getEdges(direction, *labels)
       labels = extract_varargs_strings(labels)
-      edges = graph.getEdges.select { |e| e.getOutVertex == self and (labels.empty? or labels.include? e.getLabel) }
+      if direction == Pacer::Pipes::BOTH
+        edges = raw_graph.getEdges.select do |e|
+          ( (e.getVertex(Pacer::Pipes::IN) == self or e.getVertex(Pacer::Pipes::OUT) == self) and
+            (labels.empty? or labels.include? e.getLabel) )
+        end
+      else
+        edges = raw_graph.getEdges.select { |e| e.getVertex(direction) == self and (labels.empty? or labels.include? e.getLabel) }
+      end
       Pacer::Pipes::EnumerablePipe.new edges
     end
-
-    include VertexExtensions
   end
 
   class RubyEdge < RubyElement
-    include com.tinkerpop.blueprints.pgm.Edge
+    include com.tinkerpop.blueprints.Edge
 
-    def initialize(graph, id, out_vertex, in_vertex, label)
-      super(graph, id)
+    def initialize(raw_graph, id, out_vertex, in_vertex, label)
+      super(raw_graph, id)
       @out_vertex = out_vertex
       @in_vertex = in_vertex
       @label = label.to_s
@@ -186,14 +213,12 @@ module Pacer
       @label
     end
 
-    def getOutVertex()
-      @out_vertex
-    end
-
-    def getInVertex()
-      @in_vertex
+    def getVertex(direction)
+      if direction == Pacer::Pipes::OUT
+        @out_vertex
+      else
+        @in_vertex
+      end
     end
-
-    include EdgeExtensions
   end
 end

data/lib/pacer/blueprints/tg.rb

@@ -1,100 +1,13 @@
 module Pacer
-  import com.tinkerpop.blueprints.pgm.impls.tg.TinkerGraph
-  import com.tinkerpop.blueprints.pgm.impls.tg.TinkerVertex
-  import com.tinkerpop.blueprints.pgm.impls.tg.TinkerEdge
-  import com.tinkerpop.blueprints.pgm.impls.tg.TinkerElement
-  import com.tinkerpop.blueprints.pgm.impls.tg.TinkerIndex
+  import com.tinkerpop.blueprints.impls.tg.TinkerGraph
 
-  # Create a new TinkerGraph. If path is given, import the GraphML data from
-  # the file specified.
+  # Create a new TinkerGraph. If path is given, use Tinkergraph in
+  # its standard simple persistant mode.
   def self.tg(path = nil)
-    graph = TinkerGraph.new
     if path
-      graph.import(path)
-    end
-    graph
-  end
-
-
-  # Extend the java class imported from blueprints.
-  class TinkerGraph
-    include GraphMixin
-    include GraphIndicesMixin
-    include GraphTransactionsStub
-    include ManagedTransactionsMixin
-    include Pacer::Core::Route
-    include Pacer::Core::Graph::GraphRoute
-    include Pacer::Core::Graph::GraphIndexRoute
-
-    def element_class
-      TinkerElement
-    end
-
-    def vertex_class
-      TinkerVertex
-    end
-
-    def edge_class
-      TinkerEdge
-    end
-
-    # Override to return an enumeration-friendly array of vertices.
-    def get_vertices
-      getVertices.iterator.to_route(:graph => self, :element_type => :vertex)
-    end
-
-    # Override to return an enumeration-friendly array of edges.
-    def get_edges
-      getEdges.iterator.to_route(:graph => self, :element_type => :edge)
-    end
-
-    def ==(other)
-      other.class == self.class and other.object_id == self.object_id
-    end
-  end
-
-
-  class TinkerIndex
-    include IndexMixin
-  end
-
-
-  # Extend the java class imported from blueprints.
-  class TinkerVertex
-    include Pacer::Core::Graph::VerticesRoute
-    include ElementMixin
-    include VertexMixin
-  end
-
-
-  # Extend the java class imported from blueprints.
-  class TinkerEdge
-    include Pacer::Core::Graph::EdgesRoute
-    include ElementMixin
-    include EdgeMixin
-
-    def in_vertex(extensions = nil)
-      v = inVertex
-      v.graph = graph
-      if extensions.is_a? Enumerable
-        v.add_extensions extensions
-      elsif extensions
-        v.add_extensions [extensions]
-      else
-        v
-      end
-    end
-
-    def out_vertex(extensions = nil)
-      v = outVertex
-      v.graph = graph
-      if extensions.is_a? Enumerable
-        v.add_extensions extensions
-      elsif extensions
-        v.add_extensions [extensions]
-      else
-        v
-      end
+      PacerGraph.new SimpleEncoder, proc { TinkerGraph.new(path) }
+    else
+      PacerGraph.new SimpleEncoder, proc { TinkerGraph.new }
     end
   end
 end

data/lib/pacer/blueprints.rb

@@ -1,4 +1,3 @@
-require 'pacer/blueprints/extensions'
 require 'pacer/blueprints/tg'
 require 'pacer/blueprints/ruby_graph'
 require 'pacer/blueprints/multi_graph'

data/lib/pacer/core/graph/edges_route.rb

@@ -2,16 +2,14 @@ module Pacer::Core::Graph
 
   # Basic methods for routes that contain only edges.
   module EdgesRoute
-    import com.tinkerpop.pipes.transform.OutVertexPipe
-    import com.tinkerpop.pipes.transform.InVertexPipe
-    import com.tinkerpop.pipes.transform.BothVerticesPipe
-
-    include ElementRoute
+    import com.tinkerpop.gremlin.pipes.transform.OutVertexPipe
+    import com.tinkerpop.gremlin.pipes.transform.InVertexPipe
+    import com.tinkerpop.gremlin.pipes.transform.BothVerticesPipe
 
     # Extends the route with out vertices from this route's matching edges.
     #
     # @param [Array<Hash, extension>, Hash, extension] filter see {Pacer::Route#property_filter}
-    # @yield [VertexMixin(Extensions::BlockFilterElement)] filter proc, see {Pacer::Route#property_filter}
+    # @yield [VertexWrapper(Extensions::BlockFilterElement)] filter proc, see {Pacer::Route#property_filter}
     # @return [VerticesRoute]
     def out_v(*filters, &block)
       Pacer::Route.property_filter(chain_route(:element_type => :vertex,
@@ -23,7 +21,7 @@ module Pacer::Core::Graph
     # Extends the route with in vertices from this route's matching edges.
     #
     # @param [Array<Hash, extension>, Hash, extension] filter see {Pacer::Route#property_filter}
-    # @yield [VertexMixin(Extensions::BlockFilterElement)] filter proc, see {Pacer::Route#property_filter}
+    # @yield [VertexWrapper(Extensions::BlockFilterElement)] filter proc, see {Pacer::Route#property_filter}
     # @return [VerticesRoute]
     def in_v(*filters, &block)
       Pacer::Route.property_filter(chain_route(:element_type => :vertex,
@@ -35,7 +33,7 @@ module Pacer::Core::Graph
     # Extends the route with both in and oud vertices from this route's matching edges.
     #
     # @param [Array<Hash, extension>, Hash, extension] filter see {Pacer::Route#property_filter}
-    # @yield [VertexMixin(Extensions::BlockFilterElement)] filter proc, see {Pacer::Route#property_filter}
+    # @yield [VertexWrapper(Extensions::BlockFilterElement)] filter proc, see {Pacer::Route#property_filter}
     # @return [VerticesRoute]
     def both_v(*filters, &block)
       Pacer::Route.property_filter(chain_route(:element_type => :vertex,
@@ -47,7 +45,7 @@ module Pacer::Core::Graph
     # Extend route with the additional edge label, property and block filters.
     #
     # @param [Array<Hash, extension>, Hash, extension] filter see {Pacer::Route#property_filter}
-    # @yield [EdgeMixin(Extensions::BlockFilterElement)] filter proc, see {Pacer::Route#property_filter}
+    # @yield [EdgeWrapper(Extensions::BlockFilterElement)] filter proc, see {Pacer::Route#property_filter}
     # @return [EdgesRoute]
     def e(*filters, &block)
       filter(*filters, &block)
@@ -58,7 +56,7 @@ module Pacer::Core::Graph
     #
     # @return [Core::Route]
     def labels
-      chain_route(:pipe_class => com.tinkerpop.pipes.transform.LabelPipe,
+      chain_route(:pipe_class => com.tinkerpop.gremlin.pipes.transform.LabelPipe,
                   :route_name => 'labels',
                   :element_type => :object)
     end
@@ -80,13 +78,13 @@ module Pacer::Core::Graph
     # @return [element_type(:edge)] The actual type varies based on
     # which graph is in use.
     def element_type
-      graph.element_type(:edge)
+      :edge
     end
 
     protected
 
     def id_pipe_class
-      com.tinkerpop.pipes.transform.IdEdgePipe
+      com.tinkerpop.gremlin.pipes.transform.IdEdgePipe
     end
   end
 end