I have an interesting question about which programming idiom is easier to use for beginner developers writing concrete file parsing classes.

I'm developing an open source library, which one of the main functionality is to parse plain text files and get structured information from them. All of the files contains the same kind of information, but can be in different formats like XML, plain text (each of them is structured differently), etc. There are a common set of information pieces which is the same in all (e.g. player names, table names, some id numbers)

There are formats which are very similar to each other, so it's possible to define a common Base class for them to facilitate concrete format parser implementations. So I can clearly define base classes like SplittablePlainTextFormat, XMLFormat, SeparateSummaryFormat, etc. Each of them hints the kind of structure they aim to parse. All of the concrete classes should have the same information pieces, no matter what.

To be useful at all, this library needs to define at least 30-40 of these parsers. A couple of them are more important than others (obviously the more popular formats).

Now my question is, which is the best programming idiom to choose to facilitate the development of these concrete classes? Let me explain:

I think imperative programming is easy to follow even for beginners, because the flow is fixed, the statements just come one after another. Right now, I have this:

class SplittableBaseFormat:
    def parse(self):
        "Parses the body of the hand history, but first parse header if not yet parsed."
        if not self.header_parsed:
            self.parse_header()

        self._parse_table()
        self._parse_players()
        self._parse_button()
        self._parse_hero()
        self._parse_preflop()
        self._parse_street('flop')
        self._parse_street('turn')
        self._parse_street('river')
        self._parse_showdown()
        self._parse_pot()
        self._parse_board()
        self._parse_winners()
        self._parse_extra()

        self.parsed = True

So the concrete parser need to define these methods in order in any way they want. Easy to follow, but takes longer to implement each individual concrete parser.

So what about declarative? In this case Base classes (like SplittableFormat and XMLFormat) would do the heavy lifting based on regex and line/node number declarations in the concrete class, and concrete classes have no code at all, just line numbers and regexes, maybe other kind of rules.

Like this:

class SplittableFormat:
    def parse_table():
        "Parses TABLE_REGEX and get information"
        # set attributes here

    def parse_players():
        "parses PLAYER_REGEX and get information"
        # set attributes here


class SpecificFormat1(SplittableFormat):
    TABLE_REGEX = re.compile('^(?P<table_name>.*) other info \d* etc')
    TABLE_LINE = 1
    PLAYER_REGEX = re.compile('^Player \d: (?P<player_name>.*) has (.*) in chips.')
    PLAYER_LINE = 16


class SpecificFormat2(SplittableFormat):
    TABLE_REGEX = re.compile(r'^Tournament #(\d*) (?P<table_name>.*) other info2 \d* etc')
    TABLE_LINE = 2
    PLAYER_REGEX = re.compile(r'^Seat \d: (?P<player_name>.*) has a stack of (\d*)')
    PLAYER_LINE = 14

So if I want to make it possible for non-developers to write these classes the way to go seems to be the declarative way, however, I'm almost certain I can't eliminate the declarations of regexes, which clearly needs (senior :D) programmers, so should I care about this at all? Do you think it matters to choose one over another or doesn't matter at all? Maybe if somebody wants to work on this project, they will, if not, no matter which idiom I choose. Can I "convert" non-programmers to help developing these? What are your observations?

Other considerations: Imperative will allow any kind of work; there is a simple flow, which they can follow but inside that, they can do whatever they want. It would be harder to force a common interface with imperative because of this arbitrary implementations. Declarative will be much more rigid, which is a bad thing, because formats might change over time without any notice. Declarative will be harder for me to develop and takes longer time. Imperative is already ready to release.

I hope a nice discussion will happen in this thread about programming idioms regarding which to use when, which is better for open source projects with different scenarios, which is better for wide range of developer skills.

TL; DR:

• Parsing different file formats (plain text, XML)
• They contains same kind of information
• Target audience: non-developers, beginners
• Regex probably cannot be avoided
• 30-40 concrete parser classes needed
• Facilitate coding these concrete classes
• Which idiom is better?