grandprix 0.0.4

data/lib/grandprix/graph.rb

@@ -0,0 +1,105 @@
+class Grandprix::Graph
+  def sort(graph)
+   Sort.new(graph).solve
+  end
+
+  class Sort
+    def initialize(graph)
+      @graph = graph
+      @preds_count = PredecessorCount.new graph
+      @successors  = SuccessorTable.new graph
+    end
+    
+    def solve
+      def visit(queue, ordered_vertices)
+        return ordered_vertices if queue.empty?
+        current, *rest = queue
+
+        successors = @successors.of(current)
+        @preds_count.decrement_all successors
+
+        new_queue = rest + @preds_count.zeroes_among(successors)
+        visit new_queue, ordered_vertices.push(current)
+      end
+
+      check_for_cycles visit(initial_queue, [])
+    end
+
+    private
+    def initial_queue
+      @preds_count.zeroes
+    end
+
+    def num_vertices
+      @preds_count.size
+    end
+
+    def check_for_cycles(seq)
+      raise CycleDetected if seq.size < num_vertices
+      seq
+    end
+  end
+
+  class PredecessorCount
+    def initialize(edges)
+      @counts = {}
+      edges.each do |j, k|
+        @counts[j] ||= 0 
+        @counts[k] ||= 0 
+
+        @counts[k] += 1
+      end
+    end
+
+    def decrement_all(vertices)
+      vertices.each do |suc|
+        @counts[suc] -= 1
+      end
+    end
+
+    def zeroes
+      @counts.select {|vertex,count| count == 0 }.keys      
+    end
+
+    def zeroes_among(vertices)
+      vertices.select do |v|
+        @counts[v] == 0
+      end
+    end
+
+    def size
+      @counts.size
+    end
+
+    def to_s
+      ks = @counts.keys.map{|k| k.to_s.rjust 2}.join(" ")
+      vs = @counts.values.map{|v| v.to_s.rjust 2}.join(" ")
+      "Predecessors:\n#{ks}\n#{vs}\n"
+    end
+  end
+
+  class SuccessorTable
+    def initialize(edges)
+      @successors = {}
+      edges.each do |j, k|
+        @successors[j] ||= []
+        @successors[k] ||= []
+
+        @successors[j].push k
+      end
+    end
+
+    def of(origin)
+      @successors[origin]
+    end
+
+    def to_s
+      ks = @successors.keys.map{|k| k.to_s.rjust 6}.join(" ")
+      vs = @successors.values.map{|v| v.inspect.rjust 6}.join(" ")
+      "Successors  :\n#{ks}\n#{vs}\n"
+    end
+  end
+
+  class CycleDetected < Exception
+  end
+end

data/lib/grandprix/planner.rb

@@ -0,0 +1,62 @@
+class Grandprix::Planner
+  def initialize(graph)
+    @graph = graph
+  end
+
+  def plan(topology, elements_array)
+    elements = Grandprix::Elements.build elements_array
+
+    nested_dependencies = project_array(topology, "after")
+    alongside = project_array(topology, "alongside")
+
+    dependencies = flatten_edges nested_dependencies
+
+    full_dependencies = dependencies.flat_map do |from, to|
+      extended_from = alongside[from] + [from]
+      extended_to   = alongside[  to] + [to  ]
+      new_deps = extended_from.product extended_to
+
+      eliminate_self_loops compact_pairs(new_deps)
+    end
+
+    before_relation = invert full_dependencies
+
+    in_order = @graph.sort before_relation
+
+    full_elements = elements.alongside alongside
+    independent_elements = elements.except in_order
+    elements_in_order = full_elements.reorder in_order 
+
+    all = independent_elements + elements_in_order
+    all.annotate project(topology, "annotation")
+  end
+
+  private
+  def project_array(hash, key)
+    projected = project(hash, key)
+    projected.tap { |h| h.default = [] }
+  end
+
+  def project(hash, key)
+    Hash[ compact_pairs hash.map{|element, config| [element, config[key]]} ]
+  end
+
+  def invert(edges)
+    edges.map {|k, v| [v, k]}
+  end
+
+  def compact_pairs(pairs)
+    pairs.reject do |pair|
+      pair.nil? || pair[0].nil? || pair[1].nil?
+    end
+  end
+
+  def eliminate_self_loops(pairs)
+    pairs.reject {|x, y| x == y }
+  end
+
+  def flatten_edges(vertex_to_successors)
+    vertex_to_successors.flat_map {|vertex_j, successors| successors.map {|vertex_k| [vertex_j, vertex_k] } }
+  end
+
+end

data/lib/grandprix/runner.rb

@@ -0,0 +1,6 @@
+class Grandprix::Runner
+  def run!(topology, elements)
+    graph = Grandprix::Graph.new
+    Grandprix::Planner.new(graph).plan(topology, elements)
+  end
+end

data/lib/grandprix/version.rb

@@ -0,0 +1,3 @@
+module Grandprix
+  VERSION = "0.0.1"
+end

data/spec/lib/grandprix/elements_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Grandprix::Elements do
+  def make(elements_array)
+    Grandprix::Elements.build elements_array
+  end
+
+  it { (make(["a","b"]) + make(["c","d"])).should == make(["a","b","c","d"]) }
+
+  it { (make(["a","b","c","d"]).except ["c","d"]).should == make(["a","b"]) }
+
+
+  it "should store extra information for each name" do
+    elements = make ["first=0.1", "second=0.2"]
+    elements.underlying.should == [["first", "0.1"], ["second", "0.2"]]
+  end
+
+  describe :reorder do
+    it "should reorder the elements according to the given names sequence" do
+      (make(["a","c"]).reorder ["d","c","b","a"]).should == make(["c","a"]) 
+    end
+   
+    it "should remove elements whose names are absent from the ordering" do
+      elements = make ["prost"]
+      order = ["prost_externo", "prost", "assets", "schumi"]
+
+      result = elements.reorder order
+      result.should == elements
+    end
+  end
+
+  describe :alongside do
+    it "should store the extra names" do
+      (make(["a","c"]).alongside "a" => ["aa"], "c" => ["cc"]).should == make(["a", "c", "aa", "cc"]) 
+    end
+
+    it "should copy extra data from the stored names to the names defined alongside" do
+      elements = make ["first=0.1", "second=0.2", "third"]
+      res = elements.alongside "first" => ["one"], "second" => ["two"], "third" => ["three"]
+      res.strings.should == ["first=0.1", "second=0.2", "third", "one=0.1", "two=0.2", "three"]
+    end
+
+    it "REGRESSION: it should not add unrelated names" do
+      elements = make ["prost=1.2.3"]
+      alongside = {"schumi"=>["assets"], "prost"=>["prost_externo"]}
+
+      res = elements.alongside alongside
+      res.should == make(["prost=1.2.3","prost_externo=1.2.3"])
+    end
+  end
+
+  describe :annotate do
+    it "should add extra string information to the appropriate names" do
+      elements = make ["first=1", "second=2", "third", "fourth=4", "fifth"]
+      res = elements.annotate "first" => "10", "second" => "20", "third" => "30"
+      res.strings.should == ["first=1=10", "second=2=20", "third==30", "fourth=4", "fifth"]
+    end
+    
+    it "should add extra object information to the appropriate names" do
+      elements = make ["first=1"]
+      res = elements.annotate "first" => {:a => "some string", "b" => ["other"]}
+      res.strings.should == [%|first=1={"a":"some string","b":["other"]}|]
+    end
+
+    it "should format properly when the element has no prior extra information but is annotated" do
+      elements = make ["backend"]
+      res = elements.annotate "backend" => "this is the backend"
+      res.strings.should == ['backend==this is the backend']
+    end
+  end
+end

data/spec/lib/grandprix/graph_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+
+describe Grandprix::Graph do
+  describe :topological_sort do
+    it "should sort a linked list" do
+      edges = [[:a, :b],[:b, :c]]
+      subject.sort(edges).should be_an_ordering_of(edges)
+      subject.sort(edges).should == [:a, :b, :c] 
+    end
+    
+    it "should sort a small graph" do
+      #         d
+      #        ^^
+      #       /  \
+      # a -> b -> c <- e
+      edges = [
+        [:a, :b],
+        [:b, :c],
+        [:b, :d],
+        [:c, :d],
+        [:e, :c],
+      ]
+      subject.sort(edges).should  be_an_ordering_of(edges)
+    end
+
+    it "should sort a larger graph" do
+      # 
+      #               4 -> 6 <- 8  <-  2
+      #               ^         ^      ^
+      #               |         |      |
+      # 1  ->  3  ->  7   --->  5  <-  9
+      edges = [
+        [9, 2], [4, 6],
+        [3, 7], [1, 3],
+        [7, 5], [7, 4],
+        [5, 8], [9, 5],
+        [8, 6], [2, 8],
+      ]
+      subject.sort(edges).should  be_an_ordering_of(edges)
+    end
+
+    context "invalid input" do
+      it "should do nothing on empty imput" do
+        subject.sort([]).should == []
+      end
+      
+      it "should raise an exception when a cycle is found" do
+        #
+        #  A -> B
+        #  ^    |
+        #  |    v
+        #  D <- C
+        #
+        expect { subject.sort([[:a, :b], [:b, :c], [:c, :d], [:d, :a]]) }.to raise_error
+      end
+
+      it "should raise an exception when a cycle is found in a small graph" do
+        #
+        # Z -> A -> B
+        #      ^    |
+        #      |    v
+        #      D <- C
+        #
+        expect { subject.sort([[:z, :a], [:a, :b], [:b, :c], [:c, :d], [:d, :a]]) }.to raise_error
+      end
+
+      it "should raise an exception when a cycle is found inside a larger graph" do
+        #
+        #        D <- E <- F -> H <-
+        #        |         ^         \
+        #        |         |          J
+        #        v         |         /
+        #  A ->  B -> C -> G -> I <-
+        #
+        expect { subject.sort([
+          [:a, :b],
+          [:b, :c],
+          [:c, :g],
+          [:g, :i],
+          [:e, :d],
+          [:f, :e],
+          [:f, :h],
+          [:d, :b],
+          [:g, :f],
+          [:j, :h],
+          [:j, :i],
+        ]) }.to raise_error
+      end
+    end
+
+  end  
+end

data/spec/lib/grandprix/planner_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+describe Grandprix::Planner do
+  let (:graph) { mock("graph") }
+  subject { described_class.new graph }
+
+  it "should understand dependencies" do
+    topology = {
+      "frontend" => {
+        "after" => ["backend"]
+      },
+      "backend" => {
+        "after" => ["db", "mq"]
+      },
+      "client" => {
+        "after" => ["frontend"]
+      }
+    }
+
+    elements = ["frontend", "db", "client"]
+    
+    graph.should_receive(:sort).with([
+      ["backend", "frontend"], 
+      ["db", "backend"], 
+      ["mq", "backend"], 
+      ["frontend", "client"], 
+    ]).and_return(["mq", "db", "backend", "frontend", "client"])
+
+    subject.plan(topology, elements).names.should == ["db", "frontend", "client"]
+  end
+
+  context " - alongside - " do
+    it "should include elements that must always be deployed together" do
+      topology = {
+        "frontend" => {
+          "after" => ["backend"],
+          "alongside" => ["assets", "images"]
+        },
+        "backend" => {
+          "alongside" => ["external_backend"]
+        }
+      }
+
+      elements = ["frontend", "backend"]
+
+      expected_deps = [
+        ["backend", "frontend"], 
+        ["backend", "assets"], 
+        ["backend", "images"], 
+        ["external_backend", "frontend"], 
+        ["external_backend", "assets"], 
+        ["external_backend", "images"], 
+      ]
+
+      graph.should_receive(:sort) do |arg|
+        arg.should =~ expected_deps
+        ["external_backend", "backend", "frontend", "assets", "images"]
+      end
+
+      result = subject.plan(topology, elements)
+
+      result.names.should =~ ["assets", "images", "frontend", "backend", "external_backend"]
+      result.should beOrderedHaving("backend", "external_backend").before("frontend","assets", "images")
+    end
+
+    it "should allow for alongside dependencies to declare their own dependencies" do
+      topology = {
+        "frontend" => {
+          "after" => ["backend", "assets"],    # frontend depends on assets in addxition to
+          "alongside" => ["assets", "images"]  # having it declared alongside
+        },
+        "backend" => {
+          "alongside" => ["external_backend"]
+        },
+        "images" => {
+          "after" => ["client"] #images that is an alongside dep of frontend depends on client
+        }
+      }
+
+      elements = ["frontend", "client", "backend"]
+      expected_deps = [
+        ["assets", "frontend"], 
+        ["assets", "images"], 
+        ["client", "images"], 
+        ["backend", "frontend"], 
+        ["backend", "assets"], 
+        ["backend", "images"], 
+        ["external_backend", "frontend"], 
+        ["external_backend", "assets"], 
+        ["external_backend", "images"], 
+      ]
+
+      graph.should_receive(:sort) do |arg|
+        arg.should =~ expected_deps
+        ["client", "backend", "external_backend", "assets", "images", "frontend"]
+      end
+
+      result = subject.plan(topology, elements)
+
+      result.names.should =~ ["client", "backend", "external_backend", "frontend", "assets", "images"]
+      result.should beOrderedHaving("backend", "assets").before("frontend")
+      result.should beOrderedHaving("backend", "assets").before("frontend", "assets", "images")
+      result.should beOrderedHaving("client").before("images")
+    end
+  end
+
+  context " - input handling - " do
+    it "should consider elements that are mentioned but not fully specified" do
+      topology = {
+        "frontend" => {
+          "after" => ["backend"]
+        },
+        "backend" => {
+          "after" => ["db", "mq"]
+        },
+      }
+
+      elements = ["frontend", "db", "client"]
+
+      graph.should_receive(:sort).with([
+        ["backend", "frontend"], 
+        ["db", "backend"], 
+        ["mq", "backend"], 
+      ]).and_return(["mq", "db", "backend", "frontend"])
+
+      subject.plan(topology, elements).names.should == ["client","db", "frontend"]
+    end
+  end
+
+  context " - output - " do
+    it "should annotate the elements with provided metadata, if given" do
+      topology = {
+        "frontend" => {
+          "after" => ["backend"],
+          "annotation" => "this is the frontend"
+        },
+        "backend" => {
+          "after" => ["db"]
+        },
+        "db" => {
+          "annotation" => {"type" => "document-oriented"}
+        }
+      }
+
+      elements = ["frontend=1.0.0", "backend=2.0.0", "db"]
+
+      graph.should_receive(:sort).with([
+        ["backend", "frontend"], 
+        ["db", "backend"], 
+      ]).and_return(["db", "backend", "frontend"])
+
+      subject.plan(topology, elements).strings.should == ['db=={"type":"document-oriented"}', 'backend=2.0.0', 'frontend=1.0.0=this is the frontend']
+    end
+
+  end
+
+
+end