dirwatch 0.0.6 → 0.0.7

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

@@ -1,276 +0,0 @@
-# frozen_string_literal: true
-# rubocop:disable Metrics/ModuleLength
-
-module RuboCop
-  module Cop
-    # This module contains a collection of useful utility methods.
-    module Util
-      include PathUtil
-      extend RuboCop::Sexp
-
-      BYTE_ORDER_MARK = 0xfeff # The Unicode codepoint
-
-      EQUALS_ASGN_NODES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn,
-                           :casgn, :masgn].freeze
-      SHORTHAND_ASGN_NODES = [:op_asgn, :or_asgn, :and_asgn].freeze
-      ASGN_NODES = (EQUALS_ASGN_NODES + SHORTHAND_ASGN_NODES).freeze
-
-      # http://phrogz.net/programmingruby/language.html#table_18.4
-      # Backtick is added last just to help editors parse this code.
-      OPERATOR_METHODS = %w(
-        | ^ & <=> == === =~ > >= < <= << >>
-        + - * / % ** ~ +@ -@ [] []= ! != !~
-      ).map(&:to_sym).push(:'`').freeze
-
-      # Match literal regex characters, not including anchors, character
-      # classes, alternatives, groups, repetitions, references, etc
-      LITERAL_REGEX = /[\w\s\-,"'!#%&<>=;:`~]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]/
-
-      module_function
-
-      def operator?(symbol)
-        OPERATOR_METHODS.include?(symbol)
-      end
-
-      def strip_quotes(str)
-        if str[0] == '"' || str[0] == "'"
-          str[0] = ''
-        else
-          # we're dealing with %q or %Q
-          str[0, 3] = ''
-        end
-        str[-1] = ''
-
-        str
-      end
-
-      def block_length(block_node)
-        block_node.loc.end.line - block_node.loc.begin.line
-      end
-
-      def comment_line?(line_source)
-        line_source =~ /^\s*#/
-      end
-
-      def line_range(arg)
-        source_range = case arg
-                       when Parser::Source::Range
-                         arg
-                       when Parser::AST::Node
-                         arg.source_range
-                       else
-                         raise ArgumentError, "Invalid argument #{arg}"
-                       end
-
-        source_range.begin.line..source_range.end.line
-      end
-
-      def parentheses?(node)
-        node.loc.respond_to?(:end) && node.loc.end &&
-          node.loc.end.is?(')'.freeze)
-      end
-
-      def parenthesized_call?(send)
-        send.loc.begin && send.loc.begin.is?('(')
-      end
-
-      def on_node(syms, sexp, excludes = [], &block)
-        return to_enum(:on_node, syms, sexp, excludes) unless block_given?
-
-        yield sexp if Array(syms).include?(sexp.type)
-        return if Array(excludes).include?(sexp.type)
-
-        sexp.each_child_node { |elem| on_node(syms, elem, excludes, &block) }
-      end
-
-      def source_range(source_buffer, line_number, column, length = 1)
-        if column.is_a?(Range)
-          column_index = column.begin
-          length = numeric_range_size(column)
-        else
-          column_index = column
-        end
-
-        line_begin_pos = if line_number.zero?
-                           0
-                         else
-                           source_buffer.line_range(line_number).begin_pos
-                         end
-        begin_pos = line_begin_pos + column_index
-        end_pos = begin_pos + length
-
-        Parser::Source::Range.new(source_buffer, begin_pos, end_pos)
-      end
-
-      # Returns the column attribute of the range, except if the range is on
-      # the first line and there's a byte order mark at the beginning of that
-      # line, in which case 1 is subtracted from the column value. This gives
-      # the column as it appears when viewing the file in an editor.
-      def effective_column(range)
-        if range.line == 1 &&
-           @processed_source.raw_source.codepoints.first == BYTE_ORDER_MARK
-          range.column - 1
-        else
-          range.column
-        end
-      end
-
-      def range_between(start_pos, end_pos)
-        Parser::Source::Range.new(processed_source.buffer, start_pos, end_pos)
-      end
-
-      def range_with_surrounding_comma(range, side = :both)
-        buffer = @processed_source.buffer
-        src = buffer.source
-
-        go_left, go_right = directions(side)
-
-        begin_pos = range.begin_pos
-        end_pos = range.end_pos
-        begin_pos = move_pos(src, begin_pos, -1, go_left, /,/)
-        end_pos = move_pos(src, end_pos, 1, go_right, /,/)
-
-        Parser::Source::Range.new(buffer, begin_pos, end_pos)
-      end
-
-      def range_with_surrounding_space(range, side = :both, with_newline = true)
-        buffer = @processed_source.buffer
-        src = buffer.source
-
-        go_left, go_right = directions(side)
-
-        begin_pos = range.begin_pos
-        end_pos = range.end_pos
-        begin_pos = move_pos(src, begin_pos, -1, go_left, /[ \t]/)
-        begin_pos = move_pos(src, begin_pos, -1, go_left && with_newline, /\n/)
-        end_pos = move_pos(src, end_pos, 1, go_right, /[ \t]/)
-        end_pos = move_pos(src, end_pos, 1, go_right && with_newline, /\n/)
-        Parser::Source::Range.new(buffer, begin_pos, end_pos)
-      end
-
-      def move_pos(src, pos, step, condition, regexp)
-        offset = step == -1 ? -1 : 0
-        pos += step while condition && src[pos + offset] =~ regexp
-        pos < 0 ? 0 : pos
-      end
-
-      def directions(side)
-        if side == :both
-          [true, true]
-        else
-          [side == :left, side == :right]
-        end
-      end
-
-      def begins_its_line?(range)
-        (range.source_line =~ /\S/) == range.column
-      end
-
-      def ends_its_line?(range)
-        line = range.source_buffer.source_line(range.last_line)
-        (line =~ /\s*\z/) == range.last_column
-      end
-
-      def within_node?(inner, outer)
-        o = outer.is_a?(Node) ? outer.source_range : outer
-        i = inner.is_a?(Node) ? inner.source_range : inner
-        i.begin_pos >= o.begin_pos && i.end_pos <= o.end_pos
-      end
-
-      # Returns, for example, a bare `if` node if the given node is an `if`
-      # with calls chained to the end of it.
-      def first_part_of_call_chain(node)
-        while node
-          case node.type
-          when :send
-            receiver, _method_name, _args = *node
-            node = receiver
-          when :block
-            method, _args, _body = *node
-            node = method
-          else
-            break
-          end
-        end
-        node
-      end
-
-      # Range#size is not available prior to Ruby 2.0.
-      def numeric_range_size(range)
-        size = range.end - range.begin
-        size += 1 unless range.exclude_end?
-        size = 0 if size < 0
-        size
-      end
-
-      # If converting a string to Ruby string literal source code, must
-      # double quotes be used?
-      def double_quotes_required?(string)
-        # Double quotes are required for strings which either:
-        # - Contain single quotes
-        # - Contain non-printable characters, which must use an escape
-
-        # Regex matches IF there is a ' or there is a \\ in the string that is
-        # not preceded/followed by another \\ (e.g. "\\x34") but not "\\\\".
-        string =~ /'|(?<! \\) \\{2}* \\ (?![\\"])/x
-      end
-
-      # If double quoted string literals are found in Ruby code, and they are
-      # not the preferred style, should they be flagged?
-      def double_quotes_acceptable?(string)
-        needs_escaping?(string) || hard_to_type?(string)
-      end
-
-      def hard_to_type?(string)
-        string.codepoints.any? { |cp| cp < 32 || cp > 126 }
-      end
-
-      def needs_escaping?(string)
-        double_quotes_required?(escape_string(string))
-      end
-
-      def escape_string(string)
-        string.inspect[1..-2].tap { |s| s.gsub!(/\\"/, '"') }
-      end
-
-      def to_string_literal(string)
-        if needs_escaping?(string) && compatible_external_encoding_for?(string)
-          string.inspect
-        else
-          "'#{string.gsub('\\') { '\\\\' }}'"
-        end
-      end
-
-      def to_symbol_literal(string)
-        ":#{string.to_sym}"
-      end
-
-      def interpret_string_escapes(string)
-        StringInterpreter.interpret(string)
-      end
-
-      def same_line?(n1, n2)
-        n1.respond_to?(:loc) &&
-          n2.respond_to?(:loc) &&
-          n1.loc.line == n2.loc.line
-      end
-
-      def line_distance(n1, n2)
-        n2.loc.line - n1.loc.line
-      end
-
-      def preceed?(n1, n2)
-        line_distance(n1, n2) == 1
-      end
-
-      def stripped_source_upto(line)
-        processed_source[0..line].map(&:strip)
-      end
-
-      def compatible_external_encoding_for?(src)
-        src = src.dup if RUBY_VERSION < '2.3'
-        src.force_encoding(Encoding.default_external).valid_encoding?
-      end
-    end
-  end
-end

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

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    class VariableForce
-      # This class represents each assignment of a variable.
-      class Assignment
-        include Locatable
-
-        MULTIPLE_LEFT_HAND_SIDE_TYPE = :mlhs
-        REFERENCE_PENETRABLE_BRANCH_TYPES = %w(rescue_main ensure_main).freeze
-
-        attr_reader :node, :variable, :referenced
-        alias referenced? referenced
-
-        def initialize(node, variable)
-          unless VARIABLE_ASSIGNMENT_TYPES.include?(node.type)
-            raise ArgumentError,
-                  "Node type must be any of #{VARIABLE_ASSIGNMENT_TYPES}, " \
-                  "passed #{node.type}"
-          end
-
-          @node = node
-          @variable = variable
-          @referenced = false
-
-          super
-        end
-
-        def name
-          @node.children.first
-        end
-
-        def scope
-          @variable.scope
-        end
-
-        def reference!
-          @referenced = true
-        end
-
-        def used?
-          @variable.captured_by_block? || @referenced
-        end
-
-        def reference_penetrable?
-          REFERENCE_PENETRABLE_BRANCH_TYPES.include?(branch_type)
-        end
-
-        def regexp_named_capture?
-          @node.type == REGEXP_NAMED_CAPTURE_TYPE
-        end
-
-        def operator_assignment?
-          return false unless meta_assignment_node
-          OPERATOR_ASSIGNMENT_TYPES.include?(meta_assignment_node.type)
-        end
-
-        def multiple_assignment?
-          return false unless meta_assignment_node
-          meta_assignment_node.type == MULTIPLE_ASSIGNMENT_TYPE
-        end
-
-        def operator
-          assignment_node = meta_assignment_node || @node
-          assignment_node.loc.operator.source
-        end
-
-        def meta_assignment_node
-          unless instance_variable_defined?(:@meta_assignment_node)
-            @meta_assignment_node =
-              operator_assignment_node || multiple_assignment_node
-          end
-
-          @meta_assignment_node
-        end
-
-        private
-
-        def operator_assignment_node
-          return nil unless node.parent
-          return nil unless OPERATOR_ASSIGNMENT_TYPES.include?(node.parent.type)
-          return nil unless node.sibling_index.zero?
-          node.parent
-        end
-
-        def multiple_assignment_node
-          grandparent_node = node.parent ? node.parent.parent : nil
-          return nil unless grandparent_node
-          return nil unless grandparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
-          return nil unless node.parent.type == MULTIPLE_LEFT_HAND_SIDE_TYPE
-          grandparent_node
-        end
-      end
-    end
-  end
-end

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

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    class VariableForce
-      # This module provides a way to locate the conditional branch the node is
-      # in. This is intended to be used as mix-in.
-      module Locatable
-        BRANCH_TYPES = [:if, :case].freeze
-        CONDITION_INDEX_OF_BRANCH_NODE = 0
-
-        LOGICAL_OPERATOR_TYPES = [:and, :or].freeze
-        LEFT_SIDE_INDEX_OF_LOGICAL_OPERATOR_NODE = 0
-
-        ENSURE_TYPE = :ensure
-        ENSURE_INDEX_OF_ENSURE_NODE = 1
-
-        FOR_LOOP_TYPE = :for
-        FOR_LOOP_CHILD_INDEX = 2
-
-        NON_FOR_LOOP_TYPES = LOOP_TYPES - [FOR_LOOP_TYPE]
-        NON_FOR_LOOP_TYPES_CHILD_INDEX = 1
-
-        def initialize(*)
-          @branch_point_node = @branch_body_node = nil
-
-          super()
-        end
-
-        def node
-          raise '#node must be declared!'
-        end
-
-        def scope
-          raise '#scope must be declared!'
-        end
-
-        def inside_of_branch?
-          branch_point_node
-        end
-
-        def run_exclusively_with?(other)
-          return false unless branch_point_node.equal?(other.branch_point_node)
-          return false if branch_body_node.equal?(other.branch_body_node)
-
-          # Main body of rescue is always run:
-          #
-          #   begin
-          #     # main
-          #   rescue
-          #     # resbody
-          #   end
-          if branch_point_node.rescue_type? &&
-             (branch_body_name == 'main' || other.branch_body_name == 'main')
-            return false
-          end
-
-          true
-        end
-
-        def branch_id
-          return nil unless inside_of_branch?
-          @branch_id ||= [branch_point_node.object_id, branch_type].join('_')
-        end
-
-        def branch_type
-          return nil unless inside_of_branch?
-          @branch_type ||= [branch_point_node.type, branch_body_name].join('_')
-        end
-
-        # Inner if, case, rescue, or ensure node.
-        def branch_point_node
-          return @branch_point_node if @branch_point_node
-
-          set_branch_point_and_body_nodes!
-          @branch_point_node
-        end
-
-        # A child node of #branch_point_node this assignment belongs.
-        def branch_body_node
-          return @branch_body_node if @branch_body_node
-
-          set_branch_point_and_body_nodes!
-          @branch_body_node
-        end
-
-        # TODO: Replace case statement with function mapping
-        def branch_body_name
-          case branch_point_node.type
-          when :if                     then if_body_name
-          when :case                   then case_body_name
-          when RESCUE_TYPE             then rescue_body_name
-          when ENSURE_TYPE             then ensure_body_name
-          when *LOGICAL_OPERATOR_TYPES then logical_operator_body_name
-          when *LOOP_TYPES             then loop_body_name
-          else
-            raise InvalidBranchBodyError, "Invalid body index #{body_index} " \
-                                          "of #{branch_point_node.type}"
-          end
-        end
-
-        private
-
-        def if_body_name
-          case body_index
-          when 1 then 'true'
-          when 2 then 'false'
-          else raise InvalidBranchBodyError
-          end
-        end
-
-        def case_body_name
-          if branch_body_node.when_type?
-            "when#{body_index - 1}"
-          else
-            'else'
-          end
-        end
-
-        def logical_operator_body_name
-          case body_index
-          when 1 then 'right'
-          else raise InvalidBranchBodyError
-          end
-        end
-
-        def rescue_body_name
-          if body_index.zero?
-            'main'
-          elsif branch_body_node.type == :resbody
-            "rescue#{body_index - 1}"
-          else
-            'else'
-          end
-        end
-
-        def ensure_body_name
-          case body_index
-          when 0 then 'main'
-          else raise InvalidBranchBodyError
-          end
-        end
-
-        def loop_body_name
-          loop_indices = [FOR_LOOP_CHILD_INDEX, NON_FOR_LOOP_TYPES_CHILD_INDEX]
-
-          raise InvalidBranchBodyError unless loop_indices.include?(body_index)
-
-          'main'
-        end
-
-        def body_index
-          branch_point_node.children.index { |n| n.equal?(branch_body_node) }
-        end
-
-        def set_branch_point_and_body_nodes!
-          self_and_ancestor_nodes = [node] + ancestor_nodes_in_scope
-
-          self_and_ancestor_nodes.each_cons(2) do |child, parent|
-            next unless branch?(parent, child)
-            @branch_point_node = parent
-            @branch_body_node = child
-            break
-          end
-        end
-
-        def ancestor_nodes_in_scope
-          node.each_ancestor.take_while do |ancestor_node|
-            !ancestor_node.equal?(scope.node)
-          end
-        end
-
-        # rubocop:disable Metrics/MethodLength
-        def branch?(parent_node, child_node)
-          child_index = parent_node.children.index(child_node)
-
-          case parent_node.type
-          when RESCUE_TYPE
-            true
-          when ENSURE_TYPE
-            child_index != ENSURE_INDEX_OF_ENSURE_NODE
-          when FOR_LOOP_TYPE
-            child_index == FOR_LOOP_CHILD_INDEX
-          when *BRANCH_TYPES
-            child_index != CONDITION_INDEX_OF_BRANCH_NODE
-          when *LOGICAL_OPERATOR_TYPES
-            child_index != LEFT_SIDE_INDEX_OF_LOGICAL_OPERATOR_NODE
-          when *NON_FOR_LOOP_TYPES
-            child_index == NON_FOR_LOOP_TYPES_CHILD_INDEX
-          else
-            false
-          end
-        end
-        # rubocop:enable Metrics/MethodLength
-
-        class InvalidBranchBodyError < StandardError; end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    class VariableForce
-      # This class represents each reference of a variable.
-      class Reference
-        include Locatable
-
-        VARIABLE_REFERENCE_TYPES = (
-          [VARIABLE_REFERENCE_TYPE] +
-          OPERATOR_ASSIGNMENT_TYPES +
-          [ZERO_ARITY_SUPER_TYPE, SEND_TYPE]
-        ).freeze
-
-        attr_reader :node, :scope
-
-        def initialize(node, scope)
-          unless VARIABLE_REFERENCE_TYPES.include?(node.type)
-            raise ArgumentError,
-                  "Node type must be any of #{VARIABLE_REFERENCE_TYPES}, " \
-                  "passed #{node.type}"
-          end
-
-          @node = node
-          @scope = scope
-
-          super
-        end
-
-        # There's an implicit variable reference by the zero-arity `super`:
-        #
-        #     def some_method(foo)
-        #       super
-        #     end
-        #
-        # Another case is `binding`:
-        #
-        #     def some_method(foo)
-        #       do_something(binding)
-        #     end
-        #
-        # In these cases, the variable `foo` is not explicitly referenced,
-        # but it can be considered used implicitly by the `super` or `binding`.
-        def explicit?
-          ![ZERO_ARITY_SUPER_TYPE, SEND_TYPE].include?(@node.type)
-        end
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    class VariableForce
-      # A Scope represents a context of local variable visibility.
-      # This is a place where local variables belong to.
-      # A scope instance holds a scope node and variable entries.
-      class Scope
-        OUTER_SCOPE_CHILD_INDICES = {
-          defs:   0..0,
-          module: 0..0,
-          class:  0..1,
-          sclass: 0..0,
-          block:  0..0
-        }.freeze
-
-        attr_reader :node, :variables
-
-        def initialize(node)
-          # Accept any node type for top level scope
-          unless SCOPE_TYPES.include?(node.type) || !node.parent
-            raise ArgumentError,
-                  "Node type must be any of #{SCOPE_TYPES}, " \
-                  "passed #{node.type}"
-          end
-          @node = node
-          @variables = {}
-        end
-
-        def ==(other)
-          @node.equal?(other.node)
-        end
-
-        def name
-          # TODO: Add an else clause
-          case @node.type
-          when :def  then @node.children[0]
-          when :defs then @node.children[1]
-          end
-        end
-
-        def body_node
-          child_index = case @node.type
-                        when :module, :sclass     then 1
-                        when :def, :class, :block then 2
-                        when :defs                then 3
-                        end
-
-          child_index ? @node.children[child_index] : @node
-        end
-
-        def each_node(&block)
-          return to_enum(__method__) unless block_given?
-          scan_node(node, &block)
-        end
-
-        private
-
-        def scan_node(node, &block)
-          yield node unless node.parent
-
-          node.each_child_node do |child_node|
-            next if belong_to_another_scope?(child_node)
-            yield child_node
-            scan_node(child_node, &block)
-          end
-        end
-
-        def belong_to_another_scope?(node)
-          belong_to_outer_scope?(node) || belong_to_inner_scope?(node)
-        end
-
-        def belong_to_outer_scope?(target_node)
-          return false unless target_node.parent.equal?(node)
-          indices = OUTER_SCOPE_CHILD_INDICES[target_node.parent.type]
-          return false unless indices
-          indices.include?(target_node.sibling_index)
-        end
-
-        def belong_to_inner_scope?(target_node)
-          return false if target_node.parent.equal?(node)
-          return false unless SCOPE_TYPES.include?(target_node.parent.type)
-          indices = OUTER_SCOPE_CHILD_INDICES[target_node.parent.type]
-          return true unless indices
-          !indices.include?(target_node.sibling_index)
-        end
-      end
-    end
-  end
-end