dirwatch 0.0.6 → 0.0.7

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

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks whether the end keywords are aligned properly for do
-      # end blocks.
-      #
-      # Three modes are supported through the `AlignWith` configuration
-      # parameter:
-      #
-      # `start_of_block` : the `end` shall be aligned with the
-      # start of the line where the `do` appeared.
-      #
-      # `start_of_line` : the `end` shall be aligned with the
-      # start of the line where the expression started.
-      #
-      # `either` (which is the default) : the `end` is allowed to be in either
-      # location. The autofixer will default to `start_of_line`.
-      #
-      # @example
-      #
-      #   # either
-      #   variable = lambda do |i|
-      #     i
-      #   end
-      #
-      #   # start_of_block
-      #   foo.bar
-      #     .each do
-      #        baz
-      #      end
-      #
-      #   # start_of_line
-      #   foo.bar
-      #     .each do
-      #        baz
-      #   end
-      class BlockAlignment < Cop
-        include ConfigurableEnforcedStyle
-
-        MSG = '%s is not aligned with %s%s.'.freeze
-
-        def_node_matcher :block_end_align_target?, <<-PATTERN
-          {assignment?
-           splat
-           and
-           or
-           (send _ :<<  ...)
-           (send equal?(%1) !:[] ...)}
-        PATTERN
-
-        def on_block(node)
-          check_block_alignment(start_for_block_node(node), node)
-        end
-
-        def parameter_name
-          'AlignWith'
-        end
-
-        private
-
-        def start_for_block_node(block_node)
-          # Which node should we align the 'end' with?
-          result = block_end_align_target(block_node)
-
-          # In offense message, we want to show the assignment LHS rather than
-          # the entire assignment
-          result, = *result while result.op_asgn_type? || result.masgn_type?
-          result
-        end
-
-        def block_end_align_target(node)
-          while (parent = node.parent)
-            break if !parent || !parent.loc
-            break if parent.loc.line != node.loc.line && !parent.masgn_type?
-            break unless block_end_align_target?(parent, node)
-            node = parent
-          end
-
-          node
-        end
-
-        def check_block_alignment(start_node, block_node)
-          end_loc = block_node.loc.end
-          return unless begins_its_line?(end_loc)
-
-          start_loc = start_node.source_range
-          return unless start_loc.column != end_loc.column ||
-                        style == :start_of_block
-
-          do_source_line_column =
-            compute_do_source_line_column(block_node, end_loc)
-          return unless do_source_line_column
-
-          offense(block_node, start_loc, end_loc, do_source_line_column)
-        end
-
-        def offense(block_node, start_loc, end_loc, do_source_line_column)
-          error_source_line_column = if style == :start_of_block
-                                       do_source_line_column
-                                     else
-                                       loc_to_source_line_column(start_loc)
-                                     end
-
-          message = format_message(start_loc, end_loc, do_source_line_column,
-                                   error_source_line_column)
-
-          add_offense(block_node, end_loc, message)
-        end
-
-        def format_message(start_loc, end_loc, do_source_line_column,
-                           error_source_line_column)
-          format(
-            MSG,
-            format_source_line_column(loc_to_source_line_column(end_loc)),
-            format_source_line_column(error_source_line_column),
-            alt_start_msg(start_loc, do_source_line_column)
-          )
-        end
-
-        def compute_do_source_line_column(node, end_loc)
-          do_loc = node.loc.begin # Actually it's either do or {.
-
-          # We've found that "end" is not aligned with the start node (which
-          # can be a block, a variable assignment, etc). But we also allow
-          # the "end" to be aligned with the start of the line where the "do"
-          # is, which is a style some people use in multi-line chains of
-          # blocks.
-          match = /\S.*/.match(do_loc.source_line)
-          indentation_of_do_line = match.begin(0)
-          return unless end_loc.column != indentation_of_do_line ||
-                        style == :start_of_line
-
-          {
-            source: match[0],
-            line: do_loc.line,
-            column: indentation_of_do_line
-          }
-        end
-
-        def loc_to_source_line_column(loc)
-          {
-            source: loc.source.lines.to_a.first.chomp,
-            line: loc.line,
-            column: loc.column
-          }
-        end
-
-        def alt_start_msg(start_loc, source_line_column)
-          if style != :either
-            ''
-          elsif start_loc.line == source_line_column[:line] &&
-                start_loc.column == source_line_column[:column]
-            ''
-          else
-            ' or ' + format_source_line_column(source_line_column)
-          end
-        end
-
-        def format_source_line_column(source_line_column)
-          "`#{source_line_column[:source]}` at #{source_line_column[:line]}, " \
-          "#{source_line_column[:column]}"
-        end
-
-        def compute_start_col(ancestor_node, node)
-          if style == :start_of_block
-            do_loc = node.loc.begin
-            return do_loc.source_line =~ /\S/
-          end
-          (ancestor_node || node).source_range.column
-        end
-
-        def autocorrect(node)
-          ancestor_node = start_for_block_node(node)
-          start_col = compute_start_col(ancestor_node, node)
-          loc_end = node.loc.end
-          delta = start_col - loc_end.column
-
-          if delta > 0
-            add_space_before(loc_end, delta)
-          elsif delta < 0
-            remove_space_before(loc_end.begin_pos, -delta)
-          end
-        end
-
-        def add_space_before(loc, delta)
-          ->(corrector) { corrector.insert_before(loc, ' ' * delta) }
-        end
-
-        def remove_space_before(end_pos, delta)
-          range = range_between(end_pos - delta, end_pos)
-          ->(corrector) { corrector.remove(range) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for circular argument references in optional keyword
-      # arguments and optional ordinal arguments.
-      #
-      # This cop mirrors a warning produced by MRI since 2.2.
-      #
-      # @example
-      #   # bad
-      #   def bake(pie: pie)
-      #     pie.heat_up
-      #   end
-      #
-      #   # good
-      #   def bake(pie:)
-      #     pie.refrigerate
-      #   end
-      #
-      #   # good
-      #   def bake(pie: self.pie)
-      #     pie.feed_to(user)
-      #   end
-      #
-      #   # bad
-      #   def cook(dry_ingredients = dry_ingredients)
-      #     dry_ingredients.reduce(&:+)
-      #   end
-      #
-      #   # good
-      #   def cook(dry_ingredients = self.dry_ingredients)
-      #     dry_ingredients.combine
-      #   end
-      class CircularArgumentReference < Cop
-        MSG = 'Circular argument reference - `%s`.'.freeze
-
-        def on_kwoptarg(node)
-          check_for_circular_argument_references(*node)
-        end
-
-        def on_optarg(node)
-          check_for_circular_argument_references(*node)
-        end
-
-        private
-
-        def check_for_circular_argument_references(arg_name, arg_value)
-          case arg_value.type
-          when :send
-            # Ruby 2.0 will have type send every time, and "send nil" if it is
-            # calling itself with a specified "self" receiver
-            receiver, name = *arg_value
-            return unless name == arg_name && receiver.nil?
-          when :lvar
-            # Ruby 2.2.2 will have type lvar if it is calling its own method
-            # without a specified "self"
-            return unless arg_value.to_a == [arg_name]
-          else
-            return
-          end
-
-          add_offense(arg_value, :expression, format(MSG, arg_name))
-        end
-      end
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for conditions that are not on the same line as
-      # if/while/until.
-      #
-      # @example
-      #
-      #   if
-      #     some_condition
-      #     do_something
-      #   end
-      class ConditionPosition < Cop
-        include IfNode
-
-        def on_if(node)
-          return if ternary?(node)
-
-          check(node)
-        end
-
-        def on_while(node)
-          check(node)
-        end
-
-        def on_until(node)
-          check(node)
-        end
-
-        private
-
-        def check(node)
-          return if !node.loc.keyword.is?('elsif') && node.loc.end.nil?
-
-          condition, = *node
-          return unless on_different_line?(node.loc.keyword.line,
-                                           condition.source_range.line)
-
-          add_offense(condition, :expression, message(node.loc.keyword.source))
-        end
-
-        def message(keyword)
-          "Place the condition on the same line as `#{keyword}`."
-        end
-
-        def on_different_line?(keyword_line, cond_line)
-          keyword_line != cond_line
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for calls to debugger or pry.
-      class Debugger < Cop
-        MSG = 'Remove debugger entry point `%s`.'.freeze
-
-        def_node_matcher :debugger_call?, <<-END
-          {(send nil {:debugger :byebug} ...)
-           (send (send nil :binding)
-             {:pry :remote_pry :pry_remote} ...)
-           (send (const nil :Pry) :rescue ...)
-           (send nil {:save_and_open_page
-                      :save_and_open_screenshot
-                      :save_screenshot} ...)}
-        END
-
-        def_node_matcher :binding_irb_call?, <<-END
-          (send (send nil :binding) :irb ...)
-        END
-
-        def_node_matcher :pry_rescue?, '(send (const nil :Pry) :rescue ...)'
-
-        def on_send(node)
-          return unless debugger_call?(node) || binding_irb?(node)
-          add_offense(node, :expression, format(MSG, node.source))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            if pry_rescue?(node)
-              block = node.parent
-              body  = block.children[2] # (block <send> <parameters> <body>)
-              corrector.replace(block.source_range, body.source)
-            else
-              range = node.source_range
-              range = range_with_surrounding_space(range, :left, false)
-              range = range_with_surrounding_space(range, :right, true)
-              corrector.remove(range)
-            end
-          end
-        end
-
-        def binding_irb?(node)
-          target_ruby_version >= 2.4 && binding_irb_call?(node)
-        end
-      end
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks whether the end keywords of method definitions are
-      # aligned properly.
-      #
-      # Two modes are supported through the AlignWith configuration
-      # parameter. If it's set to `start_of_line` (which is the default), the
-      # `end` shall be aligned with the start of the line where the `def`
-      # keyword is. If it's set to `def`, the `end` shall be aligned with the
-      # `def` keyword.
-      #
-      # @example
-      #
-      #   private def foo
-      #   end
-      class DefEndAlignment < Cop
-        include OnMethodDef
-        include EndKeywordAlignment
-
-        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'.freeze
-
-        def on_method_def(node, _method_name, _args, _body)
-          check_end_kw_in_node(node)
-        end
-
-        def on_send(node)
-          return unless modifier_and_def_on_same_line?(node)
-          _, _, method_def = *node
-          expr = node.source_range
-
-          line_start = range_between(expr.begin_pos,
-                                     method_def.loc.keyword.end_pos)
-          align_with = {
-            def: method_def.loc.keyword,
-            start_of_line: line_start
-          }
-
-          check_end_kw_alignment(method_def, align_with)
-          ignore_node(method_def) # Don't check the same `end` again.
-        end
-
-        private
-
-        def autocorrect(node)
-          if style == :start_of_line && node.parent && node.parent.send_type?
-            align(node, node.parent)
-          else
-            align(node, node)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for uses of the deprecated class method usages.
-      class DeprecatedClassMethods < Cop
-        # Inner class to DeprecatedClassMethods.
-        # This class exists to add abstraction and clean naming to the
-        # objects that are going to be operated on.
-        class DeprecatedClassMethod
-          include RuboCop::Sexp
-
-          attr_reader :class_constant, :deprecated_method, :replacement_method
-
-          def initialize(class_constant, deprecated_method, replacement_method)
-            @class_constant = class_constant
-            @deprecated_method = deprecated_method
-            @replacement_method = replacement_method
-          end
-
-          def class_nodes
-            @class_nodes ||= [
-              s(:const, nil, class_constant),
-              s(:const, s(:cbase), class_constant)
-            ]
-          end
-        end
-
-        MSG = '`%s` is deprecated in favor of `%s`.'.freeze
-        DEPRECATED_METHODS_OBJECT = [
-          DeprecatedClassMethod.new(:File, :exists?, :exist?),
-          DeprecatedClassMethod.new(:Dir, :exists?, :exist?)
-        ].freeze
-
-        def on_send(node)
-          check(node) do |data|
-            add_offense(node, :selector,
-                        format(MSG,
-                               deprecated_method(data),
-                               replacement_method(data)))
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            check(node) do |data|
-              corrector.replace(node.loc.selector,
-                                data.replacement_method.to_s)
-            end
-          end
-        end
-
-        private
-
-        def check(node)
-          receiver, method_name, *_args = *node
-
-          DEPRECATED_METHODS_OBJECT.each do |data|
-            next unless data.class_nodes.include?(receiver)
-            next unless method_name == data.deprecated_method
-            yield data
-          end
-        end
-
-        def deprecated_method(data)
-          method_call(data.class_constant, data.deprecated_method)
-        end
-
-        def replacement_method(data)
-          method_call(data.class_constant, data.replacement_method)
-        end
-
-        def method_call(class_constant, method)
-          format('%s.%s', class_constant, method)
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks that there are no repeated conditions
-      # used in case 'when' expressions.
-      #
-      # @example
-      #
-      #    # bad
-      #    case x
-      #    when 'first'
-      #      do_something
-      #    when 'first'
-      #      do_something_else
-      #    end
-      #
-      class DuplicateCaseCondition < Cop
-        MSG = 'Duplicate `when` condition detected.'.freeze
-
-        def on_case(case_node)
-          _condition, *whens, _else = *case_node
-          conditions_seen = []
-
-          whens.each do |when_node|
-            conditions = when_conditions(when_node)
-            conditions.each do |cond|
-              if repeated_condition?(conditions_seen, cond)
-                add_offense(case_node, cond.loc.expression, MSG)
-              end
-            end
-            conditions_seen.push(conditions)
-          end
-        end
-
-        private
-
-        def when_conditions(when_node)
-          when_node.to_a[0...-1]
-        end
-
-        def repeated_condition?(conditions_seen, condition)
-          conditions_seen.any? { |x| x.include?(condition) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for duplicated instance (or singleton) method
-      # definitions.
-      #
-      # @example
-      #   @bad
-      #   def duplicated
-      #     1
-      #   end
-      #
-      #   def duplicated
-      #     2
-      #   end
-      class DuplicateMethods < Cop
-        MSG = 'Method `%s` is defined at both %s and %s.'.freeze
-
-        def initialize(config = nil, options = nil)
-          super
-          @definitions = {}
-        end
-
-        def on_def(node)
-          # if a method definition is inside an if, it is very likely
-          # that a different definition is used depending on platform, etc.
-          return if node.ancestors.any?(&:if_type?)
-          return if possible_dsl?(node)
-
-          return unless (scope = node.parent_module_name)
-          found_instance_method(node, scope)
-        end
-
-        def on_defs(node)
-          return if node.ancestors.any?(&:if_type?)
-          return if possible_dsl?(node)
-
-          receiver, name, = *node
-          if receiver.const_type?
-            _, const_name = *receiver
-            check_const_receiver(node, name, const_name)
-          elsif receiver.self_type?
-            check_self_receiver(node, name)
-          end
-        end
-
-        private
-
-        def check_const_receiver(node, name, const_name)
-          qualified = lookup_constant(node, const_name)
-          return unless qualified
-
-          found_method(node, "#{qualified}.#{name}")
-        end
-
-        def check_self_receiver(node, name)
-          enclosing = node.parent_module_name
-          return unless enclosing
-
-          found_method(node, "#{enclosing}.#{name}")
-        end
-
-        def message_for_dup(node, method_name)
-          format(MSG, method_name, @definitions[method_name],
-                 source_location(node))
-        end
-
-        def found_instance_method(node, scope)
-          name, = *node
-          if scope =~ /\A#<Class:(.*)>\Z/
-            found_method(node, "#{Regexp.last_match(1)}.#{name}")
-          else
-            found_method(node, "#{scope}##{name}")
-          end
-        end
-
-        def found_method(node, method_name)
-          if @definitions.key?(method_name)
-            add_offense(node, :keyword, message_for_dup(node, method_name))
-          else
-            @definitions[method_name] = source_location(node)
-          end
-        end
-
-        def lookup_constant(node, const_name)
-          # this method is quite imperfect and can be fooled
-          # to do much better, we would need to do global analysis of the whole
-          # codebase
-          node.each_ancestor(:class, :module, :casgn) do |ancestor|
-            namespace, mod_name = *ancestor.defined_module
-            loop do
-              if mod_name == const_name
-                return qualified_name(ancestor.parent_module_name,
-                                      namespace,
-                                      mod_name)
-              end
-
-              break if namespace.nil?
-              namespace, mod_name = *namespace
-            end
-          end
-        end
-
-        def qualified_name(enclosing, namespace, mod_name)
-          if enclosing != 'Object'
-            if namespace
-              "#{enclosing}::#{namespace.const_name}::#{mod_name}"
-            else
-              "#{enclosing}::#{mod_name}"
-            end
-          elsif namespace
-            "#{namespace.const_name}::#{mod_name}"
-          else
-            mod_name
-          end
-        end
-
-        def possible_dsl?(node)
-          # DSL methods may evaluate a block in the context of a newly created
-          # class or module
-          # Assume that if a method definition is inside any block call which
-          # we can't identify, it could be a DSL
-          node.each_ancestor(:block).any? do |ancestor|
-            ancestor.method_name != :class_eval && !ancestor.class_constructor?
-          end
-        end
-
-        def source_location(node)
-          range = node.location.expression
-          "#{range.source_buffer.name}:#{range.line}"
-        end
-      end
-    end
-  end
-end