rom-factory 0.10.2 → 0.12.0

data/Gemfile

@@ -1,38 +1,39 @@
 # frozen_string_literal: true
 
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 gemspec
 
-eval_gemfile 'Gemfile.devtools'
+eval_gemfile "Gemfile.devtools"
 
-gem 'faker', "~> #{ENV['FAKER'].eql?('faker-1') ? '1.7' : '2.8'}"
+gem "faker", "~> 3.0"
 
-gem 'rake', '~> 12.0'
-gem 'rspec', '~> 3.0'
+gem "rspec", "~> 3.0"
 
-gem 'rom', github: 'rom-rb/rom', branch: 'master' do
-  gem 'rom-core'
+git "https://github.com/rom-rb/rom.git", branch: "release-5.3" do
+  gem "rom-core"
+  gem "rom-changeset"
+  gem "rom-repository"
+  gem "rom"
 end
 
 group :test do
-  gem 'rom-sql', github: 'rom-rb/rom-sql', branch: 'master'
-  gem 'inflecto'
-  gem 'pry-byebug', '~> 3.8', platforms: :ruby
-  gem 'pry', '~> 0.12.0', '<= 0.13'
+  gem "pry"
+  gem "pry-byebug", "~> 3.8", platforms: :ruby
+  gem "rom-sql", github: "rom-rb/rom-sql", branch: "release-3.6"
 
-  gem 'pg', '~> 0.21', platforms: :ruby
-  gem 'jdbc-postgres', platforms: :jruby
+  gem "jdbc-postgres", platforms: :jruby
+  gem "pg", "~> 1.5", platforms: :ruby
 end
 
 group :tools do
-  gem 'byebug', platform: :mri
-  gem 'redcarpet' # for yard
+  gem "byebug", platform: :mri
+  gem "redcarpet" # for yard
 end
 
 group :benchmarks do
-  gem 'activerecord'
-  gem 'benchmark-ips'
-  gem 'factory_bot'
-  gem 'fabrication'
+  gem "activerecord"
+  gem "benchmark-ips"
+  gem "fabrication"
+  gem "factory_bot"
 end

data/Gemfile.devtools

@@ -2,18 +2,19 @@
 
 # this file is managed by rom-rb/devtools project
 
+gem "rake", ">= 12.3.3"
+
 git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 group :test do
-  # 0.18.x breaks codacy result parser
-  gem "simplecov", "0.17.1", require: false, platforms: :ruby
-
-  gem "codacy-coverage", require: false, platforms: :ruby
+  gem "simplecov", require: false, platforms: :ruby
+  gem "simplecov-cobertura", require: false, platforms: :ruby
+  gem "rexml", require: false
 
   gem "warning" if RUBY_VERSION >= "2.4.0"
 end
 
 group :tools do
   # this is the same version that we use on codacy
-  gem "rubocop", "0.71.0"
+  gem "rubocop", "1.26.1"
 end

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015-2020 rom-rb team
+Copyright (c) 2015-2021 rom-rb team
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

data/README.md

@@ -14,14 +14,14 @@
 
 ## Links
 
-* [User documentation](http://rom-rb.org/learn/rom-factory)
-* [API documentation](http://rubydoc.info/gems/rom-factory)
+* [User documentation](https://rom-rb.org/learn/factory)
+* [API documentation](https://rubydoc.info/gems/rom-factory)
 
 ## Supported Ruby versions
 
 This library officially supports the following Ruby versions:
 
-* MRI >= `2.4`
+* MRI >= `2.5`
 * jruby >= `9.2`
 
 ## License

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

@@ -1,4 +1,39 @@
 ---
+- version: 0.12.0
+  date: 2024-01-19
+  added:
+    - Support for many-to-many and one-to-one-through associations (via #86) (@solnic)
+    - Support for UUID as PKs in associations (via #87) (@solnic)
+  fixed:
+    - Relations without PKs should work too (via #87) (@solnic)
+    - Relations with PK values generated on the Ruby side should work in SQlite too (via #87) (@solnic)
+- 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:

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 found 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(:group)
+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,11 @@ 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
+
+      def reject(&block)
+        self.class.new(elements.reject(&block))
       end
 
       private

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

@@ -3,12 +3,12 @@
 module ROM::Factory
   module Attributes
     # @api private
+    # rubocop:disable Style/OptionalArguments
     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 +23,11 @@ module ROM::Factory
           @options = options
         end
 
+        # @api private
+        def through?
+          false
+        end
+
         # @api private
         def builder
           @__builder__ ||= @builder_proc.call
@@ -42,28 +47,62 @@ module ROM::Factory
         def value?
           false
         end
+
+        # @api private
+        def factories
+          builder.factories
+        end
+
+        # @api private
+        def foreign_key
+          assoc.foreign_key
+        end
+
+        # @api private
+        def count
+          options.fetch(:count, 1)
+        end
       end
 
       # @api private
       class ManyToOne < Core
         # @api private
+        # rubocop:disable Metrics/AbcSize
         def call(attrs, persist: true)
-          if attrs.key?(name) && !attrs[foreign_key]
+          return if attrs.key?(name) && attrs[name].nil?
+
+          assoc_data = attrs.fetch(name, EMPTY_HASH)
+
+          if assoc_data.is_a?(Hash) && assoc_data[assoc.target.primary_key] && !attrs[foreign_key]
             assoc.associate(attrs, attrs[name])
-          elsif !attrs[foreign_key]
-            struct = if persist
-                       builder.persistable.create(*traits)
+          elsif assoc_data.is_a?(ROM::Struct)
+            assoc.associate(attrs, assoc_data)
+          else
+            parent = if persist && !attrs[foreign_key]
+                       builder.persistable.create(*parent_traits, **assoc_data)
                      else
-                       builder.struct(*traits)
+                       builder.struct(
+                         *parent_traits,
+                         **assoc_data.merge(assoc.target.primary_key => attrs[foreign_key])
+                       )
                      end
-            tuple = { name => struct }
-            assoc.associate(tuple, struct)
+
+            tuple = {name => parent}
+
+            assoc.associate(tuple, parent)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
-        # @api private
-        def foreign_key
-          assoc.foreign_key
+        private
+
+        def parent_traits
+          @parent_traits ||=
+            if assoc.target.associations.key?(assoc.source.name)
+              traits + [assoc.target.associations[assoc.source.name].key => false]
+            else
+              traits
+            end
         end
       end
 
@@ -78,24 +117,19 @@ 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
         def dependency?(rel)
           assoc.source == rel
         end
-
-        # @api private
-        def count
-          options.fetch(:count)
-        end
       end
 
       # @api private
@@ -103,29 +137,93 @@ 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
+      end
+
+      class ManyToMany < Core
+        def call(attrs = EMPTY_HASH, parent, persist: true)
+          return if attrs.key?(name)
+
+          structs = count.times.map do
+            if persist && attrs[tpk]
+              attrs
+            elsif persist
+              builder.persistable.create(*traits, **attrs)
+            else
+              builder.struct(*traits, **attrs)
+            end
+          end
+
+          # Delegate to through factory if it exists
+          if persist
+            if through_factory?
+              structs.each do |child|
+                through_attrs = {
+                  Dry::Core::Inflector.singularize(assoc.source.name.key).to_sym => parent,
+                  assoc.through.assoc_name => child
+                }
+
+                factories[through_factory_name, **through_attrs]
+              end
+            else
+              assoc.persist([parent], structs)
+            end
+
+            {name => result(structs)}
+          else
+            result(structs)
+          end
         end
 
-        # @api private
-        def count
-          options.fetch(:count, 1)
+        def result(structs)
+          {name => structs}
+        end
+
+        def dependency?(rel)
+          assoc.source == rel
+        end
+
+        def through?
+          true
+        end
+
+        def through_factory?
+          factories.registry.key?(through_factory_name)
+        end
+
+        def through_factory_name
+          ROM::Inflector.singularize(assoc.definition.through.source).to_sym
+        end
+
+        private
+
+        def tpk
+          assoc.target.primary_key
+        end
+      end
+
+      class OneToOneThrough < ManyToMany
+        def result(structs)
+          {name => structs[0]}
         end
       end
     end
   end
+  # rubocop:enable Style/OptionalArguments
 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"