tarsier 0.1.0

data/sig/tarsier.rbs

@@ -0,0 +1,485 @@
+# Type signatures for Tarsier framework
+
+module Tarsier
+  VERSION: String
+
+  def self.app: -> Application?
+  def self.app=: (Application) -> Application
+  def self.application: () { (Application) -> void } -> Application
+  def self.routes: () { (Router) -> void } -> void
+  def self.router: -> Router?
+  def self.env: -> String
+  def self.development?: -> bool
+  def self.production?: -> bool
+  def self.test?: -> bool
+
+  class Error < StandardError
+  end
+
+  class RouteNotFoundError < Error
+    attr_reader method: Symbol
+    attr_reader path: String
+    def initialize: (Symbol, String) -> void
+  end
+
+  class InvalidRouteError < Error
+  end
+
+  class ValidationError < Error
+    attr_reader errors: Hash[Symbol, Array[String]]
+    def initialize: (Hash[Symbol, Array[String]]) -> void
+  end
+
+  class MissingParameterError < ValidationError
+    def initialize: (Symbol) -> void
+  end
+
+  class TypeCoercionError < Error
+    attr_reader param_name: Symbol
+    attr_reader expected_type: Class
+    attr_reader actual_value: untyped
+    def initialize: (Symbol, Class, untyped) -> void
+  end
+
+  class Application
+    attr_reader router: Router
+    attr_reader middleware_stack: Middleware::Stack
+    attr_reader config: Configuration
+
+    def initialize: -> void
+    def configure: () { (Configuration) -> void } -> self
+    def routes: () { (Router) -> void } -> self
+    def use: (Class, *untyped, **untyped) -> self
+    def boot!: -> self
+    def booted?: -> bool
+    def call: (Hash[String, untyped]) -> [Integer, Hash[String, String], Array[String]]
+    def dispatch: (Request, Response) -> Response
+    def path_for: (Symbol, ?Hash[Symbol, untyped]) -> String
+    def routes_list: -> Array[Router::Route]
+  end
+
+  class Configuration
+    attr_accessor secret_key: String?
+    attr_accessor session_store: Symbol
+    attr_accessor log_level: Symbol
+    attr_accessor static_files: bool
+    attr_accessor default_format: Symbol
+    attr_accessor force_ssl: bool
+    attr_accessor host: String
+    attr_accessor port: Integer
+
+    def initialize: -> void
+    def set: (Hash[Symbol, untyped]) -> void
+  end
+
+  class Router
+    HTTP_METHODS: Array[Symbol]
+
+    attr_reader compiler: Router::Compiler
+
+    def initialize: -> void
+    def draw: () { -> void } -> self
+    def compile!: -> void
+    def match: (Symbol | String, String) -> [Router::Route, Hash[Symbol, String]]?
+    def path_for: (Symbol, ?Hash[Symbol, untyped]) -> String
+    def routes: -> Array[Router::Route]
+
+    def get: (String, ?to: untyped, ?as: Symbol?, ?constraints: Hash[Symbol, Regexp], **untyped) -> void
+    def post: (String, ?to: untyped, ?as: Symbol?, ?constraints: Hash[Symbol, Regexp], **untyped) -> void
+    def put: (String, ?to: untyped, ?as: Symbol?, ?constraints: Hash[Symbol, Regexp], **untyped) -> void
+    def patch: (String, ?to: untyped, ?as: Symbol?, ?constraints: Hash[Symbol, Regexp], **untyped) -> void
+    def delete: (String, ?to: untyped, ?as: Symbol?, ?constraints: Hash[Symbol, Regexp], **untyped) -> void
+    def head: (String, ?to: untyped, ?as: Symbol?, ?constraints: Hash[Symbol, Regexp], **untyped) -> void
+    def options: (String, ?to: untyped, ?as: Symbol?, ?constraints: Hash[Symbol, Regexp], **untyped) -> void
+
+    def resources: (Symbol, ?only: Array[Symbol]?, ?except: Array[Symbol]?, ?controller: Symbol?, **untyped) ?{ -> void } -> void
+    def resource: (Symbol, ?only: Array[Symbol]?, ?except: Array[Symbol]?, ?controller: Symbol?, **untyped) ?{ -> void } -> void
+    def scope: (?path: String?, ?module: Symbol?, ?as: Symbol?, **untyped) { -> void } -> void
+    def namespace: (Symbol, **untyped) { -> void } -> void
+    def mount: (untyped, at: String) -> void
+    def root: (to: untyped, ?as: Symbol) -> void
+
+    class Route
+      attr_reader method: Symbol
+      attr_reader path: String
+      attr_reader handler: untyped
+      attr_reader name: Symbol?
+      attr_reader constraints: Hash[Symbol, Regexp]
+      attr_reader middleware: Array[untyped]
+      attr_reader options: Hash[Symbol, untyped]
+
+      def initialize: (method: Symbol, path: String, handler: untyped, ?name: Symbol?, ?constraints: Hash[Symbol, Regexp], ?middleware: Array[untyped], **untyped) -> void
+      def segments: -> Array[Hash[Symbol, untyped]]
+      def param_names: -> Array[Symbol]
+      def dynamic?: -> bool
+      def generate: (?Hash[Symbol, untyped]) -> String
+      def controller_class: -> Class?
+      def action_name: -> Symbol?
+      def proc_handler?: -> bool
+    end
+
+    class Node
+      STATIC: Symbol
+      PARAM: Symbol
+      WILDCARD: Symbol
+
+      attr_reader segment: String
+      attr_reader type: Symbol
+      attr_reader param_name: Symbol?
+      attr_reader constraint: Regexp?
+      attr_reader children: Hash[String, Node]
+      attr_accessor route: Route?
+      attr_accessor priority: Integer
+
+      def initialize: (?String, ?type: Symbol, ?param_name: Symbol?, ?constraint: Regexp?) -> void
+      def add_child: (String, Node) -> Node
+      def find_child: (String) -> Node?
+      def match?: (String) -> (Hash[Symbol, String] | false)
+      def terminal?: -> bool
+      def sorted_children: -> Array[Node]
+      def invalidate_cache!: -> void
+    end
+
+    class Compiler
+      attr_reader trees: Hash[Symbol, Node]
+
+      def initialize: -> void
+      def add: (Route) -> void
+      def compile!: -> void
+      def compiled?: -> bool
+      def match: (Symbol, String) -> [Route, Hash[Symbol, String]]?
+      def named_route: (Symbol) -> Route?
+      def path_for: (Symbol, ?Hash[Symbol, untyped]) -> String
+      def routes: -> Array[Route]
+    end
+  end
+
+  class Request
+    HTTP_METHODS: Array[String]
+
+    attr_reader env: Hash[String, untyped]
+    attr_reader route_params: Hash[Symbol, String]
+
+    def initialize: (Hash[String, untyped], ?Hash[Symbol, String]) -> void
+    def method: -> Symbol
+    def path: -> String
+    def url: -> String
+    def scheme: -> String
+    def host: -> String
+    def port: -> Integer
+    def query_string: -> String
+    def query_params: -> Hash[Symbol, String]
+    def params: -> Params
+    def body: -> String
+    def body_params: -> Hash[Symbol, untyped]
+    def headers: -> Hash[String, String]
+    def header: (String) -> String?
+    def content_type: -> String?
+    def content_length: -> Integer?
+    def accept: -> String?
+    def accepted_types: -> Array[String]
+    def accepts?: (String) -> bool
+    def cookies: -> Hash[Symbol, String]
+    def user_agent: -> String?
+    def ip: -> String
+    def secure?: -> bool
+    def xhr?: -> bool
+    def json?: -> bool
+    def form?: -> bool
+    def get?: -> bool
+    def post?: -> bool
+    def put?: -> bool
+    def patch?: -> bool
+    def delete?: -> bool
+    def head?: -> bool
+    def options?: -> bool
+    def safe?: -> bool
+    def idempotent?: -> bool
+  end
+
+  class Response
+    STATUS_CODES: Hash[Integer, String]
+
+    attr_reader status: Integer
+    attr_reader headers: Hash[String, String]
+    attr_accessor body: String?
+
+    def initialize: (?status: Integer, ?headers: Hash[String, String], ?body: String?) -> void
+    def status=: (Integer) -> void
+    def set_header: (String, String) -> self
+    def []=: (String, String) -> self
+    def get_header: (String) -> String?
+    def []: (String) -> String?
+    def delete_header: (String) -> String?
+    def content_type=: (String, ?charset: String?) -> self
+    def content_length=: (Integer) -> self
+    def write: (String) -> self
+    def <<: (String) -> self
+    def json: (untyped, ?status: Integer) -> self
+    def html: (String, ?status: Integer) -> self
+    def text: (String, ?status: Integer) -> self
+    def redirect: (String, ?status: Integer) -> self
+    def set_cookie: (String, String, **untyped) -> self
+    def delete_cookie: (String, **untyped) -> self
+    def stream: () { (StreamWriter) -> void } -> self
+    def streaming?: -> bool
+    def sent?: -> bool
+    def mark_sent!: -> void
+    def to_rack: -> [Integer, Hash[String, String], Array[String]]
+    def finish: -> [Integer, Hash[String, String], Array[String]]
+  end
+
+  class StreamBody
+    def initialize: () { (StreamWriter) -> void } -> void
+    def each: () { (String) -> void } -> void
+  end
+
+  class StreamWriter
+    def initialize: () { (String) -> void } -> void
+    def write: (String) -> void
+    def <<: (String) -> void
+  end
+
+  class Params
+    Boolean: Object
+
+    attr_reader raw: Hash[Symbol, untyped]
+
+    def initialize: (?Hash[Symbol, untyped]) -> void
+    def []: (Symbol | String) -> untyped
+    def key?: (Symbol | String) -> bool
+    def has_key?: (Symbol | String) -> bool
+    def fetch: (Symbol | String, ?untyped) -> untyped
+    def require: (Symbol | String, ?type: Class?) -> untyped
+    def optional: (Symbol | String, ?type: Class?, ?default: untyped) -> untyped
+    def permit: (*Symbol) -> Hash[Symbol, untyped]
+    def slice: (*Symbol) -> Hash[Symbol, untyped]
+    def except: (*Symbol) -> Hash[Symbol, untyped]
+    def merge: (Hash[Symbol, untyped]) -> Params
+    def to_h: -> Hash[Symbol, untyped]
+    def to_hash: -> Hash[Symbol, untyped]
+    def each: () { ([Symbol, untyped]) -> void } -> void
+    def empty?: -> bool
+    def size: -> Integer
+    def length: -> Integer
+    def inspect: -> String
+  end
+
+  class ParamSchema
+    attr_reader rules: Hash[Symbol, Hash[Symbol, untyped]]
+
+    def initialize: -> void
+    def requires: (Symbol, type: Class, **untyped) -> void
+    def optional: (Symbol, type: Class, ?default: untyped, **untyped) -> void
+    def validate: (Params | Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+  end
+
+  class Controller
+    def self.params: () ?{ (ParamSchema) -> void } -> ParamSchema
+    def self.param_schema: -> ParamSchema?
+    def self.before_action: (Symbol, ?only: Array[Symbol]?, ?except: Array[Symbol]?) -> void
+    def self.after_action: (Symbol, ?only: Array[Symbol]?, ?except: Array[Symbol]?) -> void
+    def self.around_action: (Symbol, ?only: Array[Symbol]?, ?except: Array[Symbol]?) -> void
+    def self.filters: -> Hash[Symbol, Array[Hash[Symbol, untyped]]]
+    def self.rescue_from: (Class, with: Symbol) -> void
+    def self.rescue_handlers: -> Hash[Class, Symbol]
+    def self.skip_before_action: (Symbol, ?only: Array[Symbol]?, ?except: Array[Symbol]?) -> void
+    def self.skipped_filters: -> Hash[Symbol, Array[Hash[Symbol, untyped]]]
+
+    attr_reader request: Request
+    attr_reader response: Response
+    attr_reader params: Params
+    attr_reader action_name: Symbol
+
+    def initialize: (Request, Response, Symbol) -> void
+    def dispatch: -> Response
+    def validated_params: -> Hash[Symbol, untyped]
+    def render: (?json: untyped, ?html: String?, ?text: String?, ?status: Integer, **untyped) -> void
+    def redirect_to: (String, ?status: Integer) -> void
+    def send_file: (String, ?content_type: String?, ?filename: String?, ?disposition: String) -> void
+    def stream: () { (StreamWriter) -> void } -> void
+    def head: (Integer, **String) -> void
+    def halt!: -> void
+    def halted?: -> bool
+    def session: -> Hash[Symbol, untyped]
+    def flash: -> Hash[Symbol, untyped]
+  end
+
+  module Middleware
+    class Stack
+      attr_reader middlewares: Array[Hash[Symbol, untyped]]
+
+      def initialize: -> void
+      def use: (Class, *untyped, **untyped) -> self
+      def insert_before: (Class, Class, *untyped, **untyped) -> self
+      def insert_after: (Class, Class, *untyped, **untyped) -> self
+      def delete: (Class) -> self
+      def swap: (Class, Class, *untyped, **untyped) -> self
+      def build: (untyped) -> untyped
+      def call: (Request, Response, untyped) -> Response
+      def include?: (Class) -> bool
+      def size: -> Integer
+      def clear: -> self
+    end
+
+    class Base
+      attr_reader app: untyped
+      attr_reader options: Hash[Symbol, untyped]
+
+      def initialize: (untyped, **untyped) -> void
+      def call: (Request, Response) -> Response
+    end
+
+    class CORS < Base
+    end
+
+    class CSRF < Base
+    end
+
+    class RateLimit < Base
+    end
+
+    class Static < Base
+    end
+
+    class Logger < Base
+    end
+
+    class Compression < Base
+    end
+  end
+
+  class WebSocket
+    GUID: String
+    OPCODES: Hash[Symbol, Integer]
+
+    def self.on: (Symbol) { (*untyped) -> void } -> void
+    def self.handlers: -> Hash[Symbol, Proc]
+    def self.subscribe: (String) -> Array[WebSocket]
+    def self.broadcast: (String, String) -> void
+    def self.channels: -> Hash[String, Array[WebSocket]]
+
+    attr_reader request: Request
+    attr_reader params: Params
+    attr_reader socket: untyped
+
+    def initialize: (Request, untyped) -> void
+    def handshake!: -> bool
+    def run: -> void
+    def send_message: (String) -> void
+    def send: (String) -> void
+    def send_binary: (String) -> void
+    def close: (?code: Integer, ?reason: String) -> void
+    def subscribe: (String) -> void
+    def unsubscribe: (String) -> void
+    def broadcast: (String, String) -> void
+    def open?: -> bool
+  end
+
+  class SSE
+    attr_reader request: Request
+    attr_reader response: Response
+
+    def initialize: (Request, Response) -> void
+    def start: -> void
+    def send: (String, ?event: String?, ?id: String?, ?retry_ms: Integer?) -> void
+    def comment: (String) -> void
+    def close: -> void
+    def open?: -> bool
+  end
+
+  class Query[T]
+    include Enumerable[T]
+
+    attr_reader model: Class
+    attr_reader conditions: Array[Hash[Symbol, untyped]]
+    attr_reader order_clauses: Array[Hash[Symbol, untyped]]
+    attr_reader limit_value: Integer?
+    attr_reader offset_value: Integer?
+    attr_reader select_columns: Array[Symbol | String]
+    attr_reader join_clauses: Array[Hash[Symbol, untyped]]
+    attr_reader include_associations: Array[Symbol]
+
+    def initialize: (Class) -> void
+    def where: (?Hash[Symbol, untyped]?, **untyped) -> Query[T]
+    def where_not: (**untyped) -> Query[T]
+    def order: (*Symbol, **untyped) -> Query[T]
+    def limit: (Integer) -> Query[T]
+    def offset: (Integer) -> Query[T]
+    def select: (*Symbol) -> Query[T]
+    def joins: (Symbol | String, ?on: String?, ?type: Symbol) -> Query[T]
+    def includes: (*Symbol) -> Query[T]
+    def first: -> T?
+    def last: -> T?
+    def count: -> Integer
+    def exists?: -> bool
+    def empty?: -> bool
+    def find_or_create_by: (Hash[Symbol, untyped], ?create_with: Hash[Symbol, untyped]) -> T
+    def find_or_initialize_by: (Hash[Symbol, untyped]) -> T
+    def each: () { (T) -> void } -> void
+    def to_a: -> Array[T]
+    def to_sql: -> String
+    def pluck: (*Symbol) -> Array[untyped]
+    def ids: -> Array[untyped]
+    def update_all: (Hash[Symbol, untyped]) -> Integer
+    def delete_all: -> Integer
+  end
+
+  class Model
+    def self.attribute: (Symbol, Symbol, **untyped) -> void
+    def self.attributes: -> Hash[Symbol, Hash[Symbol, untyped]]
+    def self.validates: (Symbol, **untyped) -> void
+    def self.validations: -> Hash[Symbol, Array[Hash[Symbol, untyped]]]
+    def self.has_many: (Symbol, ?class_name: String?, ?foreign_key: String?, **untyped) -> void
+    def self.belongs_to: (Symbol, ?class_name: String?, ?foreign_key: String?, **untyped) -> void
+    def self.has_one: (Symbol, ?class_name: String?, ?foreign_key: String?, **untyped) -> void
+    def self.associations: -> Hash[Symbol, Hash[Symbol, Hash[Symbol, untyped]]]
+    def self.table_name: (?String?) -> String
+    def self.primary_key: (?Symbol?) -> Symbol
+    def self.find: (untyped) -> instance?
+    def self.find!: (untyped) -> instance
+    def self.find_by: (**untyped) -> instance?
+    def self.all: -> Array[instance]
+    def self.query: -> Query[instance]
+    def self.where: (*untyped, **untyped) -> Query[instance]
+    def self.order: (*untyped, **untyped) -> Query[instance]
+    def self.limit: (Integer) -> Query[instance]
+    def self.offset: (Integer) -> Query[instance]
+    def self.select: (*Symbol) -> Query[instance]
+    def self.joins: (Symbol | String, **untyped) -> Query[instance]
+    def self.includes: (*Symbol) -> Query[instance]
+    def self.create: (?Hash[Symbol, untyped]) -> instance
+    def self.create!: (?Hash[Symbol, untyped]) -> instance
+    def self.coerce: (untyped, Symbol) -> untyped
+    def self.connection=: (untyped) -> untyped
+    def self.connection: -> untyped
+
+    attr_reader errors: Hash[Symbol, Array[String]]
+
+    def initialize: (?Hash[Symbol, untyped]) -> void
+    def id: -> untyped
+    def id=: (untyped) -> void
+    def new_record?: -> bool
+    def persisted?: -> bool
+    def destroyed?: -> bool
+    def changed?: -> bool
+    def changed_attributes: -> Array[Symbol]
+    def valid?: -> bool
+    def save: -> bool
+    def save!: -> bool
+    def update: (Hash[Symbol, untyped]) -> bool
+    def update!: (Hash[Symbol, untyped]) -> bool
+    def destroy: -> bool
+    def reload: -> self
+    def to_h: -> Hash[Symbol, untyped]
+    def to_hash: -> Hash[Symbol, untyped]
+    def to_json: (*untyped) -> String
+    def inspect: -> String
+  end
+
+  class RecordNotFoundError < Error
+    attr_reader model: Class
+    attr_reader id: untyped
+    def initialize: (Class, untyped) -> void
+  end
+end

metadata

@@ -0,0 +1,230 @@
+--- !ruby/object:Gem::Specification
+name: tarsier
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Eira Elif
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+- !ruby/object:Gem::Dependency
+  name: memory_profiler
+  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'
+- !ruby/object:Gem::Dependency
+  name: stackprof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+description: Tarsier is a fast, clean Ruby web framework with async support, compiled
+  routing, and zero runtime dependencies.
+email:
+- tarsier.rb@protonmail.com
+executables:
+- tarsier
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/tarsier
+- lib/tarsier.rb
+- lib/tarsier/application.rb
+- lib/tarsier/cli.rb
+- lib/tarsier/cli/commands/console.rb
+- lib/tarsier/cli/commands/generate.rb
+- lib/tarsier/cli/commands/help.rb
+- lib/tarsier/cli/commands/new.rb
+- lib/tarsier/cli/commands/routes.rb
+- lib/tarsier/cli/commands/server.rb
+- lib/tarsier/cli/commands/version.rb
+- lib/tarsier/cli/generators/app.rb
+- lib/tarsier/cli/generators/base.rb
+- lib/tarsier/cli/generators/controller.rb
+- lib/tarsier/cli/generators/middleware.rb
+- lib/tarsier/cli/generators/migration.rb
+- lib/tarsier/cli/generators/model.rb
+- lib/tarsier/cli/generators/resource.rb
+- lib/tarsier/cli/loader.rb
+- lib/tarsier/controller.rb
+- lib/tarsier/database.rb
+- lib/tarsier/errors.rb
+- lib/tarsier/middleware/base.rb
+- lib/tarsier/middleware/compression.rb
+- lib/tarsier/middleware/cors.rb
+- lib/tarsier/middleware/csrf.rb
+- lib/tarsier/middleware/logger.rb
+- lib/tarsier/middleware/rate_limit.rb
+- lib/tarsier/middleware/stack.rb
+- lib/tarsier/middleware/static.rb
+- lib/tarsier/model.rb
+- lib/tarsier/params.rb
+- lib/tarsier/query.rb
+- lib/tarsier/request.rb
+- lib/tarsier/response.rb
+- lib/tarsier/router.rb
+- lib/tarsier/router/compiler.rb
+- lib/tarsier/router/node.rb
+- lib/tarsier/router/route.rb
+- lib/tarsier/version.rb
+- lib/tarsier/websocket.rb
+- sig/tarsier.rbs
+homepage: https://github.com/tarsier-rb/tarsier
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/tarsier-rb/tarsier
+  source_code_uri: https://github.com/tarsier-rb/tarsier
+  changelog_uri: https://github.com/tarsier-rb/tarsier/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: A modern, high-performance Ruby web framework
+test_files: []