redcord 0.0.1.alpha → 0.0.2.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abc776db5aa9171e1f8a478013a55179158d7c9dc97e65953c27c162ad4069c7
-  data.tar.gz: 55d37148a8069725c09637f29392a6461993d93f6999bc76247e646f96a94528
+  metadata.gz: 679b0154429c95be05676a47608f0778c3d34e714d60eb5ec065863691fa9461
+  data.tar.gz: 43847db0f9fd339c8a91db402b8b2da70ea4b3f874b6faf8a05d20f234cf0aea
 SHA512:
-  metadata.gz: 1cfe27b4241554f39ce0f8f0dbce4492f308e3a1db5607f4dbb7153832f976b692987926a6cc9c7c051121f55819f9e9b9b10c02b82250986d3aa6fdf4964e8e
-  data.tar.gz: fa4865ee7e9ad1b70b4c7037d196bb60ed2aed8ab774356ec07b06a9cefd1f964d05f4da1cdd7cd2e09a5366f7bfb8da06ab84e50e282cfc74cccbb16a185621
+  metadata.gz: b01c381b8e3436aaf0f4d2ebc8604bfd582c64663601a17044b0a29ca45c46e4e8ced22969ed5c53123af65808e1c4749cf262bec17e26468c1624c0023d2b9d
+  data.tar.gz: cb4403b960c7f2e017143738edcbbfbe356e7e8c8e5b761d1f98482296541dcc2255b480d1285ce233d5add5c7e7e78fda29ab8f5fafd561f106a64e9e144460

data/lib/redcord/actions.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 # typed: strict
+
 require 'sorbet-coerce'
 
 require 'redcord/relation'
@@ -6,9 +9,6 @@ require 'redcord/relation'
 module Redcord
   # Raised by Model.find
   class RecordNotFound < StandardError; end
-  # Raised by Model.where
-  class AttributeNotIndexed < StandardError; end
-  class WrongAttributeType < TypeError; end
 end
 
 module Redcord::Actions
@@ -38,13 +38,17 @@ module Redcord::Actions
       instance_key = "#{model_key}:id:#{id}"
       args = redis.hgetall(instance_key)
       if args.empty?
-        raise Redcord::RecordNotFound.new(
-          "Couldn't find #{name} with 'id'=#{id}"
-        )
+        raise Redcord::RecordNotFound, "Couldn't find #{name} with 'id'=#{id}"
       end
+
       coerce_and_set_id(args, id)
     end
 
+    sig { params(args: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
+    def find_by(args)
+      where(args).to_a.first
+    end
+
     sig { params(args: T::Hash[Symbol, T.untyped]).returns(Redcord::Relation) }
     def where(args)
       Redcord::Relation.new(T.let(self, T.untyped)).where(args)
@@ -52,7 +56,7 @@ module Redcord::Actions
 
     sig { params(id: T.untyped).returns(T::Boolean) }
     def destroy(id)
-      return redis.delete_hash(model_key, id) == 1
+      redis.delete_hash(model_key, id) == 1
     end
   end
 
@@ -65,13 +69,21 @@ module Redcord::Actions
     sig { abstract.returns(T.nilable(ActiveSupport::TimeWithZone)) }
     def created_at; end
 
-    sig { abstract.params(time: ActiveSupport::TimeWithZone).returns(T.nilable(ActiveSupport::TimeWithZone)) }
+    sig {
+      abstract.params(
+        time: ActiveSupport::TimeWithZone,
+      ).returns(T.nilable(ActiveSupport::TimeWithZone))
+    }
     def created_at=(time); end
 
     sig { abstract.returns(T.nilable(ActiveSupport::TimeWithZone)) }
     def updated_at; end
 
-    sig { abstract.params(time: ActiveSupport::TimeWithZone).returns(T.nilable(ActiveSupport::TimeWithZone)) }
+    sig {
+      abstract.params(
+        time: ActiveSupport::TimeWithZone,
+      ).returns(T.nilable(ActiveSupport::TimeWithZone))
+    }
     def updated_at=(time); end
 
     sig { void }
@@ -80,15 +92,22 @@ module Redcord::Actions
       _id = id
       if _id.nil?
         self.created_at = T.must(self.updated_at)
-        _id = redis.create_hash_returning_id(self.class.model_key, self.class.to_redis_hash(serialize))
+        _id = redis.create_hash_returning_id(
+          self.class.model_key,
+          self.class.to_redis_hash(serialize),
+        )
         send(:id=, _id)
       else
-        redis.update_hash(self.class.model_key, _id, self.class.to_redis_hash(serialize))
+        redis.update_hash(
+          self.class.model_key,
+          _id,
+          self.class.to_redis_hash(serialize),
+        )
       end
     end
 
     sig { params(args: T::Hash[Symbol, T.untyped]).void }
-    def update!(args={})
+    def update!(args = {})
       _id = id
       if _id.nil?
         _set_args!(args)
@@ -96,13 +115,18 @@ module Redcord::Actions
       else
         args[:updated_at] = Time.zone.now
         _set_args!(args)
-        redis.update_hash(self.class.model_key, _id, self.class.to_redis_hash(args))
+        redis.update_hash(
+          self.class.model_key,
+          _id,
+          self.class.to_redis_hash(args),
+        )
       end
     end
 
     sig { returns(T::Boolean) }
     def destroy
       return false if id.nil?
+
       self.class.destroy(T.must(id))
     end
 
@@ -123,7 +147,7 @@ module Redcord::Actions
       instance_variable_get(:@_id)
     end
 
-  private
+    private
 
     sig { params(id: Integer).returns(Integer) }
     def id=(id)

data/lib/redcord/attribute.rb

@@ -1,11 +1,19 @@
+# frozen_string_literal: true
+
 # typed: strict
+
 module Redcord::Attribute
   extend T::Sig
   extend T::Helpers
 
-  # We implicitly determine what should be a range index on Redis based on Ruby type.
+  # We implicitly determine what should be a range index on Redis based on Ruby
+  # type.
   RangeIndexType = T.type_alias {
-    T.any(T.nilable(Time), T.nilable(Float), T.nilable(Integer))
+    T.any(
+      T.nilable(Float),
+      T.nilable(Integer),
+      T.nilable(Time),
+    )
   }
 
   sig { params(klass: T.class_of(T::Struct)).void }
@@ -26,23 +34,22 @@ module Redcord::Attribute
         options: T::Hash[Symbol, T.untyped],
       ).void
     end
-    def attribute(name, type, options={})
+    def attribute(name, type, options = {})
       # TODO: support uniq options
+      # TODO: validate types
       prop(name, type)
-      if options[:index]
-        index_attribute(name, type)
-      end
+
+      index_attribute(name, type) if options[:index]
     end
-    
 
-    sig { params(attr: Symbol, type: T.any(Class,T::Types::Base)).void }
+    sig { params(attr: Symbol, type: T.any(Class, T::Types::Base)).void }
     def index_attribute(attr, type)
       if should_range_index?(type)
         class_variable_get(:@@range_index_attributes) << attr
-        sadd_proc_on_redis_connection("range_index_attrs", attr.to_s)
+        sadd_proc_on_redis_connection('range_index_attrs', attr.to_s)
       else
         class_variable_get(:@@index_attributes) << attr
-        sadd_proc_on_redis_connection("index_attrs", attr.to_s)
+        sadd_proc_on_redis_connection('index_attrs', attr.to_s)
       end
     end
 
@@ -52,22 +59,23 @@ module Redcord::Attribute
     end
 
     private
+
     sig { params(redis_key: String, item_to_add: String).void }
     def sadd_proc_on_redis_connection(redis_key, item_to_add)
-      # TODO: Currently we're setting indexed attributes through procs that are run
-      # when a RedisConnection is established. This should be replaced with migrations
-      Redcord::RedisConnection.procs_to_prepare << Proc.new do |redis|
+      # TODO: Currently we're setting indexed attributes through procs that are
+      # run when a RedisConnection is established. This should be replaced with
+      # migrations
+      Redcord::RedisConnection.procs_to_prepare << proc do |redis|
         redis.sadd("#{model_key}:#{redis_key}", item_to_add)
       end
     end
 
-    sig { params(type: T.any(Class,T::Types::Base)).returns(T::Boolean) }
+    sig { params(type: T.any(Class, T::Types::Base)).returns(T::Boolean) }
     def should_range_index?(type)
       # Change Ruby raw type to Sorbet type in order to call subtype_of?
-      if type.is_a?(Class)
-        type = T::Types::Simple.new(type)
-      end
-      return type.subtype_of?(RangeIndexType)
+      type = T::Types::Simple.new(type) if type.is_a?(Class)
+
+      type.subtype_of?(RangeIndexType)
     end
   end
 

data/lib/redcord/base.rb

@@ -52,8 +52,9 @@ module Redcord::Base
       # coerced to the specified attribute types. Like ActiveRecord,
       # Redcord manages the created_at and updated_at fields behind the
       # scene.
-      prop :created_at, T.nilable(Time)
-      prop :updated_at, T.nilable(Time)
+      attribute :id, T.nilable(Integer), index: true
+      attribute :created_at, T.nilable(Time), index: true
+      attribute :updated_at, T.nilable(Time), index: true
     end
   end
 end

data/lib/redcord/lua_script_reader.rb

@@ -1,16 +1,27 @@
+# frozen_string_literal: true
+
 # typed: strict
+
+require 'erb'
+
 module Redcord::LuaScriptReader
   extend T::Sig
 
-  sig {params(script_name: String).returns(String) }
+  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")
+    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) }
+  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")
+    path = File.join(
+      File.dirname(__FILE__),
+      "server_scripts/#{relative_path}.erb.lua",
+    )
     File.read(path)
   end
-end
+end

data/lib/redcord/migration/migrator.rb

@@ -50,7 +50,7 @@ class Redcord::Migration::Migrator
   MIGRATION_FILENAME_REGEX = /\A([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?\.rb\z/
 
   @@migrations_paths = T.let(
-    ['db/redisrecord/migrate'],
+    ['db/redcord/migrate'],
     T::Array[String],
   )
 

data/lib/redcord/migration/version.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 # typed: strict
+
 class Redcord::Migration::Version
   extend T::Sig
 

data/lib/redcord/redis_connection.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 # typed: strict
+
 require 'rails'
-require 'redcord/prepared_redis'
+
 require 'redcord/lua_script_reader'
+require 'redcord/prepared_redis'
 
 module Redcord::RedisConnection
   extend T::Sig
@@ -37,7 +41,8 @@ module Redcord::RedisConnection
 
     sig { params(redis: Redis).returns(Redcord::PreparedRedis) }
     def redis=(redis)
-      Redcord::RedisConnection.connections[name.underscore] = prepare_redis!(redis)
+      Redcord::RedisConnection.connections[name.underscore] =
+        prepare_redis!(redis)
     end
 
     # We prepare the model definition such as TTL, index, and uniq when we
@@ -46,11 +51,17 @@ module Redcord::RedisConnection
     #
     # TODO: Replace this with Redcord migrations
     sig { params(client: T.nilable(Redis)).returns(Redcord::PreparedRedis) }
-    def prepare_redis!(client=nil)
+    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)),
+        **(
+          if client.nil?
+            connection_config
+          else
+            client.instance_variable_get(:@options)
+          end
+        ),
         logger: Redcord::Logger.proxy,
       )
 
@@ -63,7 +74,10 @@ module Redcord::RedisConnection
       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))
+          client.script(
+            :load,
+            Redcord::LuaScriptReader.read_lua_script(script_name.to_s),
+          )
         end
       end
 
@@ -81,11 +95,15 @@ module Redcord::RedisConnection
     end
   end
 
-  sig { params(config: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]) }
+  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[env] = {} unless config.include?(env)
+    config[env]['default'] = {} unless config[env].include?('default')
     config
   end
 

data/lib/redcord/relation.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 # typed: strict
+
+require 'active_support/core_ext/array'
 require 'active_support/core_ext/module'
 
 class Redcord::Relation
@@ -6,33 +10,25 @@ class Redcord::Relation
 
   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]
+      select_attrs: T::Set[Symbol],
     ).void
   end
-  def initialize(model, query_conditions={}, select_attrs=Set.new)
+  def initialize(
+    model,
+    query_conditions = {},
+    select_attrs = Set.new
+  )
     @model = model
     @query_conditions = query_conditions
     @select_attrs = select_attrs
@@ -50,14 +46,17 @@ class Redcord::Relation
 
   sig do
     params(
-    args: Symbol,
+    args: T.untyped,
     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) }
+      return execute_query.select do |*item|
+        blk.call(*item)
+      end
     end
+
     select_attrs.merge(args)
     self
   end
@@ -67,24 +66,93 @@ class Redcord::Relation
     redis.find_by_attr_count(model.model_key, query_conditions)
   end
 
-  sig { returns(T::Array[T.untyped]) }
-  def to_a
-    execute_query
-  end
+  delegate(
+    :&,
+    :[],
+    :all?,
+    :any?,
+    :any?,
+    :at,
+    :collect!,
+    :collect,
+    :compact!,
+    :compact,
+    :each,
+    :each_index,
+    :empty?,
+    :eql?,
+    :exists?,
+    :fetch,
+    :fifth!,
+    :fifth,
+    :filter!,
+    :filter,
+    :first!,
+    :first,
+    :forty_two!,
+    :forty_two,
+    :fourth!,
+    :fourth,
+    :include?,
+    :inspect,
+    :last!,
+    :last,
+    :many?,
+    :map!,
+    :map,
+    :none?,
+    :one?,
+    :reject!,
+    :reject,
+    :reverse!,
+    :reverse,
+    :reverse_each,
+    :second!,
+    :second,
+    :second_to_last!,
+    :second_to_last,
+    :size,
+    :sort!,
+    :sort,
+    :sort_by!,
+    :take!,
+    :take,
+    :third!,
+    :third,
+    :third_to_last!,
+    :third_to_last,
+    :to_a,
+    :to_ary,
+    :to_h,
+    :to_s,
+    :zip,
+    :|,
+    to: :execute_query,
+  )
 
   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)
+      res_hash = redis.find_by_attr(
+        model.model_key,
+        query_conditions,
+        select_attrs,
+      )
+
+      res_hash.map do |id, args|
+        model.from_redis_hash(args).map do |k, v|
+          [k.to_sym, TypeCoerce[model.get_attr_type(k.to_sym)].new.from(v)]
+        end.to_h.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) }
+      res_hash = redis.find_by_attr(
+        model.model_key,
+        query_conditions,
+      )
+
+      res_hash.map { |id, args| model.coerce_and_set_id(args, id) }
     end
   end
 

data/lib/redcord/serializer.rb

@@ -1,14 +1,17 @@
-require 'redcord/range_interval'
+# frozen_string_literal: true
+
 # typed: strict
-#
-# This module defines various helper methods on Redcord for serialization between the 
-# Ruby client and Redis server.
+
+require 'redcord/range_interval'
+
 module Redcord
   # Raised by Model.where
   class AttributeNotIndexed < StandardError; end
   class WrongAttributeType < TypeError; end
 end
 
+# This module defines various helper methods on Redcord for serialization
+# between the  Ruby client and Redis server.
 module Redcord::Serializer
   extend T::Sig
 
@@ -16,27 +19,30 @@ module Redcord::Serializer
   def self.included(klass)
     klass.extend(ClassMethods)
   end
-  
+
   module ClassMethods
     extend T::Sig
 
-    # Redis only allows range queries on floats. To allow range queries on the Ruby Time
-    # type, encode_attr_value and decode_attr_value will implicitly encode and decode
-    # Time attributes to a float.
+    # Redis only allows range queries on floats. To allow range queries on the
+    # Ruby Time type, encode_attr_value and decode_attr_value will implicitly
+    # encode and decode Time attributes to a float.
     TIME_TYPES = T.let(Set[Time, T.nilable(Time)], T::Set[T.untyped])
+
     sig { params(attribute: Symbol, val: T.untyped).returns(T.untyped) }
     def encode_attr_value(attribute, val)
-      if val && TIME_TYPES.include?(props[attribute][:type])
+      if !val.blank? && TIME_TYPES.include?(props[attribute][:type])
         val = val.to_f
       end
+
       val
     end
 
     sig { params(attribute: Symbol, val: T.untyped).returns(T.untyped) }
     def decode_attr_value(attribute, val)
-      if val && TIME_TYPES.include?(props[attribute][:type])
+      if !val.blank? && TIME_TYPES.include?(props[attribute][:type])
         val = Time.zone.at(val.to_f)
       end
+
       val
     end
 
@@ -44,11 +50,13 @@ module Redcord::Serializer
     def validate_and_encode_query(attr_key, attr_val)
       # Validate that attributes queried for are index attributes
       if !class_variable_get(:@@index_attributes).include?(attr_key) &&
-        !class_variable_get(:@@range_index_attributes).include?(attr_key)
-        raise Redcord::AttributeNotIndexed.new(
-        "#{attr_key} is not an indexed attribute."
+         !class_variable_get(:@@range_index_attributes).include?(attr_key)
+        raise(
+          Redcord::AttributeNotIndexed,
+          "#{attr_key} is not an indexed attribute.",
         )
       end
+
       # Validate attribute types for normal index attributes
       attr_type = get_attr_type(attr_key)
       if class_variable_get(:@@index_attributes).include?(attr_key)
@@ -56,44 +64,66 @@ module Redcord::Serializer
       else
         # Validate attribute types for range index attributes
         if attr_val.is_a?(Redcord::RangeInterval)
-          validate_attr_type(attr_val.min, T.cast(T.nilable(attr_type), T::Types::Base))
-          validate_attr_type(attr_val.max, T.cast(T.nilable(attr_type), T::Types::Base))
+          validate_attr_type(
+            attr_val.min,
+            T.cast(T.nilable(attr_type), T::Types::Base),
+          )
+          validate_attr_type(
+            attr_val.max,
+            T.cast(T.nilable(attr_type), T::Types::Base),
+          )
         else
           validate_attr_type(attr_val, attr_type)
         end
-        # Range index attributes need to be further encoded into a format understood by the Lua script.
-        if attr_val != nil
+
+        # Range index attributes need to be further encoded into a format
+        # understood by the Lua script.
+        unless attr_val.nil?
           attr_val = encode_range_index_attr_val(attr_key, attr_val)
         end
       end
+
       attr_val
     end
 
-    sig { params(attr_val: T.untyped, attr_type: T.any(Class, T::Types::Base)).void }
+    sig {
+      params(
+        attr_val: T.untyped,
+        attr_type: T.any(Class, T::Types::Base),
+      ).void
+    }
     def validate_attr_type(attr_val, attr_type)
       if (attr_type.is_a?(Class) && !attr_val.is_a?(attr_type)) ||
-        (attr_type.is_a?(T::Types::Base) && !attr_type.valid?(attr_val))
-        raise Redcord::WrongAttributeType.new(
-          "Expected type #{attr_type}, got #{attr_val.class}"
+         (attr_type.is_a?(T::Types::Base) && !attr_type.valid?(attr_val))
+        raise(
+          Redcord::WrongAttributeType,
+          "Expected type #{attr_type}, got #{attr_val.class.name}",
         )
       end
     end
 
-    sig { params(attribute: Symbol, val: T.untyped).returns([T.untyped, T.untyped]) }
+    sig {
+      params(
+        attribute: Symbol,
+        val: T.untyped,
+      ).returns([T.untyped, T.untyped])
+    }
     def encode_range_index_attr_val(attribute, val)
       if val.is_a?(Redcord::RangeInterval)
-        # nil is treated as -inf and +inf. This is supported in Redis sorted sets
-        # so clients aren't required to know the highest and lowest scores in a range
+        # nil is treated as -inf and +inf. This is supported in Redis sorted
+        # sets so clients aren't required to know the highest and lowest scores
+        # in a range
         min_val = !val.min ? '-inf' : encode_attr_value(attribute, val.min)
         max_val = !val.max ? '+inf' : encode_attr_value(attribute, val.max)
 
-        # In Redis, by default min and max is closed. You can prefix the score with '(' to
-        # specify an open interval.
+        # In Redis, by default min and max is closed. You can prefix the score
+        # with '(' to specify an open interval.
         min_val = val.min_exclusive ? '(' + min_val.to_s : min_val.to_s
         max_val = val.max_exclusive ? '(' + max_val.to_s : max_val.to_s
-        return [min_val, max_val]
+        [min_val, max_val]
       else
-        # Equality queries for range indices are be passed to redis as a range [val, val].
+        # Equality queries for range indices are be passed to redis as a range
+        # [val, val].
         encoded_val = encode_attr_value(attribute, val)
         [encoded_val, encoded_val]
       end
@@ -104,24 +134,41 @@ module Redcord::Serializer
       props[attr_key][:type_object]
     end
 
-    sig { params(redis_hash: T::Hash[T.untyped, T.untyped], id: Integer).returns(T.untyped) }
+    sig {
+      params(
+        redis_hash: T::Hash[T.untyped, T.untyped],
+        id: Integer,
+      ).returns(T.untyped)
+    }
     def coerce_and_set_id(redis_hash, id)
-      # Coerce each serialized result returned from Redis back into Model instance
+      # Coerce each serialized result returned from Redis back into Model
+      # instance
       instance = TypeCoerce.send(:[], self).new.from(from_redis_hash(redis_hash))
       instance.send(:id=, id)
       instance
     end
+
     sig { returns(String) }
     def model_key
       "Redcord:#{name}"
     end
 
-    sig { params(args: T::Hash[T.any(String, Symbol), T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+    sig {
+      params(
+        args: T::Hash[T.any(String, Symbol), T.untyped],
+      ).returns(T::Hash[Symbol, T.untyped])
+    }
     def to_redis_hash(args)
-      args.map { |key, val| [key.to_sym, encode_attr_value(key.to_sym, val)] }.to_h
+      args.map do |key, val|
+        [key.to_sym, encode_attr_value(key.to_sym, val)]
+      end.to_h
     end
 
-    sig { params(args: T::Hash[T.untyped, T.untyped]).returns(T::Hash[T.untyped, T.untyped]) }
+    sig {
+      params(
+        args: T::Hash[T.untyped, T.untyped],
+      ).returns(T::Hash[T.untyped, T.untyped])
+    }
     def from_redis_hash(args)
       args.map { |key, val| [key, decode_attr_value(key.to_sym, val)] }.to_h
     end

data/lib/redcord/server_scripts/create_hash_returning_id.erb.lua

@@ -60,6 +60,7 @@ if #index_attr_keys > 0 then
   end
 end
 local range_index_attr_keys = redis.call('smembers', model .. ':range_index_attrs')
+attrs_hash['id'] = id
 if #range_index_attr_keys > 0 then
   for _, attr_key in ipairs(range_index_attr_keys) do
     add_id_to_range_index_attr(model, attr_key, attrs_hash[attr_key], id)

data/lib/redcord/server_scripts/shared/query_helper_methods.erb.lua

@@ -52,6 +52,11 @@ local function batch_exists(model, ids_set)
   for id, _ in pairs(ids_set) do
     table.insert(id_keys, model .. ':id:' .. id)
   end
+
+  if #id_keys == 0 then
+    return 0
+  end
+
   return redis.call('exists', unpack(id_keys))
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redcord
 version: !ruby/object:Gem::Version
-  version: 0.0.1.alpha
+  version: 0.0.2.alpha
 platform: ruby
 authors:
 - Chan Zuckerberg Initiative
@@ -14,28 +14,28 @@ dependencies:
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5'
 - !ruby/object:Gem::Dependency
@@ -203,7 +203,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.1.3
+rubyforge_project: 
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: A Ruby ORM like Active Record, but for Redis