Ruby: File formats handling by extending File with a module

Question

Once I have a File instance, I would like to check if it matches a file format and extend that instance with corresponding methods:

module MP3
  def self.extended(base)
    raise "Can only extend a File" unless base.is_a?(File)
    raise "Incorrect file format" unless is_mp3?(base)
  end

  def self.is_mp3?(file)
    # Full metadata check if it is a MP3 format
  end

  def year
    # Extract year from metadata
  end
end

song = File.new("song.mp3")
if MP3.is_mp3?(song)
  song.extend(MP3)
  puts song.ctime # Original File method
  puts song.year  # Extended MP3 method
end

picture = File.new("picture.jpg")
MP3.is_mp3?(picture) #=> False
picture.extend(MP3)  #=> raise "Incorrect file format"

I guess that is not conventional but my needs are:

• Be able to handle several file formats.
• Open a file before knowing its format.
• Re-use the same File instance without having to create a new object. (see below)
• Have both original File methods and format specific methods in the same object.
• Check the file format is correct before adding corresponding methods.

Is this approach correct?

This question is a follow-up of a previous question.

I want to extend the existing File instance instead of creating a new instance because I am using a wrapper for File, that holds the whole file in RAM (read from a tape drive that does not allow sequential access).

Answer 1

What you're proposing puts too much of the logic of choosing which class to use into the caller's code. Every time you add a new file type, you need to change everywhere your code is used.

Instead, use a Factory pattern. Write a class (the factory) which examines a filename and decides what to do. Except I'm going to use the much superior Pathname.

require "pathname"

class Pathname::Format
  def self.from_filename(filename)
    path = Pathname.new(filename)

    from_pathname!(path)

    return path
  end

  def self.from_pathname!(path)
    case path.extname
    when ".mp3"
      path.extend(MP3)
    when ".jpg"
      path.extend(JPG)
    end

    return
  end
end

Point is to put that decision into the factory class, not in the calling code.

Then you can write your modules.

module JPG
  def type
    return "JPG"
  end
end

module MP3
  def type
    return "MP3"
  end

  def year
    puts "MP3 year called"
  end
end

Now the caller just uses the factory.

# From a filename
song = Pathname::Format.from_filename("song.mp3")
puts song.ctime # Original File method
puts song.year  # Extended MP3 method

# From a Pathname
picture = Pathname.new("picture.jpg")
Pathname::Format.from_pathname!(picture)
puts picture.type

Instead of having a proliferation of special methods to check if an object is of a particular type, either check a type method, check if it's a kind of a module, or rely on duck typing.

if song.type == "MP3"
  puts song.year
end

if song.kind_of?(MP3)
  puts song.year
end

if song.respond_to?("year")
  puts song.year
end