rbcsv 0.1.8 → 0.2.0

data/examples/features/test_typed_functionality.rb

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../../lib/rbcsv'
+
+puts "=== RbCsv 型認識機能テスト ==="
+puts
+
+# テストデータ
+csv_data = <<~CSV
+  name,age,score,rating
+  Alice,25,85.5,A
+  Bob,30,92,B+
+  Charlie,0,100.0,S
+CSV
+
+puts "元のCSVデータ:"
+puts csv_data
+puts
+
+# 通常のparseテスト（すべて文字列）
+puts "1. RbCsv.parse (すべて文字列):"
+result = RbCsv.parse(csv_data)
+result.each_with_index do |row, i|
+  puts "Row #{i}: #{row.inspect}"
+  if i > 0  # ヘッダー以外
+    puts "  age (#{row[1].class}): #{row[1]}"
+    puts "  score (#{row[2].class}): #{row[2]}"
+  end
+end
+puts
+
+# 型認識parseテスト
+puts "2. RbCsv.parse_typed (数値は数値型):"
+result_typed = RbCsv.parse_typed(csv_data)
+result_typed.each_with_index do |row, i|
+  puts "Row #{i}: #{row.inspect}"
+  if i > 0  # ヘッダー以外
+    puts "  age (#{row[1].class}): #{row[1]}"
+    puts "  score (#{row[2].class}): #{row[2]}"
+    puts "  計算可能: age * 2 = #{row[1] * 2}"
+  end
+end
+puts
+
+# エッジケースのテスト
+edge_case_csv = <<~CSV
+  type,value
+  integer,123
+  negative,-456
+  float,45.6
+  scientific,1.23e-4
+  empty,
+  text,hello world
+  mixed,123abc
+CSV
+
+puts "3. エッジケーステスト:"
+puts "CSVデータ:"
+puts edge_case_csv
+puts
+
+puts "RbCsv.parse_typed の結果:"
+result_edge = RbCsv.parse_typed(edge_case_csv)
+result_edge.each_with_index do |row, i|
+  if i > 0  # ヘッダー以外
+    value = row[1]
+    type_name = value.class.name
+    puts "#{row[0]}: #{value.inspect} (#{type_name})"
+  end
+end
+puts
+
+# trim版のテスト
+csv_with_spaces = "  name  ,  age  ,  score  \n  Alice  ,  25  ,  85.5  "
+
+puts "4. RbCsv.parse_typed! (trim + 型認識):"
+puts "CSVデータ（空白付き）: #{csv_with_spaces.inspect}"
+result_trim = RbCsv.parse_typed!(csv_with_spaces)
+result_trim.each do |row|
+  puts "Row: #{row.inspect}"
+end
+puts
+
+# ファイル書き込み→型認識読み込みテスト
+test_file = '/tmp/test_typed.csv'
+write_data = [
+  ['product', 'price', 'quantity', 'in_stock'],
+  ['Apple', '100', '50', 'true'],
+  ['Orange', '80.5', '30', 'false'],
+  ['Banana', '60.25', '0', 'yes']
+]
+
+puts "5. ファイル書き込み→型認識読み込みテスト:"
+RbCsv.write(test_file, write_data)
+puts "書き込み完了: #{test_file}"
+
+read_typed = RbCsv.read_typed(test_file)
+puts "RbCsv.read_typed の結果:"
+read_typed.each_with_index do |row, i|
+  puts "Row #{i}: #{row.inspect}"
+  if i > 0
+    puts "  price (#{row[1].class}): #{row[1]}"
+    puts "  quantity (#{row[2].class}): #{row[2]}"
+  end
+end
+puts
+
+puts "=== テスト完了 ==="

data/{test_write_functionality.rb → examples/features/test_write_functionality.rb}

@@ -9,7 +9,7 @@
 # 前提条件:
 #   - bundle exec rake compile でライブラリがビルド済みであること
 
-require_relative 'lib/rbcsv'
+require_relative '../../lib/rbcsv'
 require 'fileutils'
 
 class RbCsvWriteTest

data/ext/rbcsv/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rbcsv"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 authors = ["fujitani sora <fujitanisora0414@gmail.com>"]
 license = "MIT"

data/ext/rbcsv/src/error.rs

@@ -86,7 +86,7 @@ impl CsvError {
     }
 }
 
-// csv crateのエラーからの変換
+// csv crate error to CsvError conversion
 impl From<csv::Error> for CsvError {
     fn from(err: csv::Error) -> Self {
         match err.kind() {
@@ -98,4 +98,4 @@ impl From<csv::Error> for CsvError {
             _ => CsvError::parse(err.to_string()),
         }
     }
-}
+}

data/ext/rbcsv/src/lib.rs

@@ -1,9 +1,10 @@
 mod error;
 mod parser;
 mod ruby_api;
+mod value;
 
 use magnus::{Object, Ruby};
-use ruby_api::{parse, parse_trim, read, read_trim, write};
+use ruby_api::{parse, parse_trim, read, read_trim, write, parse_typed, parse_typed_trim, read_typed, read_typed_trim};
 
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), magnus::Error> {
@@ -15,6 +16,12 @@ fn init(ruby: &Ruby) -> Result<(), magnus::Error> {
     module.define_singleton_method("read!", magnus::function!(read_trim, 1))?;
     module.define_singleton_method("write", magnus::function!(write, 2))?;
 
+    // typed variants
+    module.define_singleton_method("parse_typed", magnus::function!(parse_typed, 1))?;
+    module.define_singleton_method("parse_typed!", magnus::function!(parse_typed_trim, 1))?;
+    module.define_singleton_method("read_typed", magnus::function!(read_typed, 1))?;
+    module.define_singleton_method("read_typed!", magnus::function!(read_typed_trim, 1))?;
+
     Ok(())
 }
 

data/ext/rbcsv/src/parser.rs

@@ -2,7 +2,6 @@ use crate::error::{CsvError, ErrorKind};
 use std::fs;
 use std::path::Path;
 
-/// CSV解析のオプション設定
 #[derive(Debug, Clone)]
 #[allow(dead_code)]
 pub struct CsvParseOptions {
@@ -17,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")
@@ -28,14 +26,13 @@ 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());
     }
 
-    // CSV crate に任せて適切なパースを行う（escape_sanitize は削除）
     let mut reader = csv::ReaderBuilder::new()
-        .has_headers(false) // ヘッダーを無効にして、すべての行を読み込む
+        .has_headers(false)
         .trim(trim_config)
         .from_reader(input.as_bytes());
 
@@ -48,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",
@@ -59,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));
             }
         }
@@ -108,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";

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, write_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文字列をパースする（通常版）
 ///
@@ -67,6 +67,105 @@ pub fn write(ruby: &Ruby, file_path: String, data: Vec<Vec<String>>) -> Result<(
         .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 {

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.8"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbcsv
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.2.0
 platform: ruby
 authors:
 - fujitani sora
@@ -48,23 +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
-- test_write_functionality.rb
 homepage: https://github.com/fs0414/rbcsv
 licenses:
 - MIT