dirwatch 0.0.1 → 0.0.2

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking the closing brace of a literal is
+    # either on the same line as the last contained elements, or a new line.
+    module MultilineLiteralBraceLayout
+      include ConfigurableEnforcedStyle
+
+      def check_brace_layout(node)
+        return if ignored_literal?(node)
+
+        # If the last node is or contains a conflicting HEREDOC, we don't want
+        # to adjust the brace layout because this will result in invalid code.
+        return if last_line_heredoc?(node.children.last)
+
+        check(node)
+      end
+
+      def autocorrect(node)
+        if closing_brace_on_same_line?(node)
+          lambda do |corrector|
+            corrector.insert_before(node.loc.end, "\n".freeze)
+          end
+        else
+          lambda do |corrector|
+            corrector.remove(range_with_surrounding_space(node.loc.end,
+                                                          :left))
+
+            corrector.insert_after(last_element_range_with_trailing_comma(node),
+                                   node.loc.end.source)
+          end
+        end
+      end
+
+      private
+
+      def check(node)
+        case style
+        when :symmetrical then check_symmetrical(node)
+        when :new_line then check_new_line(node)
+        when :same_line then check_same_line(node)
+        end
+      end
+
+      def check_new_line(node)
+        return unless closing_brace_on_same_line?(node)
+
+        add_offense(node, :end, self.class::ALWAYS_NEW_LINE_MESSAGE)
+      end
+
+      def check_same_line(node)
+        return if closing_brace_on_same_line?(node)
+
+        add_offense(node, :end, self.class::ALWAYS_SAME_LINE_MESSAGE)
+      end
+
+      def check_symmetrical(node)
+        if opening_brace_on_same_line?(node)
+          return if closing_brace_on_same_line?(node)
+
+          add_offense(node, :end, self.class::SAME_LINE_MESSAGE)
+        else
+          return unless closing_brace_on_same_line?(node)
+
+          add_offense(node, :end, self.class::NEW_LINE_MESSAGE)
+        end
+      end
+
+      def ignored_literal?(node)
+        implicit_literal?(node) || empty_literal?(node) || node.single_line?
+      end
+
+      def implicit_literal?(node)
+        !node.loc.begin
+      end
+
+      def empty_literal?(node)
+        children(node).empty?
+      end
+
+      def last_element_range_with_trailing_comma(node)
+        trailing_comma_range = last_element_trailing_comma_range(node)
+        if trailing_comma_range
+          children(node).last.source_range.join(trailing_comma_range)
+        else
+          children(node).last.source_range
+        end
+      end
+
+      def last_element_trailing_comma_range(node)
+        range = range_with_surrounding_space(children(node).last.source_range,
+                                             :right).end.resize(1)
+        range.source == ',' ? range : nil
+      end
+
+      def children(node)
+        node.children
+      end
+
+      # This method depends on the fact that we have guarded
+      # against implicit and empty literals.
+      def opening_brace_on_same_line?(node)
+        node.loc.begin.line == children(node).first.loc.first_line
+      end
+
+      # This method depends on the fact that we have guarded
+      # against implicit and empty literals.
+      def closing_brace_on_same_line?(node)
+        node.loc.end.line == children(node).last.loc.last_line
+      end
+
+      # Starting with the parent node and recursively for the parent node's
+      # children, check if the node is a HEREDOC and if the HEREDOC ends below
+      # or on the last line of the parent node.
+      #
+      # Example:
+      #
+      #   # node is `b: ...` parameter
+      #   # last_line_heredoc?(node) => false
+      #   foo(a,
+      #     b: {
+      #       a: 1,
+      #       c: <<-EOM
+      #         baz
+      #       EOM
+      #     }
+      #   )
+      #
+      #   # node is `b: ...` parameter
+      #   # last_line_heredoc?(node) => true
+      #   foo(a,
+      #     b: <<-EOM
+      #       baz
+      #     EOM
+      #   )
+      def last_line_heredoc?(node, parent = nil)
+        parent ||= node
+
+        if node.respond_to?(:loc) &&
+           node.loc.respond_to?(:heredoc_end) &&
+           node.loc.heredoc_end.last_line >= parent.loc.last_line
+          return true
+        end
+
+        return false unless node.respond_to?(:children)
+
+        node.children.any? { |child| last_line_heredoc?(child, parent) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Some common code shared between FavorUnlessOverNegatedIf and
+    # FavorUntilOverNegatedWhile.
+    module NegativeConditional
+      extend NodePattern::Macros
+      include IfNode
+
+      def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
+      def_node_matcher :empty_condition?, '(begin)'
+
+      def check_negative_conditional(node)
+        condition, _body, _rest = *node
+
+        return if empty_condition?(condition)
+
+        # Look at last expression of contents if there are parentheses
+        # around condition.
+        condition = condition.children.last while condition.begin_type?
+
+        return unless single_negative?(condition) && !if_else?(node)
+
+        add_offense(node, :expression)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking instance methods and singleton methods.
+    module OnMethodDef
+      def on_def(node)
+        method_name, args, body = *node
+        on_method_def(node, method_name, args, body)
+      end
+
+      def on_defs(node)
+        _scope, method_name, args, body = *node
+        on_method_def(node, method_name, args, body)
+      end
+
+      private
+
+      # Returns true for constructs such as
+      # private def my_method
+      # which are allowed in Ruby 2.1 and later.
+      def modifier_and_def_on_same_line?(send_node)
+        send_node.receiver.nil? &&
+          send_node.method_name != :def &&
+          send_node.method_args.size == 1 &&
+          [:def, :defs].include?(send_node.method_args.first.type)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops checking if and unless expressions.
+    module OnNormalIfUnless
+      include IfNode
+
+      def on_if(node)
+        invoke_hook_for_normal_if_unless(node)
+      end
+
+      def invoke_hook_for_normal_if_unless(node)
+        # We won't check modifier or ternary conditionals.
+        return if modifier_if?(node) || ternary?(node)
+        on_normal_if_unless(node)
+      end
+
+      def if_else_clause(node)
+        return unless node.if_type?
+
+        keyword = node.loc.keyword
+        if keyword.is?('if')
+          node.children.last
+        elsif keyword.is?('elsif')
+          node.children.last
+        elsif keyword.is?('unless')
+          node.children[1]
+        end
+      end
+
+      def case_else_clause(node)
+        node.children.last if node.case_type?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling parentheses.
+    module Parentheses
+      def parens_required?(node)
+        range  = node.source_range
+        source = range.source_buffer.source
+        source[range.begin_pos - 1] =~ /[a-z]/ ||
+          source[range.end_pos] =~ /[a-z]/
+      end
+
+      def autocorrect(node)
+        lambda do |corrector|
+          corrector.remove(node.loc.begin)
+          corrector.remove(node.loc.end)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops which processes Parser's diagnostics.
+    # This mixin requires its user class to define `#relevant_diagnostic?`.
+    #
+    #     def relevant_diagnostic?(diagnostic)
+    #       diagnostic.reason == :my_interested_diagnostic_type
+    #     end
+    #
+    # If you want to use an alternative offense message rather than the one in
+    # Parser's diagnostic, define `#alternative_message`.
+    #
+    #     def alternative_message(diagnostic)
+    #       'My custom message'
+    #     end
+    module ParserDiagnostic
+      def investigate(processed_source)
+        processed_source.diagnostics.each do |d|
+          next unless relevant_diagnostic?(d)
+
+          message = if respond_to?(:alternative_message, true)
+                      alternative_message(d)
+                    else
+                      d.message.capitalize
+                    end
+
+          add_offense(nil, d.location, message, d.level)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling percent literals.
+    module PercentLiteral
+      def percent_literal?(node)
+        return unless (begin_source = begin_source(node))
+        begin_source.start_with?('%')
+      end
+
+      def process(node, *types)
+        return unless percent_literal?(node) && types.include?(type(node))
+        on_percent_literal(node)
+      end
+
+      def begin_source(node)
+        node.loc.begin.source if node.loc.respond_to?(:begin) && node.loc.begin
+      end
+
+      def type(node)
+        node.loc.begin.source[0..-2]
+      end
+
+      # A range containing only the contents of the percent literal (e.g. in
+      # %i{1 2 3} this will be the range covering '1 2 3' only)
+      def contents_range(node)
+        range_between(node.loc.begin.end_pos, node.loc.end.begin_pos)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking whether an AST node/token is aligned
+    # with something on a preceding or following line
+    module PrecedingFollowingAlignment
+      def allow_for_alignment?
+        cop_config['AllowForAlignment']
+      end
+
+      def aligned_with_something?(range)
+        aligned_with_adjacent_line?(range, method(:aligned_token?))
+      end
+
+      def aligned_with_operator?(range)
+        aligned_with_adjacent_line?(range, method(:aligned_operator?))
+      end
+
+      def aligned_with_adjacent_line?(range, predicate)
+        # minus 2 because node.loc.line is zero-based
+        pre  = (range.line - 2).downto(0)
+        post = range.line.upto(processed_source.lines.size - 1)
+
+        aligned_with_any_line_range?([pre, post], range, &predicate)
+      end
+
+      def aligned_with_any_line_range?(line_ranges, range, &predicate)
+        return true if aligned_with_any_line?(line_ranges, range, &predicate)
+
+        # If no aligned token was found, search for an aligned token on the
+        # nearest line with the same indentation as the checked line.
+        base_indentation = processed_source.lines[range.line - 1] =~ /\S/
+
+        aligned_with_any_line?(line_ranges, range, base_indentation, &predicate)
+      end
+
+      def aligned_with_any_line?(line_ranges, range, indent = nil, &predicate)
+        line_ranges.any? do |line_nos|
+          aligned_with_line?(line_nos, range, indent, &predicate)
+        end
+      end
+
+      def aligned_with_line?(line_nos, range, indent = nil)
+        line_nos.each do |lineno|
+          next if comment_lines.include?(lineno + 1)
+          line = processed_source.lines[lineno]
+          index = line =~ /\S/
+          next unless index
+          next if indent && indent != index
+          return yield(range, line)
+        end
+        false
+      end
+
+      def comment_lines
+        @comment_lines ||= processed_source.comments.map(&:loc).select do |r|
+          begins_its_line?(r.expression)
+        end.map(&:line)
+      end
+
+      def aligned_token?(range, line)
+        aligned_words?(range, line) ||
+          aligned_char?(range, line) ||
+          aligned_assignment?(range, line)
+      end
+
+      def aligned_operator?(range, line)
+        (aligned_identical?(range, line) || aligned_assignment?(range, line))
+      end
+
+      def aligned_words?(range, line)
+        line[range.column - 1, 2] =~ /\s\S/
+      end
+
+      def aligned_char?(range, line)
+        line[range.column] == range.source[0]
+      end
+
+      def aligned_assignment?(range, line)
+        range.source[-1] == '=' && line[range.last_column - 1] == '='
+      end
+
+      def aligned_identical?(range, line)
+        range.source == line[range.column, range.size]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for safe assignment. By safe assignment we mean
+    # putting parentheses around an assignment to indicate "I know I'm using an
+    # assignment as a condition. It's not a mistake."
+    module SafeAssignment
+      extend NodePattern::Macros
+
+      def_node_matcher :empty_condition?, '(begin)'
+      def_node_matcher :safe_assignment?,
+                       '(begin {equals_asgn? asgn_method_call?})'
+
+      def safe_assignment_allowed?
+        cop_config['AllowSafeAssignment']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Rails safe mode.
+    module SafeMode
+      private
+
+      def rails_safe_mode?
+        safe_mode? || rails?
+      end
+
+      def safe_mode?
+        cop_config['SafeMode']
+      end
+
+      def rails?
+        config['Rails'] && config['Rails']['Enabled']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops checking for missing space after
+    # punctuation.
+    module SpaceAfterPunctuation
+      MSG = 'Space missing after %s.'.freeze
+
+      def investigate(processed_source)
+        each_missing_space(processed_source.tokens) do |token|
+          add_offense(token, token.pos, format(MSG, kind(token)))
+        end
+      end
+
+      def each_missing_space(tokens)
+        tokens.each_cons(2) do |t1, t2|
+          next unless kind(t1)
+          next unless space_missing?(t1, t2)
+          next unless space_required_before?(t2)
+
+          yield t1
+        end
+      end
+
+      def space_missing?(t1, t2)
+        t1.pos.line == t2.pos.line && t2.pos.column == t1.pos.column + offset
+      end
+
+      def space_required_before?(token)
+        !(allowed_type?(token) ||
+          (token.type == :tRCURLY && space_forbidden_before_rcurly?))
+      end
+
+      def allowed_type?(token)
+        [:tRPAREN, :tRBRACK, :tPIPE].include?(token.type)
+      end
+
+      def space_forbidden_before_rcurly?
+        style = space_style_before_rcurly
+        style == 'no_space'
+      end
+
+      # The normal offset, i.e., the distance from the punctuation
+      # token where a space should be, is 1.
+      def offset
+        1
+      end
+
+      def autocorrect(token)
+        ->(corrector) { corrector.replace(token.pos, token.pos.source + ' ') }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops checking for space before
+    # punctuation.
+    module SpaceBeforePunctuation
+      MSG = 'Space found before %s.'.freeze
+
+      def investigate(processed_source)
+        each_missing_space(processed_source.tokens) do |token, pos_before|
+          add_offense(pos_before, pos_before, format(MSG, kind(token)))
+        end
+      end
+
+      def each_missing_space(tokens)
+        tokens.each_cons(2) do |t1, t2|
+          next unless kind(t2)
+          next unless space_missing?(t1, t2)
+          next if space_required_after?(t1)
+
+          pos_before_punctuation = range_between(t1.pos.end_pos,
+                                                 t2.pos.begin_pos)
+
+          yield t2, pos_before_punctuation
+        end
+      end
+
+      def space_missing?(t1, t2)
+        t1.pos.line == t2.pos.line && t2.pos.begin_pos > t1.pos.end_pos
+      end
+
+      def space_required_after?(token)
+        token.type == :tLCURLY && space_required_after_lcurly?
+      end
+
+      def space_required_after_lcurly?
+        cfg = config.for_cop('Style/SpaceInsideBlockBraces')
+        style = cfg['EnforcedStyle'] || 'space'
+        style == 'space'
+      end
+
+      def autocorrect(pos_before_punctuation)
+        ->(corrector) { corrector.remove(pos_before_punctuation) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking for spaces inside various
+    # kinds of brackets.
+    module SpaceInside
+      include SurroundingSpace
+      MSG = 'Space inside %s detected.'.freeze
+
+      def investigate(processed_source)
+        @processed_source = processed_source
+        each_extraneous_space(processed_source.tokens) do |kind, range|
+          add_offense(range, range, format(MSG, kind))
+        end
+      end
+
+      def autocorrect(range)
+        ->(corrector) { corrector.remove(range) }
+      end
+
+      private
+
+      def each_extraneous_space(tokens)
+        brackets = Brackets.new(*specifics)
+        tokens.each_cons(2) do |t1, t2|
+          next unless matching_brackets?(brackets, t1, t2)
+
+          # If the second token is a comment, that means that a line break
+          # follows, and that the rules for space inside don't apply.
+          next if t2.type == :tCOMMENT
+          next unless t2.pos.line == t1.pos.line && space_between?(t1, t2)
+
+          yield brackets.kind, range_between_tokens(t1, t2)
+        end
+      end
+
+      def matching_brackets?(brackets, t1, t2)
+        brackets.left_side?(t1) || brackets.right_side?(t2)
+      end
+
+      def range_between_tokens(t1, t2)
+        range_between(t1.pos.end_pos, t2.pos.begin_pos)
+      end
+
+      # Wraps info about the brackets. Makes it easy to check whether a token
+      # is one of the brackets.
+      #
+      # @example Parentheses `()`
+      #   Brackets.new(:tLPAREN, :tRPAREN, 'parentheses')
+      #
+      # @example Square brackets `[]`
+      #   Brackets.new([:tLBRACK, :tLBRACK2], :tRBRACK, 'square brackets')
+      #
+      class Brackets
+        attr_reader :kind
+
+        def initialize(left, right, kind)
+          @left_side_types = [left].flatten
+          @right_side_type = right
+          @kind = kind
+        end
+
+        def left_side?(token)
+          # Left side bracket has to be able to match multiple types
+          # (e.g. :tLBRACK and :tLBRACK2)
+          @left_side_types.include?(token.type)
+        end
+
+        def right_side?(token)
+          @right_side_type == token.type
+        end
+      end
+    end
+  end
+end