rubyjobbuilderdsl 0.0.0 → 0.0.1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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