dirwatch 0.0.6 → 0.0.7

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/safe_navigation.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop transforms usages of a method call safeguarded by a non `nil`
-      # check for the variable whose method is being called to
-      # safe navigation (`&.`).
-      #
-      # Configuration option: ConvertCodeThatCanStartToReturnNil
-      # The default for this is `false`. When configured to `true`, this will
-      # check for code in the format `!foo.nil? && foo.bar`. As it is written,
-      # the return of this code is limited to `false` and whatever the return
-      # of the method is. If this is converted to safe navigation,
-      # `foo&.bar` can start returning `nil` as well as what the method
-      # returns.
-      #
-      # @example
-      #   # bad
-      #   foo.bar if foo
-      #   foo.bar(param1, param2) if foo
-      #   foo.bar { |e| e.something } if foo
-      #   foo.bar(param) { |e| e.something } if foo
-      #
-      #   foo.bar if !foo.nil?
-      #   foo.bar unless !foo
-      #   foo.bar unless foo.nil?
-      #
-      #   foo && foo.bar
-      #   foo && foo.bar(param1, param2)
-      #   foo && foo.bar { |e| e.something }
-      #   foo && foo.bar(param) { |e| e.something }
-      #
-      #   # good
-      #   foo&.bar
-      #   foo&.bar(param1, param2)
-      #   foo&.bar { |e| e.something }
-      #   foo&.bar(param) { |e| e.something }
-      #
-      #   foo.nil? || foo.bar
-      #   !foo || foo.bar
-      #
-      #   # Methods that `nil` will `respond_to?` should not be converted to
-      #   # use safe navigation
-      #   foo.to_i if foo
-      class SafeNavigation < Cop
-        include IfNode
-
-        MSG = 'Use safe navigation (`&.`) instead of checking if an object ' \
-              'exists before calling the method.'.freeze
-        NIL_METHODS = nil.methods.freeze
-
-        def_node_matcher :safe_navigation_candidate, <<-PATTERN
-          {
-            (if
-              {(send (send $_ :nil?) :!) $_}
-              {(send $_ $_ ...) (block (send $_ $_ ...) ...)}
-            ...)
-            (if
-              (send $_ {:nil? :!}) nil
-              {(send $_ $_ ...) (block (send $_ $_ ...) ...)}
-            ...)
-          }
-        PATTERN
-
-        def_node_matcher :candidate_that_may_introduce_nil, <<-PATTERN
-          (and
-            {(send (send $_ :nil?) :!) $_}
-            {(send $_ $_ ...) (block (send $_ $_ ...) ...)}
-          ...)
-        PATTERN
-
-        def on_if(node)
-          return if ternary?(node)
-          check_node(node)
-        end
-
-        def on_and(node)
-          check_node(node)
-        end
-
-        def on_or(node)
-          check_node(node)
-        end
-
-        def check_node(node)
-          return if target_ruby_version < 2.3
-          return if if_else?(node)
-          return if elsif?(node)
-          checked_variable, receiver, method = extract_parts(node)
-          return unless receiver == checked_variable
-          return if NIL_METHODS.include?(method)
-          return unless method =~ /\w+[=!?]?/
-          add_offense(node, :expression)
-        end
-
-        def extract_parts(node)
-          if cop_config['ConvertCodeThatCanStartToReturnNil']
-            safe_navigation_candidate(node) ||
-              candidate_that_may_introduce_nil(node)
-          else
-            safe_navigation_candidate(node)
-          end
-        end
-
-        def autocorrect(node)
-          if node.loc.respond_to?(:keyword) && node.loc.keyword.is?('unless')
-            _check, _else, body = *node
-          else
-            _check, body = *node
-          end
-
-          method_call, = *body if body.block_type?
-
-          lambda do |corrector|
-            corrector.remove(begin_range(node, body))
-            corrector.remove(end_range(node, body))
-            corrector.insert_before((method_call || body).loc.dot, '&')
-          end
-        end
-
-        private
-
-        def begin_range(node, method_call)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    node.loc.expression.begin_pos,
-                                    method_call.loc.expression.begin_pos)
-        end
-
-        def end_range(node, method_call)
-          Parser::Source::Range.new(node.loc.expression,
-                                    method_call.loc.expression.end_pos,
-                                    node.loc.expression.end_pos)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/self_assignment.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-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
-        MSG = 'Use self-assignment shorthand `%s=`.'.freeze
-        OPS = [:+, :-, :*, :**, :/, :|, :&].freeze
-
-        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.send_type?
-            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
-
-        def autocorrect(node)
-          _var_name, rhs = *node
-
-          if rhs.send_type?
-            autocorrect_send_node(node, rhs)
-          elsif [:and, :or].include?(rhs.type)
-            autocorrect_boolean_node(node, rhs)
-          end
-        end
-
-        def autocorrect_send_node(node, rhs)
-          _receiver, method_name, args = *rhs
-          apply_autocorrect(node, rhs, method_name.to_s, args)
-        end
-
-        def autocorrect_boolean_node(node, rhs)
-          _first_operand, second_operand = *rhs
-          apply_autocorrect(node, rhs, rhs.loc.operator.source, second_operand)
-        end
-
-        def apply_autocorrect(node, rhs, operator, new_rhs)
-          lambda do |corrector|
-            corrector.insert_before(node.loc.operator, operator)
-            corrector.replace(rhs.source_range, new_rhs.source)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/semicolon.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for multiple expressions placed on the same line.
-      # It also checks for lines terminated with a semicolon.
-      class Semicolon < Cop
-        MSG = 'Do not use semicolons to terminate expressions.'.freeze
-
-        def investigate(processed_source)
-          return unless processed_source.ast
-          @processed_source = processed_source
-
-          check_for_line_terminator_or_opener
-        end
-
-        def on_begin(node)
-          return if cop_config['AllowAsExpressionSeparator']
-          exprs = node.children
-
-          return if exprs.size < 2
-
-          # create a map matching lines to the number of expressions on them
-          exprs_lines = exprs.map { |e| e.source_range.line }
-          lines = exprs_lines.group_by { |i| i }
-
-          # every line with more than 1 expression on it is an offense
-          lines.each do |line, expr_on_line|
-            next unless expr_on_line.size > 1
-            # TODO: Find the correct position of the semicolon. We don't know
-            # if the first semicolon on the line is a separator of
-            # expressions. It's just a guess.
-            column = @processed_source[line - 1].index(';')
-            convention_on(line, column, false)
-          end
-        end
-
-        private
-
-        def check_for_line_terminator_or_opener
-          each_semicolon { |line, column| convention_on(line, column, true) }
-        end
-
-        def each_semicolon
-          tokens_for_lines.each do |line, tokens|
-            yield line, tokens.last.pos.column if tokens.last.type == :tSEMI
-            yield line, tokens.first.pos.column if tokens.first.type == :tSEMI
-          end
-        end
-
-        def tokens_for_lines
-          @processed_source.tokens.group_by { |token| token.pos.line }
-        end
-
-        def convention_on(line, column, autocorrect)
-          range = source_range(@processed_source.buffer, line, column)
-          # Don't attempt to autocorrect if semicolon is separating statements
-          # on the same line
-          add_offense(autocorrect ? range : nil, range)
-        end
-
-        def autocorrect(range)
-          return unless range
-          ->(corrector) { corrector.remove(range) }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/send.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for the use of the send method.
-      class Send < Cop
-        MSG = 'Prefer `Object#__send__` or `Object#public_send` to ' \
-              '`send`.'.freeze
-
-        def_node_matcher :sending?, '(send _ :send $...)'
-
-        def on_send(node)
-          sending?(node) do |args|
-            return if args.empty?
-            add_offense(node, :selector)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/signal_exception.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for uses of `fail` and `raise`.
-      class SignalException < Cop
-        include ConfigurableEnforcedStyle
-
-        FAIL_MSG = 'Use `fail` instead of `raise` to signal exceptions.'.freeze
-        RAISE_MSG = 'Use `raise` instead of `fail` to ' \
-                    'rethrow exceptions.'.freeze
-
-        def_node_matcher :kernel_call?, '(send (const nil :Kernel) %1 ...)'
-        def_node_search :custom_fail_methods,
-                        '{(def :fail ...) (defs _ :fail ...)}'
-
-        def investigate(processed_source)
-          ast = processed_source.ast
-          @custom_fail_defined = ast && custom_fail_methods(ast).any?
-        end
-
-        def on_rescue(node)
-          return unless style == :semantic
-
-          begin_node, *rescue_nodes, _else_node = *node
-          check_scope(:raise, begin_node)
-
-          rescue_nodes.each do |rescue_node|
-            check_scope(:fail, rescue_node)
-            allow(:raise, rescue_node)
-          end
-        end
-
-        def on_send(node)
-          case style
-          when :semantic
-            check_send(:raise, node) unless ignored_node?(node)
-          when :only_raise
-            return if @custom_fail_defined
-            check_send(:fail, node)
-          when :only_fail
-            check_send(:raise, node)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            name =
-              case style
-              when :semantic
-                command_or_kernel_call?(:raise, node) ? 'fail' : 'raise'
-              when :only_raise then 'raise'
-              when :only_fail then 'fail'
-              end
-
-            corrector.replace(node.loc.selector, name)
-          end
-        end
-
-        private
-
-        def message(method_name)
-          case style
-          when :semantic
-            method_name == :fail ? RAISE_MSG : FAIL_MSG
-          when :only_raise
-            'Always use `raise` to signal exceptions.'
-          when :only_fail
-            'Always use `fail` to signal exceptions.'
-          end
-        end
-
-        def check_scope(method_name, node)
-          return unless node
-
-          each_command_or_kernel_call(method_name, node) do |send_node|
-            next if ignored_node?(send_node)
-
-            add_offense(send_node, :selector, message(method_name))
-            ignore_node(send_node)
-          end
-        end
-
-        def check_send(method_name, node)
-          return unless node && command_or_kernel_call?(method_name, node)
-
-          add_offense(node, :selector, message(method_name))
-        end
-
-        def command_or_kernel_call?(name, node)
-          node.command?(name) || kernel_call?(node, name)
-        end
-
-        def allow(method_name, node)
-          each_command_or_kernel_call(method_name, node) do |send_node|
-            ignore_node(send_node)
-          end
-        end
-
-        def each_command_or_kernel_call(method_name, node)
-          on_node(:send, node, :rescue) do |send_node|
-            yield send_node if command_or_kernel_call?(method_name, send_node)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/single_line_block_params.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks whether the block parameters of a single-line
-      # method accepting a block match the names specified via configuration.
-      #
-      # For instance one can configure `reduce`(`inject`) to use |a, e| as
-      # parameters.
-      class SingleLineBlockParams < Cop
-        def on_block(node)
-          # we care only for single line blocks
-          return unless block_length(node).zero?
-
-          method_node, args_node, _body_node = *node
-          receiver, method_name, _method_args = *method_node
-
-          # discard other scenarios
-          return unless receiver
-          return unless method_names.include?(method_name)
-
-          args = *args_node
-
-          return if args.empty?
-          # discard cases with argument destructuring
-          return true unless args.all?(&:arg_type?)
-          return if args_match?(method_name, args)
-
-          add_offense(args_node, :expression, message(method_name))
-        end
-
-        private
-
-        def message(method_name)
-          args = target_args(method_name).join(', ')
-          "Name `#{method_name}` block params `|#{args}|`."
-        end
-
-        def methods
-          cop_config['Methods']
-        end
-
-        def method_names
-          methods.map { |e| e.keys.first.to_sym }
-        end
-
-        def target_args(method_name)
-          method_name = method_name.to_s
-          method_hash = methods.find { |m| m.keys.first == method_name }
-          method_hash[method_name]
-        end
-
-        def args_match?(method_name, args)
-          actual_args = args.flat_map(&:to_a)
-
-          # Prepending an underscore to mark an unused parameter is allowed, so
-          # we remove any leading underscores before comparing.
-          actual_args_no_underscores = actual_args.map do |arg|
-            arg.to_s.sub(/^_+/, '')
-          end
-
-          actual_args_no_underscores == target_args(method_name)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/single_line_methods.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for single-line method definitions.
-      # It can optionally accept single-line methods with no body.
-      class SingleLineMethods < Cop
-        include AutocorrectAlignment
-        include OnMethodDef
-
-        MSG = 'Avoid single-line method definitions.'.freeze
-
-        def allow_empty?
-          cop_config['AllowIfMethodIsEmpty']
-        end
-
-        private
-
-        def on_method_def(node, _method_name, _args, body)
-          start_line = node.loc.keyword.line
-          end_line = node.loc.end.line
-
-          empty_body = body.nil?
-          return unless start_line == end_line && !(allow_empty? && empty_body)
-
-          @body = body
-          add_offense(node, :expression)
-        end
-
-        def autocorrect(node)
-          body = @body
-
-          lambda do |corrector|
-            each_part(body) do |part|
-              break_line_before(part, node, corrector, 1)
-            end
-
-            break_line_before(node.loc.end, node, corrector, 0)
-
-            eol_comment = end_of_line_comment(node.source_range.line)
-            move_comment(eol_comment, node, corrector) if eol_comment
-          end
-        end
-
-        def end_of_line_comment(line)
-          processed_source.comments.find { |c| c.loc.line == line }
-        end
-
-        def each_part(body)
-          return unless body
-
-          if body.begin_type?
-            body.each_child_node { |part| yield part.source_range }
-          else
-            yield body.source_range
-          end
-        end
-
-        def break_line_before(range, node, corrector, indent_steps)
-          corrector.insert_before(
-            range,
-            "\n" + ' ' * (node.loc.keyword.column +
-                          indent_steps * configured_indentation_width)
-          )
-        end
-
-        def move_comment(eol_comment, node, corrector)
-          text = eol_comment.loc.expression.source
-          corrector.insert_before(node.source_range,
-                                  text + "\n" + (' ' * node.loc.keyword.column))
-          corrector.remove(eol_comment.loc.expression)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/space_after_colon.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for colon (:) not followed by some kind of space.
-      # N.B. this cop does not handle spaces after a ternary operator, which are
-      # instead handled by Style/SpaceAroundOperators.
-      class SpaceAfterColon < Cop
-        include IfNode
-
-        MSG = 'Space missing after colon.'.freeze
-
-        def on_pair(node)
-          colon = node.loc.operator
-
-          return unless colon.is?(':')
-
-          add_offense(colon, colon) unless followed_by_space?(colon)
-        end
-
-        def on_kwoptarg(node)
-          # We have no direct reference to the colon source range following an
-          # optional keyword argument's name, so must construct one.
-          colon = node.loc.name.end.resize(1)
-
-          add_offense(colon, colon) unless followed_by_space?(colon)
-        end
-
-        private
-
-        def followed_by_space?(colon)
-          colon.source_buffer.source[colon.end_pos] =~ /\s/
-        end
-
-        def autocorrect(range)
-          ->(corrector) { corrector.insert_after(range, ' ') }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/space_after_comma.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for comma (,) not followed by some kind of space.
-      class SpaceAfterComma < Cop
-        include SpaceAfterPunctuation
-
-        def space_style_before_rcurly
-          cfg = config.for_cop('Style/SpaceInsideHashLiteralBraces')
-          cfg['EnforcedStyle'] || 'space'
-        end
-
-        def kind(token)
-          'comma' if token.type == :tCOMMA
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/space_after_method_name.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for space between a method name and a left parenthesis in defs.
-      #
-      # @example
-      #
-      #   # bad
-      #   def func (x) ... end
-      #
-      #   # good
-      #   def func(x) ... end
-      class SpaceAfterMethodName < Cop
-        include OnMethodDef
-
-        MSG = 'Do not put a space between a method name and the opening ' \
-              'parenthesis.'.freeze
-
-        def on_method_def(_node, _method_name, args, _body)
-          return unless args.loc.begin && args.loc.begin.is?('(')
-          expr = args.source_range
-          pos_before_left_paren = range_between(expr.begin_pos - 1,
-                                                expr.begin_pos)
-          return unless pos_before_left_paren.source =~ /\s/
-
-          add_offense(pos_before_left_paren, pos_before_left_paren)
-        end
-
-        def autocorrect(pos_before_left_paren)
-          ->(corrector) { corrector.remove(pos_before_left_paren) }
-        end
-      end
-    end
-  end
-end