rubyjobbuilderdsl 0.0.0 → 0.0.1

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for uses of Perl-style regexp match
+      # backreferences like $1, $2, etc.
+      class PerlBackrefs < Cop
+        MSG = 'Avoid the use of Perl-style backrefs.'
+
+        def on_nth_ref(node)
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            backref, = *node
+
+            corrector.replace(node.loc.expression,
+                              "Regexp.last_match[#{backref}]")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop makes sure that predicates are named properly.
+      #
+      # @example
+      #   # bad
+      #   def is_even?(value) ...
+      #
+      #   # good
+      #   def even?(value)
+      #
+      #   # bad
+      #   def has_value? ...
+      #
+      #   # good
+      #   def value? ...
+      class PredicateName < Cop
+        include OnMethod
+
+        private
+
+        def on_method(node, method_name, _args, _body)
+          predicate_prefices.each do |prefix|
+            method_name = method_name.to_s
+            next unless method_name.start_with?(prefix)
+            next if method_name == expected_name(method_name, prefix)
+            add_offense(
+              node,
+              :name,
+              message(method_name, expected_name(method_name, prefix))
+            )
+          end
+        end
+
+        def expected_name(method_name, prefix)
+          new_name = if prefix_blacklist.include?(prefix)
+                       method_name.sub(prefix, '')
+                     else
+                       method_name.dup
+                     end
+          new_name << '?' unless method_name.end_with?('?')
+          new_name
+        end
+
+        def message(method_name, new_name)
+          "Rename `#{method_name}` to `#{new_name}`."
+        end
+
+        def prefix_blacklist
+          cop_config['NamePrefixBlacklist']
+        end
+
+        def predicate_prefices
+          cop_config['NamePrefix']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks for uses of Proc.new where Kernel#proc
+      # would be more appropriate.
+      class Proc < Cop
+        MSG = 'Use `proc` instead of `Proc.new`.'
+
+        TARGET = s(:send, s(:const, nil, :Proc), :new)
+
+        def on_block(node)
+          # We're looking for
+          # (block
+          #   (send
+          #     (const nil :Proc) :new)
+          #   ...)
+          block_method, = *node
+
+          add_offense(block_method, :expression) if block_method == TARGET
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.expression, 'proc')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks the args passed to `fail` and `raise`.
+      class RaiseArgs < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_send(node)
+          return unless command?(:raise, node) || command?(:fail, node)
+
+          case style
+          when :compact
+            check_compact(node)
+          when :exploded
+            check_exploded(node)
+          end
+        end
+
+        private
+
+        def check_compact(node)
+          _receiver, selector, *args = *node
+
+          if args.size > 1
+            add_offense(node, :expression, message(selector)) do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        def check_exploded(node)
+          _receiver, selector, *args = *node
+
+          if args.size == 1
+            arg, = *args
+
+            if arg.type == :send && arg.loc.selector.is?('new')
+              _receiver, _selector, *constructor_args = *arg
+
+              # Allow code like `raise Ex.new(arg1, arg2)`.
+              if constructor_args.size <= 1
+                add_offense(node, :expression, message(selector)) do
+                  opposite_style_detected
+                end
+              end
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        def message(method)
+          case style
+          when :compact
+            "Provide an exception object as an argument to `#{method}`."
+          when :exploded
+            'Provide an exception class and message as ' \
+            "arguments to `#{method}`."
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for redundant `begin` blocks.
+      #
+      # Currently it checks for code like this:
+      #
+      # @example
+      #
+      #   def test
+      #     begin
+      #       ala
+      #       bala
+      #     rescue StandardError => e
+      #       something
+      #     end
+      #   end
+      class RedundantBegin < Cop
+        include OnMethod
+
+        MSG = 'Redundant `begin` block detected.'
+
+        def on_method(_node, _method_name, _args, body)
+          return unless body && body.type == :kwbegin
+
+          add_offense(body, :begin)
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            child = node.children.first
+
+            begin_indent = node.loc.column
+            child_indent = child.loc.column
+
+            indent_diff = child_indent - begin_indent
+
+            corrector.replace(
+              range_with_surrounding_space(node.loc.expression),
+              range_with_surrounding_space(
+                child.loc.expression
+              ).source.gsub(/^[ \t]{#{indent_diff}}/, '')
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for RuntimeError as the argument of raise/fail.
+      #
+      # Currently it checks for code like this:
+      #
+      # @example
+      #
+      #   raise RuntimeError, 'message'
+      class RedundantException < Cop
+        MSG = 'Redundant `RuntimeError` argument can be removed.'
+
+        TARGET_NODE = s(:const, nil, :RuntimeError)
+
+        def on_send(node)
+          return unless command?(:raise, node) || command?(:fail, node)
+
+          _receiver, _selector, *args = *node
+
+          return unless args.size == 2
+
+          first_arg, = *args
+
+          add_offense(first_arg, :expression) if first_arg == TARGET_NODE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for redundant `return` expressions.
+      #
+      # @example
+      #
+      #   def test
+      #     return something
+      #   end
+      #
+      #   def test
+      #     one
+      #     two
+      #     three
+      #     return something
+      #   end
+      #
+      # It should be extended to handle methods whose body is if/else
+      # or a case expression with a default branch.
+      class RedundantReturn < Cop
+        include OnMethod
+
+        MSG = 'Redundant `return` detected.'
+
+        private
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            if node.children.size > 1
+              kids = node.children.map { |child| child.loc.expression }
+              corrector.insert_before(kids.first, '[')
+              corrector.insert_after(kids.last, ']')
+            end
+            return_kw = range_with_surrounding_space(node.loc.keyword, :right)
+            corrector.remove(return_kw)
+          end
+        end
+
+        def on_method(_node, _method_name, _args, body)
+          return unless body
+
+          if body.type == :return
+            check_return_node(body)
+          elsif body.type == :begin
+            expressions = *body
+            last_expr = expressions.last
+
+            if last_expr && last_expr.type == :return
+              check_return_node(last_expr)
+            end
+          end
+        end
+
+        def check_return_node(node)
+          return if cop_config['AllowMultipleReturnValues'] &&
+            node.children.size > 1
+
+          add_offense(node, :keyword)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for redundant uses of `self`.
+      #
+      # `self` is only needed when:
+      #
+      # * Sending a message to same object with zero arguments in
+      #   presence of a method name clash with an argument or a local
+      #   variable.
+      #
+      #   Note, with using explicit self you can only send messages
+      #   with public or protected scope, you cannot send private
+      #   messages this way.
+      #
+      #   Example:
+      #
+      #   def bar
+      #     :baz
+      #   end
+      #
+      #   def foo(bar)
+      #     self.bar # resolves name clash with argument
+      #   end
+      #
+      #   def foo2
+      #     bar = 1
+      #     self.bar # resolves name clash with local variable
+      #   end
+      #
+      # * Calling an attribute writer to prevent an local variable assignment
+      #
+      #   attr_writer :bar
+      #
+      #   def foo
+      #     self.bar= 1 # Make sure above attr writer is called
+      #   end
+      #
+      # Special cases:
+      #
+      # We allow uses of `self` with operators because it would be awkward
+      # otherwise.
+      class RedundantSelf < Cop
+        MSG = 'Redundant `self` detected.'
+
+        def initialize(config = nil, options = nil)
+          super
+          @allowed_send_nodes = []
+          @local_variables = []
+        end
+
+        # Assignment of self.x
+
+        def on_or_asgn(node)
+          lhs, _rhs = *node
+          allow_self(lhs)
+        end
+
+        alias_method :on_and_asgn, :on_or_asgn
+
+        def on_op_asgn(node)
+          lhs, _op, _rhs = *node
+          allow_self(lhs)
+        end
+
+        # Using self.x to distinguish from local variable x
+
+        def on_def(_node)
+          @local_variables = []
+        end
+
+        def on_defs(_node)
+          @local_variables = []
+        end
+
+        def on_args(node)
+          node.children.each { |arg| on_argument(arg) }
+        end
+
+        def on_blockarg(node)
+          on_argument(node)
+        end
+
+        def on_lvasgn(node)
+          lhs, _rhs = *node
+          @local_variables << lhs
+        end
+
+        # Detect offenses
+
+        def on_send(node)
+          receiver, method_name, *_args = *node
+          return unless receiver && receiver.type == :self
+          return if operator?(method_name) || keyword?(method_name) ||
+            constant_name?(method_name) ||
+            @allowed_send_nodes.include?(node) ||
+            @local_variables.include?(method_name)
+
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          receiver, _method_name, *_args = *node
+          @corrections << lambda do |corrector|
+            corrector.remove(receiver.loc.expression)
+            corrector.remove(node.loc.dot)
+          end
+        end
+
+        private
+
+        def on_argument(node)
+          name, _ = *node
+          @local_variables << name
+        end
+
+        def operator?(method_name)
+          method_name.to_s =~ /\W/
+        end
+
+        def keyword?(method_name)
+          [:alias, :and, :begin, :break, :case, :class, :def, :defined, :do,
+           :else, :elsif, :end, :ensure, :false, :for, :if, :in, :module,
+           :next, :nil, :not, :or, :redo, :rescue, :retry, :return, :self,
+           :super, :then, :true, :undef, :unless, :until, :when, :while,
+           :yield].include?(method_name)
+        end
+
+        def constant_name?(method_name)
+          method_name.match(/^[A-Z]/)
+        end
+
+        def allow_self(node)
+          return unless node.type == :send
+
+          receiver, _method_name, *_args = *node
+          @allowed_send_nodes << node if receiver && receiver.type == :self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for regexp literals and reports offenses based
+      # on how many escaped slashes there are in the regexp and on the
+      # value of the configuration parameter MaxSlashes.
+      class RegexpLiteral < Cop
+        class << self
+          attr_accessor :slash_count
+        end
+
+        def on_regexp(node)
+          string_parts = node.children.select { |child| child.type == :str }
+          total_string = string_parts.map { |s| s.loc.expression.source }.join
+          slashes = total_string.count('/')
+          delimiter_start = node.loc.begin.source[0]
+
+          if delimiter_start == '/'
+            if slashes > max_slashes
+              add_offense(node, :expression, error_message(''))
+            end
+          elsif slashes <= max_slashes
+            add_offense(node, :expression, error_message('only '))
+          end
+
+          configure_max(delimiter_start, slashes) if @options[:auto_gen_config]
+        end
+
+        private
+
+        def max_slashes
+          m = cop_config['MaxSlashes']
+          unless m.is_a?(Fixnum) && m >= 0
+            fail "Illegal value for MaxSlashes: #{m}"
+          end
+          m
+        end
+
+        def configure_max(delimiter_start, value)
+          self.class.slash_count ||= {
+            '/' => Set.new([0]),
+            '%' => Set.new([100_000])
+          }
+
+          self.class.slash_count[delimiter_start].add(value)
+
+          # To avoid reports, MaxSlashes must be set equal to the highest
+          # number of slashes used within //, and also one less than the
+          # highest number of slashes used within %r{}. If no value can satisfy
+          # both requirements, just disable.
+          max = self.class.slash_count['/'].max
+          min = self.class.slash_count['%'].min
+
+          self.config_to_allow_offenses = if max > max_slashes
+                                            if max < min
+                                              { 'MaxSlashes' => max }
+                                            else
+                                              { 'Enabled' => false }
+                                            end
+                                          elsif min < max_slashes + 1
+                                            if max < min
+                                              { 'MaxSlashes' => min - 1 }
+                                            else
+                                              { 'Enabled' => false }
+                                            end
+                                          end
+        end
+
+        def error_message(word)
+          format('Use %%r %sfor regular expressions matching more ' \
+                 "than %d '/' character%s.",
+                 word,
+                 max_slashes,
+                 max_slashes == 1 ? '' : 's')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of rescue in its modifier form.
+      class RescueModifier < Cop
+        include OnMethod
+
+        MSG = 'Avoid using `rescue` in its modifier form.'
+
+        def on_rescue(node)
+          return if ignored_node?(node)
+
+          add_offense(node, :expression)
+        end
+
+        def on_kwbegin(node)
+          body, *_ = *node
+          check(body)
+        end
+
+        def on_method(_node, _method_name, _args, body)
+          check(body)
+        end
+
+        def check(body)
+          return unless body
+
+          case body.type
+          when :rescue
+            ignore_node(body)
+          when :ensure
+            first_child = body.children.first
+            if first_child && first_child.type == :rescue
+              ignore_node(first_child)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use the shorthand for self-assignment.
+      #
+      # @example
+      #
+      #   # bad
+      #   x = x + 1
+      #
+      #   # good
+      #   x += 1
+      class SelfAssignment < Cop
+        include AST::Sexp
+
+        MSG = 'Use self-assignment shorthand `%s=`.'
+        OPS = [:+, :-, :*, :**, :/, :|, :&]
+
+        def on_lvasgn(node)
+          check(node, :lvar)
+        end
+
+        def on_ivasgn(node)
+          check(node, :ivar)
+        end
+
+        def on_cvasgn(node)
+          check(node, :cvar)
+        end
+
+        private
+
+        def check(node, var_type)
+          var_name, rhs = *node
+          return unless rhs
+
+          if rhs.type == :send
+            check_send_node(node, rhs, var_name, var_type)
+          elsif [:and, :or].include?(rhs.type)
+            check_boolean_node(node, rhs, var_name, var_type)
+          end
+        end
+
+        def check_send_node(node, rhs, var_name, var_type)
+          receiver, method_name, *_args = *rhs
+          return unless OPS.include?(method_name)
+
+          target_node = s(var_type, var_name)
+          return unless receiver == target_node
+
+          add_offense(node, :expression, format(MSG, method_name))
+        end
+
+        def check_boolean_node(node, rhs, var_name, var_type)
+          first_operand, _second_operand = *rhs
+
+          target_node = s(var_type, var_name)
+          return unless first_operand == target_node
+
+          operator = rhs.loc.operator.source
+          add_offense(node, :expression, format(MSG, operator))
+        end
+      end
+    end
+  end
+end