rubyjobbuilderdsl 0.0.2 → 0.0.3

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/space_before_block_braces.rb

@@ -1,64 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks that block braces have or don't have a space before the opening
-      # brace depending on configuration.
-      class SpaceBeforeBlockBraces < Cop
-        include ConfigurableEnforcedStyle
-
-        def on_block(node)
-          return if node.loc.begin.is?('do') # No braces.
-
-          # If braces are on separate lines, and the Blocks cop is enabled,
-          # those braces will be changed to do..end by the user or by
-          # auto-correct, so reporting space issues is not useful, and it
-          # creates auto-correct conflicts.
-          if config.for_cop('Style/Blocks')['Enabled'] &&
-              Util.block_length(node) > 0
-            return
-          end
-
-          left_brace = node.loc.begin
-          space_plus_brace = range_with_surrounding_space(left_brace)
-          used_style =
-            space_plus_brace.source.start_with?('{') ? :no_space : :space
-
-          case used_style
-          when style  then correct_style_detected
-          when :space then space_detected(left_brace, space_plus_brace)
-          else             space_missing(left_brace)
-          end
-        end
-
-        private
-
-        def space_missing(left_brace)
-          add_offense(left_brace, left_brace,
-                      'Space missing to the left of {.') do
-            opposite_style_detected
-          end
-        end
-
-        def space_detected(left_brace, space_plus_brace)
-          space = Parser::Source::Range.new(left_brace.source_buffer,
-                                            space_plus_brace.begin_pos,
-                                            left_brace.begin_pos)
-          add_offense(space, space, 'Space detected to the left of {.') do
-            opposite_style_detected
-          end
-        end
-
-        def autocorrect(range)
-          @corrections << lambda do |corrector|
-            case range.source
-            when /\s/ then corrector.remove(range)
-            else           corrector.insert_before(range, ' ')
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/space_before_comma.rb

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for comma (,) preceded by space.
-      class SpaceBeforeComma < Cop
-        include SpaceBeforePunctuation
-
-        def kind(token)
-          'comma' if token.type == :tCOMMA
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/space_before_comment.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for missing space between a token and a comment on the
-      # same line.
-      class SpaceBeforeComment < Cop
-        MSG = 'Put a space before an end-of-line comment.'
-
-        def investigate(processed_source)
-          processed_source.tokens.each_cons(2) do |t1, t2|
-            next unless t2.type == :tCOMMENT
-            next unless t1.pos.line == t2.pos.line
-            add_offense(t2.pos, t2.pos) if t1.pos.end == t2.pos.begin
-          end
-        end
-
-        private
-
-        def autocorrect(range)
-          @corrections << lambda do |corrector|
-            corrector.insert_before(range, ' ')
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/space_before_modifier_keyword.rb

@@ -1,39 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # Here we check if modifier keywords are preceded by a space.
-      class SpaceBeforeModifierKeyword < Cop
-        MSG = 'Put a space before the modifier keyword.'
-
-        def on_if(node)
-          return unless modifier?(node)
-
-          kw = node.loc.keyword
-          b = kw.begin_pos
-          left_of_kw = Parser::Source::Range.new(kw.source_buffer, b - 1, b)
-          add_offense(node, left_of_kw) unless left_of_kw.is?(' ')
-        end
-        alias_method :on_while, :on_if
-        alias_method :on_until, :on_if
-
-        private
-
-        def modifier?(node)
-          node.loc.respond_to?(:end) && node.loc.end.nil? && !elsif?(node)
-        end
-
-        def elsif?(node)
-          node.loc.keyword.is?('elsif')
-        end
-
-        def autocorrect(node)
-          @corrections << lambda do |corrector|
-            corrector.insert_before(node.loc.keyword, ' ')
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/space_before_semicolon.rb

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for semicolon (;) preceded by space.
-      class SpaceBeforeSemicolon < Cop
-        include SpaceBeforePunctuation
-
-        def kind(token)
-          'semicolon' if token.type == :tSEMI
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/space_inside_block_braces.rb

@@ -1,156 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks that block braces have or don't have surrounding space inside
-      # them on configuration. For blocks taking parameters, it checks that the
-      # left brace has or doesn't have trailing space depending on
-      # configuration.
-      class SpaceInsideBlockBraces < Cop
-        include ConfigurableEnforcedStyle
-        include SurroundingSpace
-
-        def on_block(node)
-          return if node.loc.begin.is?('do') # No braces.
-
-          # If braces are on separate lines, and the Blocks cop is enabled,
-          # those braces will be changed to do..end by the user or by
-          # auto-correct, so reporting space issues is not useful, and it
-          # creates auto-correct conflicts.
-          if config.for_cop('Style/Blocks')['Enabled'] &&
-              Util.block_length(node) > 0
-            return
-          end
-
-          left_brace, right_brace = node.loc.begin, node.loc.end
-
-          check_inside(node, left_brace, right_brace)
-        end
-
-        private
-
-        def check_inside(node, left_brace, right_brace)
-          sb = node.loc.expression.source_buffer
-
-          if left_brace.end_pos == right_brace.begin_pos
-            if style_for_empty_braces == :space
-              offense(sb, left_brace.begin_pos, right_brace.end_pos,
-                      'Space missing inside empty braces.')
-            end
-          else
-            range = Parser::Source::Range.new(sb, left_brace.end_pos,
-                                              right_brace.begin_pos)
-            inner = range.source
-            unless inner =~ /\n/
-              if inner =~ /\S/
-                braces_with_contents_inside(node, inner, sb)
-              elsif style_for_empty_braces == :no_space
-                offense(sb, range.begin_pos, range.end_pos,
-                        'Space inside empty braces detected.')
-              end
-            end
-          end
-        end
-
-        def braces_with_contents_inside(node, inner, sb)
-          _method, args, _body = *node
-          left_brace, right_brace = node.loc.begin, node.loc.end
-          args_delimiter = args.loc.begin # Can be ( | or nil.
-
-          if inner =~ /^\S/
-            no_space_inside_left_brace(left_brace, args_delimiter, sb)
-          else
-            space_inside_left_brace(left_brace, args_delimiter, sb)
-          end
-
-          if inner =~ /\S$/
-            no_space(sb, right_brace.begin_pos, right_brace.end_pos,
-                     'Space missing inside }.')
-          else
-            space_inside_right_brace(right_brace, sb)
-          end
-        end
-
-        def no_space_inside_left_brace(left_brace, args_delimiter, sb)
-          if pipe?(args_delimiter)
-            if left_brace.end_pos == args_delimiter.begin_pos &&
-                cop_config['SpaceBeforeBlockParameters']
-              offense(sb, left_brace.begin_pos, args_delimiter.end_pos,
-                      'Space between { and | missing.')
-            end
-          else
-            # We indicate the position after the left brace. Otherwise it's
-            # difficult to distinguish between space missing to the left and to
-            # the right of the brace in autocorrect.
-            no_space(sb, left_brace.end_pos, left_brace.end_pos + 1,
-                     'Space missing inside {.')
-          end
-        end
-
-        def space_inside_left_brace(left_brace, args_delimiter, sb)
-          if pipe?(args_delimiter)
-            unless cop_config['SpaceBeforeBlockParameters']
-              offense(sb, left_brace.end_pos, args_delimiter.begin_pos,
-                      'Space between { and | detected.')
-            end
-          else
-            brace_with_space = range_with_surrounding_space(left_brace, :right)
-            space(sb, brace_with_space.begin_pos + 1, brace_with_space.end_pos,
-                  'Space inside { detected.')
-          end
-        end
-
-        def pipe?(args_delimiter)
-          args_delimiter && args_delimiter.is?('|')
-        end
-
-        def space_inside_right_brace(right_brace, sb)
-          brace_with_space = range_with_surrounding_space(right_brace, :left)
-          space(sb, brace_with_space.begin_pos, brace_with_space.end_pos - 1,
-                'Space inside } detected.')
-        end
-
-        def no_space(sb, begin_pos, end_pos, msg)
-          if style == :space
-            offense(sb, begin_pos, end_pos, msg) { opposite_style_detected }
-          else
-            correct_style_detected
-          end
-        end
-
-        def space(sb, begin_pos, end_pos, msg)
-          if style == :no_space
-            offense(sb, begin_pos, end_pos, msg) { opposite_style_detected }
-          else
-            correct_style_detected
-          end
-        end
-
-        def offense(sb, begin_pos, end_pos, msg)
-          range = Parser::Source::Range.new(sb, begin_pos, end_pos)
-          add_offense(range, range, msg) { yield if block_given? }
-        end
-
-        def style_for_empty_braces
-          case cop_config['EnforcedStyleForEmptyBraces']
-          when 'space'    then :space
-          when 'no_space' then :no_space
-          else fail 'Unknown EnforcedStyleForEmptyBraces selected!'
-          end
-        end
-
-        def autocorrect(range)
-          @corrections << lambda do |corrector|
-            case range.source
-            when /\s/ then corrector.remove(range)
-            when '{}' then corrector.replace(range, '{ }')
-            when '{|' then corrector.replace(range, '{ |')
-            else           corrector.insert_before(range, ' ')
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/space_inside_brackets.rb

@@ -1,20 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for spaces inside square brackets.
-      class SpaceInsideBrackets < Cop
-        include SpaceInside
-
-        def specifics
-          [
-            [:tLBRACK, :tLBRACK2],
-            :tRBRACK,
-            'square brackets'
-          ]
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/space_inside_hash_literal_braces.rb

@@ -1,109 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks that braces used for hash literals have or don't have
-      # surrounding space depending on configuration.
-      class SpaceInsideHashLiteralBraces < Cop
-        include SurroundingSpace
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Space inside %s.'
-
-        def on_hash(node)
-          b_ix = index_of_first_token(node)
-          tokens = processed_source.tokens
-
-          # Hash literal with braces?
-          return unless tokens[b_ix].type == :tLBRACE
-
-          e_ix = index_of_last_token(node)
-          check(tokens[b_ix], tokens[b_ix + 1])
-          check(tokens[e_ix - 1], tokens[e_ix]) unless b_ix == e_ix - 1
-        end
-
-        private
-
-        def check(t1, t2)
-          # No offense if line break inside.
-          return if t1.pos.line < t2.pos.line
-          return if t2.type == :tCOMMENT # Also indicates there's a line break.
-
-          is_empty_braces = t1.text == '{' && t2.text == '}'
-          expect_space = if is_empty_braces
-                           cop_config['EnforcedStyleForEmptyBraces'] == 'space'
-                         else
-                           style == :space
-                         end
-          if offense?(t1, t2, expect_space)
-            brace = (t1.text == '{' ? t1 : t2).pos
-            range = expect_space ? brace : space_range(brace)
-            add_offense(range, range, message(brace, is_empty_braces,
-                                              expect_space)) do
-              opposite_style_detected
-            end
-          else
-            correct_style_detected
-          end
-        end
-
-        def offense?(t1, t2, expect_space)
-          has_space = space_between?(t1, t2)
-          expect_space ? !has_space : has_space
-        end
-
-        def message(brace, is_empty_braces, expect_space)
-          inside_what = if is_empty_braces
-                          'empty hash literal braces'
-                        else
-                          brace.source
-                        end
-          problem = expect_space ? 'missing' : 'detected'
-          format(MSG, "#{inside_what} #{problem}")
-        end
-
-        def autocorrect(range)
-          @corrections << lambda do |corrector|
-            # It is possible that BracesAroundHashParameters will remove the
-            # braces while this cop inserts spaces. This can lead to unwanted
-            # changes to the inspected code. If we replace the brace with a
-            # brace plus space (rather than just inserting a space), then any
-            # removal of the same brace will give us a clobbering error. This
-            # in turn will make RuboCop fall back on cop-by-cop
-            # auto-correction.  Problem solved.
-            case range.source
-            when /\s/ then corrector.remove(range)
-            when '{' then corrector.replace(range, '{ ')
-            else corrector.replace(range, ' }')
-            end
-          end
-        end
-
-        def space_range(token_range)
-          if token_range.source == '{'
-            range_of_space_to_the_right(token_range)
-          else
-            range_of_space_to_the_left(token_range)
-          end
-        end
-
-        def range_of_space_to_the_right(range)
-          src = range.source_buffer.source
-          end_pos = range.end_pos
-          end_pos += 1 while src[end_pos] =~ /[ \t]/
-          Parser::Source::Range.new(range.source_buffer,
-                                    range.begin_pos + 1, end_pos)
-        end
-
-        def range_of_space_to_the_left(range)
-          src = range.source_buffer.source
-          begin_pos = range.begin_pos
-          begin_pos -= 1 while src[begin_pos - 1] =~ /[ \t]/
-          Parser::Source::Range.new(range.source_buffer, begin_pos,
-                                    range.end_pos - 1)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/space_inside_parens.rb

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for spaces inside ordinary round parentheses.
-      class SpaceInsideParens < Cop
-        include SpaceInside
-
-        def specifics
-          [:tLPAREN2, :tRPAREN, 'parentheses']
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/space_inside_range_literal.rb

@@ -1,58 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for spaces inside range literals.
-      # @example
-      #   # bad
-      #   1 .. 3
-      #
-      #   # good
-      #   1..3
-      #
-      #   # bad
-      #   'a' .. 'z'
-      #
-      #   # good
-      #   'a'..'z'
-      class SpaceInsideRangeLiteral < Cop
-        MSG = 'Space inside range literal.'
-
-        def on_irange(node)
-          check(node)
-        end
-
-        def on_erange(node)
-          check(node)
-        end
-
-        private
-
-        def check(node)
-          expression = node.loc.expression.source
-          operator = node.loc.operator.source.gsub(/\./, '\.')
-
-          return unless expression =~ /(\s#{operator})|(#{operator}\s)/
-
-          add_offense(node, :expression)
-        end
-
-        def autocorrect(node)
-          expression = node.loc.expression.source
-          operator = node.loc.operator.source
-          operator_escaped = operator.gsub(/\./, '\.')
-
-          @corrections << lambda do |corrector|
-            corrector.replace(
-              node.loc.expression,
-              expression
-                .sub(/\s+#{operator_escaped}/, operator)
-                .sub(/#{operator_escaped}\s+/, operator)
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/special_global_vars.rb

@@ -1,84 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop looks for uses of Perl-style global variables.
-      class SpecialGlobalVars < Cop
-        MSG_BOTH = 'Prefer `%s` from the English library, or `%s` over `%s`.'
-        MSG_ENGLISH = 'Prefer `%s` from the English library over `%s`.'
-        MSG_REGULAR = 'Prefer `%s` over `%s`.'
-
-        PREFERRED_VARS = {
-          '$:' => ['$LOAD_PATH'],
-          '$"' => ['$LOADED_FEATURES'],
-          '$0' => ['$PROGRAM_NAME'],
-          '$!' => ['$ERROR_INFO'],
-          '$@' => ['$ERROR_POSITION'],
-          '$;' => ['$FIELD_SEPARATOR', '$FS'],
-          '$,' => ['$OUTPUT_FIELD_SEPARATOR', '$OFS'],
-          '$/' => ['$INPUT_RECORD_SEPARATOR', '$RS'],
-          '$\\' => ['$OUTPUT_RECORD_SEPARATOR', '$ORS'],
-          '$.' => ['$INPUT_LINE_NUMBER', '$NR'],
-          '$_' => ['$LAST_READ_LINE'],
-          '$>' => ['$DEFAULT_OUTPUT'],
-          '$<' => ['$DEFAULT_INPUT'],
-          '$$' => ['$PROCESS_ID', '$PID'],
-          '$?' => ['$CHILD_STATUS'],
-          '$~' => ['$LAST_MATCH_INFO'],
-          '$=' => ['$IGNORECASE'],
-          '$*' => ['$ARGV', 'ARGV'],
-          '$&' => ['$MATCH'],
-          '$`' => ['$PREMATCH'],
-          '$\'' => ['$POSTMATCH'],
-          '$+' => ['$LAST_PAREN_MATCH']
-        }.symbolize_keys
-
-        # Anything *not* in this set is provided by the English library.
-        NON_ENGLISH_VARS = Set.new([
-          '$LOAD_PATH',
-          '$LOADED_FEATURES',
-          '$PROGRAM_NAME',
-          'ARGV'
-        ])
-
-        def on_gvar(node)
-          global_var, = *node
-
-          add_offense(node, :expression) if PREFERRED_VARS[global_var]
-        end
-
-        def message(node)
-          global_var, = *node
-
-          regular, english = PREFERRED_VARS[global_var].partition do |var|
-            NON_ENGLISH_VARS.include? var
-          end
-
-          # For now, we assume that lists are 2 items or less. Easy grammar!
-          regular_msg = regular.join('` or `')
-          english_msg = english.join('` or `')
-
-          if regular.length > 0 && english.length > 0
-            format(MSG_BOTH, english_msg, regular_msg, global_var)
-          elsif regular.length > 0
-            format(MSG_REGULAR, regular_msg, global_var)
-          elsif english.length > 0
-            format(MSG_ENGLISH, english_msg, global_var)
-          else
-            fail 'Bug in SpecialGlobalVars - global var w/o preferred vars!'
-          end
-        end
-
-        def autocorrect(node)
-          @corrections << lambda do |corrector|
-            global_var, = *node
-
-            corrector.replace(node.loc.expression,
-                              PREFERRED_VARS[global_var].first)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/string_literals.rb

@@ -1,43 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks if uses of quotes match the configured preference.
-      class StringLiterals < Cop
-        include ConfigurableEnforcedStyle
-        include StringHelp
-
-        private
-
-        def message(*)
-          if style == :single_quotes
-            "Prefer single-quoted strings when you don't need string " \
-            'interpolation or special symbols.'
-          else
-            'Prefer double-quoted strings unless you need single quotes to ' \
-            'avoid extra backslashes for escaping.'
-          end
-        end
-
-        def offense?(node)
-          src = node.loc.expression.source
-          return false if src =~ /^(%[qQ]?|\?|<<-)/i
-          if style == :single_quotes
-            src !~ /'/ && src !~ StringHelp::ESCAPED_CHAR_REGEXP
-          else
-            src !~ /" | \\/x
-          end
-        end
-
-        def autocorrect(node)
-          @corrections << lambda do |corrector|
-            replacement = node.loc.begin.is?('"') ? "'" : '"'
-            corrector.replace(node.loc.begin, replacement)
-            corrector.replace(node.loc.end, replacement)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/style/symbol_array.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for array literals made up of symbols
-      # that are not using the %i() syntax.
-      #
-      # This check makes sense only on Ruby 2.0+.
-      class SymbolArray < Cop
-        include ArraySyntax
-
-        MSG = 'Use %i or %I for array of symbols.'
-
-        def on_array(node)
-          # %i and %I were introduced in Ruby 2.0
-          return if RUBY_VERSION < '2.0.0'
-          add_offense(node, :expression) if array_of?(:sym, node)
-        end
-      end
-    end
-  end
-end