kreuzberg 4.0.0.pre.rc.11 → 4.0.0.pre.rc.13

data/vendor/rb-sys/build/stable_api_config.rs

@@ -1,155 +1,155 @@
-use rb_sys_build::{RbConfig, RubyEngine};
-
-use crate::{
-    features::is_env_variable_defined,
-    version::{Version, MIN_SUPPORTED_STABLE_VERSION},
-};
-use std::{convert::TryFrom, error::Error, path::Path};
-
-pub fn setup(rb_config: &RbConfig) -> Result<(), Box<dyn Error>> {
-    let ruby_version = Version::current(rb_config);
-    let ruby_engine = rb_config.ruby_engine();
-    let strategy = Strategy::try_from((ruby_engine, ruby_version))?;
-
-    strategy.apply()?;
-
-    Ok(())
-}
-
-#[derive(Debug)]
-enum Strategy {
-    RustOnly(Version),
-    CompiledOnly,
-    RustThenCompiled(Version),
-    Testing(Version),
-}
-
-impl TryFrom<(RubyEngine, Version)> for Strategy {
-    type Error = Box<dyn Error>;
-
-    fn try_from(
-        (engine, current_ruby_version): (RubyEngine, Version),
-    ) -> Result<Self, Self::Error> {
-        let mut strategy = None;
-
-        match engine {
-            RubyEngine::TruffleRuby => {
-                return Ok(Strategy::CompiledOnly);
-            }
-            RubyEngine::JRuby => {
-                return Err("JRuby is not supported".into());
-            }
-            RubyEngine::Mri => {}
-        }
-
-        if current_ruby_version.is_stable() {
-            strategy = Some(Strategy::RustOnly(current_ruby_version));
-        } else {
-            maybe_warn_old_ruby_version(current_ruby_version);
-        }
-
-        if is_fallback_enabled() {
-            strategy = Some(Strategy::RustThenCompiled(current_ruby_version));
-        }
-
-        if is_testing() {
-            strategy = Some(Strategy::Testing(current_ruby_version));
-        }
-
-        if is_force_enabled() {
-            strategy = Some(Strategy::CompiledOnly);
-        }
-
-        if let Some(strategy) = strategy {
-            return Ok(strategy);
-        }
-
-        Err("Stable API is needed but could not find a candidate. Try enabling the `stable-api-compiled-fallback` feature in rb-sys.".into())
-    }
-}
-
-impl Strategy {
-    fn apply(self) -> Result<(), Box<dyn Error>> {
-        println!("cargo:rustc-check-cfg=cfg(stable_api_include_rust_impl)");
-        println!("cargo:rustc-check-cfg=cfg(stable_api_enable_compiled_mod)");
-        println!("cargo:rustc-check-cfg=cfg(stable_api_export_compiled_as_api)");
-        println!("cargo:rustc-check-cfg=cfg(stable_api_has_rust_impl)");
-        match self {
-            Strategy::RustOnly(current_ruby_version) => {
-                if current_ruby_version.is_stable() {
-                    println!("cargo:rustc-cfg=stable_api_include_rust_impl");
-                } else {
-                    return Err(format!("A stable Ruby API is needed but could not find a candidate. If you are using a stable version of Ruby, try upgrading rb-sys. Otherwise if you are testing against ruby-head or Ruby < {}, enable the `stable-api-compiled-fallback` feature in rb-sys.", MIN_SUPPORTED_STABLE_VERSION).into());
-                }
-            }
-            Strategy::CompiledOnly => {
-                compile()?;
-                println!("cargo:rustc-cfg=stable_api_enable_compiled_mod");
-                println!("cargo:rustc-cfg=stable_api_export_compiled_as_api");
-            }
-            Strategy::RustThenCompiled(current_ruby_version) => {
-                if current_ruby_version.is_stable() {
-                    println!("cargo:rustc-cfg=stable_api_has_rust_impl");
-                    println!("cargo:rustc-cfg=stable_api_include_rust_impl");
-                } else {
-                    compile()?;
-                    println!("cargo:rustc-cfg=stable_api_enable_compiled_mod");
-                    println!("cargo:rustc-cfg=stable_api_export_compiled_as_api");
-                }
-            }
-            Strategy::Testing(current_ruby_version) => {
-                compile()?;
-
-                println!("cargo:rustc-cfg=stable_api_enable_compiled_mod");
-
-                if current_ruby_version.is_stable() {
-                    println!("cargo:rustc-cfg=stable_api_include_rust_impl");
-                } else {
-                    println!("cargo:rustc-cfg=stable_api_export_compiled_as_api");
-                }
-            }
-        };
-
-        Ok(())
-    }
-}
-
-fn is_fallback_enabled() -> bool {
-    println!("cargo:rerun-if-env-changed=RB_SYS_STABLE_API_COMPILED_FALLBACK");
-
-    is_env_variable_defined("CARGO_FEATURE_STABLE_API_COMPILED_FALLBACK")
-        || cfg!(rb_sys_use_stable_api_compiled_fallback)
-        || is_env_variable_defined("RB_SYS_STABLE_API_COMPILED_FALLBACK")
-}
-
-fn is_force_enabled() -> bool {
-    println!("cargo:rerun-if-env-changed=RB_SYS_STABLE_API_COMPILED_FORCE");
-
-    is_env_variable_defined("CARGO_FEATURE_STABLE_API_COMPILED_FORCE")
-        || cfg!(rb_sys_force_stable_api_compiled)
-        || is_env_variable_defined("RB_SYS_STABLE_API_COMPILED_FORCE")
-}
-
-fn is_testing() -> bool {
-    is_env_variable_defined("CARGO_FEATURE_STABLE_API_COMPILED_TESTING")
-}
-
-fn maybe_warn_old_ruby_version(current_ruby_version: Version) {
-    if current_ruby_version < MIN_SUPPORTED_STABLE_VERSION {
-        println!(
-            "cargo:warning=Support for Ruby {} will be removed in a future release.",
-            current_ruby_version
-        );
-    }
-}
-
-fn compile() -> Result<(), Box<dyn Error>> {
-    eprintln!("INFO: Compiling the stable API compiled module");
-    let mut build = rb_sys_build::cc::Build::new();
-    let crate_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
-    let path = crate_dir.join("src").join("stable_api").join("compiled.c");
-    eprintln!("cargo:rerun-if-changed={}", path.display());
-
-    build.file(path);
-    build.try_compile("compiled")
-}
+use rb_sys_build::{RbConfig, RubyEngine};
+
+use crate::{
+    features::is_env_variable_defined,
+    version::{Version, MIN_SUPPORTED_STABLE_VERSION},
+};
+use std::{convert::TryFrom, error::Error, path::Path};
+
+pub fn setup(rb_config: &RbConfig) -> Result<(), Box<dyn Error>> {
+    let ruby_version = Version::current(rb_config);
+    let ruby_engine = rb_config.ruby_engine();
+    let strategy = Strategy::try_from((ruby_engine, ruby_version))?;
+
+    strategy.apply()?;
+
+    Ok(())
+}
+
+#[derive(Debug)]
+enum Strategy {
+    RustOnly(Version),
+    CompiledOnly,
+    RustThenCompiled(Version),
+    Testing(Version),
+}
+
+impl TryFrom<(RubyEngine, Version)> for Strategy {
+    type Error = Box<dyn Error>;
+
+    fn try_from(
+        (engine, current_ruby_version): (RubyEngine, Version),
+    ) -> Result<Self, Self::Error> {
+        let mut strategy = None;
+
+        match engine {
+            RubyEngine::TruffleRuby => {
+                return Ok(Strategy::CompiledOnly);
+            }
+            RubyEngine::JRuby => {
+                return Err("JRuby is not supported".into());
+            }
+            RubyEngine::Mri => {}
+        }
+
+        if current_ruby_version.is_stable() {
+            strategy = Some(Strategy::RustOnly(current_ruby_version));
+        } else {
+            maybe_warn_old_ruby_version(current_ruby_version);
+        }
+
+        if is_fallback_enabled() {
+            strategy = Some(Strategy::RustThenCompiled(current_ruby_version));
+        }
+
+        if is_testing() {
+            strategy = Some(Strategy::Testing(current_ruby_version));
+        }
+
+        if is_force_enabled() {
+            strategy = Some(Strategy::CompiledOnly);
+        }
+
+        if let Some(strategy) = strategy {
+            return Ok(strategy);
+        }
+
+        Err("Stable API is needed but could not find a candidate. Try enabling the `stable-api-compiled-fallback` feature in rb-sys.".into())
+    }
+}
+
+impl Strategy {
+    fn apply(self) -> Result<(), Box<dyn Error>> {
+        println!("cargo:rustc-check-cfg=cfg(stable_api_include_rust_impl)");
+        println!("cargo:rustc-check-cfg=cfg(stable_api_enable_compiled_mod)");
+        println!("cargo:rustc-check-cfg=cfg(stable_api_export_compiled_as_api)");
+        println!("cargo:rustc-check-cfg=cfg(stable_api_has_rust_impl)");
+        match self {
+            Strategy::RustOnly(current_ruby_version) => {
+                if current_ruby_version.is_stable() {
+                    println!("cargo:rustc-cfg=stable_api_include_rust_impl");
+                } else {
+                    return Err(format!("A stable Ruby API is needed but could not find a candidate. If you are using a stable version of Ruby, try upgrading rb-sys. Otherwise if you are testing against ruby-head or Ruby < {}, enable the `stable-api-compiled-fallback` feature in rb-sys.", MIN_SUPPORTED_STABLE_VERSION).into());
+                }
+            }
+            Strategy::CompiledOnly => {
+                compile()?;
+                println!("cargo:rustc-cfg=stable_api_enable_compiled_mod");
+                println!("cargo:rustc-cfg=stable_api_export_compiled_as_api");
+            }
+            Strategy::RustThenCompiled(current_ruby_version) => {
+                if current_ruby_version.is_stable() {
+                    println!("cargo:rustc-cfg=stable_api_has_rust_impl");
+                    println!("cargo:rustc-cfg=stable_api_include_rust_impl");
+                } else {
+                    compile()?;
+                    println!("cargo:rustc-cfg=stable_api_enable_compiled_mod");
+                    println!("cargo:rustc-cfg=stable_api_export_compiled_as_api");
+                }
+            }
+            Strategy::Testing(current_ruby_version) => {
+                compile()?;
+
+                println!("cargo:rustc-cfg=stable_api_enable_compiled_mod");
+
+                if current_ruby_version.is_stable() {
+                    println!("cargo:rustc-cfg=stable_api_include_rust_impl");
+                } else {
+                    println!("cargo:rustc-cfg=stable_api_export_compiled_as_api");
+                }
+            }
+        };
+
+        Ok(())
+    }
+}
+
+fn is_fallback_enabled() -> bool {
+    println!("cargo:rerun-if-env-changed=RB_SYS_STABLE_API_COMPILED_FALLBACK");
+
+    is_env_variable_defined("CARGO_FEATURE_STABLE_API_COMPILED_FALLBACK")
+        || cfg!(rb_sys_use_stable_api_compiled_fallback)
+        || is_env_variable_defined("RB_SYS_STABLE_API_COMPILED_FALLBACK")
+}
+
+fn is_force_enabled() -> bool {
+    println!("cargo:rerun-if-env-changed=RB_SYS_STABLE_API_COMPILED_FORCE");
+
+    is_env_variable_defined("CARGO_FEATURE_STABLE_API_COMPILED_FORCE")
+        || cfg!(rb_sys_force_stable_api_compiled)
+        || is_env_variable_defined("RB_SYS_STABLE_API_COMPILED_FORCE")
+}
+
+fn is_testing() -> bool {
+    is_env_variable_defined("CARGO_FEATURE_STABLE_API_COMPILED_TESTING")
+}
+
+fn maybe_warn_old_ruby_version(current_ruby_version: Version) {
+    if current_ruby_version < MIN_SUPPORTED_STABLE_VERSION {
+        println!(
+            "cargo:warning=Support for Ruby {} will be removed in a future release.",
+            current_ruby_version
+        );
+    }
+}
+
+fn compile() -> Result<(), Box<dyn Error>> {
+    eprintln!("INFO: Compiling the stable API compiled module");
+    let mut build = rb_sys_build::cc::Build::new();
+    let crate_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
+    let path = crate_dir.join("src").join("stable_api").join("compiled.c");
+    eprintln!("cargo:rerun-if-changed={}", path.display());
+
+    build.file(path);
+    build.try_compile("compiled")
+}

data/vendor/rb-sys/build/version.rs

@@ -1,50 +1,50 @@
-use crate::RbConfig;
-
-#[allow(dead_code)]
-pub const LATEST_STABLE_VERSION: Version = Version::new(3, 4);
-#[allow(dead_code)]
-pub const MIN_SUPPORTED_STABLE_VERSION: Version = Version::new(2, 6);
-
-#[derive(Debug, PartialEq, Eq, PartialOrd, Clone, Copy)]
-pub struct Version(u32, u32);
-
-impl Version {
-    pub const fn new(major: u32, minor: u32) -> Self {
-        Self(major, minor)
-    }
-
-    pub fn major(&self) -> u32 {
-        self.0
-    }
-
-    pub fn minor(&self) -> u32 {
-        self.1
-    }
-
-    pub fn current(rbconfig: &RbConfig) -> Version {
-        match (rbconfig.get("MAJOR"), rbconfig.get("MINOR")) {
-            (Some(major), Some(minor)) => {
-                Version::new(major.parse::<u32>().unwrap(), minor.parse::<u32>().unwrap())
-            }
-            _ => {
-                // Try to parse out the first 3 components of the version string (for truffleruby)
-                let version_string = rbconfig.get("ruby_version").expect("ruby_version");
-                let mut parts = version_string.split('.').map(|s| s.parse::<u32>());
-                let major = parts.next().expect("major").unwrap();
-                let minor = parts.next().expect("minor").unwrap();
-                Version::new(major, minor)
-            }
-        }
-    }
-
-    #[allow(dead_code)]
-    pub fn is_stable(&self) -> bool {
-        *self >= MIN_SUPPORTED_STABLE_VERSION && *self <= LATEST_STABLE_VERSION
-    }
-}
-
-impl std::fmt::Display for Version {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "{}.{}", self.0, self.1)
-    }
-}
+use crate::RbConfig;
+
+#[allow(dead_code)]
+pub const LATEST_STABLE_VERSION: Version = Version::new(3, 4);
+#[allow(dead_code)]
+pub const MIN_SUPPORTED_STABLE_VERSION: Version = Version::new(2, 6);
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Clone, Copy)]
+pub struct Version(u32, u32);
+
+impl Version {
+    pub const fn new(major: u32, minor: u32) -> Self {
+        Self(major, minor)
+    }
+
+    pub fn major(&self) -> u32 {
+        self.0
+    }
+
+    pub fn minor(&self) -> u32 {
+        self.1
+    }
+
+    pub fn current(rbconfig: &RbConfig) -> Version {
+        match (rbconfig.get("MAJOR"), rbconfig.get("MINOR")) {
+            (Some(major), Some(minor)) => {
+                Version::new(major.parse::<u32>().unwrap(), minor.parse::<u32>().unwrap())
+            }
+            _ => {
+                // Try to parse out the first 3 components of the version string (for truffleruby)
+                let version_string = rbconfig.get("ruby_version").expect("ruby_version");
+                let mut parts = version_string.split('.').map(|s| s.parse::<u32>());
+                let major = parts.next().expect("major").unwrap();
+                let minor = parts.next().expect("minor").unwrap();
+                Version::new(major, minor)
+            }
+        }
+    }
+
+    #[allow(dead_code)]
+    pub fn is_stable(&self) -> bool {
+        *self >= MIN_SUPPORTED_STABLE_VERSION && *self <= LATEST_STABLE_VERSION
+    }
+}
+
+impl std::fmt::Display for Version {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}.{}", self.0, self.1)
+    }
+}

data/vendor/rb-sys/readme.md

@@ -1,36 +1,36 @@
-# rb-sys
-
-[![Join the discussion](https://img.shields.io/badge/slack-chat-blue.svg)](https://join.slack.com/t/oxidize-rb/shared_invite/zt-16zv5tqte-Vi7WfzxCesdo2TqF_RYBCw)
-
-Autogenerated Rust bindings for Ruby. Uses the [`rust-bindgen`](https://github.com/rust-lang/rust-bindgen) crate to
-generate bindings from the `ruby.h` header.
-
-## Notice
-
-This is a very low-level library. If you are looking to write a gem in Rust, you should probably use
-https://github.com/matsadler/magnus crate, with the `rb-sys-interop` feature.
-
-If you actually _need_ raw/unsafe bindings to libruby, then this crate is for you!
-
-## Documentation
-
-For comprehensive documentation, please refer to the [Ruby on Rust Book](https://oxidize-rb.github.io/rb-sys/), which
-includes:
-
-- [API Reference for rb-sys Features](https://oxidize-rb.github.io/rb-sys/api-reference/rb-sys-features.html)
-- [Usage examples and tutorials](https://oxidize-rb.github.io/rb-sys/introduction.html)
-- [Memory management guidance](https://oxidize-rb.github.io/rb-sys/memory-management.html)
-
-## License
-
-Licensed under either of
-
-- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
-- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
-
-at your option.
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as
-defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
+# rb-sys
+
+[![Join the discussion](https://img.shields.io/badge/slack-chat-blue.svg)](https://join.slack.com/t/oxidize-rb/shared_invite/zt-16zv5tqte-Vi7WfzxCesdo2TqF_RYBCw)
+
+Autogenerated Rust bindings for Ruby. Uses the [`rust-bindgen`](https://github.com/rust-lang/rust-bindgen) crate to
+generate bindings from the `ruby.h` header.
+
+## Notice
+
+This is a very low-level library. If you are looking to write a gem in Rust, you should probably use
+https://github.com/matsadler/magnus crate, with the `rb-sys-interop` feature.
+
+If you actually _need_ raw/unsafe bindings to libruby, then this crate is for you!
+
+## Documentation
+
+For comprehensive documentation, please refer to the [Ruby on Rust Book](https://oxidize-rb.github.io/rb-sys/), which
+includes:
+
+- [API Reference for rb-sys Features](https://oxidize-rb.github.io/rb-sys/api-reference/rb-sys-features.html)
+- [Usage examples and tutorials](https://oxidize-rb.github.io/rb-sys/introduction.html)
+- [Memory management guidance](https://oxidize-rb.github.io/rb-sys/memory-management.html)
+
+## License
+
+Licensed under either of
+
+- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as
+defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

data/vendor/rb-sys/src/bindings.rs

@@ -1,21 +1,21 @@
-//! Raw bindings to libruby, generated by bindgen.
-//!
-//! This module contains the raw bindings to libruby, generated by bindgen.
-
-#![allow(non_upper_case_globals)]
-#![allow(non_camel_case_types)]
-#![allow(non_snake_case)]
-#![allow(unknown_lints)]
-#![allow(deref_nullptr)]
-#![warn(unknown_lints)]
-#![allow(clippy::all)]
-#![allow(rustdoc::broken_intra_doc_links)]
-#![allow(rustdoc::invalid_rust_codeblocks)]
-#![allow(rustdoc::invalid_html_tags)]
-#![allow(deprecated)]
-#![allow(dead_code)]
-
-include!(env!("RB_SYS_BINDINGS_PATH"));
-
-pub use uncategorized::*;
-pub use unstable::*;
+//! Raw bindings to libruby, generated by bindgen.
+//!
+//! This module contains the raw bindings to libruby, generated by bindgen.
+
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(unknown_lints)]
+#![allow(deref_nullptr)]
+#![warn(unknown_lints)]
+#![allow(clippy::all)]
+#![allow(rustdoc::broken_intra_doc_links)]
+#![allow(rustdoc::invalid_rust_codeblocks)]
+#![allow(rustdoc::invalid_html_tags)]
+#![allow(deprecated)]
+#![allow(dead_code)]
+
+include!(env!("RB_SYS_BINDINGS_PATH"));
+
+pub use uncategorized::*;
+pub use unstable::*;

data/vendor/rb-sys/src/hidden.rs

@@ -1,11 +1,11 @@
-//! Hidden symbols from Ruby that we need to link to, not exposed to users.
-//!
-//! Note: Using these symbols is an absolute last resort. Try to use the
-//! official Ruby C API if at all possible.
-
-extern "C" {
-    /// A pointer to the current Ruby VM.
-    #[cfg(all(ruby_gt_2_4, ruby_lte_3_2))]
-    #[cfg(ruby_engine = "mri")]
-    pub(crate) static ruby_current_vm_ptr: *mut crate::ruby_vm_t;
-}
+//! Hidden symbols from Ruby that we need to link to, not exposed to users.
+//!
+//! Note: Using these symbols is an absolute last resort. Try to use the
+//! official Ruby C API if at all possible.
+
+extern "C" {
+    /// A pointer to the current Ruby VM.
+    #[cfg(all(ruby_gt_2_4, ruby_lte_3_2))]
+    #[cfg(ruby_engine = "mri")]
+    pub(crate) static ruby_current_vm_ptr: *mut crate::ruby_vm_t;
+}

data/vendor/rb-sys/src/lib.rs

@@ -1,35 +1,35 @@
-#![allow(rustdoc::bare_urls)]
-#![allow(unpredictable_function_pointer_comparisons)]
-#![doc = include_str!("../readme.md")]
-
-pub mod bindings;
-#[cfg(feature = "stable-api")]
-pub mod macros;
-pub mod memory;
-pub mod special_consts;
-#[cfg(feature = "stable-api")]
-pub mod stable_api;
-pub mod symbol;
-pub mod tracking_allocator;
-pub mod value_type;
-
-mod hidden;
-mod ruby_abi_version;
-mod utils;
-
-pub use bindings::*;
-#[cfg(feature = "stable-api")]
-pub use macros::*;
-pub use ruby_abi_version::*;
-pub use special_consts::*;
-#[cfg(feature = "stable-api")]
-pub use stable_api::StableApiDefinition;
-pub use value_type::*;
-
-#[deprecated(since = "0.9.79", note = "Use `VALUE` instead")]
-pub type Value = VALUE;
-#[deprecated(since = "0.9.79", note = "Use `VALUE` instead")]
-pub type RubyValue = VALUE;
-
-#[cfg(use_global_allocator)]
-set_global_tracking_allocator!();
+#![allow(rustdoc::bare_urls)]
+#![allow(unpredictable_function_pointer_comparisons)]
+#![doc = include_str!("../readme.md")]
+
+pub mod bindings;
+#[cfg(feature = "stable-api")]
+pub mod macros;
+pub mod memory;
+pub mod special_consts;
+#[cfg(feature = "stable-api")]
+pub mod stable_api;
+pub mod symbol;
+pub mod tracking_allocator;
+pub mod value_type;
+
+mod hidden;
+mod ruby_abi_version;
+mod utils;
+
+pub use bindings::*;
+#[cfg(feature = "stable-api")]
+pub use macros::*;
+pub use ruby_abi_version::*;
+pub use special_consts::*;
+#[cfg(feature = "stable-api")]
+pub use stable_api::StableApiDefinition;
+pub use value_type::*;
+
+#[deprecated(since = "0.9.79", note = "Use `VALUE` instead")]
+pub type Value = VALUE;
+#[deprecated(since = "0.9.79", note = "Use `VALUE` instead")]
+pub type RubyValue = VALUE;
+
+#[cfg(use_global_allocator)]
+set_global_tracking_allocator!();