dirwatch 0.0.6 → 0.0.7

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/performance/fixed_size.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Do not compute the size of statically sized objects.
-      class FixedSize < Cop
-        MSG = 'Do not compute the size of statically sized objects.'.freeze
-
-        def_node_matcher :counter, <<-MATCHER
-          (send ${array hash str sym} {:count :length :size} $...)
-        MATCHER
-
-        def on_send(node)
-          return if allowed_parent?(node.parent)
-
-          counter(node) do |var, arg|
-            return if allowed_variable?(var) || allowed_argument?(arg)
-
-            add_offense(node, :expression)
-          end
-        end
-
-        private
-
-        def allowed_variable?(var)
-          contains_splat?(var) || contains_double_splat?(var)
-        end
-
-        def allowed_argument?(arg)
-          arg && non_string_argument?(arg.first)
-        end
-
-        def allowed_parent?(node)
-          node && (node.casgn_type? || node.block_type?)
-        end
-
-        def contains_splat?(node)
-          return unless node.array_type?
-
-          node.each_child_node(:splat).any?
-        end
-
-        def contains_double_splat?(node)
-          return unless node.hash_type?
-
-          node.each_child_node(:kwsplat).any?
-        end
-
-        def non_string_argument?(node)
-          node && !node.str_type?
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/performance/flat_map.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop is used to identify usages of
-      #
-      # @example
-      #   # bad
-      #   [1, 2, 3, 4].map { |e| [e, e] }.flatten(1)
-      #   [1, 2, 3, 4].collect { |e| [e, e] }.flatten(1)
-      #
-      #   # good
-      #   [1, 2, 3, 4].flat_map { |e| [e, e] }
-      #   [1, 2, 3, 4].map { |e| [e, e] }.flatten
-      #   [1, 2, 3, 4].collect { |e| [e, e] }.flatten
-      class FlatMap < Cop
-        MSG = 'Use `flat_map` instead of `%s...%s`.'.freeze
-        FLATTEN_MULTIPLE_LEVELS = ' Beware, `flat_map` only flattens 1 level ' \
-                                  'and `flatten` can be used to flatten ' \
-                                  'multiple levels.'.freeze
-
-        def_node_matcher :flat_map_candidate?, <<-PATTERN
-          (send (block $(send _ ${:collect :map}) ...) ${:flatten :flatten!} $...)
-        PATTERN
-
-        def on_send(node)
-          flat_map_candidate?(node) do |map_node, first_method, flatten, params|
-            flatten_level, = *params.first
-            if cop_config['EnabledForFlattenWithoutParams'] &&
-               flatten_level.nil?
-              offense_for_levels(node, map_node, first_method, flatten)
-            elsif flatten_level == 1
-              offense_for_method(node, map_node, first_method, flatten)
-            end
-          end
-        end
-
-        def autocorrect(node)
-          map_node, _first_method, _flatten, params = flat_map_candidate?(node)
-          flatten_level, = *params.first
-          return if flatten_level.nil?
-
-          lambda do |corrector|
-            range = range_between(node.loc.dot.begin_pos,
-                                  node.source_range.end_pos)
-
-            corrector.remove(range)
-            corrector.replace(map_node.loc.selector, 'flat_map')
-          end
-        end
-
-        private
-
-        def offense_for_levels(node, map_node, first_method, flatten)
-          message = MSG + FLATTEN_MULTIPLE_LEVELS
-          offense(node, map_node, first_method, flatten, message)
-        end
-
-        def offense_for_method(node, map_node, first_method, flatten)
-          offense(node, map_node, first_method, flatten, MSG)
-        end
-
-        def offense(node, map_node, first_method, flatten, message)
-          range = range_between(map_node.loc.selector.begin_pos,
-                                node.loc.expression.end_pos)
-
-          add_offense(node, range, format(message, first_method, flatten))
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/performance/hash_each_methods.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop checks for uses of `each_key` & `each_value` Hash methods.
-      #
-      # @example
-      #   # bad
-      #   hash.keys.each { |k| p k }
-      #   hash.values.each { |v| p v }
-      #   hash.each { |k, _v| p k }
-      #   hash.each { |_k, v| p v }
-      #
-      #   # good
-      #   hash.each_key { |k| p k }
-      #   hash.each_value { |v| p v }
-      class HashEachMethods < Cop
-        include Lint::UnusedArgument
-
-        MSG = 'Use `%s` instead of `%s`.'.freeze
-
-        def_node_matcher :plain_each, <<-END
-          (block $(send (send _ :hash) :each) (args (arg $_k) (arg $_v)) ...)
-        END
-
-        def_node_matcher :kv_each, <<-END
-          (block $(send (send (send _ :hash) ${:keys :values}) :each) ...)
-        END
-
-        def on_block(node)
-          plain_each(node) do |target, k, v|
-            return if @args[k] && @args[v]
-            used = @args[k] ? :key : :value
-            add_offense(target, range(target), format(message,
-                                                      "each_#{used}",
-                                                      :each))
-          end
-          kv_each(node) do |target, method|
-            add_offense(target, range(target), format(message,
-                                                      "each_#{method[0..-2]}",
-                                                      "#{method}.each"))
-          end
-        end
-
-        def check_argument(variable)
-          return unless variable.block_argument?
-          (@args ||= {})[variable.name] = variable.used?
-        end
-
-        def autocorrect(node)
-          receiver, _second_method = *node
-          caller, first_method = *receiver
-          lambda do |corrector|
-            if first_method == :hash
-              method = @args.values.first ? :key : :value
-              new_source = receiver.source + ".each_#{method}"
-              corrector.replace(node.loc.expression, new_source)
-              correct_args(node, corrector)
-            else
-              new_source = caller.source + ".each_#{first_method[0..-2]}"
-              corrector.replace(node.loc.expression, new_source)
-            end
-          end
-        end
-
-        private
-
-        def correct_args(node, corrector)
-          args = node.parent.children[1]
-          used_arg = "|#{@args.detect { |_k, v| v }.first}|"
-          args_range = range_between(args.loc.begin.begin_pos,
-                                     args.loc.end.end_pos)
-          corrector.replace(args_range, used_arg)
-        end
-
-        def range(outer_node)
-          inner_node = outer_node.children.first
-          inner_node.loc.selector.join(outer_node.loc.selector)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/performance/lstrip_rstrip.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies places where `lstrip.rstrip` can be replaced by
-      # `strip`.
-      #
-      # @example
-      #   @bad
-      #   'abc'.lstrip.rstrip
-      #   'abc'.rstrip.lstrip
-      #
-      #   @good
-      #   'abc'.strip
-      class LstripRstrip < Cop
-        MSG = 'Use `strip` instead of `%s.%s`.'.freeze
-
-        def_node_matcher :lstrip_rstrip, <<-END
-          {(send $(send _ $:rstrip) $:lstrip)
-           (send $(send _ $:lstrip) $:rstrip)}
-        END
-
-        def on_send(node)
-          lstrip_rstrip(node) do |first_send, method_one, method_two|
-            range = range_between(first_send.loc.selector.begin_pos,
-                                  node.source_range.end_pos)
-            add_offense(node, range, format(MSG, method_one, method_two))
-          end
-        end
-
-        def autocorrect(node)
-          first_send, = *node
-          range = range_between(first_send.loc.selector.begin_pos,
-                                node.source_range.end_pos)
-          ->(corrector) { corrector.replace(range, 'strip') }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/performance/range_include.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies uses of `Range#include?`, which iterates over each
-      # item in a `Range` to see if a specified item is there. In contrast,
-      # `Range#cover?` simply compares the target item with the beginning and
-      # end points of the `Range`. In a great majority of cases, this is what
-      # is wanted.
-      #
-      # Here is an example of a case where `Range#cover?` may not provide the
-      # desired result:
-      #
-      #     ('a'..'z').cover?('yellow') # => true
-      #
-      class RangeInclude < Cop
-        MSG = 'Use `Range#cover?` instead of `Range#include?`.'.freeze
-
-        # TODO: If we traced out assignments of variables to their uses, we
-        # might pick up on a few more instances of this issue
-        # Right now, we only detect direct calls on a Range literal
-        # (We don't even catch it if the Range is in double parens)
-
-        def_node_matcher :range_include, <<-END
-          (send {irange erange (begin {irange erange})} :include? ...)
-        END
-
-        def on_send(node)
-          add_offense(node, :selector, MSG) if range_include(node)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'cover?') }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/performance/redundant_block_call.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies the use of a `&block` parameter and `block.call`
-      # where `yield` would do just as well.
-      #
-      # @example
-      #   @bad
-      #   def method(&block)
-      #     block.call
-      #   end
-      #   def another(&func)
-      #     func.call 1, 2, 3
-      #   end
-      #
-      #   @good
-      #   def method
-      #     yield
-      #   end
-      #   def another
-      #     yield 1, 2, 3
-      #   end
-      class RedundantBlockCall < Cop
-        MSG = 'Use `yield` instead of `%s.call`.'.freeze
-        YIELD = 'yield'.freeze
-        OPEN_PAREN = '('.freeze
-        CLOSE_PAREN = ')'.freeze
-        SPACE = ' '.freeze
-
-        def_node_matcher :blockarg_def, <<-END
-          {(def  _   (args ... (blockarg $_)) $_)
-           (defs _ _ (args ... (blockarg $_)) $_)}
-        END
-
-        def_node_search :blockarg_calls, <<-END
-          (send (lvar %1) :call ...)
-        END
-
-        def_node_search :blockarg_assigned?, <<-END
-          (lvasgn %1 ...)
-        END
-
-        def on_def(node)
-          blockarg_def(node) do |argname, body|
-            next unless body
-
-            calls_to_report(argname, body).each do |blockcall|
-              add_offense(blockcall, :expression, format(MSG, argname))
-            end
-          end
-        end
-
-        private
-
-        def calls_to_report(argname, body)
-          return [] if blockarg_assigned?(body, argname)
-
-          calls = to_enum(:blockarg_calls, body, argname)
-
-          return [] if calls.any? { |call| args_include_block_pass?(call) }
-
-          calls
-        end
-
-        def args_include_block_pass?(blockcall)
-          _receiver, _call, *args = *blockcall
-
-          args.any?(&:block_pass_type?)
-        end
-
-        # offenses are registered on the `block.call` nodes
-        def autocorrect(node)
-          _receiver, _method, *args = *node
-          new_source = String.new(YIELD)
-          unless args.empty?
-            new_source += if parentheses?(node)
-                            OPEN_PAREN
-                          else
-                            SPACE
-                          end
-
-            new_source << args.map(&:source).join(', ')
-          end
-
-          new_source << CLOSE_PAREN if parentheses?(node) && !args.empty?
-          ->(corrector) { corrector.replace(node.source_range, new_source) }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/performance/redundant_match.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies use of `Regexp#match` or `String#match in a context
-      # where the integral return value of `=~` would do just as well.
-      #
-      # @example
-      #   @bad
-      #   do_something if str.match(/regex/)
-      #   while regex.match('str')
-      #     do_something
-      #   end
-      #
-      #   @good
-      #   method(str.match(/regex/))
-      #   return regex.match('str')
-      class RedundantMatch < Cop
-        MSG = 'Use `=~` in places where the `MatchData` returned by ' \
-              '`#match` will not be used.'.freeze
-
-        # 'match' is a fairly generic name, so we don't flag it unless we see
-        # a string or regexp literal on one side or the other
-        def_node_matcher :match_call?, <<-END
-          {(send {str regexp} :match _)
-           (send !nil :match {str regexp})}
-        END
-
-        def_node_matcher :only_truthiness_matters?, <<-END
-          ^({if while until case while_post until_post} equal?(%0) ...)
-        END
-
-        def on_send(node)
-          return unless match_call?(node) &&
-                        (!node.value_used? || only_truthiness_matters?(node)) &&
-                        !(node.parent && node.parent.block_type?)
-          add_offense(node, :expression, MSG)
-        end
-
-        def autocorrect(node)
-          receiver, _method, arg = *node
-
-          # Regexp#match can take a second argument, but this cop doesn't
-          # register an offense in that case
-          return unless arg.regexp_type?
-
-          new_source = receiver.source + ' =~ ' + arg.source
-          ->(corrector) { corrector.replace(node.source_range, new_source) }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/performance/redundant_merge.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies places where `Hash#merge!` can be replaced by
-      # `Hash#[]=`.
-      #
-      # @example
-      #   hash.merge!(a: 1)
-      #   hash.merge!({'key' => 'value'})
-      #   hash.merge!(a: 1, b: 2)
-      class RedundantMerge < Cop
-        AREF_ASGN = '%s[%s] = %s'.freeze
-        MSG = 'Use `%s` instead of `%s`.'.freeze
-
-        def_node_matcher :redundant_merge, '(send $_ :merge! (hash $...))'
-        def_node_matcher :modifier_flow_control?, <<-END
-          [{if while until} modifier_form?]
-        END
-
-        def on_send(node)
-          each_redundant_merge(node) do |receiver, pairs|
-            assignments = to_assignments(receiver, pairs).join('; ')
-            message = format(MSG, assignments, node.source)
-            add_offense(node, :expression, message)
-          end
-        end
-
-        def autocorrect(node)
-          redundant_merge(node) do |receiver, pairs|
-            new_source = to_assignments(receiver, pairs).join("\n")
-
-            parent = node.parent
-            if parent && pairs.size > 1
-              correct_multiple_elements(node, parent, new_source)
-            else
-              correct_single_element(node, new_source)
-            end
-          end
-        end
-
-        private
-
-        def each_redundant_merge(node)
-          redundant_merge(node) do |receiver, pairs|
-            next unless receiver
-            next if node.value_used? &&
-                    !EachWithObjectInspector.new(node, receiver).value_used?
-            next if pairs.size > 1 && !receiver.pure?
-            next if pairs.size > max_key_value_pairs
-
-            yield receiver, pairs
-          end
-        end
-
-        def correct_multiple_elements(node, parent, new_source)
-          if modifier_flow_control?(parent)
-            new_source = rewrite_with_modifier(node, parent, new_source)
-            node = parent
-          else
-            padding = "\n#{leading_spaces(node)}"
-            new_source.gsub!(/\n/, padding)
-          end
-
-          ->(corrector) { corrector.replace(node.source_range, new_source) }
-        end
-
-        def correct_single_element(node, new_source)
-          ->(corrector) { corrector.replace(node.source_range, new_source) }
-        end
-
-        def to_assignments(receiver, pairs)
-          pairs.map do |pair|
-            key, value = *pair
-            key_src = if key.sym_type? && !key.source.start_with?(':')
-                        ":#{key.source}"
-                      else
-                        key.source
-                      end
-
-            format(AREF_ASGN, receiver.source, key_src, value.source)
-          end
-        end
-
-        def rewrite_with_modifier(node, parent, new_source)
-          cond, = *parent
-          padding = "\n#{(' ' * indent_width) + leading_spaces(node)}"
-          new_source.gsub!(/\n/, padding)
-
-          parent.loc.keyword.source << ' ' << cond.source << padding <<
-            new_source << "\n" << leading_spaces(node) << 'end'
-        end
-
-        def leading_spaces(node)
-          node.source_range.source_line[/\A\s*/]
-        end
-
-        def indent_width
-          @config.for_cop('IndentationWidth')['Width'] || 2
-        end
-
-        def max_key_value_pairs
-          cop_config['MaxKeyValuePairs'].to_i
-        end
-
-        # A utility class for checking the use of values within an
-        # `each_with_object` call.
-        class EachWithObjectInspector
-          extend NodePattern::Macros
-
-          def initialize(node, receiver)
-            @node = node
-            @receiver = unwind(receiver)
-          end
-
-          def value_used?
-            return false unless eligible_receiver? && second_argument
-
-            receiver.loc.name.source == second_argument.loc.name.source
-          end
-
-          private
-
-          attr_reader :node, :receiver
-
-          def eligible_receiver?
-            receiver.respond_to?(:lvar_type?) && receiver.lvar_type?
-          end
-
-          def second_argument
-            parent = node.parent
-            parent = parent.parent if parent.begin_type?
-
-            @second_argument ||= each_with_object_node(parent)
-          end
-
-          def unwind(receiver)
-            while receiver.respond_to?(:send_type?) && receiver.send_type?
-              receiver, = *receiver
-            end
-            receiver
-          end
-
-          def_node_matcher :each_with_object_node, <<-END
-            (block (send _ :each_with_object _) (args _ $_) ...)
-          END
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/performance/redundant_sort_by.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies places where `sort_by { ... }` can be replaced by
-      # `sort`.
-      #
-      # @example
-      #   @bad
-      #   array.sort_by { |x| x }
-      #   array.sort_by do |var|
-      #     var
-      #   end
-      #
-      #   @good
-      #   array.sort
-      class RedundantSortBy < Cop
-        MSG = 'Use `sort` instead of `sort_by { |%s| %s }`.'.freeze
-
-        def_node_matcher :redundant_sort_by, <<-END
-          (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
-        END
-
-        def on_block(node)
-          redundant_sort_by(node) do |send, var_name|
-            range = sort_by_range(send, node)
-            add_offense(node, range, format(MSG, var_name, var_name))
-          end
-        end
-
-        def autocorrect(node)
-          send, = *node
-          ->(corrector) { corrector.replace(sort_by_range(send, node), 'sort') }
-        end
-
-        private
-
-        def sort_by_range(send, node)
-          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/performance/reverse_each.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop is used to identify usages of `reverse.each` and
-      # change them to use `reverse_each` instead.
-      #
-      # @example
-      #   # bad
-      #   [].reverse.each
-      #
-      #   # good
-      #   [].reverse_each
-      class ReverseEach < Cop
-        MSG = 'Use `reverse_each` instead of `reverse.each`.'.freeze
-        UNDERSCORE = '_'.freeze
-
-        def_node_matcher :reverse_each?, <<-MATCHER
-          (send $(send array :reverse) :each)
-        MATCHER
-
-        def on_send(node)
-          reverse_each?(node) do |receiver|
-            location_of_reverse = receiver.loc.selector.begin_pos
-            end_location = node.loc.selector.end_pos
-
-            range = range_between(location_of_reverse, end_location)
-            add_offense(node, range, MSG)
-          end
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.dot, UNDERSCORE) }
-        end
-      end
-    end
-  end
-end