sparqcode_cane 1.3.0.1

data/lib/cane/cli/spec.rb

@@ -0,0 +1,135 @@
+require 'optparse'
+require 'cane/cli/translator'
+
+module Cane
+  module CLI
+
+    # Provides a specification for the command line interface that drives
+    # documentation, parsing, and default values.
+    class Spec
+      DEFAULTS = {
+        abc_glob:       '{app,lib}/**/*.rb',
+        abc_max:        '15',
+        style_glob:     '{app,lib,spec}/**/*.rb',
+        style_measure:  '80',
+        doc_glob:       '{app,lib}/**/*.rb',
+        max_violations: '0',
+      }
+
+      # Exception to indicate that no further processing is required and the
+      # program can exit. This is used to handle --help and --version flags.
+      class OptionsHandled < RuntimeError; end
+
+      def initialize
+        add_banner
+
+        add_abc_options
+        add_style_options
+        add_doc_options
+        add_threshold_options
+        add_cane_options
+
+        add_version
+        add_help
+      end
+
+      def parse(args)
+        parser.parse!(get_default_options + args)
+
+        Translator.new(options, DEFAULTS).to_hash
+      rescue OptionsHandled
+        nil
+      end
+
+      def get_default_options
+        if File.exists?('./.cane')
+          File.read('./.cane').gsub("\n", ' ').split(' ')
+        else
+          []
+        end
+      end
+
+      def add_banner
+        parser.banner = <<-BANNER
+Usage: cane [options]
+
+You can also put these options in a .cane file.
+
+BANNER
+      end
+
+      def add_abc_options
+        add_option %w(--abc-glob GLOB), "Glob to run ABC metrics over"
+        add_option %w(--abc-max VALUE), "Ignore methods under this complexity"
+        add_option %w(--no-abc), "Disable ABC checking"
+
+        parser.separator ""
+      end
+
+      def add_style_options
+        add_option %w(--style-glob GLOB), "Glob to run style metrics over"
+        add_option %w(--style-measure VALUE), "Max line length"
+        add_option %w(--no-style), "Disable style checking"
+
+        parser.separator ""
+      end
+
+      def add_doc_options
+        add_option %w(--doc-glob GLOB), "Glob to run documentation checks over"
+        add_option %w(--no-doc), "Disable documentation checking"
+
+        parser.separator ""
+      end
+
+      def add_threshold_options
+        desc = "If FILE contains a number, verify it is >= to THRESHOLD."
+        parser.on("--gte FILE,THRESHOLD", Array, desc) do |opts|
+          (options[:threshold] ||= []) << opts.unshift(:>=)
+        end
+
+        parser.separator ""
+      end
+
+      def add_cane_options
+        add_option %w(--max-violations VALUE), "Max allowed violations"
+
+        parser.separator ""
+      end
+
+      def add_version
+        parser.on_tail("--version", "Show version") do
+          puts Cane::VERSION
+          raise OptionsHandled
+        end
+      end
+
+      def add_help
+        parser.on_tail("-h", "--help", "Show this message") do
+          puts parser
+          raise OptionsHandled
+        end
+      end
+
+      def add_option(option, description)
+        option_key = option[0].gsub('--', '').tr('-', '_').to_sym
+
+        if DEFAULTS.has_key?(option_key)
+          description += " (default: %s)" % DEFAULTS[option_key]
+        end
+
+        parser.on(option.join(' '), description) do |v|
+          options[option_key] = v
+        end
+      end
+
+      def options
+        @options ||= {}
+      end
+
+      def parser
+        @parser ||= OptionParser.new
+      end
+    end
+
+  end
+end

data/lib/cane/cli/translator.rb

@@ -0,0 +1,51 @@
+module Cane
+  module CLI
+
+    # Translates CLI options with given defaults to a hash suitable to be
+    # passed to `Cane.run`.
+    class Translator < Struct.new(:options, :defaults)
+      def to_hash
+        result = {}
+        translate_abc_options(result)
+        translate_doc_options(result)
+        translate_style_options(result)
+
+        result[:threshold] = options.fetch(:threshold, [])
+        result[:max_violations] = option_with_default(:max_violations).to_i
+
+        result
+      end
+
+      def translate_abc_options(result)
+        result[:abc] = {
+          files: option_with_default(:abc_glob),
+          max:   option_with_default(:abc_max).to_i
+        } unless check_disabled(:no_abc, [:abc_glob, :abc_max])
+      end
+
+      def translate_style_options(result)
+        result[:style] = {
+          files:   option_with_default(:style_glob),
+          measure: option_with_default(:style_measure).to_i,
+        } unless check_disabled(:no_style, [:style_glob])
+      end
+
+      def translate_doc_options(result)
+        result[:doc] = {
+          files: option_with_default(:doc_glob),
+        } unless check_disabled(:no_doc, [:doc_glob])
+      end
+
+      def check_disabled(check, params)
+        relevant_options = options.keys & params + [check]
+
+        check == relevant_options[-1]
+      end
+
+      def option_with_default(key)
+        options.fetch(key, defaults.fetch(key))
+      end
+    end
+
+  end
+end

data/lib/cane/doc_check.rb

@@ -0,0 +1,51 @@
+module Cane
+
+  # Creates violations for class definitions that do not have an explantory
+  # comment immediately preceeding.
+  class DocCheck < Struct.new(:opts)
+    def violations
+      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|
+        result = if class_definition?(line) && !comment?(last_line)
+          UndocumentedClassViolation.new(file_name, number + 1, line)
+        end
+        last_line = line
+        result
+      end.compact
+    end
+
+    def file_names
+      Dir[opts.fetch(:files)]
+    end
+
+    def class_definition?(line)
+      line =~ /^\s*class\s+/ and $'.index('<<') != 0
+    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)]
+    end
+
+    def extract_class_name(line)
+      line.match(/class (\S+)/)[1]
+    end
+  end
+
+end

data/lib/cane/rake_task.rb

@@ -0,0 +1,82 @@
+require 'rake'
+require 'rake/tasklib'
+
+module Cane
+  # Creates a rake task to run cane with given configuration.
+  #
+  # Examples
+  #
+  #   desc "Run code quality checks"
+  #   Cane::RakeTask.new(:quality) do |cane|
+  #     cane.abc_max = 10
+  #     cane.doc_glob = 'lib/**/*.rb'
+  #     cane.no_style = true
+  #     cane.add_threshold 'coverage/covered_percent', :>=, 99
+  #   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
+
+    # 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]
+    end
+
+    def initialize(task_name = nil)
+      self.name = task_name || :cane
+      @threshold = []
+      yield self if block_given?
+
+      unless ::Rake.application.last_comment
+        desc %(Check code quality metrics with cane)
+      end
+
+      task name do
+        require 'cane/cli'
+        abort unless Cane.run(translated_options)
+      end
+    end
+
+    def options
+      [
+        :abc_glob,
+        :abc_max,
+        :doc_glob,
+        :no_doc,
+        :max_violations,
+        :style_glob,
+        :no_style,
+        :style_measure
+      ].inject(threshold: @threshold) 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

@@ -0,0 +1,45 @@
+require 'cane/style_violation'
+
+module Cane
+
+  # Creates violations for files that do not meet style conventions. Only
+  # highly obvious, probable, and non-controversial checks are performed here.
+  # It is not the goal of the tool to provide an extensive style report, but
+  # only to prevent studid mistakes.
+  class StyleCheck < Struct.new(:opts)
+    def violations
+      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
+        end
+      end.flatten
+    end
+
+    protected
+
+    def violations_for_line(line)
+      result = []
+      if line.length > measure
+        result << "Line is >%i characters (%i)" % [measure, line.length]
+      end
+      result << "Line contains trailing whitespace" if line =~ /\s$/
+      result << "Line contains hard tabs"           if line =~ /\t/
+      result
+    end
+
+    def file_list
+      Dir[opts.fetch(:files)]
+    end
+
+    def measure
+      opts.fetch(:measure)
+    end
+
+    def map_lines(file_path, &block)
+      File.open(file_path).each_line.map.with_index(&block)
+    end
+  end
+
+end

data/lib/cane/style_violation.rb

@@ -0,0 +1,10 @@
+# Value object used by StyleCheck.
+class StyleViolation < Struct.new(:file_name, :line, :message)
+  def description
+    "Lines violated style requirements"
+  end
+
+  def columns
+    ["%s:%i" % [file_name, line], message]
+  end
+end

data/lib/cane/syntax_violation.rb

@@ -0,0 +1,20 @@
+module Cane
+
+  # Value object used by AbcCheck for a file that cannot be parsed. This is
+  # handled by AbcCheck rather than a separate class since it is a low value
+  # violation (syntax errors should have been picked up by specs) but we still
+  # have to deal with the edge case.
+  class SyntaxViolation < Struct.new(:file_name)
+    def columns
+      [file_name]
+    end
+
+    def description
+      "Files contained invalid syntax"
+    end
+
+    def sort_index
+      0
+    end
+  end
+end

data/lib/cane/threshold_check.rb

@@ -0,0 +1,30 @@
+require 'cane/threshold_violation'
+
+# 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)
+
+      unless value.send(operator, limit.to_f)
+        ThresholdViolation.new(file, operator, value, limit)
+      end
+    end.compact
+  end
+
+  def value_from_file(file)
+    begin
+      contents = File.read(file).chomp.to_f
+    rescue Errno::ENOENT
+      UnavailableValue.new
+    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/threshold_violation.rb

@@ -0,0 +1,15 @@
+# Value object used by ThresholdCheck.
+class ThresholdViolation < Struct.new(:name, :operator, :value, :limit)
+  def description
+    "Quality threshold crossed"
+  end
+
+  def columns
+    ["%s is %s, should be %s %s" % [
+      name,
+      value,
+      operator,
+      limit
+    ]]
+  end
+end