dirwatch 0.0.7 → 0.0.8

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/encoding.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether the source file has a utf-8 encoding
+      # comment or not.
+      # Setting this check to "always" and "when_needed" makes sense only
+      # for code that should support Ruby 1.9, since in 2.0+ utf-8 is the
+      # default source file encoding. There are three styles:
+      #
+      # when_needed - only enforce an encoding comment if there are non ASCII
+      #               characters, otherwise report an offense
+      # always - enforce encoding comment in all files
+      # never - enforce no encoding comment in all files
+      class Encoding < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_MISSING = 'Missing utf-8 encoding comment.'.freeze
+        MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'.freeze
+        ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/
+        AUTO_CORRECT_ENCODING_COMMENT = 'AutoCorrectEncodingComment'.freeze
+        SHEBANG = '#!'.freeze
+
+        def investigate(processed_source)
+          return if processed_source.buffer.source.empty?
+
+          line_number = encoding_line_number(processed_source)
+          return unless (@message = offense(processed_source, line_number))
+
+          range = processed_source.buffer.line_range(line_number + 1)
+          add_offense(range, range, @message)
+        end
+
+        def autocorrect(range)
+          if @message == MSG_MISSING
+            raise encoding_mismatch_message unless matching_encoding?
+
+            lambda do |corrector|
+              corrector.insert_before(range, "#{encoding}\n")
+            end
+          else
+            # Need to remove unnecessary encoding comment
+            lambda do |corrector|
+              corrector.remove(range_with_surrounding_space(range, :right))
+            end
+          end
+        end
+
+        private
+
+        def encoding
+          cop_config[AUTO_CORRECT_ENCODING_COMMENT]
+        end
+
+        def matching_encoding?
+          encoding =~ ENCODING_PATTERN
+        end
+
+        def encoding_mismatch_message
+          "#{encoding} does not match #{ENCODING_PATTERN}"
+        end
+
+        def offense(processed_source, line_number)
+          line = processed_source[line_number]
+
+          if !encoding_present?(line) && !encoding_omitable?
+            MSG_MISSING
+          elsif encoding_present?(line) && encoding_omitable?
+            MSG_UNNECESSARY
+          end
+        end
+
+        def encoding_present?(line)
+          line =~ ENCODING_PATTERN
+        end
+
+        def encoding_omitable?
+          return true if style == :never
+
+          style != :always && processed_source.buffer.source.ascii_only?
+        end
+
+        def encoding_line_number(processed_source)
+          line_number = 0
+          line_number += 1 if processed_source[line_number].start_with?(SHEBANG)
+          line_number
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/end_block.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for END blocks.
+      class EndBlock < Cop
+        MSG = 'Avoid the use of `END` blocks. ' \
+              'Use `Kernel#at_exit` instead.'.freeze
+
+        def on_postexe(node)
+          add_offense(node, :keyword)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/end_of_line.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for Windows-style line endings in the source code.
+      class EndOfLine < Cop
+        MSG = 'Carriage return character detected.'.freeze
+
+        def investigate(processed_source)
+          last_token = processed_source.tokens.last
+          last_line =
+            last_token ? last_token.pos.line : processed_source.lines.length
+
+          processed_source.raw_source.each_line.with_index do |line, index|
+            break if index >= last_line
+            next unless line =~ /\r$/
+
+            range =
+              source_range(processed_source.buffer, index + 1, 0, line.length)
+            add_offense(nil, range, MSG)
+            # Usually there will be carriage return characters on all or none
+            # of the lines in a file, so we report only one offense.
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/even_odd.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where Integer#even? or Integer#odd?
+      # should have been used.
+      #
+      # @example
+      #
+      #   # bad
+      #   if x % 2 == 0
+      #
+      #   # good
+      #   if x.even?
+      class EvenOdd < Cop
+        MSG = 'Replace with `Integer#%s?`.'.freeze
+
+        def_node_matcher :even_odd_candidate?, <<-PATTERN
+          (send
+            {(send $_ :% (int 2))
+             (begin (send $_ :% (int 2)))}
+            ${:== :!=}
+            (int ${0 1 2}))
+        PATTERN
+
+        def on_send(node)
+          even_odd_candidate?(node) do |_base_number, method, arg|
+            replacement_method = replacement_method(arg, method)
+            add_offense(node, :expression, format(MSG, replacement_method))
+          end
+        end
+
+        def autocorrect(node)
+          even_odd_candidate?(node) do |base_number, method, arg|
+            replacement_method = replacement_method(arg, method)
+
+            correction = "#{base_number.source}.#{replacement_method}?"
+            ->(corrector) { corrector.replace(node.source_range, correction) }
+          end
+        end
+
+        private
+
+        def replacement_method(arg, method)
+          case arg
+          when 0
+            method == :== ? :even : :odd
+          when 1
+            method == :== ? :odd : :even
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/extra_spacing.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for extra/unnecessary whitespace.
+      #
+      # @example
+      #
+      #   # good if AllowForAlignment is true
+      #   name      = "RuboCop"
+      #   # Some comment and an empty line
+      #
+      #   website  += "/bbatsov/rubocop" unless cond
+      #   puts        "rubocop"          if     debug
+      #
+      #   # bad for any configuration
+      #   set_app("RuboCop")
+      #   website  = "https://github.com/bbatsov/rubocop"
+      class ExtraSpacing < Cop
+        include PrecedingFollowingAlignment
+
+        MSG_UNNECESSARY = 'Unnecessary spacing detected.'.freeze
+        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %s assignment.'.freeze
+
+        def investigate(processed_source)
+          return if processed_source.ast.nil?
+
+          if force_equal_sign_alignment?
+            @asgn_tokens = assignment_tokens
+            @asgn_lines  = @asgn_tokens.map { |t| t.pos.line }
+            # Don't attempt to correct the same = more than once
+            @corrected   = Set.new
+          end
+
+          processed_source.tokens.each_cons(2) do |t1, t2|
+            check_tokens(processed_source.ast, t1, t2)
+          end
+        end
+
+        def autocorrect(range)
+          lambda do |corrector|
+            if range.source.end_with?('=')
+              align_equal_signs(range, corrector)
+            else
+              corrector.remove(range)
+            end
+          end
+        end
+
+        private
+
+        def assignment_tokens
+          tokens = processed_source.tokens.select { |t| equal_sign?(t) }
+          # we don't want to operate on equals signs which are part of an
+          #   optarg in a method definition
+          # e.g.: def method(optarg = default_val); end
+          tokens = remove_optarg_equals(tokens, processed_source)
+
+          # Only attempt to align the first = on each line
+          Set.new(tokens.uniq { |t| t.pos.line })
+        end
+
+        def check_tokens(ast, t1, t2)
+          return if t2.type == :tNL
+
+          if force_equal_sign_alignment? &&
+             @asgn_tokens.include?(t2) &&
+             (@asgn_lines.include?(t2.pos.line - 1) ||
+              @asgn_lines.include?(t2.pos.line + 1))
+            check_assignment(t2)
+          else
+            check_other(t1, t2, ast)
+          end
+        end
+
+        def check_assignment(token)
+          assignment_line = ''
+          message = ''
+          if should_aligned_with_preceding_line?(token)
+            assignment_line = preceding_line(token)
+            message = format(MSG_UNALIGNED_ASGN, 'preceding')
+          else
+            assignment_line = following_line(token)
+            message = format(MSG_UNALIGNED_ASGN, 'following')
+          end
+          return if aligned_assignment?(token.pos, assignment_line)
+          add_offense(token.pos, token.pos, message)
+        end
+
+        def should_aligned_with_preceding_line?(token)
+          @asgn_lines.include?(token.pos.line - 1)
+        end
+
+        def preceding_line(token)
+          processed_source.lines[token.pos.line - 2]
+        end
+
+        def following_line(token)
+          processed_source.lines[token.pos.line]
+        end
+
+        def check_other(t1, t2, ast)
+          extra_space_range(t1, t2) do |range|
+            # Unary + doesn't appear as a token and needs special handling.
+            next if ignored_range?(ast, range.begin_pos)
+            next if unary_plus_non_offense?(range)
+
+            add_offense(range, range, MSG_UNNECESSARY)
+          end
+        end
+
+        def extra_space_range(t1, t2)
+          return if t1.pos.line != t2.pos.line
+
+          start_pos = t1.pos.end_pos
+          end_pos = t2.pos.begin_pos - 1
+          return if end_pos <= start_pos
+
+          return if allow_for_alignment? && aligned_tok?(t2)
+
+          yield range_between(start_pos, end_pos)
+        end
+
+        def aligned_tok?(token)
+          if token.type == :tCOMMENT
+            aligned_comments?(token)
+          else
+            aligned_with_something?(token.pos)
+          end
+        end
+
+        def ignored_range?(ast, start_pos)
+          ignored_ranges(ast).any? { |r| r.include?(start_pos) }
+        end
+
+        def unary_plus_non_offense?(range)
+          range.resize(range.size + 1).source =~ /^ ?\+$/
+        end
+
+        # Returns an array of ranges that should not be reported. It's the
+        # extra spaces between the keys and values in a multiline hash,
+        # since those are handled by the Style/AlignHash cop.
+        def ignored_ranges(ast)
+          return [] unless ast
+
+          @ignored_ranges ||= on_node(:pair, ast).map do |pair|
+            next if pair.parent.single_line?
+
+            key, value = *pair
+            key.source_range.end_pos...value.source_range.begin_pos
+          end.compact
+        end
+
+        def aligned_comments?(token)
+          ix = processed_source.comments.index do |c|
+            c.loc.expression.begin_pos == token.pos.begin_pos
+          end
+          aligned_with_previous_comment?(ix) || aligned_with_next_comment?(ix)
+        end
+
+        def aligned_with_previous_comment?(ix)
+          ix > 0 && comment_column(ix - 1) == comment_column(ix)
+        end
+
+        def aligned_with_next_comment?(ix)
+          ix < processed_source.comments.length - 1 &&
+            comment_column(ix + 1) == comment_column(ix)
+        end
+
+        def comment_column(ix)
+          processed_source.comments[ix].loc.column
+        end
+
+        def force_equal_sign_alignment?
+          cop_config['ForceEqualSignAlignment']
+        end
+
+        def equal_sign?(token)
+          token.type == :tEQL || token.type == :tOP_ASGN
+        end
+
+        def align_equal_signs(range, corrector)
+          lines  = contiguous_assignment_lines(range)
+          tokens = @asgn_tokens.select { |t| lines.include?(t.pos.line) }
+
+          columns  = tokens.map { |t| align_column(t) }
+          align_to = columns.max
+
+          tokens.each { |token| align_equal_sign(corrector, token, align_to) }
+        end
+
+        def align_equal_sign(corrector, token, align_to)
+          return unless @corrected.add?(token)
+
+          diff = align_to - token.pos.last_column
+
+          if diff > 0
+            corrector.insert_before(token.pos, ' ' * diff)
+          elsif diff < 0
+            corrector.remove_preceding(token.pos, -diff)
+          end
+        end
+
+        def contiguous_assignment_lines(range)
+          result = [range.line]
+
+          range.line.downto(1) do |lineno|
+            @asgn_lines.include?(lineno) ? result << lineno : break
+          end
+          range.line.upto(processed_source.lines.size) do |lineno|
+            @asgn_lines.include?(lineno) ? result << lineno : break
+          end
+
+          result.sort!
+        end
+
+        def align_column(asgn_token)
+          # if we removed unneeded spaces from the beginning of this =,
+          # what column would it end from?
+          line    = processed_source.lines[asgn_token.pos.line - 1]
+          leading = line[0...asgn_token.pos.column]
+          spaces  = leading.size - (leading =~ / *\Z/)
+          asgn_token.pos.last_column - spaces + 1
+        end
+
+        def remove_optarg_equals(asgn_tokens, processed_source)
+          optargs    = processed_source.ast.each_node(:optarg)
+          optarg_eql = optargs.map { |o| o.loc.operator.begin_pos }.to_set
+          asgn_tokens.reject { |t| optarg_eql.include?(t.pos.begin_pos) }
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.46.0/lib/rubocop/cop/style/file_name.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop makes sure that Ruby source files have snake_case
+      # names. Ruby scripts (i.e. source files with a shebang in the
+      # first line) are ignored.
+      class FileName < Cop
+        MSG_SNAKE_CASE = 'The name of this source file (`%s`) ' \
+                         'should use snake_case.'.freeze
+        MSG_NO_DEFINITION = '%s should define a class or module ' \
+                            'called `%s`.'.freeze
+        MSG_REGEX = '`%s` should match `%s`.'.freeze
+
+        SNAKE_CASE = /^[\da-z_.?!]+$/
+
+        def investigate(processed_source)
+          file_path = processed_source.buffer.name
+          return if config.file_to_include?(file_path)
+
+          for_bad_filename(file_path) do |range, msg|
+            add_offense(nil, range, msg)
+          end
+        end
+
+        private
+
+        def for_bad_filename(file_path)
+          basename = File.basename(file_path)
+          msg = if filename_good?(basename)
+                  return unless expect_matching_definition?
+                  return if find_class_or_module(processed_source.ast,
+                                                 to_namespace(file_path))
+                  no_definition_message(basename, file_path)
+                else
+                  return if cop_config['IgnoreExecutableScripts'] &&
+                            shebang?(first_line)
+                  other_message(basename)
+                end
+
+          yield source_range(processed_source.buffer, 1, 0), msg
+        end
+
+        def first_line
+          processed_source.lines.first
+        end
+
+        def no_definition_message(basename, file_path)
+          format(MSG_NO_DEFINITION,
+                 basename,
+                 to_namespace(file_path).join('::'))
+        end
+
+        def other_message(basename)
+          if regex
+            format(MSG_REGEX, basename, regex)
+          else
+            format(MSG_SNAKE_CASE, basename)
+          end
+        end
+
+        def shebang?(line)
+          line && line.start_with?('#!')
+        end
+
+        def expect_matching_definition?
+          cop_config['ExpectMatchingDefinition']
+        end
+
+        def regex
+          cop_config['Regex']
+        end
+
+        def filename_good?(basename)
+          basename = basename.sub(/\.[^\.]+$/, '')
+          basename =~ (regex || SNAKE_CASE)
+        end
+
+        def find_class_or_module(node, namespace)
+          return nil if node.nil?
+          name = namespace.pop
+
+          on_node([:class, :module, :casgn], node) do |child|
+            next unless (const = child.defined_module)
+
+            const_namespace, const_name = *const
+            next unless name == const_name
+
+            return node if namespace.empty?
+            return node if match_namespace(child, const_namespace, namespace)
+          end
+          nil
+        end
+
+        def match_namespace(node, namespace, expected)
+          match_partial = partial_matcher!(expected)
+
+          match_partial.call(namespace)
+
+          node.each_ancestor(:class, :module, :sclass, :casgn) do |ancestor|
+            return false if ancestor.sclass_type?
+            match_partial.call(ancestor.defined_module)
+          end
+
+          match?(expected)
+        end
+
+        def partial_matcher!(expected)
+          lambda do |namespace|
+            while namespace
+              return match?(expected) if namespace.cbase_type?
+
+              namespace, name = *namespace
+
+              expected.pop if name == expected.last
+            end
+
+            false
+          end
+        end
+
+        def match?(expected)
+          expected.empty? || expected == [:Object]
+        end
+
+        def to_namespace(path)
+          components = Pathname(path).each_filename.to_a
+          # To convert a pathname to a Ruby namespace, we need a starting point
+          # But RC can be run from any working directory, and can check any path
+          # We can't assume that the working directory, or any other, is the
+          # "starting point" to build a namespace
+          start = %w(lib spec test src)
+          start_index = nil
+
+          # To find the closest namespace root take the path components, and
+          # then work through them backwards until we find a candidate. This
+          # makes sure we work from the actual root in the case of a path like
+          # /home/user/src/project_name/lib.
+          components.reverse.each_with_index do |c, i|
+            if start.include?(c)
+              start_index = components.size - i
+              break
+            end
+          end
+
+          if start_index.nil?
+            [to_module_name(components.last)]
+          else
+            components[start_index..-1].map { |c| to_module_name(c) }
+          end
+        end
+
+        def to_module_name(basename)
+          words = basename.sub(/\..*/, '').split('_')
+          words.map(&:capitalize).join.to_sym
+        end
+      end
+    end
+  end
+end