Class: RuboCop::Cop::Base

Inherits:

Object

Object
RuboCop::Cop::Base

show all

Extended by:: NodePattern::Macros, AST::Sexp, ExcludeLimit

Includes:: AST::Sexp, AutocorrectLogic, IgnoredNode, Util

Defined in:: lib/rubocop/cop/base.rb

Overview

A scaffold for concrete cops.

The Cop::Base class is meant to be extended.

Cops track offenses and can autocorrect them on the fly.

A commissioner object is responsible for traversing the AST and invoking the specific callbacks on each cop.

First the callback on_new_investigation is called; if a cop needs to do its own processing of the AST or depends on something else.

Then callbacks like on_def, on_send (see AST::Traversal) are called with their respective nodes.

Finally the callback on_investigation_end is called.

Within these callbacks, cops are meant to call add_offense or add_global_offense. Use the processed_source method to get the currently processed source being investigated.

In case of invalid syntax / unparsable content, the callback on_other_file is called instead of all the other on_... callbacks.

Private methods are not meant for custom cops consumption, nor are any instance variables.

Direct Known Subclasses

Defined Under Namespace

Classes: InvestigationReport

Constant Summary collapse

RESTRICT_ON_SEND = List of methods names to restrict calls for on_send / on_csend

Set[].freeze

DEPARTMENT_SEVERITIES = Departments whose cops report above convention unless a cop says otherwise. The exceptions live in config/default.yml as an explicit Severity, such as the lint-like cops in Bundler and Gemspec.

{ Lint: :warning, Security: :warning, Metrics: :refactor }.freeze

Class Attribute Summary collapse

.gem_requirements ⇒ Object readonly
Returns the value of attribute gem_requirements.

Instance Attribute Summary collapse

#config ⇒ Object readonly
Returns the value of attribute config.
#processed_source ⇒ Object readonly
Returns the value of attribute processed_source.
#project_index ⇒ Object
Returns the value of attribute project_index.

Class Method Summary collapse

.autocorrect_incompatible_with ⇒ Array<RuboCop::Cop::Base>
List of cops that should not try to autocorrect at the same time as this cop.
.badge ⇒ Object
Naming.
.callbacks_needed ⇒ Object private
.cop_name ⇒ Object
.department ⇒ Object
.documentation_url(config = nil) ⇒ String^?
Returns a url to view this cops documentation online.
.exclude_from_registry ⇒ Object
Call for abstract Cop classes.
.inherited(subclass) ⇒ Object
.joining_forces ⇒ Object
Override and return the Force class(es) you need to join.
.lint? ⇒ Boolean
.match?(given_names) ⇒ Boolean
Returns true if the cop name or the cop namespace matches any of the given names.
.requires_gem(gem_name, *version_requirements) ⇒ Object
Register a version requirement for the given gem name.
.support_autocorrect? ⇒ Boolean
Returns if class supports autocorrect.
.support_multiple_source? ⇒ Boolean
Override if your cop should be called repeatedly for multiple investigations Between calls to on_new_investigation and on_investigation_end, the result of processed_source will remain constant.

Instance Method Summary collapse

#active_support_extensions_enabled? ⇒ Boolean
#add_global_offense(message = nil, severity: nil) ⇒ Object
Adds an offense that has no particular location.
#add_offense(node_or_range, message: nil, severity: nil, &block) ⇒ Object
Adds an offense on the specified range (or node with an expression) Unless that offense is disabled for this range, a corrector will be yielded to provide the cop the opportunity to autocorrect the offense.
#always_autocorrect? ⇒ Boolean private
#begin_investigation(processed_source, offset: 0, original: processed_source) ⇒ Object private
Called before any investigation.
#callbacks_needed ⇒ Object private
rubocop:disable Layout/ClassStructure -- grouped under the Commissioner heading above.
#config_to_allow_offenses ⇒ Object
#config_to_allow_offenses=(hash) ⇒ Object
#contextual_autocorrect? ⇒ Boolean private
#cop_config ⇒ Object
Configuration Helpers.
#cop_name ⇒ Object (also: #name)
#excluded_file?(file) ⇒ Boolean
#external_dependency_checksum ⇒ Object
This method should be overridden when a cop's behavior depends on state that lives outside of these locations:.
#initialize(config = nil, options = nil) ⇒ Base constructor
A new instance of Base.
#inspect ⇒ Object
:nodoc:.
#message(_range = nil) ⇒ Object
Gets called if no message is specified when calling add_offense or add_global_offense Cops are discouraged to override this; instead pass your message directly.
#offenses ⇒ Object deprecated Deprecated.
Make potential errors with previous API more obvious
#on_investigation_end ⇒ Object
Called after all on_...
#on_new_investigation ⇒ Object
Called before all on_...
#on_other_file ⇒ Object
Called instead of all on_...
#parse(source, path = nil) ⇒ Object
There should be very limited reasons for a Cop to do it's own parsing.
#parser_engine ⇒ Object
#preview? ⇒ Boolean
Whether the user opted in to unstable behavior, with --preview or AllCops: Preview.
#ready ⇒ Object private
Called between investigations.
#relevant_file?(file) ⇒ Boolean
#string_literals_frozen_by_default? ⇒ Boolean
#target_gem_version(gem_name) ⇒ Object
Returns a gems locked versions (i.e. from Gemfile.lock or gems.locked).
#target_rails_version ⇒ Object
#target_ruby_version ⇒ Object

Constructor Details

#initialize(config = nil, options = nil) ⇒ `Base`

Returns a new instance of Base.

# File 'lib/rubocop/cop/base.rb', line 164

def initialize(config = nil, options = nil)
  @config = config || Config.new
  @options = options || { debug: false }
  reset_investigation
end

Class Attribute Details

.gem_requirements ⇒ `Object` (readonly)

Returns the value of attribute gem_requirements.



146
147
148

# File 'lib/rubocop/cop/base.rb', line 146

def gem_requirements
  @gem_requirements
end

Instance Attribute Details

#config ⇒ `Object` (readonly)

Returns the value of attribute config.



43
44
45

# File 'lib/rubocop/cop/base.rb', line 43

def config
  @config
end

#processed_source ⇒ `Object` (readonly)

Returns the value of attribute processed_source.



43
44
45

# File 'lib/rubocop/cop/base.rb', line 43

def processed_source
  @processed_source
end

#project_index ⇒ `Object`

Returns the value of attribute project_index.



44
45
46

# File 'lib/rubocop/cop/base.rb', line 44

def project_index
  @project_index
end

Class Method Details

.autocorrect_incompatible_with ⇒ `Array<RuboCop::Cop::Base>`

List of cops that should not try to autocorrect at the same time as this cop

Returns:

(Array<RuboCop::Cop::Base>)



65
66
67

# File 'lib/rubocop/cop/base.rb', line 65

def self.autocorrect_incompatible_with
  []
end

.badge ⇒ `Object`

Naming



99
100
101

# File 'lib/rubocop/cop/base.rb', line 99

def self.badge
  @badge ||= Badge.for(name)
end

.callbacks_needed ⇒ `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.

# File 'lib/rubocop/cop/base.rb', line 348

def self.callbacks_needed
  @callbacks_needed ||= public_instance_methods.select do |m|
    # OPTIMIZE: `start_with?` with two string arguments instead of a regex
    # is faster in this specific case.
    m.start_with?('on_', 'after_') &&
      # exclude standard "callbacks" like 'on_new_investigation' unless refined
      instance_method(m).owner != Base
  end
end

.cop_name ⇒ `Object`



103
104
105

# File 'lib/rubocop/cop/base.rb', line 103

def self.cop_name
  badge.to_s
end

.department ⇒ `Object`



107
108
109

# File 'lib/rubocop/cop/base.rb', line 107

def self.department
  badge.department
end

.documentation_url(config = nil) ⇒ `String`^?

Returns a url to view this cops documentation online. Requires 'DocumentationBaseURL' to be set for your department. Will follow the convention of RuboCops own documentation structure, overwrite this method to accommodate your custom layout.

Returns:

(String, nil)



76
77
78

# File 'lib/rubocop/cop/base.rb', line 76

def self.documentation_url(config = nil)
  Documentation.url_for(self, config)
end

.exclude_from_registry ⇒ `Object`

Call for abstract Cop classes



87
88
89

# File 'lib/rubocop/cop/base.rb', line 87

def self.exclude_from_registry
  Registry.global.dismiss(self)
end

.inherited(subclass) ⇒ `Object`

# File 'lib/rubocop/cop/base.rb', line 80

def self.inherited(subclass)
  super
  subclass.instance_variable_set(:@gem_requirements, gem_requirements.dup)
  Registry.global.enlist(subclass)
end

.joining_forces ⇒ `Object`

Override and return the Force class(es) you need to join

124	# File 'lib/rubocop/cop/base.rb', line 124 def self.joining_forces; end

.lint? ⇒ `Boolean`

Returns:

(Boolean)



111
112
113

# File 'lib/rubocop/cop/base.rb', line 111

def self.lint?
  department == :Lint
end

.match?(given_names) ⇒ `Boolean`

Returns true if the cop name or the cop namespace matches any of the given names.

Returns:

(Boolean)

# File 'lib/rubocop/cop/base.rb', line 117

def self.match?(given_names)
  return false unless given_names

  given_names.include?(cop_name) || given_names.include?(badge.department_name)
end

.requires_gem(gem_name, *version_requirements) ⇒ `Object`

Register a version requirement for the given gem name. This cop will be skipped unless the target satisfies all requirements.

Parameters:

gem_name (String)
version_requirements (Array<String>) —
The version requirements, using the same syntax as a Gemfile, e.g. ">= 1.2.3"

If omitted, any version of the gem will be accepted.

https://guides.rubygems.org/patterns/#declaring-dependencies



159
160
161

# File 'lib/rubocop/cop/base.rb', line 159

def requires_gem(gem_name, *version_requirements)
  @gem_requirements[gem_name] = Gem::Requirement.new(version_requirements)
end

.support_autocorrect? ⇒ `Boolean`

Returns if class supports autocorrect. It is recommended to extend AutoCorrector instead of overriding

Returns:

(Boolean)



93
94
95

# File 'lib/rubocop/cop/base.rb', line 93

def self.support_autocorrect?
  false
end

.support_multiple_source? ⇒ `Boolean`

Override if your cop should be called repeatedly for multiple investigations Between calls to on_new_investigation and on_investigation_end, the result of processed_source will remain constant. You should invalidate any caches that depend on the current processed_source in the on_new_investigation callback. If your cop does autocorrections, be aware that your instance may be called multiple times with the same processed_source.path but different content. Note that under --parallel each worker process has its own cop instances, so state persists only within a worker's share of the files.

Returns:

(Boolean)



137
138
139

# File 'lib/rubocop/cop/base.rb', line 137

def self.support_multiple_source?
  false
end

Instance Method Details

#active_support_extensions_enabled? ⇒ `Boolean`

Returns:

(Boolean)



288
289
290

# File 'lib/rubocop/cop/base.rb', line 288

def active_support_extensions_enabled?
  @config.active_support_extensions_enabled?
end

#add_global_offense(message = nil, severity: nil) ⇒ `Object`

Adds an offense that has no particular location. No correction can be applied to global offenses

# File 'lib/rubocop/cop/base.rb', line 197

def add_global_offense(message = nil, severity: nil)
  severity = find_severity(nil, severity)
  message = find_message(nil, message)
  range = Offense::NO_LOCATION
  status = enabled_line?(range.line) ? :unsupported : :disabled
  current_offenses << Offense.new(severity, range, message, name, status)
end

#add_offense(node_or_range, message: nil, severity: nil, &block) ⇒ `Object`

Adds an offense on the specified range (or node with an expression) Unless that offense is disabled for this range, a corrector will be yielded to provide the cop the opportunity to autocorrect the offense. If message is not specified, the method message will be called.

# File 'lib/rubocop/cop/base.rb', line 209

def add_offense(node_or_range, message: nil, severity: nil, &block)
  range = range_from_node_or_range(node_or_range)
  return unless current_offense_locations.add?(range)

  range_to_pass = callback_argument(range)

  severity = find_severity(range_to_pass, severity)
  message = find_message(range_to_pass, message)

  status, corrector = enabled_lines?(range) ? correct(range, &block) : :disabled
  justification = suppression_reason(range) if status == :disabled

  # Since this range may be generated from Ruby code embedded in some
  # template file, we convert it to location info in the original file.
  range = range_for_original(range)

  current_offenses << Offense.new(severity, range, message, name, status, corrector,
                                  justification: justification)
end

#always_autocorrect? ⇒ `Boolean`

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:

(Boolean)

# File 'lib/rubocop/cop/base.rb', line 375

def always_autocorrect?
  # `true` is the same as `'always'` for backward compatibility.
  ['always', true].include?(cop_config.fetch('AutoCorrect', 'always'))
end

#begin_investigation(processed_source, offset: 0, original: processed_source) ⇒ `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.

Called before any investigation

# File 'lib/rubocop/cop/base.rb', line 361

def begin_investigation(processed_source, offset: 0, original: processed_source)
  @current_offenses = nil
  @current_offense_locations = nil
  @currently_disabled_lines = nil
  @processed_source = processed_source
  @current_corrector = nil

  # We need to keep track of the original source and offset,
  # because `processed_source` here may be an embedded code in it.
  @current_offset = offset
  @current_original = original
end

#callbacks_needed ⇒ `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 Layout/ClassStructure -- grouped under the Commissioner heading above



343
344
345

# File 'lib/rubocop/cop/base.rb', line 343

def callbacks_needed
  self.class.callbacks_needed
end

#config_to_allow_offenses ⇒ `Object`



262
263
264

# File 'lib/rubocop/cop/base.rb', line 262

def config_to_allow_offenses
  Formatter::DisabledConfigFormatter.config_to_allow_offenses[cop_name] ||= {}
end

#config_to_allow_offenses=(hash) ⇒ `Object`



266
267
268

# File 'lib/rubocop/cop/base.rb', line 266

def config_to_allow_offenses=(hash)
  Formatter::DisabledConfigFormatter.config_to_allow_offenses[cop_name] = hash
end

#contextual_autocorrect? ⇒ `Boolean`

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:

(Boolean)



381
382
383

# File 'lib/rubocop/cop/base.rb', line 381

def contextual_autocorrect?
  cop_config.fetch('AutoCorrect', 'always') == 'contextual'
end

#cop_config ⇒ `Object`

Configuration Helpers

# File 'lib/rubocop/cop/base.rb', line 256

def cop_config
  # Use department configuration as basis, but let individual cop
  # configuration override.
  @cop_config ||= @config.for_badge(self.class.badge)
end

#cop_name ⇒ `Object` Also known as: name



248
249
250

# File 'lib/rubocop/cop/base.rb', line 248

def cop_name
  @cop_name ||= self.class.cop_name
end

#excluded_file?(file) ⇒ `Boolean`

Returns:

(Boolean)



312
313
314

# File 'lib/rubocop/cop/base.rb', line 312

def excluded_file?(file)
  !relevant_file?(file)
end

#external_dependency_checksum ⇒ `Object`

This method should be overridden when a cop's behavior depends on state that lives outside of these locations:

(1) the file under inspection
(2) the cop's source code
(3) the config (eg a .rubocop.yml file)

For example, some cops may want to look at other parts of the codebase being inspected to find violations. A cop may use the presence or absence of file foo.rb to determine whether a certain violation exists in bar.rb.

Overriding this method allows the cop to indicate to RuboCop's ResultCache system when those external dependencies change, ie when the ResultCache should be invalidated.



244
245
246

# File 'lib/rubocop/cop/base.rb', line 244

def external_dependency_checksum
  nil
end

#inspect ⇒ `Object`

:nodoc:



385
386
387

# File 'lib/rubocop/cop/base.rb', line 385

def inspect # :nodoc:
  "#<#{self.class.name}:#{object_id} @config=#{@config} @options=#{@options}>"
end

#message(_range = nil) ⇒ `Object`

Gets called if no message is specified when calling add_offense or add_global_offense Cops are discouraged to override this; instead pass your message directly



191
192
193

# File 'lib/rubocop/cop/base.rb', line 191

def message(_range = nil)
  self.class::MSG
end

#offenses ⇒ `Object`

Deprecated.

Make potential errors with previous API more obvious

# File 'lib/rubocop/cop/base.rb', line 334

def offenses
  raise 'The offenses are not directly available; ' \
        'they are returned as the result of the investigation'
end

#on_investigation_end ⇒ `Object`

Called after all on_... have been called When refining this method, always call super



178
179
180

# File 'lib/rubocop/cop/base.rb', line 178

def on_investigation_end
  # Typically do nothing here
end

#on_new_investigation ⇒ `Object`

Called before all on_... have been called When refining this method, always call super



172
173
174

# File 'lib/rubocop/cop/base.rb', line 172

def on_new_investigation
  # Typically do nothing here
end

#on_other_file ⇒ `Object`

Called instead of all on_... callbacks for unrecognized files / syntax errors When refining this method, always call super



184
185
186

# File 'lib/rubocop/cop/base.rb', line 184

def on_other_file
  # Typically do nothing here
end

#parse(source, path = nil) ⇒ `Object`

There should be very limited reasons for a Cop to do it's own parsing



317
318
319

# File 'lib/rubocop/cop/base.rb', line 317

def parse(source, path = nil)
  ProcessedSource.new(source, target_ruby_version, path, parser_engine: parser_engine)
end

#parser_engine ⇒ `Object`



280
281
282

# File 'lib/rubocop/cop/base.rb', line 280

def parser_engine
  @config.parser_engine
end

#preview? ⇒ `Boolean`

Whether the user opted in to unstable behavior, with --preview or AllCops: Preview. Cops branch on this to ship a change that is not ready to be the default yet.

Returns:

(Boolean)



299
300
301

# File 'lib/rubocop/cop/base.rb', line 299

def preview?
  @config.preview?(@options)
end

#ready ⇒ `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.

Called between investigations

# File 'lib/rubocop/cop/base.rb', line 323

def ready
  return self if self.class.support_multiple_source?

  self.class.new(@config, @options).tap do |fresh|
    fresh.project_index = @project_index
  end
end

#relevant_file?(file) ⇒ `Boolean`

Returns:

(Boolean)

# File 'lib/rubocop/cop/base.rb', line 303

def relevant_file?(file)
  return false unless target_satisfies_all_gem_version_requirements?
  return true unless @config.clusivity_config_for_badge?(self.class.badge)

  file == RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME ||
    (file_name_matches_any?(file, 'Include', true) &&
      !file_name_matches_any?(file, 'Exclude', false))
end

#string_literals_frozen_by_default? ⇒ `Boolean`

Returns:

(Boolean)



292
293
294

# File 'lib/rubocop/cop/base.rb', line 292

def string_literals_frozen_by_default?
  @config.string_literals_frozen_by_default?
end

#target_gem_version(gem_name) ⇒ `Object`

Returns a gems locked versions (i.e. from Gemfile.lock or gems.locked)



276
277
278

# File 'lib/rubocop/cop/base.rb', line 276

def target_gem_version(gem_name)
  @config.gem_versions_in_target && @config.gem_versions_in_target[gem_name]
end

#target_rails_version ⇒ `Object`



284
285
286

# File 'lib/rubocop/cop/base.rb', line 284

def target_rails_version
  @config.target_rails_version
end

#target_ruby_version ⇒ `Object`



270
271
272

# File 'lib/rubocop/cop/base.rb', line 270

def target_ruby_version
  @config.target_ruby_version
end

Class: RuboCop::Cop::Base

Overview

Direct Known Subclasses

Defined Under Namespace

Constant Summary collapse

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from ExcludeLimit

Methods included from AutocorrectLogic

Methods included from IgnoredNode

Methods included from Util

Constructor Details

#initialize(config = nil, options = nil) ⇒ Base

Class Attribute Details

.gem_requirements ⇒ Object (readonly)

Instance Attribute Details

#config ⇒ Object (readonly)

#processed_source ⇒ Object (readonly)

#project_index ⇒ Object

Class Method Details

.autocorrect_incompatible_with ⇒ Array<RuboCop::Cop::Base>

.badge ⇒ Object

.callbacks_needed ⇒ Object

.cop_name ⇒ Object

.department ⇒ Object

.documentation_url(config = nil) ⇒ String?

.exclude_from_registry ⇒ Object

.inherited(subclass) ⇒ Object

.joining_forces ⇒ Object

.lint? ⇒ Boolean

.match?(given_names) ⇒ Boolean

.requires_gem(gem_name, *version_requirements) ⇒ Object

.support_autocorrect? ⇒ Boolean

.support_multiple_source? ⇒ Boolean

Instance Method Details

#active_support_extensions_enabled? ⇒ Boolean

#add_global_offense(message = nil, severity: nil) ⇒ Object

#add_offense(node_or_range, message: nil, severity: nil, &block) ⇒ Object

#always_autocorrect? ⇒ Boolean

#begin_investigation(processed_source, offset: 0, original: processed_source) ⇒ Object

#callbacks_needed ⇒ Object

#config_to_allow_offenses ⇒ Object

#config_to_allow_offenses=(hash) ⇒ Object

#contextual_autocorrect? ⇒ Boolean

#cop_config ⇒ Object

#cop_name ⇒ Object Also known as: name

#excluded_file?(file) ⇒ Boolean

#external_dependency_checksum ⇒ Object

#inspect ⇒ Object

#message(_range = nil) ⇒ Object

#offenses ⇒ Object

#on_investigation_end ⇒ Object

#on_new_investigation ⇒ Object

#on_other_file ⇒ Object

#parse(source, path = nil) ⇒ Object

#parser_engine ⇒ Object

#preview? ⇒ Boolean

#ready ⇒ Object

#relevant_file?(file) ⇒ Boolean

#string_literals_frozen_by_default? ⇒ Boolean

#target_gem_version(gem_name) ⇒ Object

#target_rails_version ⇒ Object

#target_ruby_version ⇒ Object

#initialize(config = nil, options = nil) ⇒ `Base`

.gem_requirements ⇒ `Object` (readonly)

#config ⇒ `Object` (readonly)

#processed_source ⇒ `Object` (readonly)

#project_index ⇒ `Object`

.autocorrect_incompatible_with ⇒ `Array<RuboCop::Cop::Base>`

.badge ⇒ `Object`

.callbacks_needed ⇒ `Object`

.cop_name ⇒ `Object`

.department ⇒ `Object`

.documentation_url(config = nil) ⇒ `String`^?

.exclude_from_registry ⇒ `Object`

.inherited(subclass) ⇒ `Object`

.joining_forces ⇒ `Object`

.lint? ⇒ `Boolean`

.match?(given_names) ⇒ `Boolean`

.requires_gem(gem_name, *version_requirements) ⇒ `Object`

.support_autocorrect? ⇒ `Boolean`

.support_multiple_source? ⇒ `Boolean`

#active_support_extensions_enabled? ⇒ `Boolean`

#add_global_offense(message = nil, severity: nil) ⇒ `Object`

#add_offense(node_or_range, message: nil, severity: nil, &block) ⇒ `Object`

#always_autocorrect? ⇒ `Boolean`

#begin_investigation(processed_source, offset: 0, original: processed_source) ⇒ `Object`

#callbacks_needed ⇒ `Object`

#config_to_allow_offenses ⇒ `Object`

#config_to_allow_offenses=(hash) ⇒ `Object`

#contextual_autocorrect? ⇒ `Boolean`

#cop_config ⇒ `Object`

#cop_name ⇒ `Object` Also known as: name

#excluded_file?(file) ⇒ `Boolean`

#external_dependency_checksum ⇒ `Object`

#inspect ⇒ `Object`

#message(_range = nil) ⇒ `Object`

#offenses ⇒ `Object`

#on_investigation_end ⇒ `Object`

#on_new_investigation ⇒ `Object`

#on_other_file ⇒ `Object`

#parse(source, path = nil) ⇒ `Object`

#parser_engine ⇒ `Object`

#preview? ⇒ `Boolean`

#ready ⇒ `Object`

#relevant_file?(file) ⇒ `Boolean`

#string_literals_frozen_by_default? ⇒ `Boolean`

#target_gem_version(gem_name) ⇒ `Object`

#target_rails_version ⇒ `Object`

#target_ruby_version ⇒ `Object`