red_grape 0.0.12 → 0.0.13

data/.gitignore

@@ -2,4 +2,4 @@
 dbfile.bin
 pkg/
 red_grape-*.gem
-public
+public/js/d3

data/bin/juicer

@@ -1,14 +1,33 @@
 #!/usr/bin/env ruby
 $: << File.expand_path('../../lib', __FILE__)
 
+require 'optparse'
 require 'sinatra'
 require 'red_grape'
+require 'red_grape/tools/trellis'
 
+# interprete options
+::Version = RedGrape::VERSION
+COMMAND_LINE = "#{$0} #{ARGV.join(' ')}"
+OPT = {}
+#  port:RedGrape::Tools::Trellis::DEFAULT_PORT
+opts = OptionParser.new
+opts.on('-p', '--port <port number>', 
+  "Set the port number (default: #{OPT[:port]})"){|v| OPT[:port] = v.to_i}
+opts.on_tail('-v', '--version', 'Show version'){puts(opts.ver); exit}
+opts.on_tail('-h', '--help', 'Show this message'){puts(opts.help); exit}
+opts.order! ARGV
+
+# start
 use Rack::Static, :urls => ['/cellar', '/js', '/css'], :root => 'public'
 
-graphs = {
-  'tinkergraph' => RedGrape.create_tinker_graph
-}
+graphs = nil
+if OPT[:port]
+  graphs = RedGrape::Tools::Trellis.open OPT[:port]
+else
+  graphs = RedGrape::GraphStore.new
+  graphs[:tinkergraph] = RedGrape.create_tinker_graph
+end
 
 get '/' do
   {
@@ -57,7 +76,7 @@ get %r{/graphs/?$} do
   {
     version: RedGrape::VERSION,
     name: 'Juicer: A Graph Server',
-    graphs: graphs.keys
+    graphs: graphs.graph_names
   }.to_pretty_json
 end
 
@@ -108,4 +127,3 @@ get %r{/graphs/([^/]+)/vertices/([^/]+)/(out_e|in_e|both_e|outE|inE|bothE)/?$} d
     vertex.send(dir)[].map(&:to_h).to_pretty_json
   end
 end
-

data/bin/redgrape

@@ -3,14 +3,14 @@ $: << File.expand_path('../../lib', __FILE__)
 
 require 'optparse'
 require 'red_grape'
-require 'red_grape/tools/graph_store'
+require 'red_grape/tools/trellis'
 require 'red_grape/tools/irg'
 
 # interprete options
 ::Version = RedGrape::VERSION
 COMMAND_LINE = "#{$0} #{ARGV.join(' ')}"
 OPT = {
-  port:RedGrape::Tools::GraphStore::DEFAULT_PORT
+  port:RedGrape::Tools::Trellis::DEFAULT_PORT
 }
 opts = OptionParser.new
 opts.on('-p', '--port <port number>', 

data/bin/trellis

@@ -3,13 +3,13 @@ $: << File.expand_path('../../lib', __FILE__)
 
 require 'optparse'
 require 'red_grape'
-require 'red_grape/tools/graph_store'
+require 'red_grape/tools/trellis'
 
 # interprete options
 ::Version = RedGrape::VERSION
 COMMAND_LINE = "#{$0} #{ARGV.join(' ')}"
 OPT = {
-  port:RedGrape::Tools::GraphStore::DEFAULT_PORT,
+  port:RedGrape::Tools::Trellis::DEFAULT_PORT,
   dbfile:'dbfile.bin'
 }
 opts = OptionParser.new
@@ -23,7 +23,7 @@ opts.order! ARGV
 
 # start
 Signal.trap :INT, 'EXIT'
-RedGrape::Tools::GraphStore.start(OPT[:port], OPT[:dbfile]) do
+RedGrape::Tools::Trellis.start(OPT[:port], OPT[:dbfile]) do
   puts <<-EOS
   +=================+
   |  +     T     +  |

data/lib/red_grape/element.rb

@@ -75,6 +75,10 @@ module RedGrape
       self.class == obj.class && self.id == obj.id
     end
 
+    def <=>(other)
+      self.id <=> other.id
+    end
+
     def directed_value(direction, out_value, in_value, error=true)
       case direction.to_s
       when 'out'

data/lib/red_grape/graph.rb

@@ -17,7 +17,7 @@ module RedGrape
 
       # Returns the default graph which has 6 vertices and 6 edges.
       def create_tinker_graph
-        self.new do |g|
+        self.new :tinkergraph do |g|
           v1 = g.add_vertex 1, name:'marko', age:29
           v2 = g.add_vertex 2, name:'vadas', age:27
           v3 = g.add_vertex 3, name:'lop', lang:'java'
@@ -67,12 +67,13 @@ module RedGrape
       end
     end
 
-    attr_accessor :serializer
+    attr_accessor :name, :serializer
       
     # Returns a new instance
     # _block_ :: a block which is given the instance as the first argument 
     # to initialize it
-    def initialize(&block)
+    def initialize(name=nil, &block)
+      @name = name || uid
       @serializer = Serializer::GraphMLSerializer.new self
       @vertices = {}
       @edges = {}

data/lib/red_grape/graph_store.rb

@@ -0,0 +1,29 @@
+require 'red_grape'
+
+module RedGrape
+  class GraphStore
+    def initialize
+      @graphs = {}
+    end
+
+    def graph_names
+      @graphs.keys.sort
+    end
+
+    def graph(key)
+      @graphs[key.to_s.to_sym]
+    end
+    alias [] graph
+
+    def put_graph(key, graph)
+      graph.name = key.to_s.to_sym
+      self << graph
+    end
+    alias []= put_graph
+
+    def <<(graph)
+      raise ArgumentError.new('The given graph does not have its name.') unless graph.name
+      @graphs[graph.name.to_sym] = graph
+    end
+  end
+end

data/lib/red_grape/pipe/base.rb

@@ -62,10 +62,8 @@ module RedGrape
             context.resume_from_aggregating
           elsif context.grouping?
             context.resume_from_grouping
-          elsif context.gathering?
-            context.resume_from_gathering
-          elsif context.counting?
-            context.resume_from_counting
+          elsif context.accumulating?
+            context.resume_from_accumulating
           else
             val
           end

data/lib/red_grape/pipe/context.rb

@@ -7,11 +7,13 @@ module RedGrape
       def initialize
         @history = []
         @marks = {}
+
         @aggregating_items = {}
         @aggregated_items = {}
         @grouping_items = {}
-        @gathering_items = []
-        @counting_items = []
+
+        @accumulated_items = {}
+
         @loops = 1
       end
 
@@ -88,44 +90,92 @@ module RedGrape
         end
       end
 
-      def gather(obj, next_pipe)
-        @gathering_items << [obj, next_pipe]
+      def accumulate(key, obj, &block)
+        items = (@accumulated_items[key] ||= {})
+        (items[:objects] ||= []) << obj
+        items[:resume_block] = block if block
       end
 
-      def gathering?
-        not @gathering_items.empty?
+      def accumulating?(key=nil)
+        if key
+          not @accumulated_items[key].nil?
+        else
+          @accumulated_items.any?{|k, _| accumulating? k}
+        end
       end
 
-      def clear_gathering
-        @gathering_items.clear
+      def clear_accumulating(key=nil)
+        if key
+          @accumulated_items[key] = nil if @accumulated_items[key]
+        else
+          @accumulated_items.clear
+        end
       end
 
-      def resume_from_gathering
-        obj, pipe = *@gathering_items.first
-        objs = @gathering_items.map &:first
-        objs.should_pass_through_whole = true
-        if pipe
-          push_history objs do |ctx|
-            pipe.prev = objs
-            pipe.take ctx
+      def resume_from_accumulating(key=nil, should_clear=true)
+        ret = nil
+        if key
+          if items = @accumulated_items[key]
+            ret = items[:resume_block].call(items[:objects]) if items[:resume_block]
           end
+          @accumulated_items[key] = nil if should_clear
         else
-          objs
+          @accumulated_items.each do |k, _|
+            ret = resume_from_accumulating k
+          end
+        end
+        ret
+      end
+
+      def gather(obj, next_pipe)
+        accumulate :gather, obj do |objs|
+          objs = objs.dup
+          objs.should_pass_through_whole = true
+          if next_pipe
+            push_history objs do |ctx|
+              next_pipe.prev = objs
+              next_pipe.take ctx
+            end
+          else
+            objs
+          end
         end
       end
 
+      def gathering?
+        accumulating? :gather
+      end
+
+      def resume_from_gathering
+        resume_from_accumulating :gather
+      end
+
       def count(obj, next_pipe)
-        @counting_items << obj
+        accumulate :count, obj do |objs|
+          objs.size
+        end
       end
 
       def counting?
-        not @counting_items.empty?
+        accumulating? :count
       end
 
       def resume_from_counting
-        size = @counting_items.size
-        @counting_items.clear
-        size
+        resume_from_accumulating :count
+      end
+
+      def order(obj, next_pipe)
+        accumulate :order, obj do |objs|
+          objs.sort
+        end
+      end
+
+      def ordering?
+        accumulating? :order
+      end
+
+      def resume_from_ordering
+        resume_from_accumulating :order
       end
 
       def eval(args={}, &block)

data/lib/red_grape/pipe/order_pipe.rb

@@ -0,0 +1,12 @@
+require 'red_grape/pipe/base'
+
+module RedGrape
+  module Pipe
+    class OrderPipe < Pipe::Base
+      def pass(obj, context)
+        context.order obj, self.next
+        obj
+      end
+    end
+  end
+end

data/lib/red_grape/pipe/{paths_pipe.rb → path_pipe.rb}

@@ -1,9 +1,18 @@
+require 'forwardable'
 require 'red_grape/pipe/base'
-require 'red_grape/path_group'
 
 module RedGrape
+  class PathGroup
+    extend Forwardable
+    def_delegators :@paths, :size, :to_s, :[], :first, :last
+
+    def initialize(ary)
+      @paths = ary.dup
+    end
+  end
+
   module Pipe
-    class PathsPipe < Pipe::Base
+    class PathPipe < Pipe::Base
       def pass(obj, context)
         context.push_history obj do |ctx|
           history = ctx.history.dup
@@ -26,6 +35,6 @@ module RedGrape
       end
     end
 
-    PathPipe = PathsPipe
+    PathsPipe = PathPipe
   end
 end

data/lib/red_grape/pipe/scatter_pipe.rb

@@ -5,7 +5,7 @@ module RedGrape
     class ScatterPipe < Pipe::Base
       def pass(obj, context)
         obj.should_pass_through_whole = false
-        context.clear_gathering
+        context.clear_accumulating :gather
         pass_next context, obj
       end
     end      

data/lib/red_grape/pipe/select_pipe.rb

@@ -4,7 +4,14 @@ module RedGrape
   module Pipe
     class SelectPipe < Pipe::Base
       def pass(obj, context)
-        context.marks
+        if converter = self.opts[0]
+          context.marks.inject({}) do |h, kv| 
+            h[kv[0]] = context.eval(:it => kv[1], &converter)
+            h
+          end
+        else
+          context.marks
+        end
       end
     end
   end

data/lib/red_grape/tools/irg.rb

@@ -2,7 +2,7 @@ require 'drb/drb'
 require 'irb'
 require 'irb/completion'
 require 'red_grape'
-require 'red_grape/tools/graph_store'
+require 'red_grape/tools/trellis'
 
 module RedGrape
   module Tools
@@ -61,7 +61,7 @@ Subcommands:
         }
 
         RedGrape.set_auto_take
-        $store = RedGrape::Tools::GraphStore.open port if port
+        $store = RedGrape::Tools::Trellis.open port if port
         block.call if block
         IRB.start
       end

data/lib/red_grape/tools/{graph_store.rb → trellis.rb}

@@ -1,9 +1,10 @@
 require 'drb/drb'
 require 'red_grape'
+require 'red_grape/graph_store'
 
 module RedGrape
   module Tools
-    class GraphStore
+    class Trellis < GraphStore
       DEFAULT_PORT = 28282
 
       class << self
@@ -32,26 +33,6 @@ module RedGrape
           end
       end
 
-      def graphs
-        @graphs.keys.sort
-      end
-
-      def graph(key)
-        self[key]
-      end
-
-      def put_graph(key, graph)
-        self[key] = graph
-      end
-
-      def [](key)
-        @graphs[key.to_sym]
-      end
-
-      def []=(key, graph)
-        @graphs[key.to_sym] = graph
-      end
-
       def start(port=nil, &block)
         at_exit do
           File.open @filename, 'w' do |file|

data/lib/red_grape.rb

@@ -1,5 +1,5 @@
 module RedGrape
-  VERSION = '0.0.12'
+  VERSION = '0.0.13'
 end
 
 require 'ext/nil_class_ext'
@@ -27,11 +27,12 @@ require 'red_grape/pipe/in_e_pipe'
 require 'red_grape/pipe/in_v_pipe'
 require 'red_grape/pipe/loop_pipe'
 require 'red_grape/pipe/map_pipe'
+require 'red_grape/pipe/order_pipe'
 require 'red_grape/pipe/out_pipe'
 require 'red_grape/pipe/out_e_pipe'
 require 'red_grape/pipe/out_v_pipe'
 require 'red_grape/pipe/property_pipe'
-require 'red_grape/pipe/paths_pipe'
+require 'red_grape/pipe/path_pipe'
 require 'red_grape/pipe/retain_pipe'
 require 'red_grape/pipe/scatter_pipe'
 require 'red_grape/pipe/select_pipe'
@@ -40,6 +41,7 @@ require 'red_grape/pipe/transform_pipe'
 require 'red_grape/pipe/v_pipe'
 require 'red_grape/pipe/e_pipe'
 require 'red_grape/graph'
+require 'red_grape/graph_store'
 
 module RedGrape
   module_function

data/public/cellar/graph.html

@@ -0,0 +1,220 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Force-Directed Layout</title>
+    <!--script type='text/javascript' src='/js/d3.v3.js'></script-->
+    <script type='text/javascript' src='/js/d3.v2.js'></script>
+    <style type='text/css'>
+
+div.node {
+  border-radius: 6px;
+  width: 12px;
+  height: 12px;
+  margin: -6px 0 0 -6px;
+  position: absolute;
+
+  border-radius: 10px;
+  width: 20px;
+  height: 20px;
+  margin: -10px 0 0 -10px;
+  color: white;
+  text-align:center;
+  vertical-align:middle;
+  font-size:0.5em;
+}
+
+div.link {
+  position: absolute;
+  border-bottom: solid #999 1px;
+  height: 0;
+  -webkit-transform-origin: 0 0;
+  -moz-transform-origin: 0 0;
+  -ms-transform-origin: 0 0;
+  -o-transform-origin: 0 0;
+  transform-origin: 0 0;
+
+  font-size:0.1em;
+  padding-left:10px;
+  white-space:nowrap;
+  color:#999;
+}
+
+div.graph {
+  position:absolute;
+  left:200px;
+  top:0;
+  height:auto;
+}
+
+div.inspector {
+  position:absolute;
+  top:0;
+  left:0;
+  width:200px;
+  height:500px;
+  height:100%;
+  background-color:#eee;
+  box-shadow: -2px 2px 3px #888 inset;
+}
+
+div.inspector h2 {
+  margin:0;
+  padding-left:10px;
+  margin-top:10px;
+  font-size:1em;
+  font-weight:normal;
+  background-color:gray;
+  color:white;
+}
+
+div.inspector dt {
+  border-bottom:1px solid gray;
+  display:block;
+  width:80px;
+  float:left;
+  padding-left:10px;
+  font-weight:bold;
+}
+
+div.inspector dd {
+  border-bottom:1px solid gray;
+  display:block;
+  width:160px;
+  height:auto;
+}
+    </style>
+  </head>
+  <body>
+    <script type='text/javascript'>
+function isIn(array, key) {
+  for (var i in array) {
+    if (array[i] == key) return true
+  }
+  return false;
+}
+
+var height = window.document.body.scrollHeight;
+var width = window.document.body.scrollWidth - 200;
+var graphId = window.location.hash.substring(1);
+var radius = 6,
+    fill = d3.scale.category20();
+var force = d3.layout.force()
+    .charge(-120)
+    .linkDistance(100)
+    .gravity(0)
+    .size([width, height]);
+var vis = d3.select('body').append('div')
+    .attr('class', 'graph')
+    .style('width', width + 'px')
+    .style('height', height + 'px');
+
+/*
+setTimeout(function() {
+  force.linkDistance(30);
+  force.stop();
+  vis.selectAll('div.link').style('font-size', '0');
+  force.start();
+}, 5000);
+
+setTimeout(function() {
+  force.linkDistance(100);
+  force.stop();
+  vis.selectAll('div.link').style('font-size', '0.1em');
+  force.start();
+}, 10000);
+*/
+
+var vertices = [];
+var edges = [];
+d3.json('/graphs/' + graphId + '/vertices', function(json) {
+  for (var i = 0; i < json.length; i++) {
+    vertices.push(json[i].results);
+  }
+
+  function getVertexIndex(id) {
+    for (var i = 0; i < vertices.length; i++) {
+      if (vertices[i]._id == id) return i;
+    }
+    return -1;
+  }
+
+  d3.json('/graphs/' + graphId + '/edges', function(json) {
+    for (var i = 0; i < json.length; i++) {
+      var result = json[i].results;
+      edges.push({
+        source:getVertexIndex(result._source),
+        target:getVertexIndex(result._target),
+        data:result
+      });
+    }
+
+    var link = vis.selectAll('div.link')
+        .data(edges)
+      .enter().append('div')
+        .attr('class', 'link');
+
+    link.append('text')
+     .attr('text-anchor', 'middle')
+     .attr('dy', '.1em')
+     .text(function(d) { return '-[' + d.data._label + ']->'; });
+
+    var node = vis.selectAll('div.node')
+        .data(vertices)
+      .enter().append('div')
+        .attr('class', 'node')
+        .style('background', function(d) { return fill(d.group); })
+        .style('border-color', function(d) { return d3.rgb(fill(d.group)).darker(); })
+        .on('click', function(d) { 
+          var props = '';
+          for (var k in d) {
+            if (!isIn(['_type', 'index', 'weight', 'x', 'y', 'px', 'py', 'fixed'], k)) {
+              props += '<dt>' + k + '</dt><dd>' + d[k] + '</dd>'; 
+            }
+          }
+          d3.select('.inspector').html('<h2>Properties</h2><dl>' + props + '</dl>'); 
+        })
+        .call(force.drag);
+
+    node.append('text')
+     .attr('text-anchor', 'middle')
+     .attr('dy', '.3em')
+     .text(function(d) { return d._id; });
+
+    force
+        .nodes(vertices)
+        .links(edges)
+        .on('tick', tick)
+        .start();
+
+    function tick() {
+      node.style('left', function(d) { return (d.x = Math.max(radius, Math.min(width - radius, d.x))) + 'px'; })
+          .style('top', function(d) { return (d.y = Math.max(radius, Math.min(height - radius, d.y))) + 'px'; });
+
+      link.style('left', function(d) { return d.source.x + 'px'; })
+          .style('top', function(d) { return d.source.y + 'px'; })
+          .style('width', length)
+          .style('-webkit-transform', transform)
+          .style('-moz-transform', transform)
+          .style('-ms-transform', transform)
+          .style('-o-transform', transform)
+          .style('transform', transform);
+    }
+
+    function transform(d) {
+      return 'rotate(' + Math.atan2(d.target.y - d.source.y, d.target.x - d.source.x) * 180 / Math.PI + 'deg)';
+    }
+
+    function length(d) {
+      var dx = d.target.x - d.source.x,
+          dy = d.target.y - d.source.y;
+      return Math.sqrt(dx * dx + dy * dy) + 'px';
+    }
+  });
+});
+    </script>
+    <div class='inspector'>
+      <h2>Properties</h2>
+      &nbsp;Click a node.
+    </div>
+  </body>
+</html>