mq-ruby 0.1.0

data/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+authors = ["Takahiro Sato <harehare1110@gmail.com>"]
+categories = ["command-line-utilities", "text-processing"]
+description = "Ruby bindings for mq Markdown processing"
+edition = "2024"
+homepage = "https://mqlang.org/"
+keywords = ["markdown", "jq", "query", "ruby"]
+license = "MIT"
+name = "mq-ruby"
+publish = false
+readme = "README.md"
+repository = "https://github.com/harehare/mq"
+version = "0.1.0"
+
+[lib]
+crate-type = ["cdylib"]
+name = "mq_ruby"
+
+[dependencies]
+magnus = {version = "0.8"}
+mq-lang = "0.5.9"
+mq-markdown = "0.5.9"
+

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Takahiro Sato
+
+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,51 @@
+# mq-ruby
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Ruby bindings for [mq](https://mqlang.org/), a jq-like command-line tool for processing Markdown.
+
+## Ruby API
+
+Once complete, the Ruby API will look like this:
+
+```ruby
+require 'mq'
+
+# Basic usage
+markdown = <<~MD
+  # Main Title
+  ## Section 1
+  Some content here.
+  ## Section 2
+  More content.
+MD
+
+result = MQ.run('.h2', markdown)
+result.values.each do |heading|
+  puts heading
+end
+# => ## Section 1
+# => ## Section 2
+
+# With options
+options = MQ::Options.new
+options.input_format = MQ::InputFormat::HTML
+
+result = MQ.run('.h1', '<h1>Hello</h1><p>World</p>', options)
+puts result.text  # => # Hello
+
+# HTML to Markdown conversion
+html = '<h1>Title</h1><p>Paragraph</p>'
+markdown = MQ.html_to_markdown(html)
+puts markdown  # => # Title\n\nParagraph
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Links
+
+- [mq Website](https://mqlang.org/)
+- [GitHub Repository](https://github.com/harehare/mq)
+- [Command-line Tool](https://github.com/harehare/mq#installation)

data/extconf.rb

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

data/lib/mq.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+begin
+  # Try to load the compiled extension
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require_relative "mq/#{Regexp.last_match(1)}/mq_ruby"
+rescue LoadError
+  require_relative "mq/mq_ruby"
+end
+
+module MQ
+  class Error < StandardError; end
+
+  # Options class for configuring mq queries
+  class Options
+    attr_accessor :input_format
+
+    def initialize
+      @input_format = nil
+    end
+
+    def to_h
+      {
+        input_format: @input_format,
+      }.compact
+    end
+  end
+
+  # Conversion options for HTML to Markdown conversion
+  class ConversionOptions
+    attr_accessor :extract_scripts_as_code_blocks, :generate_front_matter, :use_title_as_h1
+
+    def initialize
+      @extract_scripts_as_code_blocks = false
+      @generate_front_matter = false
+      @use_title_as_h1 = false
+    end
+
+    def to_h
+      {
+        extract_scripts_as_code_blocks: @extract_scripts_as_code_blocks,
+        generate_front_matter: @generate_front_matter,
+        use_title_as_h1: @use_title_as_h1
+      }
+    end
+  end
+
+  class << self
+    # Run an mq query on the provided content
+    #
+    # @param code [String] The mq query string
+    # @param content [String] The markdown/HTML/text content to process
+    # @param options [Options, nil] Optional configuration options
+    # @return [Result] The query results
+    def run(code, content, options = nil)
+      options_hash = options&.to_h
+      _run(code, content, options_hash)
+    end
+
+    # Convert HTML to Markdown
+    #
+    # @param content [String] The HTML content to convert
+    # @param options [ConversionOptions, nil] Optional conversion options
+    # @return [String] The converted Markdown
+    def html_to_markdown(content, options = nil)
+      options_hash = options&.to_h
+      _html_to_markdown(content, options_hash)
+    end
+  end
+end

data/src/lib.rs

@@ -0,0 +1,106 @@
+//! Ruby bindings for the mq markdown processing library.
+//!
+//! This crate provides Ruby bindings for mq, allowing Ruby applications to
+//! process markdown, MDX, and HTML using the mq query language.
+
+pub mod result;
+pub mod value;
+
+use magnus::{Error, RHash, Ruby, TryConvert, function, prelude::*};
+use result::MQResult;
+use value::InputFormat;
+
+/// Main entry point for the Ruby extension
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let mq_module = ruby.define_module("MQ")?;
+
+    // Define input format constants
+    InputFormat::define_constants(ruby, mq_module)?;
+
+    // Define result class
+    MQResult::define_class(ruby, mq_module)?;
+
+    // Define module functions
+    mq_module.define_singleton_method("_run", function!(run, 3))?;
+    mq_module.define_singleton_method("_html_to_markdown", function!(html_to_markdown, 2))?;
+
+    Ok(())
+}
+
+/// Run an mq query on the provided content
+fn run(code: String, content: String, options_hash: Option<RHash>) -> Result<MQResult, Error> {
+    let ruby = Ruby::get().unwrap();
+    let mut engine = mq_lang::DefaultEngine::default();
+    engine.load_builtin_module();
+
+    // Parse options from hash
+    let input_format = if let Some(opts) = options_hash {
+        if let Some(val) = opts.get(ruby.to_symbol("input_format")) {
+            let format_val: i32 = TryConvert::try_convert(val)?;
+            InputFormat::from_i32(format_val)
+        } else {
+            InputFormat::Markdown
+        }
+    } else {
+        InputFormat::Markdown
+    };
+
+    let input = match input_format {
+        InputFormat::Markdown => mq_lang::parse_markdown_input(&content),
+        InputFormat::Mdx => mq_lang::parse_mdx_input(&content),
+        InputFormat::Text => mq_lang::parse_text_input(&content),
+        InputFormat::Html => mq_lang::parse_html_input(&content),
+        InputFormat::Raw => Ok(mq_lang::raw_input(&content)),
+        InputFormat::Null => Ok(mq_lang::null_input()),
+    }
+    .map_err(|e| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            format!("Error parsing input: {}", e),
+        )
+    })?;
+
+    engine
+        .eval(&code, input.into_iter())
+        .map(|values| MQResult::from(values.into_iter().map(Into::into).collect::<Vec<_>>()))
+        .map_err(|e| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                format!("Error evaluating query: {}", e),
+            )
+        })
+}
+
+/// Convert HTML to Markdown
+fn html_to_markdown(content: String, options_hash: Option<RHash>) -> Result<String, Error> {
+    let ruby = Ruby::get().unwrap();
+    let opts = if let Some(opts) = options_hash {
+        let extract_scripts = get_bool_option(&ruby, &opts, "extract_scripts_as_code_blocks")?;
+        let generate_front = get_bool_option(&ruby, &opts, "generate_front_matter")?;
+        let use_title = get_bool_option(&ruby, &opts, "use_title_as_h1")?;
+
+        mq_markdown::ConversionOptions {
+            extract_scripts_as_code_blocks: extract_scripts,
+            generate_front_matter: generate_front,
+            use_title_as_h1: use_title,
+        }
+    } else {
+        mq_markdown::ConversionOptions::default()
+    };
+
+    mq_markdown::convert_html_to_markdown(&content, opts).map_err(|e| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            format!("Error converting HTML to Markdown: {}", e),
+        )
+    })
+}
+
+fn get_bool_option(ruby: &Ruby, hash: &RHash, key: &str) -> Result<bool, Error> {
+    if let Some(val) = hash.get(ruby.to_symbol(key)) {
+        TryConvert::try_convert(val)
+    } else {
+        Ok(false)
+    }
+}

data/src/result.rs

@@ -0,0 +1,99 @@
+use crate::value::MQValue;
+use magnus::{DataTypeFunctions, Error, RModule, Ruby, TypedData, Value, method, prelude::*};
+
+/// Result of an mq query execution
+#[derive(Debug, Clone, TypedData)]
+#[magnus(class = "MQ::Result", free_immediately, mark)]
+pub struct MQResult {
+    pub values: Vec<MQValue>,
+}
+
+impl DataTypeFunctions for MQResult {}
+
+impl MQResult {
+    /// Define the MQResult class in Ruby
+    pub fn define_class(ruby: &Ruby, mq_module: RModule) -> Result<(), Error> {
+        let class = mq_module.define_class("Result", ruby.class_object())?;
+        class.define_method("text", method!(MQResult::text, 0))?;
+        class.define_method("values", method!(MQResult::values_as_strings, 0))?;
+        class.define_method("length", method!(MQResult::len, 0))?;
+        class.define_method("[]", method!(MQResult::get_at, 1))?;
+        class.define_method("each", method!(MQResult::each, 0))?;
+        Ok(())
+    }
+
+    /// Get the text representation of all values joined by newlines
+    pub fn text(&self) -> String {
+        self.values
+            .iter()
+            .filter_map(|value| {
+                if value.is_empty() {
+                    None
+                } else {
+                    Some(value.text())
+                }
+            })
+            .collect::<Vec<String>>()
+            .join("\n")
+    }
+
+    /// Get an array of text values
+    pub fn values_as_strings(&self) -> Vec<String> {
+        self.values
+            .iter()
+            .filter_map(|value| {
+                if value.is_empty() {
+                    None
+                } else {
+                    Some(value.text())
+                }
+            })
+            .collect()
+    }
+
+    /// Get the number of values
+    pub fn len(&self) -> usize {
+        self.values.len()
+    }
+
+    /// Check if the result is empty
+    pub fn is_empty(&self) -> bool {
+        self.values.is_empty()
+    }
+
+    /// Access a value by index (for Ruby)
+    fn get_at(&self, idx: usize) -> Result<String, Error> {
+        if idx < self.values.len() {
+            Ok(self.values[idx].text())
+        } else {
+            let ruby = Ruby::get().unwrap();
+            Err(Error::new(
+                ruby.exception_runtime_error(),
+                format!(
+                    "Index {} out of range for MQResult with length {}",
+                    idx,
+                    self.len()
+                ),
+            ))
+        }
+    }
+
+    /// Iterator for Ruby each method
+    fn each(&self) -> Result<Value, Error> {
+        let ruby = Ruby::get().unwrap();
+        let block = ruby.block_proc()?;
+
+        for value in &self.values {
+            let text = value.text();
+            block.call::<(String,), Value>((text,))?;
+        }
+
+        Ok(ruby.qnil().as_value())
+    }
+}
+
+impl From<Vec<MQValue>> for MQResult {
+    fn from(values: Vec<MQValue>) -> Self {
+        Self { values }
+    }
+}

data/src/value.rs

@@ -0,0 +1,124 @@
+use magnus::{Error, Module, RModule, Ruby};
+use std::{collections::HashMap, fmt};
+
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub enum InputFormat {
+    #[default]
+    Markdown,
+    Mdx,
+    Text,
+    Html,
+    Raw,
+    Null,
+}
+
+impl InputFormat {
+    pub fn define_constants(ruby: &Ruby, mq_module: RModule) -> Result<(), Error> {
+        let class = ruby.define_class("InputFormat", ruby.class_object())?;
+        mq_module.const_set("InputFormat", class)?;
+        class.const_set("MARKDOWN", 0)?;
+        class.const_set("MDX", 1)?;
+        class.const_set("TEXT", 2)?;
+        class.const_set("HTML", 3)?;
+        class.const_set("RAW", 4)?;
+        class.const_set("NULL", 5)?;
+        Ok(())
+    }
+
+    pub fn from_i32(val: i32) -> Self {
+        match val {
+            0 => InputFormat::Markdown,
+            1 => InputFormat::Mdx,
+            2 => InputFormat::Text,
+            3 => InputFormat::Html,
+            4 => InputFormat::Raw,
+            5 => InputFormat::Null,
+            _ => InputFormat::Markdown, // Default
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum MQValue {
+    Array { value: Vec<MQValue> },
+    Dict { value: HashMap<String, MQValue> },
+    Markdown { value: String },
+}
+
+impl fmt::Display for MQValue {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            MQValue::Array { value } => write!(
+                f,
+                "{}",
+                value
+                    .iter()
+                    .map(|val| val.text())
+                    .collect::<Vec<String>>()
+                    .join("\n")
+            ),
+            MQValue::Dict { value } => write!(
+                f,
+                "{}",
+                value
+                    .iter()
+                    .map(|(k, v)| format!("{}: {}", k, v.text()))
+                    .collect::<Vec<String>>()
+                    .join("\n")
+            ),
+            MQValue::Markdown { value } => write!(f, "{}", value),
+        }
+    }
+}
+
+impl MQValue {
+    pub fn text(&self) -> String {
+        self.to_string()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        match self {
+            MQValue::Array { value } => value.is_empty(),
+            MQValue::Dict { value } => value.is_empty(),
+            MQValue::Markdown { value } => value.is_empty(),
+        }
+    }
+}
+
+impl From<mq_lang::RuntimeValue> for MQValue {
+    fn from(value: mq_lang::RuntimeValue) -> Self {
+        match value {
+            mq_lang::RuntimeValue::Array(arr) => MQValue::Array {
+                value: arr.into_iter().map(|v| v.into()).collect(),
+            },
+            mq_lang::RuntimeValue::Dict(map) => MQValue::Dict {
+                value: map
+                    .into_iter()
+                    .map(|(k, v)| (k.as_str(), v.into()))
+                    .collect(),
+            },
+            mq_lang::RuntimeValue::Markdown(node, _) => MQValue::Markdown {
+                value: node.to_string(),
+            },
+            mq_lang::RuntimeValue::String(s) => MQValue::Markdown { value: s },
+            mq_lang::RuntimeValue::Symbol(i) => MQValue::Markdown { value: i.as_str() },
+            mq_lang::RuntimeValue::Number(n) => MQValue::Markdown {
+                value: n.to_string(),
+            },
+            mq_lang::RuntimeValue::Boolean(b) => MQValue::Markdown {
+                value: b.to_string(),
+            },
+            mq_lang::RuntimeValue::Function(..)
+            | mq_lang::RuntimeValue::NativeFunction(..)
+            | mq_lang::RuntimeValue::Module(..) => MQValue::Markdown {
+                value: "".to_string(),
+            },
+            mq_lang::RuntimeValue::Ast(_) => MQValue::Markdown {
+                value: "".to_string(),
+            },
+            mq_lang::RuntimeValue::None => MQValue::Markdown {
+                value: "".to_string(),
+            },
+        }
+    }
+}

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: mq-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Takahiro Sato
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: mq is a jq-like command-line tool for Markdown processing. This gem provides
+  Ruby bindings for mq.
+email:
+- harehare1110@gmail.com
+executables: []
+extensions:
+- extconf.rb
+extra_rdoc_files: []
+files:
+- Cargo.lock
+- Cargo.toml
+- LICENSE
+- README.md
+- extconf.rb
+- lib/mq.rb
+- src/lib.rs
+- src/result.rs
+- src/value.rs
+homepage: https://mqlang.org/
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://mqlang.org/
+  source_code_uri: https://github.com/harehare/mq
+  changelog_uri: https://github.com/harehare/mq/blob/main/crates/mq-ruby/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Ruby bindings for mq Markdown processing
+test_files: []