artirix_data_models 0.20.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d6a0efe535f958e9d7c4e23504add310d21bb9a4
-  data.tar.gz: 3978b682cccc7694680ec9268d4a3d3f09e44c77
+  metadata.gz: e774ad4922bb0f7943c4cc423b2ae1873f6b46e6
+  data.tar.gz: 57534ba90ffbd420208668a691e6d9da0dfb7909
 SHA512:
-  metadata.gz: 0af80ece0e4b1797bf39f35150fedbe5f50dbe81ae8a6dba1bad6a7a7ab1fbee31b391826450afdbaa25c555748e33f914757bb175a95cd6cbb5e322f5cfdfb8
-  data.tar.gz: 61f793fd6c07f5c4d3a763d29ae1810c606bf464340deffc8d749abd7e9c326c99d3edaf7f76a416ac50b3127bada35cbeba36f56d36e7cc6ef910146b2da7e2
+  metadata.gz: e0dd43e33cf943a652303f559063f71d4ce98a2239da72d633b87c2fc64f10088d61417bc72687dfc9226ce335fadcfa72a4933afe92ccf1fab7a81b41a018bf
+  data.tar.gz: 3463066ddcb4ac5e7adf630546c84512ec66b0c33849a23cc4c70f012ec6b3c5b1d8327ae7026a053cbca93f78272ae7c256dc36223148a0e21deaf7eef4a45e

data/README.md

@@ -315,6 +315,31 @@ end
 
 ## Changes
 
+### 0.21.0
+
+Changed cache to use `ArtirixCacheService` (gem `artirix_cache_service`). 
+
+Deprecated the use of method_missing on cache in favour of the `.key` method: 
+
+```ruby
+# this is deprecated
+ArtirixDataModels::CacheService.dao_get_some_key dao_name, model_pks
+
+# in favour of this
+ArtirixDataModels::CacheService.key :dao_get_some, dao_name, model_pks
+```
+
+Deprecated the key `return_if_none` on `first_options` in favour of `return_if_missing`:
+
+```ruby
+# this is deprecated
+ArtirixDataModels::CacheService.first_options 'some', 'other', return_if_none: :default
+
+# in favour of this
+ArtirixDataModels::CacheService.first_options 'some', 'other', return_if_missing: :default
+```
+
+
 ### 0.20.0
 Added `ensure_relative` boolean option to the creation of a `DataGateway` (disable by default). With it enabled, it will ensure that any given `path` is relative by removing the leading `/`. This is necessary if the Gateway should call a nested endpoint and not just a host. 
 

data/artirix_data_models.gemspec

@@ -25,6 +25,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'keyword_init', '~> 1.4'
   spec.add_dependency 'naught'
   spec.add_dependency 'hashie', '~> 3.4'
+  spec.add_dependency 'artirix_cache_service'
 
   spec.add_development_dependency 'simpleconfig'
 

data/lib/artirix_data_models/cache_service.rb

@@ -1,179 +1,104 @@
 module ArtirixDataModels::CacheService
-
-  def self.digest_element(element)
-    Digest::SHA1.hexdigest element.to_s
-  end
-
-  def self.first_options(*options, return_if_none: :default)
-    key = options.detect { |x| OptionsStore.has? x }
-    return OptionsStore.get(key) if key.present?
-
-    case return_if_none
-    when NilClass
-      nil
-    when :default
-      OptionsStore.default.dup
-    else
-      {}
-    end
+  def self.reload_service
+    @service = nil
+    service
   end
 
-  def self.expire_cache(*args, &block)
-    Expirer.expire_cache *args, &block
-  end
-
-  def self.method_missing(m, *args, &block)
-    method = m.to_s
-
-    if KeyCleaner.valid_method method
-      KeyCleaner.final_key(m, *args)
-
-    elsif OptionsStore.valid_method method
-      OptionsStore.send m, *args, &block
+  def self.service
+    @service ||= ArtirixCacheService::Service.new.tap do |service|
+      prefix = ArtirixDataModels.configuration.try(:cache_app_prefix)
+      if prefix
+        service.register_key_prefix "#{prefix}__"
+      end
 
-    elsif Expirer.valid_method method
-      Expirer.send m, *args, &block
+      options = ArtirixDataModels.configuration.try(:cache_options)
+      if options
+        options.each do |name, opts|
+          if name.to_s == 'default_options'
+            service.register_default_options opts
+          else
+            service.register_options name, opts
+          end
+        end
+      end
 
-    else
-      super
     end
   end
 
-  def self.respond_to_missing?(m, include_all = false)
-    method = m.to_s
-
-    if KeyCleaner.valid_method method
-      true
-
-    elsif OptionsStore.valid_method method
-      OptionsStore.respond_to? m, include_all
-
-    elsif Expirer.valid_method method
-      Expirer.respond_to? m, include_all
-
-    else
-      super
-    end
+  def self.digest_element(element)
+    service.digest element
   end
 
-  private
-
-  module KeyCleaner
-    def self.valid_method(method_name)
-      method_name.end_with? '_key'
-    end
-
-    def self.final_key(m, *args)
-      cleaned = clean_key_section(m, *args)
-      CacheStoreHelper.final_key cleaned
-    end
-
-    private
-    def self.clean_key_section(key, *args)
-      key_name = clean_key_name key
-      a        = clean_key_args args
-      suffix   = a.present? ? "/#{a}" : ''
-      "#{key_name}#{suffix}"
+  def self.first_options(*options, return_if_missing: :default, **opts)
+    if opts.key? :return_if_none
+      ActiveSupport::Deprecation.warn('use `return_if_missing` instead of `return_if_none`')
+      return_if_missing = opts[:return_if_none]
     end
 
-    def self.clean_key_name(key)
-      key.to_s.gsub(/_key$/, '').to_sym
-    end
-
-    def self.clean_key_args(args)
-      args.map { |x| x.try(:cache_key) || x.to_s }.join '/'
-    end
+    service.options *options, return_if_missing: return_if_missing
   end
 
-  module OptionsStore
-    def self.valid_method(method_name)
-      method_name.end_with? '_options'
-    end
-
-    def self.method_missing(m, *args, &block)
-      if has?(m)
-        get(m)
-      else
-        super
-      end
-    end
+  def self.key(*given_args)
+    service.key *given_args
+  end
 
-    def self.respond_to_missing?(m, include_all = false)
-      has?(m) || super
-    end
+  def self.options(options_name)
+    service.registered_options options_name
+  end
 
-    private
-    def self.has?(name)
-      option_store.respond_to?(name)
-    end
+  def self.options?(options_name)
+    service.registered_options? options_name
+  end
 
-    def self.get(name)
-      default.merge(get_particular(name))
-    end
+  # we use `delete_matched` method -> it will work fine with Redis but it seems that it won't with Memcached
+  def self.expire_cache(pattern = nil, add_wildcard: true, add_prefix: true)
+    return false unless ArtirixDataModels.cache.present?
 
-    def self.get_particular(name)
-      Hash(option_store.send(name))
-    end
+    p = final_pattern(pattern, add_wildcard: add_wildcard, add_prefix: add_prefix)
 
-    def self.default
-      @default ||= Hash(option_store.default_options)
-    end
+    ArtirixDataModels.cache.delete_matched p
+  end
 
-    def self.option_store
-      @option_store ||= ArtirixDataModels.configuration.try(:cache_options) || disabled_options_store
-    end
+  def self.final_pattern(pattern, add_wildcard: true, add_prefix: true)
+    p = pattern
+    p = p.present? ? "#{p}*" : '' if add_wildcard
+    p = "*#{service.key_prefix}*#{p}" if add_prefix
+    p
+  end
 
-    def self.disabled_options_store
-      DisabledOptionsStore.new
-    end
 
-    class DisabledOptionsStore
-      def method_missing(m, *args, &block)
-        {}
-      end
+  def self.method_missing(m, *args, &block)
+    method = m.to_s
 
-      def respond_to_missing?(m, include_all = false)
-        true
-      end
-    end
-  end
+    if method.end_with? '_key'
+      ActiveSupport::Deprecation.warn('using method_missing with `service.some_key("1", "2")` is deprecated, use this instead: `service.key(:some, "1", "2")`')
+      key = method.gsub(/_key$/, '')
+      self.key key, *args
 
-  module Expirer
-    def self.valid_method(method_name)
-      method_name.start_with? 'expire_'
-    end
+    elsif method.end_with? '_options'
+      ActiveSupport::Deprecation.warn('using method_missing with `service.some_options` is deprecated, use this instead: `service.options(:some)`')
+      options_name = method.gsub(/_options$/, '')
+      self.options options_name
 
-    def self.expire_cache(pattern = nil, add_wildcard: true, add_prefix: true)
-      CacheStoreHelper.delete_matched pattern,
-                                      add_wildcard: add_wildcard,
-                                      add_prefix:   add_prefix
+    else
+      super
     end
   end
 
-  # we use `delete_matched` method -> it will work fine with Redis but it seems that it won't with Memcached
-  module CacheStoreHelper
-    def self.final_key(key_value)
-      "#{prefix}__#{key_value}"
-    end
-
-    def self.final_pattern(pattern, add_wildcard: true, add_prefix: true)
-      p = pattern
-      p = p.present? ? "#{p}*" : '' if add_wildcard
-      p = "*#{prefix}*#{p}" if add_prefix
-      p
-    end
+  def self.respond_to_missing?(m, include_all = false)
+    method = m.to_s
 
-    def self.delete_matched(pattern = nil, add_wildcard: true, add_prefix: true)
-      return false unless ArtirixDataModels.cache.present?
+    if method.end_with? '_key'
+      ActiveSupport::Deprecation.warn('using method_missing with `service.some_key("1", "2")` is deprecated, use this instead: `service.key(:some, "1", "2")`')
+      true
 
-      p = final_pattern(pattern, add_wildcard: add_wildcard, add_prefix: add_prefix)
+    elsif method.end_with? '_options'
+      ActiveSupport::Deprecation.warn('using method_missing with `service.some_options` is deprecated, use this instead: `service.options(:some)`')
+      options_name = method.gsub(/_options$/, '')
+      self.options options_name
 
-      ArtirixDataModels.cache.delete_matched p
-    end
-
-    def self.prefix
-      ArtirixDataModels.configuration.try(:cache_app_prefix)
+    else
+      super
     end
   end
-
 end

data/lib/artirix_data_models/cached_action_adaptor/get.rb

@@ -10,13 +10,13 @@ class ArtirixDataModels::CachedActionAdaptor::Get < ArtirixDataModels::CachedAct
   end
 
   def load_cache_key
-    ArtirixDataModels::CacheService.dao_get_key(dao_name, model_pk)
+    ArtirixDataModels::CacheService.key :dao_get, dao_name, model_pk
   end
 
   def load_cache_options
     ArtirixDataModels::CacheService.first_options "dao_#{dao_name}_get_options",
                                                   "dao_#{dao_name}_options",
                                                   'dao_get_options',
-                                                  return_if_none: :default
+                                                  return_if_missing: :default
   end
 end

data/lib/artirix_data_models/cached_action_adaptor/get_full.rb

@@ -52,20 +52,20 @@ class ArtirixDataModels::CachedActionAdaptor::GetFull < ArtirixDataModels::Cache
 
   module WithTimestamp
     def self.cache_key_from_model(model)
-      ArtirixDataModels::CacheService.dao_get_full_key(model)
+      ArtirixDataModels::CacheService.key :dao_get_full, model
     end
 
     def self.cache_options(dao_name)
       ArtirixDataModels::CacheService.first_options "dao_#{dao_name}_get_full_options",
                                                     "dao_#{dao_name}_options",
                                                     'dao_get_full_options',
-                                                    return_if_none: :default
+                                                    return_if_missing: :default
     end
   end
 
   module WithoutTimestamp
     def self.cache_key_from_model(model)
-      ArtirixDataModels::CacheService.dao_get_full_no_time_key(model)
+      ArtirixDataModels::CacheService.key :dao_get_full_no_time, model
     end
 
     def self.cache_options(dao_name)
@@ -74,7 +74,7 @@ class ArtirixDataModels::CachedActionAdaptor::GetFull < ArtirixDataModels::Cache
                                                     'dao_get_full_no_time_options',
                                                     "dao_#{dao_name}_options",
                                                     'dao_get_full_options',
-                                                    return_if_none: :default
+                                                    return_if_missing: :default
     end
   end
 end

data/lib/artirix_data_models/cached_action_adaptor/get_some.rb

@@ -10,13 +10,13 @@ class ArtirixDataModels::CachedActionAdaptor::GetSome < ArtirixDataModels::Cache
   end
 
   def load_cache_key
-    ArtirixDataModels::CacheService.dao_get_key(dao_name, model_pks)
+    ArtirixDataModels::CacheService.key :dao_get_some, dao_name, model_pks
   end
 
   def load_cache_options
     ArtirixDataModels::CacheService.first_options "dao_#{dao_name}_get_some_options",
                                                   "dao_#{dao_name}_options",
                                                   'dao_get_some_options',
-                                                  return_if_none: :default
+                                                  return_if_missing: :default
   end
 end

data/lib/artirix_data_models/cached_action_adaptor.rb

@@ -94,22 +94,21 @@ class ArtirixDataModels::CachedActionAdaptor
 
   def cache_exist?
     logger.debug "EXIST CACHE with key #{cache_key.inspect}"
-    return false unless cache.present?
+    return false unless cache
 
     cache.exist? cache_key, cache_options
   end
 
-
   def cache_read
     logger.debug "READ CACHE with key #{cache_key.inspect}"
-    return nil unless cache.present?
+    return nil unless cache
 
     cache.read cache_key, cache_options
   end
 
   def cache_write(value)
     logger.debug "WRITE CACHE with key #{cache_key.inspect}"
-    return value unless cache.present?
+    return value unless cache
 
     cache.write cache_key, value, cache_options
     value

data/lib/artirix_data_models/version.rb

@@ -1,3 +1,3 @@
 module ArtirixDataModels
-  VERSION = '0.20.0'
+  VERSION = '0.21.0'
 end

data/lib/artirix_data_models.rb

@@ -9,6 +9,8 @@ require 'keyword_init'
 require 'naught'
 require 'hashie'
 
+require 'artirix_cache_service'
+
 # note DO NOT require kaminari or will_paginate, it'll be done when invoking `ArtirixDataModels::EsCollection.work_with_will_paginate`
 # note: do not require SimpleConfig, it has to exist before used. Same as we don't require Rails.
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: artirix_data_models
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 0.21.0
 platform: ruby
 authors:
 - Eduardo Turiño
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-03 00:00:00.000000000 Z
+date: 2016-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: artirix_cache_service
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simpleconfig
   requirement: !ruby/object:Gem::Requirement