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?