wool 0.5.1

data/spec/warning_specs/comment_spacing_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe InlineCommentSpaceWarning do
+  SETTINGS = {InlineCommentSpaceWarning::OPTION_KEY => 2, :indent_size => 2}
+  it 'is a line-based warning' do
+    InlineCommentSpaceWarning.new('(stdin)', 'hello').should be_a(LineWarning)
+  end
+
+  it 'matches when there are less than 2 spaces between code and comment' do
+    InlineCommentSpaceWarning.should warn('a + b#comment', SETTINGS)
+    InlineCommentSpaceWarning.should warn('a + b # comment', SETTINGS)
+    InlineCommentSpaceWarning.should_not warn('a + b  # comment', SETTINGS)
+    InlineCommentSpaceWarning.should_not warn('a +b  # wool: ignore OperatorSpacing', SETTINGS)
+  end
+
+  it 'has an option to specify the necessary spacing' do
+    InlineCommentSpaceWarning.options.size.should be > 0
+    InlineCommentSpaceWarning.options[0].first.should ==
+        InlineCommentSpaceWarning::OPTION_KEY
+  end
+
+  it 'respects the option for specifying the necessary spacing' do
+    settings = {InlineCommentSpaceWarning::OPTION_KEY => 0}
+    InlineCommentSpaceWarning.should warn('a + b # comment', settings)
+    InlineCommentSpaceWarning.should_not warn('a + b# comment', settings)
+  end
+
+  it 'has a remotely useful description' do
+    InlineCommentSpaceWarning.new('(stdin)', 'hello  #').desc.should =~ /inline.*comment/i
+  end
+
+  context 'when fixing' do
+    before do
+      @settings = {InlineCommentSpaceWarning::OPTION_KEY => 2}
+    end
+
+    after do
+      InlineCommentSpaceWarning.should correct_to(@input, @output, @settings)
+    end
+
+    it 'adds spaces when necessary' do
+      @input = 'a + b#comment'
+      @output = 'a + b  #comment'
+    end
+
+    it 'removes spaces when necessary' do
+      @input = 'a + b        #comment'
+      @output = 'a + b  #comment'
+    end
+
+    it 'respects the option for spacing' do
+      @settings = {InlineCommentSpaceWarning::OPTION_KEY => 0}
+      @input = 'a + b        #comment'
+      @output = 'a + b#comment'
+    end
+  end
+end

data/spec/warning_specs/extra_blank_lines_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe ExtraBlankLinesWarning do
+  it 'is a file-based warning' do
+    ExtraBlankLinesWarning.new('(stdin)', 'hello').should be_a(FileWarning)
+    FileWarning.all_warnings.should include(ExtraBlankLinesWarning)
+  end
+
+  it 'matches when there is a single empty blank line' do
+    ExtraBlankLinesWarning.should warn("a + b\n")
+  end
+
+  it 'matches when there is a single blank line with spaces' do
+    ExtraBlankLinesWarning.should warn("a + b\n  ")
+  end
+
+  it 'matches when there is are multiple blank lines' do
+    ExtraBlankLinesWarning.should warn("a + b\n  \n\t\n")
+  end
+
+  it 'counts the number of blank lines' do
+    ExtraBlankLinesWarning.new('(stdin)', "a + b\n").count_extra_lines.should == 1
+    ExtraBlankLinesWarning.new('(stdin)', "a + b\n\t\n").count_extra_lines.should == 2
+    ExtraBlankLinesWarning.new('(stdin)', "a + b\n\n").count_extra_lines.should == 2
+    ExtraBlankLinesWarning.new('(stdin)', "a + b\n  \n\n").count_extra_lines.should == 3
+    ExtraBlankLinesWarning.new('(stdin)', "a + b\n  \n\t\n").count_extra_lines.should == 3
+    ExtraBlankLinesWarning.new('(stdin)', "a + b\n\n\n\n\n").count_extra_lines.should == 5
+  end
+
+  it 'has a remotely useful description' do
+    ExtraBlankLinesWarning.new('(stdin)', 'hello  ').desc.should =~ /blank line/
+  end
+
+  INPUTS = ["a + b\n\n\t  \t\n\t  ", "a + b\n  \n\t\n", "a + b\n  \n\n",
+            "a + b\n\n\n\n\n", "a + b\n", "a + b\n  " ]
+
+  INPUTS.each do |input|
+    context "When fixing #{input.inspect}" do
+      it 'fixes by removing all extra whitespace' do
+        ExtraBlankLinesWarning.should correct_to(input, 'a + b')
+      end
+    end
+  end
+
+  context 'when fixing a realistic multiline block' do
+    before do
+      @original = <<-EOF
+    # Warning for using semicolons outside of class declarations.
+  class SemicolonWarning < LineWarning
+
+  def initialize(file, line)
+    severity = line =~ /['"]/ ? 2 : 4
+    super('Semicolon for multiple statements', file, line, 0, severity)
+  end
+
+  def desc
+    'The line uses a semicolon to separate multiple statements outside of a class declaration.'
+  end
+
+end
+EOF
+      @original.strip!
+      @invalid = @original + "\n  \t\t\n  \n\n"
+    end
+
+    it 'only removes the trailing whitespace' do
+      ExtraBlankLinesWarning.should correct_to(@invalid, @original)
+    end
+  end
+end

data/spec/warning_specs/extra_whitespace_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe ExtraWhitespaceWarning do
+  it 'is a line-based warning' do
+    ExtraWhitespaceWarning.new('(stdin)', 'hello').should be_a(LineWarning)
+  end
+
+  it 'matches when there are spaces at the end of a line' do
+    ExtraWhitespaceWarning.should warn('a + b  ')
+    ExtraWhitespaceWarning.should warn('a + b ')
+    ExtraWhitespaceWarning.should_not warn('a + b')
+  end
+
+  it 'matches when there are tabs at the end of a line' do
+    ExtraWhitespaceWarning.should warn("a + b\t\t")
+    ExtraWhitespaceWarning.should warn("a + b\t")
+    ExtraWhitespaceWarning.should_not warn('a + b')
+  end
+
+  it 'has a remotely useful description' do
+    ExtraWhitespaceWarning.new('(stdin)', 'hello  ').desc.should =~ /whitespace/
+  end
+
+  context 'when fixing' do
+    it 'fixes by removing extra spaces' do
+      ExtraWhitespaceWarning.should correct_to('a + b  ', 'a + b')
+    end
+
+    it 'fixes by removing extra tabs' do
+      ExtraWhitespaceWarning.should correct_to("a + b\t\t", 'a + b')
+    end
+  end
+end

data/spec/warning_specs/line_length_spec.rb

@@ -0,0 +1,165 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe GenericLineLengthWarning do
+  before do
+    @eighty_cap = LineLengthCustomSeverity(80, 2)
+    @eighty_cap.line_length_limit = 80
+  end
+
+  it 'is a line-based warning' do
+    GenericLineLengthWarning.new('(stdin)', 'hello').should be_a(LineWarning)
+  end
+
+  it 'initializes to a file and line' do
+    warning = @eighty_cap.new('(stdin)', 'x' * 81)
+    warning.severity.should == @eighty_cap.severity
+  end
+
+  it 'has a remotely useful description' do
+    @eighty_cap.new('(stdin)', 'x' * 80).desc.should =~ /line length/i
+  end
+
+  it 'matches lines longer than the specified number of characters' do
+    @eighty_cap.should warn('x' * 82)
+  end
+
+  it 'does not match lines shorter than the specified number of characters' do
+    @eighty_cap.should_not warn('x' * 78)
+  end
+
+  it 'does not match lines equal to the specified number of characters' do
+    @eighty_cap.should_not warn('x' * 80)
+  end
+
+  context 'when fixing' do
+    before do
+      @twenty_cap = Class.new(GenericLineLengthWarning)
+      @twenty_cap.line_length_limit = 20
+      @settings = {}
+    end
+
+    after do
+      @twenty_cap.should correct_to(@input, @output, @settings)
+    end
+
+    it 'takes a line with just a comment on it and breaks it into many lines' do
+      @input = '# my comment is this and that and another thing'
+      @output = "# my comment is this\n# and that and\n# another thing"
+    end
+
+    it 'creates new lines with the same indentation as the input' do
+      @input = '   # my comment is this and that and another thing'
+      @output = "   # my comment is\n   # this and that\n   # and another\n   # thing"
+    end
+
+    it 'uses the same number of hashes to denote the comment' do
+      @input = ' ## my comment is this and that and another thing'
+      @output = " ## my comment is\n ## this and that\n ## and another\n ## thing"
+    end
+
+    it 'splits up code with an overly long comment at the end' do
+      @input = '  a + b # this is a stupidly long comment lol'
+      @output = "  # this is a\n  # stupidly long\n  # comment lol\n  a + b"
+    end
+
+    it 'uses the same indentation and hashes for the new comment' do
+      @input = ' a + b ### this is a stupidly long comment lol'
+      @output = " ### this is a\n ### stupidly long\n ### comment lol\n a + b"
+    end
+    
+    it 'fails to fix when if/unless are in a symbol' do
+      # This came from an actual bug from running wool on wool's source.
+      @input = "    left, right = @class.new('').split_on_keyword('x = 5 unless y == 2', :unless)"
+      @output = @input
+    end
+
+    context 'with an indent size of 2' do
+      before { @settings = {:indent_size => 2} }
+      it "doesn't try to convert the 'end if foobar' technique" do
+        @input = '  end if should_run_block?'
+        @output = '  end if should_run_block?'
+      end
+
+      it "doesn't try to convert the 'end unless foobar' technique" do
+        @input = '  end unless should_run_block?'
+        @output = '  end unless should_run_block?'
+      end
+
+      it 'converts lines with guarded ifs into 3 liners' do
+        @input = 'puts x if x > y && y.call'
+        @output = "if x > y && y.call\n  puts x\nend"
+      end
+
+      it 'converts lines with guarded unlesses into 3 liners' do
+        @input = 'puts x unless x > number'
+        @output = "unless x > number\n  puts x\nend"
+      end
+
+      it 'converts lines with guarded ifs while maintaining indentation' do
+        @input = '  puts x unless x > number'
+        @output = "  unless x > number\n    puts x\n  end"
+      end
+
+      it 'only converts when it finds a guard on the top level expression' do
+        @input = %Q[syms.each { |sym| raise ArgumentError, "unknown option '\#{sym}'" unless @specs[sym] }]
+        @output = %Q[syms.each { |sym| raise ArgumentError, "unknown option '\#{sym}'" unless @specs[sym] }]
+      end
+
+      it 'only converts when it finds a guard on the real-world top level expression' do
+        @input = 'x.select { |x| x if 5 }'
+        @output = 'x.select { |x| x if 5 }'
+      end
+
+      it 'converts nested if/unless as guards' do
+        @input = 'puts x if foo.bar unless baz.boo'
+        @output = "unless baz.boo\n  if foo.bar\n    puts x\n  end\nend"
+      end
+
+      it 'converts nested three if/unless as guards' do
+        @input = 'puts x if foo.bar unless baz.boo if alpha.beta'
+        @output = "if alpha.beta\n  unless baz.boo\n    if foo.bar\n      puts x\n    end\n  end\nend"
+      end
+
+      it 'converts nested three if/unless as guards maintaining indentation' do
+        @input = '    puts x if foo.bar unless baz.boo if alpha.beta'
+        @output = "    if alpha.beta\n      unless baz.boo\n        if foo.bar\n          puts x\n        end\n      end\n    end"
+      end
+    end
+  end
+end
+
+describe 'LineLengthMaximum' do
+  before do
+    @hundred_cap = LineLengthMaximum(100)
+  end
+
+  it 'matches lines longer than the specified maximum' do
+    @hundred_cap.should warn('x' * 101)
+  end
+
+  it 'has a high severity' do
+    @hundred_cap.severity.should >= 7.5
+  end
+
+  it 'does not match lines smaller than the specified maximum' do
+    @hundred_cap.should_not warn('x' * 100)
+  end
+end
+
+describe 'LineLengthWarning' do
+  before do
+    @hundred_cap = LineLengthWarning(80)
+  end
+
+  it 'matches lines longer than the specified maximum' do
+    @hundred_cap.should warn('x' * 81)
+  end
+
+  it 'has a lower severity' do
+    @hundred_cap.severity.should <= 4
+  end
+
+  it 'does not match lines smaller than the specified maximum' do
+    @hundred_cap.should_not warn('x' * 80)
+  end
+end

data/spec/warning_specs/misaligned_unindentation_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe MisalignedUnindentationWarning do
+  context 'when fixing' do
+    it 'is a line-based warning' do
+      MisalignedUnindentationWarning.new('(stdin)', 'hello', 80).should be_a(LineWarning)
+    end
+
+    it 'matches nothing' do
+      MisalignedUnindentationWarning.should_not warn(' a + b', 2)
+    end
+
+    it 'fixes by removing more spaces than expected' do
+      MisalignedUnindentationWarning.should correct_to('   a + b', '  a + b', 2)
+    end
+
+    it 'fixes by adding a second space' do
+      MisalignedUnindentationWarning.should correct_to(' a + b', '  a + b', 2)
+    end
+
+    it 'fixes by adding indentation' do
+      MisalignedUnindentationWarning.should correct_to('a + b', '    a + b', 4)
+    end
+
+    it 'describes the incorrect indentation values' do
+      warning = MisalignedUnindentationWarning.new('(stdin)', '   a + b', 2)
+      other_warning = MisalignedUnindentationWarning.new('(stdin)', ' a + b', 2)
+      warning_3 = MisalignedUnindentationWarning.new('(stdin)', 'a + b', 4)
+      warning.desc.should =~ /Expected 2/
+      warning.desc.should =~ /found 3/
+      other_warning.desc.should =~ /Expected 2/
+      other_warning.desc.should =~ /found 1/
+    end
+  end
+end

data/spec/warning_specs/operator_spacing_spec.rb

@@ -0,0 +1,101 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe OperatorSpacing do
+  it 'is a line-based warning' do
+    OperatorSpacing.new('(stdin)', 'hello').should be_a(LineWarning)
+  end
+
+  it "doesn't match block declarations" do
+    OperatorSpacing.should_not warn('[1, 2].each { |x| p x }')
+    OperatorSpacing.should_not warn('[1, 2].each {| y | p x }')
+    OperatorSpacing.should_not warn("[1, 2].each do |x|\n p x\nend")
+    OperatorSpacing.should_not warn("[1, 2].each do|x|\n p x\nend")
+  end
+
+  it "doesn't match in a comment" do
+    OperatorSpacing.should_not warn('hello # a+b')
+  end
+
+  it "doesn't match a <<- heredoc" do
+    OperatorSpacing.should_not warn('@original = <<-EOF')
+  end
+
+  it "doesn't match a << heredoc" do
+    OperatorSpacing.should_not warn('@original = <<EOF')
+  end
+
+  it "doesn't match adjacent negative numbers" do
+    OperatorSpacing.should_not warn('  exit(-1)')
+  end
+
+  it "doesn't match *args in block parameters" do
+    OperatorSpacing.should_not warn('list.each do |*args|')
+    OperatorSpacing.should_not warn('list.each { |*args| }')
+  end
+
+  it "doesn't match splat arguments" do
+    OperatorSpacing.should_not warn('x.call(*args)')
+    OperatorSpacing.should_not warn('x.call(a, *args)')
+    OperatorSpacing.should_not warn('x.call(*args, b)')
+    OperatorSpacing.should_not warn('x.call(a, *args, b)')
+  end
+
+  it "does match multiplication in an argument list" do
+    OperatorSpacing.should warn('x.call(a *b)')
+    OperatorSpacing.should warn('x.call(x, a *b)')
+    OperatorSpacing.should warn('x.call(a *b, z)')
+  end
+
+  it "doesn't match block arguments" do
+    OperatorSpacing.should_not warn('x.call(&b)')
+    OperatorSpacing.should_not warn('x.call(a, &b)')
+    OperatorSpacing.should_not warn('x.call(&b, b)')
+    OperatorSpacing.should_not warn('x.call(a, &b, b)')
+  end
+
+  it "doesn't match the [*item] idiom" do
+    OperatorSpacing.should_not warn('[*args]')
+  end
+
+  it 'has a reasonable description' do
+    OperatorSpacing.new('(stdin)', 'a+ b').desc.should =~ /spacing/
+  end
+
+  OperatorSpacing::OPERATORS.each do |operator|
+    context "with #{operator}" do
+      it "matches when there is no space on the left side" do
+        OperatorSpacing.should warn("a#{operator} b")
+      end
+
+      it "matches when there is no space on the right side" do
+        OperatorSpacing.should warn("a #{operator}b")
+      end unless operator == '/'  # This confuses the shit out of the lexer
+
+      it "matches when there is no space on both sides" do
+        OperatorSpacing.should warn("a#{operator}b")
+      end
+
+      it "doesn't match when there is exactly one space on both sides" do
+        OperatorSpacing.should_not warn("a #{operator} b")
+      end
+
+      context 'when fixing' do
+        it 'changes nothing when there is one space on both sides' do
+          OperatorSpacing.should correct_to("a #{operator} b", "a #{operator} b")
+        end
+
+        it 'fixes by inserting an extra space on the left' do
+          OperatorSpacing.should correct_to("a#{operator} b", "a #{operator} b")
+        end
+
+        it 'fixes by inserting an extra space on the right' do
+          OperatorSpacing.should correct_to("a #{operator}b", "a #{operator} b")
+        end unless operator == '/'  # This confuses the shit out of the lexer
+
+        it 'fixes by inserting an extra space on both sides' do
+          OperatorSpacing.should correct_to("a#{operator}b", "a #{operator} b")
+        end
+      end
+    end
+  end
+end