rom-factory 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5b3b45c040487ccf89d27457241ba3b117e51ed1a346e089d0da8f6bb223fb1
-  data.tar.gz: c56f6cac0fd002de3cb4b34e272704086cf4fd196e66e3931c82c9a17fbccfe1
+  metadata.gz: 2f2cad99dc93108f4bb7e9ac571ed198eaedee1b541b886fc018bb4501360817
+  data.tar.gz: 7fde94283a3d31672b6fa3ea8c082320524dc106025d4f50ac64ab3005bda6c7
 SHA512:
-  metadata.gz: decd39e777394bdc13022f9ae17c2a340bf325d66950c7487b6ffc60505e4b1097d437fc9e0a8cda287ac2e47aef71145ea5191d26b8d8d6fa6ecb9581e0fdd9
-  data.tar.gz: 2c2d34cfe48bcc3909b3599ea8fa241ae974c4993e021bcfdededbdba5a5c0f62e4a91a393033173ba649fcb74e3ded0458562d426c2b3b948275b1cc5639da6
+  metadata.gz: 8d14003a058a9eda9b2a407be0d4571de6213ded73532a01a0dbee8bdb3de47836a517425a742cf117b8674b67b64bf00d7e2ac9f47887f110a05d8143d7e0be
+  data.tar.gz: 389317084e6d7331c8e1fafcd304f34c458e393a63aee70debf0e04bd78d026b005a5f5ff5678eb3be29e499fdb2f1052b27a3602c31232d8ca14588cd506bfa

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 0.7.0 2018-11-17
+
+### Added
+
+* Support for traits (v-kolesnikov)
+* Support building structs with associations (@ianks)
+
+### Fixed
+
+* Overwritten attributes with dependencies (JanaVPetrova)
+
+[Compare v0.6.0...v0.7.0](https://github.com/rom-rb/rom-factory/compare/v0.6.0...v0.7.0)
+
 ## 0.6.0 2018-01-31
 
 ### Added

data/Gemfile

@@ -7,6 +7,7 @@ gem 'rspec', '~> 3.0'
 
 group :test do
   gem 'rom-sql', '~> 2.1'
+  gem 'rom-core', '~> 4.2', '>= 4.2.1'
   gem 'inflecto'
   gem 'pry-byebug', platforms: :mri
   gem 'pry', platforms: :jruby

data/README.md

@@ -1,6 +1,5 @@
 [gem]: https://rubygems.org/gems/rom-factory
 [travis]: https://travis-ci.org/rom-rb/rom-factory
-[gemnasium]: https://gemnasium.com/rom-rb/rom-factory
 [codeclimate]: https://codeclimate.com/github/rom-rb/rom-factory
 [inchpages]: http://inch-ci.org/github/rom-rb/rom-factory
 
@@ -8,7 +7,6 @@
 
 [![Gem Version](https://badge.fury.io/rb/rom-factory.svg)][gem]
 [![Build Status](https://travis-ci.org/rom-rb/rom-factory.svg?branch=master)][travis]
-[![Dependency Status](https://gemnasium.com/rom-rb/rom-factory.svg)][gemnasium]
 [![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]
 [![Inline docs](http://inch-ci.org/github/rom-rb/rom-factory.svg?branch=master)][inchpages]

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

@@ -2,24 +2,25 @@ module ROM::Factory
   module Attributes
     # @api private
     module Association
-      def self.new(assoc, builder, options = {})
-        const_get(assoc.definition.type).new(assoc, builder, options)
+      def self.new(assoc, builder, *traits, **options)
+        const_get(assoc.definition.type).new(assoc, builder, *traits, **options)
       end
 
       # @api private
       class Core
-        attr_reader :assoc, :options
+        attr_reader :assoc, :options, :traits
 
         # @api private
-        def initialize(assoc, builder, options = {})
+        def initialize(assoc, builder, *traits, **options)
           @assoc = assoc
           @builder_proc = builder
+          @traits = traits
           @options = options
         end
 
         # @api private
         def builder
-          @__builder__ ||= @builder_proc.()
+          @__builder__ ||= @builder_proc.call
         end
 
         # @api private
@@ -41,13 +42,16 @@ module ROM::Factory
       # @api private
       class ManyToOne < Core
         # @api private
-        def call(attrs = EMPTY_HASH)
+        def call(attrs, opts)
           if attrs.key?(name) && !attrs[foreign_key]
             assoc.associate(attrs, attrs[name])
           elsif !attrs[foreign_key]
-            struct = builder.persistable.create
+            struct = if opts.fetch(:persist, true)
+                       builder.persistable.create(*traits)
+                     else
+                       builder.struct(*traits, attrs)
+                     end
             tuple = { name => struct }
-
             assoc.associate(tuple, struct)
           end
         end
@@ -61,12 +65,19 @@ module ROM::Factory
       # @api private
       class OneToMany < Core
         # @api private
-        def call(attrs = EMPTY_HASH, parent)
+        def call(attrs = EMPTY_HASH, parent, persist: true)
           return if attrs.key?(name)
 
-          structs = count.times.map {
-            builder.persistable.create(assoc.associate(attrs, parent))
-          }
+          structs = Array.new(count).map do
+            # hash which contains the foreign key info, i.e: { user_id: 1 }
+            association_hash = assoc.associate(attrs, parent)
+
+            if persist
+              builder.persistable.create(*traits, association_hash)
+            else
+              builder.struct(*traits, attrs.merge(association_hash))
+            end
+          end
 
           { name => structs }
         end
@@ -85,10 +96,19 @@ module ROM::Factory
       # @api private
       class OneToOne < OneToMany
         # @api private
-        def call(attrs = EMPTY_HASH, parent)
+        def call(attrs = EMPTY_HASH, parent, opts)
           return if attrs.key?(name)
 
-          struct = builder.persistable.create(assoc.associate(attrs, parent))
+          association_hash = assoc.associate(attrs, parent)
+
+          struct = if opts.fetch(:persist, true)
+                     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
 
           { name => struct }
         end

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

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

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

@@ -19,16 +19,16 @@ module ROM
         end
 
         # @api private
-        def create(attrs = {})
-          tuple = tuple(attrs)
+        def create(*traits, **attrs)
+          tuple = tuple(*traits, attrs)
           persisted = persist(tuple)
 
-          if tuple_evaluator.has_associations?
-            tuple_evaluator.persist_associations(tuple, persisted)
+          if tuple_evaluator.has_associations?(traits)
+            tuple_evaluator.persist_associations(tuple, persisted, traits)
 
             pk = primary_key_names.map { |key| persisted[key] }
 
-            relation.by_pk(*pk).combine(*tuple_evaluator.assoc_names).first
+            relation.by_pk(*pk).combine(*tuple_evaluator.assoc_names(traits)).first
           else
             persisted
           end

data/lib/rom/factory/builder.rb

@@ -16,18 +16,22 @@ module ROM::Factory
     #   @return [ROM::Factory::Attributes]
     param :attributes
 
+    # @!attribute [r] traits
+    #   @return [Hash]
+    param :traits, default: -> { EMPTY_HASH }
+
     # @!attribute [r] relation
     #   @return [ROM::Relation]
     option :relation, reader: false
 
     # @api private
-    def tuple(attrs = EMPTY_HASH)
-      tuple_evaluator.defaults(attrs)
+    def tuple(*traits, **attrs)
+      tuple_evaluator.defaults(traits, attrs)
     end
 
     # @api private
-    def struct(attrs = EMPTY_HASH)
-      tuple_evaluator.struct(attrs)
+    def struct(*traits, **attrs)
+      tuple_evaluator.struct(*traits, attrs)
     end
     alias_method :create, :struct
 
@@ -43,7 +47,7 @@ module ROM::Factory
 
     # @api private
     def tuple_evaluator
-      @__tuple_evaluator__ ||= TupleEvaluator.new(attributes, options[:relation])
+      @__tuple_evaluator__ ||= TupleEvaluator.new(attributes, options[:relation], traits)
     end
 
     # @api private

data/lib/rom/factory/dsl.rb

@@ -26,6 +26,7 @@ module ROM
       define_method(:rand, ::Kernel.instance_method(:rand))
 
       attr_reader :_name, :_relation, :_attributes, :_factories, :_valid_names
+      attr_reader :_traits
 
       # @api private
       def initialize(name, attributes: AttributeRegistry.new, relation:, factories:)
@@ -33,13 +34,14 @@ module ROM
         @_relation = relation
         @_factories = factories
         @_attributes = attributes.dup
+        @_traits = {}
         @_valid_names = _relation.schema.attributes.map(&:name)
         yield(self)
       end
 
       # @api private
       def call
-        ::ROM::Factory::Builder.new(_attributes, relation: _relation)
+        ::ROM::Factory::Builder.new(_attributes, _traits, relation: _relation)
       end
 
       # Delegate to a builder and persist a struct
@@ -57,9 +59,7 @@ module ROM
       #
       # @api private
       def sequence(meth, &block)
-        if _valid_names.include?(meth)
-          define_sequence(meth, block)
-        end
+        define_sequence(meth, block) if _valid_names.include?(meth)
       end
 
       # Set timestamp attributes
@@ -100,6 +100,18 @@ module ROM
         ::ROM::Factory.fake(*args)
       end
 
+      def trait(name, parents = [], &block)
+        _traits[name] = DSL.new(
+          "#{_name}_#{name}",
+          attributes: _traits.values_at(*parents).flat_map(&:elements).inject(
+            AttributeRegistry.new, :<<
+          ),
+          relation: _relation,
+          factories: _factories,
+          &block
+        )._attributes
+      end
+
       # Create an association attribute
       #
       # @example belongs-to
@@ -113,11 +125,11 @@ module ROM
       # @option options [Integer] count Number of objects to generate (has-many only)
       #
       # @api public
-      def association(name, options = {})
+      def association(name, *traits, **options)
         assoc = _relation.associations[name]
         builder = -> { _factories.for_relation(assoc.target) }
 
-        _attributes << attributes::Association.new(assoc, builder, options)
+        _attributes << attributes::Association.new(assoc, builder, *traits, **options)
       end
 
       private
@@ -143,11 +155,11 @@ module ROM
 
       # @api private
       def define_attr(name, *args, &block)
-        if block
-          _attributes << attributes::Callable.new(name, self, block)
-        else
-          _attributes << 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

data/lib/rom/factory/factories.rb

@@ -39,8 +39,8 @@ module ROM::Factory
     # @return [ROM::Struct]
     #
     # @api public
-    def [](name, attrs = {})
-      registry[name].struct_namespace(struct_namespace).create(attrs)
+    def [](name, *traits, **attrs)
+      registry[name].struct_namespace(struct_namespace).create(*traits, attrs)
     end
   end
 
@@ -160,8 +160,8 @@ module ROM::Factory
     # @return [ROM::Struct]
     #
     # @api public
-    def [](name, attrs = {})
-      registry[name].persistable(struct_namespace).create(attrs)
+    def [](name, *traits, **attrs)
+      registry[name].persistable(struct_namespace).create(*traits, attrs)
     end
 
     # Return in-memory struct builder

data/lib/rom/factory/tuple_evaluator.rb

@@ -10,6 +10,9 @@ module ROM
       # @api private
       attr_reader :relation
 
+      # @api private
+      attr_reader :traits
+
       # @api private
       attr_reader :model
 
@@ -17,39 +20,61 @@ module ROM
       attr_reader :sequence
 
       # @api private
-      def initialize(attributes, relation)
+      def initialize(attributes, relation, traits = {})
         @attributes = attributes
         @relation = relation.with(auto_struct: true)
+        @traits = traits
         @model = @relation.combine(*assoc_names).mapper.model
         @sequence = Sequences[relation]
       end
 
       # @api private
-      def defaults(attrs)
-        evaluate(attrs).merge(attrs)
+      def defaults(traits, attrs, opts = EMPTY_HASH)
+        evaluate(traits, attrs, opts).merge(attrs)
       end
 
       # @api private
-      def struct(attrs)
-        model.new(struct_attrs.merge(defaults(attrs)))
+      def struct(*traits, attrs)
+        merged_attrs = struct_attrs.merge(defaults(traits, attrs, persist: false))
+        is_callable = proc { |_name, value| value.respond_to?(:call) }
+
+        callables = merged_attrs.select(&is_callable)
+        attributes = merged_attrs.reject(&is_callable)
+
+        materialized_callables = {}
+        callables.each do |_name, callable|
+          materialized_callables.merge!(callable.call(attributes, persist: false))
+        end
+
+        attributes.merge!(materialized_callables)
+        attributes = relation.output_schema.call(attributes)
+
+        model.new(attributes)
       end
 
       # @api private
-      def persist_associations(tuple, parent)
-        assoc_names.each do |name|
+      def persist_associations(tuple, parent, traits = [])
+        assoc_names(traits).each do |name|
           assoc = tuple[name]
-          assoc.(parent) if assoc.is_a?(Proc)
+          assoc.call(parent, persist: true) if assoc.is_a?(Proc)
         end
       end
 
       # @api private
-      def assoc_names
-        attributes.associations.map(&:name)
+      def assoc_names(traits = [])
+        assocs(traits).map(&:name)
+      end
+
+      def assocs(traits_names = [])
+        traits
+          .values_at(*traits_names)
+          .map(&:associations).flat_map(&:elements)
+          .inject(AttributeRegistry.new(attributes.associations.elements), :<<)
       end
 
       # @api private
-      def has_associations?
-        assoc_names.size > 0
+      def has_associations?(traits = [])
+        !assoc_names(traits).empty?
       end
 
       # @api private
@@ -60,12 +85,14 @@ module ROM
       private
 
       # @api private
-      def evaluate(attrs)
-        evaluate_values(attrs).merge(evaluate_associations(attrs))
+      def evaluate(traits, attrs, opts)
+        evaluate_values(attrs, opts)
+          .merge(evaluate_associations(attrs, opts))
+          .merge(evaluate_traits(traits, attrs, opts))
       end
 
       # @api private
-      def evaluate_values(attrs)
+      def evaluate_values(attrs, opts)
         attributes.values.tsort.each_with_object({}) do |attr, h|
           deps = attr.dependency_names.map { |k| h[k] }.compact
           result = attr.(attrs, *deps)
@@ -76,13 +103,23 @@ module ROM
         end
       end
 
+      def evaluate_traits(traits, attrs, opts)
+        return {} if traits.empty?
+
+        traits_attrs = self.traits.values_at(*traits).flat_map(&:elements)
+        registry = AttributeRegistry.new(traits_attrs)
+        self.class.new(registry, relation).defaults([], attrs, opts)
+      end
+
       # @api private
-      def evaluate_associations(attrs)
+      def evaluate_associations(attrs, opts)
         attributes.associations.each_with_object({}) do |assoc, h|
           if assoc.dependency?(relation)
-            h[assoc.name] = -> parent { assoc.call(parent) }
+            h[assoc.name] = ->(parent, call_opts) do
+              assoc.call(parent, opts.merge(call_opts))
+            end
           else
-            result = assoc.(attrs)
+            result = assoc.(attrs, opts)
             h.update(result) if result
           end
         end

data/lib/rom/factory/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module Factory
-    VERSION = '0.6.0'.freeze
+    VERSION = '0.7.0'.freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rom-factory
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Janis Miezitis
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-31 00:00:00.000000000 Z
+date: 2018-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable
@@ -132,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.4
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: ROM based builder library to make your specs awesome. DSL partially inspired