dirwatch 0.0.7 → 0.0.8

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of consistent method names
+      # from the String class.
+      class StringMethods < Cop
+        include MethodPreference
+
+        MSG = 'Prefer `%s` over `%s`.'.freeze
+
+        def on_send(node)
+          _receiver, method_name, *_args = *node
+          return unless preferred_methods[method_name]
+          add_offense(node, :selector,
+                      format(MSG,
+                             preferred_method(method_name),
+                             method_name))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              preferred_method(node.loc.selector.source))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for inheritance from Struct.new.
+      #
+      # @example
+      #   # bad
+      #   class Person < Struct.new(:first_name, :last_name)
+      #   end
+      #
+      #   # good
+      #   Person = Struct.new(:first_name, :last_name)
+      class StructInheritance < Cop
+        MSG = "Don't extend an instance initialized by `Struct.new`.".freeze
+
+        def on_class(node)
+          _name, superclass, _body = *node
+          return unless struct_constructor?(superclass)
+
+          add_offense(node, superclass.source_range, MSG)
+        end
+
+        private
+
+        def struct_constructor?(node)
+          return false unless node
+
+          send_node = node.block_type? ? node.children.first : node
+          return false unless send_node.send_type?
+
+          receiver, method_name = *send_node
+
+          receiver &&
+            receiver.const_type? &&
+            receiver.children.last == :Struct &&
+            method_name == :new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop can check for array literals made up of symbols that are not
+      # using the %i() syntax.
+      #
+      # Alternatively, it checks for symbol arrays using the %i() syntax on
+      # projects which do not want to use that syntax, perhaps because they
+      # support a version of Ruby lower than 2.0.
+      class SymbolArray < Cop
+        include ConfigurableEnforcedStyle
+        include ArraySyntax
+
+        PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'.freeze
+        ARRAY_MSG = 'Use `[]` for an array of symbols.'.freeze
+
+        def on_array(node)
+          if bracketed_array_of?(:sym, node)
+            check_bracketed_array(node)
+          elsif percent_array?(node)
+            check_percent_array(node)
+          end
+        end
+
+        def validate_config
+          return unless style == :percent && target_ruby_version < 2.0
+
+          raise ValidationError, 'The default `percent` style for the ' \
+                                '`Style/SymbolArray` cop is only compatible' \
+                                ' with Ruby 2.0 and up, but the target Ruby' \
+                                " version for your project is 1.9.\nPlease " \
+                                'either disable this cop, configure it to ' \
+                                'use `array` style, or adjust the ' \
+                                '`TargetRubyVersion` parameter in your ' \
+                                'configuration.'
+        end
+
+        private
+
+        def percent_array?(node)
+          node.loc.begin && node.loc.begin.source =~ /\A%[iI]/
+        end
+
+        def check_bracketed_array(node)
+          return if comments_in_array?(node)
+          return if symbols_contain_spaces?(node)
+
+          style_detected(:brackets)
+          add_offense(node, :expression, PERCENT_MSG) if style == :percent
+        end
+
+        def check_percent_array(node)
+          style_detected(:percent)
+          add_offense(node, :expression, ARRAY_MSG) if style == :brackets
+        end
+
+        def comments_in_array?(node)
+          comments = processed_source.comments
+          array_range = node.source_range.to_a
+
+          comments.any? do |comment|
+            !(comment.loc.expression.to_a & array_range).empty?
+          end
+        end
+
+        def symbols_contain_spaces?(node)
+          node.children.any? do |sym|
+            content, = *sym
+            content =~ / /
+          end
+        end
+
+        def autocorrect(node)
+          syms = node.children.map { |c| c.children[0].to_s }
+          corrected = if style == :percent
+                        percent_replacement(syms)
+                      else
+                        bracket_replacement(syms)
+                      end
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, corrected)
+          end
+        end
+
+        def percent_replacement(syms)
+          escape = syms.any? { |s| needs_escaping?(s) }
+          syms = syms.map { |s| escape_string(s) } if escape
+          syms = syms.map { |s| s.gsub(/\)/, '\\)') }
+          if escape
+            "%I(#{syms.join(' ')})"
+          else
+            "%i(#{syms.join(' ')})"
+          end
+        end
+
+        def bracket_replacement(syms)
+          syms = syms.map { |s| to_symbol_literal(s) }
+          "[#{syms.join(', ')}]"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks symbol literal syntax.
+      #
+      # @example
+      #
+      #   # bad
+      #   :"symbol"
+      #
+      #   # good
+      #   :symbol
+      class SymbolLiteral < Cop
+        MSG = 'Do not use strings for word-like symbol literals.'.freeze
+
+        def on_sym(node)
+          return unless node.source =~ /\A:["'][A-Za-z_]\w*["']\z/
+
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, node.source.delete(%q('")))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use symbols as procs when possible.
+      #
+      # @example
+      #   # bad
+      #   something.map { |s| s.upcase }
+      #
+      #   # good
+      #   something.map(&:upcase)
+      class SymbolProc < Cop
+        MSG = 'Pass `&:%s` as an argument to `%s` instead of a block.'.freeze
+        SUPER_TYPES = [:super, :zsuper].freeze
+
+        def_node_matcher :proc_node?, '(send (const nil :Proc) :new)'
+        def_node_matcher :symbol_proc?, <<-PATTERN
+          (block
+            ${(send ...) (super ...) zsuper}
+            $(args (arg _))
+            $(send lvar $_))
+        PATTERN
+
+        def on_block(node)
+          symbol_proc?(node) do |send_or_super, block_args, block_body, method|
+            block_method_name = resolve_block_method_name(send_or_super)
+
+            # TODO: Rails-specific handling that we should probably make
+            # configurable - https://github.com/bbatsov/rubocop/issues/1485
+            # we should ignore lambdas & procs
+            return if proc_node?(send_or_super)
+            return if [:lambda, :proc].include?(block_method_name)
+            return if ignored_method?(block_method_name)
+            return unless can_shorten?(block_args, block_body)
+
+            offense(node, method, block_method_name)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            block_send_or_super, _block_args, block_body = *node
+            _receiver, method_name, _args = *block_body
+
+            if super?(block_send_or_super)
+              args = *block_send_or_super
+            else
+              _breceiver, _bmethod_name, *args = *block_send_or_super
+            end
+            autocorrect_method(corrector, node, args, method_name)
+          end
+        end
+
+        private
+
+        def resolve_block_method_name(block_send_or_super)
+          return :super if super?(block_send_or_super)
+
+          _receiver, method_name, _args = *block_send_or_super
+          method_name
+        end
+
+        def offense(node, method_name, block_method_name)
+          block_start = node.loc.begin.begin_pos
+          block_end = node.loc.end.end_pos
+          range = range_between(block_start, block_end)
+
+          add_offense(node,
+                      range,
+                      format(MSG,
+                             method_name,
+                             block_method_name))
+        end
+
+        def autocorrect_method(corrector, node, args, method_name)
+          if args.empty?
+            autocorrect_no_args(corrector, node, method_name)
+          else
+            autocorrect_with_args(corrector, node, args, method_name)
+          end
+        end
+
+        def autocorrect_no_args(corrector, node, method_name)
+          corrector.replace(block_range_with_space(node), "(&:#{method_name})")
+        end
+
+        def autocorrect_with_args(corrector, node, args, method_name)
+          arg_range = args.last.source_range
+          arg_range = range_with_surrounding_comma(arg_range, :right)
+          replacement = " &:#{method_name}"
+          replacement = ',' + replacement unless arg_range.source.end_with?(',')
+          corrector.insert_after(arg_range, replacement)
+          corrector.remove(block_range_with_space(node))
+        end
+
+        def block_range_with_space(node)
+          block_range = range_between(begin_pos_for_replacement(node),
+                                      node.loc.end.end_pos)
+          range_with_surrounding_space(block_range, :left)
+        end
+
+        def begin_pos_for_replacement(node)
+          block_send_or_super, _block_args, _block_body = *node
+          expr = block_send_or_super.source_range
+
+          if (paren_pos = (expr.source =~ /\(\s*\)$/))
+            expr.begin_pos + paren_pos
+          else
+            node.loc.begin.begin_pos
+          end
+        end
+
+        def ignored_methods
+          cop_config['IgnoredMethods']
+        end
+
+        def ignored_method?(name)
+          ignored_methods.include?(name.to_s)
+        end
+
+        def can_shorten?(block_args, block_body)
+          argument_matches_receiver?(block_args, block_body)
+        end
+
+        # TODO: This might be clearer as a node matcher with unification
+        def argument_matches_receiver?(block_args, block_body)
+          receiver, = *block_body
+
+          block_arg_name, = *block_args.children.first
+          receiver_name, = *receiver
+
+          block_arg_name == receiver_name
+        end
+
+        def super?(node)
+          SUPER_TYPES.include?(node.type)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for tabs inside the source code.
+      class Tab < Cop
+        MSG = 'Tab detected.'.freeze
+
+        def investigate(processed_source)
+          str_lines = string_literal_lines(processed_source.ast)
+
+          processed_source.lines.each_with_index do |line, index|
+            match = line.match(/^( *)[\t ]*\t/)
+            next unless match
+            next if str_lines.include?(index + 1)
+
+            spaces = match.captures[0]
+            range = source_range(processed_source.buffer,
+                                 index + 1,
+                                 (spaces.length)...(match.end(0)))
+
+            add_offense(range, range, MSG)
+          end
+        end
+
+        private
+
+        def autocorrect(range)
+          lambda do |corrector|
+            corrector.replace(range, range.source.gsub(/\t/, '  '))
+          end
+        end
+
+        def string_literal_lines(ast)
+          # which lines start inside a string literal?
+          return [] if ast.nil?
+
+          ast.each_node(:str, :dstr).each_with_object(Set.new) do |str, lines|
+            loc = str.location
+
+            str_lines = if loc.is_a?(Parser::Source::Map::Heredoc)
+                          body = loc.heredoc_body
+                          (body.first_line)..(body.last_line)
+                        else
+                          (loc.first_line + 1)..(loc.last_line)
+                        end
+
+            lines.merge(str_lines.to_a)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the presence of parentheses around ternary
+      # conditions. It is configurable to enforce inclusion or omission of
+      # parentheses using `EnforcedStyle`.
+      #
+      # @example
+      #
+      #   EnforcedStyle: require_no_parentheses (default)
+      #
+      #   @bad
+      #   foo = (bar?) ? a : b
+      #   foo = (bar.baz) ? a : b
+      #   foo = (bar && baz) ? a : b
+      #
+      #   @good
+      #   foo = bar? ? a : b
+      #   foo = bar.baz? ? a : b
+      #   foo = bar && baz ? a : b
+      #
+      # @example
+      #
+      #   EnforcedStyle: require_parentheses
+      #
+      #   @bad
+      #   foo = bar? ? a : b
+      #   foo = bar.baz? ? a : b
+      #   foo = bar && baz ? a : b
+      #
+      #   @good
+      #   foo = (bar?) ? a : b
+      #   foo = (bar.baz) ? a : b
+      #   foo = (bar && baz) ? a : b
+      #
+      # @example
+      #
+      #   EnforcedStyle: require_parentheses_when_complex
+      #
+      #   @bad
+      #   foo = (bar?) ? a : b
+      #   foo = (bar.baz?) ? a : b
+      #   foo = bar && baz ? a : b
+      #
+      #   @good
+      #   foo = bar? ? a : b
+      #   foo = bar.baz ? a : b
+      #   foo = (bar && baz) ? a : b
+      class TernaryParentheses < Cop
+        include IfNode
+        include SafeAssignment
+        include ConfigurableEnforcedStyle
+
+        MSG = '%s parentheses for ternary conditions.'.freeze
+        MSG_COMPLEX = '%s parentheses for ternary expressions with' \
+          ' complex conditions.'.freeze
+
+        def on_if(node)
+          return unless ternary?(node) && !infinite_loop? && offense?(node)
+          add_offense(node, node.source_range, message(node))
+        end
+
+        private
+
+        def offense?(node)
+          condition, = *node
+
+          if safe_assignment?(condition)
+            !safe_assignment_allowed?
+          else
+            parens = parenthesized?(condition)
+            case style
+            when :require_parentheses_when_complex
+              complex_condition?(condition) ? !parens : parens
+            else
+              require_parentheses? ? !parens : parens
+            end
+          end
+        end
+
+        def autocorrect(node)
+          condition, = *node
+
+          return nil if parenthesized?(condition) &&
+                        (safe_assignment?(condition) ||
+                        unsafe_autocorrect?(condition))
+
+          lambda do |corrector|
+            if parenthesized?(condition)
+              corrector.remove(condition.loc.begin)
+              corrector.remove(condition.loc.end)
+            else
+              corrector.insert_before(condition.source_range, '(')
+              corrector.insert_after(condition.source_range, ')')
+            end
+          end
+        end
+
+        # If the condition is parenthesized we recurse and check for any
+        # complex expressions within it.
+        def complex_condition?(condition)
+          if condition.type == :begin
+            condition.to_a.any? { |x| complex_condition?(x) }
+          else
+            non_complex_type?(condition) ? false : true
+          end
+        end
+
+        # Anything that is not a variable, constant, or method/.method call
+        # will be counted as a complex expression.
+        def non_complex_type?(condition)
+          condition.variable? || condition.const_type? ||
+            (condition.send_type? && !operator?(condition.method_name)) ||
+            condition.defined_type?
+        end
+
+        def message(node)
+          if require_parentheses_when_complex?
+            condition, = *node
+            omit = parenthesized?(condition) ? 'Only use' : 'Use'
+            format(MSG_COMPLEX, omit)
+          else
+            verb = require_parentheses? ? 'Use' : 'Omit'
+            format(MSG, verb)
+          end
+        end
+
+        def require_parentheses?
+          style == :require_parentheses
+        end
+
+        def require_parentheses_when_complex?
+          style == :require_parentheses_when_complex
+        end
+
+        def redundant_parentheses_enabled?
+          @config.for_cop('RedundantParentheses')['Enabled']
+        end
+
+        def parenthesized?(node)
+          node.begin_type?
+        end
+
+        # When this cop is configured to enforce parentheses and the
+        # `RedundantParentheses` cop is enabled, it will cause an infinite loop
+        # as they compete to add and remove the parentheses respectively.
+        def infinite_loop?
+          require_parentheses? &&
+            redundant_parentheses_enabled?
+        end
+
+        def unsafe_autocorrect?(condition)
+          condition.children.any? do |child|
+            unparenthesized_method_call?(child)
+          end
+        end
+
+        def unparenthesized_method_call?(child)
+          argument = method_call_argument(child)
+          argument && argument !~ /^\(/
+        end
+
+        def_node_matcher :method_call_argument, <<-PATTERN
+          {(:defined? $...)
+           (send {(send ...) nil} _ $(send nil _)...)}
+        PATTERN
+      end
+    end
+  end
+end