simple-feed 2.0.2 → 3.1.2

data/lib/simplefeed/providers/base/provider.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 require 'simplefeed/providers/key'
+require 'date'
+require 'time'
 
 module SimpleFeed
   module Providers
@@ -27,7 +31,7 @@ module SimpleFeed
           at = at.to_time if at.respond_to?(:to_time)
           at = at.to_f if at.respond_to?(:to_f)
 
-          if self.respond_to?(:reset_last_read)
+          if respond_to?(:reset_last_read)
             reset_last_read(user_ids: user_ids, at: at)
           else
             raise ArgumentError, "Class #{self.class} does not implement #reset_last_read method"
@@ -54,7 +58,7 @@ module SimpleFeed
         def with_response_batched(user_ids, external_response = nil)
           with_response(external_response) do |response|
             batch(user_ids) do |key|
-              response.for(key.user_id) { yield(key, response) }
+              response.for(key.consumer) { yield(key, response) }
             end
           end
         end
@@ -70,7 +74,7 @@ module SimpleFeed
         def with_response(response = nil)
           response ||= SimpleFeed::Response.new
           yield(response)
-          if self.respond_to?(:transform_response)
+          if respond_to?(:transform_response)
             response.transform do |user_id, result|
               # calling into a subclass
               transform_response(user_id, result)
@@ -78,7 +82,6 @@ module SimpleFeed
           end
           response
         end
-
       end
     end
   end

data/lib/simplefeed/providers/hash.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SimpleFeed
   module Providers
     module Hash

data/lib/simplefeed/providers/key.rb

@@ -1,9 +1,7 @@
+# frozen_string_literal: true
+
 require 'base62-rb'
 require 'hashie/mash'
-require 'simplefeed/key/template'
-require 'simplefeed/key/type'
-
-require 'forwardable'
 
 module SimpleFeed
   module Providers
@@ -13,60 +11,86 @@ module SimpleFeed
     #              ↓        ↓
     #          "ff|u.f23098.m"
     #           ↑         ↑
-    #         namespace user_id(base62)
+    #         namespace consumer(base62)
     #
     class Key
-      attr_accessor :user_id, :key_template
+      class << self
+        def rot13(value)
+          value.tr('abcdefghijklmnopqrstuvwxyz',
+                   'nopqrstuvwxyzabcdefghijklm')
+        end
+      end
 
-      extend Forwardable
-      def_delegators :@key_template, :key_names, :key_types
+      SERIALIZED_DATA_TEMPLATE = '{{namespace}}u.{{data_id}}.d'
+      SERIALIZED_META_TEMPLATE = '{{namespace}}u.{{meta_id}}.m'
 
-      def initialize(user_id, key_template)
-        self.user_id  = user_id
-        self.key_template = key_template
+      attr_reader :consumer, :namespace, :data_key_transformer, :meta_key_transformer
 
-        define_key_methods
+      def initialize(consumer,
+                     namespace: nil,
+                     data_key_transformer: nil,
+                     meta_key_transformer: nil)
+        @consumer = consumer
+        @namespace = namespace
+        @data_key_transformer = data_key_transformer
+        @meta_key_transformer = meta_key_transformer
       end
 
-      def define_key_methods
-        key_template.key_types.each do |type|
-          key_name = type.name
-          unless self.respond_to?(key_name)
-            self.class.send(:define_method, key_name) do
-              instance_variable_get("@#{key_name}") ||
-                instance_variable_set("@#{key_name}", type.render(render_options))
-            end
-          end
-
-        end
+      def data
+        @data ||= render(SERIALIZED_DATA_TEMPLATE)
       end
 
-      def base62_user_id
-        @base62_user_id ||= ::Base62.encode(user_id)
+      def meta
+        @meta ||= render(SERIALIZED_META_TEMPLATE)
       end
 
       def keys
-        key_names.map { |name| self.send(name) }
-      end
-
-      def render_options
-        key_template.render_options.merge!({
-                                             'user_id'        => user_id,
-                                             'base62_user_id' => base62_user_id
-                                           })
+        [data, meta]
       end
 
       def to_s
-        super + { user_id: user_id, base62_user_id: base62_user_id, keys: keys }.to_s
+        super + key_params.to_s
       end
 
       def inspect
-        render_options.inspect
+        super + key_params.inspect
       end
 
       private
 
+      def render(template)
+        template.dup.tap do |output|
+          key_params.each_pair do |key, value|
+            output.gsub!(/{{#{key}}}/, value.to_s)
+          end
+        end
+      end
+
+      def obscure_value(id)
+        id = id.to_i if id.is_a?(String) && id =~ /^\d+$/
+
+        if id.is_a?(Numeric)
+          ::Base62.encode(id)
+        else
+          self.class.rot13(id.to_s)
+        end
+      end
+
+      def key_params
+        @key_params ||= Hashie::Mash.new(
+          namespace: namespace ? "#{namespace}|" : '',
+          data_id:   obscure_value(data_id),
+          meta_id:   obscure_value(meta_id)
+        )
+      end
+
+      def meta_id
+        meta_key_transformer&.call(consumer) || consumer
+      end
+
+      def data_id
+        data_key_transformer&.call(consumer) || consumer
+      end
     end
   end
 end
-

data/lib/simplefeed/providers/proxy.rb

@@ -1,36 +1,50 @@
+# frozen_string_literal: true
+
 module SimpleFeed
   module Providers
+    RUBY_MAJOR_VERSION = RUBY_VERSION.split('.')[0..1].join.to_i
+
     class Proxy
       attr_accessor :provider
 
       def self.from(definition)
         if definition.is_a?(::Hash)
           ::SimpleFeed.symbolize!(definition)
-          self.new(definition[:klass], *definition[:args], **definition[:opts])
+          new(definition[:klass], *definition[:args], **definition[:opts])
         else
-          self.new(definition)
+          new(definition)
         end
-
       end
 
       def initialize(provider_or_klass, *args, **options)
-        if provider_or_klass.is_a?(::String)
-          self.provider = ::Object.const_get(provider_or_klass).new(*args, **options)
-        else
-          self.provider = provider_or_klass
-        end
+        self.provider = if provider_or_klass.is_a?(::String) || provider_or_klass.is_a?(::Symbol)
+                          ::Object.const_get(provider_or_klass).new(*args, **options)
+                        else
+                          provider_or_klass
+                        end
 
         SimpleFeed::Providers::REQUIRED_METHODS.each do |m|
           raise ArgumentError, "Invalid provider #{provider.class}\nMethod '#{m}' is required." unless provider.respond_to?(m)
         end
       end
 
-      # Forward all other method calls to Provider
-      def method_missing(name, *args, &block)
-        if self.provider && provider.respond_to?(name)
-          self.provider.send(name, *args, &block)
-        else
-          super(name, *args, &block)
+      if RUBY_MAJOR_VERSION >= 27
+        # Forward all other method calls to Provider
+        def method_missing(name, *args, **opts, &block)
+          if provider&.respond_to?(name)
+            provider.send(name, *args, **opts, &block)
+          else
+            super(name, *args, **opts, &block)
+          end
+        end
+      else
+        # Forward all other method calls to Provider
+        def method_missing(name, *args, &block)
+          if provider&.respond_to?(name)
+            provider.send(name, *args, &block)
+          else
+            super(name, *args, &block)
+          end
         end
       end
     end

data/lib/simplefeed/providers/redis/driver.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'redis'
 require 'redis/connection/hiredis'
 require 'connection_pool'
@@ -12,10 +14,10 @@ module SimpleFeed
       @debug = ENV['REDIS_DEBUG']
 
       def self.debug?
-        self.debug
+        debug
       end
 
-      def self.with_debug(&block)
+      def self.with_debug
         previous_value                     = SimpleFeed::Providers::Redis.debug
         SimpleFeed::Providers::Redis.debug = true
         result                             = yield if block_given?
@@ -48,10 +50,11 @@ module SimpleFeed
               colors     = [:blue, nil, :blue, :blue, :yellow, :cyan, nil, :blue]
               components = [
                 Time.now.strftime('%H:%M:%S.%L'), ' rtt=',
-                (sprintf '%.5f', delta*1000), ' ms ',
+                (sprintf '%.5f', delta * 1000), ' ms ',
                 (sprintf '%15s ', m.to_s.upcase),
                 (sprintf '%-40s', args.inspect.gsub(/[",\[\]]/, '')), ' ⇒ ',
-                (result.is_a?(::Redis::Future) ? '' : result.to_s)]
+                (result.is_a?(::Redis::Future) ? '' : result.to_s)
+              ]
               components.each_with_index do |component, index|
                 color = self.class.disable_color ? nil : colors[index]
                 component = component.send(color) if color
@@ -71,18 +74,16 @@ module SimpleFeed
 
         attr_accessor :pool
 
-=begin
-
-Various ways of defining a new Redis driver:
-
-SimpleFeed::Redis::Driver.new(pool: ConnectionPool.new(size: 2) { Redis.new })
-SimpleFeed::Redis::Driver.new(redis: -> { Redis.new }, pool_size: 2)
-SimpleFeed::Redis::Driver.new(redis: Redis.new)
-SimpleFeed::Redis::Driver.new(redis: { host: 'localhost', port: 6379, db: 1, timeout: 0.2 }, pool_size: 1)
-
-=end
-        def initialize(**opts)
-          if opts[:pool] && opts[:pool].respond_to?(:with)
+        #
+        # Various ways of defining a new Redis driver:
+        #
+        # SimpleFeed::Redis::Driver.new(pool: ConnectionPool.new(size: 2) { Redis.new })
+        # SimpleFeed::Redis::Driver.new(redis: -> { Redis.new }, pool_size: 2)
+        # SimpleFeed::Redis::Driver.new(redis: Redis.new)
+        # SimpleFeed::Redis::Driver.new(redis: { host: 'localhost', port: 6379, db: 1, timeout: 0.2 }, pool_size: 1)
+        #
+        def initialize(opts)
+          if opts[:pool]&.respond_to?(:with)
             self.pool = opts[:pool]
 
           elsif opts[:redis]
@@ -104,7 +105,7 @@ SimpleFeed::Redis::Driver.new(redis: { host: 'localhost', port: 6379, db: 1, tim
             end
           end
 
-          raise ArgumentError, "Unable to construct Redis connection from arguments: #{opts.inspect}" unless self.pool && self.pool.respond_to?(:with)
+          raise ArgumentError, "Unable to construct Redis connection from arguments: #{opts.inspect}" unless pool&.respond_to?(:with)
         end
 
         %i(set get incr decr setex expire del setnx exists zadd zrange).each do |method|
@@ -117,7 +118,7 @@ SimpleFeed::Redis::Driver.new(redis: { host: 'localhost', port: 6379, db: 1, tim
         alias_method :rm, :del
         alias_method :exists?, :exists
 
-        def exec(redis_method, *args, **opts, &block)
+        def exec(redis_method, *args, **_opts, &block)
           send_proc = redis_method if redis_method.respond_to?(:call)
           send_proc ||= ->(redis) { redis.send(redis_method, *args, &block) }
 
@@ -125,7 +126,7 @@ SimpleFeed::Redis::Driver.new(redis: { host: 'localhost', port: 6379, db: 1, tim
         end
 
         class MockRedis
-          def method_missing(name, *args, &block)
+          def method_missing(name, *args, **_opts, &block)
             puts "calling redis.#{name}(#{args.to_s.gsub(/[\[\]]/, '')}) { #{block ? block.call : nil} }"
           end
         end
@@ -133,17 +134,15 @@ SimpleFeed::Redis::Driver.new(redis: { host: 'localhost', port: 6379, db: 1, tim
         def with_redis
           with_retries do
             pool.with do |redis|
-              yield(self.debug? ? LoggingRedis.new(redis) : redis)
+              yield(debug? ? LoggingRedis.new(redis) : redis)
             end
           end
         end
 
-        def with_pipelined
+        def with_pipelined(&block)
           with_retries do
             with_redis do |redis|
-              redis.pipelined do
-                yield(redis)
-              end
+              redis.pipelined(&block)
             end
           end
         end
@@ -170,13 +169,12 @@ SimpleFeed::Redis::Driver.new(redis: { host: 'localhost', port: 6379, db: 1, tim
             on_error e
           end
         rescue ::Redis::CommandError => e
-          (e.message =~ /loading/i || e.message =~ /connection/i) ? on_error(e) : raise(e)
+          e.message =~ /loading/i || e.message =~ /connection/i ? on_error(e) : raise(e)
         end
 
         def on_error(e)
-          raise Error.new(e)
+          raise Error, e
         end
-
       end
     end
   end

data/lib/simplefeed/providers/redis/provider.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'redis'
 require 'base62-rb'
 require 'forwardable'
@@ -21,7 +23,6 @@ module SimpleFeed
       #     u.afkj234.meta: { total: 2, unread: 2, last_read: 2016-11-20 22:00:34 -08:00 GMT }
       #   ```
       class Provider < ::SimpleFeed::Providers::Base::Provider
-
         # SimpleFeed::Providers.define_provider_methods(self) do |provider, method, **opts, &block|
         #   users = Users.new(provider: provider, user_ids: opts.delete(:user_ids))
         #   opts.empty? ?
@@ -48,10 +49,11 @@ module SimpleFeed
 
         def delete_if(user_ids:)
           raise ArgumentError, '#delete_if must be called with a block that receives (user_id, event) as arguments.' unless block_given?
+
           with_response_batched(user_ids) do |key|
-            fetch(user_ids: [key.user_id])[key.user_id].map do |event|
+            fetch(user_ids: [key.consumer])[key.consumer].map do |event|
               with_redis do |redis|
-                if yield(event, key.user_id)
+                if yield(event, key.consumer)
                   redis.zrem(key.data, event.value) ? event : nil
                 end
               end
@@ -88,7 +90,7 @@ module SimpleFeed
 
           response = with_response_pipelined(user_ids) do |redis, key|
             if since == :unread
-              redis.zrevrangebyscore(key.data, '+inf', (last_read_response.delete(key.user_id) || 0).to_f, withscores: true)
+              redis.zrevrangebyscore(key.data, '+inf', (last_read_response.delete(key.consumer) || 0).to_f, withscores: true)
             elsif since
               redis.zrevrangebyscore(key.data, '+inf', since.to_f, withscores: true)
             else
@@ -118,7 +120,7 @@ module SimpleFeed
             get_users_last_read(redis, key)
           end
           with_response_pipelined(response.user_ids, response) do |redis, key, _response|
-            last_read = _response.delete(key.user_id).to_f
+            last_read = _response.delete(key.consumer).to_f
             redis.zcount(key.data, last_read, '+inf')
           end
         end
@@ -129,7 +131,7 @@ module SimpleFeed
           end
         end
 
-        FEED_METHODS = %i(total_memory_bytes total_users last_disk_save_time)
+        FEED_METHODS = %i(total_memory_bytes total_users last_disk_save_time).freeze
 
         def total_memory_bytes
           with_stats(:used_memory_since_boot)
@@ -147,39 +149,39 @@ module SimpleFeed
 
         def transform_response(user_id = nil, result)
           case result
-            when ::Redis::Future
-              transform_response(user_id, result.value)
+          when ::Redis::Future
+            transform_response(user_id, result.value)
 
-            when ::Hash
+          when ::Hash
 
-              if result.values.any? { |v| transformable_type?(v) }
-                result.each { |k, v| result[k] = transform_response(user_id, v) }
-              else
-                result
-              end
+            if result.values.any? { |v| transformable_type?(v) }
+              result.each { |k, v| result[k] = transform_response(user_id, v) }
+            else
+              result
+            end
 
-            when ::Array
+          when ::Array
 
-              if result.any? { |v| transformable_type?(v) }
-                result = result.map { |v| transform_response(user_id, v) }
-              end
+            if result.any? { |v| transformable_type?(v) }
+              result = result.map { |v| transform_response(user_id, v) }
+            end
 
-              if result.size == 2 && result[1].is_a?(Float)
-                SimpleFeed::Event.new(value: result[0], at: Time.at(result[1]))
-              else
-                result
-              end
+            if result.size == 2 && result[1].is_a?(Float)
+              SimpleFeed::Event.new(value: result[0], at: Time.at(result[1]))
+            else
+              result
+            end
 
-            when ::String
-              if result =~ /^\d+\.\d+$/
-                result.to_f
-              elsif result =~ /^\d+$/
-                result.to_i
-              else
-                result
-              end
+          when ::String
+            if result =~ /^\d+\.\d+$/
+              result.to_f
+            elsif result =~ /^\d+$/
+              result.to_i
             else
               result
+            end
+          else
+            result
           end
         end
 
@@ -194,9 +196,9 @@ module SimpleFeed
 
         private
 
-        #——————————————————————————————————————————————————————————————————————————————————————
+        # ——————————————————————————————————————————————————————————————————————————————————————
         # helpers
-        #——————————————————————————————————————————————————————————————————————————————————————
+        # ——————————————————————————————————————————————————————————————————————————————————————
 
         def reset_users_last_read(redis, key, time = nil)
           time = time.nil? ? Time.now.to_f : time.to_f
@@ -214,14 +216,14 @@ module SimpleFeed
           redis.zrevrange(key.data, (page - 1) * per_page, page * per_page - 1, withscores: true)
         end
 
-        #——————————————————————————————————————————————————————————————————————————————————————
+        # ——————————————————————————————————————————————————————————————————————————————————————
         # Operations with response
-        #——————————————————————————————————————————————————————————————————————————————————————
+        # ——————————————————————————————————————————————————————————————————————————————————————
 
         def with_response_pipelined(user_ids, response = nil)
           with_response(response) do |response|
             batch_pipelined(user_ids) do |redis, key|
-              response.for(key.user_id) { yield(redis, key, response) }
+              response.for(key.consumer) { yield(redis, key, response) }
             end
           end
         end
@@ -229,14 +231,14 @@ module SimpleFeed
         def with_response_multi(user_ids, response = nil)
           with_response(response) do |response|
             batch_multi(user_ids) do |redis, key|
-              response.for(key.user_id) { yield(redis, key, response) }
+              response.for(key.consumer) { yield(redis, key, response) }
             end
           end
         end
 
-        #——————————————————————————————————————————————————————————————————————————————————————
+        # ——————————————————————————————————————————————————————————————————————————————————————
         # Batch operations
-        #——————————————————————————————————————————————————————————————————————————————————————
+        # ——————————————————————————————————————————————————————————————————————————————————————
         def batch_pipelined(user_ids)
           to_array(user_ids).each_slice(batch_size) do |batch|
             with_pipelined do |redis|

data/lib/simplefeed/providers/redis/stats.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'redis'
 require 'hashie/mash'
 require 'yaml'
@@ -6,7 +8,6 @@ module SimpleFeed
   module Providers
     module Redis
       class Stats
-
         attr_accessor :redis
 
         def initialize(redis)
@@ -56,27 +57,25 @@ module SimpleFeed
           end
 
           def load_boot_stats!
-            @boot_info ||= destringify(YAML.load(File.open(File.expand_path('../boot_info.yml', __FILE__))))
+            @boot_info ||= destringify(YAML.load(File.open(File.expand_path('boot_info.yml', __dir__))))
           end
-
         end
 
         load_boot_stats!
 
         boot_info.keys.each do |key|
-          unless key.to_s =~ /^db[0-9]+/
+          next if key.to_s =~ /^db[0-9]+/
 
-            define_method(key.to_sym) do
-              info[key]
-            end
+          define_method(key.to_sym) do
+            info[key]
+          end
 
-            define_method("#{key}_at_boot".to_sym) do
-              boot_info[key]
-            end
+          define_method("#{key}_at_boot".to_sym) do
+            boot_info[key]
+          end
 
-            define_method("#{key}_since_boot".to_sym) do
-              info[key] - boot_info[key]
-            end
+          define_method("#{key}_since_boot".to_sym) do
+            info[key] - boot_info[key]
           end
         end
       end

data/lib/simplefeed/providers/redis.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SimpleFeed
   module Providers
     module Redis

data/lib/simplefeed/providers.rb

@@ -1,33 +1,48 @@
+# frozen_string_literal: true
+
 require_relative 'providers/key'
 require_relative 'providers/proxy'
 
 module SimpleFeed
   module Providers
     @registry = {}
-    
+
     def self.registry
       @registry
     end
-    
+
     def self.register(provider_name, provider_class)
-      self.registry[provider_name] = provider_class
+      registry[provider_name] = provider_class
     end
-    
+
     # These methods must be implemented by each Provider, and operation on a given
     # set of users passed via the user_ids: parameter.
-    ACTIVITY_METHODS = %i(store delete delete_if wipe reset_last_read last_read paginate fetch total_count unread_count)
+    ACTIVITY_METHODS = %i[
+      store
+      delete
+      delete_if
+      wipe
+      reset_last_read
+      last_read paginate
+      fetch
+      total_count
+      unread_count
+    ].freeze
 
-    # These methods must be implemented in order to gather statistics about each provider's
+    # These optional methods must be implemented in order to gather statistics about each provider's
     # memory consumption and state.
-    FEED_METHODS = %i(total_memory_bytes total_users)
+    FEED_METHODS = %i[
+      total_memory_bytes
+      total_users
+    ].freeze
 
-    REQUIRED_METHODS = ACTIVITY_METHODS + FEED_METHODS
+    REQUIRED_METHODS = (ACTIVITY_METHODS + FEED_METHODS).freeze
 
     def self.define_provider_methods(klass, prefix = nil, &block)
       # Methods on the class instance
       klass.class_eval do
         SimpleFeed::Providers::REQUIRED_METHODS.each do |m|
-          method_name = prefix ? "#{prefix}_#{m.to_s}".to_sym : m
+          method_name = prefix ? "#{prefix}_#{m}".to_sym : m
           define_method(method_name) do |*args, **opts, &b|
             block.call(self, m, *args, **opts, &b)
           end
@@ -37,5 +52,4 @@ module SimpleFeed
   end
 end
 
-require_relative 'providers/hash'
 require_relative 'providers/redis'