clusta 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Dhruv Bansal
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/clusta

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path('../lib', File.dirname(__FILE__)) unless $:.include?(File.expand_path('../lib', File.dirname(__FILE__)))
+
+require 'clusta'
+
+def usage
+  "usage: #{File.basename(__FILE__)} --transform=TRANSFORM_NAME [ARGS ...]"
+end
+
+def extract_transform_arg
+  transform_arg = ARGV.find_all { |arg| arg =~ Clusta::Transforms::ARG_REGEXP }.first
+  if transform_arg.nil?
+    $stderr.puts(usage)
+    exit(1)
+  end
+  # ARGV.delete_if { |arg| arg =~ Clusta::Transforms::ARG_REGEXP }
+  transform_arg
+end
+
+def add_default_run_arg
+  ARGV.unshift('--run=local') unless ARGV.detect { |arg| arg =~ /--run/ }
+end
+
+if $0 == __FILE__
+  begin
+    add_default_run_arg
+    transform = Clusta::Transforms.from_arg(extract_transform_arg)
+    script    = Clusta::Transforms.script_for(transform)
+    script.run
+  rescue Clusta::Error => e
+    $stderr.puts e.message
+    exit(1)
+  end
+end

data/lib/clusta.rb

@@ -0,0 +1,24 @@
+require 'wukong'
+
+module Clusta
+
+  def self.underscore string
+    string.gsub(/([A-Z])/, '_\1').downcase[1..-1]
+  end
+
+  def self.classify string
+    string.split('_').map(&:capitalize).join
+  end
+
+  def self.require_name path
+    File.basename(path).gsub(/\.rb$/, '')
+  end
+
+  Error                     = Class.new(StandardError)
+  DirectednessMismatchError = Class.new(Error)
+  AmbiguousArgumentsError   = Class.new(Error)
+
+  autoload :Geometry,   'clusta/geometry'
+  autoload :Transforms, 'clusta/transforms'
+  
+end

data/lib/clusta/geometry.rb

@@ -0,0 +1,25 @@
+module Clusta
+  
+  module Geometry
+
+    autoload :Element, 'clusta/geometry/element'
+
+    ELEMENTS = []
+
+    def self.register_geometry name, path, geometries=nil
+      autoload name, path
+      self::ELEMENTS << name
+    end
+
+    Dir[File.join(File.dirname(__FILE__), "geometry/*.rb")].each do |path|
+      require_name = Clusta.require_name(path)
+      register_geometry Clusta.classify(require_name), "clusta/geometry/#{require_name}"
+    end
+
+    Dir[File.join(File.dirname(__FILE__), "geometry/directed/*.rb")].each do |path|
+      require_name = Clusta.require_name(path)
+      register_geometry ("Directed" + Clusta.classify(require_name)), "clusta/geometry/directed/#{require_name}"
+    end
+
+  end
+end

data/lib/clusta/geometry/arrow.rb

@@ -0,0 +1,16 @@
+module Clusta
+  module Geometry
+
+    class Arrow < Element
+      field :target_label
+      field :weight, :optional => true
+
+      def directed?
+        false
+      end
+      
+    end
+    
+  end
+end
+

data/lib/clusta/geometry/assortativity.rb

@@ -0,0 +1,31 @@
+module Clusta
+
+  module Geometry
+
+    class Assortativity < Element
+
+      field :source_degree_value, :type => :int
+      field :target_degree_value, :type => :int
+      field :count,               :type => :int
+
+      def directed?
+        false
+      end
+
+      def key
+        [source_degree_value, target_degree_value]
+      end
+
+      def zero
+        self.class.new(*(key + [0]))
+      end
+
+      def +(other)
+        raise DirectednessMismatchError.new if other.directed?
+        self.class.new(*(key + [count + other.count]))
+      end
+      
+    end
+    
+  end
+end

data/lib/clusta/geometry/degree.rb

@@ -0,0 +1,28 @@
+module Clusta
+  module Geometry
+    
+    class Degree < Element
+
+      field :vertex_label
+      field :degree, :type => :int
+      
+      def directed?
+        false
+      end
+
+      def zero
+        self.class.new(vertex_label, 0)
+      end
+
+      def one deg=1
+        self.class.new(vertex_label, deg)
+      end
+      
+      def +(other)
+        raise DirectednessMismatchError.new if other.directed?
+        self.class.new(vertex_label, self.degree + other.degree)
+      end
+    end
+    
+  end
+end

data/lib/clusta/geometry/directed/arrow.rb

@@ -0,0 +1,12 @@
+module Clusta
+  module Geometry
+
+    class DirectedArrow < Arrow
+      def directed
+        true
+      end
+    end
+    
+  end
+end
+

data/lib/clusta/geometry/directed/degree.rb

@@ -0,0 +1,29 @@
+module Clusta
+  module Geometry
+    
+    class DirectedDegree < Element
+
+      field :vertex_label
+      field :in_degree,   :type => :int
+      field :out_degree,  :type => :int
+      
+      def directed?
+        true
+      end
+
+      def zero
+        self.class.new(vertex_label, 0, 0)
+      end
+
+      def one inbound=1, outbound=0
+        self.class.new(vertex_label, inbound, outbound)
+      end
+      
+      def +(other)
+        raise DirectednessMismatchError.new unless other.directed?
+        self.class.new(vertex_label, self.in_degree + other.in_degree, self.out_degree + other.out_degree)
+      end
+    end
+    
+  end
+end

data/lib/clusta/geometry/directed/edge.rb

@@ -0,0 +1,26 @@
+module Clusta
+  module Geometry
+    
+    class DirectedEdge < Edge
+      
+      def directed?
+        true
+      end
+
+      def source_degree
+        DirectedDegree.new(source_label, 0, 1)
+      end
+
+      def target_degree
+        DirectedDegree.new(target_label, 1, 0)
+      end
+
+      def arrow
+        DirectedArrow.new(target_label, weight)
+      end
+      
+
+    end
+    
+  end
+end

data/lib/clusta/geometry/directed/edge_degree_pair.rb

@@ -0,0 +1,24 @@
+module Clusta
+  module Geometry
+
+    class DirectedEdgeDegreePair < Element
+      field :source_label
+      field :target_label
+      field :source_in_degree_value,  :type => :int
+      field :source_out_degree_value, :type => :int
+      field :target_in_degree_value,  :type => :int
+      field :target_out_degree_value, :type => :int
+      field :weight,                  :optional => true
+
+      def directed?
+        true
+      end
+
+      def assortativity
+        Assortativity.new(source_in_degree_value, target_out_degree_value, 1)
+      end
+      
+    end
+    
+  end
+end

data/lib/clusta/geometry/directed/vertex_arrows.rb

@@ -0,0 +1,25 @@
+module Clusta
+  module Geometry
+    
+    class DirectedVertexArrows < VertexArrows
+      
+      def directed?
+        true
+      end
+
+      def source_degrees
+        [0, arrows.size]
+      end
+
+      def target_degrees
+        [1, 0]
+      end
+
+      def edge_degree_pair source_label, target_label, *args
+        DirectedEdgeDegreePair.new(source_label, target_label, *args)
+      end
+      
+    end
+    
+  end
+end

data/lib/clusta/geometry/edge.rb

@@ -0,0 +1,58 @@
+module Clusta
+  module Geometry
+
+    class Edge < Element
+
+      field :source_label
+      field :target_label
+      field :weight,      :optional => true
+
+      def weighted?
+        self.weight
+      end
+
+      def directed?
+        false
+      end
+
+      def joins? label
+        source_label == label || target_label == label
+      end
+
+      def labels_string
+        [source_label, target_label].map(&:to_s).join(' -> ')
+      end
+
+      def source_degree
+        Degree.new(source_label, 1)
+      end
+
+      def target_degree
+        Degree.new(target_label, 1)
+      end
+
+      def degrees
+        [source_degree, target_degree]
+      end
+
+      def degree_of label
+        case label
+        when source_label then source_degree
+        when target_label then target_degree
+        else
+          raise Error.new("This edge (#{labels_string}) does not contain vertex #{label}")
+        end
+      end
+
+      def reversed
+        self.class.new(target_label, source_label, weight)
+      end
+
+      def arrow
+        Arrow.new(target_label, weight)
+      end
+      
+    end
+    
+  end
+end

data/lib/clusta/geometry/edge_degree_pair.rb

@@ -0,0 +1,21 @@
+module Clusta
+  module Geometry
+
+    class EdgeDegreePair < Element
+      field :source_label
+      field :target_label
+      field :source_degree_value, :type => :int
+      field :target_degree_value, :type => :int
+
+      def directed?
+        false
+      end
+
+      def assortativity
+        Assortativity.new(source_degree_value, target_degree_value, 1)
+      end
+
+    end
+    
+  end
+end

data/lib/clusta/geometry/element.rb

@@ -0,0 +1,131 @@
+module Clusta
+  module Geometry
+
+    class Element
+      
+      attr_accessor :input_fields
+
+      @fields = []
+      class << self ; attr_reader :fields ; end
+
+      def self.inherited(subclass)
+        subclass.instance_variable_set("@fields", @fields.dup)
+        super
+      end
+
+      def self.field_names
+        @fields.map { |field| field[:name].to_s }
+      end
+
+      def self.has_optional_field?
+        @fields.any? { |field| field[:optional] }
+      end
+
+      def self.optional_field
+        @fields.detect { |field| field[:optional] }
+      end
+
+      def self.from_string string
+        return string unless string.is_a?(String)
+        args  = string.split(';')
+        klass_name = args.shift
+        raise ArgumentError.new("Elements instantiated from a string must match the format 'klass;[field1;[field2;]...]'") unless klass_name
+        Wukong.class_from_resource(klass_name).new(*args)
+      end
+      
+      def self.field name, options={}
+        raise AmbiguousArgumentsError.new("Cannot define a second optional field #{name} because field #{optional_field[:name]} is already optional.") if has_optional_field?
+        attr_reader name
+        case options[:type]
+        when :int
+          define_method "#{name}=" do |val|
+            instance_variable_set("@#{name}", val.to_i)
+          end
+        when :float
+          define_method "#{name}=" do |val|
+            instance_variable_set("@#{name}", val.to_f)
+          end
+        when :geometry
+          define_method "#{name}=" do |val|
+            instance_variable_set("@#{name}", self.class.from_string(val))
+          end
+        else
+          define_method "#{name}=" do |val|
+            instance_variable_set("@#{name}", val)
+          end
+        end
+        @fields << options.merge(:name => name)
+      end
+
+      def fields
+        self.class.fields
+      end
+
+      def self.input_fields name
+        alias_method name, :input_fields
+      end
+
+      def self.stream_name
+        if defined?(Settings) && Settings[:full_class_names]
+          to_s
+        else
+          to_s.split("::").last
+        end
+      end
+
+      def stream_name
+        self.class.stream_name
+      end
+
+      def initialize *args
+        self.class.fields.each_with_index do |field, index|
+          suffix = case index.to_s
+            when /1$/ then 'st'
+            when /2$/ then 'nd'
+            when /3$/ then 'rd'
+            else 'th'
+            end
+          case
+          when field[:optional]
+            self.send("#{field[:name]}=", args[index]) if args[index]
+          when args[index].nil?
+            raise ArgumentError.new("A #{self.class} requires a non-nil value for #{field[:name]} as its #{index}#{suffix} argument.")
+          else
+            self.send("#{field[:name]}=", args[index])
+          end
+        end
+        self.set_input_fields(*(args[self.class.fields.size..-1] || []))
+      end
+
+      def set_input_fields *input_fields
+        self.input_fields = input_fields.map do |field|
+          if field =~ /^[A-Z].*;/
+            self.class.from_string(field)
+          else
+            field
+          end
+        end
+      end
+
+      def output_fields
+        input_fields.map(&:to_s)
+      end
+
+      def to_flat
+        [stream_name].tap do |record|
+          fields.each do |field|
+            value  = send(field[:name])
+            record << value.to_s unless value.nil? && field[:optional]
+          end
+        end.concat(output_fields)
+      end
+
+      def to_s
+        to_flat.join(';')
+      end
+      
+    end
+
+  end
+end
+