dirwatch 0.0.6 → 0.0.7

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

@@ -1,179 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Place `when` conditions that use splat at the end
-      # of the list of `when` branches.
-      #
-      # Ruby has to allocate memory for the splat expansion every time
-      # that the `case` `when` statement is run. Since Ruby does not support
-      # fall through inside of `case` `when`, like some other languages do,
-      # the order of the `when` branches does not matter. By placing any
-      # splat expansions at the end of the list of `when` branches we will
-      # reduce the number of times that memory has to be allocated for
-      # the expansion.
-      #
-      # This is not a guaranteed performance improvement. If the data being
-      # processed by the `case` condition is normalized in a manner that favors
-      # hitting a condition in the splat expansion, it is possible that
-      # moving the splat condition to the end will use more memory,
-      # and run slightly slower.
-      #
-      # @example
-      #   # bad
-      #   case foo
-      #   when *condition
-      #     bar
-      #   when baz
-      #     foobar
-      #   end
-      #
-      #   case foo
-      #   when *[1, 2, 3, 4]
-      #     bar
-      #   when 5
-      #     baz
-      #   end
-      #
-      #   # good
-      #   case foo
-      #   when baz
-      #     foobar
-      #   when *condition
-      #     bar
-      #   end
-      #
-      #   case foo
-      #   when 1, 2, 3, 4
-      #     bar
-      #   when 5
-      #     baz
-      #   end
-      class CaseWhenSplat < Cop
-        include AutocorrectAlignment
-
-        MSG = 'Place `when` conditions with a splat ' \
-              'at the end of the `when` branches.'.freeze
-        ARRAY_MSG = 'Do not expand array literals in `when` conditions.'.freeze
-        PERCENT_W = '%w'.freeze
-        PERCENT_CAPITAL_W = '%W'.freeze
-        PERCENT_I = '%i'.freeze
-        PERCENT_CAPITAL_I = '%I'.freeze
-
-        def on_case(node)
-          _case_branch, *when_branches, _else_branch = *node
-          when_conditions =
-            when_branches.each_with_object([]) do |branch, conditions|
-              *condition, _ = *branch
-              condition.each { |c| conditions << c }
-            end
-
-          splat_offenses(when_conditions).reverse_each do |condition|
-            range = condition.parent.loc.keyword.join(condition.source_range)
-            variable, = *condition
-            message = variable.array_type? ? ARRAY_MSG : MSG
-            add_offense(condition.parent, range, message)
-          end
-        end
-
-        def autocorrect(node)
-          *conditions, _body = *node
-
-          lambda do |corrector|
-            if needs_reorder?(node)
-              reorder_condition(corrector, node, replacement(conditions))
-            else
-              inline_fix_branch(corrector, node, conditions,
-                                replacement(conditions))
-            end
-          end
-        end
-
-        private
-
-        def replacement(conditions)
-          ordered_conditions = conditions.partition { |cond| !cond.splat_type? }
-          ordered_conditions.flatten!
-          ordered_conditions.map!(&:source)
-          ordered_conditions.join(', ')
-        end
-
-        def inline_fix_branch(corrector, _node, conditions, new_condition)
-          range = range_between(conditions[0].loc.expression.begin_pos,
-                                conditions[-1].loc.expression.end_pos)
-          corrector.replace(range, new_condition)
-        end
-
-        def reorder_condition(corrector, node, new_condition)
-          *_conditions, body = *node
-          _case_branch, *when_branches, _else_branch = *node.parent
-          return if when_branches.size == 1 # Can't reorder one branch
-
-          corrector.remove(when_branch_range(node, when_branches))
-
-          correction = if same_line?(node, body)
-                         new_condition_with_then(node, new_condition)
-                       else
-                         new_branch_without_then(node, body, new_condition)
-                       end
-
-          corrector.insert_after(when_branches.last.source_range, correction)
-        end
-
-        def when_branch_range(node, when_branches)
-          current_index = when_branches.index { |branch| branch == node }
-          next_branch = when_branches[current_index + 1]
-
-          range_between(node.source_range.begin_pos,
-                        next_branch.source_range.begin_pos)
-        end
-
-        def same_line?(node, other)
-          node.loc.first_line == other.loc.first_line
-        end
-
-        def new_condition_with_then(node, new_condition)
-          "\n#{' ' * node.loc.column}when " \
-          "#{new_condition} then #{node.children.last.source}"
-        end
-
-        def new_branch_without_then(node, body, new_condition)
-          "\n#{' ' * node.loc.column}when #{new_condition}\n" \
-          "#{' ' * body.loc.column}#{node.children.last.source}"
-        end
-
-        def splat_offenses(when_conditions)
-          found_non_splat = false
-          when_conditions.reverse.each_with_object([]) do |condition, result|
-            found_non_splat ||= error_condition?(condition)
-
-            next unless condition.splat_type?
-            variable, = *condition
-            next if variable.array_type?
-            result << condition if found_non_splat
-          end
-        end
-
-        def error_condition?(condition)
-          variable, = *condition
-
-          (condition.splat_type? && variable.array_type?) ||
-            !condition.splat_type?
-        end
-
-        def needs_reorder?(node)
-          _case_condition, *when_branches, _else_branch = *node.parent
-          current_index = when_branches.index { |branch| branch == node }
-          when_branches[(current_index + 1)..-1].any? do |branch|
-            *conditions, _ = *branch
-            conditions.none? do |condition|
-              variable, = *condition
-              condition.splat_type? && !(variable && variable.array_type?)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies places where a case-insensitive string comparison
-      # can better be implemented using `casecmp`.
-      #
-      # @example
-      #   @bad
-      #   str.downcase == 'abc'
-      #   str.upcase.eql? 'ABC'
-      #   'abc' == str.downcase
-      #   'ABC'.eql? str.upcase
-      #   str.downcase == str.downcase
-      #
-      #   @good
-      #   str.casecmp('ABC').zero?
-      #   'abc'.casecmp(str).zero?
-      class Casecmp < Cop
-        MSG = 'Use `casecmp` instead of `%s %s`.'.freeze
-        CASE_METHODS = [:downcase, :upcase].freeze
-
-        def_node_matcher :downcase_eq, <<-END
-          (send
-            $(send _ ${:downcase :upcase})
-            ${:== :eql? :!=}
-            ${str (send _ {:downcase :upcase} ...) (begin str)})
-        END
-
-        def_node_matcher :eq_downcase, <<-END
-          (send
-            {str (send _ {:downcase :upcase} ...) (begin str)}
-            ${:== :eql? :!=}
-            $(send _ ${:downcase :upcase}))
-        END
-
-        def on_send(node)
-          return if part_of_ignored_node?(node)
-
-          inefficient_comparison(node) do |range, is_other_part, *methods|
-            ignore_node(node) if is_other_part
-            add_offense(node, range, format(MSG, *methods))
-          end
-        end
-
-        def autocorrect(node)
-          downcase_eq(node) do
-            receiver, method, arg = *node
-            variable, = *receiver
-            return correction(node, receiver, method, arg, variable)
-          end
-
-          eq_downcase(node) do
-            arg, method, receiver = *node
-            variable, = *receiver
-            return correction(node, receiver, method, arg, variable)
-          end
-        end
-
-        private
-
-        def inefficient_comparison(node)
-          loc = node.loc
-
-          downcase_eq(node) do |send_downcase, case_method, eq_method, other|
-            *_, method = *other
-            range, is_other_part = downcase_eq_range(method, loc, send_downcase)
-
-            yield range, is_other_part, case_method, eq_method
-            return
-          end
-
-          eq_downcase(node) do |eq_method, send_downcase, case_method|
-            range = loc.selector.join(send_downcase.loc.selector)
-            yield range, false, eq_method, case_method
-          end
-        end
-
-        def downcase_eq_range(method, loc, send_downcase)
-          if CASE_METHODS.include?(method)
-            [loc.expression, true]
-          else
-            [loc.selector.join(send_downcase.loc.selector), false]
-          end
-        end
-
-        def correction(node, _receiver, method, arg, variable)
-          lambda do |corrector|
-            corrector.insert_before(node.loc.expression, '!') if method == :!=
-
-            # we want resulting call to be parenthesized
-            # if arg already includes one or more sets of parens, don't add more
-            # or if method call already used parens, again, don't add more
-            replacement = if arg.send_type? || !parentheses?(arg)
-                            "#{variable.source}.casecmp(#{arg.source}).zero?"
-                          else
-                            "#{variable.source}.casecmp#{arg.source}.zero?"
-                          end
-
-            corrector.replace(node.loc.expression, replacement)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies places where `sort { |a, b| a.foo <=> b.foo }`
-      # can be replaced by `sort_by(&:foo)`.
-      # This cop also checks `max` and `min` methods.
-      #
-      # @example
-      #   @bad
-      #   array.sort { |a, b| a.foo <=> b.foo }
-      #   array.max { |a, b| a.foo <=> b.foo }
-      #   array.min { |a, b| a.foo <=> b.foo }
-      #
-      #   @good
-      #   array.sort_by(&:foo)
-      #   array.sort_by { |v| v.foo }
-      #   array.sort_by do |var|
-      #     var.foo
-      #   end
-      #   array.max_by(&:foo)
-      #   array.min_by(&:foo)
-      class CompareWithBlock < Cop
-        MSG = 'Use `%s_by(&:%s)` instead of ' \
-              '`%s { |%s, %s| %s.%s <=> %s.%s }`.'.freeze
-
-        def_node_matcher :compare?, <<-END
-          (block $(send _ {:sort :min :max}) (args (arg $_a) (arg $_b)) (send (send (lvar _a) $_m) :<=> (send (lvar _b) $_m)))
-        END
-
-        def on_block(node)
-          compare?(node) do |send, var_a, var_b, method|
-            range = compare_range(send, node)
-            compare_method = send.method_name
-            add_offense(node, range,
-                        format(MSG, compare_method, method,
-                               compare_method, var_a, var_b,
-                               var_a, method, var_b, method))
-          end
-        end
-
-        def autocorrect(node)
-          send, = *node
-
-          lambda do |corrector|
-            method = node.children.last.children.last.children.last
-            corrector.replace(compare_range(send, node),
-                              "#{send.method_name}_by(&:#{method})")
-          end
-        end
-
-        private
-
-        def compare_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/count.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop is used to identify usages of `count` on an `Enumerable` that
-      # follow calls to `select` or `reject`. Querying logic can instead be
-      # passed to the `count` call.
-      #
-      # @example
-      #   # bad
-      #   [1, 2, 3].select { |e| e > 2 }.size
-      #   [1, 2, 3].reject { |e| e > 2 }.size
-      #   [1, 2, 3].select { |e| e > 2 }.length
-      #   [1, 2, 3].reject { |e| e > 2 }.length
-      #   [1, 2, 3].select { |e| e > 2 }.count { |e| e.odd? }
-      #   [1, 2, 3].reject { |e| e > 2 }.count { |e| e.even? }
-      #   array.select(&:value).count
-      #
-      #   # good
-      #   [1, 2, 3].count { |e| e > 2 }
-      #   [1, 2, 3].count { |e| e < 2 }
-      #   [1, 2, 3].count { |e| e > 2 && e.odd? }
-      #   [1, 2, 3].count { |e| e < 2 && e.even? }
-      #   Model.select('field AS field_one').count
-      #   Model.select(:value).count
-      #
-      # `ActiveRecord` compatibility:
-      # `ActiveRecord` will ignore the block that is passed to `count`.
-      # Other methods, such as `select`, will convert the association to an
-      # array and then run the block on the array. A simple work around to
-      # make `count` work with a block is to call `to_a.count {...}`.
-      #
-      # Example:
-      #   Model.where(id: [1, 2, 3].select { |m| m.method == true }.size
-      #
-      #   becomes:
-      #
-      #   Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }
-      class Count < Cop
-        include SafeMode
-
-        MSG = 'Use `count` instead of `%s...%s`.'.freeze
-
-        def_node_matcher :count_candidate?, <<-PATTERN
-          {
-            (send (block $(send _ ${:select :reject}) ...) ${:count :length :size})
-            (send $(send _ ${:select :reject} (:block_pass _)) ${:count :length :size})
-          }
-        PATTERN
-
-        def on_send(node)
-          return if rails_safe_mode?
-
-          count_candidate?(node) do |selector_node, selector, counter|
-            return unless eligible_node?(node)
-
-            range = source_starting_at(node) do
-              selector_node.loc.selector.begin_pos
-            end
-
-            add_offense(node, range, format(MSG, selector, counter))
-          end
-        end
-
-        private
-
-        def autocorrect(node)
-          selector_node, selector, _counter = count_candidate?(node)
-          selector_loc = selector_node.loc.selector
-
-          return if selector == :reject
-
-          range = source_starting_at(node) { |n| n.loc.dot.begin_pos }
-
-          lambda do |corrector|
-            corrector.remove(range)
-            corrector.replace(selector_loc, 'count')
-          end
-        end
-
-        def eligible_node?(node)
-          !(node.parent && node.parent.block_type?)
-        end
-
-        def source_starting_at(node)
-          begin_pos = if block_given?
-                        yield node
-                      else
-                        node.source_range.begin_pos
-                      end
-
-          range_between(begin_pos, node.source_range.end_pos)
-        end
-      end
-    end
-  end
-end

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

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop is used to identify usages of
-      # `select.first`, `select.last`, `find_all.first`, and `find_all.last`
-      # and change them to use `detect` instead.
-      #
-      # @example
-      #   # bad
-      #   [].select { |item| true }.first
-      #   [].select { |item| true }.last
-      #   [].find_all { |item| true }.first
-      #   [].find_all { |item| true }.last
-      #
-      #   # good
-      #   [].detect { |item| true }
-      #   [].reverse.detect { |item| true }
-      #
-      # `ActiveRecord` compatibility:
-      # `ActiveRecord` does not implement a `detect` method and `find` has its
-      # own meaning. Correcting ActiveRecord methods with this cop should be
-      # considered unsafe.
-      class Detect < Cop
-        include SafeMode
-
-        MSG = 'Use `%s` instead of `%s.%s`.'.freeze
-        REVERSE_MSG = 'Use `reverse.%s` instead of `%s.%s`.'.freeze
-
-        def_node_matcher :detect_candidate?, <<-PATTERN
-          {
-            (send $(block (send _ {:select :find_all}) ...) ${:first :last} $...)
-            (send $(send _ {:select :find_all} ...) ${:first :last} $...)
-          }
-        PATTERN
-
-        def on_send(node)
-          return if rails_safe_mode?
-
-          detect_candidate?(node) do |receiver, second_method, args|
-            return unless args.empty?
-            return unless receiver
-
-            receiver, _args, body = *receiver if receiver.block_type?
-            return if accept_first_call?(receiver, body)
-
-            offense(node, receiver, second_method)
-          end
-        end
-
-        def autocorrect(node)
-          receiver, first_method = *node
-
-          replacement = if first_method == :last
-                          "reverse.#{preferred_method}"
-                        else
-                          preferred_method
-                        end
-
-          first_range = receiver.source_range.end.join(node.loc.selector)
-
-          receiver, _args, _body = *receiver if receiver.block_type?
-
-          lambda do |corrector|
-            corrector.remove(first_range)
-            corrector.replace(receiver.loc.selector, replacement)
-          end
-        end
-
-        private
-
-        def accept_first_call?(receiver, body)
-          caller, _first_method, args = *receiver
-
-          # check that we have usual block or block pass
-          return true if body.nil? && (args.nil? || !args.block_pass_type?)
-
-          lazy?(caller)
-        end
-
-        def offense(node, receiver, second_method)
-          _caller, first_method, _args = *receiver
-          range = receiver.loc.selector.join(node.loc.selector)
-
-          message = second_method == :last ? REVERSE_MSG : MSG
-          add_offense(node, range, format(message,
-                                          preferred_method,
-                                          first_method,
-                                          second_method))
-        end
-
-        def preferred_method
-          config.for_cop('Style/CollectionMethods') \
-            ['PreferredMethods']['detect'] || 'detect'
-        end
-
-        def lazy?(node)
-          return false if node.nil?
-          receiver, method, _args = *node
-          method == :lazy && !receiver.nil?
-        end
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop checks for double `#start_with?` or `#end_with?` calls
-      # separated by `||`. In some cases such calls can be replaced
-      # with an single `#start_with?`/`#end_with?` call.
-      #
-      # @example
-      #
-      #   @bad
-      #   str.start_with?("a") || str.start_with?(Some::CONST)
-      #   str.start_with?("a", "b") || str.start_with?("c")
-      #   var1 = ...
-      #   var2 = ...
-      #   str.end_with?(var1) || str.end_with?(var2)
-      #
-      #   @good
-      #   str.start_with?("a", Some::CONST)
-      #   str.start_with?("a", "b", "c")
-      #   var1 = ...
-      #   var2 = ...
-      #   str.end_with?(var1, var2)
-      class DoubleStartEndWith < Cop
-        MSG = 'Use `%{receiver}.%{method}(%{combined_args})` ' \
-              'instead of `%{original_code}`.'.freeze
-
-        def on_or(node)
-          receiver,
-          method,
-          first_call_args,
-          second_call_args = two_start_end_with_calls(node)
-
-          return unless receiver && second_call_args.all?(&:pure?)
-
-          combined_args = combine_args(first_call_args, second_call_args)
-
-          add_offense_for_double_call(node, receiver, method, combined_args)
-        end
-
-        private
-
-        def combine_args(first_call_args, second_call_args)
-          (first_call_args + second_call_args).map(&:source).join(', ')
-        end
-
-        def add_offense_for_double_call(node, receiver, method, combined_args)
-          add_offense(node,
-                      :expression,
-                      format(
-                        MSG,
-                        receiver: receiver.source,
-                        method: method,
-                        combined_args: combined_args,
-                        original_code: node.source
-                      ))
-        end
-
-        def_node_matcher :two_start_end_with_calls, <<-END
-          (or
-            (send $_recv [{:start_with? :end_with?} $_method] $...)
-            (send _recv _method $...))
-        END
-      end
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies unnecessary use of a regex where `String#end_with?`
-      # would suffice.
-      #
-      # @example
-      #   @bad
-      #   'abc' =~ /bc\Z/
-      #   'abc'.match(/bc\Z/)
-      #
-      #   @good
-      #   'abc' =~ /ab/
-      #   'abc' =~ /\w*\Z/
-      class EndWith < Cop
-        MSG = 'Use `String#end_with?` instead of a regex match anchored to ' \
-              'the end of the string.'.freeze
-        SINGLE_QUOTE = "'".freeze
-
-        def_node_matcher :redundant_regex?, <<-END
-          {(send $!nil {:match :=~} (regexp (str $#literal_at_end?) (regopt)))
-           (send (regexp (str $#literal_at_end?) (regopt)) {:match :=~} $_)}
-        END
-
-        def literal_at_end?(regex_str)
-          # is this regexp 'literal' in the sense of only matching literal
-          # chars, rather than using metachars like . and * and so on?
-          # also, is it anchored at the end of the string?
-          regex_str =~ /\A(?:#{LITERAL_REGEX})+\\z\z/
-        end
-
-        def on_send(node)
-          add_offense(node, :expression, MSG) if redundant_regex?(node)
-        end
-
-        def autocorrect(node)
-          redundant_regex?(node) do |receiver, regex_str|
-            receiver, regex_str = regex_str, receiver if receiver.is_a?(String)
-            regex_str = regex_str[0..-3] # drop \Z anchor
-            regex_str = interpret_string_escapes(regex_str)
-
-            lambda do |corrector|
-              new_source = receiver.source + '.end_with?(' +
-                           to_string_literal(regex_str) + ')'
-              corrector.replace(node.source_range, new_source)
-            end
-          end
-        end
-      end
-    end
-  end
-end