red_blocks 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6068b8cc4aca279849069f786e0b5e03fa60e7d8
+  data.tar.gz: 74d53563c0eff20138845520f5b883a8660c1bc4
+SHA512:
+  metadata.gz: 549e680a248cc49ad5efb363e92233fb227a5ddb34d156bdb4acc1db98ecf35ae4686f25445ff2c27224d4f7490501b296636b6a89a2eb885984fabeb246028c
+  data.tar.gz: 43857558b8ef435078061f953a16361f0d8e99b8446f48acf2f68db5603a68b1dc1623de8d7e37f576d639237a7dcf96dc0704aba018bde88860163798a9f9ef

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## CHANGELOG
+
+### v0.1.0 / 2017-12-05
+
+First release.

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in red_blocks.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,78 @@
+PATH
+  remote: .
+  specs:
+    red_blocks (0.1.0)
+      redis (~> 3.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    ffi (1.9.18)
+    formatador (0.2.5)
+    guard (2.14.1)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.7.3)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    listen (3.1.5)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+      ruby_dep (~> 1.2)
+    lumberjack (1.0.12)
+    method_source (0.9.0)
+    mock_redis (0.17.3)
+    nenv (0.3.0)
+    notiffany (0.1.1)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    pry (0.11.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rake (10.5.0)
+    rb-fsevent (0.10.2)
+    rb-inotify (0.9.10)
+      ffi (>= 0.5.0, < 2)
+    redis (3.3.3)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
+    ruby_dep (1.5.0)
+    shellany (0.0.1)
+    thor (0.20.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.13)
+  guard
+  guard-rspec
+  mock_redis (~> 0.17)
+  pry
+  rake (~> 10.0)
+  red_blocks!
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.13.6

data/Guardfile

@@ -0,0 +1,17 @@
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Altech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+# RedBlocks
+
+## What is this?
+
+This gem provides some set classes based on Redis sorted set.
+So a set may have scores for each elements.
+
+By using them, it is possible to implement fast ranking system, search system, or filtering system based on coherent cache management of Redis.
+
+## Example
+
+Please suppose that there are some tagged documents and we want to provide search system.
+A user can full-text search, and filter by the tags.
+
+For example, to implement the following query:
+
+- serach by the word of "cache mangement"
+- And filter by the tag of "new" or "starred"
+
+We construct the follwoing set:
+
+```rb
+keyword_set = KeywordSet.new("Ruby") # Each elements have score based on full-text serach.
+tagged_set_1 = TaggedSet.new(:new)
+tagged_set_2 = TaggedSet.new(:starred)
+
+set = IntersectionSet.new([
+  keyword_set,
+  UnionSet.new([tagged_set_1, tagged_set_2]),
+], cache_time: 3.minutes)
+set.ids #=> [3, 4, 8, 9, 1]
+```
+
+The result is order by the score of keyword set, because each scores of elements are summed on intersection, or union by default.
+
+This is a simple example, and it is possible to apply this pattern to construct more complex system which has small latency.
+For example, if you want to personalize the result, you have to prepare a personalized ranking and use it as a base set.
+
+In general, there are some advantages by using RedBlocks.
+
+- aggregate the result of each service by sorted set operations.
+- flatten the latency of each service(e.g. full-text search service, recommendation service) by Redis cache.
+- get rid of the cost of Redis key management from programmer.
+- get rid of manual checking whether the cache exists or not from programmer.
+- possible to construct such systems in object-oridented style.
+
+## Installation
+
+```rb
+gem 'red_blocks'
+```
+
+## Classes
+
+TODO: document
+
+The latter half of the [slide](https://speakerdeck.com/altech/redblocks) describes the classes of RedBlocks (in japanese).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "red_blocks"
+
+require "pry"
+Pry.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/lib/red_blocks.rb

@@ -0,0 +1,44 @@
+module RedBlocks
+  class << self
+    attr_accessor :config
+
+    def config
+      @config ||= RedBlocks::Config.new(
+        client_proc: -> { RedBlocks.client },
+        key_namespace: 'RB',
+        intermediate_set_lifetime: 30,
+        blank_id: 0,
+      )
+    end
+
+    def client
+      if self.config.cache_client
+        @cln ||= config.client_proc.call
+      else
+        config.client_proc.call
+      end
+    end
+  end
+end
+
+require "red_blocks/config"
+
+require "red_blocks/cache_policy"
+require "red_blocks/set_optimizer"
+require "red_blocks/set_utils"
+require "red_blocks/paginator"
+
+require "red_blocks/operations"
+require "red_blocks/expression"
+require "red_blocks/composed_expression"
+
+require "red_blocks/domain_error"
+
+require "red_blocks/set"
+require "red_blocks/composed_set"
+require "red_blocks/union_set"
+require "red_blocks/intersection_set"
+require "red_blocks/subtraction_set"
+require "red_blocks/unit_set"
+require "red_blocks/enum_set"
+require "red_blocks/instant_set"

data/lib/red_blocks/cache_policy.rb

@@ -0,0 +1,21 @@
+module RedBlocks
+  module CachePolicy
+    def self.none
+      0
+    end
+
+    def self.daily
+      # 15.minutes is padding for daily update.
+      # This will avoid to expire the cache before
+      # the update has completed.
+      24.hours + 15.minutes
+    end
+
+    def self.hourly
+      # 3.minutes is padding for hourly update.
+      # This will avoid to expire the cache before
+      # the update has completed.
+      1.hour + 3.minutes
+    end
+  end
+end

data/lib/red_blocks/composed_expression.rb

@@ -0,0 +1,27 @@
+module RedBlocks
+  class ComposedExpression < Expression
+    attr_accessor :operands, :operator
+
+    def initialize(key, operator:,  operands:, weight: 1, label: nil)
+      super(key, weight: weight, label: label)
+      @operator = operator
+      @operands = operands
+    end
+
+    def to_s
+      operands_str = operands
+        .select { |exp| exp.is_a?(ComposedExpression) || exp.score.nil? || exp.score != 0 }
+        .map { |exp| exp.to_s }
+      case operator
+      when :sum
+        str = operands_str.join(' + ')
+        str = "(#{str}) * #{weight}" if weight != 1
+        str
+      else
+        str = "#{operator.to_s}(#{operands_str.join(', ')})"
+        str = "#{str} * #{weight}" if weight != 1
+        str
+      end
+    end
+  end
+end

data/lib/red_blocks/composed_set.rb

@@ -0,0 +1,57 @@
+module RedBlocks
+  class ComposedSet < RedBlocks::Set
+    attr_accessor :sets, :score_func
+    attr_writer :cache_time
+
+    SCORE_AGGREGATORS = [:sum, :min, :max]
+
+    def initialize(sets, score_func: :sum, cache_time: nil)
+      if sets.size&.zero? # Accepts enumerator, which can return nil for size.
+        raise ArgumentError.new("Passed sets are blank.")
+      end
+      unless SCORE_AGGREGATORS.include?(score_func)
+        raise ArgumentError.new("`#{score_func.inspect}` is not valid aggregator. Avaiable aggregator is #{SCORE_AGGREGATORS.join(', ')}")
+      end
+      unless sets.all? { |set| set.is_a?(RedBlocks::Set) }
+        raise TypeError.new("sets must be a Array<RedBlocks::Set>, but got the following list: #{sets.map(&:class).join(', ')}")
+      end
+
+      @sets = sets
+      @score_func = score_func
+      @cache_time = cache_time
+    end
+
+    def key_suffix
+      joined_key(@sets.map(&:key).sort, sep: '|', wrap: true)
+    end
+
+    def update!
+      disabled_sets.each(&:update!)
+      compose_sets!
+      RedBlocks.client.expire(key, expiration_time)
+    end
+
+    def cache_time
+      @cache_time || super
+    end
+
+    def expression(id)
+      ComposedExpression.new(key, operator: score_func, operands: sets.map {|s| s.expression(id)}, label: label, weight: weight)
+    end
+
+    private
+
+    def compose_sets!
+      raise NotImplementedError
+    end
+
+    def disabled_sets
+      ttls = RedBlocks.client.pipelined do
+        @sets.each { |set| RedBlocks.client.ttl(set.key) }
+      end
+      @sets.zip(ttls).select do |set, ttl|
+        set.disabled?(ttl)
+      end.map(&:first)
+    end
+  end
+end

data/lib/red_blocks/config.rb

@@ -0,0 +1,30 @@
+module RedBlocks
+  class Config
+    # Proc which returns Redis client.
+    attr_reader :client_proc
+    attr_reader :cache_client
+
+    # The key prefix for Redis.
+    attr_reader :key_namespace
+
+    # It is guaranteed that all set exist in 30 seconds at least.
+    # This means that all transaction must be completed in the time.
+    attr_reader :intermediate_set_lifetime
+
+    # Used to represent a "blank" set.
+    # So you cannot use 0 in real id.
+    attr_reader :blank_id
+
+    # For test. See spec_helper.rb
+    attr_reader :infinity
+
+    def initialize(client_proc:, cache_client: false, key_namespace:, intermediate_set_lifetime:, blank_id:, infinity: Float::INFINITY)
+      @key_namespace = key_namespace
+      @intermediate_set_lifetime = intermediate_set_lifetime
+      @blank_id = blank_id
+      @client_proc = client_proc
+      @cache_client = cache_client
+      @infinity = infinity
+    end
+  end
+end

data/lib/red_blocks/domain_error.rb

@@ -0,0 +1,14 @@
+module RedBlocks
+  class DomainError < StandardError
+    def initialize(value, domain)
+      @value = value
+      @domain = domain
+    end
+
+    def message
+      "Input `#{@value.inspect}` is out of the domain `#{@domain.inspect}`"
+    end
+  end
+end
+
+

data/lib/red_blocks/enum_set.rb

@@ -0,0 +1,36 @@
+module RedBlocks
+  class EnumSet < RedBlocks::Set
+    attr_reader :value
+
+    def initialize(value)
+      unless self.class.available_values.include?(value)
+        raise RedBlocks::OutOfDomainError.new(value, self.class.available_values)
+      end
+      @value = value
+    end
+
+    # Match string such as `#<User:0x007fa3323a2b90>`
+    ADDRESSED_OBJECT_REGEXP = /^#<(.+):0x\w+>$/
+
+    def key_suffix
+      suffix = @value.to_s
+      if suffix =~ ADDRESSED_OBJECT_REGEXP
+        raise <<MSG
+The key suffix may include random address #{suffix.inspect}.
+You must override `key_suffix` explicitly, or use `value` which implements deterministic `to_s`.
+MSG
+      end
+      suffix
+    end
+
+    def self.warmup!
+      available_values.each do |value|
+        self.new(value).update!
+      end
+    end
+
+    def self.available_values
+      raise NotImplementedError
+    end
+  end
+end

data/lib/red_blocks/expression.rb

@@ -0,0 +1,21 @@
+module RedBlocks
+  class Expression
+    attr_accessor :score, :weight, :label, :key
+
+    def initialize(key, score: nil, weight: 1, label: nil)
+      @score = score
+      @weight = weight
+      @key   = key
+      @label = label
+    end
+
+    def label
+      @label || key
+    end
+
+    def to_s
+      socre_str = score ? '%0.4f' % (score * weight) : '?'
+      "#{socre_str}[#{label}]"
+    end
+  end
+end

data/lib/red_blocks/instant_set.rb

@@ -0,0 +1,28 @@
+module RedBlocks
+  class InstantSet < RedBlocks::Set
+    attr_reader :value, :suffix
+
+    RAND_MAX = 100_000_000
+
+    def initialize(value)
+      unless value.is_a?(Array)
+        raise TypeError.new("Expect value as Array, but got #{ids_or_ids_with_scores.class}")
+      end
+
+      @value = value
+      @suffix = rand(RAND_MAX)
+    end
+
+    def cache_time
+      0
+    end
+
+    def get
+      value
+    end
+
+    def key_suffix
+      suffix
+    end
+  end
+end

data/lib/red_blocks/intersection_set.rb

@@ -0,0 +1,17 @@
+module RedBlocks
+  class IntersectionSet < ComposedSet
+    private
+
+    def compose_sets!
+      sets = @sets.to_a
+      if sets.size > 0
+        RedBlocks.client.zinterstore(key, sets.map(&:key), weights: sets.map(&:weight), aggregate: score_func)
+      else
+        RedBlocks.client.pipelined do
+          RedBlocks.client.del(key)
+          RedBlocks.client.zadd(key, normalize_entries([]))
+        end
+      end
+    end
+  end
+end

data/lib/red_blocks/operations.rb

@@ -0,0 +1,53 @@
+# Operations for development.
+# Please be careful with using in prduction.
+module RedBlocks::Operations
+  def self.delete(set_or_pattern)
+    keys = self.keys(set_or_pattern)
+    RedBlocks.client.pipelined do
+      keys.each do |key|
+        RedBlocks.client.del(key)
+      end
+    end
+  end
+
+  def self.keys(set_or_pattern)
+    if set_or_pattern.is_a?(Class) && set_or_pattern <= RedBlocks::Set
+      pattern = set_or_pattern.key_pattern
+    elsif set_or_pattern.is_a?(String)
+      pattern = set_or_pattern
+    else
+      raise ArgumentError.new("Unexpected pattern(#{set_or_pattern.inspect})")
+    end
+    scan_keys(pattern)
+  end
+
+  def self.delete_intermediate(set, threshold: RedBlocks::CachePolicy.none)
+    case set
+    when RedBlocks::ComposedSet
+      if set.cache_time <= threshold
+        RedBlocks.client.del(set.key)
+      end
+
+      set.sets.each do |internal_set|
+        delete_intermediate(internal_set, threshold: threshold)
+      end
+    when RedBlocks::Set
+      if set.cache_time <= threshold
+        RedBlocks.client.del(set.key)
+      end
+    else
+      raise TypeError.new("Expect RedBlocks::Set, but got #{set.class.name}")
+    end
+  end
+
+  private
+
+  def self.scan_keys(pattern)
+    result = []
+    while true
+      cursor, keys = RedBlocks.client.scan(cursor, match: pattern, count: 1000)
+      result += keys
+      return result if cursor == "0"
+    end
+  end
+end

data/lib/red_blocks/paginator.rb

@@ -0,0 +1,39 @@
+module RedBlocks
+  class Paginator
+    DEFAULT_PER     = 10
+    DEFAULT_PAGE    = 1
+
+    attr_reader :head, :tail, :per, :page
+
+    def initialize(per: DEFAULT_PER, page: DEFAULT_PAGE, head: nil, tail: nil)
+      if head && tail
+        unless head >= 0 && tail >= 0 && head <= tail
+          raise ArgumentError.new("head and tail is out of range (head=#{head}, tail=#{tail})")
+        end
+
+        @head = head
+        @tail = tail
+        return
+      end
+
+      @per     = per.to_i
+      @page    = page.to_i
+
+      @head = @per * (@page - 1)
+      @tail = @head + @per - 1
+    end
+
+    def size
+      @per || (@tail - @head + 1)
+    end
+
+    class All
+      def head; 0  end
+      def tail; -1 end
+    end
+
+    def self.all
+      All.new
+    end
+  end
+end

data/lib/red_blocks/set.rb

@@ -0,0 +1,110 @@
+module RedBlocks
+  class Set
+    include SetUtils
+    include SetOptimizer
+
+    def update!(get_result = self.get)
+      entries = normalize_entries(validate_entries!(get_result))
+      removed_ids = self.ids(paginator: Paginator.all, update_if_disabled: false) - entries.map(&:last)
+      RedBlocks.client.pipelined do
+        RedBlocks.client.zrem(key, removed_ids) if removed_ids.size > 0
+        RedBlocks.client.zadd(key, entries)
+        RedBlocks.client.expire(key, expiration_time)
+      end
+      nil
+    end
+
+    def update_if_disabled!
+      update! if disabled?
+    end
+
+    def disabled?(ttl = RedBlocks.client.ttl(key))
+      ttl < RedBlocks.config.intermediate_set_lifetime
+    end
+
+    def expiration_time
+      RedBlocks.config.intermediate_set_lifetime + cache_time
+    end
+
+    def ids(paginator: Paginator.new, with_scores: false, with_expressions: false, update_if_disabled: true)
+      update_if_disabled! if update_if_disabled
+      res = RedBlocks.client.zrevrange(key, paginator.head, paginator.tail, with_scores: with_scores)
+      res
+        .map { |id, _score|
+          if with_scores || with_expressions
+            res = [id.to_i]
+            res << _score if with_scores
+            res << expression(id) if with_expressions
+            res
+          else
+            id.to_i
+          end
+        }.select{ |id, _, _|
+        id !=  RedBlocks.config.blank_id
+      }
+    end
+
+    def size(update_if_disabled: true)
+      update_if_disabled! if update_if_disabled
+      RedBlocks.client.zcard(key) - 1 # Discount the blank entry.
+    end
+
+    def key
+      joined_key([RedBlocks.config.key_namespace, self.class.key_prefix, key_suffix])
+    end
+
+    def self.key_pattern
+      joined_key([RedBlocks.config.key_namespace, key_prefix, '*'])
+    end
+
+    # # Overridable to sub-classes.
+    # ------------------------------------------------------
+
+    private
+
+    # @return [String] A key prefix. This is intended to distinct sets on class-level.
+    #  So it uses class name by default. It uses name without module to save memory.
+    def self.key_prefix
+      self.name
+    end
+
+    # @return [String] A key suffix. This is intended to distinct sets on instance-level.
+    #   So it will use some instance variable.
+    def key_suffix
+      raise NotImplementedError
+    end
+
+    public
+
+    # @return [Array, Array<Array>] A list of ids, or a zippped list of ids and scores.
+    # @example
+    #   [1, 3, 5]
+    # @example
+    #   [[1, 3.4], [5, 2.3]]
+    def get
+      raise NotImplementedError
+    end
+
+    # @return [Integer] Cache time in seconds.
+    def cache_time
+      RedBlocks::CachePolicy.none
+    end
+
+    # @return [Numeric] A scale factor for score calculaton on intersection or union.
+    def weight
+      @weight || 1
+    end
+
+    attr_writer :weight
+
+    def label
+      nil
+    end
+
+    # Used in debug mode (with_expressions option)
+    def expression(id)
+      score = self.disabled? ? nil : (RedBlocks.client.zscore(key, id) || 0)
+      Expression.new(key, score: score, label: label, weight: weight)
+    end
+  end
+end

data/lib/red_blocks/set_optimizer.rb

@@ -0,0 +1,23 @@
+module RedBlocks
+  module SetOptimizer
+    # Remove intersection set(and union set) that has one set.
+    # i.e. `IntersectionSet.new([some_set])` is always equal
+    # to `some_set`. So we can remove it.
+    def unset
+      case self
+      when RedBlocks::ComposedSet
+        if self.sets.size == 1
+          self.sets.first
+        else
+          new_set = self.dup
+          new_set.sets = self.sets.map { |set| set.unset }
+          new_set
+        end
+      when RedBlocks::Set
+        self
+      else
+        raise TypeError.new("Expected a set but got #{self}")
+      end
+    end
+  end
+end

data/lib/red_blocks/set_utils.rb

@@ -0,0 +1,65 @@
+module RedBlocks
+  module SetUtils
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    class InvalidEntriesError < StandardError
+      def initialize(entries, key)
+        @entries = entries
+        @key = key
+      end
+      attr_reader :entries, :key
+
+      def message
+        "Invalid entry: `#{entries.inspect}` for key = #{self.key}"
+      end
+    end
+
+    module ClassMethods
+      def joined_key(array, sep: ':', wrap: false)
+        array.map { |key| wrap ? "[#{key}]" : key.to_s }.join(sep)
+      end
+    end
+
+    def joined_key(*args); self.class.joined_key(*args) end
+
+    def normalize_entries(entries)
+      blank_entry = [-RedBlocks.config.infinity, RedBlocks.config.blank_id]
+      if entries.first.is_a?(Array)
+        entries.map{ |id, score| [score, id] } + [blank_entry]
+      else
+        entries.map {|id| [0, id] } + [blank_entry]
+      end
+    end
+
+    def validate_entries!(entries)
+      case entries
+      when Array
+        entry = entries[0]
+        case entry
+        when Integer
+          entries
+        when Array
+          if !validate_array_entry(entry)
+            raise InvalidEntriesError.new(entries, key)
+          else
+            entries
+          end
+        when NilClass
+          entries
+        else
+          raise InvalidEntriesError.new(entries, key)
+        end
+      else
+        raise InvalidEntriesError.new(entries, key)
+      end
+    end
+
+    def validate_array_entry(entry)
+      is_pair = entry.size == 2
+      id, score = entry
+      is_pair && id.is_a?(Integer) && (score.is_a?(Numeric) && !score.to_f.nan?)
+    end
+  end
+end

data/lib/red_blocks/subtraction_set.rb

@@ -0,0 +1,51 @@
+module RedBlocks
+  class SubtractionSet < RedBlocks::Set
+    attr_accessor :set1, :set2
+    attr_writer :cache_time
+
+    def initialize(set1, set2, cache_time: nil)
+      unless [set1, set2].all? { |set| set.is_a?(RedBlocks::Set) }
+        raise TypeError.new("set1 and set2 must be a Array<RedBlocks::Set>, but got the following list: #{sets.map(&:class).join(', ')}")
+      end
+
+      @set1 = set1
+      @set2 = set2
+      @cache_time = cache_time
+    end
+
+    def key_suffix
+      joined_key(sets.map(&:key).sort, sep: '|', wrap: true)
+    end
+
+    def update!
+      disabled_sets.each(&:update!)
+      # [Note] The following operation will be faster if we use Redis script.
+      RedBlocks.client.zunionstore(key, [set1.key])
+      RedBlocks.client.zrem(key, set2.ids(paginator: RedBlocks::Paginator.all))
+      RedBlocks.client.expire(key, expiration_time)
+    end
+
+    def cache_time
+      @cache_time || super
+    end
+
+    def expression(id)
+      set1.expression(id)
+    end
+
+    def sets
+      [set1, set2]
+    end
+
+    private
+
+    def disabled_sets
+      ttls = RedBlocks.client.pipelined do
+        sets.each { |set| RedBlocks.client.ttl(set.key) }
+      end
+      sets.zip(ttls).select do |set, ttl|
+        set.disabled?(ttl)
+      end.map(&:first)
+    end
+  end
+end

data/lib/red_blocks/union_set.rb

@@ -0,0 +1,17 @@
+module RedBlocks
+  class UnionSet < ComposedSet
+    private
+
+    def compose_sets!
+      sets = @sets.to_a
+      if sets.size > 0
+        RedBlocks.client.zunionstore(key, sets.map(&:key), weights: sets.map(&:weight), aggregate: score_func)
+      else
+        RedBlocks.client.pipelined do
+          RedBlocks.client.del(key)
+          RedBlocks.client.zadd(key, normalize_entries([]))
+        end
+      end
+    end
+  end
+end

data/lib/red_blocks/unit_set.rb

@@ -0,0 +1,11 @@
+module RedBlocks
+  class UnitSet < RedBlocks::Set
+    def key_suffix
+      'Unit'
+    end
+
+    def self.warmup!
+      self.new.update!
+    end
+  end
+end

data/lib/red_blocks/version.rb

@@ -0,0 +1,3 @@
+module RedBlocks
+  VERSION = "0.1.0"
+end

data/red_blocks.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'red_blocks/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "red_blocks"
+  spec.version       = RedBlocks::VERSION
+  spec.authors       = ["Altech"]
+  spec.email         = ["takeno.sh@gmail.com"]
+
+  spec.summary       = 'Object-oriented abstraction of Redis sorted set.'
+  spec.description   = 'This module provides classes of redis sorted set'\
+    ' to implement fast ranking, search, filtering'\
+    ' with coherent cache management policy.'
+  spec.homepage      = "https://github.com/Altech/red_blocks"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "redis", "~> 3.3"
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "mock_redis", "~> 0.17"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: red_blocks
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Altech
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: mock_redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This module provides classes of redis sorted set to implement fast ranking,
+  search, filtering with coherent cache management policy.
+email:
+- takeno.sh@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/red_blocks.rb
+- lib/red_blocks/cache_policy.rb
+- lib/red_blocks/composed_expression.rb
+- lib/red_blocks/composed_set.rb
+- lib/red_blocks/config.rb
+- lib/red_blocks/domain_error.rb
+- lib/red_blocks/enum_set.rb
+- lib/red_blocks/expression.rb
+- lib/red_blocks/instant_set.rb
+- lib/red_blocks/intersection_set.rb
+- lib/red_blocks/operations.rb
+- lib/red_blocks/paginator.rb
+- lib/red_blocks/set.rb
+- lib/red_blocks/set_optimizer.rb
+- lib/red_blocks/set_utils.rb
+- lib/red_blocks/subtraction_set.rb
+- lib/red_blocks/union_set.rb
+- lib/red_blocks/unit_set.rb
+- lib/red_blocks/version.rb
+- red_blocks.gemspec
+homepage: https://github.com/Altech/red_blocks
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Object-oriented abstraction of Redis sorted set.
+test_files: []