rubyjobbuilderdsl 0.0.2 → 0.0.3

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/spec/rubocop/formatter/formatter_set_spec.rb

@@ -1,132 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'tempfile'
-
-module RuboCop
-  module Formatter
-    describe FormatterSet do
-      subject(:formatter_set) { described_class.new }
-
-      it 'responds to all formatter API methods' do
-        [:started, :file_started, :file_finished, :finished].each do |method|
-          expect(formatter_set).to respond_to(method)
-        end
-      end
-
-      describe 'formatter API method' do
-        before do
-          formatter_set.add_formatter('simple')
-          formatter_set.add_formatter('emacs')
-        end
-
-        let(:files) { ['/path/to/file1', '/path/to/file2'] }
-
-        it 'invokes same method of all containing formatters' do
-          formatter_set.each do |formatter|
-            expect(formatter).to receive(:started).with(files)
-          end
-          formatter_set.started(files)
-        end
-      end
-
-      describe 'add_formatter' do
-        it 'adds a formatter to itself' do
-          formatter_set.add_formatter('simple')
-          expect(formatter_set.size).to eq(1)
-        end
-
-        it 'adds a formatter with specified formatter type' do
-          formatter_set.add_formatter('simple')
-          expect(formatter_set.first.class).to eq(SimpleTextFormatter)
-        end
-
-        it 'can add multiple formatters by being invoked multiple times' do
-          formatter_set.add_formatter('simple')
-          formatter_set.add_formatter('emacs')
-          expect(formatter_set[0].class).to eq(SimpleTextFormatter)
-          expect(formatter_set[1].class).to eq(EmacsStyleFormatter)
-        end
-
-        context 'when output path is omitted' do
-          it 'adds a formatter outputs to $stdout' do
-            formatter_set.add_formatter('simple')
-            expect(formatter_set.first.output).to eq($stdout)
-          end
-        end
-
-        context 'when output path is specified' do
-          it 'adds a formatter outputs to the specified file' do
-            output_path = Tempfile.new('').path
-            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
-
-      describe '#close_output_files' do
-        before do
-          2.times do
-            output_path = Tempfile.new('').path
-            formatter_set.add_formatter('simple', output_path)
-          end
-          formatter_set.add_formatter('simple')
-        end
-
-        it 'closes all output files' do
-          formatter_set.close_output_files
-          formatter_set[0..1].each do |formatter|
-            expect(formatter.output).to be_closed
-          end
-        end
-
-        it 'does not close non file output' do
-          expect(formatter_set[2].output).not_to be_closed
-        end
-      end
-
-      describe '#builtin_formatter_class' do
-        def builtin_formatter_class(string)
-          described_class.new.send(:builtin_formatter_class, string)
-        end
-
-        it 'returns class which matches passed alias name exactly' do
-          expect(builtin_formatter_class('simple'))
-            .to eq(SimpleTextFormatter)
-        end
-
-        it 'returns class whose first letter of alias name ' \
-           'matches passed letter' do
-          expect(builtin_formatter_class('s'))
-            .to eq(SimpleTextFormatter)
-        end
-      end
-
-      describe '#custom_formatter_class' do
-        def custom_formatter_class(string)
-          described_class.new.send(:custom_formatter_class, string)
-        end
-
-        it 'returns constant represented by the passed string' do
-          expect(custom_formatter_class('RuboCop')).to eq(RuboCop)
-        end
-
-        it 'can handle namespaced constant name' do
-          expect(custom_formatter_class('RuboCop::CLI')).to eq(RuboCop::CLI)
-        end
-
-        it 'can handle top level namespaced constant name' do
-          expect(custom_formatter_class('::RuboCop::CLI')).to eq(RuboCop::CLI)
-        end
-
-        context 'when non-existent constant name is passed' do
-          it 'raises error' do
-            expect { custom_formatter_class('RuboCop::NonExistentClass') }
-              .to raise_error(NameError)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/spec/rubocop/formatter/fuubar_style_formatter_spec.rb

@@ -1,129 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'stringio'
-
-module RuboCop
-  describe Formatter::FuubarStyleFormatter do
-    subject(:formatter) { described_class.new(output) }
-    let(:output) { StringIO.new }
-
-    let(:files) do
-      %w(lib/rubocop.rb spec/spec_helper.rb).map do |path|
-        File.expand_path(path)
-      end
-    end
-
-    describe '#with_color' do
-      around do |example|
-        original_state = formatter.rainbow.enabled
-
-        begin
-          example.run
-        ensure
-          formatter.rainbow.enabled = original_state
-        end
-      end
-
-      context 'when color is enabled' do
-        before do
-          formatter.rainbow.enabled = true
-        end
-
-        it 'outputs coloring sequence code at the beginning and the end' do
-          formatter.with_color { formatter.output.write 'foo' }
-          expect(output.string).to eq("\e[32mfoo\e[0m")
-        end
-      end
-
-      context 'when color is enabled' do
-        before do
-          formatter.rainbow.enabled = false
-        end
-
-        it 'outputs nothing' do
-          formatter.with_color { formatter.output.write 'foo' }
-          expect(output.string).to eq('foo')
-        end
-      end
-    end
-
-    describe '#progressbar_color' do
-      before do
-        formatter.started(files)
-      end
-
-      def offense(severity, corrected = false)
-        source_range = double('source_range').as_null_object
-        Cop::Offense.new(severity, source_range, 'message', 'Cop', corrected)
-      end
-
-      context 'initially' do
-        it 'is green' do
-          expect(formatter.progressbar_color).to eq(:green)
-        end
-      end
-
-      context 'when no offenses are detected in a file' do
-        before do
-          formatter.file_finished(files[0], [])
-        end
-
-        it 'is still green' do
-          expect(formatter.progressbar_color).to eq(:green)
-        end
-      end
-
-      context 'when a convention offense is detected in a file' do
-        before do
-          formatter.file_finished(files[0], [offense(:convention)])
-        end
-
-        it 'is yellow' do
-          expect(formatter.progressbar_color).to eq(:yellow)
-        end
-      end
-
-      context 'when an error offense is detected in a file' do
-        before do
-          formatter.file_finished(files[0], [offense(:error)])
-        end
-
-        it 'is red' do
-          expect(formatter.progressbar_color).to eq(:red)
-        end
-
-        context 'and then a convention offense is detected in the next file' do
-          before do
-            formatter.file_finished(files[1], [offense(:convention)])
-          end
-
-          it 'is still red' do
-            expect(formatter.progressbar_color).to eq(:red)
-          end
-        end
-      end
-
-      context 'when convention and error offenses are detected in a file' do
-        before do
-          offenses = [offense(:convention), offense(:error)]
-          formatter.file_finished(files[0], offenses)
-        end
-
-        it 'is red' do
-          expect(formatter.progressbar_color).to eq(:red)
-        end
-      end
-
-      context 'when a offense is detected in a file and auto-corrected' do
-        before do
-          formatter.file_finished(files[0], [offense(:convention, true)])
-        end
-
-        it 'is green' do
-          expect(formatter.progressbar_color).to eq(:green)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/spec/rubocop/formatter/html_formatter_spec.rb

@@ -1,145 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'stringio'
-
-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] }
-
-      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
-
-    describe '#file_finished' do
-      before do
-        count = 0
-        allow(formatter).to receive(:hash_for_file) do
-          count += 1
-        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)
-      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])
-      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')
-      end
-
-      before do
-        count = 0
-        allow(formatter).to receive(:hash_for_offense) do
-          count += 1
-        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)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/spec/rubocop/formatter/json_formatter_spec.rb

@@ -1,152 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'stringio'
-
-module RuboCop
-  describe Formatter::JSONFormatter 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] }
-
-      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
-
-    describe '#file_finished' do
-      before do
-        count = 0
-        allow(formatter).to receive(:hash_for_file) do
-          count += 1
-        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)
-      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])
-      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
-
-      it 'outputs #output_hash as JSON' do
-        formatter.finished(files)
-        json = output.string
-        restored_hash = JSON.parse(json, symbolize_names: true)
-        expect(restored_hash).to eq(formatter.output_hash)
-      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')
-      end
-
-      before do
-        count = 0
-        allow(formatter).to receive(:hash_for_offense) do
-          count += 1
-        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)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/spec/rubocop/formatter/offense_count_formatter_spec.rb

@@ -1,77 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'stringio'
-require 'tempfile'
-
-module RuboCop
-  module Formatter
-    describe OffenseCountFormatter do
-      subject(:formatter) { described_class.new(output) }
-      let(:output) { StringIO.new }
-
-      let(:files) do
-        %w(lib/rubocop.rb spec/spec_helper.rb bin/rubocop).map do |path|
-          File.expand_path(path)
-        end
-      end
-
-      let(:finish) { formatter.file_finished(files.first, offenses) }
-
-      describe '#file_finished' do
-        before { formatter.started(files) }
-
-        context 'when no offenses are detected' do
-          let(:offenses) { [] }
-          it 'does not add to offense_counts' do
-            expect { finish }.to_not change { formatter.offense_counts }
-          end
-        end
-
-        context 'when any offenses are detected' do
-          let(:offenses) { [double('offense', cop_name: 'OffendedCop')] }
-          it 'increments the count for the cop in offense_counts' do
-            expect { finish }.to change { formatter.offense_counts }
-          end
-        end
-      end
-
-      describe '#report_summary' do
-        context 'when an offense is detected' do
-          let(:cop_counts) { { 'OffendedCop' => 1 } }
-          it 'shows the cop and the offense count' do
-            formatter.report_summary(cop_counts)
-            expect(output.string).to include(
-              "\n1  OffendedCop\n--\n1  Total")
-          end
-        end
-      end
-
-      describe '#finished' do
-        context 'when there are many offenses' do
-          let(:offenses) do
-            %w(CopB CopA CopC CopC).map { |c| double('offense', cop_name: c) }
-          end
-
-          before do
-            formatter.started(files)
-            finish
-          end
-
-          it 'sorts by offense count first and then by cop name' do
-            formatter.finished(files)
-            expect(output.string).to eq(['',
-                                         '2  CopC',
-                                         '1  CopA',
-                                         '1  CopB',
-                                         '--',
-                                         '4  Total',
-                                         '',
-                                         ''].join("\n"))
-          end
-        end
-      end
-
-    end
-  end
-end