ruby read and write/change the same file

Question

I am trying to change the content of an existing file. I have this piece of code, which works. But I would like to find a better way to do the manipulation in one time of opening file.

  File.open(file_name , 'r') do |f|
    content = f.read
  end
  File.open(file_name , 'w') do |f|
    content.insert(0, "something ")
    f.write(content)
  end

Is there a way we can do it only opening once the file?

I have tried using File.open(file_name , 'r+'), which seems only append to the end of the file (not be able to insert thing at the beginning of the file).

Answer 1

[Edit: I misunderstood your question, but my code below can be fixed by simply inserting the line:

text_to_prepend = ''

after

line_out = text_to_prepend + buf.shift

It could be simplified a little (for your question), but I'll leave it as is to show how the same string could be prepended to each line.]

You can open the file but once, and not read the entire file before writing, but it's messy and a bit tricky. Basically, you need to move the file pointer between reading and writing and maintain a buffer that contains lines from the file that will be wholly or partially overwritten when each modified line is written.

At each step, remove the first line from the buffer and modify it in preparation for writing. Before writing, however, you may need to read one or more additional lines into the buffer, in order that the read pointer remains ahead of the write pointer after the modified line is written. After all lines have been read, each remaining line in the buffer is modified and written.

Code

def prepend_file_lines(file_name, text_to_prepend)
  f = File.open(file_name, 'r+')
  return if f.eof?
  write_pos = 0
  line_in = f.readline
  read_pos = line_in.size
  buf = [line_in]
  last_line_read = f.eof?
  loop do
    break if buf.empty?   
    line_out = text_to_prepend + buf.shift
    while (!last_line_read && read_pos <= write_pos + line_out.size) do
      line_in = f.readline 
      buf << line_in 
      read_pos += line_in.size
      last_line_read = f.eof?
    end
    f.seek(write_pos, IO::SEEK_SET) 
    write_pos += f.write(line_out)
    f.seek(read_pos, IO::SEEK_SET) 
  end
end

Example

First, create a test file.

text =<<_
Now is
the time
for all Rubiests
to raise their
glasses to Matz.
_

F_NAME = "sample.txt"
File.write(F_NAME, text)

We can confirm the file was written correctly:

File.readlines(F_NAME).each { |l| puts l } 
  # Now is
  # the time
  # for all Rubiests
  # to raise their
  # glasses to Matz.

Now let's try it:

prepend_file_lines("sample.txt", "Here's to Matz: ")

File.readlines(F_NAME).each { |l| puts l } 
  # Here's to Matz: Now is
  # Here's to Matz: the time
  # Here's to Matz: for all Rubiests
  # Here's to Matz: to raise their
  # Here's to Matz: glasses to Matz.

Note that when testing, it's necessary to write the test file before each call to prepend_file_lines, since the file is being modified.

Answer 2

You can do it in the same file, but you'll likely overwrite the content of the file.

Each file operation sets the file's cursor to a different position, which is the position used for the latter operations. So if you read 8 bytes, you have to back your cursor 8 bytes earlier and write exactly 8 bytes to not overwrite anything, if you write fewer bytes, you'll keep unchanged bytes.

The Ruby File class is IO class, which is documented in http://www.ruby-doc.org/core-1.9.3/IO.html.

To open a file for read/write operations, use "r+" mode.

Answer 3

It looks like you want IO::SEEK_SET with 0 to rewind the file pointer after reading.

file_name = "File.txt";

File.open(file_name , 'r+') do |f|
    content = f.read
    content.insert(0, "somehting else")
    f.seek(0, IO::SEEK_SET)
    f.write(content)
end