talon_one 1.4.0 → 2.0.0

data/vendor/bundle/ruby/2.7.0/gems/rubocop-0.66.0/lib/rubocop/cop/lint/safe_navigation_with_empty.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks to make sure safe navigation isn't used with `empty?` in
+      # a conditional.
+      #
+      # While the safe navigation operator is generally a good idea, when
+      # checking `foo&.empty?` in a conditional, `foo` being `nil` will actually
+      # do the opposite of what the author intends.
+      #
+      # @example
+      #   # bad
+      #   return if foo&.empty?
+      #   return unless foo&.empty?
+      #
+      #   # good
+      #   return if foo && foo.empty?
+      #   return unless foo && foo.empty?
+      #
+      class SafeNavigationWithEmpty < Cop
+        MSG = 'Avoid calling `empty?` with the safe navigation operator ' \
+          'in conditionals.'.freeze
+
+        def_node_matcher :safe_navigation_empty_in_conditional?, <<-PATTERN
+          (if (csend (send ...) :empty?) ...)
+        PATTERN
+
+        def on_if(node)
+          return unless safe_navigation_empty_in_conditional?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rubocop-0.66.0/lib/rubocop/cop/lint/script_permission.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks if a file which has a shebang line as
+      # its first line is granted execute permission.
+      #
+      # @example
+      #   # bad
+      #
+      #   # A file which has a shebang line as its first line is not
+      #   # granted execute permission.
+      #
+      #   #!/usr/bin/env ruby
+      #   puts 'hello, world'
+      #
+      #   # good
+      #
+      #   # A file which has a shebang line as its first line is
+      #   # granted execute permission.
+      #
+      #   #!/usr/bin/env ruby
+      #   puts 'hello, world'
+      #
+      #   # good
+      #
+      #   # A file which has not a shebang line as its first line is not
+      #   # granted execute permission.
+      #
+      #   puts 'hello, world'
+      #
+      class ScriptPermission < Cop
+        MSG = "Script file %<file>s doesn't have execute permission.".freeze
+        SHEBANG = '#!'.freeze
+
+        def investigate(processed_source)
+          return if @options.key?(:stdin)
+          return if Platform.windows?
+          return unless processed_source.start_with?(SHEBANG)
+          return if executable?(processed_source)
+
+          comment = processed_source.comments[0]
+          message = format_message_from(processed_source)
+          add_offense(comment, message: message)
+        end
+
+        def autocorrect(node)
+          lambda do |_corrector|
+            FileUtils.chmod('+x', node.loc.expression.source_buffer.name)
+          end
+        end
+
+        private
+
+        def executable?(processed_source)
+          # Returns true if stat is executable or if the operating system
+          # doesn't distinguish executable files from nonexecutable files.
+          # See at: https://github.com/ruby/ruby/blob/ruby_2_4/file.c#L5362
+          File.stat(processed_source.file_path).executable?
+        end
+
+        def format_message_from(processed_source)
+          basename = File.basename(processed_source.file_path)
+          format(MSG, file: basename)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rubocop-0.66.0/lib/rubocop/cop/lint/shadowed_argument.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for shadowed arguments.
+      #
+      # This cop has `IgnoreImplicitReferences` configuration option.
+      # It means argument shadowing is used in order to pass parameters
+      # to zero arity `super` when `IgnoreImplicitReferences` is `true`.
+      #
+      # @example
+      #
+      #   # bad
+      #   do_something do |foo|
+      #     foo = 42
+      #     puts foo
+      #   end
+      #
+      #   def do_something(foo)
+      #     foo = 42
+      #     puts foo
+      #   end
+      #
+      #   # good
+      #   do_something do |foo|
+      #     foo = foo + 42
+      #     puts foo
+      #   end
+      #
+      #   def do_something(foo)
+      #     foo = foo + 42
+      #     puts foo
+      #   end
+      #
+      #   def do_something(foo)
+      #     puts foo
+      #   end
+      #
+      # @example IgnoreImplicitReferences: false (default)
+      #
+      #   # bad
+      #   def do_something(foo)
+      #     foo = 42
+      #     super
+      #   end
+      #
+      #   def do_something(foo)
+      #     foo = super
+      #     bar
+      #   end
+      #
+      # @example IgnoreImplicitReferences: true
+      #
+      #   # good
+      #   def do_something(foo)
+      #     foo = 42
+      #     super
+      #   end
+      #
+      #   def do_something(foo)
+      #     foo = super
+      #     bar
+      #   end
+      #
+      class ShadowedArgument < Cop
+        MSG = 'Argument `%<argument>s` was shadowed by a local variable ' \
+              'before it was used.'.freeze
+
+        def_node_search :uses_var?, '(lvar %)'
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            check_argument(variable)
+          end
+        end
+
+        private
+
+        def check_argument(argument)
+          return unless argument.method_argument? || argument.block_argument?
+          # Block local variables, i.e., variables declared after ; inside
+          # |...| aren't really arguments.
+          return if argument.explicit_block_local_variable?
+
+          shadowing_assignment(argument) do |node|
+            message = format(MSG, argument: argument.name)
+
+            add_offense(node, message: message)
+          end
+        end
+
+        def shadowing_assignment(argument)
+          return unless argument.referenced?
+
+          assignment_without_argument_usage(argument) do |node, location_known|
+            assignment_without_usage_pos = node.source_range.begin_pos
+
+            references = argument_references(argument)
+
+            # If argument was referenced before it was reassigned
+            # then it's not shadowed
+            next if references.any? do |reference|
+              next true if !reference.explicit? && ignore_implicit_references?
+
+              reference_pos(reference.node) <= assignment_without_usage_pos
+            end
+
+            yield location_known ? node : argument.declaration_node
+          end
+        end
+
+        # Find the first argument assignment, which doesn't reference the
+        # argument at the rhs. If the assignment occurs inside a branch or
+        # block, it is impossible to tell whether it's executed, so precise
+        # shadowing location is not known.
+        #
+        def assignment_without_argument_usage(argument)
+          argument.assignments.reduce(true) do |location_known, assignment|
+            assignment_node = assignment.meta_assignment_node || assignment.node
+
+            # Shorthand assignments always use their arguments
+            next false if assignment_node.shorthand_asgn?
+
+            node_within_block_or_conditional =
+              node_within_block_or_conditional?(assignment_node.parent,
+                                                argument.scope.node)
+
+            unless uses_var?(assignment_node, argument.name)
+              # It's impossible to decide whether a branch or block is executed,
+              # so the precise reassignment location is undecidable.
+              next false if node_within_block_or_conditional
+
+              yield(assignment.node, location_known)
+              break
+            end
+
+            location_known
+          end
+        end
+
+        def reference_pos(node)
+          node = node.parent.masgn_type? ? node.parent : node
+
+          node.source_range.begin_pos
+        end
+
+        # Check whether the given node is nested into block or conditional.
+        #
+        def node_within_block_or_conditional?(node, stop_search_node)
+          return false if node == stop_search_node
+
+          node.conditional? || node.block_type? ||
+            node_within_block_or_conditional?(node.parent, stop_search_node)
+        end
+
+        # Get argument references without assignments' references
+        #
+        def argument_references(argument)
+          assignment_references = argument
+                                  .assignments
+                                  .flat_map(&:references)
+                                  .map(&:source_range)
+
+          argument.references.reject do |ref|
+            next false unless ref.explicit?
+
+            assignment_references.include?(ref.node.source_range)
+          end
+        end
+
+        def ignore_implicit_references?
+          cop_config['IgnoreImplicitReferences']
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rubocop-0.66.0/lib/rubocop/cop/lint/shadowed_exception.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for a rescued exception that get shadowed by a
+      # less specific exception being rescued before a more specific
+      # exception is rescued.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     something
+      #   rescue Exception
+      #     handle_exception
+      #   rescue StandardError
+      #     handle_standard_error
+      #   end
+      #
+      #   # good
+      #
+      #   begin
+      #     something
+      #   rescue StandardError
+      #     handle_standard_error
+      #   rescue Exception
+      #     handle_exception
+      #   end
+      #
+      #   # good, however depending on runtime environment.
+      #   #
+      #   # This is a special case for system call errors.
+      #   # System dependent error code depends on runtime environment.
+      #   # For example, whether `Errno::EAGAIN` and `Errno::EWOULDBLOCK` are
+      #   # the same error code or different error code depends on environment.
+      #   # This good case is for `Errno::EAGAIN` and `Errno::EWOULDBLOCK` with
+      #   # the same error code.
+      #   begin
+      #     something
+      #   rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+      #     handle_standard_error
+      #   end
+      #
+      class ShadowedException < Cop
+        include RescueNode
+        include RangeHelp
+
+        MSG = 'Do not shadow rescued Exceptions.'.freeze
+
+        def on_rescue(node)
+          return if rescue_modifier?(node)
+
+          _body, *rescues, _else = *node
+          rescued_groups = rescued_groups_for(rescues)
+
+          rescue_group_rescues_multiple_levels = rescued_groups.any? do |group|
+            contains_multiple_levels_of_exceptions?(group)
+          end
+
+          return if !rescue_group_rescues_multiple_levels &&
+                    sorted?(rescued_groups)
+
+          add_offense(node, location: offense_range(rescues))
+        end
+
+        private
+
+        def offense_range(rescues)
+          shadowing_rescue = find_shadowing_rescue(rescues)
+          expression = shadowing_rescue.loc.expression
+          range_between(expression.begin_pos, expression.end_pos)
+        end
+
+        def rescued_groups_for(rescues)
+          rescues.map do |group|
+            rescue_group, = *group
+            evaluate_exceptions(rescue_group)
+          end
+        end
+
+        def contains_multiple_levels_of_exceptions?(group)
+          # Always treat `Exception` as the highest level exception.
+          return true if group.size > 1 && group.include?(Exception)
+
+          group.combination(2).any? do |a, b|
+            compare_exceptions(a, b)
+          end
+        end
+
+        def compare_exceptions(exception, other_exception)
+          if system_call_err?(exception) && system_call_err?(other_exception)
+            # This condition logic is for special case.
+            # System dependent error code depends on runtime environment.
+            # For example, whether `Errno::EAGAIN` and `Errno::EWOULDBLOCK` are
+            # the same error code or different error code depends on runtime
+            # environment. This checks the error code for that.
+            exception.const_get(:Errno) != other_exception.const_get(:Errno) &&
+              exception <=> other_exception
+          else
+            exception && other_exception && exception <=> other_exception
+          end
+        end
+
+        def system_call_err?(error)
+          error && error.ancestors[1] == SystemCallError
+        end
+
+        def silence_warnings
+          # Replaces Kernel::silence_warnings since it hides any warnings,
+          # including the RuboCop ones
+          old_verbose = $VERBOSE
+          $VERBOSE = nil
+          yield
+        ensure
+          $VERBOSE = old_verbose
+        end
+
+        def evaluate_exceptions(rescue_group)
+          if rescue_group
+            rescued_exceptions = rescued_exceptions(rescue_group)
+            rescued_exceptions.each_with_object([]) do |exception, converted|
+              begin
+                silence_warnings do
+                  # Avoid printing deprecation warnings about constants
+                  converted << Kernel.const_get(exception)
+                end
+              rescue NameError
+                converted << nil
+              end
+            end
+          else
+            # treat an empty `rescue` as `rescue StandardError`
+            [StandardError]
+          end
+        end
+
+        def sorted?(rescued_groups)
+          rescued_groups.each_cons(2).all? do |x, y|
+            if x.include?(Exception)
+              false
+            elsif y.include?(Exception)
+              true
+            elsif x.none? || y.none?
+              # consider sorted if a group is empty or only contains
+              # `nil`s
+              true
+            else
+              (x <=> y || 0) <= 0
+            end
+          end
+        end
+
+        # @param [RuboCop::AST::Node] rescue_group is a node of array_type
+        def rescued_exceptions(rescue_group)
+          klasses = *rescue_group
+          klasses.map do |klass|
+            next unless klass.const_type?
+
+            klass.source
+          end.compact
+        end
+
+        def find_shadowing_rescue(rescues)
+          rescued_groups = rescued_groups_for(rescues)
+          rescued_groups.zip(rescues).each do |group, res|
+            return res if contains_multiple_levels_of_exceptions?(group)
+          end
+
+          rescued_groups.each_cons(2).with_index do |group_pair, i|
+            return rescues[i] unless sorted?(group_pair)
+          end
+        end
+      end
+    end
+  end
+end