dirwatch 0.0.7 → 0.0.8

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+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)
+          return unless node.loc.begin
+          return unless node.loc.begin.source_line =~ /then\s*(#.*)?$/
+          add_offense(node, :begin)
+        end
+
+        def message(node)
+          "Do not use `then` for multi-line `#{node.loc.keyword.source}`."
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(range_with_surrounding_space(node.loc.begin,
+                                                          :left))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks that multiline memoizations are wrapped in a `begin`
+      # and `end` block.
+      #
+      # @example
+      #
+      #   @bad
+      #   foo ||= (
+      #     bar
+      #     baz
+      #   )
+      #
+      #   @good
+      #   foo ||= begin
+      #     bar
+      #     baz
+      #   end
+      class MultilineMemoization < Cop
+        MSG = 'Wrap multiline memoization blocks in `begin` and `end`.'.freeze
+
+        def on_or_asgn(node)
+          _lhs, rhs = *node
+
+          return unless rhs.multiline? && rhs.begin_type?
+
+          add_offense(rhs, node.source_range, MSG)
+        end
+
+        private
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, 'begin')
+            corrector.replace(node.loc.end, 'end')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks that the closing brace in a method call is either
+      # on the same line as the last method argument, or a new line.
+      #
+      # When using the `symmetrical` (default) style:
+      #
+      # If a method call's opening brace is on the same line as the first
+      # argument of the call, then the closing brace should be on the same
+      # line as the last argument of the call.
+      #
+      # If an method call's opening brace is on the line above the first
+      # argument of the call, then the closing brace should be on the line
+      # below the last argument of the call.
+      #
+      # When using the `new_line` style:
+      #
+      # The closing brace of a multi-line method call must be on the line
+      # after the last argument of the call.
+      #
+      # When using the `same_line` style:
+      #
+      # The closing brace of a multi-line method call must be on the same
+      # line as the last argument of the call.
+      #
+      # @example
+      #
+      #     # symmetrical: bad
+      #     # new_line: good
+      #     # same_line: bad
+      #     foo(a,
+      #       b
+      #     )
+      #
+      #     # symmetrical: bad
+      #     # new_line: bad
+      #     # same_line: good
+      #     foo(
+      #       a,
+      #       b)
+      #
+      #     # symmetrical: good
+      #     # new_line: bad
+      #     # same_line: good
+      #     foo(a,
+      #       b)
+      #
+      #     # symmetrical: good
+      #     # new_line: good
+      #     # same_line: bad
+      #     foo(
+      #       a,
+      #       b
+      #     )
+      class MultilineMethodCallBraceLayout < Cop
+        include MultilineLiteralBraceLayout
+
+        SAME_LINE_MESSAGE = 'Closing method call brace must be on the ' \
+          'same line as the last argument when opening brace is on the same ' \
+          'line as the first argument.'.freeze
+
+        NEW_LINE_MESSAGE = 'Closing method call brace must be on the ' \
+          'line after the last argument when opening brace is on a separate ' \
+          'line from the first argument.'.freeze
+
+        ALWAYS_NEW_LINE_MESSAGE = 'Closing method call brace must be on ' \
+          'the line after the last argument.'.freeze
+
+        ALWAYS_SAME_LINE_MESSAGE = 'Closing method call brace must be on ' \
+          'the same line as the last argument.'.freeze
+
+        def on_send(node)
+          check_brace_layout(node)
+        end
+
+        private
+
+        def children(node)
+          _receiver, _method_name, *args = *node
+
+          args
+        end
+
+        def ignored_literal?(node)
+          single_line_ignoring_receiver?(node) || super
+        end
+
+        def single_line_ignoring_receiver?(node)
+          return false unless node.loc.begin && node.loc.end
+          node.loc.begin.line == node.loc.end.line
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks the indentation of the method name part in method calls
+      # that span more than one line.
+      #
+      # @example
+      #   # bad
+      #   while a
+      #   .b
+      #     something
+      #   end
+      #
+      #   # good, EnforcedStyle: aligned
+      #   while a
+      #         .b
+      #     something
+      #   end
+      #
+      #   # good, EnforcedStyle: aligned
+      #   Thing.a
+      #        .b
+      #        .c
+      #
+      #   # good, EnforcedStyle: indented
+      #   while a
+      #       .b
+      #     something
+      #   end
+      class MultilineMethodCallIndentation < Cop
+        include ConfigurableEnforcedStyle
+        include AutocorrectAlignment
+        include MultilineExpressionIndentation
+
+        def validate_config
+          return unless style == :aligned && cop_config['IndentationWidth']
+
+          raise ValidationError,
+                'The `Style/MultilineMethodCallIndentation`' \
+                ' cop only accepts an `IndentationWidth` ' \
+                'configuration parameter when ' \
+                '`EnforcedStyle` is `indented`.'
+        end
+
+        private
+
+        def relevant_node?(send_node)
+          send_node.loc.dot # Only check method calls with dot operator
+        end
+
+        def offending_range(node, lhs, rhs, given_style)
+          return false unless begins_its_line?(rhs)
+          return false if not_for_this_cop?(node)
+
+          @base = alignment_base(node, rhs, given_style)
+          correct_column = if @base
+                             @base.column + extra_indentation(given_style)
+                           else
+                             indentation(lhs) + correct_indentation(node)
+                           end
+          @column_delta = correct_column - rhs.column
+          rhs if @column_delta.nonzero?
+        end
+
+        def extra_indentation(given_style)
+          if given_style == :indented_relative_to_receiver
+            configured_indentation_width
+          else
+            0
+          end
+        end
+
+        def message(node, lhs, rhs)
+          if should_indent_relative_to_receiver?
+            relative_to_receiver_message(rhs)
+          elsif should_align_with_base?
+            align_with_base_message(rhs)
+          else
+            no_base_message(lhs, rhs, node)
+          end
+        end
+
+        def should_indent_relative_to_receiver?
+          @base && style == :indented_relative_to_receiver
+        end
+
+        def should_align_with_base?
+          @base && style != :indented_relative_to_receiver
+        end
+
+        def relative_to_receiver_message(rhs)
+          "Indent `#{rhs.source}` #{configured_indentation_width} spaces " \
+            "more than `#{base_source}` on line #{@base.line}."
+        end
+
+        def align_with_base_message(rhs)
+          "Align `#{rhs.source}` with `#{base_source}` on line #{@base.line}."
+        end
+
+        def base_source
+          @base.source[/[^\n]*/]
+        end
+
+        def no_base_message(lhs, rhs, node)
+          used_indentation = rhs.column - indentation(lhs)
+          what = operation_description(node, rhs)
+
+          "Use #{correct_indentation(node)} (not #{used_indentation}) " \
+            "spaces for indenting #{what} spanning multiple lines."
+        end
+
+        def alignment_base(node, rhs, given_style)
+          return nil if given_style == :indented
+
+          if given_style == :indented_relative_to_receiver
+            receiver_base = receiver_alignment_base(node)
+            return receiver_base if receiver_base
+          end
+
+          semantic_alignment_base(node, rhs) ||
+            syntactic_alignment_base(node, rhs)
+        end
+
+        def syntactic_alignment_base(lhs, rhs)
+          # a if b
+          #      .c
+          n = kw_node_with_special_indentation(lhs)
+          if n
+            case n.type
+            when :if, :while, :until then expression, = *n
+            when :for                then _, expression, = *n
+            when :return             then expression, = *n
+            end
+            return expression.source_range
+          end
+
+          # a = b
+          #     .c
+          n = part_of_assignment_rhs(lhs, rhs)
+          return assignment_rhs(n).source_range if n
+
+          # a + b
+          #     .c
+          n = operation_rhs(lhs)
+          return n.source_range if n
+        end
+
+        # a.b
+        #  .c
+        def semantic_alignment_base(node, rhs)
+          return unless rhs.source.start_with?('.')
+
+          node = semantic_alignment_node(node)
+          return unless node
+
+          node.loc.dot.join(node.loc.selector)
+        end
+
+        # a
+        #   .b
+        #   .c
+        def receiver_alignment_base(node)
+          node = semantic_alignment_node(node)
+          return unless node
+
+          node.receiver.source_range
+        end
+
+        def semantic_alignment_node(node)
+          return if argument_in_method_call(node)
+
+          # descend to root of method chain
+          node = node.receiver while node.receiver
+          # ascend to first call which has a dot
+          node = node.parent
+          node = node.parent until node.loc.dot
+
+          return if node.loc.dot.line != node.loc.line
+          node
+        end
+
+        def operation_rhs(node)
+          receiver, = *node
+          receiver.each_ancestor(:send) do |a|
+            _, method, args = *a
+            return args if operator?(method) && args &&
+                           within_node?(receiver, args)
+          end
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks that the closing brace in a method definition is either
+      # on the same line as the last method parameter, or a new line.
+      #
+      # When using the `symmetrical` (default) style:
+      #
+      # If a method definition's opening brace is on the same line as the
+      # first parameter of the definition, then the closing brace should be
+      # on the same line as the last parameter of the definition.
+      #
+      # If an method definition's opening brace is on the line above the first
+      # parameter of the definition, then the closing brace should be on the
+      # line below the last parameter of the definition.
+      #
+      # When using the `new_line` style:
+      #
+      # The closing brace of a multi-line method definition must be on the line
+      # after the last parameter of the definition.
+      #
+      # When using the `same_line` style:
+      #
+      # The closing brace of a multi-line method definition must be on the same
+      # line as the last parameter of the definition.
+      #
+      # @example
+      #
+      #     # symmetrical: bad
+      #     # new_line: good
+      #     # same_line: bad
+      #     def foo(a,
+      #       b
+      #     )
+      #
+      #     # symmetrical: bad
+      #     # new_line: bad
+      #     # same_line: good
+      #     def foo(
+      #       a,
+      #       b)
+      #
+      #     # symmetrical: good
+      #     # new_line: bad
+      #     # same_line: good
+      #     def foo(a,
+      #       b)
+      #
+      #     # symmetrical: good
+      #     # new_line: good
+      #     # same_line: bad
+      #     def foo(
+      #       a,
+      #       b
+      #     )
+      class MultilineMethodDefinitionBraceLayout < Cop
+        include OnMethodDef
+        include MultilineLiteralBraceLayout
+
+        SAME_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
+          'same line as the last parameter when opening brace is on the same ' \
+          'line as the first parameter.'.freeze
+
+        NEW_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
+          'line after the last parameter when opening brace is on a separate ' \
+          'line from the first parameter.'.freeze
+
+        ALWAYS_NEW_LINE_MESSAGE = 'Closing method definition brace must be ' \
+          'on the line after the last parameter.'.freeze
+
+        ALWAYS_SAME_LINE_MESSAGE = 'Closing method definition brace must be ' \
+          'on the same line as the last parameter.'.freeze
+
+        def on_method_def(_node, _method_name, args, _body)
+          check_brace_layout(args)
+        end
+      end
+    end
+  end
+end