ridecharge-rubocop 0.0.1

data/spec/rubocop/path_util_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::PathUtil do
+  describe '#relative_path' do
+    pending 'builds paths relative to the current project by default'
+    it 'builds paths relative to PWD by default as a stop-gap' do
+      relative = File.join(Dir.pwd, 'relative')
+      expect(subject.relative_path(relative)).to eq('relative')
+    end
+
+    it 'supports custom base paths' do
+      expect(subject.relative_path('/foo/bar', '/foo')).to eq('bar')
+    end
+  end
+
+  describe '#match_path?' do
+    it 'matches strings to the basename' do
+      expect(subject.match_path?('file', '/dir/file')).to be_true
+      expect(subject.match_path?('file', '/dir/files')).to be_false
+      expect(subject.match_path?('dir', '/dir/file')).to be_false
+    end
+
+    it 'matches strings to the full path' do
+      expect(subject.match_path?('/dir/file', '/dir/file')).to be_true
+      expect(subject.match_path?('/dir/file', '/dir/dir/file')).to be_false
+    end
+
+    it 'matches glob expressions' do
+      expect(subject.match_path?('dir/*', 'dir/file')).to be_true
+      expect(subject.match_path?('dir/*', 'dir/sub/file')).to be_true
+      expect(subject.match_path?('dir/**/*', 'dir/sub/file')).to be_true
+      expect(subject.match_path?('sub/*', 'dir/sub/file')).to be_false
+    end
+
+    it 'matches regexps' do
+      expect(subject.match_path?(/^d.*e$/, 'dir/file')).to be_true
+      expect(subject.match_path?(/^d.*e$/, 'dir/filez')).to be_false
+    end
+  end
+end

data/spec/rubocop/processed_source_spec.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::ProcessedSource do
+  subject(:processed_source) do
+    described_class.new(
+      buffer,
+      double('ast'),
+      double('comments'),
+      double('tokens'),
+      diagnostics
+    )
+  end
+
+  let(:diagnostics) { double('diagnostics') }
+
+  let(:source) do
+    [
+      'def some_method',
+      "  puts 'foo'",
+      'end',
+      'some_method'
+    ].join("\n")
+  end
+
+  let(:buffer) do
+    buffer = Parser::Source::Buffer.new('(string)', 1)
+    buffer.source = source
+    buffer
+  end
+
+  describe '#lines' do
+    it 'is an array' do
+      expect(processed_source.lines).to be_a(Array)
+    end
+
+    it 'has same number of elements as line count' do
+      expect(processed_source.lines.size).to eq(4)
+    end
+
+    it 'contains lines as string without linefeed' do
+      first_line = processed_source.lines.first
+      expect(first_line).to eq('def some_method')
+    end
+  end
+
+  describe '#[]' do
+    context 'when an index is passed' do
+      it 'returns the line' do
+        expect(processed_source[2]).to eq('end')
+      end
+    end
+
+    context 'when a range is passed' do
+      it 'returns the array of lines' do
+        expect(processed_source[2..3]).to eq(%w(end some_method))
+      end
+    end
+
+    context 'when start index and length are passed' do
+      it 'returns the array of lines' do
+        expect(processed_source[2, 2]).to eq(%w(end some_method))
+      end
+    end
+  end
+
+  describe 'valid_syntax?' do
+    def create_diagnostics(level)
+      Parser::Diagnostic.new(level, :odd_hash, [], double('location'))
+    end
+
+    let(:diagnostics) do
+      [create_diagnostics(level)]
+    end
+
+    context 'when the source has diagnostic with error level' do
+      let(:level) { :error }
+
+      it 'returns false' do
+        expect(processed_source.valid_syntax?).to be_false
+      end
+    end
+
+    context 'when the source has diagnostic with fatal level' do
+      let(:level) { :fatal }
+
+      it 'returns false' do
+        expect(processed_source.valid_syntax?).to be_false
+      end
+    end
+
+    context 'when the source has diagnostic with warning level' do
+      let(:level) { :warning }
+
+      it 'returns true' do
+        expect(processed_source.valid_syntax?).to be_true
+      end
+    end
+
+    context 'when the source has diagnostics with error and warning level' do
+      let(:diagnostics) do
+        [
+          create_diagnostics(:error),
+          create_diagnostics(:warning)
+        ]
+      end
+
+      it 'returns false' do
+        expect(processed_source.valid_syntax?).to be_false
+      end
+    end
+  end
+end

data/spec/rubocop/source_parser_spec.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::SourceParser, :isolated_environment do
+  include FileHelper
+
+  describe '.parse_file' do
+    let(:file) { 'example.rb' }
+
+    let(:source) do
+      [
+        '# encoding: utf-8',
+        '',
+        'def some_method',
+        "  puts 'foo'",
+        'end',
+        '',
+        'some_method'
+      ]
+    end
+
+    before do
+      create_file(file, source)
+    end
+
+    let(:processed_source) do
+      described_class.parse_file(file)
+    end
+
+    it 'returns ProcessedSource' do
+      expect(processed_source).to be_a(Rubocop::ProcessedSource)
+    end
+
+    describe 'the returned processed source' do
+      it 'has the root node of AST' do
+        expect(processed_source.ast).to be_a(Parser::AST::Node)
+      end
+
+      it 'has an array of comments' do
+        expect(processed_source.comments).to be_a(Array)
+        expect(processed_source.comments.first)
+          .to be_a(Parser::Source::Comment)
+      end
+
+      it 'has an array of tokens' do
+        expect(processed_source.tokens).to be_a(Array)
+        expect(processed_source.tokens.first).to be_a(Rubocop::Token)
+      end
+
+      it 'has a source buffer' do
+        expect(processed_source.buffer).to be_a(Parser::Source::Buffer)
+      end
+
+      context 'when the source is valid' do
+        it 'does not have diagnostics' do
+          expect(processed_source.diagnostics).to be_a(Array)
+          expect(processed_source.diagnostics).to be_empty
+        end
+      end
+
+      context 'when the source has invalid syntax' do
+        let(:source) do
+          [
+            '# encoding: utf-8',
+            '',
+            'def some_method',
+            "  puts 'foo'",
+            'end',
+            '',
+            'some_method',
+            '',
+            '?invalid_syntax'
+          ]
+        end
+
+        it 'has an array of diagnostics' do
+          expect(processed_source.diagnostics).to be_a(Array)
+          expect(processed_source.diagnostics.first)
+            .to be_a(Parser::Diagnostic)
+        end
+      end
+    end
+  end
+
+  describe '.cop_disabled_lines_in' do
+    let(:source) do
+      [
+        '# encoding: utf-8',
+        '',
+        '# rubocop:disable MethodLength',
+        'def some_method',
+        "  puts 'foo'",
+        'end',
+        '# rubocop:enable MethodLength',
+        '',
+        '# rubocop:disable all',
+        'some_method',
+        '# rubocop:enable all',
+        '',
+        "code = 'This is evil.'",
+        'eval(code) # rubocop:disable Eval',
+        "puts 'This is not evil.'"
+      ]
+    end
+
+    let(:disabled_lines) { described_class.cop_disabled_lines_in(source) }
+
+    it 'has keys for disabled cops' do
+      expect(disabled_lines).to have_key('MethodLength')
+      expect(disabled_lines).to have_key('Eval')
+    end
+
+    it 'supports disabling multiple lines with a pair of directive' do
+      method_length_disabled_lines = disabled_lines['MethodLength']
+      expected_part = (3..6).to_a
+      expect(method_length_disabled_lines & expected_part)
+        .to eq(expected_part)
+    end
+
+    it 'supports disabling single line with a direcive at end of line' do
+      eval_disabled_lines = disabled_lines['Eval']
+      expect(eval_disabled_lines).to include(14)
+      expect(eval_disabled_lines).not_to include(15)
+    end
+
+    it 'supports disabling all cops with keyword all' do
+      all_cop_names = Rubocop::Cop::Cop.all.map(&:cop_name).sort
+      expect(disabled_lines.keys.sort).to eq(all_cop_names)
+
+      expected_part = (9..10).to_a
+
+      disabled_lines.each_value do |each_cop_disabled_lines|
+        expect(each_cop_disabled_lines & expected_part)
+          .to eq(expected_part)
+      end
+    end
+  end
+end

data/spec/rubocop/target_finder_spec.rb

@@ -0,0 +1,180 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::TargetFinder, :isolated_environment do
+  include FileHelper
+
+  subject(:target_finder) { described_class.new(config_store, debug) }
+  let(:config_store) { Rubocop::ConfigStore.new }
+  let(:debug) { false }
+
+  before do
+    create_file('dir1/ruby1.rb',   '# encoding: utf-8')
+    create_file('dir1/ruby2.rb',   '# encoding: utf-8')
+    create_file('dir1/file.txt',   '# encoding: utf-8')
+    create_file('dir1/file',       '# encoding: utf-8')
+    create_file('dir1/executable', '#!/usr/bin/env ruby')
+    create_file('dir2/ruby3.rb',   '# encoding: utf-8')
+  end
+
+  describe '#find' do
+    let(:found_files) { target_finder.find(args) }
+    let(:found_basenames) { found_files.map { |f| File.basename(f) } }
+    let(:args) { [] }
+
+    it 'returns absolute paths' do
+      expect(found_files).not_to be_empty
+      found_files.each do |file|
+        expect(file).to start_with('/')
+      end
+    end
+
+    context 'when no argument is passed' do
+      let(:args) { [] }
+
+      it 'finds files under the current directory' do
+        Dir.chdir('dir1') do
+          expect(found_files).not_to be_empty
+          found_files.each do |file|
+            expect(file).to include('/dir1/')
+            expect(file).not_to include('/dir2/')
+          end
+        end
+      end
+    end
+
+    context 'when a directory path is passed' do
+      let(:args) { ['../dir2'] }
+
+      it 'finds files under the specified directory' do
+        Dir.chdir('dir1') do
+          expect(found_files).not_to be_empty
+          found_files.each do |file|
+            expect(file).to include('/dir2/')
+            expect(file).not_to include('/dir1/')
+          end
+        end
+      end
+    end
+
+    context 'when a file is passed' do
+      let(:args) { ['dir2/file'] }
+
+      it 'picks the file' do
+        expect(found_basenames).to eq(['file'])
+      end
+    end
+
+    context 'when a pattern is passed' do
+      let(:args) { ['dir1/*2.rb'] }
+
+      it 'finds files which match the pattern' do
+        expect(found_basenames).to eq(['ruby2.rb'])
+      end
+    end
+
+    context 'when same paths are passed' do
+      let(:args) { %w(dir1 dir1) }
+
+      it 'does not return duplicated file paths' do
+        count = found_basenames.count { |f| f == 'ruby1.rb' }
+        expect(count).to eq(1)
+      end
+    end
+  end
+
+  describe '#target_files_in_dir' do
+    let(:found_files) { target_finder.target_files_in_dir(base_dir) }
+    let(:found_basenames) { found_files.map { |f| File.basename(f) } }
+    let(:base_dir) { '.' }
+
+    it 'picks files with extension .rb' do
+      rb_file_count = found_files.count { |f| f.end_with?('.rb') }
+      expect(rb_file_count).to eq(3)
+    end
+
+    it 'picks ruby executable files with no extension' do
+      expect(found_basenames).to include('executable')
+    end
+
+    it 'does not pick files with no extension and no ruby shebang' do
+      expect(found_basenames).not_to include('file')
+    end
+
+    it 'picks ruby executable files with no extension' do
+      expect(found_basenames).to include('executable')
+    end
+
+    it 'does not pick directories' do
+      found_basenames = found_files.map { |f| File.basename(f) }
+      expect(found_basenames).not_to include('dir1')
+    end
+
+    it 'picks files specified to be included in config' do
+      config = double('config')
+      allow(config).to receive(:file_to_include?) do |file|
+        File.basename(file) == 'file'
+      end
+      allow(config).to receive(:file_to_exclude?).and_return(false)
+      allow(config_store).to receive(:for).and_return(config)
+
+      expect(found_basenames).to include('file')
+    end
+
+    it 'does not pick files specified to be excluded in config' do
+      config = double('config').as_null_object
+      allow(config).to receive(:file_to_include?).and_return(false)
+      allow(config).to receive(:file_to_exclude?) do |file|
+        File.basename(file) == 'ruby2.rb'
+      end
+      allow(config_store).to receive(:for).and_return(config)
+
+      expect(found_basenames).not_to include('ruby2.rb')
+    end
+
+    it 'does not return duplicated paths' do
+      config = double('config').as_null_object
+      allow(config).to receive(:file_to_include?).and_return(true)
+      allow(config).to receive(:file_to_exclude?).and_return(false)
+      allow(config_store).to receive(:for).and_return(config)
+
+      count = found_basenames.count { |f| f == 'ruby1.rb' }
+      expect(count).to eq(1)
+    end
+
+    context 'when an exception is raised while reading file' do
+      around do |example|
+        original_stderr = $stderr
+        $stderr = StringIO.new
+        begin
+          example.run
+        ensure
+          $stderr = original_stderr
+        end
+      end
+
+      before do
+        allow_any_instance_of(File).to receive(:readline).and_raise(EOFError)
+      end
+
+      context 'and debug mode is enabled' do
+        let(:debug) { true }
+
+        it 'outputs error message' do
+          found_files
+          expect($stderr.string).to include('Unprocessable file')
+        end
+      end
+
+      context 'and debug mode is disabled' do
+        let(:debug) { false }
+
+        it 'outputs nothing' do
+          found_files
+          expect($stderr.string).to be_empty
+        end
+      end
+    end
+  end
+end