Class: ROM::Mapper::AttributeDSL Private

Inherits:
Object
  • Object
show all
Includes:
ModelDSL
Defined in:
lib/rom/mapper/attribute_dsl.rb

Overview

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

Mapper attribute DSL exposed by mapper subclasses

This class is private even though its methods are exposed by mappers. Typically it's not meant to be used directly.

TODO: break this madness down into smaller pieces

Constant Summary

Constants included from ModelDSL

ModelDSL::DEFAULT_TYPE

Instance Attribute Summary collapse

Attributes included from ModelDSL

#builder, #klass

Instance Method Summary collapse

Methods included from ModelDSL

#model

Constructor Details

#initialize(attributes, options) ⇒ AttributeDSL

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 a new instance of AttributeDSL.


23
24
25
26
27
28
29
30
31
32
# File 'lib/rom/mapper/attribute_dsl.rb', line 23

def initialize(attributes, options)
  @attributes = attributes
  @options = options
  @copy_keys = options.fetch(:copy_keys)
  @symbolize_keys = options.fetch(:symbolize_keys)
  @prefix = options.fetch(:prefix)
  @prefix_separator = options.fetch(:prefix_separator)
  @reject_keys = options.fetch(:reject_keys)
  @steps = []
end

Instance Attribute Details

#attributesObject (readonly)

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.


17
18
19
# File 'lib/rom/mapper/attribute_dsl.rb', line 17

def attributes
  @attributes
end

#copy_keysObject (readonly)

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.


17
18
19
# File 'lib/rom/mapper/attribute_dsl.rb', line 17

def copy_keys
  @copy_keys
end

#optionsObject (readonly)

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.


17
18
19
# File 'lib/rom/mapper/attribute_dsl.rb', line 17

def options
  @options
end

#reject_keysObject (readonly)

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.


17
18
19
# File 'lib/rom/mapper/attribute_dsl.rb', line 17

def reject_keys
  @reject_keys
end

#stepsObject (readonly)

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.


17
18
19
# File 'lib/rom/mapper/attribute_dsl.rb', line 17

def steps
  @steps
end

#symbolize_keysObject (readonly)

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.


17
18
19
# File 'lib/rom/mapper/attribute_dsl.rb', line 17

def symbolize_keys
  @symbolize_keys
end

Instance Method Details

#attribute(name, options = EMPTY_HASH, &block) ⇒ Object

Define a mapping attribute with its options and/or block

Examples:

dsl = AttributeDSL.new([])

dsl.attribute(:name)
dsl.attribute(:email, from: 'user_email')
dsl.attribute(:name) { 'John' }
dsl.attribute(:name) { |t| t.upcase }

77
78
79
80
81
82
83
84
# File 'lib/rom/mapper/attribute_dsl.rb', line 77

def attribute(name, options = EMPTY_HASH, &block)
  with_attr_options(name, options) do |attr_options|
    raise ArgumentError,
      "can't specify type and block at the same time" if options[:type] && block
    attr_options[:coercer] = block if block
    add_attribute(name, attr_options)
  end
end

#combine(name, options, &block) ⇒ Object

Define an embedded combined attribute that requires “combine” transformation

Typically this can be used to process results of eager-loading

Examples:

dsl = AttributeDSL.new([])

dsl.combine(:tags, user_id: :id) do
  model Tag

  attribute :name
end

329
330
331
332
333
334
335
336
337
338
339
340
# File 'lib/rom/mapper/attribute_dsl.rb', line 329

def combine(name, options, &block)
  dsl = new(options, &block)

  attr_opts = {
    type: options.fetch(:type, :array),
    keys: options.fetch(:on),
    combine: true,
    header: dsl.header
  }

  add_attribute(name, attr_opts)
end

#embedded(name, options, &block) ⇒ Object

Define an embedded attribute

Block exposes the attribute dsl too

Examples:

dsl = AttributeDSL.new([])

dsl.embedded :tags, type: :array do
  attribute :name
end

dsl.embedded :address, type: :hash do
  model Address
  attribute :name
end

Options Hash (options):

  • :type (Symbol)

    Embedded type can be :hash or :array

  • :prefix (Symbol)

    Prefix that should be used for its attributes


128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
# File 'lib/rom/mapper/attribute_dsl.rb', line 128

def embedded(name, options, &block)
  with_attr_options(name) do |attr_options|
    mapper = options[:mapper]

    if mapper
      embedded_options = { type: :array }.update(options)
      attributes_from_mapper(
        mapper, name, embedded_options.update(attr_options)
      )
    else
      dsl = new(options, &block)
      attr_options.update(options)
      add_attribute(
        name, { header: dsl.header, type: :array }.update(attr_options)
      )
    end
  end
end

#exclude(name) ⇒ 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.


86
87
88
# File 'lib/rom/mapper/attribute_dsl.rb', line 86

def exclude(name)
  attributes << [name, { exclude: true }]
end

#fold(*args, &block) ⇒ Object

Define an embedded hash attribute that requires “fold” transformation

Typically this is used in sql context to fold single joined field to the array of values.

Examples:

dsl = AttributeDSL.new([])

dsl.fold(tags: [:name])

See Also:


273
274
275
276
277
278
# File 'lib/rom/mapper/attribute_dsl.rb', line 273

def fold(*args, &block)
  with_name_or_options(*args) do |name, *|
    fold_options = { type: :array, fold: true }
    dsl(name, fold_options, &block)
  end
end

#group(*args, &block) ⇒ Object

Define an embedded hash attribute that requires “grouping” transformation

Typically this is used in sql context when relation is a join.

Examples:

dsl = AttributeDSL.new([])

dsl.group(tags: [:name])

dsl.group(:tags) do
  model Tag
  attribute :name
end

See Also:


228
229
230
231
232
233
234
235
236
237
238
239
240
# File 'lib/rom/mapper/attribute_dsl.rb', line 228

def group(*args, &block)
  ensure_mapper_configuration('group', args, block_given?)

  with_name_or_options(*args) do |name, options, mapper|
    group_options = { type: :array, group: true }.update(options)

    if mapper
      attributes_from_mapper(mapper, name, group_options)
    else
      dsl(name, group_options, &block)
    end
  end
end

#headerHeader

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.

Generate a header from attribute definitions


347
348
349
# File 'lib/rom/mapper/attribute_dsl.rb', line 347

def header
  Header.coerce(attributes, copy_keys: copy_keys, model: model, reject_keys: reject_keys)
end

#prefix(value = Undefined) ⇒ Object

Redefine the prefix for the following attributes

Examples:


dsl = AttributeDSL.new([])
dsl.attribute(:prefix, 'user')

42
43
44
45
46
47
48
# File 'lib/rom/mapper/attribute_dsl.rb', line 42

def prefix(value = Undefined)
  if value.equal?(Undefined)
    @prefix
  else
    @prefix = value
  end
end

#prefix_separator(value = Undefined) ⇒ Object

Redefine the prefix separator for the following attributes

Examples:


dsl = AttributeDSL.new([])
dsl.attribute(:prefix_separator, '.')

58
59
60
61
62
63
64
# File 'lib/rom/mapper/attribute_dsl.rb', line 58

def prefix_separator(value = Undefined)
  if value.equal?(Undefined)
    @prefix_separator
  else
    @prefix_separator = value
  end
end

#step(options = EMPTY_HASH, &block) ⇒ Object

Perform transformations sequentially

Examples:

dsl = AttributeDSL.new()

dsl.step do
  attribute :name
end

100
101
102
# File 'lib/rom/mapper/attribute_dsl.rb', line 100

def step(options = EMPTY_HASH, &block)
  steps << new(options, &block)
end

#unfold(name, options = EMPTY_HASH) ⇒ Object

Define an embedded hash attribute that requires “unfold” transformation

Typically this is used in non-sql context to convert array of values (like in Cassandra 'SET' or 'LIST' types) to array of tuples.

Source values are assigned to the first key, the other keys being left blank.

Examples:

dsl = AttributeDSL.new([])

dsl.unfold(tags: [:name, :type], from: :tags_list)

dsl.unfold :tags, from: :tags_list do
  attribute :name, from: :tag_name
  attribute :type, from: :tag_type
end

See Also:


300
301
302
303
304
305
306
307
308
# File 'lib/rom/mapper/attribute_dsl.rb', line 300

def unfold(name, options = EMPTY_HASH)
  with_attr_options(name, options) do |attr_options|
    old_name = attr_options.fetch(:from, name)
    dsl(old_name, type: :array, unfold: true) do
      attribute name, attr_options
      yield if block_given?
    end
  end
end

#ungroup(*args, &block) ⇒ Object

Define an embedded array attribute that requires “ungrouping” transformation

Typically this is used in non-sql context being prepared for import to sql.

Examples:

dsl = AttributeDSL.new([])
dsl.ungroup(tags: [:name])

See Also:


253
254
255
256
257
258
# File 'lib/rom/mapper/attribute_dsl.rb', line 253

def ungroup(*args, &block)
  with_name_or_options(*args) do |name, options, *|
    ungroup_options = { type: :array, ungroup: true }.update(options)
    dsl(name, ungroup_options, &block)
  end
end

#unwrap(*args, &block) ⇒ Object

Define an embedded hash attribute that requires “unwrapping” transformation

Typically this is used in no-sql context to normalize data before inserting to sql gateway.

Examples:

dsl = AttributeDSL.new([])

dsl.unwrap(address: [:street, :zipcode, :city])

dsl.unwrap(:address) do
  attribute :street
  attribute :zipcode
  attribute :city
end

See Also:


199
200
201
202
203
204
205
206
207
208
209
# File 'lib/rom/mapper/attribute_dsl.rb', line 199

def unwrap(*args, &block)
  with_name_or_options(*args) do |name, options, mapper|
    unwrap_options = { type: :hash, unwrap: true }.update(options)

    if mapper
      attributes_from_mapper(mapper, name, unwrap_options)
    else
      dsl(name, unwrap_options, &block)
    end
  end
end

#wrap(*args, &block) ⇒ Object

Define an embedded hash attribute that requires “wrapping” transformation

Typically this is used in sql context when relation is a join.

Examples:

dsl = AttributeDSL.new([])

dsl.wrap(address: [:street, :zipcode, :city])

dsl.wrap(:address) do
  model Address
  attribute :street
  attribute :zipcode
  attribute :city
end

See Also:


166
167
168
169
170
171
172
173
174
175
176
177
178
# File 'lib/rom/mapper/attribute_dsl.rb', line 166

def wrap(*args, &block)
  ensure_mapper_configuration('wrap', args, block_given?)

  with_name_or_options(*args) do |name, options, mapper|
    wrap_options = { type: :hash, wrap: true }.update(options)

    if mapper
      attributes_from_mapper(mapper, name, wrap_options)
    else
      dsl(name, wrap_options, &block)
    end
  end
end