sugarcane 0.0.1

data/spec/abc_check_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+require 'sugarcane/abc_check'
+
+describe SugarCane::AbcCheck do
+  def check(file_name, opts = {})
+    described_class.new(opts.merge(abc_glob: file_name))
+  end
+
+  it 'does not create violations when no_abc flag is set' do
+    file_name = make_file(<<-RUBY)
+      class Harness
+        def complex_method(a)
+          b = a
+          return b if b > 3
+        end
+      end
+    RUBY
+
+    violations = check(file_name, abc_max: 1, no_abc: true).violations
+    violations.should be_empty
+  end
+
+  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 = check(file_name, abc_max: 1, no_abc: false).violations
+    violations.length.should == 1
+    violations[0].values_at(:file, :label, :value).should ==
+      [file_name, "Harness#complex_method", 2]
+  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 = check(file_name, abc_max: 0).violations
+    violations.length.should == 2
+    complexities = violations.map {|x| x[:value] }
+    complexities.should == complexities.sort.reverse
+  end
+
+  it 'creates a violation when code cannot be parsed' do
+    file_name = make_file(<<-RUBY)
+      class Harness
+    RUBY
+
+    violations = check(file_name).violations
+    violations.length.should == 1
+    violations[0][:file].should == file_name
+    violations[0][:description].should be_instance_of(String)
+  end
+
+  it 'skips declared exclusions' do
+    file_name = make_file(<<-RUBY)
+      class Harness
+        def instance_meth
+          true
+        end
+
+        def self.class_meth
+          true
+        end
+
+        module Nested
+          def i_meth
+            true
+          end
+
+          def self.c_meth
+            true
+          end
+
+          def other_meth
+            true
+          end
+        end
+      end
+    RUBY
+
+    exclusions = %w[ Harness#instance_meth  Harness.class_meth
+                     Harness::Nested#i_meth Harness::Nested.c_meth ]
+    violations = check(file_name,
+      abc_max:        0,
+      abc_exclude: exclusions
+    ).violations
+    violations.length.should == 1
+    violations[0].values_at(:file, :label, :value).should ==
+      [file_name, "Harness::Nested#other_meth", 1]
+  end
+
+  it "creates an AbcMaxViolation for method in assigned anonymous class" do
+    file_name = make_file(<<-RUBY)
+      MyClass = Struct.new(:foo) do
+        def test_method(a)
+          b = a
+          return b if b > 3
+        end
+      end
+    RUBY
+
+    violations = check(file_name, abc_max: 1).violations
+    violations[0][:label] == "MyClass#test_method"
+  end
+
+  it "creates an AbcMaxViolation for method in anonymous class" do
+    file_name = make_file(<<-RUBY)
+      Class.new do
+        def test_method(a)
+          b = a
+          return b if b > 3
+        end
+      end
+    RUBY
+
+    violations = check(file_name, abc_max: 1).violations
+    violations[0][:label].should == "(anon)#test_method"
+  end
+
+  def self.it_should_extract_method_name(name, label=name, sep='#')
+    it "creates an AbcMaxViolation for #{name}" do
+      file_name = make_file(<<-RUBY)
+        class Harness
+          def #{name}(a)
+            b = a
+            return b if b > 3
+          end
+        end
+      RUBY
+
+      violations = check(file_name, abc_max: 1).violations
+      violations[0][:label].should == "Harness#{sep}#{label}"
+    end
+  end
+
+  # These method names all create different ASTs. Which is weird.
+  it_should_extract_method_name 'a'
+  it_should_extract_method_name 'self.a', 'a', '.'
+  it_should_extract_method_name 'next'
+  it_should_extract_method_name 'GET'
+  it_should_extract_method_name '`'
+  it_should_extract_method_name '>='
+end

data/spec/cane_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+require "stringio"
+require 'sugarcane/cli'
+require 'sugarcane/menu'
+
+require 'sugarcane/rake_task'
+require 'sugarcane/task_runner'
+
+# Acceptance tests
+describe 'The sugarcane application' do
+  let(:class_name) { "C#{rand(10 ** 10)}" }
+
+  let(:fn) do
+    make_file(<<-RUBY + "  ")
+      class Harness
+        def complex_method(a)
+          if a < 2
+            return "low"
+          else
+            return "high"
+          end
+        end
+      end
+    RUBY
+  end
+
+  let(:check_file) do
+    make_file <<-RUBY
+      class #{class_name} < Struct.new(:opts)
+        def self.options
+          {
+            unhappy_file: ["File to check", default: [nil]]
+          }
+        end
+
+        def violations
+          [
+            description: "Files are unhappy",
+            file:        opts.fetch(:unhappy_file),
+            label:       ":("
+          ]
+        end
+      end
+    RUBY
+  end
+
+  it 'returns a non-zero exit code and a details of checks that failed' do
+    output, exitstatus = run %(
+      --report
+      --style-glob #{fn}
+      --doc-glob #{fn}
+      --abc-glob #{fn}
+      --abc-max 1
+      -r #{check_file}
+      --check #{class_name}
+      --unhappy-file #{fn}
+    )
+    output.should include("Lines violated style requirements")
+    output.should include("Methods exceeded maximum allowed ABC complexity")
+    output.should include(
+      "Class and Module definitions require explanatory comments"
+    )
+    exitstatus.should == 1
+  end
+
+  it 'should not show methods within the expected ABC complexity' do
+    output, exitstatus = run %(
+      --report
+      --style-glob #{fn}
+      --doc-glob #{fn}
+      --abc-glob #{fn}
+      --abc-max 10
+      -r #{check_file}
+      --check #{class_name}
+      --unhappy-file #{fn}
+    )
+    output.should include("Lines violated style requirements")
+    output.should_not include("Methods exceeded maximum allowed ABC complexity")
+    output.should include(
+      "Class and Module definitions require explanatory comments"
+    )
+    exitstatus.should == 1
+  end
+
+  it 'creates a menu' do
+    pending "Make a unit test or find a way to create artificial key presses"
+    output, exitstatus = run %(
+      --style-glob #{fn}
+      --doc-glob #{fn}
+      --abc-glob #{fn}
+      --abc-max 1
+      -r #{check_file}
+      --check #{class_name}
+      --unhappy-file #{fn}
+    )
+
+    exitstatus.should == 1
+  end
+
+  it 'handles invalid unicode input' do
+    fn = make_file("\xc3\x28")
+
+    _, exitstatus = run("--style-glob #{fn} --abc-glob #{fn} --doc-glob #{fn}")
+
+    exitstatus.should == 0
+  end
+
+  it 'can run tasks in parallel' do
+    # This spec isn't great, but there is no good way to actually observe that
+    # tasks run in parallel and we want to verify the conditional is correct.
+    SugarCane.task_runner(parallel: true).should == Parallel
+  end
+
+  it 'colorizes output' do
+    output, exitstatus = run("--report --color --abc-max 0")
+
+    output.should include("\e[31m")
+  end
+
+  after do
+    if Object.const_defined?(class_name)
+      Object.send(:remove_const, class_name)
+    end
+  end
+
+  def run(cli_args)
+    result = nil
+    output = capture_stdout do
+      result = SugarCane::CLI.run(
+        %w(--no-abc --no-style --no-doc) + cli_args.split(/\s+/m)
+      )
+    end
+
+    [output, result ? 0 : 1]
+  end
+end

data/spec/cli_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'sugarcane/cli'
+
+describe SugarCane::CLI do
+  describe '.run' do
+
+    let!(:parser) { class_double("SugarCane::CLI::Parser").as_stubbed_const }
+    let!(:cane)   { class_double("SugarCane").as_stubbed_const }
+
+    it 'runs SugarCane with the given arguments' do
+      parser.should_receive(:parse).with("--args").and_return(args: true)
+      cane.should_receive(:run).with(args: true).and_return("tracer")
+
+      described_class.run("--args").should == "tracer"
+    end
+
+    it 'does not run SugarCane if parser was able to handle input' do
+      parser.should_receive(:parse).with("--args").and_return("tracer")
+
+      described_class.run("--args").should == "tracer"
+    end
+  end
+end

data/spec/doc_check_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+require 'sugarcane/doc_check'
+
+describe SugarCane::DocCheck do
+  def check(file_name, opts = {})
+    described_class.new(opts.merge(doc_glob: file_name))
+  end
+
+  it 'creates a DocViolation for each undocumented class with a method' do
+    file_name = make_file <<-RUBY
+class Doc; end
+class  Empty; end # No doc is fine
+  class NoDoc; def with_method; end; end
+classIgnore = nil
+[:class]
+# class Ignore
+class Meta
+  class << self; end
+end
+module DontNeedDoc; end
+# This module is documented
+module HasDoc
+  def mixin; end
+end
+module AlsoNeedsDoc; def mixin; end; end
+module NoDocIsFine
+  module ButThisNeedsDoc
+    def self.global
+    end
+  end
+  module AlsoNoDocIsFine; end
+  # We've got docs
+  module CauseWeNeedThem
+    def mixin
+    end
+  end
+end
+    RUBY
+
+    violations = check(file_name).violations
+    violations.length.should == 3
+
+    violations[0].values_at(:file, :line, :label).should == [
+      file_name, 3, "NoDoc"
+    ]
+
+    violations[1].values_at(:file, :line, :label).should == [
+      file_name, 15, "AlsoNeedsDoc"
+    ]
+
+    violations[2].values_at(:file, :line, :label).should == [
+      file_name, 17, "ButThisNeedsDoc"
+    ]
+  end
+
+  it 'does not create violations for single line classes without methods' do
+    file_name = make_file <<-RUBY
+class NeedsDoc
+  class AlsoNeedsDoc < StandardError; def foo; end; end
+  class NoDocIsOk < StandardError; end
+  class NoDocIsAlsoOk < StandardError; end # No doc is fine on this too
+
+  def my_method
+  end
+end
+RUBY
+
+    violations = check(file_name).violations
+    violations.length.should == 2
+
+    violations[0].values_at(:file, :line, :label).should == [
+      file_name, 1, "NeedsDoc"
+    ]
+
+    violations[1].values_at(:file, :line, :label).should == [
+      file_name, 2, "AlsoNeedsDoc"
+    ]
+  end
+
+  it 'ignores magic encoding comments' do
+    file_name = make_file <<-RUBY
+# coding = utf-8
+class NoDoc; def do_stuff; end; end
+# -*-  encoding :  utf-8  -*-
+class AlsoNoDoc; def do_more_stuff; end; end
+# Parse a Transfer-Encoding: Chunked response
+class Doc; end
+    RUBY
+
+    violations = check(file_name).violations
+    violations.length.should == 2
+
+    violations[0].values_at(:file, :line, :label).should == [
+      file_name, 2, "NoDoc"
+    ]
+    violations[1].values_at(:file, :line, :label).should == [
+      file_name, 4, "AlsoNoDoc"
+    ]
+  end
+
+  it 'creates a violation for missing README' do
+    file = class_double("SugarCane::File").as_stubbed_const
+    stub_const("SugarCane::File", file)
+    file.should_receive(:case_insensitive_glob).with("README*").and_return([])
+
+    violations = check("").violations
+    violations.length.should == 1
+
+    violations[0].values_at(:description, :label).should == [
+      "Missing documentation", "No README found"
+    ]
+  end
+
+  it 'does not create a violation when readme exists' do
+    file = class_double("SugarCane::File").as_stubbed_const
+    stub_const("SugarCane::File", file)
+    file
+      .should_receive(:case_insensitive_glob)
+      .with("README*")
+      .and_return(%w(readme.md))
+
+    violations = check("").violations
+    violations.length.should == 0
+  end
+
+  it 'skips declared exclusions' do
+    file_name = make_file <<-FILE.gsub /^\s{6}/, ''
+      class NeedsDocumentation
+      end
+    FILE
+
+    violations = check(file_name,
+      doc_exclude: [file_name]
+    ).violations
+
+    violations.length.should == 0
+  end
+
+  it 'skips declared glob-based exclusions' do
+    file_name = make_file <<-FILE.gsub /^\s{6}/, ''
+      class NeedsDocumentation
+      end
+    FILE
+
+    violations = check(file_name,
+      doc_exclude: ["#{File.dirname(file_name)}/*"]
+    ).violations
+
+    violations.length.should == 0
+  end
+
+  it 'skips class inside an array' do
+    file_name = make_file <<-RUBY
+    %w(
+      class
+      method
+    )
+    RUBY
+
+    violations = check(file_name).violations
+    violations.length.should == 0
+  end
+end

data/spec/encoding_aware_iterator_spec.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'sugarcane/encoding_aware_iterator'
+
+# Example bad input from:
+#   http://stackoverflow.com/questions/1301402/example-invalid-utf8-string
+describe SugarCane::EncodingAwareIterator do
+  it 'handles non-UTF8 input' do
+    lines = ["\xc3\x28"]
+    result = described_class.new(lines).map.with_index do |line, number|
+      line.should be_kind_of(String)
+      [line =~ /\s/, number]
+    end
+    result.should == [[nil, 0]]
+  end
+
+  it 'does not enter an infinite loop on persistently bad input' do
+    ->{
+      described_class.new([""]).map.with_index do |line, number|
+        "\xc3\x28" =~ /\s/
+      end
+    }.should raise_error(ArgumentError)
+  end
+
+  it 'allows each with no block' do
+    called_with_line = nil
+    described_class.new([""]).each.with_index do |line, number|
+      called_with_line = line
+    end
+    called_with_line.should == ""
+  end
+end

data/spec/file_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'tmpdir'
+
+require 'sugarcane/file'
+
+describe SugarCane::File do
+  describe '.case_insensitive_glob' do
+    it 'matches all kinds of readmes' do
+      expected = %w(
+        README
+        readme.md
+        ReaDME.TEXTILE
+      )
+
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          expected.each do |x|
+            FileUtils.touch(x)
+          end
+          SugarCane::File.case_insensitive_glob("README*").should =~ expected
+        end
+      end
+    end
+  end
+end

data/spec/json_formatter_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'sugarcane/json_formatter'
+
+describe SugarCane::JsonFormatter do
+  it 'outputs violations as JSON' do
+    violations = [{description: 'Fail', line: 3}]
+    JSON.parse(described_class.new(violations).to_s).should ==
+      [{'description' => 'Fail', 'line' => 3}]
+  end
+end