dirwatch 0.0.1 → 0.0.2

data/vendor/bundle/ruby/2.3.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.3.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.3.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.3.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

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

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

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

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