better_auth-sinatra 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c8cfbde43e94311d211b9d355ed4fed778af108b0f6d149e4b3a6611ab3f9e90
+  data.tar.gz: 95e66c4b67168cfcb669ecfcf3aaa65798cbec20e8fd1d3b19e2833209520f0d
+SHA512:
+  metadata.gz: d158fe7e73c3a9622ebee45408fe2e6762f6372c36c310bf7b79cc1b58454c0cf507c4656d44bbbf49a7d95f84a41da1c3662bebf357fa0f9a1ddcac97e88115
+  data.tar.gz: 78125ddabbd5ea6fa93bf2f7447154ef1ba9f308bfc71c0244bdc99f970fe309488829c84bf19b7b7bce7007a11302f1f869fc19da3d57994d601d08ce9380a7

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0
+
+- Initial Sinatra adapter.

data/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sebastian Sala
+
+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,91 @@
+# Better Auth Sinatra
+
+Sinatra adapter for Better Auth Ruby. This package is a thin integration around
+the framework-agnostic `better_auth` Rack core.
+
+## Installation
+
+```ruby
+gem "better_auth-sinatra"
+```
+
+```bash
+bundle install
+```
+
+## Setup
+
+```ruby
+require "sinatra/base"
+require "better_auth/sinatra"
+
+class App < Sinatra::Base
+  register BetterAuth::Sinatra
+
+  better_auth at: "/api/auth" do |config|
+    config.secret = ENV.fetch("BETTER_AUTH_SECRET")
+    config.base_url = ENV.fetch("BETTER_AUTH_URL")
+    config.database = ->(options) {
+      BetterAuth::Adapters::Postgres.new(options, url: ENV.fetch("DATABASE_URL"))
+    }
+    config.email_and_password = {enabled: true}
+    config.plugins = []
+  end
+
+  get "/dashboard" do
+    require_authentication
+    current_user.fetch("email")
+  end
+end
+```
+
+The extension mounts the core Rack app at `/api/auth` by default. The core app
+still owns routes such as `/ok`, `/sign-up/email`, `/sign-in/email`, and plugin
+endpoints.
+
+## Helpers
+
+- `current_session`
+- `current_user`
+- `authenticated?`
+- `require_authentication`
+
+`require_authentication` halts with `401` when no Better Auth user is present.
+
+## Rake Tasks
+
+Load tasks from your app Rakefile:
+
+```ruby
+require "better_auth/sinatra/tasks"
+```
+
+Available tasks:
+
+```bash
+rake better_auth:install
+rake better_auth:generate:migration
+rake better_auth:migrate
+rake better_auth:routes
+```
+
+`better_auth:install` creates `config/better_auth.rb`. SQL migrations are
+generated under `db/better_auth/migrate`.
+
+## Database Notes
+
+Sinatra does not include a Rails-style database layer or migration command.
+This adapter uses Better Auth core SQL adapters for migrations. Set
+`BETTER_AUTH_DIALECT=postgres`, `mysql`, or `sqlite` when generating SQL.
+
+ActiveRecord-backed Sinatra migrations are not supported yet. Apps that already
+use `sinatra-activerecord` can still configure Better Auth manually, but the v1
+Rake tasks do not emit ActiveRecord migrations.
+
+## Development
+
+```bash
+cd packages/better_auth-sinatra
+rbenv exec bundle exec rspec
+RUBOCOP_CACHE_ROOT=/private/var/folders/7x/jrsz946d2w73n42fb1_ff5000000gn/T/rubocop_cache_sinatra rbenv exec bundle exec standardrb
+```

data/lib/better_auth/sinatra/configuration.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Sinatra
+    class Configuration
+      AUTH_OPTION_NAMES = %i[
+        app_name
+        base_url
+        base_path
+        secret
+        database
+        plugins
+        trusted_origins
+        rate_limit
+        session
+        account
+        user
+        verification
+        advanced
+        email_and_password
+        password_hasher
+        email_verification
+        social_providers
+        experimental
+        secondary_storage
+        database_hooks
+        hooks
+        on_api_error
+        disabled_paths
+        logger
+      ].freeze
+
+      attr_accessor(*AUTH_OPTION_NAMES)
+
+      def initialize
+        @base_path = BetterAuth::Configuration::DEFAULT_BASE_PATH
+        @plugins = []
+        @trusted_origins = []
+      end
+
+      def to_auth_options
+        AUTH_OPTION_NAMES.each_with_object({}) do |name, options|
+          value = public_send(name)
+          next if value.nil?
+          next if value.respond_to?(:empty?) && value.empty?
+
+          options[name] = value
+        end
+      end
+
+      def copy
+        self.class.new.tap do |copy|
+          AUTH_OPTION_NAMES.each do |name|
+            value = public_send(name)
+            copy.public_send("#{name}=", deep_dup(value))
+          end
+        end
+      end
+
+      private
+
+      def deep_dup(value)
+        case value
+        when Hash
+          value.transform_values { |entry| deep_dup(entry) }
+        when Array
+          value.map { |entry| deep_dup(entry) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/better_auth/sinatra/extension.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Sinatra
+    module Extension
+      def self.registered(app)
+        app.extend ClassMethods
+        app.helpers Helpers
+      end
+
+      module ClassMethods
+        def better_auth(at: BetterAuth::Configuration::DEFAULT_BASE_PATH, auth: nil, **overrides)
+          mount_path = normalize_better_auth_mount_path(at)
+          config = BetterAuth::Sinatra.configuration.copy
+          yield config if block_given?
+          config.base_path = mount_path
+          options = config.to_auth_options.merge(overrides)
+          auth_instance = auth || BetterAuth.auth(options)
+
+          set :better_auth_auth, auth_instance
+          set :better_auth_mount_path, mount_path
+          use BetterAuth::Sinatra::MountedApp, -> { settings.better_auth_auth }, mount_path: mount_path
+        end
+
+        private
+
+        def normalize_better_auth_mount_path(path)
+          normalized = path.to_s
+          normalized = "/#{normalized}" unless normalized.start_with?("/")
+          normalized = normalized.squeeze("/")
+          (normalized == "/") ? normalized : normalized.delete_suffix("/")
+        end
+      end
+    end
+  end
+end

data/lib/better_auth/sinatra/helpers.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Sinatra
+    module Helpers
+      def current_session
+        data = better_auth_session_data
+        data&.fetch(:session, nil) || data&.fetch("session", nil)
+      end
+
+      def current_user
+        data = better_auth_session_data
+        data&.fetch(:user, nil) || data&.fetch("user", nil)
+      end
+
+      def authenticated?
+        !current_user.nil?
+      end
+
+      def require_authentication
+        return true if authenticated?
+
+        halt 401, ""
+      end
+
+      private
+
+      def better_auth_session_data
+        return request.env["better_auth.session"] if request.env.key?("better_auth.session")
+
+        request.env["better_auth.session"] = resolve_better_auth_session
+      end
+
+      def resolve_better_auth_session
+        context = BetterAuth::Endpoint::Context.new(
+          path: request.path_info,
+          method: request.request_method,
+          query: request.GET,
+          body: {},
+          params: params,
+          headers: {"cookie" => request.env["HTTP_COOKIE"]},
+          context: better_auth_auth.context,
+          request: request
+        )
+        BetterAuth::Session.find_current(context, disable_refresh: true)
+      end
+
+      def better_auth_auth
+        if respond_to?(:settings) && settings.respond_to?(:better_auth_auth)
+          settings.better_auth_auth
+        else
+          BetterAuth::Sinatra.auth
+        end
+      end
+    end
+  end
+end

data/lib/better_auth/sinatra/migration.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module BetterAuth
+  module Sinatra
+    module Migration
+      DEFAULT_MIGRATIONS_PATH = "db/better_auth/migrate"
+
+      class UnsupportedAdapterError < StandardError; end
+
+      module_function
+
+      def render(options, dialect:)
+        config = configuration_for(options)
+        statements = BetterAuth::Schema::SQL.create_statements(config, dialect: dialect)
+        [
+          "-- Generated by better_auth-sinatra",
+          "-- Dialect: #{dialect}",
+          "",
+          statements.join("\n\n"),
+          ""
+        ].join("\n")
+      end
+
+      def generate(options, dialect:, migrations_path: DEFAULT_MIGRATIONS_PATH, timestamp: Time.now.utc.strftime("%Y%m%d%H%M%S"))
+        FileUtils.mkdir_p(migrations_path)
+        path = File.join(migrations_path, "#{timestamp}_create_better_auth_tables.sql")
+        return path if File.exist?(path)
+
+        File.write(path, render(options, dialect: dialect))
+        path
+      end
+
+      def migrate(auth_or_options, migrations_path: DEFAULT_MIGRATIONS_PATH)
+        auth = auth_for(auth_or_options)
+        adapter = auth.context.adapter
+        unless adapter.respond_to?(:dialect) && adapter.respond_to?(:connection)
+          raise UnsupportedAdapterError, "better_auth-sinatra migrations require core SQL adapters with connection and dialect support"
+        end
+
+        connection = adapter.connection
+        dialect = adapter.dialect.to_sym
+        files = Dir[File.join(migrations_path, "*.sql")].sort
+        ensure_schema_migrations!(connection, dialect)
+        applied = applied_migrations(connection, dialect)
+
+        files.reject { |file| applied.include?(File.basename(file)) }.each do |file|
+          execute_sql(connection, File.read(file))
+          record_migration(connection, dialect, File.basename(file))
+        end
+      end
+
+      def configuration_for(options)
+        return options.options if options.is_a?(BetterAuth::Auth)
+        return options if options.is_a?(BetterAuth::Configuration)
+
+        BetterAuth::Configuration.new(options)
+      end
+
+      def auth_for(value)
+        return value if value.is_a?(BetterAuth::Auth)
+
+        BetterAuth.auth(value)
+      end
+
+      def ensure_schema_migrations!(connection, dialect)
+        sql = case dialect
+        when :postgres, :sqlite
+          %(CREATE TABLE IF NOT EXISTS #{quote("better_auth_schema_migrations", dialect)} (#{quote("version", dialect)} text PRIMARY KEY);)
+        when :mysql
+          %(CREATE TABLE IF NOT EXISTS #{quote("better_auth_schema_migrations", dialect)} (#{quote("version", dialect)} varchar(191) PRIMARY KEY) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;)
+        when :mssql
+          %(IF OBJECT_ID(N'#{quote("better_auth_schema_migrations", dialect)}', N'U') IS NULL CREATE TABLE #{quote("better_auth_schema_migrations", dialect)} (#{quote("version", dialect)} varchar(255) PRIMARY KEY);)
+        else
+          raise UnsupportedAdapterError, "Unsupported SQL dialect for better_auth-sinatra migrations: #{dialect}"
+        end
+        execute_sql(connection, sql)
+      end
+
+      def applied_migrations(connection, dialect)
+        rows = execute_sql(connection, "SELECT #{quote("version", dialect)} FROM #{quote("better_auth_schema_migrations", dialect)};")
+        Array(rows).map { |row| row["version"] || row[:version] }
+      rescue
+        []
+      end
+
+      def record_migration(connection, dialect, version)
+        sql = "INSERT INTO #{quote("better_auth_schema_migrations", dialect)} (#{quote("version", dialect)}) VALUES (#{literal(version)});"
+        execute_sql(connection, sql)
+      end
+
+      def execute_sql(connection, sql)
+        statements(sql).each_with_object([]) do |statement, results|
+          result =
+            if connection.respond_to?(:exec)
+              connection.exec(statement)
+            elsif connection.respond_to?(:execute)
+              connection.execute(statement)
+            elsif connection.respond_to?(:query)
+              connection.query(statement)
+            else
+              raise UnsupportedAdapterError, "SQL connection does not support exec, execute, or query"
+            end
+          results.concat(result.to_a) if result.respond_to?(:to_a)
+        end
+      end
+
+      def statements(sql)
+        sql.split(/;\s*$/).map(&:strip).reject(&:empty?)
+      end
+
+      def quote(identifier, dialect)
+        BetterAuth::Schema::SQL.quote(identifier, dialect)
+      end
+
+      def literal(value)
+        "'#{value.to_s.gsub("'", "''")}'"
+      end
+    end
+  end
+end

data/lib/better_auth/sinatra/mounted_app.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Sinatra
+    class MountedApp
+      def initialize(app, auth, mount_path:)
+        @app = app
+        @auth = auth
+        @mount_path = normalize_path(mount_path)
+      end
+
+      def call(env)
+        return auth.call(env) if mounted_path?(env["PATH_INFO"])
+
+        @app.call(env)
+      end
+
+      private
+
+      def auth
+        return @auth.call if @auth.respond_to?(:call) && !@auth.respond_to?(:context)
+
+        @auth
+      end
+
+      def mounted_path?(path)
+        normalized = normalize_path(path)
+        return true if @mount_path == "/"
+
+        normalized == @mount_path || normalized.start_with?("#{@mount_path}/")
+      end
+
+      def normalize_path(path)
+        normalized = path.to_s
+        normalized = "/#{normalized}" unless normalized.start_with?("/")
+        normalized = normalized.squeeze("/")
+        normalized = normalized.delete_suffix("/") unless normalized == "/"
+        normalized.empty? ? "/" : normalized
+      end
+    end
+  end
+end

data/lib/better_auth/sinatra/tasks.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "rake"
+require "better_auth/sinatra"
+
+namespace :better_auth do
+  desc "Create the Better Auth Sinatra config and migration directory"
+  task :install do
+    config_path = "config/better_auth.rb"
+    FileUtils.mkdir_p(File.dirname(config_path))
+    if File.exist?(config_path)
+      puts "skip #{config_path} already exists"
+    else
+      File.write(config_path, BetterAuth::Sinatra.default_config_template)
+      puts "create #{config_path}"
+    end
+
+    FileUtils.mkdir_p(BetterAuth::Sinatra::Migration::DEFAULT_MIGRATIONS_PATH)
+  end
+
+  namespace :generate do
+    desc "Create the Better Auth SQL migration"
+    task :migration do
+      BetterAuth::Sinatra.load_app_config
+      dialect = ENV.fetch("BETTER_AUTH_DIALECT", "postgres").to_sym
+      config = BetterAuth::Sinatra.migration_configuration
+      path = BetterAuth::Sinatra::Migration.generate(config, dialect: dialect)
+      puts "create #{path}"
+    end
+  end
+
+  desc "Create the Better Auth SQL migration"
+  task "generate:migration" do
+    Rake::Task["better_auth:generate:migration"].invoke
+  end
+
+  desc "Run pending Better Auth SQL migrations"
+  task :migrate do
+    BetterAuth::Sinatra.load_app_config
+    BetterAuth::Sinatra::Migration.migrate(BetterAuth::Sinatra.auth)
+  end
+
+  desc "Print Better Auth Sinatra mount information"
+  task :routes do
+    BetterAuth::Sinatra.load_app_config
+    puts "#{BetterAuth::Sinatra.configuration.base_path}/* -> BetterAuth.auth"
+  end
+end

data/lib/better_auth/sinatra/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Sinatra
+    VERSION = "0.1.0"
+  end
+end

data/lib/better_auth/sinatra.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "better_auth"
+require "sinatra/base"
+
+require_relative "sinatra/version"
+require_relative "sinatra/configuration"
+require_relative "sinatra/mounted_app"
+require_relative "sinatra/helpers"
+require_relative "sinatra/migration"
+require_relative "sinatra/extension"
+
+module BetterAuth
+  module Sinatra
+    class << self
+      def registered(app)
+        Extension.registered(app)
+      end
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield configuration
+        @auth = nil
+        self
+      end
+
+      def reset!
+        @configuration = nil
+        @auth = nil
+      end
+
+      def auth(overrides = nil)
+        options = configuration.to_auth_options
+        return @auth ||= BetterAuth.auth(options) if overrides.nil? || overrides.empty?
+
+        BetterAuth.auth(options.merge(overrides))
+      end
+
+      def migration_configuration
+        options = configuration.to_auth_options
+        options[:secret] ||= BetterAuth::Configuration::DEFAULT_SECRET
+        BetterAuth::Configuration.new(options)
+      end
+
+      def load_app_config(path = "config/better_auth.rb")
+        load path if File.exist?(path)
+      end
+
+      def default_config_template
+        <<~RUBY
+          # frozen_string_literal: true
+
+          require "better_auth/sinatra"
+
+          BetterAuth::Sinatra.configure do |config|
+            config.secret = ENV.fetch("BETTER_AUTH_SECRET", "change-me-sinatra-secret-12345678901234567890")
+            config.base_url = ENV["BETTER_AUTH_URL"]
+            config.base_path = "/api/auth"
+
+            config.database = ->(options) do
+              case ENV.fetch("BETTER_AUTH_DATABASE_DIALECT", "postgres")
+              when "postgres", "postgresql"
+                BetterAuth::Adapters::Postgres.new(options, url: ENV.fetch("DATABASE_URL"))
+              when "mysql"
+                BetterAuth::Adapters::MySQL.new(options, url: ENV.fetch("DATABASE_URL"))
+              when "sqlite", "sqlite3"
+                BetterAuth::Adapters::SQLite.new(options, path: ENV.fetch("DATABASE_URL", "db/better_auth.sqlite3"))
+              else
+                raise "Unsupported BETTER_AUTH_DATABASE_DIALECT for better_auth-sinatra"
+              end
+            end
+
+            config.email_and_password = {
+              enabled: true
+            }
+
+            config.plugins = []
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/better_auth_sinatra.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "better_auth/sinatra"

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: better_auth-sinatra
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sebastian Sala
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: better_auth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: standardrb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Sinatra integration for Better Auth Ruby. Provides mounting helpers,
+  request helpers, and SQL migration tasks.
+email:
+- sebastian.sala.tech@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+- lib/better_auth/sinatra.rb
+- lib/better_auth/sinatra/configuration.rb
+- lib/better_auth/sinatra/extension.rb
+- lib/better_auth/sinatra/helpers.rb
+- lib/better_auth/sinatra/migration.rb
+- lib/better_auth/sinatra/mounted_app.rb
+- lib/better_auth/sinatra/tasks.rb
+- lib/better_auth/sinatra/version.rb
+- lib/better_auth_sinatra.rb
+homepage: https://github.com/sebasxsala/better-auth
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/sebasxsala/better-auth
+  source_code_uri: https://github.com/sebasxsala/better-auth
+  changelog_uri: https://github.com/sebasxsala/better-auth/blob/main/packages/better_auth-sinatra/CHANGELOG.md
+  bug_tracker_uri: https://github.com/sebasxsala/better-auth/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Sinatra adapter for Better Auth
+test_files: []