dirwatch 0.0.6 → 0.0.7

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

@@ -1,177 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for redundant parentheses.
-      #
-      # @example
-      #
-      #   # bad
-      #   (x) if ((y.z).nil?)
-      #
-      #   # good
-      #   x if y.z.nil?
-      #
-      class RedundantParentheses < Cop
-        include Parentheses
-
-        ALLOWED_LITERALS = [:irange, :erange].freeze
-
-        def_node_matcher :square_brackets?,
-                         '(send {(send _recv _msg) str array hash} :[] ...)'
-        def_node_matcher :range_end?, '^^{irange erange}'
-        def_node_matcher :method_node_and_args, '$(send _recv _msg $...)'
-        def_node_matcher :rescue?, '{^resbody ^^resbody}'
-        def_node_matcher :arg_in_call_with_block?,
-                         '^^(block (send _ _ equal?(%0) ...) ...)'
-
-        def on_begin(node)
-          return if !parentheses?(node) || parens_allowed?(node)
-          check(node)
-        end
-
-        def parens_allowed?(node)
-          empty_parentheses?(node) ||
-            allowed_ancestor?(node) ||
-            hash_literal_as_first_arg?(node) ||
-            rescue?(node) ||
-            allowed_method_call?(node) ||
-            allowed_array_or_hash_element?(node)
-        end
-
-        def allowed_ancestor?(node)
-          # Don't flag `break(1)`, etc
-          keyword_ancestor?(node) && parens_required?(node)
-        end
-
-        def allowed_method_call?(node)
-          # Don't flag `method (arg) { }`
-          arg_in_call_with_block?(node) && !parentheses?(node.parent)
-        end
-
-        def empty_parentheses?(node)
-          # Don't flag `()`
-          node.children.empty?
-        end
-
-        def hash_literal_as_first_arg?(node)
-          # Don't flag `method ({key: value})`
-          node.children.first.hash_type? && first_arg?(node) &&
-            !parentheses?(node.parent)
-        end
-
-        def check(begin_node)
-          node = begin_node.children.first
-          if keyword_with_redundant_parentheses?(node)
-            return offense(begin_node, 'a keyword')
-          end
-          return offense(begin_node, 'a literal') if disallowed_literal?(node)
-          return offense(begin_node, 'a variable') if node.variable?
-          return offense(begin_node, 'a constant') if node.const_type?
-          check_send(begin_node, node) if node.send_type?
-        end
-
-        def check_send(begin_node, node)
-          return check_unary(begin_node, node) if node.unary_operation?
-
-          return unless method_call_with_redundant_parentheses?(node)
-          return if call_chain_starts_with_int?(begin_node, node)
-
-          offense(begin_node, 'a method call')
-        end
-
-        def check_unary(begin_node, node)
-          return if begin_node.chained?
-
-          # parens are not redundant in `(!recv.method arg)`
-          node = node.children.first while node.unary_operation?
-          if node.send_type?
-            return unless method_call_with_redundant_parentheses?(node)
-          end
-
-          offense(begin_node, 'an unary operation')
-        end
-
-        def offense(node, msg)
-          add_offense(node, :expression, "Don't use parentheses around #{msg}.")
-        end
-
-        def keyword_ancestor?(node)
-          node.parent && node.parent.keyword?
-        end
-
-        def allowed_array_or_hash_element?(node)
-          # Don't flag
-          # ```
-          # { a: (1
-          #      ), }
-          # ```
-          (hash_element?(node) || array_element?(node)) &&
-            only_closing_paren_before_comma?(node)
-        end
-
-        def hash_element?(node)
-          node.parent && node.parent.pair_type?
-        end
-
-        def array_element?(node)
-          node.parent && node.parent.array_type?
-        end
-
-        def only_closing_paren_before_comma?(node)
-          source_buffer = node.source_range.source_buffer
-          line_range = source_buffer.line_range(node.loc.end.line)
-
-          line_range.source =~ /^\s*\)\s*,/
-        end
-
-        def disallowed_literal?(node)
-          node.literal? && !ALLOWED_LITERALS.include?(node.type)
-        end
-
-        def keyword_with_redundant_parentheses?(node)
-          return false unless node.keyword?
-          return true if node.special_keyword?
-
-          args = *node
-
-          if only_begin_arg?(args)
-            parentheses?(args.first)
-          else
-            args.empty? || parentheses?(node)
-          end
-        end
-
-        def method_call_with_redundant_parentheses?(node)
-          return false unless node.send_type?
-          return false if node.keyword_not?
-          return false if range_end?(node)
-
-          send_node, args = method_node_and_args(node)
-
-          args.empty? || parentheses?(send_node) || square_brackets?(send_node)
-        end
-
-        def only_begin_arg?(args)
-          args.size == 1 && args.first && args.first.begin_type?
-        end
-
-        def first_arg?(node)
-          send_node = node.parent
-          return false unless send_node && send_node.send_type?
-
-          _receiver, _method_name, *args = *send_node
-          node.equal?(args.first)
-        end
-
-        def call_chain_starts_with_int?(begin_node, send_node)
-          recv = first_part_of_call_chain(send_node)
-          recv && recv.int_type? && (parent = begin_node.parent) &&
-            parent.send_type? &&
-            (parent.method_name == :-@ || parent.method_name == :+@)
-        end
-      end
-    end
-  end
-end

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

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for redundant `return` expressions.
-      #
-      # @example
-      #
-      #   def test
-      #     return something
-      #   end
-      #
-      #   def test
-      #     one
-      #     two
-      #     three
-      #     return something
-      #   end
-      #
-      # It should be extended to handle methods whose body is if/else
-      # or a case expression with a default branch.
-      class RedundantReturn < Cop
-        include OnMethodDef
-        include IfNode
-
-        MSG = 'Redundant `return` detected.'.freeze
-
-        private
-
-        def autocorrect(node)
-          lambda do |corrector|
-            unless arguments?(node.children)
-              corrector.replace(node.source_range, 'nil')
-              next
-            end
-
-            return_value, = *node
-            if node.children.size > 1
-              add_brackets(corrector, node)
-            elsif return_value.hash_type?
-              add_braces(corrector, return_value) unless braces?(return_value)
-            end
-            return_kw = range_with_surrounding_space(node.loc.keyword, :right)
-            corrector.remove(return_kw)
-          end
-        end
-
-        def braces?(arg)
-          arg.loc.begin
-        end
-
-        def add_brackets(corrector, node)
-          kids = node.children.map(&:source_range)
-          corrector.insert_before(kids.first, '[')
-          corrector.insert_after(kids.last, ']')
-        end
-
-        def add_braces(corrector, node)
-          kids = node.children.map(&:source_range)
-          corrector.insert_before(kids.first, '{')
-          corrector.insert_after(kids.last, '}')
-        end
-
-        def arguments?(args)
-          return false if args.empty?
-          return true if args.size > 1
-
-          !args.first.begin_type? || !args.first.children.empty?
-        end
-
-        def on_method_def(_node, _method_name, _args, body)
-          return unless body
-
-          check_branch(body)
-        end
-
-        def check_branch(node)
-          case node.type
-          when :return then check_return_node(node)
-          when :case then check_case_node(node)
-          when :if then check_if_node(node)
-          when :begin then check_begin_node(node)
-          end
-        end
-
-        def check_return_node(node)
-          return if cop_config['AllowMultipleReturnValues'] &&
-                    node.children.size > 1
-
-          add_offense(node, :keyword)
-        end
-
-        def check_case_node(node)
-          _cond, *when_nodes, else_node = *node
-          when_nodes.each { |when_node| check_when_node(when_node) }
-          check_branch(else_node) if else_node
-        end
-
-        def check_when_node(node)
-          return unless node
-          _cond, body = *node
-          check_branch(body) if body
-        end
-
-        def check_if_node(node)
-          return if modifier_if?(node) || ternary?(node)
-
-          _cond, if_node, else_node = if_node_parts(node)
-          check_branch(if_node) if if_node
-          check_branch(else_node) if else_node
-        end
-
-        def check_begin_node(node)
-          expressions = *node
-          last_expr = expressions.last
-
-          return unless last_expr && last_expr.return_type?
-
-          check_return_node(last_expr)
-        end
-      end
-    end
-  end
-end

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

@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for redundant uses of `self`.
-      #
-      # `self` is only needed when:
-      #
-      # * Sending a message to same object with zero arguments in
-      #   presence of a method name clash with an argument or a local
-      #   variable.
-      #
-      #   Note, with using explicit self you can only send messages
-      #   with public or protected scope, you cannot send private
-      #   messages this way.
-      #
-      #   Example:
-      #
-      #   def bar
-      #     :baz
-      #   end
-      #
-      #   def foo(bar)
-      #     self.bar # resolves name clash with argument
-      #   end
-      #
-      #   def foo2
-      #     bar = 1
-      #     self.bar # resolves name clash with local variable
-      #   end
-      #
-      # * Calling an attribute writer to prevent an local variable assignment
-      #
-      #   attr_writer :bar
-      #
-      #   def foo
-      #     self.bar= 1 # Make sure above attr writer is called
-      #   end
-      #
-      # Special cases:
-      #
-      # We allow uses of `self` with operators because it would be awkward
-      # otherwise.
-      class RedundantSelf < Cop
-        MSG = 'Redundant `self` detected.'.freeze
-
-        def initialize(config = nil, options = nil)
-          super
-          @allowed_send_nodes = []
-          @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }
-        end
-
-        # Assignment of self.x
-
-        def on_or_asgn(node)
-          lhs, _rhs = *node
-          allow_self(lhs)
-        end
-
-        alias on_and_asgn on_or_asgn
-
-        def on_op_asgn(node)
-          lhs, _op, _rhs = *node
-          allow_self(lhs)
-        end
-
-        # Using self.x to distinguish from local variable x
-
-        def on_def(node)
-          add_scope(node)
-        end
-
-        def on_defs(node)
-          add_scope(node)
-        end
-
-        def on_args(node)
-          node.children.each { |arg| on_argument(arg) }
-        end
-
-        def on_blockarg(node)
-          on_argument(node)
-        end
-
-        def on_lvasgn(node)
-          lhs, _rhs = *node
-          @local_variables_scopes[node] << lhs
-        end
-
-        # Detect offenses
-
-        def on_send(node)
-          receiver, method_name, *_args = *node
-          return unless receiver && receiver.self_type?
-          return unless regular_method_call?(node)
-
-          return if @allowed_send_nodes.include?(node) ||
-                    @local_variables_scopes[node].include?(method_name)
-          add_offense(node, :expression)
-        end
-
-        def autocorrect(node)
-          receiver, _method_name, *_args = *node
-          lambda do |corrector|
-            corrector.remove(receiver.source_range)
-            corrector.remove(node.loc.dot)
-          end
-        end
-
-        private
-
-        def add_scope(node)
-          local_variables = []
-          node.descendants.each do |child_node|
-            @local_variables_scopes[child_node] = local_variables
-          end
-        end
-
-        def regular_method_call?(node)
-          _receiver, method_name, *_args = *node
-
-          !(operator?(method_name) ||
-            keyword?(method_name) ||
-            constant_name?(method_name) ||
-            node.asgn_method_call? ||
-            braces_style_call?(node))
-        end
-
-        def on_argument(node)
-          name, = *node
-          @local_variables_scopes[node] << name
-        end
-
-        def keyword?(method_name)
-          [:alias, :and, :begin, :break, :case, :class, :def, :defined?, :do,
-           :else, :elsif, :end, :ensure, :false, :for, :if, :in, :module,
-           :next, :nil, :not, :or, :redo, :rescue, :retry, :return, :self,
-           :super, :then, :true, :undef, :unless, :until, :when, :while,
-           :yield].include?(method_name)
-        end
-
-        def constant_name?(method_name)
-          method_name.match(/^[A-Z]/)
-        end
-
-        def braces_style_call?(node)
-          node.loc.selector.nil?
-        end
-
-        def allow_self(node)
-          return unless node.send_type?
-
-          receiver, _method_name, *_args = *node
-
-          return unless receiver && receiver.self_type?
-
-          @allowed_send_nodes << node
-        end
-      end
-    end
-  end
-end

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

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop enforces using // or %r around regular expressions.
-      #
-      # @example
-      #   # Good if EnforcedStyle is slashes or mixed, bad if percent_r.
-      #   snake_case = /^[\dA-Z_]+$/
-      #
-      #   # Good if EnforcedStyle is percent_r, bad if slashes or mixed.
-      #   snake_case = %r{^[\dA-Z_]+$}
-      #
-      #   # Good if EnforcedStyle is slashes, bad if percent_r or mixed.
-      #   regex = /
-      #     foo
-      #     (bar)
-      #     (baz)
-      #   /x
-      #
-      #   # Good if EnforcedStyle is percent_r or mixed, bad if slashes.
-      #   regex = %r{
-      #     foo
-      #     (bar)
-      #     (baz)
-      #   }x
-      #
-      #   # Bad unless AllowInnerSlashes is true.
-      #   x =~ /home\//
-      class RegexpLiteral < Cop
-        include ConfigurableEnforcedStyle
-
-        MSG_USE_SLASHES = 'Use `//` around regular expression.'.freeze
-        MSG_USE_PERCENT_R = 'Use `%r` around regular expression.'.freeze
-
-        def on_regexp(node)
-          if slash_literal?(node)
-            check_slash_literal(node)
-          else
-            check_percent_r_literal(node)
-          end
-        end
-
-        private
-
-        def check_slash_literal(node)
-          return if allowed_slash_literal?(node)
-
-          add_offense(node, :expression, MSG_USE_PERCENT_R)
-        end
-
-        def check_percent_r_literal(node)
-          return if allowed_percent_r_literal?(node)
-
-          add_offense(node, :expression, MSG_USE_SLASHES)
-        end
-
-        def allowed_slash_literal?(node)
-          style == :slashes && !contains_disallowed_slash?(node) ||
-            style == :mixed && node.single_line? &&
-              !contains_disallowed_slash?(node)
-        end
-
-        def allowed_percent_r_literal?(node)
-          style == :slashes && contains_disallowed_slash?(node) ||
-            style == :percent_r ||
-            style == :mixed && node.multiline? ||
-            style == :mixed && contains_disallowed_slash?(node)
-        end
-
-        def contains_disallowed_slash?(node)
-          !allow_inner_slashes? && contains_slash?(node)
-        end
-
-        def contains_slash?(node)
-          node_body(node).include?('/')
-        end
-
-        def allow_inner_slashes?
-          cop_config['AllowInnerSlashes']
-        end
-
-        def node_body(node)
-          node.each_child_node(:str).map(&:source).join
-        end
-
-        def slash_literal?(node)
-          node.loc.begin.source == '/'
-        end
-
-        def preferred_delimiters
-          config.for_cop('Style/PercentLiteralDelimiters') \
-            ['PreferredDelimiters']['%r'].split(//)
-        end
-
-        def autocorrect(node)
-          return if contains_slash?(node)
-
-          replacement = if slash_literal?(node)
-                          ['%r', ''].zip(preferred_delimiters).map(&:join)
-                        else
-                          %w(/ /)
-                        end
-
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, replacement.first)
-            corrector.replace(node.loc.end, replacement.last)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks whether the rescue and ensure keywords are aligned
-      # properly.
-      #
-      # @example
-      #
-      #   # bad
-      #   begin
-      #     something
-      #     rescue
-      #     puts 'error'
-      #   end
-      #
-      #   # good
-      #   begin
-      #     something
-      #   rescue
-      #     puts 'error'
-      #   end
-      class RescueEnsureAlignment < Cop
-        MSG = '`%s` at %d, %d is not aligned with `end` at %d, %d.'.freeze
-
-        def on_resbody(node)
-          check(node) unless modifier?(node)
-        end
-
-        def on_ensure(node)
-          check(node)
-        end
-
-        def investigate(processed_source)
-          @modifier_locations =
-            processed_source.tokens.each_with_object([]) do |token, locations|
-              next unless token.type == :kRESCUE_MOD
-              locations << token.pos
-            end
-        end
-
-        def autocorrect(node)
-          whitespace = whitespace_range(node)
-          return false unless whitespace.source.strip.empty?
-
-          new_column = ancestor_node(node).loc.end.column
-          ->(corrector) { corrector.replace(whitespace, ' ' * new_column) }
-        end
-
-        private
-
-        def check(node)
-          end_loc = ancestor_node(node).loc.end
-          kw_loc = node.loc.keyword
-
-          return if end_loc.column == kw_loc.column
-          return if end_loc.line == kw_loc.line
-
-          add_offense(node, kw_loc, format_message(kw_loc, end_loc))
-        end
-
-        def format_message(kw_loc, end_loc)
-          format(MSG, kw_loc.source, kw_loc.line, kw_loc.column, end_loc.line,
-                 end_loc.column)
-        end
-
-        def modifier?(node)
-          return false unless @modifier_locations.respond_to?(:include?)
-          @modifier_locations.include?(node.loc.keyword)
-        end
-
-        def whitespace_range(node)
-          begin_pos = node.loc.keyword.begin_pos
-          current_column = node.loc.keyword.column
-
-          range_between(begin_pos - current_column, begin_pos)
-        end
-
-        def ancestor_node(node)
-          node.each_ancestor(:kwbegin, :def, :defs, :class, :module).first
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for uses of rescue in its modifier form.
-      class RescueModifier < Cop
-        include AutocorrectAlignment
-
-        MSG = 'Avoid using `rescue` in its modifier form.'.freeze
-
-        def investigate(processed_source)
-          @modifier_locations = processed_source
-                                .tokens
-                                .select { |t| t.type == :kRESCUE_MOD }
-                                .map(&:pos)
-        end
-
-        def on_resbody(node)
-          return unless modifier?(node)
-          add_offense(node.parent, :expression)
-        end
-
-        def autocorrect(node)
-          operation, rescue_modifier, = *node
-          *_, rescue_args = *rescue_modifier
-
-          indent = indentation(node)
-          correction =
-            "begin\n" \
-            "#{operation.source.gsub(/^/, indent)}" \
-            "\n#{offset(node)}rescue\n" \
-            "#{rescue_args.source.gsub(/^/, indent)}" \
-            "\n#{offset(node)}end"
-
-          lambda do |corrector|
-            corrector.replace(node.source_range, correction)
-          end
-        end
-
-        private
-
-        def modifier?(node)
-          @modifier_locations.include?(node.loc.keyword)
-        end
-      end
-    end
-  end
-end