rigortype 0.1.19 → 0.2.1

data/data/vendored_gem_sigs/ast/ast.rbs

@@ -0,0 +1,130 @@
+# Hand-authored by Rigor maintainers. See LICENSE.upstream.
+#
+# Covers AST::Node, AST::Processor::Mixin, AST::Processor, and
+# AST::Sexp from the `ast` gem (whitequark/ast v2.4.3).
+#
+# Design notes (ADR-5 robustness principle):
+#  - `children` is `Array[untyped]` — AST node children are
+#    heterogeneous (other Nodes, Symbols, Integers, Strings, nils).
+#  - `#==` / `#eql?` accept `untyped` — `#==` calls `to_ast` on the
+#    argument and `#eql?` does a class + field equality check.
+#  - `#updated` returns `AST::Node`, not `instance`, because concrete
+#    subclasses (Parser::AST::Node) override `initialize` via
+#    `original_dup` + `send(:initialize, ...)`, so the return type is
+#    always an instance of `self.class` at runtime — widening to
+#    `AST::Node` is the safe upper bound Rigor can check against.
+#  - `AST::Processor::Mixin#process` returns `AST::Node?` — the method
+#    returns `nil` when given `nil`, and handlers may return `nil` to
+#    preserve the original node (then `process` returns the original).
+
+module AST
+  # Immutable AST node. The type and children are set at construction
+  # and the object is frozen. Subclasses add metadata (e.g. source
+  # location) via `#assign_properties`.
+  class Node
+    # Returns the node type (e.g. `:send`, `:begin`, `:int`).
+    attr_reader type: Symbol
+
+    # Returns the (frozen) children array. Elements are heterogeneous:
+    # either other AST::Node instances or plain Ruby values (Symbol,
+    # Integer, String, nil, …).
+    attr_reader children: Array[untyped]
+
+    # Precomputed hash based on type, children, and class.
+    attr_reader hash: Integer
+
+    # Constructs a new Node. `type` is coerced with `to_sym`;
+    # `children` is coerced with `to_a` and then frozen.
+    def initialize: (untyped type, ?untyped children, ?untyped properties) -> void
+
+    # Equality ignores metadata; only type and children are compared.
+    def ==: (untyped other) -> bool
+
+    # Structural equality (type, children, and class must match).
+    def eql?: (untyped other) -> bool
+
+    # Returns a new Node with non-nil arguments replacing the
+    # corresponding fields. If the result would be identical to self,
+    # returns self unchanged.
+    def updated: (?Symbol? type, ?Array[untyped]? children, ?Hash[Symbol, untyped]? properties) -> AST::Node
+
+    # Concatenates `array` with children and returns a new node.
+    def concat: (Array[untyped] array) -> AST::Node
+
+    # Alias for `concat`.
+    def +: (Array[untyped] array) -> AST::Node
+
+    # Appends `element` to children and returns a new node.
+    def append: (untyped element) -> AST::Node
+
+    # Alias for `append`.
+    def <<: (untyped element) -> AST::Node
+
+    # Alias for `children`.
+    def to_a: () -> Array[untyped]
+
+    # Returns self — nodes are already frozen.
+    def dup: () -> AST::Node
+
+    # Alias for `dup`.
+    def clone: () -> AST::Node
+
+    # Returns self — satisfies the `to_ast` protocol.
+    def to_ast: () -> AST::Node
+
+    # Pretty-printed s-expression string.
+    def to_sexp: (?Integer indent) -> String
+
+    # Alias for `to_sexp`.
+    def to_s: (?Integer indent) -> String
+
+    # Ruby-source s-expression string (uses `s(:type, ...)` notation).
+    def inspect: (?Integer indent) -> String
+
+    # Converts to `[type, *children_as_sexp_arrays]` recursively.
+    def to_sexp_array: () -> Array[untyped]
+
+    # Pattern-match support: `[type, *children]`.
+    def deconstruct: () -> Array[untyped]
+
+    # Assigns entries from `properties` as instance variables.
+    # Protected in Ruby; declared here without visibility for RBS
+    # compatibility (RBS does not support `protected` on class members).
+    def assign_properties: (Hash[Symbol, untyped] properties) -> nil
+
+    # Returns the type with underscores replaced by dashes.
+    def fancy_type: () -> String
+
+    # The original unfrozen `dup` kept for use in `#updated`.
+    private def original_dup: () -> AST::Node
+  end
+
+  # The processor mixin provides a node-dispatch framework. Mix into a
+  # class and define `on_<type>` handlers; unhandled nodes fall through
+  # to `#handler_missing`.
+  module Processor::Mixin
+    # Dispatches `node` to the appropriate `on_<type>` handler.
+    # Returns the handler's return value if non-nil, otherwise the
+    # original `node`. Returns `nil` when `node` is `nil`.
+    def process: (AST::Node? node) -> AST::Node?
+
+    # Processes each node in `nodes` and returns the array of results.
+    def process_all: (Array[AST::Node?] nodes) -> Array[AST::Node?]
+
+    # Default handler for unrecognised node types. Does nothing and
+    # returns `nil`, which causes `#process` to return the node unchanged.
+    def handler_missing: (AST::Node node) -> nil
+  end
+
+  # Deprecated superclass. Prefer `include AST::Processor::Mixin`.
+  class Processor
+    include AST::Processor::Mixin
+  end
+
+  # Mixin providing the `s(type, *children)` shorthand for building
+  # nodes in tests or DSLs.
+  module Sexp
+    # Creates an AST::Node with the given type and children.
+    def s: (Symbol type, *untyped children) -> AST::Node
+  end
+end

data/data/vendored_gem_sigs/bcrypt/bcrypt.rbs

@@ -0,0 +1,47 @@
+module BCrypt
+  class Password < String
+    attr_reader checksum: String
+    attr_reader salt: String
+    attr_reader version: String
+    attr_reader cost: Integer
+    def self.create: (_ToS secret, {cost: _ToI} options) -> BCrypt::Password
+    def self.valid_hash?: (String h) -> bool
+    def initialize: (String raw_hash) -> void
+    def ==: (_ToS secret) -> bool
+    alias is_password? ==
+  end
+
+  class Engine
+    DEFAULT_COST: Integer
+    MIN_COST: Integer
+    MAX_COST: Integer
+    MAX_SECRET_BYTESIZE: Integer
+    MAX_SALT_LENGTH: Integer
+
+    def self.cost: () -> Integer
+    def self.cost=: (Integer cost) -> Integer
+    def self.hash_secret: (_ToS secret, String salt, ?untyped _) -> String
+    def self.generate_salt: (?_ToI cost) -> String
+    def self.valid_salt?: (String salt) -> bool
+    def self.valid_secret?: (Object secret) -> bool
+    def self.calibrate: (Numeric upper_time_limit_in_ms) -> Integer
+    def self.autodetect_cost: (String salt) -> Integer
+  end
+
+  class Error < StandardError
+  end
+
+  module Errors
+    class InvalidSalt < Error
+    end
+
+    class InvalidHash < Error
+    end
+
+    class InvalidCost < Error
+    end
+
+    class InvalidSecret < Error
+    end
+  end
+end

data/data/vendored_gem_sigs/bundler/bundler.rbs

@@ -0,0 +1,238 @@
+#
+# Rigor-side vendored RBS stub for the `bundler` gem.
+#
+# The `bundler` gem does not ship its own `sig/` and is not
+# covered by `ruby/gem_rbs_collection`. The shim in
+# `references/rbs/sig/shims/bundler.rbs` (rbs gem upstream)
+# carries a tiny subset (`LockfileParser`, `LazySpecification`,
+# `Dependency`, `Definition`, `default_lockfile`, `definition`,
+# `Source::Gemspec`) but is only loaded when the user opts in via
+# `library "bundler"` — that's rare in Rigor `.rigor.yml` setups,
+# so most projects analyse bundler-using code with NO `Bundler`
+# RBS in scope.
+#
+# This stub covers the Bundler module's top-25 singleton methods
+# surfaced by the `references/ruby/lib` survey
+# (`docs/CURRENT_WORK.md`), plus the handful of class-level
+# entries (`Definition`, `LockfileParser`, `LazySpecification`,
+# `Dependency`, `ConfigFile`, `Settings`, `UI`) that downstream
+# Rigor users routinely touch. Most return types are `untyped`
+# because Bundler's surface is dynamic / opaque; the goal is to
+# silence `call.undefined-method` rather than infer precise
+# returns.
+#
+# Declarations are intentionally a SUPERSET of the
+# `references/rbs/sig/shims/bundler.rbs` shim. When the user
+# opts into `library "bundler"`, the shim's typed declarations
+# (`LockfileParser#specs -> Array[LazySpecification]`, etc.)
+# would conflict; users who want both should drop the
+# `library "bundler"` entry from their config so this vendored
+# stub wins.
+#
+module Bundler
+  # `Bundler.<name>` — accessors / module-level entry points.
+  # Return types: `untyped` unless the surface is documented and
+  # widely-used (`bundle_path` -> Pathname).
+  def self.configure: () -> untyped
+  def self.ui: () -> untyped
+  def self.ui=: (untyped) -> untyped
+  def self.bundle_path: () -> Pathname
+  def self.create_bundle_path: () -> Pathname
+  def self.configured_bundle_path: () -> untyped
+  def self.bin_path: () -> Pathname
+  def self.setup: (*untyped groups) -> untyped
+  def self.auto_switch: () -> untyped
+  def self.auto_install: () -> untyped
+  def self.require: (*untyped groups) -> untyped
+  def self.load: () -> untyped
+  def self.environment: () -> untyped
+  def self.definition: (?untyped unlock, ?untyped lockfile) -> Definition
+  def self.frozen_bundle?: () -> bool
+  def self.locked_gems: () -> untyped
+  def self.ruby_scope: () -> String
+  def self.user_home: () -> Pathname
+  def self.user_bundle_path: (?untyped dir) -> Pathname
+  def self.user_cache: () -> Pathname
+  def self.home: () -> Pathname
+  def self.install_path: () -> Pathname
+  def self.specs_path: () -> Pathname
+  def self.root: () -> Pathname
+  def self.app_config_path: () -> Pathname
+  def self.app_cache: (?untyped custom_path) -> Pathname
+  def self.tmp: (?untyped name) -> Pathname
+  def self.rm_rf: (untyped path) -> untyped
+  def self.settings: () -> untyped
+  def self.original_env: () -> Hash[String, String]
+  def self.clean_env: () -> Hash[String, String]
+  def self.unbundled_env: () -> Hash[String, String]
+  def self.unbundle_env!: () -> untyped
+  def self.with_original_env: () { () -> untyped } -> untyped
+  def self.with_clean_env: () { () -> untyped } -> untyped
+  def self.with_unbundled_env: () { () -> untyped } -> untyped
+  def self.original_system: (*untyped) -> untyped
+  def self.clean_system: (*untyped) -> untyped
+  def self.unbundled_system: (*untyped) -> untyped
+  def self.original_exec: (*untyped) -> untyped
+  def self.clean_exec: (*untyped) -> untyped
+  def self.unbundled_exec: (*untyped) -> untyped
+  def self.local_platform: () -> untyped
+  def self.generic_local_platform: () -> untyped
+  def self.default_gemfile: () -> Pathname
+  def self.default_lockfile: () -> Pathname
+  def self.default_bundle_dir: () -> Pathname?
+  def self.system_bindir: () -> String?
+  def self.preferred_gemfile_name: () -> String
+  def self.use_system_gems?: () -> bool
+  def self.rubygems: () -> untyped
+  def self.which: (untyped) -> String?
+  def self.load_gemspec: (untyped path, ?bool validate) -> untyped
+  def self.read_file: (untyped path) -> String
+  def self.safe_load_marshal: (untyped data) -> untyped
+  def self.git_present?: () -> bool
+  def self.gem_version: () -> Gem::Version
+  def self.verbose_version: () -> String
+  def self.self_manager: () -> untyped
+  def self.reset!: () -> void
+
+  # Top-level classes touched in real-world bundler / rubygems
+  # code paths the survey analysed. Each class declares only the
+  # most-used members; the rest fall through to `untyped`-typed
+  # singleton-class dispatch via the surrounding module's
+  # untyped return contracts.
+  class Definition
+    def self.build: (untyped gemfile, untyped lockfile, untyped unlock) -> Definition
+
+    def initialize: (*untyped) -> void
+    def gemfiles: () -> Array[Pathname]
+    def lockfile: () -> Pathname
+    def lockfile=: (untyped) -> untyped
+    def locked_gems: () -> LockfileParser
+    def dependencies: () -> Array[Dependency]
+    def current_dependencies: () -> Array[Dependency]
+    def requested_dependencies: () -> Array[Dependency]
+    def dependencies_for: (untyped groups) -> Array[Dependency]
+    def specs: () -> untyped
+    def specs_for: (untyped groups) -> untyped
+    def missing_specs: () -> untyped
+    def validate_runtime!: () -> untyped
+    def check!: () -> untyped
+    def lock: (?untyped) -> untyped
+    def write_lock: () -> untyped
+    def to_lock: () -> String
+    def resolve: () -> untyped
+    def resolve_with_cache!: () -> untyped
+    def resolve_remotely!: () -> untyped
+    def remotely!: () -> untyped
+    def ensure_equivalent_gemfile_and_lockfile: (?bool) -> untyped
+    def normalize_platforms: () -> untyped
+    def platforms: () -> Array[untyped]
+    def add_platform: (untyped) -> untyped
+    def remove_platform: (untyped) -> untyped
+    def add_checksums: () -> untyped
+    def groups: () -> Array[Symbol]
+    def ruby_version: () -> untyped
+  end
+
+  class LockfileParser
+    def initialize: (String body) -> void
+    def specs: () -> Array[LazySpecification]
+    def platforms: () -> Array[untyped]
+    def sources: () -> Array[untyped]
+    def dependencies: () -> Array[Dependency]
+    def ruby_version: () -> untyped
+    def bundler_version: () -> untyped
+  end
+
+  class LazySpecification
+    def name: () -> String
+    def version: () -> Gem::Version
+    def platform: () -> untyped
+    def dependencies: () -> Array[Gem::Dependency]
+    def source: () -> untyped
+  end
+
+  class Dependency < Gem::Dependency
+    attr_reader autorequire: Array[String]?
+    attr_reader source: untyped
+    attr_reader groups: Array[Symbol]
+    attr_reader platforms: Array[Symbol]
+  end
+
+  class ConfigFile
+    def []: (*untyped) -> untyped
+    def []=: (*untyped) -> untyped
+    def set_global: (untyped, untyped) -> untyped
+    def set_local: (untyped, untyped) -> untyped
+    def all: () -> Hash[String, untyped]
+  end
+
+  module Source
+    class Gemspec
+      def initialize: (*untyped) -> void
+      attr_accessor name: String?
+      attr_accessor version: String?
+    end
+
+    class Path
+      def initialize: (*untyped) -> void
+      attr_accessor name: String?
+      attr_accessor version: String?
+      attr_accessor path: String?
+    end
+
+    class Git
+      def initialize: (*untyped) -> void
+      attr_accessor uri: String?
+      attr_accessor branch: String?
+      attr_accessor ref: String?
+      attr_accessor submodules: bool
+      attr_accessor glob: String?
+      attr_accessor name: String?
+      attr_accessor version: String?
+    end
+
+    class Rubygems
+      def initialize: (*untyped) -> void
+      attr_accessor remotes: Array[String]
+      attr_accessor name: String?
+      attr_accessor version: String?
+    end
+  end
+
+  module UI
+    class Shell
+      def initialize: (?untyped) -> void
+      def info: (untyped, ?bool newline) -> void
+      def confirm: (untyped, ?bool newline) -> void
+      def warn: (untyped, ?bool newline) -> void
+      def debug: (untyped, ?bool newline) -> void
+      def debug?: () -> bool
+      def error: (untyped, ?bool newline) -> void
+      def trace: (untyped, ?untyped newline, ?bool force) -> void
+      def silence: () { () -> untyped } -> untyped
+      def ask: (untyped) -> String?
+      def yes?: (untyped) -> bool
+      def no?: () -> bool
+      def level: (?String name) -> String
+      def level=: (untyped) -> untyped
+      def quiet?: () -> bool
+      def quiet=: (bool) -> bool
+    end
+
+    class RGProxy
+      def initialize: (?untyped) -> void
+    end
+  end
+
+  class GemfileError < StandardError
+  end
+
+  class GemfileNotFound < StandardError
+  end
+
+  class LockfileError < StandardError
+  end
+
+  class GemNotFound < StandardError
+  end
+end

data/data/vendored_gem_sigs/cgi/cgi_extras.rbs

@@ -0,0 +1,34 @@
+#
+# Rigor-side supplement to the rbs gem's
+# `stdlib/cgi/0/core.rbs` declarations.
+#
+# Re-opens `class CGI` to bring in the instance methods that
+# real-world Ruby code calls on a CGI instance: `params`,
+# `params=`, `cookies`, `cookies=`, `multipart?`, `query_string`,
+# the parsed-request bits.
+#
+# Why this isn't already in the upstream RBS: at runtime
+# `CGI#initialize` does `extend CGI::QueryExtension`, which
+# attaches the methods to each instance via singleton-class
+# inheritance. The static-RBS surface can't represent
+# per-instance `extend` calls. Declaring `class CGI; include
+# CGI::QueryExtension; end` here is a deliberate
+# over-approximation that matches the real surface every CGI
+# instance you actually use (you got it from `CGI.new`) has.
+#
+# Driven by the tdiary-core survey
+# (`docs/notes/20260519-oss-library-survey.md`) where
+# `lib/tdiary/core_ext.rb:62`'s `cgi.params['key']` /
+# `self.params[param]` surfaced as `undefined method 'params'
+# for CGI` (3 errors per call site, 6 total).
+#
+# Adds new declarations only — never redeclares anything the
+# upstream RBS already covers, so the loader does not raise
+# `RBS::DuplicatedDeclarationError`. `include` is permitted
+# because the upstream `class CGI` declaration already does
+# `include CGI::Util` + `extend CGI::Util`; adding a sibling
+# `include CGI::QueryExtension` is purely additive.
+#
+class CGI
+  include CGI::QueryExtension
+end

data/data/vendored_gem_sigs/did_you_mean/did_you_mean_extras.rbs

@@ -0,0 +1,34 @@
+#
+# Rigor-side supplement to the rbs gem's
+# `stdlib/did_you_mean/0/did_you_mean.rbs` declarations.
+#
+# Re-opens `module DidYouMean` to add the top-level singleton
+# methods the upstream RBS omits — every method below is defined
+# in `lib/did_you_mean.rb` and called by rubygems / bundler /
+# optparse / thor without an RBS declaration to back it.
+#
+# Adds new declarations only; never redeclares anything the
+# upstream RBS already covers, so the loader does not raise
+# `RBS::DuplicatedDeclarationError`.
+#
+module DidYouMean
+  # Sharable hash of error-class names to spell-checker objects.
+  # Defaults to `Hash.new(NullChecker)` — the value's runtime
+  # default makes any missing-key lookup return `NullChecker`.
+  def self.spell_checkers: () -> Hash[String, untyped]
+
+  # `correct_error(error_class, spell_checker)` registers a
+  # spell-checker for the named error class, prepending
+  # `Correctable` to it when the class doesn't already include
+  # it. Returns the registered spell_checker (the assignment's
+  # value).
+  def self.correct_error: (untyped error_class, untyped spell_checker) -> untyped
+
+  # The active formatter. Returns the per-Ractor override when
+  # one is set; otherwise `DidYouMean::Formatter` (the module).
+  def self.formatter: () -> untyped
+
+  # Per-Ractor formatter override. Returns the assigned
+  # formatter under Ractor; nil otherwise.
+  def self.formatter=: (untyped) -> untyped
+end

data/data/vendored_gem_sigs/idn-ruby/idn.rbs

@@ -0,0 +1,54 @@
+# Minimal hand-authored RBS stub for the `idn-ruby` gem
+# (libidn binding for Internationalised Domain Names).
+#
+# `idn-ruby` is not in `ruby/gem_rbs_collection` as of 2026-05-15.
+# Authorship: hand-written by Rigor maintainers based on the
+# upstream README (https://github.com/idnruby/idn-ruby).
+
+module IDN
+  VERSION: String
+
+  class Error < StandardError
+  end
+
+  class Stringprep
+    class StringprepError < IDN::Error
+    end
+
+    NAMEPREP: String
+    ISCSIPREP: String
+    NODEPREP: String
+    RESOURCEPREP: String
+    PLAIN: String
+    TRACE: String
+    SASLPREP: String
+
+    def self.with_profile: (String profile, String input) -> String
+    def self.nameprep: (String input) -> String
+    def self.iscsiprep: (String input) -> String
+    def self.nodeprep: (String input) -> String
+    def self.resourceprep: (String input) -> String
+    def self.plain: (String input) -> String
+    def self.trace: (String input) -> String
+    def self.saslprep: (String input) -> String
+  end
+
+  class Punycode
+    class PunycodeError < IDN::Error
+    end
+
+    def self.encode: (String input) -> String
+    def self.decode: (String input) -> String
+  end
+
+  class Idna
+    class IdnaError < IDN::Error
+    end
+
+    ALLOW_UNASSIGNED: Integer
+    USE_STD3_ASCII_RULES: Integer
+
+    def self.toASCII: (String input, ?Integer flags) -> String
+    def self.toUnicode: (String input, ?Integer flags) -> String
+  end
+end

data/data/vendored_gem_sigs/mysql2/client.rbs

@@ -0,0 +1,55 @@
+module Mysql2
+  class Client[ResultType]
+    MULTI_STATEMENTS: Integer
+
+    self.@default_query_options: untyped
+
+    @read_timeout: untyped
+
+    @query_options: untyped
+
+    attr_reader query_options: untyped
+
+    attr_reader read_timeout: untyped
+
+    def self.default_query_options: () -> untyped
+
+    def initialize: (Hash[(String | Symbol), untyped] opts) -> void
+
+    def self.new: (as: :hash, **untyped) -> Mysql2::Client[Mysql2::ResultAsHash]
+                | (as: :array, **untyped) -> Mysql2::Client[Mysql2::ResultAsArray]
+                | (as: Symbol, **untyped) -> Mysql2::Client[Mysql2::ResultAsHash | Mysql2::ResultAsArray]
+                | (**untyped) -> Mysql2::Client[Mysql2::ResultAsHash]
+
+    def parse_ssl_mode: (untyped mode) -> untyped
+
+    def parse_flags_array: (untyped flags, ?::Integer initial) -> untyped
+
+    # Find any default system CA paths to handle system roots
+    # by default if stricter validation is requested and no
+    # path is provide.
+    def find_default_ca_path: () -> untyped
+
+    # Set default program_name in performance_schema.session_connect_attrs
+    # and performance_schema.session_account_connect_attrs
+    def parse_connect_attrs: (untyped conn_attrs) -> (::Hash[untyped, untyped] | untyped)
+
+    def query: (String sql, as: :hash, **untyped) -> ResultAsHash
+             | (String sql, as: :array, **untyped) -> ResultAsArray
+             | (String sql, **untyped) -> ResultType
+
+    def query_info: () -> (::Hash[untyped, untyped] | untyped)
+
+    def info: () -> untyped
+
+    def last_id: () -> Integer
+
+    def affected_rows: () -> Integer
+
+    def prepare: (String sql) -> Mysql2::Statement
+
+    private
+
+    def self.local_offset: () -> untyped
+  end
+end

data/data/vendored_gem_sigs/mysql2/error.rbs

@@ -0,0 +1,5 @@
+module Mysql2
+  class Error < StandardError
+    attr_reader error_number: Integer
+  end
+end

data/data/vendored_gem_sigs/mysql2/result.rbs

@@ -0,0 +1,31 @@
+module Mysql2
+  type row_value_type = String | Integer | BigDecimal | Float | Time | Date | nil
+
+  class ResultAsHash
+    attr_reader server_flags: untyped
+
+    # NOTE:
+    #   The type of key is controlled by `symbolize_keys` option of `Mysql2::Client.new`.
+    #   It can be expressed using a type argument such as `Client[ResultType]`,
+    #   but since the state becomes complicated. So `String | Symbol` is allowed.
+    type key_type = String | Symbol
+
+    include Enumerable[Hash[key_type, row_value_type]]
+
+    def each: () { (Hash[key_type, row_value_type]) -> void } -> void
+    def count: () -> Integer
+    def to_a: () -> Array[untyped]
+    alias size count
+  end
+
+  class ResultAsArray
+    attr_reader server_flags: untyped
+
+    include Enumerable[Array[row_value_type]]
+
+    def each: () { (Array[row_value_type]) -> void } -> void
+    def count: () -> Integer
+    def to_a: () -> Array[untyped]
+    alias size count
+  end
+end

data/data/vendored_gem_sigs/mysql2/statement.rbs

@@ -0,0 +1,5 @@
+module Mysql2
+  class Statement
+    def execute: (*untyped, **untyped) -> (Mysql2::ResultAsHash | Mysql2::ResultAsArray)
+  end
+end