nakajima-dash-ci 0.0.3

data/lib/dash-ci.rb

@@ -0,0 +1,47 @@
+# CI.register(:my_awesome_app) do
+#   build :rspec, 'rake spec'
+#   build :cucumber, 'cucumber features/'
+#   build :selenium, 'rake selenium:test'
+# end
+
+# CI.run(:my_awesome_app)
+
+require 'rubygems'
+require 'fiveruns/dash'
+require 'base'
+require 'target'
+require 'session'
+
+module CI
+  # 
+  class BrokenBuild < StandardError ; end
+  
+  class << self
+    # Register a new recipe, declaring the suite it measures in the block.
+    # The actual Dash recipe generation doesn't happen until run() though.
+    def register(sym, &block)
+      Base.register(sym, &block)
+    end
+
+    # Find the instrument target class for the given recipe, generate Dash
+    # recipe for suite, start Dash.
+    def run(sym, options={})
+      Base.run(sym, options)
+    end
+    
+    # Sanitize name to be passed around to indicate a suite.
+    def clean(sym)
+      sym.to_s.gsub(/\W/, '_')
+    end
+    
+    # Get an instrument target class.
+    def get(sym)
+      CI.const_get(clean(sym).capitalize)
+    end
+    
+    # Set an instrument target class.
+    def set(sym, klass)
+      CI.const_set(clean(sym).capitalize, klass)
+    end
+  end
+end

data/lib/dash-ci/base.rb

@@ -0,0 +1,76 @@
+module CI
+  class Base
+    class << self
+      # Generate a new class that will have methods generated for it which
+      # Dash will then instrument.
+      def register(sym, &block)
+        klass = Class.new(InstrumentTarget) 
+        klass.suites = []
+        CI.set(sym, klass)
+        new(klass).instance_eval(&block)
+      end
+
+      # Run a set of suites that correspond with a given generated recipe.
+      # This method is called after .register().
+      def run(sym, options={})
+        klass = CI.get(sym)
+        make_recipe(klass, CI.clean(sym), options)
+        klass.new.build!
+      end
+
+      # Generate Dash recipe from suite commands passed to the .register()
+      # block, then start Dash.
+      def make_recipe(klass, recipe, options)
+        puts "Generating recipe..."
+
+        Fiveruns::Dash.register_recipe recipe, :url => 'http://dash.ci' do |recipe|
+          klass.suites.each do |suite|
+            puts '  - adding %s' % suite
+            method_id = instrument(klass, CI.clean(suite))
+            recipe.time CI.clean(suite), :method => method_id
+          end
+
+          recipe.time    :total_time,   :method => 'CI.run'
+          recipe.counter :total_builds, :incremented_by => instrument(klass, 'finish!')
+          recipe.counter :green_builds, :incremented_by => instrument(klass, 'green!')
+          recipe.counter :broken_builds, :incremented_by => instrument(klass, 'fail!')
+        end
+
+        Fiveruns::Dash.logger = Logger.new \
+          options[:verbose] ? STDERR : StringIO.new("")
+
+        Fiveruns::Dash.start :app => options[:token] do |config|
+          config.add_recipe recipe
+        end
+      end
+
+      private
+
+      def instrument(klass, sym)
+        '%s#%s' % [klass.to_s, sym]
+      end
+    end
+
+    def initialize(klass)
+      @klass = klass
+    end
+
+    # Define a method on the instrument class for Dash to monkey-patch. The
+    # method corresponds to a system command that will run that suite, for
+    # example:
+    #
+    #   CI.register(:fixjour) do
+    #     build :specs, 'spec spec/'
+    #   end
+    #
+    # When the command is run and exits without error, the suite passes.
+    def build(suite, command)
+      @klass.suites << suite
+      @klass.class_eval do
+        define_method(CI.clean(suite)) do
+          system(command) or raise(BrokenBuild.new('%s suite failed.' % suite))
+        end
+      end
+    end
+  end
+end

data/lib/dash-ci/session.rb

@@ -0,0 +1,28 @@
+module CI
+  # Provide wrapper around dash-ruby session in order to be able to send
+  # data to FiveRuns when suites complete instead of relying on periodic
+  # update to finish.
+  class Session
+    def initialize
+      @session = Fiveruns::Dash.send(:session)
+    end
+  
+    def report!
+      reporter.send :send_data_update
+      reporter.send :send_exceptions_update
+    end
+    
+    def error(e)
+      @session.exception_recorder.record(e)
+    end
+  
+    private
+  
+    def reporter
+      @reporter ||= begin
+        @session.reporter.secure!
+        @session.reporter
+      end
+    end
+  end
+end

data/lib/dash-ci/target.rb

@@ -0,0 +1,56 @@
+module CI
+  # Acts as target for Dash instrumentation
+  class InstrumentTarget
+    class << self
+      attr_accessor :suites
+    end
+
+    # Run each of the build's suites, calling the appropriate instrumented
+    # method for each respective outcome.
+    def build!
+      suites.each do |suite|
+        begin; send(CI.clean(suite)); green!(suite)
+        rescue BrokenBuild => e
+          error(e)
+          fail!(suite)
+        end
+      end ; finish! ; report!
+    end
+    
+    # Instrumented methods
+    def fail!(suite)
+      puts "Suite failed: #{suite}"
+    end
+    
+    def green!(suite)
+      puts "Suite passed: #{suite}"
+    end
+    
+    # Ensure data gets reported back to FiveRuns before process exits.
+    def finish!
+      puts "Finished all suites."
+    end
+    
+    def report!
+      session.report!
+    end
+    
+    private
+    
+    def suites
+      self.class.suites
+    end
+    
+    def error(e)
+      session.error(e)
+    end
+    
+    def reporter
+      session.reporter
+    end
+    
+    def session
+      @session ||= Session.new
+    end
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: nakajima-dash-ci
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Pat Nakajima
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-06 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: fiveruns-dash-ruby
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/dash-ci.rb
+- lib/dash-ci
+- lib/dash-ci/base.rb
+- lib/dash-ci/target.rb
+- lib/dash-ci/session.rb
+has_rdoc: false
+homepage: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- lib/dash-ci
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: CI metrics for Dash.
+test_files: []
+