Class: ActiveRecordCompose::Model

Inherits:

Object

Object
ActiveRecordCompose::Model

show all

Extended by:: ActiveModel::Attributes::ClassMethods, ActiveModel::Callbacks, ActiveModel::Validations::Callbacks::ClassMethods, ActiveModel::Validations::ClassMethods

Includes:: ActiveModel::Attributes, ActiveModel::Model, ActiveModel::Validations::Callbacks, Attributes, Callbacks, Inspectable, Persistence, TransactionSupport, Validations

Defined in:: lib/active_record_compose/model.rb,
sig/active_record_compose.rbs,
sig/_internal/package_private.rbs

Overview

This is the core class of ActiveRecordCompose.

By defining subclasses of this model, you can use ActiveRecordCompose functionality in your application. It has the basic functionality of ActiveModel::Model and ActiveModel::Attributes, and also provides aggregation of multiple models and atomic updates through transaction control.

Examples:

Example of model registration.

class AccountRegistration < ActiveRecordCompose::Model
  def initialize(account = Account.new, attributes = {})
    @account = account
    @profile = @account.build_profile
    models << account << profile
    super(attributes)
  end

  attribute :register_confirmation, :boolean, default: false
  delegate_attribute :name, :email, to: :account
  delegate_attribute :firstname, :lastname, :age, to: :profile

  validates :register_confirmation, presence: true

  private

  attr_reader :account, :profile
end

Multiple model update once.

registration = AccountRegistration.new
registration.assign_attributes(
  name: "alice-in-wonderland",
  email: "alice@example.com",
  firstname: "Alice",
  lastname: "Smith",
  age: 24,
  register_confirmation: true
)

registration.save!      # Register Account and Profile models at the same time.
Account.count           # => (0 ->) 1
Profile.count           # => (0 ->) 1

Attribute delegation.

account = Account.new
account.name = "foo"

registration = AccountRegistration.new(account)
registration.name         # => "foo" (delegated)
registration.name?        # => true  (delegated attribute method + `?`)

registration.name = "bar" # => updates account.name
account.name              # => "bar"
account.name?             # => true

registration.attributes   # => { "original_attribute" => "qux", "name" => "bar" }

Aggregate errors on invalid.

registration = AccountRegistration.new

registration.name = "alice-in-wonderland"
registration.firstname = "Alice"
registration.age = 18

registration.valid?
#=> false

# The error contents of the objects stored in models are aggregated.
# For example, direct access to errors in Account#email.
registration.errors[:email].to_a  # Account#email
#=> ["can't be blank"]

# Of course, the validation defined for itself is also working.
registration.errors[:register_confirmation].to_a
#=> ["can't be blank"]

registration.errors.to_a
#=> ["Email can't be blank", "Lastname can't be blank", "Register confirmation can't be blank"]

Instance Method Summary collapse

#id ⇒ Object
Returns the ID value.
#initialize(attributes = {}) ⇒ Model constructor
A new instance of Model.
#inspect ⇒ String
#models ⇒ ActiveRecordCompose::ComposedCollection
Returns a collection of model elements to encapsulate.
#override_validation_context ⇒ validation_context
#pretty_print ⇒ void
#save ⇒ Boolean
#save! ⇒ Object
#update ⇒ Boolean
#update! ⇒ Object
#validate_models ⇒ void

Constructor Details

#initialize(attributes = {}) ⇒ `Model`

Returns a new instance of Model.

Parameters:

(Hash[attribute_name, untyped])



92
93
94

# File 'lib/active_record_compose/model.rb', line 92

def initialize(attributes = {})
  super
end

Class Method Details

.after_commit ⇒ `void`

This method returns an undefined value.

Parameters:

(callback[instance])
if: (condition[instance])
unless: (condition[instance])
(Object)

# File 'sig/active_record_compose.rbs', line 75

def self.after_commit: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void

.after_create ⇒ `void`

This method returns an undefined value.

Parameters:

(callback[instance])
if: (condition[instance])
unless: (condition[instance])
(Object)

# File 'sig/active_record_compose.rbs', line 68

def self.after_create: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void

.after_rollback ⇒ `void`

This method returns an undefined value.

Parameters:

(callback[instance])
if: (condition[instance])
unless: (condition[instance])
(Object)

# File 'sig/active_record_compose.rbs', line 76

def self.after_rollback: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void

.after_save ⇒ `void`

This method returns an undefined value.

Parameters:

(callback[instance])
if: (condition[instance])
unless: (condition[instance])
(Object)

64	# File 'sig/active_record_compose.rbs', line 64 def self.after_save: (callback[instance], ?if: condition[instance], ?unless: condition[instance], *untyped) ?{ () [self: instance] -> void } -> void

.after_update ⇒ `void`

This method returns an undefined value.

Parameters:

(callback[instance])
if: (condition[instance])
unless: (condition[instance])
(Object)

# File 'sig/active_record_compose.rbs', line 72

def self.after_update: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void

.around_create ⇒ `void`

This method returns an undefined value.

Parameters:

(around_callback[instance])
if: (condition[instance])
unless: (condition[instance])
(Object)

# File 'sig/active_record_compose.rbs', line 67

def self.around_create: (*around_callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void

.around_save ⇒ `void`

This method returns an undefined value.

Parameters:

(around_callback[instance])
if: (condition[instance])
unless: (condition[instance])
(Object)

# File 'sig/active_record_compose.rbs', line 63

def self.around_save: (*around_callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void

.around_update ⇒ `void`

This method returns an undefined value.

Parameters:

(around_callback[instance])
if: (condition[instance])
unless: (condition[instance])
(Object)

# File 'sig/active_record_compose.rbs', line 71

def self.around_update: (*around_callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void

.before_commit ⇒ `void`

This method returns an undefined value.

Parameters:

(callback[instance])
if: (condition[instance])
unless: (condition[instance])
(Object)

# File 'sig/active_record_compose.rbs', line 74

def self.before_commit: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void

.before_create ⇒ `void`

This method returns an undefined value.

Parameters:

(callback[instance])
if: (condition[instance])
unless: (condition[instance])
(Object)

# File 'sig/active_record_compose.rbs', line 66

def self.before_create: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void

.before_save ⇒ `void`

This method returns an undefined value.

Parameters:

(callback[instance])
if: (condition[instance])
unless: (condition[instance])
(Object)

# File 'sig/active_record_compose.rbs', line 62

def self.before_save: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void

.before_update ⇒ `void`

This method returns an undefined value.

Parameters:

(callback[instance])
if: (condition[instance])
unless: (condition[instance])
(Object)

# File 'sig/active_record_compose.rbs', line 70

def self.before_update: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void

.delegate_attribute ⇒ `Object`

Parameters:

methods (Object)
to: (Object)
allow_nil: (Boolean)

Returns:

(Object)

78	# File 'sig/active_record_compose.rbs', line 78 def self.delegate_attribute: (*untyped methods, to: untyped, ?allow_nil: bool) -> untyped

.filter_attributes ⇒ `Array[untyped]`

Returns:

(Array[untyped])

80	# File 'sig/active_record_compose.rbs', line 80 def self.filter_attributes: () -> Array[untyped]

.filter_attributes= ⇒ `Object`

Parameters:

(Array[untyped])

Returns:

(Object)

81	# File 'sig/active_record_compose.rbs', line 81 def self.filter_attributes=: (Array[untyped]) -> untyped

Instance Method Details

#id ⇒ `Object`

Returns the ID value. This value is used when passing it to the :model option of form_with, etc. Normally it returns nil, but it can be overridden to delegate to the containing model.

Examples:

Redefine the id method by delegating to the containing model

class Foo < ActiveRecordCompose::Model
  def initialize(primary_model)
    @primary_model = primary_model
    # ...
  end

  def id
    primary_model.id
  end

  private

  attr_reader :primary_model
end

Returns:

(Object) —
ID value

117	# File 'lib/active_record_compose/model.rb', line 117 def id = nil

#inspect ⇒ `String`

Returns:

(String)

91	# File 'sig/active_record_compose.rbs', line 91 def inspect: () -> String

#models ⇒ `ActiveRecordCompose::ComposedCollection`

Returns a collection of model elements to encapsulate.

Examples:

Adding models

models << inner_model_a << inner_model_b
models.push(inner_model_c)

`#push` can have `:destroy` `:if` options

models.push(profile, destroy: :blank_profile?)
models.push(profile, destroy: -> { blank_profile? })

Returns:

(ActiveRecordCompose::ComposedCollection)

130	# File 'lib/active_record_compose/model.rb', line 130 def models = @__models \|\|= ActiveRecordCompose::ComposedCollection.new(self)

#override_validation_context ⇒ `validation_context`

Returns:

(validation_context)

112	# File 'sig/_internal/package_private.rbs', line 112 def override_validation_context: -> validation_context

#pretty_print ⇒ `void`

This method returns an undefined value.

Parameters:

q (Object)

92	# File 'sig/active_record_compose.rbs', line 92 def pretty_print: (untyped q) -> void

#save ⇒ `Boolean`

Parameters:

options (Object)

Returns:

(Boolean)

84	# File 'sig/active_record_compose.rbs', line 84 def save: (**untyped options) -> bool

#save! ⇒ `Object`

Parameters:

options (Object)

Returns:

(Object)

85	# File 'sig/active_record_compose.rbs', line 85 def save!: (**untyped options) -> untyped

#update ⇒ `Boolean`

Parameters:

(Hash[attribute_name, untyped])

Returns:

(Boolean)

86	# File 'sig/active_record_compose.rbs', line 86 def update: (Hash[attribute_name, untyped]) -> bool

#update! ⇒ `Object`

Parameters:

(Hash[attribute_name, untyped])

Returns:

(Object)

87	# File 'sig/active_record_compose.rbs', line 87 def update!: (Hash[attribute_name, untyped]) -> untyped

#validate_models ⇒ `void`

This method returns an undefined value.

111	# File 'sig/_internal/package_private.rbs', line 111 def validate_models: -> void

Class: ActiveRecordCompose::Model

Overview

Examples:

Example of model registration.

Multiple model update once.

Attribute delegation.

Aggregate errors on invalid.

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Inspectable

Methods included from Attributes

Methods included from TransactionSupport

Methods included from Validations

Constructor Details

#initialize(attributes = {}) ⇒ Model

Class Method Details

.after_commit ⇒ void

.after_create ⇒ void

.after_rollback ⇒ void

.after_save ⇒ void

.after_update ⇒ void

.around_create ⇒ void

.around_save ⇒ void

.around_update ⇒ void

.before_commit ⇒ void

.before_create ⇒ void

.before_save ⇒ void

.before_update ⇒ void

.delegate_attribute ⇒ Object

.filter_attributes ⇒ Array[untyped]

.filter_attributes= ⇒ Object

Instance Method Details

#id ⇒ Object

Examples:

Redefine the id method by delegating to the containing model

#inspect ⇒ String

#models ⇒ ActiveRecordCompose::ComposedCollection

Examples:

Adding models

#push can have :destroy :if options

#override_validation_context ⇒ validation_context

#pretty_print ⇒ void

#save ⇒ Boolean

#save! ⇒ Object

#update ⇒ Boolean

#update! ⇒ Object

#validate_models ⇒ void

#initialize(attributes = {}) ⇒ `Model`

.after_commit ⇒ `void`

.after_create ⇒ `void`

.after_rollback ⇒ `void`

.after_save ⇒ `void`

.after_update ⇒ `void`

.around_create ⇒ `void`

.around_save ⇒ `void`

.around_update ⇒ `void`

.before_commit ⇒ `void`

.before_create ⇒ `void`

.before_save ⇒ `void`

.before_update ⇒ `void`

.delegate_attribute ⇒ `Object`

.filter_attributes ⇒ `Array[untyped]`

.filter_attributes= ⇒ `Object`

#id ⇒ `Object`

#inspect ⇒ `String`

#models ⇒ `ActiveRecordCompose::ComposedCollection`

`#push` can have `:destroy` `:if` options

#override_validation_context ⇒ `validation_context`

#pretty_print ⇒ `void`

#save ⇒ `Boolean`

#save! ⇒ `Object`

#update ⇒ `Boolean`

#update! ⇒ `Object`

#validate_models ⇒ `void`