rubyjobbuilderdsl 0.0.0 → 0.0.1

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/spec/rubocop/cop/style/constant_name_spec.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe RuboCop::Cop::Style::ConstantName do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offense for camel case in const name' do
+    inspect_source(cop,
+                   ['TopCase = 5'])
+    expect(cop.offenses.size).to eq(1)
+  end
+
+  it 'registers offenses for camel case in multiple const assignment' do
+    inspect_source(cop,
+                   ['TopCase, Test2, TEST_3 = 5, 6, 7'])
+    expect(cop.offenses.size).to eq(2)
+  end
+
+  it 'registers an offense for snake case in const name' do
+    inspect_source(cop,
+                   ['TOP_test = 5'])
+    expect(cop.offenses.size).to eq(1)
+  end
+
+  it 'allows screaming snake case in const name' do
+    inspect_source(cop,
+                   ['TOP_TEST = 5'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'allows screaming snake case in multiple const assignment' do
+    inspect_source(cop,
+                   ['TOP_TEST, TEST_2 = 5, 6'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not check names if rhs is a method call' do
+    inspect_source(cop,
+                   ['AnythingGoes = test'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not check names if rhs is a method call with block' do
+    inspect_source(cop,
+                   ['AnythingGoes = test do',
+                    '  do_something',
+                    'end'
+                   ])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not check if rhs is another constant' do
+    inspect_source(cop,
+                   ['Parser::CurrentRuby = Parser::Ruby20'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'checks qualified const names' do
+    inspect_source(cop,
+                   ['::AnythingGoes = 30',
+                    'a::Bar_foo = 10'])
+    expect(cop.offenses.size).to eq(2)
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/spec/rubocop/cop/style/def_with_parentheses_spec.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe RuboCop::Cop::Style::DefWithParentheses do
+  subject(:cop) { described_class.new }
+
+  it 'reports an offense for def with empty parens' do
+    src = ['def func()',
+           'end']
+    inspect_source(cop, src)
+    expect(cop.offenses.size).to eq(1)
+  end
+
+  it 'reports an offense for class def with empty parens' do
+    src = ['def Test.func()',
+           'end']
+    inspect_source(cop, src)
+    expect(cop.offenses.size).to eq(1)
+  end
+
+  it 'accepts def with arg and parens' do
+    src = ['def func(a)',
+           'end']
+    inspect_source(cop, src)
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'accepts empty parentheses in one liners' do
+    src = ["def to_s() join '/' end"]
+    inspect_source(cop, src)
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'auto-removes unneeded parens' do
+    new_source = autocorrect_source(cop, ['def test();',
+                                          'something',
+                                          'end'])
+    expect(new_source).to eq(['def test;',
+                              'something',
+                              'end'].join("\n"))
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/spec/rubocop/cop/style/deprecated_hash_methods_spec.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe RuboCop::Cop::Style::DeprecatedHashMethods do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offense for has_key? with one arg' do
+    inspect_source(cop,
+                   ['o.has_key?(o)'])
+    expect(cop.offenses.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['`Hash#has_key?` is deprecated in favor of `Hash#key?`.'])
+  end
+
+  it 'accepts has_key? with no args' do
+    inspect_source(cop,
+                   ['o.has_key?'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'registers an offense for has_value? with one arg' do
+    inspect_source(cop,
+                   ['o.has_value?(o)'])
+    expect(cop.offenses.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['`Hash#has_value?` is deprecated in favor of `Hash#value?`.'])
+  end
+
+  it 'accepts has_value? with no args' do
+    inspect_source(cop,
+                   ['o.has_value?'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'auto-corrects has_key? with key?' do
+    new_source = autocorrect_source(cop, 'hash.has_key?(:test)')
+    expect(new_source).to eq('hash.key?(:test)')
+  end
+
+  it 'auto-corrects has_value? with value?' do
+    new_source = autocorrect_source(cop, 'hash.has_value?(value)')
+    expect(new_source).to eq('hash.value?(value)')
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/spec/rubocop/cop/style/documentation_spec.rb

@@ -0,0 +1,147 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe RuboCop::Cop::Style::Documentation do
+
+  subject(:cop) { described_class.new(config) }
+  let(:config) do
+    RuboCop::Config.new('Style/CommentAnnotation' => {
+                          'Keywords' => %w(TODO FIXME OPTIMIZE HACK REVIEW)
+                        })
+  end
+
+  it 'registers an offense for non-empty class' do
+    inspect_source(cop,
+                   ['class My_Class',
+                    '  TEST = 20',
+                    'end'
+                   ])
+    expect(cop.offenses.size).to eq(1)
+  end
+
+  it 'does not consider comment followed by empty line to be class ' \
+     'documentation' do
+    inspect_source(cop,
+                   ['# Copyright 2014',
+                    '# Some company',
+                    '',
+                    'class My_Class',
+                    '  TEST = 20',
+                    'end'
+                   ])
+    expect(cop.offenses.size).to eq(1)
+  end
+
+  it 'registers an offense for non-namespace' do
+    inspect_source(cop,
+                   ['module My_Class',
+                    '  TEST = 20',
+                    'end'
+                   ])
+    expect(cop.offenses.size).to eq(1)
+  end
+
+  it 'registers an offense for empty module without documentation' do
+    # Because why would you have an empty module? It requires some
+    # explanation.
+    inspect_source(cop,
+                   ['module Test',
+                    'end'
+                   ])
+    expect(cop.offenses.size).to eq(1)
+  end
+
+  it 'accepts non-empty class with documentation' do
+    inspect_source(cop,
+                   ['# class comment',
+                    'class My_Class',
+                    '  TEST = 20',
+                    'end'
+                   ])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'registers an offense for non-empty class with annotation comment' do
+    inspect_source(cop,
+                   ['# OPTIMIZE: Make this faster.',
+                    'class My_Class',
+                    '  TEST = 20',
+                    'end'
+                   ])
+    expect(cop.offenses.size).to eq(1)
+  end
+
+  it 'accepts non-empty class with annotation comment followed by other ' \
+     'comment' do
+    inspect_source(cop,
+                   ['# OPTIMIZE: Make this faster.',
+                    '# Class comment.',
+                    'class My_Class',
+                    '  TEST = 20',
+                    'end'
+                   ])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'accepts non-empty class with comment that ends with an annotation' do
+    inspect_source(cop,
+                   ['# Does fooing.',
+                    '# FIXME: Not yet implemented.',
+                    'class Foo',
+                    '  def initialize',
+                    '  end',
+                    'end'
+                   ])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'accepts non-empty module with documentation' do
+    inspect_source(cop,
+                   ['# class comment',
+                    'module My_Class',
+                    '  TEST = 20',
+                    'end'
+                   ])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'accepts empty class without documentation' do
+    inspect_source(cop,
+                   ['class My_Class',
+                    'end'
+                   ])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'accepts namespace module without documentation' do
+    inspect_source(cop,
+                   ['module Test',
+                    '  class A; end',
+                    '  class B; end',
+                    'end'
+                   ])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'accepts namespace class without documentation' do
+    inspect_source(cop,
+                   ['class Test',
+                    '  class A; end',
+                    '  class B; end',
+                    'end'
+                   ])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not raise an error for an implicit match conditional' do
+    expect do
+      inspect_source(cop,
+                     ['class Test',
+                      '  if //',
+                      '  end',
+                      'end'
+                     ])
+    end.to_not raise_error
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/spec/rubocop/cop/style/dot_position_spec.rb

@@ -0,0 +1,130 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe RuboCop::Cop::Style::DotPosition, :config do
+  subject(:cop) { described_class.new(config) }
+
+  context 'Leading dots style' do
+    let(:cop_config) { { 'EnforcedStyle' => 'leading' } }
+
+    it 'registers an offense for trailing dot in multi-line call' do
+      inspect_source(cop, ['something.',
+                           '  method_name'])
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.highlights).to eq(['.'])
+      expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'trailing')
+    end
+
+    it 'registers an offense for correct + opposite' do
+      inspect_source(cop, ['something',
+                           '  .method_name',
+                           'something.',
+                           '  method_name'])
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
+    end
+
+    it 'accepts leading do in multi-line method call' do
+      inspect_source(cop, ['something',
+                           '  .method_name'])
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'does not err on method call with no dots' do
+      inspect_source(cop, ['puts something'])
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'does not err on method call without a method name' do
+      inspect_source(cop, ['l.', '(1)'])
+      expect(cop.offenses.size).to eq(1)
+    end
+
+    it 'does not err on method call on same line' do
+      inspect_source(cop, ['something.method_name'])
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'auto-corrects trailing dot in multi-line call' do
+      new_source = autocorrect_source(cop, ['something.',
+                                            '  method_name'])
+      expect(new_source).to eq(['something',
+                                '  .method_name'].join("\n"))
+    end
+
+    it 'auto-corrects trailing dot in multi-line call without selector' do
+      new_source = autocorrect_source(cop, ['something.',
+                                            '  (1)'])
+      expect(new_source).to eq(['something',
+                                '  .(1)'].join("\n"))
+    end
+
+    it 'auto-corrects correct + opposite style' do
+      new_source = autocorrect_source(cop, ['something',
+                                            '  .method_name',
+                                            'something.',
+                                            '  method_name'])
+      expect(new_source).to eq(['something',
+                                '  .method_name',
+                                'something',
+                                '  .method_name'].join("\n"))
+    end
+  end
+
+  context 'Trailing dots style' do
+    let(:cop_config) { { 'EnforcedStyle' => 'trailing' } }
+
+    it 'registers an offense for leading dot in multi-line call' do
+      inspect_source(cop, ['something',
+                           '  .method_name'])
+      expect(cop.messages)
+        .to eq(['Place the . on the previous line, together with the method ' \
+                'call receiver.'])
+      expect(cop.highlights).to eq(['.'])
+      expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'leading')
+    end
+
+    it 'accepts trailing dot in multi-line method call' do
+      inspect_source(cop, ['something.',
+                           '  method_name'])
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'does not err on method call with no dots' do
+      inspect_source(cop, ['puts something'])
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'does not err on method call without a method name' do
+      inspect_source(cop, ['l', '.(1)'])
+      expect(cop.offenses.size).to eq(1)
+    end
+
+    it 'does not err on method call on same line' do
+      inspect_source(cop, ['something.method_name'])
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'does not get confused by several lines of chained methods' do
+      inspect_source(cop, ['File.new(something).',
+                           'readlines.map.',
+                           'compact.join("\n")'])
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'auto-corrects leading dot in multi-line call' do
+      new_source = autocorrect_source(cop, ['something',
+                                            '  .method_name'])
+      expect(new_source).to eq(['something.',
+                                '  method_name'].join("\n"))
+    end
+
+    it 'auto-corrects leading dot in multi-line call without selector' do
+      new_source = autocorrect_source(cop, ['something',
+                                            '  .(1)'])
+      expect(new_source).to eq(['something.',
+                                '  (1)'].join("\n"))
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/spec/rubocop/cop/style/double_negation_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe RuboCop::Cop::Style::DoubleNegation do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offense for !!' do
+    inspect_source(cop, '!!test.something')
+    expect(cop.offenses.size).to eq(1)
+  end
+
+  it 'does not register an offense for !' do
+    inspect_source(cop, '!test.something')
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not register an offense for not not' do
+    inspect_source(cop, 'not not test.something')
+    expect(cop.offenses).to be_empty
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/spec/rubocop/cop/style/each_with_object_spec.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe RuboCop::Cop::Style::EachWithObject do
+  subject(:cop) { described_class.new }
+
+  it 'finds inject and reduce with passed in and returned hash' do
+    inspect_source(cop,
+                   ['[].inject({}) { |a, e| a }',
+                    '',
+                    '[].reduce({}) do |a, e|',
+                    '  a[e] = 1',
+                    '  a[e] = 1',
+                    '  a',
+                    'end'])
+    expect(cop.offenses.size).to eq(2)
+    expect(cop.offenses.map(&:line).sort).to eq([1, 3])
+    expect(cop.messages)
+      .to eq(['Use `each_with_object` instead of `inject`.',
+              'Use `each_with_object` instead of `reduce`.'])
+    expect(cop.highlights).to eq(%w(inject reduce))
+  end
+
+  it 'ignores inject and reduce with passed in, but not returned hash' do
+    inspect_source(cop,
+                   ['[].inject({}) do |a, e|',
+                    '  a + e',
+                    'end',
+                    '',
+                    '[].reduce({}) do |a, e|',
+                    '  my_method e, a',
+                    'end'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'ignores inject and reduce with empty body' do
+    inspect_source(cop,
+                   ['[].inject({}) do |a, e|',
+                    'end',
+                    '',
+                    '[].reduce({}) { |a, e| }'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'ignores inject and reduce with condition as body' do
+    inspect_source(cop,
+                   ['[].inject({}) do |a, e|',
+                    '  a = e if e',
+                    'end',
+                    '',
+                    '[].inject({}) do |a, e|',
+                    '  if e',
+                    '    a = e',
+                    '  end',
+                    'end',
+                    '',
+                    '[].reduce({}) do |a, e|',
+                    '  a = e ? e : 2',
+                    'end'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'ignores inject and reduce passed in symbol' do
+    inspect_source(cop, ['[].inject(:+)', '[].reduce(:+)'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not blow up for reduce with no arguments' do
+    inspect_source(cop, ['[1, 2, 3].inject { |a, e| a + e }'])
+    expect(cop.offenses).to be_empty
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/spec/rubocop/cop/style/empty_line_between_defs_spec.rb

@@ -0,0 +1,135 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe RuboCop::Cop::Style::EmptyLineBetweenDefs, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'AllowAdjacentOneLineDefs' => false } }
+
+  it 'finds offenses in inner classes' do
+    source = ['class K',
+              '  def m',
+              '  end',
+              '  class J',
+              '    def n',
+              '    end',
+              '    def o',
+              '    end',
+              '  end',
+              '  # checks something',
+              '  def p',
+              '  end',
+              'end']
+    inspect_source(cop, source)
+    expect(cop.offenses.size).to eq(1)
+    expect(cop.offenses.map(&:line).sort).to eq([7])
+  end
+
+  # Only one def, so rule about empty line *between* defs does not
+  # apply.
+  it 'accepts a def that follows a line with code' do
+    source = ['x = 0',
+              'def m',
+              'end']
+    inspect_source(cop, source)
+    expect(cop.offenses).to be_empty
+  end
+
+  # Only one def, so rule about empty line *between* defs does not
+  # apply.
+  it 'accepts a def that follows code and a comment' do
+    source = ['  x = 0',
+              '  # 123',
+              '  def m',
+              '  end']
+    inspect_source(cop, source)
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'accepts the first def without leading empty line in a class' do
+    source = ['class K',
+              '  def m',
+              '  end',
+              'end']
+    inspect_source(cop, source)
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'accepts a def that follows an empty line and then a comment' do
+    source = ['class A',
+              '  # calculates value',
+              '  def m',
+              '  end',
+              '',
+              '  private',
+              '  # calculates size',
+              '  def n',
+              '  end',
+              'end'
+             ]
+    inspect_source(cop, source)
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'accepts a def that is the first of a module' do
+    source = ['module Util',
+              '  public',
+              '  #',
+              '  def html_escape(s)',
+              '  end',
+              'end'
+             ]
+    inspect_source(cop, source)
+    expect(cop.messages).to be_empty
+  end
+
+  it 'accepts a nested def' do
+    source = ['def mock_model(*attributes)',
+              '  Class.new do',
+              '    def initialize(attrs)',
+              '    end',
+              '  end',
+              'end'
+             ]
+    inspect_source(cop, source)
+    expect(cop.messages).to be_empty
+  end
+
+  it 'registers an offense for adjacent one-liners by default' do
+    source = ['def a; end',
+              'def b; end']
+    inspect_source(cop, source)
+    expect(cop.offenses.size).to eq(1)
+  end
+
+  it 'auto-corrects adjacent one-liners by default' do
+    corrected = autocorrect_source(cop, ['  def a; end',
+                                         '  def b; end'])
+    expect(corrected).to eq(['  def a; end',
+                             '',
+                             '  def b; end'].join("\n"))
+  end
+
+  context 'when AllowAdjacentOneLineDefs is enabled' do
+    let(:cop_config) { { 'AllowAdjacentOneLineDefs' => true } }
+
+    it 'accepts adjacent one-liners' do
+      source = ['def a; end',
+                'def b; end']
+      inspect_source(cop, source)
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'registers an offense for adjacent defs if some are multi-line' do
+      source = ['def a; end',
+                'def b; end',
+                'def c', # Not a one-liner, so this is an offense.
+                'end',
+                # Also an offense since previous was multi-line:
+                'def d; end'
+               ]
+      inspect_source(cop, source)
+      expect(cop.offenses.map(&:line)).to eq([3, 5])
+    end
+  end
+end