dirwatch 0.0.7 → 0.0.8

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/if_inside_else.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # If the `else` branch of a conditional consists solely of an `if` node,
+      # it can be combined with the `else` to become an `elsif`.
+      # This helps to keep the nesting level from getting too deep.
+      #
+      # @example
+      #   @good
+      #   if condition_a
+      #     action_a
+      #   elsif condition_b
+      #     action_b
+      #   else
+      #     action_c
+      #   end
+      #
+      #   @bad
+      #   if condition_a
+      #     action_a
+      #   else
+      #     if condition_b
+      #       action_b
+      #     else
+      #       action_c
+      #     end
+      #   end
+      class IfInsideElse < Cop
+        include IfNode
+
+        MSG = 'Convert `if` nested inside `else` to `elsif`.'.freeze
+
+        def on_if(node)
+          _cond, _if_branch, else_branch = *node
+          return unless else_branch
+          return unless else_branch.if_type?
+          return if ternary?(node) || ternary?(else_branch)
+          return unless else_branch.loc.keyword.is?('if')
+          return if node.loc.keyword.is?('unless')
+
+          add_offense(else_branch, :keyword, MSG)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/if_unless_modifier.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for if and unless statements that would fit on one line
+      # if written as a modifier if/unless.
+      # The maximum line length is configurable.
+      class IfUnlessModifier < Cop
+        include IfNode
+        include StatementModifier
+
+        ASSIGNMENT_TYPES = [:lvasgn, :casgn, :cvasgn,
+                            :gvasgn, :ivasgn, :masgn].freeze
+
+        def on_if(node)
+          return unless eligible_node?(node)
+
+          add_offense(node, :keyword, message(node.loc.keyword.source))
+        end
+
+        private
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.source_range, oneline(node)) }
+        end
+
+        def eligible_node?(node)
+          !non_eligible_if?(node) && !node.chained? &&
+            !nested_conditional?(node) && single_line_as_modifier?(node)
+        end
+
+        def non_eligible_if?(node)
+          ternary?(node) || modifier_if?(node) ||
+            elsif?(node) || if_else?(node)
+        end
+
+        def message(keyword)
+          "Favor modifier `#{keyword}` usage when having a single-line body." \
+          ' Another good alternative is the usage of control flow `&&`/`||`.'
+        end
+
+        def parenthesize?(node)
+          # Parenthesize corrected expression if changing to modifier-if form
+          # would change the meaning of the parent expression
+          # (due to the low operator precedence of modifier-if)
+          return false if node.parent.nil?
+          return true if ASSIGNMENT_TYPES.include?(node.parent.type)
+
+          if node.parent.send_type?
+            _receiver, _name, *args = *node.parent
+            return !method_uses_parens?(node.parent, args.first)
+          end
+
+          false
+        end
+
+        def method_uses_parens?(node, limit)
+          source = node.source_range.source_line[0...limit.loc.column]
+          source =~ /\s*\(\s*$/
+        end
+
+        # returns false if the then or else children are conditionals
+        def nested_conditional?(node)
+          node.children[1, 2].compact.any?(&:if_type?)
+        end
+
+        def oneline(node)
+          cond, body, _else = if_node_parts(node)
+
+          expr = "#{body.source} #{node.loc.keyword.source} " + cond.source
+          if (comment_after = first_line_comment(node))
+            expr << ' ' << comment_after
+          end
+          expr = "(#{expr})" if parenthesize?(node)
+
+          expr
+        end
+
+        def first_line_comment(node)
+          comment =
+            processed_source.comments.find { |c| c.loc.line == node.loc.line }
+
+          comment ? comment.loc.expression.source : nil
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/if_unless_modifier_of_if_unless.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for if and unless statements used as modifers of other if or
+      # unless statements.
+      #
+      # @example
+      #
+      #  # bad
+      #  tired? ? 'stop' : 'go faster' if running?
+      #
+      #  # bad
+      #  if tired?
+      #    "please stop"
+      #  else
+      #    "keep going"
+      #  end if running?
+      #
+      #  # good
+      #  if running?
+      #    tired? ? 'stop' : 'go faster'
+      #  end
+      class IfUnlessModifierOfIfUnless < Cop
+        include StatementModifier
+
+        MESSAGE = 'Avoid modifier `%s` after another conditional.'.freeze
+
+        def message(keyword)
+          format(MESSAGE, keyword)
+        end
+
+        def on_if(node)
+          return unless modifier_if?(node)
+          _cond, body, _else = if_node_parts(node)
+          return unless body.if_type?
+
+          add_offense(node, :keyword, message(node.loc.keyword.source))
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/if_with_semicolon.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of semicolon in if statements.
+      class IfWithSemicolon < Cop
+        include OnNormalIfUnless
+
+        MSG = 'Do not use if x; Use the ternary operator instead.'.freeze
+
+        def on_normal_if_unless(node)
+          beginning = node.loc.begin
+          return unless beginning && beginning.is?(';')
+          add_offense(node, :expression, MSG)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/implicit_runtime_error.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for `raise` or `fail` statements which do not specify an
+      # explicit exception class. (This raises a `RuntimeError`. Some projects
+      # might prefer to use exception classes which more precisely identify the
+      # nature of the error.)
+      #
+      # @example
+      #   @bad
+      #   raise 'Error message here'
+      #
+      #   @good
+      #   raise ArgumentError, 'Error message here'
+      class ImplicitRuntimeError < Cop
+        def_node_matcher :implicit_runtime_error_raise_or_fail,
+                         '(send nil ${:raise :fail} {str dstr})'
+
+        def on_send(node)
+          implicit_runtime_error_raise_or_fail(node) do |method|
+            add_offense(node, :expression, "Use `#{method}` with an explicit " \
+                                           'exception class and message, ' \
+                                           'rather than just a message.')
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/indent_array.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks the indentation of the first element in an array literal
+      # where the opening bracket and the first element are on separate lines.
+      # The other elements' indentations are handled by the AlignArray cop.
+      #
+      # By default, array literals that are arguments in a method call with
+      # parentheses, and where the opening square bracket of the array is on the
+      # same line as the opening parenthesis of the method call, shall have
+      # their first element indented one step (two spaces) more than the
+      # position inside the opening parenthesis.
+      #
+      # Other array literals shall have their first element indented one step
+      # more than the start of the line where the opening square bracket is.
+      #
+      # This default style is called 'special_inside_parentheses'. Alternative
+      # styles are 'consistent' and 'align_brackets'. Here are examples:
+      #
+      #     # special_inside_parentheses
+      #     array = [
+      #       :value
+      #     ]
+      #     but_in_a_method_call([
+      #                            :its_like_this
+      #                          ])
+      #     # consistent
+      #     array = [
+      #       :value
+      #     ]
+      #     and_in_a_method_call([
+      #       :no_difference
+      #     ])
+      #     # align_brackets
+      #     and_now_for_something = [
+      #                               :completely_different
+      #                             ]
+      #
+      class IndentArray < Cop
+        include AutocorrectAlignment
+        include ConfigurableEnforcedStyle
+        include ArrayHashIndentation
+
+        def on_array(node)
+          check(node, nil) if node.loc.begin
+        end
+
+        def on_send(node)
+          each_argument_node(node, :array) do |array_node, left_parenthesis|
+            check(array_node, left_parenthesis)
+          end
+        end
+
+        private
+
+        def brace_alignment_style
+          :align_brackets
+        end
+
+        def check(array_node, left_parenthesis)
+          return if ignored_node?(array_node)
+
+          left_bracket = array_node.loc.begin
+          first_elem = array_node.children.first
+          if first_elem
+            return if first_elem.source_range.line == left_bracket.line
+            check_first(first_elem, left_bracket, left_parenthesis, 0)
+          end
+
+          check_right_bracket(array_node.loc.end, left_bracket,
+                              left_parenthesis)
+        end
+
+        def check_right_bracket(right_bracket, left_bracket, left_parenthesis)
+          # if the right bracket is on the same line as the last value, accept
+          return if right_bracket.source_line[0...right_bracket.column] =~ /\S/
+
+          expected_column = base_column(left_bracket, left_parenthesis)
+          @column_delta = expected_column - right_bracket.column
+          return if @column_delta.zero?
+
+          msg = if style == :align_brackets
+                  'Indent the right bracket the same as the left bracket.'
+                elsif style == :special_inside_parentheses && left_parenthesis
+                  'Indent the right bracket the same as the first position ' \
+                  'after the preceding left parenthesis.'
+                else
+                  'Indent the right bracket the same as the start of the line' \
+                  ' where the left bracket is.'
+                end
+          add_offense(right_bracket, right_bracket, msg)
+        end
+
+        # Returns the description of what the correct indentation is based on.
+        def base_description(left_parenthesis)
+          if style == :align_brackets
+            'the position of the opening bracket'
+          elsif left_parenthesis && style == :special_inside_parentheses
+            'the first position after the preceding left parenthesis'
+          else
+            'the start of the line where the left square bracket is'
+          end
+        end
+
+        def message(base_description)
+          format('Use %d spaces for indentation in an array, relative to %s.',
+                 configured_indentation_width, base_description)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/indent_assignment.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks the indentation of the first line of the
+      # right-hand-side of a multi-line assignment.
+      #
+      # @example
+      #   # bad
+      #   value =
+      #   if foo
+      #     'bar'
+      #   end
+      #
+      #   # good
+      #   value =
+      #     if foo
+      #     'bar'
+      #   end
+      #
+      # The indentation of the remaining lines can be corrected with
+      # other cops such as `IndentationConsistency` and `EndAlignment`.
+      class IndentAssignment < Cop
+        include CheckAssignment
+        include AutocorrectAlignment
+
+        MSG = 'Indent the first line of the right-hand-side of a ' \
+              'multi-line assignment.'.freeze
+
+        def check_assignment(node, rhs)
+          return unless rhs
+          return unless node.loc.operator
+          return if node.loc.operator.line == rhs.loc.line
+
+          base = display_column(node.source_range)
+          check_alignment([rhs], base + configured_indentation_width)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/indent_hash.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks the indentation of the first key in a hash literal
+      # where the opening brace and the first key are on separate lines. The
+      # other keys' indentations are handled by the AlignHash cop.
+      #
+      # By default, Hash literals that are arguments in a method call with
+      # parentheses, and where the opening curly brace of the hash is on the
+      # same line as the opening parenthesis of the method call, shall have
+      # their first key indented one step (two spaces) more than the position
+      # inside the opening parenthesis.
+      #
+      # Other hash literals shall have their first key indented one step more
+      # than the start of the line where the opening curly brace is.
+      #
+      # This default style is called 'special_inside_parentheses'. Alternative
+      # styles are 'consistent' and 'align_braces'. Here are examples:
+      #
+      #     # special_inside_parentheses
+      #     hash = {
+      #       key: :value
+      #     }
+      #     but_in_a_method_call({
+      #                            its_like: :this
+      #                          })
+      #     # consistent
+      #     hash = {
+      #       key: :value
+      #     }
+      #     and_in_a_method_call({
+      #       no: :difference
+      #     })
+      #     # align_braces
+      #     and_now_for_something = {
+      #                               completely: :different
+      #                             }
+      #
+      class IndentHash < Cop
+        include AutocorrectAlignment
+        include ConfigurableEnforcedStyle
+        include ArrayHashIndentation
+
+        def on_hash(node)
+          check(node, nil) if node.loc.begin
+        end
+
+        def on_send(node)
+          each_argument_node(node, :hash) do |hash_node, left_parenthesis|
+            check(hash_node, left_parenthesis)
+          end
+        end
+
+        private
+
+        def brace_alignment_style
+          :align_braces
+        end
+
+        def check(hash_node, left_parenthesis)
+          return if ignored_node?(hash_node)
+
+          left_brace = hash_node.loc.begin
+          first_pair = hash_node.children.first
+          if first_pair
+            return if first_pair.source_range.line == left_brace.line
+
+            if separator_style?(first_pair)
+              check_based_on_longest_key(hash_node.children, left_brace,
+                                         left_parenthesis)
+            else
+              check_first(first_pair, left_brace, left_parenthesis, 0)
+            end
+          end
+
+          check_right_brace(hash_node.loc.end, left_brace, left_parenthesis)
+        end
+
+        def check_right_brace(right_brace, left_brace, left_parenthesis)
+          # if the right brace is on the same line as the last value, accept
+          return if right_brace.source_line[0...right_brace.column] =~ /\S/
+
+          expected_column = base_column(left_brace, left_parenthesis)
+          @column_delta = expected_column - right_brace.column
+          return if @column_delta.zero?
+
+          msg = if style == :align_braces
+                  'Indent the right brace the same as the left brace.'
+                elsif style == :special_inside_parentheses && left_parenthesis
+                  'Indent the right brace the same as the first position ' \
+                  'after the preceding left parenthesis.'
+                else
+                  'Indent the right brace the same as the start of the line ' \
+                  'where the left brace is.'
+                end
+          add_offense(right_brace, right_brace, msg)
+        end
+
+        def separator_style?(first_pair)
+          separator = first_pair.loc.operator
+          key = "Enforced#{separator.is?(':') ? 'Colon' : 'HashRocket'}Style"
+          config.for_cop('Style/AlignHash')[key] == 'separator'
+        end
+
+        def check_based_on_longest_key(pairs, left_brace, left_parenthesis)
+          key_lengths = pairs.map do |pair|
+            pair.children.first.source_range.length
+          end
+          check_first(pairs.first, left_brace, left_parenthesis,
+                      key_lengths.max - key_lengths.first)
+        end
+
+        # Returns the description of what the correct indentation is based on.
+        def base_description(left_parenthesis)
+          if style == :align_braces
+            'the position of the opening brace'
+          elsif left_parenthesis && style == :special_inside_parentheses
+            'the first position after the preceding left parenthesis'
+          else
+            'the start of the line where the left curly brace is'
+          end
+        end
+
+        def message(base_description)
+          format('Use %d spaces for indentation in a hash, relative to %s.',
+                 configured_indentation_width, base_description)
+        end
+      end
+    end
+  end
+end