laser 0.7.0.pre1

data/spec/warning_specs/assignment_in_condition_spec.rb

@@ -0,0 +1,68 @@
+require_relative 'spec_helper'
+
+describe AssignmentInConditionWarning do
+  it 'is a file-based warning' do
+    AssignmentInConditionWarning.new('(stdin)', 'hello').should be_a(FileWarning)
+  end
+
+  context 'in an if condition' do
+    it 'matches when the only condition is an unwrapped assignment' do
+      AssignmentInConditionWarning.should warn('if x = 5; end')
+    end
+
+    it 'does not match if the simple assignment is wrapped in parentheses' do
+      AssignmentInConditionWarning.should_not warn('if (x = 5); end')
+    end
+    
+    it 'matches in a complex expression which contains an assignment' do
+      AssignmentInConditionWarning.should warn('if (x && y) || x = 5; end')
+    end
+  end
+  
+  context 'in an elseif condition' do
+    it 'matches when the only condition is an unwrapped assignment' do
+      AssignmentInConditionWarning.should warn('if true; elsif x = 5; end')
+    end
+
+    it 'does not match if the simple assignment is wrapped in parentheses' do
+      AssignmentInConditionWarning.should_not warn('if true; elsif (x = 5); end')
+    end
+    
+    it 'matches in a complex expression which contains an assignment' do
+      AssignmentInConditionWarning.should warn('if true; elsif (x && y) || x = 5; end')
+    end
+  end
+  
+  context 'in an unless condition' do
+    it 'matches when the only condition is an unwrapped assignment' do
+      AssignmentInConditionWarning.should warn('unless x = 5; end')
+    end
+
+    it 'does not match if the simple assignment is wrapped in parentheses' do
+      AssignmentInConditionWarning.should_not warn('unless (x = 5); end')
+    end
+    
+    it 'matches in a complex expression which contains an assignment' do
+      AssignmentInConditionWarning.should warn('unless (x && y) || x = 5; end')
+    end
+  end
+  
+  it 'is not fooled when the entire if expression is in parentheses' do
+    AssignmentInConditionWarning.should warn('(if true; elsif x = 5; end)')
+  end
+
+  # it 'does not match when arguments are surrounded by parentheses' do
+  #   AssignmentInConditionWarning.should_not warn('def abc(arg); end')
+  # end
+  # 
+  # it 'does not match when there are no arguments' do
+  #   AssignmentInConditionWarning.should_not warn('def abc; end')
+  # end
+  # 
+  # describe '#desc' do
+  #   it 'includes the name of the offending method' do
+  #     matches = AssignmentInConditionWarning.new('(stdin)', 'def silly_monkey arg1, *rest; end').match?
+  #     matches[0].desc.should =~ /silly_monkey/
+  #   end
+  # end
+end

data/spec/warning_specs/comment_spacing_spec.rb

@@ -0,0 +1,65 @@
+require_relative '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  # laser: 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 'should not warn for improperly spaced comments that are inside comments' do
+    InlineCommentSpaceWarning.should_not warn('#a + b   # comment', SETTINGS)
+  end
+  
+  it 'should not warn for an empty comment at the start of a line' do
+    InlineCommentSpaceWarning.should_not warn('#', SETTINGS)
+  end
+
+  it 'has a remotely useful description' do
+    InlineCommentSpaceWarning.new('(stdin)', 'hello  #').desc.should =~ /inline.*comment/i
+  end
+
+  describe '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_relative '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|
+    describe "When fixing #{input.inspect}" do
+      it 'fixes by removing all extra whitespace' do
+        ExtraBlankLinesWarning.should correct_to(input, 'a + b')
+      end
+    end
+  end
+
+  describe '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_relative '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
+
+  describe '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/hash_symbol_18_warning_spec.rb

@@ -0,0 +1,89 @@
+require_relative 'spec_helper'
+
+describe HashSymbol18Warning do
+  it 'is a file-based warning' do
+    HashSymbol18Warning.new('(stdin)', 'hello').should be_a(FileWarning)
+  end
+
+  it 'matches against a 1.8-style hash' do
+    HashSymbol18Warning.should warn('x = { :foo => bar }')
+  end
+  
+  it 'does not match against a 1.9-style hash' do
+    HashSymbol18Warning.should_not warn('x = { foo: bar }')
+  end
+  
+  it 'matches against a multiline 1.8-style hash' do
+    HashSymbol18Warning.should warn('x = { :foo =>
+bar }')
+  end
+  
+  it 'does not match against a multiline 1.9-style hash' do
+    HashSymbol18Warning.should_not warn('x = { foo:
+bar }')
+  end
+
+  describe '#fix' do
+    it 'fixes a simple 1.8-style single-keyed hash to 1.9-style hash keys' do
+      input = <<-EOF
+x = { :foo => bar }
+EOF
+      output = <<-EOF
+x = { foo: bar }
+EOF
+      HashSymbol18Warning.new('(stdin)', input).match?(input).first.fix.should == output
+    end
+
+    it 'fixes many 1.8-style hash keys into 1.9-style hash keys' do
+      input = %q{
+with_jumps_redirected(:break => ensure_body[1], :redo => ensure_body[1], :next => ensure_body[1],
+                      :return => ensure_body[1], :rescue => ensure_body[1],
+                      :yield_fail => ensure_body[1]) do
+  rescue_target, yield_fail_target =
+      build_rescue_target(node, result, rescue_body, ensure_block,
+                          current_rescue, current_yield_fail)
+  walk_body_with_rescue_target(result, body, body_block, rescue_target, yield_fail_target)
+end
+}
+      output = %q{
+with_jumps_redirected(break: ensure_body[1], redo: ensure_body[1], next: ensure_body[1],
+                      return: ensure_body[1], rescue: ensure_body[1],
+                      yield_fail: ensure_body[1]) do
+  rescue_target, yield_fail_target =
+      build_rescue_target(node, result, rescue_body, ensure_block,
+                          current_rescue, current_yield_fail)
+  walk_body_with_rescue_target(result, body, body_block, rescue_target, yield_fail_target)
+end
+}
+      HashSymbol18Warning.new('(stdin)', input).match?(input).inject(input) do |input, warning|
+        warning.fix(input)
+      end.should == output
+    end
+    
+    it 'fixes many 1.8-style hash keys into 1.9-style hash keys despite spacing' do
+      input = %q{
+with_jumps_redirected(:break=>ensure_body[1], :redo=>ensure_body[1], :next=>ensure_body[1],
+                      :return=>ensure_body[1], :rescue=>ensure_body[1],
+                      :yield_fail=>ensure_body[1]) do
+  rescue_target, yield_fail_target =
+      build_rescue_target(node, result, rescue_body, ensure_block,
+                          current_rescue, current_yield_fail)
+  walk_body_with_rescue_target(result, body, body_block, rescue_target, yield_fail_target)
+end
+}
+      output = %q{
+with_jumps_redirected(break:ensure_body[1], redo:ensure_body[1], next:ensure_body[1],
+                      return:ensure_body[1], rescue:ensure_body[1],
+                      yield_fail:ensure_body[1]) do
+  rescue_target, yield_fail_target =
+      build_rescue_target(node, result, rescue_body, ensure_block,
+                          current_rescue, current_yield_fail)
+  walk_body_with_rescue_target(result, body, body_block, rescue_target, yield_fail_target)
+end
+}
+      HashSymbol18Warning.new('(stdin)', input).match?(input).inject(input) do |input, warning|
+        warning.fix(input)
+      end.should == output
+    end
+  end
+end

data/spec/warning_specs/hash_symbol_19_warning_spec.rb

@@ -0,0 +1,63 @@
+require_relative 'spec_helper'
+
+describe HashSymbol19Warning do
+  it 'is a file-based warning' do
+    HashSymbol19Warning.new('(stdin)', 'hello').should be_a(FileWarning)
+  end
+
+  it 'matches against a 1.8-style hash' do
+    HashSymbol19Warning.should_not warn('x = { :foo => bar }')
+  end
+  
+  it 'does not match against a 1.9-style hash' do
+    HashSymbol19Warning.should warn('x = { foo: bar }')
+  end
+  
+  it 'matches against a multiline 1.8-style hash' do
+    HashSymbol19Warning.should_not warn('x = { :foo =>
+bar }')
+  end
+  
+  it 'does not match against a multiline 1.9-style hash' do
+    HashSymbol19Warning.should warn('x = { foo:
+bar }')
+  end
+
+  describe '#fix' do
+    it 'fixes a simple 1.8-style single-keyed hash to 1.9-style hash keys' do
+      input = <<-EOF
+x = { foo: bar }
+EOF
+      output = <<-EOF
+x = { :foo => bar }
+EOF
+      HashSymbol19Warning.new('(stdin)', input).match?(input).first.fix.should == output
+    end
+
+    it 'fixes many 1.8-style hash keys into 1.9-style hash keys' do
+      input = %q{
+with_jumps_redirected(break: ensure_body[1], redo: ensure_body[1], next: ensure_body[1],
+                      return: ensure_body[1], rescue: ensure_body[1],
+                      yield_fail: ensure_body[1]) do
+  rescue_target, yield_fail_target =
+      build_rescue_target(node, result, rescue_body, ensure_block,
+                          current_rescue, current_yield_fail)
+  walk_body_with_rescue_target(result, body, body_block, rescue_target, yield_fail_target)
+end
+}
+     output = %q{
+with_jumps_redirected(:break => ensure_body[1], :redo => ensure_body[1], :next => ensure_body[1],
+                      :return => ensure_body[1], :rescue => ensure_body[1],
+                      :yield_fail => ensure_body[1]) do
+  rescue_target, yield_fail_target =
+      build_rescue_target(node, result, rescue_body, ensure_block,
+                          current_rescue, current_yield_fail)
+  walk_body_with_rescue_target(result, body, body_block, rescue_target, yield_fail_target)
+end
+}
+      HashSymbol19Warning.new('(stdin)', input).match?(input).inject(input) do |input, warning|
+        warning.fix(input)
+      end.should == output
+    end
+  end
+end

data/spec/warning_specs/line_length_spec.rb

@@ -0,0 +1,173 @@
+require_relative '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
+
+  describe '#desc' do
+    it 'has a remotely useful description' do
+      @eighty_cap.new('(stdin)', 'x' * 80).desc.should =~ /line length/i
+    end
+  end
+  
+  describe '#inspect' do  
+    it 'contains the capacity in the description' do
+      @eighty_cap.inspect.should =~ /80/i
+    end
+  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
+
+  describe '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 laser on laser's source.
+      @input = "    left, right = @class.new('').split_on_keyword('x = 5 unless y == 2', :unless)"
+      @output = @input
+    end
+
+    describe '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