Class: ROM::Schema::DSL

Inherits:
BasicObject
Extended by:
Initializer
Defined in:
lib/rom/schema/dsl.rb

Overview

Schema DSL exposed as schema { .. } in relation classes

Constant Summary collapse

KERNEL_METHODS =
%i[extend method].freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(&block) ⇒ DSL

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 DSL.


66
67
68
69
70
71
72
73
# File 'lib/rom/schema/dsl.rb', line 66

def initialize(*, &block)
  super

  @attributes = {}
  @plugins = {}

  @definition = block
end

Instance Attribute Details

#adapterSymbol (readonly)

Returns The adapter identifier used in gateways.

Returns:

  • (Symbol)

    The adapter identifier used in gateways


39
# File 'lib/rom/schema/dsl.rb', line 39

option :adapter, default: -> { :default }

#associations_dslObject (readonly)


58
59
60
# File 'lib/rom/schema/dsl.rb', line 58

def associations_dsl
  @associations_dsl
end

#attr_classClass (readonly)

Returns Attribute class that should be used.

Returns:

  • (Class)

    Attribute class that should be used


35
# File 'lib/rom/schema/dsl.rb', line 35

option :attr_class, default: -> { Attribute }

#attributesObject (readonly)


46
47
48
# File 'lib/rom/schema/dsl.rb', line 46

def attributes
  @attributes
end

#definitionObject (readonly)


54
55
56
# File 'lib/rom/schema/dsl.rb', line 54

def definition
  @definition
end

#inferrerInferrer (readonly)

Returns Optional attribute inferrer.

Returns:

  • (Inferrer)

    Optional attribute inferrer


27
# File 'lib/rom/schema/dsl.rb', line 27

option :inferrer, default: -> { DEFAULT_INFERRER }

#inflectorObject (readonly)


63
64
65
# File 'lib/rom/schema/dsl.rb', line 63

def inflector
  @inflector
end

#pluginsObject (readonly)


50
51
52
# File 'lib/rom/schema/dsl.rb', line 50

def plugins
  @plugins
end

#relationRelation::Name (readonly)

Returns The name of the schema's relation.

Returns:


23
# File 'lib/rom/schema/dsl.rb', line 23

param :relation

#schema_classClass (readonly)

Returns Schema class that should be instantiated.

Returns:

  • (Class)

    Schema class that should be instantiated


31
# File 'lib/rom/schema/dsl.rb', line 31

option :schema_class, default: -> { Schema }

Instance Method Details

#app_plugin(plugin, options = ::ROM::EMPTY_HASH) ⇒ 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.


184
185
186
187
# File 'lib/rom/schema/dsl.rb', line 184

def app_plugin(plugin, options = ::ROM::EMPTY_HASH)
  plugin.extend_dsl(self)
  @plugins[plugin.name] = [plugin, plugin.config.to_hash.merge(options)]
end

#associations(&block) ⇒ AssociationDSL

Define associations for a relation

Examples:

class Users < ROM::Relation[:sql]
  schema(infer: true) do
    associations do
      has_many :tasks
      has_many :posts
      has_many :posts, as: :priority_posts, view: :prioritized
      belongs_to :account
    end
  end
end

class Posts < ROM::Relation[:sql]
  schema(infer: true) do
    associations do
      belongs_to :users, as: :author
    end
  end

  view(:prioritized) do
    where { priority <= 3 }
  end
end

Returns:

  • (AssociationDSL)

123
124
125
# File 'lib/rom/schema/dsl.rb', line 123

def associations(&block)
  @associations_dsl = AssociationsDSL.new(relation, inflector, &block)
end

#attribute(name, type_or_options, options = EMPTY_HASH) ⇒ Object

Defines a relation attribute with its type and options.

When only options are given, type is left as nil. It makes sense when it is used alongside an schema inferrer, which will populate the type.

See Also:


85
86
87
88
89
90
91
92
# File 'lib/rom/schema/dsl.rb', line 85

def attribute(name, type_or_options, options = EMPTY_HASH)
  if attributes.key?(name)
    ::Kernel.raise ::ROM::AttributeAlreadyDefinedError,
                   "Attribute #{name.inspect} already defined"
  end

  attributes[name] = build_attribute_info(name, type_or_options, options)
end

#build_attribute_info(name, type_or_options, options = EMPTY_HASH) ⇒ Hash

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.

Builds a representation of the information needed to create an attribute. It returns a hash with :type and :options keys.

Returns:

  • (Hash)

See Also:

  • ROM::Schema::DSL.[Schema[Schema.build_attribute_info]

135
136
137
138
139
140
141
142
143
144
# File 'lib/rom/schema/dsl.rb', line 135

def build_attribute_info(name, type_or_options, options = EMPTY_HASH)
  type, options = if type_or_options.is_a?(::Hash)
                    [nil, type_or_options]
                  else
                    [build_type(type_or_options, options), options]
                  end
  Schema.build_attribute_info(
    type, **options, name: name
  )
end

#build_type(type, options = EMPTY_HASH) ⇒ Dry::Types::Type

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.

Builds a type instance from base type and meta options

Returns:

  • (Dry::Types::Type)

    Type instance


151
152
153
154
155
156
157
158
159
# File 'lib/rom/schema/dsl.rb', line 151

def build_type(type, options = EMPTY_HASH)
  if options[:read]
    type.meta(source: relation, read: options[:read])
  elsif type.optional? && type.meta[:read]
    type.meta(source: relation, read: type.meta[:read].optional)
  else
    type.meta(source: relation)
  end.meta(Attribute::META_OPTIONS.map { |opt| [opt, options[opt]] if options.key?(opt) }.compact.to_h)
end

#call(inflector: Inflector, &block) ⇒ 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.


190
191
192
193
194
195
196
197
198
199
200
201
# File 'lib/rom/schema/dsl.rb', line 190

def call(inflector: Inflector, &block)
  @inflector = inflector

  instance_exec(&block) if block
  instance_exec(&definition) if definition

  schema_class.define(relation, **opts) do |schema|
    plugins.values.each do |plugin, options|
      plugin.apply_to(schema, **options)
    end
  end
end

#plugin_options(plugin) ⇒ 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.


204
205
206
# File 'lib/rom/schema/dsl.rb', line 204

def plugin_options(plugin)
  @plugins[plugin][1]
end

#primary_key(*names) ⇒ Object

Specify which key(s) should be the primary key


164
165
166
167
168
169
170
# File 'lib/rom/schema/dsl.rb', line 164

def primary_key(*names)
  names.each do |name|
    attributes[name][:type] =
      attributes[name][:type].meta(primary_key: true)
  end
  self
end

#use(plugin_name, options = ::ROM::EMPTY_HASH) ⇒ Object

Enables for the schema

Parameters:

  • plugin_name (Symbol)

    Plugin name

  • options (Hash) (defaults to: ::ROM::EMPTY_HASH)

    Plugin options


178
179
180
181
# File 'lib/rom/schema/dsl.rb', line 178

def use(plugin_name, options = ::ROM::EMPTY_HASH)
  plugin = ::ROM.plugin_registry[:schema].fetch(plugin_name, adapter)
  app_plugin(plugin, options)
end