dirwatch 0.0.6 → 0.0.7

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

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

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

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

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

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

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

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

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