rbcsv 0.1.6 → 0.1.8

data/README.md

@@ -1,8 +1,6 @@
-# RCsv
+# RbCsv
 
-TODO: Delete this and the text below, and describe your gem
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/r_csv`. To experiment with that code, run `bin/console` for an interactive prompt.
+A fast CSV processing library for Ruby, built with Rust for high performance. RbCsv provides simple, efficient methods for parsing CSV strings, reading CSV files, and writing CSV data to files.
 
 ## Installation
 
@@ -22,7 +20,70 @@ gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
 
 ## Usage
 
-TODO: Write usage instructions here
+### Parsing CSV strings
+
+```ruby
+require 'rbcsv'
+
+# Parse CSV string
+csv_data = "name,age,city\nAlice,25,Tokyo\nBob,30,Osaka"
+result = RbCsv.parse(csv_data)
+# => [["name", "age", "city"], ["Alice", "25", "Tokyo"], ["Bob", "30", "Osaka"]]
+
+# Parse CSV with automatic whitespace trimming
+csv_with_spaces = " name , age , city \n Alice , 25 , Tokyo "
+result = RbCsv.parse!(csv_with_spaces)
+# => [["name", "age", "city"], ["Alice", "25", "Tokyo"]]
+```
+
+### Reading CSV files
+
+```ruby
+# Read CSV file
+result = RbCsv.read("data.csv")
+# => [["name", "age", "city"], ["Alice", "25", "Tokyo"], ["Bob", "30", "Osaka"]]
+
+# Read CSV file with automatic whitespace trimming
+result = RbCsv.read!("data_with_spaces.csv")
+# => [["name", "age", "city"], ["Alice", "25", "Tokyo"], ["Bob", "30", "Osaka"]]
+```
+
+### Writing CSV files
+
+```ruby
+# Prepare data
+data = [
+  ["name", "age", "city"],
+  ["Alice", "25", "Tokyo"],
+  ["Bob", "30", "Osaka"]
+]
+
+# Write CSV data to file
+RbCsv.write("output.csv", data)
+# Creates a file with:
+# name,age,city
+# Alice,25,Tokyo
+# Bob,30,Osaka
+```
+
+### Error Handling
+
+RbCsv provides detailed error messages for various scenarios:
+
+```ruby
+# Empty data
+RbCsv.write("output.csv", [])
+# => RuntimeError: Invalid Data Error: CSV data is empty
+
+# Inconsistent field count
+data = [["name", "age"], ["Alice", "25", "Tokyo"]]  # 3 fields in second row
+RbCsv.write("output.csv", data)
+# => RuntimeError: Invalid Data Error: Field count mismatch at line 2: expected 2 fields, got 3 fields
+
+# File not found
+RbCsv.read("nonexistent.csv")
+# => RuntimeError: IO Error: File not found: nonexistent.csv
+```
 
 ## Development
 

data/ext/rbcsv/Cargo.toml

@@ -11,5 +11,9 @@ crate-type = ["cdylib"]
 
 [dependencies]
 csv = "1.3.1"
-magnus = { version = "0.6.2" }
-rb-sys = { version = "0.9", features = ["link-ruby"] }
+magnus = { version = "0.8.1" }
+# rb-sys = { version = "0.9", features = ["link-ruby"] }
+log = "0.4"
+
+[dev-dependencies]
+env_logger = "0.10"

data/ext/rbcsv/src/error.rs

@@ -0,0 +1,101 @@
+use std::error::Error as StdError;
+use std::fmt;
+
+#[derive(Debug)]
+pub struct CsvError {
+    message: String,
+    kind: ErrorKind,
+}
+
+#[derive(Debug)]
+pub enum ErrorKind {
+    // IO関連エラー
+    Io,
+    // CSV解析エラー
+    Parse,
+    // UTF-8エンコーディングエラー
+    Encoding,
+    // フィールド数の不一致
+    FieldCountMismatch,
+    // 空のCSVデータ
+    EmptyData,
+    // 書き込み権限エラー
+    WritePermission,
+    // 無効なデータエラー
+    InvalidData,
+    // その他のエラー
+    #[allow(dead_code)]
+    Other,
+}
+
+impl fmt::Display for CsvError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.kind {
+            ErrorKind::Io => write!(f, "IO Error: {}", self.message),
+            ErrorKind::Parse => write!(f, "Parse Error: {}", self.message),
+            ErrorKind::Encoding => write!(f, "Encoding Error: {}", self.message),
+            ErrorKind::FieldCountMismatch => write!(f, "Field Count Mismatch: {}", self.message),
+            ErrorKind::EmptyData => write!(f, "Empty Data: {}", self.message),
+            ErrorKind::WritePermission => write!(f, "Write Permission Error: {}", self.message),
+            ErrorKind::InvalidData => write!(f, "Invalid Data Error: {}", self.message),
+            ErrorKind::Other => write!(f, "Error: {}", self.message),
+        }
+    }
+}
+
+impl StdError for CsvError {}
+
+impl CsvError {
+    pub fn new(kind: ErrorKind, message: impl Into<String>) -> Self {
+        CsvError {
+            message: message.into(),
+            kind,
+        }
+    }
+
+    pub fn io(message: impl Into<String>) -> Self {
+        Self::new(ErrorKind::Io, message)
+    }
+
+    pub fn parse(message: impl Into<String>) -> Self {
+        Self::new(ErrorKind::Parse, message)
+    }
+
+    pub fn encoding(message: impl Into<String>) -> Self {
+        Self::new(ErrorKind::Encoding, message)
+    }
+
+    #[allow(dead_code)]
+    pub fn field_count_mismatch(expected: usize, actual: usize) -> Self {
+        Self::new(
+            ErrorKind::FieldCountMismatch,
+            format!("Expected {} fields, but got {}", expected, actual),
+        )
+    }
+
+    pub fn empty_data() -> Self {
+        Self::new(ErrorKind::EmptyData, "CSV data is empty")
+    }
+
+    pub fn write_permission(message: impl Into<String>) -> Self {
+        Self::new(ErrorKind::WritePermission, message)
+    }
+
+    pub fn invalid_data(message: impl Into<String>) -> Self {
+        Self::new(ErrorKind::InvalidData, message)
+    }
+}
+
+// csv crateのエラーからの変換
+impl From<csv::Error> for CsvError {
+    fn from(err: csv::Error) -> Self {
+        match err.kind() {
+            csv::ErrorKind::Io(_) => CsvError::io(err.to_string()),
+            csv::ErrorKind::Utf8 { .. } => CsvError::encoding(err.to_string()),
+            csv::ErrorKind::UnequalLengths { .. } => {
+                CsvError::new(ErrorKind::FieldCountMismatch, err.to_string())
+            }
+            _ => CsvError::parse(err.to_string()),
+        }
+    }
+}

data/ext/rbcsv/src/lib.rs

@@ -1,149 +1,20 @@
-use core::fmt;
+mod error;
+mod parser;
+mod ruby_api;
 
-use std::error::Error as StdError;
-
-use magnus::{Error as MagnusError, Object};
-
-#[derive(Debug)]
-struct CustomError {
-    message: String,
-    kind: ErrorKind,
-}
-
-#[derive(Debug)]
-enum ErrorKind {
-    Io,
-    _Parse,
-    _Network,
-    _Other,
-}
-
-impl fmt::Display for CustomError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}: {}", self.kind, self.message)
-    }
-}
-
-impl StdError for CustomError {}
-
-impl CustomError {
-    fn new(kind: ErrorKind, message: impl Into<String>) -> Self {
-        CustomError {
-            message: message.into(),
-            kind,
-        }
-    }
-}
-
-type Error = CustomError;
-
-fn escape_sanitize(s: String) -> String {
-    s.replace("\\n", "\n")
-        .replace("\\r", "\r")
-        .replace("\\t", "\t")
-        .replace("\\\"", "\"")
-        .replace("\\\\", "\\")
-}
-
-fn parse(s: String) -> Result<Vec<Vec<String>>, MagnusError> {
-    parse_with_options(s, false)  // デフォルトはトリムなし
-        .map_err(|e| MagnusError::new(magnus::exception::runtime_error(), e.to_string()))
-}
-
-fn parse_with_trim(s: String, trim_whitespace: bool) -> Result<Vec<Vec<String>>, MagnusError> {
-    parse_with_options(s, trim_whitespace)
-        .map_err(|e| MagnusError::new(magnus::exception::runtime_error(), e.to_string()))
-}
-
-fn parse_with_options(s: String, trim_whitespace: bool) -> Result<Vec<Vec<String>>, Error> {
-    // エスケープシーケンスを実際の文字に変換
-    let processed = escape_sanitize(s);
-
-    let mut reader = csv::ReaderBuilder::new()
-        .has_headers(false) // ヘッダーを無効にして、すべての行 を読み込む
-        .trim(if trim_whitespace { csv::Trim::All } else { csv::Trim::None })
-        .from_reader(processed.as_bytes());
-
-    let mut records = Vec::new();
-
-    for result in reader.records() {
-        match result {
-            Ok(record) => {
-                let row: Vec<String> = record.iter().map(|field| field.to_string()).collect();
-                println!("row {:?}", row);
-                records.push(row);
-            }
-            Err(_e) => {
-                return Err(Error::new(ErrorKind::Io, "File not found"));
-            }
-        }
-    }
-
-    Ok(records)
-}
+use magnus::{Object, Ruby};
+use ruby_api::{parse, parse_trim, read, read_trim, write};
 
 #[magnus::init]
-fn init() {
-    let module = magnus::define_module("RbCsv").expect("Failed to define module");
-    module.define_singleton_method("parse", magnus::function!(parse, 1)).expect("Failed to define parse method");
-    module.define_singleton_method("parse_with_trim", magnus::function!(parse_with_trim, 2)).expect("Failed to define parse_with_trim method");
-}
-
-#[cfg(test)]
-mod tests {
-
-    use super::*;
-
-    #[test]
-    fn test_parse_simple() {
-        let csv_data = "a,b\n1,2";
-        let result = parse(csv_data.to_string());
-
-        assert!(result.is_ok());
+fn init(ruby: &Ruby) -> Result<(), magnus::Error> {
+    let module = ruby.define_module("RbCsv")?;
 
-        let records = result.unwrap();
-        assert_eq!(records.len(), 2);
-        assert_eq!(records[0], vec!["a", "b"]);
-        assert_eq!(records[1], vec!["1", "2"]);
-    }
+    module.define_singleton_method("parse", magnus::function!(parse, 1))?;
+    module.define_singleton_method("parse!", magnus::function!(parse_trim, 1))?;
+    module.define_singleton_method("read", magnus::function!(read, 1))?;
+    module.define_singleton_method("read!", magnus::function!(read_trim, 1))?;
+    module.define_singleton_method("write", magnus::function!(write, 2))?;
 
-    #[test]
-    /// -  シングルクォートの文字列のようなエスケープされた改行をテスト
-    fn test_parse_with_escaped_newline() {
-        let csv_data = "a,b\\n1,2";
-        let result = parse(csv_data.to_string());
-
-        assert!(result.is_ok());
-
-        let records = result.unwrap();
-        assert_eq!(records.len(), 2);
-        assert_eq!(records[0], vec!["a", "b"]);
-        assert_eq!(records[1], vec!["1", "2"]);
-    }
-
-    #[test]
-    fn test_parse_with_trim() {
-        let csv_data = " a , b \n 1 , 2 ";
-        let result = parse_with_trim(csv_data.to_string(), true);
-
-        assert!(result.is_ok());
-
-        let records = result.unwrap();
-        assert_eq!(records.len(), 2);
-        assert_eq!(records[0], vec!["a", "b"]);
-        assert_eq!(records[1], vec!["1", "2"]);
-    }
-
-    #[test]
-    fn test_parse_without_trim() {
-        let csv_data = " a , b \n 1 , 2 ";
-        let result = parse_with_trim(csv_data.to_string(), false);
-
-        assert!(result.is_ok());
-
-        let records = result.unwrap();
-        assert_eq!(records.len(), 2);
-        assert_eq!(records[0], vec![" a ", " b "]);
-        assert_eq!(records[1], vec![" 1 ", " 2 "]);
-    }
+    Ok(())
 }
+

data/ext/rbcsv/src/parser.rs

@@ -0,0 +1,306 @@
+use crate::error::{CsvError, ErrorKind};
+use std::fs;
+use std::path::Path;
+
+/// CSV解析のオプション設定
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct CsvParseOptions {
+    pub trim: bool,
+}
+
+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());
+    }
+
+    // CSV crate に任せて適切なパースを行う（escape_sanitize は削除）
+    let mut reader = csv::ReaderBuilder::new()
+        .has_headers(false) // ヘッダーを無効にして、すべての行を読み込む
+        .trim(trim_config)
+        .from_reader(input.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"]);
+    }
+
+    #[test]
+    fn test_write_csv_file_basic() {
+
+        let temp_path = "/tmp/test_write_csv.csv";
+        let test_data = vec![
+            vec!["name".to_string(), "age".to_string(), "city".to_string()],
+            vec!["Alice".to_string(), "25".to_string(), "Tokyo".to_string()],
+            vec!["Bob".to_string(), "30".to_string(), "Osaka".to_string()],
+        ];
+
+        // ファイルに書き込み
+        let result = write_csv_file(temp_path, &test_data);
+        assert!(result.is_ok(), "Write should succeed");
+
+        // 書き込んだファイルを読み込んで検証
+        let content = std::fs::read_to_string(temp_path).expect("Failed to read written file");
+        let expected = "name,age,city\nAlice,25,Tokyo\nBob,30,Osaka\n";
+        assert_eq!(content, expected);
+
+        // クリーンアップ
+        let _ = std::fs::remove_file(temp_path);
+    }
+
+    #[test]
+    fn test_write_csv_file_empty_data() {
+        let temp_path = "/tmp/test_write_empty.csv";
+        let empty_data: Vec<Vec<String>> = vec![];
+
+        let result = write_csv_file(temp_path, &empty_data);
+        assert!(result.is_err());
+        if let Err(e) = result {
+            assert!(e.to_string().contains("CSV data is empty"));
+        }
+    }
+
+    #[test]
+    fn test_write_csv_file_field_count_mismatch() {
+        let temp_path = "/tmp/test_write_mismatch.csv";
+        let inconsistent_data = vec![
+            vec!["name".to_string(), "age".to_string()],
+            vec!["Alice".to_string(), "25".to_string(), "Tokyo".to_string()], // 3 fields instead of 2
+        ];
+
+        let result = write_csv_file(temp_path, &inconsistent_data);
+        assert!(result.is_err());
+        if let Err(e) = result {
+            assert!(e.to_string().contains("Field count mismatch"));
+        }
+    }
+
+    #[test]
+    fn test_write_csv_file_permission_denied() {
+        // 書き込み権限のないパスをテスト（rootディレクトリ）
+        let result = write_csv_file("/root/test.csv", &vec![vec!["test".to_string()]]);
+        assert!(result.is_err());
+        if let Err(e) = result {
+            // Permission deniedまたはParent directory does not existのいずれかになる
+            let error_msg = e.to_string();
+            assert!(error_msg.contains("Permission denied") || error_msg.contains("Parent directory does not exist"));
+        }
+    }
+}
+
+/// CSVデータをファイルに書き込む
+pub fn write_csv_file(file_path: &str, data: &[Vec<String>]) -> Result<(), CsvError> {
+    // データ検証：空配列チェック
+    if data.is_empty() {
+        return Err(CsvError::invalid_data("CSV data is empty"));
+    }
+
+    // データ検証：各行のフィールド数一貫性チェック
+    if data.len() > 1 {
+        let expected_len = data[0].len();
+        for (line_num, row) in data.iter().enumerate() {
+            if row.len() != expected_len {
+                let error_msg = format!(
+                    "Field count mismatch at line {}: expected {} fields, got {} fields",
+                    line_num + 1,
+                    expected_len,
+                    row.len()
+                );
+                return Err(CsvError::invalid_data(error_msg));
+            }
+        }
+    }
+
+    // ファイルパス検証：親ディレクトリの存在確認
+    let path = Path::new(file_path);
+    if let Some(parent) = path.parent() {
+        if !parent.exists() {
+            return Err(CsvError::io(format!("Parent directory does not exist: {}", parent.display())));
+        }
+    }
+
+    // CSV Writer作成とデータ書き込み
+    let file = match fs::File::create(path) {
+        Ok(file) => file,
+        Err(e) => {
+            if e.kind() == std::io::ErrorKind::PermissionDenied {
+                return Err(CsvError::write_permission(format!("Permission denied: {}", file_path)));
+            }
+            return Err(CsvError::io(format!("Failed to create file '{}': {}", file_path, e)));
+        }
+    };
+
+    let mut writer = csv::WriterBuilder::new()
+        .has_headers(false)
+        .from_writer(file);
+
+    // データ書き込み
+    for row in data {
+        if let Err(e) = writer.write_record(row) {
+            return Err(CsvError::from(e));
+        }
+    }
+
+    // ファイルフラッシュ：データの確実な書き込み保証
+    if let Err(e) = writer.flush() {
+        return Err(CsvError::io(format!("Failed to flush data to file '{}': {}", file_path, e)));
+    }
+
+    Ok(())
+}