rubyjobbuilderdsl 0.0.2 → 0.0.3

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/lint/loop.rb

@@ -1,27 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for uses of *begin...end while/until something*.
-      class Loop < Cop
-        MSG = 'Use `Kernel#loop` with `break` rather than ' \
-              '`begin/end/until`(or `while`).'
-
-        def on_while_post(node)
-          register_offense(node)
-        end
-
-        def on_until_post(node)
-          register_offense(node)
-        end
-
-        private
-
-        def register_offense(node)
-          add_offense(node, :keyword)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb

@@ -1,51 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # Checks for space between a the name of a called method and a left
-      # parenthesis.
-      #
-      # @example
-      #
-      # puts (x + y)
-      class ParenthesesAsGroupedExpression < Cop
-        MSG = '`(...)` interpreted as grouped expression.'
-
-        def on_send(node)
-          _receiver, method_name, args = *node
-          return if operator?(method_name) || method_name.to_s.end_with?('=')
-          return unless args && args.loc.expression.source.start_with?('(')
-
-          space_length = spaces_before_left_parenthesis(node)
-          return unless space_length > 0
-          expr = args.loc.expression
-          space_range =
-            Parser::Source::Range.new(expr.source_buffer,
-                                      expr.begin_pos - space_length,
-                                      expr.begin_pos)
-
-          add_offense(nil, space_range)
-        end
-
-        private
-
-        def spaces_before_left_parenthesis(node)
-          receiver, method_name, _args = *node
-          receiver_length = if receiver
-                              receiver.loc.expression.source.length
-                            else
-                              0
-                            end
-          without_receiver = node.loc.expression.source[receiver_length..-1]
-
-          # Escape question mark if any.
-          method_regexp = Regexp.escape(method_name)
-
-          match = without_receiver.match(/^\s*\.?\s*#{method_regexp}(\s+)\(/)
-          match ? match.captures[0].length : 0
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/lint/require_parentheses.rb

@@ -1,68 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for expressions where there is a call to a predicate
-      # method with at least one argument, where no parentheses are used around
-      # the parameter list, and a boolean operator, && or ||, is used in the
-      # last argument.
-      #
-      # The idea behind warning for these constructs is that the user might
-      # be under the impression that the return value from the method call is
-      # an operand of &&/||.
-      #
-      # @example
-      #
-      # if day.is? :tuesday && month == :jan
-      #   ...
-      # end
-      class RequireParentheses < Cop
-        include IfNode
-
-        MSG = 'Use parentheses in the method call to avoid confusion about ' \
-              'precedence.'
-
-        def on_send(node)
-          _receiver, method_name, *args = *node
-
-          return if parentheses?(node)
-          return if args.empty?
-
-          if ternary_op?(args.first)
-            check_ternary(args.first, node)
-          else
-            # We're only checking predicate methods. There would be false
-            # positives otherwise.
-            check_send(args.last, node) if predicate?(method_name)
-          end
-        end
-
-        private
-
-        def check_ternary(arg, node)
-          condition, _, _ = *arg
-          return unless offense?(condition)
-
-          expr = node.loc.expression
-          range = Parser::Source::Range.new(expr.source_buffer,
-                                            expr.begin_pos,
-                                            condition.loc.expression.end_pos)
-          add_offense(range, range)
-        end
-
-        def check_send(arg, node)
-          add_offense(node, :expression) if offense?(arg)
-        end
-
-        def predicate?(method_name)
-          method_name =~ /\w\?$/
-        end
-
-        def offense?(node)
-          [:and, :or].include?(node.type)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/lint/rescue_exception.rb

@@ -1,35 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for *rescue* blocks targeting the Exception class.
-      class RescueException < Cop
-        MSG = 'Avoid rescuing the `Exception` class.'
-
-        def on_resbody(node)
-          return unless node.children.first
-          rescue_args = node.children.first.children
-          return unless rescue_args.any? { |a| targets_exception?(a) }
-
-          add_offense(node, :expression)
-        end
-
-        def targets_exception?(rescue_arg_node)
-          Util.const_name(rescue_arg_node) == 'Exception'
-        end
-
-        def autocorrect(node)
-          @corrections << lambda do |corrector|
-            corrector.remove(
-              range_with_surrounding_space(
-                node.children.first.children.first.loc.expression,
-                :left
-              )
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop looks for use of the same name as outer local variables
-      # for block arguments or block local variables.
-      # This is a mimic of the warning
-      # "shadowing outer local variable - foo" from `ruby -cw`.
-      class ShadowingOuterLocalVariable < Cop
-        MSG = 'Shadowing outer local variable - `%s`.'
-
-        def join_force?(force_class)
-          force_class == VariableForce
-        end
-
-        def before_declaring_variable(variable, variable_table)
-          return if variable.should_be_unused?
-
-          outer_local_variable = variable_table.find_variable(variable.name)
-          return unless outer_local_variable
-
-          message = format(MSG, variable.name)
-          add_offense(variable.declaration_node, :expression, message)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/lint/space_before_first_arg.rb

@@ -1,44 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # Checks for space between a method name and the first argument for
-      # method calls without parentheses.
-      #
-      # @example
-      #
-      #   something?x
-      #   something!x
-      #
-      class SpaceBeforeFirstArg < Cop
-        MSG = 'Put space between the method name and the first argument.'
-
-        def on_send(node)
-          return if parentheses?(node)
-
-          _receiver, method_name, *args = *node
-          return if args.empty?
-          return if operator?(method_name)
-          return if method_name.to_s.end_with?('=')
-
-          # Setter calls with parentheses are parsed this way. The parentheses
-          # belong to the argument, not the send node.
-          return if args.first.type == :begin
-
-          arg1 = args.first.loc.expression
-          arg1_with_space = range_with_surrounding_space(arg1, :left)
-          space = Parser::Source::Range.new(arg1.source_buffer,
-                                            arg1_with_space.begin_pos,
-                                            arg1.begin_pos)
-
-          add_offense(space, arg1) if arg1_with_space.source =~ /\A\S/
-        end
-
-        def autocorrect(range)
-          @corrections << ->(corrector) { corrector.insert_before(range, ' ') }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/lint/string_conversion_in_interpolation.rb

@@ -1,50 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for string conversion in string interpolation,
-      # which is redundant.
-      #
-      # @example
-      #
-      #   "result is #{something.to_s}"
-      class StringConversionInInterpolation < Cop
-        MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'
-        MSG_SELF = 'Use `self` instead of `Object#to_s` in interpolation.'
-
-        def on_dstr(node)
-          node.children.select { |n| n.type == :begin }.each do |begin_node|
-            final_node = begin_node.children.last
-            next unless final_node && final_node.type == :send
-
-            receiver, method_name, *args = *final_node
-            next unless method_name == :to_s && args.empty?
-
-            add_offense(
-              final_node,
-              :selector,
-              receiver ? MSG_DEFAULT : MSG_SELF
-            )
-          end
-        end
-
-        private
-
-        def autocorrect(node)
-          @corrections << lambda do |corrector|
-            receiver, _method_name, *_args = *node
-            corrector.replace(
-              node.loc.expression,
-              if receiver
-                receiver.loc.expression.source
-              else
-                'self'
-              end
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/lint/syntax.rb

@@ -1,52 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This is actually not a cop and inspects nothing. It just provides
-      # methods to repack Parser's diagnostics/errors into RuboCop's offenses.
-      module Syntax
-        PseudoSourceRange = Struct.new(:line, :column, :source_line)
-
-        COP_NAME = 'Syntax'.freeze
-        ERROR_SOURCE_RANGE = PseudoSourceRange.new(1, 0, '').freeze
-
-        def self.offenses_from_processed_source(processed_source)
-          offenses = []
-
-          if processed_source.parser_error
-            offenses << offense_from_error(processed_source.parser_error)
-          end
-
-          processed_source.diagnostics.each do |diagnostic|
-            offenses << offense_from_diagnostic(diagnostic)
-          end
-
-          offenses
-        end
-
-        def self.offense_from_diagnostic(diagnostic)
-          Offense.new(
-            diagnostic.level,
-            diagnostic.location,
-            diagnostic.message,
-            COP_NAME
-          )
-        end
-
-        def self.offense_from_error(error)
-          message = beautify_message(error.message)
-          Offense.new(:fatal, ERROR_SOURCE_RANGE, message, COP_NAME)
-        end
-
-        def self.beautify_message(message)
-          message = message.capitalize
-          message << '.' unless message.end_with?('.')
-          message
-        end
-
-        private_class_method :beautify_message
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb

@@ -1,39 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for underscore-prefixed variables that are actually
-      # used.
-      class UnderscorePrefixedVariableName < Cop
-        MSG = 'Do not use prefix `_` for a variable that is used.'
-
-        def join_force?(force_class)
-          force_class == VariableForce
-        end
-
-        def after_leaving_scope(scope, _variable_table)
-          scope.variables.each_value do |variable|
-            check_variable(variable)
-          end
-        end
-
-        def check_variable(variable)
-          return unless variable.should_be_unused?
-          return if variable.references.empty?
-          return if variable.references.none?(&:explicit?)
-
-          node = variable.declaration_node
-
-          location = if node.type == :match_with_lvasgn
-                       node.children.first.loc.expression
-                     else
-                       node.loc.name
-                     end
-
-          add_offense(nil, location)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/lint/unreachable_code.rb

@@ -1,32 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for unreachable code.
-      # The check are based on the presence of flow of control
-      # statement in non-final position in *begin*(implicit) blocks.
-      class UnreachableCode < Cop
-        MSG = 'Unreachable code detected.'
-
-        NODE_TYPES = [:return, :next, :break, :retry, :redo]
-        FLOW_COMMANDS = [:throw, :raise, :fail]
-
-        def on_begin(node)
-          expressions = *node
-
-          expressions.each_cons(2) do |e1, e2|
-            next unless NODE_TYPES.include?(e1.type) || flow_command?(e1)
-            add_offense(e2, :expression)
-          end
-        end
-
-        private
-
-        def flow_command?(node)
-          FLOW_COMMANDS.any? { |c| command?(c, node) }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/lint/unused_block_argument.rb

@@ -1,80 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for unused block arguments.
-      #
-      # @example
-      #
-      #   do_something do |used, unused, _unused_but_allowed|
-      #     puts used
-      #   end
-      class UnusedBlockArgument < Cop
-        include UnusedArgument
-        include Util
-
-        def check_argument(variable)
-          return unless variable.block_argument?
-          super
-        end
-
-        def message(variable)
-          message = "Unused #{variable_type(variable)} - `#{variable.name}`."
-
-          return message if variable.explicit_block_local_variable?
-
-          message << ' '
-
-          scope = variable.scope
-          all_arguments = scope.variables.each_value.select(&:block_argument?)
-
-          if lambda?(scope.node)
-            message << message_for_lambda(variable, all_arguments)
-          else
-            message << message_for_normal_block(variable, all_arguments)
-          end
-
-          message
-        end
-
-        def variable_type(variable)
-          if variable.explicit_block_local_variable?
-            'block local variable'
-          else
-            'block argument'
-          end
-        end
-
-        def message_for_normal_block(variable, all_arguments)
-          if all_arguments.none?(&:referenced?)
-            if all_arguments.count > 1
-              "You can omit all the arguments if you don't care about them."
-            else
-              "You can omit the argument if you don't care about it."
-            end
-          else
-            message_for_underscore_prefix(variable)
-          end
-        end
-
-        def message_for_lambda(variable, all_arguments)
-          message = message_for_underscore_prefix(variable)
-
-          if all_arguments.none?(&:referenced?)
-            message << ' Also consider using a proc without arguments ' \
-                       'instead of a lambda if you want it ' \
-                        "to accept any arguments but don't care about them."
-          end
-
-          message
-        end
-
-        def message_for_underscore_prefix(variable)
-          "If it's necessary, use `_` or `_#{variable.name}` " \
-          "as an argument name to indicate that it won't be used."
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/lint/unused_method_argument.rb

@@ -1,43 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for unused method arguments.
-      #
-      # @example
-      #
-      #   def some_method(used, unused, _unused_but_allowed)
-      #     puts used
-      #   end
-      class UnusedMethodArgument < Cop
-        include UnusedArgument
-
-        def check_argument(variable)
-          return unless variable.method_argument?
-          super
-        end
-
-        def message(variable)
-          message = "Unused method argument - `#{variable.name}`."
-
-          unless variable.keyword_argument?
-            message << " If it's necessary, use `_` or `_#{variable.name}` " \
-                       "as an argument name to indicate that it won't be used."
-          end
-
-          scope = variable.scope
-          all_arguments = scope.variables.each_value.select(&:method_argument?)
-
-          if all_arguments.none?(&:referenced?)
-            message << " You can also write as `#{scope.name}(*)` " \
-                       'if you want the method to accept any arguments ' \
-                       "but don't care about them."
-          end
-
-          message
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -1,59 +0,0 @@
-# encoding: utf-8
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for access modifiers without any code.
-      #
-      # @example
-      #   class Foo
-      #     private # This is useless
-      #
-      #     def self.some_method
-      #     end
-      #   end
-      class UselessAccessModifier < Cop
-        include AccessModifierNode
-
-        MSG = 'Useless `%s` access modifier.'
-
-        def on_class(node)
-          _name, _base_class, body = *node
-          return unless body
-
-          body_nodes = body.type == :begin ? body.children : [body]
-
-          body_nodes.each do |child_node|
-            check_for_access_modifier(child_node) ||
-            check_for_instance_method(child_node)
-          end
-
-          add_offense_for_access_modifier
-        end
-
-        private
-
-        def add_offense_for_access_modifier
-          return unless @access_modifier_node
-
-          _, modifier = *@access_modifier_node
-          message = format(MSG, modifier)
-          add_offense(@access_modifier_node, :expression, message)
-        end
-
-        def check_for_instance_method(node)
-          return unless node.type == :def ||
-            node.type == :send
-
-          @access_modifier_node = nil
-        end
-
-        def check_for_access_modifier(node)
-          return unless modifier_node?(node)
-
-          add_offense_for_access_modifier
-          @access_modifier_node = node
-        end
-      end
-    end
-  end
-end