red_grape 0.0.1

data/lib/red_grape/pipe/loop_pipe.rb

@@ -0,0 +1,39 @@
+require 'red_grape/pipe/base'
+
+module RedGrape
+  module Pipe
+    class LoopPipe < Pipe::Base
+      def pass(obj, context) # TODO: 無理やり・・・
+        condition = self.opts.first
+        label = self.opts[1]
+
+        looped_pipe = self.prev.dup
+        looped_pipe.prev = self.prev.prev
+        (label - 1).times do
+          prev = looped_pipe.prev.dup
+          prev.next = looped_pipe
+          looped_pipe = prev
+        end
+
+        context.loops += 1
+        while context.eval :it => obj, &condition
+          pipe = looped_pipe
+          while pipe
+            obj = obj.pass_through pipe, context
+            pipe = pipe.next
+          end
+          context.loops += 1
+        end
+        context.loops = 1
+
+        if self.last?
+          obj
+        else
+          context.push_history obj do |ctx|
+            obj.pass_through self.next, ctx
+          end
+        end
+      end
+    end
+  end
+end

data/lib/red_grape/pipe/out_pipe.rb

@@ -0,0 +1,37 @@
+require 'red_grape/pipe/base'
+
+module RedGrape
+  module Pipe
+    module Out
+      def out(*opts)
+        OutPipe.new self, *opts
+      end
+    end
+
+    class OutPipe < Pipe::Base
+      def pipe_name
+        @opts.empty? ? super : "#{super}(#{@opts.first})"
+      end
+
+      def pass(obj, context)
+        case obj
+        when RedGrape::Vertex
+          group =
+            if self.opts.empty? or self.opts.first.empty? # TODO $B$J$<$+(Blabel$B$K(B[]$B$,F~$C$F$k(B
+              VertexGroup.new obj._out_edges.map(&:target)
+            else
+              label = self.opts.first
+              VertexGroup.new obj._out_edges.find_all{|e| e.label == label}.map(&:target)
+            end
+          if self.last?
+            group
+          else
+            context.push_history obj do |ctx|
+              group.pass_through self.next, ctx
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/red_grape/pipe/paths_pipe.rb

@@ -0,0 +1,24 @@
+require 'red_grape/pipe/base'
+require 'red_grape/path_group'
+
+module RedGrape
+  module Pipe
+    class PathsPipe < Pipe::Base
+      def pass(obj, context)
+        case obj
+        when 'TODO'
+        else
+          context.push_history obj do |ctx|
+            if self.last?
+              #ctx.history.dup
+              PathGroup.new ctx.history
+            else
+              # TODO
+              raise 'not implemented'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/red_grape/pipe/property_pipe.rb

@@ -0,0 +1,25 @@
+require 'red_grape/pipe/base'
+
+module RedGrape
+  module Pipe
+    class PropertyPipe < Pipe::Base
+      def pipe_name
+        "#{super}(#{@opts.first})"
+      end
+
+      def pass(obj, context)
+        case obj
+        when RedGrape::Vertex
+          prop = obj[self.opts.first]
+          if self.last?
+            prop
+          else
+            context.push_history obj do |ctx|
+              prop.pass_through self.next, ctx
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/red_grape/pipe/side_effect_pipe.rb

@@ -0,0 +1,23 @@
+require 'red_grape/pipe/base'
+
+module RedGrape
+  module Pipe
+    module SideEffect
+      def side_effect(&block)
+        SideEffectPipe.new self, block
+      end
+    end
+
+    class SideEffectPipe < Pipe::Base
+      def pass(obj, context)
+        side_effect = self.opts.first
+        context.eval :it => obj, &side_effect
+        if self.last?
+          obj
+        else
+          obj.pass_through self.next, context
+        end
+      end
+    end
+  end
+end

data/lib/red_grape/pipe/transform_pipe.rb

@@ -0,0 +1,21 @@
+require 'red_grape/pipe/base'
+
+module RedGrape
+  module Pipe
+    class TransformPipe < Pipe::Base
+      def pass(obj, context)
+        case obj
+        when 'TODO'
+        else
+          transformer = self.opts.first
+          val = context.eval :it => obj, &transformer
+          if self.last?
+            val
+          else
+            raise 'not implemented'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/red_grape/propertied_object.rb

@@ -0,0 +1,46 @@
+require 'red_grape/property_description'
+
+module RedGrape
+  class PropertiedObject
+    def initialize(graph, opts={})
+      @graph = graph
+      @property = {}
+      @property_description = opts[:property_description] || {}
+      @property_description.each do |k ,v|
+        if v.is_a? Array
+          v = PropertyDescription.new(*v)
+        elsif v.is_a? Hash
+          v = PropertyDescription.new v[:name], v[:type], v[:default]
+        end
+        @property_description[k] = v
+        set_property k, v.default if v.has_default?
+      end
+    end
+    
+    def set_property(kid, v)
+      # TODO: should be refactored
+      desc = @property_description[kid]
+      if desc.accessible? v
+        self[desc.name] = v
+      elsif desc.convertable? v
+        self[desc.name] = desc.convert v
+      else
+        raise ArgumentError.new "#{kid} should be #{desc.type}."
+      end
+    end
+
+    def []=(k, v)
+      # TODO: type check?
+      @property[k.to_s] = v
+    end
+
+    def [](k)
+      @property[k.to_s]
+    end
+
+    # TODO: $B$$$i$J$$!)(B
+    def pass_through(pipe, context)
+      pipe.pass self, context
+    end
+  end
+end

data/lib/red_grape/property_description.rb

@@ -0,0 +1,47 @@
+module RedGrape
+  class PropertyDescription
+    attr_reader :name, :type, :default
+
+    def initialize(name, type, default=nil)
+      @name = name
+      @type = type
+      @default = default
+    end
+
+    def accessible?(val)
+      case type
+      when 'int', 'integer'
+        val.is_a? Integer
+      else
+        true
+      end
+    end
+
+    def convertable?(val)
+      case type
+      when 'int', 'integer'
+        val =~ /^\d+$/
+      else
+        true
+      end
+    end
+
+    def convert(val)
+      case type
+      when 'int', 'integer'
+        val.to_i
+      else
+        val
+      end
+    end
+
+    def has_default?
+      not @default.nil?
+    end
+
+    def to_s
+      "{#{@name}:#{@type}:#{@default}}"
+    end
+  end
+end
+

data/lib/red_grape/vertex.rb

@@ -0,0 +1,46 @@
+require 'red_grape/propertied_object'
+
+module RedGrape
+  class Vertex < PropertiedObject
+    include RedGrape::Pipe::Out
+    include RedGrape::Pipe::OutE
+    include RedGrape::Pipe::SideEffect
+    include RedGrape::Pipe::As
+
+    def initialize(graph, id, opts={})
+      super graph, opts
+      @id = id
+      @out_edges = []
+      @in_edges = []
+    end
+
+    def _id
+      @id
+    end
+
+    def _in_edges
+      @in_edges
+    end
+
+    def _out_edges
+      @out_edges
+    end
+
+    def add_out_edge(edge)
+      @out_edges << edge
+    end
+
+    def add_in_edge(edge)
+      @in_edges << edge
+    end
+
+    def to_s
+      "v[#{_id}]"
+      #"v[id(#{_id}):#{@property}]"
+    end
+
+    def method_missing(name, *args, &block)
+      self[name.to_s] or raise NoMethodError.new(name.to_s)
+    end
+  end
+end

data/lib/red_grape/vertex_group.rb

@@ -0,0 +1,72 @@
+require 'red_grape/vertex'
+
+#TODO delegate to array
+module RedGrape
+  class VertexGroup < Vertex
+    def initialize(group=[])
+      @group = group
+    end
+
+    def _group
+      @group
+    end
+
+    def pass_through(pipe, context) 
+      @group.map! do |v|
+        pipe.pass v, context
+      end
+      @group.reject! do |v|
+        v.nil? or (v.respond_to?(:empty?) and v.empty?) # TODO
+      end
+      @group.map! do |v|
+        v.is_a?(self.class) ? v._group : v
+      end
+      #@group.flatten!
+      flatten_group!
+      @group.all? {|e| e.is_a? self.class} ? self : @group
+    end
+
+    def flatten_group
+      ret = []
+      @group.each do |v|
+        case v
+        when Array
+          ret += v.flatten
+        when self.class
+          ret += v._group.flatten_group
+        else
+          ret << v
+        end
+      end
+      ret
+    end
+
+    def flatten_group!
+      @group = flatten_group
+    end
+
+    def size
+      @group.size
+    end
+
+    def map(&block)
+      @group.map(&block)
+    end
+
+    def sort(&block)
+      @group.sort
+    end
+
+    def empty?
+      @group.empty?
+    end
+
+    def to_a
+      @group.dup.map{|e| e.is_a?(self.class) ? e.to_a : e}
+    end
+
+    def to_s
+      "[#{@group.map(&:to_s).join ', '}]"
+    end
+  end
+end

data/lib/red_grape.rb

@@ -0,0 +1,31 @@
+require 'nokogiri'
+require 'red_grape/pipe/in_pipe'
+require 'red_grape/pipe/out_pipe'
+require 'red_grape/pipe/property_pipe'
+require 'red_grape/pipe/paths_pipe'
+require 'red_grape/pipe/filter_pipe'
+require 'red_grape/pipe/transform_pipe'
+require 'red_grape/pipe/side_effect_pipe'
+require 'red_grape/pipe/if_then_else_pipe'
+require 'red_grape/pipe/back_pipe'
+require 'red_grape/pipe/as_pipe'
+require 'red_grape/pipe/loop_pipe'
+require 'red_grape/pipe/has_pipe'
+require 'red_grape/pipe/out_e_pipe'
+require 'red_grape/pipe/in_v_pipe'
+require 'red_grape/graph'
+
+module RedGrape
+  VERSION = '0.0.1'
+
+  module_function
+  def load_graph(filename)
+    Graph.load filename
+  end
+end
+
+class Object
+  def pass_through(pipe, context)
+    pipe.pass self, context
+  end
+end

data/test/test_graph.rb

@@ -0,0 +1,80 @@
+require 'test/unit'
+require 'stringio'
+require 'red_grape'
+
+class GraphTest < Test::Unit::TestCase
+  def test_vertex
+    graph = RedGrape::Graph.new
+    graph.add_vertex id:1, val:'a'
+    graph.add_vertex id:2, val:'b'
+    graph.add_vertex id:3, val:'c'
+
+    assert_equal 3, graph.vertex.size
+    assert_equal 1, graph.vertex(1)._id
+    assert_equal 2, graph.vertex(1, 2).size
+    assert_equal 2, graph.vertex([1, 2]).size
+    assert_equal 3, graph.vertex(:all).size
+  end
+
+  def test_construct
+    graph = RedGrape::Graph.new
+    v1 = graph.add_vertex 1, name:'yasushi'
+    v2 = graph.add_vertex 2, name:'ando'
+    e12 = graph.add_edge 1, :fullname, v1, v2
+
+    assert_equal 1, v1._out_edges.size
+    assert_equal 0, v1._in_edges.size
+    assert_equal e12, v1._out_edges.first
+
+    assert_equal 0, v2._out_edges.size
+    assert_equal 1, v2._in_edges.size
+    assert_equal e12, v2._in_edges.first
+  end
+
+  def test_load
+    data = <<-EOS
+<?xml version="1.0" encoding="UTF-8"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+        http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+    <key id="weight" for="edge" attr.name="weight" attr.type="float"/>
+    <key id="name" for="node" attr.name="name" attr.type="string"/>
+    <graph id="G" edgedefault="directed">
+        <node id="1">
+            <data key="name">marko</data>
+        </node>
+        <node id="2">
+            <data key="name">vadas</data>
+        </node>
+        <node id="3">
+            <data key="name">lop</data>
+        </node>
+        <edge id="4" source="1" target="2" label="knows">
+            <data key="weight">0.5</data>
+        </edge>
+        <edge id="5" source="1" target="3" label="knows">
+            <data key="weight">1.0</data>
+        </edge>
+    </graph>
+</graphml>
+    EOS
+    graph = RedGrape::Graph.load data
+    assert_equal 'marko', graph.vertex(1).name
+    assert_equal 'vadas', graph.vertex(2).name
+    assert_equal 'lop', graph.vertex(3).name
+    assert_equal 'marko', graph.edge(4).source.name
+    assert_equal 'vadas', graph.edge(4).target.name
+    assert_equal 'marko', graph.edge(5).source.name
+    assert_equal 'lop', graph.edge(5).target.name
+    
+    graph = RedGrape::Graph.load StringIO.new(data)
+    assert_equal 'marko', graph.vertex(1).name
+    assert_equal 'vadas', graph.vertex(2).name
+    assert_equal 'lop', graph.vertex(3).name
+    assert_equal 'marko', graph.edge(4).source.name
+    assert_equal 'vadas', graph.edge(4).target.name
+    assert_equal 'marko', graph.edge(5).source.name
+    assert_equal 'lop', graph.edge(5).target.name
+  end
+end

data/test/test_on_the_nature_of_pipes.rb

@@ -0,0 +1,101 @@
+require 'test/unit'
+require 'red_grape'
+
+# test the patterns shown in: http://markorodriguez.com/2011/08/03/on-the-nature-of-pipes/
+class OnTheNatureOfPipesTest < Test::Unit::TestCase
+  def setup
+    @graph = RedGrape.load_graph 'data/graph-example-1.xml'
+  end
+
+  def test_basic
+    assert_equal '1',
+      @graph.v(1)._id
+
+    assert_equal %w(2 3 4), 
+      @graph.v(1).out.take.map(&:_id).sort
+
+    assert_equal %w(josh lop vadas), 
+      @graph.v(1).out.name.take.sort
+
+    paths = @graph.v(1).out.name.paths.take
+    assert_equal 3, 
+      paths.size
+
+    assert_equal [3, 3, 3], 
+      paths.map(&:size)
+
+    assert_equal %w[OutPipe PropertyPipe(name) PathsPipe], 
+      @graph.v(1).out.name.paths.to_a
+  end
+
+  def test_filter
+    assert_equal %w(2 4), 
+      @graph.v(1).out('knows').take.map(&:_id).sort
+
+    assert_equal %W(2), 
+      @graph.v(1).out('knows').filter{it.age < 30}.take.map(&:_id).sort
+
+    assert_equal %W(vadas),
+      @graph.v(1).out('knows').filter{it.age < 30}.name.take.sort
+
+    assert_equal [5], 
+      @graph.v(1).out('knows').filter{it.age < 30}.name.transform{it.size}.take.sort
+
+    assert_equal %w[OutPipe(knows) FilterPipe PropertyPipe(name) TransformPipe], 
+      @graph.v(1).out('knows').filter{it.age < 30}.name.transform{it.size}.to_a
+  end
+
+  def test_side_effect
+    assert_equal 'marko', 
+      @graph.v(1).side_effect{@x = it}.take.name
+
+    assert_equal %w(3), 
+      @graph.v(1).side_effect{@x = it}.out('created').take.map(&:_id).sort
+
+    assert_equal %w(1 4 6), 
+      @graph.v(1).side_effect{@x = it}.out('created').in('created').take.map(&:_id).sort
+
+    assert_equal %w(4 6), 
+      @graph.v(1).side_effect{@x = it}.out('created').in('created').filter{it != @x}.take.map(&:_id).sort
+
+    assert_equal %w(SideEffectPipe OutPipe(created) InPipe(created) FilterPipe), 
+      @graph.v(1).side_effect{@x = it}.out('created').in('created').filter{it != @x}.to_a
+  end
+
+  def test_if_then_else
+    #assert_equal ['vadas', ['ripple', 'lop']], 
+    assert_equal ['vadas', 'ripple', 'lop'], 
+      @graph.v(1).out('knows').if_then_else(proc{it.age < 30}, proc{it.name}, proc{it.out('created').name}).take.to_a
+  end
+
+  def test_back
+    assert_equal %w(josh vadas),
+      @graph.v(1).out('knows').name.take.to_a.sort
+
+    assert_equal %w(vadas),
+      @graph.v(1).out('knows').name.filter{it[0] == 'v'}.take.to_a
+
+    assert_equal %w(2),
+      @graph.v(1).out('knows').name.filter{it[0] == 'v'}.back(2).take.to_a.map(&:_id)
+
+    assert_equal %w(OutPipe(knows) PropertyPipe(name) FilterPipe BackPipe),
+      @graph.v(1).out('knows').name.filter{it[0] == 'v'}.back(2).to_a
+
+    assert_equal %w(2 4),
+      @graph.v(1).out('knows').as('here').name.filter{it[0] == 'v'}.back('here').take.to_a.map(&:_id)
+  end
+
+  def test_loop
+    assert_equal %w(3 5),
+      @graph.v(1).out.out.take.to_a.map(&:_id).sort
+
+    assert_equal %w(3 5),
+      @graph.v(1).out.loop(1){loops < 3}.take.to_a.map(&:_id).sort
+
+    assert_equal %w(lop ripple),
+      @graph.v(1).out.loop(1){loops < 3}.name.take.sort
+
+    assert_equal %w(OutPipe LoopPipe PropertyPipe(name)),
+      @graph.v(1).out.loop(1){loops < 3}.name.to_a
+  end
+end

data/test/test_propertied_object.rb

@@ -0,0 +1,42 @@
+require 'test/unit'
+require 'red_grape'
+require 'red_grape/propertied_object'
+require 'red_grape/property_description'
+
+class PropertiedObjectTest < Test::Unit::TestCase
+  def test_new
+    g = RedGrape::Graph.new
+    v = RedGrape::PropertiedObject.new g, property_description:{
+      name:RedGrape::PropertyDescription.new('name', 'string'),
+      sex:RedGrape::PropertyDescription.new('sex', 'string', 'male'),
+      age:RedGrape::PropertyDescription.new('age', 'integer')
+    }
+    desc = v.instance_eval '@property_description'
+    assert_equal 'name', desc[:name].name
+    assert_equal 'string', desc[:name].type
+    assert_nil desc[:name].default
+    assert_equal 'male', desc[:sex].default
+
+    v = RedGrape::PropertiedObject.new g, property_description:{
+      name:['name', 'string'],
+      sex:['sex', 'string', 'male'],
+      age:['age', 'integer']
+    }
+    desc = v.instance_eval '@property_description'
+    assert_equal 'name', desc[:name].name
+    assert_equal 'string', desc[:name].type
+    assert_nil desc[:name].default
+    assert_equal 'male', desc[:sex].default
+    
+    v = RedGrape::PropertiedObject.new g, property_description:{
+      name:{name:'name', type:'string'},
+      sex:{name:'sex', type:'string', default:'male'},
+      age:{name:'age', type:'integer'}
+    }
+    desc = v.instance_eval '@property_description'
+    assert_equal 'name', desc[:name].name
+    assert_equal 'string', desc[:name].type
+    assert_nil desc[:name].default
+    assert_equal 'male', desc[:sex].default
+  end
+end

data/test/test_red_grape.rb

@@ -0,0 +1,8 @@
+require "test/unit"
+require "red_grape"
+
+class TestRedGrape < Test::Unit::TestCase
+  def test_sanity
+    #flunk "write tests or I will kneecap you"
+  end
+end

data/test/test_traversal_patterns.rb

@@ -0,0 +1,18 @@
+require 'test/unit'
+require 'red_grape'
+
+class TraversalPatternsTest < Test::Unit::TestCase
+  def setup
+    @graph = RedGrape.load_graph 'data/graph-example-1.xml'
+  end
+
+  # https://github.com/tinkerpop/gremlin/wiki/Backtrack-Pattern
+  def test_backtrack_pattern
+    assert_equal [29], @graph.V.out('knows').has('age', :gt, 30).back(2).age.take
+    assert_equal [29], @graph.V.as('x').outE('knows').inV.has('age', :gt, 30).back('x').age.take
+  end
+
+  # https://github.com/tinkerpop/gremlin/wiki/Except-Retain-Pattern
+  def test_except_retain_pattern
+  end
+end