red_grape 0.0.1 → 0.0.2

data/lib/ext/array_ext.rb

@@ -0,0 +1,41 @@
+class Array
+  def pass_through(pipe, context)
+    loops = context.loops
+    map! do |e| 
+      context.loops = loops
+      pipe.pass e._, context # TODO
+    end
+    context.loops = loops
+    normalize_for_graph
+  end
+
+  def normalize_for_graph
+    reject! {|e| e.nil? or (e.respond_to?(:empty?) and e.empty?)}
+    flatten!
+    self
+  end
+  
+  def vertex_array?
+    all?{|e| e.is_a? RedGrape::Vertex}
+  end
+  
+  def edge_array?
+    all?{|e| e.is_a? RedGrape::Edge}
+  end
+
+  def graph_item_array?
+    vertex_array? or edge_array?
+  end
+
+  alias method_missing_without_prop_pipe method_missing
+  def method_missing_with_prop_pipe(name, *args, &block)
+    if graph_item_array?
+      map! {|e| e.send name, *args, &block}
+    else
+      method_missing_without_prop_pipe name, *args, &block
+    end
+  end
+  alias method_missing method_missing_with_prop_pipe
+
+  
+end

data/lib/ext/object_ext.rb

@@ -0,0 +1,16 @@
+class Object
+  def pass_through(pipe, context)
+    pipe.pass self, context
+  end
+
+  def _
+    ret = self.dup
+    ret.extend RedGrape::Pipe::Out
+    ret.extend RedGrape::Pipe::OutE
+    ret.extend RedGrape::Pipe::In
+    ret.extend RedGrape::Pipe::SideEffect
+    ret.extend RedGrape::Pipe::As
+    ret.extend RedGrape::Pipe::Fill
+    ret
+  end
+end

data/lib/red_grape/edge.rb

@@ -1,8 +1,8 @@
-require 'red_grape/propertied_object'
+require 'red_grape/element'
 
 module RedGrape
-  class Edge < PropertiedObject
-    attr_reader :source, :target, :label
+  class Edge < Element
+    attr_reader :id, :source, :target, :label
 
     def initialize(graph, id, source, target, label, opts={})
       super graph, opts
@@ -14,21 +14,8 @@ module RedGrape
       @label = label
     end
 
-    def _id
-      @id
-    end
-
-    def _source
-      @source
-    end
-
-    def _target
-      @target
-    end
-
     def to_s
-      #"e[id(#{_id}):v[#{@source._id}]-v[#{@target._id}]:#{@property}]"
-      "e[#{_id}:v[#{@source._id}]-v[#{@target._id}]]"
+      "e[#{@id}][#{@source.id}-#{@label}->#{@target.id}]"
     end
   end
 end

data/lib/red_grape/{propertied_object.rb → element.rb}

@@ -1,11 +1,21 @@
 require 'red_grape/property_description'
 
 module RedGrape
-  class PropertiedObject
+  class Element
     def initialize(graph, opts={})
       @graph = graph
       @property = {}
-      @property_description = opts[:property_description] || {}
+      if opts[:property_description]
+        @property_description = opts[:property_description]
+        (opts[:property] || {}).each do |k, v|
+          self[k] = v
+        end
+      else
+        @property_description = {}
+        opts.each do |k, v|
+          self[k] = v
+        end
+      end
       @property_description.each do |k ,v|
         if v.is_a? Array
           v = PropertyDescription.new(*v)
@@ -17,6 +27,7 @@ module RedGrape
       end
     end
     
+    # set property value with type checking
     def set_property(kid, v)
       # TODO: should be refactored
       desc = @property_description[kid]
@@ -29,8 +40,8 @@ module RedGrape
       end
     end
 
+    # set property value without type checking
     def []=(k, v)
-      # TODO: type check?
       @property[k.to_s] = v
     end
 
@@ -38,9 +49,20 @@ module RedGrape
       @property[k.to_s]
     end
 
-    # TODO: $B$$$i$J$$!)(B
     def pass_through(pipe, context)
       pipe.pass self, context
     end
+
+    def copy(depth=nil)
+      self # TODO
+    end
+
+    def ==(obj)
+      self.class == obj.class && self.id == obj.id
+    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/graph.rb

@@ -1,57 +1,89 @@
-require 'stringio'
+require 'nokogiri'
 require 'red_grape/vertex'
-require 'red_grape/vertex_group'
 require 'red_grape/edge'
-require 'red_grape/edge_group'
 require 'red_grape/property_description'
+require 'red_grape/serializer/graphml_serializer'
 
 module RedGrape
   class Graph
-    # TODO: https://github.com/tinkerpop/blueprints/blob/bed2e64010882be66bf3b46d3c3e4b4ef4f6f2d9/blueprints-core/src/main/java/com/tinkerpop/blueprints/pgm/impls/tg/TinkerGraphFactory.java
-    NAMESPACES = {
-      'xmlns' => 'http://graphml.graphdrawing.org/xmlns',
-      'xsi' => 'http://www.w3.org/2001/XMLSchema-instance'
-    }
-
-    class <<self
+    class << self
       def load(filename)
-        if filename =~ /^<\?xml/
-          self.new.load StringIO.new(filename)
-        else
-          self.new.load filename
+        self.new.load filename
+      end
+
+      def create_tinker_graph
+        self.new 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'
+          v4 = g.add_vertex 4, name:'josh', age:32
+          v5 = g.add_vertex 5, name:'ripple', lang:'java'
+          v6 = g.add_vertex 6, name:'peter', age:35
+          g.add_edge 7, v1, v2, 'knows', weight:0.5
+          g.add_edge 8, v1, v4, 'knows', weight:1.0
+          g.add_edge 9, v1, v3, 'created', weight:0.4
+          g.add_edge 10, v4, v5, 'created', weight:1.0
+          g.add_edge 11, v4, v3, 'created', weight:0.4
+          g.add_edge 12, v6, v3, 'created', weight:0.2
         end
       end
     end
 
-    def initialize
+    attr_accessor :serializer
+      
+    def initialize(&block)
+      @serializer = Serializer::GraphMLSerializer.new self
       @vertices = {}
       @edges = {}
       @property_descriptions = {}
+      block.call self if block
     end
 
-    def vertex(*id)
-      if 1 < id.size
-        VertexGroup.new(id.map{|i| @vertices[i.to_s]})
+    def items(type, *id)
+      items = case type
+        when :vertex, :vertices
+          @vertices
+        when :edge, :edges
+          @edges
+        else
+          raise ArgumentError.new('type should be :vertex or :edge')
+        end
+
+      if id.size == 2 # TODO: for the time being
+        items.values.select{|e| e[id[0]] == id[1]}
+      elsif 1 < id.size
+        id.map{|i| items[i.to_s]}
       elsif id.size == 0
-        VertexGroup.new @vertices.values
+        items.values
       else
         case id.first
         when Array
-          VertexGroup.new(id.first.map{|i| @vertices[i.to_s]})
+          id.first.map{|i| items[i.to_s]}
         when :all
-          VertexGroup.new @vertices.values
+          items.values
         else
-          @vertices[id.first.to_s]
+          items[id.first.to_s]
         end
       end
     end
-    alias v vertex
-    alias V vertex
 
-    def edge(id)
-      @edges[id.to_s]
+    def vertex(*id)
+      items :vertex, *id
+    end
+
+    def v(*id)
+      vertex(*id)._
     end
-    alias e edge
+    alias V v
+
+    def edge(*id)
+      items :edge, *id
+    end
+
+    def e(*id)
+      edge(*id)._
+    end
+    alias E e
 
     def add_vertex(id, v=nil)
       if v
@@ -62,78 +94,48 @@ module RedGrape
         if id.is_a? Hash
           v = id
           id = v[:id] || v['id']
-        else
+        elsif id.respond_to?(:id)
           v = id
-          id = v._id
+          id = v.id
+        else
+          v = {}
         end
         v = Vertex.new self, id, v
       end
-      raise ArgumentError.new 'invalid id' unless id == v._id
+      raise ArgumentError.new 'invalid id' unless id == v.id
 
       @vertices[id.to_s] = v
     end
 
-    def add_edge(id, label, from, to)
+    def add_edge(id, from, to, label, opts={})
       edge = if id.is_a? Edge
           id
         else
           id = id.to_s
           from = self.vertex[from.to_s] unless from.is_a? Vertex
           to = self.vertex[to.to_s] unless to.is_a? Vertex
-          add_vertex from unless self.vertex(from._id)
-          add_vertex to unless self.vertex(to._id)
-          Edge.new self, id, from, to, label
+          add_vertex from unless self.vertex(from.id)
+          add_vertex to unless self.vertex(to.id)
+          Edge.new self, id, from, to, label, opts
         end
-      @edges[edge._id] = edge
+      @edges[edge.id] = edge
     end
 
-    def load(file, type=:xml)
-      file = File.open file if file.is_a? String
-      case type
-      when :xml
-        parse_xml Nokogiri::XML(file)
-      end
-      self
+    def load(filename)
+      @serializer.load filename
     end
 
-    # assumption: any sub-graph does not exist.
-    def parse_xml(xml)
-      nodes(xml, 'key').each do |key_elm|
-        defaults = nodes key_elm, 'default'
-        default = defaults.size == 0 ? nil : defaults.first.children.to_s
-        prop = PropertyDescription.new key_elm['attr.name'], key_elm['attr.type'], default
-        (@property_descriptions[key_elm['for']] ||= {})[key_elm['id']] = prop
-      end
-      nodes(xml, 'node').each do |node_elm|
-        vertex = Vertex.new self, node_elm['id'], 
-          :property_description => @property_descriptions['node']
-        data = nodes node_elm, 'data'
-        data.each do |data_elm|
-          vertex.set_property data_elm['key'], data_elm.children.first.to_s
-        end
-        @vertices[vertex._id] = vertex
-      end
-      nodes(xml, 'edge').each do |edge_elm|
-        edge = Edge.new self, edge_elm['id'], edge_elm['source'], edge_elm['target'], 
-          edge_elm['label'], :property_description => @property_descriptions['edge']
-        data = nodes edge_elm, 'data'
-        data.each do |data_elm|
-          edge.set_property data_elm['key'], data_elm.children.first.to_s
-        end
-        @edges[edge._id] = edge
-      end
+    def save(file)
+      file = File.open file if file.is_a? String
+      @serializer.save file
     end
 
     def find(*args)
       Graph::Vertex.new
     end
 
-    def nodes(xml, elm)
-      xml.xpath(".//xmlns:#{elm}", NAMESPACES)
-    end
-
     def to_s
-      {:vertices => @vertices, :edges => @edges}.to_s
+      "redgrape[vertices:#{@vertices.size} edges:#{@edges.size}]"
     end
   end
 end

data/lib/red_grape/path_group.rb

@@ -1,16 +1,12 @@
-#TODO delegate to an array
+require 'forwardable'
+
 module RedGrape
   class PathGroup
+    extend Forwardable
+    def_delegators :@paths, :size, :to_s, :[], :first, :last
+
     def initialize(ary)
       @paths = ary.dup
     end
-
-    def size
-      @paths.size
-    end
-
-    def to_s
-      @paths.to_s
-    end
   end
 end

data/lib/red_grape/pipe/aggregate_pipe.rb

@@ -0,0 +1,13 @@
+require 'red_grape/pipe/base'
+
+module RedGrape
+  module Pipe
+    class AggregatePipe < Pipe::Base
+      def pass(obj, context)
+        key = self.opts.first
+        context.aggregate key, obj, self.next
+        obj
+      end
+    end
+  end
+end

data/lib/red_grape/pipe/as_pipe.rb

@@ -16,16 +16,9 @@ module RedGrape
           # TODO: why??
           context.mark! label
           obj
-        when Vertex
-          if self.last?
-            context.mark! label
-            obj
-          else
-            context.push_history obj do |ctx|
-              context.mark! label
-              obj.pass_through self.next, ctx
-            end
-          end
+        when Vertex, Array
+          context.mark! label, obj
+          obj.pass_through self.next, context
         else
           raise 'not yet'
         end

data/lib/red_grape/pipe/back_pipe.rb

@@ -11,14 +11,7 @@ module RedGrape
           else
             context.mark label
           end
-
-        if self.last?
-          obj 
-        else
-          context.push_history obj do |ctx|
-            obj.pass_through self.next, ctx
-          end
-        end
+        pass_next context, obj
       end
     end
   end

data/lib/red_grape/pipe/base.rb

@@ -2,6 +2,16 @@ require 'red_grape/pipe/context'
 
 module RedGrape
   module Pipe
+    @@auto_take = false
+
+    def self.auto_take
+      @@auto_take
+    end
+
+    def self.set_auto_take(val=true)
+      @@auto_take = val
+    end
+
     class Base
       attr_accessor :opts, :prev, :next, :value
 
@@ -30,15 +40,38 @@ module RedGrape
 
       def take
         if first?
-          @prev.pass_through self, Pipe::Context.new
+          context = Context.new
+          val = @prev.pass_through self, context
+          if context.aggregating?
+            context.resume_from_aggregating
+          elsif context.grouping?
+            context.resume_from_grouping
+          else
+            val
+          end
         else
           @prev.take
         end
       end
 
+      def pass_next(context, pushed_obj, next_obj=nil, &block)
+        next_obj ||= pushed_obj
+        if self.last?
+          block.call if block
+          next_obj
+        elsif pushed_obj.nil?
+          block.call if block
+          next_obj.pass_through self.next, context
+        else
+          context.push_history pushed_obj do |ctx|
+            block.call if block
+            next_obj.pass_through self.next, ctx
+          end
+        end
+      end
+
       def to_s
-        #TODO: flag
-        take.to_s
+        Pipe.auto_take ? take.to_s : super
       end
 
       def to_a
@@ -54,7 +87,7 @@ module RedGrape
       def size
         len = 0
         pipe = self
-        while pipe.is_a?(RedGrape::Pipe::Base) and pipe.prev
+        while pipe.is_a?(Pipe::Base) and pipe.prev
           len += 1 
           pipe = pipe.prev
         end
@@ -66,15 +99,27 @@ module RedGrape
         self.class.new nil, @opts, &@block
       end
 
+      def copy(depth=nil)
+        obj = self.class.new nil, @opts, &@block
+        if depth.nil?
+          obj.prev = self.prev.copy
+          obj.prev.next = obj
+        elsif 0 < depth
+          obj.prev = self.prev.copy(depth - 1)
+          obj.prev.next = obj
+        end
+        obj
+      end
+
       def method_missing(name, *args, &block)
         class_name = "#{name.to_s.sub(/^./){$&.upcase}.gsub(/_(.)/){$1.upcase}}Pipe"
         args.unshift block if block
         pipe_class =
-          if RedGrape::Pipe.const_defined? class_name
+          if Pipe.const_defined? class_name
             eval "RedGrape::Pipe::#{class_name}"
           else
             args.unshift name
-            RedGrape::Pipe::PropertyPipe
+            PropertyPipe
           end
         @next = pipe_class.new self, *args
       end

data/lib/red_grape/pipe/cap_pipe.rb

@@ -0,0 +1,16 @@
+require 'red_grape/pipe/base'
+
+module RedGrape
+  module Pipe
+    class CapPipe < Pipe::Base
+      def pass(obj, context)
+        ret = {}
+        context.grouping_items.each do |e|
+          ret[e.first] ||= 0
+          ret[e.first] += 1
+        end
+        ret
+      end
+    end
+  end
+end

data/lib/red_grape/pipe/context.rb

@@ -2,11 +2,14 @@ module RedGrape
   module Pipe
     class Context
       attr_accessor :it, :loops
-      attr_reader :history
+      attr_reader :history, :grouping_items
 
       def initialize
         @history = []
         @marks = {}
+        @aggregating_items = {}
+        @aggregated_items = {}
+        @grouping_items = []
         @loops = 1
       end
 
@@ -17,14 +20,72 @@ module RedGrape
         ret 
       end
 
-      def mark!(label)
-        @marks[label] = @history.last
+      def mark!(label, val=nil)
+        @marks[label] = val || @history.last
       end
 
       def mark(label)
         @marks[label]
       end
 
+      def aggregated_items(key)
+        @aggregated_items[key.to_s.to_sym] ||= []
+      end
+
+      def aggregating_items(key)
+        @aggregating_items[key.to_s.to_sym] ||= []
+      end
+
+      def aggregate(key, val, next_pipe)
+        self.aggregating_items(key) << [val, next_pipe]
+        val
+      end
+
+      def aggregating?
+        not @aggregating_items.empty?
+      end
+
+      def resume_from_aggregating
+        ret = []
+        aggregating = @aggregating_items
+        @aggregating_items = {}
+        aggregating.each do |key, obj_and_pipes|
+          obj_and_pipes.each do |obj_and_pipe|
+            (@aggregated_items[key] ||= []) << obj_and_pipe.first
+          end
+        end
+
+        aggregating.each do |key, obj_and_pipes|
+          obj_and_pipes.each do |obj_and_pipe|
+            obj, pipe = *obj_and_pipe
+            push_history obj do |ctx|
+              ret << obj.pass_through(pipe, ctx)
+            end
+          end
+        end
+        ret.normalize_for_graph
+      end
+
+      def group(val, next_pipe)
+        @grouping_items << [val, next_pipe]
+        val
+      end
+
+      def grouping?
+        not @grouping_items.empty?
+      end
+
+      def resume_from_grouping
+        obj, pipe = *@grouping_items.first # TODO: is '.first' ok?
+        if pipe
+          push_history obj do |ctx|
+            obj.pass_through(pipe, ctx)
+          end
+        else
+          obj
+        end
+      end
+
       def eval(args={}, &block)
         args.each {|k, v| self.send "#{k}=", v}
         instance_eval(&block)

data/lib/red_grape/pipe/except_pipe.rb

@@ -0,0 +1,15 @@
+require 'red_grape/pipe/base'
+
+module RedGrape
+  module Pipe
+    class ExceptPipe < Pipe::Base
+      def pass(obj, context)
+        if context.aggregated_items(self.opts.first).include? obj
+          nil
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/red_grape/pipe/fill_pipe.rb

@@ -0,0 +1,19 @@
+require 'red_grape/pipe/base'
+
+module RedGrape
+  module Pipe
+    module Fill
+      def fill(*opts)
+        FillPipe.new self, *opts
+      end
+    end
+
+    class FillPipe < Pipe::Base
+      def pass(obj, context)
+        container = self.opts.first
+        container << obj
+        obj
+      end
+    end
+  end
+end