rubocop 0.26.1 → 0.27.0

data/spec/rubocop/cop/style/single_line_methods_spec.rb

@@ -2,8 +2,12 @@
 
 require 'spec_helper'
 
-describe RuboCop::Cop::Style::SingleLineMethods, :config do
+describe RuboCop::Cop::Style::SingleLineMethods do
   subject(:cop) { described_class.new(config) }
+  let(:config) do
+    RuboCop::Config.new('Style/SingleLineMethods' => cop_config,
+                        'Style/IndentationWidth' => { 'Width' => 2 })
+  end
   let(:cop_config) { { 'AllowIfMethodIsEmpty' => true } }
 
   it 'registers an offense for a single-line method' do

data/spec/rubocop/cop/style/space_before_block_braces_spec.rb

@@ -6,7 +6,8 @@ describe RuboCop::Cop::Style::SpaceBeforeBlockBraces do
   subject(:cop) { described_class.new(config) }
   let(:config) do
     merged = RuboCop::ConfigLoader
-      .default_configuration['Style/SpaceBeforeBlockBraces'].merge(cop_config)
+             .default_configuration['Style/SpaceBeforeBlockBraces']
+             .merge(cop_config)
     RuboCop::Config.new('Style/Blocks' => { 'Enabled' => false },
                         'Style/SpaceBeforeBlockBraces' => merged)
   end

data/spec/rubocop/cop/style/space_inside_block_braces_spec.rb

@@ -8,7 +8,8 @@ describe RuboCop::Cop::Style::SpaceInsideBlockBraces do
   subject(:cop) { described_class.new(config) }
   let(:config) do
     merged = RuboCop::ConfigLoader
-      .default_configuration['Style/SpaceInsideBlockBraces'].merge(cop_config)
+             .default_configuration['Style/SpaceInsideBlockBraces']
+             .merge(cop_config)
     RuboCop::Config.new('Style/Blocks' => { 'Enabled' => false },
                         'Style/SpaceInsideBlockBraces' => merged)
   end

data/spec/rubocop/cop/style/string_literals_in_interpolation_spec.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe RuboCop::Cop::Style::StringLiteralsInInterpolation, :config do
+  subject(:cop) { described_class.new(config) }
+
+  context 'configured with single quotes preferred' do
+    let(:cop_config) { { 'EnforcedStyle' => 'single_quotes' } }
+
+    it 'detects unneeded double quotes within embedded expression' do
+      src = ['"#{"A"}"']
+      inspect_source(cop, src)
+      expect(cop.messages)
+        .to eq(['Prefer single-quoted strings inside interpolations.'])
+    end
+
+    it 'accepts double quotes on a static string' do
+      src = ['"A"']
+      inspect_source(cop, src)
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'can handle a built-in constant parsed as string' do
+      # Parser will produce str nodes for constants such as __FILE__.
+      src = ['if __FILE__ == $PROGRAM_NAME',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'can handle character literals' do
+      src = 'a = ?/'
+      inspect_source(cop, src)
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'auto-corrects " with \'' do
+      new_source = autocorrect_source(cop, 's = "#{"abc"}"')
+      expect(new_source).to eq(%q(s = "#{'abc'}"))
+    end
+  end
+
+  context 'configured with double quotes preferred' do
+    let(:cop_config) { { 'EnforcedStyle' => 'double_quotes' } }
+
+    it 'registers an offense for single quotes within embedded expression' do
+      src = %q("#{'A'}")
+      inspect_source(cop, src)
+      expect(cop.messages)
+        .to eq(['Prefer double-quoted strings inside interpolations.'])
+    end
+  end
+
+  context 'when configured with a bad value' do
+    let(:cop_config) { { 'EnforcedStyle' => 'other' } }
+
+    it 'fails' do
+      expect { inspect_source(cop, ['a = "#{"b"}"']) }
+        .to raise_error(RuntimeError)
+    end
+  end
+end

data/spec/rubocop/cop/style/string_literals_spec.rb

@@ -95,10 +95,10 @@ describe RuboCop::Cop::Style::StringLiterals, :config do
       expect(cop.offenses).to be_empty
     end
 
-    it 'detects unneeded double quotes within embedded expression' do
+    it 'accepts double quotes within embedded expression' do
       src = ['"#{"A"}"']
       inspect_source(cop, src)
-      expect(cop.offenses.size).to eq(1)
+      expect(cop.offenses).to be_empty
     end
 
     it 'detects unneeded double quotes within concatenated string' do

data/spec/rubocop/cop/style/word_array_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 
 describe RuboCop::Cop::Style::WordArray, :config do
   subject(:cop) { described_class.new(config) }
-  let(:cop_config) { { 'MinSize' => 0 } }
+  let(:cop_config) { { 'MinSize' => 0, 'WordRegex' => /\A[\p{Word}]+\z/ } }
 
   it 'registers an offense for arrays of single quoted strings' do
     inspect_source(cop,
@@ -100,4 +100,18 @@ describe RuboCop::Cop::Style::WordArray, :config do
     new_source = autocorrect_source(cop, '[%{one}, %Q(two), ?\n, ?\t]')
     expect(new_source).to eq('%W(one two \n \t)')
   end
+
+  context 'with a custom WordRegex configuration' do
+    let(:cop_config) { { 'MinSize' => 0, 'WordRegex' => /\A[\w@.]+\z/ } }
+
+    it 'registers an offense for arrays of email addresses' do
+      inspect_source(cop, ["['a@example.com', 'b@example.com']"])
+      expect(cop.offenses.size).to eq(1)
+    end
+
+    it 'auto-corrects an array of email addresses' do
+      new_source = autocorrect_source(cop, "['a@example.com', 'b@example.com']")
+      expect(new_source).to eq('%w(a@example.com b@example.com)')
+    end
+  end
 end

data/spec/rubocop/formatter/base_formatter_spec.rb

@@ -168,7 +168,7 @@ module RuboCop
 
           it 'receives an array of detected offenses for the file' do
             expect(formatter).to receive(:file_finished)
-            .exactly(3).times do |file, offenses|
+              .exactly(3).times do |file, offenses|
               case File.basename(file)
               when '1_offense.rb'
                 expect(offenses.size).to eq(1)

data/spec/rubocop/formatter/disabled_lines_formatter_spec.rb

@@ -2,7 +2,6 @@
 
 require 'spec_helper'
 require 'stringio'
-require 'tempfile'
 
 module RuboCop
   module Formatter

data/spec/rubocop/formatter/formatter_set_spec.rb

@@ -62,6 +62,15 @@ module RuboCop
             expect(formatter_set.first.output.class).to eq(File)
             expect(formatter_set.first.output.path).to eq(output_path)
           end
+
+          it "creates parent directories if they don't exist" do
+            Dir.mktmpdir do |tmpdir|
+              output_path = File.join(tmpdir, 'path/does/not/exist')
+              formatter_set.add_formatter('simple', output_path)
+              expect(formatter_set.first.output.class).to eq(File)
+              expect(formatter_set.first.output.path).to eq(output_path)
+            end
+          end
         end
       end
 

data/spec/rubocop/formatter/html_formatter_spec.rb

@@ -1,144 +1,47 @@
 # encoding: utf-8
 
 require 'spec_helper'
-require 'stringio'
+require 'fileutils'
 
 module RuboCop
-  describe Formatter::HTMLFormatter do
-    subject(:formatter) { described_class.new(output) }
-    let(:output) { StringIO.new }
-    let(:files) { %w(/path/to/file1 /path/to/file2) }
-    let(:location) do
-      source_buffer = Parser::Source::Buffer.new('test', 1)
-      source_buffer.source = %w(a b cdefghi).join("\n")
-      Parser::Source::Range.new(source_buffer, 9, 10)
-    end
-    let(:offense) do
-      Cop::Offense.new(:convention, location,
-                       'This is message', 'CopName', true)
-    end
-
-    describe '#started' do
-      let(:summary) { formatter.output_hash[:summary] }
+  module Formatter
+    describe HTMLFormatter, :isolated_environment do
+      spec_root = File.expand_path('../../..', __FILE__)
 
-      it 'sets target file count in summary' do
-        expect(summary[:target_file_count]).to be_nil
-        formatter.started(%w(/path/to/file1 /path/to/file2))
-        expect(summary[:target_file_count]).to eq(2)
-      end
-    end
+      around do |example|
+        project_path = File.join(spec_root, 'fixtures/html_formatter/project')
+        FileUtils.cp_r(project_path, '.')
 
-    describe '#file_finished' do
-      before do
-        count = 0
-        allow(formatter).to receive(:hash_for_file) do
-          count += 1
+        Dir.chdir(File.basename(project_path)) do
+          example.run
         end
       end
 
-      let(:summary) { formatter.output_hash[:summary] }
-
-      it 'adds detected offense count in summary' do
-        expect(summary[:offense_count]).to eq(0)
-
-        formatter.file_started(files[0], {})
-        expect(summary[:offense_count]).to eq(0)
-        formatter.file_finished(files[0], [
-          double('offense1'), double('offense2')
-        ])
-        expect(summary[:offense_count]).to eq(2)
+      let(:actual_html_path) do
+        path = File.expand_path('result.html')
+        CLI.new.run(['--format', 'html', '--out', path])
+        path
       end
 
-      it 'adds value of #hash_for_file to #output_hash[:files]' do
-        expect(formatter.output_hash[:files]).to be_empty
-
-        formatter.file_started(files[0], {})
-        expect(formatter.output_hash[:files]).to be_empty
-        formatter.file_finished(files[0], [])
-        expect(formatter.output_hash[:files]).to eq([1])
-
-        formatter.file_started(files[1], {})
-        expect(formatter.output_hash[:files]).to eq([1])
-        formatter.file_finished(files[1], [])
-        expect(formatter.output_hash[:files]).to eq([1, 2])
+      let(:actual_html) do
+        File.read(actual_html_path, encoding: 'UTF-8')
       end
-    end
 
-    describe '#finished' do
-      let(:summary) { formatter.output_hash[:summary] }
-
-      it 'sets inspected file count in summary' do
-        expect(summary[:inspected_file_count]).to be_nil
-        formatter.finished(%w(/path/to/file1 /path/to/file2))
-        expect(summary[:inspected_file_count]).to eq(2)
-      end
-    end
-
-    describe '#hash_for_file' do
-      subject(:hash) { formatter.hash_for_file(file, offenses) }
-      let(:file) { File.expand_path('spec/spec_helper.rb') }
-      let(:offenses) { [double('offense1'), double('offense2')] }
-
-      it 'sets relative file path for :path key' do
-        expect(hash[:path]).to eq('spec/spec_helper.rb')
+      let(:expected_html_path) do
+        File.join(spec_root, 'fixtures/html_formatter/expected.html')
       end
 
-      before do
-        count = 0
-        allow(formatter).to receive(:hash_for_offense) do
-          count += 1
+      let(:expected_html) do
+        html = File.read(expected_html_path, encoding: 'UTF-8')
+        # Avoid failure on version bump
+        html.sub(/(class="version".{0,20})\d+(?:\.\d+){2}/i) do
+          Regexp.last_match(1) + RuboCop::Version::STRING
         end
       end
 
-      it 'sets an array of #hash_for_offense values for :offenses key' do
-        expect(hash[:offenses]).to eq([1, 2])
-      end
-    end
-
-    describe '#hash_for_offense' do
-      subject(:hash) { formatter.hash_for_offense(offense) }
-
-      it 'sets Offense#severity value for :severity key' do
-        expect(hash[:severity]).to eq(:convention)
-      end
-
-      it 'sets Offense#message value for :message key' do
-        expect(hash[:message]).to eq('This is message')
-      end
-
-      it 'sets Offense#cop_name value for :cop_name key' do
-        expect(hash[:cop_name]).to eq('CopName')
-      end
-
-      it 'sets Offense#corrected? value for :corrected key' do
-        expect(hash[:corrected]).to be_truthy
-      end
-
-      before do
-        allow(formatter)
-          .to receive(:hash_for_location).and_return(location_hash)
-      end
-
-      let(:location_hash) { { line: 1, column: 2 } }
-
-      it 'sets value of #hash_for_location for :location key' do
-        expect(hash[:location]).to eq(location_hash)
-      end
-    end
-
-    describe '#hash_for_location' do
-      subject(:hash) { formatter.hash_for_location(offense) }
-
-      it 'sets line value for :line key' do
-        expect(hash[:line]).to eq(3)
-      end
-
-      it 'sets column value for :column key' do
-        expect(hash[:column]).to eq(6)
-      end
-
-      it 'sets length value for :length key' do
-        expect(hash[:length]).to eq(1)
+      it 'outputs the result in HTML' do
+        # FileUtils.copy(actual_html_path, expected_html_path)
+        expect(actual_html).to eq(expected_html)
       end
     end
   end

data/spec/rubocop/formatter/offense_count_formatter_spec.rb

@@ -2,7 +2,6 @@
 
 require 'spec_helper'
 require 'stringio'
-require 'tempfile'
 
 module RuboCop
   module Formatter

data/spec/rubocop/runner_spec.rb

@@ -52,7 +52,7 @@ describe RuboCop::Runner, :isolated_environment do
 
           Offenses:
 
-          example.rb:2:5: C: Use snake_case for methods.
+          example.rb:2:5: C: Use snake_case for method names.
           def INVALID_CODE
               ^^^^^^^^^^^^
 

data/spec/spec_helper.rb

@@ -1,64 +1,10 @@
 # encoding: utf-8
 
-if ENV['TRAVIS'] && RUBY_ENGINE == 'jruby'
-  # Force JRuby not to select working directory
-  # as temporary directory on Travis CI.
-  # https://github.com/jruby/jruby/issues/405
-  require 'fileutils'
-  tmp_dir = ENV['TMPDIR'] || ENV['TMP'] || ENV['TEMP'] ||
-            Etc.systmpdir || '/tmp'
-  non_world_writable_tmp_dir = File.join(tmp_dir, 'rubocop')
-  FileUtils.makedirs(non_world_writable_tmp_dir, mode: 0700)
-  ENV['TMPDIR'] = non_world_writable_tmp_dir
-end
-
-if ENV['TRAVIS'] || ENV['COVERAGE']
-  require 'simplecov'
-
-  if ENV['TRAVIS']
-    require 'coveralls'
-    SimpleCov.formatter = Coveralls::SimpleCov::Formatter
-  end
-
-  SimpleCov.start do
-    add_filter '/spec/'
-    add_filter '/vendor/bundle/'
-  end
-end
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'rspec'
 require 'rubocop'
-require 'rubocop/cli'
-
-# disable colors in specs
-Rainbow.enabled = false
-
-module ExitCodeMatchers
-  RSpec::Matchers.define :exit_with_code do |code|
-    supports_block_expectations
-    actual = nil
-    match do |block|
-      begin
-        block.call
-      rescue SystemExit => e
-        actual = e.status
-      end
-      actual && actual == code
-    end
-    failure_message do
-      "expected block to call exit(#{code}) but exit" +
-        (actual.nil? ? ' not called' : "(#{actual}) was called")
-    end
-    failure_message_when_negated do
-      "expected block not to call exit(#{code})"
-    end
-    description do
-      "expect block to call exit(#{code})"
-    end
-  end
-end
 
 RSpec.configure do |config|
   # These two settings work together to allow you to limit a spec run
@@ -67,88 +13,24 @@ RSpec.configure do |config|
   # get run.
   config.filter_run :focus
   config.run_all_when_everything_filtered = true
+
   config.order = :random
 
+  config.filter_run_excluding ruby: ->(v) { !RUBY_VERSION.start_with?(v.to_s) }
+
   broken_filter = lambda do |v|
     v.is_a?(Symbol) ? RUBY_ENGINE == v.to_s : v
   end
-  config.filter_run_excluding ruby: ->(v) { !RUBY_VERSION.start_with?(v.to_s) }
   config.filter_run_excluding broken: broken_filter
 
-  config.expect_with :rspec do |c|
-    c.syntax = :expect # disables `should`
-  end
-
-  config.mock_with :rspec do |c|
-    c.syntax = :expect # disables `should_receive` and `stub`
-  end
-
-  config.include(ExitCodeMatchers)
-end
-
-def inspect_source_file(cop, source)
-  Tempfile.open('tmp') { |f| inspect_source(cop, source, f) }
-end
-
-def inspect_source(cop, source, file = nil)
-  RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
-  processed_source = parse_source(source, file)
-  fail 'Error parsing example code' unless processed_source.valid_syntax?
-  _investigate(cop, processed_source)
-end
-
-def parse_source(source, file = nil)
-  source = source.join($RS) if source.is_a?(Array)
-
-  if file && file.respond_to?(:write)
-    file.write(source)
-    file.rewind
-    file = file.path
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect # Disable `should`
   end
 
-  RuboCop::ProcessedSource.new(source, file)
-end
-
-def autocorrect_source_file(cop, source)
-  Tempfile.open('tmp') { |f| autocorrect_source(cop, source, f) }
-end
-
-def autocorrect_source(cop, source, file = nil)
-  cop.instance_variable_get(:@options)[:auto_correct] = true
-  processed_source = parse_source(source, file)
-  _investigate(cop, processed_source)
-
-  corrector =
-    RuboCop::Cop::Corrector.new(processed_source.buffer, cop.corrections)
-  corrector.rewrite
-end
-
-def _investigate(cop, processed_source)
-  forces = RuboCop::Cop::Force.all.each_with_object([]) do |klass, instances|
-    next unless cop.join_force?(klass)
-    instances << klass.new([cop])
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect # Disable `should_receive` and `stub`
   end
-
-  commissioner =
-    RuboCop::Cop::Commissioner.new([cop], forces, raise_error: true)
-  commissioner.investigate(processed_source)
-  commissioner
 end
 
-module RuboCop
-  module Cop
-    class Cop
-      def messages
-        offenses.sort.map(&:message)
-      end
-
-      def highlights
-        offenses.sort.map { |o| o.location.source }
-      end
-    end
-  end
-end
-
-# Requires supporting files with custom matchers and macros, etc,
-# in ./support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+# Disable colors in specs
+Rainbow.enabled = false