Class: ROM::Factory::Factories

Inherits:
Object
  • Object
show all
Extended by:
Dry::Configurable, Initializer
Defined in:
lib/rom/factory/factories.rb

Overview

A registry with all configured factories

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#registry ⇒ Hash<Symbol=>Builder> (readonly)

Returns a map with defined db-backed builders.

Returns:

  • (Hash<Symbol=>Builder>) —

    a map with defined db-backed builders



68
 
# File 'lib/rom/factory/factories.rb', line 68

option :registry, default: proc { Registry.new }

#rom ⇒ ROM::Container (readonly)

Returns configured rom container.

Returns:

  • (ROM::Container) —

    configured rom container



60
 
# File 'lib/rom/factory/factories.rb', line 60

param :rom

#struct_namespace(namespace = Undefined) ⇒ Factories (readonly)

Get factories with a custom struct namespace

Examples:

EntityFactory = MyFactory.struct_namespace(MyApp::Entities)

EntityFactory[:user]
# => #<MyApp::Entities::User id=2 ...>

Parameters:

  • namespace (Module) (defaults to: Undefined)

Returns:



64
 
# File 'lib/rom/factory/factories.rb', line 64

option :struct_namespace, optional: true, default: proc { ROM::Struct }

Instance Method Details

#[](name, *traits, **attrs) ⇒ ROM::Struct

Create and persist a new struct

Examples:

create a struct with default attributes

MyFactory[:user]

create a struct with some attributes overridden

MyFactory[:user, name: "Jane"]

Parameters:

  • name (Symbol) —

    The name of the registered factory

  • attrs (Hash) —

    An optional hash with attributes

Returns:

  • (ROM::Struct) 


165
166
167
 
# File 'lib/rom/factory/factories.rb', line 165

def [](name, *traits, **attrs)
  registry[name].persistable(struct_namespace).create(*traits, attrs)
end

#define(spec, **opts, &block) ⇒ ROM::Factory::Builder

Define a new builder

Examples:

a simple builder

MyFactory.define(:user) do |f|
  f.name "Jane"
  f.email "jane@doe.org"
end

a builder using auto-generated fake values

MyFactory.define(:user) do |f|
  f.name { fake(:name) }
  f.email { fake(:internet, :email) }
end

a builder using sequenced values

MyFactory.define(:user) do |f|
  f.sequence(:name) { |n| "user-#{n}" }
end

a builder using values from other attribute(s)

MyFactory.define(:user) do |f|
  f.name "Jane"
  f.email { |name| "#{name.downcase}@rom-rb.org" }
end

a builder with "belongs-to" association

MyFactory.define(:group) do |f|
  f.name "Admins"
end

MyFactory.define(:user) do |f|
  f.name "Jane"
  f.association(:group)
end

a builder with "has-many" association

MyFactory.define(:group) do |f|
  f.name "Admins"
  f.association(:users, count: 2)
end

MyFactory.define(:user) do |f|
  f.sequence(:name) { |n| "user-#{n}" }
end

a builder which extends another builder

MyFactory.define(:user) do |f|
  f.name "Jane"
  f.admin false
end

MyFactory.define(admin: :user) do |f|
  f.admin true
end

Parameters:

  • spec (Symbol, Hash<Symbol=>Symbol>) —

    Builder identifier, can point to a parent builder too

  • opts (Hash) —

    Additional options

Options Hash (**opts):

  • relation (Symbol) —

    An optional relation name (defaults to pluralized builder name)

Returns:

  • (ROM::Factory::Builder) 


132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/rom/factory/factories.rb', line 132

def define(spec, **opts, &block)
  name, parent = spec.is_a?(Hash) ? spec.flatten(1) : spec

  if registry.key?(name)
    raise ArgumentError, "#{name.inspect} factory has been already defined"
  end

  builder =
    if parent
      extend_builder(name, registry[parent], &block)
    else
      relation_name = opts.fetch(:relation) { infer_relation(name) }
      relation = rom.relations[relation_name]
      DSL.new(name, relation: relation.struct_namespace(struct_namespace), factories: self, &block).call
    end

  registry[name] = builder
end

#structs ⇒ Structs

Return in-memory struct builder

Returns:



174
175
176
 
# File 'lib/rom/factory/factories.rb', line 174

def structs
  @__structs__ ||= Structs.new(registry, struct_namespace)
end