clusta 0.0.1

data/lib/clusta/geometry/vertex.rb

@@ -0,0 +1,11 @@
+module Clusta
+  module Geometry
+
+    class Vertex < Element
+      field :label
+    end
+    
+  end
+end
+
+  

data/lib/clusta/geometry/vertex_arrows.rb

@@ -0,0 +1,45 @@
+module Clusta
+  module Geometry
+    
+    class VertexArrows < Vertex
+      
+      input_fields :arrows
+
+      def joins? target_label
+        arrows.detect { |arrow| arrow.target_label == target_label }
+      end
+
+      def directed?
+        false
+      end
+
+      def source_degrees
+        [arrows.size]
+      end
+
+      def target_degrees
+        [1]
+      end
+
+      def edge_degree_pair source_label, target_label, *args
+        EdgeDegreePair.new(source_label, target_label, *args)
+      end
+
+      def edge_degrees_pairs
+        sds = source_degrees
+        arrows.map do |arrow|
+          edge_degree_pair(label, arrow.target_label, *(sds + target_degrees))
+        end
+      end
+
+      def reversed_edge_degree_pairs
+        sds = source_degrees
+        arrows.map do |arrow|
+          edge_degree_pair(arrow.target_label, label, *(target_degrees + sds))
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/clusta/runner.rb

@@ -0,0 +1,15 @@
+module Clusta
+  
+  class Runner
+
+    def initialize args
+      self.args = args
+    end
+
+    def run!
+      Settings.resolve!
+    end
+    
+  end
+  
+end

data/lib/clusta/transforms.rb

@@ -0,0 +1,50 @@
+module Clusta
+
+  module Transforms
+
+    def self.register_streamable klass, aliases=nil
+      (aliases || [klass.to_s]).each do |klass_alias|
+        Wukong::RESOURCE_CLASS_MAP[klass_alias] = klass
+      end
+    end
+
+    def self.register_transform name, path
+      autoload name, path
+    end
+
+    Dir[File.join(File.dirname(__FILE__), "transforms/*.rb")].each do |path|
+      require_name = Clusta.require_name(path)
+      register_transform Clusta.classify(require_name), "clusta/transforms/#{require_name}"
+    end
+    
+    ARG_REGEXP = /--transform=[\w\d_]+/
+
+    def self.from_arg arg
+      from_name(arg.split('=').last)
+    end
+
+    def self.from_name name
+      begin
+        const_get(Clusta.classify(name))
+      rescue NameError => e
+        raise Error.new("No such transform: '#{name}'")
+      end
+    end
+
+    def self.script_for transform
+      mapper  = transform::Mapper  if defined?(transform::Mapper)
+      reducer = transform::Reducer if defined?(transform::Reducer)
+      Wukong::Script.new(mapper, reducer)
+    end
+    
+  end
+
+  Geometry::ELEMENTS.each do |element_name|
+    Transforms.register_streamable Geometry.const_get(element_name), [
+       "Clusta::Geometry::#{element_name}",
+       "Geometry::#{element_name}",
+       element_name.to_s
+      ]
+  end
+  
+end

data/lib/clusta/transforms/edge_degree_pairs_to_assortativities.rb

@@ -0,0 +1,42 @@
+module Clusta
+
+  module Transforms
+
+    module EdgeDegreePairsToAssortativities
+
+      class Mapper < Wukong::Streamer::StructStreamer
+
+        def process edge_degree_pair, *record
+          emit edge_degree_pair.assortativity
+        end
+        
+      end
+
+      class Reducer < Wukong::Streamer::AccumulatingReducer
+
+        attr_accessor :assortativity
+
+        include Wukong::Streamer::StructRecordizer
+        
+        def get_key new_assortativity, *record
+          new_assortativity.key
+        end
+
+        def start! new_assortativity, *record
+          self.assortativity = new_assortativity.zero
+        end
+
+        def accumulate new_assortativity, *record
+          self.assortativity += new_assortativity
+        end
+
+        def finalize &block
+          emit self.assortativity
+        end
+        
+      end
+      
+    end
+  end
+  
+end

data/lib/clusta/transforms/edges_to_degrees.rb

@@ -0,0 +1,42 @@
+module Clusta
+
+  module Transforms
+
+    module EdgesToDegrees
+
+      class Mapper < Wukong::Streamer::StructStreamer
+
+        def process edge, *record
+          edge.degrees.each { |degree| emit(degree) }
+        end
+        
+      end
+
+      class Reducer < Wukong::Streamer::AccumulatingReducer
+
+        attr_accessor :degree
+        
+        include Wukong::Streamer::StructRecordizer
+        
+        def get_key new_degree, *record
+          new_degree.vertex_label
+        end
+
+        def start! new_degree, *record
+          self.degree = (new_degree.directed? ? new_degree.class.new(key, 0, 0) : new_degree.class.new(key, 0))
+        end
+
+        def accumulate new_degree, *record
+          self.degree += new_degree
+        end
+
+        def finalize &block
+          emit degree
+        end
+        
+      end
+      
+    end
+  end
+  
+end

data/lib/clusta/transforms/edges_to_vertex_arrows.rb

@@ -0,0 +1,50 @@
+module Clusta
+
+  module Transforms
+
+    module EdgesToVertexArrows
+
+      class Mapper < Wukong::Streamer::StructStreamer
+
+        def process edge, *record
+          emit edge
+          emit edge.reversed unless edge.directed?
+        end
+        
+      end
+
+      class Reducer < Wukong::Streamer::AccumulatingReducer
+
+        attr_accessor :arrows, :directed
+        
+        include Wukong::Streamer::StructRecordizer
+
+        alias_method :vertex_label, :key
+        
+        def get_key new_edge, *record
+          new_edge.source_label
+        end
+
+        def start! new_edge, *record
+          self.arrows   = []
+          self.directed = new_edge.directed?
+        end
+
+        def accumulate new_edge, *record
+          self.arrows << new_edge.arrow
+        end
+
+        def finalize &block
+          if directed
+            emit Geometry::DirectedVertexArrows.new(vertex_label, *arrows)
+          else
+            emit Geometry::VertexArrows.new(vertex_label, *arrows)
+          end
+        end
+        
+      end
+      
+    end
+  end
+  
+end

data/lib/clusta/transforms/import.rb

@@ -0,0 +1,17 @@
+module Clusta
+
+  module Transforms
+
+    module Import
+
+      class Mapper < Wukong::Streamer::Base
+
+        def process *record
+          emit record.unshift(Settings[:as])
+        end
+      end
+      
+    end
+  end
+  
+end

data/lib/clusta/transforms/vertex_arrows_to_edge_degree_pairs.rb

@@ -0,0 +1,63 @@
+module Clusta
+
+  module Transforms
+
+    module VertexArrowsToEdgeDegreePairs
+
+      class Mapper < Wukong::Streamer::StructStreamer
+
+        def process vertex_arrows, *record
+          vertex_arrows.reversed_edge_degree_pairs.each { |edge_degree| emit(edge_degree) }
+        end
+        
+      end
+
+      class Reducer < Wukong::Streamer::AccumulatingReducer
+
+        attr_accessor :edge_degree_pairs, :source_degree, :source_in_degree, :source_out_degree
+        
+        include Wukong::Streamer::StructRecordizer
+
+        def get_key new_edge_degree_pair, *record
+          new_edge_degree_pair.source_label
+        end
+
+        def start! new_edge_degree_pair, *record
+          self.edge_degree_pairs = []
+          if new_edge_degree_pair.directed?
+            self.source_in_degree  = 0
+            self.source_out_degree = 0
+          else
+            self.source_degree = 0
+          end
+        end
+
+        def accumulate new_edge_degree_pair, *record
+          self.edge_degree_pairs      << new_edge_degree_pair
+          if new_edge_degree_pair.directed?
+            self.source_in_degree  += new_edge_degree_pair.source_in_degree_value
+            self.source_out_degree += new_edge_degree_pair.source_out_degree_value
+          else
+            self.source_degree += new_edge_degree_pair.source_degree_value
+          end
+        end
+
+        def finalize &block
+          edge_degree_pairs.each do |edge_degree_pair|
+            if edge_degree_pair.directed?
+              edge_degree_pair.source_in_degree_value  = source_in_degree
+              edge_degree_pair.source_out_degree_value = source_out_degree
+            else
+              edge_degree_pair.source_degree_value = source_degree
+            end
+            emit edge_degree_pair
+          end
+        end
+        
+      end
+      
+    end
+  end
+  
+end
+

data/spec/clusta/geometry/element_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+
+describe Clusta::Geometry::Element do
+
+  describe "setting inheritable fields" do
+
+    it "should not define any fields of its own" do
+      Clusta::Geometry::Element.fields.should == []
+    end
+
+    it "should allow a subclass to set its own fields without polluting the parent" do
+      wrapper = Class.new(Clusta::Geometry::Element)
+      wrapper.field :foo
+      Clusta::Geometry::Element.field_names.should_not include('foo')
+      wrapper.field_names.should include('foo')
+    end
+
+    it "should allow a subclass of a subclass to set its own fields without polluting the parent" do
+      wrapper1 = Class.new(Clusta::Geometry::Element)
+      wrapper1.field :foo
+      wrapper2 = Class.new(wrapper1)
+      wrapper2.field :bar
+      
+      Clusta::Geometry::Element.field_names.should_not include('foo')
+      Clusta::Geometry::Element.field_names.should_not include('bar')
+      
+      wrapper1.field_names.should include('foo')
+      wrapper1.field_names.should_not include('bar')
+
+      wrapper2.field_names.should include('foo')
+      wrapper2.field_names.should include('bar')
+    end
+
+    it "should not allow for more than one optional field" do
+      wrapper = Class.new(Clusta::Geometry::Element)
+      wrapper.field :foo, :optional => true
+      lambda { wrapper.field :bar, :optional => true }.should raise_error
+    end
+  end
+
+  describe "initializing" do
+
+    it "should assign declared fields" do
+      wrapper = Class.new(Clusta::Geometry::Element)
+      wrapper.field :foo
+      wrapper.field :baz
+      instance = wrapper.new("bar", "boof")
+      instance.foo.should == "bar"
+      instance.baz.should == "boof"
+    end
+
+    it "should allow for an optional field at the end" do
+      wrapper = Class.new(Clusta::Geometry::Element)
+      wrapper.field :foo
+      wrapper.field :baz, :optional => true
+      instance = wrapper.new("bar")
+      instance.foo.should == "bar"
+      instance.baz.should == nil
+
+      instance = wrapper.new("bar", "boof")
+      instance.foo.should == "bar"
+      instance.baz.should == "boof"
+    end
+    
+  end
+  
+  describe "serializing" do
+
+    it "constructs an array" do
+      wrapper = Class.new(Clusta::Geometry::Element)
+      wrapper.field :foo
+      wrapper.field :baz
+      wrapper.new("bar", "boof").to_flat[1].should == 'bar'
+      wrapper.new("bar", "boof").to_flat[2].should == 'boof'
+    end
+
+    it "constructs an array with optional fields" do
+      wrapper = Class.new(Clusta::Geometry::Element)
+      wrapper.field :foo
+      wrapper.field :baz, :optional => true
+      wrapper.new("bar").to_flat[2].should == nil
+      wrapper.new("bar", "boof").to_flat[2].should == 'boof'
+    end
+    
+  end
+
+  describe "dealing with fields beyond those declared" do
+
+    it "should accept additional fields by default" do
+      instance = Clusta::Geometry::Element.new("foo", "bar", "baz")
+      instance.input_fields.should include("foo", "bar", "baz")
+    end
+
+    it "should serialize additional fields properly" do
+      instance = Clusta::Geometry::Element.new("foo", "bar", "baz")
+      instance.to_flat.should include("foo", "bar", "baz")
+    end
+    
+    it "should accept additional fields on a subclass" do
+      wrapper = Class.new(Clusta::Geometry::Element)
+      wrapper.field :foo
+      instance = wrapper.new("foovalue", "bar", "baz")
+      instance.foo.should == "foovalue"
+      instance.input_fields.should include("bar", "baz")
+    end
+
+    it "should serialize additional fields on a subclass properly" do
+      wrapper = Class.new(Clusta::Geometry::Element)
+      wrapper.field :foo
+      instance = wrapper.new("foovalue", "bar", "baz")
+      instance.to_flat.should include("foovalue", "bar", "baz")
+    end
+
+    it "should allow a subclass to alias input_fields" do
+      wrapper = Class.new(Clusta::Geometry::Element)
+      wrapper.field :foo
+      wrapper.input_fields :bar
+      instance = wrapper.new("foovalue", "bar", "baz")
+      instance.foo.should == "foovalue"
+      instance.bar.should == instance.input_fields
+    end
+
+    it "should behave sensibly with both an optional field and input fields" do
+      wrapper = Class.new(Clusta::Geometry::Element)
+      wrapper.field :foo
+      wrapper.field :bar, :optional => true
+      
+      instance = wrapper.new("foovalue", "barvalue", "extra1", "extra2")
+      instance.foo.should == 'foovalue'
+      instance.bar.should == 'barvalue'
+      instance.input_fields.should == ['extra1', 'extra2']
+
+      instance = wrapper.new("foovalue")
+      instance.foo.should == 'foovalue'
+      instance.bar.should be_nil
+      instance.input_fields.should be_empty
+      
+    end
+  end
+
+  describe "embedded geometry elements" do
+
+    it "should be able to instantiate embedded elements when named as fields" do
+      parent = Class.new(Clusta::Geometry::Element)
+      
+      parent.field :foo
+      parent.field :child, :type => :geometry
+      
+      instance = parent.new("foovalue", "Edge;1;2")
+      instance.foo.should == 'foovalue'
+      instance.child.source_label.should == '1'
+      instance.child.target_label.should == '2'
+    end
+
+    it "should be able to serialize embedded elements when named as fields" do
+      parent = Class.new(Clusta::Geometry::Element)
+      
+      parent.field :foo
+      parent.field :child, :type => :geometry
+
+      instance = parent.new('foovalue', Clusta::Geometry::Edge.new('1', '2'))
+      instance.to_flat.should include('foovalue', 'Edge;1;2')
+    end
+
+    it "should be able to instantiate embedded elements when given as input fields" do
+      parent = Class.new(Clusta::Geometry::Element)
+      
+      parent.field :foo
+      instance = parent.new("foovalue", "Edge;1;2", "Edge;3;4")
+      
+      instance.foo.should == 'foovalue'
+      
+      instance.input_fields.size.should == 2
+      instance.input_fields[0].source_label.should == '1'
+      instance.input_fields[0].target_label.should == '2'
+      instance.input_fields[1].source_label.should == '3'
+      instance.input_fields[1].target_label.should == '4'
+    end
+
+    it "should be able to serialize embedded elements when given as input fields" do
+      parent = Class.new(Clusta::Geometry::Element)
+      
+      parent.field :foo
+      instance = parent.new('foovalue', Clusta::Geometry::Edge.new('1','2'), Clusta::Geometry::Edge.new('3','4'))
+      instance.to_flat.should include('foovalue', 'Edge;1;2')
+    end
+    
+  end
+
+end
+