Module: RuboCop::Version

Defined in:
lib/rubocop/version.rb

Overview

This module holds the RuboCop version information.

Constant Summary collapse

STRING =
'1.73.1'
MSG =
'%<version>s (using %<parser_version>s, ' \
'rubocop-ast %<rubocop_ast_version>s, ' \
'analyzing as Ruby %<target_ruby_version>s, ' \
'running on %<ruby_engine>s %<ruby_version>s)%<server_mode>s [%<ruby_platform>s]'
CANONICAL_FEATURE_NAMES =
{
  'Rspec' => 'RSpec', 'Graphql' => 'GraphQL', 'Md' => 'Markdown', 'Factory_bot' => 'FactoryBot',
  'Thread_safety' => 'ThreadSafety', 'Rspec_rails' => 'RSpecRails'
}.freeze
EXTENSION_PATH_NAMES =
{
  'rubocop-md' => 'markdown', 'rubocop-factory_bot' => 'factory_bot'
}.freeze

Class Method Summary collapse

Class Method Details

.config_for_pwd(env) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.


114
115
116
117
118
119
120
# File 'lib/rubocop/version.rb', line 114

def self.config_for_pwd(env)
  Util.silence_warnings do
    # Suppress any config issues when loading the config (ie. deprecations,
    # pending cops, etc.).
    env.config_store.unvalidated.for_pwd
  end
end

.document_versionObject

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.


144
145
146
# File 'lib/rubocop/version.rb', line 144

def self.document_version
  STRING.match('\d+\.\d+').to_s
end

.extension_versions(env) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity


67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
# File 'lib/rubocop/version.rb', line 67

def self.extension_versions(env)
  plugins = config_for_pwd(env).loaded_plugins
  plugin_versions = plugins.filter_map do |plugin|
    next if Plugin::BUILTIN_INTERNAL_PLUGINS.key?(plugin.about.name)
    next unless (plugin_name = plugin.about.name)

    "  - #{plugin_name} #{plugin.about.version}"
  end

  # TODO: It needs to be maintained for a while to ensure compatibility with extensions that
  # don't support plugins. It should be removed in future once the old style becomes obsolete.
  features = config_for_pwd(env).loaded_features.sort
  features -= plugins.map { |plugin| plugin.about.name }
  feature_versions = features.filter_map do |loaded_feature|
    next unless (match = loaded_feature.match(/rubocop-(?<feature>.*)/))

    # Get the expected name of the folder containing the extension code.
    # Usually it would be the same as the extension name. but sometimes authors
    # can choose slightly different name for their gems, e.g. rubocop-md instead of
    # rubocop-markdown.
    feature = EXTENSION_PATH_NAMES.fetch(loaded_feature, match[:feature])

    begin
      require "rubocop/#{feature}/version"
    rescue LoadError
      # Not worth mentioning libs that are not installed
    end

    next unless (feature_version = feature_version(feature))

    "  - #{loaded_feature} #{feature_version}"
  end

  plugin_versions + feature_versions
end

.feature_version(feature) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns feature version in one of two ways:

  • Find by RuboCop core version style (e.g. rubocop-performance, rubocop-rspec)

  • Find by ‘bundle gem` version style (e.g. rubocop-rake)


128
129
130
131
132
133
134
135
136
137
138
139
140
141
# File 'lib/rubocop/version.rb', line 128

def self.feature_version(feature)
  capitalized_feature = feature.capitalize
  extension_name = CANONICAL_FEATURE_NAMES.fetch(capitalized_feature, capitalized_feature)

  # Find by RuboCop core version style (e.g. rubocop-performance, rubocop-rspec)
  RuboCop.const_get(extension_name)::Version::STRING
rescue NameError
  begin
    # Find by `bundle gem` version style (e.g. rubocop-rake, rubocop-packaging)
    RuboCop.const_get(extension_name)::VERSION
  rescue NameError
    # noop
  end
end

.parser_versionObject

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.


51
52
53
54
55
56
57
58
59
60
61
62
63
# File 'lib/rubocop/version.rb', line 51

def self.parser_version
  config_path = ConfigFinder.find_config_path(Dir.pwd)
  yaml = Util.silence_warnings do
    ConfigLoader.load_yaml_configuration(config_path)
  end

  if yaml.dig('AllCops', 'ParserEngine') == 'parser_prism'
    require 'prism'
    "Prism #{Prism::VERSION}"
  else
    "Parser #{Parser::VERSION}"
  end
end

.server_modeObject

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.


149
150
151
# File 'lib/rubocop/version.rb', line 149

def self.server_mode
  RuboCop.const_defined?(:Server) && Server.running? ? ' +server' : ''
end

.target_ruby_version(env) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.


105
106
107
108
109
110
111
# File 'lib/rubocop/version.rb', line 105

def self.target_ruby_version(env)
  if env
    config_for_pwd(env).target_ruby_version
  else
    TargetRuby.new(Config.new).version
  end
end

.verbose(env: nil) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.


46
47
48
# File 'lib/rubocop/version.rb', line 46

def self.verbose(env: nil)
  version(debug: true, env: env)
end

.version(debug: false, env: nil) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

NOTE: Marked as private but used by gems like standard.


23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# File 'lib/rubocop/version.rb', line 23

def self.version(debug: false, env: nil)
  if debug
    verbose_version = format(MSG, version: STRING, parser_version: parser_version,
                                  rubocop_ast_version: RuboCop::AST::Version::STRING,
                                  target_ruby_version: target_ruby_version(env),
                                  ruby_engine: RUBY_ENGINE, ruby_version: RUBY_VERSION,
                                  server_mode: server_mode,
                                  ruby_platform: RUBY_PLATFORM)
    return verbose_version unless env

    extension_versions = extension_versions(env)
    return verbose_version if extension_versions.empty?

    <<~VERSIONS
      #{verbose_version}
      #{extension_versions.join("\n")}
    VERSIONS
  else
    STRING
  end
end