artirix_data_models 0.22.1 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88e79f89e6e91ab1deda5af61d7dda701857db07
-  data.tar.gz: 4099f19094480614606364d876d0af9ea301ab2a
+  metadata.gz: 4bfb65d885ba816daff5dafaf4f725cbacf35a6e
+  data.tar.gz: 84baf5c1431d2b39438ae646e85c450183227f35
 SHA512:
-  metadata.gz: 71e7fdf8e33deacada7d9a656d2006f5aa1f8f29f2c2cf6fb57fb36a0b54b2ac9d971970558c02facd79c0a24653cd56dbf55efbf9a460db58fe8cab12de98ac
-  data.tar.gz: f7b8de3340efd86fe0515bf7d8f4d65e04880d0da1f5ae0ec0826f064cb53308d60608bcca7c297d5883e5652e1a8d96c0f013a6544dc52cf488c63067c880d9
+  metadata.gz: 04d9eb00b920c981e36cda90369f200df8c7449c5d9178a8bcd9f59d5c593ce3c6d3178ea2e7fb9954585e5a55ed323a7e02fafdf54141e605e6882a73c8e07b
+  data.tar.gz: 55772da2c303dd510e28956f13cebbad4e475b08c6a243813e3f373c08a73d2328ddfaca8c632829f6099f6732573d9ad1159afa673ac32aa36be2b6e77eacea

data/README.md

@@ -137,19 +137,21 @@ Your app should extend the `ArtirixDataModels::DAORegistry`. We can override the
 
 Also, the Registry class that you want to use in your app should have in its definition a call to `self.mark_as_main_registry`. This call must be **after the override of `setup_config`.**
 
+You can add loaders that will be called only and memoized with `set_persistent_loader` and loaders that will cbe called every time with `set_transient_loader`. `se_loader` is an alias of `set_persistent_loader`.
+
 ```ruby
 class DAORegistry < ArtirixDataModels::DAORegistry
   def setup_config
     super
 
-    set_loader(:aggregations_factory) { AggregationsFactory.new }
+    set_persistent_loader(:aggregations_factory) { AggregationsFactory.new }
 
-    set_loader(:yacht) { YachtDAO.new gateway: get(:gateway) }
-    set_loader(:article) { ArticleDAO.new gateway: get(:gateway) }
-    set_loader(:broker) { BrokerDAO.new gateway: get(:gateway) }
+    set_transient_loader(:yacht) { YachtDAO.new gateway: get(:gateway) }
+    set_transient_loader(:article) { ArticleDAO.new gateway: get(:gateway) }
+    set_transient_loader(:broker) { BrokerDAO.new gateway: get(:gateway) }
 
     set_loader(:artirix_hub_api_gateway) { ArtirixDataModels::DataGateway.new connection: ArtirixHubApiService::ConnectionLoader.connection }
-    set_loader(:lead) { LeadDAO.new gateway: get(:artirix_hub_api_gateway) }
+    set_transient_loader(:lead) { LeadDAO.new gateway: get(:artirix_hub_api_gateway) }
   end
 
 
@@ -159,6 +161,16 @@ class DAORegistry < ArtirixDataModels::DAORegistry
 end
 ```
 
+You can use the DAORegistry by invoking it directly (or calling its instance) `DAORegistry.get(:name)` or `DAORegistry.instance.get(:name)`.
+
+You can also use an identity map mode (see bellow)
+
+### Identity Map
+
+You can use `dao_registry = DAORegistry.with_identity_map`. Then, the DAO's default methods `get`, `find` and `get_some` will register the loaded models into the DAO, acting as an identity map, and will also use that identity map to check for the existence of models with those PKs, returning them if they are found.
+
+The Identity Map does not have a TTL, so use it only with transient DAOs -> you don't want the identity map to live between requests, since that will mean that the models will never be forgotten, not being able to see new fresh versions, with the extra problem of memory leak.
+
 ### initializer
 
 An initializer should be added for extra configuration.
@@ -315,6 +327,11 @@ end
 
 ## Changes
 
+### 0.23.0
+- DAORegistry now DI'ed into the DAOs and models, by adding `dao_registry_loader` or a direct `dao_registry`.
+- DAORegistry with support for Identity Map
+- deprecated the use of `Aggregation.from_json`, please use the factory.
+
 ### 0.22.1
 
 added message support for DataGateway exceptions

data/bin/rake

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/lib/artirix_data_models.rb

@@ -16,6 +16,7 @@ require 'artirix_cache_service'
 
 
 # loading features
+require 'artirix_data_models/with_dao_registry'
 require 'artirix_data_models/inspectable'
 require 'artirix_data_models/es_collection'
 require 'artirix_data_models/aggregation'

data/lib/artirix_data_models/aggregation.rb

@@ -1,14 +1,19 @@
 module ArtirixDataModels
   class CommonAggregation
     include Inspectable
+    include ArtirixDataModels::WithDAORegistry
+
     attr_accessor :name
 
     def initialize(name)
       @name = name
     end
 
-    def self.from_json(definition, value_class = Aggregation::Value)
-      DAORegistry.aggregations_factory.aggregation_from_json(definition, value_class: value_class, aggregation_class: self)
+    # DEPRECATED
+    def self.from_json(definition, value_class = Aggregation::Value, aggregations_factory: nil)
+      ActiveSupport::Deprecation.new('1.0', 'ArtirixDataModels').warn('`Aggregation.from_json` is deprecated in favour of `AggregationsFactory#aggregation_from_json`')
+      aggregations_factory ||= DAORegistry.get(:aggregations_factory)
+      aggregations_factory.aggregation_from_json(definition, value_class: value_class, aggregation_class: self)
     end
 
     def pretty_name

data/lib/artirix_data_models/aggregations_factory.rb

@@ -2,6 +2,8 @@ module ArtirixDataModels
   class AggregationsFactory
     DEFAULT_COLLECTION_CLASS_NAME = ''.freeze
 
+    include ArtirixDataModels::WithDAORegistry
+
     # AGGREGATION CLASS BUILDING
 
     def self.sorted_aggregation_class_based_on_index_on(index_array)
@@ -32,7 +34,12 @@ module ArtirixDataModels
     end
 
     def default_loader
-      proc { |aggregation| Aggregation.from_json aggregation }
+      aggregations_factory = self
+      proc { |definition|
+        aggregations_factory.aggregation_from_json definition,
+                                                   value_class: Aggregation::Value,
+                                                   aggregation_class: Aggregation
+      }
     end
 
     def get_loader(aggregation_name, collection_class)

data/lib/artirix_data_models/dao.rb

@@ -4,48 +4,76 @@ module ArtirixDataModels
 
     DELEGATED_METHODS = [
       :partial_mode_fields,
+
       :model_name,
       :model_class,
+
       :paths_factory,
       :fake_mode_factory,
+
       :gateway,
+
       :force_fake_enabled,
       :force_fake_disabled,
       :remove_force_fake,
       :fake?,
       :forced_fake_enabled?,
       :forced_fake_disabled?,
+
       :empty_collection,
       :empty_collection_for,
+
       :perform_get,
       :perform_post,
       :perform_put,
       :perform_delete,
+
+      :dao_registry,
+      :dao_registry=,
+      :set_dao_registry,
+      :dao_registry_loader,
+      :dao_registry_loader=,
+      :set_dao_registry_loader,
+      :set_default_dao_registry_loader,
+      :set_default_dao_registry,
     ]
 
     included do
       include ArtirixDataModels::DAOConcerns::WithResponseAdaptors
+      include ArtirixDataModels::WithDAORegistry
 
       attr_reader :basic_model_dao
       delegate *DELEGATED_METHODS, to: :basic_model_dao
     end
 
 
-    def initialize(gateway: nil, gateway_factory: nil, ignore_default_gateway: false, model_name: nil, model_class: nil, paths_factory: nil, fake_mode_factory: nil)
-      if gateway.blank? && gateway_factory.blank? && !ignore_default_gateway
-        gateway = ArtirixDataModels::DAORegistry.gateway
-      end
+    def initialize(dao_registry: nil,
+                   dao_registry_loader: nil,
+                   gateway: nil,
+                   gateway_factory: nil,
+                   ignore_default_gateway: false,
+                   model_name: nil,
+                   model_class: nil,
+                   paths_factory: nil,
+                   fake_mode_factory: nil)
 
       model_name        ||= default_model_name
       model_class       ||= default_model_class
       paths_factory     ||= default_path_factory
       fake_mode_factory ||= default_fake_mode_factory
-      @basic_model_dao  = ArtirixDataModels::DAORegistry.basic_class.new model_name:        model_name,
-                                                                         model_class:       model_class,
-                                                                         fake_mode_factory: fake_mode_factory,
-                                                                         paths_factory:     paths_factory,
-                                                                         gateway:           gateway,
-                                                                         gateway_factory:   gateway_factory
+
+      # temporary dao registry to load basic_class only
+      dr                = ArtirixDataModels::WithDAORegistry.loader_or_registry_or_default(dao_registry_loader: dao_registry_loader, dao_registry: dao_registry)
+      @basic_model_dao  = dr.get(:basic_class).new model_name:             model_name,
+                                                   model_class:            model_class,
+                                                   fake_mode_factory:      fake_mode_factory,
+                                                   paths_factory:          paths_factory,
+                                                   gateway:                gateway,
+                                                   gateway_factory:        gateway_factory,
+                                                   dao_registry:           dao_registry,
+                                                   dao_registry_loader:    dao_registry_loader,
+                                                   ignore_default_gateway: ignore_default_gateway
+
     end
 
     def default_model_name
@@ -88,24 +116,63 @@ module ArtirixDataModels
     end
 
     def get_full(model_pk, model_to_reload: nil, cache_adaptor: nil, **extra_options)
+      # we do not check in the registry, since it could be a reload
       model_to_reload ||= new_model_with_pk(model_pk)
       cache_adaptor   ||= cache_model_adaptor_for_get_full(model_pk, model_to_reload: model_to_reload, **extra_options)
-      basic_model_dao.get_full(model_pk, model_to_reload: model_to_reload, cache_adaptor: cache_adaptor, **extra_options)
+
+      model = basic_model_dao.get_full(model_pk, model_to_reload: model_to_reload, cache_adaptor: cache_adaptor, **extra_options)
+
+      complete_model model
     end
 
     def get(model_pk, cache_adaptor: nil, **extra_options)
+      model = dao_registry.get_model model_name, model_pk
+      return model if model.present?
+
       cache_adaptor ||= cache_model_adaptor_for_get(model_pk, **extra_options)
-      basic_model_dao.get(model_pk, cache_adaptor: cache_adaptor, **extra_options)
+
+      model = basic_model_dao.get(model_pk, cache_adaptor: cache_adaptor, **extra_options)
+
+      complete_model model
     end
 
     def find(model_pk, cache_adaptor: nil, **extra_options)
+      model = dao_registry.get_model model_name, model_pk
+      return model if model.present?
+
       cache_adaptor ||= cache_model_adaptor_for_find(model_pk, **extra_options)
-      basic_model_dao.find(model_pk, cache_adaptor: cache_adaptor, **extra_options)
+
+      model = basic_model_dao.find(model_pk, cache_adaptor: cache_adaptor, **extra_options)
+
+      complete_model model
     end
 
     def get_some(model_pks, cache_adaptor: nil, **extra_options)
-      cache_adaptor ||= cache_model_adaptor_for_get_some(model_pks, **extra_options)
-      basic_model_dao.get_some(model_pks, cache_adaptor: cache_adaptor, **extra_options)
+      registered = Array(model_pks).map do |model_pk|
+        [
+          model_pk,
+          dao_registry.get_model(model_name, model_pk)
+        ]
+      end.to_h
+
+      return registered.values if registered.values.all?(&:present?)
+
+      # load only the missing
+      missing_pks = registered.select { |_k, v| v.blank? }.keys
+
+      cache_adaptor ||= cache_model_adaptor_for_get_some(missing_pks, **extra_options)
+
+      models = basic_model_dao.get_some(missing_pks, cache_adaptor: cache_adaptor, **extra_options)
+
+      Array(models).each do |model|
+        complete_model model
+      end
+
+      list = registered.values.compact.concat(models)
+
+      # reorder with the same order of the model_pks
+      # (if for any reason it does not have a primary key or if it is not in the list, then use -1 so they are at the start)
+      list.sort_by { |m| pk = m.try :primary_key; model_pks.index(pk) || -1 }
     end
 
     private
@@ -134,6 +201,15 @@ module ArtirixDataModels
       ArtirixDataModels::CachedActionAdaptor::GetSome.new(dao_name: model_name, model_pks: model_pks, **extra_options)
     end
 
+    def complete_model(model)
+      if model
+        dao_registry.register_model model
+        model.try :set_dao_registry_loader, dao_registry_loader
+      end
+
+      model
+    end
+
     module FakeModes
       module Factory
 
@@ -145,15 +221,15 @@ module ArtirixDataModels
           raise NotImplementedError
         end
 
-        def get(model_pk)
+        def get(_model_pk)
           raise NotImplementedError
         end
 
-        def get_full(model_pk, given_model_to_reload = nil)
+        def get_full(_model_pk, given_model_to_reload = nil)
           raise NotImplementedError
         end
 
-        def get_some(model_pks)
+        def get_some(_model_pks)
           raise NotImplementedError
         end
 

data/lib/artirix_data_models/dao_concerns/with_response_adaptors.rb

@@ -25,7 +25,7 @@ module ArtirixDataModels
       end
 
       def response_adaptor_for_collection(from, size, collection_element_model_class = model_class)
-        model_adaptor_factory.collection collection_element_model_class, from, size
+        model_adaptor_factory.collection collection_element_model_class, from, size, dao_registry_loader
       end
 
       def response_adaptor_for_block(&block)

data/lib/artirix_data_models/dao_registry.rb

@@ -14,17 +14,18 @@ class ArtirixDataModels::DAORegistry
 
   # singleton instance
   def initialize
-    @_repository = {}
-    @_loaders    = {}
+    @_repository         = {}
+    @_persistent_loaders = {}
+    @_transient_loaders  = {}
 
     setup_config
   end
 
   def setup_config
-    set_loader(:aggregations_factory) { ArtirixDataModels::AggregationsFactory.new }
-    set_loader(:basic_class) { ArtirixDataModels::BasicModelDAO }
-    set_loader(:gateway) { ArtirixDataModels::DataGateway.new }
-    set_loader(:model_fields) { ArtirixDataModels::ModelFieldsDAO.new gateway: get(:gateway) }
+    set_persistent_loader(:aggregations_factory) { ArtirixDataModels::AggregationsFactory.new }
+    set_persistent_loader(:basic_class) { ArtirixDataModels::BasicModelDAO }
+    set_persistent_loader(:gateway) { ArtirixDataModels::DataGateway.new }
+    set_persistent_loader(:model_fields) { ArtirixDataModels::ModelFieldsDAO.new gateway: get(:gateway) }
   end
 
   def aggregations_factory
@@ -45,36 +46,95 @@ class ArtirixDataModels::DAORegistry
 
   def exist?(key)
     key = key.to_sym
-    @_repository.key?(key) || @_loaders.key?(key)
+    @_repository.key?(key) || @_persistent_loaders.key?(key) || @_transient_loaders.key?(key)
   end
 
-  def get(key)
-    @_repository[key.to_sym] || call_loader(key)
+  def get(key, override_dao_registry: nil)
+    x = @_repository[key.to_sym] || call_loader(key)
+    if x.present? && override_dao_registry.present? && x.respond_to?(:set_dao_registry)
+      x.set_dao_registry override_dao_registry
+    end
+
+    x
   end
 
-  def call_loader(key)
-    key               = key.to_sym
-    @_repository[key] = @_loaders[key].call
+  def set_transient_loader(key, loader = nil, &block)
+    key = key.to_sym
+
+    if block
+      @_transient_loaders[key] = block
+    elsif loader.respond_to? :call
+      @_transient_loaders[key] = loader
+    else
+      raise ArgumentError, "no block and no loader given for key #{key}"
+    end
   end
 
-  def set_loader(key, loader = nil, &block)
+  def set_persistent_loader(key, loader = nil, &block)
     key = key.to_sym
 
     if block
-      @_loaders[key] = block
+      @_persistent_loaders[key] = block
     elsif loader.respond_to? :call
-      @_loaders[key] = loader
+      @_persistent_loaders[key] = loader
     else
       raise ArgumentError, "no block and no loader given for key #{key}"
     end
   end
 
+  alias_method :set_loader, :set_persistent_loader
+
+  ################
+  # IDENTITY MAP #
+  ################
+
+  def with_identity_map
+    IdentityMap.new dao_registry: self
+  end
+
+  # IDENTITY MAP compatible
+  def register_model(_model)
+    # DO NOTHING
+    self
+  end
+
+  def unload_model(_model)
+    # DO NOTHING
+    self
+  end
+
+  def get_model(_model_dao_name, _primary_key)
+    # DO NOTHING
+    nil
+  end
+
+  private
+  def call_loader(key)
+    key = key.to_sym
+    if @_persistent_loaders[key]
+      @_repository[key] = @_persistent_loaders[key].call
+    elsif @_transient_loaders[key]
+      @_transient_loaders[key].call
+    else
+      raise LoaderNotFound, "no loader or transient found for #{key}"
+    end
+  end
+
+
   # static methods
 
   def self.set_loader(key, loader = nil, &block)
     instance.set_loader key, loader, &block
   end
 
+  def self.set_persistent_loader(key, loader = nil, &block)
+    instance.set_persistent_loader key, loader, &block
+  end
+
+  def self.set_transient_loader(key, loader = nil, &block)
+    instance.set_transient_loader key, loader, &block
+  end
+
   def self.get(key)
     instance.get key
   end
@@ -83,6 +143,10 @@ class ArtirixDataModels::DAORegistry
     instance.exist? key
   end
 
+  def self.with_identity_map
+    instance.with_identity_map
+  end
+
   def self.method_missing(method, *args, &block)
     if exist?(method)
       get(method)
@@ -95,4 +159,100 @@ class ArtirixDataModels::DAORegistry
     exist?(method) || super
   end
 
+  class LoaderNotFound < StandardError
+  end
+
+  class IdentityMap
+    include ArtirixDataModels::WithDAORegistry
+
+    def initialize(dao_registry_loader: nil, dao_registry: nil)
+      set_dao_registry_and_loader dao_registry_loader, dao_registry
+      @identity_map = {}
+    end
+
+    ##############################
+    # DELEGATING TO DAO REGISTRY #
+    ##############################
+
+    delegate :exist?, :aggregations_factory, to: :dao_registry
+
+    def respond_to_missing?(method_name, include_private = false)
+      dao_registry.respond_to? method_name, include_private
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      dao_registry.send method_name, *arguments, &block
+    end
+
+    def get(key, override_dao_registry: nil)
+      override_dao_registry ||= self
+      dao_registry.get key, override_dao_registry: override_dao_registry
+    end
+
+    ###########################
+    # IDENTITY MAP FOR MODELS #
+    ###########################
+
+    def register_model(model)
+      model_dao_name, primary_key = keys_from_model(model, action: :register)
+      return self unless model_dao_name.present? && primary_key.present?
+
+      log "register model #{model_dao_name}:#{primary_key}"
+
+      @identity_map[model_dao_name] ||= {}
+      @identity_map[model_dao_name][primary_key] = model
+
+      self
+    end
+
+    def unload_model(model)
+      model_dao_name, primary_key = keys_from_model(model, action: :unload)
+      return self unless model_dao_name.present? && primary_key.present?
+
+      log "unload model #{model_dao_name}:#{primary_key}"
+
+      @identity_map[model_dao_name] ||= {}
+      @identity_map[model_dao_name].delete primary_key
+
+      self
+    end
+
+    def get_model(model_dao_name, primary_key)
+      model_dao_name = model_dao_name.to_s
+      primary_key = primary_key.to_s
+      return nil unless model_dao_name.present? && primary_key.present?
+
+      @identity_map[model_dao_name] ||= {}
+      val = @identity_map[model_dao_name][primary_key]
+
+      if val.nil?
+        log "get model #{model_dao_name}:#{primary_key} NOT PRESENT"
+      else
+        log "get model #{model_dao_name}:#{primary_key} PRESENT!!!!!"
+      end
+
+      val
+    end
+
+    private
+    def log(msg)
+      ArtirixDataModels.logger.debug "DAO-REGISTRY-IDENTITY-MAP #{object_id} => #{msg}"
+    end
+
+    def keys_from_model(model, action: :use)
+      model_dao_name = model.try :model_dao_name
+      primary_key    = model.try :primary_key
+
+      if model_dao_name.blank?
+        ArtirixDataModels.logger.error("model does not have a `model_dao_name` #{model}: we cannot #{action} it")
+      end
+
+      if primary_key.blank?
+        ArtirixDataModels.logger.error("model does not have a `primary_key` #{model}: we cannot #{action} it")
+      end
+
+      [model_dao_name.to_s, primary_key.to_s]
+    end
+
+  end
 end

data/lib/artirix_data_models/daos/basic_model_dao.rb

@@ -1,15 +1,38 @@
 class ArtirixDataModels::BasicModelDAO
   include ArtirixDataModels::DAOConcerns::WithResponseAdaptors
+  include ArtirixDataModels::WithDAORegistry
 
-  attr_reader :model_name, :model_class, :paths_factory, :fake_mode_factory, :gateway_factory, :loaded_gateway
+  attr_reader :model_name, :model_class, :paths_factory, :fake_mode_factory, :gateway_factory
 
-  def initialize(model_name:, model_class:, paths_factory:, gateway:, fake_mode_factory:, gateway_factory:)
-    @model_name        = model_name
-    @model_class       = model_class
-    @paths_factory     = paths_factory
-    @loaded_gateway    = gateway
-    @gateway_factory   = gateway_factory
-    @fake_mode_factory = fake_mode_factory
+  def initialize(dao_registry: nil,
+                 dao_registry_loader: nil,
+                 model_name:,
+                 model_class:,
+                 paths_factory:,
+                 gateway:,
+                 fake_mode_factory:,
+                 gateway_factory:,
+                 ignore_default_gateway: false)
+
+    set_dao_registry_and_loader dao_registry_loader, dao_registry
+
+    @model_name             = model_name
+    @model_class            = model_class
+    @paths_factory          = paths_factory
+    @loaded_gateway         = gateway
+    @gateway_factory        = gateway_factory
+    @fake_mode_factory      = fake_mode_factory
+    @ignore_default_gateway = ignore_default_gateway
+  end
+
+  def default_gateway_available?
+    !@ignore_default_gateway
+  end
+
+  def loaded_gateway
+    @loaded_gateway ||= if gateway_factory.blank? && default_gateway_available?
+                          dao_registry.get(:gateway)
+                        end
   end
 
   ###########
@@ -62,7 +85,7 @@ class ArtirixDataModels::BasicModelDAO
     if fake?
       fake_mode_factory.partial_mode_fields
     else
-      ArtirixDataModels::DAORegistry.model_fields.partial_mode_fields_for model_name
+      dao_registry.get(:model_fields).partial_mode_fields_for model_name
     end
   end
 

data/lib/artirix_data_models/daos/model_fields_dao.rb

@@ -7,10 +7,15 @@
 class ArtirixDataModels::ModelFieldsDAO
   PARTIAL_FIELDS = {}
 
-  attr_reader :gateway
+  include ArtirixDataModels::WithDAORegistry
 
-  def initialize(gateway: nil)
-    @gateway = gateway || ArtirixDataModels::DAORegistry.gateway
+  def initialize(dao_registry: nil, dao_registry_loader: nil, gateway: nil)
+    set_dao_registry_and_loader dao_registry_loader, dao_registry
+    @gateway = gateway
+  end
+
+  def gateway
+    @gateway ||= dao_registry.gateway
   end
 
   def partial_mode_fields_for(model_name)

data/lib/artirix_data_models/es_collection.rb

@@ -3,9 +3,9 @@ require 'oj'
 module ArtirixDataModels
   class EsCollection
 
-    DEFAULT_SIZE = 10
+    DEFAULT_SIZE                = 10
     CACHE_KEY_SECTION_SEPARATOR = '/'.freeze
-    CACHE_KEY_RESULT_SEPARATOR = '\\'.freeze
+    CACHE_KEY_RESULT_SEPARATOR  = '\\'.freeze
 
     def self.work_with_kaminari
       require 'kaminari'
@@ -66,16 +66,26 @@ module ArtirixDataModels
     end
 
     include Enumerable
+    include ArtirixDataModels::WithDAORegistry
 
     attr_reader :klass_or_factory, :response, :from, :size
 
-    # @param klass_or_factory    [A Model Class|Callable] The model class or the Factory (callable object) to build the model
-    # @param response            [Hash]  The full response returned from the DataLayer
-    # @param from                [Int]  requested offset (0 by default)
-    # @param size                [Int]  requested amount of hits (10 by default)
+    # @param klass_or_factory     [A Model Class|Callable] The model class or the Factory (callable object) to build the model
+    # @param response             [Hash]  The full response returned from the DataLayer
+    # @param from                 [Int]  requested offset (0 by default)
+    # @param size                 [Int]  requested amount of hits (10 by default)
     # @param aggregations_factory [Int]  requested amount of hits (10 by default)
     #
-    def initialize(klass_or_factory, response:, from: 0, size: DEFAULT_SIZE, aggregations_factory: nil)
+    def initialize(klass_or_factory,
+                   response:,
+                   from: 0,
+                   size: DEFAULT_SIZE,
+                   dao_registry: nil,
+                   dao_registry_loader: nil,
+                   aggregations_factory: nil)
+
+      set_dao_registry_and_loader dao_registry_loader, dao_registry
+
       @klass_or_factory     = klass_or_factory
       @response             = response
       @from                 = from
@@ -84,7 +94,7 @@ module ArtirixDataModels
     end
 
     def aggregations_factory
-      @aggregations_factory || ArtirixDataModels::DAORegistry.aggregations_factory
+      @aggregations_factory || dao_registry.get(:aggregations_factory)
     end
 
     # The number of total hits for a query
@@ -170,13 +180,23 @@ module ArtirixDataModels
     def deserialize_document(document)
       info = info_from_document(document)
 
-      if model_factory
-        model_factory.call info
-      elsif model_class
-        model_class.new info
-      else
-        raise 'no model class, nor model factory'
+      model = if model_factory
+                model_factory.call info
+              elsif model_class
+                model_class.new info
+              else
+                raise 'no model class, nor model factory'
+              end
+      complete_model model
+    end
+
+    def complete_model(model)
+      if model
+        dao_registry.register_model model
+        model.try :set_dao_registry_loader, dao_registry_loader
       end
+
+      model
     end
 
     def model_factory

data/lib/artirix_data_models/gateway_response_adaptors/model_adaptor.rb

@@ -52,9 +52,15 @@ module ArtirixDataModels::GatewayResponseAdaptors
       new ->(data_list) { Array(data_list).map { |data_hash| model_class.new data_hash } }
     end
 
-    def self.collection(object_class_or_factory, from = 0, size = nil)
+    def self.collection(object_class_or_factory, from = 0, size = nil, dao_registry_loader = nil)
       size ||= ArtirixDataModels.configuration.try(:search_page_size).try(:default) || 10
-      new ->(data_collection) { ArtirixDataModels::EsCollection.new object_class_or_factory, response: data_collection, from: from, size: size }
+      new ->(data_collection) {
+        ArtirixDataModels::EsCollection.new object_class_or_factory,
+                                            response:            data_collection,
+                                            from:                from,
+                                            size:                size,
+                                            dao_registry_loader: dao_registry_loader
+      }
     end
 
     def self.with_block(&block)

data/lib/artirix_data_models/model.rb

@@ -324,6 +324,15 @@ module ArtirixDataModels
     module WithDAO
       extend ActiveSupport::Concern
 
+      included do
+        include ArtirixDataModels::WithDAORegistry
+      end
+
+      def initialize(dao_registry: nil, dao_registry_loader: nil, **properties)
+        set_dao_registry_and_loader dao_registry_loader, dao_registry
+        _set_properties properties
+      end
+
       def model_dao_name
         dao.model_name
       end
@@ -339,8 +348,8 @@ module ArtirixDataModels
 
       def load_dao
         key = self.class.dao_name
-        raise UndefinedDAOError unless key.present?
-        ArtirixDataModels::DAORegistry.send(key)
+        raise UndefinedDAOError, "`dao_name` not defined for #{self.class}" unless key.present?
+        dao_registry.get(key)
       end
 
       module ClassMethods

data/lib/artirix_data_models/version.rb

@@ -1,3 +1,3 @@
 module ArtirixDataModels
-  VERSION = '0.22.1'
+  VERSION = '0.23.0'
 end

data/lib/artirix_data_models/with_dao_registry.rb

@@ -0,0 +1,73 @@
+module ArtirixDataModels::WithDAORegistry
+  DEFAULT_DAO_REGISTRY_LOADER = ->() { ArtirixDataModels::DAORegistry.instance }
+
+  def self.loader_or_registry_or_default(dao_registry: nil, dao_registry_loader: nil)
+    raise ArgumentError, 'loader has to respond to :call' if dao_registry_loader.present? && !dao_registry_loader.respond_to?(:call)
+
+    if dao_registry_loader.respond_to? :call
+      dao_registry_loader.call
+    elsif dao_registry
+      dao_registry
+    else
+      DEFAULT_DAO_REGISTRY_LOADER.call
+    end
+  end
+
+  # set_xxx* methods can be chained (return self)
+  # xxx= methods return the value set
+
+  def dao_registry
+    dao_registry_loader.call
+  end
+
+  def dao_registry_loader
+    @dao_registry_loader || DEFAULT_DAO_REGISTRY_LOADER
+  end
+
+  attr_writer :dao_registry_loader
+
+  def set_dao_registry_loader(dao_registry_loader)
+    self.dao_registry_loader = dao_registry_loader
+    self
+  end
+
+  def dao_registry=(dao_registry)
+    if dao_registry
+      set_dao_registry_loader ->() { dao_registry }
+    else
+      set_default_dao_registry_loader
+    end
+
+    dao_registry
+  end
+
+  def set_dao_registry(dao_registry)
+    self.dao_registry = dao_registry
+    self
+  end
+
+  def default_dao_registry
+    DEFAULT_DAO_REGISTRY_LOADER.call
+  end
+
+  def set_default_dao_registry_loader
+    @dao_registry_loader = nil
+    self
+  end
+
+  alias_method :set_default_dao_registry, :set_default_dao_registry_loader
+
+  # will use the loader if present, if not it will use the registry, if not present it will do nothing.
+  def set_dao_registry_and_loader(dao_registry_loader, dao_registry)
+    raise ArgumentError, 'loader has to respond to :call' if dao_registry_loader.present? && !dao_registry_loader.respond_to?(:call)
+
+    if dao_registry_loader.respond_to? :call
+      set_dao_registry_loader dao_registry_loader
+    elsif dao_registry
+      set_dao_registry dao_registry
+    end
+
+    self
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: artirix_data_models
 version: !ruby/object:Gem::Version
-  version: 0.22.1
+  version: 0.23.0
 platform: ruby
 authors:
 - Eduardo Turiño
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-01 00:00:00.000000000 Z
+date: 2016-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -239,6 +239,7 @@ email:
 - eturino@artirix.com
 executables:
 - console
+- rake
 - setup
 extensions: []
 extra_rdoc_files: []
@@ -252,6 +253,7 @@ files:
 - Rakefile
 - artirix_data_models.gemspec
 - bin/console
+- bin/rake
 - bin/setup
 - lib/artirix_data_models.rb
 - lib/artirix_data_models/active_null.rb
@@ -284,6 +286,7 @@ files:
 - lib/artirix_data_models/spec_support/shared_examples/an_artirix_data_model_model.rb
 - lib/artirix_data_models/spec_support/shared_examples/has_attributes.rb
 - lib/artirix_data_models/version.rb
+- lib/artirix_data_models/with_dao_registry.rb
 - spec/artirix_data_models/dao_registry_spec.rb
 - spec/artirix_data_models/es_collection_spec.rb
 - spec/artirix_data_models/gateways/data_gateway_spec.rb