rubyjobbuilderdsl 0.0.0 → 0.0.1

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether comments have a leading space
+      # after the # denoting the start of the comment. The
+      # leading space is not required for some RDoc special syntax,
+      # like #++, #--, #:nodoc, etc.
+      class LeadingCommentSpace < Cop
+        MSG = 'Missing space after #.'
+
+        def investigate(processed_source)
+          processed_source.comments.each do |comment|
+            next unless comment.text =~ /^#+[^#\s:+-]/
+            next if comment.text.start_with?('#!') && comment.loc.line == 1
+
+            add_offense(comment, :expression)
+          end
+        end
+
+        def autocorrect(comment)
+          expr = comment.loc.expression
+          b = expr.begin_pos
+          hash_mark = Parser::Source::Range.new(expr.source_buffer, b, b + 1)
+          @corrections << lambda do |corrector|
+            corrector.insert_after(hash_mark, ' ')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for string literal concatenation at
+      # the end of a line.
+      #
+      # @example
+      #
+      #   # bad
+      #   some_str = 'ala' +
+      #              'bala'
+      #
+      #   some_str = 'ala' <<
+      #              'bala'
+      #
+      #   # good
+      #   some_str = 'ala' \
+      #              'bala'
+      #
+      class LineEndConcatenation < Cop
+        MSG = 'Use `\\` instead of `+` or `<<` to concatenate those strings.'
+
+        def on_send(node)
+          add_offense(node, :selector) if offending_node?(node)
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            # replace + with \
+            corrector.replace(node.loc.selector, '\\')
+          end
+        end
+
+        private
+
+        def concat?(method)
+          [:+, :<<].include?(method)
+        end
+
+        def offending_node?(node)
+          receiver, method, first_arg = *node
+
+          return false unless concat?(method)
+
+          return false unless final_node_is_string_type?(receiver)
+
+          return false unless root_node_is_string_type?(first_arg)
+
+          expression = node.loc.expression.source
+          concatenator_at_line_end?(expression)
+        end
+
+        def concatenator_at_line_end?(expression)
+          # check if the first line of the expression ends with a + or a <<
+          expression =~ /.+(\+|<<)\s*$/
+        end
+
+        def string_type?(node)
+          return false unless [:str, :dstr].include?(node.type)
+          # strings like __FILE__ are of no interest
+          return false unless node.loc.respond_to?(:begin)
+
+          # we care only about quotes-delimited literals
+          node.loc.begin && ["'", '"'].include?(node.loc.begin.source)
+        end
+
+        def final_node_is_string_type?(node)
+          if node.type == :send
+            _, method, first_arg = *node
+            concat?(method) && final_node_is_string_type?(first_arg)
+          else
+            string_type?(node)
+          end
+        end
+
+        def root_node_is_string_type?(node)
+          if node.type == :send
+            receiver, method, _ = *node
+            concat?(method) && root_node_is_string_type?(receiver)
+          else
+            string_type?(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for unwanted parentheses in parameterless method calls.
+      class MethodCallParentheses < Cop
+        MSG = 'Do not use parentheses for method calls with no arguments.'
+
+        def on_send(node)
+          _receiver, method_name, *args = *node
+
+          # methods starting with a capital letter should be skipped
+          return if method_name =~ /\A[A-Z]/
+
+          add_offense(node, :begin) if args.empty? && node.loc.begin
+        end
+
+        def autocorrect(node)
+          # Bail out if the call is going to be auto-corrected by EmptyLiteral.
+          if config.for_cop('Style/EmptyLiteral')['Enabled'] &&
+              [EmptyLiteral::HASH_NODE,
+               EmptyLiteral::ARRAY_NODE,
+               EmptyLiteral::STR_NODE].include?(node)
+            return
+          end
+          @corrections << lambda do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for methods called on a do...end block. The point of
+      # this check is that it's easy to miss the call tacked on to the block
+      # when reading code.
+      #
+      # @example
+      #
+      # a do
+      #   b
+      # end.c
+      class MethodCalledOnDoEndBlock < Cop
+        MSG = 'Avoid chaining a method call on a do...end block.'
+
+        def on_block(node)
+          method, _args, _body = *node
+          # If the method that is chained on the do...end block is itself a
+          # method with a block, we allow it. It's pretty safe to assume that
+          # these calls are not missed by anyone reading code. We also want to
+          # avoid double reporting of offenses checked by the
+          # MultilineBlockChain cop.
+          ignore_node(method)
+        end
+
+        def on_send(node)
+          return if ignored_node?(node)
+          receiver, _method_name, *_args = *node
+          return unless receiver && receiver.type == :block &&
+            receiver.loc.end.is?('end')
+
+          range = Parser::Source::Range.new(receiver.loc.end.source_buffer,
+                                            receiver.loc.end.begin_pos,
+                                            node.loc.expression.end_pos)
+          add_offense(nil, range)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks for parentheses around the arguments in method
+      # definitions. Both instance and class/singleton methods are checked.
+      class MethodDefParentheses < Cop
+        include OnMethod
+        include ConfigurableEnforcedStyle
+
+        def on_method(node, _method_name, args, _body)
+          if style == :require_parentheses
+            if arguments?(args) && !parentheses?(args)
+              add_offense(node,
+                          args.loc.expression,
+                          'Use def with parentheses when there are ' \
+                          'parameters.') do
+                opposite_style_detected
+              end
+            else
+              correct_style_detected
+            end
+          elsif parentheses?(args)
+            add_offense(args, :expression, 'Use def without parentheses.') do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            if style == :require_parentheses
+              args_expr = args_node(node).loc.expression
+              args_with_space = range_with_surrounding_space(args_expr, :left)
+              just_space = Parser::Source::Range.new(args_expr.source_buffer,
+                                                     args_with_space.begin_pos,
+                                                     args_expr.begin_pos)
+              corrector.replace(just_space, '(')
+              corrector.insert_after(args_expr, ')')
+            elsif style == :require_no_parentheses
+              corrector.replace(node.loc.begin, ' ')
+              corrector.remove(node.loc.end)
+            end
+          end
+        end
+
+        private
+
+        def args_node(def_node)
+          if def_node.type == :def
+            _method_name, args, _body = *def_node
+            args
+          else
+            _scope, _method_name, args, _body = *def_node
+            args
+          end
+        end
+
+        def arguments?(args)
+          args.children.size > 0
+        end
+
+        def parentheses?(args)
+          args.loc.begin
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop makes sure that all methods use the configured style,
+      # snake_case or camelCase, for their names. Some special arrangements
+      # have to be made for operator methods.
+      class MethodName < Cop
+        include ConfigurableNaming
+
+        def on_def(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
+        def on_defs(node)
+          _object, name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
+        def message(style)
+          format('Use %s for methods.', style)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks for use of `extend self` in a module.
+      #
+      # @example
+      #
+      # module Test
+      #   extend self
+      #
+      #   ...
+      # end
+      class ModuleFunction < Cop
+        MSG = 'Use `module_function` instead of `extend self`.'
+
+        TARGET_NODE = s(:send, nil, :extend, s(:self))
+
+        def on_module(node)
+          _name, body = *node
+          return unless body && body.type == :begin
+
+          body.children.each do |body_node|
+            add_offense(body_node, :expression) if body_node == TARGET_NODE
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for chaining of a block after another block that spans
+      # multiple lines.
+      #
+      # @example
+      #
+      #   Thread.list.find_all do |t|
+      #     t.alive?
+      #   end.map do |t|
+      #     t.object_id
+      #   end
+      class MultilineBlockChain < Cop
+        MSG = 'Avoid multi-line chains of blocks.'
+
+        def on_block(node)
+          method, _args, _body = *node
+          method.each_node(:send) do |send_node|
+            receiver, _method_name, *_args = *send_node
+            next unless receiver && receiver.type == :block
+
+            # The begin and end could also be braces, but we call the
+            # variables do... and end...
+            do_kw_loc, end_kw_loc = receiver.loc.begin, receiver.loc.end
+            next if do_kw_loc.line == end_kw_loc.line
+
+            range =
+              Parser::Source::Range.new(end_kw_loc.source_buffer,
+                                        end_kw_loc.begin_pos,
+                                        method.loc.expression.end_pos)
+            add_offense(nil, range)
+            # Done. If there are more blocks in the chain, they will be
+            # found by subsequent calls to on_block.
+            break
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether the multiline do end blocks have a newline
+      # after the start of the block.
+      #
+      # @example
+      #   # bad
+      #   blah do |i| foo(i)
+      #     bar(i)
+      #   end
+      #
+      #   # good
+      #   blah do |i|
+      #     foo(i)
+      #     bar(i)
+      #   end
+      #
+      #   # bad
+      #   blah { |i| foo(i)
+      #     bar(i)
+      #   }
+      #
+      #   # good
+      #   blah { |i|
+      #     foo(i)
+      #     bar(i)
+      #   }
+      class MultilineBlockLayout < Cop
+        MSG = 'Block body expression is on the same line as the block start.'
+
+        def on_block(node)
+          end_loc = node.loc.end
+          do_loc = node.loc.begin # Actually it's either do or {.
+          return if do_loc.line == end_loc.line # One-liner, no newline needed.
+
+          # A block node has three children: the block start,
+          # the arguments, and the expression. We care if the block start
+          # and the expression start on the same line.
+          last_expression = node.children.last
+          return unless last_expression
+          expression_loc = last_expression.loc
+          return unless do_loc.line == expression_loc.line
+
+          expression = last_expression.loc.expression
+          range = Parser::Source::Range.new(expression.source_buffer,
+                                            expression.begin_pos,
+                                            expression.end_pos)
+
+          add_offense(node, range)
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            _method, _args, block_body = *node
+            first_node = if block_body.type == :begin
+                           block_body.children.first
+                         else
+                           block_body
+                         end
+
+            block_start_col = node.loc.expression.column
+
+            corrector.insert_before(first_node.loc.expression,
+                                    "\n  #{' ' * block_start_col}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of the `then` keyword in multi-line if statements.
+      #
+      # @example This is considered bad practice:
+      #
+      #   if cond then
+      #   end
+      #
+      # @example If statements can contain `then` on the same line:
+      #
+      #   if cond then a
+      #   elsif cond then b
+      #   end
+      class MultilineIfThen < Cop
+        include IfNode
+        include OnNormalIfUnless
+
+        def on_normal_if_unless(node)
+          condition, body, else_clause = *node
+          next_thing = if body && body.loc.expression
+                         body.loc.expression.begin
+                       elsif else_clause && else_clause.loc.expression
+                         else_clause.loc.expression.begin
+                       else
+                         node.loc.end # No body, use "end".
+                       end
+          right_after_cond =
+            Parser::Source::Range.new(next_thing.source_buffer,
+                                      end_position(condition),
+                                      next_thing.begin_pos)
+          return unless right_after_cond.source =~ /\A\s*then\s*(#.*)?\s*\n/
+
+          add_offense(node, :expression, message(node))
+        end
+
+        def end_position(conditional_node)
+          conditional_node.loc.expression.end.end_pos
+        end
+
+        def message(node)
+          "Never use `then` for multi-line `#{node.loc.keyword.source}`."
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            condition_node, = *node
+            end_of_condition_range = condition_node.loc.expression.end
+            then_range = node.loc.begin
+            whitespaces_and_then_range = end_of_condition_range.join(then_range)
+            corrector.remove(whitespaces_and_then_range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for multi-line ternary op expressions.
+      class MultilineTernaryOperator < Cop
+        MSG = 'Avoid multi-line ?: (the ternary operator);' \
+              ' use `if`/`unless` instead.'
+
+        def on_if(node)
+          loc = node.loc
+
+          # discard non-ternary ops
+          return unless loc.respond_to?(:question)
+
+          add_offense(node, :expression) if loc.line != loc.colon.line
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of if with a negated condition. Only ifs
+      # without else are considered.
+      class NegatedIf < Cop
+        include NegativeConditional
+
+        MSG = 'Favor `%s` over `%s` for negative conditions.'
+
+        def on_if(node)
+          return unless node.loc.respond_to?(:keyword)
+          return if node.loc.keyword.is?('elsif')
+
+          check_negative_conditional(node)
+        end
+
+        def message(node)
+          if node.loc.keyword.is?('if')
+            format(MSG, 'unless', 'if')
+          else
+            format(MSG, 'if', 'unless')
+          end
+        end
+
+        private
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            condition, _body, _rest = *node
+            # look inside parentheses around the condition
+            condition = condition.children.first while condition.type == :begin
+            # unwrap the negated portion of the condition (a send node)
+            pos_condition, _method, = *condition
+            corrector.replace(
+              node.loc.keyword,
+              node.loc.keyword.is?('if') ? 'unless' : 'if'
+            )
+            corrector.replace(condition.loc.expression,
+                              pos_condition.loc.expression.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of while with a negated condition.
+      class NegatedWhile < Cop
+        include NegativeConditional
+
+        MSG = 'Favor `%s` over `%s` for negative conditions.'
+
+        def on_while(node)
+          check_negative_conditional(node)
+        end
+
+        def on_until(node)
+          check_negative_conditional(node)
+        end
+
+        def message(node)
+          if node.type == :while
+            format(MSG, 'until', 'while')
+          else
+            format(MSG, 'while', 'until')
+          end
+        end
+
+        private
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            condition, _body, _rest = *node
+            # unwrap the negated portion of the condition (a send node)
+            pos_condition, _method, = *condition
+            corrector.replace(
+              node.loc.keyword,
+              node.type == :while ? 'until' : 'while')
+            corrector.replace(condition.loc.expression,
+                              pos_condition.loc.expression.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for nested ternary op expressions.
+      class NestedTernaryOperator < Cop
+        MSG = 'Ternary operators must not be nested. Prefer `if`/`else` ' \
+              'constructs instead.'
+
+        def on_if(node)
+          loc = node.loc
+
+          # discard non-ternary ops
+          return unless loc.respond_to?(:question)
+
+          node.each_descendant(:if) do |nested_if_node|
+            if nested_if_node.loc.respond_to?(:question)
+              add_offense(nested_if_node, :expression)
+            end
+          end
+        end
+      end
+    end
+  end
+end