rbcsv 0.1.4 → 0.1.7

data/ext/rbcsv/src/parser.rs

@@ -0,0 +1,187 @@
+use crate::error::{CsvError, ErrorKind};
+use std::fs;
+use std::path::Path;
+
+/// CSV解析のオプション設定
+#[derive(Debug, Clone)]
+pub struct CsvParseOptions {
+    pub trim: bool,
+    // 将来的な拡張用
+    // pub headers: bool,
+    // pub delimiter: char,
+}
+
+impl Default for CsvParseOptions {
+    fn default() -> Self {
+        Self {
+            trim: false,
+        }
+    }
+}
+
+/// エスケープシーケンスを実際の文字に変換
+pub fn escape_sanitize(s: &str) -> String {
+    s.replace("\\n", "\n")
+        .replace("\\r", "\r")
+        .replace("\\t", "\t")
+        .replace("\\\"", "\"")
+        .replace("\\\\", "\\")
+}
+
+/// 基本的なCSVパース処理
+pub fn parse_csv_core(input: &str, trim_config: csv::Trim) -> Result<Vec<Vec<String>>, CsvError> {
+    // 空のデータチェック
+    if input.trim().is_empty() {
+        return Err(CsvError::empty_data());
+    }
+
+    // エスケープシーケンスを実際の文字に変換
+    let processed = escape_sanitize(input);
+
+    let mut reader = csv::ReaderBuilder::new()
+        .has_headers(false) // ヘッダーを無効にして、すべての行を読み込む
+        .trim(trim_config)
+        .from_reader(processed.as_bytes());
+
+    let mut records = Vec::new();
+
+    for (line_num, result) in reader.records().enumerate() {
+        match result {
+            Ok(record) => {
+                let row: Vec<String> = record.iter().map(|field| field.to_string()).collect();
+                records.push(row);
+            }
+            Err(e) => {
+                // フィールド数不一致エラーを詳細化
+                if let csv::ErrorKind::UnequalLengths { expected_len, len, .. } = e.kind() {
+                    let error_msg = format!(
+                        "Field count mismatch at line {}: expected {} fields, got {} fields",
+                        line_num + 1,
+                        expected_len,
+                        len
+                    );
+                    return Err(CsvError::new(ErrorKind::FieldCountMismatch, error_msg));
+                }
+
+                // その他のcsvエラーを自動変換
+                return Err(CsvError::from(e));
+            }
+        }
+    }
+
+    if records.is_empty() {
+        return Err(CsvError::empty_data());
+    }
+
+    Ok(records)
+}
+
+/// オプション設定を使ったCSV解析（文字列用）
+pub fn parse_csv_with_options(input: &str, options: &CsvParseOptions) -> Result<Vec<Vec<String>>, CsvError> {
+    let trim_config = if options.trim { csv::Trim::All } else { csv::Trim::None };
+    parse_csv_core(input, trim_config)
+}
+
+/// オプション設定を使ったCSV解析（ファイル用）
+pub fn parse_csv_file_with_options(file_path: &str, options: &CsvParseOptions) -> Result<Vec<Vec<String>>, CsvError> {
+    let trim_config = if options.trim { csv::Trim::All } else { csv::Trim::None };
+    parse_csv_file(file_path, trim_config)
+}
+
+/// ファイルからCSVを読み込んでパースする
+pub fn parse_csv_file(file_path: &str, trim_config: csv::Trim) -> Result<Vec<Vec<String>>, CsvError> {
+    // ファイルパスの検証
+    let path = Path::new(file_path);
+    if !path.exists() {
+        return Err(CsvError::io(format!("File not found: {}", file_path)));
+    }
+
+    if !path.is_file() {
+        return Err(CsvError::io(format!("Path is not a file: {}", file_path)));
+    }
+
+    // ファイル読み込み
+    let content = match fs::read_to_string(path) {
+        Ok(content) => content,
+        Err(e) => {
+            return Err(CsvError::io(format!("Failed to read file '{}': {}", file_path, e)));
+        }
+    };
+
+    // CSVパース
+    parse_csv_core(&content, trim_config)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_escape_sanitize() {
+        let input = "Hello\\nWorld\\t\\\"Test\\\"\\\\End";
+        let expected = "Hello\nWorld\t\"Test\"\\End";
+        assert_eq!(escape_sanitize(input), expected);
+    }
+
+    #[test]
+    fn test_parse_csv_core_basic() {
+        let csv_data = "a,b,c\n1,2,3";
+        let result = parse_csv_core(csv_data, csv::Trim::None);
+
+        assert!(result.is_ok());
+        let records = result.unwrap();
+        assert_eq!(records.len(), 2);
+        assert_eq!(records[0], vec!["a", "b", "c"]);
+        assert_eq!(records[1], vec!["1", "2", "3"]);
+    }
+
+    #[test]
+    fn test_parse_csv_file_not_found() {
+        let result = parse_csv_file("non_existent_file.csv", csv::Trim::None);
+
+        assert!(result.is_err());
+        if let Err(e) = result {
+            assert!(e.to_string().contains("File not found"));
+        }
+    }
+
+    #[test]
+    fn test_parse_csv_file_directory() {
+        // ディレクトリを指定した場合のテスト
+        let result = parse_csv_file(".", csv::Trim::None);
+
+        assert!(result.is_err());
+        if let Err(e) = result {
+            assert!(e.to_string().contains("Path is not a file"));
+        }
+    }
+
+    #[test]
+    fn test_parse_csv_file_with_temp_file() {
+        use std::io::Write;
+        use std::fs::File;
+
+        // 一時ファイルを作成
+        let temp_path = "/tmp/test_csv_file.csv";
+        let csv_content = "name,age,city\nAlice,25,Tokyo\nBob,30,Osaka";
+
+        {
+            let mut file = File::create(temp_path).expect("Failed to create temp file");
+            file.write_all(csv_content.as_bytes()).expect("Failed to write to temp file");
+        }
+
+        // ファイルからCSVを読み込み
+        let result = parse_csv_file(temp_path, csv::Trim::None);
+
+        // クリーンアップ
+        let _ = std::fs::remove_file(temp_path);
+
+        // 結果を検証
+        assert!(result.is_ok());
+        let records = result.unwrap();
+        assert_eq!(records.len(), 3);
+        assert_eq!(records[0], vec!["name", "age", "city"]);
+        assert_eq!(records[1], vec!["Alice", "25", "Tokyo"]);
+        assert_eq!(records[2], vec!["Bob", "30", "Osaka"]);
+    }
+}

data/ext/rbcsv/src/ruby_api.rs

@@ -0,0 +1,98 @@
+use magnus::{Error as MagnusError, Ruby};
+use crate::parser::{parse_csv_core, parse_csv_file};
+
+/// CSV文字列をパースする（通常版）
+///
+/// # Arguments
+/// * `ruby` - Ruby VMの参照
+/// * `s` - パースするCSV文字列
+///
+/// # Returns
+/// * `Result<Vec<Vec<String>>, MagnusError>` - パース結果またはエラー
+pub fn parse(ruby: &Ruby, s: String) -> Result<Vec<Vec<String>>, MagnusError> {
+    parse_csv_core(&s, csv::Trim::None)
+        .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))
+}
+
+/// CSV文字列をパースする（trim版）
+///
+/// # Arguments
+/// * `ruby` - Ruby VMの参照
+/// * `s` - パースするCSV文字列
+///
+/// # Returns
+/// * `Result<Vec<Vec<String>>, MagnusError>` - パース結果またはエラー
+pub fn parse_trim(ruby: &Ruby, s: String) -> Result<Vec<Vec<String>>, MagnusError> {
+    parse_csv_core(&s, csv::Trim::All)
+        .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))
+}
+
+/// CSVファイルを読み込む（通常版）
+///
+/// # Arguments
+/// * `ruby` - Ruby VMの参照
+/// * `file_path` - 読み込むCSVファイルのパス
+///
+/// # Returns
+/// * `Result<Vec<Vec<String>>, MagnusError>` - パース結果またはエラー
+pub fn read(ruby: &Ruby, file_path: String) -> Result<Vec<Vec<String>>, MagnusError> {
+    parse_csv_file(&file_path, csv::Trim::None)
+        .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))
+}
+
+/// CSVファイルを読み込む（trim版）
+///
+/// # Arguments
+/// * `ruby` - Ruby VMの参照
+/// * `file_path` - 読み込むCSVファイルのパス
+///
+/// # Returns
+/// * `Result<Vec<Vec<String>>, MagnusError>` - パース結果またはエラー
+pub fn read_trim(ruby: &Ruby, file_path: String) -> Result<Vec<Vec<String>>, MagnusError> {
+    parse_csv_file(&file_path, csv::Trim::All)
+        .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_basic() {
+        let csv_data = "a,b,c\n1,2,3";
+        let result = crate::parser::parse_csv_core(csv_data, csv::Trim::None);
+
+        assert!(result.is_ok());
+        let records = result.unwrap();
+        assert_eq!(records.len(), 2);
+        assert_eq!(records[0], vec!["a", "b", "c"]);
+        assert_eq!(records[1], vec!["1", "2", "3"]);
+    }
+
+    #[test]
+    fn test_parse_with_trim_enabled() {
+        let csv_data = " a , b , c \n 1 , 2 , 3 ";
+        let result = crate::parser::parse_csv_core(csv_data, csv::Trim::All);
+
+        assert!(result.is_ok());
+        let records = result.unwrap();
+        assert_eq!(records[0], vec!["a", "b", "c"]);
+        assert_eq!(records[1], vec!["1", "2", "3"]);
+    }
+
+    #[test]
+    fn test_parse_with_trim_disabled() {
+        let csv_data = " a , b , c \n 1 , 2 , 3 ";
+        let result = crate::parser::parse_csv_core(csv_data, csv::Trim::None);
+
+        assert!(result.is_ok());
+        let records = result.unwrap();
+        assert_eq!(records[0], vec![" a ", " b ", " c "]);
+        assert_eq!(records[1], vec![" 1 ", " 2 ", " 3 "]);
+    }
+
+    // Note: Ruby API functions that return MagnusError cannot be tested
+    // in unit tests because they require a Ruby VM context.
+    // File reading functionality is tested in the parser module.
+}

data/lib/rbcsv/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RbCsv
-  VERSION = "0.1.4"
+  VERSION = "0.1.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbcsv
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.7
 platform: ruby
 authors:
 - fujitani sora
@@ -33,6 +33,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - ".ruby-version"
+- ".rust-analyzer.json"
 - ".serena/.gitignore"
 - ".serena/memories/code_style_conventions.md"
 - ".serena/memories/project_overview.md"
@@ -43,13 +44,17 @@ files:
 - CODE_OF_CONDUCT.md
 - Cargo.lock
 - Cargo.toml
+- DEVELOPMENT.md
 - LICENSE.txt
 - README.md
 - Rakefile
 - benchmark.rb
 - ext/rbcsv/Cargo.toml
 - ext/rbcsv/extconf.rb
+- ext/rbcsv/src/error.rs
 - ext/rbcsv/src/lib.rs
+- ext/rbcsv/src/parser.rs
+- ext/rbcsv/src/ruby_api.rs
 - lib/rbcsv.rb
 - lib/rbcsv/version.rb
 - output_comparison.rb
@@ -81,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.11
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.2
 specification_version: 4
 summary: High-performance CSV processing library with Rust extensions
 test_files: []