Ruby での CSV 処理の基礎知識

CSV ライブラリの導入方法と基本設定

RubyでCSVファイルを扱うには、標準ライブラリのCSVクラスを使用します。このライブラリは豊富な機能を提供し、多くの場合で追加のgemをインストールする必要はありません。

# CSVライブラリの読み込み
require 'csv'

# 基本的な設定例
CSV::DEFAULT_OPTIONS.merge!(
  encoding: 'UTF-8',     # エンコーディングの指定
  liberal_parsing: true, # ゆるい解析を有効化
  headers: true         # ヘッダーの有効化
)

主な設定オプション:

encoding: ファイルの文字エンコーディング
liberal_parsing: 不正な形式のCSVを許容するかどうか
headers: ヘッダー行の扱い方
col_sep: 列の区切り文字（デフォルトはカンマ）
row_sep: 行の区切り文字（デフォルトは”\n”）
quote_char: 引用符の文字（デフォルトは’”‘）

文字コードとエンコーディングの正しい使い方

日本語を含むCSVファイルを扱う際は、文字コードの適切な処理が重要です。特に、Windows環境で作成されたCSVファイルでは、文字化けの問題に注意が必要です。

# 文字コード関連の主要な処理パターン

# パターン1: 明示的なエンコーディング指定
CSV.read('data.csv', encoding: 'Shift_JIS:UTF-8')

# パターン2: BOMの処理
bom_utf8 = CSV.read('data.csv', encoding: 'BOM|UTF-8')

# パターン3: エンコーディング検出と変換
def read_csv_with_encoding(file_path)
  # ファイルの文字コードを検出
  content = File.read(file_path)
  detected_encoding = content.encoding

  # UTF-8に変換して読み込み
  CSV.parse(content.encode('UTF-8', detected_encoding))
rescue Encoding::UndefinedConversionError
  # 変換エラーが発生した場合の処理
  CSV.parse(content.encode('UTF-8', detected_encoding, invalid: :replace, undef: :replace))
end

エンコーディング処理のベストプラクティス:

入力ファイルのエンコーディングを明示的に指定
必要に応じてUTF-8への変換を行う
BOMの有無を考慮する
エラー時の代替文字設定を適切に行う

よくある文字コードの組み合わせ:

Shift_JIS → UTF-8（Windows環境からの読み込み）
CP932 → UTF-8（古いWindowsファイル）
EUC-JP → UTF-8（古い Unix/Linux システム）

以上の基礎知識を押さえることで、様々な環境で作成されたCSVファイルを適切に処理できるようになります。次のセクションでは、これらの基礎知識を活用した具体的な読み込み手法について説明します。

CSVファイルの読み込み攻略テクニック

1行ずつ読み込む方法とメモリ効率の改善

大きなCSVファイルを扱う際は、ファイル全体を一度にメモリに読み込むのではなく、1行ずつ処理する方法が効率的です。

# 基本的な1行ずつの読み込み
CSV.foreach('large_file.csv') do |row|
  # 各行に対する処理
  process_row(row)
end

# メモリ効率を考慮した読み込みパターン
def process_csv_efficiently(file_path)
  File.open(file_path, 'r') do |file|
    csv = CSV.new(file, headers: true)
    csv.each do |row|
      yield row if block_given?
    end
  end
end

# 使用例
process_csv_efficiently('large_file.csv') do |row|
  # 行ごとの処理をここに記述
  puts row['column_name']
end

メモリ効率改善のポイント:

CSV.foreachやCSV.newを使用して逐次処理
必要な列のみを選択して処理
大きな配列の代わりにEnumeratorを活用

ヘッダー付きCSVを扱うベストプラクティス

ヘッダー付きCSVファイルは、データの意味を明確にし、保守性の高いコードを書くことができます。

# ヘッダー付きCSVの読み込みパターン
def read_csv_with_headers(file_path)
  # ヘッダーを指定して読み込み
  CSV.read(file_path, headers: true, header_converters: :symbol)
end

# カスタムヘッダー変換の実装例
CSV::HeaderConverters[:custom] = lambda do |header|
  header.to_s.strip.downcase.gsub(/\s+/, '_').to_sym
end

# 高度なヘッダー処理の例
class CSVProcessor
  def initialize(file_path)
    @csv = CSV.table(file_path, header_converters: [:symbol, :custom])
  end

  def process
    @csv.each do |row|
      # シンボルでヘッダーにアクセス可能
      user_name = row[:user_name]
      email = row[:email]

      # データ処理ロジック
      process_user_data(user_name, email)
    end
  end

  private

  def process_user_data(name, email)
    # 実際の処理を実装
  end
end

ヘッダー処理のベストプラクティス:

ヘッダー名の標準化

小文字変換
スペースのアンダースコア置換
シンボルへの変換

データ型の自動変換設定

# データ型の自動変換例
converters = {
  date: ->(f) { Date.parse(f) rescue f },
  integer: ->(f) { Integer(f) rescue f },
  float: ->(f) { Float(f) rescue f }
}

CSV.new(file, 
  headers: true,
  header_converters: :symbol,
  converters: converters
)

バリデーション機能の実装

def validate_headers(csv_headers, required_headers)
  missing_headers = required_headers - csv_headers
  raise "Missing required headers: #{missing_headers}" unless missing_headers.empty?
end

# 使用例
CSV.open('data.csv', headers: true) do |csv|
  validate_headers(csv.headers, [:name, :email, :age])
  # 以降の処理
end

これらのテクニックを組み合わせることで、効率的で保守性の高いCSV処理を実現できます。特に大規模なデータを扱う場合は、メモリ効率を意識した実装を心がけましょう。

CSV ファイルの書き込み攻略テクニック

新規ファイル作成と間違いの注意

CSVファイルの書き込みでは、適切なファイルモードとエンコーディングの指定が重要です。また、データの整合性を保つための注意点もあります。

# 基本的な書き込みパターン
def write_csv_file(file_path, data, headers)
  CSV.open(file_path, 'wb', force_quotes: true, encoding: Encoding::UTF_8) do |csv|
    # ヘッダーの書き込み
    csv << headers

    # データの書き込み
    data.each do |row|
      csv << row
    end
  end
end

# 追記モードでの書き込み
def append_to_csv(file_path, data)
  CSV.open(file_path, 'a+', encoding: Encoding::UTF_8) do |csv|
    data.each do |row|
      csv << row
    end
  end
end

# 書き込みモードの使い分け例
class CSVWriter
  def initialize(file_path)
    @file_path = file_path
  end

  def write_new_file(data, headers)
    # 新規ファイル作成（既存ファイルは上書き）
    write_csv_file(@file_path, data, headers)
  end

  def append_data(data)
    # 既存ファイルへの追記
    append_to_csv(@file_path, data)
  end

  private

  def write_csv_file(file_path, data, headers)
    CSV.open(file_path, 'wb', force_quotes: true) do |csv|
      csv << headers
      data.each { |row| csv << row }
    end
  end

  def append_to_csv(file_path, data)
    # ファイルが存在しない場合は新規作成
    unless File.exist?(file_path)
      raise "Target file doesn't exist: #{file_path}"
    end

    CSV.open(file_path, 'a+') do |csv|
      data.each { |row| csv << row }
    end
  end
end

特殊文字を含むデータの適切な処理方法

CSVファイルに特殊文字（カンマ、改行、引用符など）を含むデータを書き込む際は、適切なエスケープ処理が必要です。

“`ruby

特殊文字を含むデータの処理例

class CSVDataProcessor
def self.escape_special_chars(data)
data.map do |row|
row.map do |cell|
if cell.nil?
”
elsif cell.to_s.match?(/[,”\r\n]/)
# 特殊文字を含む場合はダブルクォートでエスケープ
%Q(“#{cell.to_s.gsub(‘”‘, ‘””‘)}”)
else
cell.to_s
end
end
end
end
end

実装例

def write_csv_with_special_chars(file_path, data)
processed_data = CSVDataProcessor.escape_special_chars(data)

CSV.open(file_path, ‘wb’, force_quotes: true) do |csv|
processed_data.each do |row|
csv << row
end
end
end

実際の使用例

data = [
[‘Name’, ‘Description’],
[‘Product A’, ‘Contains, comma’],
[‘Product B’, “Multiple\nlines”],
[‘Product C’, ‘Has “quotes”‘]
]

write_csv_with_special_chars(‘products.csv’, data)

特殊文字処理のベストプラクティス:

1. データの事前検証

ruby
def validate_csv_data(data)
data.each_with_index do |row, i|
row.each_with_index do |cell, j|
if cell.to_s.include?(“\0”) # NULL文字のチェック
raise “Invalid character found at row #{i+1}, column #{j+1}”
end
end
end
end

2. エンコーディングの統一

ruby
def normalize_encoding(data)
data.map do |row|
row.map do |cell|
cell.to_s.encode(‘UTF-8’, invalid: :replace, undef: :replace)
end
end
end

3. BOMの適切な処理

ruby
def write_csv_with_bom(file_path, data)
File.open(file_path, ‘wb’) do |file|
file.write(“\uFEFF”) # BOMを書き込む
CSV.new(file).puts(data)
end
end
“`

CSV書き込み時の主な注意点:

注意点	対処方法
ファイルモード	新規作成は’wb’、追記は’a+’を使用
文字エンコーディング	UTF-8を基本とし、必要に応じて変換
特殊文字	force_quotesオプションとエスケープ処理を使用
データ検証	書き込み前にバリデーションを実施
パーミッション	ファイル書き込み権限の確認

これらのテクニックを適切に組み合わせることで、安全で信頼性の高いCSV書き込み処理を実装できます。

エラーハンドリングと例外処理

よくあるエラーとその対処法

CSVファイルの処理では、様々なエラーが発生する可能性があります。適切なエラーハンドリングを実装することで、安定したアプリケーションを実現できます。

# 総合的なエラーハンドリングの例
class CSVProcessor
  class CSVError < StandardError; end
  class InvalidFormatError < CSVError; end
  class EncodingError < CSVError; end
  class ValidationError < CSVError; end

  def process_csv(file_path)
    validate_file_existence!(file_path)

    CSV.foreach(file_path, headers: true) do |row|
      begin
        process_row(row)
      rescue CSV::MalformedCSVError => e
        handle_malformed_csv(e, row)
      rescue Encoding::CompatibilityError => e
        handle_encoding_error(e, row)
      rescue StandardError => e
        handle_unexpected_error(e, row)
      end
    end
  rescue Errno::ENOENT
    raise CSVError, "File not found: #{file_path}"
  rescue Errno::EACCES
    raise CSVError, "Permission denied: #{file_path}"
  end

  private

  def validate_file_existence!(file_path)
    raise CSVError, "File not found" unless File.exist?(file_path)
    raise CSVError, "Not a file" unless File.file?(file_path)
  end

  def handle_malformed_csv(error, row)
    # マルフォームCSVのログ記録と回復処理
    logger.error("Malformed CSV: #{error.message}")
    # エラー行をスキップして続行するなどの処理
  end

  def handle_encoding_error(error, row)
    # エンコーディングエラーの処理
    logger.error("Encoding error: #{error.message}")
    # 文字コード変換を試みるなどの処理
  end

  def handle_unexpected_error(error, row)
    # 予期せぬエラーの処理
    logger.error("Unexpected error: #{error.message}")
    # エラー通知の送信などの処理
  end
end

安定したエラー処理の実装パターン

エラー処理を効果的に行うために、以下のようなパターンを実装します。

# リトライ機能付きのCSV処理
def process_with_retry(file_path, max_retries: 3)
  retries = 0
  begin
    CSV.foreach(file_path, headers: true) do |row|
      yield row if block_given?
    end
  rescue CSV::MalformedCSVError => e
    retries += 1
    if retries <= max_retries
      sleep(2 ** retries)  # 指数バックオフ
      retry
    else
      raise e
    end
  end
end

# トランザクション的なCSV処理
def process_csv_with_transaction(input_path, output_path)
  temp_file = Tempfile.new(['processed', '.csv'])
  begin
    process_and_write(input_path, temp_file.path)
    FileUtils.mv(temp_file.path, output_path)
  rescue StandardError => e
    # エラー発生時は一時ファイルを削除
    temp_file.unlink
    raise e
  ensure
    temp_file.close
  end
end

# バリデーション付きのCSV処理
class CSVValidator
  def validate_row(row, rules)
    rules.each do |column, rule|
      value = row[column]
      unless rule.call(value)
        raise ValidationError, "Invalid value in column #{column}: #{value}"
      end
    end
  end
end

# 使用例
validation_rules = {
  'age' => ->(v) { v.to_i.between?(0, 120) },
  'email' => ->(v) { v =~ /\A[^@\s]+@[^@\s]+\z/ }
}

processor = CSVValidator.new
CSV.foreach('data.csv', headers: true) do |row|
  processor.validate_row(row, validation_rules)
end

エラー処理の重要なポイント:

エラーの種類に応じた適切な処理
ログ記録とモニタリング
リカバリー処理の実装
データの整合性の保持

これらの実装パターンを活用することで、より安定したCSV処理システムを構築できます。

大容量CSVファイルの効率的な処理方法

メモリ使用量を優先したストリーミング処理の実装

大容量CSVファイルを処理する際は、メモリ消費を抑えたストリーミング処理が重要です。

# ストリーミング処理の基本実装
class CSVStreamer
  def initialize(file_path)
    @file_path = file_path
  end

  def process_in_batches(batch_size: 1000)
    batch = []

    CSV.foreach(@file_path, headers: true) do |row|
      batch << row

      if batch.size >= batch_size
        yield batch
        batch = []
      end
    end

    # 残りのバッチを処理
    yield batch if batch.any?
  end
end

# 並列処理を活用したストリーミング実装
require 'parallel'

class ParallelCSVProcessor
  def initialize(file_path, worker_count: 4)
    @file_path = file_path
    @worker_count = worker_count
  end

  def process
    # ファイルを分割してチャンク単位で処理
    chunk_size = File.size(@file_path) / @worker_count
    chunks = create_chunks(chunk_size)

    Parallel.each(chunks, in_processes: @worker_count) do |chunk|
      process_chunk(chunk)
    end
  end

  private

  def create_chunks(chunk_size)
    chunks = []
    current_pos = 0

    File.open(@file_path, 'rb') do |file|
      until file.eof?
        chunk_start = current_pos
        file.seek(chunk_start + chunk_size)
        file.gets # チャンク境界を行の終わりまで調整
        chunk_end = file.pos

        chunks << {start: chunk_start, end: chunk_end}
        current_pos = chunk_end
      end
    end

    chunks
  end

  def process_chunk(chunk)
    File.open(@file_path, 'rb') do |file|
      file.seek(chunk[:start])

      while file.pos < chunk[:end]
        line = file.gets
        process_line(line) if line
      end
    end
  end

  def process_line(line)
    # 各行の処理を実装
  end
end

メモリ使用量を活用した高速化テクニック

メモリに余裕がある場合は、適切なキャッシュ戦略を使用して処理を高速化できます。

# キャッシュを活用した高速化実装
class CachedCSVProcessor
  def initialize(cache_size: 10_000)
    @cache = LruCache.new(max_size: cache_size)
  end

  def process_with_cache(file_path)
    CSV.foreach(file_path, headers: true) do |row|
      key = generate_cache_key(row)

      if @cache.has_key?(key)
        process_cached_data(@cache[key])
      else
        processed_data = process_row(row)
        @cache[key] = processed_data
        process_cached_data(processed_data)
      end
    end
  end

  private

  class LruCache
    def initialize(max_size:)
      @max_size = max_size
      @cache = {}
      @access_order = []
    end

    def [](key)
      update_access_order(key)
      @cache[key]
    end

    def []=(key, value)
      if @cache.size >= @max_size && !@cache.key?(key)
        remove_least_recently_used
      end

      @cache[key] = value
      update_access_order(key)
    end

    def has_key?(key)
      @cache.key?(key)
    end

    private

    def update_access_order(key)
      @access_order.delete(key)
      @access_order.push(key)
    end

    def remove_least_recently_used
      key = @access_order.shift
      @cache.delete(key)
    end
  end
end

効率的な処理のためのベストプラクティス:

メモリ使用量の最適化

バッチ処理の活用
ストリーミング処理の実装
適切なガベージコレクション

パフォーマンスチューニング

   # パフォーマンスモニタリングの実装例
   class CSVPerformanceMonitor
     def measure_processing_time
       start_time = Time.now
       memory_before = GetProcessMem.new.mb

       yield if block_given?

       memory_after = GetProcessMem.new.mb
       end_time = Time.now

       {
         processing_time: end_time - start_time,
         memory_usage: memory_after - memory_before
       }
     end
   end

リソース管理

ファイルハンドルの適切なクローズ
メモリリークの防止
並列処理のワーカー数調整

これらのテクニックを組み合わせることで、大容量CSVファイルでも効率的な処理が可能になります。

実践的なCSV処理のユースケース

データ変換と加工の実装例

実務でよく遭遇するデータ変換と加工のパターンを紹介します。

# データ変換ユーティリティ
module CSVTransformer
  # 日付形式の標準化
  def self.standardize_date(date_str)
    return nil if date_str.nil? || date_str.empty?

    begin
      Date.parse(date_str).strftime('%Y-%m-%d')
    rescue Date::Error
      nil
    end
  end

  # 数値データの正規化
  def self.normalize_number(number_str)
    return nil if number_str.nil? || number_str.empty?

    number_str.gsub(/[^\d.-]/, '').to_f
  end

  # 住所データの正規化
  def self.normalize_address(address)
    address
      .strip
      .gsub(/\s+/, ' ')
      .gsub(/([都道府県市区町村])/, '\1 ')
      .strip
  end
end

# データ変換の実装例
class DataTransformer
  def transform_csv(input_path, output_path)
    CSV.open(output_path, 'wb', headers: true) do |csv_out|
      first_row = true

      CSV.foreach(input_path, headers: true) do |row|
        if first_row
          csv_out << transform_headers(row.headers)
          first_row = false
        end

        csv_out << transform_row(row)
      end
    end
  end

  private

  def transform_headers(headers)
    headers.map { |h| h.downcase.gsub(/\s+/, '_') }
  end

  def transform_row(row)
    {
      'date' => CSVTransformer.standardize_date(row['date']),
      'amount' => CSVTransformer.normalize_number(row['amount']),
      'address' => CSVTransformer.normalize_address(row['address'])
    }
  end
end

バッチ処理での活用方法

大量のCSVファイルを定期的に処理する場合のバッチ処理パターンを紹介します。

# バッチ処理の基本実装
class CSVBatchProcessor
  def initialize(input_dir, output_dir)
    @input_dir = input_dir
    @output_dir = output_dir
    @processed_files = []
    @failed_files = []
  end

  def process_all_files
    Dir.glob(File.join(@input_dir, '*.csv')).each do |file_path|
      begin
        process_file(file_path)
        @processed_files << file_path
      rescue StandardError => e
        @failed_files << {
          file: file_path,
          error: e.message
        }
      end
    end

    generate_report
  end

  private

  def process_file(file_path)
    output_path = File.join(
      @output_dir,
      "processed_#{File.basename(file_path)}"
    )

    transformer = DataTransformer.new
    transformer.transform_csv(file_path, output_path)
  end

  def generate_report
    CSV.open(File.join(@output_dir, 'processing_report.csv'), 'wb') do |csv|
      csv << ['file_name', 'status', 'error_message']

      @processed_files.each do |file|
        csv << [file, 'success', '']
      end

      @failed_files.each do |failure|
        csv << [failure[:file], 'error', failure[:error]]
      end
    end
  end
end

# 定期実行用のバッチ処理実装
class ScheduledCSVProcessor
  def self.run(config)
    processor = new(config)
    processor.execute
  end

  def initialize(config)
    @config = config
    @logger = Logger.new('csv_processor.log')
  end

  def execute
    @logger.info("Starting batch processing at #{Time.now}")

    process_files
    cleanup_old_files
    send_notification

    @logger.info("Completed batch processing at #{Time.now}")
  end

  private

  def process_files
    batch_processor = CSVBatchProcessor.new(
      @config[:input_dir],
      @config[:output_dir]
    )
    batch_processor.process_all_files
  end

  def cleanup_old_files
    # 古いファイルの削除処理
    retention_days = @config[:retention_days] || 30

    Dir.glob(File.join(@config[:output_dir], '*.csv')).each do |file|
      if File.mtime(file) < Time.now - retention_days * 24 * 60 * 60
        File.delete(file)
        @logger.info("Deleted old file: #{file}")
      end
    end
  end

  def send_notification
    # 処理完了通知の送信
    # 実際の通知処理を実装
  end
end

これらのユースケースは、実際の業務でよく使用される処理パターンの基本となります。必要に応じてカスタマイズして使用してください。

セキュリティとバリデーション

入力データの検証と無害化の重要性

CSVファイルの処理では、セキュリティリスクを最小限に抑えるため、入力データの適切な検証と無害化が重要です。

# 包括的な入力検証クラス
class CSVInputValidator
  class ValidationError < StandardError; end

  def initialize(rules)
    @rules = rules
  end

  def validate_row(row)
    @rules.each do |column, validations|
      value = row[column]
      validations.each do |validation|
        unless validation.call(value)
          raise ValidationError, "Invalid value in column #{column}: #{value}"
        end
      end
    end
  end
end

# 一般的なバリデーションルール
module ValidationRules
  # 数値の検証
  def self.number_rule
    ->(value) { value.to_s.match?(/\A-?\d+(\.\d+)?\z/) }
  end

  # メールアドレスの検証
  def self.email_rule
    ->(value) { value.to_s.match?(/\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i) }
  end

  # 日付形式の検証
  def self.date_rule
    ->(value) { 
      begin
        Date.parse(value.to_s)
        true
      rescue
        false
      end
    }
  end

  # 文字列長の検証
  def self.length_rule(min: 0, max: 255)
    ->(value) { value.to_s.length.between?(min, max) }
  end

  # 許可文字の検証
  def self.allowed_chars_rule(pattern = /\A[\w\s\-,.]+\z/)
    ->(value) { value.to_s.match?(pattern) }
  end
end

# 実装例
class SecureCSVProcessor
  def initialize(validation_rules)
    @validator = CSVInputValidator.new(validation_rules)
  end

  def process_file(file_path)
    sanitized_rows = []

    CSV.foreach(file_path, headers: true) do |row|
      begin
        @validator.validate_row(row)
        sanitized_rows << sanitize_row(row)
      rescue CSVInputValidator::ValidationError => e
        log_validation_error(e, row)
        next
      end
    end

    sanitized_rows
  end

  private

  def sanitize_row(row)
    row.to_h.transform_values { |v| sanitize_value(v) }
  end

  def sanitize_value(value)
    # HTMLエスケープとトリム処理
    CGI.escape_html(value.to_s).strip
  end

  def log_validation_error(error, row)
    # エラーログの記録
    Logger.new('validation_errors.log').error("#{error.message}: #{row.to_h}")
  end
end

安全なCSV出力の実装方法

出力時のセキュリティリスクを防ぐための実装パターンを紹介します。

# セキュアなCSV出力クラス
class SecureCSVWriter
  def initialize(output_path)
    @output_path = output_path
  end

  def write(data, headers)
    # 一時ファイルを使用して安全に書き込み
    temp_file = Tempfile.new(['secure_csv', '.csv'])

    begin
      write_to_temp_file(temp_file, data, headers)
      safely_move_file(temp_file.path, @output_path)
    ensure
      temp_file.close
      temp_file.unlink
    end
  end

  private

  def write_to_temp_file(temp_file, data, headers)
    CSV.open(temp_file.path, 'wb', force_quotes: true) do |csv|
      csv << headers
      data.each do |row|
        csv << secure_format_row(row)
      end
    end
  end

  def secure_format_row(row)
    row.map { |value| secure_format_value(value) }
  end

  def secure_format_value(value)
    return '' if value.nil?

    # Formula Injection対策
    value = value.to_s
    if value.start_with?('=', '+', '-', '@')
      "'#{value}"  # シングルクォートを先頭に付けて数式として解釈されるのを防ぐ
    else
      value
    end
  end

  def safely_move_file(source, destination)
    # ファイルの権限を適切に設定
    FileUtils.chmod(0644, source)
    # アトミックな操作でファイルを移動
    FileUtils.mv(source, destination)
  end
end

# セキュリティのベストプラクティス
class CSVSecurityBestPractices
  def self.secure_file_permissions(file_path)
    # ファイルパーミッションの設定
    FileUtils.chmod(0644, file_path)
  end

  def self.validate_file_path(file_path)
    # パストラバーサル対策
    unless File.expand_path(file_path).start_with?(File.expand_path(ALLOWED_DIRECTORY))
      raise SecurityError, "Invalid file path"
    end
  end

  def self.set_secure_headers
    {
      'Content-Type' => 'text/csv',
      'Content-Disposition' => 'attachment; filename="secure.csv"',
      'X-Content-Type-Options' => 'nosniff',
      'Cache-Control' => 'no-store'
    }
  end
end

主なセキュリティ対策のポイント:

入力データの検証

データ型の確認
文字列長のチェック
禁止文字のフィルタリング

出力データの無害化

Formula Injection対策
適切なエスケープ処理
文字エンコーディングの統一

ファイル操作の安全性確保

適切なパーミッション設定
一時ファイルの使用
アトミックな操作の実装

これらのセキュリティ対策を適切に実装することで、安全なCSVファイル処理を実現できます。