redis-objects-periodical 0.4.0

data/README.md

@@ -0,0 +1,222 @@
+[![CircleCI](https://circleci.com/gh/ryz310/redis-objects-periodical.svg?style=svg)](https://circleci.com/gh/ryz310/redis-objects-periodical) [![Gem Version](https://badge.fury.io/rb/redis-objects-periodical.svg)](https://badge.fury.io/rb/redis-objects-periodical) [![Maintainability](https://api.codeclimate.com/v1/badges/deebb6c406c306a6f337/maintainability)](https://codeclimate.com/github/ryz310/redis-objects-periodical/maintainability) [![Test Coverage](https://api.codeclimate.com/v1/badges/deebb6c406c306a6f337/test_coverage)](https://codeclimate.com/github/ryz310/redis-objects-periodical/test_coverage)
+
+# Redis::Objects::Periodical
+
+This is a gem which extends [Redis::Objects](https://github.com/nateware/redis-objects) gem. Once install this gem, you can use the periodical counter, the periodical set, etc. in addition to the standard features of Redis::Objects. These counters and sets are useful for measuring conversions, implementing API rate limiting, MAU, DAU, and more.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'redis-objects-periodical'
+```
+
+If you want to know about installation and standard usage, please see Redis::Objects' GitHub page.
+
+## Usage
+
+`daily_counter` and `daily_set` automatically creates keys that are unique to each object, in the format:
+
+```
+model_name:id:field_name:yyyy-mm-dd
+```
+
+I recommend using with `expireat` option.
+For illustration purposes, consider this stub class:
+
+```rb
+class Homepage
+  include Redis::Objects
+
+  daily_counter :pv, expireat: -> { Time.now + 2_678_400 } # about a month
+  daily_hash_key :browsing_history, expireat: -> { Time.now + 2_678_400 } # about a month
+  daily_set :dau, expireat: -> { Time.now + 2_678_400 } # about a month
+
+  def id
+    1
+  end
+end
+
+# 2021-04-01
+homepage = Homepage.new
+homepage.id # 1
+
+homepage.pv.increment
+homepage.pv.increment
+homepage.pv.increment
+puts homepage.pv.value # 3
+
+# 2021-04-02 (next day)
+puts homepage.pv.value # 0
+homepage.pv.increment
+homepage.pv.increment
+puts homepage.pv.value # 2
+
+start_date = Date.new(2021, 4, 1)
+end_date = Date.new(2021, 4, 2)
+homepage.pv.range(start_date, end_date) # [3, 2]
+```
+
+### Periodical Counters
+
+The periodical counters automatically switches the save destination when the date changes.
+You can access past dates counted values like Ruby arrays:
+
+```rb
+# 2021-04-01
+homepage.pv.increment(3)
+
+# 2021-04-02 (next day)
+homepage.pv.increment(2)
+
+# 2021-04-03 (next day)
+homepage.pv.increment(5)
+
+homepage.pv[Date.new(2021, 4, 1)] # => 3
+homepage.pv[Date.new(2021, 4, 1), 3] # => [3, 2, 5]
+homepage.pv[Date.new(2021, 4, 1)..Date.new(2021, 4, 2)] # => [3, 2]
+
+homepage.pv.delete_at(Date.new(2021, 4, 1))
+homepage.pv.range(Date.new(2021, 4, 1), Date.new(2021, 4, 3)) # => [0, 2, 5]
+homepage.pv.at(Date.new(2021, 4, 2)) # => #<Redis::Counter key="homepage:1:pv:2021-04-02">
+homepage.pv.at(Date.new(2021, 4, 2)).value # 2
+```
+
+#### Periodical Counters Family
+
+- `annual_counter`
+  - Key format: `model_name:id:field_name:yyyy`
+  - Redis is a highly volatile key-value store, so I don't recommend using it.
+- `monthly_counter`
+  - Key format: `model_name:id:field_name:yyyy-mm`
+- `weekly_counter`
+  - Key format: `model_name:id:field_name:yyyyWw`
+- `daily_counter`
+  - Key format: `model_name:id:field_name:yyyy-mm-dd`
+- `hourly_counter`
+  - Key format: `model_name:id:field_name:yyyy-mm-ddThh`
+- `minutely_counter`
+  - Key format: `model_name:id:field_name:yyyy-mm-ddThh:mi`
+
+### Periodical Hashes
+
+The periodical hashes also automatically switches the save destination when the date changes.
+
+```rb
+# 2021-04-01
+homepage.browsing_history.incr('item1')
+homepage.browsing_history.incr('item2')
+homepage.browsing_history.incr('item2')
+puts homepage.browsing_history.all # { 'item1' => '1', 'item2' => '2' }
+
+# 2021-04-02 (next day)
+puts homepage.browsing_history.all # {}
+
+homepage.browsing_history.bulk_set('item1' => 3, 'item3' => 5)
+puts homepage.browsing_history.all # { 'item1' => '3', 'item3' => '5' }
+
+# 2021-04-03 (next day)
+homepage.browsing_history.incr('item2')
+homepage.browsing_history.incr('item4')
+puts homepage.browsing_history.all # { 'item2' => '1', 'item4' => '1' }
+
+homepage.browsing_history[Date.new(2021, 4, 1)] # => { 'item1' => '1', 'item2' => '2' }
+homepage.browsing_history[Date.new(2021, 4, 1), 3] # => { 'item1' => '4', 'item2' => '3', 'item3' => '5', 'item4' => '1' }
+homepage.browsing_history[Date.new(2021, 4, 1)..Date.new(2021, 4, 2)] # => { 'item1' => '4', 'item2' => '2', 'item3' => '5' }
+
+homepage.browsing_history.delete_at(Date.new(2021, 4, 1))
+homepage.browsing_history.range(Date.new(2021, 4, 1), Date.new(2021, 4, 3)) # => { 'item1' => '3', 'item2' => '1', 'item3' => '5', 'item4' => '1' }
+homepage.browsing_history.at(Date.new(2021, 4, 2)) # => #<Redis::HashKey key="homepage:1:browsing_history:2021-04-02">
+homepage.browsing_history.at(Date.new(2021, 4, 2)).all # { 'item1' => '3', 'item3' => '5' }
+```
+
+#### Periodical Hashes Family
+
+- `annual_hash_key`
+  - Key format: `model_name:id:field_name:yyyy`
+  - Redis is a highly volatile key-value store, so I don't recommend using it.
+- `monthly_hash_key`
+  - Key format: `model_name:id:field_name:yyyy-mm`
+- `weekly_hash_key`
+  - Key format: `model_name:id:field_name:yyyyWw`
+- `daily_hash_key`
+  - Key format: `model_name:id:field_name:yyyy-mm-dd`
+- `hourly_hash_key`
+  - Key format: `model_name:id:field_name:yyyy-mm-ddThh`
+- `minutely_hash_key`
+  - Key format: `model_name:id:field_name:yyyy-mm-ddThh:mi`
+
+### Periodical Sets
+
+The periodical sets also automatically switches the save destination when the date changes.
+
+```rb
+# 2021-04-01
+homepage.dau << 'user1'
+homepage.dau << 'user2'
+homepage.dau << 'user1' # dup ignored
+puts homepage.dau.members # ['user1', 'user2']
+puts homepage.dau.length # 2
+puts homepage.dau.count # alias of #length
+
+# 2021-04-02 (next day)
+puts homepage.dau.members # []
+
+homepage.dau.merge('user2', 'user3')
+puts homepage.dau.members # ['user2', 'user3']
+
+# 2021-04-03 (next day)
+homepage.dau.merge('user4')
+
+homepage.dau[Date.new(2021, 4, 1)] # => ['user1', 'user2']
+homepage.dau[Date.new(2021, 4, 1), 3] # => ['user1', 'user2', 'user3', 'user4']
+homepage.dau[Date.new(2021, 4, 1)..Date.new(2021, 4, 2)] # => ['user1', 'user2', 'user3']
+
+homepage.dau.delete_at(Date.new(2021, 4, 1))
+homepage.dau.range(Date.new(2021, 4, 1), Date.new(2021, 4, 3)) # => ['user2', 'user3', 'user4']
+homepage.dau.at(Date.new(2021, 4, 2)) # => #<Redis::Set key="homepage:1:dau:2021-04-02">
+homepage.dau.at(Date.new(2021, 4, 2)).members # ['user2', 'user3']
+```
+
+#### Periodical Sets Family
+
+- `annual_set`
+  - Key format: `model_name:id:field_name:yyyy`
+  - Redis is a highly volatile key-value store, so I don't recommend using it.
+- `monthly_set`
+  - Key format: `model_name:id:field_name:yyyy-mm`
+- `weekly_set`
+  - Key format: `model_name:id:field_name:yyyyWw`
+- `daily_set`
+  - Key format: `model_name:id:field_name:yyyy-mm-dd`
+- `hourly_set`
+  - Key format: `model_name:id:field_name:yyyy-mm-ddThh`
+- `minutely_set`
+  - Key format: `model_name:id:field_name:yyyy-mm-ddThh:mi`
+
+### Timezone
+
+This gem follows Ruby process' time zone, but if you extends Time class by ActiveSupport (e.g. `Time.current`), follows Rails process' timezone.
+
+## Development
+
+The development environment for this gem is configured with docker-compose.
+Please use the following command:
+
+    $ docker-compose up -d
+    $ docker-compose run --rm ruby bundle
+    $ docker-compose run --rm ruby rspec .
+    $ docker-compose run --rm ruby rubocop -a
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/redis-objects-periodical. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/redis-objects-periodical/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Redis::Objects::Daily::Counter project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/redis-objects-periodical/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_helper'
+
+Bundler::GemHelper.install_tasks(name: 'redis-objects-periodical')
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'redis-objects-periodical'
+
+Redis::Objects.redis = Redis.new(host: 'redis', port: 6379)
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

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/docker-compose.yml

@@ -0,0 +1,17 @@
+version: '3'
+
+services:
+  ruby:
+    build: .
+    depends_on:
+      - redis
+    volumes:
+      - .:/my_app
+      - bundle:/usr/local/bundle
+  redis:
+    image: redis:latest
+    ports:
+      - 6379:6379
+
+volumes:
+  bundle:

data/lib/redis/base_counter_object.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Redis
+  module BaseCounterObject
+    private
+
+    def get_redis_object(key)
+      Redis::Counter.new(key)
+    end
+
+    def get_value_from_redis(key)
+      redis.get(key).to_i
+    end
+
+    def get_values_from_redis(keys)
+      redis.mget(*keys).map(&:to_i)
+    end
+
+    def delete_from_redis(key)
+      redis.del(key)
+    end
+
+    def empty_value
+      []
+    end
+  end
+end

data/lib/redis/base_hash_key_object.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Redis
+  module BaseHashKeyObject
+    private
+
+    def get_redis_object(key)
+      Redis::HashKey.new(key)
+    end
+
+    def get_value_from_redis(key)
+      h = redis.hgetall(key) || {}
+      h.each { |k, v| h[k] = unmarshal(v, options[:marshal_keys][k]) }
+      h
+    end
+
+    def get_values_from_redis(keys) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      keys.inject({}) do |memo, key|
+        memo.merge(get_value_from_redis(key)) do |_, self_val, other_val|
+          values = [self_val, other_val]
+          if values.all? { |val| val =~ /\A\d+\z/ }
+            values.sum(&:to_i).to_s
+          elsif values.all? { |val| val =~ /\A\d+(\.\d+)?\z/ }
+            values.sum(&:to_f).to_s
+          else
+            values.join(',')
+          end
+        end
+      end
+    end
+
+    def delete_from_redis(key)
+      redis.del(key)
+    end
+
+    def empty_value
+      {}
+    end
+  end
+end

data/lib/redis/base_set_object.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Redis
+  module BaseSetObject
+    private
+
+    def get_redis_object(key)
+      Redis::Set.new(key)
+    end
+
+    def get_value_from_redis(key)
+      vals = redis.smembers(key)
+      vals.nil? ? [] : vals.map { |v| unmarshal(v) }
+    end
+
+    def get_values_from_redis(keys)
+      redis.sunion(*keys).map { |v| unmarshal(v) }
+    end
+
+    def delete_from_redis(key)
+      redis.del(key)
+    end
+
+    def empty_value
+      []
+    end
+  end
+end

data/lib/redis/objects/periodical/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Redis
+  module Objects
+    module Periodical
+      VERSION = '0.4.0'
+    end
+  end
+end

data/lib/redis/objects/periodical_counters.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'redis/periodical_counter'
+
+Redis::PERIODICALS.each do |periodical| # rubocop:disable Metrics/BlockLength
+  new_module = Module.new
+  new_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      def #{periodical}_counter(name, options = {})
+        options[:start] ||= 0
+        options[:type]  ||= (options[:start]).zero? ? :increment : :decrement
+        redis_objects[name.to_sym] = options.merge(type: :counter)
+
+        mod = Module.new do
+          define_method(name) do
+            Redis::#{periodical.capitalize}Counter.new(
+              redis_field_key(name), redis_field_redis(name), redis_options(name)
+            )
+          end
+        end
+
+        if options[:global]
+          extend mod
+
+          # dispatch to class methods
+          define_method(name) do
+            self.class.public_send(name)
+          end
+        else
+          include mod
+        end
+      end
+    end
+  RUBY
+  Redis::Objects.const_set("#{periodical.capitalize}Counters", new_module)
+end

data/lib/redis/objects/periodical_hashes.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'redis/periodical_hash_key'
+
+Redis::PERIODICALS.each do |periodical| # rubocop:disable Metrics/BlockLength
+  new_module = Module.new
+  new_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    # Class methods that appear in your class when you include Redis::Objects.
+    module ClassMethods
+      # Define a new hash key.  It will function like a regular instance
+      # method, so it can be used alongside ActiveRecord, DataMapper, etc.
+      def #{periodical}_hash_key(name, options = {})
+        redis_objects[name.to_sym] = options.merge(type: :dict)
+
+        mod = Module.new do
+          define_method(name) do
+            Redis::#{periodical.capitalize}HashKey.new(
+              redis_field_key(name), redis_field_redis(name), redis_options(name)
+            )
+          end
+
+          define_method(:"#\{name\}=") do |values|
+            hash_key = public_send(name)
+
+            redis.pipelined do
+              hash_key.clear
+              hash_key.bulk_set(values)
+            end
+          end
+        end
+
+        if options[:global]
+          extend mod
+
+          # dispatch to class methods
+          define_method(name) do
+            self.class.public_send(name)
+          end
+        else
+          include mod
+        end
+      end
+    end
+  RUBY
+  Redis::Objects.const_set("#{periodical.capitalize}Hashes", new_module)
+end

data/lib/redis/objects/periodical_sets.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'redis/periodical_set'
+
+Redis::PERIODICALS.each do |periodical| # rubocop:disable Metrics/BlockLength
+  new_module = Module.new
+  new_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    # Class methods that appear in your class when you include Redis::Objects.
+    module ClassMethods
+      # Define a new list.  It will function like a regular instance
+      # method, so it can be used alongside ActiveRecord, DataMapper, etc.
+      def #{periodical}_set(name, options = {})
+        redis_objects[name.to_sym] = options.merge(type: :set)
+
+        mod = Module.new do
+          define_method(name) do
+            Redis::#{periodical.capitalize}Set.new(
+              redis_field_key(name), redis_field_redis(name), redis_options(name)
+            )
+          end
+
+          define_method(:"#\{name\}=") do |values|
+            set = public_send(name)
+
+            redis.pipelined do
+              set.clear
+              set.merge(*values)
+            end
+          end
+        end
+
+        if options[:global]
+          extend mod
+
+          # dispatch to class methods
+          define_method(name) do
+            self.class.public_send(name)
+          end
+        else
+          include mod
+        end
+      end
+    end
+  RUBY
+  Redis::Objects.const_set("#{periodical.capitalize}Sets", new_module)
+end

data/lib/redis/periodical_counter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "#{File.dirname(__FILE__)}/recurring_at_intervals"
+require "#{File.dirname(__FILE__)}/base_counter_object"
+
+Redis::PERIODICALS.each do |periodical|
+  require "#{File.dirname(__FILE__)}/recurring_at_intervals/#{periodical}"
+
+  new_class = Class.new(Redis::Counter) do
+    include Redis::RecurringAtIntervals
+    include Redis::BaseCounterObject
+    include const_get("Redis::RecurringAtIntervals::#{periodical.capitalize}")
+  end
+  Redis.const_set("#{periodical.capitalize}Counter", new_class)
+end

data/lib/redis/periodical_hash_key.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "#{File.dirname(__FILE__)}/recurring_at_intervals"
+require "#{File.dirname(__FILE__)}/base_hash_key_object"
+
+Redis::PERIODICALS.each do |periodical|
+  require "#{File.dirname(__FILE__)}/recurring_at_intervals/#{periodical}"
+
+  new_class = Class.new(Redis::HashKey) do
+    include Redis::RecurringAtIntervals
+    include Redis::BaseHashKeyObject
+    include const_get("Redis::RecurringAtIntervals::#{periodical.capitalize}")
+  end
+  Redis.const_set("#{periodical.capitalize}HashKey", new_class)
+end

data/lib/redis/periodical_set.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "#{File.dirname(__FILE__)}/recurring_at_intervals"
+require "#{File.dirname(__FILE__)}/base_set_object"
+
+Redis::PERIODICALS.each do |periodical|
+  require "#{File.dirname(__FILE__)}/recurring_at_intervals/#{periodical}"
+
+  new_class = Class.new(Redis::Set) do
+    include Redis::RecurringAtIntervals
+    include Redis::BaseSetObject
+    include const_get("Redis::RecurringAtIntervals::#{periodical.capitalize}")
+  end
+  Redis.const_set("#{periodical.capitalize}Set", new_class)
+end

data/lib/redis/recurring_at_intervals/annual.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Redis
+  module RecurringAtIntervals
+    module Annual
+      private
+
+      def redis_daily_field_key(date_or_time)
+        date_key = date_or_time.strftime('%Y')
+        [original_key, date_key].flatten.join(':')
+      end
+
+      def next_key(date, length = 1)
+        date.next_year(length)
+      end
+    end
+  end
+end

data/lib/redis/recurring_at_intervals/daily.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Redis
+  module RecurringAtIntervals
+    module Daily
+      private
+
+      def redis_daily_field_key(date_or_time)
+        date_key = date_or_time.strftime('%Y-%m-%d')
+        [original_key, date_key].flatten.join(':')
+      end
+
+      def next_key(date, length = 1)
+        date + length
+      end
+    end
+  end
+end

data/lib/redis/recurring_at_intervals/hourly.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Redis
+  module RecurringAtIntervals
+    module Hourly
+      private
+
+      def redis_daily_field_key(time)
+        time_key = time.strftime('%Y-%m-%dT%H')
+        [original_key, time_key].flatten.join(':')
+      end
+
+      def next_key(time, length = 1)
+        time + 3600 * length
+      end
+    end
+  end
+end

data/lib/redis/recurring_at_intervals/minutely.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Redis
+  module RecurringAtIntervals
+    module Minutely
+      private
+
+      def redis_daily_field_key(time)
+        time_key = time.strftime('%Y-%m-%dT%H:%M')
+        [original_key, time_key].flatten.join(':')
+      end
+
+      def next_key(time, length = 1)
+        time + 60 * length
+      end
+    end
+  end
+end

data/lib/redis/recurring_at_intervals/monthly.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Redis
+  module RecurringAtIntervals
+    module Monthly
+      private
+
+      def redis_daily_field_key(date_or_time)
+        date_key = date_or_time.strftime('%Y-%m')
+        [original_key, date_key].flatten.join(':')
+      end
+
+      def next_key(date, length = 1)
+        date.next_month(length)
+      end
+    end
+  end
+end