code_ownership 2.1.0 → 2.1.1

data/ext/cargo-vendor/magnus-0.8.2/Cargo.toml

@@ -0,0 +1,277 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+name = "magnus"
+version = "0.8.2"
+build = "build.rs"
+exclude = [
+    ".github",
+    ".gitignore",
+]
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "High level Ruby bindings. Write Ruby extension gems in Rust, or call Ruby code from a Rust binary."
+homepage = "https://github.com/matsadler/magnus"
+documentation = "https://docs.rs/magnus/"
+readme = "README.md"
+keywords = [
+    "ruby",
+    "rubygem",
+    "extension",
+    "gem",
+]
+categories = [
+    "api-bindings",
+    "development-tools::ffi",
+]
+license = "MIT"
+repository = "https://github.com/matsadler/magnus"
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = [
+    "--cfg",
+    "docsrs",
+]
+
+[features]
+bytes = ["dep:bytes"]
+chrono = ["dep:chrono"]
+default = ["io"]
+embed = ["rb-sys/link-ruby"]
+io = []
+old-api = []
+rb-sys = []
+
+[lib]
+name = "magnus"
+path = "src/lib.rs"
+doc-scrape-examples = false
+
+[[example]]
+name = "fibonacci"
+path = "examples/fibonacci.rs"
+doc-scrape-examples = false
+
+[[example]]
+name = "hello_world"
+path = "examples/hello_world.rs"
+doc-scrape-examples = false
+
+[[example]]
+name = "inheritance"
+path = "examples/inheritance.rs"
+
+[[example]]
+name = "mut_point"
+path = "examples/mut_point.rs"
+doc-scrape-examples = false
+
+[[example]]
+name = "point"
+path = "examples/point.rs"
+doc-scrape-examples = false
+
+[[test]]
+name = "allocate_before_init"
+path = "tests/allocate_before_init.rs"
+
+[[test]]
+name = "array_slice"
+path = "tests/array_slice.rs"
+
+[[test]]
+name = "block_call"
+path = "tests/block_call.rs"
+
+[[test]]
+name = "bytes"
+path = "tests/bytes.rs"
+
+[[test]]
+name = "call_proc"
+path = "tests/call_proc.rs"
+
+[[test]]
+name = "classname"
+path = "tests/classname.rs"
+
+[[test]]
+name = "clone"
+path = "tests/clone.rs"
+
+[[test]]
+name = "codepoints"
+path = "tests/codepoints.rs"
+
+[[test]]
+name = "debug_exception"
+path = "tests/debug_exception.rs"
+
+[[test]]
+name = "encoding_capable"
+path = "tests/encoding_capable.rs"
+
+[[test]]
+name = "enumerator"
+path = "tests/enumerator.rs"
+
+[[test]]
+name = "enumeratorize"
+path = "tests/enumeratorize.rs"
+
+[[test]]
+name = "float_convert_from_value"
+path = "tests/float_convert_from_value.rs"
+
+[[test]]
+name = "float_convert_to_value"
+path = "tests/float_convert_to_value.rs"
+
+[[test]]
+name = "fmt"
+path = "tests/fmt.rs"
+
+[[test]]
+name = "freeze"
+path = "tests/freeze.rs"
+
+[[test]]
+name = "hash"
+path = "tests/hash.rs"
+
+[[test]]
+name = "integer_convert_to_value"
+path = "tests/integer_convert_to_value.rs"
+
+[[test]]
+name = "integer_traits"
+path = "tests/integer_traits.rs"
+
+[[test]]
+name = "io"
+path = "tests/io.rs"
+
+[[test]]
+name = "ivar"
+path = "tests/ivar.rs"
+
+[[test]]
+name = "lazy_id"
+path = "tests/lazy_id.rs"
+
+[[test]]
+name = "make_proc"
+path = "tests/make_proc.rs"
+
+[[test]]
+name = "proc_new"
+path = "tests/proc_new.rs"
+
+[[test]]
+name = "range"
+path = "tests/range.rs"
+
+[[test]]
+name = "return_custom_error"
+path = "tests/return_custom_error.rs"
+
+[[test]]
+name = "return_iter"
+path = "tests/return_iter.rs"
+
+[[test]]
+name = "scan_args"
+path = "tests/scan_args.rs"
+
+[[test]]
+name = "str"
+path = "tests/str.rs"
+
+[[test]]
+name = "string"
+path = "tests/string.rs"
+
+[[test]]
+name = "struct"
+path = "tests/struct.rs"
+
+[[test]]
+name = "symbol"
+path = "tests/symbol.rs"
+
+[[test]]
+name = "time"
+path = "tests/time.rs"
+
+[[test]]
+name = "try_convert_array"
+path = "tests/try_convert_array.rs"
+
+[[test]]
+name = "tuple_to_array"
+path = "tests/tuple_to_array.rs"
+
+[[test]]
+name = "typed_data"
+path = "tests/typed_data.rs"
+
+[[test]]
+name = "typed_data_obj"
+path = "tests/typed_data_obj.rs"
+
+[[test]]
+name = "typed_data_subclass"
+path = "tests/typed_data_subclass.rs"
+
+[[test]]
+name = "typed_data_subclass_from_ruby"
+path = "tests/typed_data_subclass_from_ruby.rs"
+
+[[test]]
+name = "yield"
+path = "tests/yield.rs"
+
+[dependencies.bytes]
+version = "1"
+optional = true
+
+[dependencies.chrono]
+version = "0.4.38"
+optional = true
+
+[dependencies.magnus-macros]
+version = "0.8.0"
+
+[dependencies.rb-sys]
+version = ">=0.9.113"
+features = [
+    "bindgen-rbimpls",
+    "bindgen-deprecated-types",
+    "stable-api",
+]
+default-features = false
+
+[dependencies.seq-macro]
+version = "0.3"
+
+[dev-dependencies.rb-sys]
+version = "0.9.113"
+features = ["stable-api-compiled-fallback"]
+default-features = false
+
+[build-dependencies.rb-sys-env]
+version = "0.2.2"

data/ext/cargo-vendor/{magnus-0.7.1 → magnus-0.8.2}/Cargo.toml.orig

@@ -1,6 +1,6 @@
 [package]
 name = "magnus"
-version = "0.7.1"
+version = "0.8.2"
 edition = "2021"
 description = "High level Ruby bindings. Write Ruby extension gems in Rust, or call Ruby code from a Rust binary."
 keywords = ["ruby", "rubygem", "extension", "gem"]
@@ -21,16 +21,19 @@ exclude = [
 ]
 
 [features]
-default = ["old-api"]
+default = ["io"]
 bytes = ["dep:bytes"]
+chrono = ["dep:chrono"]
 embed = ["rb-sys/link-ruby"]
 old-api = []
 rb-sys = []
+io = []
 
 [dependencies]
 bytes = { version = "1", optional = true }
-magnus-macros = { version = "0.6.0", path = "magnus-macros" }
-rb-sys = { version = "0.9.85", default-features = false, features = [
+chrono = { version = "0.4.38", optional = true }
+magnus-macros = { version = "0.8.0", path = "magnus-macros" }
+rb-sys = { version = ">=0.9.113", default-features = false, features = [
     "bindgen-rbimpls",
     "bindgen-deprecated-types",
     "stable-api",
@@ -42,13 +45,15 @@ magnus = { path = ".", default-features = false, features = [
     "embed",
     "rb-sys",
     "bytes",
+    "chrono",
+    "io",
 ] }
-rb-sys = { version = "0.9", default-features = false, features = [
+rb-sys = { version = "0.9.113", default-features = false, features = [
     "stable-api-compiled-fallback",
 ] }
 
 [build-dependencies]
-rb-sys-env = "0.1.2"
+rb-sys-env = "0.2.2"
 
 [lib]
 doc-scrape-examples = false

data/ext/cargo-vendor/{magnus-0.7.1 → magnus-0.8.2}/README.md

@@ -82,13 +82,24 @@ make sure the return type is `magnus::Value`.
 
 ### Wrapping Rust Types in Ruby Objects
 
-Rust structs and enums can be wrapped in Ruby objects so they can be returned
-to Ruby.
+Magnus allows you to wrap Rust structs and enums as Ruby objects, enabling seamless interaction between Rust and Ruby. This functionality is ideal for exposing Rust logic to Ruby modules.
 
-Types can opt-in to this with the `magnus::wrap` macro (or by implementing
-`magnus::TypedData`). Whenever a compatible type is returned to Ruby it will be
-wrapped in the specified class, and whenever it is passed back to Rust it will
-be unwrapped to a reference.
+Use one of the following approaches to expose a Rust type to Ruby:
+
+* A convenience macro [`#[magnus::wrap]`][magnus-wrap].
+* More customised approach by implementing the [`magnus::TypedData`] trait.
+
+[magnus-wrap]: https://docs.rs/magnus/latest/magnus/attr.wrap.html
+[`magnus::TypedData`]: https://docs.rs/magnus/latest/magnus/derive.TypedData.html
+
+Then this Rust type can be:
+
+* Returned to Ruby as a wrapped object.
+* Passed back to Rust and automatically unwrapped to a native Rust reference.
+
+#### Basic Usage
+
+Here’s how you can wrap a simple Rust struct and expose its methods to Ruby:
 
 ```rust
 use magnus::{function, method, prelude::*, Error, Ruby};
@@ -128,16 +139,20 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
 }
 ```
 
-The newtype pattern and `RefCell` can be used if mutability is required:
+#### Handling Mutability
+
+Because Ruby's GC manages the memory where your Rust type is stored, Magnus can't bind functions with mutable references. To allow mutable fields in wrapped Rust structs, you can use the newtype pattern with `RefCell`:
 
 ```rust
+use std::cell::RefCell;
+
 struct Point {
     x: isize,
     y: isize,
 }
 
 #[magnus::wrap(class = "Point")]
-struct MutPoint(std::cell::RefCell<Point>);
+struct MutPoint(RefCell<Point>);
 
 impl MutPoint {
     fn set_x(&self, i: isize) {
@@ -146,8 +161,17 @@ impl MutPoint {
 }
 ```
 
-To allow wrapped types to be subclassed they must implement `Default`, and
-define and alloc func and an initialize method:
+See [`examples/mut_point.rs`] for the complete example.
+
+[`examples/mut_point.rs`]: https://github.com/matsadler/magnus/blob/main/examples/mut_point.rs
+
+#### Supporting Subclassing
+
+To enable Ruby subclassing for wrapped Rust types, the type must:
+
+* Implement the `Default` trait.
+* Define an allocator.
+* Define an initialiser.
 
 ``` rust
 #[derive(Default)]
@@ -177,6 +201,26 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
 }
 ```
 
+#### Error Handling
+
+Use `magnus::Error` to propagate errors to Ruby from Rust:
+
+```rust
+#[magnus::wrap(class = "Point")]
+struct MutPoint(RefCell<Point>);
+
+impl MutPoint {
+    fn add_x(ruby: &Ruby, rb_self: &Self, val: isize) -> Result<isize, Error> {
+        if let Some(sum) = rb_self.0.borrow().x.checked_add(val) {
+            rb_self.0.borrow_mut().x = sum;
+            Ok(sum)
+        } else {
+            return Err(Error::new(ruby.exception_range_error(), "result out of range"));
+        }
+    }
+}
+```
+
 ## Getting Started
 
 ### Writing an extension gem (calling Rust from Ruby)
@@ -191,7 +235,7 @@ setting the `crate-type` attribute in your `Cargo.toml`.
 crate-type = ["cdylib"]
 
 [dependencies]
-magnus = "0.7"
+magnus = "0.8"
 ```
 
 When Ruby loads your extension it calls an 'init' function defined in your
@@ -246,7 +290,7 @@ require "rb_sys/mkmf"
 create_rust_makefile("my_example_gem/my_example_gem")
 ```
 
-See the [`rust_blank`] example for examples if `extconf.rb` and `Rakefile`.
+See the [`rust_blank`] example for examples of `extconf.rb` and `Rakefile`.
 Running `rake compile` will place the extension at
 `lib/my_example_gem/my_example_gem.so` (or `.bundle` on macOS), which you'd
 load from Ruby like so:
@@ -274,7 +318,7 @@ To call Ruby from a Rust program, enable the `embed` feature:
 
 ```toml
 [dependencies]
-magnus = { version = "0.7", features = ["embed"] }
+magnus = { version = "0.8", features = ["embed"] }
 ```
 
 This enables linking to Ruby and gives access to the `embed` module.
@@ -319,7 +363,7 @@ See `magnus::TryConvert` for more details.
 | `i8`,`i16`,`i32`,`i64`,`isize`, `magnus::Integer`                    | `Integer`, `#to_int`                    |
 | `u8`,`u16`,`u32`,`u64`,`usize`                                       | `Integer`, `#to_int`                    |
 | `f32`,`f64`, `magnus::Float`                                         | `Float`, `Numeric`                      |
-| `String`, `PathBuf`, `char`, `magnus::RString`, `bytes::Bytes`\*\*\* | `String`, `#to_str`                     |
+| `String`, `PathBuf`, `char`, `magnus::RString`, `bytes::Bytes`‡      | `String`, `#to_str`                     |
 | `magnus::Symbol`                                                     | `Symbol`, `#to_sym`                     |
 | `bool`                                                               | any object                              |
 | `magnus::Range`                                                      | `Range`                                 |
@@ -329,17 +373,19 @@ See `magnus::TryConvert` for more details.
 | `[T; N]`                                                             | `[T]`, `#to_ary`                        |
 | `magnus::RArray`                                                     | `Array`, `#to_ary`                      |
 | `magnus::RHash`                                                      | `Hash`, `#to_hash`                      |
-| `std::time::SystemTime`, `magnus::Time`                              | `Time`                                  |
+| `std::time::SystemTime`, `magnus::Time`, `chrono::DateTime<T>`§      | `Time`                                  |
 | `magnus::Value`                                                      | any object                              |
 | `Vec<T>`\*                                                           | `[T]`, `#to_ary`                        |
 | `HashMap<K, V>`\*                                                    | `{K => V}`, `#to_hash`                  |
-| `&T`, `typed_data::Obj<T>` where `T: TypedData`\*\*                  | instance of `<T as TypedData>::class()` |
+| `&T`, `typed_data::Obj<T>` where `T: TypedData`†                     | instance of `<T as TypedData>::class()` |
 
 \* when converting to `Vec` and `HashMap` the types of `T`/`K`,`V` must be native Rust types.
 
-\*\* see the `wrap` macro.
+† see the `wrap` macro.
+
+‡ when the `bytes` feature is enabled
 
-\*\*\* when the `bytes` feature is enabled
+§ when the `chrono` feature is enabled; `T` can be `Utc` or `FixedOffset`.
 
 ### Rust returning / passing values to Ruby
 
@@ -360,9 +406,9 @@ and `magnus::ArgList` for some additional details.
 | `(T, U)`, `(T, U, V)`, etc, `[T; N]`, `Vec<T>`     | `Array`                                 |
 | `HashMap<K, V>`                                    | `Hash`                                  |
 | `std::time::SystemTime`                            | `Time`                                  |
-| `T`, `typed_data::Obj<T>` where `T: TypedData`\*\* | instance of `<T as TypedData>::class()` |
+| `T`, `typed_data::Obj<T>` where `T: TypedData`\*  | instance of `<T as TypedData>::class()` |
 
-\*\* see the `wrap` macro.
+\* see the `wrap` macro.
 
 ### Conversions via Serde
 
@@ -432,7 +478,7 @@ use `unsafe`.
 
 ## Compatibility
 
-Ruby versions 3.0, 3.1, 3.2, and 3.3 are fully supported.
+Ruby versions 3.0, 3.1, 3.2, 3.3 and 3.4 are fully supported.
 
 Magnus currently works with, and is still tested against, Ruby 2.7, but as this
 version of the language is no longer supported by the Ruby developers it is not
@@ -441,7 +487,7 @@ recommended and future support in Magnus is not guaranteed.
 Ruby bindings will be generated at compile time, this may require libclang to
 be installed.
 
-The Minimum supported Rust version is currently Rust 1.61.
+The minimum supported Rust version is currently Rust 1.65.
 
 Support for statically linking Ruby is provided via the lower-level [rb-sys]
 crate, and can be enabled by adding the following to your `Cargo.toml`:
@@ -479,6 +525,10 @@ deserialisation of Rust to Ruby data structures and vice versa.
 
 * [`halton`](https://github.com/matsadler/halton-rb) a Ruby gem providing a
   highly optimised method for generating Halton sequences.
+* [`optify`](https://github.com/juharris/optify) a Ruby gem to
+  simplify using configuration files to manage options for experiments.
+  It has a GitHub action to publish the gem for different architectures to RubyGems
+  with a RBI file for type hints.
 
 Please open a [pull request](https://github.com/matsadler/magnus/pulls) if
 you'd like your project listed here.
@@ -512,4 +562,6 @@ library turns out better for you.
 
 ## License
 
-This project is licensed under the MIT license, see LICENSE.
+This project is licensed under the MIT license, see [LICENSE].
+
+[LICENSE]: https://github.com/matsadler/magnus/blob/main/LICENSE

data/ext/cargo-vendor/magnus-0.8.2/build.rs

@@ -0,0 +1,15 @@
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // add these here to silence warnings until rb_sys_env is updated
+    println!("cargo:rustc-check-cfg=cfg(ruby_use_flonum)");
+    println!("cargo:rustc-check-cfg=cfg(ruby_lt_3_0)");
+    println!("cargo:rustc-check-cfg=cfg(ruby_gte_3_0)");
+    println!("cargo:rustc-check-cfg=cfg(ruby_gte_3_1)");
+    println!("cargo:rustc-check-cfg=cfg(ruby_lt_3_2)");
+    println!("cargo:rustc-check-cfg=cfg(ruby_gte_3_2)");
+    println!("cargo:rustc-check-cfg=cfg(ruby_lt_3_3)");
+    println!("cargo:rustc-check-cfg=cfg(ruby_gte_3_3)");
+
+    let _ = rb_sys_env::activate()?;
+
+    Ok(())
+}

data/ext/cargo-vendor/{magnus-0.7.1 → magnus-0.8.2}/examples/complete_object/test/temperature_test.rb

@@ -31,14 +31,14 @@ class TemperatureTest < Test::Unit::TestCase
 
   def test_dup
     temp = Temperature.new(celsius: 19.5)
-    def temp.singlton_method_example
+    def temp.singleton_method_example
     end
     copy = temp.dup
 
     assert { temp.object_id != copy.object_id }
     assert { temp == copy }
     assert { !copy.frozen? }
-    assert { !copy.respond_to?(:singlton_method_example)}
+    assert { !copy.respond_to?(:singleton_method_example)}
 
     temp2 = Temperature.new(celsius: 19.5)
     temp2.freeze
@@ -48,14 +48,14 @@ class TemperatureTest < Test::Unit::TestCase
 
   def test_clone
     temp = Temperature.new(celsius: 19.5)
-    def temp.singlton_method_example
+    def temp.singleton_method_example
     end
     copy = temp.clone
 
     assert { temp.object_id != copy.object_id }
     assert { temp == copy }
     assert { !copy.frozen? }
-    assert { copy.respond_to?(:singlton_method_example)}
+    assert { copy.respond_to?(:singleton_method_example)}
 
     temp2 = Temperature.new(celsius: 19.5)
     temp2.freeze

data/ext/cargo-vendor/magnus-0.8.2/examples/inheritance.rs

@@ -0,0 +1,66 @@
+use magnus::{function, method, prelude::*};
+
+/// Building on top of `wrap`, we can rely on Rust's enum to dispatch based on enum variants.
+/// Magnus will transform the types between Ruby and Rust.
+#[magnus::wrap(class = "Shape")]
+enum Shape {
+    #[magnus(class = "Circle")]
+    Circle { radius: f64 },
+    #[magnus(class = "Rectangle")]
+    Rectangle { x: f64, y: f64 },
+}
+
+impl Shape {
+    fn new_circle(radius: f64) -> Self {
+        Self::Circle { radius }
+    }
+
+    fn new_rectangle(x: f64, y: f64) -> Self {
+        Self::Rectangle { x, y }
+    }
+
+    fn area(&self) -> f64 {
+        match self {
+            Shape::Circle { radius } => std::f64::consts::PI * radius * radius,
+            Shape::Rectangle { x, y } => x * y,
+        }
+    }
+}
+
+fn print_area(s: &Shape) {
+    println!("{}", s.area());
+}
+
+fn main() -> Result<(), String> {
+    // Normal Rust code
+    let a = Shape::Circle { radius: 10.0 };
+    let b = Shape::Rectangle { x: 10.0, y: 2.0 };
+    print_area(&a);
+    print_area(&b);
+
+    // magnus binding running in Ruby
+    magnus::Ruby::init(|ruby| {
+        let shape_class = ruby.define_class("Shape", ruby.class_object())?;
+        shape_class.undef_default_alloc_func();
+
+        // inherit from Shape
+        let circle_class = ruby.define_class("Circle", shape_class)?;
+        circle_class.define_singleton_method("new", function!(Shape::new_circle, 1))?;
+        circle_class.define_method("area", method!(Shape::area, 0))?;
+
+        let rectangle_class = ruby.define_class("Rectangle", shape_class)?;
+        rectangle_class.define_singleton_method("new", function!(Shape::new_rectangle, 2))?;
+        rectangle_class.define_method("area", method!(Shape::area, 0))?;
+
+        let d: f64 = ruby.eval(
+            "a = Circle.new(10.0)
+             b = Rectangle.new(10.0, 2.0)
+             difference = a.area - b.area
+             puts \"The difference of the area between the circle and the rectangle is #{difference}.\"
+             difference",
+        )?;
+
+        println!("{}", d);
+        Ok(())
+    })
+}