Class: ROM::Changeset::Stateful Abstract

Inherits:
ROM::Changeset show all
Defined in:
changeset/lib/rom/changeset/stateful.rb

Overview

This class is abstract.

Stateful changesets carry data and can transform it into a different structure compatible with a persistence backend

Direct Known Subclasses

Create, Update

Constant Summary collapse

EMPTY_PIPE =

Default no-op pipe

Pipe.new(use_for_diff: false).freeze

Class Method Summary collapse

Instance Method Summary collapse

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(meth, *args, &block) ⇒ Object (private)

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.

[View source]

269
270
271
272
273
274
275
276
277
278
279
280
281
 
# File 'changeset/lib/rom/changeset/stateful.rb', line 269

def method_missing(meth, *args, &block)
  if __data__.respond_to?(meth)
    response = __data__.__send__(meth, *args, &block)

    if response.is_a?(__data__.class)
      with(__data__: response)
    else
      response
    end
  else
    super
  end
end

Class Method Details

.default_pipe(context) ⇒ Pipe

Build default pipe object

This can be overridden in a custom changeset subclass

Returns:

  • (Pipe)
[View source]

89
90
91
 
# File 'changeset/lib/rom/changeset/stateful.rb', line 89

def self.default_pipe(context)
  !pipes.empty? ? pipes.map { |p| p.bind(context) }.reduce(:>>) : EMPTY_PIPE
end

.extend(&block) ⇒ Array<Pipe>, Transproc::Function

Define a changeset mapping excluded from diffs

Returns:

  • (Array<Pipe>, Transproc::Function) —

    ]

See Also:

[View source]

76
77
78
79
80
81
82
 
# File 'changeset/lib/rom/changeset/stateful.rb', line 76

def self.extend(*, &block)
  if block
    map(use_for_diff: false, &block)
  else
    super
  end
end

.map(**options, &block) ⇒ Array<Pipe>, Transproc::Function

Define a changeset mapping

Subsequent mapping definitions will be composed together and applied in the order they way defined

Examples:

Transformation DSL

class NewUser < ROM::Changeset::Create
  map do
    unwrap :address, prefix: true
  end
end

Using custom block

class NewUser < ROM::Changeset::Create
  map do |tuple|
    tuple.merge(created_at: Time.now)
  end
end

Multiple mappings (executed in the order of definition)

class NewUser < ROM::Changeset::Create
  map do
    unwrap :address, prefix: true
  end

  map do |tuple|
    tuple.merge(created_at: Time.now)
  end
end

Returns:

  • (Array<Pipe>, Transproc::Function) —

    ]

See Also:

[View source]

60
61
62
63
64
65
66
 
# File 'changeset/lib/rom/changeset/stateful.rb', line 60

def self.map(**options, &block)
  if block.parameters.empty?
    pipes << Class.new(Pipe).define!(&block).new(**options)
  else
    pipes << Pipe.new(block, **options)
  end
end

Instance Method Details

#associate(other, name = Associated.infer_assoc_name(other)) ⇒ Object

Associate a changeset with another changeset or hash-like object

Examples:

with another changeset

new_user = users.changeset(name: 'Jane')
new_task = users.changeset(:tasks, title: 'A task')

new_task.associate(new_user, :users)

with a hash-like object

user = users.users.by_pk(1).one
new_task = users.changeset(:tasks, title: 'A task')

new_task.associate(user, :users)

Parameters:

  • other (#to_hash, Changeset) —

    Other changeset or hash-like object

  • name (Symbol) (defaults to: Associated.infer_assoc_name(other)) —

    The association identifier from schema

[View source]

225
226
227
 
# File 'changeset/lib/rom/changeset/stateful.rb', line 225

def associate(other, name = Associated.infer_assoc_name(other))
  Associated.new(self, associations: { name => other })
end

#commit ⇒ Object

Commit stateful changeset

See Also:

[View source]

203
204
205
 
# File 'changeset/lib/rom/changeset/stateful.rb', line 203

def commit
  command.call(self)
end

#data(data) ⇒ Changeset

Return changeset with data

Parameters:

  • data (Hash)

Returns:

[View source]

170
171
172
 
# File 'changeset/lib/rom/changeset/stateful.rb', line 170

def data(data)
  with(__data__: data)
end

#extend(*steps, **options, &block) ⇒ Changeset

Pipe changeset's data using custom steps define on the pipe. You should use #map instead except updating timestamp fields. Calling changeset.extend builds a pipe that excludes certain steps for generating the diff. Currently the only place where it is used is update changesets with the :touch step, i.e. changeset.extend(:touch).diff will exclude :updated_at from the diff.

Returns:

See Also:

[View source]

151
152
153
154
155
156
157
158
159
160
161
 
# File 'changeset/lib/rom/changeset/stateful.rb', line 151

def extend(*steps, **options, &block)
  if block
    if !steps.empty?
      extend(*steps, **options).extend(**options, &block)
    else
      with(pipe: pipe.compose(Pipe.new(block).bind(self), **options))
    end
  else
    with(pipe: steps.reduce(pipe.with(**options)) { |a, e| a.compose(pipe[e], **options) })
  end
end

#inspect ⇒ String

Return string representation of the changeset

Returns:

  • (String)
[View source]

243
244
245
 
# File 'changeset/lib/rom/changeset/stateful.rb', line 243

def inspect
  %(#<#{self.class} relation=#{relation.name.inspect} data=#{__data__}>)
end

#map(*steps) ⇒ Changeset #map(&block) ⇒ Changeset #map(*steps, &block) ⇒ Changeset

Pipe changeset's data using custom steps define on the pipe

Overloads:

  • #map(*steps) ⇒ Changeset

    Apply mapping using built-in transformations

    Examples:

    changeset.map(:add_timestamps)

    Parameters:

    • steps (Array<Symbol>) —

      A list of mapping steps

  • #map(&block) ⇒ Changeset

    Apply mapping using a custom block

    Examples:

    changeset.map { |tuple| tuple.merge(created_at: Time.now) }
  • #map(*steps, &block) ⇒ Changeset

    Apply mapping using built-in transformations and a custom block

    Examples:

    changeset.map(:add_timestamps) { |tuple| tuple.merge(status: 'published') }

    Parameters:

    • steps (Array<Symbol>) —

      A list of mapping steps

Returns:

[View source]

134
135
136
 
# File 'changeset/lib/rom/changeset/stateful.rb', line 134

def map(*steps, &block)
  extend(*steps, for_diff: true, &block)
end

#to_a ⇒ Array Also known as: to_ary

Coerce changeset to an array

This will send the data through the pipe

Returns:

  • (Array)
[View source]

193
194
195
 
# File 'changeset/lib/rom/changeset/stateful.rb', line 193

def to_a
  result == :one ? [to_h] : __data__.map { |element| pipe.call(element) }
end

#to_h ⇒ Hash Also known as: to_hash

Coerce changeset to a hash

This will send the data through the pipe

Returns:

  • (Hash)
[View source]

181
182
183
 
# File 'changeset/lib/rom/changeset/stateful.rb', line 181

def to_h
  pipe.call(__data__)
end