rom-factory 0.11.0 → 0.13.0

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

@@ -3,10 +3,11 @@
 module ROM::Factory
   module Attributes
     # @api private
+    # rubocop:disable Style/OptionalArguments
     module Association
       class << self
-        def new(assoc, builder, *traits, **options)
-          const_get(assoc.definition.type).new(assoc, builder, *traits, **options)
+        def new(assoc, ...)
+          const_get(assoc.definition.type).new(assoc, ...)
         end
       end
 
@@ -23,9 +24,7 @@ module ROM::Factory
         end
 
         # @api private
-        def through?
-          false
-        end
+        def through? = false
 
         # @api private
         def builder
@@ -33,41 +32,64 @@ module ROM::Factory
         end
 
         # @api private
-        def name
-          assoc.key
-        end
+        def name = assoc.key
 
         # @api private
-        def dependency?(*)
-          false
-        end
+        def dependency?(*) = false
 
         # @api private
-        def value?
-          false
-        end
+        def value? = false
+
+        # @api private
+        def factories = builder.factories
+
+        # @api private
+        def foreign_key = assoc.foreign_key
+
+        # @api private
+        def count = options.fetch(:count, 1)
       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)
-                     else
-                       builder.struct(*traits)
-                     end
-            tuple = {name => struct}
-            assoc.associate(tuple, struct)
+          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(
+                  *parent_traits,
+                  **assoc_data, assoc.target.primary_key => attrs[foreign_key]
+                )
+              end
+
+            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
 
@@ -77,7 +99,7 @@ module ROM::Factory
         def call(attrs = EMPTY_HASH, parent, persist: true)
           return if attrs.key?(name)
 
-          structs = Array.new(count).map do
+          structs = ::Array.new(count).map do
             # hash which contains the foreign key info, i.e: { user_id: 1 }
             association_hash = assoc.associate(attrs, parent)
 
@@ -92,14 +114,7 @@ module ROM::Factory
         end
 
         # @api private
-        def dependency?(rel)
-          assoc.source == rel
-        end
-
-        # @api private
-        def count
-          options.fetch(:count)
-        end
+        def dependency?(rel) = assoc.source == rel
       end
 
       # @api private
@@ -113,59 +128,78 @@ module ROM::Factory
 
           association_hash = assoc.associate(attrs, parent)
 
-          struct = if persist
-                     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}
-                     final_attrs = attrs.merge(association_hash).merge(belongs_to_associations)
-                     builder.struct(*traits, **final_attrs)
-                   end
+          struct =
+            if persist
+              builder.persistable.create(*traits, **association_hash)
+            else
+              belongs_to_name = ::ROM::Inflector.singularize(assoc.source_alias)
+              belongs_to_associations = {belongs_to_name.to_sym => parent}
+              final_attrs = attrs.merge(association_hash).merge(belongs_to_associations)
+              builder.struct(*traits, **final_attrs)
+            end
 
           {name => struct}
         end
-
-        # @api private
-        def count
-          options.fetch(:count, 1)
-        end
       end
 
-      class OneToOneThrough < Core
+      class ManyToMany < 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
+          structs = count.times.map do
+            if persist && attrs[tpk]
+              attrs
+            elsif persist
+              builder.persistable.create(*traits, **attrs)
+            else
+              builder.struct(*traits, **attrs)
+            end
+          end
 
-          assoc.persist([parent], struct) if persist
+          # Delegate to through factory if it exists
+          if persist
+            if through_factory?
+              structs.each do |child|
+                through_attrs = {
+                  ::ROM::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 => struct}
+            {name => result(structs)}
+          else
+            result(structs)
+          end
         end
 
-        def dependency?(rel)
-          assoc.source == rel
+        def result(structs) = {name => structs}
+
+        def dependency?(rel) = assoc.source == rel
+
+        def through? = true
+
+        def through_factory?
+          factories.registry.key?(through_factory_name)
         end
 
-        def through?
-          true
+        def through_factory_name
+          ::ROM::Inflector.singularize(assoc.definition.through.source).to_sym
         end
 
         private
 
-        def count
-          options.fetch(:count, 1)
-        end
+        def tpk = assoc.target.primary_key
+      end
 
-        def tpk
-          assoc.target.primary_key
-        end
+      class OneToOneThrough < ManyToMany
+        def result(structs) = {name => structs[0]}
       end
     end
   end
+  # rubocop:enable Style/OptionalArguments
 end

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

@@ -28,6 +28,12 @@ module ROM::Factory
       def dependency_names
         block.parameters.map(&:last)
       end
+
+      # @api private
+      def inspect
+        "#<#{self.class.name} #{name} at #{block.source_location.join(":")}>"
+      end
+      alias_method :to_s, :inspect
     end
   end
 end

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

@@ -22,8 +22,9 @@ module ROM
 
         # @api private
         def create(*traits, **attrs)
-          tuple = tuple(*traits, **attrs)
           validate_keys(traits, attrs)
+
+          tuple = tuple(*traits, **attrs)
           persisted = persist(tuple)
 
           if tuple_evaluator.has_associations?(traits)
@@ -41,13 +42,29 @@ module ROM
 
         # @api private
         def persist(attrs)
-          relation.with(auto_struct: !tuple_evaluator.has_associations?).command(:create).call(attrs)
+          result = relation
+            .with(auto_struct: !tuple_evaluator.has_associations?)
+            .command(:create)
+            .call(attrs)
+
+          # Handle PK values generated by the factory
+          if pk? && (pks = attrs.values_at(*primary_key_names)).compact.size == primary_key_names.size
+            relation.by_pk(*pks).one!
+          elsif result
+            result
+          else
+            relation.where(attrs).one!
+          end
         end
 
         # @api private
         def primary_key_names
           relation.schema.primary_key.map(&:name)
         end
+
+        def pk?
+          primary_key_names.any?
+        end
       end
     end
   end

data/lib/rom/factory/builder.rb

@@ -28,6 +28,10 @@ module ROM::Factory
     #   @return [Module] Custom struct namespace
     option :struct_namespace, reader: false
 
+    # @!attribute [r] factories
+    #   @return [Module] Factories with other builders
+    option :factories, reader: true, optional: true
+
     # @api private
     def tuple(*traits, **attrs)
       tuple_evaluator.defaults(traits, attrs)
@@ -57,7 +61,11 @@ module ROM::Factory
 
     # @api private
     def tuple_evaluator
-      @__tuple_evaluator__ ||= TupleEvaluator.new(attributes, tuple_evaluator_relation, traits)
+      @__tuple_evaluator__ ||= TupleEvaluator.new(
+        attributes,
+        tuple_evaluator_relation,
+        traits
+      )
     end
 
     # @api private

data/lib/rom/factory/dsl.rb

@@ -12,26 +12,39 @@ module ROM
 
     class << self
       # @api private
-      def fake(*args, **options)
-        api = fetch_or_store(:faker, *args) do
+      def fake(*args, unique: false, **options)
+        factory, produce = fetch_or_store(:faker, unique, *args) do
           *ns, method_name = args
 
           const = ns.reduce(::Faker) do |obj, name|
-            obj.const_get(::Dry::Core::Inflector.camelize(name))
+            obj.const_get(::ROM::Inflector.camelize(name))
           end
 
-          const.method(method_name)
+          if unique
+            [const.unique, method_name]
+          else
+            [const, method_name]
+          end
         end
 
-        api.(**options)
+        factory.public_send(produce, **options)
       end
     end
 
     # Factory builder DSL
     #
     # @api public
-    class DSL < BasicObject
-      define_method(:rand, ::Kernel.instance_method(:rand))
+    class DSL < ::BasicObject
+      # @api private
+      module Kernel
+        %i[binding class instance_of? is_a? rand respond_to_missing? singleton_class].each do |meth|
+          define_method(meth, ::Kernel.instance_method(meth))
+        end
+
+        private :respond_to_missing?, :rand, :binding
+      end
+
+      include Kernel
 
       attr_reader :_name, :_relation, :_attributes, :_factories, :_struct_namespace, :_valid_names
       attr_reader :_traits
@@ -50,7 +63,13 @@ module ROM
 
       # @api private
       def call
-        ::ROM::Factory::Builder.new(_attributes, _traits, relation: _relation, struct_namespace: _struct_namespace)
+        ::ROM::Factory::Builder.new(
+          _attributes,
+          _traits,
+          relation: _relation,
+          struct_namespace: _struct_namespace,
+          factories: _factories
+        )
       end
 
       # Delegate to a builder and persist a struct
@@ -58,17 +77,15 @@ module ROM
       # @param [Symbol] The name of the registered builder
       #
       # @api public
-      def create(name, *args)
-        _factories[name, *args]
-      end
+      def create(name, *args) = _factories[name, *args]
 
       # Create a sequence attribute
       #
       # @param [Symbol] name The attribute name
       #
       # @api private
-      def sequence(meth, &block)
-        define_sequence(meth, block) if _valid_names.include?(meth)
+      def sequence(meth, &)
+        define_sequence(meth, &) if _valid_names.include?(meth)
       end
 
       # Set timestamp attributes
@@ -98,9 +115,13 @@ module ROM
       #   @example
       #     f.email { fake(:number, :between, from: 10, to: 100) }
       #
+      #   @example
+      #    f.email { fake(:internet, :email, unique: true) }
+      #
       #   @param [Symbol] genre The faker API identifier ie. :internet, :product etc.
       #   @param [Symbol] type The value type to generate
-      #   @param [Hash] options Additional arguments
+      #   @param [Hash] options Additional arguments, including unique: true will generate unique values
+      #
       #
       # @overload fake(genre, subgenre, type, **options)
       #   @example
@@ -114,11 +135,9 @@ module ROM
       # @see https://github.com/faker-ruby/faker/tree/master/doc
       #
       # @api public
-      def fake(type, *args, **options)
-        ::ROM::Factory.fake(type, *args, **options)
-      end
+      def fake(...) = ::ROM::Factory.fake(...)
 
-      def trait(name, parents = [], &block)
+      def trait(name, parents = [], &)
         _traits[name] = DSL.new(
           "#{_name}_#{name}",
           attributes: _traits.values_at(*parents).flat_map(&:elements).inject(
@@ -127,7 +146,7 @@ module ROM
           relation: _relation,
           factories: _factories,
           struct_namespace: _struct_namespace,
-          &block
+          &
         )._attributes
       end
 
@@ -139,12 +158,16 @@ module ROM
       # @example has-many
       #   f.association(:posts, count: 2)
       #
+      # @example adding traits
+      #   f.association(:posts, traits: [:published])
+      #
       # @param [Symbol] name The name of the configured association
       # @param [Hash] options Additional options
       # @option options [Integer] count Number of objects to generate
+      # @option options [Array<Symbol>] traits Traits to apply to the association
       #
       # @api public
-      def association(name, *traits, **options)
+      def association(name, *seq_traits, traits: EMPTY_ARRAY, **options)
         assoc = _relation.associations[name]
 
         if assoc.is_a?(::ROM::SQL::Associations::OneToOne) && options.fetch(:count, 1) > 1
@@ -153,15 +176,25 @@ module ROM
 
         builder = -> { _factories.for_relation(assoc.target) }
 
-        _attributes << attributes::Association.new(assoc, builder, *traits, **options)
+        _attributes << attributes::Association.new(
+          assoc,
+          builder,
+          *seq_traits,
+          *traits,
+          **options
+        )
       end
 
+      # @api private
+      def inspect = "#<#{self.class} name=#{_name}>"
+      alias_method :to_s, :inspect
+
       private
 
       # @api private
-      def method_missing(meth, *args, &block)
+      def method_missing(meth, ...)
         if _valid_names.include?(meth)
-          define_attr(meth, *args, &block)
+          define_attr(meth, ...)
         else
           super
         end
@@ -169,27 +202,26 @@ module ROM
 
       # @api private
       def respond_to_missing?(method_name, include_private = false)
-        _valid_names.include?(meth) || super
+        _valid_names.include?(method_name) || super
       end
 
       # @api private
-      def define_sequence(name, block)
-        _attributes << attributes::Callable.new(name, self, attributes::Sequence.new(name, &block))
+      def define_sequence(name, &)
+        _attributes << attributes::Callable.new(name, self, attributes::Sequence.new(name, &))
       end
 
       # @api private
       def define_attr(name, *args, &block)
-        _attributes << if block
-                         attributes::Callable.new(name, self, block)
-                       else
-                         attributes::Value.new(name, *args)
-                       end
+        _attributes <<
+          if block
+            attributes::Callable.new(name, self, block)
+          else
+            attributes::Value.new(name, *args)
+          end
       end
 
       # @api private
-      def attributes
-        ::ROM::Factory::Attributes
-      end
+      def attributes = ::ROM::Factory::Attributes
     end
   end
 end

data/lib/rom/factory/factories.rb

@@ -126,7 +126,7 @@ module ROM::Factory
     # @return [ROM::Factory::Builder]
     #
     # @api public
-    def define(spec, opts = EMPTY_HASH, &block)
+    def define(spec, opts = EMPTY_HASH, &)
       name, parent = spec.is_a?(Hash) ? spec.flatten(1) : spec
       namespace = opts[:struct_namespace]
       relation_name = opts.fetch(:relation) { infer_relation(name) }
@@ -137,7 +137,7 @@ module ROM::Factory
 
       builder =
         if parent
-          extend_builder(name, registry[parent], relation_name, namespace, &block)
+          extend_builder(name, registry[parent], relation_name, namespace, &)
         else
           relation = rom.relations[relation_name]
           DSL.new(
@@ -145,7 +145,7 @@ module ROM::Factory
             relation: relation,
             factories: self,
             struct_namespace: builder_struct_namespace(namespace),
-            &block
+            &
           ).call
         end
 
@@ -170,6 +170,7 @@ module ROM::Factory
     def [](name, *traits, **attrs)
       registry[name].struct_namespace(struct_namespace).persistable.create(*traits, **attrs)
     end
+    alias_method :create, :[]
 
     # Return in-memory struct builder
     #
@@ -180,6 +181,25 @@ module ROM::Factory
       @__structs__ ||= Structs.new(registry, struct_namespace)
     end
 
+    # Return a new, non-persisted struct
+    #
+    # @example create a struct with default attributes
+    #   MyFactory.build(:user)
+    #
+    # @example create a struct with some attributes overridden
+    #   MyFactory.build(:uesr, name: "Jane")
+    #
+    # @param [Symbol] name The name of the registered factory
+    # @param [Array<Symbol>] traits List of traits to apply
+    # @param [Hash] attrs optional attributes to override the defaults
+    #
+    # @return [ROM::Struct]
+    #
+    # @api public
+    def build(name, *traits, **attrs)
+      structs[name, *traits, **attrs]
+    end
+
     # Get factories with a custom struct namespace
     #
     # @example
@@ -213,16 +233,16 @@ module ROM::Factory
 
     # @api private
     def infer_factory_name(name)
-      ::Dry::Core::Inflector.singularize(name).to_sym
+      ::ROM::Inflector.singularize(name).to_sym
     end
 
     # @api private
     def infer_relation(name)
-      ::Dry::Core::Inflector.pluralize(name).to_sym
+      ::ROM::Inflector.pluralize(name).to_sym
     end
 
     # @api private
-    def extend_builder(name, parent, relation_name, ns, &block)
+    def extend_builder(name, parent, relation_name, ns, &)
       namespace = parent.options[:struct_namespace]
       namespace = builder_struct_namespace(ns) if ns
       relation = rom.relations.fetch(relation_name) { parent.relation }
@@ -232,7 +252,7 @@ module ROM::Factory
         relation: relation,
         factories: self,
         struct_namespace: namespace,
-        &block
+        &
       ).call
     end
   end

data/lib/rom/factory/sequences.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "concurrent/map"
 require "singleton"
 
 module ROM
@@ -24,12 +25,12 @@ module ROM
 
       # @api private
       def next(key)
-        registry[key] += 1
+        registry.compute(key) { |v| (v || 0).succ }
       end
 
       # @api private
       def reset
-        @registry = Concurrent::Map.new { |h, k| h[k] = 0 }
+        @registry = Concurrent::Map.new
         self
       end
     end