Hi everyone,
I just read the blog post Back to Basics: Polymorphism & Ruby, and I’ve sort of been playing around with similar examples in my code and would appreciate yourt feedback!
In the last two examples of the blog post , there is a refactoring of the parse method which initially uses a conditional to check type in order to determine which parser to use.
The new example uses Polymorphism to separate concerns and apply the Single Responsibility Principle. Instead of asking the object what type of thing it is, the code is now telling the Parser ‘hey use this type of parser’, which I agree is better and easier to understand.
This makes sense to me, however it doesn’t seem to replicate the original parse method in that we’re still required to tell the Parser which type of Parser (XmlParser/JsonParser) to use?
Just to extend the example, would you consider adding another class to determine which parser to use?
Something like below:
class Parser
def initialize(file)
@file = file
end
def parse
parser.parse
end
private
attr_reader :file
def parser
FindParser.new(file).return_parser
end
end
class FindParser
def initialize(file)
@file = file
@xml_parser = XmlParser.new
@json_parser = JsonParser.new
end
def return_parser
# Determine whether to return an XmlParser or JsonParser
# Most likely use a conditional again?
end
end
# Putting it all together
Parser.new(some_file).parse
I appreciate the blog post uses a contrived example for the purposes of the explaining it’s point, however I’m just trying to get a better understanding of polymorphism and how it can be applied, hence the example above.
Do we still need to run a conditional check to determine which Parser (e.g. FindParser class) or is there a better way?