simple-feed 1.0.2

data/lib/simplefeed/dsl/formatter.rb

@@ -0,0 +1,109 @@
+require 'simplefeed/dsl'
+require 'simplefeed/activity/single_user'
+require 'simplefeed/activity/multi_user'
+module SimpleFeed
+  module DSL
+    module Formatter
+      include SimpleFeed::DSL
+
+      attr_accessor :activity, :feed
+
+      def color_dump(_activity = activity)
+        _activity = if _activity.is_a?(SimpleFeed::Activity::SingleUser)
+                      _activity.feed.activity([_activity.user_id])
+                    else
+                      _activity
+                    end
+        _puts
+
+        header do
+          field('Feed Name', feed.name, "\n")
+          field('Provider', feed.provider.provider.class, "\n")
+          field('Max Size', feed.max_size, "\n")
+        end
+
+        with_activity(_activity) do
+          _activity.each do |user_id|
+            _last_event_at = nil
+            _last_read     = (last_read[user_id] || 0.0).to_f
+
+            [['User ID', user_id, "\n"],
+             ['Activities', sprintf('%d total, %d unread', total_count[user_id], unread_count[user_id]), "\n"],
+             ['Last Read', _last_read ? Time.at(_last_read) : 'N/A'],
+            ].each do |field, value, *args|
+              field(field, value, *args)
+            end
+
+            _puts; hr '¨'
+
+            _events       = fetch[user_id]
+            _events_count = _events.size
+            _events.each_with_index do |_event, _index|
+
+              if _last_event_at.nil? && _event.at < _last_read
+                print_last_read_separator(_last_read)
+              elsif _last_event_at && _last_read < _last_event_at && _last_read > _event.at
+                print_last_read_separator(_last_read)
+              end
+
+              _last_event_at = _event.at # float
+              _print "[%2d] %16s %s\n", _index, _event.time.strftime(TIME_FORMAT).blue.bold, _event.value
+              if _index == _events_count - 1 && _last_read < _event.at
+                print_last_read_separator(_last_read)
+              end
+            end
+          end
+        end
+      end
+
+      def print_last_read_separator(lr)
+        _print ">>>> %16s <<<< last read\n", Time.at(lr).strftime(TIME_FORMAT).red.bold
+      end
+    end
+
+    @print_method = :printf
+
+    class << self
+      attr_accessor :print_method
+    end
+
+    def _print(*args, **opts, &block)
+      send(SimpleFeed::DSL.print_method, *args, **opts, &block)
+    end
+
+    def _puts(*args)
+      send(SimpleFeed::DSL.print_method, "\n" + args.join)
+    end
+
+    def field_label(text)
+      sprintf ' %20s ', text
+    end
+
+    TIME_FORMAT = '%Y-%m-%d %H:%M:%S.%L'
+
+    def field_value(value)
+      case value
+        when Numeric
+          sprintf '%-20d', value
+        when Time
+          sprintf '%-30s', value.strftime(TIME_FORMAT)
+        else
+          sprintf '%-20s', value.to_s
+      end
+    end
+
+    def field(label, value, sep = '')
+      _print field_label(label).italic + field_value(value).cyan.bold + sep
+    end
+
+    def hr(char = '—')
+      _print (char * 75 + "\n").magenta
+    end
+
+    def header(message = nil)
+      hr
+      block_given? ? yield : _print(message.capitalize.magenta.bold + "\n")
+      hr
+    end
+  end
+end

data/lib/simplefeed/event.rb

@@ -0,0 +1,87 @@
+require 'json'
+
+module SimpleFeed
+  class Event
+    attr_accessor :value, :at
+    include Comparable
+
+    def initialize(*args, value: nil, at: Time.now)
+      if args && args.size > 0
+        self.value = args[0]
+        self.at    = args[1] || at
+      else
+        self.value = value
+        self.at    = at
+      end
+
+      self.at = self.at.to_f
+
+      validate!
+    end
+
+    def time
+      Time.at(at)
+    end
+
+    def <=>(other)
+      -self.at <=> -other.at
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other)
+      other.is_a?(SimpleFeed::Event) &&
+        self.value == other.value
+    end
+
+    def to_h
+      { value: value, at: at, time: time }
+    end
+
+    def hash
+      self.value.hash
+    end
+
+    def to_json
+      to_h.to_json
+    end
+
+    def to_yaml
+      YAML.dump(to_h)
+    end
+
+    def to_s
+      "Event Value: [#{value}], epoch: [#{at}], time: [#{time}]"
+    end
+
+    def to_color_s
+      counter = 0
+      to_s.gsub(/,/, '-').split(/[\[\]]/).map do |word|
+        counter += 1
+        counter.even? ? word.bold.yellow + "\n": word.blue
+      end.join('').gsub(/[\n] /, '')
+    end
+
+    def inspect
+      super
+    end
+
+
+    private
+
+    def validate!
+      unless self.value && self.at
+        raise ArgumentError, "Required arguments missing, value=[#{value}], at=[#{at}]"
+      end
+    end
+
+    def copy(&block)
+      copy = self.clone
+      copy.instance_eval(&block)
+      copy
+    end
+
+  end
+end

data/lib/simplefeed/feed.rb

@@ -0,0 +1,78 @@
+require_relative 'providers'
+require_relative 'activity/base'
+module SimpleFeed
+  class Feed
+
+    attr_accessor :per_page, :max_size, :batch_size, :meta, :namespace
+    attr_reader :name
+
+    SimpleFeed::Providers.define_provider_methods(self) do |feed, method, opts, &block|
+      feed.provider.send(method, **opts, &block)
+    end
+
+    def initialize(name)
+      @name      = name
+      @name      = name.underscore.to_sym unless name.is_a?(Symbol)
+      # set the defaults if not passed in
+      @meta      = {}
+      @namespace = nil
+      @per_page  ||= 50
+      @max_size  ||= 1000
+      @batch_size||= 10
+      @proxy     = nil
+    end
+
+    def provider=(definition)
+      @proxy      = Providers::Proxy.from(definition)
+      @proxy.feed = self
+      @proxy
+    end
+
+    def provider
+      @proxy
+    end
+
+    def provider_type
+      SimpleFeed::Providers::Base::Provider.class_to_registry(@proxy.provider.class)
+    end
+
+    def user_activity(user_id)
+      Activity::SingleUser.new(user_id: user_id, feed: self)
+    end
+
+    def users_activity(user_ids)
+      Activity::MultiUser.new(user_ids: user_ids, feed: self)
+    end
+
+    # Depending on the argument returns either +SingleUserActivity+ or +MultiUserActivity+
+    def activity(one_or_more_users)
+      one_or_more_users.is_a?(Array) ?
+        users_activity(one_or_more_users) :
+        user_activity(one_or_more_users)
+    end
+
+    # @deprecated Please use {#activity} instead
+    def for(*args)
+      STDERR.puts 'WARNING: method #for is deprecated, please use #activity'
+      activity(*args)
+    end
+
+    def configure(hash = {})
+      SimpleFeed.symbolize!(hash)
+      class_attrs.each do |attr|
+        self.send("#{attr}=", hash[attr]) if hash.key?(attr)
+      end
+      yield self if block_given?
+    end
+
+    def eql?(other)
+      other.class == self.class &&
+        %i(per_page max_size name).all? { |m| self.send(m).equal?(other.send(m)) } &&
+        self.provider.provider.class == other.provider.provider.class
+    end
+
+    def class_attrs
+      SimpleFeed.class_attributes(self.class)
+    end
+  end
+end

data/lib/simplefeed/providers.rb

@@ -0,0 +1,45 @@
+require_relative 'providers/serialization/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
+    end
+    
+    def self.key(*args)
+      SimpleFeed::Providers::Serialization::Key.new(*args)
+    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)
+
+    # These 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)
+
+    REQUIRED_METHODS = ACTIVITY_METHODS + FEED_METHODS
+
+    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
+          define_method(method_name) do |*args, **opts, &b|
+            block.call(self, m, *args, **opts, &b)
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative 'providers/hash'
+require_relative 'providers/redis'

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

@@ -0,0 +1,84 @@
+require 'simplefeed/providers/serialization/key'
+
+module SimpleFeed
+  module Providers
+    class NotImplementedError < ::StandardError
+      def initialize(klass, method)
+        super("Class #{klass.name} did not implement abstract method #{method}, but was called.")
+      end
+    end
+
+    module Base
+      class Provider
+        attr_accessor :feed
+
+        def self.class_to_registry(klass)
+          klass.name.split('::').delete_if { |n| %w(SimpleFeed Providers Provider).include?(n) }.compact.last.downcase.to_sym
+        end
+
+        def self.inherited(klass)
+          SimpleFeed::Providers.register(class_to_registry(klass), klass)
+        end
+
+        # SimpleFeed::Providers::REQUIRED_METHODS.each do |m|
+        #   define_method(m) do |*|
+        #     raise ::SimpleFeed::Providers::NotImplementedError.new(self, m)
+        #   end
+        # end
+
+        protected
+
+        def tap(value)
+          yield
+          value
+        end
+
+        def key(user_id)
+          ::SimpleFeed::Providers.key(user_id, feed.namespace)
+        end
+
+        def to_array(user_ids)
+          user_ids.is_a?(Array) ? user_ids : [user_ids]
+        end
+
+        def batch_size
+          feed.batch_size
+        end
+
+        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) }
+            end
+          end
+        end
+
+        def batch(user_ids)
+          to_array(user_ids).each_slice(batch_size) do |batch|
+            batch.each do |user_id|
+              yield(key(user_id))
+            end
+          end
+        end
+
+        def with_response(response = nil)
+          response ||= SimpleFeed::Response.new
+          yield(response)
+          if self.respond_to?(:transform_response)
+            response.transform do |user_id, result|
+              # calling into a subclass
+              transform_response(user_id, result)
+            end
+          end
+          response
+        end
+
+        def with_result
+          result = yield
+          result = transform_response(nil, result) if self.respond_to?(:transform_response)
+          result
+        end
+      end
+    end
+  end
+end

data/lib/simplefeed/providers/hash.rb

@@ -0,0 +1,8 @@
+module SimpleFeed
+  module Providers
+    module Hash
+    end
+  end
+end
+
+require_relative 'hash/provider'

data/lib/simplefeed/providers/hash/paginator.rb

@@ -0,0 +1,31 @@
+module SimpleFeed
+  module Providers
+    module Hash
+      # Include this module into any provider etc that has access to the +feed.fetch+
+      # methods, and it will provide +paginate+ method based on all.
+      #
+      # Of course this is not very efficient, because it requires fetching all events for the user.
+      module Paginator
+
+        def paginate(user_ids:, page: nil, per_page: feed.per_page, &block)
+          response = feed.fetch(user_ids: user_ids)
+          response = SimpleFeed::Response.new(response.to_h)
+          response.transform do |*, events|
+            paginate_items(order_events(events, &block), page: page, per_page: per_page)
+          end
+        end
+
+        def paginate_items(items, page: nil, per_page: nil)
+          (page && page > 0) ? items[((page - 1) * per_page)...(page * per_page)] : items
+        end
+
+        def order_events(events, &block)
+          return nil unless events
+          events.sort do |a, b|
+            block ? yield(a, b) : b.at <=> a.at
+          end
+        end
+      end
+    end
+  end
+end