pacer-jogger 0.0.2 → 0.0.3

data/CHANGELOG.markdown

@@ -0,0 +1,4 @@
+0.0.3
+=====
+
+- fixed non working two argument traversals

data/README.markdown

@@ -1,31 +1,32 @@
-# Jogger - almost like named scopes
+Jogger - almost like named_scopes
+=================================
 
-Jogger is a JRuby library that enables lazy people to do very expressive graph traversals with the great [pacer gem](https://github.com/pangloss/pacer). If you don't know what the pacer gem is, you should probably not be here and check pacer out first.
+Jogger is a JRuby library that enables lazy people to do very expressive graph traversals with the great [pacer gem](https://github.com/pangloss/pacer). If you don't know what the pacer gem is, you should probably not be here and check pacer out first. And don't miss the pacer section at the end of text.
 
-# What does Jogger do? TL;DR
-
-Remember the _named scopes_ from back in the days when you were using rails? They were handy, weren't they? Jogger gives you _named traversals_ and is a little bit like named scopes. Jogger groups multiple pacer traversals together and give them a name. Pacer traversals are are like pipes. What are pipes? [Pipes are great!](http://markorodriguez.com/2011/08/03/on-the-nature-of-pipes/)!
+Remember the _named_scopes_ from back in the days when you were using rails? Jogger gives you _named traversals_ and is a little bit like named scopes. Jogger groups multiple pacer traversals together and give them a name. Pacer traversals are are like pipes. What are pipes? [Pipes are great!](http://markorodriguez.com/2011/08/03/on-the-nature-of-pipes/)!
 
 The most important conceptual difference is, that the order in which named traversals are called matter, while it usually doesn't matter in which order you call named scopes.
 
-Jogger does two things:
+TL; DR: Jogger does two things:
+=======================
 
 1. Keep the current pacer traversal in an instance variable and allow for method chaining as well as changing the internal state of the traversal
 2. Allows you to group together parts of a traversal (single pipes or groups of them) and give them a name. Named traversals. Helps to stay DRY.
 
-The former is really just a syntax thing, whereas the latter can help you a great deal modeling semantics of your business logic as parts of traversals. These sentences confuse me, so I will give you a TL;DR gif followed by some hands on examples.
+The former is really just a syntax thing, whereas the latter can help you a great deal modeling semantics of your business logic as parts of traversals. Let's jog!
 
-![TL;DR](http://dl.dropbox.com/u/1953503/gifs/berneydidnotread.gif)
+![Run](http://dl.dropbox.com/u/1953503/gifs/vizPZ.gif)
 
 
-# Feature #1 (not so important): keep the current traversal
+Feature #1: keep the current traversal
+--------------------------------------
 
 To demonstrate why point 1) in the list above can be useful, look at this traversal. It helps me find out what movies my female friends like the most, so I can impress them in a conversation:
 
     t = my_pacer_vertex.in(:friends)
-    t = t.filter{|v| v.properties['gender'] == 'female}
+    t = t.filter(gender: 'female')
     t = t.out(:likes)
-    t = t.filter{ |v| v.properties['type'] == 'Movie' }
+    t = t.filter(type: 'Movie')
     t = t.sort_by{ |v, c| -c }
     t = t.group_count{ |v| v }
 
@@ -35,19 +36,20 @@ So here's the Jogger way of expressing this:
 
     t = Jogger.new(my_pacer_vertex)
     t.in(:friends)
-    t.filter{ |v| v.properties['gender'] == 'female' }
+    t.filter(gender: 'female')
     t.out(:likes)
-    t.filter{ |v| v.properties['type'] == 'Movie' }
+    t.filter(type: 'Movie')
     t.sort_by{ |v, c| -c }
     t.group_count{ |v| v }
 
 See what I did there? Jogger keeps the current pacer traversal and forwards all method calls to that traversal, and then returns itself. So you could also write (in jogger as well as pacer):
 
-       Jogger.new(my_pacer_node).in(:friends).filter{ … }.out(:likes).group_count{…}
+       Jogger.new(my_pacer_node).in(:friends).filter(…).out(:likes).group_count{…}
 
 Just saying, you can chain your methods, but I don't like it cause I can only focus on 72 characters per line at max. If you want the current traversal, just call `result` on your Jogger instance.
 
-## Feature #2 (pretty useful): Named Traversals
+Feature #2: Named Traversals
+----------------------------
 
 So that traversal above, traversing from a node to all its friends, is pretty simple, but it could be simpler. Especially if it does things that you want to reuse in many other places. How cool would it be if I just had to write this:
 
@@ -55,7 +57,7 @@ So that traversal above, traversing from a node to all its friends, is pretty si
     t.friends(:female)
     t.top_list(:movies)
 
-No problem. Just define named traversals that aggregate different pipes and give them a name:
+No problem. Just define named traversals that aggregate different pipes and give them a name. You have to put your traversal into Jogger's `NamedTraverals` module.
 
     class Jogger
       module NamedTraversals
@@ -63,21 +65,24 @@ No problem. Just define named traversals that aggregate different pipes and give
         # Traverse to somebody's woman friends
         def self.friends(current_traversal, gender)
           t = current_traversal.in(:friends)
-          t = t.filter{|v| v.properties['gender'] == gender}
+          t = t.filter(gender: gender)
         end
 
         # Group and sort
         def self.top_list(current_traversal, type)
           t = current_traversal.out(type)
-          t = t.filter{ |v| v.properties['type'] == 'Movie' }
+          t = t.filter(type: 'Movie')
           t = t.group_count{ |v| v }
         end
       end
     end
 
+Your methods have to be able to take at least one parameter: the current traversal. It represents the current traversal state of your `Jogger` instance. Your traversal can then modify this traversal and must return it. It will become your Jogger instance's new state.
+
 These are silly examples, but if you look at your traversals I guarantee that you will find repeated patterns all over the place, and Jogger can help you stop repeating these and making the actual traversals much easier on the eyes.
 
-# Installation
+Installation
+============
 
 First, you need to load pacer and whatever graph db connector you need (we use neo4j, by the way) and define your named traversals as above. Jogger doesn't include these on purpose. Then, you have to 
 
@@ -93,10 +98,64 @@ or for your Gemfile
 
 That's it!
 
-# Documentation
+Documentation
+=============
 
 I gave YARD a shot, so to open the documentation in your browser just do this in the jogger directory:
 
     yard server & sleep 3 && open http://localhost:8808/docs/file/README.markdown
 
-Or you can (browse the documentation online)[http://rubydoc.info/github/jayniz/jogger/master/frames]
+Or you can [browse the documentation online](http://rubydoc.info/github/jayniz/jogger/master/frames)
+
+Named traversals - The pacer way
+================================
+
+You can implement feature #2 purely in pacer, if you like. For example, you could express
+
+    my_node.out.filter(type: 'Movie')
+
+with
+
+    my_node.out(Movie)
+
+For this to work you need to tell pacer, what `Movie` actually means. In the simplest form, you could say:
+
+    module Movie
+      def self.route_conditions
+        { type: 'Movie' }
+      end
+    end
+    
+That way pacer knows, whenever you're talking about a `Movie` you want to filter those elements whose `type==Movie`. To do something like the named traversals described above, you could go ahead and define a route to all female likers of a movie:
+     
+    module Girl
+      def self.route_conditions
+        {gender: :female}
+      end
+    end
+    
+    module Movie
+      def self.route_conditions
+        { type: 'Movie' }
+      end
+
+    
+      module Route
+        def female_likers
+          self.in_e(:likes).in_v(Girl)
+        end
+      end
+    end
+
+You can then go ahead and fetch:
+
+    t.out(Movie).female_likers
+
+To wrap it up, using Jogger to do named traversals is for the super lazy. If you use pacer exclusively and have more complicated structures it would probably make more sense to create your named traversals in the design of your domain logic and do it purely with pacer. You can still use Jogger to traverse these routes. If you want to share common traversal patterns between different models it might be easier to do with Jogger.
+
+License
+=======
+
+Jogger is released under the MIT license:
+
+* http://www.opensource.org/licenses/MIT

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/jogger.rb

@@ -1,3 +1,4 @@
+class UnknownTraversalError < ArgumentError; end;
 
 # Allows to formulate traversals by using predefined
 # named traversals. Also allows for method chaining.
@@ -48,12 +49,12 @@ class Jogger
   def method_missing(method, *args, &block)
     begin
       traversal_args = [method, args].flatten.compact
-      @current_traversal = Jogger.traverse(@current_traversal, *traversal_args)
-    rescue ArgumentError
+      @current_traversal = Jogger.traverse(@current_traversal, method, args)
+    rescue UnknownTraversalError => a
       begin
         @current_traversal = @current_traversal.send(method, *args, &block)
-      rescue NoMethodError
-        raise "Unknown traversal #{method}"
+      rescue NoMethodError => m
+        raise "Unknown traversal #{method}. From (#{a}) via (#{m}) (method_missing rocks)"
       end
     end
     self
@@ -70,8 +71,8 @@ class Jogger
   # @param opts [Object] Whatever you want to pass to the named traverser
   # @return [Object] The result of the traversal.
   def self.traverse(traversal_base, named_traversal, opts = nil)
-    raise ArgumentError, "Unknown traversal #{named_traversal}" unless valid_traversal?(named_traversal)
-    args = [named_traversal, traversal_base] + [opts].compact
+    raise UnknownTraversalError, "Unknown traversal #{named_traversal}" unless valid_traversal?(named_traversal)
+    args = [named_traversal, traversal_base] + [*opts].compact
     Jogger::NamedTraversals.send(*args)
   end
 

data/pacer-jogger.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "pacer-jogger"
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jannis Hermanns"]
-  s.date = "2012-01-25"
+  s.date = "2012-09-14"
   s.description = "Allows to group traversal fragments/pipes to named traversals and call them like they were pacer pipes."
   s.email = "jannis@gmail.com"
   s.extra_rdoc_files = [
@@ -18,6 +18,7 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".document",
+    "CHANGELOG.markdown",
     "Gemfile",
     "Gemfile.lock",
     "LICENSE.txt",
@@ -32,7 +33,7 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/jayniz/jogger"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.10"
+  s.rubygems_version = "1.8.24"
   s.summary = "Pacer traversals for lazy people"
 
   if s.respond_to? :specification_version then

data/spec/lib/jogger_spec.rb

@@ -15,10 +15,16 @@ class Jogger
       (current_traversal || 1) * x
     end
 
+    # A traversal with no args
     def self.no_argument_traverser(current_traversal)
       :worked
     end
 
+    # A traversal with two args
+    def self.two_argument_traverser(current_traversal, x, y)
+      x+y
+    end
+
     def self.method_missing_dummy(current_traversal)
       MyFakedPacerResult.new
     end
@@ -45,13 +51,19 @@ describe Jogger do
     lambda do
       p = Jogger.new
       p.this_does_not_exist
-    end.should raise_error("Unknown traversal this_does_not_exist")
+    end.should raise_error("Unknown traversal this_does_not_exist. From (Unknown traversal this_does_not_exist) via (undefined method `this_does_not_exist' for nil:NilClass) (method_missing rocks)")
   end
 
   it "works for traversals without arguments" do
     Jogger.new.no_argument_traverser.result.should == :worked
   end
 
+  it "works for traversals with two arguments" do
+    p = Jogger.new
+    p.two_argument_traverser(3,7)
+    p.result.should == 10
+  end
+
   it "delegates method calls to the current traversal" do
     Jogger.new.method_missing_dummy.some_existing_pacer_method.result.should == :is_there
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pacer-jogger
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-25 00:00:00.000000000Z
+date: 2012-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &70106294753680 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70106294753680
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70106294753160 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +37,15 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *70106294753160
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &70106294752640 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +53,15 @@ dependencies:
         version: 1.7.0
   type: :development
   prerelease: false
-  version_requirements: *70106294752640
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.0
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70106294752040 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +69,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70106294752040
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &70106294751440 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +85,12 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70106294751440
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Allows to group traversal fragments/pipes to named traversals and call
   them like they were pacer pipes.
 email: jannis@gmail.com
@@ -76,6 +101,7 @@ extra_rdoc_files:
 - README.markdown
 files:
 - .document
+- CHANGELOG.markdown
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -101,7 +127,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3011242392760856399
+      hash: -3862290704607932107
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -110,7 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Pacer traversals for lazy people