sideroo 1.0.0

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,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sideroo"
+
+# 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/lib/sideroo.rb

@@ -0,0 +1,32 @@
+require "sideroo/version"
+require "sideroo/enumerator"
+require "sideroo/key_builder"
+require "sideroo/types/base"
+require "sideroo/types/bitmap"
+require "sideroo/types/hash"
+require "sideroo/types/hyper_log_log"
+require "sideroo/types/list"
+require "sideroo/types/set"
+require "sideroo/types/sorted_set"
+require "sideroo/types/string"
+
+module Sideroo
+  class Error < StandardError; end
+  class MissingKeys < ArgumentError; end
+  class UnexpectedKeys < ArgumentError; end
+
+  class Configuration
+    attr_accessor :redis_client
+  end
+
+  class << self
+    def configure
+      @config = Configuration.new
+      yield(@config)
+    end
+
+    def redis_client
+      @config.redis_client
+    end
+  end
+end

data/lib/sideroo/enumerator.rb

@@ -0,0 +1,83 @@
+module Sideroo
+  class Enumerator
+    attr_reader :type_klass
+    attr_reader :limit
+    attr_reader :redis_client
+
+    attr_reader :filters
+    attr_reader :search_pattern
+
+    def initialize(type_klass:, filters:, limit: -1)
+      @type_klass = type_klass
+      @limit = limit
+      @redis_client = redis_client || Sideroo.redis_client
+      @filters = stringify_keys(filters)
+
+      @search_pattern = build_search_pattern
+    end
+
+    def each
+      cursor = nil
+      count = 0
+
+      until cursor.to_s == '0'
+        cursor ||= 0
+        cursor, keys = redis_client.scan(cursor, match: search_pattern)
+
+        keys.each do |key|
+          break if exceed_limit?(count)
+          next unless regex_matched?(key)
+
+          count += 1
+          item = type_klass.new(key)
+          yield(item)
+        end
+      end
+    end
+
+    def map
+      output = []
+      each do |obj|
+        output.push yield(obj)
+      end
+      output
+    end
+
+    def count
+      count = 0
+      each { count += 1 }
+      count
+    end
+
+    def to_a
+      map { |item| item }
+    end
+
+    private
+
+    def exceed_limit?(count)
+      limit >= 0 && count > limit
+    end
+
+    def regex_matched?(key)
+      key =~ type_klass.key_regex
+    end
+
+    def build_search_pattern
+      search_pattern = type_klass.key_pattern
+
+      type_klass.key_attributes.each do |attr|
+        value = filters[attr]
+        value = value.nil? ? '*' : value.to_s
+
+        term = "{#{attr}}"
+        search_pattern = search_pattern.gsub(term, value.to_s)
+      end
+      search_pattern
+    end
+
+    def stringify_keys(raw_attr_map)
+      raw_attr_map.map { |k, v| [k.to_s, v] }.to_h
+    end
+  end
+end

data/lib/sideroo/key_builder.rb

@@ -0,0 +1,53 @@
+module Sideroo
+  class KeyBuilder
+    attr_reader :attr_map
+    attr_reader :key_pattern
+
+    class << self
+      def key_attributes(key_pattern)
+        regex = /\{([^\{\}]+)\}/
+        key_pattern.scan(regex).map(&:first)
+      end
+    end
+
+    def initialize(attr_map:, key_pattern:)
+      @attr_map = attr_map
+      @key_pattern = key_pattern
+    end
+
+    def build
+      validate_attrs!
+      populate_key
+    end
+
+    private
+
+    def validate_attrs!
+      provided_attrs = attr_map.keys.map(&:to_s)
+      key_attributes = self.class.key_attributes(key_pattern)
+
+      missing_attrs = key_attributes - provided_attrs
+      unexpected_attrs = provided_attrs - key_attributes
+
+      if missing_attrs.any?
+        msg = "Missing attributes: #{missing_attrs.join(', ')}"
+        raise MissingKeys, msg
+      end
+
+      if unexpected_attrs.any?
+        msg = "Unexpected attributes: #{unexpected_attrs.join(', ')}"
+        raise UnexpectedKeys, msg
+      end
+    end
+
+    def populate_key
+      key = key_pattern
+      attr_map.each do |attr, value|
+        term = "{#{attr}}"
+        key = key.gsub(term, value.to_s)
+      end
+
+      key
+    end
+  end
+end

data/lib/sideroo/types/base.rb

@@ -0,0 +1,137 @@
+module Sideroo
+  class Base
+    class << self
+      def redis_methods(method_names)
+        method_names.each do |method_name|
+          define_redis_method(method_name)
+        end
+      end
+
+      # USAGE DEFINTIONS
+      #
+      def data_type(*args)
+        @data_type = args.first if args.count > 0
+        @data_type
+      end
+
+      def key_pattern(*args)
+        @key_pattern = args.first if args.count > 0
+        @key_pattern
+      end
+
+      def key_regex(*args)
+        @key_regex = args.first if args.count > 0
+        @key_regex || default_key_regex
+      end
+
+      ## METADATA
+      #
+      def example(*args)
+        @example = args.first if args.count > 0
+        @example
+      end
+
+      def description(*args)
+        @description = args.first if args.count > 0
+        @description
+      end
+
+      def key_attributes
+        KeyBuilder.key_attributes(key_pattern)
+      end
+
+      def redis_client(*args)
+        @redis_client = args.first if args.count > 0
+        @redis_client || Sideroo.redis_client
+      end
+
+      ## SEARCH
+      #
+      def where(attr_map)
+        Sideroo::Enumerator.new(
+          type_klass: self,
+          filters: attr_map,
+        )
+      end
+
+      def all
+        where({})
+      end
+
+      def example_valid?
+        example.nil? || example =~ key_regex
+      end
+
+      private
+
+      def define_redis_method(method_name)
+        define_method method_name do |*args|
+          redis_args = [key].concat(args)
+          # forward key and args to corresponding redis method
+          redis_client.send(method_name, *redis_args)
+        end
+      end
+
+      def default_key_regex
+        regex_str = key_pattern
+
+        key_attributes.each do |attr|
+          term = "{#{attr}}"
+          value = '(.+)'
+          regex_str = regex_str.gsub(term, value)
+        end
+
+        Regexp.new("^#{regex_str}$")
+      end
+    end
+
+    # Methods applied to all types
+    redis_methods %w[
+      del
+      dump
+      exists
+      expire
+      expireat
+      persist
+      pexpire
+      pexpireat
+      pttl
+      rename
+      renamenx
+      restore
+      touch
+      ttl
+      type
+      unlink
+    ]
+
+    attr_reader :key
+
+    def initialize(arg = {})
+      @key =
+        case arg
+        when ::String
+          message = "Expected pattern #{self.class.key_pattern}, got #{arg}"
+          raise(ArgumentError, message) if arg !~ self.class.key_regex
+          arg
+        when ::Hash
+          attr_map = arg
+          KeyBuilder.new(
+            attr_map: attr_map,
+            key_pattern: self.class.key_pattern,
+          ).build
+        else
+          message = "Hash or String expected. #{arg.class} given."
+          raise ArgumentError, message
+        end
+    end
+
+    def redis_client=(client)
+      @redis_client = client
+    end
+
+    def redis_client
+      @redis_client || self.class.redis_client
+    end
+  end
+end

data/lib/sideroo/types/bitmap.rb

@@ -0,0 +1,8 @@
+module Sideroo
+  class Bitmap < Base
+    redis_methods %w[
+      getbit
+      setbit
+    ]
+  end
+end

data/lib/sideroo/types/hash.rb

@@ -0,0 +1,23 @@
+module Sideroo
+  class Hash < Base
+    redis_methods %w[
+      hdel
+      hexists
+      hget
+      hgetall
+      hincrby
+      hincrbyfloat
+      hkeys
+      hlen
+      hmget
+      hmset
+      hscan
+      hscan_each
+      hset
+      hsetnx
+      hvals
+      mapped_hmget
+      mapped_hmset
+    ]
+  end
+end

data/lib/sideroo/types/hyper_log_log.rb

@@ -0,0 +1,17 @@
+module Sideroo
+  class HyperLogLog < Base
+    redis_methods %w[
+      pfadd
+      pfcount
+    ]
+
+    def pfmerge(destination, *other_keys)
+      redis_client.pfmerge(destination, key, *other_keys)
+    end
+
+    # Use `self.key` as destination
+    def pfmerge!(*other_keys)
+      redis_client.pfmerge(key, *other_keys)
+    end
+  end
+end

data/lib/sideroo/types/list.rb

@@ -0,0 +1,23 @@
+module Sideroo
+  class List < Base
+    redis_methods %w[
+      blpop
+      brpop
+      brpoplpush
+      lindex
+      linsert
+      llen
+      lpop
+      lpush
+      lpushx
+      lrange
+      lrem
+      lset
+      ltrim
+      rpop
+      rpoplpush
+      rpush
+      rpushx
+    ]
+  end
+end

data/lib/sideroo/types/set.rb

@@ -0,0 +1,46 @@
+module Sideroo
+  class Set < Base
+    redis_methods %w[
+      sadd
+      scard
+      sdiff
+      sinter
+      sismember
+      smembers
+      smove
+      spop
+      srandmember
+      srem
+      sscan
+      sscan_each
+      sunion
+    ]
+  end
+
+  def sdiffstore(destination, *other_keys)
+    redis_client.sdiffstore(destination, key, *other_keys)
+  end
+
+  # Use `self.key` as destination
+  def sdiffstore!(*other_keys)
+    redis_client.sdiffstore(key, *other_keys)
+  end
+
+  def sinterstore(destination, *other_keys)
+    redis_client.sinterstore(destination, key, *other_keys)
+  end
+
+  # Use `self.key` as destination
+  def sinterstore!(*other_keys)
+    redis_client.sinterstore(key, *other_keys)
+  end
+
+  def sunionstore(destination, *other_keys)
+    redis_client.sunionstore(destination, key, *other_keys)
+  end
+
+  # Use `self.key` as destination
+  def sunionstore!(*other_keys)
+    redis_client.sunionstore(key, *other_keys)
+  end
+end