rubyjobbuilderdsl 0.0.0 → 0.0.1

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

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks the indentation of comments.
+      class CommentIndentation < Cop
+        include AutocorrectAlignment
+
+        MSG = 'Incorrect indentation detected (column %d instead of %d).'
+
+        def investigate(processed_source)
+          processed_source.comments.each do |comment|
+            lines = processed_source.lines
+            own_line = lines[comment.loc.line - 1]
+            next unless own_line =~ /\A\s*#/
+
+            next_line =
+              lines[comment.loc.line..-1].find { |line| !line.blank? }
+
+            correct_comment_indentation = correct_indentation(next_line)
+            column = comment.loc.column
+
+            @column_delta = correct_comment_indentation - column
+            next if @column_delta == 0
+
+            if two_alternatives?(next_line)
+              correct_comment_indentation +=
+                IndentationWidth::CORRECT_INDENTATION # Try the other
+              # We keep @column_delta unchanged so that autocorrect changes to
+              # the preferred style of aligning the comment with the keyword.
+            end
+
+            next if column == correct_comment_indentation
+            add_offense(comment, comment.loc.expression,
+                        format(MSG, column, correct_comment_indentation))
+          end
+        end
+
+        private
+
+        def correct_indentation(next_line)
+          return 0 unless next_line
+
+          indentation_of_next_line = next_line =~ /\S/
+          indentation_of_next_line + if less_indented?(next_line)
+                                       IndentationWidth::CORRECT_INDENTATION
+                                     else
+                                       0
+                                     end
+        end
+
+        def less_indented?(line)
+          keyword = 'end\b'
+          bracket = '[}\]]'
+          line =~ /^\s*(#{keyword}|#{bracket})/
+        end
+
+        def two_alternatives?(line)
+          keyword = '(else|elsif|when|rescue|ensure)\b'
+          line =~ /^\s*#{keyword}/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether constant names are written using
+      # SCREAMING_SNAKE_CASE.
+      #
+      # To avoid false positives, it ignores cases in which we cannot know
+      # for certain the type of value that would be assigned to a constant.
+      class ConstantName < Cop
+        MSG = 'Use SCREAMING_SNAKE_CASE for constants.'
+        SNAKE_CASE = /^[\dA-Z_]+$/
+
+        def on_casgn(node)
+          _scope, const_name, value = *node
+
+          # We cannot know the result of method calls like
+          # NewClass = something_that_returns_a_class
+          # It's also ok to assign a class constant another class constant
+          # SomeClass = SomeOtherClass
+          return if value && [:send, :block, :const].include?(value.type)
+
+          add_offense(node, :name) if const_name !~ SNAKE_CASE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for parentheses in the definition of a method,
+      # that does not take any arguments. Both instance and
+      # class/singleton methods are checked.
+      class DefWithParentheses < Cop
+        include OnMethod
+
+        MSG = "Omit the parentheses in defs when the method doesn't accept " \
+              'any arguments.'
+
+        def on_method(node, _method_name, args, _body)
+          start_line = node.loc.keyword.line
+          end_line = node.loc.end.line
+
+          return if start_line == end_line
+
+          add_offense(args, :begin) if args.children == [] && args.loc.begin
+        end
+
+        def autocorrect(node)
+          @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/deprecated_hash_methods.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of the deprecated methods Hash#has_key?
+      # and Hash#has_value?
+      class DeprecatedHashMethods < Cop
+        MSG = '`Hash#%s` is deprecated in favor of `Hash#%s`.'
+
+        DEPRECATED_METHODS = [:has_key?, :has_value?]
+
+        def on_send(node)
+          _receiver, method_name, *args = *node
+          return unless args.size == 1 &&
+            DEPRECATED_METHODS.include?(method_name)
+
+          add_offense(node, :selector,
+                      format(MSG,
+                             method_name,
+                             proper_method_name(method_name)))
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              proper_method_name(node.loc.selector.source))
+          end
+        end
+
+        private
+
+        def proper_method_name(method_name)
+          method_name.to_s.sub(/has_/, '')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for missing top-level documentation of
+      # classes and modules. Classes with no body are exempt from the
+      # check and so are namespace modules - modules that have nothing in
+      # their bodies except classes or other other modules.
+      class Documentation < Cop
+        include AnnotationComment
+
+        MSG = 'Missing top-level %s documentation comment.'
+
+        def investigate(processed_source)
+          ast = processed_source.ast
+          return unless ast
+
+          ast_with_comments = Parser::Source::Comment.associate(
+            ast,
+            processed_source.comments
+          )
+
+          check(ast, ast_with_comments)
+        end
+
+        private
+
+        def check(ast, ast_with_comments)
+          ast.each_node(:class, :module) do |node|
+            case node.type
+            when :class
+              _name, _superclass, body = *node
+            when :module
+              _name, body = *node
+            end
+
+            next if node.type == :class && !body
+            next if namespace?(body)
+            next if associated_comment?(node, ast_with_comments)
+            add_offense(node, :keyword, format(MSG, node.type.to_s))
+          end
+        end
+
+        def namespace?(body_node)
+          return false unless body_node
+
+          case body_node.type
+          when :begin
+            body_node.children.all? do |node|
+              [:class, :module].include?(node.type)
+            end
+          when :class, :module
+            true
+          else
+            false
+          end
+        end
+
+        # Returns true if the node has a comment on the line above it that
+        # isn't an annotation.
+        def associated_comment?(node, ast_with_comments)
+          return false if ast_with_comments[node].empty?
+
+          preceding_comment = ast_with_comments[node].last
+          distance = node.loc.keyword.line - preceding_comment.loc.line
+          return false if distance > 1
+
+          # As long as there's at least one comment line that isn't an
+          # annotation, it's OK.
+          ast_with_comments[node].any? { |comment| !annotation?(comment) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks the . position in multi-line method calls.
+      class DotPosition < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_send(node)
+          return unless node.loc.dot
+
+          if proper_dot_position?(node)
+            correct_style_detected
+          else
+            add_offense(node, :dot) { opposite_style_detected }
+          end
+        end
+
+        private
+
+        def message(_node)
+          'Place the . on the ' +
+            case style
+            when :leading
+              'next line, together with the method name.'
+            when :trailing
+              'previous line, together with the method call receiver.'
+            end
+        end
+
+        def proper_dot_position?(node)
+          receiver, _method_name, *_args = *node
+
+          receiver_line = receiver.loc.expression.end.line
+
+          if node.loc.selector
+            selector_line = node.loc.selector.line
+          else
+            # l.(1) has no selector, so we use the opening parenthesis instead
+            selector_line = node.loc.begin.line
+          end
+
+          # receiver and selector are on the same line
+          return true if selector_line == receiver_line
+
+          dot_line = node.loc.dot.line
+
+          case style
+          when :leading then dot_line == selector_line
+          when :trailing then dot_line != selector_line
+          end
+        end
+
+        def autocorrect(node)
+          receiver, _method_name, *_args = *node
+          if node.loc.selector
+            selector = node.loc.selector
+          else
+            # l.(1) has no selector, so we use the opening parenthesis instead
+            selector = node.loc.begin
+          end
+
+          @corrections << lambda do |corrector|
+            corrector.remove(node.loc.dot)
+            case style
+            when :leading
+              corrector.insert_before(selector, '.')
+            when :trailing
+              corrector.insert_after(receiver.loc.expression, '.')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of double negation (!!) to convert something
+      # to a boolean value. As this is both cryptic and usually redundant it
+      # should be avoided.
+      #
+      # @example
+      #
+      #   # bad
+      #   !!something
+      #
+      #   # good
+      #   !something.nil?
+      class DoubleNegation < Cop
+        MSG = 'Avoid the use of double negation (`!!`).'
+
+        def on_send(node)
+          return unless not_node?(node)
+
+          receiver, _method_name, *_args = *node
+
+          add_offense(node, :selector) if not_node?(receiver)
+        end
+
+        private
+
+        def not_node?(node)
+          _receiver, method_name, *args = *node
+
+          # ! does not take any arguments
+          args.empty? && method_name == :! &&
+            node.loc.selector.is?('!')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for inject / reduce calls where the passed in object is
+      # returned at the end and so could be replace by each_with_object without
+      # the need to return the object at the end.
+      #
+      # @example
+      #   # bad
+      #   [1, 2].inject({}) { |a, e| a[e] = e; a }
+      #
+      #   # good
+      #   [1, 2].each_with_object({}) { |e, a| a[e] = e }
+      class EachWithObject < Cop
+        MSG = 'Use `each_with_object` instead of `%s`.'
+        METHODS = [:inject, :reduce]
+
+        def on_block(node)
+          method, args, body = *node
+
+          # filter out super and zsuper nodes
+          return unless method.type == :send
+
+          _, method_name, method_args = *method
+
+          return unless METHODS.include? method_name
+          return if method_args && method_args.type == :sym
+
+          return_value = return_value(body)
+          return unless return_value
+
+          return unless first_argument_returned?(args, return_value)
+
+          add_offense(method, :selector, format(MSG, method_name))
+        end
+
+        private
+
+        def return_value(body)
+          return unless body
+
+          return_value = body.type == :begin ? body.children.last : body
+          return_value if return_value && return_value.type == :lvar
+        end
+
+        def first_argument_returned?(args, return_value)
+          first_arg, = *args
+          accumulator_var = *first_arg
+          return_var = *return_value
+
+          accumulator_var == return_var
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether method definitions are
+      # separated by empty lines.
+      class EmptyLineBetweenDefs < Cop
+        MSG = 'Use empty lines between defs.'
+
+        def on_def(node)
+          if @prev_def_end && (def_start(node) - @prev_def_end) == 1
+            unless @prev_was_single_line && singe_line_def?(node) &&
+                cop_config['AllowAdjacentOneLineDefs']
+              add_offense(node, :keyword)
+            end
+          end
+
+          @prev_def_end = def_end(node)
+          @prev_was_single_line = singe_line_def?(node)
+        end
+
+        private
+
+        def singe_line_def?(node)
+          def_start(node) == def_end(node)
+        end
+
+        def def_start(node)
+          node.loc.keyword.line
+        end
+
+        def def_end(node)
+          node.loc.end.line
+        end
+
+        def autocorrect(node)
+          range = range_with_surrounding_space(node.loc.expression, :left)
+          @corrections << lambda do |corrector|
+            corrector.insert_before(range, "\n")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks for two or more consecutive blank lines.
+      class EmptyLines < Cop
+        MSG = 'Extra blank line detected.'
+        LINE_OFFSET = 2
+
+        def investigate(processed_source)
+          return if processed_source.tokens.empty?
+
+          prev_line = 1
+
+          processed_source.tokens.sort_by { |t| t.pos.line }.each do |token|
+            cur_line = token.pos.line
+
+            line_diff = cur_line - prev_line
+
+            if line_diff > LINE_OFFSET
+              # we need to be wary of comments since they
+              # don't show up in the tokens
+              ((prev_line + 1)...cur_line).each do |line|
+                # we check if the prev and current lines are empty
+                next unless processed_source[line - 2].empty? &&
+                  processed_source[line - 1].empty?
+
+                range = source_range(processed_source.buffer, line, 0)
+                add_offense(range, range)
+              end
+            end
+
+            prev_line = cur_line
+          end
+        end
+
+        def autocorrect(range)
+          @corrections << ->(corrector) { corrector.remove(range) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Access modifiers should be surrounded by blank lines.
+      class EmptyLinesAroundAccessModifier < Cop
+        include AccessModifierNode
+
+        MSG = 'Keep a blank line before and after `%s`.'
+
+        def on_send(node)
+          return unless modifier_node?(node)
+
+          return if empty_lines_around?(node)
+
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            send_line = node.loc.line
+            previous_line = processed_source[send_line - 2]
+            next_line = processed_source[send_line]
+
+            line = Parser::Source::Range.new(
+              processed_source.buffer,
+              node.loc.expression.begin_pos - node.loc.column,
+              node.loc.expression.end_pos
+            )
+
+            unless previous_line_empty?(previous_line)
+              corrector.insert_before(line, "\n")
+            end
+
+            unless next_line_empty?(next_line)
+              corrector.insert_after(line, "\n")
+            end
+          end
+        end
+
+        private
+
+        def previous_line_empty?(previous_line)
+          class_def?(previous_line.lstrip) || previous_line.blank?
+        end
+
+        def next_line_empty?(next_line)
+          body_end?(next_line.lstrip) || next_line.blank?
+        end
+
+        def empty_lines_around?(node)
+          send_line = node.loc.line
+          previous_line = processed_source[send_line - 2]
+          next_line = processed_source[send_line]
+
+          previous_line_empty?(previous_line) && next_line_empty?(next_line)
+        end
+
+        def class_def?(line)
+          %w(class module).any? { |keyword| line.start_with?(keyword) }
+        end
+
+        def body_end?(line)
+          line.start_with?('end')
+        end
+
+        def message(node)
+          format(MSG, node.loc.selector.source)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks redundant empty lines around the bodies of classes,
+      # modules & methods.
+      #
+      # @example
+      #
+      #   class Test
+      #
+      #      def something
+      #        ...
+      #      end
+      #
+      #   end
+      #
+      #   def something(arg)
+      #
+      #     ...
+      #   end
+      #
+      class EmptyLinesAroundBody < Cop
+        include OnMethod
+
+        MSG_BEG = 'Extra empty line detected at body beginning.'
+        MSG_END = 'Extra empty line detected at body end.'
+
+        def on_class(node)
+          check(node)
+        end
+
+        def on_module(node)
+          check(node)
+        end
+
+        def on_sclass(node)
+          check(node)
+        end
+
+        def autocorrect(range)
+          @corrections << ->(corrector) { corrector.remove(range) }
+        end
+
+        private
+
+        def on_method(node, _method_name, _args, _body)
+          check(node)
+        end
+
+        def check(node)
+          start_line = node.loc.keyword.line
+          end_line = node.loc.end.line
+
+          return if start_line == end_line
+
+          check_source(start_line, end_line)
+        end
+
+        def check_source(start_line, end_line)
+          check_line(start_line, MSG_BEG)
+          check_line(end_line - 2, MSG_END) unless end_line - 2 == start_line
+        end
+
+        def check_line(line, msg)
+          return unless processed_source.lines[line].empty?
+
+          range = source_range(processed_source.buffer, line + 1, 0)
+          add_offense(range, range, msg)
+        end
+      end
+    end
+  end
+end