wesc 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65b91a95acd3078a53de01dd1a5f73f99d0057c2bebffbdcc1340ca0c4195252
-  data.tar.gz: 109ceeea27a5f686e59a9d121af8974bd9e296b0b8be0af2e9a058dc9eb69290
+  metadata.gz: 47c2b769ea5ee8965966048474a3a7e7bd61a5f57aded42e5f17bd23c2a83b33
+  data.tar.gz: cb4939e9e701cf77b033ac27eb9f3a14b071806852c5315cd6bbec692fba0d3c
 SHA512:
-  metadata.gz: d4e239e1c836bece4d89fb23cd76caa418865df89fff7bdc091aa65f0c2790b615f68de025d5aea05f5c0018f33cc04860c15fb33e7dd6e3b0d8c9bbdae70671
-  data.tar.gz: 662b9ee4e0ed332b9b638b39f2854eb2ad0c810764b44e13401e4da93d7485fa76bebc9f4867ddd0c063a234dc4422d0062e285b5090c04f2428b5a5ab5677f6
+  metadata.gz: de1dbfb74b637b3ef8476a489df630cfe8da2e73243f71e9b605dbfad5eab96ef358814584df32c66268575ac7006ab16ea98e6a7088b746cc73550d70e1ef2d
+  data.tar.gz: 2f5b3bd0ac049589f640e3c863b0688818c65ab04e4d49dd1538d5eba6f1a0756467e5c7efb85ed3922efb785141050f1c6fb51ab7573feb41fe30ce3184dd54

data/README.md

@@ -21,9 +21,13 @@ gem install wesc
 ```ruby
 require "wesc"
 
-# One-shot: returns the full HTML output as a (binary) String.
-html = Wesc.build(["./index.html"], minify: true)
-puts "#{html.bytesize} bytes"
+# One-shot: returns a Wesc::Result with the HTML plus the bundled CSS/JS.
+# Pass outcss:/outjs: to also get the bundles (an empty string keeps them in
+# memory only; a path additionally writes the file).
+result = Wesc.build(["./index.html"], outcss: "", outjs: "", minify: true)
+puts "#{result.html.bytesize} bytes of HTML"
+puts result.css # the bundled CSS (nil when outcss: was not requested)
+puts result.js  # the bundled JS  (nil when outjs: was not requested)
 
 # Streaming: low memory, chunk by chunk. The block receives each chunk as a
 # String, then `nil` once to signal end-of-stream. Raising from the block
@@ -35,20 +39,24 @@ end
 
 ## API
 
-- `Wesc.build(entry_points, outcss: nil, outjs: nil, minify: false) -> String`
-- `Wesc.build_stream(entry_points, outcss: nil, outjs: nil, minify: false) { |chunk| ... } -> nil`
+- `Wesc.build(input, outcss: nil, outjs: nil, minify: false) -> Wesc::Result`
+- `Wesc.build_stream(input, outcss: nil, outjs: nil, minify: false) { |chunk| ... } -> nil`
 
 | Argument       | Type                  | Notes                                              |
 | -------------- | --------------------- | -------------------------------------------------- |
-| `entry_points` | `Array<String>`       | First entry is the host document.                  |
-| `outcss`       | `String, nil`         | Path to write the bundled CSS file. `nil` skips.   |
-| `outjs`        | `String, nil`         | Path to write the bundled JS file. `nil` skips.    |
+| `input`        | `Array<String>`       | First entry is the host document.                  |
+| `outcss`       | `String, nil`         | Request the bundled CSS. Path writes the file; `""` is in-memory only; `nil` skips. |
+| `outjs`        | `String, nil`         | Request the bundled JS. Path writes the file; `""` is in-memory only; `nil` skips.  |
 | `minify`       | `Boolean`             | Minify generated assets. Defaults to `false`.      |
 | `&block`       | `{ \|String, nil\| }` | `build_stream` only. Gets each chunk, then `nil`.  |
 
-`build` returns a binary (`ASCII-8BIT`) `String`. `build_stream` yields each
-chunk as a binary `String`, then yields `nil` once to mark end-of-stream — the
-same trailing-`nil`/`None` convention as the Python and PHP bindings.
+`build` returns a `Wesc::Result` (`Struct.new(:html, :css, :js)`): `html` is a
+binary (`ASCII-8BIT`) `String`, and `css`/`js` are binary `String`s when
+requested via `outcss`/`outjs` or `nil` otherwise. `outcss`/`outjs` still write
+the bundle to disk when given a non-empty path; an empty string returns it in
+memory only. `build_stream` yields each HTML chunk as a binary `String`, then
+yields `nil` once to mark end-of-stream — the same trailing-`nil`/`None`
+convention as the Python and PHP bindings.
 
 > The bundler keeps a process-global file/template cache, so builds should not
 > run concurrently within a single process — serialize them (the

data/ext/wesc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wesc-rb"
-version = "0.6.2" # x-release-please-version
+version = "0.7.0" # x-release-please-version
 authors = ["Wesley Luyten <me@wesleyluyten.com>"]
 edition = "2021"
 license = "MIT"
@@ -28,5 +28,5 @@ crate-type = ["cdylib"]
 # the core crate's version (the marker keeps release-please bumping it in
 # lockstep); otherwise the patched local 0.x core fails to satisfy it and the
 # whole workspace stops resolving.
-wesc = "0.6.2" # x-release-please-version
+wesc = "0.7.0" # x-release-please-version
 magnus = "0.7"

data/ext/wesc/src/lib.rs

@@ -13,7 +13,8 @@
 //! wrapper split).
 //!
 //! Two entry points, matching how a server typically consumes a build:
-//! - [`build`]        — returns the full output as a (binary) `String`.
+//! - [`build`]        — returns the full HTML output as a (binary) `String`
+//!   plus the bundled CSS/JS (each `nil` when absent), as a 3-element array.
 //! - [`build_stream`] — yields each chunk to the block (low memory). The block
 //!   runs in Ruby, then receives `nil` once to signal end-of-stream.
 //!
@@ -31,38 +32,51 @@ use wesc::{build as wesc_build, BuildOptions};
 
 /// Assemble [`BuildOptions`] from the native (positional) arguments.
 fn collect_options(
-    entry_points: Vec<String>,
+    input: Vec<String>,
     outcss: Option<String>,
     outjs: Option<String>,
     minify: bool,
 ) -> BuildOptions {
     BuildOptions {
-        entry_points,
+        input,
+        source: None,
         outcss,
         outjs,
+        cwd: None,
         minify,
     }
 }
 
-/// Build the entry points and return the full HTML output as a binary `String`.
+/// Build the entry points and return the full HTML output plus the bundled
+/// CSS/JS.
+///
+/// Returns a 3-tuple `(html, css, js)` — Magnus converts it to a Ruby array,
+/// and each `None` to `nil`. `html` is always present (a binary `String`); the
+/// CSS/JS are bundled and returned when requested via `outcss`/`outjs` and
+/// `nil` otherwise. A non-empty `outcss`/`outjs` path additionally writes the
+/// bundle to disk; an empty string returns it in memory only.
 ///
 /// Exposed to Ruby as `Wesc::Native.build`; see `Wesc.build` in `lib/wesc.rb`
 /// for the public keyword-argument API.
 fn build(
     ruby: &Ruby,
-    entry_points: Vec<String>,
+    input: Vec<String>,
     outcss: Option<String>,
     outjs: Option<String>,
     minify: bool,
-) -> RString {
-    let options = collect_options(entry_points, outcss, outjs, minify);
+) -> (RString, Option<RString>, Option<RString>) {
+    let options = collect_options(input, outcss, outjs, minify);
 
     let mut output: Vec<u8> = Vec::new();
-    wesc_build(options, &mut |chunk: &[u8]| {
+    let assets = wesc_build(options, &mut |chunk: &[u8]| {
         output.extend_from_slice(chunk);
     });
 
-    ruby.str_from_slice(&output)
+    let html = ruby.str_from_slice(&output);
+    let css = assets.css.map(|css| ruby.str_new(&css));
+    let js = assets.js.map(|js| ruby.str_new(&js));
+
+    (html, css, js)
 }
 
 /// Stream the build to the block, chunk by chunk, for low-memory output.
@@ -71,17 +85,21 @@ fn build(
 /// `String`, then once with `nil` to signal the end of the stream. If the block
 /// raises, no further chunks are delivered and the exception propagates out.
 ///
+/// HTML only: this streams just the markup. A non-empty `outcss`/`outjs` path
+/// still bundles and writes the CSS/JS to disk (the in-memory assets are not
+/// returned here — use [`build`] for those).
+///
 /// Exposed to Ruby as `Wesc::Native.build_stream`; see `Wesc.build_stream` in
 /// `lib/wesc.rb` for the public keyword-argument API.
 fn build_stream(
     ruby: &Ruby,
-    entry_points: Vec<String>,
+    input: Vec<String>,
     outcss: Option<String>,
     outjs: Option<String>,
     minify: bool,
 ) -> Result<(), Error> {
     let block = ruby.block_proc()?;
-    let options = collect_options(entry_points, outcss, outjs, minify);
+    let options = collect_options(input, outcss, outjs, minify);
 
     // Remember the first block error so we can stop yielding and surface it.
     let mut pending_error: Option<Error> = None;

data/lib/wesc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wesc
-  VERSION = "0.6.2"
+  VERSION = "0.7.0"
 end

data/lib/wesc.rb

@@ -8,8 +8,9 @@
 #
 #   require "wesc"
 #
-#   # One-shot: returns the full HTML output as a (binary) String.
-#   html = Wesc.build(["./index.html"], minify: true)
+#   # One-shot: returns a Wesc::Result with the HTML plus the bundled CSS/JS.
+#   result = Wesc.build(["./index.html"], minify: true)
+#   result.html # => the rendered HTML (binary String)
 #
 #   # Streaming: low memory, chunk by chunk. The block gets each chunk as a
 #   # String, then `nil` once to signal end-of-stream.
@@ -23,20 +24,33 @@ require_relative "wesc/version"
 require_relative "wesc/wesc_rb"
 
 module Wesc
+  # The result of a one-shot {Wesc.build}: the rendered +html+ plus the bundled
+  # +css+/+js+. The CSS/JS are populated when requested via `outcss`/`outjs`
+  # (an empty string keeps them in memory only; a path also writes the file) and
+  # are `nil` otherwise.
+  Result = Struct.new(:html, :css, :js)
+
   module_function
 
-  # Build the entry points and return the full HTML output as a (binary) String.
+  # Build the entry points and return a {Wesc::Result}.
   #
-  #   html = Wesc.build(["./index.html"], minify: true)
+  #   result = Wesc.build(["./index.html"], minify: true)
+  #   result.html # => the rendered HTML (binary String)
+  #   result.css  # => the bundled CSS, or nil
+  #   result.js   # => the bundled JS, or nil
   #
-  # @param entry_points [Array<String>] entry point paths; the first is the host
+  # @param input [Array<String>] entry point paths; the first is the host
   #   document.
-  # @param outcss [String, nil] optional path to write the bundled CSS file.
-  # @param outjs [String, nil] optional path to write the bundled JS file.
+  # @param outcss [String, nil] request the bundled CSS. A non-empty path also
+  #   writes the file; an empty string keeps it in memory only; `nil` skips it.
+  # @param outjs [String, nil] request the bundled JS. A non-empty path also
+  #   writes the file; an empty string keeps it in memory only; `nil` skips it.
   # @param minify [Boolean] minify generated JS/CSS assets. Defaults to false.
-  # @return [String] the rendered HTML (ASCII-8BIT / binary encoding).
-  def build(entry_points, outcss: nil, outjs: nil, minify: false)
-    Native.build(Array(entry_points), outcss, outjs, minify ? true : false)
+  # @return [Wesc::Result] the rendered HTML (ASCII-8BIT / binary encoding) plus
+  #   the bundled CSS/JS (each `nil` when not requested).
+  def build(input, outcss: nil, outjs: nil, minify: false)
+    html, css, js = Native.build(Array(input), outcss, outjs, minify ? true : false)
+    Result.new(html, css, js)
   end
 
   # Stream the build to a block, chunk by chunk, for low-memory output.
@@ -49,16 +63,16 @@ module Wesc
   #     io.write(chunk) unless chunk.nil?
   #   end
   #
-  # @param entry_points [Array<String>] entry point paths; the first is the host
+  # @param input [Array<String>] entry point paths; the first is the host
   #   document.
   # @param outcss [String, nil] optional path to write the bundled CSS file.
   # @param outjs [String, nil] optional path to write the bundled JS file.
   # @param minify [Boolean] minify generated JS/CSS assets. Defaults to false.
   # @yieldparam chunk [String, nil] each output chunk, then `nil` at end-of-stream.
   # @return [void]
-  def build_stream(entry_points, outcss: nil, outjs: nil, minify: false, &block)
+  def build_stream(input, outcss: nil, outjs: nil, minify: false, &block)
     raise ArgumentError, "Wesc.build_stream requires a block" unless block
 
-    Native.build_stream(Array(entry_points), outcss, outjs, minify ? true : false, &block)
+    Native.build_stream(Array(input), outcss, outjs, minify ? true : false, &block)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wesc
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Wesley Luyten
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-10 00:00:00.000000000 Z
+date: 2026-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys