Dealing with Version Information

Hello! My name is Florian. How are you?

My name is Florian.

# Python's .ini library comes with a ton of features such as referencing
# values or defining default values for other sections

[DEFAULT]
# Optional parameters. If not set, niles will use the default encoding and
# line ending defined by the operating system
_charset = utf-8
_end_of_line = crlf

[**/{hello,name}.txt]
_regex = My name is (?P<name>[A-za-z]+(\s[A-za-z]+)?)
first_name = Max
second_name = Mustermann
name = %(first_name)s %(second_name)s

Hello! My name is Max Mustermann. How are you?

My name is Max Mustermann.

[DEFAULT]
major = 5
minor = 10
patch = 0

[**/AssemblyInfo.cs]
_regex = ^\[assembly: Assembly(File)?Version\("(?P<assembly_version>.+)"\)\]$
assembly_version = %(major)s.%(minor)s.%(patch)s.0

[**/*.nuspec]
_regex = ^\s*<version>(?P<semantic_version>.+)<\/version>$
semantic_version = %(major)s.%(minor)s.%(patch)s

#!/usr/bin/env python3

import argparse
import collections
import configparser
import glob
import re


class Config(collections.namedtuple(
        'Config', 'file_names charset end_of_line regex_list values')):
    __slots__ = ()


def expand_curly(line):
    match = re.search('{([^{]*?)}', line)
    expanded_lines = []
    if match is None:
        expanded_lines.append(line)
    else:
        snippets = match.group(1).split(',')
        for snippet in snippets:
            expanded_lines.append(
                line[:match.start()] + snippet + line[match.end():])
    return expanded_lines


def fetch_files(glob_pattern):
    expanded_patterns = expand_curly(glob_pattern)
    file_names = []
    [file_names.extend(
        glob.glob(p, recursive=True)) for p in expanded_patterns]
    return file_names


def parse_config(text):
    config_parser = configparser.ConfigParser()
    config_parser.read_string(text)
    config_list = []
    for section in config_parser.sections():
        file_names = fetch_files(section)
        section_data = config_parser[section]
        charset = section_data.get('_charset')
        end_of_line_text = section_data.get('_end_of_line')
        if end_of_line_text is None:
            end_of_line = None
        elif end_of_line_text == 'lf':
            end_of_line = '\n'
        elif end_of_line_text == 'crlf':
            end_of_line = '\r\n'
        else:
            raise ValueError(
                "Supported end of line characters: 'lf' and 'crlf'")
        regex_list_text = section_data.get('_regex', '').splitlines()
        regex_list = [re.compile(r) for r in regex_list_text]
        config_list.append(Config(file_names, charset, end_of_line,
                                  regex_list, dict(config_parser[section])))
    return tuple(config_list)


def load_config():
    with open('niles.ini', 'r') as f:
        return parse_config(f.read())


def read_file_lines(file_name, charset, end_of_line):
    with open(file_name, 'r', encoding=charset, newline=end_of_line) as f:
        return f.read().splitlines()


def write_file_lines(file_name, lines, charset, end_of_line):
    with open(file_name, 'w', encoding=charset, newline=end_of_line) as f:
        for line in lines:
            f.write(line + '\n')


def replace_line(regex, line, values):
    match = regex.search(line)
    replaced_line = line
    line_changed = False
    offset = 0
    if match is not None:
        group_dict = match.groupdict()
        for group_name in group_dict.keys():
            if group_name in values:
                old_value_len = len(match.group(group_name))
                new_value = values[group_name]
                start_index = offset + match.start(group_name)
                end_index = start_index + old_value_len
                start = replaced_line[:start_index]
                end = replaced_line[end_index:]
                replaced_line = start + new_value + end
                line_changed = line != replaced_line
                offset += len(new_value) - old_value_len
    return line_changed, replaced_line


def list_values(config, read_file, log):
    for entry in config:
        for file_name in entry.file_names:
            for line in read_file(file_name, entry.charset, entry.end_of_line):
                for regex in entry.regex_list:
                    match = regex.search(line)
                    if match is not None:
                        for group_name in match.groupdict().keys():
                            log("{}: {}".format(
                                file_name, match.group(group_name)))


def apply_changes(config, read_file, write_file, log):
    for entry in config:
        for file_name in entry.file_names:
            new_lines = []
            file_dirty = False
            for line in read_file(file_name, entry.charset, entry.end_of_line):
                new_line = line
                for regex in entry.regex_list:
                    line_changed, new_line = replace_line(
                        regex, new_line, entry.values)
                    file_dirty |= line_changed
                new_lines.append(new_line)
            if file_dirty:
                write_file(
                    file_name, new_lines, entry.charset, entry.end_of_line)
                print("Wrote file '{}'".format(file_name))
            else:
                print("Skipped file '{}'".format(file_name))


def list_files(config, log):
    for entry in config:
        for file_name in entry.file_names:
            log(file_name)


def list_values_cmd():
    list_values(load_config(), read_file_lines, print)


def apply_changes_cmd():
    apply_changes(load_config(), read_file_lines, write_file_lines, print)


def list_files_cmd():
    list_files(load_config(), print)


def main():
    arg_parser = argparse.ArgumentParser(
        description='Search and replace text in files')
    subparsers = arg_parser.add_subparsers()
    values_parser = subparsers.add_parser('values', help='List all values')
    values_parser.set_defaults(func=list_values_cmd)
    apply_parser = subparsers.add_parser('apply', help='Writes values to files')
    apply_parser.set_defaults(func=apply_changes_cmd)
    files_parser = subparsers.add_parser('files', help='List all files')
    files_parser.set_defaults(func=list_files_cmd)
    args = arg_parser.parse_args()
    if hasattr(args, 'func'):
        args.func()
    else:
        arg_parser.print_help()


if __name__ == '__main__':
    main()