koality 1.0.0

data/lib/koality/reporter/cane.rb

@@ -0,0 +1,64 @@
+module Koality
+  module Reporter
+    class Cane < Base
+
+      def report(type, violations)
+        unless violations.count > 0
+          report_success(type)
+          return
+        end
+
+        show_table(type, violations)
+      end
+
+      def show_table(type, errors)
+        return if errors.empty?
+
+        table = build_table
+        table.title = color("Cane - #{type} - #{errors.count} Errors", :bold)
+
+        if type == :style
+          by_message = errors.group_by { |e| e.message.split(/\(\d+\)/).first }
+          by_message.each do |message, errors|
+            msg = color(message, :red)
+            locations = errors.map { |e| "  #{e.file_name}:#{e.line}" }
+
+            table.add_row ["#{msg}\n#{locations.join("\n")}", errors.count]
+            table.add_row :separator unless message == by_message.keys.last
+          end
+        else
+          errors.each do |error|
+            table.add_row columns_for_type(type, error)
+            table.add_row :separator unless error == errors.last
+          end
+        end
+
+        puts table
+      end
+
+      def columns_for_type(type, error)
+        case type
+        when :abc
+          ["#{color(error.detail, :red)}\n  #{error.file_name}", error.complexity]
+        when :style
+          ["#{color(error.message, :red)}\n  #{error.file_name}:#{error.line}"]
+        when :threshold
+          [color(error.name, :red), "expected: #{error.operator} #{color(error.limit, :green)}, actual: #{color(error.value, :red)}"]
+        else
+          error.columns
+        end
+      end
+
+      private
+
+      def report_success(type)
+        puts color("Cane - #{type} - 0 Errors", :green)
+      end
+
+      def grouped_errors(errors)
+        errors.group_by(&:url)
+      end
+
+    end
+  end
+end

data/lib/koality/reporter/rails_best_practices.rb

@@ -0,0 +1,44 @@
+module Koality
+  module Reporter
+    class RailsBestPractices < Base
+
+      attr_reader :table
+
+      def initialize
+        @table = build_table
+      end
+
+      def report(errors)
+        unless errors.count > 0
+          report_success
+          return
+        end
+
+        table.title = color("Rails Best Practices - #{errors.count} Errors", :bold)
+        rows = grouped_errors(errors).map do |message, errors|
+          info = "#{color(message, :red)}\n#{color(errors.first.url, :cyan)}\n"
+          info << errors.map { |e| "  #{e.short_filename}:#{e.line_number}" }.join("\n")
+          [info, errors.count]
+        end
+
+        rows.each do |row|
+          table.add_row row
+          table.add_row :separator unless row == rows.last
+        end
+
+        puts table
+      end
+
+      private
+
+      def report_success
+        puts color("Rails Best Practices - 0 Errors", :green)
+      end
+
+      def grouped_errors(errors)
+        errors.group_by(&:message)
+      end
+
+    end
+  end
+end

data/lib/koality/runner/cane.rb

@@ -0,0 +1,78 @@
+require 'cane'
+
+module Koality
+  module Runner
+    class Cane
+
+      attr_reader :cane_options, :violations
+
+      def initialize(options)
+        @cane_options = translate_options(options)
+        @violations = {}
+      end
+
+      def run
+        violations.clear
+        checkers.each { |type, _| run_checker(type) }
+        success?
+      end
+
+      def checkers
+        ::Cane::Runner::CHECKERS.select { |type, _| cane_options.key?(type) }
+      end
+
+      def run_checker(type)
+        Koality::Reporter::Cane.start do |reporter|
+          checker = checkers[type].new(cane_options[type])
+          self.violations[type] = checker.violations
+
+          reporter.report(type, violations[type])
+        end
+      end
+
+      def success?
+        return false if exceeds_total_violations_threshold?
+        violations.none? { |type, _| exceeds_violations_threshold?(type) }
+      end
+
+      def exceeds_total_violations_threshold?
+        max_violations = Koality.options.total_violations_threshold
+        total_violations = violations.values.flatten.count
+
+        max_violations >= 0 && total_violations > max_violations
+      end
+
+      def exceeds_violations_threshold?(type)
+        max_violations = Koality.options[:"#{type}_violations_threshold"].to_i
+        total_violations = violations[type].count
+
+        max_violations >= 0 && total_violations > max_violations
+      end
+
+      private
+
+      def translate_options(options)
+        Hash.new.tap do |cane_opts|
+          cane_opts[:abc] = {
+            :files => options[:abc_file_pattern],
+            :max => options[:abc_threshold]
+          } if options[:abc_enabled]
+
+          cane_opts[:style] = {
+            :files => options[:style_file_pattern],
+            :measure => options[:style_line_length_threshold]
+          } if options[:style_enabled]
+
+          cane_opts[:doc] = {
+            :files => options[:doc_file_pattern]
+          } if options[:doc_enabled]
+
+          cane_opts[:threshold] = options.thresholds if options.thresholds.any?
+        end
+      end
+
+
+
+    end
+  end
+end

data/lib/koality/runner/rails_best_practices.rb

@@ -0,0 +1,44 @@
+module Koality
+  module Runner
+    class RailsBestPractices
+
+      attr_reader :output_file, :rbp_options
+
+      def initialize(options)
+        require 'rails_best_practices'
+
+        @output_file = options.output_file(:rails_bp_error_file)
+        @rbp_options = translate_options(options)
+      end
+
+      def run
+        analyzer = ::RailsBestPractices::Analyzer.new('.', rbp_options)
+
+        Koality::Reporter::RailsBestPractices.start do |reporter|
+          analyzer.analyze
+          reporter.report(analyzer.errors)
+        end
+
+        File.open(output_file, 'w') do |f|
+          f << analyzer.errors.count
+        end
+      end
+
+      private
+
+      def translate_options(options)
+        {
+          'silent' => true,
+          'only' => regexp_list(options[:rails_bp_accept_patterns]),
+          'except' => regexp_list(options[:rails_bp_ignore_patterns])
+        }
+      end
+
+      def regexp_list(list)
+        list.map { |item| Regexp.new item }
+      end
+
+    end
+
+  end
+end

data/lib/koality/simplecov.rb

@@ -0,0 +1,2 @@
+require 'koality/simplecov/formatter'
+SimpleCov.formatter = Koality::SimpleCov::Formatter

data/lib/koality/simplecov/formatter.rb

@@ -0,0 +1,21 @@
+require 'koality'
+require 'simplecov'
+
+module Koality
+  module SimpleCov
+    class Formatter
+
+      def format(result)
+        ::SimpleCov::Formatter::HTMLFormatter.new.format(result)
+
+        Koality.options.ensure_output_directory_exists
+        threshold_file = Koality.options.output_file(:code_coverage_file)
+
+        File.open(threshold_file, "w") do |f|
+          f << result.source_files.covered_percent.to_f
+        end
+      end
+
+    end
+  end
+end

data/lib/koality/version.rb

@@ -0,0 +1,3 @@
+module Koality
+  VERSION = "1.0.0"
+end

data/spec/koality/options_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+describe Koality::Options do
+
+  let(:default_options) do
+    {
+      :abc_enabled                    => true,
+      :style_enabled                  => true,
+
+      :code_coverage_threshold        => 90,
+      :code_coverage_file             => 'code_coverage',
+      :code_coverage_enabled          => true,
+
+      :rails_bp_error_file            => 'rails_bp_errors',
+      :rails_bp_errors_threshold      => 5,
+      :rails_bp_enabled               => true,
+
+      :custom_thresholds              => [],
+      :total_violations_threshold     => 0,
+      :abort_on_failure               => true,
+      :output_directory               => 'quality'
+    }
+  end
+
+  describe '.new' do
+    it 'allows you to override default options' do
+      Koality::Options.with_constants(:DEFAULTS => default_options) do
+        opts = Koality::Options.new(:abc_enabled => false, :style_enabled => false)
+
+        opts[:abc_enabled].should be_false
+        opts[:style_enabled].should be_false
+        opts[:code_coverage_enabled].should be_true
+      end
+    end
+  end
+
+  describe '#[]' do
+    it 'delegates to the underlying options' do
+      Koality::Options.with_constants(:DEFAULTS => default_options) do
+        opts = Koality::Options.new
+        opts[:abc_enabled].should be_true
+      end
+    end
+  end
+
+  describe '#[]=' do
+    it 'delegates to the underlying options' do
+      Koality::Options.with_constants(:DEFAULTS => default_options) do
+        opts = Koality::Options.new
+        opts[:abc_enabled] = false
+        opts[:abc_enabled].should be_false
+      end
+    end
+  end
+
+  describe 'dynamic reader methods' do
+    it 'delegates to the underlying options' do
+      Koality::Options.with_constants(:DEFAULTS => default_options) do
+        opts = Koality::Options.new
+        opts.abc_enabled.should be_true
+      end
+    end
+  end
+
+  describe 'dynamic reader methods' do
+    it 'delegates to the underlying options' do
+      Koality::Options.with_constants(:DEFAULTS => default_options) do
+        opts = Koality::Options.new
+        opts.abc_enabled = false
+        opts.abc_enabled.should be_false
+      end
+    end
+  end
+
+  describe '#add_threshold' do
+    it 'adds a new threshold in the format Cane expects' do
+      Koality::Options.with_constants(:DEFAULTS => default_options) do
+        opts = Koality::Options.new
+        opts.add_threshold('quality/foo', :>=, 99)
+        opts.custom_thresholds.should == [[:>=, 'quality/foo', 99]]
+
+        opts.add_threshold('quality/bar', :==, 75)
+        opts.custom_thresholds.should == [[:>=, 'quality/foo', 99], [:==, 'quality/bar', 75]]
+      end
+    end
+  end
+
+  describe '#runner_thresholds' do
+    it 'is empty if no extra runners are enabled' do
+      Koality::Options.with_constants(:DEFAULTS => default_options) do
+        opts = Koality::Options.new(:rails_bp_enabled => false, :code_coverage_enabled => false)
+        opts.runner_thresholds.should be_empty
+      end
+    end
+
+    it 'includes a threshold check for Rails BP if enabled' do
+      Koality::Options.with_constants(:DEFAULTS => default_options) do
+        opts = Koality::Options.new
+        opts.stubs(:rails_bp_enabled? => true)
+        opts.runner_thresholds.should include([:<=, 'quality/rails_bp_errors', 5])
+      end
+    end
+
+    it 'includes a threshold check for code coverage if enabled' do
+      Koality::Options.with_constants(:DEFAULTS => default_options) do
+        opts = Koality::Options.new
+        opts.stubs(:code_coverage_enabled? => true)
+        opts.runner_thresholds.should include([:>=, 'quality/code_coverage', 90])
+      end
+    end
+  end
+
+  describe '#thresholds' do
+    it 'returns the union of custom_thresholds and runner_thresholds' do
+      opts = Koality::Options.new
+      opts.stubs(:custom_thresholds => [:c1, :c2], :runner_thresholds => [:r1])
+      opts.thresholds.should == [:c1, :c2, :r1]
+    end
+  end
+
+  describe '#output_file' do
+    it 'returns the path for a file relative to the output directory' do
+      Koality::Options.with_constants(:DEFAULTS => default_options) do
+        opts = Koality::Options.new
+        opts.output_file(:rails_bp_error_file).should == 'quality/rails_bp_errors'
+      end
+    end
+  end
+
+  describe '#rails_bp_enabled?' do
+    context 'when inside a rails project' do
+      it 'returns true if the :rails_bp_enabled flag is set to true' do
+        Koality::Options.with_constants(:Rails => true, :DEFAULTS => default_options) do
+          opts = Koality::Options.new(:rails_bp_enabled => true)
+          opts.rails_bp_enabled?.should be_true
+        end
+      end
+
+      it 'returns false if the :rails_bp_enabled flag is set to false' do
+        Koality::Options.with_constants(:Rails => true, :DEFAULTS => default_options) do
+          opts = Koality::Options.new(:rails_bp_enabled => false)
+          opts.rails_bp_enabled?.should be_false
+        end
+      end
+    end
+
+    context 'when not inside a rails project' do
+      it 'returns false' do
+        Koality::Options.with_constants(:DEFAULTS => default_options) do
+          opts = Koality::Options.new(:rails_bp_enabled => true)
+          opts.rails_bp_enabled?.should be_false
+        end
+      end
+    end
+  end
+end

data/spec/koality/rake_task_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'koality/rake_task'
+
+describe Koality::RakeTask do
+
+  before do
+    Rake::Task.clear
+  end
+
+  describe '.new' do
+    it 'allows you to configure options' do
+      task = Koality::RakeTask.new do |options|
+        options.should == Koality.options
+      end
+    end
+
+    it 'defines a task that runs Koality with the options' do
+      Koality::RakeTask.new
+      task = Rake::Task[:koality]
+
+      Koality.expects(:run)
+      task.invoke
+    end
+  end
+end