simple-feed 1.0.2

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+require 'yard'
+
+
+YARD::Rake::YardocTask.new(:doc) do |t|
+  t.files = %w(lib/**/*.rb exe/*.rb - README.md LICENSE.txt)
+  t.options.unshift('--title', '"SimpleFeed — Fast and Scalable "write-time" Simple Feed for Social Networks, with a Redis-based default backend implementation."')
+  t.after = ->() { exec('open doc/index.html') } if RUBY_PLATFORM =~ /darwin/
+end
+
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "activity/feed"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/hash_provider_example.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+# This is an executable example of working with a Redis feed, and storing
+# events for various users.
+# 
+# DEPENDENCIES: 
+#  gem install colored2
+#  gem install awesome_print
+#
+# RUNNING
+#  ruby redis-feed.rb
+#
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'simplefeed'
+
+@feed = SimpleFeed.define(:news) do |f|
+  f.provider = SimpleFeed.provider(:hash)
+  f.max_size = 1000
+end
+
+require_relative 'shared/provider_example'
+

data/examples/redis_provider_example.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+# This is an executable example of working with a Redis feed, and storing
+# events for various users.
+# 
+# DEPENDENCIES: 
+#   gem install colored2
+#   gem install awesome_print
+#
+# RUNNING
+#   ruby examples/redis-feed.rb [ number_of_users ] 
+#
+# TO SEE ALL REDIS COMMANDS:
+#   export REDIS_DEBUG=1
+#   ruby examples/redis-feed.rb
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'simplefeed'
+
+@feed = SimpleFeed.define(:news) do |f|
+  f.provider = SimpleFeed.provider(:redis,
+                                   redis: -> { Redis.new },
+                                   pool_size: 10,
+                                   batch_size: 10)
+end
+
+require_relative 'shared/provider_example'

data/examples/shared/provider_example.rb

@@ -0,0 +1,66 @@
+$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
+
+# Please set @feed in the enclosing context
+
+raise ArgumentError, 'No @feed defined in the enclosing example' unless defined?(@feed)
+
+require 'simplefeed'
+
+@number_of_users = ARGV[0] ? ARGV[0].to_i : 1
+@users           = Array.new(@number_of_users) { rand(200_000_000...800_000_000) }
+@activity        = @feed.activity(@users)
+@uid             = @users.first
+
+include SimpleFeed::DSL
+
+class Object
+  def _v
+    self.to_s.bold.red
+  end
+end
+
+def p(*args)
+  printf "%-40s %s\n", args[0].blue, args[1].bold.red
+end
+
+with_activity(@activity) do
+  header "#{@activity.feed.provider_type.to_s} provider example"
+  wipe { puts 'wiping feed...' }
+
+  store('value one') { p 'storing', 'value one' }
+  store('value two') { p 'storing', 'value two' }
+  store('value three') { p 'storing', 'value three' }
+  hr
+
+  total_count { |r| p 'total_count is now', "#{r[@uid]._v}" }
+  unread_count { |r| p 'unread_count is now', "#{r[@uid]._v}" }
+
+  header 'FIRST PAGE (PER-PAGE: 2) #to_json'
+  paginate(page: 1, per_page: 2) { |r| puts r[@uid].map(&:to_json) }
+  header 'SECOND PAGE (PER-PAGE: 2) #to_s'
+  paginate(page: 2, per_page: 2) { |r| puts r[@uid].map(&:to_s) }
+  header 'LAST PAGE (PER-PAGE: 1) #to_color_s'
+  paginate(page: 3, per_page: 1) { |r| puts r[@uid].map(&:to_color_s) }
+
+  hr
+  total_count { |r| p 'total_count is now', "#{r[@uid]._v}" }
+  unread_count { |r| p 'unread_count is now', "#{r[@uid]._v}" }
+
+  hr
+  store('value four') { p 'storing', 'value four' }
+  total_count { |r| p 'total_count is now', "#{r[@uid]._v}" }
+  unread_count { |r| p 'unread_count is now', "#{r[@uid]._v}" }
+
+  color_dump
+
+  hr
+  delete('value three') { p 'deleting', 'value three' }
+  total_count { |r| p 'total_count is now', "#{r[@uid]._v}" }
+  unread_count { |r| p 'unread_count is now', "#{r[@uid]._v}" }
+  hr
+  delete('value four') { p 'deleting', 'value four' }
+  total_count { |r| p 'total_count is now', "#{r[@uid]._v}" }
+  unread_count { |r| p 'unread_count is now', "#{r[@uid]._v}" }
+
+end
+

data/lib/simple-feed.rb

@@ -0,0 +1 @@
+require 'simplefeed'

data/lib/simple_feed.rb

@@ -0,0 +1 @@
+require 'simplefeed'

data/lib/simplefeed.rb

@@ -0,0 +1,61 @@
+require 'hashie/extensions/symbolize_keys'
+require 'simplefeed/version'
+
+::Dir.glob(::File.expand_path('../simplefeed/*.rb', __FILE__)).each { |f| require_relative(f) }
+
+require 'simplefeed/providers/redis'
+require 'simplefeed/providers/hash'
+require 'simplefeed/dsl'
+
+Float.class_eval do
+  def near_eql?(other)
+    delta = 0.001
+    n     = (other - self).abs
+    delta >= n
+  end
+end
+
+module SimpleFeed
+  @registry = {}
+
+  def self.registry
+    @registry
+  end
+
+  def self.define(name, **options, &block)
+    name = name.to_sym unless name.is_a?(Symbol)
+    feed = registry[name] ? registry[name] : SimpleFeed::Feed.new(name)
+    feed.configure(options) do
+      block.call(feed) if block
+    end
+    registry[name] = feed
+    feed
+  end
+
+  def self.get(name)
+    registry[name.to_sym]
+  end
+
+  def self.provider(provider_name, *args, **opts, &block)
+    provider_class = SimpleFeed::Providers.registry[provider_name]
+    raise ArgumentError, "No provider named #{provider_name} was found, #{SimpleFeed::Providers.registry.inspect}" unless provider_class
+    provider_class.new(*args, **opts, &block)
+  end
+
+  class << self
+    # Forward all other method calls to Provider
+    def method_missing(name, *args, &block)
+      registry[name] || super
+    end
+  end
+
+  # Returns list of class attributes based on the setter methods.
+  # Not fool-proof, but works in this context.
+  def self.class_attributes(klass)
+    klass.instance_methods.grep(%r{[^=!]=$}).map { |m| m.to_s.gsub(/=/, '').to_sym }
+  end
+
+  def self.symbolize!(hash)
+    Hashie::Extensions::SymbolizeKeys.symbolize_keys!(hash)
+  end
+end

data/lib/simplefeed/activity/base.rb

@@ -0,0 +1,14 @@
+module SimpleFeed
+  module Activity
+    class Base
+      attr_reader :feed
+
+      def initialize(feed:)
+        @feed = feed
+      end
+    end
+  end
+end
+
+require_relative 'multi_user'
+require_relative 'single_user'

data/lib/simplefeed/activity/multi_user.rb

@@ -0,0 +1,71 @@
+require 'forwardable'
+require_relative 'base'
+
+module SimpleFeed
+  module Activity
+    class MultiUser < Base
+
+      attr_reader :user_ids
+
+      extend Forwardable
+      def_delegators :@user_ids, :size, :each, :select, :delete_if, :inject
+
+      include Enumerable
+
+      #
+      # Multi-user API for the feeds.
+      #
+      # ```ruby
+      # @multi = SimpleFeed.get(:feed_name).for(User.active.map(&:id))
+      #
+      # @multi.store(value:, at:)
+      # @multi.store(event:)
+      # # => [Response] { user_id => [Boolean], ... } true if the value was stored, false if it wasn't.
+      #
+      # @multi.delete(value:, at:)
+      # @multi.delete(event:)
+      # # => [Response] { user_id => [Boolean], ... } true if the value was deleted, false if it didn't exist
+      #
+      # @multi.wipe
+      # # => [Response] { user_id => [Boolean], ... } true if user activity was found and deleted, false otherwise
+      #
+      # @multi.paginate(page:, per_page:, peek: false)
+      # # => [Response] { user_id => [Array]<Event>, ... }
+      #
+      # # With (peak: true) does not reset last_read, otherwise it does.
+      #
+      # @multi.fetch
+      # # => [Response] { user_id => [Array]<Event>, ... }
+      #
+      # @multi.reset_last_read
+      # # => [Response] { user_id => [Time] last_read, ... }
+      #
+      # @multi.total_count
+      # # => [Response] { user_id => [Integer] total_count, ... }
+      #
+      # @multi.unread_count
+      # # => [Response] { user_id => [Integer] unread_count, ... }
+      #
+      # @multi.last_read
+      # # => [Response] { user_id => [Time] last_read, ... }
+      # ```
+
+      SimpleFeed::Providers.define_provider_methods(self) do |instance, method, *args, **opts, &block|
+        opts.merge!(user_ids: instance.user_ids)
+        if opts[:event]
+          opts.merge!(value: opts[:event].value, at: opts[:event].at)
+          opts.delete(:event)
+        end
+        response = instance.feed.send(method, *args, **opts, &block)
+        yield(response) if block_given?
+        raise StandardError, "Nil response from provider #{instance.feed.provider&.provider&.class}, method #{method}(#{opts})" unless response
+        response
+      end
+
+      def initialize(feed:, user_ids:)
+        super(feed: feed)
+        @user_ids = user_ids
+      end
+    end
+  end
+end

data/lib/simplefeed/activity/single_user.rb

@@ -0,0 +1,70 @@
+require_relative 'base'
+
+module SimpleFeed
+  module Activity
+
+    # Lazy implementation of SingleUser based on delegating an array of
+    # one user_id to +MultiUser+
+
+    class SingleUser < ::SimpleFeed::Activity::Base
+      attr_reader :user_id
+      attr_accessor :user_activity
+
+      include Enumerable
+
+      def each
+        yield(user_id)
+      end
+
+      #
+      # Single-user API for the feeds.
+      #
+      # @ua = SimpleFeed.get(:feed_name).user_activity(current_user.id)
+      #
+      # @ua.store(value:, at:)
+      # # => [Boolean] true if the value was stored, false if it wasn't.
+      #
+      # @ua.delete(value:, at:)
+      # # => [Boolean] true if the value was deleted, false if it didn't exist
+      #
+      # @ua.wipe
+      # # => [Boolean] true
+      #
+      # @ua.paginate(page:, per_page:, peek: false)
+      # # => [Array]<Event>
+      # # with peak: true does not reset last_read
+      #
+      # @ua.fetch
+      # # => [Array]<Event>
+      #
+      # @ua.reset_last_read
+      # # => [Time] last_read
+      #
+      # @ua.total_count
+      # # => [Integer] total_count
+      #
+      # @ua.unread_count
+      # # => [Integer] unread_count
+      #
+      # @ua.last_read
+      # # => [Time] last_read
+      # ```
+
+      SimpleFeed::Providers.define_provider_methods(self) do |instance, method, *args, **opts, &block|
+        response = instance.user_activity.send(method, *args, **opts, &block)
+        unless response.has_user?(instance.user_id)
+          raise StandardError, "Nil response from provider #{instance.feed.provider&.provider&.class}, method #{method}(#{opts}) — user_id #{instance.user_id}"
+        end
+        response = response[instance.user_id]
+        yield(response) if block_given?
+        response
+      end
+
+      def initialize(user_id:, feed:)
+        @feed              = feed
+        @user_id           = user_id
+        self.user_activity = MultiUser.new(feed: feed, user_ids: [user_id])
+      end
+    end
+  end
+end

data/lib/simplefeed/dsl.rb

@@ -0,0 +1,38 @@
+require_relative 'providers'
+require 'simplefeed'
+require_relative 'dsl/activities'
+
+module SimpleFeed
+  # This module offers a convenient DSL-based approach to manipulating user feeds.
+  #
+  # Usage:
+  #
+  #     require 'simplefeed/dsl'
+  #     include SimpleFeed::DSL
+  #
+  #     with_activity(SimpleFeed.get(:newsfeed).activity(user_id)) do
+  #       puts 'success' if store(value: 'hello', at: Time.now)
+  #       puts fetch
+  #       puts total_count
+  #       puts unread_count
+  #     end
+  #
+  module DSL
+    class << self
+      attr_accessor :debug
+
+      def debug?
+        self.debug
+      end
+    end
+
+    def with_activity(activity, **opts, &block)
+      opts.merge!({ context: self }) unless opts && opts[:context]
+      SimpleFeed::DSL::Activities.new(activity, **opts).instance_eval(&block)
+    end
+
+    def event(value, at = Time.now)
+      SimpleFeed::Event.new(value, at)
+    end
+  end
+end

data/lib/simplefeed/dsl/activities.rb

@@ -0,0 +1,70 @@
+require_relative 'formatter'
+module SimpleFeed
+  module DSL
+    class Activities
+
+      include SimpleFeed::DSL::Formatter
+
+      attr_accessor :activity, :feed
+
+      def initialize(activity, **opts)
+        self.activity = activity
+        self.feed     = activity.feed
+        opts.each_pair do |key, value|
+          self.class.instance_eval do
+            attr_accessor key
+          end
+          self.send("#{key}=".to_sym, value)
+        end
+      end
+
+      # Creates wrapper methods around the API and optionally prints both calls and return values
+      #
+      # def store(event: .., | value:, at: )
+      #   activity.store(**opts)
+      # end
+      # etc...
+      SimpleFeed::Providers.define_provider_methods(self) do |instance, method, *args, **opts, &block|
+        if args&.first
+          arg1 = args.shift
+          if arg1.is_a?(SimpleFeed::Event)
+            event = arg1
+          else
+            opts[:value] = arg1 unless opts[:value]
+            opts[:at]    = args.shift unless opts[:value]
+          end
+        else
+          event = opts.delete(:event)
+        end
+
+        opts.merge!(value: event.value, at: event.at) if event
+
+        response = instance.instance_eval do
+          print_debug_info(method, **opts) do
+            activity.send(method, *args, **opts)
+          end
+        end
+
+        if block
+          if instance.context
+            instance.context.instance_exec(response, &block)
+          else
+            block.call(response)
+          end
+        end
+
+        response
+      end
+
+      private
+
+      def print_debug_info(method, **opts)
+        brackets = opts.empty? ? ['', ''] : %w{( )}
+        printf "\n#{self.feed.name.to_s.blue}.#{method.to_s.cyan.bold}#{brackets[0]}#{opts.to_s.gsub(/[{}]/, '').blue}#{brackets[1]} \n" if SimpleFeed::DSL.debug?
+        response = yield if block_given?
+        puts response.inspect.yellow if SimpleFeed::DSL.debug?
+        response
+      end
+    end
+  end
+end