sleeping_king_studios-tasks 0.1.0.rc.0

data/lib/sleeping_king_studios/tasks/apps/ci/rubocop_task.rb

@@ -0,0 +1,29 @@
+# lib/sleeping_king_studios/tasks/apps/ci/rubocop_task.rb
+
+require 'sleeping_king_studios/tasks/apps/ci'
+require 'sleeping_king_studios/tasks/apps/ci/steps_task'
+
+module SleepingKingStudios::Tasks::Apps::Ci
+  # Defines a Thor task for running the RuboCop linter for each application.
+  class RuboCopTask < SleepingKingStudios::Tasks::Task
+    def self.description
+      'Runs the RuboCop linter for each application.'
+    end # class method description
+
+    def self.task_name
+      'rubocop'
+    end # class method task_name
+
+    option :quiet,
+      :aliases => '-q',
+      :type    => :boolean,
+      :default => false,
+      :desc    => 'Do not write lint results to STDOUT.'
+
+    def call *applications
+      SleepingKingStudios::Tasks::Apps::Ci::StepsTask.
+        new(options.merge('only' => %w(rubocop))).
+        call(*applications)
+    end # method call
+  end # class
+end # module

data/lib/sleeping_king_studios/tasks/apps/ci/rubocop_wrapper.rb

@@ -0,0 +1,29 @@
+# lib/sleeping_king_studios/tasks/apps/ci/rubocop_wrapper.rb
+
+require 'sleeping_king_studios/tasks/apps/ci'
+require 'sleeping_king_studios/tasks/apps/ci/step_wrapper'
+require 'sleeping_king_studios/tasks/ci/rubocop_results'
+
+module SleepingKingStudios::Tasks::Apps::Ci
+  # Wrapper class for calling a RuboCop Ci task for a specific application.
+  class RuboCopWrapper < SleepingKingStudios::Tasks::Apps::Ci::StepWrapper
+    def call application
+      super
+
+      run_step(*source_files)
+    end # method call
+
+    private
+
+    def source_files
+      config =
+        SleepingKingStudios::Tasks::Apps.configuration[current_application]
+
+      config.source_files + config.spec_files
+    end # method source_files
+
+    def step_key
+      :rubocop
+    end # method step_key
+  end # module
+end # module

data/lib/sleeping_king_studios/tasks/apps/ci/simplecov_task.rb

@@ -0,0 +1,68 @@
+# lib/sleeping_king_studios/tasks/apps/ci/simplecov_task.rb
+
+require 'sleeping_king_studios/tasks/apps/ci'
+require 'sleeping_king_studios/tasks/ci/simplecov_results'
+require 'sleeping_king_studios/tasks/task'
+
+module SleepingKingStudios::Tasks::Apps::Ci
+  # Defines a Thor task for aggregating SimpleCov coverage results across
+  # applications.
+  class SimpleCovTask < SleepingKingStudios::Tasks::Task
+    RESULTS_STRUCT =
+      Struct.new(
+        :covered_lines,
+        :covered_percent,
+        :missed_lines,
+        :total_lines
+      ) # end struct
+
+    def self.configure_simplecov!
+      require 'simplecov'
+      require 'simplecov-json'
+
+      ::SimpleCov.configure do
+        command_name "#{command_name}:#{ENV['APP_NAME']}" if ENV['APP_NAME']
+
+        self.formatter =
+          ::SimpleCov::Formatter::MultiFormatter.new(
+            [formatter, ::SimpleCov::Formatter::JSONFormatter]
+          ) # end formatter
+      end # configure
+    end # class method configure_simplecov!
+
+    def self.description
+      'Aggregates the SimpleCov results for all applications.'
+    end # class method description
+
+    def self.task_name
+      'simplecov'
+    end # class method task_name
+
+    def call _application = nil
+      results = load_report :report => File.join('coverage', 'coverage.json')
+      results = convert_results_to_object(results)
+
+      SleepingKingStudios::Tasks::Ci::SimpleCovResults.new(results)
+    end # method call
+
+    private
+
+    def load_report report:
+      raw  = File.read report
+      json = JSON.parse raw
+
+      json['metrics']
+    rescue
+      {}
+    end # method load_report
+
+    def convert_results_to_object hsh
+      RESULTS_STRUCT.new(
+        hsh.fetch('covered_lines', 0),
+        hsh.fetch('covered_percent', 0.0),
+        hsh.fetch('total_lines', 0) - hsh.fetch('covered_lines', 0),
+        hsh.fetch('total_lines', 0)
+      ) # end object
+    end # method convert_results_to_object
+  end # module
+end # module

data/lib/sleeping_king_studios/tasks/apps/ci/step_wrapper.rb

@@ -0,0 +1,49 @@
+# lib/sleeping_king_studios/tasks/apps/ci/step_wrapper.rb
+
+require 'sleeping_king_studios/tasks/apps/applications_task'
+require 'sleeping_king_studios/tasks/apps/ci'
+
+module SleepingKingStudios::Tasks::Apps::Ci
+  # Wrapper class for calling a configured task for a specific application.
+  class StepWrapper < SleepingKingStudios::Tasks::Task
+    include SleepingKingStudios::Tasks::Apps::ApplicationsTask
+
+    def call application, *_rest
+      @current_application = application
+      @step_config         = nil
+    end # method call
+
+    private
+
+    attr_reader :current_application
+
+    def build_step
+      require step_config.fetch(:require) if step_config.key?(:require)
+
+      step_class = Object.const_get(step_config.fetch :class)
+
+      step_class.new(step_options)
+    end # method
+
+    def run_step *args
+      return if skip_step?
+
+      build_step.call(*args)
+    end # method run_step
+
+    def skip_step?
+      step_config == false
+    end # method skip_step?
+
+    def step_config
+      config = SleepingKingStudios::Tasks.configuration
+      steps  = config.ci.steps_with_options
+
+      steps.fetch(step_key, false)
+    end # method step_config
+
+    def step_options
+      options
+    end # method step_options
+  end # class
+end # module

data/lib/sleeping_king_studios/tasks/apps/ci/steps_runner.rb

@@ -0,0 +1,37 @@
+# lib/sleeping_king_studios/tasks/apps/ci/steps_runner.rb
+
+require 'sleeping_king_studios/tasks/apps/applications_task'
+require 'sleeping_king_studios/tasks/ci/steps_runner'
+
+module SleepingKingStudios::Tasks::Apps::Ci
+  # Abstract base class for running a sequence of tasks for a specific
+  # application from a configured list.
+  class StepsRunner < SleepingKingStudios::Tasks::Ci::StepsRunner
+    include SleepingKingStudios::Tasks::Apps::ApplicationsTask
+
+    def call application
+      @current_application = application
+
+      super application
+    end # method call
+
+    private
+
+    attr_reader :current_application
+
+    def ci_steps
+      SleepingKingStudios::Tasks::Apps.configuration[current_application].
+        ci.steps_with_options
+    end # method ci_steps
+
+    def skip_step? _name, config
+      return true if config == false
+
+      if options.fetch('global', false)
+        !config.fetch(:global, false)
+      else
+        config.fetch(:global, false)
+      end # if-else
+    end # method skip_step?
+  end # class
+end # module

data/lib/sleeping_king_studios/tasks/apps/ci/steps_task.rb

@@ -0,0 +1,92 @@
+# lib/sleeping_king_studios/tasks/apps/ci/steps_task.rb
+
+require 'sleeping_king_studios/tasks/apps/applications_task'
+require 'sleeping_king_studios/tasks/apps/ci'
+require 'sleeping_king_studios/tasks/apps/ci/results_reporter'
+require 'sleeping_king_studios/tasks/apps/ci/steps_runner'
+
+module SleepingKingStudios::Tasks::Apps::Ci
+  # Thor task for running each step in the CI suite for each application and
+  # generating a report.
+  class StepsTask < SleepingKingStudios::Tasks::Task
+    include SleepingKingStudios::Tasks::Apps::ApplicationsTask
+
+    def self.description
+      'Runs the configured steps for each application.'
+    end # class method description
+
+    option :except,
+      :type    => :array,
+      :default => [],
+      :desc    => 'Exclude steps from the CI process.'
+    option :only,
+      :type    => :array,
+      :default => [],
+      :desc    => 'Run only the specified steps from the CI process.'
+    option :quiet,
+      :aliases => '-q',
+      :type    => :boolean,
+      :default => false,
+      :desc    => 'Do not write intermediate results to STDOUT.'
+
+    def call *applications
+      filtered = filter_applications :only => applications
+      results  = run_steps(filtered)
+      globals  = run_global_steps
+
+      aggregate_results(results) if filtered.count > 1
+
+      (results['Totals'] ||= {}).update(globals)
+
+      say "\n" unless quiet?
+
+      reporter = ResultsReporter.new(self)
+      reporter.call(results)
+
+      results
+    end # method call
+
+    private
+
+    def aggregate_results results
+      totals = Hash.new { |hsh, key| hsh[key] = 0 }
+
+      results.each do |_, app_results|
+        app_results.each do |step, step_results|
+          next if step_results.nil?
+
+          next totals[step] = step_results unless totals.key?(step)
+
+          totals[step] = totals[step].merge(step_results)
+        end # each
+      end # each
+
+      results['Totals'] = totals
+    end # method aggregate_results
+
+    def run_global_steps
+      opts   = options.merge 'global' => true
+      runner = SleepingKingStudios::Tasks::Apps::Ci::StepsRunner.new(opts)
+
+      runner.call(nil)
+    end # method run_global_steps
+
+    def run_steps applications
+      results = Hash.new { |hsh, key| hsh[key] = {} }
+
+      applications.each do |name, _|
+        results[name] = run_steps_for_application(name)
+      end # each
+
+      results
+    end # method run_steps
+
+    def run_steps_for_application name
+      steps_runner.call(name)
+    end # method run_steps_for_application
+
+    def steps_runner
+      SleepingKingStudios::Tasks::Apps::Ci::StepsRunner.new(options)
+    end # method steps_runner
+  end # class
+end # module

data/lib/sleeping_king_studios/tasks/ci.rb

@@ -0,0 +1,8 @@
+# lib/sleeping_king_studios/tasks/ci.rb
+
+require 'sleeping_king_studios/tasks'
+
+module SleepingKingStudios::Tasks
+  # Thor tasks for continuous integration.
+  module Ci; end
+end # module

data/lib/sleeping_king_studios/tasks/ci/cucumber_parser.rb

@@ -0,0 +1,118 @@
+# lib/sleeping_king_studios/tasks/ci/cucumber_parser.rb
+
+require 'sleeping_king_studios/tasks/ci'
+
+module SleepingKingStudios::Tasks::Ci
+  # Parses the output from cucumber --format=json into a summary report.
+  module CucumberParser
+    class << self
+      def parse results
+        @report = build_report
+
+        results.each { |feature| parse_feature(feature) }
+
+        report['duration'] = report['duration'] / (1.0 * 10**9)
+
+        report
+      end # class method parse
+
+      private
+
+      attr_reader :report
+
+      def build_report
+        {
+          'scenario_count'     => 0,
+          'failing_scenarios'  => [],
+          'pending_scenarios'  => [],
+          'step_count'         => 0,
+          'failing_step_count' => 0,
+          'pending_step_count' => 0,
+          'duration'           => 0
+        } # end report
+      end # method build report
+
+      def parse_feature feature
+        feature['elements'].each do |scenario|
+          parse_scenario(scenario, feature)
+        end # each
+      end # method parse_feature
+
+      # rubocop:disable Metrics/MethodLength
+      def parse_scenario scenario, feature
+        failing = false
+        pending = false
+
+        scenario['steps'].each do |step|
+          status = parse_step(step)
+
+          failing ||= status == 'failed'
+          pending ||= status == 'pending' || status == 'skipped'
+        end # each
+
+        report_scenario(
+          scenario,
+          feature,
+          :failing => failing,
+          :pending => pending
+        ) # end report scenario
+      end # method parse_scenario
+      # rubocop:enable Metrics/MethodLength
+
+      def parse_step step
+        report['step_count'] += 1
+        report['duration']   += step_duration(step)
+
+        status = step_status(step) || 'failed'
+
+        if status == 'failed'
+          report['failing_step_count'] += 1
+        elsif status == 'pending' || status == 'skipped'
+          report['pending_step_count'] += 1
+        end # if
+
+        status
+      end # method parse_step
+
+      # rubocop:disable Metrics/MethodLength
+      def report_scenario scenario, feature, failing:, pending:
+        report['scenario_count'] += 1
+
+        return unless failing || pending
+
+        hsh =
+          {
+            'location' => "#{feature['uri']}:#{scenario['line']}",
+            'description' => "#{scenario['keyword']}: #{scenario['name']}"
+          }
+
+        if failing
+          report['failing_scenarios'] << hsh
+        else
+          report['pending_scenarios'] << hsh
+        end # if-else
+      end # method report_scenario
+      # rubocop:enable Metrics/MethodLength
+
+      def step_duration hsh
+        return 0 if hsh.nil? || hsh.empty?
+
+        result = hsh['result']
+
+        return 0 if result.nil? || result.empty?
+
+        result['duration'] || 0
+      end # method step_duration
+
+      def step_status hsh
+        return nil if hsh.nil? || hsh.empty?
+
+        result = hsh['result']
+
+        return nil if result.nil? || result.empty?
+
+        result['status']
+      end # method step_status
+    end # class
+  end # module
+end # module

data/lib/sleeping_king_studios/tasks/ci/cucumber_results.rb

@@ -0,0 +1,191 @@
+# lib/sleeping_king_studios/tasks/ci/cucumber_results.rb
+
+require 'sleeping_king_studios/tasks/ci'
+
+module SleepingKingStudios::Tasks::Ci
+  # rubocop:disable Metrics/ClassLength
+
+  # Encapsulates the results of a Cucumber call.
+  class CucumberResults
+    # @param results [Hash] The raw results of the RSpec call.
+    def initialize results
+      @results = results
+    end # constructor
+
+    # @param other [RSpecResults] The other results object to compare.
+    #
+    # @return [Boolean] True if the results are equal, otherwise false.
+    def == other
+      if other.is_a?(Hash)
+        empty? ? other.empty? : to_h == other
+      elsif other.is_a?(CucumberResults)
+        to_h == other.to_h
+      else
+        false
+      end # if-elsif-else
+    end # method ==
+
+    # @return [Float] The duration value.
+    def duration
+      @results.fetch('duration', 0.0)
+    end # method duration
+
+    # @return [Boolean] True if there are no scenarios, otherwise false.
+    def empty?
+      scenario_count.zero?
+    end # method empty?
+
+    # @return [Boolean] True if there are any failing scenarios, otherwise
+    #   false.
+    def failing?
+      !failing_scenario_count.zero?
+    end # method failing?
+
+    # @return [Integer] The list of failing scenarios.
+    def failing_scenarios
+      @results.fetch('failing_scenarios', [])
+    end # method failing_scenarios
+
+    # @return [Integer] The number of failing scenarios.
+    def failing_scenario_count
+      failing_scenarios.count
+    end # method failing_scenario_count
+
+    # @return [Integer] The number of failing steps.
+    def failing_step_count
+      @results.fetch('failing_step_count', 0)
+    end # method failing_step_count
+
+    # Adds the given result values and returns a new results object with the
+    # sums.
+    #
+    # @param other [RSpecResults] The results to add.
+    #
+    # @return [RSpecResults] The total results.
+    def merge other
+      merged = {}
+
+      keys.each do |key|
+        merged[key] = public_send(key) + other.public_send(key)
+      end # each
+
+      self.class.new(merged)
+    end # method merge
+
+    # @return [Boolean] True if there are any pending scenarios, otherwise
+    #   false.
+    def pending?
+      !pending_scenario_count.zero?
+    end # method pending?
+
+    # @return [Integer] The number of pending scenarios.
+    def pending_scenario_count
+      pending_scenarios.count
+    end # method pending_scenario_count
+
+    # @return [Integer] The list of pending scenarios.
+    def pending_scenarios
+      @results.fetch('pending_scenarios', [])
+    end # method pending_scenarios
+
+    # @return [Integer] The number of pending steps.
+    def pending_step_count
+      @results.fetch('pending_step_count', 0)
+    end # method pending_step_count
+
+    # @return [Integer] The total number of scenarios.
+    def scenario_count
+      @results.fetch('scenario_count', 0)
+    end # method scenario_count
+
+    # @return [String] A brief summary of the scenario results.
+    def scenarios_summary
+      build_summary(
+        'scenario',
+        scenario_count,
+        failing_scenario_count,
+        pending_scenario_count
+      ) # end build_summary
+    end # method scenarios_summary
+
+    # @return [Integer] The total number of steps.
+    def step_count
+      @results.fetch('step_count', 0)
+    end # method step_count
+
+    # @return [String] A brief summary of the scenario results.
+    def steps_summary
+      build_summary(
+        'step',
+        step_count,
+        failing_step_count,
+        pending_step_count
+      ) # end build_summary
+    end # method steps_summary
+
+    # @return [String] A brief summary of the results.
+    def summary
+      str = scenarios_summary
+
+      str << ', '
+
+      str << steps_summary
+
+      str << " in #{duration.round(2)} seconds"
+    end # method summary
+    alias_method :to_s, :summary
+
+    # @return [Hash] The hash representation of the results.
+    def to_h
+      hsh = {}
+
+      keys.each { |key| hsh[key] = public_send(key) }
+
+      hsh
+    end # method to_h
+
+    private
+
+    def build_summary name, count, failing_count, pending_count
+      str = pluralize(count, name)
+
+      return str if failing_count.zero? && pending_count.zero?
+
+      str << build_summary_details(failing_count, pending_count)
+    end # method build_summary
+
+    def build_summary_details failing_count, pending_count
+      str = ' ('
+
+      str << pluralize(failing_count, 'failure') unless failing_count.zero?
+
+      str << ', ' if !failing_count.zero? && !pending_count.zero?
+
+      str << "#{pending_count} pending" unless pending_count.zero?
+
+      str << ')'
+    end # method build_summary_details
+
+    def keys
+      %w(
+        duration
+        step_count
+        pending_step_count
+        failing_step_count
+        scenario_count
+        pending_scenarios
+        failing_scenarios
+      ) # end keys
+    end # method keys
+
+    def pluralize count, singular, plural = nil
+      "#{count} #{tools.integer.pluralize count, singular, plural}"
+    end # method pluralize
+
+    def tools
+      SleepingKingStudios::Tools::Toolbelt.instance
+    end # method tools
+  end # class
+
+  # rubocop:enable Metrics/ClassLength
+end # module