rubocop 0.75.1

data/lib/rubocop/cop/registry.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Error raised when an unqualified cop name is used that could
+    # refer to two or more cops under different departments
+    class AmbiguousCopName < RuboCop::Error
+      MSG = 'Ambiguous cop name `%<name>s` used in %<origin>s needs ' \
+            'department qualifier. Did you mean %<options>s?'
+
+      def initialize(name, origin, badges)
+        super(
+          format(
+            MSG,
+            name: name,
+            origin: origin,
+            options: badges.to_a.join(' or ')
+          )
+        )
+      end
+    end
+
+    # Registry that tracks all cops by their badge and department.
+    class Registry
+      def initialize(cops = [])
+        @registry = {}
+        @departments = {}
+        @cops_by_cop_name = Hash.new { |hash, key| hash[key] = [] }
+
+        cops.each { |cop| enlist(cop) }
+      end
+
+      def enlist(cop)
+        @registry[cop.badge] = cop
+        @departments[cop.department] ||= []
+        @departments[cop.department] << cop
+        @cops_by_cop_name[cop.cop_name] << cop
+      end
+
+      # @return [Array<Symbol>] list of departments for current cops.
+      def departments
+        @departments.keys
+      end
+
+      # @return [Registry] Cops for that specific department.
+      def with_department(department)
+        with(@departments.fetch(department, []))
+      end
+
+      # @return [Registry] Cops not for a specific department.
+      def without_department(department)
+        without_department = @departments.dup
+        without_department.delete(department)
+
+        with(without_department.values.flatten)
+      end
+
+      def contains_cop_matching?(names)
+        cops.any? { |cop| cop.match?(names) }
+      end
+
+      # Convert a user provided cop name into a properly namespaced name
+      #
+      # @example gives back a correctly qualified cop name
+      #
+      #   cops = RuboCop::Cop::Cop.all
+      #   cops.
+      #     qualified_cop_name('Layout/EndOfLine') # => 'Layout/EndOfLine'
+      #
+      # @example fixes incorrect namespaces
+      #
+      #   cops = RuboCop::Cop::Cop.all
+      #   cops.qualified_cop_name('Lint/EndOfLine') # => 'Layout/EndOfLine'
+      #
+      # @example namespaces bare cop identifiers
+      #
+      #   cops = RuboCop::Cop::Cop.all
+      #   cops.qualified_cop_name('EndOfLine') # => 'Layout/EndOfLine'
+      #
+      # @example passes back unrecognized cop names
+      #
+      #   cops = RuboCop::Cop::Cop.all
+      #   cops.qualified_cop_name('NotACop') # => 'NotACop'
+      #
+      # @param name [String] Cop name extracted from config
+      # @param path [String, nil] Path of file that `name` was extracted from
+      #
+      # @raise [AmbiguousCopName]
+      #   if a bare identifier with two possible namespaces is provided
+      #
+      # @note Emits a warning if the provided name has an incorrect namespace
+      #
+      # @return [String] Qualified cop name
+      def qualified_cop_name(name, path, shall_warn = true)
+        badge = Badge.parse(name)
+        if shall_warn && department_missing?(badge, name)
+          print_warning(name, path)
+        end
+        return name if registered?(badge)
+
+        potential_badges = qualify_badge(badge)
+
+        case potential_badges.size
+        when 0 then name # No namespace found. Deal with it later in caller.
+        when 1 then resolve_badge(badge, potential_badges.first, path)
+        else raise AmbiguousCopName.new(badge, path, potential_badges)
+        end
+      end
+
+      def department_missing?(badge, name)
+        !badge.qualified? && unqualified_cop_names.include?(name)
+      end
+
+      def print_warning(name, path)
+        message = "#{path}: Warning: no department given for #{name}."
+        if path.end_with?('.rb')
+          message += ' Run `rubocop -a --only Migration/DepartmentName` to fix.'
+        end
+        warn message
+      end
+
+      def unqualified_cop_names
+        @unqualified_cop_names ||=
+          Set.new(@cops_by_cop_name.keys.map { |qn| File.basename(qn) }) <<
+          'UnneededCopDisableDirective'
+      end
+
+      # @return [Hash{String => Array<Class>}]
+      def to_h
+        @cops_by_cop_name
+      end
+
+      def cops
+        @registry.values
+      end
+
+      def length
+        @registry.size
+      end
+
+      def enabled(config, only, only_safe = false)
+        select do |cop|
+          only.include?(cop.cop_name) || enabled?(cop, config, only_safe)
+        end
+      end
+
+      def enabled?(cop, config, only_safe)
+        cfg = config.for_cop(cop)
+        if only_safe
+          cfg.fetch('Enabled') && cfg.fetch('Safe', true)
+        else
+          cfg.fetch('Enabled')
+        end
+      end
+
+      def names
+        cops.map(&:cop_name)
+      end
+
+      def ==(other)
+        cops == other.cops
+      end
+
+      def sort!
+        @registry = Hash[@registry.sort_by { |badge, _| badge.cop_name }]
+
+        self
+      end
+
+      def select(&block)
+        cops.select(&block)
+      end
+
+      def each(&block)
+        cops.each(&block)
+      end
+
+      # @param [String] cop_name
+      # @return [Class, nil]
+      def find_by_cop_name(cop_name)
+        @cops_by_cop_name[cop_name].first
+      end
+
+      private
+
+      def with(cops)
+        self.class.new(cops)
+      end
+
+      def qualify_badge(badge)
+        @departments
+          .map { |department, _| badge.with_department(department) }
+          .select { |potential_badge| registered?(potential_badge) }
+      end
+
+      def resolve_badge(given_badge, real_badge, source_path)
+        unless given_badge.match?(real_badge)
+          path = PathUtil.smart_path(source_path)
+          warn "#{path}: #{given_badge} has the wrong namespace - " \
+               "should be #{real_badge.department}"
+        end
+
+        real_badge.to_s
+      end
+
+      def registered?(badge)
+        @registry.key?(badge)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/security/eval.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # This cop checks for the use of `Kernel#eval` and `Binding#eval`.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   eval(something)
+      #   binding.eval(something)
+      class Eval < Cop
+        MSG = 'The use of `eval` is a serious security risk.'
+
+        def_node_matcher :eval?, <<~PATTERN
+          (send {nil? (send nil? :binding)} :eval $!str ...)
+        PATTERN
+
+        def on_send(node)
+          eval?(node) do |code|
+            return if code.dstr_type? && code.recursive_literal?
+
+            add_offense(node, location: :selector)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/security/json_load.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # This cop checks for the use of JSON class methods which have potential
+      # security issues.
+      #
+      # Autocorrect is disabled by default 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 < Cop
+        MSG = 'Prefer `JSON.parse` over `JSON.%<method>s`.'
+
+        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,
+                        location: :selector,
+                        message: format(MSG, method: method))
+          end
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.selector, 'parse') }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/security/marshal_load.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # This cop 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 < Cop
+        MSG = 'Avoid using `Marshal.%<method>s`.'
+
+        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,
+                        location: :selector,
+                        message: format(MSG, method: method))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/security/open.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # This cop checks for the use of `Kernel#open`.
+      #
+      # `Kernel#open` enables 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`. It would be better to use `File.open`, `IO.popen` or
+      # `URI#open` explicitly.
+      #
+      # @example
+      #   # bad
+      #   open(something)
+      #
+      #   # good
+      #   File.open(something)
+      #   IO.popen(something)
+      #   URI.parse(something).open
+      class Open < Cop
+        MSG = 'The use of `Kernel#open` is a serious security risk.'
+
+        def_node_matcher :open?, <<~PATTERN
+          (send nil? :open $!str ...)
+        PATTERN
+
+        def on_send(node)
+          open?(node) do |code|
+            return if safe?(code)
+
+            add_offense(node, location: :selector)
+          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/lib/rubocop/cop/security/yaml_load.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # This cop checks for the use of YAML class methods which have
+      # potential security issues leading to remote code execution when
+      # loading from an untrusted source.
+      #
+      # @example
+      #   # bad
+      #   YAML.load("--- foo")
+      #
+      #   # good
+      #   YAML.safe_load("--- foo")
+      #   YAML.dump("foo")
+      #
+      class YAMLLoad < Cop
+        MSG = 'Prefer using `YAML.safe_load` over `YAML.load`.'
+
+        def_node_matcher :yaml_load, <<~PATTERN
+          (send (const {nil? cbase} :YAML) :load ...)
+        PATTERN
+
+        def on_send(node)
+          yaml_load(node) do
+            add_offense(node, location: :selector)
+          end
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.selector, 'safe_load') }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/severity.rb

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