fablicop 1.10.1 → 1.10.2

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/security/io_methods.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # Checks for the first argument to `IO.read`, `IO.binread`, `IO.write`, `IO.binwrite`,
+      # `IO.foreach`, and `IO.readlines`.
+      #
+      # If argument starts with a pipe character (`'|'`) and the receiver is the `IO` class,
+      # a subprocess is created in the same way as `Kernel#open`, and its output is returned.
+      # `Kernel#open` may allow unintentional command injection, which is the reason these
+      # `IO` methods are a security risk.
+      # Consider to use `File.read` to disable the behavior of subprocess invocation.
+      #
+      # @safety
+      #   This cop is unsafe because false positive will occur if the variable passed as
+      #   the first argument is a command that is not a file path.
+      #
+      # @example
+      #
+      #   # bad
+      #   IO.read(path)
+      #   IO.read('path')
+      #
+      #   # good
+      #   File.read(path)
+      #   File.read('path')
+      #   IO.read('| command') # Allow intentional command invocation.
+      #
+      class IoMethods < Base
+        extend AutoCorrector
+
+        MSG = '`File.%<method_name>s` is safer than `IO.%<method_name>s`.'
+        RESTRICT_ON_SEND = %i[read binread write binwrite foreach readlines].freeze
+
+        def on_send(node)
+          return unless (receiver = node.receiver) && receiver.source == 'IO'
+
+          argument = node.first_argument
+          return if argument.respond_to?(:value) && argument.value.strip.start_with?('|')
+
+          add_offense(node, message: format(MSG, method_name: node.method_name)) do |corrector|
+            corrector.replace(receiver, 'File')
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/security/json_load.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # Checks for the use of JSON class methods which have potential
+      # security issues.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it's potentially dangerous.
+      #   If using a stream, like `JSON.load(open('file'))`, it will need to call
+      #   `#read` manually, like `JSON.parse(open('file').read)`.
+      #   If reading single values (rather than proper JSON objects), like
+      #   `JSON.load('false')`, it will need to pass the `quirks_mode: true`
+      #   option, like `JSON.parse('false', quirks_mode: true)`.
+      #   Other similar issues may apply.
+      #
+      # @example
+      #   # bad
+      #   JSON.load("{}")
+      #   JSON.restore("{}")
+      #
+      #   # good
+      #   JSON.parse("{}")
+      #
+      class JSONLoad < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `JSON.parse` over `JSON.%<method>s`.'
+        RESTRICT_ON_SEND = %i[load restore].freeze
+
+        # @!method json_load(node)
+        def_node_matcher :json_load, <<~PATTERN
+          (send (const {nil? cbase} :JSON) ${:load :restore} ...)
+        PATTERN
+
+        def on_send(node)
+          json_load(node) do |method|
+            add_offense(node.loc.selector, message: format(MSG, method: method)) do |corrector|
+              corrector.replace(node.loc.selector, 'parse')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/security/marshal_load.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # Checks for the use of Marshal class methods which have
+      # potential security issues leading to remote code execution when
+      # loading from an untrusted source.
+      #
+      # @example
+      #   # bad
+      #   Marshal.load("{}")
+      #   Marshal.restore("{}")
+      #
+      #   # good
+      #   Marshal.dump("{}")
+      #
+      #   # okish - deep copy hack
+      #   Marshal.load(Marshal.dump({}))
+      #
+      class MarshalLoad < Base
+        MSG = 'Avoid using `Marshal.%<method>s`.'
+        RESTRICT_ON_SEND = %i[load restore].freeze
+
+        # @!method marshal_load(node)
+        def_node_matcher :marshal_load, <<~PATTERN
+          (send (const {nil? cbase} :Marshal) ${:load :restore}
+          !(send (const {nil? cbase} :Marshal) :dump ...))
+        PATTERN
+
+        def on_send(node)
+          marshal_load(node) do |method|
+            add_offense(node.loc.selector, message: format(MSG, method: method))
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/security/open.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # Checks for the use of `Kernel#open` and `URI.open` with dynamic
+      # data.
+      #
+      # `Kernel#open` and `URI.open` enable not only file access but also process
+      # invocation by prefixing a pipe symbol (e.g., `open("| ls")`).
+      # So, it may lead to a serious security risk by using variable input to
+      # the argument of `Kernel#open` and `URI.open`. It would be better to use
+      # `File.open`, `IO.popen` or `URI.parse#open` explicitly.
+      #
+      # NOTE: `open` and `URI.open` with literal strings are not flagged by this
+      # cop.
+      #
+      # @safety
+      #   This cop could register false positives if `open` is redefined
+      #   in a class and then used without a receiver in that class.
+      #
+      # @example
+      #   # bad
+      #   open(something)
+      #   open("| #{something}")
+      #   URI.open(something)
+      #
+      #   # good
+      #   File.open(something)
+      #   IO.popen(something)
+      #   URI.parse(something).open
+      #
+      #   # good (literal strings)
+      #   open("foo.text")
+      #   open("| foo")
+      #   URI.open("http://example.com")
+      class Open < Base
+        MSG = 'The use of `%<receiver>sopen` is a serious security risk.'
+        RESTRICT_ON_SEND = %i[open].freeze
+
+        # @!method open?(node)
+        def_node_matcher :open?, <<~PATTERN
+          (send ${nil? (const {nil? cbase} :URI)} :open $!str ...)
+        PATTERN
+
+        def on_send(node)
+          open?(node) do |receiver, code|
+            return if safe?(code)
+
+            message = format(MSG, receiver: receiver ? "#{receiver.source}." : 'Kernel#')
+            add_offense(node.loc.selector, message: message)
+          end
+        end
+
+        private
+
+        def safe?(node)
+          if simple_string?(node)
+            safe_argument?(node.str_content)
+          elsif composite_string?(node)
+            safe?(node.children.first)
+          else
+            false
+          end
+        end
+
+        def safe_argument?(argument)
+          !argument.empty? && !argument.start_with?('|')
+        end
+
+        def simple_string?(node)
+          node.str_type?
+        end
+
+        def composite_string?(node)
+          interpolated_string?(node) || concatenated_string?(node)
+        end
+
+        def interpolated_string?(node)
+          node.dstr_type?
+        end
+
+        def concatenated_string?(node)
+          node.send_type? && node.method?(:+) && node.receiver.str_type?
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/security/yaml_load.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # Checks for the use of YAML class methods which have
+      # potential security issues leading to remote code execution when
+      # loading from an untrusted source.
+      #
+      # NOTE: Ruby 3.1+ (Psych 4) uses `Psych.load` as `Psych.safe_load` by default.
+      #
+      # @safety
+      #   The behavior of the code might change depending on what was
+      #   in the YAML payload, since `YAML.safe_load` is more restrictive.
+      #
+      # @example
+      #   # bad
+      #   YAML.load("--- !ruby/object:Foo {}") # Psych 3 is unsafe by default
+      #
+      #   # good
+      #   YAML.safe_load("--- !ruby/object:Foo {}", [Foo])                    # Ruby 2.5  (Psych 3)
+      #   YAML.safe_load("--- !ruby/object:Foo {}", permitted_classes: [Foo]) # Ruby 3.0- (Psych 3)
+      #   YAML.load("--- !ruby/object:Foo {}", permitted_classes: [Foo])      # Ruby 3.1+ (Psych 4)
+      #   YAML.dump(foo)
+      #
+      class YAMLLoad < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer using `YAML.safe_load` over `YAML.load`.'
+        RESTRICT_ON_SEND = %i[load].freeze
+
+        # @!method yaml_load(node)
+        def_node_matcher :yaml_load, <<~PATTERN
+          (send (const {nil? cbase} :YAML) :load ...)
+        PATTERN
+
+        def on_send(node)
+          return if target_ruby_version >= 3.1
+
+          yaml_load(node) do
+            add_offense(node.loc.selector) do |corrector|
+              corrector.replace(node.loc.selector, 'safe_load')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/severity.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Severity class is simple value object about severity
+    class Severity
+      include Comparable
+
+      NAMES = %i[info refactor convention warning error fatal].freeze
+
+      # @api private
+      CODE_TABLE = { I: :info, R: :refactor, C: :convention,
+                     W: :warning, E: :error, F: :fatal }.freeze
+
+      # @api public
+      #
+      # @!attribute [r] name
+      #
+      # @return [Symbol]
+      #   severity.
+      #   any of `:info`, `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
+      attr_reader :name
+
+      def self.name_from_code(code)
+        name = code.to_sym
+        CODE_TABLE[name] || name
+      end
+
+      # @api private
+      def initialize(name_or_code)
+        name = Severity.name_from_code(name_or_code)
+        raise ArgumentError, "Unknown severity: #{name}" unless NAMES.include?(name)
+
+        @name = name.freeze
+        freeze
+      end
+
+      def to_s
+        @name.to_s
+      end
+
+      def code
+        @name.to_s[0].upcase
+      end
+
+      def level
+        NAMES.index(name) + 1
+      end
+
+      def ==(other)
+        @name == if other.is_a?(Symbol)
+                   other
+                 else
+                   other.name
+                 end
+      end
+
+      def hash
+        @name.hash
+      end
+
+      def <=>(other)
+        level <=> other.level
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/style/access_modifier_declarations.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Access modifiers should be declared to apply to a group of methods
+      # or inline before each method, depending on configuration.
+      # EnforcedStyle config covers only method definitions.
+      # Applications of visibility methods to symbols can be controlled
+      # using AllowModifiersOnSymbols config.
+      #
+      # @safety
+      #   Autocorrection is not safe, because the visibility of dynamically
+      #   defined methods can vary depending on the state determined by
+      #   the group access modifier.
+      #
+      # @example EnforcedStyle: group (default)
+      #   # bad
+      #   class Foo
+      #
+      #     private def bar; end
+      #     private def baz; end
+      #
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #
+      #     private
+      #
+      #     def bar; end
+      #     def baz; end
+      #
+      #   end
+      #
+      # @example EnforcedStyle: inline
+      #   # bad
+      #   class Foo
+      #
+      #     private
+      #
+      #     def bar; end
+      #     def baz; end
+      #
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #
+      #     private def bar; end
+      #     private def baz; end
+      #
+      #   end
+      #
+      # @example AllowModifiersOnSymbols: true (default)
+      #   # good
+      #   class Foo
+      #
+      #     private :bar, :baz
+      #
+      #   end
+      #
+      # @example AllowModifiersOnSymbols: false
+      #   # bad
+      #   class Foo
+      #
+      #     private :bar, :baz
+      #
+      #   end
+      class AccessModifierDeclarations < Base
+        extend AutoCorrector
+
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        GROUP_STYLE_MESSAGE = [
+          '`%<access_modifier>s` should not be',
+          'inlined in method definitions.'
+        ].join(' ')
+
+        INLINE_STYLE_MESSAGE = [
+          '`%<access_modifier>s` should be',
+          'inlined in method definitions.'
+        ].join(' ')
+
+        RESTRICT_ON_SEND = %i[private protected public module_function].freeze
+
+        ALLOWED_NODE_TYPES = %i[pair block].freeze
+
+        # @!method access_modifier_with_symbol?(node)
+        def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
+          (send nil? {:private :protected :public :module_function} (sym _))
+        PATTERN
+
+        def on_send(node)
+          return unless node.access_modifier?
+          return if ALLOWED_NODE_TYPES.include?(node.parent&.type)
+          return if allow_modifiers_on_symbols?(node)
+
+          if offense?(node)
+            add_offense(node.loc.selector) do |corrector|
+              autocorrect(corrector, node)
+            end
+            opposite_style_detected
+          else
+            correct_style_detected
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          case style
+          when :group
+            def_node = find_corresponding_def_node(node)
+            return unless def_node
+
+            replace_def(corrector, node, def_node)
+          when :inline
+            remove_node(corrector, node)
+            select_grouped_def_nodes(node).each do |grouped_def_node|
+              insert_inline_modifier(corrector, grouped_def_node, node.method_name)
+            end
+          end
+        end
+
+        def allow_modifiers_on_symbols?(node)
+          cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
+        end
+
+        def offense?(node)
+          (group_style? && access_modifier_is_inlined?(node) &&
+            !right_siblings_same_inline_method?(node)) ||
+            (inline_style? && access_modifier_is_not_inlined?(node))
+        end
+
+        def group_style?
+          style == :group
+        end
+
+        def inline_style?
+          style == :inline
+        end
+
+        def access_modifier_is_inlined?(node)
+          node.arguments.any?
+        end
+
+        def access_modifier_is_not_inlined?(node)
+          !access_modifier_is_inlined?(node)
+        end
+
+        def right_siblings_same_inline_method?(node)
+          node.right_siblings.any? do |sibling|
+            sibling.send_type? && sibling.method?(node.method_name) && !sibling.arguments.empty?
+          end
+        end
+
+        def message(range)
+          access_modifier = range.source
+
+          if group_style?
+            format(GROUP_STYLE_MESSAGE, access_modifier: access_modifier)
+          elsif inline_style?
+            format(INLINE_STYLE_MESSAGE, access_modifier: access_modifier)
+          end
+        end
+
+        def find_corresponding_def_node(node)
+          if access_modifier_with_symbol?(node)
+            method_name = node.arguments.first.value
+            node.parent.each_child_node(:def).find do |child|
+              child.method?(method_name)
+            end
+          else
+            node.arguments.first
+          end
+        end
+
+        def find_argument_less_modifier_node(node)
+          return unless (parent = node.parent)
+
+          parent.each_child_node(:send).find do |child|
+            child.method?(node.method_name) && child.arguments.empty?
+          end
+        end
+
+        def select_grouped_def_nodes(node)
+          node.right_siblings.take_while do |sibling|
+            !(sibling.send_type? && sibling.bare_access_modifier_declaration?)
+          end.select(&:def_type?)
+        end
+
+        def replace_def(corrector, node, def_node)
+          source = def_source(node, def_node)
+          argument_less_modifier_node = find_argument_less_modifier_node(node)
+          if argument_less_modifier_node
+            corrector.insert_after(argument_less_modifier_node, "\n\n#{source}")
+          elsif (ancestor = node.each_ancestor(:block, :class, :module).first)
+
+            corrector.insert_before(ancestor.loc.end, "#{node.method_name}\n\n#{source}\n")
+          else
+            corrector.replace(node, "#{node.method_name}\n\n#{source}")
+            return
+          end
+
+          remove_node(corrector, def_node)
+          remove_node(corrector, node)
+        end
+
+        def insert_inline_modifier(corrector, node, modifier_name)
+          corrector.insert_before(node, "#{modifier_name} ")
+        end
+
+        def remove_node(corrector, node)
+          corrector.remove(range_with_comments_and_lines(node))
+        end
+
+        def def_source(node, def_node)
+          [*processed_source.ast_with_comments[node].map(&:text), def_node.source].join("\n")
+        end
+      end
+    end
+  end
+end