cane 1.4.0 → 2.0.0

data/lib/cane/doc_check.rb

@@ -1,19 +1,44 @@
+require 'cane/file'
+
 module Cane
 
   # Creates violations for class definitions that do not have an explantory
   # comment immediately preceeding.
   class DocCheck < Struct.new(:opts)
+
+    def self.key; :doc; end
+    def self.name; "documentation checking"; end
+    def self.options
+      {
+        doc_glob: ['Glob to run doc checks over',
+                      default:  '{app,lib}/**/*.rb',
+                      variable: 'GLOB',
+                      clobber:  :no_doc],
+        no_doc:   ['Disable documentation checking', cast: ->(x) { !x }]
+      }
+    end
+
+    # Stolen from ERB source.
+    MAGIC_COMMENT_REGEX = %r"coding\s*[=:]\s*([[:alnum:]\-_]+)"
+
     def violations
-      file_names.map { |file_name|
+      return [] if opts[:no_doc]
+
+      file_names.map {|file_name|
         find_violations(file_name)
       }.flatten
     end
 
     def find_violations(file_name)
       last_line = ""
-      File.open(file_name, 'r:utf-8').lines.map.with_index do |line, number|
+      Cane::File.iterator(file_name).map_with_index do |line, number|
         result = if class_definition?(line) && !comment?(last_line)
-          UndocumentedClassViolation.new(file_name, number + 1, line)
+          {
+            file:        file_name,
+            line:        number + 1,
+            label:       extract_class_name(line),
+            description: "Classes are not documented"
+          }
         end
         last_line = line
         result
@@ -21,7 +46,7 @@ module Cane
     end
 
     def file_names
-      Dir[opts.fetch(:files)]
+      Dir[opts.fetch(:doc_glob)]
     end
 
     def class_definition?(line)
@@ -29,18 +54,7 @@ module Cane
     end
 
     def comment?(line)
-      line =~ /^\s*#/
-    end
-  end
-
-  # Value object used by DocCheck.
-  class UndocumentedClassViolation < Struct.new(:file_name, :number, :line)
-    def description
-      "Classes are not documented"
-    end
-
-    def columns
-      ["%s:%i" % [file_name, number], extract_class_name(line)]
+      line =~ /^\s*#/ && !(MAGIC_COMMENT_REGEX =~ line)
     end
 
     def extract_class_name(line)

data/lib/cane/encoding_aware_iterator.rb

@@ -0,0 +1,35 @@
+module Cane
+
+  # Provides iteration over lines (from a file), correctly handling encoding.
+  class EncodingAwareIterator < Struct.new(:lines)
+    def map_with_index(&block)
+      lines.map.with_index do |line, index|
+        with_encoding_retry(line) do
+          block.call(line, index)
+        end
+      end
+    end
+
+    protected
+
+    # This is to avoid re-encoding every line, since most are valid. I should
+    # performance test this but haven't (maybe can just re-encode always but my
+    # hunch says no).
+    def with_encoding_retry(line, &block)
+      retried = false
+      begin
+        block.call(line)
+      rescue ArgumentError
+        if retried
+          # I haven't seen input that causes this to occur. Please report it!
+          raise
+        else
+          line.encode!('UTF-8', 'UTF-8', invalid: :replace)
+          retried = true
+          retry
+        end
+      end
+    end
+  end
+
+end

data/lib/cane/file.rb

@@ -0,0 +1,22 @@
+require 'cane/encoding_aware_iterator'
+
+module Cane
+
+  # An interface for interacting with files that ensures encoding is handled in
+  # a consistent manner.
+  class File
+    class << self
+      def iterator(path)
+        EncodingAwareIterator.new(open(path).lines)
+      end
+
+      def contents(path)
+        open(path).read
+      end
+
+      def open(path)
+        ::File.open(path, 'r:utf-8')
+      end
+    end
+  end
+end

data/lib/cane/rake_task.rb

@@ -1,6 +1,8 @@
 require 'rake'
 require 'rake/tasklib'
 
+require 'cane/cli/spec'
+
 module Cane
   # Creates a rake task to run cane with given configuration.
   #
@@ -15,35 +17,22 @@ module Cane
   #   end
   class RakeTask < ::Rake::TaskLib
     attr_accessor :name
-
-    # Glob to run ABC metrics over (default: "lib/**/*.rb")
-    attr_accessor :abc_glob
-    # Max complexity of methods to allow (default: 15)
-    attr_accessor :abc_max
-    # Glob to run style checks over (default: "{lib,spec}/**/*.rb")
-    attr_accessor :style_glob
-    # TRUE to disable style checks
-    attr_accessor :no_style
-    # Max line length (default: 80)
-    attr_accessor :style_measure
-    # Glob to run doc checks over (default: "lib/**/*.rb")
-    attr_accessor :doc_glob
-    # TRUE to disable doc checks
-    attr_accessor :no_doc
-    # Max violations to tolerate (default: 0)
-    attr_accessor :max_violations
-    # File containing list of exclusions in YAML format
-    attr_accessor :exclusions_file
+    OPTIONS = Cane::CLI::Spec::OPTIONS
+    OPTIONS.each do |name, value|
+      attr_accessor name
+    end
 
     # Add a threshold check. If the file exists and it contains a number,
     # compare that number with the given value using the operator.
     def add_threshold(file, operator, value)
-      @threshold << [operator, file, value]
+      if operator == :>=
+        @gte << [file, value]
+      end
     end
 
     def initialize(task_name = nil)
       self.name = task_name || :cane
-      @threshold = []
+      @gte = []
       yield self if block_given?
 
       unless ::Rake.application.last_comment
@@ -52,34 +41,16 @@ module Cane
 
       task name do
         require 'cane/cli'
-        abort unless Cane.run(translated_options)
+        abort unless Cane.run(OPTIONS.merge(options), Cane::CLI::Spec::CHECKS)
       end
     end
 
     def options
-      [
-        :abc_glob,
-        :abc_max,
-        :doc_glob,
-        :no_doc,
-        :max_violations,
-        :style_glob,
-        :no_style,
-        :style_measure,
-        :exclusions_file
-      ].inject(threshold: @threshold) do |opts, setting|
+      OPTIONS.keys.inject({}) do |opts, setting|
         value = self.send(setting)
         opts[setting] = value unless value.nil?
         opts
       end
     end
-
-    def default_options
-      Cane::CLI::Spec::DEFAULTS
-    end
-
-    def translated_options
-      Cane::CLI::Translator.new(options, default_options).to_hash
-    end
   end
 end

data/lib/cane/style_check.rb

@@ -1,6 +1,7 @@
-require 'cane/style_violation'
 require 'set'
 
+require 'cane/file'
+
 module Cane
 
   # Creates violations for files that do not meet style conventions. Only
@@ -8,12 +9,39 @@ module Cane
   # It is not the goal of the tool to provide an extensive style report, but
   # only to prevent stupid mistakes.
   class StyleCheck < Struct.new(:opts)
+
+    def self.key; :style; end
+    def self.name; "style checking"; end
+    def self.options
+      {
+        style_glob:    ['Glob to run style checks over',
+                           default:  '{app,lib,spec}/**/*.rb',
+                           variable: 'GLOB',
+                           clobber:  :no_style],
+        style_measure: ['Max line length',
+                           default: 80,
+                           cast:    :to_i,
+                           clobber: :no_style],
+        style_exclude: ['Exclude file from style checking',
+                         variable: 'FILE',
+                         type: Array,
+                         default: [],
+                         clobber: :no_style],
+        no_style:      ['Disable style checking']
+      }
+    end
+
     def violations
+      return [] if opts[:no_style]
+
       file_list.map do |file_path|
         map_lines(file_path) do |line, line_number|
-          violations_for_line(line.chomp).map do |message|
-            StyleViolation.new(file_path, line_number + 1, message)
-          end
+          violations_for_line(line.chomp).map {|message| {
+            file:        file_path,
+            line:        line_number + 1,
+            label:       message,
+            description: "Lines violated style requirements"
+          }}
         end
       end.flatten
     end
@@ -31,19 +59,19 @@ module Cane
     end
 
     def file_list
-      Dir[opts.fetch(:files)].reject { |f| excluded?(f) }
+      Dir[opts.fetch(:style_glob)].reject {|f| excluded?(f) }
     end
 
     def measure
-      opts.fetch(:measure)
+      opts.fetch(:style_measure)
     end
 
     def map_lines(file_path, &block)
-      File.open(file_path).each_line.map.with_index(&block)
+      Cane::File.iterator(file_path).map_with_index(&block)
     end
 
     def exclusions
-      @exclusions ||= opts.fetch(:exclusions, []).to_set
+      @exclusions ||= opts.fetch(:style_exclude, []).flatten.to_set
     end
 
     def excluded?(file)

data/lib/cane/threshold_check.rb

@@ -1,30 +1,55 @@
-require 'cane/threshold_violation'
+require 'cane/file'
 
-# Configurable check that allows the contents of a file to be compared against
-# a given value.
-class ThresholdCheck < Struct.new(:checks)
-  def violations
-    checks.map do |operator, file, limit|
-      value = value_from_file(file)
+module Cane
 
-      unless value.send(operator, limit.to_f)
-        ThresholdViolation.new(file, operator, value, limit)
+  # Configurable check that allows the contents of a file to be compared against
+  # a given value.
+  class ThresholdCheck < Struct.new(:opts)
+
+    def self.key; :threshold; end
+    def self.options
+      {
+        gte: ["If FILE contains a number, verify it is >= to THRESHOLD",
+                variable: "FILE,THRESHOLD",
+                type:     Array]
+      }
+    end
+
+    def violations
+      thresholds.map do |operator, file, limit|
+        value = value_from_file(file)
+
+        unless value.send(operator, limit.to_f)
+          {
+            description: 'Quality threshold crossed',
+            label:       "%s is %s, should be %s %s" % [
+              file, value, operator, limit
+            ]
+          }
+        end
+      end.compact
+    end
+
+    def value_from_file(file)
+      begin
+        contents = Cane::File.contents(file).chomp.to_f
+      rescue Errno::ENOENT
+        UnavailableValue.new
       end
-    end.compact
-  end
+    end
+
+    def thresholds
+      (opts[:gte] || []).map do |x|
+        x.unshift(:>=)
+      end
+    end
 
-  def value_from_file(file)
-    begin
-      contents = File.read(file).chomp.to_f
-    rescue Errno::ENOENT
-      UnavailableValue.new
+    # Null object for all cases when the value to be compared against cannot be
+    # read.
+    class UnavailableValue
+      def >=(_); false end
+      def to_s; 'unavailable' end
     end
   end
 
-  # Null object for all cases when the value to be compared against cannot be
-  # read.
-  class UnavailableValue
-    def >=(_); false end
-    def to_s; 'unavailable' end
-  end
 end

data/lib/cane/version.rb

@@ -1,3 +1,3 @@
 module Cane
-  VERSION = '1.4.0'
+  VERSION = '2.0.0'
 end

data/lib/cane/violation_formatter.rb

@@ -1,53 +1,61 @@
 require 'stringio'
+require 'ostruct'
 
 module Cane
 
   # Computes a string to be displayed as output from an array of violations
   # computed by the checks.
-  class ViolationFormatter < Struct.new(:violations)
+  class ViolationFormatter
+    attr_reader :violations
+
+    def initialize(violations)
+      @violations = violations.map do |v|
+        v.merge(file_and_line: v[:line] ?
+          "%s:%i" % v.values_at(:file, :line) :
+          v[:file]
+        )
+      end
+    end
+
     def to_s
-      return '' if violations.empty?
+      return "" if violations.empty?
 
-      grouped_violations.map do |description, violations|
-        format_group_header(description, violations) +
-          format_violations(violations)
-      end.flatten.join("\n") + "\n\n" + totals + "\n\n"
+      violations.group_by {|x| x[:description] }.map do |d, vs|
+        format_group_header(d, vs) +
+          format_violations(vs)
+      end.join("\n") + "\n\n" + totals + "\n\n"
     end
 
     protected
 
-    def totals
-      "Total Violations: #{violations.count}"
-    end
-
     def format_group_header(description, violations)
       ["", "%s (%i):" % [description, violations.length], ""]
     end
 
     def format_violations(violations)
-      column_widths = calculate_columm_widths(violations)
+      columns = [:file_and_line, :label, :value]
+
+      widths = column_widths(violations, columns)
 
-      violations.map do |violation|
-        format_violation(violation, column_widths)
+      violations.map do |v|
+        format_violation(v, widths)
       end
     end
 
-    def format_violation(violation, column_widths)
-      [
-        '  ' + violation.columns.map.with_index { |column, index|
-          "%-#{column_widths[index]}s" % column
-        }.join('  ')
-      ]
+    def column_widths(violations, columns)
+      columns.each_with_object({}) do |column, h|
+        h[column] = violations.map {|v| v[column].to_s.length }.max
+      end
     end
 
-    def calculate_columm_widths(violations)
-      violations.map { |violation|
-        violation.columns.map { |x| x.to_s.length }
-      }.transpose.map(&:max)
+    def format_violation(v, column_widths)
+      '  ' + column_widths.keys.map {|column|
+        v[column].to_s.ljust(column_widths[column])
+      }.join('  ').strip
     end
 
-    def grouped_violations
-      violations.group_by(&:description)
+    def totals
+      "Total Violations: #{violations.length}"
     end
   end
 end