dirwatch 0.0.6 → 0.0.7

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/implicit_string_concatenation.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for implicit string concatenation of string literals
-      # which are on the same line.
-      #
-      # @example
-      #   @bad
-      #   array = ['Item 1' 'Item 2']
-      #
-      #   @good
-      #   array = ['Item 1Item 2']
-      #   array = ['Item 1' + 'Item 2']
-      #   array = [
-      #     'Item 1' \
-      #     'Item 2'
-      #   ]
-      class ImplicitStringConcatenation < Cop
-        MSG = 'Combine %s and %s into a single string literal, rather than ' \
-              'using implicit string concatenation.'.freeze
-        FOR_ARRAY = ' Or, if they were intended to be separate array ' \
-                    'elements, separate them with a comma.'.freeze
-        FOR_METHOD = ' Or, if they were intended to be separate method ' \
-                     'arguments, separate them with a comma.'.freeze
-
-        def on_dstr(node)
-          each_bad_cons(node) do |child1, child2|
-            range   = child1.source_range.join(child2.source_range)
-            message = format(MSG, display_str(child1), display_str(child2))
-            if node.parent && node.parent.array_type?
-              message << FOR_ARRAY
-            elsif node.parent && node.parent.send_type?
-              message << FOR_METHOD
-            end
-            add_offense(node, range, message)
-          end
-        end
-
-        private
-
-        def each_bad_cons(node)
-          node.children.each_cons(2) do |child1, child2|
-            # `'abc' 'def'` -> (dstr (str "abc") (str "def"))
-            next unless string_literal?(child1) && string_literal?(child2)
-            next unless child1.loc.last_line == child2.loc.line
-
-            # Make sure we don't flag a string literal which simply has
-            # embedded newlines
-            # `"abc\ndef"` also -> (dstr (str "abc") (str "def"))
-            next unless child1.source[-1] == ending_delimiter(child1)
-
-            yield child1, child2
-          end
-        end
-
-        def ending_delimiter(str)
-          # implicit string concatenation does not work with %{}, etc.
-          if str.source[0] == "'"
-            "'"
-          elsif str.source[0] == '"'
-            '"'
-          end
-        end
-
-        def string_literal?(node)
-          node.str_type? ||
-            (node.dstr_type? && node.children.all? { |c| string_literal?(c) })
-        end
-
-        def display_str(node)
-          if node.source =~ /\n/
-            str_content(node).inspect
-          else
-            node.source
-          end
-        end
-
-        def str_content(node)
-          if node.str_type?
-            node.children[0]
-          else
-            node.children.map { |c| str_content(c) }.join
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/ineffective_access_modifier.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for `private` or `protected` access modifiers which are
-      # applied to a singleton method. These access modifiers do not make
-      # singleton methods private/protected. `private_class_method` can be
-      # used for that.
-      #
-      # @example
-      #   @bad
-      #   class C
-      #     private
-      #
-      #     def self.method
-      #       puts 'hi'
-      #     end
-      #   end
-      #
-      #   @good
-      #   class C
-      #     def self.method
-      #       puts 'hi'
-      #     end
-      #
-      #     private_class_method :method
-      #   end
-      #
-      #   class C
-      #     class << self
-      #       private
-      #
-      #       def method
-      #         puts 'hi'
-      #       end
-      #     end
-      #   end
-      class IneffectiveAccessModifier < Cop
-        MSG = '`%s` (on line %d) does not make singleton methods %s. ' \
-              'Use %s instead.'.freeze
-        ALTERNATIVE_PRIVATE = '`private_class_method` or `private` inside a ' \
-                              '`class << self` block'.freeze
-        ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` ' \
-                                'block'.freeze
-
-        def_node_matcher :access_modifier, <<-PATTERN
-          (send nil ${:public :protected :private})
-        PATTERN
-
-        def_node_matcher :private_class_method, <<-PATTERN
-          (send nil :private_class_method $...)
-        PATTERN
-
-        def on_class(node)
-          check_node(node.children[2]) # class body
-        end
-
-        def on_module(node)
-          check_node(node.children[1]) # module body
-        end
-
-        private
-
-        def clear
-          @useless = {}
-          @last_access_modifier = nil
-        end
-
-        def check_node(node)
-          return unless node && node.begin_type?
-
-          clear
-          check_scope(node)
-
-          @useless.each do |_name, (defs_node, visibility, modifier)|
-            add_offense(defs_node, :keyword,
-                        format_message(visibility, modifier))
-          end
-        end
-
-        def format_message(visibility, modifier)
-          alternative = if visibility == :private
-                          ALTERNATIVE_PRIVATE
-                        else
-                          ALTERNATIVE_PROTECTED
-                        end
-          format(MSG, visibility, modifier.location.expression.line, visibility,
-                 alternative)
-        end
-
-        def check_scope(node, cur_vis = :public)
-          node.children.reduce(cur_vis) do |visibility, child|
-            check_child_scope(child, visibility)
-          end
-        end
-
-        def check_child_scope(node, cur_vis)
-          if (new_vis = access_modifier(node))
-            cur_vis = change_visibility(node, new_vis)
-          elsif node.defs_type?
-            mark_method_as_useless(node, cur_vis) if cur_vis != :public
-          elsif (methods = private_class_method(node))
-            # don't warn about defs nodes which are followed by a call to
-            # `private_class_method :name`
-            # obviously the programmer knows what they are doing
-            revert_method_uselessness(methods)
-          elsif node.kwbegin_type?
-            cur_vis = check_scope(node, cur_vis)
-          end
-
-          cur_vis
-        end
-
-        def change_visibility(node, new_vis)
-          @last_access_modifier = node
-          new_vis
-        end
-
-        def mark_method_as_useless(node, cur_vis)
-          _, method_name, = *node
-          @useless[method_name] = [node, cur_vis, @last_access_modifier]
-        end
-
-        def revert_method_uselessness(methods)
-          methods.each do |sym|
-            next unless sym.sym_type?
-            @useless.delete(sym.children[0])
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/inherit_exception.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop looks for error classes inheriting from `Exception`
-      # and its standard library subclasses, excluding subclasses of
-      # `StandardError`. It is configurable to suggest using either
-      # `RuntimeError` (default) or `StandardError` instead.
-      #
-      # @example
-      #
-      #   # bad
-      #
-      #   class C < Exception; end
-      #
-      # @example
-      #
-      #   # EnforcedStyle: runtime_error (default)
-      #
-      #   # good
-      #
-      #   class C < RuntimeError; end
-      #
-      # @example
-      #
-      #   # EnforcedStyle: standard_error
-      #
-      #   # good
-      #
-      #   class C < StandardError; end
-      class InheritException < Cop
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Inherit from `%s` instead of `%s`.'.freeze
-        PREFERRED_BASE_CLASS = {
-          runtime_error: 'RuntimeError',
-          standard_error: 'StandardError'
-        }.freeze
-        ILLEGAL_CLASSES = %w(
-          Exception
-          SystemStackError
-          NoMemoryError
-          SecurityError
-          NotImplementedError
-          LoadError
-          SyntaxError
-          ScriptError
-          Interrupt
-          SignalException
-          SystemExit
-        ).freeze
-
-        def on_class(node)
-          _class, base_class, _body = *node
-
-          return if base_class.nil?
-
-          check(base_class)
-        end
-
-        private
-
-        def check(node)
-          return unless ILLEGAL_CLASSES.include?(node.const_name)
-
-          msg = format(MSG, preferred_base_class, node.const_name)
-          add_offense(node, :expression, msg)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, preferred_base_class)
-          end
-        end
-
-        def preferred_base_class
-          PREFERRED_BASE_CLASS[style]
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/invalid_character_literal.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for invalid character literals with a non-escaped
-      # whitespace character (e.g. `? `).
-      # However, currently it's unclear whether there's a way to emit this
-      # warning without syntax errors.
-      #
-      #     $ ruby -w
-      #     p(? )
-      #     -:1: warning: invalid character syntax; use ?\s
-      #     -:1: syntax error, unexpected '?', expecting ')'
-      #     p(? )
-      #        ^
-      #
-      # @example
-      #   p(? )
-      class InvalidCharacterLiteral < Cop
-        include ParserDiagnostic
-
-        private
-
-        def relevant_diagnostic?(diagnostic)
-          diagnostic.reason == :invalid_escape_use
-        end
-
-        def alternative_message(diagnostic)
-          diagnostic
-            .message
-            .capitalize
-            .gsub('character syntax', 'character literal')
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/literal_in_condition.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for literals used as the conditions or as
-      # operands in and/or expressions serving as the conditions of
-      # if/while/until.
-      #
-      # @example
-      #
-      #   if 20
-      #     do_something
-      #   end
-      #
-      #   if some_var && true
-      #     do_something
-      #   end
-      #
-      class LiteralInCondition < Cop
-        MSG = 'Literal `%s` appeared in a condition.'.freeze
-
-        def on_if(node)
-          check_for_literal(node)
-        end
-
-        def on_while(node)
-          check_for_literal(node)
-        end
-
-        def on_while_post(node)
-          check_for_literal(node)
-        end
-
-        def on_until(node)
-          check_for_literal(node)
-        end
-
-        def on_until_post(node)
-          check_for_literal(node)
-        end
-
-        def on_case(node)
-          cond, *whens, _else = *node
-
-          if cond
-            check_case_cond(cond)
-          else
-            whens.each do |when_node|
-              check_for_literal(when_node)
-            end
-          end
-        end
-
-        def message(node)
-          format(MSG, node.source)
-        end
-
-        private
-
-        def check_for_literal(node)
-          cond, = *node
-
-          # if the cond node is literal we obviously have a problem
-          if cond.literal?
-            add_offense(cond, :expression)
-          else
-            # alternatively we have to consider a logical node with a
-            # literal argument
-            check_node(cond)
-          end
-        end
-
-        def not?(node)
-          return false unless node && node.send_type?
-
-          _receiver, method_name, *_args = *node
-
-          method_name == :!
-        end
-
-        def basic_literal?(node)
-          if node && node.array_type?
-            primitive_array?(node)
-          else
-            node.basic_literal?
-          end
-        end
-
-        def primitive_array?(node)
-          node.children.all? { |n| basic_literal?(n) }
-        end
-
-        def check_node(node)
-          return unless node
-
-          if not?(node)
-            receiver, = *node
-
-            handle_node(receiver)
-          elsif [:and, :or].include?(node.type)
-            *operands = *node
-            operands.each do |op|
-              handle_node(op)
-            end
-          elsif node.begin_type? && node.children.one?
-            child_node = node.children.first
-            handle_node(child_node)
-          end
-        end
-
-        def handle_node(node)
-          if node.literal?
-            add_offense(node, :expression)
-          elsif [:send, :and, :or, :begin].include?(node.type)
-            check_node(node)
-          end
-        end
-
-        def check_case_cond(node)
-          return if node.array_type? && !primitive_array?(node)
-          return if node.dstr_type?
-
-          handle_node(node)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/literal_in_interpolation.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for interpolated literals.
-      #
-      # @example
-      #
-      #   "result is #{10}"
-      class LiteralInInterpolation < Cop
-        MSG = 'Literal interpolation detected.'.freeze
-        COMPOSITE = [:array, :hash, :pair, :irange, :erange].freeze
-
-        def on_dstr(node)
-          node.each_child_node(:begin) do |begin_node|
-            final_node = begin_node.children.last
-            next unless final_node
-            next if special_keyword?(final_node)
-            next unless prints_as_self?(final_node)
-
-            add_offense(final_node, :expression)
-          end
-        end
-
-        def autocorrect(node)
-          return if node.dstr_type? # nested, fixed in next iteration
-
-          value = autocorrected_value(node)
-          ->(corrector) { corrector.replace(node.parent.source_range, value) }
-        end
-
-        private
-
-        def special_keyword?(node)
-          # handle strings like __FILE__
-          (node.str_type? && !node.loc.respond_to?(:begin)) ||
-            node.source_range.is?('__LINE__')
-        end
-
-        def autocorrected_value(node)
-          case node.type
-          when :str
-            node.children.last
-          when :sym
-            autocorrected_value_for_symbol(node)
-          else
-            node.source.gsub('"', '\"')
-          end
-        end
-
-        def autocorrected_value_for_symbol(node)
-          end_pos =
-            node.loc.end ? node.loc.end.begin_pos : node.loc.expression.end_pos
-
-          range_between(node.loc.begin.end_pos, end_pos).source
-        end
-
-        # Does node print its own source when converted to a string?
-        def prints_as_self?(node)
-          node.basic_literal? ||
-            (COMPOSITE.include?(node.type) &&
-              node.children.all? { |child| prints_as_self?(child) })
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/loop.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for uses of *begin...end while/until something*.
-      class Loop < Cop
-        MSG = 'Use `Kernel#loop` with `break` rather than ' \
-              '`begin/end/until`(or `while`).'.freeze
-
-        def on_while_post(node)
-          register_offense(node)
-        end
-
-        def on_until_post(node)
-          register_offense(node)
-        end
-
-        private
-
-        def register_offense(node)
-          add_offense(node, :keyword)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/nested_method_definition.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for nested method definitions.
-      #
-      # @example
-      #   # `bar` definition actually produces methods in the same scope
-      #   # as the outer `foo` method. Furthermore, the `bar` method
-      #   # will be redefined every time `foo` is invoked.
-      #   def foo
-      #     def bar
-      #     end
-      #   end
-      #
-      class NestedMethodDefinition < Cop
-        include OnMethodDef
-        extend RuboCop::NodePattern::Macros
-
-        MSG = 'Method definitions must not be nested. ' \
-              'Use `lambda` instead.'.freeze
-
-        def on_method_def(node, _method_name, _args, _body)
-          find_nested_defs(node) do |nested_def_node|
-            add_offense(nested_def_node, :expression)
-          end
-        end
-
-        def find_nested_defs(node, &block)
-          node.each_child_node do |child|
-            if child.def_type?
-              yield child
-            elsif child.defs_type?
-              subject, = *child
-              next if subject.lvar_type?
-              yield child
-            elsif !ignored_child?(child)
-              find_nested_defs(child, &block)
-            end
-          end
-        end
-
-        private
-
-        def ignored_child?(child)
-          eval_call?(child) || class_or_module_or_struct_new_call?(child)
-        end
-
-        def_node_matcher :eval_call?, <<-PATTERN
-          (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
-        PATTERN
-
-        def_node_matcher :class_or_module_or_struct_new_call?, <<-PATTERN
-          (block (send (const nil {:Class :Module :Struct}) :new ...) ...)
-        PATTERN
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/lint/next_without_accumulator.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # Don't omit the accumulator when calling `next` in a `reduce` block.
-      #
-      # @example
-      #   # bad
-      #   result = (1..4).reduce(0) do |acc, i|
-      #     next if i.odd?
-      #     acc + i
-      #   end
-      #
-      #   # good
-      #   result = (1..4).reduce(0) do |acc, i|
-      #     next acc if i.odd?
-      #     acc + i
-      #   end
-      class NextWithoutAccumulator < Cop
-        MSG = 'Use `next` with an accumulator argument in a `reduce`.'.freeze
-
-        def_node_matcher :on_body_of_reduce, <<-PATTERN
-          (block (send _recv {:reduce :inject} !sym) _blockargs $(begin ...))
-        PATTERN
-
-        def on_block(node)
-          on_body_of_reduce(node) do |body|
-            void_next = body.each_node(:next).find do |n|
-              n.children.empty? && parent_block_node(n) == node
-            end
-
-            add_offense(void_next, :expression) if void_next
-          end
-        end
-
-        private
-
-        def parent_block_node(node)
-          node.each_ancestor(:block).first
-        end
-      end
-    end
-  end
-end