e621stream 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b16a81259148bd2d44ea56a857d2aeefbf15029660f8bd79d219198e3231711e
+  data.tar.gz: d24d99e59eb909cbf80f39108c9d90835022f2d886b4f89060245e8c6ceb86c7
+SHA512:
+  metadata.gz: d8b860f937490e74e90af663866c043b9923321ef85a6d2a84a7a8ba57571605079c71fcaf9153f28343262583647ceb1bd4b3c659cb1aa0346e8d2581c1cd47
+  data.tar.gz: aa52fe6a7af0ac4f3bf7e0adff246b800b16b8350a12ea27feb55c4d389c06bdacd54e17c03e62f84d11bc40cbb7c2d49b5b1b62dd9df16b894b5e82fcabd83c

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) undefined Donovan_DMC
+
+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,35 @@
+# e621stream
+
+A Ruby client for [E621Stream](https://e621.stream), a live WebSocket stream of e621 activity. It's built on [async-websocket](https://github.com/socketry/async-websocket) and typed with Sorbet.
+
+```bash
+gem install e621stream
+```
+
+```ruby
+require "e621stream"
+
+client = E621Stream::Client.new(
+  username:      "your_name",
+  api_key:       "your e621 api key",
+  subscriptions: ["post.create", { "type" => "post.update", "filter" => { "tags" => "fox -solo" } }, "comment.*"],
+)
+
+client.on("post.create") { |event| puts(event.data["post"]["id"]) }
+client.on("post.update") { |event| p(event.data["changes"]) }
+client.on(:error) { |error| warn(error.message) }
+
+client.run
+```
+
+- **Events:** `on("<event type>")` for one type, or `on(:dispatch)` for everything. Each is an `E621Stream::Event` with `id`, `type`, `time` and `data`, which is the record as e621's api returns it. See [Events](https://e621.stream/events/) for what each one is.
+- **Running:** `run` blocks. Inside a reactor already, it runs as a task, so `client.close` from another task stops it.
+- **Reconnecting:** the connection is reopened with backoff when it drops, and resumes from the last event it got. It isn't reopened after a close retrying won't fix, like bad credentials. `reconnect: false` turns it off.
+- **Resuming:** pass `cursor:` (an event id, or a millisecond timestamp) to replay from there. `client.cursor` is the last event received.
+- **Changing subscriptions:** `client.subscribe([...])`.
+- **Private events:** like `dmail.create`, these are polled with your own credentials and have to be subscribed to by name.
+- **Other events:** `:ready`, `:replay_complete`, `:subscribed`, `:reconnecting`, `:close` and `:error`.
+
+```bash
+bundle exec rake    # rubocop, zeitwerk, tests and sorbet
+```

data/lib/e621stream/client/options.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# typed: strict
+
+module E621Stream
+  class Client
+    class Options < T::Struct
+      const(:subscriptions, T::Array[Subscription])
+      # Your e621 username and an api key, from Account > Manage API Access.
+      const(:username, T.nilable(String), default: nil)
+      const(:api_key, T.nilable(String), default: nil)
+      const(:url, String, default: "wss://e621.stream/ws")
+      # A name for your client, shown in the server's logs.
+      const(:client, T.nilable(String), default: nil)
+      # An event id (or a millisecond timestamp) to replay from. After that, reconnecting resumes from the last event.
+      const(:cursor, T.nilable(T.any(String, Integer)), default: nil)
+      # Reconnects with backoff when the connection drops, unless the server closed it for something retrying won't fix.
+      const(:reconnect, T::Boolean, default: true)
+    end
+  end
+end

data/lib/e621stream/client.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+# typed: strict
+
+require("async")
+require("async/http/endpoint")
+require("async/websocket/client")
+
+module E621Stream
+  # A connection to E621Stream. Listeners run inside the client's reactor, between reading messages.
+  #
+  #   client = E621Stream::Client.new(username: "...", api_key: "...", subscriptions: ["post.create"])
+  #   client.on("post.create") { |event| puts(event.data["post"]["id"]) }
+  #   client.run
+  class Client
+    extend(T::Sig)
+
+    Listener = T.type_alias { T.proc.params(arg0: T.untyped).void }
+    # An event type, `<resource>.*`, `*`, or `{ "type" => ..., "filter" => { ... } }`.
+    Subscription = T.type_alias { T.any(String, T::Hash[T.any(String, Symbol), T.untyped]) }
+
+    # Opens the real connection, tests swap it for a fake one.
+    class Connector
+      extend(T::Sig)
+
+      sig { params(url: String, block: T.proc.params(connection: T.untyped).void).void }
+      def connect(url, &block)
+        endpoint = Async::HTTP::Endpoint.parse(url, alpn_protocols: Async::HTTP::Protocol::HTTP11.names)
+        Async::WebSocket::Client.connect(endpoint, &block)
+      end
+    end
+
+    HEARTBEAT_SECONDS = 30
+    # The server answers heartbeats and pings, nothing for this long means the connection is gone without having closed.
+    SILENT_SECONDS = 75
+    MAX_DELAY_SECONDS = 60
+
+    sig { returns(Options) }
+    attr_reader(:options)
+
+    # The newest event received, which reconnecting resumes from.
+    sig { returns(T.nilable(String)) }
+    attr_reader(:cursor)
+
+    sig do
+      params(
+        subscriptions: T::Array[Subscription],
+        username:      T.nilable(String),
+        api_key:       T.nilable(String),
+        url:           String,
+        client:        T.nilable(String),
+        cursor:        T.nilable(T.any(String, Integer)),
+        reconnect:     T::Boolean,
+        connector:     Connector,
+      ).void
+    end
+    def initialize(subscriptions:, username: nil, api_key: nil, url: "wss://e621.stream/ws", client: nil, cursor: nil, reconnect: true, connector: Connector.new)
+      @options = T.let(Options.new(subscriptions: subscriptions, username: username, api_key: api_key, url: url, client: client, cursor: cursor, reconnect: reconnect), Options)
+      @connector = connector
+      @cursor = T.let(cursor&.to_s, T.nilable(String))
+      @listeners = T.let(Hash.new { |hash, key| hash[key] = [] }, T::Hash[String, T::Array[Listener]])
+      @connection = T.let(nil, T.untyped)
+      @closing = T.let(false, T::Boolean)
+      @attempt = T.let(0, Integer)
+      @last_message = T.let(0.0, Float)
+      @last_error = T.let(nil, T.nilable(StreamError))
+    end
+
+    # Listens for an event type (like "post.create"), or one of :dispatch (every event), :ready, :replay_complete,
+    # :subscribed, :error, :close and :reconnecting.
+    sig { params(name: T.any(String, Symbol), block: Listener).returns(T.self_type) }
+    def on(name, &block)
+      T.must(@listeners[name.to_s]) << block
+      self
+    end
+
+    # Connects and keeps the connection going until #close is called, or the server closes it for something
+    # reconnecting won't fix. Blocks, or runs as a task when called inside a reactor already.
+    sig { void }
+    def run
+      @closing = false
+      Sync do
+        loop do
+          code, reason = connect_once
+          error = @last_error
+          @last_error = nil
+          reconnecting = !closing? && options.reconnect && !CloseCodes::FATAL.include?(code)
+          emit("error", error) if error
+          emit("close", { code: code, reason: error&.message || reason, reconnecting: reconnecting })
+          break unless reconnecting
+
+          @attempt += 1
+          # a server that's rate limiting this connection wants a longer break
+          base = code == CloseCodes::RATE_LIMITED ? 30 : 1
+          delay = [base * (2**(@attempt - 1)), MAX_DELAY_SECONDS].min * rand(0.75..1.25)
+          emit("reconnecting", { attempt: @attempt, delay: delay })
+          sleep(delay)
+        end
+      end
+    end
+
+    # Replaces the current subscriptions, and keeps them for reconnecting.
+    sig { params(subscriptions: T::Array[Subscription]).void }
+    def subscribe(subscriptions)
+      @options = Options.new(**options.serialize.transform_keys(&:to_sym), subscriptions: subscriptions)
+      send_message({ op: "subscribe", d: { subscriptions: subscriptions } })
+    end
+
+    # Closes the connection for good.
+    sig { void }
+    def close
+      @closing = true
+      @connection&.close(1000, "closed by client")
+    end
+
+    private
+
+    # resolves to the close code and reason
+    sig { returns([Integer, String]) }
+    def connect_once
+      result = T.let([1000, ""], [Integer, String])
+      @connector.connect(options.url) do |connection|
+        @connection = connection
+        @last_message = now
+        heartbeat = Async { heartbeat_loop(connection) }
+        begin
+          while (message = connection.read)
+            @last_message = now
+            handle(JSON.parse(message.buffer))
+          end
+        ensure
+          heartbeat.stop
+          @connection = nil
+        end
+      end
+      result
+    rescue Protocol::WebSocket::ClosedError => e
+      [e.code || 1006, e.message]
+    rescue StandardError => e
+      # closing tears the connection down under the read, which isn't worth reporting
+      return [1000, "closed by client"] if closing?
+
+      emit("error", e)
+      [1006, e.message]
+    end
+
+    sig { params(connection: T.untyped).void }
+    def heartbeat_loop(connection)
+      loop do
+        sleep(HEARTBEAT_SECONDS)
+        if now - @last_message > SILENT_SECONDS
+          connection.close(4999, "no response from the server")
+          break
+        end
+        send_message({ op: "heartbeat" })
+      end
+    end
+
+    sig { params(message: T::Hash[String, T.untyped]).void }
+    def handle(message)
+      data = message["d"]
+      case message["op"]
+      when "hello"
+        identify = { subscriptions: options.subscriptions }
+        identify[:auth] = { username: options.username, api_key: options.api_key } if options.username && options.api_key
+        identify[:client] = options.client if options.client
+        identify[:cursor] = @cursor if @cursor
+        send_message({ op: "identify", d: identify })
+      when "ready"
+        @attempt = 0
+        emit("ready", data)
+      when "dispatch"
+        event = Event.new(id: message["id"], type: message["type"], time: message["time"], data: message["data"], private: message["private"] == true)
+        # private events aren't in the stream, so they can't be resumed from
+        @cursor = event.id unless event.private?
+        emit("dispatch", event)
+        emit(event.type, event)
+      when "replay_complete"
+        emit("replay_complete", data)
+      when "subscribed"
+        emit("subscribed", data["subscriptions"])
+      when "error"
+        @last_error = StreamError.new(data["code"], data["message"])
+      end
+    end
+
+    sig { params(payload: T::Hash[Symbol, T.untyped]).void }
+    def send_message(payload)
+      connection = @connection
+      return unless connection
+
+      connection.write(Protocol::WebSocket::TextMessage.generate(payload))
+      connection.flush
+    end
+
+    sig { params(name: String, value: T.untyped).void }
+    def emit(name, value)
+      @listeners[name]&.each { |listener| listener.call(value) }
+    end
+
+    # read through a method, since #close changes it from another fiber while #run is waiting
+    sig { returns(T::Boolean) }
+    def closing?
+      @closing
+    end
+
+    sig { returns(Float) }
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC).to_f
+    end
+  end
+end

data/lib/e621stream/close_codes.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+# typed: strict
+
+module E621Stream
+  # Why the server closed the connection, see https://e621.stream/close-codes/
+  module CloseCodes
+    UNKNOWN_ERROR = 4000
+    UNKNOWN_OP = 4001
+    DECODE_ERROR = 4002
+    NOT_IDENTIFIED = 4003
+    AUTHENTICATION_FAILED = 4004
+    ALREADY_IDENTIFIED = 4005
+    INVALID_SUBSCRIPTION = 4006
+    INVALID_CURSOR = 4007
+    RATE_LIMITED = 4008
+    SLOW_CONSUMER = 4009
+    TOO_MANY_CONNECTIONS = 4010
+    AUTHENTICATION_EXPIRED = 4011
+
+    # Closing for any of these again would just get the same result, so they aren't reconnected from.
+    FATAL = T.let([UNKNOWN_OP, DECODE_ERROR, AUTHENTICATION_FAILED, ALREADY_IDENTIFIED, INVALID_SUBSCRIPTION, INVALID_CURSOR, AUTHENTICATION_EXPIRED].freeze, T::Array[Integer])
+  end
+end

data/lib/e621stream/event.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+# typed: strict
+
+module E621Stream
+  # One event from the stream. `data` is the record as e621's api returns it, or for update events
+  # `{ "<resource>" => record, "changes" => ... }`, see https://e621.stream/events/
+  class Event < T::Struct
+    extend(T::Sig)
+
+    # The event's cursor, pass it as `cursor:` to resume after it. Private events have no cursor.
+    const(:id, String)
+    const(:type, String)
+    # When it happened on e621.
+    const(:time, String)
+    const(:data, T::Hash[String, T.untyped])
+    # Only for private events, which are polled with your own credentials and never stored.
+    const(:private, T::Boolean, default: false)
+
+    sig { returns(T::Boolean) }
+    def private?
+      private
+    end
+  end
+end

data/lib/e621stream/events.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# typed: strict
+
+module E621Stream
+  module Events
+    # Kept identical to the server's src/events.ts, the repository's tests check it.
+    EVENT_TYPES = %w[
+      artist.create artist.delete artist.update artist_url.create artist_version.create avoid_posting.create
+      avoid_posting.delete avoid_posting.destroy avoid_posting.undelete avoid_posting.update
+      avoid_posting_version.create ban.create ban.delete ban.update blip.create bulk_update_request.create
+      bulk_update_request.update comment.create comment.delete comment.hide comment.unhide comment.update
+      forum_post.create forum_post.delete forum_post.hide forum_post.unhide forum_post.update forum_topic.create
+      forum_topic.delete forum_topic.hide forum_topic.unhide forum_topic.update help_page.create help_page.update
+      mod_action.create news_update.create news_update.update note.create note.update note_version.create
+      pool.add_posts pool.create pool.delete pool.remove_posts pool.update pool_version.create post.create post.update
+      post_approval.create post_event.create post_flag.create post_flag.update post_replacement.create
+      post_set.add_posts post_set.create post_set.delete post_set.remove_posts post_set.update post_version.create
+      post_version.hide post_version.unhide tag.create tag.delete tag.update tag_alias.create tag_alias.update
+      tag_implication.create tag_implication.update tag_type_version.create takedown.create takedown.delete
+      takedown.update upload_karma_event.create user.create user.delete user.update user_feedback.create
+      user_feedback.delete user_feedback.destroy user_feedback.undelete user_feedback.update wiki_page.create
+      wiki_page.delete wiki_page.update wiki_page_version.create
+    ].freeze
+
+    # Polled with your own credentials and only sent to you. They have to be subscribed to by name, `*` doesn't include
+    # them.
+    PRIVATE_EVENT_TYPES = %w[dmail.create].freeze
+  end
+end

data/lib/e621stream/stream_error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+# typed: strict
+
+module E621Stream
+  # Sent by the server right before it closes the connection, `code` is one of CloseCodes.
+  class StreamError < StandardError
+    extend(T::Sig)
+
+    sig { returns(Integer) }
+    attr_reader(:code)
+
+    sig { params(code: Integer, message: String).void }
+    def initialize(code, message)
+      super(message)
+      @code = code
+    end
+  end
+end

data/lib/e621stream/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module E621Stream
+  VERSION = "0.0.0"
+end

data/lib/e621stream.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require("json")
+require("zeitwerk")
+require("sorbet-runtime")
+
+# Loaded eagerly (rather than left to Zeitwerk) because the gemspec already requires version.rb to read the version,
+# which defines E621Stream before Zeitwerk::Loader#setup runs.
+require_relative("e621stream/version")
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect({ "e621stream" => "E621Stream" })
+loader.ignore("#{__dir__}/e621stream/version.rb")
+loader.setup
+
+# A client for E621Stream, a live WebSocket stream of e621 activity. See https://e621.stream
+module E621Stream
+end

data/sorbet/config

@@ -0,0 +1,6 @@
+--dir
+.
+--ignore=test/
+--ignore=tmp/
+--ignore=vendor/
+--parser=prism

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true

data/sorbet/rbi/annotations/minitest.rbi

@@ -0,0 +1,120 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Minitest::Assertions
+  sig { params(test: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert(test, msg = nil); end
+
+  sig { params(obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_empty(obj, msg = nil); end
+
+  sig { params(exp: T.anything, act: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_equal(exp, act, msg = nil); end
+
+  sig { params(exp: T.anything, act: T.anything, delta: Numeric, msg: T.anything).returns(TrueClass) }
+  def assert_in_delta(exp, act, delta = T.unsafe(nil), msg = nil); end
+
+  sig { params(a: T.anything, b: T.anything, epsilon: Numeric, msg: T.anything).returns(TrueClass) }
+  def assert_in_epsilon(a, b, epsilon = T.unsafe(nil), msg = nil); end
+
+  sig { params(collection: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_includes(collection, obj, msg = nil); end
+
+  sig { params(cls: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_instance_of(cls, obj, msg = nil); end
+
+  sig { params(cls: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_kind_of(cls, obj, msg = nil); end
+
+  sig { params(matcher: T.any(String, Regexp), obj: T.anything, msg: T.anything).returns(MatchData) }
+  def assert_match(matcher, obj, msg = nil); end
+
+  sig { params(obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_nil(obj, msg = nil); end
+
+  sig { params(o1: T.anything, op: T.any(Symbol, String), o2: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_operator(o1, op, o2 = T.unsafe(nil), msg = nil); end
+
+  sig { params(stdout: T.nilable(T.any(String, Regexp)), stderr: T.nilable(T.any(String, Regexp)), block: T.proc.void).returns(T::Boolean) }
+  def assert_output(stdout = nil, stderr = nil, &block); end
+
+  sig { params(path: T.any(String, Pathname), msg: T.anything).returns(TrueClass) }
+  def assert_path_exists(path, msg = nil); end
+
+  sig { params(block: T.proc.void).returns(TrueClass) }
+  def assert_pattern(&block); end
+
+  sig { params(o1: T.anything, op: T.any(String, Symbol), msg: T.anything).returns(TrueClass) }
+  def assert_predicate(o1, op, msg = nil); end
+
+  sig { params(exp: NilClass, block: T.proc.void).returns(StandardError) }
+  sig { type_parameters(:T).params(exp: T.any(T::Class[T.type_parameter(:T)], Regexp, String), block: T.proc.void).returns(T.type_parameter(:T)) }
+  def assert_raises(*exp, &block); end
+
+  sig { params(obj: T.anything, meth: T.any(String, Symbol), msg: T.anything, include_all: T::Boolean).returns(TrueClass) }
+  def assert_respond_to(obj, meth, msg = nil, include_all: false); end
+
+  sig { params(exp: T.anything, act: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_same(exp, act, msg = nil); end
+
+  # @version < 6.0.0
+  sig { params(send_ary: T::Array[T.anything], m: T.anything).returns(T::Boolean) }
+  def assert_send(send_ary, m = nil); end
+
+  sig { params(block: T.proc.void).returns(T::Boolean) }
+  def assert_silent(&block); end
+
+  sig { params(sym: Symbol, msg: T.anything, block: T.proc.void).returns(T.anything) }
+  def assert_throws(sym, msg = nil, &block); end
+
+  sig { params(test: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute(test, msg = nil); end
+
+  sig { params(obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_empty(obj, msg = nil); end
+
+  sig { params(exp: T.anything, act: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_equal(exp, act, msg = nil); end
+
+  sig { params(exp: T.anything, act: T.anything, delta: Numeric, msg: T.anything).returns(TrueClass) }
+  def refute_in_delta(exp, act, delta = T.unsafe(nil), msg = nil); end
+
+  sig { params(a: T.anything, b: T.anything, epsilon: Numeric, msg: T.anything).returns(TrueClass) }
+  def refute_in_epsilon(a, b, epsilon = T.unsafe(nil), msg = nil); end
+
+  sig { params(collection: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_includes(collection, obj, msg = nil); end
+
+  sig { params(cls: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_instance_of(cls, obj, msg = nil); end
+
+  sig { params(cls: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_kind_of(cls, obj, msg = nil); end
+
+  sig { params(matcher: T.any(String, Regexp), obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_match(matcher, obj, msg = nil); end
+
+  sig { params(obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_nil(obj, msg = nil); end
+
+  sig { params(block: T.proc.void).returns(TrueClass) }
+  def refute_pattern(&block); end
+
+  sig { params(o1: T.anything, op: T.any(Symbol, String), o2: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_operator(o1, op, o2 = T.unsafe(nil), msg = nil); end
+
+  sig { params(path: T.any(String, Pathname), msg: T.anything).returns(TrueClass) }
+  def refute_path_exists(path, msg = nil); end
+
+  sig { params(o1: T.anything, op: T.any(String, Symbol), msg: T.anything).returns(TrueClass) }
+  def refute_predicate(o1, op, msg = nil); end
+
+  sig { params(obj: T.anything, meth: T.any(String, Symbol), msg: T.anything, include_all: T::Boolean).returns(TrueClass) }
+  def refute_respond_to(obj, meth, msg = nil, include_all: false); end
+
+  sig { params(exp: T.anything, act: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_same(exp, act, msg = nil); end
+end