redis-objects-daily-counter 0.2.0

data/README.md

@@ -0,0 +1,122 @@
+[![CircleCI](https://circleci.com/gh/ryz310/redis-objects-daily-counter.svg?style=svg)](https://circleci.com/gh/ryz310/redis-objects-daily-counter) [![Gem Version](https://badge.fury.io/rb/redis-objects-daily-counter.svg)](https://badge.fury.io/rb/redis-objects-daily-counter) [![Maintainability](https://api.codeclimate.com/v1/badges/3639d1776e23031b1b31/maintainability)](https://codeclimate.com/github/ryz310/redis-objects-daily-counter/maintainability) [![Test Coverage](https://api.codeclimate.com/v1/badges/3639d1776e23031b1b31/test_coverage)](https://codeclimate.com/github/ryz310/redis-objects-daily-counter/test_coverage) [![Dependabot Status](https://api.dependabot.com/badges/status?host=github&repo=ryz310/redis-objects-daily-counter)](https://dependabot.com)
+
+# Redis::Objects::Daily::Counter
+
+This is a gem which extends [Redis::Objects](https://github.com/nateware/redis-objects) gem. Once install this gem, you can use the daily counter, etc. in addition to the standard features of Redis::Objects. These counters are useful for measuring conversions, implementing API rate limiting, and more.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'redis-objects-daily-counter'
+```
+
+If you want to know about installation and standard usage, please see Redis::Objects' GitHub page.
+
+## Usage
+
+`daily_counter` automatically creates keys that are unique to each object, in the format:
+
+```
+model_name:id:field_name:yyyy-mm-dd
+```
+
+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
+
+  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]
+```
+
+The daily counter 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(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)) # => 2
+```
+
+### Counters
+
+I recommend using with `expireat` option.
+
+* `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`
+
+### 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-daily-counter. 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-daily-counter/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-daily-counter/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+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,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'redis-objects-daily-counter'
+
+# 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(__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/annual_counter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "#{File.dirname(__FILE__)}/base_counter_object"
+
+class Redis
+  class AnnualCounter < BaseCounterObject
+    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)
+      date.next_year(length - 1)
+    end
+  end
+end

data/lib/redis/base_counter_object.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class Redis
+  class BaseCounterObject < Counter
+    def initialize(key, *args)
+      @original_key = key
+      super(redis_daily_field_key(current_time), *args)
+    end
+
+    attr_reader :original_key
+
+    def [](date_or_time, length = nil)
+      if date_or_time.is_a? Range
+        range(date_or_time.first, date_or_time.max)
+      elsif length
+        case length <=> 0
+        when 1  then range(date_or_time, next_key(date_or_time, length))
+        when 0  then []
+        when -1 then nil  # Ruby does this (a bit weird)
+        end
+      else
+        at(date_or_time)
+      end
+    end
+    alias slice []
+
+    def delete(date_or_time)
+      redis.del(redis_daily_field_key(date_or_time))
+    end
+
+    def range(start_date, end_date)
+      keys = (start_date..end_date).map { |date| redis_daily_field_key(date) }.uniq
+      redis.mget(*keys).map(&:to_i)
+    end
+
+    def at(date_or_time)
+      redis.get(redis_daily_field_key(date_or_time)).to_i
+    end
+
+    def current_time
+      @current_time ||= Time.respond_to?(:current) ? Time.current : Time.now
+    end
+
+    private
+
+    def redis_daily_field_key(_date_or_time)
+      raise 'not implemented'
+    end
+
+    def next_key(_date, _length)
+      raise 'not implemented'
+    end
+  end
+end

data/lib/redis/daily_counter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "#{File.dirname(__FILE__)}/base_counter_object"
+
+class Redis
+  class DailyCounter < BaseCounterObject
+    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)
+      date + length - 1
+    end
+  end
+end

data/lib/redis/hourly_counter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "#{File.dirname(__FILE__)}/base_counter_object"
+
+class Redis
+  class HourlyCounter < BaseCounterObject
+    def range(start_time, end_time)
+      keys =
+        (start_time.to_i..end_time.to_i)
+        .step(3600)
+        .map { |integer| redis_daily_field_key(Time.at(integer)) }
+      redis.mget(*keys).map(&:to_i)
+    end
+
+    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)
+      time + 3600 * (length - 1)
+    end
+  end
+end

data/lib/redis/minutely_counter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "#{File.dirname(__FILE__)}/base_counter_object"
+
+class Redis
+  class MinutelyCounter < BaseCounterObject
+    def range(start_time, end_time)
+      keys =
+        (start_time.to_i..end_time.to_i)
+        .step(60)
+        .map { |integer| redis_daily_field_key(Time.at(integer)) }
+      redis.mget(*keys).map(&:to_i)
+    end
+
+    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)
+      time + 60 * (length - 1)
+    end
+  end
+end

data/lib/redis/monthly_counter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "#{File.dirname(__FILE__)}/base_counter_object"
+
+class Redis
+  class MonthlyCounter < BaseCounterObject
+    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)
+      date.next_month(length - 1)
+    end
+  end
+end

data/lib/redis/objects/annual_counters.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'redis/annual_counter'
+class Redis
+  module Objects
+    module AnnualCounters
+      class << self
+        def included(klass)
+          klass.extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        def annual_counter(name, options = {}) # rubocop:disable Metrics/MethodLength
+          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::AnnualCounter.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
+    end
+  end
+end

data/lib/redis/objects/daily-counter/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Redis
+  module Objects
+    module Daily
+      module Counter
+        VERSION = '0.2.0'
+      end
+    end
+  end
+end

data/lib/redis/objects/daily_counters.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'redis/daily_counter'
+class Redis
+  module Objects
+    module DailyCounters
+      class << self
+        def included(klass)
+          klass.extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        def daily_counter(name, options = {}) # rubocop:disable Metrics/MethodLength
+          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::DailyCounter.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
+    end
+  end
+end

data/lib/redis/objects/hourly_counters.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'redis/hourly_counter'
+class Redis
+  module Objects
+    module HourlyCounters
+      class << self
+        def included(klass)
+          klass.extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        def hourly_counter(name, options = {}) # rubocop:disable Metrics/MethodLength
+          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::HourlyCounter.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
+    end
+  end
+end

data/lib/redis/objects/minutely_counters.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'redis/minutely_counter'
+class Redis
+  module Objects
+    module MinutelyCounters
+      class << self
+        def included(klass)
+          klass.extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        def minutely_counter(name, options = {}) # rubocop:disable Metrics/MethodLength
+          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::MinutelyCounter.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
+    end
+  end
+end

data/lib/redis/objects/monthly_counters.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'redis/daily_counter'
+class Redis
+  module Objects
+    module MonthlyCounters
+      class << self
+        def included(klass)
+          klass.extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        def monthly_counter(name, options = {}) # rubocop:disable Metrics/MethodLength
+          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::MonthlyCounter.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
+    end
+  end
+end

data/lib/redis/objects/weekly_counters.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'redis/weekly_counter'
+class Redis
+  module Objects
+    module WeeklyCounters
+      class << self
+        def included(klass)
+          klass.extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        def weekly_counter(name, options = {}) # rubocop:disable Metrics/MethodLength
+          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::WeeklyCounter.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
+    end
+  end
+end

data/lib/redis/weekly_counter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "#{File.dirname(__FILE__)}/base_counter_object"
+
+class Redis
+  class WeeklyCounter < BaseCounterObject
+    private
+
+    def redis_daily_field_key(date_or_time)
+      date_key = date_or_time.strftime('%YW%W')
+      [original_key, date_key].flatten.join(':')
+    end
+
+    def next_key(date, length)
+      date + 7 * (length - 1)
+    end
+  end
+end

data/lib/redis-objects-daily-counter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'redis-objects'
+
+class Redis
+  autoload :DailyCounter, 'redis/daily_counter'
+  autoload :WeeklyCounter, 'redis/weekly_counter'
+  autoload :MonthlyCounter, 'redis/monthly_counter'
+  autoload :AnnualCounter, 'redis/annual_counter'
+  autoload :HourlyCounter, 'redis/hourly_counter'
+  autoload :MinutelyCounter, 'redis/minutely_counter'
+
+  module Objects
+    autoload :DailyCounters, 'redis/objects/daily_counters'
+    autoload :WeeklyCounters, 'redis/objects/weekly_counters'
+    autoload :MonthlyCounters, 'redis/objects/monthly_counters'
+    autoload :AnnualCounters, 'redis/objects/annual_counters'
+    autoload :HourlyCounters, 'redis/objects/hourly_counters'
+    autoload :MinutelyCounters, 'redis/objects/minutely_counters'
+
+    class << self
+      alias original_included included
+
+      def included(klass)
+        original_included(klass)
+
+        # Pull in each object type
+        klass.send :include, Redis::Objects::DailyCounters
+        klass.send :include, Redis::Objects::WeeklyCounters
+        klass.send :include, Redis::Objects::MonthlyCounters
+        klass.send :include, Redis::Objects::AnnualCounters
+        klass.send :include, Redis::Objects::HourlyCounters
+        klass.send :include, Redis::Objects::MinutelyCounters
+      end
+    end
+  end
+end