rfmt 0.1.0 → 0.2.2

data/ext/rfmt/src/emitter/mod.rs

@@ -0,0 +1,363 @@
+use crate::ast::{Comment, Node, NodeType};
+use crate::config::{Config, IndentStyle};
+use crate::error::Result;
+use std::fmt::Write;
+
+/// Code emitter that converts AST back to Ruby source code
+pub struct Emitter {
+    config: Config,
+    source: String,
+    buffer: String,
+    all_comments: Vec<Comment>,
+    emitted_comment_indices: Vec<usize>,
+}
+
+impl Emitter {
+    pub fn new(config: Config) -> Self {
+        Self {
+            config,
+            source: String::new(),
+            buffer: String::new(),
+            all_comments: Vec::new(),
+            emitted_comment_indices: Vec::new(),
+        }
+    }
+
+    /// Create emitter with source code for fallback extraction
+    pub fn with_source(config: Config, source: String) -> Self {
+        Self {
+            config,
+            source,
+            buffer: String::new(),
+            all_comments: Vec::new(),
+            emitted_comment_indices: Vec::new(),
+        }
+    }
+
+    /// Emit Ruby source code from an AST
+    pub fn emit(&mut self, ast: &Node) -> Result<String> {
+        self.buffer.clear();
+        self.emitted_comment_indices.clear();
+
+        // Collect all comments from the AST
+        self.collect_comments(ast);
+
+        self.emit_node(ast, 0)?;
+        Ok(self.buffer.clone())
+    }
+
+    /// Recursively collect all comments from the AST
+    fn collect_comments(&mut self, node: &Node) {
+        self.all_comments.extend(node.comments.clone());
+        for child in &node.children {
+            self.collect_comments(child);
+        }
+    }
+
+    /// Emit comments that appear before a given line
+    fn emit_comments_before(&mut self, line: usize, indent_level: usize) -> Result<()> {
+        let indent_str = match self.config.formatting.indent_style {
+            IndentStyle::Spaces => " ".repeat(self.config.formatting.indent_width * indent_level),
+            IndentStyle::Tabs => "\t".repeat(indent_level),
+        };
+
+        let mut indices_to_emit = Vec::new();
+        for (idx, comment) in self.all_comments.iter().enumerate() {
+            if self.emitted_comment_indices.contains(&idx) {
+                continue;
+            }
+
+            // Collect comments that end before this line
+            if comment.location.end_line < line {
+                indices_to_emit.push((idx, comment.text.clone()));
+            }
+        }
+
+        // Now emit the collected comments
+        for (idx, text) in indices_to_emit {
+            writeln!(self.buffer, "{}{}", indent_str, text)?;
+            self.emitted_comment_indices.push(idx);
+        }
+
+        Ok(())
+    }
+
+    /// Emit comments that appear on the same line (trailing comments)
+    fn emit_trailing_comments(&mut self, line: usize) -> Result<()> {
+        let mut indices_to_emit = Vec::new();
+        for (idx, comment) in self.all_comments.iter().enumerate() {
+            if self.emitted_comment_indices.contains(&idx) {
+                continue;
+            }
+
+            // Collect comments on the same line (trailing)
+            if comment.location.start_line == line {
+                indices_to_emit.push((idx, comment.text.clone()));
+            }
+        }
+
+        // Now emit the collected comments
+        for (idx, text) in indices_to_emit {
+            write!(self.buffer, " {}", text)?;
+            self.emitted_comment_indices.push(idx);
+        }
+
+        Ok(())
+    }
+
+    /// Emit a node with given indentation level
+    fn emit_node(&mut self, node: &Node, indent_level: usize) -> Result<()> {
+        match &node.node_type {
+            NodeType::ProgramNode => self.emit_program(node, indent_level)?,
+            NodeType::StatementsNode => self.emit_statements(node, indent_level)?,
+            NodeType::ClassNode => self.emit_class(node, indent_level)?,
+            NodeType::ModuleNode => self.emit_module(node, indent_level)?,
+            NodeType::DefNode => self.emit_method(node, indent_level)?,
+            _ => self.emit_generic(node, indent_level)?,
+        }
+        Ok(())
+    }
+
+    /// Emit program node (root)
+    fn emit_program(&mut self, node: &Node, indent_level: usize) -> Result<()> {
+        for (i, child) in node.children.iter().enumerate() {
+            self.emit_node(child, indent_level)?;
+
+            // Add newlines between top-level statements, normalizing to max 1 blank line
+            if i < node.children.len() - 1 {
+                let current_end_line = child.location.end_line;
+                let next_start_line = node.children[i + 1].location.start_line;
+                let line_diff = next_start_line.saturating_sub(current_end_line);
+
+                // Add 1 newline if consecutive, 2 newlines (1 blank line) if there was a gap
+                let newlines = if line_diff > 1 { 2 } else { 1 };
+                for _ in 0..newlines {
+                    self.buffer.push('\n');
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Emit statements node (body of class/module/def)
+    fn emit_statements(&mut self, node: &Node, indent_level: usize) -> Result<()> {
+        for (i, child) in node.children.iter().enumerate() {
+            self.emit_node(child, indent_level)?;
+
+            // Add newlines between statements, normalizing to max 1 blank line
+            if i < node.children.len() - 1 {
+                let current_end_line = child.location.end_line;
+                let next_start_line = node.children[i + 1].location.start_line;
+                let line_diff = next_start_line.saturating_sub(current_end_line);
+
+                // Add 1 newline if consecutive, 2 newlines (1 blank line) if there was a gap
+                let newlines = if line_diff > 1 { 2 } else { 1 };
+                for _ in 0..newlines {
+                    self.buffer.push('\n');
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Emit class definition
+    fn emit_class(&mut self, node: &Node, indent_level: usize) -> Result<()> {
+        // Emit any comments before this class
+        self.emit_comments_before(node.location.start_line, indent_level)?;
+
+        self.emit_indent(indent_level)?;
+        write!(self.buffer, "class ")?;
+
+        if let Some(name) = node.metadata.get("name") {
+            write!(self.buffer, "{}", name)?;
+        }
+
+        if let Some(superclass) = node.metadata.get("superclass") {
+            write!(self.buffer, " < {}", superclass)?;
+        }
+
+        self.buffer.push('\n');
+
+        // Emit body (children), but skip structural nodes like constant_read_node
+        for child in &node.children {
+            if self.is_structural_node(&child.node_type) {
+                continue;
+            }
+            self.emit_node(child, indent_level + 1)?;
+            // Note: don't add newline here, statements node will handle it
+        }
+
+        // Add newline before end if there was body content
+        if node
+            .children
+            .iter()
+            .any(|c| !self.is_structural_node(&c.node_type))
+        {
+            self.buffer.push('\n');
+        }
+
+        self.emit_indent(indent_level)?;
+        write!(self.buffer, "end")?;
+
+        Ok(())
+    }
+
+    /// Emit module definition
+    fn emit_module(&mut self, node: &Node, indent_level: usize) -> Result<()> {
+        // Emit any comments before this module
+        self.emit_comments_before(node.location.start_line, indent_level)?;
+
+        self.emit_indent(indent_level)?;
+        write!(self.buffer, "module ")?;
+
+        if let Some(name) = node.metadata.get("name") {
+            write!(self.buffer, "{}", name)?;
+        }
+
+        self.buffer.push('\n');
+
+        // Emit body (children), but skip structural nodes
+        for child in &node.children {
+            if self.is_structural_node(&child.node_type) {
+                continue;
+            }
+            self.emit_node(child, indent_level + 1)?;
+        }
+
+        // Add newline before end if there was body content
+        if node
+            .children
+            .iter()
+            .any(|c| !self.is_structural_node(&c.node_type))
+        {
+            self.buffer.push('\n');
+        }
+
+        self.emit_indent(indent_level)?;
+        write!(self.buffer, "end")?;
+
+        Ok(())
+    }
+
+    /// Emit method definition
+    fn emit_method(&mut self, node: &Node, indent_level: usize) -> Result<()> {
+        // Emit any comments before this method
+        self.emit_comments_before(node.location.start_line, indent_level)?;
+
+        self.emit_indent(indent_level)?;
+        write!(self.buffer, "def ")?;
+
+        if let Some(name) = node.metadata.get("name") {
+            write!(self.buffer, "{}", name)?;
+        }
+
+        // TODO: Handle parameters properly
+        // For now, extract from source if method has parameters
+        if node
+            .metadata
+            .get("parameters_count")
+            .and_then(|s| s.parse::<usize>().ok())
+            .unwrap_or(0)
+            > 0
+        {
+            // Extract parameter part from source
+            if !self.source.is_empty() && node.location.end_offset <= self.source.len() {
+                if let Some(source_text) = self
+                    .source
+                    .get(node.location.start_offset..node.location.end_offset)
+                {
+                    // Find parameters in source (between def name and \n or ;)
+                    if let Some(def_line) = source_text.lines().next() {
+                        if let Some(params_start) = def_line.find('(') {
+                            if let Some(params_end) = def_line.find(')') {
+                                let params = &def_line[params_start..=params_end];
+                                write!(self.buffer, "{}", params)?;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        self.buffer.push('\n');
+
+        // Emit body (children), but skip structural nodes like parameter nodes
+        for child in &node.children {
+            if self.is_structural_node(&child.node_type) {
+                continue;
+            }
+            self.emit_node(child, indent_level + 1)?;
+        }
+
+        // Add newline before end if there was body content
+        if node
+            .children
+            .iter()
+            .any(|c| !self.is_structural_node(&c.node_type))
+        {
+            self.buffer.push('\n');
+        }
+
+        self.emit_indent(indent_level)?;
+        write!(self.buffer, "end")?;
+
+        Ok(())
+    }
+
+    /// Emit generic node by extracting from source
+    fn emit_generic(&mut self, node: &Node, indent_level: usize) -> Result<()> {
+        // Emit any comments before this node
+        self.emit_comments_before(node.location.start_line, indent_level)?;
+
+        if !self.source.is_empty() {
+            let start = node.location.start_offset;
+            let end = node.location.end_offset;
+
+            // Clone text first to avoid borrow conflict
+            let text_owned = self.source.get(start..end).map(|s| s.to_string());
+
+            if let Some(text) = text_owned {
+                // Add indentation before the extracted text
+                self.emit_indent(indent_level)?;
+                write!(self.buffer, "{}", text)?;
+
+                // Emit any trailing comments on the same line
+                self.emit_trailing_comments(node.location.end_line)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Emit indentation
+    fn emit_indent(&mut self, level: usize) -> Result<()> {
+        let indent_str = match self.config.formatting.indent_style {
+            IndentStyle::Spaces => " ".repeat(self.config.formatting.indent_width * level),
+            IndentStyle::Tabs => "\t".repeat(level),
+        };
+
+        write!(self.buffer, "{}", indent_str)?;
+        Ok(())
+    }
+
+    /// Check if node is structural (part of definition syntax, not body)
+    fn is_structural_node(&self, node_type: &NodeType) -> bool {
+        matches!(
+            node_type,
+            NodeType::ConstantReadNode
+                | NodeType::ConstantWriteNode
+                | NodeType::ConstantPathNode
+                | NodeType::RequiredParameterNode
+                | NodeType::OptionalParameterNode
+                | NodeType::RestParameterNode
+                | NodeType::KeywordParameterNode
+                | NodeType::KeywordRestParameterNode
+                | NodeType::BlockParameterNode
+        )
+    }
+}
+
+impl Default for Emitter {
+    fn default() -> Self {
+        Self::new(Config::default())
+    }
+}

data/ext/rfmt/src/error/mod.rs

@@ -0,0 +1,48 @@
+use magnus::{Error as MagnusError, Ruby};
+use thiserror::Error;
+
+pub type Result<T> = std::result::Result<T, RfmtError>;
+
+#[derive(Error, Debug)]
+pub enum RfmtError {
+    #[error("Prism integration error: {0}")]
+    PrismError(String),
+
+    #[error("Format error: {0}")]
+    FormatError(String),
+
+    #[error("Unsupported feature: {feature}\n{explanation}")]
+    UnsupportedFeature {
+        feature: String,
+        explanation: String,
+    },
+
+    #[error("Configuration error: {message}")]
+    #[cfg(test)]
+    ConfigError { message: String },
+}
+
+// Implement From for std::fmt::Error
+impl From<std::fmt::Error> for RfmtError {
+    fn from(err: std::fmt::Error) -> Self {
+        RfmtError::FormatError(err.to_string())
+    }
+}
+
+impl RfmtError {
+    /// Convert RfmtError to Magnus Error for Ruby interop
+    pub fn to_magnus_error(&self, ruby: &Ruby) -> MagnusError {
+        let exception_class = match self {
+            RfmtError::PrismError(_) => "PrismError",
+            RfmtError::FormatError(_) => "FormatError",
+            RfmtError::UnsupportedFeature { .. } => "UnsupportedFeature",
+            #[cfg(test)]
+            RfmtError::ConfigError { .. } => "ConfigError",
+        };
+
+        MagnusError::new(
+            ruby.exception_standard_error(),
+            format!("[Rfmt::{}] {}", exception_class, self),
+        )
+    }
+}

data/ext/rfmt/src/lib.rs

@@ -1,48 +1,71 @@
+mod ast;
+mod config;
+mod emitter;
+mod error;
+mod logging;
+mod parser;
+mod policy;
+
+use policy::SecurityPolicy;
+
+use config::Config;
+use emitter::Emitter;
 use magnus::{define_module, function, prelude::*, Error, Ruby};
+use parser::{PrismAdapter, RubyParser};
+
+fn format_ruby_code(ruby: &Ruby, source: String, json: String) -> Result<String, Error> {
+    let policy = SecurityPolicy::default();
+
+    policy
+        .validate_source_size(&source)
+        .map_err(|e| e.to_magnus_error(ruby))?;
+
+    log::debug!("Source code validated, size: {} bytes", source.len());
+
+    let parser = PrismAdapter::new();
+    let ast = parser.parse(&json).map_err(|e| e.to_magnus_error(ruby))?;
+
+    let config = Config::default();
+    let mut emitter = Emitter::with_source(config, source);
+
+    let formatted = emitter.emit(&ast).map_err(|e| e.to_magnus_error(ruby))?;
 
-fn format_ruby_code(source: String) -> String {
-    // indent with 2 spaces
-    let lines: Vec<&str> = source.lines().collect();
-    let mut result = Vec::new();
-    let mut indent_level: i32 = 0;
-    
-    for line in lines {
-        let trimmed = line.trim();
-        
-        if trimmed == "end" || trimmed.starts_with("end ") 
-            || trimmed == "}" || trimmed == "]" {
-            indent_level = indent_level.saturating_sub(1);
-        }
-        
-        // eval indent
-        if !trimmed.is_empty() {
-            result.push(format!("{}{}", "  ".repeat(indent_level as usize), trimmed));
-        } else {
-            result.push(String::new());
-        }
-        
-        // add indent lebel
-        if trimmed.starts_with("def ") || trimmed.starts_with("class ")
-            || trimmed.starts_with("module ") || trimmed.starts_with("if ")
-            || trimmed.starts_with("unless ") || trimmed.starts_with("while ")
-            || trimmed.starts_with("for ") || trimmed.starts_with("do ")
-            || trimmed == "do" || trimmed.ends_with(" do")
-            || trimmed == "{" || trimmed == "[" {
-            indent_level += 1;
-        }
-    }
-    
-    result.join("\n")
+    Ok(formatted)
+}
+
+/// Parse Ruby source code and return JSON AST representation
+/// This is useful for debugging and integration testing
+fn parse_to_json(ruby: &Ruby, source: String) -> Result<String, Error> {
+    let parser = PrismAdapter::new();
+    let ast = parser.parse(&source).map_err(|e| e.to_magnus_error(ruby))?;
+
+    Ok(format!("{:#?}", ast))
 }
 
 fn rust_version() -> String {
-    "0.1.0 (Rust)".to_string()
+    "0.2.0 (Rust)".to_string()
 }
 
 #[magnus::init]
-fn init(_ruby: &Ruby) -> Result<(), Error> {
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    logging::RfmtLogger::init();
+    log::info!("Initializing rfmt Rust extension");
+
     let module = define_module("Rfmt")?;
-    module.define_singleton_method("format_code", function!(format_ruby_code, 1))?;
+
+    module.define_singleton_method("format_code", function!(format_ruby_code, 2))?;
+    module.define_singleton_method("parse_to_json", function!(parse_to_json, 1))?;
     module.define_singleton_method("rust_version", function!(rust_version, 0))?;
+
+    let rfmt_error = ruby.define_error("RfmtError", ruby.exception_standard_error())?;
+    ruby.define_error("ParseError", rfmt_error)?;
+    ruby.define_error("ConfigError", rfmt_error)?;
+    ruby.define_error("PrismError", rfmt_error)?;
+    ruby.define_error("RuleError", rfmt_error)?;
+    ruby.define_error("InternalError", rfmt_error)?;
+    ruby.define_error("FormattingError", rfmt_error)?;
+    ruby.define_error("UnsupportedFeature", rfmt_error)?;
+
+    log::info!("rfmt Rust extension initialized successfully");
     Ok(())
 }

data/ext/rfmt/src/logging/logger.rs

@@ -0,0 +1,128 @@
+use log::{LevelFilter, Log, Metadata, Record};
+use std::io::Write;
+use std::sync::Mutex;
+
+pub struct RfmtLogger {
+    level: LevelFilter,
+    output: Mutex<Box<dyn Write + Send>>,
+}
+
+impl RfmtLogger {
+    pub fn new(level: LevelFilter) -> Self {
+        Self {
+            level,
+            output: Mutex::new(Box::new(std::io::stderr())),
+        }
+    }
+
+    #[cfg(test)]
+    pub fn with_output(mut self, output: Box<dyn Write + Send>) -> Self {
+        self.output = Mutex::new(output);
+        self
+    }
+
+    pub fn init() {
+        let logger = Self::new(LevelFilter::Info);
+        log::set_boxed_logger(Box::new(logger)).expect("Failed to initialize logger");
+        log::set_max_level(LevelFilter::Trace);
+    }
+}
+
+impl Log for RfmtLogger {
+    fn enabled(&self, metadata: &Metadata) -> bool {
+        metadata.level() <= self.level
+    }
+
+    fn log(&self, record: &Record) {
+        if !self.enabled(record.metadata()) {
+            return;
+        }
+
+        let mut output = self.output.lock().unwrap();
+
+        writeln!(
+            output,
+            "[{}] {} - {}",
+            record.level(),
+            record.target(),
+            record.args()
+        )
+        .ok();
+    }
+
+    fn flush(&self) {
+        let mut output = self.output.lock().unwrap();
+        output.flush().ok();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use log::{debug, error, info, trace, warn};
+    use std::sync::{Arc, Mutex};
+
+    struct TestWriter {
+        data: Arc<Mutex<Vec<u8>>>,
+    }
+
+    impl TestWriter {
+        fn new() -> (Self, Arc<Mutex<Vec<u8>>>) {
+            let data = Arc::new(Mutex::new(Vec::new()));
+            (
+                Self {
+                    data: Arc::clone(&data),
+                },
+                data,
+            )
+        }
+    }
+
+    impl Write for TestWriter {
+        fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+            self.data.lock().unwrap().write(buf)
+        }
+
+        fn flush(&mut self) -> std::io::Result<()> {
+            self.data.lock().unwrap().flush()
+        }
+    }
+
+    #[test]
+    fn test_logger_creation() {
+        let logger = RfmtLogger::new(LevelFilter::Info);
+        assert!(logger.enabled(&Metadata::builder().level(log::Level::Info).build()));
+        assert!(!logger.enabled(&Metadata::builder().level(log::Level::Debug).build()));
+    }
+
+    #[test]
+    fn test_logger_level_filtering() {
+        let logger = RfmtLogger::new(LevelFilter::Warn);
+
+        assert!(logger.enabled(&Metadata::builder().level(log::Level::Error).build()));
+        assert!(logger.enabled(&Metadata::builder().level(log::Level::Warn).build()));
+        assert!(!logger.enabled(&Metadata::builder().level(log::Level::Info).build()));
+        assert!(!logger.enabled(&Metadata::builder().level(log::Level::Debug).build()));
+        assert!(!logger.enabled(&Metadata::builder().level(log::Level::Trace).build()));
+    }
+
+    #[test]
+    fn test_logger_output() {
+        let (writer, data) = TestWriter::new();
+        let logger = RfmtLogger::new(LevelFilter::Info).with_output(Box::new(writer));
+
+        let record = Record::builder()
+            .level(log::Level::Info)
+            .target("test")
+            .args(format_args!("test message"))
+            .build();
+
+        logger.log(&record);
+        logger.flush();
+
+        let output = String::from_utf8(data.lock().unwrap().clone()).unwrap();
+        assert!(output.contains("[INFO]"));
+        assert!(output.contains("test"));
+        assert!(output.contains("test message"));
+    }
+}

data/ext/rfmt/src/logging/mod.rs

@@ -0,0 +1,3 @@
+pub mod logger;
+
+pub use logger::RfmtLogger;

data/ext/rfmt/src/parser/mod.rs

@@ -0,0 +1,9 @@
+use crate::ast::Node;
+use crate::error::Result;
+
+pub mod prism_adapter;
+pub use prism_adapter::PrismAdapter;
+
+pub trait RubyParser: Send + Sync {
+    fn parse(&self, source: &str) -> Result<Node>;
+}