async_storage 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffa57bbe53ad587cdd628ce556aaf679ed9b4ff02f5a9b8c4217be4b6ffa495d
-  data.tar.gz: 5557aa324800a20d599a94ddcbf21894f8ffa3ccc97672f7e0329d5283090d84
+  metadata.gz: add79afe0dfa294abeee5fb5102e05f5d5fbecfc70d700c5b25fc4f17cf9881f
+  data.tar.gz: e0a8841f106ac58f7146938749732c43d99e0f56dacfcc4816d62c251bf34d2a
 SHA512:
-  metadata.gz: f6f33f4f1d4728c5933c7b312daa602a14eb2408f40168a8b5a3f490e8853e1b84464cc698fb6a3c6721f4bc0b72fb1dae0c4341bec2c481ce46f1acb5128718
-  data.tar.gz: 0d976a57d701639a1e46b3f9d236b3e983ac6a652e96e6ac481475f1293326251e0f4e1045ed945027ed6cd26f552fa9ec5793b2337fa6179ebc380f6fb42651
+  metadata.gz: 28800339448b6668b3da60bb5ad80d5e998c26ef42ebd3c06c881d49b09bfe7a8aed7893323578f3c0171183f705a5ca58fc9b871aa420425f161896e0e02d2a
+  data.tar.gz: dff1ad907077f87c95977f14b56c4a8c9d49f394f781a1c164a53266c5a0ee3cae45078728b41b1020d47b3bb9c7949bf9e5286f83c21fc8e39c49735a286c36

data/.gitignore

@@ -8,4 +8,4 @@
 /tmp/
 .rspec_status
 .env
-
+async_storage-*.gem

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    async_storage (0.1.0)
+    async_storage (0.0.1)
       multi_json (> 0.0.0)
       redis (> 0.0.0)
 

data/lib/async_storage/allocator.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'async_storage/naming'
+
+module AsyncStorage
+  class Allocator
+    CTRL = {
+      enqueued: '0',
+      executed: '1',
+      missing: nil,
+    }.freeze
+
+    extend Forwardable
+    def_delegators :@repo, :resolver_class, :expires_in
+
+    attr_reader :naming
+
+    # @param repo [AsyncStorage::Repo] An instance of Repo
+    # @param args [Array] An array with arguments to be fowarded to resolver#call
+    def initialize(repo, *args)
+      @repo = repo
+      @args = args
+      @naming = AsyncStorage::Naming.new(repo.resolver_class, *args)
+      # It's different than the config.namespace.
+      # Thinking about a directory structure.. The global namespace would be the root directory.
+      # And the namespace under Repo level would be the subdirectory.
+      @naming.prefix = repo.namespace if repo.namespace
+    end
+
+    # Async get value with a given key
+    #
+    # @return [Object, NilClass] Return both stale or fresh object. If does not exist async call the retriever and return nil
+    def get
+      connection do |redis|
+        raw_head = redis.get(naming.head)
+        case raw_head
+        when CTRL[:executed], CTRL[:enqueued]
+          read_body(redis) # Try to deliver stale content
+        when CTRL[:missing]
+          return update!(redis) unless async?
+
+          perform_async(redis) # Enqueue background job to resolve content
+          redis.set(naming.head, CTRL[:enqueued])
+          read_body(redis) # Try to deliver stale content
+        else
+          raise AsyncStorage::Error, format('the key %<k>s have an invalid value. Only "1" or "0" values are expected. And we got %<v>p', v: raw_head, k: naming.head)
+        end
+      end
+    end
+
+    # Sync get value with a given value
+    #
+    # @return [Object] Return the result from resolver
+    def get!
+      connection do |redis|
+        raw_head = redis.get(naming.head)
+        case raw_head
+        when CTRL[:executed]
+          read_body(redis) || begin
+            update!(redis) unless redis.exists?(naming.body)
+          end
+        when CTRL[:missing], CTRL[:enqueued]
+          update!(redis)
+        else
+          raise AsyncStorage::Error, format('the key %<k>s have an invalid value. Only "1" or "0" values are expected. And we got %<v>p', v: raw_head, k: naming.head)
+        end
+      end
+    end
+
+    # Expire object the object with a given key. The stale object will not be removed
+    #
+    # @return [Boolean] True or False according to the object existence
+    def invalidate
+      connection do |redis|
+        redis.del(naming.head) == 1
+      end
+    end
+
+    # Delete object with a given key.
+    #
+    # @return [Boolean] True or False according to the object existence
+    def invalidate!
+      connection do |redis|
+        redis.multi do |cli|
+          cli.del(naming.body)
+          cli.del(naming.head)
+        end.include?(1)
+      end
+    end
+
+    # Invalidate object with the given key and update content according to the strategy
+    #
+    # @return [Object, NilClass] Stale object or nil when it does not exist
+    def refresh
+      value = get(*@args)
+      invalidate(*@args)
+      value
+    end
+
+    # Fetch data from resolver and store it into redis
+    #
+    # @return [Object] Return the result from resolver
+    def refresh!
+      connection { |redis| update!(redis) }
+    end
+
+    # Check if a fresh value exist.
+    #
+    # @return [Boolean] True or False according the object existence
+    def exist?
+      connection { |redis| redis.exists?(naming.head) && redis.exists?(naming.body) }
+    end
+
+    # Check if object with a given key is stale
+    #
+    # @return [NilClass, Boolean] Return nil if the object does not exist or true/false according to the object freshness state
+    def stale?
+      connection { |redis| redis.exists?(naming.body) && redis.ttl(naming.head) < 0 }
+    end
+
+    # Check if a fresh object exists into the storage
+    #
+    # @return [Boolean] true/false according to the object existence and freshness
+    def fresh?
+      connection { |redis| redis.exists?(naming.body) && redis.ttl(naming.head) > 0 }
+    end
+
+    private
+
+    def async?
+      false
+    end
+
+    def perform_async(redis)
+      # @TODO Enqueue a real background job here. It's only working on sync mode
+      # redis.set(name.head, CTRL[:enqueued])
+      refresh!
+    end
+
+    def update!(redis)
+      payload = resolver_class.new.(*@args)
+
+      json = AsyncStorage::JSON.dump(payload, mode: :compat)
+      redis.multi do |cli|
+        cli.set(naming.body, json)
+        cli.set(naming.head, CTRL[:executed])
+        cli.expire(naming.head, expires_in) if expires_in
+      end
+      AsyncStorage::JSON.load(json)
+    end
+
+    def read_body(redis)
+      raw = redis.get(naming.body)
+      return unless raw
+
+      AsyncStorage::JSON.load(raw)
+    end
+
+    def connection
+      return unless block_given?
+
+      AsyncStorage.redis_pool.with { |redis| yield(redis) }
+    end
+  end
+end

data/lib/async_storage/repo.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'async_storage/naming'
+require 'async_storage/allocator'
 
 module AsyncStorage
   class Repo
@@ -36,150 +36,81 @@ module AsyncStorage
     #
     # @return [Object, NilClass] Return both stale or fresh object. If does not exist async call the retriever and return nil
     def get(*args)
-      connection(*args) do |redis, naming|
-        raw_head = redis.get(naming.head)
-        case raw_head
-        when CTRL[:executed], CTRL[:enqueued]
-          read(redis, naming.body) # Try to deliver stale content
-        when CTRL[:missing]
-          return update!(redis, naming, *args) unless async?
-
-          perform_async(*args) # Enqueue background job to resolve content
-          redis.set(naming.head, CTRL[:enqueued])
-          read(redis, naming.body) # Try to deliver stale content
-        else
-          raise AsyncStorage::Error, format('the key %<k>s have an invalid value. Only "1" or "0" values are expected. And we got %<v>p', v: raw_head, k: naming.head)
-        end
-      end
+      alloc(*args).get
     end
 
     # Sync get value with a given value
     #
     # @return [Object] Return the result from resolver
     def get!(*args)
-      connection(*args) do |redis, naming|
-        raw_head = redis.get(naming.head)
-        case raw_head
-        when CTRL[:executed]
-          read(redis, naming.body) || begin
-            update!(redis, naming, *args) unless redis.exists?(naming.body)
-          end
-        when CTRL[:missing], CTRL[:enqueued]
-          update!(redis, naming, *args)
-        else
-          raise AsyncStorage::Error, format('the key %<k>s have an invalid value. Only "1" or "0" values are expected. And we got %<v>p', v: raw_head, k: naming.head)
-        end
-      end
+      alloc(*args).get!
     end
 
     # Expire object the object with a given key. The stale object will not be removed
     #
     # @return [Boolean] True or False according to the object existence
     def invalidate(*args)
-      connection(*args) do |redis, naming|
-        redis.del(naming.head) == 1
-      end
+      alloc(*args).invalidate
     end
 
     # Delete object with a given key.
     #
     # @return [Boolean] True or False according to the object existence
     def invalidate!(*args)
-      connection(*args) do |redis, naming|
-        redis.multi do |cli|
-          cli.del(naming.body)
-          cli.del(naming.head)
-        end.include?(1)
-      end
+      alloc(*args).invalidate!
     end
 
     # Invalidate object with the given key and update content according to the strategy
     #
     # @return [Object, NilClass] Stale object or nil when it does not exist
     def refresh(*args)
-      value = get(*args)
-      invalidate(*args)
-      value
+      alloc(*args).refresh
     end
 
     # Fetch data from resolver and store it into redis
     #
     # @return [Object] Return the result from resolver
     def refresh!(*args)
-      connection(*args) { |redis, naming| update!(redis, naming, *args) }
+      alloc(*args).refresh!
     end
 
     # Check if a fresh value exist.
     #
     # @return [Boolean] True or False according the object existence
     def exist?(*args)
-      connection(*args) { |redis, naming| redis.exists?(naming.head) && redis.exists?(naming.body) }
+      alloc(*args).exist?
     end
 
     # Check if object with a given key is stale
     #
     # @return [NilClass, Boolean] Return nil if the object does not exist or true/false according to the object freshness state
     def stale?(*args)
-      connection(*args) { |redis, naming| redis.exists?(naming.body) && redis.ttl(naming.head) < 0 }
+      alloc(*args).stale?
     end
 
     # Check if a fresh object exists into the storage
     #
     # @return [Boolean] true/false according to the object existence and freshness
     def fresh?(*args)
-      connection(*args) { |redis, naming| redis.exists?(naming.body) && redis.ttl(naming.head) > 0 }
-    end
-
-    private
-
-    def async?
-      false
-    end
-
-    def perform_async(*args)
-      # @TODO Enqueue a real background job here. It's only working on sync mode
-      # redis.set(name.head, CTRL[:enqueued])
-      refresh!(*args)
+      alloc(*args).fresh?
     end
 
-    def update!(redis, naming, *args)
-      payload = resolver_class.new.(*args)
-
-      json = AsyncStorage::JSON.dump(payload, mode: :compat)
-      naming = build_naming(*args)
-      redis.multi do |cli|
-        cli.set(naming.body, json)
-        cli.set(naming.head, CTRL[:executed])
-        cli.expire(naming.head, expires_in) if expires_in
-      end
-      AsyncStorage::JSON.load(json)
-    end
-
-    def read(redis, key)
-      return unless key
-
-      raw = redis.get(key)
-      return unless raw
-
-      AsyncStorage::JSON.load(raw)
+    # Build an Allocator instance
+    #
+    # @param [*Array] list of parameters to be forwaded to the resolver#call
+    def alloc(*args)
+      Allocator.new(self, *args)
     end
 
     def expires_in
       @options[:expires_in] || AsyncStorage.config.expires_in
     end
 
-    def connection(*args)
-      return unless block_given?
-
-      naming = build_naming(*args)
-      AsyncStorage.redis_pool.with { |redis| yield(redis, naming) }
+    def namespace
+      @options[:namespace]
     end
 
-    def build_naming(*args)
-      naming = AsyncStorage::Naming.new(resolver_class, *args)
-      naming.prefix = @options[:namespace] if @options[:namespace]
-      naming
-    end
+    protected
 
     def validate_resolver_class!(klass)
       unless klass.is_a?(Class)

data/lib/async_storage/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AsyncStorage
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async_storage
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Marcos G. Zimmermann
@@ -57,6 +57,7 @@ files:
 - bin/console
 - bin/setup
 - lib/async_storage.rb
+- lib/async_storage/allocator.rb
 - lib/async_storage/bath_actions.rb
 - lib/async_storage/config.rb
 - lib/async_storage/json.rb