redcord 0.0.1.alpha

data/lib/redcord/logger.rb

@@ -0,0 +1,69 @@
+# typed: strict
+require 'rails'
+module Redcord::Logger
+  extend T::Sig
+  extend T::Helpers
+
+  sig { params(klass: Module).void }
+  def self.included(klass)
+    klass.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    extend T::Sig
+
+    @@logger = T.let(Rails.logger, T.untyped)
+
+    sig { returns(T.untyped) }
+    def logger
+      @@logger
+    end
+
+    sig { params(logger: T.untyped).void }
+    def logger=(logger)
+      @@logger = logger
+    end
+  end
+
+  module LoggerMethods
+    extend T::Sig
+
+    #
+    # Forward all the logger methods call to a module -- almost all logger
+    # methods are missing and handled by method_missing. We use this trick to
+    # dynamically swap loggers without reconfiguring the Redis clients.
+    #
+    sig do
+      params(
+        method: Symbol,
+        args: T.untyped,
+        blk: T.nilable(T.proc.returns(T.untyped))
+      ).returns(T.untyped)
+    end
+    def self.method_missing(method, *args, &blk)
+      logger = Redcord::Base.logger
+      return if logger.nil?
+      logger.send(method, *args)
+    end
+  end
+
+  # If we set the logger to nil, but we're not rebuilding the connection(s) at
+  # all.
+  # Example:
+  #
+  #   2.5.5 :001 > Redcord::Base.redis.ping
+  #   [Redis] command=PING args=
+  #   [Redis] call_time=0.80 ms
+  #    => "PONG"
+  #   2.5.5 :002 > Redcord::Base.logger = nil
+  #    => nil
+  #   2.5.5 :003 > Redcord::Base.redis.ping # show no logs
+  #    => "PONG"
+  #
+  sig { returns(T.untyped) }
+  def self.proxy
+    Redcord::Logger::LoggerMethods
+  end
+
+  mixes_in_class_methods(ClassMethods)
+end

data/lib/redcord/lua_script_reader.rb

@@ -0,0 +1,16 @@
+# typed: strict
+module Redcord::LuaScriptReader
+  extend T::Sig
+
+  sig {params(script_name: String).returns(String) }
+  def self.read_lua_script(script_name)
+    path = File.join(File.dirname(__FILE__), "server_scripts/#{script_name}.erb.lua")
+    ERB.new(File.read(path)).result(binding)
+  end
+
+  sig {params(relative_path: String).returns(String) }
+  def self.include_lua(relative_path)
+    path = File.join(File.dirname(__FILE__), "server_scripts/#{relative_path}.erb.lua")
+    File.read(path)
+  end
+end

data/lib/redcord/migration.rb

@@ -0,0 +1,27 @@
+# typed: strict
+class Redcord::Migration
+end
+
+require 'redcord/migration/ttl'
+
+class Redcord::Migration
+  extend T::Sig
+  extend T::Helpers
+  include Redcord::Migration::TTL
+
+  abstract!
+
+  sig { returns(Redis) }
+  attr_reader :redis
+
+  sig { params(redis: Redis).void }
+  def initialize(redis)
+    @redis = redis
+  end
+
+  sig { abstract.void }
+  def up; end
+
+  sig { abstract.void }
+  def down; end
+end

data/lib/redcord/migration/migrator.rb

@@ -0,0 +1,74 @@
+# typed: strict
+require 'redcord/migration'
+class Redcord::Migration::Migrator
+  extend T::Sig
+
+  sig { params(redis: Redis).returns(T::Boolean) }
+  def self.need_to_migrate?(redis)
+    local_version = Redcord::Migration::Version.new
+    remote_version = Redcord::Migration::Version.new(redis: redis)
+    !(local_version.all - remote_version.all).empty?
+  end
+
+  sig { params(redis: Redis, version: String, direction: Symbol).void }
+  def self.migrate(redis:, version:, direction:)
+    migration = load_version(version)
+    print [
+      T.must("#{redis.inspect.match('(redis://.*)>')[1]}"[0...30]),
+      direction.to_s.upcase,
+      version,
+      T.must(migration.name).underscore.humanize,
+    ].map { |str| str.ljust(30) }.join("\t")
+
+    start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    migration.new(redis).send(direction)
+    if direction == :up
+      redis.sadd(
+        Redcord::Migration::Version::MIGRATION_VERSIONS_REDIS_KEY,
+        version,
+      )
+    else
+      redis.srem(
+        Redcord::Migration::Version::MIGRATION_VERSIONS_REDIS_KEY,
+        version,
+      )
+    end
+    end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    puts "\t#{(end_time - start_time) * 1000.0.round(3)} ms"
+  end
+
+  private
+
+  sig { params(version: String).returns(T.class_of(Redcord::Migration)) }
+  def self.load_version(version)
+    file = T.must(migration_files.select { |f| f.match(version) }.first)
+    require(File.expand_path(file))
+    underscore_const_name = parse_migration_filename(file)[1]
+    Object.const_get(underscore_const_name.camelize)
+  end
+
+  MIGRATION_FILENAME_REGEX = /\A([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?\.rb\z/
+
+  @@migrations_paths = T.let(
+    ['db/redisrecord/migrate'],
+    T::Array[String],
+  )
+
+  sig { returns(T::Array[String]) }
+  def self.migrations_paths
+    @@migrations_paths
+  end
+
+  sig { returns(T::Array[String]) }
+  def self.migration_files
+    paths = migrations_paths
+    # Use T.unsafe to workaround sorbet: splat the paths
+    T.unsafe(Dir)[*paths.flat_map { |path| "#{path}/**/[0-9]*_*.rb" }]
+  end
+
+
+  sig { params(filename: String).returns([String, String, String]) }
+  def self.parse_migration_filename(filename)
+    T.unsafe(File.basename(filename).scan(MIGRATION_FILENAME_REGEX).first)
+  end
+end

data/lib/redcord/migration/ttl.rb

@@ -0,0 +1,11 @@
+# typed: strict
+module Redcord::Migration::TTL
+  extend T::Sig
+
+  # This won't change ttl until we call update on a record
+  sig { params(model: T.class_of(Redcord::Base)).void }
+  def change_ttl_passive(model)
+    ttl = model.class_variable_get(:@@ttl)
+    model.redis.set("#{model.model_key}:ttl", ttl ? ttl : -1)
+  end
+end

data/lib/redcord/migration/version.rb

@@ -0,0 +1,40 @@
+# typed: strict
+class Redcord::Migration::Version
+  extend T::Sig
+
+  MIGRATION_VERSIONS_REDIS_KEY = 'Redcord:__migration_versions__'
+
+  sig { params(redis: T.nilable(Redis)).void }
+  def initialize(redis: nil)
+    @redis = T.let(redis, T.nilable(Redis))
+  end
+
+  sig { returns(T.nilable(String)) }
+  def current
+    all.sort.last
+  end
+
+  sig { returns(T::Array[String]) }
+  def all
+    if @redis
+      remote_versions
+    else
+      local_versions
+    end
+  end
+
+  private
+
+  sig { returns(T::Array[String]) }
+  def local_versions
+    Redcord::Migration::Migrator.migration_files.map do |filename|
+      fields = Redcord::Migration::Migrator.parse_migration_filename(filename)
+      fields[0]
+    end
+  end
+
+  sig { returns(T::Array[String]) }
+  def remote_versions
+    T.must(@redis).smembers(MIGRATION_VERSIONS_REDIS_KEY)
+  end
+end

data/lib/redcord/prepared_redis.rb

@@ -0,0 +1,18 @@
+# typed: strict
+require 'redis'
+require 'redcord/server_scripts'
+
+class Redcord::PreparedRedis < Redis
+  extend T::Sig
+  include Redcord::ServerScripts
+
+  sig { returns(T::Hash[Symbol, String]) }
+  def redcord_server_script_shas
+    instance_variable_get(:@_redcord_server_script_shas)
+  end
+
+  sig { params(shas: T::Hash[Symbol, String]).void }
+  def redcord_server_script_shas=(shas)
+    instance_variable_set(:@_redcord_server_script_shas, shas)
+  end
+end

data/lib/redcord/railtie.rb

@@ -0,0 +1,16 @@
+# typed: strict
+require 'rails'
+
+class Redcord::Railtie < Rails::Railtie
+  railtie_name 'redcord'
+
+  rake_tasks do
+    path = File.expand_path(T.must(__dir__))
+    Dir.glob("#{path}/tasks/**/*.rake").each { |f| load f }
+  end
+
+  # Load necessary dependency to configure redcord
+  config.before_configuration do
+    require 'redcord/base'
+  end
+end

data/lib/redcord/range_interval.rb

@@ -0,0 +1,9 @@
+# typed: strict
+require 'redcord/attribute'
+
+class Redcord::RangeInterval < T::Struct
+  prop :min, T.nilable(Redcord::Attribute::RangeIndexType), default: nil
+  prop :min_exclusive, T::Boolean, default: false
+  prop :max, T.nilable(Redcord::Attribute::RangeIndexType), default: nil
+  prop :max_exclusive, T::Boolean, default: false
+end

data/lib/redcord/redis_connection.rb

@@ -0,0 +1,103 @@
+# typed: strict
+require 'rails'
+require 'redcord/prepared_redis'
+require 'redcord/lua_script_reader'
+
+module Redcord::RedisConnection
+  extend T::Sig
+  extend T::Helpers
+
+  @connections = T.let(nil, T.nilable(T::Hash[String, T.untyped]))
+  @procs_to_prepare = T.let([], T::Array[Proc])
+
+  sig { params(klass: T.any(Module, T.class_of(T::Struct))).void }
+  def self.included(klass)
+    klass.extend(ClassMethods)
+    klass.include(InstanceMethods)
+  end
+
+  module ClassMethods
+    extend T::Sig
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def connection_config
+      env_config = Redcord::Base.configurations[Rails.env]
+      (env_config[name.underscore] || env_config['default']).symbolize_keys
+    end
+
+    sig { returns(Redcord::PreparedRedis) }
+    def redis
+      Redcord::RedisConnection.connections[name.underscore] ||= prepare_redis!
+    end
+
+    sig { returns(Redcord::PreparedRedis) }
+    def establish_connection
+      Redcord::RedisConnection.connections[name.underscore] = prepare_redis!
+    end
+
+    sig { params(redis: Redis).returns(Redcord::PreparedRedis) }
+    def redis=(redis)
+      Redcord::RedisConnection.connections[name.underscore] = prepare_redis!(redis)
+    end
+
+    # We prepare the model definition such as TTL, index, and uniq when we
+    # establish a Redis connection (once per connection) instead of sending the
+    # definitions in each Redis query.
+    #
+    # TODO: Replace this with Redcord migrations
+    sig { params(client: T.nilable(Redis)).returns(Redcord::PreparedRedis) }
+    def prepare_redis!(client=nil)
+      return client if client.is_a?(Redcord::PreparedRedis)
+
+      client = Redcord::PreparedRedis.new(
+        **(client.nil? ? connection_config : client.instance_variable_get(:@options)),
+        logger: Redcord::Logger.proxy,
+      )
+
+      client.pipelined do
+        Redcord::RedisConnection.procs_to_prepare.each do |proc_to_prepare|
+          proc_to_prepare.call(client)
+        end
+      end
+
+      script_names = Redcord::ServerScripts.instance_methods
+      res = client.pipelined do
+        script_names.each do |script_name|
+          client.script(:load, Redcord::LuaScriptReader.read_lua_script(script_name.to_s))
+        end
+      end
+
+      client.redcord_server_script_shas = script_names.zip(res).to_h
+      client
+    end
+  end
+
+  module InstanceMethods
+    extend T::Sig
+
+    sig { returns(Redcord::PreparedRedis) }
+    def redis
+      self.class.redis
+    end
+  end
+
+  sig { params(config: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]) }
+  def self.merge_and_resolve_default(config)
+    env = Rails.env
+    config[env] = {} if !config.include?(env)
+    config[env]['default'] = {} if !config[env].include?('default')
+    config
+  end
+
+  sig { returns(T::Hash[String, T.untyped]) }
+  def self.connections
+    @connections ||= {}
+  end
+
+  sig { returns(T::Array[Proc]) }
+  def self.procs_to_prepare
+    @procs_to_prepare
+  end
+
+  mixes_in_class_methods(ClassMethods)
+end

data/lib/redcord/relation.rb

@@ -0,0 +1,95 @@
+# typed: strict
+require 'active_support/core_ext/module'
+
+class Redcord::Relation
+  extend T::Sig
+
+  sig { returns(T.class_of(Redcord::Base)) }
+  attr_reader :model
+  
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  attr_reader :query_conditions
+
+  sig { returns(T::Set[Symbol]) }
+  attr_reader :select_attrs
+
+  # TODO: Add sig for []
+  delegate :[], to: :to_a
+
+  sig do
+    type_parameters(:U).params(
+      blk: T.proc.params(arg0: Redcord::Base).returns(T.type_parameter(:U)),
+    ).returns(T::Array[T.type_parameter(:U)])
+  end
+  def map(&blk)
+    to_a.map(&blk)
+  end
+
+  sig do
+    params(
+      model: T.class_of(Redcord::Base),
+      query_conditions: T::Hash[Symbol, T.untyped],
+      select_attrs: T::Set[Symbol]
+    ).void
+  end
+  def initialize(model, query_conditions={}, select_attrs=Set.new)
+    @model = model
+    @query_conditions = query_conditions
+    @select_attrs = select_attrs
+  end
+
+  sig { params(args: T::Hash[Symbol, T.untyped]).returns(Redcord::Relation) }
+  def where(args)
+    encoded_args = args.map do |attr_key, attr_val|
+      encoded_val = model.validate_and_encode_query(attr_key, attr_val)
+      [attr_key, encoded_val]
+    end
+    query_conditions.merge!(encoded_args.to_h)
+    self
+  end
+
+  sig do
+    params(
+    args: Symbol,
+    blk: T.nilable(T.proc.params(arg0: T.untyped).void),
+  ).returns(T.any(Redcord::Relation, T::Array[T.untyped]))
+  end
+  def select(*args, &blk)
+    if block_given?
+      return execute_query.select { |*item| blk.call(*item) }
+    end
+    select_attrs.merge(args)
+    self
+  end
+
+  sig { returns(Integer) }
+  def count
+    redis.find_by_attr_count(model.model_key, query_conditions)
+  end
+
+  sig { returns(T::Array[T.untyped]) }
+  def to_a
+    execute_query
+  end
+
+  private
+  sig { returns(T::Array[T.untyped]) }
+  def execute_query
+    if !select_attrs.empty?
+      res_hash = redis.find_by_attr(model.model_key, query_conditions, select_attrs)
+      return res_hash.map do |id, args|
+        args = model.from_redis_hash(args)
+        args = args.map { |k, v| [k.to_sym, TypeCoerce[model.get_attr_type(k.to_sym)].new.from(v)] }.to_h
+        args.merge!(:id => id)
+      end
+    else
+      res_hash = redis.find_by_attr(model.model_key, query_conditions)
+      return res_hash.map { |id, args| model.coerce_and_set_id(args, id) }
+    end
+  end
+
+  sig { returns(Redcord::PreparedRedis) }
+  def redis
+    model.redis
+  end
+end