How to Strip Newlines in Ruby - A Complete Guide

# Example: Cleaning up a CSV file
require 'csv'

def clean_csv_data(filename)
  # Read the whole file and get rid of any extra newlines
  raw_data = File.read(filename).gsub(/\r\n?/, "\n").strip

  # Parse the cleaned-up CSV data
  CSV.parse(raw_data).map do |row|
    # Strip whitespace and newlines from each field
    row.map { |field| field&.strip }
  end
end

# How to use it
begin
  cleaned_data = clean_csv_data('sample.csv')
  puts "Processed #{cleaned_data.size} rows"
rescue Errno::ENOENT
  puts "Error: File not found"
end

# A simple script to collect names from the command line
def collect_names(count)
  names = []
  
  count.times do |i|
    print "Enter name #{i + 1}: "
    # gets.chomp gets rid of the trailing newline
    # strip takes care of any extra whitespace
    name = gets.chomp.strip
    
    # Skip any empty inputs
    next if name.empty?
    
    names << name
  end
  
  names
end

# How to use it
puts "Let's collect 3 names!"
names = collect_names(3)
puts "\nCollected names:"
names.each { |name| puts "- #{name}" }

require 'net/http'
require 'json'

class APIResponseCleaner
  def self.fetch_and_clean_bio(user_id)
    # Simulate an API response with a multi-line bio
    response = fetch_user_bio(user_id)
    
    case response
    when Net::HTTPSuccess
      data = JSON.parse(response.body)
      # Clean up the biography text
      clean_bio = data['biography']
        .gsub(/\r\n|\r|\n/, ' ')  # Replace newlines with spaces
        .gsub(/\s+/, ' ')         # Get rid of multiple spaces
        .strip                    # Trim leading/trailing whitespace
      
      { success: true, bio: clean_bio }
    else
      { success: false, error: 'Failed to fetch biography' }
    end
  end

  private

  def self.fetch_user_bio(user_id)
    uri = URI("https://api.example.com/users/#{user_id}/bio")
    Net::HTTP.get_response(uri)
  end
end

# How to use it
begin
  result = APIResponseCleaner.fetch_and_clean_bio(123)
  if result[:success]
    puts "Cleaned biography: #{result[:bio]}"
  else
    puts "Error: #{result[:error]}"
  end
rescue StandardError => e
  puts "Unexpected error: #{e.message}"
end

class TextProcessor
  def self.format_paragraph(text, max_length: 80)
    # Normalize newlines and collapse extra spaces
    cleaned_text = text
      .gsub(/\r\n|\r|\n/, ' ')  # Turn newlines into spaces
      .gsub(/\s+/, ' ')         # Normalize spaces
      .strip                    # Trim leading/trailing whitespace

    # Word-wrap the text at the max length
    words = cleaned_text.split(' ')
    lines = []
    current_line = []
    current_length = 0

    words.each do |word|
      # Check if adding this word would go over the max length
      if current_length + word.length + current_line.length > max_length
        # Start a new line
        lines << current_line.join(' ')
        current_line = [word]
        current_length = word.length
      else
        current_line << word
        current_length += word.length
      end
    end

    # Add the last line
    lines << current_line.join(' ') unless current_line.empty?
    lines
  end

  def self.extract_sentences(text)
    # Get rid of newlines and normalize spaces
    cleaned_text = text
      .gsub(/\r\n|\r|\n/, ' ')
      .gsub(/\s+/, ' ')
      .strip

    # Split into sentences (this is a basic implementation)
    cleaned_text.split(/(?<=[.!?])\s+/)
  end
end

# How to use it
text = <<~HEREDOC
  This is a sample text
  with multiple lines.
  It needs to be processed
  and formatted properly!
  Some sentences might be
  split across lines.
HEREDOC

puts "\nFormatted paragraph with word wrap:"
TextProcessor.format_paragraph(text, max_length: 40).each do |line|
  puts line
end

puts "\nExtracted sentences:"
TextProcessor.extract_sentences(text).each do |sentence|
  puts "- #{sentence}"
end

class StringValidator
  class ValidationError < StandardError; end
  
  def self.validate_comment(text, max_length: 1000)
    # Clean up the input text
    cleaned_text = text
      .gsub(/\r\n|\r|\n/, ' ')  # Turn newlines into spaces
      .gsub(/\s+/, ' ')         # Normalize spaces
      .strip                    # Trim leading/trailing whitespace
    
    # Run your validations
    raise ValidationError, 'Comment cannot be empty' if cleaned_text.empty?
    raise ValidationError, "Comment exceeds #{max_length} characters" if cleaned_text.length > max_length
    
    cleaned_text
  end
  
  def self.strings_match?(str1, str2)
    # Normalize both strings before you compare them
    clean_str1 = normalize_string(str1)
    clean_str2 = normalize_string(str2)
    
    clean_str1 == clean_str2
  end
  
  def self.validate_code_block(text)
    # Make sure line endings are consistent and there's no trailing whitespace
    cleaned_lines = text.split(/\r\n|\r|\n/).map(&:rstrip)
    
    # Validate indentation (must be spaces, not tabs)
    cleaned_lines.each.with_index(1) do |line, index|
      if line.match?(/\t/)
        raise ValidationError, "Line #{index} contains tabs instead of spaces"
      end
    end
    
    cleaned_lines.join("\n")
  end
  
  private
  
  def self.normalize_string(str)
    str
      .gsub(/\r\n|\r|\n/, ' ')
      .gsub(/\s+/, ' ')
      .strip
      .downcase  # For case-insensitive comparison
  end
end

# How to use it
begin
  # Validate a comment
  comment = "This is a multi-line\ncomment that needs\nto be validated!"
  clean_comment = StringValidator.validate_comment(comment, max_length: 100)
  puts "Validated comment: #{clean_comment}"
  
  # Compare strings
  str1 = "Hello\nWorld"
  str2 = "Hello World"
  puts "Strings match: #{StringValidator.strings_match?(str1, str2)}"
  
  # Validate a code block
  code = "def hello_world\n  puts 'Hello!'\nend"
  clean_code = StringValidator.validate_code_block(code)
  puts "Validated code:\n#{clean_code}"
rescue StringValidator::ValidationError => e
  puts "Validation error: #{e.message}"
end