prefatory 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7102730a0aeebb54993b61da17dcf1f1bcf8e45d21b17af26afd1925a7fb3177
-  data.tar.gz: 03c2a801624b128938fa4f78f02df0a18c53f0695e53cbd034173c91851d5ca1
+  metadata.gz: ab95dbbd20cd5b03132b0dcbfe30ccfde2fb1b2bca7deb538c4eb54982b19a7a
+  data.tar.gz: 7e011d86d50c43cf1e60b392e9cff5d968230793150766a0294ee063cc8cc09f
 SHA512:
-  metadata.gz: f71144bb0a99865d9eba74c9aba2b11dd326680ac0d560f18103777ad902f2f4895883ce38ac4e91aea347fa586cad694a7203a20f04f7d45cff4926712829c0
-  data.tar.gz: 66eec9eaf91a357db544cee99022a7ab5ef5acd2b580d5677897eaf8cc6a5a7e1c611ad50578030adadd849d54fe0b8de92bc447706382468e4555260a3ffa71
+  metadata.gz: 1c9ae5daa2224cb673a1454f52806dcbdb8cd65c12d09e2149f206470321c280252d3881ecb956e5fa16a0e70ce5b0270e88ccc6c5e0e51d71e80ec8f6a323e1
+  data.tar.gz: e624b6605b4d317b147029cb44ad4c1e3ed9e6f2458a985546cd37748c463b0a719254b54d3d051aa1ce93e278e52daf084979f962adef9684312707b6ae2b1e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    prefatory (0.1.0)
+    prefatory (0.1.1)
       dry-configurable (~> 0.7.0)
 
 GEM

data/README.md

@@ -50,9 +50,9 @@ Redis:
 
 # default configuration:
     Prefatory.configure do |config|
-      configure.storage.engine = :redis
+      config.storage.provider = :redis
       # accepts any additional options redis-rb gem accepts          
-      configure.storage.options = {url: ENV['REDIS_URL']||Redis.current||'redis://127.0.0.1:0'}
+      config.storage.options = {url: ENV['REDIS_URL']||Redis.current||'redis://127.0.0.1:0'}
       config.ttl =  
     end
 

data/lib/prefatory.rb

@@ -1,7 +1,6 @@
 require_relative "prefatory/version"
 require_relative 'prefatory/config'
 require_relative 'prefatory/errors'
-require_relative 'prefatory/keys'
 require_relative 'prefatory/storage/discover'
 
 module Prefatory
@@ -10,17 +9,14 @@ module Prefatory
     KEY_NOT_FOUND_MSG = "Unable to find the object with key ?"
 
     def initialize(key_prefix: nil, storage: nil,
-                   config: Prefatory.config,
-                   marshaler: Marshal)
+                   config: Prefatory.config)
       @config = config
-      @storage = storage || Storage::Discover.new(@config.storage, @config.ttl, key_prefix).instance
-      @marshaler = marshaler
+      @storage = storage || Storage::Discover.new(@config.storage, @config.ttl).instance
     end
 
     def find(key)
       return nil unless @storage.key?(key)
-      value = @storage.get(key)
-      @marshaler.load(value)
+      @storage.get(key)
     end
 
     def find!(key)
@@ -31,9 +27,8 @@ module Prefatory
 
     def save(obj, ttl=nil)
       begin
-        value = @marshaler.dump(obj)
         key = @storage.next_key(obj)
-        @storage.set(key, value, ttl)
+        @storage.set(key, obj, ttl)
       rescue StandardError => e
         logger.info("An error occurred (#{e.inspect}) storing object: #{obj.inspect}")
         key = nil
@@ -50,13 +45,13 @@ module Prefatory
 
     def update(key, obj, ttl=nil)
       return false unless @storage.key?(key)
-      value = @marshaler.dump(obj)
-      @storage.set(key, value, ttl)
+      @storage.set(key, obj, ttl)
       true
     end
 
     def update!(key, obj, ttl=nil)
       raise Errors::NotFound, KEY_NOT_FOUND_MSG.sub('?',key) unless @storage.key?(key)
+
       update(key, obj, ttl)
     end
 
@@ -73,8 +68,6 @@ module Prefatory
 
     private
 
-    include Prefatory::Keys
-
     def logger
       @config.logger
     end

data/lib/prefatory/config.rb

@@ -1,12 +1,22 @@
 require 'dry-configurable'
+require_relative 'key_generator'
 
 module Prefatory
   extend Dry::Configurable
 
   setting :logger, Logger.new(STDOUT)
   setting :ttl, 86400 # in seconds - defaults to one day
+  setting     :keys do
+    setting :generator, Prefatory::KeyGenerator
+    setting :prefix, 'prefatory'
+    # If the object being stored responds to :entity_primary_key and that value is not null,
+    # it is assumed to be a universally unique primary key for the object.
+    # The default key_generator will use it
+    setting     :primary_uuid, :primary_uuid
+  end
   setting :storage do
     setting :provider # :memcached or :redis
     setting :options
+    setting :marshaler, Marshal
   end
 end

data/lib/prefatory/key_generator.rb

@@ -0,0 +1,19 @@
+require 'securerandom'
+
+module Prefatory
+  class KeyGenerator
+    def initialize(prefix = nil)
+      @prefix = prefix
+    end
+
+    def prefix(key)
+      [@prefix, key].compact.join(':')
+    end
+
+    def key(obj)
+      next_key = obj.send(Prefatory.config.keys.primary_uuid) if obj.respond_to?(Prefatory.config.keys.primary_uuid)
+      next_key = SecureRandom.hex(16) unless next_key
+      next_key
+    end
+  end
+end

data/lib/prefatory/storage/discover.rb

@@ -1,18 +1,27 @@
+require 'prefatory/config'
+require 'prefatory/errors'
+
 module Prefatory
   module Storage
     class Discover
-      def initialize(config, ttl, key_prefix)
+      def initialize(config, ttl=Prefatory.config.ttl)
         @config = config
         @ttl = ttl
-        @key_prefix = key_prefix
         @provider = find_provider(config.provider)
       end
 
       def instance
         require_relative "#{@provider}_provider"
-        Object.const_get("Prefatory::Storage::#{@provider.to_s.capitalize}Provider").new(@config.options, @ttl, @key_prefix)
+        Object.const_get("Prefatory::Storage::#{@provider.to_s.capitalize}Provider").new(@config.options,
+                                                                                         @ttl,
+                                                                                         marshaler: marshaler)
       end
       private
+
+      def marshaler
+        @config.respond_to?(:marshaler) ? @config.marshaler : Marshal
+      end
+
       def find_provider(provider)
         return provider if provider
         return :redis if defined?(Redis)

data/lib/prefatory/storage/memcached_provider.rb

@@ -3,46 +3,54 @@ require 'dalli'
 module Prefatory
   module Storage
     class MemcachedProvider
-      include Prefatory::Keys
       DEFAULT_SERVER = '127.0.0.1:11211'.freeze
-      DEFAULT_OPTIONS = {namespace: 'prefatory', compress: true}
+      DEFAULT_OPTIONS = {namespace: Prefatory.config.keys.prefix, compress: true, cache_nils: true}
 
-      def initialize(options, ttl=nil, key_prefix=nil)
+      def initialize(options = nil, ttl = nil,
+                     key_generator: Prefatory.config.keys.generator.new,
+                     marshaler: Prefatory.config.storage.marshaler)
         @ttl = ttl
-        @key_prefix = key_prefix
+        @key_generator = key_generator
+        @marshaler = marshaler
         @client = Dalli::Client.new(default_servers(options), default_options(options))
       end
 
-      def set(key, value, ttl=nil)
-        @client.set(key, value, ttl||@ttl)
+      def set(key, value, ttl = nil)
+        @client.set(prefix(key), @marshaler.dump(value), ttl || @ttl)
       end
 
       def get(key)
-        @client.get(key)
+        value = @client.get(prefix(key))
+        value ? @marshaler.load(value) : value
       end
 
       def delete(key)
-        @client.delete(key)
+        @client.delete(prefix(key))
       end
 
       def key?(key)
-        v = @client.fetch(key){:does_not_exists}
+        v = @client.fetch(prefix(key)) {:does_not_exists}
         v != :does_not_exists
       end
 
-      def next_key(obj=nil)
-        build_key(obj, @client.incr(build_key(obj, nil, @key_prefix), 1, nil, 0), @key_prefix)
+      def next_key(obj = nil)
+        @key_generator.key(obj)
       end
 
       private
 
+      def prefix(key)
+        @key_generator.prefix(key)
+      end
+
+
       def default_servers(options)
         return options[:servers] if options&.fetch(:servers) {false}
         DEFAULT_SERVER
       end
 
       def default_options(options)
-        return options.except(:servers) if options
+        return options.select {|key| key != :servers} if options
         DEFAULT_OPTIONS
       end
     end

data/lib/prefatory/storage/redis_provider.rb

@@ -3,40 +3,46 @@ require 'redis'
 module Prefatory
   module Storage
     class RedisProvider
-      include Prefatory::Keys
-
-      def initialize(options, ttl, key_prefix=nil)
+      def initialize(options=nil, ttl=Prefatory.config.ttl,
+                     key_generator:  Prefatory.config.keys.generator.new(Prefatory.config.keys.prefix),
+                     marshaler: Prefatory.config.storage.marshaler)
         options = default_settings(options)
         @ttl = ttl
-        @key_prefix = key_prefix
+        @key_generator = key_generator
+        @marshaler = marshaler
         @client = options ? Redis.new(options) : Redis.current
       end
 
       def set(key, value, ttl=nil)
-        @client.set(key, value, ex: ttl||@ttl)
+        @client.set(prefix(key), @marshaler.dump(value), ex: ttl||@ttl)
       end
 
       def get(key)
-        @client.get(key)
+        value = @client.get(prefix(key))
+        value ? @marshaler.load(value) : value
       end
 
       def delete(key)
-        @client.del(key)
+        @client.del(prefix(key))
       end
 
       def key?(key)
-        @client.exists(key)
+        @client.exists(prefix(key))
       end
 
       def next_key(obj=nil)
-        build_key(obj, @client.incr(build_key(obj, nil, @key_prefix)), @key_prefix)
+        @key_generator.key(obj)
       end
 
       private
 
+      def prefix(key)
+        @key_generator.prefix(key)
+      end
+
       def default_settings(options)
         return options if options&.fetch(:url){false} || options&.fetch(:host){false}
-        url = ENV['REDIS_PROVIDER'] || ENV['REDIS_URL']
+        url = ENV['REDIS_PROVIDER'] || ENV['REDIS_URL'] || ENV['REDIS_SERVER']
         if (url)
           options ||= {}
           options = options.merge(url: url)

data/lib/prefatory/storage/test_provider.rb

@@ -1,24 +1,23 @@
-require 'dalli'
-
 module Prefatory
   module Storage
     # Used by Specs. This is not safe for production (in any way!) You have been warned.
     class TestProvider
-      include Prefatory::Keys
 
-      def initialize(ttl = nil, key_prefix = nil)
-        @ttl = ttl
-        @key_prefix = key_prefix
+      def initialize(_ttl = nil,
+                     key_generator:  Prefatory.config.keys.generator.new,
+                     marshaler: Prefatory.config.storage.marshaler)
         @hash = {}
-        @next_key = 0
+        @key_generator = key_generator
+        @marshaler = marshaler
       end
 
-      def set(key, value, ttl=nil)
-        @hash.store(key, value)
+      def set(key, value, _ttl=nil)
+        @hash.store(key, @marshaler.dump(value))
       end
 
       def get(key)
-        @hash.fetch(key){nil}
+        value = @hash.fetch(key){nil}
+        value ? @marshaler.load(value) : value
       end
 
       def key?(key)
@@ -30,7 +29,7 @@ module Prefatory
       end
 
       def next_key(obj = nil)
-        build_key(obj, @next_key += 1, @key_prefix)
+        @key_generator.key(obj)
       end
     end
   end

data/lib/prefatory/version.rb

@@ -1,3 +1,3 @@
 module Prefatory
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prefatory
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Russell Edens
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-07 00:00:00.000000000 Z
+date: 2019-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable
@@ -132,7 +132,7 @@ files:
 - lib/prefatory.rb
 - lib/prefatory/config.rb
 - lib/prefatory/errors.rb
-- lib/prefatory/keys.rb
+- lib/prefatory/key_generator.rb
 - lib/prefatory/storage/discover.rb
 - lib/prefatory/storage/memcached_provider.rb
 - lib/prefatory/storage/redis_provider.rb
@@ -158,8 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.2
 signing_key: 
 specification_version: 4
 summary: Prefatory provides storage of entities (models or values/attributes) in a

data/lib/prefatory/keys.rb

@@ -1,11 +0,0 @@
-module Prefatory
-  module Keys
-    INCR_KEY = 'prefatory'.freeze
-
-    def build_key(obj=nil,value=nil, prefix=nil)
-      klass = nil
-      klass = obj&.class == 'Class' ? obj.name.downcase : obj&.class.name.downcase   if obj
-      "#{INCR_KEY}#{prefix ? ":#{prefix}" : nil}#{klass ? ":#{klass}" : nil}#{value ? ":#{value}" : nil}"
-    end
-  end
-end