artirix_data_models 0.32.0 → 1.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 68ae21ecebbb6e23b0e20e3cc9aed1dfbe0932ea
-  data.tar.gz: d9e1ff08adcb57dee94cea2b69cabde6483d8451
+  metadata.gz: b24c8e95bc1bd45a7df4207da2d02673adb6f721
+  data.tar.gz: 7bbe651de9dcdeb677687ad0839c10a2b1b45d14
 SHA512:
-  metadata.gz: e2adcab677b934257e58d7579a4b65ef46b97033b6b1caf8b16e86f2bbd07dd1cf7acd503c0d46488669f9d073ab7c6614694783280200976f37b29cb179d43e
-  data.tar.gz: c2f3b98d7b7d9a7c1e4eb428edc936083bb754d965a3a021a818d9a8054b87b3f8b74f16dc818c6cc42c2cfb4c3a32a70f113839413aff3e3aff13957be1409d
+  metadata.gz: 2065f4af7b36c022d2160d899ed4535b8cefe5764f3eabc282a48750d5b0616c1f16ee72d786c53d0c5cb8be226fbba7aeca6c1615f194057279a73384f74a4c
+  data.tar.gz: 213acba354ebaca8c02116674c08aa9b6db758c78f705250f67ddac5dc8c99765f9dd9a9d96cc9cf8059d94482e90c90867c0516abb2b4ad2492b38fe7aa5eee

data/.travis.yml

@@ -7,7 +7,7 @@ addons:
   code_climate:
     repo_token: 84e47c3e41ba9fbc2d639c167be45aa3f6c077374015309dac005ab51f713d83
 
-script: 'bundle exec rake spec'
+script: 'bundle exec rake'
 
 notifications:
   email:

data/Gemfile

@@ -17,3 +17,4 @@ group :test do
 end
 
 gem 'codeclimate-test-reporter', group: :test, require: nil
+gem 'simplecov'

data/README.md

@@ -131,7 +131,7 @@ TODO:
 
 ### The Registry
 
-Your app should extend the `ArtirixDataModels::DAORegistry`. We can override the `setup_config` method to add extra loaders.
+Your app should extend the `ArtirixDataModels::ADMRegistry`. We can override the `setup_config` method to add extra loaders.
 
 **important: do not forget to call `super` on `setup_config`.**
 
@@ -140,7 +140,7 @@ Also, the Registry class that you want to use in your app should have in its def
 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
+class ADMRegistry < ArtirixDataModels::ADMRegistry
   def setup_config
     super
 
@@ -161,13 +161,13 @@ 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 use the ADMRegistry by invoking it directly (or calling its instance) `ADMRegistry.get(:name)` or `ADMRegistry.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.
+You can use `adm_registry = ADMRegistry.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.
 
@@ -269,8 +269,8 @@ require File.expand_path("../../config/environment", __FILE__)
 require 'rspec/rails'
 # Add additional requires below this line. Rails is not loaded until this point!
 
-# force the use of the custom DAORegistry
-require 'dao_registry'
+# force the use of the custom ADMRegistry
+require 'adm_registry'
 ```
 
 #### Spec Support
@@ -327,6 +327,14 @@ end
 
 ## Changes
 
+### Breaking Changes!!: version 1.0.0.beta1
+
+- rename `DAORegistry` to `ADMRegistry`, and `dao_registry` to `adm_registry`. Passed the rename to all places (`adm_registry_loader`, etc.)
+
+- Registry changes:
+  - instance is thread safe controlled by a class level mutex, shared across all subclasses
+  - instance level mutexes to control changes in persistent (setting new persistent loader or saving in local registry a persisted value) and transient (setting new transient loader).
+
 ### 0.32.0
 
 - minor changes to allow backwards compatibility. Better mocking of gateway.

data/lib/artirix_data_models/{dao_registry.rb → adm_registry.rb}

@@ -1,22 +1,36 @@
-class ArtirixDataModels::DAORegistry
+class ArtirixDataModels::ADMRegistry
+  @instance_mutex = Mutex.new
+
+  def self.instance_mutex
+    ArtirixDataModels::ADMRegistry.instance_variable_get :@instance_mutex
+  end
 
   def self.instance
-    @__instance ||= new
+    instance_mutex.synchronize {
+      @instance = new unless @instance
+      @instance
+    }
   end
 
   def self.instance=(x)
-    @__instance = x
+    instance_mutex.synchronize {
+      @instance = x
+      @instance
+    }
   end
 
   def self.mark_as_main_registry
-    ArtirixDataModels::DAORegistry.instance = self.instance
+    ArtirixDataModels::ADMRegistry.instance = self.instance
   end
 
   # singleton instance
   def initialize
-    @_repository         = {}
-    @_persistent_loaders = {}
-    @_transient_loaders  = {}
+    @persistent_mutex = Mutex.new
+    @transient_mutex = Mutex.new
+
+    @repository = {}
+    @persistent_loaders = {}
+    @transient_loaders = {}
 
     setup_config
   end
@@ -46,13 +60,13 @@ class ArtirixDataModels::DAORegistry
 
   def exist?(key)
     key = key.to_sym
-    @_repository.key?(key) || @_persistent_loaders.key?(key) || @_transient_loaders.key?(key)
+    repository_has_key?(key) || has_persistent_loader?(key) || has_transient_loader?(key)
   end
 
-  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
+  def get(key, override_adm_registry: nil)
+    x = @repository[key.to_sym] || call_loader(key)
+    if x.present? && override_adm_registry.present? && x.respond_to?(:set_adm_registry)
+      x.set_adm_registry override_adm_registry
     end
 
     x
@@ -62,24 +76,28 @@ class ArtirixDataModels::DAORegistry
     key = key.to_sym
 
     if block
-      @_transient_loaders[key] = block
+      value_to_store = block
     elsif loader.respond_to? :call
-      @_transient_loaders[key] = loader
+      value_to_store = loader
     else
       raise ArgumentError, "no block and no loader given for key #{key}"
     end
+
+    @transient_mutex.synchronize { @transient_loaders[key] = value_to_store }
   end
 
   def set_persistent_loader(key, loader = nil, &block)
     key = key.to_sym
 
     if block
-      @_persistent_loaders[key] = block
+      value_to_store = block
     elsif loader.respond_to? :call
-      @_persistent_loaders[key] = loader
+      value_to_store = loader
     else
       raise ArgumentError, "no block and no loader given for key #{key}"
     end
+
+    @persistent_mutex.synchronize { @persistent_loaders[key] = value_to_store }
   end
 
   alias_method :set_loader, :set_persistent_loader
@@ -89,7 +107,7 @@ class ArtirixDataModels::DAORegistry
   ################
 
   def with_identity_map
-    IdentityMap.new dao_registry: self
+    IdentityMap.new adm_registry: self
   end
 
   # IDENTITY MAP compatible
@@ -111,15 +129,29 @@ class ArtirixDataModels::DAORegistry
   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
+    if @persistent_loaders[key]
+      @persistent_loaders[key].call.tap do |value_to_store|
+        @persistent_mutex.synchronize { @repository[key] = value_to_store }
+      end
+    elsif @transient_loaders[key]
+      @transient_loaders[key].call
     else
       raise LoaderNotFound, "no loader or transient found for #{key}"
     end
   end
 
+  def has_transient_loader?(key)
+    @transient_loaders.key?(key)
+  end
+
+  def has_persistent_loader?(key)
+    @persistent_loaders.key?(key)
+  end
+
+  def repository_has_key?(key)
+    @repository.key?(key)
+  end
+
 
   # static methods
 
@@ -163,10 +195,10 @@ class ArtirixDataModels::DAORegistry
   end
 
   class IdentityMap
-    include ArtirixDataModels::WithDAORegistry
+    include ArtirixDataModels::WithADMRegistry
 
-    def initialize(dao_registry_loader: nil, dao_registry: nil)
-      set_dao_registry_and_loader dao_registry_loader, dao_registry
+    def initialize(adm_registry_loader: nil, adm_registry: nil)
+      set_adm_registry_and_loader adm_registry_loader, adm_registry
       @identity_map = {}
     end
 
@@ -174,19 +206,19 @@ class ArtirixDataModels::DAORegistry
     # DELEGATING TO DAO REGISTRY #
     ##############################
 
-    delegate :exist?, :aggregations_factory, to: :dao_registry
+    delegate :exist?, :aggregations_factory, to: :adm_registry
 
     def respond_to_missing?(method_name, include_private = false)
-      dao_registry.respond_to? method_name, include_private
+      adm_registry.respond_to? method_name, include_private
     end
 
     def method_missing(method_name, *arguments, &block)
-      dao_registry.send method_name, *arguments, &block
+      adm_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
+    def get(key, override_adm_registry: nil)
+      override_adm_registry ||= self
+      adm_registry.get key, override_adm_registry: override_adm_registry
     end
 
     ###########################
@@ -241,7 +273,7 @@ class ArtirixDataModels::DAORegistry
 
     def keys_from_model(model, action: :use)
       model_dao_name = model.try :model_dao_name
-      primary_key    = model.try :primary_key
+      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")

data/lib/artirix_data_models/aggregation.rb

@@ -1,7 +1,7 @@
 module ArtirixDataModels
   class CommonAggregation
     include Inspectable
-    include ArtirixDataModels::WithDAORegistry
+    include ArtirixDataModels::WithADMRegistry
 
     attr_accessor :name
 
@@ -12,7 +12,7 @@ module ArtirixDataModels
     # 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 ||= ADMRegistry.get(:aggregations_factory)
       aggregations_factory.aggregation_from_json(definition, value_class: value_class, aggregation_class: self)
     end
 

data/lib/artirix_data_models/aggregations_factory.rb

@@ -2,7 +2,7 @@ module ArtirixDataModels
   class AggregationsFactory
     DEFAULT_COLLECTION_CLASS_NAME = ''.freeze
 
-    include ArtirixDataModels::WithDAORegistry
+    include ArtirixDataModels::WithADMRegistry
 
     # AGGREGATION CLASS BUILDING
 

data/lib/artirix_data_models/dao.rb

@@ -28,27 +28,27 @@ module ArtirixDataModels
       :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,
+      :adm_registry,
+      :adm_registry=,
+      :set_adm_registry,
+      :adm_registry_loader,
+      :adm_registry_loader=,
+      :set_adm_registry_loader,
+      :set_default_adm_registry_loader,
+      :set_default_adm_registry,
     ]
 
     included do
       include ArtirixDataModels::DAOConcerns::WithResponseAdaptors
-      include ArtirixDataModels::WithDAORegistry
+      include ArtirixDataModels::WithADMRegistry
 
       attr_reader :basic_model_dao
       delegate *DELEGATED_METHODS, to: :basic_model_dao
     end
 
 
-    def initialize(dao_registry: nil,
-                   dao_registry_loader: nil,
+    def initialize(adm_registry: nil,
+                   adm_registry_loader: nil,
                    gateway: nil,
                    gateway_factory: nil,
                    ignore_default_gateway: false,
@@ -63,8 +63,8 @@ module ArtirixDataModels
       fake_mode_factory ||= default_fake_mode_factory
 
       # temporary dao registry to load basic_class only
-      create_basic_model_dao dao_registry: dao_registry,
-                             dao_registry_loader: dao_registry_loader,
+      create_basic_model_dao adm_registry: adm_registry,
+                             adm_registry_loader: adm_registry_loader,
                              fake_mode_factory: fake_mode_factory,
                              gateway: gateway,
                              gateway_factory: gateway_factory,
@@ -75,8 +75,8 @@ module ArtirixDataModels
 
     end
 
-    def create_basic_model_dao(dao_registry:,
-                               dao_registry_loader:,
+    def create_basic_model_dao(adm_registry:,
+                               adm_registry_loader:,
                                fake_mode_factory:,
                                gateway:,
                                gateway_factory:,
@@ -86,8 +86,8 @@ module ArtirixDataModels
                                paths_factory:,
                                **other_basic_model_dao_params)
 
-      dr = ArtirixDataModels::WithDAORegistry.loader_or_registry_or_default dao_registry_loader: dao_registry_loader,
-                                                                            dao_registry: dao_registry
+      dr = ArtirixDataModels::WithADMRegistry.loader_or_registry_or_default adm_registry_loader: adm_registry_loader,
+                                                                            adm_registry: adm_registry
 
       basic_model_class = dr.get(:basic_class)
 
@@ -97,8 +97,8 @@ module ArtirixDataModels
                                                paths_factory: paths_factory,
                                                gateway: gateway,
                                                gateway_factory: gateway_factory,
-                                               dao_registry: dao_registry,
-                                               dao_registry_loader: dao_registry_loader,
+                                               adm_registry: adm_registry,
+                                               adm_registry_loader: adm_registry_loader,
                                                ignore_default_gateway: ignore_default_gateway,
                                                **other_basic_model_dao_params
     end
@@ -153,7 +153,7 @@ module ArtirixDataModels
     end
 
     def get(model_pk, cache_adaptor: nil, **extra_options)
-      model = dao_registry.get_model model_name, model_pk
+      model = adm_registry.get_model model_name, model_pk
       return model if model.present?
 
       cache_adaptor ||= cache_model_adaptor_for_get(model_pk, **extra_options)
@@ -164,7 +164,7 @@ module ArtirixDataModels
     end
 
     def find(model_pk, cache_adaptor: nil, **extra_options)
-      model = dao_registry.get_model model_name, model_pk
+      model = adm_registry.get_model model_name, model_pk
       return model if model.present?
 
       cache_adaptor ||= cache_model_adaptor_for_find(model_pk, **extra_options)
@@ -178,7 +178,7 @@ module ArtirixDataModels
       registered = Array(model_pks).map do |model_pk|
         [
           model_pk,
-          dao_registry.get_model(model_name, model_pk)
+          adm_registry.get_model(model_name, model_pk)
         ]
       end.to_h
 
@@ -230,8 +230,8 @@ module ArtirixDataModels
 
     def complete_model(model)
       if model
-        dao_registry.register_model model
-        model.try :set_dao_registry_loader, dao_registry_loader
+        adm_registry.register_model model
+        model.try :set_adm_registry_loader, adm_registry_loader
       end
 
       model

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, dao_registry_loader
+        model_adaptor_factory.collection collection_element_model_class, from, size, adm_registry_loader
       end
 
       def response_adaptor_for_block(&block)

data/lib/artirix_data_models/daos/basic_model_dao.rb

@@ -1,11 +1,11 @@
 class ArtirixDataModels::BasicModelDAO
   include ArtirixDataModels::DAOConcerns::WithResponseAdaptors
-  include ArtirixDataModels::WithDAORegistry
+  include ArtirixDataModels::WithADMRegistry
 
   attr_reader :model_name, :model_class, :paths_factory, :fake_mode_factory, :gateway_factory
 
-  def initialize(dao_registry: nil,
-                 dao_registry_loader: nil,
+  def initialize(adm_registry: nil,
+                 adm_registry_loader: nil,
                  model_name:,
                  model_class:,
                  paths_factory:,
@@ -14,7 +14,7 @@ class ArtirixDataModels::BasicModelDAO
                  gateway_factory:,
                  ignore_default_gateway: false)
 
-    set_dao_registry_and_loader dao_registry_loader, dao_registry
+    set_adm_registry_and_loader adm_registry_loader, adm_registry
 
     @model_name = model_name
     @model_class = model_class
@@ -31,7 +31,7 @@ class ArtirixDataModels::BasicModelDAO
 
   def loaded_gateway
     @loaded_gateway ||= if gateway_factory.blank? && default_gateway_available?
-                          dao_registry.get(:gateway)
+                          adm_registry.get(:gateway)
                         end
   end
 
@@ -95,7 +95,7 @@ class ArtirixDataModels::BasicModelDAO
     if fake?
       fake_mode_factory.partial_mode_fields
     else
-      dao_registry.get(:model_fields).partial_mode_fields_for model_name
+      adm_registry.get(:model_fields).partial_mode_fields_for model_name
     end
   end
 

data/lib/artirix_data_models/daos/model_fields_dao.rb

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

data/lib/artirix_data_models/es_collection.rb

@@ -66,7 +66,7 @@ module ArtirixDataModels
     end
 
     include Enumerable
-    include ArtirixDataModels::WithDAORegistry
+    include ArtirixDataModels::WithADMRegistry
 
     attr_reader :klass_or_factory, :response, :from, :size
 
@@ -80,11 +80,11 @@ module ArtirixDataModels
                    response:,
                    from: 0,
                    size: DEFAULT_SIZE,
-                   dao_registry: nil,
-                   dao_registry_loader: nil,
+                   adm_registry: nil,
+                   adm_registry_loader: nil,
                    aggregations_factory: nil)
 
-      set_dao_registry_and_loader dao_registry_loader, dao_registry
+      set_adm_registry_and_loader adm_registry_loader, adm_registry
 
       @klass_or_factory     = klass_or_factory
       @response             = response
@@ -94,7 +94,7 @@ module ArtirixDataModels
     end
 
     def aggregations_factory
-      @aggregations_factory || dao_registry.get(:aggregations_factory)
+      @aggregations_factory || adm_registry.get(:aggregations_factory)
     end
 
     # The number of total hits for a query
@@ -192,8 +192,8 @@ module ArtirixDataModels
 
     def complete_model(model)
       if model
-        dao_registry.register_model model
-        model.try :set_dao_registry_loader, dao_registry_loader
+        adm_registry.register_model model
+        model.try :set_adm_registry_loader, adm_registry_loader
       end
 
       model

data/lib/artirix_data_models/gateway_response_adaptors/model_adaptor.rb

@@ -52,14 +52,14 @@ 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, dao_registry_loader = nil)
+    def self.collection(object_class_or_factory, from = 0, size = nil, adm_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,
-                                            dao_registry_loader: dao_registry_loader
+                                            adm_registry_loader: adm_registry_loader
       }
     end
 

data/lib/artirix_data_models/model.rb

@@ -325,11 +325,11 @@ module ArtirixDataModels
       extend ActiveSupport::Concern
 
       included do
-        include ArtirixDataModels::WithDAORegistry
+        include ArtirixDataModels::WithADMRegistry
       end
 
-      def initialize(dao_registry: nil, dao_registry_loader: nil, **properties)
-        set_dao_registry_and_loader dao_registry_loader, dao_registry
+      def initialize(adm_registry: nil, adm_registry_loader: nil, **properties)
+        set_adm_registry_and_loader adm_registry_loader, adm_registry
         _set_properties properties
       end
 
@@ -349,7 +349,7 @@ module ArtirixDataModels
       def load_dao
         key = self.class.dao_name
         raise UndefinedDAOError, "`dao_name` not defined for #{self.class}" unless key.present?
-        dao_registry.get(key)
+        adm_registry.get(key)
       end
 
       module ClassMethods

data/lib/artirix_data_models/spec_support/gateway_mock.rb

@@ -27,10 +27,12 @@ def mock_gateway_response(response:,
                           authorization_bearer: nil,
                           authorization_token_hash: nil,
                           gateway: nil,
+                          gateway_repository_name: :gateway,
                           headers: nil,
                           expect: false,
                           &block)
-  gateway ||= ArtirixDataModels::DAORegistry.gateway
+
+  gateway ||= ArtirixDataModels::ADMRegistry.instance.get(gateway_repository_name)
 
   callable = block_given? ? block : ->(x) { x }
 
@@ -65,9 +67,10 @@ def mock_gateway_not_found_response(method:,
                                     authorization_bearer: nil,
                                     authorization_token_hash: nil,
                                     gateway: nil,
+                                    gateway_repository_name: :gateway,
                                     headers: nil)
 
-  gateway ||= ArtirixDataModels::DAORegistry.gateway
+  gateway ||= ArtirixDataModels::ADMRegistry.instance.get(gateway_repository_name)
 
   params_hash = {
     path: path,

data/lib/artirix_data_models/spec_support/shared_examples/an_artirix_data_model_dao.rb

@@ -98,7 +98,7 @@ shared_examples_for 'an ArtirixDataModel DAO' do
     end
 
     Given do
-      allow(subject.dao_registry).to receive(:get).with(:model_fields).and_return(model_fields_dao)
+      allow(subject.adm_registry).to receive(:get).with(:model_fields).and_return(model_fields_dao)
     end
 
     When(:result) { subject.partial_mode_fields }

data/lib/artirix_data_models/version.rb

@@ -1,3 +1,3 @@
 module ArtirixDataModels
-  VERSION = '0.32.0'
+  VERSION = '1.0.0.beta1'
 end

data/lib/artirix_data_models/with_adm_registry.rb

@@ -0,0 +1,73 @@
+module ArtirixDataModels::WithADMRegistry
+  DEFAULT_DAO_REGISTRY_LOADER = ->() { ArtirixDataModels::ADMRegistry.instance }
+
+  def self.loader_or_registry_or_default(adm_registry: nil, adm_registry_loader: nil)
+    raise ArgumentError, 'loader has to respond to :call' if adm_registry_loader.present? && !adm_registry_loader.respond_to?(:call)
+
+    if adm_registry_loader.respond_to? :call
+      adm_registry_loader.call
+    elsif adm_registry
+      adm_registry
+    else
+      DEFAULT_DAO_REGISTRY_LOADER.call
+    end
+  end
+
+  # set_xxx* methods can be chained (return self)
+  # xxx= methods return the value set
+
+  def adm_registry
+    adm_registry_loader.call
+  end
+
+  def adm_registry_loader
+    @adm_registry_loader || DEFAULT_DAO_REGISTRY_LOADER
+  end
+
+  attr_writer :adm_registry_loader
+
+  def set_adm_registry_loader(adm_registry_loader)
+    self.adm_registry_loader = adm_registry_loader
+    self
+  end
+
+  def adm_registry=(adm_registry)
+    if adm_registry
+      set_adm_registry_loader ->() { adm_registry }
+    else
+      set_default_adm_registry_loader
+    end
+
+    adm_registry
+  end
+
+  def set_adm_registry(adm_registry)
+    self.adm_registry = adm_registry
+    self
+  end
+
+  def default_adm_registry
+    DEFAULT_DAO_REGISTRY_LOADER.call
+  end
+
+  def set_default_adm_registry_loader
+    @adm_registry_loader = nil
+    self
+  end
+
+  alias_method :set_default_adm_registry, :set_default_adm_registry_loader
+
+  # will use the loader if present, if not it will use the registry, if not present it will do nothing.
+  def set_adm_registry_and_loader(adm_registry_loader, adm_registry)
+    raise ArgumentError, 'loader has to respond to :call' if adm_registry_loader.present? && !adm_registry_loader.respond_to?(:call)
+
+    if adm_registry_loader.respond_to? :call
+      set_adm_registry_loader adm_registry_loader
+    elsif adm_registry
+      set_adm_registry adm_registry
+    end
+
+    self
+  end
+
+end

data/lib/artirix_data_models.rb

@@ -16,7 +16,7 @@ require 'artirix_cache_service'
 
 
 # loading features
-require 'artirix_data_models/with_dao_registry'
+require 'artirix_data_models/with_adm_registry'
 require 'artirix_data_models/inspectable'
 require 'artirix_data_models/es_collection'
 require 'artirix_data_models/aggregation'
@@ -35,7 +35,7 @@ require 'artirix_data_models/dao_concerns/with_response_adaptors'
 require 'artirix_data_models/dao'
 require 'artirix_data_models/daos/model_fields_dao'
 require 'artirix_data_models/daos/basic_model_dao'
-require 'artirix_data_models/dao_registry'
+require 'artirix_data_models/adm_registry'
 require 'artirix_data_models/fake_response_factory'
 require 'artirix_data_models/active_null'
 

data/spec/artirix_data_models/{dao_registry_spec.rb → adm_registry_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe ArtirixDataModels::DAORegistry, type: :model do
+RSpec.describe ArtirixDataModels::ADMRegistry, type: :model do
   Given(:subject) { described_class.instance }
 
   # common config mock

data/spec/spec_helper.rb

@@ -2,8 +2,8 @@ $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'bundler/setup'
 Bundler.setup
 
-require 'codeclimate-test-reporter'
-CodeClimate::TestReporter.start
+require 'simplecov'
+SimpleCov.start
 
 require 'rspec/given'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: artirix_data_models
 version: !ruby/object:Gem::Version
-  version: 0.32.0
+  version: 1.0.0.beta1
 platform: ruby
 authors:
 - Eduardo Turiño
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-30 00:00:00.000000000 Z
+date: 2016-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -257,6 +257,7 @@ files:
 - bin/setup
 - lib/artirix_data_models.rb
 - lib/artirix_data_models/active_null.rb
+- lib/artirix_data_models/adm_registry.rb
 - lib/artirix_data_models/aggregation.rb
 - lib/artirix_data_models/aggregation_builder.rb
 - lib/artirix_data_models/aggregations_factory.rb
@@ -267,7 +268,6 @@ files:
 - lib/artirix_data_models/cached_action_adaptor/get_some.rb
 - lib/artirix_data_models/dao.rb
 - lib/artirix_data_models/dao_concerns/with_response_adaptors.rb
-- lib/artirix_data_models/dao_registry.rb
 - lib/artirix_data_models/daos/basic_model_dao.rb
 - lib/artirix_data_models/daos/model_fields_dao.rb
 - lib/artirix_data_models/es_collection.rb
@@ -286,8 +286,8 @@ 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
+- lib/artirix_data_models/with_adm_registry.rb
+- spec/artirix_data_models/adm_registry_spec.rb
 - spec/artirix_data_models/es_collection_spec.rb
 - spec/artirix_data_models/gateways/data_gateway_spec.rb
 - spec/artirix_data_models/gateways/gateway_response_adaptors/model_adaptor_spec.rb
@@ -321,9 +321,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.1
@@ -331,7 +331,7 @@ signing_key:
 specification_version: 4
 summary: Data Models (read only model) and Data Layer connection lib
 test_files:
-- spec/artirix_data_models/dao_registry_spec.rb
+- spec/artirix_data_models/adm_registry_spec.rb
 - spec/artirix_data_models/es_collection_spec.rb
 - spec/artirix_data_models/gateways/data_gateway_spec.rb
 - spec/artirix_data_models/gateways/gateway_response_adaptors/model_adaptor_spec.rb
@@ -350,4 +350,3 @@ test_files:
 - spec/support/a_search_enabled_ui_model_dao.rb
 - spec/support/artirix_data_models.rb
 - spec/support/fixtures.rb
-has_rdoc: 

data/lib/artirix_data_models/with_dao_registry.rb

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