rom-factory 0.10.1 → 0.11.0

data/README.md

@@ -1,64 +1,29 @@
 [gem]: https://rubygems.org/gems/rom-factory
 [actions]: https://github.com/rom-rb/rom-factory/actions
-[codeclimate]: https://codeclimate.com/github/rom-rb/rom-factory
+[codacy]: https://www.codacy.com/gh/rom-rb/rom-factory
+[chat]: https://rom-rb.zulipchat.com
 [inchpages]: http://inch-ci.org/github/rom-rb/rom-factory
 
-# rom-factory
+# rom-factory [![Join the chat at https://rom-rb.zulipchat.com](https://img.shields.io/badge/rom--rb-join%20chat-%23346b7a.svg)][chat]
 
 [![Gem Version](https://badge.fury.io/rb/rom-factory.svg)][gem]
 [![CI Status](https://github.com/rom-rb/rom-factory/workflows/ci/badge.svg)][actions]
-[![Code Climate](https://codeclimate.com/github/rom-rb/rom-factory/badges/gpa.svg)][codeclimate]
-[![Test Coverage](https://codeclimate.com/github/rom-rb/rom-factory/badges/coverage.svg)][codeclimate]
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/5fd26fae687549218458879b1a607e18)][codacy]
+[![Codacy Badge](https://api.codacy.com/project/badge/Coverage/5fd26fae687549218458879b1a607e18)][codacy]
 [![Inline docs](http://inch-ci.org/github/rom-rb/rom-factory.svg?branch=master)][inchpages]
 
-Data generator with support for persistence backends, built on top of [rom-rb](http://rom-rb.org) and [dry-rb](http://dry-rb.org).
+## Links
 
-More information:
+* [User documentation](https://rom-rb.org/learn/factory)
+* [API documentation](https://rubydoc.info/gems/rom-factory)
 
-- [API docs](http://rubydoc.info/gems/rom-factory)
+## Supported Ruby versions
 
-## Installation
+This library officially supports the following Ruby versions:
 
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'rom-factory'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install rom-factory
-
-### Performance
-
-Seems like this thing is a bit faster than other popular factory gems:
-
-```
-Warming up --------------------------------------
-         rom-factory     1.000  i/100ms
-        factory_girl     1.000  i/100ms
-         fabrication     1.000  i/100ms
-Calculating -------------------------------------
-         rom-factory      1.550  (± 0.0%) i/s -      8.000  in   5.166227s
-        factory_girl      0.982  (± 0.0%) i/s -      5.000  in   5.098193s
-         fabrication      1.011  (± 0.0%) i/s -      6.000  in   5.942209s
-
-Comparison:
-         rom-factory:        1.5 i/s
-         fabrication:        1.0 i/s - 1.53x  slower
-        factory_girl:        1.0 i/s - 1.58x  slower
-```
-
-> See [benchmarks/basic.rb](https://github.com/rom-rb/rom-factory/blob/master/benchmarks/basic.rb)
-
-## Credits
-
-This project was originally created by [Jānis Miezītis](https://github.com/janjiss) and eventually moved to `rom-rb` organization.
+* MRI >= `2.5`
+* jruby >= `9.2`
 
 ## License
 
-See `LICENSE.txt` file.
+See `LICENSE` file.

data/Rakefile

@@ -5,4 +5,4 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/benchmarks/basic.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require 'rom-factory'
-require 'rom-core'
-require 'active_record'
-require 'factory_bot'
-require 'fabrication'
-require 'benchmark/ips'
+require "rom-factory"
+require "rom-core"
+require "active_record"
+require "factory_bot"
+require "fabrication"
+require "benchmark/ips"
 
-DATABASE_URL = 'postgres://localhost/rom_factory_bench'.freeze
+DATABASE_URL = "postgres://localhost/rom_factory_bench"
 
 rom = ROM.container(:sql, DATABASE_URL) do |conf|
   conf.default.connection.create_table?(:users) do
@@ -50,15 +50,15 @@ Fabricator(:user) do
 end
 
 Benchmark.ips do |x|
-  x.report('rom-factory persisted struct') do
+  x.report("rom-factory persisted struct") do
     factory[:user]
   end
 
-  x.report('factory_bot') do
+  x.report("factory_bot") do
     FactoryBot.create(:user)
   end
 
-  x.report('fabrication') do
+  x.report("fabrication") do
     Fabricate(:user)
   end
 

data/changelog.yml

@@ -0,0 +1,99 @@
+---
+- version: 0.11.0
+  date: 2022-11-11
+  added:
+    - Support for one-to-one associations (@ianks)
+    - "[internal] cache for Faker constants (@flash-gordon)"
+  changed:
+    - |
+      [BREAKING] attributes are always passed as keywords (@alassek)
+      This may affect your code in places where attributes are passed as hashes.
+      Places like
+      ```ruby
+      user_attributes = { name: 'Jane' }
+      Factory[:user, user_attributes]
+      ```
+      must be updated to
+      ```ruby
+      user_attributes = { name: 'Jane' }
+      Factory[:user, **user_attributes]
+      ```
+    - "Upgraded to the latest versions of dry-rb dependencies, compatible with rom 5.3 (@flash-gordon)"
+    - Support for Faker 1.x was dropped (@alassek)
+  fixed:
+    - Support for plural Faker generators (@wuarmin)
+- version: 0.10.2
+  date: "2020-04-05"
+  fixed:
+  - Fix more keyword warnings (@flash-gordon)
+- version: 0.10.1
+  date: '2019-12-28'
+  added:
+  - 'Support for faker 2 (@ianks)'
+  fixed:
+  - Keyword warnings reported by Ruby 2.7 (@flash-gordon)
+- version: 0.10.0
+  date: '2019-12-11'
+  added:
+  - |-
+    `struct_namespace` option is supported by factory builders (@graceful-potato)
+
+      ``` ruby
+      factories.define(:user, struct_namespace: MyApp::Entities) do |f|
+        # ...
+      end
+      ```
+  fixed:
+  - Support building structs when child assoc does not define parent (@psparrow)
+  - 'Fixed `TupleEvaluator#struct_attrs` for non-standard output schema (@AMHOL)'
+- version: 0.9.1
+  date: '2019-10-23'
+  fixed:
+  - Attributes of a struct are no longer accidentally passed to their associations (@psparrow)
+- version: 0.9.0
+  date: '2019-08-12'
+  added:
+  - 'When attributes hash includes unknown attributes, a `ROM::Factory::UnknownAttributeError` will be raised (@rawburt)'
+- version: 0.8.0
+  date: '2019-04-24'
+  fixed:
+  - 'Loaded association structs are no longer rejected by output schemas (issue #34) (flash-gordon + solnic)'
+- version: 0.7.0
+  date: '2018-11-17'
+  added:
+  - Support for traits (v-kolesnikov)
+  - Support building structs with associations (@ianks)
+  fixed:
+  - Overwritten attributes with dependencies (JanaVPetrova)
+- version: 0.6.0
+  date: '2018-01-31'
+  added:
+  - Support for factories with custom struct namespaces (solnic)
+  changed:
+  - 'Accessing a factory which is not defined will result in `FactoryNotDefinedError` exception (GustavoCaso + solnic)'
+  fixed:
+  - 'Using dependent attributes with sequences works correctly, ie `f.sequence(:login) { |i, name| "name-#{i}"}` (solnic)'
+- version: 0.5.0
+  date: '2017-10-24'
+  added:
+  - Updated to rom 4.0 (solnic)
+  - 'Support for `has_many` and `has_one` associations (solnic)'
+  - Support for attributes depending on values from other attributes (solnic)
+  - 'Support for `rand` inside the generator block (flash-gordon)'
+  changed:
+  - 'Depends on `rom-core` now (solnic)'
+- version: 0.4.0
+  date: '2017-03-03'
+  summary: improves internals.
+  added:
+  - 'Support for defining multiple factories via `MyFactory = ROM::Factory.configure { |c| ... }` (solnic)'
+  - 'Support for builder inheritence via `define(admin: :user) { |f| ... }` (solnic)'
+  - 'Support for generating in-memory structs via `MyFactory.structs[:user]` that are not persisted (solnic)'
+  - 'Support for `belongs_to` associations via `f.association(:user)` (solnic)'
+  - 'New DSL for defining builders `MyFactory.define(:user) { |f| ... }` which infers default relation name (solnic)'
+  - 'New factory method `MyFactory#[]` ie `MyFactory[:user, name: "Jane"]` (solnic)'
+  - 'New `fake` helper which uses faker gem under the hood ie `f.email { fake(:internet, :email) }` (solnic)'
+  changed:
+  - "`Rom::Factory::Config.configure` was replaced with `ROM::Factory.configure` (solnic)"
+  - Global factory config and builders are gone (solnic)
+  - Structs are now based on dry-struct (solnic)

data/docsite/source/index.html.md

@@ -5,4 +5,165 @@ chapter: Factory
 
 # rom-factory
 
-TODO: write docs :)
+`rom-factory` provides a simple API for creating and persisting `ROM::Struct`'s. If you already know FactoryBot you'll definitely understand the concept.
+
+## Installation
+
+First of all you need to define a ROM Container for Factory. For example if you are using `rspec`, you can add these lines to `spec_helper.rb`. Also you need to require here all files with Factories.
+
+```ruby
+Factory = ROM::Factory.configure do |config|
+  config.rom = my_rom_container
+end
+
+Dir[File.dirname(__FILE__) + '/support/factories/*.rb'].each { |file| require file }
+```
+
+## Usage
+
+### Define factory
+
+```ruby
+# 'spec/support/factories/users.rb'
+
+Factory.define(:user) do |f|
+  f.name 'John'
+  f.age 42
+end
+```
+#### Specify relations
+
+You can specify ROM relation if you want. It'll be pluralized factory name by default.
+
+```ruby
+Factory.define(:user, relation: :people) do |f|
+  f.name 'John'
+  f.age 42
+end
+```
+
+#### Specify namespace for your structs
+
+Struct `User` will be find in MyApp::Entities namespace
+
+```ruby
+Factory.define(:user, struct_namespace: MyApp::Entities) do |f|
+  # ...
+end
+```
+
+#### Sequences
+
+You can use sequences for uniq fields
+
+```ruby
+Factory.define(:user) do |f|
+  f.name 'John'
+  f.sequence(:email) { |n| "john#{n}@example.com" }
+end
+```
+
+#### Timestamps
+
+```ruby
+Factory.define(:user) do |f|
+  f.name 'John'
+  f.timestamps
+  # same as
+  # f.created_at { Time.now }
+  # f.updated_at { Time.now }
+end
+```
+
+#### Associations
+
+* belongs_to
+
+```ruby
+Factory.define(:group) do |f|
+  f.name 'Admins'
+end
+
+Factory.define(:user) do |f|
+  f.name 'John'
+  f.association(:user)
+end
+```
+
+* has_many
+
+```ruby
+Factory.define(:group) do |f|
+  f.name 'Admins'
+  f.association(:user, count: 2)
+end
+
+Factory.define(:user) do |f|
+  f.name 'John'
+end
+```
+
+#### Extend already existing factory
+
+```ruby
+Factory.define(:user) do |f|
+  f.name 'John'
+  f.admin false
+end
+
+Factory.define(admin: :user) do |f|
+  f.admin true
+end
+
+# Factory.structs(:admin)
+```
+
+#### Traits
+
+```ruby
+Factory.define(:user) do |f|
+  f.name 'John'
+  f.admin false
+
+  f.trait :with_age do |t|
+    t.age 42
+  end
+end
+
+# Factory.structs(:user, :with_age)
+```
+
+#### Build-in [Faker](https://github.com/faker-ruby/faker) objects
+
+```ruby
+Factory.define(:user) do |f|
+  f.email { fake(:internet, :email) }
+end
+```
+
+#### Dependent attributes
+
+Attributes can be based on the values of other attributes:
+
+```ruby
+Factory.define(:user) do |f|
+  f.full_name { fake(:name) }
+  # Dependent attributes are inferred from the block parameter names:
+  f.login { |full_name| full_name.downcase.gsub(/\s+/, '_') }
+  # Works with sequences too:
+  f.sequence(:email) { |n, login| "#{login}-#{n}@example.com" }
+end
+```
+
+### Build and persist objects
+
+```ruby
+# Create in-memory object
+Factory.structs[:user]
+
+# Persist struct in database
+Factory[:user]
+
+# Override attributes
+Factory[:user, age: 24]
+```

data/lib/rom/factory/attribute_registry.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'tsort'
+require "tsort"
 
 module ROM
   module Factory
@@ -47,7 +47,7 @@ module ROM
 
       # @api private
       def associations
-        self.class.new(elements.select { |e| e.kind_of?(Attributes::Association::Core) })
+        self.class.new(elements.select { |e| e.is_a?(Attributes::Association::Core) })
       end
 
       private

data/lib/rom/factory/attributes/association.rb

@@ -5,10 +5,9 @@ module ROM::Factory
     # @api private
     module Association
       class << self
-        def new(assoc, builder, *args)
-          const_get(assoc.definition.type).new(assoc, builder, *args)
+        def new(assoc, builder, *traits, **options)
+          const_get(assoc.definition.type).new(assoc, builder, *traits, **options)
         end
-        ruby2_keywords(:new) if respond_to?(:ruby2_keywords, true)
       end
 
       # @api private
@@ -23,6 +22,11 @@ module ROM::Factory
           @options = options
         end
 
+        # @api private
+        def through?
+          false
+        end
+
         # @api private
         def builder
           @__builder__ ||= @builder_proc.call
@@ -56,7 +60,7 @@ module ROM::Factory
                      else
                        builder.struct(*traits)
                      end
-            tuple = { name => struct }
+            tuple = {name => struct}
             assoc.associate(tuple, struct)
           end
         end
@@ -78,13 +82,13 @@ module ROM::Factory
             association_hash = assoc.associate(attrs, parent)
 
             if persist
-              builder.persistable.create(*traits, association_hash)
+              builder.persistable.create(*traits, **association_hash)
             else
-              builder.struct(*traits, attrs.merge(association_hash))
+              builder.struct(*traits, **attrs, **association_hash)
             end
           end
 
-          { name => structs }
+          {name => structs}
         end
 
         # @api private
@@ -103,22 +107,22 @@ module ROM::Factory
         # @api private
         def call(attrs = EMPTY_HASH, parent, persist: true)
           # do not associate if count is 0
-          return { name => nil } if count.zero?
+          return {name => nil} if count.zero?
 
           return if attrs.key?(name)
 
           association_hash = assoc.associate(attrs, parent)
 
           struct = if persist
-                     builder.persistable.create(*traits, association_hash)
+                     builder.persistable.create(*traits, **association_hash)
                    else
                      belongs_to_name = Dry::Core::Inflector.singularize(assoc.source_alias)
-                     belongs_to_associations = { belongs_to_name.to_sym => parent }
+                     belongs_to_associations = {belongs_to_name.to_sym => parent}
                      final_attrs = attrs.merge(association_hash).merge(belongs_to_associations)
-                     builder.struct(*traits, final_attrs)
+                     builder.struct(*traits, **final_attrs)
                    end
 
-          { name => struct }
+          {name => struct}
         end
 
         # @api private
@@ -126,6 +130,42 @@ module ROM::Factory
           options.fetch(:count, 1)
         end
       end
+
+      class OneToOneThrough < Core
+        def call(attrs = EMPTY_HASH, parent, persist: true)
+          return if attrs.key?(name)
+
+          struct = if persist && attrs[tpk]
+                     attrs
+                   elsif persist
+                     builder.persistable.create(*traits, **attrs)
+                   else
+                     builder.struct(*traits, **attrs)
+                   end
+
+          assoc.persist([parent], struct) if persist
+
+          {name => struct}
+        end
+
+        def dependency?(rel)
+          assoc.source == rel
+        end
+
+        def through?
+          true
+        end
+
+        private
+
+        def count
+          options.fetch(:count, 1)
+        end
+
+        def tpk
+          assoc.target.primary_key
+        end
+      end
     end
   end
 end

data/lib/rom/factory/attributes/callable.rb

@@ -16,7 +16,7 @@ module ROM::Factory
       # @api private
       def call(attrs, *args)
         result = attrs[name] || dsl.instance_exec(*args, &block)
-        { name => result }
+        {name => result}
       end
 
       # @api private

data/lib/rom/factory/attributes/value.rb

@@ -16,7 +16,7 @@ module ROM::Factory
       def call(attrs = EMPTY_HASH)
         return if attrs.key?(name)
 
-        { name => value }
+        {name => value}
       end
 
       # @api private

data/lib/rom/factory/attributes.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
-require 'dry/core/constants'
-
 module ROM
   module Factory
     include Dry::Core::Constants
   end
 end
 
-require 'rom/factory/attributes/value'
-require 'rom/factory/attributes/callable'
-require 'rom/factory/attributes/sequence'
-require 'rom/factory/attributes/association'
+require "rom/factory/attributes/value"
+require "rom/factory/attributes/callable"
+require "rom/factory/attributes/sequence"
+require "rom/factory/attributes/association"

data/lib/rom/factory/builder/persistable.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'delegate'
+require "delegate"
 
 module ROM
   module Factory
@@ -21,10 +21,8 @@ module ROM
         end
 
         # @api private
-        def create(*args)
-          traits, attrs = builder.extract_tuple(args)
-
-          tuple = tuple(*traits, attrs)
+        def create(*traits, **attrs)
+          tuple = tuple(*traits, **attrs)
           validate_keys(traits, attrs)
           persisted = persist(tuple)
 

data/lib/rom/factory/builder.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-require 'dry/core/constants'
-
-require 'rom/struct'
-require 'rom/initializer'
-require 'rom/factory/tuple_evaluator'
-require 'rom/factory/builder/persistable'
+require "rom/struct"
+require "rom/initializer"
+require "rom/factory/tuple_evaluator"
+require "rom/factory/builder/persistable"
 
 module ROM::Factory
   # @api private
@@ -31,18 +29,15 @@ module ROM::Factory
     option :struct_namespace, reader: false
 
     # @api private
-    def tuple(*args)
-      traits, attrs = extract_tuple(args)
-
+    def tuple(*traits, **attrs)
       tuple_evaluator.defaults(traits, attrs)
     end
 
     # @api private
-    def struct(*args)
-      traits, attrs = extract_tuple(args)
+    def struct(*traits, **attrs)
       validate_keys(traits, attrs, allow_associations: true)
 
-      tuple_evaluator.struct(*args)
+      tuple_evaluator.struct(*traits, **attrs)
     end
     alias_method :create, :struct
 
@@ -75,18 +70,13 @@ module ROM::Factory
       tuple_evaluator.relation
     end
 
-    # @api private
-    def extract_tuple(args)
-      tuple_evaluator.extract_tuple(args)
-    end
-
     # @api private
     def validate_keys(traits, tuple, allow_associations: false)
       schema_keys = relation.schema.attributes.map(&:name)
       assoc_keys = tuple_evaluator.assoc_names(traits)
       unknown_keys = tuple.keys - schema_keys - assoc_keys
 
-      unknown_keys = unknown_keys - relation.schema.associations.to_h.keys if allow_associations
+      unknown_keys -= relation.schema.associations.to_h.keys if allow_associations
 
       raise UnknownFactoryAttributes, unknown_keys unless unknown_keys.empty?
     end

data/lib/rom/factory/constants.rb

@@ -10,7 +10,7 @@ module ROM
 
     class UnknownFactoryAttributes < StandardError
       def initialize(attrs)
-        super("Unknown attributes: #{attrs.join(', ')}")
+        super("Unknown attributes: #{attrs.join(", ")}")
       end
     end
   end