laser 0.7.0.pre1

data/spec/annotation_parser_specs/overload_parser_spec.rb

@@ -0,0 +1,39 @@
+require_relative 'spec_helper'
+
+describe Parsers::OverloadParser do
+  before do
+    @parser = Parsers::AnnotationParser.new
+  end
+
+  describe 'a simple overload type' do
+    it 'is parsed as a generic proc type' do
+      '(Float=) -> Float='.should parse_to(
+        Types::GenericType.new(
+          Types::PROC, [Types::TupleType.new([Types::FLOAT]), Types::FLOAT]))
+    end
+
+    it 'is parsed as a generic proc type without the arrow' do
+      '(Float=) Float='.should parse_to(
+        Types::GenericType.new(
+          Types::PROC, [Types::TupleType.new([Types::FLOAT]), Types::FLOAT]))
+    end
+  end
+
+  describe 'more complex overload listings' do
+    it 'is parsed as a generic proc type' do
+      '(Float=, Array=, Fixnum=) -> Float= | NilClass='.should parse_to(
+        Types::GenericType.new(
+          Types::PROC,
+          [Types::TupleType.new([Types::FLOAT, Types::ARRAY, Types::FIXNUM]),
+           Types::UnionType.new([Types::FLOAT, Types::NILCLASS])]))
+    end
+
+    it 'is parsed as a generic proc type without the arrow' do
+      '(Float=, Array=, Fixnum=) Float= | NilClass='.should parse_to(
+        Types::GenericType.new(
+          Types::PROC,
+          [Types::TupleType.new([Types::FLOAT, Types::ARRAY, Types::FIXNUM]),
+           Types::UnionType.new([Types::FLOAT, Types::NILCLASS])]))
+    end
+  end
+end

data/spec/annotation_parser_specs/parsers_spec.rb

@@ -0,0 +1,14 @@
+require_relative 'spec_helper'
+
+describe Parsers do
+  describe Parsers::AnnotationParser do
+    it 'exists' do
+      Parsers::AnnotationParser != nil
+    end
+  end
+  describe Parsers::ClassParser do
+    it 'exists' do
+      Parsers::ClassParser != nil
+    end
+  end
+end

data/spec/annotation_parser_specs/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../spec_helper'

data/spec/annotation_parser_specs/structural_parser_spec.rb

@@ -0,0 +1,67 @@
+require_relative 'spec_helper'
+
+describe Parsers::StructuralParser do
+  before do
+    @parser = Parsers::AnnotationParser.new
+  end
+  
+  describe 'a simple, full structural constraint' do
+    it 'is parsed into a single constraint' do
+      '#write(String, Fixnum=) -> NilClass'.should parse_to(
+          Types::StructuralType.new('write',
+            [Types::ClassType.new('String', :covariant),
+             Types::ClassType.new('Fixnum', :invariant)],
+            Types::ClassType.new('NilClass', :covariant)))
+    end
+    
+    it 'parses with an empty arg list' do
+      '#write() -> NilClass'.should parse_to(
+          Types::StructuralType.new('write',
+            [], Types::ClassType.new('NilClass', :covariant)))
+    end
+  end
+  
+  describe 'a full structural constraint in Go-style' do
+    it 'is parsed into the equivalent constraint' do
+      '#write(String) NilClass'.should parse_to(
+          Types::StructuralType.new('write',
+            [Types::ClassType.new('String', :covariant)],
+            Types::ClassType.new('NilClass', :covariant)))
+    end
+    
+    it 'parses with an empty arg list' do
+      '#write() NilClass'.should parse_to(
+          Types::StructuralType.new('write',
+            [], Types::ClassType.new('NilClass', :covariant)))
+    end
+  end
+  
+  describe 'a structural constraint without a return type' do
+    it 'is parsed into a constraint with an empty return type constraint set' do
+      '#write(String, Fixnum=)'.should parse_to(
+          Types::StructuralType.new('write',
+            [Types::ClassType.new('String', :covariant),
+             Types::ClassType.new('Fixnum', :invariant)],
+            []))
+    end
+    
+    it 'parses with an empty arg list' do
+      '#write()'.should parse_to(
+          Types::StructuralType.new('write', [], []))
+    end
+  end
+
+  describe 'a structural constraint with an elided argument list' do
+    it 'is parsed into a constraint with an empty return type and argument constraint set' do
+      '#write->Fixnum-'.should parse_to(
+          Types::StructuralType.new('write', [],
+            Types::ClassType.new('Fixnum', :contravariant)))
+    end
+  end
+  
+  describe 'a structural constraint with no arguments or return types specified' do
+    it 'is parsed into a constraint with an empty return type and argument constraint set' do
+      '#write'.should parse_to(Types::StructuralType.new('write', [], []))
+    end
+  end
+end

data/spec/laser_spec.rb

@@ -0,0 +1,14 @@
+require_relative 'spec_helper'
+
+describe Laser do
+  it "has a version" do
+    VERSION.should_not be_nil
+    VERSION.should >= "0.5.0"
+  end
+  
+  describe 'TESTS_ACTIVATED' do
+    it 'should be true' do
+      TESTS_ACTIVATED.should be true
+    end
+  end
+end

data/spec/rake_specs/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../spec_helper'

data/spec/rake_specs/task_spec.rb

@@ -0,0 +1,67 @@
+require_relative 'spec_helper'
+require 'rubygems'
+require 'rake'
+require 'tmpdir'
+require 'laser/rake/task'
+
+describe Laser::Rake::LaserTask do
+  describe '#initialize' do
+    it 'yields to allow setting :libs and :extras' do
+      task_name = "temptask1-#{rand(65329)}".to_sym
+      task = Laser::Rake::LaserTask.new(task_name) do |laser|
+        laser.libs = "LOL"
+        laser.extras = "hai"
+      end
+      task.settings.libs.should == "LOL"
+      task.settings.extras.should == "hai"
+    end
+
+    it 'creates a Rake task with the given name that calls #run' do
+      task_name = "temptask2_#{rand(65000)}".to_sym
+      task = Laser::Rake::LaserTask.new(task_name)
+      Rake::Task[task_name].should_not be_nil
+      task.should_receive(:run)
+      Rake::Task[task_name].invoke
+    end
+
+    it 'allows you to specify which warnings to use' do
+      task_name = "temptask3_#{rand(65000)}".to_sym
+      task = Laser::Rake::LaserTask.new(task_name) do |laser|
+        laser.using << :one << :two
+      end
+      task.settings.using.should == [:one, :two]
+    end
+
+    it 'defaults to using all warnings' do
+      task_name = "temptask4_#{rand(65000)}".to_sym
+      task = Laser::Rake::LaserTask.new(task_name) do |laser|
+      end
+      task.settings.using.should == [:all]
+    end
+  end
+
+  describe '#run' do
+    it 'searches the listed libraries for files' do
+      Dir.should_receive(:[]).with('lib/**/*.rb').and_return([])
+      Dir.should_receive(:[]).with('spec/**/*.rb').and_return([])
+      task = Laser::Rake::LaserTask.new("temptask3-#{rand(65329)}".to_sym) do |laser|
+        laser.libs << 'lib' << 'spec'
+      end
+      swizzling_io { task.run }
+    end
+
+    it 'scans the matching files' do
+      test_file = File.open(File.join(Dir.tmpdir, 'test_input'), 'w') do |fp|
+        fp << 'a + b  '
+      end
+      Dir.should_receive(:[]).with('lib/**/*.rb').and_return([File.join(Dir.tmpdir, 'test_input')])
+      Dir.should_receive(:[]).with('spec/**/*.rb').and_return([])
+      task = Laser::Rake::LaserTask.new("temptask4-#{rand(65329)}".to_sym) do |laser|
+        laser.libs << 'lib' << 'spec'
+      end
+      printout = swizzling_io { task.run }
+      printout.should =~ /whitespace/
+      printout.should =~ /1 are fixable/
+    end
+  end
+end

data/spec/runner_spec.rb

@@ -0,0 +1,207 @@
+require_relative 'spec_helper'
+
+describe Runner do
+  before do
+    @runner = Runner.new(['a', :b])
+  end
+
+  describe '#run' do
+    it 'collects options and arguments, decides what to scan, scans, and displays' do
+      runner = Runner.new(['--report-fixed', 'hello', 'world'])
+      expected_settings = {:"report-fixed_given"=>true, :"report-fixed"=>true,
+                           fix: false, help: false, debug: false,
+                           InlineCommentSpaceWarning::OPTION_KEY => 2,
+                           :"line-length" => nil, only: nil, stdin: false,
+                           display: true, :"list-modules" => false, profile: false,
+                           __using__: Warning.all_warnings,
+                           __fix__: Warning.all_warnings}
+      scanner = mock(:scanner)
+      Scanner.should_receive(:new, expected_settings).and_return(scanner)
+
+      data1, data2 = mock(:data1), mock(:data2)
+      warning1, warning2 = mock(:warning1), mock(:warning2)
+      file1, file2 = mock(:file1), mock(:file2)
+
+      scanner.should_receive(:settings).exactly(3).times.and_return({:"report-fixed" => true})
+      File.should_receive(:read).with('hello').twice.and_return(data1)
+      scanner.should_receive(:scan).
+              with(data1, 'hello').
+              and_return([warning1])
+      warning1.should_receive(:to_ary)
+
+      scanner.should_receive(:settings).and_return({})
+      File.should_receive(:read).with('world').twice.and_return(data2)
+      scanner.should_receive(:scan).
+              with(data2, 'world').
+              and_return([warning2])
+      warning2.should_receive(:to_ary)
+
+      runner.should_receive(:display_warnings).with([warning1, warning2], expected_settings)
+
+      runner.run
+    end
+    
+    it 'works with stdin: true' do
+      runner = Runner.new(['--stdin', '--only', 'UselessDoubleQuotesWarning'])
+      expected_settings = {:"report-fixed" => false, fix: false, help: false,
+                           debug: false, InlineCommentSpaceWarning::OPTION_KEY => 2,
+                           :"line-length" => nil, only: 'UselessDoubleQuotesWarning',
+                           stdin: true, stdin_given: true, only_given: true,
+                           display: true, :"list-modules" => false, profile: false,
+                           __using__: [UselessDoubleQuotesWarning],
+                           __fix__: [UselessDoubleQuotesWarning]}
+      scanner = mock(:scanner)
+      Scanner.should_receive(:new, expected_settings).and_return(scanner)
+
+      data1 = mock(:data1)
+      warning1 = mock(:warning1)
+
+      scanner.should_receive(:settings).twice.and_return({:"report-fixed" => true})
+      STDIN.should_receive(:read).twice.and_return(data1)
+      scanner.should_receive(:scan).
+              with(data1, '(stdin)').
+              and_return([warning1])
+      warning1.should_receive(:to_ary)
+
+      runner.should_receive(:display_warnings).with([warning1], expected_settings)
+      runner.run
+    end
+    
+    it 'works with --list-modules' do
+      output = swizzling_io do
+        runner = Runner.new(['--list-modules'])
+        runner.run
+      end
+      modules = output.split("\n")[2..-1]
+      modules.should_not be_empty
+      modules.should == modules.sort
+      ["Array < Object", "Module < Object", "Proc < Object", "Class < Module", "Object < BasicObject"].each do |mod|
+        modules.should include(mod)
+      end
+    end
+  end
+
+  describe '#collect_options_and_arguments' do
+    before do
+      @runner = Runner.new(['--fix', '--report-fixed', '--line-length', '103', 'hello', 'there'])
+      @settings, @arguments = @runner.collect_options_and_arguments
+    end
+
+    after do
+      new_warning = current = Warning.all_warnings.find do |warning|
+        warning.superclass == GenericLineLengthWarning && warning.line_length_limit == 103
+      end
+      while (current = current.superclass) && current != Warning.superclass
+        current.all_warnings.delete new_warning
+      end if current
+    end
+
+    it 'finds both flags' do
+      @settings[:fix].should be_true
+      @settings[:"report-fixed"].should be_true
+      @settings[:"line-length"].should == 103
+    end
+
+    it 'finds both stray arguments' do
+      @arguments.should == ['hello', 'there']
+    end
+  end
+
+  describe '#swizzling_argv' do
+    it 'changes ARGV to the runner\'s argv value' do
+      @runner.swizzling_argv do
+        ARGV.should == ['a', :b]
+      end
+    end
+
+    it 'restores ARGV despite an exception' do
+      old_argv = ARGV.dup
+      expect {
+        @runner.swizzling_argv do
+          raise SystemExit.new('exiting')
+        end
+      }.to raise_error(SystemExit)
+      ARGV.should == old_argv
+    end
+  end
+
+  describe '#get_settings' do
+    it 'has a --fix option' do
+      runner = Runner.new(['--fix'])
+      settings = runner.swizzling_argv { runner.get_settings }
+      settings[:fix].should be_true
+      settings[:fix_given].should be_true
+    end
+
+    it 'has a --report-fixed option' do
+      runner = Runner.new(['--report-fixed'])
+      settings = runner.swizzling_argv { runner.get_settings }
+      settings[:"report-fixed"].should be_true
+      settings[:"report-fixed_given"].should be_true
+    end
+  end
+
+  describe '#handle_global_options' do
+    it 'specifies :using and :fix when :only is provided' do
+      runner = Runner.new([])
+      runner.handle_global_options(only: 'UselessDoubleQuotesWarning')
+      runner.using.should == [UselessDoubleQuotesWarning]
+      runner.fix.should == [UselessDoubleQuotesWarning]
+    end
+    
+    it 'works with multiple short names' do
+      runner = Runner.new([])
+      runner.handle_global_options(only: 'ST1,ST3')
+      runner.using.size.should == 2
+      runner.using.each {|w| w.ancestors.should include(Warning) }
+    end
+  end
+  
+  describe '#convert_warning_list' do
+    it 'should have a :whitespace helper' do
+      result = @runner.convert_warning_list([:whitespace])
+      list = ExtraBlankLinesWarning, ExtraWhitespaceWarning, 
+             OperatorSpacing, MisalignedUnindentationWarning
+      (result & list).should == list
+    end
+    
+    it 'should have an :all option' do
+      @runner.convert_warning_list([:all]).should == Warning.all_warnings
+    end
+  end
+
+  describe '#display_warnings' do
+    it 'prints the lines and files where there are warnings' do
+      warning = Warning.new('hello', 'a+b')
+      warning.line_number = 4
+      warning.severity = 3
+      warnings = [warning]
+      runner = Runner.new(['temp', 'hello'])
+      output = swizzling_io do
+        runner.display_warnings(warnings, {})
+      end
+      output.should =~ /hello:4/
+      output.should =~ /(3)/
+      output.should =~ /Warning/
+      output.should =~ /1 warning/
+      output.should =~ /0 are fixable/
+    end
+  end
+
+  describe '#collect_warnings' do
+    it 'scans each file provided' do
+      scanner = mock(:scanner)
+      data1, data2 = mock(:data1), mock(:data2)
+      warning_list1, warning_list2 = mock(:wl1), mock(:wl2)
+      File.should_receive(:read).with('abc').and_return(data1)
+      scanner.should_receive(:settings).exactly(4).times.and_return({})
+      scanner.should_receive(:scan).with(data1, 'abc').and_return(warning_list1)
+      warning_list1.should_receive(:to_ary)
+      File.should_receive(:read).with('def').and_return(data2)
+      scanner.should_receive(:scan).with(data2, 'def').and_return(warning_list2)
+      warning_list2.should_receive(:to_ary)
+
+      @runner.collect_warnings(['abc', 'def'], scanner).should == [warning_list1, warning_list2]
+    end
+  end
+end

data/spec/scanner_spec.rb

@@ -0,0 +1,75 @@
+require_relative 'spec_helper'
+require 'stringio'
+
+describe Scanner do
+  before do
+    @scanner = Scanner.new(InlineCommentSpaceWarning::OPTION_KEY => 2)
+
+    @fix_scanner_stdout = StringIO.new
+    @fix_scanner = Scanner.new(fix: true, output_file: @fix_scanner_stdout)
+  end
+
+  describe '#scan' do
+    it 'takes an input and gathers warnings about it' do
+      warnings = @scanner.scan('1 + 2 ', '(stdin)')
+      warnings.size.should == 1
+      warnings[0].should be_a(ExtraWhitespaceWarning)
+    end
+
+    it "ignores warnings specified in the line's comments by class name" do
+      warnings = @scanner.scan('1 +2  # laser: ignore OperatorSpacing')
+      warnings.size.should == 0
+    end
+
+    it "ignores warnings specified in the line's comments by short name" do
+      warnings = @scanner.scan("1 +2  # laser: ignore #{OperatorSpacing.short_name}")
+      warnings.size.should == 0
+    end
+
+    it "ignores multiple warnings that are marked in the line's comments" do
+      warnings = @scanner.scan(
+          '1 +2; 3 + 4  # laser: ignore OperatorSpacing SemicolonWarning')
+      warnings.size.should == 0
+    end
+
+    it "ignores multiple warnings in the line's comments as short name" do
+      warnings = @scanner.scan(
+          "1 +2; 3 + 4  # laser: ignore #{OperatorSpacing.short_name} #{SemicolonWarning.short_name}")
+      warnings.size.should == 0
+    end
+
+    it 'fixes the input and writes it to :output_file' do
+      warnings = @fix_scanner.scan('1 + 2 ', '(stdin)')
+      warnings.size.should == 1
+      warnings[0].should be_a(ExtraWhitespaceWarning)
+      @fix_scanner_stdout.string.should == "1 + 2"
+    end
+
+    it 'fixes multiple errors on one line' do
+      warnings = @fix_scanner.scan('1 +2 ', '(stdin)')
+      warnings.size.should == 2
+      @fix_scanner_stdout.string.should == "1 + 2"
+    end
+
+    it 'fixes multiline inputs' do
+      warnings = @fix_scanner.scan("def plus(a, b)\n  a + b \nend", '(stdin)')
+      warnings.size.should == 1
+      warnings[0].should be_a(ExtraWhitespaceWarning)
+      @fix_scanner_stdout.string.should == "def plus(a, b)\n  a + b\nend"
+    end
+
+    it 'fixes multiline mis-indented inputs' do
+      warnings = @fix_scanner.scan("def plus(a, b)\n  a + b\n end", '(stdin)')
+      warnings.size.should == 1
+      warnings[0].should be_a(MisalignedUnindentationWarning)
+      @fix_scanner_stdout.string.should == "def plus(a, b)\n  a + b\nend"
+    end
+
+    it 'fixes class definitions' do
+      warnings = @fix_scanner.scan("class Hello\n  1+2\nend", '(stdin)')
+      warnings.size.should == 1
+      warnings[0].should be_a(OperatorSpacing)
+      @fix_scanner_stdout.string.should == "class Hello\n  1 + 2\nend"
+    end
+  end
+end