dirwatch 0.0.1 → 0.0.2

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

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for redundant access modifiers, including those with no
+      # code, those which are repeated, and leading `public` modifiers in a
+      # class or module body. Conditionally-defined methods are considered as
+      # always being defined, and thus access modifiers guarding such methods
+      # are not redundant.
+      #
+      # @example
+      #
+      #   class Foo
+      #     public # this is redundant (default access is public)
+      #
+      #     def method
+      #     end
+      #
+      #     private # this is not redundant (a method is defined)
+      #     def method2
+      #     end
+      #
+      #     private # this is redundant (no following methods are defined)
+      #   end
+      #
+      # @example
+      #
+      #   class Foo
+      #     # The following is not redundant (conditionally defined methods are
+      #     # considered as always defining a method)
+      #     private
+      #
+      #     if condition?
+      #       def method
+      #       end
+      #     end
+      #
+      #     protected # this is not redundant (method is defined)
+      #
+      #     define_method(:method2) do
+      #     end
+      #
+      #     protected # this is redundant (repeated from previous modifier)
+      #
+      #     [1,2,3].each do |i|
+      #       define_method("foo#{i}") do
+      #       end
+      #     end
+      #
+      #     # The following is redundant (methods defined on the class'
+      #     # singleton class are not affected by the public modifier)
+      #     public
+      #
+      #     def self.method3
+      #     end
+      #   end
+      #
+      # @example
+      #   # Lint/UselessAccessModifier:
+      #   #   ContextCreatingMethods:
+      #   #     - concerning
+      #   require 'active_support/concern'
+      #   class Foo
+      #     concerning :Bar do
+      #       def some_public_method
+      #       end
+      #
+      #       private
+      #
+      #       def some_private_method
+      #       end
+      #     end
+      #
+      #     # this is not redundant because `concerning` created its own context
+      #     private
+      #
+      #     def some_other_private_method
+      #     end
+      #   end
+      class UselessAccessModifier < Cop
+        MSG = 'Useless `%s` access modifier.'.freeze
+
+        def on_class(node)
+          check_node(node.children[2]) # class body
+        end
+
+        def on_module(node)
+          check_node(node.children[1]) # module body
+        end
+
+        def on_block(node)
+          return unless eval_call?(node)
+
+          check_node(node.children[2]) # block body
+        end
+
+        def on_sclass(node)
+          check_node(node.children[1]) # singleton class body
+        end
+
+        private
+
+        def_node_matcher :access_modifier, <<-PATTERN
+          (send nil ${:public :protected :private})
+        PATTERN
+
+        def_node_matcher :static_method_definition?, <<-PATTERN
+          {def (send nil {:attr :attr_reader :attr_writer :attr_accessor} ...)}
+        PATTERN
+
+        def_node_matcher :dynamic_method_definition?, <<-PATTERN
+          {(send nil :define_method ...) (block (send nil :define_method ...) ...)}
+        PATTERN
+
+        def_node_matcher :class_or_instance_eval?, <<-PATTERN
+          (block (send _ {:class_eval :instance_eval}) ...)
+        PATTERN
+
+        def_node_matcher :class_or_module_or_struct_new_call?, <<-PATTERN
+          (block (send (const nil {:Class :Module :Struct}) :new ...) ...)
+        PATTERN
+
+        def check_node(node)
+          return if node.nil?
+
+          if node.begin_type?
+            check_scope(node)
+          elsif (vis = access_modifier(node))
+            add_offense(node, :expression, format(MSG, vis))
+          end
+        end
+
+        def check_scope(node)
+          cur_vis, unused = check_child_nodes(node, nil, :public)
+
+          add_offense(unused, :expression, format(MSG, cur_vis)) if unused
+        end
+
+        def check_child_nodes(node, unused, cur_vis)
+          node.child_nodes.each do |child|
+            if (new_vis = access_modifier(child))
+              cur_vis, unused =
+                check_new_visibility(child, unused, new_vis, cur_vis)
+            elsif method_definition?(child)
+              unused = nil
+            elsif start_of_new_scope?(child)
+              check_scope(child)
+            elsif !child.defs_type?
+              cur_vis, unused = check_child_nodes(child, unused, cur_vis)
+            end
+          end
+
+          [cur_vis, unused]
+        end
+
+        def check_new_visibility(node, unused, new_vis, cur_vis)
+          # does this modifier just repeat the existing visibility?
+          if new_vis == cur_vis
+            add_offense(node, :expression, format(MSG, cur_vis))
+          else
+            # was the previous modifier never applied to any defs?
+            add_offense(unused, :expression, format(MSG, cur_vis)) if unused
+            # once we have already warned about a certain modifier, don't
+            # warn again even if it is never applied to any method defs
+            unused = node
+          end
+
+          [new_vis, unused]
+        end
+
+        def method_definition?(child)
+          static_method_definition?(child) || dynamic_method_definition?(child)
+        end
+
+        def start_of_new_scope?(child)
+          child.module_type? || child.class_type? ||
+            child.sclass_type? || eval_call?(child)
+        end
+
+        def eval_call?(child)
+          class_or_instance_eval?(child) ||
+            class_or_module_or_struct_new_call?(child) ||
+            any_context_creating_methods?(child)
+        end
+
+        def any_context_creating_methods?(child)
+          cop_config.fetch('ContextCreatingMethods', []).any? do |m|
+            matcher_name = "#{m}_block?".to_sym
+            unless respond_to?(matcher_name)
+              self.class.def_node_matcher matcher_name, <<-PATTERN
+                (block (send {nil const} {:#{m}} ...) ...)
+              PATTERN
+            end
+
+            send(matcher_name, child)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for every useless assignment to local variable in every
+      # scope.
+      # The basic idea for this cop was from the warning of `ruby -cw`:
+      #
+      #   assigned but unused variable - foo
+      #
+      # Currently this cop has advanced logic that detects unreferenced
+      # reassignments and properly handles varied cases such as branch, loop,
+      # rescue, ensure, etc.
+      class UselessAssignment < Cop
+        include NameSimilarity
+        MSG = 'Useless assignment to variable - `%s`.'.freeze
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            check_for_unused_assignments(variable)
+          end
+        end
+
+        def check_for_unused_assignments(variable)
+          return if variable.should_be_unused?
+
+          variable.assignments.each do |assignment|
+            next if assignment.used?
+
+            message = message_for_useless_assignment(assignment)
+
+            location = if assignment.regexp_named_capture?
+                         assignment.node.children.first.source_range
+                       else
+                         assignment.node.loc.name
+                       end
+
+            add_offense(nil, location, message)
+          end
+        end
+
+        def message_for_useless_assignment(assignment)
+          variable = assignment.variable
+
+          format(MSG, variable.name) +
+            message_specification(assignment, variable).to_s
+        end
+
+        def message_specification(assignment, variable)
+          if assignment.multiple_assignment?
+            multiple_assignment_message(variable.name)
+          elsif assignment.operator_assignment?
+            operator_assignment_message(variable.scope, assignment)
+          else
+            similar_name_message(variable)
+          end
+        end
+
+        def multiple_assignment_message(variable_name)
+          " Use `_` or `_#{variable_name}` as a variable name to indicate " \
+            "that it won't be used."
+        end
+
+        def operator_assignment_message(scope, assignment)
+          return_value_node = return_value_node_of_scope(scope)
+          return unless assignment.meta_assignment_node
+                                  .equal?(return_value_node)
+
+          " Use just operator `#{assignment.operator.sub(/=$/, '')}`."
+        end
+
+        def similar_name_message(variable)
+          similar_name = find_similar_name(variable.name, variable.scope)
+          " Did you mean `#{similar_name}`?" if similar_name
+        end
+
+        # TODO: More precise handling (rescue, ensure, nested begin, etc.)
+        def return_value_node_of_scope(scope)
+          body_node = scope.body_node
+
+          if body_node.begin_type?
+            body_node.children.last
+          else
+            body_node
+          end
+        end
+
+        def collect_variable_like_names(scope)
+          names = scope.each_node.with_object(Set.new) do |node, set|
+            if variable_like_method_invocation?(node)
+              _receiver, method_name, = *node
+              set << method_name
+            end
+          end
+
+          variable_names = scope.variables.each_value.map(&:name)
+          names.merge(variable_names)
+        end
+
+        def variable_like_method_invocation?(node)
+          return false unless node.send_type?
+          receiver, _method_name, *args = *node
+          receiver.nil? && args.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for comparison of something with itself.
+      #
+      # @example
+      #
+      #  x.top >= x.top
+      class UselessComparison < Cop
+        MSG = 'Comparison of something with itself detected.'.freeze
+        OPS = %w(== === != < > <= >= <=>).freeze
+
+        def_node_matcher :comparison?, "(send $_ {:#{OPS.join(' :')}} $_)"
+
+        def on_send(node)
+          comparison?(node) do |receiver, args|
+            add_offense(node, :selector) if receiver == args
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for useless `else` in `begin..end` without `rescue`.
+      #
+      # @example
+      #   begin
+      #     do_something
+      #   else
+      #     handle_errors # This will never be run.
+      #   end
+      class UselessElseWithoutRescue < Cop
+        include ParserDiagnostic
+
+        MSG = '`else` without `rescue` is useless.'.freeze
+
+        private
+
+        def relevant_diagnostic?(diagnostic)
+          diagnostic.reason == :useless_else
+        end
+
+        def alternative_message(_diagnostic)
+          MSG
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for setter call to local variable as the final
+      # expression of a function definition.
+      #
+      # @example
+      #
+      #  def something
+      #    x = Something.new
+      #    x.attr = 5
+      #  end
+      class UselessSetterCall < Cop
+        include OnMethodDef
+
+        MSG = 'Useless setter call to local variable `%s`.'.freeze
+        ASSIGNMENT_TYPES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn].freeze
+
+        private
+
+        def on_method_def(_node, _method_name, _args, body)
+          return unless body
+
+          last_expr = last_expression(body)
+          return unless setter_call_to_local_variable?(last_expr)
+
+          tracker = MethodVariableTracker.new(body)
+          receiver, = *last_expr
+          variable_name, = *receiver
+          return unless tracker.contain_local_object?(variable_name)
+
+          add_offense(receiver, :name, format(MSG, receiver.loc.name.source))
+        end
+
+        def last_expression(body)
+          expression = body.begin_type? ? body.children : body
+
+          expression.is_a?(Array) ? expression.last : expression
+        end
+
+        def setter_call_to_local_variable?(node)
+          return unless node && node.send_type?
+          receiver, method, _args = *node
+          return unless receiver && receiver.lvar_type?
+          method =~ /(?:\w|\[\])=$/
+        end
+
+        # This class tracks variable assignments in a method body
+        # and if a variable contains object passed as argument at the end of
+        # the method.
+        class MethodVariableTracker
+          def initialize(body_node)
+            @body_node = body_node
+            @local = nil
+          end
+
+          def contain_local_object?(variable_name)
+            return @local[variable_name] if @local
+
+            @local = {}
+
+            scan(@body_node) { |node| process_assignment_node(node) }
+
+            @local[variable_name]
+          end
+
+          def scan(node, &block)
+            catch(:skip_children) do
+              yield node
+
+              node.each_child_node do |child_node|
+                scan(child_node, &block)
+              end
+            end
+          end
+
+          def process_assignment_node(node)
+            case node.type
+            when :masgn
+              process_multiple_assignment(node)
+            when :or_asgn, :and_asgn
+              process_logical_operator_assignment(node)
+            when :op_asgn
+              process_binary_operator_assignment(node)
+            when *ASSIGNMENT_TYPES
+              _, rhs_node = *node
+              process_assignment(node, rhs_node) if rhs_node
+            end
+          end
+
+          def process_multiple_assignment(masgn_node)
+            mlhs_node, mrhs_node = *masgn_node
+
+            mlhs_node.children.each_with_index do |lhs_node, index|
+              next unless ASSIGNMENT_TYPES.include?(lhs_node.type)
+
+              lhs_variable_name, = *lhs_node
+              rhs_node = mrhs_node.children[index]
+
+              if mrhs_node.array_type? && rhs_node
+                process_assignment(lhs_variable_name, rhs_node)
+              else
+                @local[lhs_variable_name] = true
+              end
+            end
+
+            throw :skip_children
+          end
+
+          def process_logical_operator_assignment(asgn_node)
+            lhs_node, rhs_node = *asgn_node
+            return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
+            process_assignment(lhs_node, rhs_node)
+
+            throw :skip_children
+          end
+
+          def process_binary_operator_assignment(op_asgn_node)
+            lhs_node, = *op_asgn_node
+            return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
+            lhs_variable_name, = *lhs_node
+            @local[lhs_variable_name] = true
+
+            throw :skip_children
+          end
+
+          def process_assignment(asgn_node, rhs_node)
+            lhs_variable_name, = *asgn_node
+
+            @local[lhs_variable_name] = if rhs_node.variable?
+                                          rhs_variable_name, = *rhs_node
+                                          @local[rhs_variable_name]
+                                        else
+                                          constructor?(rhs_node)
+                                        end
+          end
+
+          def constructor?(node)
+            return true if node.literal?
+            return false unless node.send_type?
+            _receiver, method = *node
+            method == :new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for operators, variables and literals used
+      # in void context.
+      class Void < Cop
+        OP_MSG = 'Operator `%s` used in void context.'.freeze
+        VAR_MSG = 'Variable `%s` used in void context.'.freeze
+        LIT_MSG = 'Literal `%s` used in void context.'.freeze
+
+        OPS = %w(* / % + - == === != < > <= >= <=>).freeze
+
+        def on_begin(node)
+          check_begin(node)
+        end
+
+        def on_kwbegin(node)
+          check_begin(node)
+        end
+
+        private
+
+        def check_begin(node)
+          expressions = *node
+
+          expressions.drop_last(1).each do |expr|
+            check_for_void_op(expr)
+            check_for_literal(expr)
+            check_for_var(expr)
+          end
+        end
+
+        def check_for_void_op(node)
+          return unless node.send_type? && node.loc.selector
+
+          op = node.loc.selector.source
+
+          add_offense(node, :selector, format(OP_MSG, op)) if OPS.include?(op)
+        end
+
+        def check_for_var(node)
+          return unless node.variable? || node.const_type?
+          add_offense(node, :name, format(VAR_MSG, node.loc.name.source))
+        end
+
+        def check_for_literal(node)
+          return if !node.literal? || node.xstr_type?
+
+          add_offense(node, :expression, format(LIT_MSG, node.source))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks that the ABC size of methods is not higher than the
+      # configured maximum. The ABC size is based on assignments, branches
+      # (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
+      class AbcSize < Cop
+        include MethodComplexity
+
+        MSG = 'Assignment Branch Condition size for %s is too high. ' \
+              '[%.4g/%.4g]'.freeze
+        BRANCH_NODES = [:send, :csend].freeze
+        CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
+
+        private
+
+        def complexity(node)
+          assignment = 0
+          branch = 0
+          condition = 0
+
+          node.each_node do |child|
+            if child.assignment?
+              assignment += 1
+            elsif BRANCH_NODES.include?(child.type)
+              branch += 1
+            elsif CONDITION_NODES.include?(child.type)
+              condition += 1
+            end
+          end
+
+          Math.sqrt(assignment**2 + branch**2 + condition**2).round(2)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks if the length of a block exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      class BlockLength < Cop
+        include TooManyLines
+
+        LABEL = 'Block'.freeze
+
+        def on_block(node)
+          check_code_length(node)
+        end
+
+        private
+
+        def cop_label
+          LABEL
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks for excessive nesting of conditional and looping
+      # constructs. Despite the cop's name, blocks are not considered as an
+      # extra level of nesting.
+      #
+      # The maximum level of nesting allowed is configurable.
+      class BlockNesting < Cop
+        include ConfigurableMax
+        include IfNode
+
+        NESTING_BLOCKS = [
+          :case, :if, :while, :while_post,
+          :until, :until_post, :for, :resbody
+        ].freeze
+
+        def investigate(processed_source)
+          return unless processed_source.ast
+          max = cop_config['Max']
+          check_nesting_level(processed_source.ast, max, 0)
+        end
+
+        private
+
+        def check_nesting_level(node, max, current_level)
+          if NESTING_BLOCKS.include?(node.type)
+            current_level += 1 unless elsif?(node)
+            if current_level > max
+              self.max = current_level
+              unless part_of_ignored_node?(node)
+                add_offense(node, :expression, message(max)) do
+                  ignore_node(node)
+                end
+              end
+            end
+          end
+
+          node.each_child_node do |child_node|
+            check_nesting_level(child_node, max, current_level)
+          end
+        end
+
+        def message(max)
+          "Avoid more than #{max} levels of block nesting."
+        end
+      end
+    end
+  end
+end