pacer 0.9.1.1-java

data/.autotest

@@ -0,0 +1,8 @@
+require 'autotest/bundler'
+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)
+  at.add_exception %r{^\./tmp} # ignore temp files, lest autotest will run again, and again...
+  at.add_exception %r{^\./(coverage|data|samples|pkg|\.yardoc)}
+  nil
+}

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,26 @@
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+Gemfile.lock
+
+# jeweler generated
+pkg
+
+# Project specific
+*.graph
+*.db
+*.graphml
+pkg
+tmp
+lib/*.jar
+jdex.log
+bin

data/.rspec

@@ -0,0 +1 @@
+#--format d

data/CONTRIBUTORS

@@ -0,0 +1,5 @@
+Maintainer:
+  Darrick Wiebe <dw@xnlogic.com>
+
+Contributors:
+* 

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,24 @@
+Copyright (c) 2010, TinkerPop [http://tinkerpop.com]
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the TinkerPop nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL TINKERPOP BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,187 @@
+# Pacer
+
+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!
+
+## Mailing List
+
+With the release of 0.8.1, I just set up a brand new [pacer google
+group](http://groups.google.com/group/pacer-users?lnk=gcimv). Join and
+let's get the conversation going!
+
+## Documentation
+
+Pacer is documented with a comprehensive RSpec test suite and with a
+thorough YARD documentation. [Dig in!](http://rubydoc.info/github/pangloss/pacer/develop/frames)
+
+If you like, you can also use the documentation locally via
+
+  gem install yard
+  yard server
+
+## Installation
+
+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`.
+
+## Graph Database Support
+
+The Tinkerpop suite supports a number of graph data stores. They are all
+compatible with Pacer, but I have not yet implemented the simple
+adapters Pacer needs to use them yet. Here is the list of what's
+supported so far:
+
+ * TinkerGraph - In-memory graph db, built in and ready to use without
+   additional dependencies.
+ * [Neo4J](http://neo4j.org) - The industry-leading graph db. `gem
+   install pacer-neo4j`
+   [pangloss/pacer-neo4j](https://github.com/pangloss/pacer-neo4j)
+ * [Dex](http://sparsity-technologies.com) - A very fast, relatively new graph db. `gem
+   install pacer-dex`
+   [pangloss/pacer-dex](https://github.com/pangloss/pacer-dex)
+
+You can run any or all of the above graph databases. Pacer supports
+running them simultaneuosly and even supports having many of any given
+type open at once.
+
+### Interoperation with the neo4j gem
+
+Pacer can work together with other Ruby GraphDB libraries, too. The
+first functioning example is with theo neo4j gem. Hopefully more will
+follow soon as I find out about them or get requests to support them.
+
+To use Pacer together with the neo4j gem, get your Pacer graph instance
+as follows:
+
+```ruby
+    require 'neo4j'
+    require 'pacer-neo4j'
+    Neo4j.db.start
+    graph = Pacer.neo4j(Neo4j.db.graph)
+```
+
+After that, you can continue to use the graph as normal with *both*
+gems. Any update that's committed with one gem will be visible
+immediately to the other because they are now both pointing to the same
+Java graphdb instance.
+
+### A note on safely exiting
+
+Some databases need to be shutdown cleanly when the program exits. You
+can shut a database down anytime by calling `graph.shutdown`, but you
+don't need to worry about it much. Pacer uses Ruby's `at_exit` hook to
+automatically shut down all open databases!
+
+## Example traversals
+
+Friend recommendation algorithm expressed in basic traversal functions:
+
+```ruby
+    friends = person.out_e(:friend).in_v(:type => 'person')
+    friends.out_e(:friend).in_v(:type => 'person').except(friends).except(person).most_frequent(0...10)
+```
+
+or using Pacer's route extensions to create your own query methods:
+
+```ruby
+    person.friends.friends.except(person.friends).except(person).most_frequent(0...10)
+```
+
+or to take it one step further:
+
+```ruby
+    person.recommended_friends
+```
+
+## Create and populate a graph
+
+To get started, you need to know just a few methods. First, open up a graph (if one doesn't exist it will be automatically created) and add some vertices to it:
+
+```ruby
+    dex = Pacer.dex '/tmp/dex_demo'
+    pangloss = dex.create_vertex :name => 'pangloss', :type => 'user'
+    okram = dex.create_vertex :name => 'okram', :type => 'user'
+    group = dex.create_vertex :name => 'Tinkerpop', :type => 'group'
+```
+
+Now, let's see what we've got:
+
+```ruby
+    dex.v
+```
+
+produces:
+
+```ruby
+    #<V[1024]> #<V[1025]> #<V[1026]>
+    Total: 3
+    => #<GraphV>
+```
+
+There are our vertices. Let's look their properties:
+
+```ruby
+    dex.v.properties
+
+    {"name"=>"pangloss", "type"=>"user"} {"name"=>"okram", "type"=>"user"}
+    {"name"=>"Tinkerpop", "type"=>"group"}
+    Total: 3
+    => #<GraphV -> Obj-Map>
+```
+
+Now let's put an edge between them:
+
+```ruby
+    dex.create_edge okram, pangloss, :inspired
+    => #<E[2048]:1025-inspired-1024>
+```
+
+That's great for creating an edge but what if I've got lots to create? Try this method instead which can add edges to the cross product of all vertices in one route with all vertices in the other:
+
+```ruby
+    group.add_edges_to :member, dex.v(:type => 'user')
+
+    #<E[4097]:1026-member-1024> #<E[4098]:1026-member-1025>
+    Total: 2
+    => #<Obj 2 ids -> lookup>
+```
+
+There is plenty more to see as well! Please dig into the code and the spec suite to find loads of examples and edge cases. And if you think of a case that I've missed, I'll greatly appreciate your contributions!
+
+## Design Philosophy
+
+I want Pacer and its ecosystem to become a repository for real implementations of ideas, best practices and techniques for streaming data manipulation. I've got lots of ideas that I'd like to add, and although Pacer seems to be quite rock solid right now -- and I am using it in limited production environments -- it is still in flux. If we find a better way to do something, we're going to do it that way even if that means breaking changes from one release to another.
+
+Once Pacer matures further, a decision will be made to 'lock it down' at least a little more, hopefully there will be a community in place by then to help determine the right time for that to happen!
+
+## Pluggable Architecture
+
+Pacer is meant to be extensible and is built on a very modular architecture. Nearly every chainable route method is actually implemented in an independent module that is plugged into the route only when it's in use. That allows great flexibility in adding methods to routes without clogging up the method namespace. It also makes it natural to make pacer plugin gems.
+
+There are lots of examples of route extensions right inside Pacer. Have a look at the [lib/pacer/filter](https://github.com/pangloss/pacer/tree/develop/lib/pacer/filter), [side_effect](https://github.com/pangloss/pacer/tree/develop/lib/pacer/side_effect) and [transform](https://github.com/pangloss/pacer/tree/develop/lib/pacer/transform) folders to see the modules that are built into Pacer. They vary widely in complexity, so take a look around.
+
+If you want to add a traversal technique to Pacer, you can fork Pacer and send me a pull request or just create your own pacer-&lt;feature name&gt; plugin! To see how to build your own Pacer plugin, see my [example pacer-bloomfilter plugin](https://github.com/pangloss/pacer-bloomfilter) which also has a readme file that goes into considerable detail on the process of creating plugins and provides some additional usage examples as well.
+
+As a side note, don't worry about any magic happening behind the scenes to discover or automatically load pacer plugins, there is none of that! If you want to use a pacer plugin, treat it like any other gem, add it to your Gemfile (if that's what you use) and <code>require</code> the gem as normal if you need it.
+
+## Gremlin
+
+If you're already familiar with [Gremlin](http://gremlin.tinkerpop.com), please look at my [Introducing Pacer](http://ofallpossibleworlds.wordpress.com/2010/12/19/introducing-pacer) post for a simple introduction and explanation of how Pacer is at once similar to and quite different from Gremlin, the project that inspired it. That post is a little out of date at this point since it refers to the original version of Gremlin. Groovy Gremlin is the latest version, inspired in turn by Pacer!
+
+A great introduction to the underlying concept of pipes can be found in Marko Rodriguez' post [On the Nature of Pipes](http://markorodriguez.com/2011/08/03/on-the-nature-of-pipes/)
+
+## 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.

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+require 'yard'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  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'
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb', '-', 'LICENSE.txt']
+  t.options = ['--no-private']
+end
+
+file 'pom.xml' => 'lib/pacer/version.rb' do
+  pom = File.read 'pom.xml'
+  when_writing('Update pom.xml version number') do
+    open 'pom.xml', 'w' do |f|
+      pom.each_line do |line|
+        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>")
+        f << line
+      end
+    end
+  end
+end
+
+file Pacer::JAR_PATH => 'pom.xml' do
+  when_writing("Execute 'mvn package' task") do
+    system('mvn clean package')
+  end
+end
+
+task :jar => Pacer::JAR_PATH
+task :build => Pacer::JAR_PATH
+task :install => Pacer::JAR_PATH

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/bin/autospec

@@ -0,0 +1,16 @@
+#!/usr/bin/env jruby
+#
+# This file was generated by Bundler.
+#
+# The application 'autospec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rspec-core', 'autospec')

data/bin/autotest

@@ -0,0 +1,16 @@
+#!/usr/bin/env jruby
+#
+# This file was generated by Bundler.
+#
+# The application 'autotest' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('ZenTest', 'autotest')

data/bin/rake

@@ -0,0 +1,16 @@
+#!/usr/bin/env jruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rake', 'rake')

data/bin/rcov

@@ -0,0 +1,16 @@
+#!/usr/bin/env jruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rcov' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rcov', 'rcov')

data/bin/rspec

@@ -0,0 +1,16 @@
+#!/usr/bin/env jruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rspec-core', 'rspec')

data/bin/yard

@@ -0,0 +1,16 @@
+#!/usr/bin/env jruby
+#
+# This file was generated by Bundler.
+#
+# The application 'yard' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('yard', 'yard')

data/bin/yardoc

@@ -0,0 +1,16 @@
+#!/usr/bin/env jruby
+#
+# This file was generated by Bundler.
+#
+# The application 'yardoc' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('yard', 'yardoc')

data/lib/pacer/blueprints/extensions.rb

@@ -0,0 +1,77 @@
+module Pacer
+  # NOTE these extensions modules can only be included in classes that don't include the
+  # default Java method aliases generated when importing Java classes into JRuby. In those
+  # classes the methods must be copied and pasted in order to overwrite the aliased methods.
+  module GraphExtensions
+    def self.included(target)
+      target.class_eval do
+        include GraphMixin
+        include GraphIndicesMixin if target.ancestors.include? com.tinkerpop.blueprints.pgm.IndexableGraph
+        include GraphTransactionsStub
+        include ManagedTransactionsMixin
+        include Pacer::Core::Route
+        include Pacer::Core::Graph::GraphRoute
+        include Pacer::Core::Graph::GraphIndexRoute if target.ancestors.include? com.tinkerpop.blueprints.pgm.IndexableGraph
+      end
+    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
+
+  module VertexExtensions
+    def self.included(target)
+      target.class_eval do
+        include Pacer::Core::Graph::VerticesRoute
+        include ElementMixin
+        include VertexMixin
+      end
+    end
+  end
+
+  module EdgeExtensions
+    def self.included(target)
+      target.class_eval do
+        include Pacer::Core::Graph::EdgesRoute
+        include ElementMixin
+        include EdgeMixin
+      end
+    end
+
+    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
+    end
+  end
+end

data/lib/pacer/blueprints/multi_graph.rb

@@ -0,0 +1,121 @@
+module Pacer
+  class MultiGraph < RubyGraph
+    def element_class
+      RubyElement
+    end
+
+    def vertex_class
+      MultiVertex
+    end
+
+    def edge_class
+      RubyEdge
+    end
+  end
+
+
+  class MultiVertex < RubyVertex
+    import com.tinkerpop.pipes.util.MultiIterator
+
+    def initialize(*args)
+      super
+      @vertex_keys = Set[]
+      @join_keys = @vertex_keys
+    end
+
+    attr_accessor :vertex_keys, :join_keys
+
+    def join_on(keys)
+      if keys.is_a? Enumerable
+        @join_keys = keys.map { |k| k.to_s }.to_set
+      elsif keys
+        @join_keys = Set[keys.to_s]
+      else
+        @join_keys = Set[]
+      end
+    end
+
+    def vertices
+      join_keys.flat_map do |key|
+        @properties[key]
+      end
+    end
+
+    def setProperty(key, value)
+      case value
+      when Pacer::Vertex
+        vertex_keys << key.to_s
+        super
+      when Hash
+        vertex_keys.delete key.to_s
+        super
+      when Enumerable
+        values = value.to_a
+        if values.any? and values.all? { |v| v.is_a? Pacer::Vertex }
+          vertex_keys << key.to_s
+        end
+        super(key, values)
+      else
+        vertex_keys.delete key.to_s
+        super
+      end
+    end
+
+    def append_property_array(key, value)
+      values = value.to_a
+      existing_values = getProperty(key)
+      if existing_values
+        if vertex_keys.include? key and not values.all? { |v| v.is_a? Pacer::Vertex }
+          vertex_keys.delete key.to_s
+        end
+        raise "Can't append to key #{ key } because it is not an Array" unless existing_values.is_a? Array
+      else
+        existing_values = []
+        setProperty(key, existing_values)
+        vertex_keys << key.to_s if values.all? { |v| v.is_a? Pacer::Vertex }
+      end
+      existing_values.concat values
+    end
+
+    def removeProperty(key)
+      vertex_keys.delete key.to_s
+      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)
+      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
+      else
+        super
+      end
+    end
+
+    def inspect
+      s = super
+      s[2] = 'M'
+      s
+    end
+
+    def to_s
+      "m[#{ element_id }]"
+    end
+
+    include VertexExtensions
+  end
+end