rfmt 0.1.0 → 0.2.1

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

@@ -0,0 +1,407 @@
+use crate::ast::{Comment, CommentPosition, CommentType, FormattingInfo, Location, Node, NodeType};
+use crate::error::{Result, RfmtError};
+use crate::parser::RubyParser;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// Prism parser adapter
+/// This integrates with Ruby Prism parser via Magnus FFI
+pub struct PrismAdapter;
+
+impl PrismAdapter {
+    pub fn new() -> Self {
+        Self
+    }
+
+    /// Parse JSON from Ruby's PrismBridge
+    fn parse_json(&self, json: &str) -> Result<(PrismNode, Vec<PrismComment>)> {
+        // Try to parse as new format with comments first
+        if let Ok(wrapper) = serde_json::from_str::<PrismWrapper>(json) {
+            return Ok((wrapper.ast, wrapper.comments));
+        }
+
+        // Fall back to old format (single node without comments)
+        let node: PrismNode = serde_json::from_str(json)
+            .map_err(|e| RfmtError::PrismError(format!("Failed to parse Prism JSON: {}", e)))?;
+        Ok((node, Vec::new()))
+    }
+
+    /// Convert PrismNode to internal Node representation
+    fn convert_node(&self, prism_node: &PrismNode) -> Result<Node> {
+        // Convert node type (always succeeds, returns Unknown for unsupported types)
+        let node_type = NodeType::from_str(&prism_node.node_type);
+
+        // Convert location
+        let location = Location::new(
+            prism_node.location.start_line,
+            prism_node.location.start_column,
+            prism_node.location.end_line,
+            prism_node.location.end_column,
+            prism_node.location.start_offset,
+            prism_node.location.end_offset,
+        );
+
+        // Convert children recursively
+        let children: Result<Vec<Node>> = prism_node
+            .children
+            .iter()
+            .map(|child| self.convert_node(child))
+            .collect();
+        let children = children?;
+
+        // Convert comments
+        let comments: Vec<Comment> = prism_node
+            .comments
+            .iter()
+            .map(|c| self.convert_comment(c))
+            .collect();
+
+        // Convert formatting info
+        let formatting = FormattingInfo {
+            indent_level: prism_node.formatting.indent_level,
+            needs_blank_line_before: prism_node.formatting.needs_blank_line_before,
+            needs_blank_line_after: prism_node.formatting.needs_blank_line_after,
+            preserve_newlines: prism_node.formatting.preserve_newlines,
+            multiline: prism_node.formatting.multiline,
+            original_formatting: prism_node.formatting.original_formatting.clone(),
+        };
+
+        Ok(Node {
+            node_type,
+            location,
+            children,
+            metadata: prism_node.metadata.clone(),
+            comments,
+            formatting,
+        })
+    }
+
+    /// Convert PrismComment to internal Comment
+    fn convert_comment(&self, comment: &PrismComment) -> Comment {
+        let comment_type = match comment.comment_type.as_str() {
+            "line" => CommentType::Line,
+            "block" => CommentType::Block,
+            _ => CommentType::Line, // default to line comment
+        };
+
+        let position = match comment.position.as_str() {
+            "leading" => CommentPosition::Leading,
+            "trailing" => CommentPosition::Trailing,
+            "inner" => CommentPosition::Inner,
+            _ => CommentPosition::Leading, // default to leading
+        };
+
+        Comment {
+            text: comment.text.clone(),
+            location: Location::new(
+                comment.location.start_line,
+                comment.location.start_column,
+                comment.location.end_line,
+                comment.location.end_column,
+                comment.location.start_offset,
+                comment.location.end_offset,
+            ),
+            comment_type,
+            position,
+        }
+    }
+}
+
+impl RubyParser for PrismAdapter {
+    fn parse(&self, json: &str) -> Result<Node> {
+        let (prism_ast, top_level_comments) = self.parse_json(json)?;
+        let mut node = self.convert_node(&prism_ast)?;
+
+        // Attach top-level comments to the root node
+        if !top_level_comments.is_empty() {
+            node.comments
+                .extend(top_level_comments.iter().map(|c| self.convert_comment(c)));
+        }
+
+        Ok(node)
+    }
+}
+
+impl Default for PrismAdapter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Wrapper for JSON containing both AST and comments
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PrismWrapper {
+    pub ast: PrismNode,
+    pub comments: Vec<PrismComment>,
+}
+
+/// JSON representation of a Prism node from Ruby
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PrismNode {
+    pub node_type: String,
+    pub location: PrismLocation,
+    pub children: Vec<PrismNode>,
+    pub metadata: HashMap<String, String>,
+    pub comments: Vec<PrismComment>,
+    pub formatting: PrismFormattingInfo,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PrismLocation {
+    pub start_line: usize,
+    pub start_column: usize,
+    pub end_line: usize,
+    pub end_column: usize,
+    pub start_offset: usize,
+    pub end_offset: usize,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PrismComment {
+    pub text: String,
+    pub location: PrismLocation,
+    pub comment_type: String,
+    pub position: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PrismFormattingInfo {
+    pub indent_level: usize,
+    pub needs_blank_line_before: bool,
+    pub needs_blank_line_after: bool,
+    pub preserve_newlines: bool,
+    pub multiline: bool,
+    pub original_formatting: Option<String>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_simple_program() {
+        let adapter = PrismAdapter::new();
+        let json = r#"{
+            "node_type": "program_node",
+            "location": {
+                "start_line": 1,
+                "start_column": 0,
+                "end_line": 1,
+                "end_column": 12,
+                "start_offset": 0,
+                "end_offset": 12
+            },
+            "children": [],
+            "metadata": {},
+            "comments": [],
+            "formatting": {
+                "indent_level": 0,
+                "needs_blank_line_before": false,
+                "needs_blank_line_after": false,
+                "preserve_newlines": false,
+                "multiline": false,
+                "original_formatting": null
+            }
+        }"#;
+
+        let result = adapter.parse(json);
+        assert!(result.is_ok());
+
+        let node = result.unwrap();
+        assert_eq!(node.node_type, NodeType::ProgramNode);
+        assert_eq!(node.location.start_line, 1);
+        assert_eq!(node.location.end_line, 1);
+    }
+
+    #[test]
+    fn test_parse_with_children() {
+        let adapter = PrismAdapter::new();
+        let json = r#"{
+            "node_type": "program_node",
+            "location": {
+                "start_line": 1,
+                "start_column": 0,
+                "end_line": 1,
+                "end_column": 14,
+                "start_offset": 0,
+                "end_offset": 14
+            },
+            "children": [
+                {
+                    "node_type": "class_node",
+                    "location": {
+                        "start_line": 1,
+                        "start_column": 0,
+                        "end_line": 1,
+                        "end_column": 14,
+                        "start_offset": 0,
+                        "end_offset": 14
+                    },
+                    "children": [],
+                    "metadata": {"name": "Foo"},
+                    "comments": [],
+                    "formatting": {
+                        "indent_level": 0,
+                        "needs_blank_line_before": false,
+                        "needs_blank_line_after": false,
+                        "preserve_newlines": false,
+                        "multiline": false,
+                        "original_formatting": null
+                    }
+                }
+            ],
+            "metadata": {},
+            "comments": [],
+            "formatting": {
+                "indent_level": 0,
+                "needs_blank_line_before": false,
+                "needs_blank_line_after": false,
+                "preserve_newlines": false,
+                "multiline": false,
+                "original_formatting": null
+            }
+        }"#;
+
+        let result = adapter.parse(json);
+        assert!(result.is_ok());
+
+        let node = result.unwrap();
+        assert_eq!(node.node_type, NodeType::ProgramNode);
+        assert_eq!(node.children.len(), 1);
+
+        let child = &node.children[0];
+        assert_eq!(child.node_type, NodeType::ClassNode);
+        assert_eq!(child.metadata.get("name"), Some(&"Foo".to_string()));
+    }
+
+    #[test]
+    fn test_parse_with_metadata() {
+        let adapter = PrismAdapter::new();
+        let json = r#"{
+            "node_type": "def_node",
+            "location": {
+                "start_line": 1,
+                "start_column": 0,
+                "end_line": 1,
+                "end_column": 10,
+                "start_offset": 0,
+                "end_offset": 10
+            },
+            "children": [],
+            "metadata": {
+                "name": "hello",
+                "parameters_count": "1"
+            },
+            "comments": [],
+            "formatting": {
+                "indent_level": 0,
+                "needs_blank_line_before": false,
+                "needs_blank_line_after": false,
+                "preserve_newlines": false,
+                "multiline": false,
+                "original_formatting": null
+            }
+        }"#;
+
+        let result = adapter.parse(json);
+        assert!(result.is_ok());
+
+        let node = result.unwrap();
+        assert_eq!(node.node_type, NodeType::DefNode);
+        assert_eq!(node.metadata.get("name"), Some(&"hello".to_string()));
+        assert_eq!(
+            node.metadata.get("parameters_count"),
+            Some(&"1".to_string())
+        );
+    }
+
+    #[test]
+    fn test_parse_multiline() {
+        let adapter = PrismAdapter::new();
+        let json = r#"{
+            "node_type": "class_node",
+            "location": {
+                "start_line": 1,
+                "start_column": 0,
+                "end_line": 3,
+                "end_column": 3,
+                "start_offset": 0,
+                "end_offset": 20
+            },
+            "children": [],
+            "metadata": {"name": "Foo"},
+            "comments": [],
+            "formatting": {
+                "indent_level": 0,
+                "needs_blank_line_before": false,
+                "needs_blank_line_after": false,
+                "preserve_newlines": false,
+                "multiline": true,
+                "original_formatting": null
+            }
+        }"#;
+
+        let result = adapter.parse(json);
+        assert!(result.is_ok());
+
+        let node = result.unwrap();
+        assert_eq!(node.node_type, NodeType::ClassNode);
+        assert_eq!(node.formatting.multiline, true);
+        assert!(node.is_multiline());
+        assert_eq!(node.line_count(), 3);
+    }
+
+    #[test]
+    fn test_parse_invalid_json() {
+        let adapter = PrismAdapter::new();
+        let json = "invalid json";
+
+        let result = adapter.parse(json);
+        assert!(result.is_err());
+
+        match result {
+            Err(RfmtError::PrismError(msg)) => {
+                assert!(msg.contains("Failed to parse Prism JSON"));
+            }
+            _ => panic!("Expected PrismError"),
+        }
+    }
+
+    #[test]
+    fn test_parse_unknown_node_type() {
+        let adapter = PrismAdapter::new();
+        let json = r#"{
+            "node_type": "totally_unknown_node",
+            "location": {
+                "start_line": 1,
+                "start_column": 0,
+                "end_line": 1,
+                "end_column": 10,
+                "start_offset": 0,
+                "end_offset": 10
+            },
+            "children": [],
+            "metadata": {},
+            "comments": [],
+            "formatting": {
+                "indent_level": 0,
+                "needs_blank_line_before": false,
+                "needs_blank_line_after": false,
+                "preserve_newlines": false,
+                "multiline": false,
+                "original_formatting": null
+            }
+        }"#;
+
+        let result = adapter.parse(json);
+        assert!(result.is_ok());
+
+        let node = result.unwrap();
+        assert_eq!(
+            node.node_type,
+            NodeType::Unknown("totally_unknown_node".to_string())
+        );
+        assert!(node.is_unknown());
+        assert_eq!(node.unknown_type(), Some("totally_unknown_node"));
+    }
+}

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

@@ -0,0 +1,36 @@
+pub mod validation;
+
+use crate::error::Result;
+
+/// Security policy for rfmt operations
+#[derive(Debug, Clone)]
+pub struct SecurityPolicy {
+    /// Maximum file size in bytes (default: 10MB)
+    pub max_file_size: u64,
+}
+
+impl SecurityPolicy {
+    /// Validate source code size
+    pub fn validate_source_size(&self, source: &str) -> Result<()> {
+        validation::validate_source_size(source, self.max_file_size)
+    }
+}
+
+impl Default for SecurityPolicy {
+    fn default() -> Self {
+        Self {
+            max_file_size: 10 * 1024 * 1024, // 10MB
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_default_policy() {
+        let policy = SecurityPolicy::default();
+        assert_eq!(policy.max_file_size, 10 * 1024 * 1024);
+    }
+}

data/ext/rfmt/src/policy/validation.rs

@@ -0,0 +1,18 @@
+use crate::error::{Result, RfmtError};
+
+/// Validate source code size
+pub fn validate_source_size(source: &str, max_size: u64) -> Result<()> {
+    let size = source.len() as u64;
+
+    if size > max_size {
+        return Err(RfmtError::UnsupportedFeature {
+            feature: "Large file".to_string(),
+            explanation: format!(
+                "Source code is too large ({} bytes, max {} bytes)",
+                size, max_size
+            ),
+        });
+    }
+
+    Ok(())
+}

data/lib/rfmt/cache.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+require 'fileutils'
+
+module Rfmt
+  # Cache system for formatted files
+  # Uses SHA256 hash of file content to determine if formatting is needed
+  class Cache
+    class CacheError < StandardError; end
+
+    DEFAULT_CACHE_DIR = File.expand_path('~/.cache/rfmt').freeze
+    CACHE_VERSION = '1'
+
+    attr_reader :cache_dir
+
+    def initialize(cache_dir: DEFAULT_CACHE_DIR)
+      @cache_dir = cache_dir
+      @cache_data = {}
+      ensure_cache_dir
+      load_cache
+    end
+
+    # Check if file needs formatting
+    # Returns true if file content has changed or not in cache
+    def needs_formatting?(file_path)
+      return true unless File.exist?(file_path)
+
+      current_hash = file_hash(file_path)
+      cached_hash = @cache_data.dig(file_path, 'hash')
+
+      current_hash != cached_hash
+    end
+
+    # Mark file as formatted with current content
+    def mark_formatted(file_path)
+      return unless File.exist?(file_path)
+
+      @cache_data[file_path] = {
+        'hash' => file_hash(file_path),
+        'formatted_at' => Time.now.to_i,
+        'version' => CACHE_VERSION
+      }
+    end
+
+    # Save cache to disk
+    def save
+      cache_file = File.join(@cache_dir, 'cache.json')
+      File.write(cache_file, JSON.pretty_generate(@cache_data))
+    end
+
+    # Clear all cache data
+    def clear
+      @cache_data = {}
+      save
+    end
+
+    # Remove cache for specific file
+    def invalidate(file_path)
+      @cache_data.delete(file_path)
+    end
+
+    # Get cache statistics
+    def stats
+      {
+        total_files: @cache_data.size,
+        cache_dir: @cache_dir,
+        cache_size_bytes: cache_size
+      }
+    end
+
+    # Prune old cache entries (files that no longer exist)
+    def prune
+      before_count = @cache_data.size
+      @cache_data.delete_if { |file_path, _| !File.exist?(file_path) }
+      after_count = @cache_data.size
+      pruned = before_count - after_count
+
+      save if pruned.positive?
+      pruned
+    end
+
+    private
+
+    def ensure_cache_dir
+      FileUtils.mkdir_p(@cache_dir)
+    rescue StandardError => e
+      raise CacheError, "Failed to create cache directory: #{e.message}"
+    end
+
+    def load_cache
+      cache_file = File.join(@cache_dir, 'cache.json')
+      return unless File.exist?(cache_file)
+
+      content = File.read(cache_file)
+      @cache_data = JSON.parse(content)
+    rescue JSON::ParserError => e
+      warn "Warning: Failed to parse cache file, starting with empty cache: #{e.message}"
+      @cache_data = {}
+    rescue StandardError => e
+      warn "Warning: Failed to load cache, starting with empty cache: #{e.message}"
+      @cache_data = {}
+    end
+
+    def file_hash(file_path)
+      content = File.read(file_path)
+      Digest::SHA256.hexdigest(content)
+    rescue StandardError => e
+      raise CacheError, "Failed to read file #{file_path}: #{e.message}"
+    end
+
+    def cache_size
+      cache_file = File.join(@cache_dir, 'cache.json')
+      return 0 unless File.exist?(cache_file)
+
+      File.size(cache_file)
+    end
+  end
+end