dirwatch 0.0.1 → 0.0.2

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use `Kernel#loop` for infinite loops.
+      #
+      # @example
+      #   # bad
+      #   while true
+      #     work
+      #   end
+      #
+      #   # good
+      #   loop do
+      #     work
+      #   end
+      class InfiniteLoop < Cop
+        MSG = 'Use `Kernel#loop` for infinite loops.'.freeze
+
+        def on_while(node)
+          condition, = *node
+          return unless condition.truthy_literal?
+
+          add_offense(node, :keyword)
+        end
+
+        def on_until(node)
+          condition, = *node
+          return unless condition.falsey_literal?
+
+          add_offense(node, :keyword)
+        end
+
+        alias on_while_post on_while
+        alias on_until_post on_until
+
+        def autocorrect(node)
+          if node.while_post_type? || node.until_post_type?
+            replace_begin_end_with_modifier(node)
+          elsif node.modifier_form?
+            replace_source(node.source_range, modifier_replacement(node))
+          else
+            replace_source(non_modifier_range(node), 'loop do')
+          end
+        end
+
+        private
+
+        def replace_begin_end_with_modifier(node)
+          _, body = *node
+
+          lambda do |corrector|
+            corrector.replace(body.loc.begin, 'loop do')
+            corrector.remove(body.loc.end.end.join(node.source_range.end))
+          end
+        end
+
+        def replace_source(range, replacement)
+          ->(corrector) { corrector.replace(range, replacement) }
+        end
+
+        def modifier_replacement(node)
+          _, body = *node
+          if node.single_line?
+            'loop { ' + body.source + ' }'
+          else
+            indentation = body.loc.expression.source_line[/\A(\s*)/]
+            "loop do\n" + indentation +
+              body.source.gsub(/^/, ' ' * configured_indentation_width) +
+              "\n#{indentation}end"
+          end
+        end
+
+        def non_modifier_range(node)
+          condition_node, = *node
+          start_range = node.loc.keyword.begin
+          end_range = if node.loc.begin
+                        node.loc.begin.end
+                      else
+                        condition_node.source_range.end
+                      end
+          start_range.join(end_range)
+        end
+
+        def configured_indentation_width
+          config.for_cop('IndentationWidth')['Width']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks for indentation of the first non-blank non-comment
+      # line in a file.
+      class InitialIndentation < Cop
+        MSG = 'Indentation of first line in file detected.'.freeze
+
+        def investigate(_processed_source)
+          token = first_token
+          space_before(token) { |space| add_offense(space, token.pos) }
+        end
+
+        def autocorrect(range)
+          ->(corrector) { corrector.remove(range) }
+        end
+
+        private
+
+        def first_token
+          processed_source.tokens.find { |t| !t.text.start_with?('#') }
+        end
+
+        def space_before(token)
+          return unless token
+          return if token.pos.column.zero?
+
+          token_with_space =
+            range_with_surrounding_space(token.pos, :left, false)
+          # If the file starts with a byte order mark (BOM), the column can be
+          # non-zero, but then we find out here if there's no space to the left
+          # of the first token.
+          return if token_with_space == token.pos
+
+          yield range_between(token_with_space.begin_pos, token.pos.begin_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing inline comments.
+      #
+      # @example
+      #
+      #   # good
+      #   foo.each do |f|
+      #     # Standalone comment
+      #     f.bar
+      #   end
+      #
+      #   # bad
+      #   foo.each do |f|
+      #     f.bar # Trailing inline comment
+      #   end
+      class InlineComment < Cop
+        MSG = 'Avoid trailing inline comments.'.freeze
+
+        def investigate(processed_source)
+          processed_source.comments.each do |comment|
+            next if comment_line?(processed_source[comment.loc.line - 1])
+            add_offense(comment, :expression)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop (by default) checks for uses of the lambda literal syntax for
+      # single line lambdas, and the method call syntax for multiline lambdas.
+      # It is configurable to enforce one of the styles for both single line
+      # and multiline lambdas as well.
+      #
+      # @example
+      #
+      #   # EnforcedStyle: line_count_dependent (default)
+      #
+      #   # bad
+      #   f = lambda { |x| x }
+      #   f = ->(x) do
+      #         x
+      #       end
+      #
+      #   # good
+      #   f = ->(x) { x }
+      #   f = lambda do |x|
+      #         x
+      #       end
+      #
+      # @example
+      #
+      #   # EnforcedStyle: lambda
+      #
+      #   # bad
+      #   f = ->(x) { x }
+      #   f = ->(x) do
+      #         x
+      #       end
+      #
+      #   # good
+      #   f = lambda { |x| x }
+      #   f = lambda do |x|
+      #         x
+      #       end
+      #
+      # @example
+      #
+      #   # EnforcedStyle: literal
+      #
+      #   # bad
+      #   f = lambda { |x| x }
+      #   f = lambda do |x|
+      #         x
+      #       end
+      #
+      #   # good
+      #   f = ->(x) { x }
+      #   f = ->(x) do
+      #         x
+      #       end
+      class Lambda < Cop
+        include ConfigurableEnforcedStyle
+
+        LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for ' \
+                          '%s lambdas.'.freeze
+        METHOD_MESSAGE = 'Use the `lambda` method for %s lambdas.'.freeze
+
+        OFFENDING_SELECTORS = {
+          style: {
+            lambda: { single_line: '->', multiline: '->' },
+            literal: { single_line: 'lambda', multiline: 'lambda' },
+            line_count_dependent: { single_line: 'lambda', multiline: '->' }
+          }
+        }.freeze
+
+        def_node_matcher :lambda_node?, '(block $(send nil :lambda) ...)'
+
+        def on_block(node)
+          lambda_node?(node) do |block_method|
+            selector = block_method.source
+
+            return unless offending_selector?(node, selector)
+
+            add_offense(node,
+                        block_method.source_range,
+                        message(node, selector))
+          end
+        end
+
+        private
+
+        def offending_selector?(node, selector)
+          lines = node.multiline? ? :multiline : :single_line
+
+          selector == OFFENDING_SELECTORS[:style][style][lines]
+        end
+
+        def message(node, selector)
+          message = selector == '->' ? METHOD_MESSAGE : LITERAL_MESSAGE
+
+          format(message, message_line_modifier(node))
+        end
+
+        def message_line_modifier(node)
+          case style
+          when :line_count_dependent
+            node.multiline? ? 'multiline' : 'single line'
+          else
+            'all'
+          end
+        end
+
+        def autocorrect(node)
+          block_method, _args = *node
+          selector = block_method.source
+
+          # Don't autocorrect if this would change the meaning of the code
+          return if selector == '->' && arg_to_unparenthesized_call?(node)
+
+          lambda do |corrector|
+            if selector == 'lambda'
+              autocorrect_method_to_literal(corrector, node)
+            else
+              autocorrect_literal_to_method(corrector, node)
+            end
+          end
+        end
+
+        def autocorrect_literal_to_method(corrector, node)
+          block_method, args = *node
+
+          # Check for unparenthesized args' preceding and trailing whitespaces.
+          remove_unparenthesized_whitespaces(corrector, node)
+
+          # Avoid correcting to `lambdado` by inserting whitespace
+          # if none exists before or after the lambda arguments.
+          if needs_whitespace?(block_method, args, node)
+            corrector.insert_before(node.loc.begin, ' ')
+          end
+          corrector.replace(block_method.source_range, 'lambda')
+          corrector.remove(args.source_range) if args.source_range
+          return if args.children.empty?
+          arg_str = " |#{lambda_arg_string(args)}|"
+          corrector.insert_after(node.loc.begin, arg_str)
+        end
+
+        def autocorrect_method_to_literal(corrector, node)
+          block_method, args = *node
+          corrector.replace(block_method.source_range, '->')
+          return if args.children.empty?
+
+          arg_str = "(#{lambda_arg_string(args)})"
+          whitespace_and_old_args = node.loc.begin.end.join(args.loc.end)
+          corrector.insert_after(block_method.source_range, arg_str)
+          corrector.remove(whitespace_and_old_args)
+        end
+
+        def needs_whitespace?(block_method, args, node)
+          selector_end = block_method.loc.selector.end.end_pos
+          block_begin  = node.loc.begin.begin_pos
+
+          (block_begin == end_pos(args) && selector_end == begin_pos(args)) ||
+            (block_begin == selector_end)
+        end
+
+        def begin_pos(node)
+          node.loc.begin && node.loc.begin.begin_pos
+        end
+
+        def end_pos(node)
+          node.loc.end && node.loc.end.end_pos
+        end
+
+        def lambda_arg_string(args)
+          args.children.map(&:source).join(', ')
+        end
+
+        def arg_to_unparenthesized_call?(arg_node)
+          parent = arg_node.parent
+
+          if parent && parent.pair_type?
+            arg_node = parent.parent
+            parent = arg_node.parent
+          end
+
+          return false unless parent && parent.send_type?
+          return false if parenthesized_call?(parent)
+
+          arg_node.sibling_index > 1
+        end
+
+        def remove_unparenthesized_whitespaces(corrector, node)
+          block_method, args = *node
+          return unless unparenthesized_literal_args?(args)
+          # First, remove leading whitespaces (beetween arrow and args)
+          corrector.remove_preceding(
+            args.source_range,
+            args.source_range.begin_pos - block_method.source_range.end_pos
+          )
+
+          # Then, remove trailing whitespaces (beetween args and 'do')
+          delta = node.loc.begin.begin_pos - args.source_range.end_pos - 1
+          corrector.remove_preceding(node.loc.begin, delta)
+        end
+
+        def unparenthesized_literal_args?(args)
+          args.source_range && args.source_range.begin && !parentheses?(args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for use of the lambda.(args) syntax.
+      #
+      # @example
+      #
+      #  # bad
+      #  lambda.(x, y)
+      #
+      #  # good
+      #  lambda.call(x, y)
+      class LambdaCall < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_send(node)
+          _receiver, selector, = *node
+
+          # we care only about `call` methods
+          return unless selector == :call
+
+          if offense?(node)
+            add_offense(node, :expression) { opposite_style_detected }
+          else
+            correct_style_detected
+          end
+        end
+
+        private
+
+        def offense?(node)
+          # lambda.() does not have a selector
+          style == :call && node.loc.selector.nil? ||
+            style == :braces && node.loc.selector
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if style == :call
+              receiver_node, = *node
+              receiver = receiver_node.source
+              replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
+              corrector.replace(node.source_range, replacement)
+            else
+              corrector.remove(node.loc.selector)
+            end
+          end
+        end
+
+        def message(_node)
+          if style == :call
+            'Prefer the use of `lambda.call(...)` over `lambda.(...)`.'
+          else
+            'Prefer the use of `lambda.(...)` over `lambda.call(...)`.'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether comments have a leading space
+      # after the # denoting the start of the comment. The
+      # leading space is not required for some RDoc special syntax,
+      # like #++, #--, #:nodoc, etc. Neither is it required for
+      # =begin/=end comments.
+      class LeadingCommentSpace < Cop
+        MSG = 'Missing space after #.'.freeze
+
+        def investigate(processed_source)
+          processed_source.comments.each do |comment|
+            next unless comment.text =~ /\A#+[^#\s=:+-]/
+            next if comment.text.start_with?('#!') && comment.loc.line == 1
+
+            # in config.ru files, if the first line starts with #\ it is treated
+            # as options (e.g. `#\ -p 8765` sets the request port to 8765)
+            next if comment.text.start_with?('#\\') && comment.loc.line == 1 &&
+                    config_ru?(processed_source.buffer.name)
+
+            add_offense(comment, :expression)
+          end
+        end
+
+        def autocorrect(comment)
+          expr = comment.loc.expression
+          b = expr.begin_pos
+          hash_mark = range_between(b, b + 1)
+          ->(corrector) { corrector.insert_after(hash_mark, ' ') }
+        end
+
+        private
+
+        def config_ru?(file_path)
+          File.basename(file_path).eql?('config.ru')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for string literal concatenation at
+      # the end of a line.
+      #
+      # @example
+      #
+      #   # bad
+      #   some_str = 'ala' +
+      #              'bala'
+      #
+      #   some_str = 'ala' <<
+      #              'bala'
+      #
+      #   # good
+      #   some_str = 'ala' \
+      #              'bala'
+      #
+      class LineEndConcatenation < Cop
+        MSG = 'Use `\\` instead of `+` or `<<` to concatenate ' \
+              'those strings.'.freeze
+        CONCAT_TOKEN_TYPES = [:tPLUS, :tLSHFT].freeze
+        SIMPLE_STRING_TOKEN_TYPE = :tSTRING
+        COMPLEX_STRING_EDGE_TOKEN_TYPES = [:tSTRING_BEG, :tSTRING_END].freeze
+        HIGH_PRECEDENCE_OP_TOKEN_TYPES = [:tSTAR2, :tPERCENT, :tDOT,
+                                          :tLBRACK2].freeze
+        QUOTE_DELIMITERS = %w(' ").freeze
+
+        def investigate(processed_source)
+          processed_source.tokens.each_index do |index|
+            check_token_set(index)
+          end
+        end
+
+        def autocorrect(operator_range)
+          # Include any trailing whitespace so we don't create a syntax error.
+          operator_range = range_with_surrounding_space(operator_range,
+                                                        :right,
+                                                        false)
+          one_more_char = operator_range.resize(operator_range.size + 1)
+          # Don't create a double backslash at the end of the line, in case
+          # there already was a backslash after the concatenation operator.
+          operator_range = one_more_char if one_more_char.source.end_with?('\\')
+
+          ->(corrector) { corrector.replace(operator_range, '\\') }
+        end
+
+        private
+
+        def check_token_set(index)
+          predecessor, operator, successor = processed_source.tokens[index, 3]
+
+          return unless eligible_successor?(successor) &&
+                        eligible_operator?(operator) &&
+                        eligible_predecessor?(predecessor)
+
+          return if operator.pos.line == successor.pos.line
+
+          next_successor = token_after_last_string(successor, index)
+
+          return unless eligible_next_successor?(next_successor)
+
+          add_offense(operator.pos, operator.pos)
+        end
+
+        def eligible_successor?(successor)
+          successor && standard_string_literal?(successor)
+        end
+
+        def eligible_operator?(operator)
+          CONCAT_TOKEN_TYPES.include?(operator.type)
+        end
+
+        def eligible_next_successor?(next_successor)
+          !(next_successor &&
+            HIGH_PRECEDENCE_OP_TOKEN_TYPES.include?(next_successor.type))
+        end
+
+        def eligible_predecessor?(predecessor)
+          standard_string_literal?(predecessor)
+        end
+
+        def token_after_last_string(successor, base_index)
+          index = base_index + 3
+          begin_token, end_token = COMPLEX_STRING_EDGE_TOKEN_TYPES
+          if successor.type == begin_token
+            ends_to_find = 1
+            while ends_to_find > 0
+              case processed_source.tokens[index].type
+              when begin_token then ends_to_find += 1
+              when end_token then ends_to_find -= 1
+              end
+              index += 1
+            end
+          end
+          processed_source.tokens[index]
+        end
+
+        def standard_string_literal?(token)
+          case token.type
+          when SIMPLE_STRING_TOKEN_TYPE
+            true
+          when *COMPLEX_STRING_EDGE_TOKEN_TYPES
+            QUOTE_DELIMITERS.include?(token.text)
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for unwanted parentheses in parameterless method calls.
+      class MethodCallParentheses < Cop
+        MSG = 'Do not use parentheses for method calls with ' \
+              'no arguments.'.freeze
+
+        ASGN_NODES = [:lvasgn, :masgn] + SHORTHAND_ASGN_NODES
+
+        def on_send(node)
+          _receiver, method_name, *args = *node
+
+          # methods starting with a capital letter should be skipped
+          return if method_name =~ /\A[A-Z]/
+          return unless args.empty? && node.loc.begin
+          return if same_name_assignment?(node)
+          return if lambda_call_syntax?(node)
+          return if node.keyword_not?
+
+          add_offense(node, :begin)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+          end
+        end
+
+        private
+
+        def same_name_assignment?(node)
+          _receiver, method_name, *_args = *node
+
+          any_assignment?(node) do |asgn_node|
+            if asgn_node.masgn_type?
+              next variable_in_mass_assignment?(method_name, asgn_node)
+            end
+
+            asgn_node.loc.name.source == method_name.to_s
+          end
+        end
+
+        def any_assignment?(node)
+          node.each_ancestor(*ASGN_NODES).any? do |asgn_node|
+            # `obj.method = value` parses as (send ... :method= ...), and will
+            # not be returned as an `asgn_node` here, however,
+            # `obj.method ||= value` parses as (or-asgn (send ...) ...)
+            # which IS an `asgn_node`. Similarly, `obj.method += value` parses
+            # as (op-asgn (send ...) ...), which is also an `asgn_node`.
+            if asgn_node.or_asgn_type? || asgn_node.and_asgn_type? ||
+               asgn_node.op_asgn_type?
+              asgn_node, _value = *asgn_node
+              next if asgn_node.send_type?
+            end
+
+            yield asgn_node
+          end
+        end
+
+        def variable_in_mass_assignment?(variable_name, node)
+          mlhs_node, _mrhs_node = *node
+          var_nodes = *mlhs_node
+
+          var_nodes.map { |n| n.to_a.first }.include?(variable_name)
+        end
+
+        # don't check `lambda.()` syntax; the Style/LambdaCall cop does that
+        def lambda_call_syntax?(node)
+          node.method_name == :call && node.loc.selector.nil?
+        end
+      end
+    end
+  end
+end