dirwatch 0.0.7 → 0.0.8

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

@@ -0,0 +1,179 @@
+# 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.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/performance/casecmp.rb

@@ -0,0 +1,107 @@
+# 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.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/performance/compare_with_block.rb

@@ -0,0 +1,61 @@
+# 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.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/performance/count.rb

@@ -0,0 +1,98 @@
+# 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