dirwatch 0.0.1 → 0.0.2

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks how the *when*s of a *case* expression
+      # are indented in relation to its *case* or *end* keyword.
+      #
+      # It will register a separate offense for each misaligned *when*.
+      class CaseIndentation < Cop
+        include AutocorrectAlignment
+        include ConfigurableEnforcedStyle
+
+        def on_case(case_node)
+          _condition, *whens, _else = *case_node
+
+          base = style
+          indent = cop_config['IndentOneStep']
+          base_column = base_column(case_node, base)
+
+          whens.each do |when_node|
+            check_when(when_node, case_node, base, indent, base_column)
+          end
+        end
+
+        private
+
+        def check_when(when_node, case_node, base, indent, base_column)
+          pos = when_node.loc.keyword
+          expected_column = base_column +
+                            (indent ? configured_indentation_width : 0)
+          if pos.column == expected_column
+            correct_style_detected
+          else
+            incorrect_style(when_node, case_node, base, pos, indent)
+          end
+        end
+
+        def incorrect_style(when_node, case_node, base, pos, indent)
+          msg = 'Indent `when` ' + if indent
+                                     "one step more than `#{base}`."
+                                   else
+                                     "as deep as `#{base}`."
+                                   end
+          add_offense(when_node, pos, msg) do
+            if pos.column == base_column(case_node, alternative_style)
+              opposite_style_detected
+            else
+              unrecognized_style_detected
+            end
+          end
+        end
+
+        def parameter_name
+          'IndentWhenRelativeTo'
+        end
+
+        def base_column(case_node, base)
+          case base
+          when :case then case_node.location.keyword.column
+          when :end  then case_node.location.end.column
+          end
+        end
+
+        def autocorrect(node)
+          whitespace = whitespace_range(node)
+          return false unless whitespace.source.strip.empty?
+
+          ->(corrector) { corrector.replace(whitespace, replacement(node)) }
+        end
+
+        def whitespace_range(node)
+          when_column = node.location.keyword.column
+          begin_pos = node.loc.keyword.begin_pos
+
+          range_between(begin_pos - when_column, begin_pos)
+        end
+
+        def replacement(node)
+          case_node = node.each_ancestor(:case).first
+          base_type = cop_config[parameter_name] == 'end' ? :end : :case
+          column = base_column(case_node, base_type)
+          column += configured_indentation_width if cop_config['IndentOneStep']
+          ' ' * column
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of the character literal ?x.
+      class CharacterLiteral < Cop
+        include StringHelp
+
+        MSG = 'Do not use the character literal - ' \
+              'use string literal instead.'.freeze
+
+        def offense?(node)
+          # we don't register an offense for things like ?\C-\M-d
+          node.loc.begin.is?('?') &&
+            node.source.size.between?(2, 3)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            string = node.source[1..-1]
+
+            # special character like \n
+            # or ' which needs to use "" or be escaped.
+            if string.length == 2 || string == "'"
+              corrector.replace(node.source_range, %("#{string}"))
+            elsif string.length == 1 # normal character
+              corrector.replace(node.source_range, "'#{string}'")
+            end
+          end
+        end
+
+        # Dummy implementation of method in ConfigurableEnforcedStyle that is
+        # called from StringHelp.
+        def opposite_style_detected; end
+
+        # Dummy implementation of method in ConfigurableEnforcedStyle that is
+        # called from StringHelp.
+        def correct_style_detected; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks for class and module names with
+      # an underscore in them.
+      class ClassAndModuleCamelCase < Cop
+        MSG = 'Use CamelCase for classes and modules.'.freeze
+
+        def on_class(node)
+          check_name(node)
+        end
+
+        def on_module(node)
+          check_name(node)
+        end
+
+        private
+
+        def check_name(node)
+          name = node.loc.name.source
+
+          add_offense(node, :name) if name =~ /_/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks the style of children definitions at classes and
+      # modules. Basically there are two different styles:
+      #
+      # nested - have each child on its own line
+      #   class Foo
+      #     class Bar
+      #     end
+      #   end
+      #
+      # compact - combine definitions as much as possible
+      #   class Foo::Bar
+      #   end
+      #
+      # The compact style is only forced for classes/modules with one child.
+      class ClassAndModuleChildren < Cop
+        include ConfigurableEnforcedStyle
+
+        NESTED_MSG = 'Use nested module/class definitions instead of ' \
+                     'compact style.'.freeze
+        COMPACT_MSG = 'Use compact module/class definition instead of ' \
+                      'nested style.'.freeze
+
+        def on_class(node)
+          _name, superclass, body = *node
+          return if superclass && style != :nested
+          check_style(node, body)
+        end
+
+        def on_module(node)
+          _name, body = *node
+          check_style(node, body)
+        end
+
+        private
+
+        def check_style(node, body)
+          if style == :nested
+            check_nested_style(node)
+          else
+            check_compact_style(node, body)
+          end
+        end
+
+        def check_nested_style(node)
+          return unless compact_node_name?(node)
+          add_offense(node, :name, NESTED_MSG)
+        end
+
+        def check_compact_style(node, body)
+          return unless one_child?(body) && !compact_node_name?(node)
+          add_offense(node, :name, COMPACT_MSG)
+        end
+
+        def one_child?(body)
+          body && [:module, :class].include?(body.type)
+        end
+
+        def compact_node_name?(node)
+          node.loc.name.source =~ /::/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces consistent use of `Object#is_a?` or `Object#kind_of?`.
+      class ClassCheck < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Prefer `Object#%s` over `Object#%s`.'.freeze
+
+        def_node_matcher :class_check?, '(send _ ${:is_a? :kind_of?} _)'
+
+        def on_send(node)
+          class_check?(node) do |method_name|
+            return if style == method_name
+            add_offense(node, :selector)
+          end
+        end
+
+        def message(node)
+          _receiver, method_name, *_args = *node
+
+          if method_name == :is_a?
+            format(MSG, 'kind_of?', 'is_a?')
+          else
+            format(MSG, 'is_a?', 'kind_of?')
+          end
+        end
+
+        def autocorrect(node)
+          _receiver, method_name, *_args = *node
+
+          lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              method_name == :is_a? ? 'kind_of?' : 'is_a?')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of the class/module name instead of
+      # self, when defining class/module methods.
+      #
+      # @example
+      #   # bad
+      #   class SomeClass
+      #     def SomeClass.class_method
+      #       ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SomeClass
+      #     def self.class_method
+      #       ...
+      #     end
+      #   end
+      class ClassMethods < Cop
+        MSG = 'Use `self.%s` instead of `%s.%s`.'.freeze
+
+        def on_class(node)
+          name, _superclass, body = *node
+          check(name, body)
+        end
+
+        def on_module(node)
+          name, body = *node
+          check(name, body)
+        end
+
+        private
+
+        def check(name, node)
+          return unless node
+
+          if node.defs_type?
+            check_defs(name, node)
+          elsif node.begin_type?
+            node.each_child_node(:defs) { |n| check_defs(name, n) }
+          end
+        end
+
+        def check_defs(name, node)
+          definee, method_name, _args, _body = *node
+          # check if the class/module name matches the definee for the defs node
+          return unless name == definee
+
+          _, class_name = *definee
+          add_offense(definee, :name, message(class_name, method_name))
+        end
+
+        def message(class_name, method_name)
+          format(MSG, method_name, class_name, method_name)
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.name, 'self') }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of class variables. Offenses
+      # are signaled only on assignment to class variables to
+      # reduced the number of offenses that would be reported.
+      class ClassVars < Cop
+        MSG = 'Replace class var %s with a class instance var.'.freeze
+
+        def on_cvasgn(node)
+          add_offense(node, :name)
+        end
+
+        def message(node)
+          class_var, = *node
+          format(MSG, class_var)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks the indentation of hanging closing parentheses in
+      # method calls, method definitions, and grouped expressions. A hanging
+      # closing parenthesis means `)` preceded by a line break.
+      #
+      # @example
+      #
+      #   # good: when x is on its own line, indent this way
+      #   func(
+      #     x,
+      #     y
+      #   )
+      #
+      #   # good: when x follows opening parenthesis, align parentheses
+      #   a = b * (x +
+      #            y
+      #           )
+      #
+      #   # bad
+      #   def func(
+      #     x,
+      #     y
+      #     )
+      class ClosingParenthesisIndentation < Cop
+        include AutocorrectAlignment
+        include OnMethodDef
+
+        MSG_INDENT =
+          'Indent `)` the same as the start of the line where `(` is.'.freeze
+        MSG_ALIGN = 'Align `)` with `(`.'.freeze
+
+        def on_send(node)
+          _receiver, _method_name, *args = *node
+          check(node, args)
+        end
+
+        def on_begin(node)
+          check(node, node.children)
+        end
+
+        private
+
+        def on_method_def(_node, _method_name, args, _body)
+          check(args, args.children)
+        end
+
+        def check(node, elements)
+          right_paren = node.loc.end
+          return unless right_paren
+          return unless begins_its_line?(right_paren)
+
+          correct_column = expected_column(node, elements)
+          @column_delta = correct_column - right_paren.column
+          return if @column_delta.zero?
+
+          left_paren = node.loc.begin
+          msg = correct_column == left_paren.column ? MSG_ALIGN : MSG_INDENT
+          add_offense(right_paren, right_paren, msg)
+        end
+
+        def expected_column(node, elements)
+          left_paren = node.loc.begin
+
+          if node.send_type? && fixed_parameter_indentation? ||
+             line_break_after_left_paren?(left_paren, elements)
+            left_paren.source_line =~ /\S/
+          else
+            left_paren.column
+          end
+        end
+
+        def fixed_parameter_indentation?
+          config.for_cop('Style/AlignParameters')['EnforcedStyle'] ==
+            'with_fixed_indentation'
+        end
+
+        def line_break_after_left_paren?(left_paren, elements)
+          elements.first && elements.first.loc.line > left_paren.line
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of consistent method names
+      # from the Enumerable module.
+      #
+      # Unfortunately we cannot actually know if a method is from
+      # Enumerable or not (static analysis limitation), so this cop
+      # can yield some false positives.
+      class CollectionMethods < Cop
+        include MethodPreference
+
+        MSG = 'Prefer `%s` over `%s`.'.freeze
+
+        def on_block(node)
+          method, _args, _body = *node
+
+          check_method_node(method)
+        end
+
+        def on_send(node)
+          _receiver, _method_name, *args = *node
+          return unless args.one? && args.first.block_pass_type?
+
+          check_method_node(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              preferred_method(node.loc.selector.source))
+          end
+        end
+
+        private
+
+        def check_method_node(node)
+          _receiver, method_name, *_args = *node
+
+          return unless preferred_methods[method_name]
+          add_offense(node, :selector,
+                      format(MSG,
+                             preferred_method(method_name),
+                             method_name))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for methods invoked via the :: operator instead
+      # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
+      class ColonMethodCall < Cop
+        MSG = 'Do not use `::` for method calls.'.freeze
+
+        def_node_matcher :java_type_node?, <<-PATTERN
+          (send
+            (const nil :Java)
+            {:boolean :byte :char :double :float :int :long :short})
+        PATTERN
+
+        def on_send(node)
+          # ignore Java interop code like Java::int
+          return if java_type_node?(node)
+
+          receiver, method_name, *_args = *node
+
+          # discard methods with nil receivers and op methods(like [])
+          return unless receiver && node.loc.dot && node.loc.dot.is?('::')
+          return if allowed_name(method_name.to_s)
+
+          add_offense(node, :dot)
+        end
+
+        def allowed_name(method_name)
+          method_name.match(/^[A-Z]/)
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.dot, '.') }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces using `` or %x around command literals.
+      #
+      # @example
+      #   # Good if EnforcedStyle is backticks or mixed, bad if percent_x.
+      #   folders = `find . -type d`.split
+      #
+      #   # Good if EnforcedStyle is percent_x, bad if backticks or mixed.
+      #   folders = %x(find . -type d).split
+      #
+      #   # Good if EnforcedStyle is backticks, bad if percent_x or mixed.
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      #   # Good if EnforcedStyle is percent_x or mixed, bad if backticks.
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      #   # Bad unless AllowInnerBackticks is true.
+      #   `echo \`ls\``
+      class CommandLiteral < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_USE_BACKTICKS = 'Use backticks around command string.'.freeze
+        MSG_USE_PERCENT_X = 'Use `%x` around command string.'.freeze
+
+        def on_xstr(node)
+          return if heredoc_literal?(node)
+
+          if backtick_literal?(node)
+            check_backtick_literal(node)
+          else
+            check_percent_x_literal(node)
+          end
+        end
+
+        private
+
+        def check_backtick_literal(node)
+          return if allowed_backtick_literal?(node)
+
+          add_offense(node, :expression, MSG_USE_PERCENT_X)
+        end
+
+        def check_percent_x_literal(node)
+          return if allowed_percent_x_literal?(node)
+
+          add_offense(node, :expression, MSG_USE_BACKTICKS)
+        end
+
+        def allowed_backtick_literal?(node)
+          style == :backticks && !contains_disallowed_backtick?(node) ||
+            style == :mixed && node.single_line? &&
+              !contains_disallowed_backtick?(node)
+        end
+
+        def allowed_percent_x_literal?(node)
+          style == :backticks && contains_disallowed_backtick?(node) ||
+            style == :percent_x ||
+            style == :mixed && node.multiline? ||
+            style == :mixed && contains_disallowed_backtick?(node)
+        end
+
+        def contains_disallowed_backtick?(node)
+          !allow_inner_backticks? && contains_backtick?(node)
+        end
+
+        def allow_inner_backticks?
+          cop_config['AllowInnerBackticks']
+        end
+
+        def contains_backtick?(node)
+          node_body(node) =~ /`/
+        end
+
+        def node_body(node)
+          loc = node.loc
+          loc.expression.source[loc.begin.length...-loc.end.length]
+        end
+
+        def heredoc_literal?(node)
+          node.loc.respond_to?(:heredoc_body)
+        end
+
+        def backtick_literal?(node)
+          node.loc.begin.source == '`'
+        end
+
+        def preferred_delimiters
+          config.for_cop('Style/PercentLiteralDelimiters') \
+            ['PreferredDelimiters']['%x'].split(//)
+        end
+
+        def autocorrect(node)
+          return if contains_backtick?(node)
+
+          replacement = if backtick_literal?(node)
+                          ['%x', ''].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