cane 1.0.0

data/HISTORY.md

@@ -0,0 +1,5 @@
+# Cane History
+
+## 1.0.0 - 14 January 2012 (4e400534)
+
+Initial release.

data/README.md

@@ -0,0 +1,89 @@
+# Cane
+
+Fails your build if code quality thresholds are not met.
+
+> Discipline will set you free.
+
+## Usage
+
+    gem install cane
+    cane --abc-glob '{lib,spec}/**/*.rb' --abc-max 15
+
+Your main build task should run this, probably via `bundle exec`. It will have
+a non-zero exit code if any quality checks fail. Also, a report:
+
+    > cane
+
+    Methods exceeded maximum allowed ABC complexity (2):
+
+      lib/cane.rb  Cane > sample    23
+      lib/cane.rb  Cane > sample_2  17
+
+    Lines violated style requirements (2):
+
+      lib/cane.rb:20   Line length >80
+      lib/cane.rb:42   Trailing whitespace
+
+    Classes are not documented (1):
+      lib/cane:3  SomeClass
+
+Customize behaviour with a wealth of options:
+
+    > cane --help
+    Usage: cane [options]
+            --abc-glob GLOB              Glob to run ABC metrics over (default: lib/**/*.rb)
+            --abc-max VALUE              Report any methods with complexity greater than VALUE (default: 15)
+            --no-abc                     Disable ABC checking
+
+            --style-glob GLOB            Glob to run style metrics over (default: {lib,spec}/**/*.rb)
+            --style-measure VALUE        Max line length (default: 80)
+            --no-style                   Disable style checking
+
+            --doc-glob GLOB              Glob to run documentation metrics over (default: lib/**/*.rb)
+            --no-doc                     Disable documentation checking
+
+            --gte FILE,THRESHOLD         If FILE contains a single number, verify it is >= to THRESHOLD.
+
+            --max-violations VALUE       Max allowed violations (default: 0)
+
+            --version                    Show version
+        -h, --help                       Show this message
+
+## Adding to a legacy project
+
+Cane can be configured to still pass in the presence of a set number of
+violations using the `--max-violations` option. This is ideal for retrofitting
+on to an existing application that may already have many violations. By setting
+the maximum to the current number, no immediate changes will be required to
+your existing code base, but you will be protected from things getting worse.
+
+## Integrating with SimpleCov
+
+Any value in a file can be used as a threshold:
+
+    > echo "89" > coverage/covered_percent
+    > cane --gte 'coverage/covered_percent,90'
+
+    Quality threshold crossed
+
+      coverage/covered_percent is 89, should be >= 90
+
+You can use a `SimpleCov` formatter to create the required file:
+
+    class SimpleCov::Formatter::QualityFormatter
+      def format(result)
+        SimpleCov::Formatter::HTMLFormatter.new.format(result)
+        File.open("coverage/covered_percent", "w") do |f|
+          f.puts result.source_files.covered_percent.to_f
+        end
+      end
+    end
+
+    SimpleCov.formatter = SimpleCov::Formatter::QualityFormatter
+
+## Compatibility
+
+Requires MRI 1.9, since it depends on the `ripper` library to calculate
+complexity metrics. This only applies to the Ruby used to run Cane, not the
+project it is being run against. In other words, you can run Cane against your
+1.8 project.

data/bin/cane

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'cane/cli'
+
+result = Cane::CLI.run(ARGV)
+
+exit(1) unless result

data/cane.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/cane/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Xavier Shay"]
+  gem.email         = ["xavier@squareup.com"]
+  gem.description   =
+    %q{Fails your build if code quality thresholds are not met}
+  gem.summary       = %q{
+    Fails your build if code quality thresholds are not met. Provides
+    complexity and style checkers built-in, and allows integration with with
+    custom quality metrics.
+  }
+  gem.homepage      = "http://github.com/square/cane"
+
+  gem.executables   = []
+  gem.files         = Dir.glob("{spec,lib}/**/*.rb") + %w(
+                        README.md
+                        HISTORY.md
+                        cane.gemspec
+                      )
+  gem.test_files    = Dir.glob("spec/**/*.rb")
+  gem.name          = "cane"
+  gem.require_paths = ["lib"]
+  gem.bindir        = "bin"
+  gem.executables  << "cane"
+  gem.version       = Cane::VERSION
+  gem.has_rdoc      = false
+  gem.add_dependency 'tailor'
+  gem.add_development_dependency 'rspec', '~> 2.0'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'simplecov'
+end

data/lib/cane.rb

@@ -0,0 +1,49 @@
+require 'cane/abc_check'
+require 'cane/style_check'
+require 'cane/doc_check'
+require 'cane/threshold_check'
+require 'cane/violation_formatter'
+
+module Cane
+  def run(opts)
+    Runner.new(opts).run
+  end
+  module_function :run
+
+  # Orchestrates the running of checks per the provided configuration, and
+  # hands the result to a formatter for display. This is the core of the
+  # application, but for the actual entry point see `Cane::CLI`.
+  class Runner
+    CHECKERS = {
+      abc:       AbcCheck,
+      style:     StyleCheck,
+      doc:       DocCheck,
+      threshold: ThresholdCheck
+    }
+
+    def initialize(opts)
+      @opts = opts
+    end
+
+    def run
+      outputter.print ViolationFormatter.new(violations)
+
+      violations.length <= opts.fetch(:max_violations)
+    end
+
+    protected
+
+    attr_reader :opts
+
+    def violations
+      @violations ||= CHECKERS.
+        select { |key, _| opts.has_key?(key) }.
+        map { |key, check| check.new(opts.fetch(key)).violations }.
+        flatten
+    end
+
+    def outputter
+      opts.fetch(:out, $stdout)
+    end
+  end
+end

data/lib/cane/abc_check.rb

@@ -0,0 +1,96 @@
+require 'ripper'
+
+require 'cane/abc_max_violation'
+
+module Cane
+
+  # Creates violations for methods that are too complicated using a simple
+  # algorithm run against the parse tree of a file to count assignments,
+  # branches, and conditionals. Borrows heavily from metric_abc.
+  class AbcCheck < Struct.new(:opts)
+    def violations
+      order file_names.map { |file_name|
+        find_violations(file_name)
+      }.flatten
+    end
+
+    protected
+
+    def find_violations(file_name)
+      ast = sexps_from_file(file_name)
+
+      process_ast(ast).
+        select { |nesting, complexity| complexity > max_allowed_complexity }.
+        map { |x| AbcMaxViolation.new(file_name, x.first, x.last) }
+    end
+
+    # Recursive function to process an AST. The `complexity` variable mutates,
+    # which is a bit confusing. `nesting` does not.
+    def process_ast(node, complexity = {}, nesting = [])
+      if method_nodes.include?(node[0])
+        nesting = nesting + [node[1][1]]
+        complexity[nesting.join(" > ")] = calculate_abc(node)
+      elsif container_nodes.include?(node[0])
+        parent = if node[1][1][1].is_a?(Symbol)
+          node[1][1][1]
+        else
+          node[1][-1][1]
+        end
+        nesting = nesting + [parent]
+      end
+
+      if node.is_a? Array
+        node[1..-1].each { |n| process_ast(n, complexity, nesting) if n }
+      end
+      complexity
+    end
+
+    def sexps_from_file(file_name)
+      Ripper::SexpBuilder.new(File.open(file_name, 'r:utf-8').read).parse
+    end
+
+    def max_allowed_complexity
+      opts.fetch(:max)
+    end
+
+    def calculate_abc(method_node)
+      a = count_nodes(method_node, assignment_nodes)
+      b = count_nodes(method_node, branch_nodes) + 1
+      c = count_nodes(method_node, condition_nodes)
+      abc = Math.sqrt(a**2 + b**2 + c**2).round
+      abc
+    end
+
+    def count_nodes(node, types)
+      node.flatten.select { |n| types.include?(n) }.length
+    end
+
+    def file_names
+      Dir[opts.fetch(:files)]
+    end
+
+    def order(result)
+      result.sort_by(&:complexity).reverse
+    end
+
+    def assignment_nodes
+      [:assign, :opassign]
+    end
+
+    def method_nodes
+      [:def]
+    end
+
+    def container_nodes
+      [:class, :module]
+    end
+
+    def branch_nodes
+      [:call, :fcall, :brace_block, :do_block]
+    end
+
+    def condition_nodes
+      [:==, :===, :"<>", :"<=", :">=", :"=~", :>, :<, :else, :"<=>"]
+    end
+  end
+end

data/lib/cane/abc_max_violation.rb

@@ -0,0 +1,13 @@
+module Cane
+
+  # Value object used by AbcCheck for a method that is too complicated.
+  class AbcMaxViolation < Struct.new(:file_name, :detail, :complexity)
+    def columns
+      [file_name, detail, complexity]
+    end
+
+    def description
+      "Methods exceeded maximum allowed ABC complexity"
+    end
+  end
+end

data/lib/cane/cli.rb

@@ -0,0 +1,21 @@
+require 'cane'
+require 'cane/version'
+
+require 'cane/cli/spec'
+require 'cane/cli/translator'
+
+module Cane
+  module CLI
+
+    def run(args)
+      opts = Spec.new.parse(args)
+      if opts
+        Cane.run(opts)
+      else
+        true
+      end
+    end
+    module_function :run
+
+  end
+end

data/lib/cane/cli/spec.rb

@@ -0,0 +1,114 @@
+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:       'lib/**/*.rb',
+        abc_max:        '15',
+        style_glob:     '{lib,spec}/**/*.rb',
+        style_measure:  '80',
+        doc_glob:       '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_abc_options
+        add_style_options
+        add_doc_options
+        add_threshold_options
+        add_cane_options
+
+        add_version
+        add_help
+      end
+
+      def parse(args)
+        parser.parse!(args)
+        Translator.new(options, DEFAULTS).to_hash
+      rescue OptionsHandled
+        nil
+      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,49 @@
+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)
+        ((params + [check]) & options.keys) == [check]
+      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/
+    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/style_check.rb

@@ -0,0 +1,98 @@
+require 'tailor'
+
+require 'cane/style_violation'
+
+module Cane
+
+  # Creates violations for files that do not meet style conventions. This uses
+  # the `tailor` gem, configured to exclude some of its less reliable checks
+  # (mostly spacing around punctuation).
+  class StyleCheck < Struct.new(:opts)
+    def violations
+      Dir[opts.fetch(:files)].map do |file_name|
+        find_violations_in_file(file_name)
+      end.flatten
+    end
+
+    protected
+
+    def find_violations_in_file(file_name)
+      source    = File.open(file_name, 'r:utf-8')
+      file_path = Pathname.new(file_name)
+
+      source.each_line.map.with_index do |source_line, line_number|
+        violations_for_line(file_path, source_line, line_number)
+      end
+    end
+
+    def violations_for_line(file_path, source_line, line_number)
+      FileLine.new(source_line, opts).problems.map do |message|
+        StyleViolation.new(file_path, line_number + 1, message)
+      end
+    end
+  end
+
+  # The `tailor` gem was not designed to be used as a library, so interfacing
+  # with it is a bit of a mess. This wrapper is attempt to confine that mess to
+  # a single point in the code.
+  class FileLine < Tailor::FileLine
+    attr_accessor :opts
+
+    def initialize(source_line, opts)
+      self.opts = opts
+
+      super(source_line, nil, nil)
+    end
+
+    def find_problems
+      # This is weird. These methods actually have side-effects! We capture
+      # the effects my monkey-patching #print_problem below.
+      spacing_problems
+      method_line? && camel_case_method?
+      class_line?  && snake_case_class?
+      too_long?
+    end
+
+    def print_problem(message)
+      @problems << message.gsub(/\[.+\]\s+/, '')
+    end
+
+    def problems
+      @problems = []
+      find_problems
+      @problems
+    end
+
+    # A copy of the parent method that only uses a small subset of the spacing
+    # checks we actually want (the others are too buggy or controversial).
+    def spacing_problems
+      spacing_conditions.each_pair do |condition, values|
+        unless self.scan(values.first).empty?
+          print_problem values[1]
+        end
+      end
+    end
+
+    def spacing_conditions
+      SPACING_CONDITIONS.select {|k, _|
+        [:hard_tabbed, :trailing_whitespace].include?(k)
+      }
+    end
+
+    # Copy of parent method using a configurable line length.
+    def too_long?
+      length = self.length
+      if length > line_length_max
+        print_problem "Line is >#{line_length_max} characters (#{length})"
+        return true
+      end
+
+      false
+    end
+
+    def line_length_max
+      opts.fetch(:measure)
+    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/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

data/lib/cane/version.rb

@@ -0,0 +1,3 @@
+module Cane
+  VERSION = '1.0.0'
+end

data/lib/cane/violation_formatter.rb

@@ -0,0 +1,49 @@
+require 'stringio'
+
+module Cane
+
+  # Computes a string to be displayed as output from an array of violations
+  # computed by the checks.
+  class ViolationFormatter < Struct.new(:violations)
+    def to_s
+      return '' if violations.empty?
+
+      grouped_violations.map do |description, violations|
+        format_group_header(description, violations) +
+          format_violations(violations)
+      end.flatten.join("\n") + "\n\n"
+    end
+
+    protected
+
+    def format_group_header(description, violations)
+      ["", "%s (%i):" % [description, violations.length], ""]
+    end
+
+    def format_violations(violations)
+      column_widths = calculate_columm_widths(violations)
+
+      violations.map do |violation|
+        format_violation(violation, column_widths)
+      end
+    end
+
+    def format_violation(violation, column_widths)
+      [
+        '  ' + violation.columns.map.with_index { |column, index|
+          "%-#{column_widths[index]}s" % column
+        }.join('  ')
+      ]
+    end
+
+    def calculate_columm_widths(violations)
+      violations.map { |violation|
+        violation.columns.map { |x| x.to_s.length }
+      }.transpose.map(&:max)
+    end
+
+    def grouped_violations
+      violations.group_by(&:description)
+    end
+  end
+end

data/spec/abc_check_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+require 'cane/abc_check'
+
+describe Cane::AbcCheck do
+  it 'creates an AbcMaxViolation for each method above the threshold' do
+    file_name = make_file(<<-RUBY)
+      class Harness
+        def not_complex
+          true
+        end
+
+        def complex_method(a)
+          b = a
+          return b if b > 3
+        end
+      end
+    RUBY
+
+    violations = described_class.new(files: file_name, max: 1).violations
+    violations.length.should == 1
+    violations[0].should be_instance_of(Cane::AbcMaxViolation)
+    violations[0].to_s.should include("Harness")
+    violations[0].to_s.should include("complex_method")
+  end
+
+  it 'sorts violations by complexity' do
+    file_name = make_file(<<-RUBY)
+      class Harness
+        def not_complex
+          true
+        end
+
+        def complex_method(a)
+          b = a
+          return b if b > 3
+        end
+      end
+    RUBY
+
+    violations = described_class.new(files: file_name, max: 0).violations
+    violations.length.should == 2
+    complexities = violations.map(&:complexity)
+    complexities.should == complexities.sort.reverse
+  end
+end

data/spec/cane_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+require "stringio"
+require 'cane/cli'
+
+describe 'Cane' do
+  def capture_stdout &block
+    real_stdout, $stdout = $stdout, StringIO.new
+    yield
+    $stdout.string
+  ensure
+    $stdout = real_stdout
+  end
+
+  def run(cli_args)
+    result = nil
+    output = capture_stdout do
+      default_cli_opts = %w(--no-style --no-abc --no-doc)
+      result = Cane::CLI.run(default_cli_opts + cli_args.split(' '))
+    end
+
+    [output, result ? 0 : 1]
+  end
+
+  it 'fails if ABC metric does not meet requirements' do
+    file_name = make_file(<<-RUBY)
+      class Harness
+        def complex_method(a)
+          if a < 2
+            return "low"
+          else
+            return "high"
+          end
+        end
+      end
+    RUBY
+
+    _, exitstatus = run("--abc-glob #{file_name} --abc-max 1")
+
+    exitstatus.should == 1
+  end
+
+  it 'fails if style metrics do not meet requirements' do
+    file_name = make_file("whitespace ")
+
+    output, exitstatus = run("--style-glob #{file_name}")
+    exitstatus.should == 1
+    output.should include("Lines violated style requirements")
+  end
+
+  it 'allows measure to be configured' do
+    file_name = make_file("toolong")
+
+    output, exitstatus = run("--style-glob #{file_name} --style-measure 3")
+    exitstatus.should == 1
+    output.should include("Lines violated style requirements")
+  end
+
+  it 'allows upper bound of failed checks' do
+    file_name = make_file("whitespace ")
+
+    output, exitstatus = run("--style-glob #{file_name} --max-violations 1")
+    exitstatus.should == 0
+    output.should include("Lines violated style requirements")
+  end
+
+  it 'allows checking of a value in a file' do
+    file_name = make_file("89")
+
+    output, exitstatus = run("--gte #{file_name},90")
+    exitstatus.should == 1
+    output.should include("Quality threshold crossed")
+  end
+
+  it 'allows checking of class documentation' do
+    file_name = make_file("class NoDoc")
+
+    output, exitstatus = run("--doc-glob #{file_name}")
+    exitstatus.should == 1
+    output.should include("Classes are not documented")
+  end
+
+  it 'displays a help message' do
+    output, exitstatus = run("--help")
+
+    exitstatus.should == 0
+    output.should include("Usage:")
+  end
+
+  it 'displays version' do
+    output, exitstatus = run("--version")
+
+    exitstatus.should == 0
+    output.should include(Cane::VERSION)
+  end
+end

data/spec/doc_check_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+require 'cane/doc_check'
+
+describe Cane::DocCheck do
+  it 'creates a DocViolation for each undocumented class' do
+    file_name = make_file <<-RUBY
+# This class is documented
+class Doc; end
+class NoDoc; end # No doc
+  class AlsoNoDoc; end
+[:class]
+# class Ignore
+    RUBY
+
+    violations = described_class.new(files: file_name).violations
+    violations.length.should == 2
+
+    violations[0].should be_instance_of(Cane::UndocumentedClassViolation)
+    violations[0].file_name.should == file_name
+    violations[0].number.should == 3
+
+    violations[1].should be_instance_of(Cane::UndocumentedClassViolation)
+    violations[1].file_name.should == file_name
+    violations[1].number.should == 4
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'tempfile'
+
+# Keep a reference to all tempfiles so they are not garbage collected until the
+# process exits.
+$tempfiles = []
+
+def make_file(content)
+  tempfile = Tempfile.new('cane')
+  $tempfiles << tempfile
+  tempfile.print(content)
+  tempfile.flush
+  tempfile.path
+end
+
+require 'simplecov'
+
+class SimpleCov::Formatter::QualityFormatter
+  def format(result)
+    SimpleCov::Formatter::HTMLFormatter.new.format(result)
+    File.open("coverage/covered_percent", "w") do |f|
+      f.puts result.source_files.covered_percent.to_i
+    end
+  end
+end
+
+SimpleCov.formatter = SimpleCov::Formatter::QualityFormatter
+SimpleCov.start

data/spec/style_check_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+require 'cane/style_check'
+
+describe Cane::StyleCheck do
+  it 'creates a StyleViolation for each method above the threshold' do
+    ruby = [
+      "def test  ",
+      "\t1",
+      "end"
+    ].join("\n")
+    file_name = make_file(ruby)
+
+    violations = Cane::StyleCheck.new(files: file_name, measure: 80).violations
+    violations.length.should == 2
+    violations[0].should be_instance_of(StyleViolation)
+  end
+end

data/spec/threshold_check_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+require 'cane/threshold_check'
+
+describe ThresholdCheck do
+  it 'returns a value of unavailable when file cannot be read' do
+    check = ThresholdCheck.new([[:>=, 'bogus_file', 20]])
+    violations = check.violations
+    violations.length.should == 1
+    violations[0].to_s.should include("unavailable")
+  end
+end

data/spec/violation_formatter_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+require 'cane/violation_formatter'
+
+describe Cane::ViolationFormatter do
+  def violation(description)
+    stub("violation",
+      description: description,
+      columns:     []
+    )
+  end
+
+  it 'includes number of violations in the group header' do
+    described_class.new([violation("FAIL")]).to_s.should include("(1)")
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: cane
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Xavier Shay
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tailor
+  requirement: &2156048880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2156048880
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2156048380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156048380
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2156047960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156047960
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &2156047500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156047500
+description: Fails your build if code quality thresholds are not met
+email:
+- xavier@squareup.com
+executables:
+- cane
+extensions: []
+extra_rdoc_files: []
+files:
+- spec/abc_check_spec.rb
+- spec/cane_spec.rb
+- spec/doc_check_spec.rb
+- spec/spec_helper.rb
+- spec/style_check_spec.rb
+- spec/threshold_check_spec.rb
+- spec/violation_formatter_spec.rb
+- lib/cane/abc_check.rb
+- lib/cane/abc_max_violation.rb
+- lib/cane/cli/spec.rb
+- lib/cane/cli/translator.rb
+- lib/cane/cli.rb
+- lib/cane/doc_check.rb
+- lib/cane/style_check.rb
+- lib/cane/style_violation.rb
+- lib/cane/threshold_check.rb
+- lib/cane/threshold_violation.rb
+- lib/cane/version.rb
+- lib/cane/violation_formatter.rb
+- lib/cane.rb
+- README.md
+- HISTORY.md
+- cane.gemspec
+- bin/cane
+homepage: http://github.com/square/cane
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Fails your build if code quality thresholds are not met. Provides complexity
+  and style checkers built-in, and allows integration with with custom quality metrics.
+test_files:
+- spec/abc_check_spec.rb
+- spec/cane_spec.rb
+- spec/doc_check_spec.rb
+- spec/spec_helper.rb
+- spec/style_check_spec.rb
+- spec/threshold_check_spec.rb
+- spec/violation_formatter_spec.rb