tokra 0.0.1.pre.1 → 0.0.1.pre.2

data/ext/tokra/src/webview.rs

@@ -0,0 +1,194 @@
+// SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+//! `WebView` wrapper for wry.
+//!
+//! This module provides the Ruby-facing `Tokra::Native::WebView` class,
+//! which wraps `wry::WebView` and implements the tokra:// custom protocol.
+
+use magnus::{function, method, prelude::*, Error, Ruby, Value};
+use wry::{PageLoadEvent, WebView, WebViewBuilder};
+
+use crate::proxy::RbProxy;
+use crate::responders::{get_responders, next_request_id};
+use crate::runtime_error;
+use crate::user_event::UserEvent;
+use crate::window::RbWindow;
+
+/// Ruby wrapper for `wry::WebView`.
+#[magnus::wrap(class = "Tokra::Native::WebView", free_immediately, size)]
+pub struct RbWebView {
+    inner: WebView,
+}
+
+// SPDX-SnippetBegin
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+// SPDX-SnippetCopyrightText: 2020-2023 Tauri Programme within The Commons Conservancy
+// SPDX-SnippetComment: Thread safety pattern adapted from tauri-runtime-wry/lib.rs unsafe impl Send for WindowsStore
+
+// SAFETY: RbWebView is only accessed from the main thread. WebView operations
+// are only performed within the event loop callback on the main thread.
+// This matches Tauri's pattern in tauri-runtime-wry where they use:
+// `unsafe impl Send for WindowsStore {}` with the comment:
+// "SAFETY: we ensure this type is only used on the main thread."
+// See clippy_exceptions.rb for full justification.
+#[allow(unsafe_code)]
+#[allow(clippy::non_send_fields_in_send_ty)]
+unsafe impl Send for RbWebView {}
+
+// SPDX-SnippetEnd
+
+impl RbWebView {
+    /// Create a new `WebView` attached to the given `Window`.
+    ///
+    /// The `ipc_callback` must be a `Ractor.shareable_proc`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if `WebView` creation fails.
+    // Magnus FFI requires owned types at the Ruby-Rust boundary.
+    // See clippy_exceptions.rb for justification.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn new(
+        window: &RbWindow,
+        url: String,
+        _ipc_callback: Value,
+        proxy: &RbProxy,
+    ) -> Result<Self, Error> {
+        let proxy_clone = proxy.inner().clone();
+
+        let webview = WebViewBuilder::new()
+            .with_url(&url)
+            .with_ipc_handler(move |msg| {
+                let _ = proxy_clone.send_event(UserEvent::IpcMessage(msg.body().clone()));
+            })
+            .build(&window.inner)
+            .map_err(|e| Error::new(runtime_error(), e.to_string()))?;
+
+        Ok(Self { inner: webview })
+    }
+
+    // SPDX-SnippetBegin
+    // SPDX-License-Identifier: Apache-2.0 OR MIT
+    // SPDX-SnippetCopyrightText: 2020-2023 Tauri Programme within The Commons Conservancy
+    // SPDX-SnippetComment: Async custom protocol pattern adapted from tauri/app.rs register_asynchronous_uri_scheme_protocol
+    //                      Initial URL pattern adapted from tauri/manager/webview.rs WebviewUrl::App
+    //                      Page load handler pattern adapted from tauri/webview/mod.rs on_page_load
+
+    /// Create a new `WebView` with the `tokra://` custom protocol.
+    ///
+    /// This is the primary constructor for Rack-style apps. The `WebView` navigates
+    /// to `tokra://localhost/` and Ruby handles all requests via `HttpRequestEvent`.
+    /// Ruby controls everything: initial HTML, form submissions, API responses.
+    ///
+    /// This matches Tauri's pattern where apps load from `tauri://localhost/`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if `WebView` creation fails.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the responders mutex is poisoned (internal invariant violation).
+    pub fn new_with_protocol(window: &RbWindow, proxy: &RbProxy) -> Result<Self, Error> {
+        let proxy_clone = proxy.inner().clone();
+        let proxy_for_protocol = proxy.inner().clone();
+        let proxy_for_page_load = proxy.inner().clone();
+
+        let webview = WebViewBuilder::new()
+            .with_url("tokra://localhost/")
+            .with_asynchronous_custom_protocol(
+                "tokra".into(),
+                move |_webview_id, request, responder| {
+                    // Generate unique request ID
+                    let request_id = next_request_id();
+
+                    // Extract request details
+                    let method = request.method().to_string();
+                    let uri = request.uri().to_string();
+
+                    // SPDX-SnippetBegin
+                    // SPDX-License-Identifier: Apache-2.0 OR MIT
+                    // SPDX-SnippetCopyrightText: 2019-2024 Tauri Programme within The Commons Conservancy
+                    // SPDX-SnippetComment: Header extraction pattern adapted from tauri/src/protocol/tauri.rs request.headers() iteration
+
+                    // Extract headers for CSRF/Cookie support (ADR 002 requirement)
+                    let headers: Vec<(String, String)> = request
+                        .headers()
+                        .iter()
+                        .map(|(name, value)| {
+                            (name.to_string(), value.to_str().unwrap_or("").to_string())
+                        })
+                        .collect();
+
+                    // SPDX-SnippetEnd
+
+                    let body = String::from_utf8_lossy(request.body()).to_string();
+
+                    // Store the responder for later (Ruby will call back with the response)
+                    get_responders()
+                        .lock()
+                        .unwrap()
+                        .insert(request_id, responder);
+
+                    // Send HTTP request through the event loop to Ruby
+                    // Ruby will process and send back an HttpResponse event
+                    let _ = proxy_for_protocol.send_event(UserEvent::HttpRequest {
+                        request_id,
+                        method,
+                        uri,
+                        headers,
+                        body,
+                    });
+                },
+            )
+            .with_on_page_load_handler(move |event, url| {
+                let event_name = match event {
+                    PageLoadEvent::Started => "started",
+                    PageLoadEvent::Finished => "finished",
+                };
+                let _ = proxy_for_page_load.send_event(UserEvent::PageLoad {
+                    event: event_name.to_string(),
+                    url,
+                });
+            })
+            // SPDX-SnippetEnd
+            .with_ipc_handler(move |msg| {
+                let _ = proxy_clone.send_event(UserEvent::IpcMessage(msg.body().clone()));
+            })
+            .build(&window.inner)
+            .map_err(|e| Error::new(runtime_error(), e.to_string()))?;
+
+        Ok(Self { inner: webview })
+    }
+
+    /// Evaluate JavaScript in the `WebView`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if JavaScript evaluation fails.
+    // Magnus FFI requires owned types at the Ruby-Rust boundary.
+    // See clippy_exceptions.rb for justification.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn eval(&self, js: String) -> Result<(), Error> {
+        self.inner
+            .evaluate_script(&js)
+            .map_err(|e| Error::new(runtime_error(), e.to_string()))
+    }
+}
+
+/// Define the `WebView` class methods on the given Ruby module.
+///
+/// # Errors
+///
+/// Returns an error if class or method definition fails.
+pub fn define_class(ruby: &Ruby, native: magnus::RModule) -> Result<(), Error> {
+    let webview_class = native.define_class("WebView", ruby.class_object())?;
+    webview_class.define_singleton_method("new", function!(RbWebView::new, 4))?;
+    webview_class.define_singleton_method(
+        "new_with_protocol",
+        function!(RbWebView::new_with_protocol, 2),
+    )?;
+    webview_class.define_method("eval", method!(RbWebView::eval, 1))?;
+    Ok(())
+}

data/ext/tokra/src/window.rs

@@ -0,0 +1,92 @@
+// SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+//! Window wrapper for tao.
+//!
+//! This module provides the Ruby-facing `Tokra::Native::Window` class,
+//! which wraps `tao::window::Window`.
+
+use magnus::{function, method, prelude::*, Error, Ruby};
+use tao::window::{Window, WindowBuilder};
+
+use crate::event_loop::RbEventLoop;
+use crate::runtime_error;
+
+/// Ruby wrapper for `tao::window::Window`.
+#[magnus::wrap(class = "Tokra::Native::Window", free_immediately, size)]
+pub struct RbWindow {
+    pub(crate) inner: Window,
+}
+
+// SPDX-SnippetBegin
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+// SPDX-SnippetCopyrightText: 2020-2023 Tauri Programme within The Commons Conservancy
+// SPDX-SnippetComment: Thread safety pattern adapted from tauri-runtime-wry/lib.rs unsafe impl Send for WindowsStore/WindowBuilderWrapper
+
+// SAFETY: RbWindow is only accessed from the main thread. Window operations
+// are only performed within the event loop callback on the main thread.
+// This matches Tauri's pattern in tauri-runtime-wry.
+// See clippy_exceptions.rb for full justification.
+#[allow(unsafe_code)]
+unsafe impl Send for RbWindow {}
+
+// SPDX-SnippetEnd
+
+impl RbWindow {
+    /// Create a new `Window` attached to the given `EventLoop`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the event loop has been consumed or window creation fails.
+    pub fn new(event_loop: &RbEventLoop) -> Result<Self, Error> {
+        let el = event_loop.inner.borrow();
+        let el_ref = el.as_ref().ok_or_else(|| {
+            Error::new(
+                runtime_error(),
+                "EventLoop has already been consumed by run()",
+            )
+        })?;
+
+        let window = WindowBuilder::new()
+            .with_title("Tokra")
+            .build(el_ref)
+            .map_err(|e| Error::new(runtime_error(), e.to_string()))?;
+
+        Ok(Self { inner: window })
+    }
+
+    /// Set the window title.
+    // Magnus FFI requires owned types at the Ruby-Rust boundary.
+    // See clippy_exceptions.rb for justification.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn set_title(&self, title: String) {
+        self.inner.set_title(&title);
+    }
+
+    /// Set the window inner size.
+    pub fn set_size(&self, width: f64, height: f64) {
+        use tao::dpi::LogicalSize;
+        let size = LogicalSize::new(width, height);
+        self.inner.set_inner_size(size);
+    }
+
+    /// Get the window ID as a string.
+    #[must_use]
+    pub fn id(&self) -> String {
+        format!("{:?}", self.inner.id())
+    }
+}
+
+/// Define the `Window` class methods on the given Ruby module.
+///
+/// # Errors
+///
+/// Returns an error if class or method definition fails.
+pub fn define_class(ruby: &Ruby, native: magnus::RModule) -> Result<(), Error> {
+    let window_class = native.define_class("Window", ruby.class_object())?;
+    window_class.define_singleton_method("new", function!(RbWindow::new, 1))?;
+    window_class.define_method("set_title", method!(RbWindow::set_title, 1))?;
+    window_class.define_method("set_size", method!(RbWindow::set_size, 2))?;
+    window_class.define_method("id", method!(RbWindow::id, 0))?;
+    Ok(())
+}

data/lib/tokra/rack/handler.rb

@@ -63,16 +63,14 @@ module Rack # :nodoc:
         #
         #   Rack::Handler::Tokra.run(MyApp.freeze.app)
         #
-        def run(app, **options)
-          opts = DEFAULT_OPTIONS.merge(options)
-
+        def run(app, title: "Tokra", width: 800.0, height: 600.0, invoke_handler: nil)
           # Create Tokra components
           event_loop = ::Tokra::Native::EventLoop.new
           proxy = event_loop.create_proxy
 
           window = ::Tokra::Native::Window.new(event_loop)
-          window.set_title(opts[:title])
-          window.set_size(opts[:width].to_f, opts[:height].to_f)
+          window.set_title(title)
+          window.set_size(width.to_f, height.to_f)
 
           # Create the handler
           handler = new(app, proxy)
@@ -83,7 +81,13 @@ module Rack # :nodoc:
           # Run the event loop, dispatching HTTP requests to the Rack app
           event_loop.run(
             lambda { |event|
-              handler.call(event) if event.is_a?(::Tokra::Native::HttpRequestEvent)
+              case event
+              when ::Tokra::Native::HttpRequestEvent
+                handler.call(event)
+              when ::Tokra::Native::IpcEvent
+                # If an invoke_handler is provided, call it with the message
+                invoke_handler&.call(event.message)
+              end
             }
           )
         end
@@ -110,7 +114,7 @@ module Rack # :nodoc:
       # 4. Sends the final response back through the protocol
       def call(event)
         uri = URI.parse(event.uri)
-        env = build_env(uri, event.method, event.body)
+        env = build_env(uri, event.method, event.body, event)
 
         # Follow redirects internally (WKWebView doesn't follow for custom protocols)
         redirect_count = 0
@@ -133,15 +137,27 @@ module Rack # :nodoc:
 
             # Follow the redirect with GET (PRG pattern)
             new_uri = URI.parse(headers["location"])
-            env = build_env(new_uri, "GET", "", cookies)
+            env = build_env(new_uri, "GET", "", nil, cookies)
             next
           end
 
           # Send the response
-          header_pairs = headers.map { |k, v| [k.to_s, v.to_s] }
-
-          body_str = String.new
-          body.each { |chunk| body_str << chunk }
+          header_pairs = headers.map { |k, v| [k.to_s, v.to_s] } #: Array[[String, String]]
+
+          # Prefer to_ary over each - Rails RackBody#each triggers synchronization
+          # (sending!/sent!) that can cause rendering issues in single-threaded contexts.
+          # to_ary bypasses this and returns the raw body array directly.
+          body_str = if body.respond_to?(:to_ary)
+            body.to_ary.join
+          elsif body.respond_to?(:to_path)
+            # Rack::Files::Iterator provides to_path for sendfile optimization
+            # Read the file directly instead of iterating
+            File.read(body.to_path)
+          else
+            buf = String.new
+            body.each { |chunk| buf << chunk }
+            buf
+          end
           body.close if body.respond_to?(:close)
 
           @proxy.respond(event.request_id, status, header_pairs, body_str)
@@ -149,11 +165,11 @@ module Rack # :nodoc:
         end
       end
 
-      private def build_env(uri, method, body, cookies = nil)
+      private def build_env(uri, method, body, event = nil, cookies = nil)
         env = {
           "REQUEST_METHOD" => method,
           "SCRIPT_NAME" => "",
-          "PATH_INFO" => uri.path.empty? ? "/" : uri.path,
+          "PATH_INFO" => (uri.path.nil? || uri.path.empty?) ? "/" : uri.path,
           "QUERY_STRING" => uri.query || "",
           "SERVER_NAME" => uri.host || "localhost",
           "SERVER_PORT" => (uri.port || 80).to_s,
@@ -165,6 +181,13 @@ module Rack # :nodoc:
           "rack.multiprocess" => false,
           "rack.run_once" => false,
         }
+
+        # Forward only the Cookie header from WebView
+        # Other headers (Accept-Encoding, etc.) caused rendering issues in WKWebView
+        event&.headers&.each do |(name, value)|
+          env["HTTP_COOKIE"] = value if name.downcase == "cookie"
+        end
+
         env["HTTP_COOKIE"] = cookies if cookies
         env
       end

data/lib/tokra/version.rb

@@ -8,5 +8,5 @@
 
 module Tokra
   # TODO: Document me.
-  VERSION = "0.0.1.pre.1"
+  VERSION = "0.0.1.pre.2"
 end

data/rbs_exceptions.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+# Approved RBS 'untyped' exceptions.
+# Each entry must explain WHY the exception is unavoidable.
+# Review carefully before adding new entries.
+
+# Currently no exceptions - all types should be explicit.

data/sig/tokra.rbs

@@ -3,5 +3,99 @@
 
 module Tokra
   VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  class Error < StandardError
+  end
+
+  # Native extension classes (implemented in Rust via Magnus)
+  module Native
+    class EventLoop
+      def initialize: () -> void
+      def create_proxy: () -> Proxy
+      def run: (^(HttpRequestEvent | IpcEvent | WakeUpEvent | WindowCloseEvent | PageLoadEvent) -> void) -> void
+    end
+
+    class Window
+      def initialize: (EventLoop) -> void
+      def set_title: (String) -> void
+      def set_size: (Float, Float) -> void
+    end
+
+    class WebView
+      def self.new_with_protocol: (Window, Proxy) -> WebView
+      def initialize: (Window, String, ^(String) -> void, Proxy) -> void
+      def eval: (String) -> void
+    end
+
+    class Proxy
+      def respond: (Integer, Integer, Array[[String, String]], String) -> void
+      def send_http_response: (Integer, Integer, Hash[String, String], String) -> void
+    end
+
+    class HttpRequestEvent
+      def request_id: () -> Integer
+      def method: () -> String
+      def uri: () -> String
+      def headers: () -> Array[[String, String]]
+      def body: () -> String
+    end
+
+    class IpcEvent
+      def message: () -> String
+    end
+
+    class WakeUpEvent
+    end
+
+    class WindowCloseEvent
+    end
+
+    class PageLoadEvent
+      def event: () -> String
+      def url: () -> String
+    end
+  end
+end
+
+# Rack types based on Rack 3.x spec
+module Rack
+  type env = Hash[String, (String | Integer | Array[Integer] | IO | bool | nil | StringIO)]
+  type headers = Hash[String, String]
+  type status = Integer
+
+  # Rack body - any object that responds to each yielding strings
+  # We use Object as base to get respond_to? and other Object methods
+  class Body < Object
+    def each: () { (String) -> void } -> void
+    def close: () -> void
+    # Optional: Array-style bodies
+    def to_ary: () -> Array[String]
+    # Optional: File path for sendfile optimization
+    def to_path: () -> String
+  end
+
+  type response = [status, headers, Body]
+
+  interface _App
+    def call: (env) -> response
+  end
+
+  module Handler
+    class Tokra
+      MAX_REDIRECTS: Integer
+      DEFAULT_OPTIONS: { title: String, width: Float, height: Float }
+
+      @app: Rack::_App
+      @proxy: ::Tokra::Native::Proxy
+
+      def self.run: (Rack::_App app, ?title: String, ?width: Float, ?height: Float, ?invoke_handler: (^(String) -> void)?) -> void
+
+      def initialize: (Rack::_App app, ::Tokra::Native::Proxy proxy) -> void
+      def call: (::Tokra::Native::HttpRequestEvent event) -> void
+
+      private
+
+      def build_env: (URI::Generic uri, String method, String body, ?::Tokra::Native::HttpRequestEvent? event, ?String? cookies) -> Rack::env
+      def respond_with_error: (Integer request_id, Integer status, String message) -> void
+    end
+  end
 end

data/tasks/lint.rake

@@ -122,10 +122,10 @@ namespace :lint do
     sh "bundle exec rake rdoc:coverage"
   end
 
-  task docs: %w[rdoc:coverage rubycritic reuse:lint]
+  task docs: %w[safe_rdoc_coverage rubycritic reuse:lint]
   task code: %w[rubocop rubycritic lint:rust]
   task licenses: %w[reuse:lint]
-  task all: %w[docs code licenses]
+  task all: %w[docs code licenses rbs]
 
   namespace :fix do
     desc "Auto-fix RuboCop offenses (most aggressive)"

data/tasks/lint.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+# Declared lint exceptions with justifications.
+class Lint
+  def self.load(path) = new(path)
+
+  def initialize(path)
+    @path = path
+    instance_eval(File.read(path))
+  end
+
+  def allow(path, line: nil, lines: nil, lint: nil, reason:)
+    line_numbers = lines || [line]
+    line_numbers.each { |n| list << "#{path}:#{n}" }
+  end
+
+  # Enforce no violations. Aborts with message if any found, otherwise prints success.
+  def enforce!(glob:, pattern:, reject_pattern: nil, violation_name:)
+    found = violations(glob:, pattern:, reject_pattern:)
+
+    abort <<~ERROR if found.any?
+      ❌ Unapproved #{violation_name} found:
+      #{found.join("\n")}
+
+      Add to #{File.basename(@path)} with justification if truly unavoidable.
+    ERROR
+
+    puts "✅ No unapproved #{violation_name} found"
+  end
+
+  def violations(glob:, pattern:, reject_pattern: nil)
+    Dir.glob(glob)
+      .reject { |f| f.include?("/target/") }
+      .flat_map { |file| File.readlines(file).map.with_index(1) { |line, n| [file, n, line] } }
+      .select { |_, _, line| pattern.match?(line) }
+      .reject { |_, _, line| reject_pattern&.match?(line) }
+      .reject { |file, n, _| include?("#{file}:#{n}") }
+      .map { |file, n, line| "  #{file}:#{n}: #{line.strip}" }
+  end
+
+  def include?(location) = list.any? { |ex| location.start_with?(ex) }
+  def to_a = list
+  def list = @list ||= []
+end

data/tasks/rust.rake

@@ -5,12 +5,7 @@
 # SPDX-License-Identifier: AGPL-3.0-or-later
 #++
 
-class ClippyExceptions
-  def self.load(path) = new.tap { |e| e.instance_eval(File.read(path)) }
-  def allow(path, line:, reason:) = list << "#{path}:#{line}"
-  def to_a = list
-  def list = @list ||= []
-end
+require_relative "lint"
 
 namespace :rust do
   desc "Check Rust formatting with cargo fmt"
@@ -37,23 +32,11 @@ namespace :rust do
 
   desc "Forbid #[allow(clippy::...)] except approved exceptions"
   task :no_allows do
-    exceptions = ClippyExceptions.load(File.expand_path("../clippy_exceptions.rb", __dir__))
-
-    violations = Dir.glob("ext/**/*.rs")
-      .reject { |f| f.include?("/target/") }
-      .flat_map { |file| File.readlines(file).map.with_index(1) { |line, n| [file, n, line] } }
-      .select { |_, _, line| line.include?("#[allow(clippy::") }
-      .reject { |file, n, _| exceptions.to_a.any? { |ex| "#{file}:#{n}".start_with?(ex) } }
-      .map { |file, n, line| "  #{file}:#{n}: #{line.strip}" }
-
-    abort <<~ERROR if violations.any?
-      ❌ Unapproved #[allow(clippy::...)] found:
-      #{violations.join("\n")}
-
-      Add to clippy_exceptions.rb with justification if truly unavoidable.
-    ERROR
-
-    puts "✅ No unapproved Clippy allows found"
+    Lint.load(File.expand_path("../clippy_exceptions.rb", __dir__)).enforce!(
+      glob: "ext/**/*.rs",
+      pattern: /#\[allow\(clippy::/,
+      violation_name: "#[allow(clippy::...)]"
+    )
   end
 end
 

data/tasks/steep.rake

@@ -5,7 +5,29 @@
 # SPDX-License-Identifier: AGPL-3.0-or-later
 #++
 
-desc "Run Steep type checker"
-task :steep do
-  sh "bundle exec steep check"
+require_relative "lint"
+
+namespace :steep do
+  desc "Run Steep type checker"
+  task :check do
+    sh "bundle exec steep check"
+  end
+
+  desc "Forbid 'untyped' in RBS files except approved exceptions"
+  task :no_untyped do
+    Lint.load(File.expand_path("../rbs_exceptions.rb", __dir__)).enforce!(
+      glob: "sig/**/*.rbs",
+      pattern: /\buntyped\b/,
+      reject_pattern: /^\s*#/,
+      violation_name: "'untyped' in RBS files"
+    )
+  end
+end
+
+desc "Run Steep type checker (with no_untyped check)"
+task steep: %w[steep:check steep:no_untyped]
+
+namespace :lint do
+  desc "Run RBS linting (no unapproved untyped)"
+  task rbs: "steep:no_untyped"
 end

data/tasks/test.rake

@@ -21,6 +21,6 @@ namespace :test do
 
   # Create a specific Minitest task for Ruby tests
   Minitest::TestTask.create(:ruby) do |t|
-    t.test_globs = ["test/**/*.rb", "examples/**/test_*.rb"]
+    t.test_globs = ["test/**/*.rb"]
   end
 end