rom-factory 0.4.0 → 0.5.0

data/lib/rom/factory/attributes.rb

@@ -0,0 +1,12 @@
+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'

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

@@ -0,0 +1,98 @@
+module ROM::Factory
+  module Attributes
+    # @api private
+    module Association
+      def self.new(assoc, builder, options = {})
+        const_get(assoc.definition.type).new(assoc, builder, options)
+      end
+
+      # @api private
+      class Core
+        attr_reader :assoc, :options
+
+        # @api private
+        def initialize(assoc, builder, options = {})
+          @assoc = assoc
+          @builder_proc = builder
+          @options = options
+        end
+
+        # @api private
+        def builder
+          @__builder__ ||= @builder_proc.()
+        end
+
+        # @api private
+        def name
+          assoc.key
+        end
+
+        # @api private
+        def dependency?(*)
+          false
+        end
+
+        # @api private
+        def value?
+          false
+        end
+      end
+
+      # @api private
+      class ManyToOne < Core
+        # @api private
+        def call(attrs = EMPTY_HASH)
+          if attrs.key?(name) && !attrs[foreign_key]
+            assoc.associate(attrs, attrs[name])
+          elsif !attrs[foreign_key]
+            struct = builder.persistable.create
+            tuple = { name => struct }
+
+            assoc.associate(tuple, struct)
+          end
+        end
+
+        # @api private
+        def foreign_key
+          assoc.foreign_key
+        end
+      end
+
+      # @api private
+      class OneToMany < Core
+        # @api private
+        def call(attrs = EMPTY_HASH, parent)
+          return if attrs.key?(name)
+
+          structs = count.times.map {
+            builder.persistable.create(assoc.associate(attrs, parent))
+          }
+
+          { name => structs }
+        end
+
+        # @api private
+        def dependency?(rel)
+          assoc.source == rel
+        end
+
+        # @api private
+        def count
+          options.fetch(:count)
+        end
+      end
+
+      # @api private
+      class OneToOne < OneToMany
+        # @api private
+        def call(attrs = EMPTY_HASH, parent)
+          return if attrs.key?(name)
+
+          struct = builder.persistable.create(assoc.associate(attrs, parent))
+
+          { name => struct }
+        end
+      end
+    end
+  end
+end

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

@@ -1,19 +1,31 @@
 module ROM::Factory
   module Attributes
+    # @api private
     class Callable
-      attr_reader :dsl, :block
+      attr_reader :name, :dsl, :block
 
-      def initialize(dsl, block)
+      # @api private
+      def initialize(name, dsl = nil, &block)
+        @name = name
         @dsl = dsl
         @block = block
       end
 
-      def call
-        if block.is_a?(Proc)
-          dsl.instance_exec(&block)
-        else
-          block.call
-        end
+      # @api private
+      def call(attrs, *args)
+        return if attrs.key?(name)
+        result = dsl.instance_exec(*args, &block)
+        { name => result }
+      end
+
+      # @api private
+      def value?
+        true
+      end
+
+      # @api private
+      def dependency_names
+        block.parameters.map(&:last)
       end
     end
   end

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

@@ -1,18 +1,30 @@
 module ROM::Factory
   module Attributes
     class Sequence
-      def initialize(&block)
+      attr_reader :name, :count, :block
+
+      def initialize(name, &block)
+        @name = name
         @count = 0
         @block = block
       end
 
-      def call
-        @block.call(increment)
+      def call(attrs = EMPTY_HASH)
+        return if attrs.key?(name)
+        block.call(increment)
+      end
+
+      def to_proc
+        method(:call).to_proc
       end
 
       def increment
         @count += 1
       end
+
+      def dependency_names
+        EMPTY_ARRAY
+      end
     end
   end
 end

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

@@ -0,0 +1,31 @@
+module ROM::Factory
+  module Attributes
+    # @api private
+    class Value
+      attr_reader :name, :value
+
+      # @api private
+      def initialize(name, value)
+        @name = name
+        @value = value
+      end
+
+      # @api private
+      def call(attrs = EMPTY_HASH)
+        return if attrs.key?(name)
+
+        { name => value }
+      end
+
+      # @api private
+      def value?
+        true
+      end
+
+      # @api private
+      def dependency_names
+        EMPTY_ARRAY
+      end
+    end
+  end
+end

data/lib/rom/factory/builder.rb

@@ -1,55 +1,44 @@
-require 'delegate'
-require 'rom/factory/struct'
+require 'dry/core/constants'
+
+require 'rom/factory/tuple_evaluator'
+require 'rom/factory/builder/persistable'
 
 module ROM::Factory
+  # @api private
   class Builder
-    attr_reader :schema, :relation
+    include Dry::Core::Constants
 
-    def initialize(schema, relation)
-      @schema = schema
-      @relation = relation
-      @sequence = 0
-    end
+    # @api private
+    attr_reader :attributes
+
+    # @api private
+    attr_reader :tuple_evaluator
 
-    def tuple(attrs)
-      schema.map {|k, v| [k, v.call] }.to_h.merge(attrs)
+    # @api private
+    def initialize(attributes, relation)
+      @attributes = attributes
+      @tuple_evaluator = TupleEvaluator.new(attributes, relation)
     end
 
-    def create(attrs = {})
-      struct(tuple(attrs.merge(primary_key => next_id)))
+    # @api private
+    def tuple(attrs = EMPTY_HASH)
+      tuple_evaluator.defaults(attrs)
     end
 
-    def struct(attrs)
-      Struct.define(relation.name.relation, relation.schema.project(*attrs.keys)).new(attrs)
+    # @api private
+    def struct(attrs = EMPTY_HASH)
+      tuple_evaluator.struct(attrs)
     end
+    alias_method :create, :struct
 
+    # @api private
     def persistable
       Persistable.new(self)
     end
 
-    def primary_key
-      relation.primary_key
-    end
-
-    private
-
-    def next_id
-      @sequence += 1
-    end
-  end
-
-  class Persistable < SimpleDelegator
-    attr_reader :builder, :relation
-
-    def initialize(builder, relation = builder.relation)
-      super(builder)
-      @builder = builder
-      @relation = relation
-    end
-
-    def create(attrs = {})
-      tuple = builder.tuple(attrs)
-      struct(tuple.merge(primary_key => relation.insert(tuple)))
+    # @api private
+    def relation
+      tuple_evaluator.relation
     end
   end
 end

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

@@ -0,0 +1,51 @@
+require 'delegate'
+
+module ROM
+  module Factory
+    class Builder
+      # @api private
+      class Persistable < SimpleDelegator
+        # @api private
+        attr_reader :builder
+
+        # @api private
+        attr_reader :relation
+
+        # @api private
+        def initialize(builder, relation = builder.relation)
+          super(builder)
+          @builder = builder
+          @relation = relation
+        end
+
+        # @api private
+        def create(attrs = {})
+          tuple = tuple(attrs)
+          persisted = persist(tuple)
+
+          if tuple_evaluator.has_associations?
+            tuple_evaluator.persist_associations(tuple, persisted)
+
+            pk = primary_key_names.map { |key| persisted[key] }
+
+            relation.by_pk(*pk).combine(*tuple_evaluator.assoc_names).first
+          else
+            persisted
+          end
+        end
+
+        private
+
+        # @api private
+        def persist(attrs)
+          relation.with(auto_struct: !tuple_evaluator.has_associations?).command(:create).call(attrs)
+        end
+
+        # @api private
+        def primary_key_names
+          relation.schema.primary_key.map(&:name)
+        end
+      end
+    end
+  end
+end

data/lib/rom/factory/dsl.rb

@@ -2,12 +2,12 @@ require 'faker'
 require 'dry/core/inflector'
 
 require 'rom/factory/builder'
-require 'rom/factory/attributes/regular'
-require 'rom/factory/attributes/callable'
-require 'rom/factory/attributes/sequence'
+require 'rom/factory/attribute_registry'
+require 'rom/factory/attributes'
 
 module ROM
   module Factory
+    # @api private
     def self.fake(type, *args)
       api = Faker.const_get(Dry::Core::Inflector.classify(type.to_s))
       meth, *rest = args
@@ -19,55 +19,110 @@ module ROM
       end
     end
 
+    # Factory builder DSL
+    #
+    # @api public
     class DSL < BasicObject
-      attr_reader :_name, :_relation, :_schema, :_factories, :_valid_names
+      define_method(:rand, ::Kernel.instance_method(:rand))
 
-      def initialize(name, schema: {}, relation:, factories:, &block)
+      attr_reader :_name, :_relation, :_attributes, :_factories, :_valid_names
+
+      # @api private
+      def initialize(name, attributes: AttributeRegistry.new, relation:, factories:)
         @_name = name
         @_relation = relation
         @_factories = factories
-        @_schema = schema.dup
+        @_attributes = attributes.dup
         @_valid_names = _relation.schema.attributes.map(&:name)
         yield(self)
       end
 
+      # @api private
       def call
-        ::ROM::Factory::Builder.new(_schema, _relation)
+        ::ROM::Factory::Builder.new(_attributes, _relation)
       end
 
+      # Delegate to a builder and persist a struct
+      #
+      # @param [Symbol] The name of the registered builder
+      #
+      # @api public
       def create(name, *args)
         _factories[name, *args]
       end
 
+      # Create a sequence attribute
+      #
+      # @param [Symbol] name The attribute name
+      #
+      # @api private
       def sequence(meth, &block)
         if _valid_names.include?(meth)
           define_sequence(meth, block)
         end
       end
 
+      # Set timestamp attributes
+      #
+      # @api public
       def timestamps
         created_at { ::Time.now }
         updated_at { ::Time.now }
       end
 
+      # Create a fake value using Faker gem
+      #
+      # @overload fake(type)
+      #   @example
+      #     f.email { fake(:name) }
+      #
+      #   @param [Symbol] type The value type to generate
+      #
+      # @overload fake(api, type)
+      #   @example
+      #     f.email { fake(:internet, :email) }
+      #
+      #   @param [Symbol] api The faker API identifier ie. :internet, :product etc.
+      #   @param [Symbol] type The value type to generate
+      #
+      # @overload fake(api, type, *args)
+      #   @example
+      #     f.email { fake(:number, :between, 10, 100) }
+      #
+      #   @param [Symbol] api The faker API identifier ie. :internet, :product etc.
+      #   @param [Symbol] type The value type to generate
+      #   @param [Array] args Additional arguments
+      #
+      # @see https://github.com/stympy/faker/tree/master/doc
+      #
+      # @api public
       def fake(*args)
         ::ROM::Factory.fake(*args)
       end
 
-      def association(name)
+      # Create an association attribute
+      #
+      # @example belongs-to
+      #   f.association(:group)
+      #
+      # @example has-many
+      #   f.association(:posts, count: 2)
+      #
+      # @param [Symbol] name The name of the configured association
+      # @param [Hash] options Additional options
+      # @option options [Integer] count Number of objects to generate (has-many only)
+      #
+      # @api public
+      def association(name, options = {})
         assoc = _relation.associations[name]
-        other = _relation.__registry__[assoc.target]
-
-        fk = _relation.foreign_key(other)
-        pk = other.primary_key
-
-        block = -> { create(name)[pk] }
+        builder = -> { _factories.for_relation(assoc.target) }
 
-        _schema[fk] = attributes::Callable.new(self, block)
+        _attributes << attributes::Association.new(assoc, builder, options)
       end
 
       private
 
+      # @api private
       def method_missing(meth, *args, &block)
         if _valid_names.include?(meth)
           define_attr(meth, *args, &block)
@@ -76,18 +131,26 @@ module ROM
         end
       end
 
+      # @api private
+      def respond_to_missing?(method_name, include_private = false)
+        _valid_names.include?(meth) || super
+      end
+
+      # @api private
       def define_sequence(name, block)
-        _schema[name] = attributes::Callable.new(self, attributes::Sequence.new(&block))
+        _attributes << attributes::Callable.new(name, self, &attributes::Sequence.new(name, &block))
       end
 
+      # @api private
       def define_attr(name, *args, &block)
         if block
-          _schema[name] = attributes::Callable.new(self, block)
+          _attributes << attributes::Callable.new(name, self, &block)
         else
-          _schema[name] = attributes::Regular.new(*args)
+          _attributes << attributes::Value.new(name, *args)
         end
       end
 
+      # @api private
       def attributes
         ::ROM::Factory::Attributes
       end