build_eval 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1daad2c7e52f801829e07f22003bf4536cf91a51
+  data.tar.gz: 3ab822f2da5e6cad9f5a22d5f0a9b5368d162b98
+SHA512:
+  metadata.gz: a35303425c8ac6b5cec64f15ae1daec79c08cafa96d2193a8e75ea7f701fc05144dc898a81f232df11d8888ca440f8f55257da4d2c1d880263925cda502ff1c8
+  data.tar.gz: 12d7ceb5d11e619699da7cc19965e8accecd442bddae5e4b81692b8434bcbebcfe6e038972cd16075bf686d434b41862e2fd7f145bbedc65f03475b975902b05

data/lib/build_eval/build_result.rb

@@ -0,0 +1,39 @@
+module BuildEval
+
+  class BuildResult
+
+    class << self
+
+      def create(args)
+        self.new(build_name: args[:build_name], status: BuildEval::Status.find(args[:status_name]))
+      end
+
+      def unknown(build_name)
+        self.new(build_name: build_name, status: BuildEval::Status::UNKNOWN)
+      end
+
+    end
+
+    attr_reader :build_name
+    attr_reader :status
+
+    private
+
+    def initialize(args)
+      @build_name = args[:build_name]
+      @status     = args[:status]
+    end
+
+    public
+
+    def unsuccessful?
+      @status.unsuccessful?
+    end
+
+    def to_s
+      "#{@build_name}: #{@status}"
+    end
+
+  end
+
+end

data/lib/build_eval/build_results.rb

@@ -0,0 +1,23 @@
+module BuildEval
+
+  class BuildResults
+
+    def initialize(build_results)
+      @build_results = build_results
+    end
+
+    def status
+      BuildEval::Status.effective_status(@build_results.map(&:status))
+    end
+
+    def unsuccessful
+      @build_results.find_all(&:unsuccessful?)
+    end
+
+    def to_s
+      @build_results.map(&:to_s).join(", ")
+    end
+
+  end
+
+end

data/lib/build_eval/ci_server/decorator.rb

@@ -0,0 +1,25 @@
+module BuildEval
+  module CIServer
+
+    class Decorator
+
+      def initialize(delegate)
+        @delegate = delegate
+      end
+
+      def build_result(name)
+        begin
+          @delegate.build_result(name)
+        rescue Exception
+          BuildEval::BuildResult.unknown(name)
+        end
+      end
+
+      def monitor(*build_names)
+        BuildEval::Monitor.new(server: @delegate, build_names: build_names.flatten)
+      end
+
+    end
+
+  end
+end

data/lib/build_eval/ci_server/team_city.rb

@@ -0,0 +1,33 @@
+module BuildEval
+  module CIServer
+
+    class TeamCity
+
+      def initialize(args)
+        @base_uri = args[:uri]
+        @username = args[:username]
+        @password = args[:password]
+      end
+
+      def build_result(name)
+        response = issue_request(name)
+        build_element = Nokogiri::XML(response.body).xpath("//build").first
+        raise "Unexpected build response: #{response.message}" unless build_element
+        BuildEval::BuildResult.create(build_name: name, status_name: build_element.attribute("status").value)
+      end
+
+      private
+
+      def issue_request(name)
+        uri = URI.parse("#{@base_uri}/httpAuth/app/rest/buildTypes/id:#{name}/builds")
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+          request = Net::HTTP::Get.new(uri.request_uri)
+          request.basic_auth(@username, @password)
+          http.request(request)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/build_eval/monitor.rb

@@ -0,0 +1,15 @@
+module BuildEval
+
+  class Monitor
+
+    def initialize(args)
+      @server      = args[:server]
+      @build_names = args[:build_names]
+    end
+
+    def evaluate
+      BuildEval::BuildResults.new(@build_names.map { |build_name| @server.build_result(build_name) })
+    end
+
+  end
+end

data/lib/build_eval/status.rb

@@ -0,0 +1,51 @@
+module BuildEval
+
+  class Status
+
+    private
+
+    def initialize(args)
+      @severity    = args[:severity]
+      @symbol      = args[:symbol]
+      @description = args[:description]
+    end
+
+    public
+
+    SUCCESS = self.new(severity: 0, symbol: :success!, description: "succeeded")
+    FAILURE = self.new(severity: 2, symbol: :failed!,  description: "failed")
+    UNKNOWN = self.new(severity: 1, symbol: :warning!, description: "unknown")
+
+    class << self
+
+      def find(name)
+        begin
+          self.const_get(name)
+        rescue NameError
+          raise "Build status '#{name}' is invalid"
+        end
+      end
+
+      def effective_status(statuses)
+        statuses.sort_by { |status| status.severity }.last
+      end
+
+    end
+
+    attr_reader :severity
+
+    def unsuccessful?
+      self != SUCCESS
+    end
+
+    def to_sym
+      @symbol
+    end
+
+    def to_s
+      @description
+    end
+
+  end
+
+end

data/lib/build_eval/version.rb

@@ -0,0 +1,3 @@
+module BuildEval
+  VERSION = "0.0.1".freeze
+end

data/lib/build_eval.rb

@@ -0,0 +1,33 @@
+require 'nokogiri'
+
+require_relative 'build_eval/status'
+require_relative 'build_eval/build_result'
+require_relative 'build_eval/build_results'
+require_relative 'build_eval/ci_server/decorator'
+require_relative 'build_eval/ci_server/team_city'
+require_relative 'build_eval/monitor'
+
+module BuildEval
+
+  class << self
+
+    def server(args)
+      type_args = args.clone
+      server_type = type_args.delete(:type)
+      BuildEval::CIServer::Decorator.new(server_class_for(server_type).new(type_args))
+    end
+
+    private
+
+    def server_class_for(type)
+      begin
+        BuildEval::CIServer.const_get(type.to_s)
+      rescue NameError
+        raise "Server type '#{type}' is invalid"
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/build_eval/build_result_spec.rb

@@ -0,0 +1,85 @@
+describe BuildEval::BuildResult do
+
+  describe "::create" do
+
+    let(:build_name)  { "Some build name" }
+    let(:status_name) { "SUCCESS" }
+
+    subject { described_class.create(build_name: build_name, status_name: status_name) }
+
+    it "returns a result with the provided build name" do
+      expect(subject.build_name).to eql(build_name)
+
+    end
+
+    it "determines the status with the provided status name" do
+      expect(BuildEval::Status).to receive(:find).with(status_name)
+
+      subject
+    end
+
+    it "returns a result with the determined status" do
+      status = BuildEval::Status::UNKNOWN
+      allow(BuildEval::Status).to receive(:find).and_return(status)
+
+      expect(subject.status).to eql(status)
+    end
+
+  end
+
+  describe "::unknown" do
+
+    let(:build_name) { "Some build name" }
+
+    subject { described_class.unknown(build_name) }
+
+    it "returns a result with the provided build name" do
+      expect(subject.build_name).to eql(build_name)
+    end
+
+    it "returns a result with an unknown status" do
+      expect(subject.status).to eql(BuildEval::Status::UNKNOWN)
+    end
+
+  end
+
+  describe "#unsuccessful?" do
+
+    let(:status)       { instance_double(BuildEval::Status) }
+    let(:build_result) { described_class.create(build_name: "some build", status_name: "some status") }
+
+    subject { build_result.unsuccessful? }
+
+    before(:example) { allow(BuildEval::Status).to receive(:find).and_return(status) }
+
+    it "delegates to the underlying status" do
+      allow(status).to receive(:unsuccessful?).and_return(true)
+
+      expect(subject).to be(true)
+    end
+
+  end
+
+  describe "#to_s" do
+
+    let(:build_name)                   { "Some build name" }
+    let(:status_string_representation) { "SUCCESS" }
+    let(:status)                       { instance_double(BuildEval::Status, to_s: status_string_representation) }
+
+    let(:build_result) { described_class.create(build_name: build_name, status_name: "some status") }
+
+    subject { build_result.to_s }
+
+    before(:example) { allow(BuildEval::Status).to receive(:find).and_return(status) }
+
+    it "contains the name of the build" do
+      expect(subject).to include(build_name)
+    end
+
+    it "contains the string representation of the status" do
+      expect(subject).to include(status_string_representation)
+    end
+
+  end
+
+end

data/spec/lib/build_eval/build_results_spec.rb

@@ -0,0 +1,82 @@
+describe BuildEval::BuildResults do
+
+  let(:results) { (1..3).map { instance_double(BuildEval::BuildResult) } }
+
+  let(:build_results) { described_class.new(results) }
+
+  describe "#status" do
+
+    let(:statuses) { results.map { instance_double(BuildEval::Status) } }
+
+    subject { build_results.status }
+
+    before(:example) do
+      results.zip(statuses).each { |result, status| allow(result).to receive(:status).and_return(status) }
+    end
+
+    it "determines the effective status of the build results" do
+      expect(BuildEval::Status).to receive(:effective_status).with(statuses)
+
+      subject
+    end
+
+    it "returns the effective status" do
+      status = instance_double(BuildEval::Status)
+      allow(BuildEval::Status).to receive(:effective_status).and_return(status)
+
+      expect(subject).to be(status)
+    end
+
+  end
+
+  describe "#unsuccessful" do
+
+    subject { build_results.unsuccessful }
+
+    before(:example) do
+      results.each do |build_result|
+        allow(build_result).to receive(:unsuccessful?).and_return(unsuccessful_results.include?(build_result))
+      end
+    end
+
+    context "when some build results are unsuccessful" do
+
+      let(:unsuccessful_results) { [ results[0], results[2] ] }
+
+      it "returns the unsuccessful build results" do
+        expect(subject).to eql(unsuccessful_results)
+      end
+
+    end
+
+    context "when no build results are unsuccessful" do
+
+      let(:unsuccessful_results) { [] }
+
+      it "returns an empty array" do
+        expect(subject).to eql([])
+      end
+
+    end
+
+  end
+
+  describe "#to_s" do
+
+    let(:result_string_representations) { results.each_with_index.map { |_, i| "Result description ##{i}" } }
+
+    subject { build_results.to_s }
+
+    before(:example) do
+      results.zip(result_string_representations).each do |build_result, string|
+        allow(build_result).to receive(:to_s).and_return(string)
+      end
+    end
+
+    it "contains the string representation of each result" do
+      result_string_representations.each { |string| expect(subject).to include(string) }
+    end
+
+  end
+
+end

data/spec/lib/build_eval/ci_server/decorator_spec.rb

@@ -0,0 +1,97 @@
+describe BuildEval::CIServer::Decorator do
+
+  let(:decorated_server)  { double("BuildEval::CIServer::Server") }
+
+  let(:decorator) { described_class.new(decorated_server) }
+
+  describe "#build_result" do
+
+    let(:build_name) { "some build name" }
+
+    subject { decorator.build_result(build_name) }
+
+    it "delegates to the decorated server" do
+      expect(decorated_server).to receive(:build_result).with(build_name)
+
+      subject
+    end
+
+    context "when the decorated server returns a result" do
+
+      let(:build_result) { instance_double(BuildEval::BuildResult) }
+
+      before(:example) { allow(decorated_server).to receive(:build_result).and_return(build_result) }
+
+      it "returns the result" do
+        expect(subject).to eql(build_result)
+      end
+
+    end
+
+    context "when the decorated server raises an error" do
+
+      before(:example) { allow(decorated_server).to receive(:build_result).and_raise("Forced error") }
+
+      it "creates an unknown result" do
+        expect(BuildEval::BuildResult).to receive(:unknown).with(build_name)
+
+        subject
+      end
+
+      it "returns the unknown result" do
+        unknown_build_result = instance_double(BuildEval::BuildResult)
+        allow(BuildEval::BuildResult).to receive(:unknown).and_return(unknown_build_result)
+
+        expect(subject).to eql(unknown_build_result)
+      end
+
+    end
+
+  end
+
+  describe "#monitor" do
+
+    let(:build_names) { (1..3).map { |i| "build##{i}" } }
+
+    subject { decorator.monitor(*build_names) }
+
+    it "creates a monitor for the decorated server" do
+      expect(BuildEval::Monitor).to receive(:new).with(hash_including(server: decorated_server))
+
+      subject
+    end
+
+    it "returns the monitor" do
+      monitor = instance_double(BuildEval::Monitor)
+      allow(BuildEval::Monitor).to receive(:new).and_return(monitor)
+
+      expect(subject).to eql(monitor)
+    end
+
+    context "when an array of build names is provided" do
+
+      subject { decorator.monitor(build_names) }
+
+      it "creates a monitor for the provided build names" do
+        expect(BuildEval::Monitor).to receive(:new).with(hash_including(build_names: build_names))
+
+        subject
+      end
+
+    end
+
+    context "when variable argument list of build names is provided" do
+
+      subject { decorator.monitor(*build_names) }
+
+      it "creates a monitor for the provided build names" do
+        expect(BuildEval::Monitor).to receive(:new).with(hash_including(build_names: build_names))
+
+        subject
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/build_eval/ci_server/team_city_spec.rb

@@ -0,0 +1,111 @@
+describe BuildEval::CIServer::TeamCity do
+
+  let(:scheme)   { "http" }
+  let(:host)     { "some.teamcity.server" }
+  let(:uri)      { "#{scheme}://#{host}" }
+  let(:username) { "some_username" }
+  let(:password) { "some_password" }
+
+  let(:team_city) { described_class.new(uri: uri, username: username, password: password) }
+
+  describe "#build_result" do
+
+    let(:build_name)  { "some_build_name" }
+    let(:last_status) { "FAILED" }
+
+    let(:expected_uri) do
+      "#{scheme}://#{username}:#{password}@#{host}/httpAuth/app/rest/buildTypes/id:#{build_name}/builds"
+    end
+
+    subject { team_city.build_result(build_name) }
+
+    before(:example) { FakeWeb.register_uri(:get, expected_uri, body: response_body, status: response_status) }
+
+    context "when the server responds with build results" do
+
+      let(:response_body) do
+        <<-RESPONSE
+          <builds count="3" href="/httpAuth/app/rest/buildTypes/#{build_name}/builds/" nextHref="/httpAuth/app/rest/buildTypes/#{build_name}/builds/?count=3&start=3">
+          <build id="87735" buildTypeId="#{build_name}" number="2062" status="#{last_status}" state="finished" href="/httpAuth/app/rest/builds/id:87735" webUrl="#{uri}/viewLog.html?buildId=87735&buildTypeId=#{build_name}"/>
+          <build id="87723" buildTypeId="#{build_name}" number="2061" status="SUCCESS" state="finished" href="/httpAuth/app/rest/builds/id:87723" webUrl="#{uri}/viewLog.html?buildId=87723&buildTypeId=#{build_name}"/>
+          <build id="87658" buildTypeId="#{build_name}" number="2060" status="SUCCESS" state="finished" href="/httpAuth/app/rest/builds/id:87658" webUrl="#{uri}/viewLog.html?buildId=87658&buildTypeId=#{build_name}"/>
+          </builds>
+        RESPONSE
+      end
+      let(:response_status) { [ "200", "OK" ] }
+
+      it "creates a build result containing the build name" do
+        expect(BuildEval::BuildResult).to receive(:create).with(hash_including(build_name: build_name))
+
+        subject
+      end
+
+      it "creates a build result containing the latest build status" do
+        expect(BuildEval::BuildResult).to receive(:create).with(hash_including(status_name: last_status))
+
+        subject
+      end
+
+      it "returns the created result" do
+        build_result = instance_double(BuildEval::BuildResult)
+        allow(BuildEval::BuildResult).to receive(:create).and_return(build_result)
+
+        expect(subject).to eql(build_result)
+      end
+
+      context "and the uri has a https scheme" do
+
+        let(:scheme) { "https" }
+
+        it "creates a build result from the response" do
+          expect(BuildEval::BuildResult).to receive(:create).with(hash_including(status_name: last_status))
+
+          subject
+        end
+
+      end
+
+    end
+
+    context "when the server authentication request fails" do
+
+      let(:response_body)   { "Incorrect username or password" }
+      let(:response_status) { [ "401", "Unauthorized" ] }
+
+      it "raises an error" do
+        expect { subject }.to raise_error(/Unauthorized/)
+      end
+
+    end
+
+    context "when the build is not found" do
+
+      let(:response_body) do
+        <<-BODY
+        Error has occurred during request processing (Not Found).
+        Error: jetbrains.buildServer.server.rest.errors.NotFoundException: No build type nor template is found by id '#{build_name}'.
+        BODY
+      end
+      let(:response_status) { [ "404", "Not Found" ] }
+
+      it "raises an error" do
+        expect { subject }.to raise_error(/Not Found/)
+      end
+
+    end
+
+    context "when the server cannot be reached" do
+
+      let(:expected_uri)    { "http://some.invalid.uri" }
+      let(:response_body)   { nil }
+      let(:response_status) { nil }
+
+      it "raises an error" do
+        expect { subject }.to raise_error(/Not Found/)
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/build_eval/monitor_spec.rb

@@ -0,0 +1,37 @@
+describe BuildEval::Monitor do
+
+  let(:server)      { double("BuildEval::CIServer") }
+  let(:build_names) { (1..3).map { |i| "build##{i}" } }
+
+  let(:monitor) { described_class.new(server: server, build_names: build_names) }
+
+  describe "#evaluate" do
+
+    let(:results) { build_names.map { instance_double(BuildEval::BuildResult) } }
+
+    subject { monitor.evaluate }
+
+    before(:example) { allow(server).to receive(:build_result).and_return(*results) }
+
+    it "determines build results for builds of interest" do
+      build_names.each { |build_name| expect(server).to receive(:build_result).with(build_name) }
+
+      subject
+    end
+
+    it "composes a build results object containing the results" do
+      expect(BuildEval::BuildResults).to receive(:new).with(results)
+
+      subject
+    end
+
+    it "returns the build results object" do
+      build_results = instance_double(BuildEval::BuildResults)
+      expect(BuildEval::BuildResults).to receive(:new).and_return(build_results)
+
+      expect(subject).to eql(build_results)
+    end
+
+  end
+
+end

data/spec/lib/build_eval/status_spec.rb

@@ -0,0 +1,138 @@
+describe BuildEval::Status do
+
+  describe "::find" do
+
+    subject { described_class.find(name) }
+
+    context "when the name exactly matches a status constant name" do
+
+      let(:name) { "UNKNOWN" }
+
+      it "returns the constant" do
+        expect(subject).to be(BuildEval::Status::UNKNOWN)
+      end
+
+    end
+
+    context "when the name is completely different from a status constant name" do
+
+      let(:name) { "does_not_match" }
+
+      it "raises an error indicating the name is invalid" do
+        expect { subject }.to raise_error("Build status '#{name}' is invalid")
+      end
+
+    end
+
+  end
+
+  describe "::effective_status" do
+
+    subject { described_class.effective_status(statuses) }
+
+    context "when a single status is provided" do
+
+      let(:statuses) { [ BuildEval::Status::UNKNOWN ] }
+
+      it "returns the status" do
+        expect(subject).to eql(BuildEval::Status::UNKNOWN)
+      end
+
+    end
+
+    context "when the statuses are ordered in descending severity" do
+
+      let(:statuses) { [ BuildEval::Status::FAILURE, BuildEval::Status::UNKNOWN, BuildEval::Status::SUCCESS ] }
+
+      it "returns the most severe status" do
+        expect(subject).to eql(BuildEval::Status::FAILURE)
+      end
+
+    end
+
+    context "when the statuses are ordered in ascending severity" do
+
+      let(:statuses) { [ BuildEval::Status::SUCCESS, BuildEval::Status::UNKNOWN, BuildEval::Status::FAILURE ] }
+
+      it "returns the most severe status" do
+        expect(subject).to eql(BuildEval::Status::FAILURE)
+      end
+
+    end
+
+  end
+
+  describe "#unsuccessful?" do
+
+    subject { status.unsuccessful? }
+
+    context "when the status is SUCCESS" do
+
+      let(:status) { BuildEval::Status::SUCCESS }
+
+      it "returns false" do
+        expect(subject).to be(false)
+      end
+
+    end
+
+    {
+      "FAILURE" => BuildEval::Status::FAILURE,
+      "UNKNOWN" => BuildEval::Status::UNKNOWN
+    }.each do |name, status|
+
+      context "when the status is #{name}" do
+
+        let(:status) { status }
+
+        it "returns true" do
+          expect(subject).to be(true)
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "#to_sym" do
+
+    subject { status.to_sym }
+
+    { SUCCESS: :success!, FAILURE: :failed!, UNKNOWN: :warning! }.each do |name, expected_symbol|
+
+      context "when the status is #{name}" do
+
+        let(:status) { BuildEval::Status.const_get(name) }
+
+        it "returns success!" do
+          expect(subject).to eql(expected_symbol)
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "#to_s" do
+
+    subject { status.to_s }
+
+    { SUCCESS: "succeeded", FAILURE: "failed", UNKNOWN: "unknown" }.each do |name, expected_string|
+
+      context "when the status is #{name}" do
+
+        let(:status) { BuildEval::Status.const_get(name) }
+
+        it "returns success!" do
+          expect(subject).to eql(expected_string)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/build_eval_spec.rb

@@ -0,0 +1,58 @@
+describe BuildEval do
+
+  describe "::server" do
+
+    class BuildEval::CIServer::TestableServer
+
+      def initialize(_args)
+        # Intentionally blank
+      end
+
+    end
+
+    let(:server_type)      { :TestableServer }
+    let(:server_arguments) { { key1: "value1", key2: "value2", key3: "value3" } }
+    let(:args)             { { type: server_type }.merge(server_arguments) }
+
+    subject { described_class.server(args) }
+
+    it "constructs an instance of the server with the provided type" do
+      expect(BuildEval::CIServer::TestableServer).to receive(:new)
+
+      subject
+    end
+
+    it "constructs the instance with additional arguments" do
+      expect(BuildEval::CIServer::TestableServer).to receive(:new).with(server_arguments)
+
+      subject
+    end
+
+    it "decorates the server with standard server behaviour" do
+      server = instance_double(BuildEval::CIServer::TestableServer)
+      allow(BuildEval::CIServer::TestableServer).to receive(:new).and_return(server)
+      expect(BuildEval::CIServer::Decorator).to receive(:new).with(server)
+
+      subject
+    end
+
+    it "returns the decorated server" do
+      server_decorator = instance_double(BuildEval::CIServer::Decorator)
+      allow(BuildEval::CIServer::Decorator).to receive(:new).and_return(server_decorator)
+
+      expect(subject).to eql(server_decorator)
+    end
+
+    context "when a server of the provided type is not found" do
+
+      let(:server_type) { :invalid_type }
+
+      it "raises an error indicating the server type is invalid" do
+        expect { subject }.to raise_error("Server type '#{server_type}' is invalid")
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'bundler'
+Bundler.require(:development)
+
+SimpleCov.start do
+  coverage_dir "tmp/coverage"
+
+  add_filter "/spec/"
+
+  minimum_coverage 100
+  refuse_coverage_drop
+end if ENV["coverage"]
+
+require_relative '../lib/build_eval'

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification
+name: build_eval
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Matthew Ueckerman
+- Ryan Davis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: travis-lint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: metric_fu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.12'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: Evaluates the effective status of continuous integration builds.  Useful
+  for subsequent display on information radiators.
+email: matthew.ueckerman@myob.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "./lib/build_eval.rb"
+- "./lib/build_eval/build_result.rb"
+- "./lib/build_eval/build_results.rb"
+- "./lib/build_eval/ci_server/decorator.rb"
+- "./lib/build_eval/ci_server/team_city.rb"
+- "./lib/build_eval/monitor.rb"
+- "./lib/build_eval/status.rb"
+- "./lib/build_eval/version.rb"
+- "./spec/lib/build_eval/build_result_spec.rb"
+- "./spec/lib/build_eval/build_results_spec.rb"
+- "./spec/lib/build_eval/ci_server/decorator_spec.rb"
+- "./spec/lib/build_eval/ci_server/team_city_spec.rb"
+- "./spec/lib/build_eval/monitor_spec.rb"
+- "./spec/lib/build_eval/status_spec.rb"
+- "./spec/lib/build_eval_spec.rb"
+- "./spec/spec_helper.rb"
+homepage: http://github.com/MYOB-Technology/build_eval
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: build_eval
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Evaluates the effective status of continuous integration builds
+test_files:
+- "./spec/lib/build_eval/build_result_spec.rb"
+- "./spec/lib/build_eval/build_results_spec.rb"
+- "./spec/lib/build_eval/ci_server/decorator_spec.rb"
+- "./spec/lib/build_eval/ci_server/team_city_spec.rb"
+- "./spec/lib/build_eval/monitor_spec.rb"
+- "./spec/lib/build_eval/status_spec.rb"
+- "./spec/lib/build_eval_spec.rb"
+- "./spec/spec_helper.rb"