mx-platform-ruby 0.4.0 → 0.4.1

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/config_loader.rb

@@ -1,214 +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'.freeze
-    RUBOCOP_HOME = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
-    DEFAULT_FILE = File.join(RUBOCOP_HOME, 'config', 'default.yml')
-    AUTO_GENERATED_FILE = '.rubocop_todo.yml'.freeze
-
-    class << self
-      include FileFinder
-
-      attr_accessor :debug, :auto_gen_config, :ignore_parent_exclusion,
-                    :options_config
-      attr_writer :default_configuration
-
-      alias debug? debug
-      alias auto_gen_config? auto_gen_config
-      alias ignore_parent_exclusion? ignore_parent_exclusion
-
-      def clear_options
-        @debug = @auto_gen_config = @options_config = nil
-        FileFinder.root_level = nil
-      end
-
-      def load_file(file)
-        path = File.absolute_path(file.is_a?(RemoteConfig) ? file.file : file)
-
-        hash = load_yaml_configuration(path)
-
-        # Resolve requires first in case they define additional cops
-        resolver.resolve_requires(path, hash)
-
-        add_missing_namespaces(path, hash)
-
-        resolver.resolve_inheritance_from_gems(hash, hash.delete('inherit_gem'))
-        resolver.resolve_inheritance(path, hash, file, debug?)
-
-        hash.delete('inherit_from')
-
-        Config.create(hash, path)
-      end
-
-      def add_missing_namespaces(path, hash)
-        hash.keys.each do |key|
-          q = Cop::Cop.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_file_upwards(DOTFILE, target_dir, use_home: true) || DEFAULT_FILE
-      end
-
-      def configuration_from_file(config_file)
-        config = load_file(config_file)
-        return config if config_file == DEFAULT_FILE
-
-        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)
-      end
-
-      def add_excludes_from_files(config, config_file)
-        found_files = find_files_upwards(DOTFILE, config_file, use_home: true)
-        return if found_files.empty?
-        return if PathUtil.relative_path(found_files.last) ==
-                  PathUtil.relative_path(config_file)
-
-        print 'AllCops/Exclude ' if debug?
-        config.add_excludes_from_higher_level(load_file(found_files.last))
-      end
-
-      def default_configuration
-        @default_configuration ||= begin
-                                     print 'Default ' if debug?
-                                     load_file(DEFAULT_FILE)
-                                   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)
-        resolver.merge_with_default(config, config_file)
-      end
-
-      def add_inheritance_from_auto_generated_file
-        file_string = " #{AUTO_GENERATED_FILE}"
-
-        config_file = options_config || DOTFILE
-
-        if File.exist?(config_file)
-          files = Array(load_yaml_configuration(config_file)['inherit_from'])
-
-          return if files.include?(AUTO_GENERATED_FILE)
-
-          files.unshift(AUTO_GENERATED_FILE)
-          file_string = "\n  - " + files.join("\n  - ") if files.size > 1
-          rubocop_yml_contents = existing_configuration(config_file)
-        end
-
-        write_config_file(config_file, file_string, rubocop_yml_contents)
-
-        puts "Added inheritance from `#{AUTO_GENERATED_FILE}` in `#{DOTFILE}`."
-      end
-
-      private
-
-      def existing_configuration(config_file)
-        IO.read(config_file, encoding: Encoding::UTF_8)
-          .sub(%r{^inherit_from: *[.\/\w]+}, '')
-          .sub(%r{^inherit_from: *(\n *- *[.\/\w]+)+}, '')
-      end
-
-      def write_config_file(file_name, file_string, rubocop_yml_contents)
-        File.open(file_name, 'w') do |f|
-          f.write "inherit_from:#{file_string}\n"
-          f.write "\n#{rubocop_yml_contents}" if rubocop_yml_contents =~ /\S/
-        end
-      end
-
-      def resolver
-        @resolver ||= ConfigLoaderResolver.new
-      end
-
-      def load_yaml_configuration(absolute_path)
-        yaml_code = read_file(absolute_path)
-        check_duplication(yaml_code, absolute_path)
-        hash = yaml_safe_load(yaml_code, absolute_path) || {}
-
-        puts "configuration from #{absolute_path}" if debug?
-
-        unless hash.is_a?(Hash)
-          raise(TypeError, "Malformed configuration in #{absolute_path}")
-        end
-
-        hash
-      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
-          line1 = key1.start_line + 1
-          line2 = key2.start_line + 1
-          message = "#{smart_path}:#{line1}: " \
-                    "`#{value}` is concealed by line #{line2}"
-          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)
-        IO.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)
-        if defined?(SafeYAML) && SafeYAML.respond_to?(:load)
-          SafeYAML.load(yaml_code, filename,
-                        whitelisted_tags: %w[!ruby/regexp])
-        else
-          YAML.safe_load(
-            yaml_code,
-            permitted_classes: [Regexp, Symbol],
-            permitted_symbols: [],
-            aliases: false,
-            filename: filename
-          )
-        end
-      end
-    end
-
-    # Initializing class ivars
-    clear_options
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/config_loader_resolver.rb

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'pathname'
-
-module RuboCop
-  # A help class for ConfigLoader that handles configuration resolution.
-  class ConfigLoaderResolver
-    def resolve_requires(path, hash)
-      config_dir = File.dirname(path)
-      Array(hash.delete('require')).each do |r|
-        if r.start_with?('.')
-          require(File.join(config_dir, r))
-        else
-          require(r)
-        end
-      end
-    end
-
-    def resolve_inheritance(path, hash, file, debug)
-      inherited_files = Array(hash['inherit_from'])
-      base_configs(path, inherited_files, file)
-        .reverse.each_with_index do |base_config, index|
-        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
-        end
-      end
-    end
-
-    def resolve_inheritance_from_gems(hash, gems)
-      (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)
-      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
-
-      if disabled_by_default
-        config = handle_disabled_by_default(config, default_configuration)
-      end
-
-      Config.new(merge(default_configuration, config,
-                       inherit_mode: config['inherit_mode'] || {}),
-                 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 base_hash[key].is_a?(Hash)
-          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
-
-    private
-
-    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 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)
-        RemoteConfig.new(inherit_from, File.dirname(path))
-      elsif file.is_a?(RemoteConfig)
-        file.inherit_from_remote(inherit_from, path)
-      else
-        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])
-      uri =~ /\A#{regex}\z/
-    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|
-        # Rails is always disabled by default and the department's Enabled flag
-        # works like the --rails command line option, which is that when
-        # AllCops:DisabledByDefault is true, each Rails cop must still be
-        # explicitly mentioned in user configuration in order to be enabled.
-        next if dept == 'Rails'
-
-        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)
-      Hash[config.map { |cop, params| [cop, yield(params)] }]
-    end
-
-    def gem_config_path(gem_name, relative_config_path)
-      spec = Gem::Specification.find_by_name(gem_name)
-      File.join(spec.gem_dir, relative_config_path)
-    rescue Gem::LoadError => e
-      raise Gem::LoadError,
-            "Unable to find gem #{gem_name}; is the gem installed? #{e}"
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/config_store.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  # Handles caching of configurations and association of inspected
-  # ruby files to configurations.
-  class ConfigStore
-    def initialize
-      # @options_config stores a config that is specified in the command line.
-      # This takes precedence over configs located in any directories
-      @options_config = nil
-
-      # @path_cache maps directories to configuration paths. We search
-      # for .rubocop.yml only if we haven't already found it for the
-      # given directory.
-      @path_cache = {}
-
-      # @object_cache maps configuration file paths to
-      # configuration objects so we only need to load them once.
-      @object_cache = {}
-    end
-
-    def options_config=(options_config)
-      loaded_config = ConfigLoader.load_file(options_config)
-      @options_config = ConfigLoader.merge_with_default(loaded_config,
-                                                        options_config)
-    end
-
-    def force_default_config!
-      @options_config = ConfigLoader.default_configuration
-    end
-
-    def for(file_or_dir)
-      return @options_config if @options_config
-
-      dir = if File.directory?(file_or_dir)
-              file_or_dir
-            else
-              File.dirname(file_or_dir)
-            end
-      @path_cache[dir] ||= ConfigLoader.configuration_file_for(dir)
-      path = @path_cache[dir]
-      @object_cache[path] ||= begin
-                                print "For #{dir}: " if ConfigLoader.debug?
-                                ConfigLoader.configuration_from_file(path)
-                              end
-    end
-  end
-end