rbcsv 0.1.7 → 0.2.0

data/ext/rbcsv/src/parser.rs

@@ -2,13 +2,10 @@ 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,
-    // 将来的な拡張用
-    // pub headers: bool,
-    // pub delimiter: char,
 }
 
 impl Default for CsvParseOptions {
@@ -19,8 +16,7 @@ impl Default for CsvParseOptions {
     }
 }
 
-/// エスケープシーケンスを実際の文字に変換
-pub fn escape_sanitize(s: &str) -> String {
+pub fn _escape_sanitize(s: &str) -> String {
     s.replace("\\n", "\n")
         .replace("\\r", "\r")
         .replace("\\t", "\t")
@@ -30,18 +26,15 @@ pub fn escape_sanitize(s: &str) -> String {
 
 /// 基本的なCSVパース処理
 pub fn parse_csv_core(input: &str, trim_config: csv::Trim) -> Result<Vec<Vec<String>>, CsvError> {
-    // 空のデータチェック
+    println!("input: {:?}", input);
     if input.trim().is_empty() {
         return Err(CsvError::empty_data());
     }
 
-    // エスケープシーケンスを実際の文字に変換
-    let processed = escape_sanitize(input);
-
     let mut reader = csv::ReaderBuilder::new()
-        .has_headers(false) // ヘッダーを無効にして、すべての行を読み込む
+        .has_headers(false)
         .trim(trim_config)
-        .from_reader(processed.as_bytes());
+        .from_reader(input.as_bytes());
 
     let mut records = Vec::new();
 
@@ -52,7 +45,6 @@ pub fn parse_csv_core(input: &str, trim_config: csv::Trim) -> Result<Vec<Vec<Str
                 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",
@@ -63,7 +55,6 @@ pub fn parse_csv_core(input: &str, trim_config: csv::Trim) -> Result<Vec<Vec<Str
                     return Err(CsvError::new(ErrorKind::FieldCountMismatch, error_msg));
                 }
 
-                // その他のcsvエラーを自動変換
                 return Err(CsvError::from(e));
             }
         }
@@ -77,13 +68,13 @@ pub fn parse_csv_core(input: &str, trim_config: csv::Trim) -> Result<Vec<Vec<Str
 }
 
 /// オプション設定を使ったCSV解析（文字列用）
-pub fn parse_csv_with_options(input: &str, options: &CsvParseOptions) -> Result<Vec<Vec<String>>, CsvError> {
+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> {
+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)
 }
@@ -112,17 +103,81 @@ pub fn parse_csv_file(file_path: &str, trim_config: csv::Trim) -> Result<Vec<Vec
     parse_csv_core(&content, trim_config)
 }
 
+/// 型認識を行うCSVパース処理
+pub fn parse_csv_typed(input: &str, trim_config: csv::Trim) -> Result<Vec<Vec<crate::value::CsvValue>>, CsvError> {
+    use crate::value::CsvValue;
+
+    if input.trim().is_empty() {
+        return Err(CsvError::empty_data());
+    }
+
+    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<CsvValue> = record.iter().map(|field| {
+                    if matches!(trim_config, csv::Trim::All | csv::Trim::Fields) {
+                        CsvValue::from_str_trimmed(field)
+                    } else {
+                        CsvValue::from_str(field)
+                    }
+                }).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));
+                }
+
+                return Err(CsvError::from(e));
+            }
+        }
+    }
+
+    if records.is_empty() {
+        return Err(CsvError::empty_data());
+    }
+
+    Ok(records)
+}
+
+/// 型認識を行うCSVファイル読み込み処理
+pub fn parse_csv_file_typed(file_path: &str, trim_config: csv::Trim) -> Result<Vec<Vec<crate::value::CsvValue>>, 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)));
+        }
+    };
+
+    parse_csv_typed(&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";
@@ -184,4 +239,127 @@ mod tests {
         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(())
+}

data/ext/rbcsv/src/ruby_api.rs

@@ -1,5 +1,5 @@
-use magnus::{Error as MagnusError, Ruby};
-use crate::parser::{parse_csv_core, parse_csv_file};
+use magnus::{Error as MagnusError, Ruby, Value as MagnusValue, value::ReprValue};
+use crate::parser::{parse_csv_core, parse_csv_file, write_csv_file, parse_csv_typed, parse_csv_file_typed};
 
 /// CSV文字列をパースする（通常版）
 ///
@@ -53,10 +53,122 @@ pub fn read_trim(ruby: &Ruby, file_path: String) -> Result<Vec<Vec<String>>, Mag
         .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))
 }
 
+/// CSVファイルに書き込む
+///
+/// # Arguments
+/// * `ruby` - Ruby VMの参照
+/// * `file_path` - 書き込み先ファイルのパス
+/// * `data` - 書き込むCSVデータ（2次元配列）
+///
+/// # Returns
+/// * `Result<(), MagnusError>` - 成功時は空、失敗時はエラー
+pub fn write(ruby: &Ruby, file_path: String, data: Vec<Vec<String>>) -> Result<(), MagnusError> {
+    write_csv_file(&file_path, &data)
+        .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))
+}
+
+/// CSV文字列を型認識してパースする（通常版）
+///
+/// # Arguments
+/// * `ruby` - Ruby VMの参照
+/// * `s` - パースするCSV文字列
+///
+/// # Returns
+/// * `Result<Vec<Vec<MagnusValue>>, MagnusError>` - パース結果（数値は数値型）またはエラー
+pub fn parse_typed(ruby: &Ruby, s: String) -> Result<MagnusValue, MagnusError> {
+    let result = parse_csv_typed(&s, csv::Trim::None)
+        .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))?;
+
+    // Vec<Vec<CsvValue>> を Ruby配列に変換
+    let outer_array = ruby.ary_new();
+    for row in result {
+        let inner_array = ruby.ary_new();
+        for value in row {
+            inner_array.push(value.to_ruby(ruby))?;
+        }
+        outer_array.push(inner_array.as_value())?;
+    }
+
+    Ok(outer_array.as_value())
+}
+
+/// CSV文字列を型認識してパースする（trim版）
+///
+/// # Arguments
+/// * `ruby` - Ruby VMの参照
+/// * `s` - パースするCSV文字列
+///
+/// # Returns
+/// * `Result<Vec<Vec<MagnusValue>>, MagnusError>` - パース結果（数値は数値型）またはエラー
+pub fn parse_typed_trim(ruby: &Ruby, s: String) -> Result<MagnusValue, MagnusError> {
+    let result = parse_csv_typed(&s, csv::Trim::All)
+        .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))?;
+
+    // Vec<Vec<CsvValue>> を Ruby配列に変換
+    let outer_array = ruby.ary_new();
+    for row in result {
+        let inner_array = ruby.ary_new();
+        for value in row {
+            inner_array.push(value.to_ruby(ruby))?;
+        }
+        outer_array.push(inner_array.as_value())?;
+    }
+
+    Ok(outer_array.as_value())
+}
+
+/// CSVファイルを型認識して読み込む（通常版）
+///
+/// # Arguments
+/// * `ruby` - Ruby VMの参照
+/// * `file_path` - 読み込むCSVファイルのパス
+///
+/// # Returns
+/// * `Result<Vec<Vec<MagnusValue>>, MagnusError>` - パース結果（数値は数値型）またはエラー
+pub fn read_typed(ruby: &Ruby, file_path: String) -> Result<MagnusValue, MagnusError> {
+    let result = parse_csv_file_typed(&file_path, csv::Trim::None)
+        .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))?;
+
+    // Vec<Vec<CsvValue>> を Ruby配列に変換
+    let outer_array = ruby.ary_new();
+    for row in result {
+        let inner_array = ruby.ary_new();
+        for value in row {
+            inner_array.push(value.to_ruby(ruby))?;
+        }
+        outer_array.push(inner_array.as_value())?;
+    }
+
+    Ok(outer_array.as_value())
+}
+
+/// CSVファイルを型認識して読み込む（trim版）
+///
+/// # Arguments
+/// * `ruby` - Ruby VMの参照
+/// * `file_path` - 読み込むCSVファイルのパス
+///
+/// # Returns
+/// * `Result<Vec<Vec<MagnusValue>>, MagnusError>` - パース結果（数値は数値型）またはエラー
+pub fn read_typed_trim(ruby: &Ruby, file_path: String) -> Result<MagnusValue, MagnusError> {
+    let result = parse_csv_file_typed(&file_path, csv::Trim::All)
+        .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))?;
+
+    // Vec<Vec<CsvValue>> を Ruby配列に変換
+    let outer_array = ruby.ary_new();
+    for row in result {
+        let inner_array = ruby.ary_new();
+        for value in row {
+            inner_array.push(value.to_ruby(ruby))?;
+        }
+        outer_array.push(inner_array.as_value())?;
+    }
+
+    Ok(outer_array.as_value())
+}
 
 #[cfg(test)]
 mod tests {
-    use super::*;
 
     #[test]
     fn test_parse_basic() {

data/ext/rbcsv/src/value.rs

@@ -0,0 +1,87 @@
+use magnus::{Ruby, Value as MagnusValue, value::ReprValue};
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum CsvValue {
+    Integer(i64),
+    Float(f64),
+    String(String),
+}
+
+impl CsvValue {
+    /// 文字列からCsvValueへの変換
+    /// 優先順位: 整数 → 浮動小数点 → 文字列
+    pub fn from_str(s: &str) -> Self {
+        if s.is_empty() {
+            return CsvValue::String(s.to_string());
+        }
+
+        if let Ok(i) = s.parse::<i64>() {
+            return CsvValue::Integer(i);
+        }
+
+        if let Ok(f) = s.parse::<f64>() {
+            if f.is_finite() {
+                return CsvValue::Float(f);
+            }
+        }
+
+        CsvValue::String(s.to_string())
+    }
+
+    pub fn from_str_trimmed(s: &str) -> Self {
+        Self::from_str(s.trim())
+    }
+
+    pub fn to_ruby(&self, ruby: &Ruby) -> MagnusValue {
+        match self {
+            CsvValue::Integer(i) => ruby.integer_from_i64(*i).as_value(),
+            CsvValue::Float(f) => ruby.float_from_f64(*f).as_value(),
+            CsvValue::String(s) => ruby.str_new(s).as_value(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_from_str_integer() {
+        assert_eq!(CsvValue::from_str("123"), CsvValue::Integer(123));
+        assert_eq!(CsvValue::from_str("-456"), CsvValue::Integer(-456));
+        assert_eq!(CsvValue::from_str("0"), CsvValue::Integer(0));
+    }
+
+    #[test]
+    fn test_from_str_float() {
+        assert_eq!(CsvValue::from_str("123.45"), CsvValue::Float(123.45));
+        assert_eq!(CsvValue::from_str("-0.67"), CsvValue::Float(-0.67));
+        assert_eq!(CsvValue::from_str("1.23e-4"), CsvValue::Float(0.000123));
+        assert_eq!(CsvValue::from_str("3.14159"), CsvValue::Float(3.14159));
+    }
+
+    #[test]
+    fn test_from_str_string() {
+        assert_eq!(CsvValue::from_str("hello"), CsvValue::String("hello".to_string()));
+        assert_eq!(CsvValue::from_str(""), CsvValue::String("".to_string()));
+        assert_eq!(CsvValue::from_str("123abc"), CsvValue::String("123abc".to_string()));
+        assert_eq!(CsvValue::from_str("true"), CsvValue::String("true".to_string()));
+    }
+
+    #[test]
+    fn test_from_str_edge_cases() {
+        // NaN と Infinity は文字列として扱う
+        assert_eq!(CsvValue::from_str("NaN"), CsvValue::String("NaN".to_string()));
+        assert_eq!(CsvValue::from_str("Infinity"), CsvValue::String("Infinity".to_string()));
+
+        // 非常に大きな数値（i64の範囲を超える）は浮動小数点として扱われる
+        assert!(matches!(CsvValue::from_str("99999999999999999999"), CsvValue::Float(_)));
+    }
+
+    #[test]
+    fn test_from_str_trimmed() {
+        assert_eq!(CsvValue::from_str_trimmed("  123  "), CsvValue::Integer(123));
+        assert_eq!(CsvValue::from_str_trimmed("  45.6  "), CsvValue::Float(45.6));
+        assert_eq!(CsvValue::from_str_trimmed("  hello  "), CsvValue::String("hello".to_string()));
+    }
+}

data/lib/rbcsv/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbcsv
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - fujitani sora
@@ -48,22 +48,31 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- benchmark.rb
+- docs/exe_upgrade_version.md
+- docs/release_process_v0.1.8.md
+- docs/special_character_bug_fix.md
+- docs/write_functionality_implementation.md
+- examples/README.md
+- examples/basic/basic_usage.rb
+- examples/basic/quick_test.rb
+- examples/basic/test_fixed.rb
+- examples/basic/test_install.rb
+- examples/benchmarks/benchmark.rb
+- examples/benchmarks/output_comparison.rb
+- examples/benchmarks/sample.csv
+- examples/features/test_typed_functionality.rb
+- examples/features/test_write_functionality.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
+- ext/rbcsv/src/value.rs
 - lib/rbcsv.rb
 - lib/rbcsv/version.rb
-- output_comparison.rb
-- quick_test.rb
 - sample.csv
 - sig/r_csv.rbs
-- test.rb
-- test_fixed.rb
-- test_install.rb
 homepage: https://github.com/fs0414/rbcsv
 licenses:
 - MIT