HornsAndHooves-flat_map 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7902561902733c34e2f37b66ae25ed17fded33ff38f6f0f013630137a87eacb6
-  data.tar.gz: ba3167200d89dad368a42d23dbe4bebcfc147f15879ef8a78835a609127aa20c
+  metadata.gz: fd4f2b02c245613b8d3f3346d2355ae2108a4342ddb9f9cd1e268ef87310f1b8
+  data.tar.gz: fdf3bf9c4a4ffaa3c6647d907d0e02846eabbc60f5d9b593555d1904f371e72d
 SHA512:
-  metadata.gz: 44f53062529bafb8ae96504dbaa6576e6e44c453749a01012c37a723726aa459a31f1f097e3e364a47ad1453d1609e1da7e87099d4cd27d0f2a2d8f365463bff
-  data.tar.gz: 5d8861f359ea9c460e0cbac177726143cf87b4d18299f43052a845fb0c74faf2aef483e828bbd7be06160a5d9c7719c6cd55c64c505f0a9d99fede9bf142feaa
+  metadata.gz: ded272e0095638c4173d099651186dedd3116e1ac4532c0473d7dd6f126227026b55c6346728630fffe2580f483b5c0521c982a8bb0231eecc0917d498fa56e5
+  data.tar.gz: 20037626c6382fd471dff4db1a41f7ec09f81e7a5bbbe0ff80ffa6b1990bda10a1992dbf989da33e77ad1c0da7e0a9767bfff69a8ade32dfaf0abb08b9bda2e5

data/lib/flat_map/errors.rb

@@ -49,7 +49,7 @@ module FlatMap
     end
 
     # Overridden to add suffixing support for mappings of mappers with name suffix
-    def add(attr, *args)
+    def add(attr, type, **options)
       attr = :"#{attr}_#{@base.suffix}" if attr != :base && @base.suffixed?
       super
     end

data/lib/flat_map/model_mapper/associations.rb

@@ -0,0 +1,148 @@
+module FlatMap
+  # This module enhances and modifies original FlatMap::OpenMapper::Persistence
+  # functionality for ActiveRecord models as targets.
+  module ModelMapper::Associations
+    extend ActiveSupport::Concern
+
+    # Raised when there is no active record association between models.
+    class AssociationError < StandardError; end
+
+    # ModelMethods class macros
+    module ClassMethods
+      # Build relation for given traits.
+      # Allows to create relation which loads data from all tables related to given traits.
+      # For example:
+      #
+      # class CommentMapper < FlatMap::ModelMapper
+      # end
+      #
+      # class ArticleMapper < FlatMap::ModelMapper
+      #   trait :with_comments do
+      #     mount :comments, mapper_class: CommentMapper
+      #   end
+      # end
+      #
+      # Following call:
+      # ArticleMapper.relation(%i[with_comments]).where(...)
+      #
+      # is same as:
+      # Article.includes(:comments).where(...)
+      #
+      #
+      # @param traits [Array<Symbol>]
+      # @return [ActiveRecord::Relation]
+      def relation(traits)
+        trait_associations = associations(traits)
+        target_class.includes(trait_associations).references(trait_associations)
+      end
+
+      # Return associations list for given traits based on current mapper mounting.
+      # This method allows to receive associations list for given traits.
+      # Then associations list could be used as parameters for .joins method
+      # to build active record relation to select data form tables related to traits.
+      # For example:
+      #
+      # class AuthorMapper < FlatMap::ModelMapper
+      # end
+      #
+      # class TagMapper < FlatMap::ModelMapper
+      # end
+      #
+      # class CommentMapper < FlatMap::ModelMapper
+      #   trait :with_author do
+      #     mount :author, mapper_class: AuthorMapper
+      #   end
+      # end
+      #
+      # class ArticleMapper < FlatMap::ModelMapper
+      #   trait :with_comments do
+      #     mount :comments, mapper_class: CommentMapper
+      #   end
+      #
+      #   trait :with_tags do
+      #     mount :tags, mapper_class: TagMapper
+      #   end
+      # end
+      #
+      # ArticleMapper.associations(%i[ with_comments ])
+      # => :comments
+      #
+      # ArticleMapper.associations(%i[ with_tags ])
+      # => :tags
+      #
+      # ArticleMapper.associations(%i[ with_comments with_tags ])
+      # => [:comments, :tags]
+      #
+      # ArticleMapper.associations(%i[ with_comments with_author ])
+      # => { comments: :author }
+      #
+      #
+      # @param traits [Array<Symbol>]
+      # @return       [Array,Hash]
+      def associations(traits)
+        build_associations(traits, target_class, false)
+      end
+
+      # Return associations list for given traits based on current mapper mounting.
+      #
+      # @param traits       [Array<Symbol>]
+      # @param context      [ActiveRecord::Base]
+      # @param include_self [Boolean]
+      # @return             [Array,Hash]
+      protected def build_associations(traits, context, include_self)
+        classes_list = find_dependency_classes(traits)
+
+        map_classes_to_associations(context, classes_list, include_self)
+      end
+
+      # Return associations list for given traits based on current mapper mounting.
+      #
+      # @param traits [Array<Symbol>]
+      # @return       [Array<Symbol>]
+      private def find_dependency_classes(traits)
+        mountings.map do |mounting|
+          mapper_class = mounting.mapper_class
+
+          if mounting.traited?
+            mapper_class.build_associations(traits, target_class, false) if traits.include?(mounting.trait_name)
+          else
+            mapper_class.build_associations(traits, target_class, true)
+          end
+        end.compact
+      end
+
+      # Map given classes to association object names.
+      #
+      # @param context      [ActiveRecord::Base]
+      # @param classes_list [Array<ActiveRecord::Base>]
+      # @param include_self [Boolean]
+      # @return             [Symbol,Array,Hash,nil]
+      private def map_classes_to_associations(context, classes_list, include_self)
+        if classes_list.empty?
+          include_self ? association_for_class(context) : nil
+        else
+          classes_list = classes_list.first if classes_list.length == 1
+
+          include_self ? { association_for_class(context) => classes_list } : classes_list
+        end
+      end
+
+      # Return association name for target_class in given context.
+      #
+      # @param context [ActiveRecord::Base]
+      # #return        [Symbol,nil]
+      private def association_for_class(context)
+        reflection = context.reflections.find do |_, reflection|
+          reflection.klass == target_class
+        end
+
+        unless reflection
+          raise AssociationError, "No association between #{context.name} and #{target_class.name} models."
+        end
+
+        reflection.first.to_sym
+      end
+    end
+  end
+end
+

data/lib/flat_map/model_mapper/persistence.rb

@@ -19,12 +19,24 @@ module FlatMap
       # Find a record of the +target_class+ by +id+ and use it as a
       # target for a new mapper, with a list of passed +traits+ applied
       # to it.
+      # When `preload: true` option passed calls mapper `relation` method
+      # with traits list. This allows to load all related objects in one query.
       #
       # @param [#to_i] id of the record
       # @param [*Symbol] traits
       # @return [FlatMap::Mapper] mapper
       def find(id, *traits, &block)
-        new(target_class.find(id), *traits, &block)
+        options = { preload: false }
+
+        options.merge!(traits.extract_options!)
+
+        if options[:preload]
+          record = relation(traits).find(id)
+        else
+          record = target_class.find(id)
+        end
+
+        new(record, *traits, &block)
       end
 
       # Fetch a class for the target of the mapper.

data/lib/flat_map/model_mapper.rb

@@ -184,9 +184,11 @@ module FlatMap
   class ModelMapper < OpenMapper
     extend ActiveSupport::Autoload
 
+    autoload :Associations
     autoload :Persistence
     autoload :Skipping
 
+    include Associations
     include Persistence
     include Skipping
 

data/lib/flat_map/open_mapper/associations.rb

@@ -0,0 +1,19 @@
+module FlatMap
+  # This module enhances and modifies original FlatMap::OpenMapper::Persistence
+  # functionality for ActiveRecord models as targets.
+  module OpenMapper::Associations
+    extend ActiveSupport::Concern
+
+    # ModelMethods class macros
+    module ClassMethods
+      # Return association list for given traits.
+      # Used in ModelMapper.
+      #
+      # @return [nil]
+      def associations(*)
+        nil
+      end
+    end
+  end
+end
+

data/lib/flat_map/open_mapper.rb

@@ -16,6 +16,7 @@ module FlatMap
 
     autoload :Mapping
     autoload :Mounting
+    autoload :Associations
     autoload :Traits
     autoload :Factory
     autoload :AttributeMethods
@@ -24,6 +25,7 @@ module FlatMap
 
     include Mapping
     include Mounting
+    include Associations
     include Traits
     include AttributeMethods
     include ActiveModel::Validations
@@ -53,13 +55,13 @@ module FlatMap
     # @param [Object] target Target of mapping
     # @param [*Symbol] traits List of traits
     # @raise [FlatMap::Mapper::NoTargetError]
-    def initialize(target, *traits)
+    def initialize(target, *traits, &block)
       raise NoTargetError.new(self.class) unless target
 
       @target, @traits = target, traits
 
       if block_given?
-        singleton_class.trait :extension, &Proc.new
+        singleton_class.trait :extension, &block
       end
     end
 

data/lib/flat_map/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FlatMap # :nodoc:
-  VERSION = "0.5.0" # :nodoc:
+  VERSION = "0.7.0" # :nodoc:
 end

data/spec/flat_map/mapper/mapping_spec.rb

@@ -35,10 +35,10 @@ module FlatMap
           with({:attr_a => :attr_a, :mapped_attr_b => :attr_b}, {:writer => false}).
           and_call_original
         expect(Mapping::Factory).to receive(:new).
-                         with(:attr_a, :attr_a, :writer => false).
+                         with(:attr_a, :attr_a, { :writer => false }).
                          and_call_original
         expect(Mapping::Factory).to receive(:new).
-                         with(:mapped_attr_b, :attr_b, :writer => false).
+                         with(:mapped_attr_b, :attr_b, { :writer => false }).
                          and_call_original
 
         MappingSpec::EmptyMapper.class_eval do

data/spec/flat_map/mapper/mounting_spec.rb

@@ -76,7 +76,7 @@ module FlatMap
     context 'defining mountings' do
       it "should use Factory for defining mappings" do
         expect(Mapper::Factory).to receive(:new).
-                        with(:foo, :mapper_class_name => 'FooMapper').
+                        with(:foo, { :mapper_class_name => 'FooMapper' }).
                         and_call_original
 
         expect{ MountingSpec::EmptyMapper.mount(:foo, :mapper_class_name => 'FooMapper') }.

data/spec/flat_map/mapper/persistence_spec.rb

@@ -54,10 +54,21 @@ module FlatMap
     describe '.find' do
       let(:target){ PersistenceSpec::TargetClass.new('a', 'b') }
 
-      it 'should delegate to target class to find object for mapper' do
-        expect(PersistenceSpec::TargetClass).to receive(:find).with(1).and_return(target)
-        expect(PersistenceSpec::TargetClassMapper).to receive(:new).with(target, :used_trait)
-        PersistenceSpec::TargetClassMapper.find(1, :used_trait)
+      context "with preload" do
+        it 'should preload tables and find object for mapper' do
+          expect(PersistenceSpec::TargetClassMapper).to receive_message_chain(:relation, :find).
+            with([:used_trait]).with(1).and_return(target)
+          expect(PersistenceSpec::TargetClassMapper).to receive(:new).with(target, :used_trait)
+          PersistenceSpec::TargetClassMapper.find(1, :used_trait, preload: true)
+        end
+      end
+
+      context "without preload" do
+        it 'should delegate to target class to find object for mapper' do
+          expect(PersistenceSpec::TargetClass).to receive(:find).with(1).and_return(target)
+          expect(PersistenceSpec::TargetClassMapper).to receive(:new).with(target, :used_trait)
+          PersistenceSpec::TargetClassMapper.find(1, :used_trait)
+        end
       end
     end
 

data/spec/flat_map/mapper/targeting_spec.rb

@@ -54,10 +54,21 @@ module FlatMap
     describe '.find' do
       let(:target){ ModelMethodsSpec::TargetClass.new('a', 'b') }
 
-      it 'should delegate to target class to find object for mapper' do
-        expect(ModelMethodsSpec::TargetClass).to receive(:find).with(1).and_return(target)
-        expect(ModelMethodsSpec::TargetClassMapper).to receive(:new).with(target, :used_trait)
-        ModelMethodsSpec::TargetClassMapper.find(1, :used_trait)
+      context "with preload" do
+        it 'should preload tables and find object for mapper' do
+          expect(ModelMethodsSpec::TargetClassMapper).to receive_message_chain(:relation, :find).
+            with([:used_trait]).with(1).and_return(target)
+          expect(ModelMethodsSpec::TargetClassMapper).to receive(:new).with(target, :used_trait)
+          ModelMethodsSpec::TargetClassMapper.find(1, :used_trait, preload: true)
+        end
+      end
+
+      context "without preload" do
+        it 'should delegate to target class to find object for mapper' do
+          expect(ModelMethodsSpec::TargetClass).to receive(:find).with(1).and_return(target)
+          expect(ModelMethodsSpec::TargetClassMapper).to receive(:new).with(target, :used_trait)
+          ModelMethodsSpec::TargetClassMapper.find(1, :used_trait)
+        end
       end
     end
 

data/spec/flat_map/model_mapper/associations_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+module FlatMap
+  module AssociationsListSpec
+    # Simulate active record models.
+    # Only .reflections method is used.
+    Reflection = Struct.new(:klass)
+
+    class Author
+      def self.reflections; {}; end
+    end
+
+    class Link
+      def self.reflections; {}; end
+    end
+
+    class Tag
+      def self.reflections; {}; end
+    end
+
+    class Category
+      def self.reflections; {}; end
+    end
+
+    class Comment
+      # belongs_to :author
+      # has_many :links
+
+      def self.reflections
+        {
+          "author" => Reflection.new(Author),
+          "links"  => Reflection.new(Link)
+        }
+      end
+    end
+
+    class Article
+      # has_many :comments
+      # has_many :tags
+
+      def self.reflections
+        {
+          "comments" => Reflection.new(Comment),
+          "tags"     => Reflection.new(Tag)
+        }
+      end
+
+      def self.joins(associations); end
+    end
+
+    # Mappers for models.
+    class AuthorMapper < FlatMap::ModelMapper; end
+
+    class LinkMapper < FlatMap::ModelMapper; end
+
+    class TagMapper < FlatMap::ModelMapper; end
+
+    class CategoryMapper < FlatMap::ModelMapper; end
+
+    class CommentMapper < FlatMap::ModelMapper
+      trait :with_author do
+        mount :author, mapper_class: AuthorMapper
+      end
+
+      trait :with_links do
+        mount :links, mapper_class: LinkMapper
+      end
+    end
+
+    class ArticleMapper < FlatMap::ModelMapper
+      trait :with_comments do
+        mount :comments, mapper_class: CommentMapper
+      end
+
+      trait :with_tags do
+        mount :tags, mapper_class: TagMapper
+      end
+
+      trait :with_category do
+        mount :category, mapper_class: CategoryMapper
+      end
+    end
+
+    describe ".relation" do
+      let(:relation) { double }
+      subject { ArticleMapper.relation(%i[ with_comments with_author ]) }
+
+      it "generates active record relation with correct associations" do
+        expect(Article).to receive_message_chain(:includes, :references).
+          with({ comments: :author }).with({ comments: :author }).
+          and_return(relation)
+
+        is_expected.to eq relation
+      end
+    end
+
+    describe ".associations" do
+      subject { ArticleMapper.associations(traits) }
+
+      context "one mounted class" do
+        let(:traits) { %i[ with_comments ] }
+
+        it { is_expected.to eq :comments }
+      end
+
+      context "nested mounted class" do
+        let(:traits) { %i[ with_comments with_author ] }
+
+        it { is_expected.to eq({ comments: :author }) }
+      end
+
+      context "mounted and nested mounted classes" do
+        let(:traits) { %i[ with_comments with_author with_tags ] }
+
+        it { is_expected.to eq([{ comments: :author }, :tags]) }
+      end
+
+      context "two nested mounted classes" do
+        let(:traits) { %i[ with_comments with_author with_links ] }
+
+        it { is_expected.to eq({ comments: [:author, :links] }) }
+      end
+
+      context "no relation between models" do
+        let(:traits) { %i[ with_category ] }
+
+        it do
+          expect { subject }.to raise_error(FlatMap::ModelMapper::Associations::AssociationError,
+                                            "No association between FlatMap::AssociationsListSpec::Article " \
+                                            "and FlatMap::AssociationsListSpec::Category models.")
+        end
+      end
+    end
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: HornsAndHooves-flat_map
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - HornsAndHooves
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-04 00:00:00.000000000 Z
+date: 2024-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -149,9 +149,11 @@ files:
 - lib/flat_map/mapping/writer/method.rb
 - lib/flat_map/mapping/writer/proc.rb
 - lib/flat_map/model_mapper.rb
+- lib/flat_map/model_mapper/associations.rb
 - lib/flat_map/model_mapper/persistence.rb
 - lib/flat_map/model_mapper/skipping.rb
 - lib/flat_map/open_mapper.rb
+- lib/flat_map/open_mapper/associations.rb
 - lib/flat_map/open_mapper/attribute_methods.rb
 - lib/flat_map/open_mapper/factory.rb
 - lib/flat_map/open_mapper/mapping.rb
@@ -181,6 +183,7 @@ files:
 - spec/flat_map/mapping/writer/method_spec.rb
 - spec/flat_map/mapping/writer/proc_spec.rb
 - spec/flat_map/mapping_spec.rb
+- spec/flat_map/model_mapper/associations_spec.rb
 - spec/flat_map/open_mapper_spec.rb
 - spec/spec_helper.rb
 - tmp/metric_fu/_data/20131218.yml
@@ -204,7 +207,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.9
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Deep object graph to a plain properties mapper
@@ -230,5 +233,6 @@ test_files:
 - spec/flat_map/mapping/writer/method_spec.rb
 - spec/flat_map/mapping/writer/proc_spec.rb
 - spec/flat_map/mapping_spec.rb
+- spec/flat_map/model_mapper/associations_spec.rb
 - spec/flat_map/open_mapper_spec.rb
 - spec/spec_helper.rb