Allow metadata file to inherit values from another configuration file

chainedconfigparser.py

 # coding: utf-8
 
 # This file is part of the Adblock Plus build tools,
 # Copyright (C) 2006-2012 Eyeo GmbH
 #
 # Adblock Plus is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 3 as
 # published by the Free Software Foundation.
 #
 # Adblock Plus is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
 
 # Note: These are the base functions common to all packagers, the actual
 # packagers are implemented in packagerGecko and packagerChrome.
 
 import os, codecs, ConfigParser
 
+class Item(tuple):
+  def __new__(cls, name, value, source):
+    result = super(Item, cls).__new__(cls, (name, value))
+    result.source = source
+    return result
+
 class ChainedConfigParser:

[Sebastian Noack, 2013/11/05 12:19:38]

I find this approach slightly overkill. I would prefer something as simple as
following instead:


def read_with_inheritance(path):
  files = []
  basedir = os.path.dirname(path)

  try:
    while True:
      file = codecs.open(path, 'rb', encoding='utf-8')
      files.insert(0, file)

      parser = ConfigParser.SafeConfigParser()
      parser.readfp(path)

      try:
        path = parser.get('default', 'inherit')
      except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
        file.close()
        files.remove(file)
        break

      path = os.path.join(basedir, *path.split('/'))

    for file in files:
      file.seek(0)
      parser.readfp(file)
  finally:
    for file in files:
      file.close()

  return parser

[Wladimir Palant, 2013/11/05 12:45:38]

That was a consideration of course. However, we need to be able to resolve
relative paths in configs - basedir isn't fixed, it's rather dependent on the
config file. Consider the following file foo/metadata:

  [default]
  inherit = bar/metadata
  [mapping]
  icon.png = icon64.png

And foo/bar/metadata (typically inside a subrepository):

  [mapping]
  contentScript.js = default/contentScript.js

Whoever writes foo/bar/metadata file shouldn't need to think about files that
will inherit from it - it's obvious that the relative path
default/contentScript.js here should be resolved relative to the foo/bar/
directory. On the other hand, the relative path icon64.png in foo/metadata file
should be resolved relative to the foo/ directory.

I see now that the change that actually allowed retrieving the source directory
for each setting was part of a different review. I've added this change here but
packager.py is no longer part of the patchset because of that.

[Sebastian Noack, 2013/11/05 13:13:25]

Fair enough, LGTM.

   """
     This class provides essentially the same interfaces as SafeConfigParser but
     allows chaining configuration files so that one config file provides the
     default values for the other. To specify the config file to inherit from
     a config file needs to contain the following option:
 
     [default]
     inherit = foo/bar.config
 
     The value of the inherit option has to be a relative path with forward
     slashes as delimiters. Up to 5 configuration files can be chained this way,
     longer chains are disallowed to deal with circular references.
 
     A main API difference to SafeConfigParser is the way a class instance is
     constructed: a file path has to be passed, this file is assumed to be
     encoded as UTF-8. Also, ChainedConfigParser data is read-only and the
-    options are case-sensitive.
+    options are case-sensitive. An additional option_source(section, option)
+    method is provided to get the path of the configuration file defining this
+    option (for relative paths). Items returned by the items() function also
+    have a source attribute serving the same purpose.
   """
 
   def __init__(self, path):
     self.chain = []
     self.read_path(path)
 
   def read_path(self, path):
     if len(self.chain) >= 5:
       raise Exception('Too much inheritance in config files')
 
     config = ConfigParser.SafeConfigParser()
     config.optionxform = str
+    config.source_path = path
     handle = codecs.open(path, 'rb', encoding='utf-8')
     config.readfp(handle)
     handle.close()
     self.chain.append(config)
 
     if config.has_section('default') and config.has_option('default', 'inherit'):
       parts = config.get('default', 'inherit').split('/')
       defaults_path = os.path.join(os.path.dirname(path), *parts)
       self.read_path(defaults_path)
 
@@ skipping 38 matching lines @@
     raise ConfigParser.NoOptionError(option, section)
 
   def items(self, section):
     seen = set()
     result = []
     for config in self.chain:
       if config.has_section(section):
         for name, value in config.items(section):
           if name not in seen:
             seen.add(name)
-            result.append((name, value))
+            result.append(Item(name, value, config.source_path))
     return result
+
+  def option_source(self, section, option):
+    for config in self.chain:
+      if config.has_section(section) and config.has_option(section, option):
+        return config.source_path
+    raise ConfigParser.NoOptionError(option, section)