dirwatch 0.0.1 → 0.0.2

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for duplicated keys in hash literals.
+      #
+      # This cop mirrors a warning in Ruby 2.2.
+      #
+      # @example
+      #   hash = { food: 'apple', food: 'orange' }
+      class DuplicatedKey < Cop
+        MSG = 'Duplicated key in hash literal.'.freeze
+
+        def on_hash(node)
+          keys = []
+
+          hash_pairs = *node
+          hash_pairs.each do |pair|
+            key, _value = *pair
+            if keys.include?(key) && key.recursive_basic_literal?
+              add_offense(key, :expression)
+            end
+            keys << key
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks if each_with_object is called with an immutable
+      # argument. Since the argument is the object that the given block shall
+      # make calls on to build something based on the enumerable that
+      # each_with_object iterates over, an immutable argument makes no sense.
+      # It's definitely a bug.
+      #
+      # @example
+      #
+      #   sum = numbers.each_with_object(0) { |e, a| a += e }
+      class EachWithObjectArgument < Cop
+        MSG = 'The argument to each_with_object can not be immutable.'.freeze
+
+        def_node_matcher :each_with_object?, '(send _ :each_with_object $_)'
+
+        def on_send(node)
+          each_with_object?(node) do |arg|
+            add_offense(node, :expression) if arg.immutable_literal?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for odd else block layout - like
+      # having an expression on the same line as the else keyword,
+      # which is usually a mistake.
+      #
+      # @example
+      #
+      #   if something
+      #     ...
+      #   else do_this
+      #     do_that
+      #   end
+      class ElseLayout < Cop
+        include IfNode
+
+        def on_if(node)
+          return if ternary?(node)
+          # ignore modifier ops & elsif nodes
+          return unless node.loc.end
+
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return unless node
+          return check_else(node) if else?(node)
+
+          check_if(node) if if?(node)
+        end
+
+        def check_else(node)
+          _cond, _if_branch, else_branch = *node
+          return unless else_branch && else_branch.begin_type?
+
+          first_else_expr = else_branch.children.first
+          return unless first_else_expr.source_range.line == node.loc.else.line
+
+          add_offense(first_else_expr, :expression, message)
+        end
+
+        def check_if(node)
+          _cond, _if_branch, else_branch = *node
+          check(else_branch)
+        end
+
+        def if?(node)
+          node.loc.respond_to?(:keyword) &&
+            %w(if elsif).include?(node.loc.keyword.source)
+        end
+
+        def else?(node)
+          node.loc.respond_to?(:else) && node.loc.else &&
+            node.loc.else.is?('else')
+        end
+
+        def message
+          'Odd `else` layout detected. Did you mean to use `elsif`?'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for empty `ensure` blocks
+      class EmptyEnsure < Cop
+        MSG = 'Empty `ensure` block detected.'.freeze
+
+        def on_ensure(node)
+          _body, ensure_body = *node
+
+          add_offense(node, :keyword) unless ensure_body
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the presence of empty expressions.
+      #
+      # @example
+      #
+      #   @bad
+      #   foo = ()
+      #   if ()
+      #     bar
+      #   end
+      class EmptyExpression < Cop
+        MSG = 'Avoid empty expressions.'.freeze
+
+        def on_begin(node)
+          return unless empty_expression?(node)
+
+          add_offense(node, node.source_range, MSG)
+        end
+
+        private
+
+        def empty_expression?(begin_node)
+          begin_node.children.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for empty interpolation.
+      #
+      # @example
+      #
+      #   "result is #{}"
+      class EmptyInterpolation < Cop
+        MSG = 'Empty interpolation detected.'.freeze
+
+        def on_dstr(node)
+          node.each_child_node(:begin) do |begin_node|
+            add_offense(begin_node, :expression) if begin_node.children.empty?
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |collector|
+            collector.remove(node.loc.expression)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the presence of `when` branches without a body.
+      #
+      # @example
+      #
+      #   @bad
+      #   case foo
+      #   when bar then 1
+      #   when baz then # nothing
+      #   end
+      class EmptyWhen < Cop
+        MSG = 'Avoid `when` branches without a body.'.freeze
+
+        def on_case(node)
+          _cond_node, *when_nodes, _else_node = *node
+
+          when_nodes.each do |when_node|
+            check_when(when_node)
+          end
+        end
+
+        private
+
+        def check_when(when_node)
+          return unless empty_when_body?(when_node)
+
+          add_offense(when_node, when_node.source_range, MSG)
+        end
+
+        def empty_when_body?(when_node)
+          !when_node.to_a.last
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks whether the end keywords are aligned properly.
+      #
+      # Three modes are supported through the `AlignWith` configuration
+      # parameter:
+      #
+      # If it's set to `keyword` (which is the default), the `end`
+      # shall be aligned with the start of the keyword (if, class, etc.).
+      #
+      # If it's set to `variable` the `end` shall be aligned with the
+      # left-hand-side of the variable assignment, if there is one.
+      #
+      # If it's set to `start_of_line`, the `end` shall be aligned with the
+      # start of the line where the matching keyword appears.
+      #
+      # @example
+      #   @good
+      #   # keyword style
+      #   variable = if true
+      #              end
+      #
+      #   # variable style
+      #   variable = if true
+      #   end
+      #
+      #   # start_of_line style
+      #   puts(if true
+      #   end)
+      class EndAlignment < Cop
+        include CheckAssignment
+        include EndKeywordAlignment
+        include IfNode
+
+        def on_class(node)
+          check_other_alignment(node)
+        end
+
+        def on_module(node)
+          check_other_alignment(node)
+        end
+
+        def on_if(node)
+          check_other_alignment(node) unless ternary?(node)
+        end
+
+        def on_while(node)
+          check_other_alignment(node)
+        end
+
+        def on_until(node)
+          check_other_alignment(node)
+        end
+
+        def on_case(node)
+          return check_asgn_alignment(node.parent, node) if argument_case?(node)
+          check_other_alignment(node)
+        end
+
+        private
+
+        def check_assignment(node, rhs)
+          # If there are method calls chained to the right hand side of the
+          # assignment, we let rhs be the receiver of those method calls before
+          # we check if it's an if/unless/while/until.
+          return unless (rhs = first_part_of_call_chain(rhs))
+          return unless [:if, :while, :until, :case].include?(rhs.type)
+          return if ternary?(rhs)
+
+          check_asgn_alignment(node, rhs)
+        end
+
+        def check_asgn_alignment(outer_node, inner_node)
+          expr = outer_node.source_range
+
+          align_with = {
+            keyword: inner_node.loc.keyword,
+            start_of_line: start_line_range(outer_node)
+          }
+
+          align_with[:variable] =
+            if !line_break_before_keyword?(expr, inner_node)
+              range_between(expr.begin_pos, inner_node.loc.keyword.end_pos)
+            else
+              inner_node.loc.keyword
+            end
+
+          check_end_kw_alignment(inner_node, align_with)
+          ignore_node(inner_node) # Don't check again.
+        end
+
+        def check_other_alignment(node)
+          align_with = {
+            keyword: node.loc.keyword,
+            variable: node.loc.keyword,
+            start_of_line: start_line_range(node)
+          }
+          check_end_kw_alignment(node, align_with)
+        end
+
+        def autocorrect(node)
+          align(node, alignment_node(node))
+        end
+
+        def alignment_node(node)
+          if style == :keyword
+            node
+          elsif style == :variable
+            return node.parent if argument_case?(node)
+            # Fall back to 'keyword' style if this node is not on the RHS
+            # of an assignment
+            node.ancestors.find(&:assignment?) || node
+          else
+            start_line_range(node)
+          end
+        end
+
+        def argument_case?(node)
+          node.case_type? && node.parent && node.parent.send_type?
+        end
+
+        def start_line_range(node)
+          expr   = node.source_range
+          buffer = expr.source_buffer
+          source = buffer.source_line(expr.line)
+          range  = buffer.line_range(expr.line)
+
+          range_between(range.begin_pos + (source =~ /\S/),
+                        range.begin_pos + (source =~ /\s*\z/))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for END blocks in method definitions.
+      class EndInMethod < Cop
+        MSG = '`END` found in method definition. Use `at_exit` instead.'.freeze
+
+        def on_postexe(node)
+          inside_of_method = node.each_ancestor(:def, :defs).count.nonzero?
+          add_offense(node, :keyword) if inside_of_method
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for *return* from an *ensure* block.
+      class EnsureReturn < Cop
+        MSG = 'Do not return from an `ensure` block.'.freeze
+
+        def on_ensure(node)
+          _body, ensure_body = *node
+
+          return unless ensure_body
+
+          ensure_body.each_node(:return) do |return_node|
+            add_offense(return_node, :expression)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the use of *Kernel#eval*.
+      class Eval < Cop
+        MSG = 'The use of `eval` is a serious security risk.'.freeze
+
+        def_node_matcher :eval?, '(send nil :eval $!str ...)'
+
+        def on_send(node)
+          eval?(node) { add_offense(node, :selector) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop identifies Float literals which are, like, really really really
+      # really really really really really big. Too big. No-one needs Floats
+      # that big. If you need a float that big, something is wrong with you.
+      #
+      # @example
+      #   # bad
+      #   float = 3.0e400
+      #
+      #   # good
+      #   float = 42.9
+      class FloatOutOfRange < Cop
+        MSG = 'Float out of range.'.freeze
+
+        def on_float(node)
+          value, = *node
+          if value.infinite?
+            add_offense(node, :expression, MSG)
+          elsif value.zero? && node.source =~ /[1-9]/
+            add_offense(node, :expression, MSG)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This lint sees if there is a mismatch between the number of
+      # expected fields for format/sprintf/#% and what is actually
+      # passed as arguments.
+      #
+      # @example
+      #
+      #   format('A value: %s and another: %i', a_value)
+      #
+      class FormatParameterMismatch < Cop
+        # http://rubular.com/r/CvpbxkcTzy
+        MSG = "Number of arguments (%i) to `%s` doesn't match the number of " \
+              'fields (%i).'.freeze
+        FIELD_REGEX =
+          /(%(([\s#+-0\*]*)(\d*)?(.\d+)?[bBdiouxXeEfgGaAcps]|%))/
+        NAMED_FIELD_REGEX = /%\{[_a-zA-Z][_a-zA-Z]+\}/
+        KERNEL = 'Kernel'.freeze
+        SHOVEL = '<<'.freeze
+        PERCENT = '%'.freeze
+        PERCENT_PERCENT = '%%'.freeze
+        STRING_TYPES = [:str, :dstr].freeze
+        NAMED_INTERPOLATION = /%(?:<\w+>|\{\w+\})/
+
+        def on_send(node)
+          add_offense(node, :selector) if offending_node?(node)
+        end
+
+        private
+
+        def offending_node?(node)
+          return false unless called_on_string?(node)
+          return false unless method_with_format_args?(node)
+          return false if named_mode?(node) || node_with_splat_args?(node)
+
+          num_of_format_args, num_of_expected_fields = count_matches(node)
+
+          num_of_format_args != :unknown &&
+            num_of_expected_fields != num_of_format_args
+        end
+
+        def called_on_string?(node)
+          receiver_node, _method, format_string, = *node
+          if receiver_node.nil? || receiver_node.const_type?
+            format_string && format_string.str_type?
+          else
+            receiver_node.str_type?
+          end
+        end
+
+        def method_with_format_args?(node)
+          sprintf?(node) || format?(node) || percent?(node)
+        end
+
+        def named_mode?(node)
+          receiver_node, _method_name, *args = *node
+
+          relevant_node = if sprintf?(node) || format?(node)
+                            args.first
+                          elsif percent?(node)
+                            receiver_node
+                          end
+
+          !relevant_node.source.scan(NAMED_FIELD_REGEX).empty?
+        end
+
+        def node_with_splat_args?(node)
+          return false if percent?(node)
+
+          _receiver_node, _method_name, *args = *node
+
+          args.butfirst.any?(&:splat_type?)
+        end
+
+        def heredoc?(node)
+          _receiver, _name, args = *node
+
+          args.source[0, 2] == SHOVEL
+        end
+
+        def count_matches(node)
+          receiver_node, _method_name, *args = *node
+
+          if (sprintf?(node) || format?(node)) && !heredoc?(node)
+            number_of_args_for_format = (args.size - 1)
+            number_of_expected_fields = expected_fields_count(args.first)
+          elsif percent?(node) && args.first.array_type?
+            number_of_expected_fields = expected_fields_count(receiver_node)
+            number_of_args_for_format = args.first.child_nodes.size
+          else
+            number_of_args_for_format = number_of_expected_fields = :unknown
+          end
+
+          [number_of_args_for_format, number_of_expected_fields]
+        end
+
+        def format_method?(name, node)
+          receiver, method_name, *args = *node
+
+          if receiver && receiver.const_type?
+            return false unless receiver.loc.name.is?(KERNEL)
+          end
+
+          return false unless method_name == name
+
+          args.size > 1 && args.first.str_type?
+        end
+
+        def expected_fields_count(node)
+          return :unknown unless node.str_type?
+          return 1 if node.source =~ NAMED_INTERPOLATION
+
+          node
+            .source
+            .scan(FIELD_REGEX)
+            .select { |x| x.first != PERCENT_PERCENT }
+            .reduce(0) { |acc, elem| acc + (elem[2] =~ /\*/ ? 2 : 1) }
+        end
+
+        def format?(node)
+          format_method?(:format, node)
+        end
+
+        def sprintf?(node)
+          format_method?(:sprintf, node)
+        end
+
+        def percent?(node)
+          receiver_node, method_name, *arg_nodes = *node
+
+          percent = method_name == :% &&
+                    (STRING_TYPES.include?(receiver_node.type) ||
+                     arg_nodes[0].array_type?)
+
+          if percent && STRING_TYPES.include?(receiver_node.type)
+            return false if heredoc?(node)
+          end
+
+          percent
+        end
+
+        def message(node)
+          _receiver, method_name, *_args = *node
+          num_args_for_format, num_expected_fields = count_matches(node)
+
+          method_name = 'String#%' if PERCENT == method_name.to_s
+          format(MSG, num_args_for_format, method_name, num_expected_fields)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for *rescue* blocks with no body.
+      class HandleExceptions < Cop
+        MSG = 'Do not suppress exceptions.'.freeze
+
+        def on_resbody(node)
+          _exc_list_node, _exc_var_node, body_node = *node
+
+          add_offense(node, :expression) unless body_node
+        end
+      end
+    end
+  end
+end