rust_on_background 0.1.1

data/lib/generators/job/job_generator.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module RustOnBackground
+  module Generators
+    class JobGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+      argument :job_name, type: :string, banner: "job_name"
+      argument :fields, type: :array, default: [], banner: "field:type field:type"
+
+      TYPE_MAPPINGS = {
+        # Ruby/Rails types
+        "string" => "String", "text" => "String", "citext" => "String",
+        "integer" => "i64", "int" => "i64", "i64" => "i64", "bigint" => "i64",
+        "i32" => "i32",
+        "float" => "f64", "decimal" => "f64", "f64" => "f64",
+        "boolean" => "bool", "bool" => "bool",
+        "array" => "Vec<serde_json::Value>", "vec" => "Vec<serde_json::Value>",
+        "set" => "Vec<serde_json::Value>",
+        "hash" => "serde_json::Value", "object" => "serde_json::Value",
+        "json" => "serde_json::Value", "jsonb" => "serde_json::Value",
+        "date" => "String", "datetime" => "String", "time" => "String", "timestamp" => "String",
+        "uuid" => "String", "binary" => "Vec<u8>", "blob" => "Vec<u8>"
+      }.freeze
+
+      desc "Creates a new Rust background job"
+
+      def create_job_file
+        @args = parsed_attributes
+        template "job.rs.erb", "app/jobs/rust/src/jobs/#{file_name}.rs"
+      end
+
+      def add_module_declaration
+        mod_file = "app/jobs/rust/src/jobs/mod.rs"
+
+        inject_into_file mod_file, after: "use crate::worker::{Job, JobResult};\n" do
+          "pub mod #{file_name};\n"
+        end
+      end
+
+      def add_dispatch_route
+        mod_file = "app/jobs/rust/src/jobs/mod.rs"
+        content = File.read(mod_file)
+
+        new_content = content.sub(/^([ \t]*)unknown\s*=>/m) do |_match|
+          indent = $1
+          "#{indent}\"#{file_name}\" => {\n" \
+          "#{indent}    #{file_name}::run(&job.args, database_url).await\n" \
+          "#{indent}}\n\n" \
+          "#{indent}unknown =>"
+        end
+
+        File.write(mod_file, new_content)
+      end
+
+      def show_post_generate_message
+        say ""
+        say "Job '#{file_name}' created!", :green
+        say ""
+        say "Files:"
+        say "  app/jobs/rust/src/jobs/#{file_name}.rs"
+        say ""
+        say "Usage in Rails:"
+        say "  RustOnBackground.perform(\"#{file_name}\"#{usage_example})"
+        say ""
+        say "Next steps:"
+        say "  1. Edit the job file to add your logic"
+        say "  2. Run: cd app/jobs/rust && cargo build"
+        say ""
+      end
+
+      private
+
+      def file_name
+        job_name.underscore
+      end
+
+      def parsed_attributes
+        fields.map do |attr|
+          name, type = attr.split(":")
+          type ||= "string"
+
+          if model_type?(type)
+            { name: name, rust_type: type, ruby_type: type, is_model: true }
+          else
+            { name: name, rust_type: to_rust_type(type), ruby_type: type, is_model: false }
+          end
+        end
+      end
+
+      def model_type?(type)
+        type.match?(/\A[A-Z]/)
+      end
+
+      def model_attributes
+        @args.select { |a| a[:is_model] }.map { |a| a[:ruby_type] }.uniq
+      end
+
+      def model_columns(model_name)
+        model_class = model_name.constantize
+        model_class.columns.map do |col|
+          {
+            name: col.name,
+            rust_type: to_rust_type(col.type, nullable: col.null)
+          }
+        end
+      rescue NameError
+        say "Warning: Model #{model_name} not found, using empty struct", :yellow
+        [{ name: "id", rust_type: "i64" }]
+      end
+
+      def to_rust_type(type, nullable: false)
+        key = type.to_s.downcase
+        base_type = TYPE_MAPPINGS[key] || "serde_json::Value"
+        nullable ? "Option<#{base_type}>" : base_type
+      end
+
+      def usage_example
+        return "" if @args.empty?
+
+        examples = @args.map do |arg|
+          value = if arg[:is_model]
+            "#{arg[:ruby_type]}.first"
+          else
+            case arg[:ruby_type]
+            when "string", "text" then "\"...\""
+            when "integer", "int", "i64", "i32" then "123"
+            when "float", "decimal", "f64" then "1.5"
+            when "boolean", "bool" then "true"
+            else "..."
+            end
+          end
+          "#{arg[:name]}: #{value}"
+        end
+
+        ", " + examples.join(", ")
+      end
+    end
+  end
+end

data/lib/generators/job/templates/job.rs.erb

@@ -0,0 +1,37 @@
+use serde::Deserialize;
+use crate::worker::JobResult;
+<% model_attributes.each do |model_name| -%>
+
+#[derive(Debug, Deserialize)]
+struct <%= model_name %> {
+<% model_columns(model_name).each do |col| -%>
+    <%= col[:name] %>: <%= col[:rust_type] %>,
+<% end -%>
+}
+<% end -%>
+<% if @args.any? %>
+
+#[derive(Debug, Deserialize)]
+struct Args {
+<% @args.each do |arg| -%>
+    <%= arg[:name] %>: <%= arg[:rust_type] %>,
+<% end -%>
+}
+<% end %>
+
+pub async fn run(args: &serde_json::Value, _database_url: &str) -> JobResult {
+<% if @args.any? -%>
+    let args: Args = match serde_json::from_value(args.clone()) {
+        Ok(a) => a,
+        Err(e) => return JobResult::Failed(format!("Failed to parse args: {}", e)),
+    };
+
+    tracing::info!("<%= file_name %> job started: {:?}", args);
+<% else -%>
+    tracing::info!("<%= file_name %> job started with args: {:?}", args);
+<% end -%>
+
+    // TODO: Add your job logic here
+
+    JobResult::Success
+}

data/lib/rust_on_background/railtie.rb

@@ -0,0 +1,10 @@
+require "rails/railtie"
+
+module RustOnBackground
+  class Railtie < Rails::Railtie
+    generators do
+      require_relative "../generators/install/install_generator"
+      require_relative "../generators/job/job_generator"
+    end
+  end
+end

data/lib/rust_on_background/version.rb

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

data/lib/rust_on_background.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "json"
+require "redis"
+require "toml-rb"
+require_relative "rust_on_background/version"
+require_relative "rust_on_background/railtie" if defined?(Rails::Railtie)
+
+module RustOnBackground
+  class Error < StandardError; end
+
+  SCHEDULE_KEY = "rust_on_background:schedule"
+
+  def self.config
+    @config ||= TomlRB.load_file(Rails.root.join("app/jobs/rust/config.#{Rails.env}.toml"))
+  end
+
+  def self.perform(job_name, queue: "default", retry_count: 3, **args)
+    payload = {
+      job: job_name.to_s,
+      args: serialize_args(args),
+      retry: retry_count,
+      created_at: Time.now.to_i
+    }
+
+    begin
+      redis.lpush("queue:#{queue}", payload.to_json)
+    rescue Redis::BaseError => e
+      raise Error, "Failed to enqueue job: #{e.message}"
+    end
+  end
+
+  def self.perform_at(time, job_name, queue: "default", retry_count: 3, **args)
+    timestamp = normalize_time(time)
+    return perform(job_name, queue: queue, retry_count: retry_count, **args) if timestamp <= Time.now.to_f
+
+    payload = {
+      job: job_name.to_s,
+      args: serialize_args(args),
+      retry: retry_count,
+      created_at: Time.now.to_i,
+      queue: queue,
+      scheduled_at: timestamp.to_i
+    }
+
+    begin
+      redis.zadd(SCHEDULE_KEY, timestamp, payload.to_json)
+    rescue Redis::BaseError => e
+      raise Error, "Failed to schedule job: #{e.message}"
+    end
+  end
+
+  def self.serialize_args(args)
+    args.transform_values { |v| serialize_value(v) }
+  end
+
+  def self.normalize_time(time)
+    case time
+    when Time then time.to_f
+    when DateTime then time.to_time.to_f
+    when Integer, Float then time.to_f
+    else
+      if time.respond_to?(:to_time)
+        time.to_time.to_f
+      else
+        raise ArgumentError, "Invalid time class: #{time.class}"
+      end
+    end
+  end
+
+  def self.serialize_value(value)
+    case value
+    when nil, true, false, Integer, Float, String
+      value
+    when Symbol
+      value.to_s
+    when Time, DateTime
+      value.iso8601
+    when Date
+      value.to_s
+    when BigDecimal
+      value.to_f
+    when Set
+      value.to_a.map { |v| serialize_value(v) }
+    when Range
+      { start: serialize_value(value.begin), end: serialize_value(value.end), exclude_end: value.exclude_end? }
+    when Array
+      value.map { |v| serialize_value(v) }
+    when Hash
+      value.transform_keys(&:to_s).transform_values { |v| serialize_value(v) }
+    else
+      if defined?(ActiveRecord::Base) && value.is_a?(ActiveRecord::Base)
+        value.as_json
+      elsif defined?(ActiveRecord::Relation) && value.is_a?(ActiveRecord::Relation)
+        value.as_json
+      elsif value.respond_to?(:as_json)
+        value.as_json
+      elsif value.respond_to?(:to_h)
+        serialize_value(value.to_h)
+      else
+        value.to_s
+      end
+    end
+  end
+
+  def self.redis
+    @redis ||= Redis.new(url: config.dig("redis", "url") || "redis://127.0.0.1:6379")
+  end
+
+  def self.redis=(client)
+    @redis = client
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: rust_on_background
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- QuarkXZ
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2026-03-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: toml-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: A Rails gem that generates a Rust worker for processing background jobs
+  from Redis
+email:
+- quarkXZ@proton.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/generators/install/install_generator.rb
+- lib/generators/install/templates/Cargo.toml.erb
+- lib/generators/install/templates/config.toml.erb
+- lib/generators/install/templates/jobs/mod.rs
+- lib/generators/install/templates/main.rs
+- lib/generators/install/templates/rust_on_background.rake
+- lib/generators/install/templates/scheduler.rs
+- lib/generators/install/templates/worker.rs
+- lib/generators/job/job_generator.rb
+- lib/generators/job/templates/job.rs.erb
+- lib/rust_on_background.rb
+- lib/rust_on_background/railtie.rb
+- lib/rust_on_background/version.rb
+homepage: https://github.com/QuarkOnRails/rust_on_background
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/QuarkOnRails/rust_on_background
+  source_code_uri: https://github.com/QuarkOnRails/rust_on_background
+  changelog_uri: https://github.com/QuarkOnRails/rust_on_background/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key: 
+specification_version: 4
+summary: Run background jobs in Rust for Rails applications
+test_files: []