RubyGems - cocRb - Versions diffs - 0.1.0 → 1.1.5 - Mend

cocRb 0.1.0 → 1.1.5

Files changed (1708) hide show

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/config_loader.rb DELETED Viewed

@@ -1,277 +0,0 @@
-# frozen_string_literal: true
-require 'yaml'
-require 'pathname'
-module RuboCop
-  # Raised when a RuboCop configuration file is not found.
-  class ConfigNotFoundError < Error
-  end
-  # This class represents the configuration of the RuboCop application
-  # and all its cops. A Config is associated with a YAML configuration
-  # file from which it was read. Several different Configs can be used
-  # during a run of the rubocop program, if files in several
-  # directories are inspected.
-  class ConfigLoader
-    DOTFILE = '.rubocop.yml'
-    XDG_CONFIG = 'config.yml'
-    RUBOCOP_HOME = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
-    DEFAULT_FILE = File.join(RUBOCOP_HOME, 'config', 'default.yml')
-    class << self
-      include FileFinder
-      attr_accessor :debug, :ignore_parent_exclusion, :disable_pending_cops, :enable_pending_cops
-      attr_writer :default_configuration, :project_root
-      attr_reader :loaded_features
-      alias debug? debug
-      alias ignore_parent_exclusion? ignore_parent_exclusion
-      def clear_options
-        @debug = nil
-        @loaded_features = Set.new
-        FileFinder.root_level = nil
-      end
-      def load_file(file, check: true)
-        path = file_path(file)
-        hash = load_yaml_configuration(path)
-        # Resolve requires first in case they define additional cops
-        loaded_features = resolver.resolve_requires(path, hash)
-        add_loaded_features(loaded_features)
-        add_missing_namespaces(path, hash)
-        resolver.override_department_setting_for_cops({}, hash)
-        resolver.resolve_inheritance_from_gems(hash)
-        resolver.resolve_inheritance(path, hash, file, debug?)
-        hash.delete('inherit_from')
-        Config.create(hash, path, check: check)
-      end
-      def load_yaml_configuration(absolute_path)
-        file_contents = read_file(absolute_path)
-        yaml_code = Dir.chdir(File.dirname(absolute_path)) { ERB.new(file_contents).result }
-        check_duplication(yaml_code, absolute_path)
-        hash = yaml_safe_load(yaml_code, absolute_path) || {}
-        puts "configuration from #{absolute_path}" if debug?
-        raise(TypeError, "Malformed configuration in #{absolute_path}") unless hash.is_a?(Hash)
-        hash
-      end
-      def add_missing_namespaces(path, hash)
-        # Using `hash.each_key` will cause the
-        # `can't add a new key into hash during iteration` error
-        hash_keys = hash.keys
-        hash_keys.each do |key|
-          q = Cop::Registry.qualified_cop_name(key, path)
-          next if q == key
-          hash[q] = hash.delete(key)
-        end
-      end
-      # Return a recursive merge of two hashes. That is, a normal hash merge,
-      # with the addition that any value that is a hash, and occurs in both
-      # arguments, will also be merged. And so on.
-      def merge(base_hash, derived_hash)
-        resolver.merge(base_hash, derived_hash)
-      end
-      # Returns the path of .rubocop.yml searching upwards in the
-      # directory structure starting at the given directory where the
-      # inspected file is. If no .rubocop.yml is found there, the
-      # user's home directory is checked. If there's no .rubocop.yml
-      # there either, the path to the default file is returned.
-      def configuration_file_for(target_dir)
-        find_project_dotfile(target_dir) || find_user_dotfile ||
-          find_user_xdg_config || DEFAULT_FILE
-      end
-      def configuration_from_file(config_file, check: true)
-        return default_configuration if config_file == DEFAULT_FILE
-        config = load_file(config_file, check: check)
-        if ignore_parent_exclusion?
-          print 'Ignoring AllCops/Exclude from parent folders' if debug?
-        else
-          add_excludes_from_files(config, config_file)
-        end
-        merge_with_default(config, config_file).tap do |merged_config|
-          warn_on_pending_cops(merged_config.pending_cops) unless possible_new_cops?(merged_config)
-        end
-      end
-      def possible_new_cops?(config)
-        disable_pending_cops || enable_pending_cops ||
-          config.disabled_new_cops? || config.enabled_new_cops?
-      end
-      def add_excludes_from_files(config, config_file)
-        exclusion_file = find_last_file_upwards(DOTFILE, config_file, project_root)
-        return unless exclusion_file
-        return if PathUtil.relative_path(exclusion_file) == PathUtil.relative_path(config_file)
-        print 'AllCops/Exclude ' if debug?
-        config.add_excludes_from_higher_level(load_file(exclusion_file))
-      end
-      def default_configuration
-        @default_configuration ||= begin
-          print 'Default ' if debug?
-          load_file(DEFAULT_FILE)
-        end
-      end
-      # Returns the path rubocop inferred as the root of the project. No file
-      # searches will go past this directory.
-      def project_root
-        @project_root ||= find_project_root
-      end
-      PENDING_BANNER = <<~BANNER
-        The following cops were added to RuboCop, but are not configured. Please set Enabled to either `true` or `false` in your `.rubocop.yml` file.
-        Please also note that can also opt-in to new cops by default by adding this to your config:
-          AllCops:
-            NewCops: enable
-      BANNER
-      def warn_on_pending_cops(pending_cops)
-        return if pending_cops.empty?
-        warn Rainbow(PENDING_BANNER).yellow
-        pending_cops.each { |cop| warn_pending_cop cop }
-        warn Rainbow('For more information: https://docs.rubocop.org/rubocop/versioning.html').yellow
-      end
-      def warn_pending_cop(cop)
-        version = cop.metadata['VersionAdded'] || 'N/A'
-        warn Rainbow("#{cop.name}: # (new in #{version})").yellow
-        warn Rainbow('  Enabled: true').yellow
-      end
-      # Merges the given configuration with the default one.
-      def merge_with_default(config, config_file, unset_nil: true)
-        resolver.merge_with_default(config, config_file, unset_nil: unset_nil)
-      end
-      # @api private
-      # Used to add features that were required inside a config or from
-      # the CLI using `--require`.
-      def add_loaded_features(loaded_features)
-        @loaded_features.merge(Array(loaded_features))
-      end
-      private
-      def file_path(file)
-        File.absolute_path(file.is_a?(RemoteConfig) ? file.file : file)
-      end
-      def find_project_dotfile(target_dir)
-        find_file_upwards(DOTFILE, target_dir, project_root)
-      end
-      def find_project_root
-        pwd = Dir.pwd
-        gems_file = find_last_file_upwards('Gemfile', pwd) || find_last_file_upwards('gems.rb', pwd)
-        return unless gems_file
-        File.dirname(gems_file)
-      end
-      def find_user_dotfile
-        return unless ENV.key?('HOME')
-        file = File.join(Dir.home, DOTFILE)
-        return file if File.exist?(file)
-      end
-      def find_user_xdg_config
-        xdg_config_home = expand_path(ENV.fetch('XDG_CONFIG_HOME', '~/.config'))
-        xdg_config = File.join(xdg_config_home, 'rubocop', XDG_CONFIG)
-        return xdg_config if File.exist?(xdg_config)
-      end
-      def expand_path(path)
-        File.expand_path(path)
-      rescue ArgumentError
-        # Could happen because HOME or ID could not be determined. Fall back on
-        # using the path literally in that case.
-        path
-      end
-      def resolver
-        @resolver ||= ConfigLoaderResolver.new
-      end
-      def check_duplication(yaml_code, absolute_path)
-        smart_path = PathUtil.smart_path(absolute_path)
-        YAMLDuplicationChecker.check(yaml_code, absolute_path) do |key1, key2|
-          value = key1.value
-          # .start_line is only available since ruby 2.5 / psych 3.0
-          message = if key1.respond_to? :start_line
-                      line1 = key1.start_line + 1
-                      line2 = key2.start_line + 1
-                      "#{smart_path}:#{line1}: " \
-                      "`#{value}` is concealed by line #{line2}"
-                    else
-                      "#{smart_path}: `#{value}` is concealed by duplicate"
-                    end
-          warn Rainbow(message).yellow
-        end
-      end
-      # Read the specified file, or exit with a friendly, concise message on
-      # stderr. Care is taken to use the standard OS exit code for a "file not
-      # found" error.
-      def read_file(absolute_path)
-        File.read(absolute_path, encoding: Encoding::UTF_8)
-      rescue Errno::ENOENT
-        raise ConfigNotFoundError, "Configuration file not found: #{absolute_path}"
-      end
-      def yaml_safe_load(yaml_code, filename)
-        yaml_safe_load!(yaml_code, filename)
-      rescue ::StandardError
-        if defined?(::SafeYAML)
-          raise 'SafeYAML is unmaintained, no longer needed and should be removed'
-        end
-        raise
-      end
-      if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0')
-        def yaml_safe_load!(yaml_code, filename)
-          YAML.safe_load(yaml_code,
-                         permitted_classes: [Regexp, Symbol],
-                         permitted_symbols: [],
-                         aliases: true,
-                         filename: filename)
-        end
-      else # Ruby < 2.6
-        def yaml_safe_load!(yaml_code, filename)
-          YAML.safe_load(yaml_code, [Regexp, Symbol], [], true, filename)
-        end
-      end
-    end
-    # Initializing class ivars
-    clear_options
-  end
-end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/config_loader_resolver.rb DELETED Viewed

@@ -1,266 +0,0 @@
-# frozen_string_literal: true
-require 'yaml'
-require 'pathname'
-module RuboCop
-  # A help class for ConfigLoader that handles configuration resolution.
-  # @api private
-  class ConfigLoaderResolver
-    def resolve_requires(path, hash)
-      config_dir = File.dirname(path)
-      hash.delete('require').tap do |loaded_features|
-        Array(loaded_features).each do |feature|
-          if feature.start_with?('.')
-            require(File.join(config_dir, feature))
-          else
-            require(feature)
-          end
-        end
-      end
-    end
-    def resolve_inheritance(path, hash, file, debug) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      inherited_files = Array(hash['inherit_from'])
-      base_configs(path, inherited_files, file)
-        .reverse.each_with_index do |base_config, index|
-        override_department_setting_for_cops(base_config, hash)
-        override_enabled_for_disabled_departments(base_config, hash)
-        base_config.each do |k, v|
-          next unless v.is_a?(Hash)
-          if hash.key?(k)
-            v = merge(v, hash[k],
-                      cop_name: k, file: file, debug: debug,
-                      inherited_file: inherited_files[index],
-                      inherit_mode: determine_inherit_mode(hash, k))
-          end
-          hash[k] = v
-          fix_include_paths(base_config.loaded_path, hash, path, k, v) if v.key?('Include')
-        end
-      end
-    end
-    # When one .rubocop.yml file inherits from another .rubocop.yml file, the Include paths in the
-    # base configuration are relative to the directory where the base configuration file is. For the
-    # derived configuration, we need to make those paths relative to where the derived configuration
-    # file is.
-    def fix_include_paths(base_config_path, hash, path, key, value)
-      return unless File.basename(base_config_path).start_with?('.rubocop')
-      base_dir = File.dirname(base_config_path)
-      derived_dir = File.dirname(path)
-      hash[key]['Include'] = value['Include'].map do |include_path|
-        PathUtil.relative_path(File.join(base_dir, include_path), derived_dir)
-      end
-    end
-    def resolve_inheritance_from_gems(hash)
-      gems = hash.delete('inherit_gem')
-      (gems || {}).each_pair do |gem_name, config_path|
-        if gem_name == 'rubocop'
-          raise ArgumentError, "can't inherit configuration from the rubocop gem"
-        end
-        hash['inherit_from'] = Array(hash['inherit_from'])
-        Array(config_path).reverse_each do |path|
-          # Put gem configuration first so local configuration overrides it.
-          hash['inherit_from'].unshift gem_config_path(gem_name, path)
-        end
-      end
-    end
-    # Merges the given configuration with the default one. If
-    # AllCops:DisabledByDefault is true, it changes the Enabled params so that
-    # only cops from user configuration are enabled. If
-    # AllCops::EnabledByDefault is true, it changes the Enabled params so that
-    # only cops explicitly disabled in user configuration are disabled.
-    def merge_with_default(config, config_file, unset_nil:)
-      default_configuration = ConfigLoader.default_configuration
-      disabled_by_default = config.for_all_cops['DisabledByDefault']
-      enabled_by_default = config.for_all_cops['EnabledByDefault']
-      if disabled_by_default || enabled_by_default
-        default_configuration = transform(default_configuration) do |params|
-          params.merge('Enabled' => !disabled_by_default)
-        end
-      end
-      config = handle_disabled_by_default(config, default_configuration) if disabled_by_default
-      override_enabled_for_disabled_departments(default_configuration, config)
-      opts = { inherit_mode: config['inherit_mode'] || {}, unset_nil: unset_nil }
-      Config.new(merge(default_configuration, config, **opts), config_file)
-    end
-    # Return a recursive merge of two hashes. That is, a normal hash merge,
-    # with the addition that any value that is a hash, and occurs in both
-    # arguments, will also be merged. And so on.
-    #
-    # rubocop:disable Metrics/AbcSize
-    def merge(base_hash, derived_hash, **opts)
-      result = base_hash.merge(derived_hash)
-      keys_appearing_in_both = base_hash.keys & derived_hash.keys
-      keys_appearing_in_both.each do |key|
-        if opts[:unset_nil] && derived_hash[key].nil?
-          result.delete(key)
-        elsif merge_hashes?(base_hash, derived_hash, key)
-          result[key] = merge(base_hash[key], derived_hash[key], **opts)
-        elsif should_union?(base_hash, key, opts[:inherit_mode])
-          result[key] = base_hash[key] | derived_hash[key]
-        elsif opts[:debug]
-          warn_on_duplicate_setting(base_hash, derived_hash, key, **opts)
-        end
-      end
-      result
-    end
-    # rubocop:enable Metrics/AbcSize
-    # An `Enabled: true` setting in user configuration for a cop overrides an
-    # `Enabled: false` setting for its department.
-    def override_department_setting_for_cops(base_hash, derived_hash)
-      derived_hash.each_key do |key|
-        next unless key =~ %r{(.*)/.*}
-        department = Regexp.last_match(1)
-        next unless disabled?(derived_hash, department) || disabled?(base_hash, department)
-        # The `override_department` setting for the `Enabled` parameter is an
-        # internal setting that's not documented in the manual. It will cause a
-        # cop to be enabled later, when logic surrounding enabled/disabled it
-        # run, even though its department is disabled.
-        derived_hash[key]['Enabled'] = 'override_department' if derived_hash[key]['Enabled']
-      end
-    end
-    # If a cop was previously explicitly enabled, but then superseded by the
-    # department being disabled, disable it.
-    def override_enabled_for_disabled_departments(base_hash, derived_hash)
-      cops_to_disable = derived_hash.each_key.with_object([]) do |key, cops|
-        next unless disabled?(derived_hash, key)
-        cops.concat(base_hash.keys.grep(Regexp.new("^#{key}/")))
-      end
-      cops_to_disable.each do |cop_name|
-        next unless base_hash.dig(cop_name, 'Enabled') == true
-        derived_hash.replace(merge({ cop_name => { 'Enabled' => false } }, derived_hash))
-      end
-    end
-    private
-    def disabled?(hash, department)
-      hash[department].is_a?(Hash) && hash[department]['Enabled'] == false
-    end
-    def duplicate_setting?(base_hash, derived_hash, key, inherited_file)
-      return false if inherited_file.nil? # Not inheritance resolving merge
-      return false if inherited_file.start_with?('..') # Legitimate override
-      return false if base_hash[key] == derived_hash[key] # Same value
-      return false if remote_file?(inherited_file) # Can't change
-      Gem.path.none? { |dir| inherited_file.start_with?(dir) } # Can change?
-    end
-    def warn_on_duplicate_setting(base_hash, derived_hash, key, **opts)
-      return unless duplicate_setting?(base_hash, derived_hash, key, opts[:inherited_file])
-      inherit_mode = opts[:inherit_mode]['merge'] || opts[:inherit_mode]['override']
-      return if base_hash[key].is_a?(Array) && inherit_mode && inherit_mode.include?(key)
-      puts "#{PathUtil.smart_path(opts[:file])}: " \
-           "#{opts[:cop_name]}:#{key} overrides " \
-           "the same parameter in #{opts[:inherited_file]}"
-    end
-    def determine_inherit_mode(hash, key)
-      cop_cfg = hash[key]
-      local_inherit = cop_cfg.delete('inherit_mode') if cop_cfg.is_a?(Hash)
-      local_inherit || hash['inherit_mode'] || {}
-    end
-    def should_union?(base_hash, key, inherit_mode)
-      base_hash[key].is_a?(Array) &&
-        inherit_mode &&
-        inherit_mode['merge'] &&
-        inherit_mode['merge'].include?(key)
-    end
-    def merge_hashes?(base_hash, derived_hash, key)
-      base_hash[key].is_a?(Hash) && derived_hash[key].is_a?(Hash)
-    end
-    def base_configs(path, inherit_from, file)
-      configs = Array(inherit_from).compact.map do |f|
-        ConfigLoader.load_file(inherited_file(path, f, file))
-      end
-      configs.compact
-    end
-    def inherited_file(path, inherit_from, file)
-      if remote_file?(inherit_from)
-        # A remote configuration, e.g. `inherit_from: http://example.com/rubocop.yml`.
-        RemoteConfig.new(inherit_from, File.dirname(path))
-      elsif Pathname.new(inherit_from).absolute?
-        # An absolute path to a config, e.g. `inherit_from: /Users/me/rubocop.yml`.
-        # The path may come from `inherit_gem` option, where a gem name is expanded
-        # to an absolute path to that gem.
-        print 'Inheriting ' if ConfigLoader.debug?
-        inherit_from
-      elsif file.is_a?(RemoteConfig)
-        # A path relative to a URL, e.g. `inherit_from: configs/default.yml`
-        # in a config included with `inherit_from: http://example.com/rubocop.yml`
-        file.inherit_from_remote(inherit_from, path)
-      else
-        # A local relative path, e.g. `inherit_from: default.yml`
-        print 'Inheriting ' if ConfigLoader.debug?
-        File.expand_path(inherit_from, File.dirname(path))
-      end
-    end
-    def remote_file?(uri)
-      regex = URI::DEFAULT_PARSER.make_regexp(%w[http https])
-      /\A#{regex}\z/.match?(uri)
-    end
-    def handle_disabled_by_default(config, new_default_configuration)
-      department_config = config.to_hash.reject { |cop| cop.include?('/') }
-      department_config.each do |dept, dept_params|
-        next unless dept_params['Enabled']
-        new_default_configuration.each do |cop, params|
-          next unless cop.start_with?("#{dept}/")
-          # Retain original default configuration for cops in the department.
-          params['Enabled'] = ConfigLoader.default_configuration[cop]['Enabled']
-        end
-      end
-      transform(config) do |params|
-        { 'Enabled' => true }.merge(params) # Set true if not set.
-      end
-    end
-    def transform(config, &block)
-      config.transform_values(&block)
-    end
-    def gem_config_path(gem_name, relative_config_path)
-      if defined?(Bundler)
-        gem = Bundler.load.specs[gem_name].first
-        gem_path = gem.full_gem_path if gem
-      end
-      gem_path ||= Gem::Specification.find_by_name(gem_name).gem_dir
-      File.join(gem_path, relative_config_path)
-    rescue Gem::LoadError => e
-      raise Gem::LoadError, "Unable to find gem #{gem_name}; is the gem installed? #{e}"
-    end
-  end
-end