diaspora-cluster-creator 0.2.0 → 0.3.0

data/lib/diaspora-cluster-creator/edge_drawer.rb

@@ -0,0 +1,41 @@
+module Diaspora
+  module Cluster
+    module Creator
+      class EdgeDrawer
+        extend DependencyInjector
+        def_injector(:dice) { FateDice.new }
+        attr_reader :cluster
+        def initialize(cluster)
+          @cluster = cluster
+        end
+        
+        def draw(nodes)
+          return @edges if @edges
+          nodes.each_with_index do |node, i|
+            result = dice.roll
+            if result < 0
+              connect(node, nodes[i+1])
+            elsif result == 0
+              connect(node, nodes[i+1], nodes[i+2])
+            elsif result > 0
+              connect(node, nodes[i+1], nodes[i+2], nodes[i+3])
+            end
+          end
+          @edges
+        end
+
+        private
+
+        def connect(node, *others)
+          @edges ||= []
+          others.flatten.compact.each do |other|
+            @edges << [node,other] 
+          end
+          @edges
+        end
+        
+      end
+    end
+  end
+end
+

data/lib/diaspora-cluster-creator/guarantor.rb

@@ -0,0 +1,21 @@
+module Diaspora
+  module Cluster
+    module Creator
+      class Guarantor
+        attr_reader :attribute_name, :minimum_value
+        def initialize(attribute_name = :technology, minimum_value = 2)
+          @attribute_name, @minimum_value = attribute_name, minimum_value
+        end
+        def guarantee!(nodes)
+          return nodes if nodes.detect {|ss| ss.send(attribute_name) >= minimum_value }
+          working = nodes.sort
+          working.first.send("#{attribute_name}=", minimum_value)
+          working.last.send("#{attribute_name}=", minimum_value)
+          nodes
+        rescue NoMethodError => e
+          nodes
+        end
+      end
+    end
+  end
+end

data/lib/diaspora-cluster-creator/node.rb

@@ -0,0 +1,71 @@
+require 'dependency_injector'
+require 'set'
+require_relative 'fate_dice'
+require_relative 'node_attribute'
+
+module Diaspora
+  module Cluster
+    module Creator
+      class Node
+        extend DependencyInjector
+        def_injector(:dice) { FateDice.new }
+        def_injector(:attribute_builder) { NodeAttribute.public_method(:new) }
+
+        attr_reader :cluster, :name, :attributes
+        def initialize(cluster, name_with_attribute_values)
+          @cluster = cluster
+          @attributes = []
+          yield(self) if block_given?
+          cluster.attributes.each do |attribute|
+            @attributes << attribute_builder.call(self,attribute)
+          end
+          set_name_and_attribute_values(name_with_attribute_values.to_s)
+        end
+        
+        def method_missing(method_name, *args, &block)
+          if attributes && attribute = attributes.detect {|a| a.to_sym == method_name.to_sym }
+            attribute.value
+          elsif attributes && attribute = attributes.detect {|a| "#{a.to_sym}=".to_sym == method_name.to_sym }
+            attribute.value = args.first
+          else
+            super
+          end
+        end
+        
+        include Comparable
+        def <=>(other)
+          to_i <=> other.to_i
+        end
+
+        def to_i
+          attributes.inject(0) {|m,v| m += v.to_i}
+        end
+
+        def to_s
+          name.to_s
+        end
+
+        def label
+          attributes.inject("#{name}\n") {|m,attrib| m << "#{attrib.label} "}.strip
+        end
+
+        protected
+        def set_name_and_attribute_values(name_with_attribtes)
+          /^(?<name>[^(?:\[|\{)]*)(?:(?:\[|\{)(?<encoded_attributes>[^(?:\]|\})]*)(?:\]|\}))?$/ =~ name_with_attribtes
+          @name = name.strip
+          extract_encoded_attributes(encoded_attributes)
+        end
+        def extract_encoded_attributes(encoded_attributes)
+          if encoded_attributes
+            encoded_attributes.split(/ +/).collect(&:strip).each do |option|
+              /(?<attribute_prefix>\w) *(?<attribute_value>-?\d)/ =~ option
+              if attribute = attributes.detect {|attrib| attrib.prefix =~ /^#{attribute_prefix}$/i}
+                attribute.value = attribute_value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/diaspora-cluster-creator/node_attribute.rb

@@ -0,0 +1,41 @@
+require 'delegate'
+require 'dependency_injector'
+require_relative 'fate_dice'
+require_relative 'attribute'
+
+module Diaspora
+  module Cluster
+    module Creator
+      class NodeAttribute < DelegateClass(Attribute)
+        extend DependencyInjector
+        def_injector(:dice) { FateDice.new }
+        
+        attr_reader :node
+        def initialize(node, attribute)
+          @node = node
+          super(attribute)
+        end
+        
+        def value
+          @value ||= dice.roll
+        end
+        
+        def value=(new_value)
+          @value = new_value.to_i
+        end
+        
+        def to_i
+          value
+        end
+        
+        def to_s
+          "#{super}#{to_i}"
+        end
+        
+        def label
+          "#{super}#{to_i}"
+        end
+      end
+    end
+  end
+end

data/lib/diaspora-cluster-creator/node_collection_factory.rb

@@ -0,0 +1,30 @@
+require 'dependency_injector'
+require_relative 'node'
+require_relative 'guarantor'
+
+module Diaspora
+  module Cluster
+    module Creator
+      class NodeCollectionFactory
+        extend DependencyInjector
+        def_injector(:node_builder) { Node.public_method(:new) }
+        def_injector(:node_guarantor) { Guarantor.new(:technology, 2).public_method(:guarantee!) }
+        
+        attr_reader :cluster
+        def initialize(cluster)
+          @cluster = cluster
+        end
+        
+        def build_from(names)
+          collection = []
+          names.each_with_object(collection) do |name,mem| 
+            mem << node_builder.call(cluster, name)
+          end
+          node_guarantor.call(collection)
+          collection
+        end
+      end
+    end
+  end
+end
+

data/lib/diaspora-cluster-creator/template.rb

@@ -3,36 +3,43 @@ module Diaspora
   module Cluster
     module Creator
       class Template
-        attr_reader :graph
-        def initialize(graph)
-          raise RuntimeError unless graph.respond_to?(:nodes)
-          raise RuntimeError unless graph.respond_to?(:edges)
-          @graph = graph
+        attr_reader :cluster
+        def initialize(cluster)
+          raise RuntimeError unless cluster.respond_to?(:each_node)
+          raise RuntimeError unless cluster.respond_to?(:each_edge)
+          @cluster = cluster
         end
+        
         def to_s
           canvas.to_s
         end
-        def to_dot(filename = 'graph.dot')
+        def to_dot(filename = 'cluster.dot')
           canvas.output(:dot => "#{filename}")
         end
-        def to_png(filename = 'graph.png')
+        def to_png(filename = 'cluster.png')
           canvas.output(:png => "#{filename}")
         end
+        def to_svg(filename = 'cluster.svg')
+          canvas.output(:svg => "#{filename}")
+        end
         protected
         def canvas
-          template = GraphViz.new(graph.to_s, :type => :graph )
-          nodes = {}
-          graph.nodes.each do |node|
-            nodes[node] = template.add_nodes(node.to_s, :label => (node.respond_to?(:label) ? node.label : node.to_s))
+          return @canvas if @canvas
+          @canvas = GraphViz.new(cluster.to_s, :type => :graph )
+
+          cluster.each_node do |node|
+            options = {}
+            options[:label] = (node.respond_to?(:label) ? node.label : node.to_s)
+            @canvas.add_nodes(node.to_s, options)
           end
-          
-          graph.edges.each do |edge|
+
+          cluster.each_edge do |edge|
             to = edge[0]
             from = edge[1]
-            template.add_edges(to.to_s, from.to_s)
+            @canvas.add_edges(to.to_s, from.to_s)
           end
-          
-          template
+
+          @canvas
         end
       end
     end

data/lib/diaspora-cluster-creator/version.rb

@@ -1,7 +1,7 @@
 module Diaspora
   module Cluster
     module Creator
-      VERSION = "0.2.0"
+      VERSION = "0.3.0"
     end
   end
 end

data/spec/diaspora-cluster-creator/attribute_collection_factory_spec.rb

@@ -0,0 +1,31 @@
+require_relative '../spec_helper_lite'
+require 'attribute_collection_factory'
+
+describe AttributeCollectionFactory do
+  subject { AttributeCollectionFactory.new(cluster)}
+  let(:cluster) { Object.new }
+  it 'should extract attributes from name' do
+    subject.attribute_builder = lambda {|string|
+      "attr-#{string}"
+    }
+    subject.build_from(['Magic','Trees','Cows']).must_equal(["attr-Magic", "attr-Trees", "attr-Cows"])
+  end
+
+  it 'should build from default when empty array is sent' do
+    attribute_builder = lambda {|string|
+      "attr-#{string}"
+    }
+    subject.attribute_builder = attribute_builder
+    expected = AttributeCollectionFactory::DEFAULT_ATTRIBUTE_NAMES.collect {|name| attribute_builder.call(name)}
+    subject.build_from([]).must_equal(expected)
+  end
+
+  it 'should build from default when nil is sent' do
+    attribute_builder = lambda {|string|
+      "attr-#{string}"
+    }
+    subject.attribute_builder = attribute_builder
+    expected = AttributeCollectionFactory::DEFAULT_ATTRIBUTE_NAMES.collect {|name| attribute_builder.call(name)}
+    subject.build_from(nil).must_equal(expected)
+  end
+end

data/spec/diaspora-cluster-creator/attribute_spec.rb

@@ -0,0 +1,69 @@
+require_relative '../spec_helper_lite'
+require 'attribute'
+
+describe Attribute do
+  describe 'with assumed prefix' do
+    subject { Attribute.new('Hair Color')}
+
+    describe '#to_s' do
+      it 'should use the name' do
+        subject.to_s.must_equal 'Hair Color'
+      end
+    end
+
+    describe '#to_sym' do
+      it 'should convert name to method friendly sym' do
+        subject.to_sym.must_equal :hair_color
+      end
+    end
+
+    describe '#name' do
+      it 'should have a name' do
+        subject.name.must_equal 'Hair Color'
+      end
+    end
+    describe '#prefix' do
+      it 'should default to first character' do
+        subject.prefix.must_equal 'H'
+      end
+    end
+
+    describe '#label' do
+      it 'should be the prefix' do
+        subject.label.must_equal(subject.prefix)
+      end
+    end
+  end
+
+  describe 'with extracted prefix' do
+    subject { Attribute.new('H(a)ir Color')}
+
+    describe '#to_s' do
+      it 'should use the name' do
+        subject.to_s.must_equal 'Hair Color'
+      end
+    end
+
+    describe '#to_sym' do
+      it 'should convert name to method friendly sym' do
+        subject.to_sym.must_equal :hair_color
+      end
+    end
+
+    describe '#name' do
+      it 'should have a name' do
+        subject.name.must_equal 'Hair Color'
+      end
+    end
+    describe '#prefix' do
+      it 'should be extracted' do
+        subject.prefix.must_equal 'A'
+      end
+    end
+    describe '#label' do
+      it 'should be the prefix' do
+        subject.label.must_equal(subject.prefix)
+      end
+    end
+  end
+end

data/spec/diaspora-cluster-creator/cluster_spec.rb

@@ -2,25 +2,76 @@ require_relative '../spec_helper_lite'
 require 'cluster'
 
 describe Cluster do
-  subject { Cluster.new(names) }
+  subject { Cluster.new(names, attribute_names) }
+  let(:attribute_names) { ['tech'] }
   let(:names) { ['a'] }
 
-  describe '#each' do
-    it 'should yield built star system' do
-      built_object = Object.new
-      transformed_object = Object.new
-      guarantor = MiniTest::Mock.new
-      builder = MiniTest::Mock.new
-      builder.expect(:call, built_object, [subject,'a'])
-      guarantor.expect(:call, [transformed_object], [[built_object]])
-      
-      subject.star_system_builder = builder
-      subject.star_system_guarantor = guarantor
+  describe '#each_node' do
+    it 'should yield the nodes' do
+      expected_output = [1,2,3]
+      subject.node_collection_builder = lambda { expected_output }
+      @yielded = []
+      subject.each_node do |node|
+        @yielded << node
+      end
+      @yielded.must_equal(expected_output)
+    end
+  end
+
+  describe '#nodes' do
+    it 'should delegate node creation to node_maker' do
+      expected_output = ['output']
+      maker = MiniTest::Mock.new
+      maker.expect(:call, expected_output)
+      subject.node_collection_builder = maker
+      subject.nodes.must_equal(expected_output)
+      maker.verify
+    end
+  end
+
+  describe '#each_edge' do
+    it 'should yield the edges' do
+      expected_output = [1,2,3]
+      subject.edge_collection_builder = lambda { expected_output }
       @yielded = []
-      subject.each {|object| @yielded << object  }
+      subject.each_edge do |edge|
+        @yielded << edge
+      end
+      @yielded.must_equal(expected_output)
+    end
+  end
+
+  describe '#edges' do
+    it 'should delegate edge drawing to the edge_collection_builder' do
+      expected_output = ['output']
+      drawer = MiniTest::Mock.new
+      drawer.expect(:call, expected_output)
+      subject.edge_collection_builder = drawer
+      subject.edges.must_equal(expected_output)
+      drawer.verify
+    end
+  end
+
+  describe '#each_attribute' do
+    it 'should yield the attributes' do
+      expected_output = [1,2,3]
+      subject.attribute_collection_builder = lambda { expected_output }
+      @yielded = []
+      subject.each_attribute do |attribute|
+        @yielded << attribute
+      end
+      @yielded.must_equal(expected_output)
+    end
+  end
+
+  describe '#attributes' do
+    it 'should delegate attribute creation to the attribute_collection_builder' do
+      expected_output = ['output']
+      builder = MiniTest::Mock.new
+      builder.expect(:call, expected_output)
+      subject.attribute_collection_builder = builder
+      subject.attributes.must_equal(expected_output)
       builder.verify
-      guarantor.verify
-      @yielded.must_equal [transformed_object]
     end
   end
 end