wry_ruby 0.0.1

data/Cargo.toml

@@ -0,0 +1,7 @@
+# This Cargo.toml is here to let externals tools (IDEs, etc.) know that this is
+# a Rust project. Your extensions dependencies should be added to the Cargo.toml
+# in the ext/ directory.
+
+[workspace]
+members = ["./ext/wry_ruby"]
+resolver = "2"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 gintama91
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+# WryRuby
+
+WryRuby is a project that provides experimental Ruby bindings for the [Tauri's Wry library](https://github.com/tauri-apps/wry). It aims to facilitate using Wry functionality in Ruby applications.
+
+**Note: This PROJECT and README is a work in progress and will be updated as we go.**
+
+## Usage
+
+Currently, WryRuby supports the following features:
+
+- **Trayid**: Provides functionality for creating system tray icons.
+- **New Window**: Allows creating new windows for your application.
+- **Clipboard**: Provides access to the system clipboard.
+- **Event Loop**: Allows creating and managing event loops for your application. as of now only new
+
+To see examples of how to use these features in Ruby, please refer to the tests directory in this project.
+
+## Installation
+
+To use WryRuby, you can install it directly using gem:(not available yet)
+
+```bash
+gem install wry_ruby
+```
+
+### For development
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/gintama91/wry_ruby
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+require "rb_sys/extensiontask"
+
+task build: :compile
+
+RbSys::ExtensionTask.new("wry_ruby") do |ext|
+  ext.lib_dir = "lib/wry_ruby"
+end
+
+task default: %i[compile test] # no rubocop add later

data/ext/wry_ruby/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "wry_ruby"
+version = "0.1.0"
+edition = "2021"
+authors = ["gintama91 <b9-20@srkrec.edu.in>"]
+license = "MIT"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+magnus = { version = "0.5.4" }
+wry = "0.29.0"
+gdk = "0.16.2"
+gtk="0.16.2"

data/ext/wry_ruby/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("wry_ruby/wry_ruby")

data/ext/wry_ruby/src/application/clipboard.rs

@@ -0,0 +1,77 @@
+// https://docs.rs/wry/latest/wry/application/clipboard/struct.Clipboard.html
+
+use std::cell::RefCell;
+
+use gdk;
+use gtk;
+
+use magnus::{function, method, Error, Module, Object};
+
+use wry::application::clipboard::Clipboard as ClipboardImpl;
+
+#[derive(Clone, Debug)]
+#[magnus::wrap(class = "Clip")]
+pub struct Clipboard {
+    inner: RefCell<ClipboardImpl>,
+}
+
+impl Clipboard {
+    pub fn new() -> Result<Self, Error> {
+        let inner = ClipboardImpl::new();
+
+        Ok(Self {
+            inner: RefCell::new(inner),
+        })
+    }
+
+    pub fn get(&self) -> std::cell::Ref<ClipboardImpl> {
+        self.inner.borrow()
+    }
+
+    pub fn get_mut(&self) -> std::cell::RefMut<ClipboardImpl> {
+        self.inner.borrow_mut()
+    }
+
+    /// Writes text to the clipboard.
+    ///
+    /// # Arguments
+    ///
+    /// * `s` - A string containing the text to be written.
+    ///
+    /// # Equivalent Ruby Method
+    ///
+    /// `clip.write_text("Hello World")`
+    pub fn write_text(&self, s: String) {
+        let text: &str = s.as_ref();
+        self.get_mut().write_text(text);
+    }
+
+    /// Reads text from the clipboard.
+    ///
+    /// # Equivalent Ruby Method
+    ///
+    /// `clip.read_text`
+    pub fn read_text(&self) -> Option<String> {
+        self.get().read_text()
+    }
+}
+
+/// Initializes the clipboard module.
+///
+/// # Equivalent Ruby Methods
+///
+/// - `clip = Clip.new`
+/// - `clip.write_text("Hello World")`
+/// - `clip.read_text`
+pub fn init() -> Result<(), Error> {
+    gdk::init();
+    let _ = gtk::init();
+
+    let class = magnus::define_class("Clip", Default::default())?;
+
+    class.define_singleton_method("new", function!(Clipboard::new, 0))?;
+    class.define_method("write_text", method!(Clipboard::write_text, 1))?;
+    class.define_method("read_text", method!(Clipboard::read_text, 0))?;
+
+    Ok(())
+}

data/ext/wry_ruby/src/application/event_loop.rs

@@ -0,0 +1,39 @@
+use magnus::{
+    function, Error, Object,
+};
+
+use std::marker::PhantomData;
+use std::sync::atomic::{AtomicPtr};
+
+use wry::application::event_loop::{
+      EventLoop as EventLoopImpl, 
+};
+
+#[magnus::wrap(class = "EventLoop")]
+pub struct EventLoop {
+    inner: SafeWrapper<EventLoopImpl<()>>,
+}
+
+pub struct SafeWrapper<T> {
+    event_loop: AtomicPtr<T>,
+    _marker: PhantomData<*mut T>,
+}
+
+unsafe impl<T> Send for SafeWrapper<T> {} 
+
+impl EventLoop {
+    pub fn new() -> Self {
+        let event_loop_impl = EventLoopImpl::new();
+        let inner = SafeWrapper {
+            event_loop: AtomicPtr::new(Box::into_raw(Box::new(event_loop_impl))),
+            _marker: PhantomData,
+        };
+        EventLoop { inner }
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = magnus::define_class("WindowBuilder", Default::default())?;
+    class.define_singleton_method("new", function!(EventLoop::new, 0))?;
+    Ok(())
+}

data/ext/wry_ruby/src/application/mod.rs

@@ -0,0 +1,17 @@
+use magnus::Error;
+
+mod tray_id;
+
+mod window;
+
+mod clipboard;
+
+mod event_loop;
+
+pub fn init() -> Result<(), Error> {
+    tray_id::init()?;
+    window::init()?;
+    clipboard::init()?;
+    event_loop::init()?;
+    Ok(())
+}

data/ext/wry_ruby/src/application/tray_id.rs

@@ -0,0 +1,51 @@
+use magnus::{function, Error, ExceptionClass, Module, Object, RString};
+use wry::application::TrayId as TrayIdImpl;
+
+#[derive(Clone, Debug)]
+#[magnus::wrap(class = "TrayId")]
+pub struct TrayId {
+    inner: TrayIdImpl,
+}
+
+impl TrayId {
+    pub const EMPTY: TrayId = TrayId {
+        inner: TrayIdImpl::EMPTY,
+    };
+
+    pub fn new(unique_string: RString) -> Result<Self, Error> {
+        if unique_string.is_empty() {
+            return Err(Error::new(
+                ExceptionClass::default(),
+                "Unique string cannot be empty",
+            ));
+        }
+
+        let s = match unique_string.as_interned_str() {
+            Some(str_ref) => str_ref.as_str().unwrap(),
+            None => {
+                println!("ok why is it none, hm check freeze or no");
+                return Err(Error::new(
+                    ExceptionClass::default(),
+                    "Interned string not available",
+                ));
+            }
+        };
+
+        Ok(Self {
+            inner: TrayIdImpl::new(s),
+        })
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = magnus::define_class("TrayId", Default::default())?;
+
+    class.define_singleton_method("new", function!(TrayId::new, 1))?;
+    class.define_method("is_empty", magnus::method!(TrayId::is_empty, 0))?;
+
+    Ok(())
+}

data/ext/wry_ruby/src/application/window.rs

@@ -0,0 +1,86 @@
+use magnus::{Error, define_global_function, function, method};
+use wry::application::dpi::LogicalSize;
+use wry::application::window::WindowBuilder;
+use wry::application::{
+    event::{Event, StartCause, WindowEvent},
+    event_loop::{ControlFlow, EventLoop},
+};
+use wry::webview::WebViewBuilder;
+use std::time::{Duration, Instant};
+
+pub fn WindoWnew(title: String, width: u32, height: u32, resizable: bool,timeout: u64) {
+    let event_loop = EventLoop::new();
+    let mut window_builder = WindowBuilder::new();
+    window_builder = window_builder.with_title(title.clone());
+    window_builder = window_builder.with_inner_size(LogicalSize::new(width, height));
+    window_builder = window_builder.with_resizable(resizable);
+
+    let window = window_builder.build(&event_loop).expect("Failed to create window");
+
+    // Get initial properties
+    let current_title = window.title();
+    let current_size = window.inner_size();
+    let resizable = window.is_resizable();
+
+    println!("Initial Title: {}", current_title);
+    println!("Initial Size: {:?}", current_size);
+    println!("Resizable: {}", resizable);
+
+    // ************************************************* as of now we are using this timeout to close for test******************************************************
+    let timeout_duration = Duration::from_secs(timeout);
+    let start_time = Instant::now();
+
+    event_loop.run(move |event, _, control_flow| {
+        *control_flow = ControlFlow::Wait;
+
+        match event {
+            Event::NewEvents(StartCause::Init) => println!("Wry has started!"),
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                ..
+            } => *control_flow = ControlFlow::Exit,
+            _ => (),
+        }
+
+        let elapsed = Instant::now() - start_time;
+        if elapsed >= timeout_duration {
+            println!("Window creation timed out after {:?}.", timeout_duration);
+            *control_flow = ControlFlow::Exit;
+        }
+    });
+}
+
+pub fn window_with_html(html:String){
+     let event_loop = EventLoop::new();
+  let window = WindowBuilder::new()
+    .with_title("Shoes with html")
+    .build(&event_loop)
+    .unwrap();
+  let _webview = WebViewBuilder::new(window).unwrap()
+    .with_html(&html)
+    .unwrap()
+    .build()
+    .unwrap();
+
+  event_loop.run(move |event, _, control_flow| {
+    *control_flow = ControlFlow::Wait;
+
+    match event {
+      Event::NewEvents(StartCause::Init) => println!("Wry has started!"),
+      Event::WindowEvent {
+        event: WindowEvent::CloseRequested,
+        ..
+      } => *control_flow = ControlFlow::Exit,
+      _ => (),
+    }
+  });
+
+}
+pub fn init() -> Result<(), Error> {
+    println!("inside init");
+    define_global_function("new_window", function!(WindoWnew, 5));
+    // as we use html in webiew i am trying to use it here not rly sure if it works though
+    define_global_function("window_with_html",function!(window_with_html,1));
+
+    Ok(())
+}

data/ext/wry_ruby/src/lib.rs

@@ -0,0 +1,8 @@
+use magnus::Error;
+
+mod application;
+
+#[magnus::init]
+fn init() -> Result<(), Error> {
+    application::init()
+}

data/lib/example.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "wry_ruby/wry_ruby"

data/lib/wry_ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module WryRuby
+  VERSION = "0.0.1"
+end

data/lib/wry_ruby.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "wry_ruby/version"
+require_relative "wry_ruby/wry_ruby"

data/sig/wry_ruby.rbs

@@ -0,0 +1,4 @@
+module WryRuby
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: wry_ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Pavan Nambi
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-07-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.39
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.39
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+description: Ruby bindings for Wry........
+email:
+- pavannambi0408@gmail.com
+executables: []
+extensions:
+- ext/wry_ruby/extconf.rb
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- ".ruby-version"
+- ".rust-version"
+- ".tool-versions"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Cargo.lock
+- Cargo.toml
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/wry_ruby/Cargo.toml
+- ext/wry_ruby/extconf.rb
+- ext/wry_ruby/src/application/clipboard.rs
+- ext/wry_ruby/src/application/event_loop.rs
+- ext/wry_ruby/src/application/mod.rs
+- ext/wry_ruby/src/application/tray_id.rs
+- ext/wry_ruby/src/application/window.rs
+- ext/wry_ruby/src/lib.rs
+- lib/example.rb
+- lib/wry_ruby.rb
+- lib/wry_ruby/version.rb
+- sig/wry_ruby.rbs
+homepage: https://github.com/gintama91/wry_ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/gintama91/wry_ruby
+  source_code_uri: https://github.com/gintama91/wry_ruby
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.11
+requirements: []
+rubygems_version: 3.4.17
+signing_key: 
+specification_version: 4
+summary: Ruby bindings for Wry.
+test_files: []