rigortype 0.1.19 → 0.2.1

data/data/vendored_gem_sigs/redis/redis.rbs

@@ -0,0 +1,348 @@
+class Redis
+  type arg = String | Symbol | Integer | Float
+  type time = Integer | Float
+
+  type sentinel = { host: String, port: Integer?, password: String? }
+
+  type node = String
+            | { host: String?, port: Integer?, db: Integer?, password: String?, path: String?, url: String? }
+
+  # Create a new client instance
+  #
+  # @param [Hash] options
+  # @option options [String] :url (value of the environment variable REDIS_URL) a Redis URL, for a TCP connection:
+  #   `redis://:[password]@[hostname]:[port]/[db]` (password, port and database are optional), for a unix socket
+  #    connection: `unix://[path to Redis socket]`. This overrides all other options.
+  # @option options [String] :host ("127.0.0.1") server hostname
+  # @option options [Integer] :port (6379) server port
+  # @option options [String] :path path to server socket (overrides host and port)
+  # @option options [Float] :timeout (5.0) timeout in seconds
+  # @option options [Float] :connect_timeout (same as timeout) timeout for initial connect in seconds
+  # @option options [String] :password Password to authenticate against server
+  # @option options [Integer] :db (0) Database to select after initial connect
+  # @option options [Symbol] :driver Driver to use, currently supported: `:ruby`, `:hiredis`, `:synchrony`
+  # @option options [String] :id ID for the client connection, assigns name to current connection by sending
+  #   `CLIENT SETNAME`
+  # @option options [Hash, Integer] :tcp_keepalive Keepalive values, if Integer `intvl` and `probe` are calculated
+  #   based on the value, if Hash `time`, `intvl` and `probes` can be specified as a Integer
+  # @option options [Integer] :reconnect_attempts Number of attempts trying to connect
+  # @option options [Boolean] :inherit_socket (false) Whether to use socket in forked process or not
+  # @option options [Array] :sentinels List of sentinels to contact
+  # @option options [Symbol] :role (:master) Role to fetch via Sentinel, either `:master` or `:slave`
+  # @option options [Array<String, Hash{Symbol => String, Integer}>] :cluster List of cluster nodes to contact
+  # @option options [Boolean] :replica Whether to use readonly replica nodes in Redis Cluster or not
+  # @option options [Class] :connector Class of custom connector
+  #
+  # @return [Redis] a new client instance
+  def initialize: (?url: String,
+                   ?scheme: String,
+                   ?host: String,
+                   ?port: Integer,
+                   ?db: Integer,
+                   ?path: String,
+                   ?sentinels: Array[sentinel],
+                   ?role: :master | :slave,
+                   ?cluster: Array[node],
+                   ?repliace: boolish,
+                   ?timeout: time,
+                   ?connect_timeout: time,
+                   ?read_timeout: time,
+                   ?write_timeout: time,
+                   ?reconnect_attempts: Integer,
+                   ?reconnect_delay: Float,
+                   ?reconnect_delay_max: Float,
+                   ?password: String,
+                   ?driver: Symbol,
+                   ?inherit_socket: boolish,
+                   ?ssl_params: Hash[Symbol, untyped]) -> void
+
+  # Set the string value of a key.
+  #
+  # @param [String] key
+  # @param [String] value
+  # @param [Hash] options
+  #   - `:ex => Integer`: Set the specified expire time, in seconds.
+  #   - `:px => Integer`: Set the specified expire time, in milliseconds.
+  #   - `:nx => true`: Only set the key if it does not already exist.
+  #   - `:xx => true`: Only set the key if it already exist.
+  #   - `:keepttl => true`: Retain the time to live associated with the key.
+  # @return [String, Boolean] `"OK"` or true, false if `:nx => true` or `:xx => true`
+  def set: ((String | Symbol) key, top value, ?ex: Integer?, ?px: Integer?, ?nx: boolish, ?xx: boolish, ?keepttl: boolish) -> (String | bool)
+
+  # Set the time to live in seconds of a key.
+  #
+  # @param [String] key
+  # @param [Integer] ttl
+  # @param [String] value
+  # @return [String] `"OK"`
+  def setex: (String key, Integer ttl, String value) -> String
+
+  # Get the value of a key.
+  #
+  # @param [String] key
+  # @return [String]
+  def get: ((String | Symbol) key) -> String?
+
+  # Delete one or more keys.
+  #
+  # @param [String, Array<String>] keys
+  # @return [Integer] number of keys that were deleted
+  def del: (*(String | Array[String]) keys) -> Integer
+
+  # Set one or more values.
+  #
+  # @example
+  #   redis.mset("key1", "v1", "key2", "v2")
+  #     # => "OK"
+  #
+  # @param [Array<String>] args array of keys and values
+  # @return [String] `"OK"`
+  #
+  # @see #mapped_mset
+  def mset: (*String args) -> String
+
+  # Get the values of all the given keys.
+  #
+  # @example
+  #   redis.mget("key1", "key2")
+  #     # => ["v1", "v2"]
+  #
+  # @param [Array<String>] keys
+  # @return [Array<String>] an array of values for the specified keys
+  #
+  # @see #mapped_mget
+  def mget: (*String keys) -> Array[String?]
+          | [T] (*String keys) { (Array[String?]) -> T } -> T
+
+  # Decrement the integer value of a key by one.
+  #
+  # @example
+  #   redis.decr("value")
+  #     # => 4
+  #
+  # @param [String] key
+  # @return [Integer] value after decrementing it
+  def decr: (String key) -> Integer
+
+  # Decrement the integer value of a key by the given number.
+  #
+  # @example
+  #   redis.decrby("value", 5)
+  #     # => 0
+  #
+  # @param [String] key
+  # @param [Integer] decrement
+  # @return [Integer] value after decrementing it
+  def decrby: (String key, Integer decrement) -> Integer
+
+  # Increment the integer value of a key by one.
+  #
+  # @example
+  #   redis.incr("value")
+  #     # => 6
+  #
+  # @param [String] key
+  # @return [Integer] value after incrementing it
+  def incr: (String key) -> Integer
+
+  # Increment the integer value of a key by the given integer number.
+  #
+  # @example
+  #   redis.incrby("value", 5)
+  #     # => 10
+  #
+  # @param [String] key
+  # @param [Integer] increment
+  # @return [Integer] value after incrementing it
+  def incrby: (String key, Integer increment) -> Integer
+
+  interface _Pipelined
+    def get: (String key) -> Future[String?]
+
+    def set: (String key, top value, ?ex: Integer?, ?px: Integer?, ?nx: boolish, ?xx: boolish, ?keepttl: boolish) -> Future[String]
+
+    def decr: (String key) -> Future[Integer]
+
+    def decrby: (String key, Integer decrement) -> Future[Integer]
+
+    def incr: (String key) -> Future[Integer]
+
+    def incrby: (String key, Integer increment) -> Future[Integer]
+  end
+
+  def pipelined: () { (self & _Pipelined) -> void } -> Array[String | Integer]
+
+  # Mark the start of a transaction block.
+  #
+  # Passing a block is optional.
+  #
+  # @example With a block
+  #   redis.multi do |multi|
+  #     multi.set("key", "value")
+  #     multi.incr("counter")
+  #   end # => ["OK", 6]
+  #
+  # @example Without a block
+  #   redis.multi
+  #     # => "OK"
+  #   redis.set("key", "value")
+  #     # => "QUEUED"
+  #   redis.incr("counter")
+  #     # => "QUEUED"
+  #   redis.exec
+  #     # => ["OK", 6]
+  #
+  # @yield [multi] the commands that are called inside this block are cached
+  #   and written to the server upon returning from it
+  # @yieldparam [Redis] multi `self`
+  #
+  # @return [String, Array<...>]
+  #   - when a block is not given, `OK`
+  #   - when a block is given, an array with replies
+  #
+  # @see #watch
+  # @see #unwatch
+  def multi: () -> String
+           | () { (self) -> void } -> Array[String | Integer]
+
+  # Ping the server.
+  #
+  # @param [optional, String] message
+  # @return [String] `PONG`
+  def ping: (?String? message) -> String
+
+  def zcard: (_ToS key) -> Integer
+  def zadd: (_ToS key, *untyped args, ?nx: bool, ?ch: bool, ?incr: bool) -> (bool | Integer | Float)
+          | (_ToS key, *untyped args, ?xx: bool, ?ch: bool, ?incr: bool) -> (bool | Integer | Float)
+  def zincrby: (_ToS key, Integer | Float | "-inf" | "+inf" increment, String member) -> Float
+  def zrem: (_ToS key, String | Array[String] member) -> (bool | Integer)
+
+  # Disconnect the client as quickly and silently as possible.
+  def close: () -> void
+
+  alias disconnect! close
+
+  # Set a key's time to live in seconds.
+  #
+  # @param [String] key
+  # @param [Integer] seconds time to live
+  # @return [Boolean] whether the timeout was set or not
+  def expire: (String key, Integer seconds) -> bool
+
+  # Evaluate Lua script by its SHA.
+  #
+  # @example EVALSHA without KEYS nor ARGV
+  #   redis.evalsha(sha)
+  #     # => <depends on script>
+  # @example EVALSHA with KEYS and ARGV as array arguments
+  #   redis.evalsha(sha, ["k1", "k2"], ["a1", "a2"])
+  #     # => <depends on script>
+  # @example EVALSHA with KEYS and ARGV in a hash argument
+  #   redis.evalsha(sha, :keys => ["k1", "k2"], :argv => ["a1", "a2"])
+  #     # => <depends on script>
+  #
+  # @param [Array<String>] keys optional array with keys to pass to the script
+  # @param [Array<String>] argv optional array with arguments to pass to the script
+  # @param [Hash] options
+  #   - `:keys => Array<String>`: optional array with keys to pass to the script
+  #   - `:argv => Array<String>`: optional array with arguments to pass to the script
+  # @return depends on the script
+  #
+  # @see #script
+  # @see #eval
+  def evalsha: (String, ?Array[String], ?Array[String], ?keys: Array[String], ?argv: Array[String]) -> untyped
+
+  # Control remote script registry.
+  #
+  # @example Load a script
+  #   sha = redis.script(:load, "return 1")
+  #     # => <sha of this script>
+  # @example Check if a script exists
+  #   redis.script(:exists, sha)
+  #     # => true
+  # @example Check if multiple scripts exist
+  #   redis.script(:exists, [sha, other_sha])
+  #     # => [true, false]
+  # @example Flush the script registry
+  #   redis.script(:flush)
+  #     # => "OK"
+  # @example Kill a running script
+  #   redis.script(:kill)
+  #     # => "OK"
+  #
+  # @param [String] subcommand e.g. `exists`, `flush`, `load`, `kill`
+  # @param [Array<String>] args depends on subcommand
+  # @return [String, Boolean, Array<Boolean>, ...] depends on subcommand
+  #
+  # @see #eval
+  # @see #evalsha
+  def script: (Symbol, *untyped) -> untyped
+
+  def with: [T] () { (self) -> T } -> T
+
+  def hdel: (arg key, *arg fields) -> Integer
+          | (arg key, Array[arg]) -> Integer
+  def hexists: (arg key, arg field) -> bool
+  def hget: (arg key, arg field) -> String?
+  def hgetall: (arg key) -> Hash[String, String?]
+  def hincrby: (arg key, arg field, _ToI | _ToInt increment) -> Integer
+  def hincrbyfloat: (arg key, arg field, _ToF increment) -> Float
+  def hkeys: (arg key) -> Array[String]
+  def hlen: (arg key) -> Integer
+
+  def hmget: (arg key, arg field1) -> [String?]
+           | (arg key, [arg]) -> [String?]
+           | (arg key, arg field1, arg field2) -> [String?, String?]
+           | (arg key, [arg, arg]) -> [String?, String?]
+           | (arg key, arg field1, arg field2, arg field3) -> [String?, String?, String?]
+           | (arg key, [arg, arg, arg]) -> [String?, String?, String?]
+           | (arg key, arg field1, arg field2, arg field3, arg field4) -> [String?, String?, String?, String?]
+           | (arg key, [arg, arg, arg, arg]) -> [String?, String?, String?, String?]
+           | (arg key, arg field1, arg field2, arg field3, arg field4, arg field5) -> [String?, String?, String?, String?, String?]
+           | (arg key, [arg, arg, arg, arg, arg]) -> [String?, String?, String?, String?, String?]
+           | (arg key, arg field1, arg field2, arg field3, arg field4, arg field5, arg field6) -> [String?, String?, String?, String?, String?, String?]
+           | (arg key, [arg, arg, arg, arg, arg, arg]) -> [String?, String?, String?, String?, String?, String?]
+           | (arg key, arg field1, arg field2, arg field3, arg field4, arg field5, arg field6, arg field7) -> [String?, String?, String?, String?, String?, String?, String?]
+           | (arg key, [arg, arg, arg, arg, arg, arg, arg]) -> [String?, String?, String?, String?, String?, String?, String?]
+           | (arg key, *arg) -> Array[String?]
+           | (arg key, Array[arg]) -> Array[String?]
+
+  def hmset: (arg key, arg field1, arg value1) -> "OK"
+           | (arg key, [arg, arg]) -> "OK"
+           | (arg key, arg field1, arg value1, arg field2, arg value2) -> "OK"
+           | (arg key, [arg, arg, arg, arg]) -> "OK"
+           | (arg key, arg field1, arg value1, arg field2, arg value2, arg field3, arg value3) -> "OK"
+           | (arg key, [arg, arg, arg, arg, arg, arg]) -> "OK"
+           | (arg key, arg field1, arg value1, arg field2, arg value2, arg field3, arg value3, arg field4, arg value4) -> "OK"
+           | (arg key, [arg, arg, arg, arg, arg, arg, arg, arg]) -> "OK"
+           | (arg key, arg field1, arg value1, arg field2, arg value2, arg field3, arg value3, arg field4, arg value4, arg field5, arg value5) -> "OK"
+           | (arg key, [arg, arg, arg, arg, arg, arg, arg, arg, arg, arg]) -> "OK"
+           | (arg key, arg field1, arg value1, arg field2, arg value2, arg field3, arg value3, arg field4, arg value4, arg field5, arg value5, arg field6, arg value6) -> "OK"
+           | (arg key, [arg, arg, arg, arg, arg, arg, arg, arg, arg, arg, arg, arg]) -> "OK"
+           | (arg key, arg field1, arg value1, arg field2, arg value2, arg field3, arg value3, arg field4, arg value4, arg field5, arg value5, arg field6, arg value6, *arg) -> "OK"
+           | (arg key, Array[arg]) -> "OK"
+           | (arg key, Hash[arg, arg]) -> "OK"
+
+  def hrandfield: (arg key) -> String?
+                | (arg key, Integer count) -> Array[String]
+                | (arg key, Integer count, with_values: false) -> Array[String]
+                | (arg key, Integer count, with_values: true) -> Array[[String, String]]
+
+  def hset: (arg key, arg field1, arg value1) -> Integer
+          | (arg key, arg field1, arg value1, arg field2, arg value2) -> Integer
+          | (arg key, arg field1, arg value1, arg field2, arg value2, arg field3, arg value3) -> Integer
+          | (arg key, arg field1, arg value1, arg field2, arg value2, arg field3, arg value3, arg field4, arg value4) -> Integer
+          | (arg key, arg field1, arg value1, arg field2, arg value2, arg field3, arg value3, arg field4, arg value4, arg field5, arg value5) -> Integer
+          | (arg key, arg field1, arg value1, arg field2, arg value2, arg field3, arg value3, arg field4, arg value4, arg field5, arg value5, arg field6, arg value6) -> Integer
+          | (arg key, arg field1, arg value1, arg field2, arg value2, arg field3, arg value3, arg field4, arg value4, arg field5, arg value5, arg field6, arg value6, *arg) -> Integer
+          | (arg key, Hash[arg, arg]) -> Integer
+
+  def hsetnx: (arg key, arg field, arg value) -> bool
+
+  def hvals: (arg key) -> Array[String]
+
+  def mapped_hmget: (arg key, *arg keys) -> Hash[String, String?]
+                  | (arg key, Array[arg] keys) -> Hash[String, String?]
+
+  def mapped_hmset: (arg key, Hash[arg, arg]) -> "OK"
+end

data/data/vendored_gem_sigs/redis/redis_extras.rbs

@@ -0,0 +1,130 @@
+# Rigor-side patches on top of the gem_rbs_collection's
+# redis/4.2/ surface to cover common methods the vendored 4.2
+# snapshot lacks. Real-world Rails projects (Discourse / Forem /
+# Canvas) call these from cache layers and Sidekiq integration.
+#
+# Source: hand-written by Rigor maintainers.
+# License: MPL-2.0 (matches the rest of Rigor).
+#
+# Add new entries when a project flags `call.undefined-method`
+# for a Redis instance method that should exist.
+
+class Redis
+  # Generic key operations.
+  def exists: (*arg keys) -> Integer
+  def exists?: (*arg keys) -> bool
+  def keys: (?String pattern) -> Array[String]
+  def type: (arg key) -> String
+  def ttl: (arg key) -> Integer
+  def pttl: (arg key) -> Integer
+  def expireat: (arg key, Integer unix_time) -> bool
+  def pexpire: (arg key, Integer milliseconds) -> bool
+  def pexpireat: (arg key, Integer unix_time_ms) -> bool
+  def persist: (arg key) -> bool
+  def rename: (arg from, arg to) -> String
+  def renamex: (arg from, arg to) -> bool
+  def renamenx: (arg from, arg to) -> bool
+  def randomkey: () -> String?
+  def touch: (*arg keys) -> Integer
+  def unlink: (*arg keys) -> Integer
+  def dump: (arg key) -> String?
+  def restore: (arg key, Integer ttl, String serialized, **untyped) -> String
+
+  # Cursor scans.
+  def scan: (?Integer cursor, ?match: String, ?count: Integer, ?type: String) -> [String, Array[String]]
+  def scan_each: (?match: String, ?count: Integer, ?type: String) { (String) -> void } -> self
+              | (?match: String, ?count: Integer, ?type: String) -> Enumerator[String, self]
+  def sscan: (arg key, ?Integer cursor, ?match: String, ?count: Integer) -> [String, Array[String]]
+  def sscan_each: (arg key, ?match: String, ?count: Integer) { (String) -> void } -> self
+              | (arg key, ?match: String, ?count: Integer) -> Enumerator[String, self]
+  def hscan: (arg key, ?Integer cursor, ?match: String, ?count: Integer) -> [String, Array[[String, String]]]
+  def hscan_each: (arg key, ?match: String, ?count: Integer) { ([String, String]) -> void } -> self
+              | (arg key, ?match: String, ?count: Integer) -> Enumerator[[String, String], self]
+  def zscan: (arg key, ?Integer cursor, ?match: String, ?count: Integer) -> [String, Array[[String, Float]]]
+
+  # String / counter / set operations the curated 4.2 snapshot
+  # didn't cover (real-world projects call them).
+  def append: (arg key, String value) -> Integer
+  def getset: (arg key, String value) -> String?
+  def strlen: (arg key) -> Integer
+  def getrange: (arg key, Integer start, Integer stop) -> String
+  def setrange: (arg key, Integer offset, String value) -> Integer
+  def bitcount: (arg key, ?Integer start, ?Integer stop) -> Integer
+  def bitop: (String operation, arg destkey, *arg keys) -> Integer
+
+  # Lists.
+  def lpush: (arg key, *untyped values) -> Integer
+  def rpush: (arg key, *untyped values) -> Integer
+  def lpop: (arg key, ?Integer count) -> (String | Array[String] | nil)
+  def rpop: (arg key, ?Integer count) -> (String | Array[String] | nil)
+  def lrange: (arg key, Integer start, Integer stop) -> Array[String]
+  def llen: (arg key) -> Integer
+  def lindex: (arg key, Integer index) -> String?
+  def lrem: (arg key, Integer count, untyped value) -> Integer
+  def ltrim: (arg key, Integer start, Integer stop) -> String
+  def lset: (arg key, Integer index, untyped value) -> String
+  def blpop: (*untyped, ?timeout: Numeric) -> [String, String]?
+  def brpop: (*untyped, ?timeout: Numeric) -> [String, String]?
+
+  # Sets.
+  def sadd: (arg key, *untyped members) -> Integer
+  def srem: (arg key, *untyped members) -> Integer
+  def smembers: (arg key) -> Array[String]
+  def scard: (arg key) -> Integer
+  def sismember: (arg key, untyped member) -> bool
+  def sinter: (*arg keys) -> Array[String]
+  def sunion: (*arg keys) -> Array[String]
+  def sdiff: (*arg keys) -> Array[String]
+  def spop: (arg key, ?Integer count) -> (String | Array[String] | nil)
+  def srandmember: (arg key, ?Integer count) -> (String | Array[String] | nil)
+
+  # Sorted sets the curated snapshot only partially covered.
+  def zrange: (arg key, Integer start, Integer stop, ?withscores: bool, ?rev: bool, ?limit: Array[Integer]) -> (Array[String] | Array[[String, Float]])
+  def zrangebyscore: (arg key, untyped min, untyped max, ?withscores: bool, ?limit: Array[Integer]) -> (Array[String] | Array[[String, Float]])
+  def zrevrange: (arg key, Integer start, Integer stop, ?withscores: bool) -> (Array[String] | Array[[String, Float]])
+  def zrevrangebyscore: (arg key, untyped max, untyped min, ?withscores: bool, ?limit: Array[Integer]) -> (Array[String] | Array[[String, Float]])
+  def zscore: (arg key, String member) -> Float?
+  def zrank: (arg key, String member) -> Integer?
+  def zrevrank: (arg key, String member) -> Integer?
+  def zcount: (arg key, untyped min, untyped max) -> Integer
+  def zpopmin: (arg key, ?Integer count) -> (Array[[String, Float]] | [String, Float] | nil)
+  def zpopmax: (arg key, ?Integer count) -> (Array[[String, Float]] | [String, Float] | nil)
+
+  # Pub/Sub.
+  def publish: (String channel, String message) -> Integer
+  def subscribe: (*String channels) { (untyped) -> void } -> void
+  def unsubscribe: (*String channels) -> void
+  def psubscribe: (*String patterns) { (untyped) -> void } -> void
+  def punsubscribe: (*String patterns) -> void
+
+  # Server / connection.
+  def info: (?String section) -> Hash[String, String]
+  def dbsize: () -> Integer
+  def flushdb: () -> String
+  def flushall: () -> String
+  def select: (Integer db) -> String
+  def auth: (String password) -> String
+  def wait: (Integer numreplicas, Integer timeout) -> Integer
+  def time: () -> [String, String]
+  def lastsave: () -> Integer
+  def echo: (String value) -> String
+  def shutdown: (?String save_mode) -> nil
+  def client: (String command, *untyped) -> untyped
+
+  # Scripting.
+  def eval: (String script, ?Array[String] keys, ?Array[String] argv, ?keys: Array[String], ?argv: Array[String]) -> untyped
+end
+
+# Redis::Cluster - used by gitlab / canvas.
+class Redis::Cluster
+  def _client: () -> untyped
+end
+
+# Redis singleton class methods.
+class Redis
+  def self.patch: (*untyped) -> untyped
+  def self.exists_returns_integer: () -> bool
+  def self.exists_returns_integer=: (bool) -> bool
+  def self.current: () -> Redis
+  def self.current=: (Redis) -> Redis
+end