dirwatch 0.0.6 → 0.0.7

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for using Fixnum or Bignum constant.
-      #
-      # @example
-      #   # bad
-      #   1.is_a?(Fixnum)
-      #   1.is_a?(Bignum)
-      #
-      #   # good
-      #   1.is_a?(Integer)
-      class UnifiedInteger < Cop
-        MSG = 'Use `Integer` instead of `%s`.'.freeze
-
-        def_node_matcher :fixnum_or_bignum_const?, <<-PATTERN
-          (:const {nil (:cbase)} ${:Fixnum :Bignum})
-        PATTERN
-
-        def on_const(node)
-          klass = fixnum_or_bignum_const?(node)
-          return unless klass
-
-          add_offense(node, :expression, format(MSG, klass))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.name, 'Integer')
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,207 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop detects instances of rubocop:disable comments that can be
-      # removed without causing any offenses to be reported. It's implemented
-      # as a cop in that it inherits from the Cop base class and calls
-      # add_offense. The unusual part of its implementation is that it doesn't
-      # have any on_* methods or an investigate method. This means that it
-      # doesn't take part in the investigation phase when the other cops do
-      # their work. Instead, it waits until it's called in a later stage of the
-      # execution. The reason it can't be implemented as a normal cop is that
-      # it depends on the results of all other cops to do its work.
-      class UnneededDisable < Cop
-        include NameSimilarity
-
-        COP_NAME = 'Lint/UnneededDisable'.freeze
-
-        def check(offenses, cop_disabled_line_ranges, comments)
-          unneeded_cops = Hash.new { |h, k| h[k] = Set.new }
-
-          each_unneeded_disable(cop_disabled_line_ranges,
-                                offenses, comments) do |comment, unneeded_cop|
-            unneeded_cops[comment].add(unneeded_cop)
-          end
-
-          add_offenses(unneeded_cops)
-        end
-
-        def autocorrect(args)
-          lambda do |corrector|
-            ranges, range = *args # Ranges are sorted by position.
-
-            range = if range.source.start_with?('#')
-                      comment_range_with_surrounding_space(range)
-                    else
-                      directive_range_in_list(range, ranges)
-                    end
-
-            corrector.remove(range)
-          end
-        end
-
-        private
-
-        def comment_range_with_surrounding_space(range)
-          # Eat the entire comment, the preceding space, and the preceding
-          # newline if there is one.
-          original_begin = range.begin_pos
-          range = range_with_surrounding_space(range, :left, true)
-          range_with_surrounding_space(range, :right,
-                                       # Special for a comment that
-                                       # begins the file: remove
-                                       # the newline at the end.
-                                       original_begin.zero?)
-        end
-
-        def directive_range_in_list(range, ranges)
-          # Is there any cop between this one and the end of the line, which
-          # is NOT being removed?
-          if ends_its_line?(ranges.last) && trailing_range?(ranges, range)
-            # Eat the comma on the left.
-            range = range_with_surrounding_space(range, :left)
-            range = range_with_surrounding_comma(range, :left)
-          end
-
-          range = range_with_surrounding_comma(range, :right)
-          # Eat following spaces up to EOL, but not the newline itself.
-          range_with_surrounding_space(range, :right, false)
-        end
-
-        def each_unneeded_disable(cop_disabled_line_ranges, offenses, comments)
-          disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
-
-          cop_disabled_line_ranges.each do |cop, line_ranges|
-            each_already_disabled(line_ranges, comments) do |comment|
-              yield comment, cop
-            end
-
-            line_ranges.each do |line_range|
-              comment = comments.find { |c| c.loc.line == line_range.begin }
-
-              unless all_disabled?(comment)
-                next if ignore_offense?(disabled_ranges, line_range)
-              end
-
-              unneeded_cop = find_unneeded(comment, offenses, cop, line_range)
-              yield comment, unneeded_cop if unneeded_cop
-            end
-          end
-        end
-
-        def each_already_disabled(line_ranges, comments)
-          line_ranges.each_cons(2) do |previous_range, range|
-            next if previous_range.end != range.begin
-
-            # If a cop is disabled in a range that begins on the same line as
-            # the end of the previous range, it means that the cop was
-            # already disabled by an earlier comment. So it's unneeded
-            # whether there are offenses or not.
-            yield comments.find { |c| c.loc.line == range.begin }
-          end
-        end
-
-        def find_unneeded(comment, offenses, cop, line_range)
-          if all_disabled?(comment)
-            'all' if offenses.none? { |o| line_range.cover?(o.line) }
-          else
-            cop_offenses = offenses.select { |o| o.cop_name == cop }
-            cop if cop_offenses.none? { |o| line_range.cover?(o.line) }
-          end
-        end
-
-        def all_disabled?(comment)
-          comment.text =~ /rubocop:disable\s+all\b/
-        end
-
-        def ignore_offense?(disabled_ranges, line_range)
-          disabled_ranges.any? do |range|
-            range.cover?(line_range.min) && range.cover?(line_range.max)
-          end
-        end
-
-        def directive_count(comment)
-          match = comment.text.match(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-          _, cops_string = match.captures
-          cops_string.split(/,\s*/).size
-        end
-
-        def add_offenses(unneeded_cops)
-          unneeded_cops.each do |comment, cops|
-            if all_disabled?(comment) ||
-               directive_count(comment) == cops.size
-              add_offense_for_entire_comment(comment, cops)
-            else
-              add_offense_for_some_cops(comment, cops)
-            end
-          end
-        end
-
-        def add_offense_for_entire_comment(comment, cops)
-          location = comment.loc.expression
-          cop_list = cops.sort.map { |c| describe(c) }
-          add_offense([[location], location], location,
-                      "Unnecessary disabling of #{cop_list.join(', ')}.")
-        end
-
-        def add_offense_for_some_cops(comment, cops)
-          cop_ranges = cops.map { |c| [c, cop_range(comment, c)] }
-          cop_ranges.sort_by! { |_, r| r.begin_pos }
-          ranges = cop_ranges.map { |_, r| r }
-
-          cop_ranges.each do |cop, range|
-            add_offense([ranges, range], range,
-                        "Unnecessary disabling of #{describe(cop)}.")
-          end
-        end
-
-        def cop_range(comment, cop)
-          matching_range(comment.loc.expression, cop) ||
-            matching_range(comment.loc.expression, cop.split('/').last) ||
-            raise("Couldn't find #{cop} in comment: #{comment.text}")
-        end
-
-        def matching_range(haystack, needle)
-          offset = (haystack.source =~ Regexp.new(Regexp.escape(needle)))
-          return unless offset
-          offset += haystack.begin_pos
-          Parser::Source::Range.new(haystack.source_buffer, offset,
-                                    offset + needle.size)
-        end
-
-        def trailing_range?(ranges, range)
-          ranges
-            .drop_while { |r| !r.equal?(range) }
-            .each_cons(2)
-            .map { |r1, r2| r1.end.join(r2.begin).source }
-            .all? { |intervening| intervening =~ /\A\s*,\s*\Z/ }
-        end
-
-        def describe(cop)
-          if cop == 'all'
-            'all cops'
-          elsif all_cop_names.include?(cop)
-            "`#{cop}`"
-          else
-            similar = find_similar_name(cop, [])
-            if similar
-              "`#{cop}` (did you mean `#{similar}`?)"
-            else
-              "`#{cop}` (unknown cop)"
-            end
-          end
-        end
-
-        def collect_variable_like_names(scope)
-          all_cop_names.each { |name| scope << name }
-        end
-
-        def all_cop_names
-          @all_cop_names ||= Cop.all.map(&:cop_name)
-        end
-      end
-    end
-  end
-end

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

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for unneeded usages of splat expansion
-      #
-      # @example
-      #   # bad
-      #   a = *[1, 2, 3]
-      #   a = *'a'
-      #   a = *1
-      #
-      #   begin
-      #     foo
-      #   rescue *[StandardError, ApplicationError]
-      #     bar
-      #   end
-      #
-      #   case foo
-      #   when *[1, 2, 3]
-      #     bar
-      #   else
-      #     baz
-      #   end
-      #
-      #   # good
-      #   c = [1, 2, 3]
-      #   a = *c
-      #   a, b = *c
-      #   a, *b = *c
-      #   a = *1..10
-      #   a = ['a']
-      #
-      #   begin
-      #     foo
-      #   rescue StandardError, ApplicationError
-      #     bar
-      #   end
-      #
-      #   case foo
-      #   when *[1, 2, 3]
-      #     bar
-      #   else
-      #     baz
-      #   end
-      class UnneededSplatExpansion < Cop
-        MSG = 'Unnecessary splat expansion.'.freeze
-        ARRAY_PARAM_MSG = 'Pass array contents as separate arguments.'.freeze
-        PERCENT_W = '%w'.freeze
-        PERCENT_CAPITAL_W = '%W'.freeze
-        PERCENT_I = '%i'.freeze
-        PERCENT_CAPITAL_I = '%I'.freeze
-        ARRAY_NEW_PATTERN = '$(send (const nil :Array) :new ...)'.freeze
-        ASSIGNMENT_TYPES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn].freeze
-
-        def_node_matcher :literal_expansion?, <<-PATTERN
-          (splat {$({str dstr int float array} ...) (block #{ARRAY_NEW_PATTERN} ...) #{ARRAY_NEW_PATTERN}} ...)
-        PATTERN
-
-        def on_splat(node)
-          literal_expansion?(node) do |object|
-            if object.send_type?
-              return unless ASSIGNMENT_TYPES.include?(node.parent.parent.type)
-            end
-
-            if array_splat?(node) &&
-               (method_argument?(node) || part_of_an_array?(node))
-              add_offense(node, :expression, ARRAY_PARAM_MSG)
-            else
-              add_offense(node, :expression)
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(node)
-          variable, = *node
-          loc = node.loc
-
-          lambda do |corrector|
-            if !variable.array_type?
-              corrector.replace(loc.expression, "[#{variable.source}]")
-            elsif unneeded_brackets?(node)
-              corrector.replace(loc.expression, remove_brackets(variable))
-            else
-              corrector.remove(loc.operator)
-            end
-          end
-        end
-
-        def array_splat?(node)
-          node.children.first.array_type?
-        end
-
-        def method_argument?(node)
-          node.parent.send_type?
-        end
-
-        def part_of_an_array?(node)
-          # The parent of a splat expansion is an array that does not have
-          # `begin` or `end`
-          parent = node.parent
-          parent.array_type? && parent.loc.begin && parent.loc.end
-        end
-
-        def unneeded_brackets?(node)
-          parent = node.parent
-          grandparent = node.parent.parent
-
-          parent.when_type? || parent.send_type? || part_of_an_array?(node) ||
-            (grandparent && grandparent.resbody_type?)
-        end
-
-        def remove_brackets(array)
-          array_start = array.loc.begin.source
-          elements = *array
-          elements = elements.map(&:source)
-
-          if array_start.start_with?(PERCENT_W)
-            "'#{elements.join("', '")}'"
-          elsif array_start.start_with?(PERCENT_CAPITAL_W)
-            %("#{elements.join('", "')}")
-          elsif array_start.start_with?(PERCENT_I)
-            ":#{elements.join(', :')}"
-          elsif array_start.start_with?(PERCENT_CAPITAL_I)
-            %(:"#{elements.join('", :"')}")
-          else
-            elements.join(', ')
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for unreachable code.
-      # The check are based on the presence of flow of control
-      # statement in non-final position in *begin*(implicit) blocks.
-      class UnreachableCode < Cop
-        MSG = 'Unreachable code detected.'.freeze
-
-        NODE_TYPES = [:return, :next, :break, :retry, :redo].freeze
-        FLOW_COMMANDS = [:throw, :raise, :fail].freeze
-
-        def on_begin(node)
-          expressions = *node
-
-          expressions.each_cons(2) do |e1, e2|
-            next unless NODE_TYPES.include?(e1.type) || flow_command?(e1)
-            add_offense(e2, :expression)
-          end
-        end
-
-        private
-
-        def flow_command?(node)
-          FLOW_COMMANDS.any? { |c| node.command?(c) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for unused block arguments.
-      #
-      # @example
-      #
-      #   #good
-      #
-      #   do_something do |used, unused|
-      #     puts used
-      #   end
-      #
-      #   do_something do
-      #     puts :foo
-      #   end
-      #
-      #   define_method(:foo) do |_bar|
-      #     puts :baz
-      #   end
-      #
-      #   # bad
-      #
-      #   do_something do |used, _unused|
-      #     puts used
-      #   end
-      #
-      #   do_something do |bar|
-      #     puts :foo
-      #   end
-      #
-      #   define_method(:foo) do |bar|
-      #     puts :baz
-      #   end
-      class UnusedBlockArgument < Cop
-        include UnusedArgument
-
-        private
-
-        def check_argument(variable)
-          return if allowed_block?(variable) ||
-                    allowed_keyword_argument?(variable)
-
-          super
-        end
-
-        def allowed_block?(variable)
-          !variable.block_argument? ||
-            (ignore_empty_blocks? && empty_block?(variable))
-        end
-
-        def allowed_keyword_argument?(variable)
-          variable.keyword_argument? &&
-            allow_unused_keyword_arguments?
-        end
-
-        def message(variable)
-          message = "Unused #{variable_type(variable)} - `#{variable.name}`."
-
-          if variable.explicit_block_local_variable?
-            message
-          else
-            augment_message(message, variable)
-          end
-        end
-
-        def augment_message(message, variable)
-          scope = variable.scope
-          all_arguments = scope.variables.each_value.select(&:block_argument?)
-
-          augmentation = if scope.node.lambda?
-                           message_for_lambda(variable, all_arguments)
-                         else
-                           message_for_normal_block(variable, all_arguments)
-                         end
-
-          [message, augmentation].join(' ')
-        end
-
-        def variable_type(variable)
-          if variable.explicit_block_local_variable?
-            'block local variable'
-          else
-            'block argument'
-          end
-        end
-
-        def message_for_normal_block(variable, all_arguments)
-          if all_arguments.none?(&:referenced?) &&
-             !define_method_call?(variable)
-            if all_arguments.count > 1
-              "You can omit all the arguments if you don't care about them."
-            else
-              "You can omit the argument if you don't care about it."
-            end
-          else
-            message_for_underscore_prefix(variable)
-          end
-        end
-
-        def message_for_lambda(variable, all_arguments)
-          message = message_for_underscore_prefix(variable)
-
-          if all_arguments.none?(&:referenced?)
-            proc_message = 'Also consider using a proc without arguments ' \
-                           'instead of a lambda if you want it ' \
-                           "to accept any arguments but don't care about them."
-          end
-
-          [message, proc_message].compact.join(' ')
-        end
-
-        def message_for_underscore_prefix(variable)
-          "If it's necessary, use `_` or `_#{variable.name}` " \
-          "as an argument name to indicate that it won't be used."
-        end
-
-        def define_method_call?(variable)
-          call, = *variable.scope.node
-          _, method, = *call
-
-          method == :define_method
-        end
-
-        def empty_block?(variable)
-          _send, _args, body = *variable.scope.node
-
-          body.nil?
-        end
-
-        def allow_unused_keyword_arguments?
-          cop_config['AllowUnusedKeywordArguments']
-        end
-
-        def ignore_empty_blocks?
-          cop_config['IgnoreEmptyBlocks']
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for unused method arguments.
-      #
-      # @example
-      #
-      #   def some_method(used, unused, _unused_but_allowed)
-      #     puts used
-      #   end
-      class UnusedMethodArgument < Cop
-        include UnusedArgument
-
-        def check_argument(variable)
-          return unless variable.method_argument?
-          return if variable.keyword_argument? &&
-                    cop_config['AllowUnusedKeywordArguments']
-
-          if cop_config['IgnoreEmptyMethods']
-            _name, _args, body = *variable.scope.node
-            return if body.nil?
-          end
-
-          super
-        end
-
-        def message(variable)
-          message = String.new("Unused method argument - `#{variable.name}`.")
-
-          unless variable.keyword_argument?
-            message << " If it's necessary, use `_` or `_#{variable.name}` " \
-                       "as an argument name to indicate that it won't be used."
-          end
-
-          scope = variable.scope
-          all_arguments = scope.variables.each_value.select(&:method_argument?)
-
-          if all_arguments.none?(&:referenced?)
-            message << " You can also write as `#{scope.name}(*)` " \
-                       'if you want the method to accept any arguments ' \
-                       "but don't care about them."
-          end
-
-          message
-        end
-      end
-    end
-  end
-end