rubyjobbuilderdsl 0.0.2 → 0.0.3

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

@@ -1,52 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for conditions that are not on the same line as
-      # if/while/until.
-      #
-      # @example
-      #
-      #   if
-      #     some_condition
-      #     do_something
-      #   end
-      class ConditionPosition < Cop
-        def on_if(node)
-          return if node.loc.respond_to?(:question)
-
-          check(node)
-        end
-
-        def on_while(node)
-          check(node)
-        end
-
-        def on_until(node)
-          check(node)
-        end
-
-        private
-
-        def check(node)
-          return if !node.loc.keyword.is?('elsif') && node.loc.end.nil?
-
-          condition, = *node
-          return unless on_different_line?(node.loc.keyword.line,
-                                           condition.loc.expression.line)
-
-          add_offense(condition, :expression, message(node.loc.keyword.source))
-        end
-
-        def message(keyword)
-          "Place the condition on the same line as `#{keyword}`."
-        end
-
-        def on_different_line?(keyword_line, cond_line)
-          keyword_line != cond_line
-        end
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for calls to debugger or pry.
-      class Debugger < Cop
-        MSG = 'Remove debugger entry point `%s`.'
-
-        # debugger call node
-        #
-        # (send nil :debugger)
-        DEBUGGER_NODE = s(:send, nil, :debugger)
-
-        # byebug call node
-        #
-        # (send nil :byebug)
-        BYEBUG_NODE = s(:send, nil, :byebug)
-
-        # binding.pry node
-        #
-        # (send
-        #   (send nil :binding) :pry)
-        PRY_NODE = s(:send, s(:send, nil, :binding), :pry)
-
-        # binding.remote_pry node
-        #
-        # (send
-        #   (send nil :binding) :remote_pry)
-        REMOTE_PRY_NODE = s(:send, s(:send, nil, :binding), :remote_pry)
-
-        # binding.pry_remote node
-        #
-        # (send
-        #   (send nil :binding) :pry_remote)
-        PRY_REMOTE_NODE = s(:send, s(:send, nil, :binding), :pry_remote)
-
-        DEBUGGER_NODES = [
-          DEBUGGER_NODE,
-          BYEBUG_NODE,
-          PRY_NODE,
-          REMOTE_PRY_NODE,
-          PRY_REMOTE_NODE
-        ]
-
-        def on_send(node)
-          return unless DEBUGGER_NODES.include?(node)
-          add_offense(node,
-                      :expression,
-                      format(MSG, node.loc.expression.source))
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks whether the end keywords of method definitions are
-      # aligned properly.
-      #
-      # Two modes are supported through the AlignWith configuration
-      # parameter. If it's set to `start_of_line` (which is the default), the
-      # `end` shall be aligned with the start of the line where the `def`
-      # keyword is. If it's set to `def`, the `end` shall be aligned with the
-      # `def` keyword.
-      #
-      # @example
-      #
-      #   private def foo
-      #   end
-      class DefEndAlignment < Cop
-        include OnMethod
-        include EndKeywordAlignment
-
-        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d'
-
-        def on_method(node, _method_name, _args, _body)
-          check_offset_of_node(node)
-        end
-
-        def on_send(node)
-          receiver, method_name, *args = *node
-          return unless visibility_and_def_on_same_line?(receiver, method_name,
-                                                         args)
-
-          method_def = args.first
-          if style == :start_of_line
-            expr = node.loc.expression
-            range = Parser::Source::Range.new(expr.source_buffer,
-                                              expr.begin_pos,
-                                              method_def.loc.keyword.end_pos)
-            check_offset(method_def, range.source,
-                         method_def.loc.keyword.begin_pos - expr.begin_pos)
-          else
-            check_offset(method_def, 'def', 0)
-          end
-
-          ignore_node(method_def) # Don't check the same `end` again.
-        end
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for uses of the deprecated class method usages.
-      class DeprecatedClassMethods < Cop
-        include AST::Sexp
-
-        MSG = '`%s` is deprecated in favor of `%s`.'
-
-        DEPRECATED_METHODS = [
-          [:File, :exists?, :exist?],
-          [:Dir, :exists?, :exist?]
-        ]
-
-        def on_send(node)
-          receiver, method_name, *_args = *node
-
-          DEPRECATED_METHODS.each do |data|
-            next unless class_nodes(data).include?(receiver)
-            next unless method_name == data[1]
-
-            add_offense(node, :selector,
-                        format(MSG,
-                               deprecated_method(data),
-                               replacement_method(data)))
-          end
-        end
-
-        def autocorrect(node)
-          @corrections << lambda do |corrector|
-            receiver, method_name, *_args = *node
-
-            DEPRECATED_METHODS.each do |data|
-              next unless class_nodes(data).include?(receiver)
-              next unless method_name == data[1]
-
-              corrector.replace(node.loc.selector,
-                                data[2].to_s)
-            end
-          end
-        end
-
-        private
-
-        def class_nodes(data)
-          [s(:const, nil, data[0]),
-           s(:const, s(:cbase), data[0])]
-        end
-
-        def deprecated_method(data)
-          format('%s.%s', data[0], data[1])
-        end
-
-        def replacement_method(data)
-          format('%s.%s', data[0], data[2])
-        end
-      end
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for odd else block layout - like
-      # having an expression on the same line as the else keyword,
-      # which is usually a mistake.
-      #
-      # @example
-      #
-      #   if something
-      #     ...
-      #   else do_this
-      #     do_that
-      #   end
-      class ElseLayout < Cop
-        def on_if(node)
-          # ignore ternary ops
-          return if node.loc.respond_to?(:question)
-          # ignore modifier ops & elsif nodes
-          return unless node.loc.end
-
-          check(node)
-        end
-
-        private
-
-        def check(node)
-          return unless node
-
-          if node.loc.respond_to?(:else) &&
-             node.loc.else &&
-             node.loc.else.is?('else')
-            _cond, _if_branch, else_branch = *node
-
-            return unless else_branch && else_branch.type == :begin
-
-            first_else_expr = else_branch.children.first
-
-            if first_else_expr.loc.expression.line == node.loc.else.line
-              add_offense(first_else_expr, :expression, message)
-            end
-          elsif node.loc.respond_to?(:keyword) &&
-                %w(if elsif).include?(node.loc.keyword.source)
-            _cond, _if_branch, else_branch = *node
-            check(else_branch)
-          end
-        end
-
-        def message
-          'Odd `else` layout detected. Did you mean to use `elsif`?'
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for empty `ensure` blocks
-      class EmptyEnsure < Cop
-        MSG = 'Empty `ensure` block detected.'
-
-        def on_ensure(node)
-          _body, ensure_body = *node
-
-          add_offense(node, :keyword) unless ensure_body
-        end
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for empty interpolation.
-      #
-      # @example
-      #
-      #   "result is #{}"
-      class EmptyInterpolation < Cop
-        MSG = 'Empty interpolation detected.'
-
-        def on_dstr(node)
-          node.children.select { |n| n.type == :begin }.each do |begin_node|
-            add_offense(begin_node, :expression) if begin_node.children.empty?
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks whether the end keywords are aligned properly.
-      #
-      # Two modes are supported through the AlignWith configuration
-      # parameter. If it's set to `keyword` (which is the default), the `end`
-      # shall be aligned with the start of the keyword (if, class, etc.). If
-      # it's set to `variable` the `end` shall be aligned with the
-      # left-hand-side of the variable assignment, if there is one.
-      #
-      # @example
-      #
-      #   variable = if true
-      #              end
-      class EndAlignment < Cop
-        include CheckAssignment
-        include EndKeywordAlignment
-        include IfNode
-
-        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d'
-
-        def on_class(node)
-          check_offset_of_node(node)
-        end
-
-        def on_module(node)
-          check_offset_of_node(node)
-        end
-
-        def on_if(node)
-          check_offset_of_node(node) unless ternary_op?(node)
-        end
-
-        def on_while(node)
-          check_offset_of_node(node)
-        end
-
-        def on_until(node)
-          check_offset_of_node(node)
-        end
-
-        private
-
-        def check_assignment(node, rhs)
-          # If there are method calls chained to the right hand side of the
-          # assignment, we let rhs be the receiver of those method calls before
-          # we check if it's an if/unless/while/until.
-          rhs = first_part_of_call_chain(rhs)
-
-          return unless rhs
-
-          return unless [:if, :while, :until].include?(rhs.type)
-          return if ternary_op?(rhs)
-
-          if style == :variable
-            expr = node.loc.expression
-            range = Parser::Source::Range.new(expr.source_buffer,
-                                              expr.begin_pos,
-                                              rhs.loc.keyword.end_pos)
-            offset = rhs.loc.keyword.column - node.loc.expression.column
-          else
-            range = rhs.loc.keyword
-            offset = 0
-          end
-
-          check_offset(rhs, range.source, offset)
-          ignore_node(rhs) # Don't check again.
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for END blocks in method definitions.
-      class EndInMethod < Cop
-        MSG = '`END` found in method definition. Use `at_exit` instead.'
-
-        def on_postexe(node)
-          inside_of_method = node.each_ancestor(:def, :defs).count.nonzero?
-          add_offense(node, :keyword) if inside_of_method
-        end
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for *return* from an *ensure* block.
-      class EnsureReturn < Cop
-        MSG = 'Never return from an `ensure` block.'
-
-        def on_ensure(node)
-          _body, ensure_body = *node
-
-          return unless ensure_body
-
-          ensure_body.each_node(:return) do |return_node|
-            add_offense(return_node, :expression)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for the use of *Kernel#eval*.
-      class Eval < Cop
-        MSG = 'The use of `eval` is a serious security risk.'
-
-        def on_send(node)
-          receiver, method_name, = *node
-
-          add_offense(node, :selector) if receiver.nil? && method_name == :eval
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for *rescue* blocks with no body.
-      class HandleExceptions < Cop
-        MSG = 'Do not suppress exceptions.'
-
-        def on_resbody(node)
-          _exc_list_node, _exc_var_node, body_node = *node
-
-          add_offense(node, :expression) unless body_node
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for invalid character literals with a non-escaped
-      # whitespace character (e.g. `? `).
-      # However, currently it's unclear whether there's a way to emit this
-      # warning without syntax errors.
-      #
-      #     $ ruby -w
-      #     p(? )
-      #     -:1: warning: invalid character syntax; use ?\s
-      #     -:1: syntax error, unexpected '?', expecting ')'
-      #     p(? )
-      #        ^
-      #
-      # @example
-      #   p(? )
-      class InvalidCharacterLiteral < Cop
-        include ParserDiagnostic
-
-        private
-
-        def relevant_diagnostic?(diagnostic)
-          diagnostic.reason == :invalid_escape_use
-        end
-
-        def alternative_message(diagnostic)
-          diagnostic.message
-            .capitalize
-            .gsub('character syntax', 'character literal')
-        end
-      end
-    end
-  end
-end

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

@@ -1,138 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for literals used as the conditions or as
-      # operands in and/or expressions serving as the conditions of
-      # if/while/until.
-      #
-      # @example
-      #
-      #   if 20
-      #     do_something
-      #   end
-      #
-      #   if some_var && true
-      #     do_something
-      #   end
-      #
-      class LiteralInCondition < Cop
-        MSG = 'Literal `%s` appeared in a condition.'
-
-        LITERALS = [:str, :dstr, :int, :float, :array,
-                    :hash, :regexp, :nil, :true, :false]
-
-        BASIC_LITERALS = LITERALS - [:dstr, :array, :hash]
-
-        def on_if(node)
-          check_for_literal(node)
-        end
-
-        def on_while(node)
-          check_for_literal(node)
-        end
-
-        def on_while_post(node)
-          check_for_literal(node)
-        end
-
-        def on_until(node)
-          check_for_literal(node)
-        end
-
-        def on_until_post(node)
-          check_for_literal(node)
-        end
-
-        def on_case(node)
-          cond, *whens, _else = *node
-
-          if cond
-            check_case_cond(cond)
-          else
-            whens.each do |when_node|
-              check_for_literal(when_node)
-            end
-          end
-        end
-
-        def message(node)
-          format(MSG, node.loc.expression.source)
-        end
-
-        private
-
-        def check_for_literal(node)
-          cond, = *node
-
-          # if the cond node is literal we obviously have a problem
-          if literal?(cond)
-            add_offense(cond, :expression)
-          else
-            # alternatively we have to consider a logical node with a
-            # literal argument
-            check_node(cond)
-          end
-        end
-
-        def not?(node)
-          return false unless node && node.type == :send
-
-          _receiver, method_name, *_args = *node
-
-          method_name == :!
-        end
-
-        def literal?(node)
-          LITERALS.include?(node.type)
-        end
-
-        def basic_literal?(node)
-          if node && node.type == :array
-            primitive_array?(node)
-          else
-            BASIC_LITERALS.include?(node.type)
-          end
-        end
-
-        def primitive_array?(node)
-          node.children.all? { |n| basic_literal?(n) }
-        end
-
-        def check_node(node)
-          return unless node
-
-          if not?(node)
-            receiver, = *node
-
-            handle_node(receiver)
-          elsif [:and, :or].include?(node.type)
-            *operands = *node
-            operands.each do |op|
-              handle_node(op)
-            end
-          elsif node.type == :begin && node.children.size == 1
-            child_node = node.children.first
-            handle_node(child_node)
-          end
-        end
-
-        def handle_node(node)
-          if literal?(node)
-            add_offense(node, :expression)
-          elsif [:send, :and, :or, :begin].include?(node.type)
-            check_node(node)
-          end
-        end
-
-        def check_case_cond(node)
-          return if node.type == :array && !primitive_array?(node)
-          return if node.type == :dstr
-
-          handle_node(node)
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for interpolated literals.
-      #
-      # @example
-      #
-      #   "result is #{10}"
-      class LiteralInInterpolation < Cop
-        LITERALS = [:str, :dstr, :int, :float, :array,
-                    :hash, :regexp, :nil, :true, :false]
-
-        MSG = 'Literal interpolation detected.'
-
-        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
-            # handle strings like __FILE__
-            return if special_string?(final_node)
-            next unless LITERALS.include?(final_node.type)
-
-            add_offense(final_node, :expression)
-          end
-        end
-
-        private
-
-        def special_string?(node)
-          node.type == :str && !node.loc.respond_to?(:begin)
-        end
-      end
-    end
-  end
-end