rubyjobbuilderdsl 0.0.0 → 0.0.1

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

@@ -0,0 +1,27 @@
+# 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

@@ -0,0 +1,51 @@
+# 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

@@ -0,0 +1,68 @@
+# 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

@@ -0,0 +1,35 @@
+# 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

@@ -0,0 +1,29 @@
+# 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

@@ -0,0 +1,44 @@
+# 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

@@ -0,0 +1,50 @@
+# 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

@@ -0,0 +1,52 @@
+# 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

@@ -0,0 +1,39 @@
+# 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

@@ -0,0 +1,32 @@
+# 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

@@ -0,0 +1,80 @@
+# 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

@@ -0,0 +1,43 @@
+# 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

@@ -0,0 +1,59 @@
+# 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