dirwatch 0.0.1 → 0.0.2

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/while_until_do.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of `do` in multi-line `while/until` statements.
+      class WhileUntilDo < Cop
+        def on_while(node)
+          handle(node)
+        end
+
+        def on_until(node)
+          handle(node)
+        end
+
+        def handle(node)
+          length = node.source.lines.to_a.size
+          return unless length > 1
+          return unless node.loc.begin && node.loc.begin.is?('do')
+
+          add_offense(node, :begin, error_message(node.type))
+        end
+
+        private
+
+        def error_message(node_type)
+          format('Do not use `do` with multi-line `%s`.', node_type)
+        end
+
+        def autocorrect(node)
+          condition_node, = *node
+          end_of_condition_range = condition_node.source_range.end
+          do_range = node.loc.begin
+          whitespaces_and_do_range = end_of_condition_range.join(do_range)
+          ->(corrector) { corrector.remove(whitespaces_and_do_range) }
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/while_until_modifier.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for while and until statements that would fit on one line
+      # if written as a modifier while/until.
+      # The maximum line length is configurable.
+      class WhileUntilModifier < Cop
+        include StatementModifier
+
+        def on_while(node)
+          check(node)
+        end
+
+        def on_until(node)
+          check(node)
+        end
+
+        def autocorrect(node)
+          cond, body = *node
+          oneline = "#{body.source} #{node.loc.keyword.source} " + cond.source
+          ->(corrector) { corrector.replace(node.source_range, oneline) }
+        end
+
+        private
+
+        def check(node)
+          return unless node.loc.end
+          return unless single_line_as_modifier?(node)
+          add_offense(node, :keyword, message(node.loc.keyword.source))
+        end
+
+        def message(keyword)
+          "Favor modifier `#{keyword}` usage when having a single-line body."
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/word_array.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop can check for array literals made up of word-like
+      # strings, that are not using the %w() syntax.
+      #
+      # Alternatively, it can check for uses of the %w() syntax, in projects
+      # which do not want to include that syntax.
+      class WordArray < Cop
+        include ArraySyntax
+
+        PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'.freeze
+        ARRAY_MSG = 'Use `[]` for an array of words.'.freeze
+        QUESTION_MARK_SIZE = '?'.size
+
+        def on_array(node)
+          if bracketed_array_of?(:str, node)
+            check_bracketed(node)
+          elsif percent_syntax?(node)
+            check_percent(node)
+          end
+        end
+
+        def autocorrect(node)
+          if style == :percent
+            correct_percent(node)
+          else
+            correct_bracketed(node)
+          end
+        end
+
+        private
+
+        def check_bracketed(node)
+          array_elems = node.children
+
+          return if complex_content?(array_elems) ||
+                    comments_in_array?(node)
+          style_detected(:brackets, array_elems.size)
+
+          return unless style == :percent && array_elems.size >= min_size
+
+          add_offense(node, :expression, PERCENT_MSG)
+        end
+
+        def check_percent(node)
+          array_elems = node.children
+
+          style_detected(:percent, array_elems.size)
+          add_offense(node, :expression, ARRAY_MSG) if style == :brackets
+        end
+
+        def percent_syntax?(node)
+          node.loc.begin && node.loc.begin.source =~ /\A%[wW]/
+        end
+
+        def comments_in_array?(node)
+          comments = processed_source.comments
+          array_range = node.source_range.to_a
+
+          comments.any? do |comment|
+            !(comment.loc.expression.to_a & array_range).empty?
+          end
+        end
+
+        def complex_content?(strings)
+          strings.any? do |s|
+            string = s.str_content
+            !string.valid_encoding? || string !~ word_regex || string =~ / /
+          end
+        end
+
+        def style
+          cop_config['EnforcedStyle'].to_sym
+        end
+
+        def min_size
+          cop_config['MinSize']
+        end
+
+        def word_regex
+          cop_config['WordRegex']
+        end
+
+        def correct_percent(node)
+          words = node.children
+          escape = words.any? { |w| needs_escaping?(w.children[0]) }
+          char = escape ? 'W' : 'w'
+          contents = autocorrect_words(words, escape, node.loc.line)
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, "%#{char}(#{contents})")
+          end
+        end
+
+        def correct_bracketed(node)
+          words = node.children.map { |w| to_string_literal(w.children[0]) }
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, "[#{words.join(', ')}]")
+          end
+        end
+
+        def autocorrect_words(word_nodes, escape, base_line_number)
+          previous_node_line_number = base_line_number
+          word_nodes.map do |node|
+            number_of_line_breaks = node.loc.line - previous_node_line_number
+            line_breaks = "\n" * number_of_line_breaks
+            previous_node_line_number = node.loc.line
+            content = node.children.first
+            content = escape ? escape_string(content) : content
+            content.gsub!(/\)/, '\\)')
+            line_breaks + content
+          end.join(' ')
+        end
+
+        def style_detected(style, ary_size)
+          cfg = config_to_allow_offenses
+          return if cfg['Enabled'] == false
+
+          largest_brackets = largest_brackets_size(style, ary_size)
+          smallest_percent = smallest_percent_size(style, ary_size)
+
+          if cfg['EnforcedStyle'] == style.to_s
+            # do nothing
+          elsif cfg['EnforcedStyle'].nil?
+            cfg['EnforcedStyle'] = style.to_s
+          elsif smallest_percent <= largest_brackets
+            self.config_to_allow_offenses = { 'Enabled' => false }
+          else
+            cfg['EnforcedStyle'] = 'percent'
+            cfg['MinSize'] = largest_brackets + 1
+          end
+        end
+
+        def largest_brackets_size(style, ary_size)
+          @largest_brackets ||= -Float::INFINITY
+
+          if style == :brackets && ary_size > @largest_brackets
+            @largest_brackets = ary_size
+          end
+
+          @largest_brackets
+        end
+
+        def smallest_percent_size(style, ary_size)
+          @smallest_percent ||= Float::INFINITY
+
+          if style == :percent && ary_size < @smallest_percent
+            @smallest_percent = ary_size
+          end
+
+          @smallest_percent
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/zero_length_predicate.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for receiver.length == 0 predicates and the
+      # negated versions receiver.length > 0 and receiver.length != 0.
+      # These can be replaced with receiver.empty? and
+      # !receiver.empty? respectively.
+      #
+      # @example
+      #
+      #   @bad
+      #   [1, 2, 3].length == 0
+      #   0 == "foobar".length
+      #   hash.size > 0
+      #
+      #   @good
+      #   [1, 2, 3].empty?
+      #   "foobar".empty?
+      #   !hash.empty?
+      class ZeroLengthPredicate < Cop
+        ZERO_MSG = 'Use `empty?` instead of `%s %s %s`.'.freeze
+        NONZERO_MSG = 'Use `!empty?` instead of `%s %s %s`.'.freeze
+
+        def on_send(node)
+          zero_length_predicate = zero_length_predicate(node)
+
+          if zero_length_predicate
+            add_offense(node, :expression,
+                        format(ZERO_MSG, *zero_length_predicate))
+          end
+
+          nonzero_length_predicate = nonzero_length_predicate(node)
+
+          # rubocop:disable Style/GuardClause
+          if nonzero_length_predicate
+            add_offense(node, :expression,
+                        format(NONZERO_MSG, *nonzero_length_predicate))
+          end
+          # rubocop:enable Style/GuardClause
+        end
+
+        def_node_matcher :zero_length_predicate, <<-END
+          {(send (send (...) ${:length :size}) $:== (int $0))
+           (send (int $0) $:== (send (...) ${:length :size}))
+           (send (send (...) ${:length :size}) $:<  (int $1))
+           (send (int $1) $:> (send (...) ${:length :size}))}
+        END
+
+        def_node_matcher :nonzero_length_predicate, <<-END
+          {(send (send (...) ${:length :size}) ${:> :!=} (int $0))
+           (send (int $0) ${:< :!=} (send (...) ${:length :size}))}
+        END
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, replacement(node))
+          end
+        end
+
+        def replacement(node)
+          receiver = zero_length_receiver(node)
+          return "#{receiver.source}.empty?" if receiver
+
+          "!#{other_receiver(node).source}.empty?"
+        end
+
+        def_node_matcher :zero_length_receiver, <<-END
+          {(send (send $_ _) :== (int 0))
+           (send (int 0) :== (send $_ _))
+           (send (send $_ _) :<  (int 1))
+           (send (int 1) :> (send $_ _))}
+        END
+
+        def_node_matcher :other_receiver, <<-END
+          {(send (send $_ _) _ _)
+           (send _ _ (send $_ _))}
+        END
+      end
+    end
+  end
+end

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

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # FIXME
+    class Team
+      # If these cops try to autocorrect the same file at the same time,
+      # bad things are liable to happen
+      INCOMPATIBLE_COPS = {
+        Style::SymbolProc => [Style::SpaceBeforeBlockBraces],
+        Style::SpaceBeforeBlockBraces => [Style::SymbolProc],
+        Style::LineEndConcatenation => [Style::UnneededInterpolation],
+        Style::UnneededInterpolation => [Style::LineEndConcatenation]
+      }.freeze
+
+      DEFAULT_OPTIONS = {
+        auto_correct: false,
+        debug: false
+      }.freeze
+
+      Investigation = Struct.new(:offenses, :errors)
+
+      attr_reader :errors, :warnings, :updated_source_file
+
+      alias updated_source_file? updated_source_file
+
+      def initialize(cop_classes, config, options = nil)
+        @cop_classes = cop_classes
+        @config = config
+        @options = options || DEFAULT_OPTIONS
+        @errors = []
+        @warnings = []
+
+        validate_config
+      end
+
+      def autocorrect?
+        @options[:auto_correct]
+      end
+
+      def debug?
+        @options[:debug]
+      end
+
+      def inspect_file(processed_source)
+        # If we got any syntax errors, return only the syntax offenses.
+        unless processed_source.valid_syntax?
+          return Lint::Syntax.offenses_from_processed_source(processed_source)
+        end
+
+        offenses(processed_source)
+      end
+
+      def cops
+        @cops ||= @cop_classes.select { |c| cop_enabled?(c) }.map do |cop_class|
+          cop_class.new(@config, @options)
+        end
+      end
+
+      def forces
+        @forces ||= forces_for(cops)
+      end
+
+      def forces_for(cops)
+        Force.all.each_with_object([]) do |force_class, forces|
+          joining_cops = cops.select { |cop| cop.join_force?(force_class) }
+          next if joining_cops.empty?
+          forces << force_class.new(joining_cops)
+        end
+      end
+
+      def autocorrect(buffer, cops)
+        @updated_source_file = false
+        return unless autocorrect?
+
+        new_source = autocorrect_all_cops(buffer, cops)
+
+        return if new_source == buffer.source
+
+        if @options[:stdin]
+          # holds source read in from stdin, when --stdin option is used
+          @options[:stdin] = new_source
+        else
+          filename = buffer.name
+          File.open(filename, 'w') { |f| f.write(new_source) }
+        end
+        @updated_source_file = true
+      end
+
+      private
+
+      def offenses(processed_source)
+        # The autocorrection process may have to be repeated multiple times
+        # until there are no corrections left to perform
+        # To speed things up, run auto-correcting cops by themselves, and only
+        # run the other cops when no corrections are left
+        autocorrect_cops, other_cops = cops.partition(&:autocorrect?)
+
+        autocorrect =
+          investigate(autocorrect_cops, processed_source) do |offenses|
+            # We corrected some errors. Another round of inspection will be
+            # done, and any other offenses will be caught then, so we don't
+            # need to continue.
+            return offenses if autocorrect(processed_source.buffer,
+                                           autocorrect_cops)
+          end
+
+        other = investigate(other_cops, processed_source)
+
+        errors = autocorrect.errors.merge(other.errors)
+        process_commissioner_errors(processed_source.path, errors)
+
+        autocorrect.offenses.concat(other.offenses)
+      end
+
+      def investigate(cops, processed_source)
+        return Investigation.new([], {}) if cops.empty?
+
+        commissioner = Commissioner.new(cops, forces_for(cops))
+        offenses = commissioner.investigate(processed_source)
+        yield offenses if block_given?
+
+        Investigation.new(offenses, commissioner.errors)
+      end
+
+      def cop_enabled?(cop_class)
+        @config.cop_enabled?(cop_class) ||
+          (@options[:only] || []).include?(cop_class.cop_name)
+      end
+
+      def autocorrect_all_cops(buffer, cops)
+        corrector = Corrector.new(buffer)
+        skip = Set.new
+
+        cops.each do |cop|
+          next if cop.corrections.empty?
+          next if skip.include?(cop.class)
+          corrector.corrections.concat(cop.corrections)
+          incompatible = INCOMPATIBLE_COPS[cop.class]
+          skip.merge(incompatible) if incompatible
+        end
+
+        if !corrector.corrections.empty?
+          corrector.rewrite
+        else
+          buffer.source
+        end
+      end
+
+      def validate_config
+        cops.each do |cop|
+          cop.validate_config if cop.respond_to?(:validate_config)
+        end
+      end
+
+      def process_commissioner_errors(file, file_errors)
+        file_errors.each do |cop, errors|
+          errors.each do |e|
+            if e.is_a?(Warning)
+              handle_warning(e,
+                             Rainbow("#{e.message} (from file: " \
+                             "#{file})").yellow)
+            else
+              handle_error(e,
+                           Rainbow("An error occurred while #{cop.name}" \
+                           " cop was inspecting #{file}.").red)
+            end
+          end
+        end
+      end
+
+      def handle_warning(e, message)
+        @warnings << message
+        warn message
+        puts e.backtrace if debug?
+      end
+
+      def handle_error(e, message)
+        @errors << message
+        warn message
+        if debug?
+          puts e.message, e.backtrace
+        else
+          warn 'To see the complete backtrace run rubocop -d.'
+        end
+      end
+    end
+  end
+end