src/git_stats/config.py

   1 #!/usr/bin/env python
   2
   3 import os
   4
   5 from git import Repo
   6
   7 class OptionList:
   8   """OptionList class
   9   """
  10
  11   pass
  12
  13 def _readVerse(verse, config, convert_camel_case):
  14   """Reads in a verse from a config file and stores the result in config
  15
  16   verse: The lines for the current verse, not including the header.
  17   config: A dictionary to store the found configurations in.
  18   convert_camel_case: Whether to convert camelCase words to dashed_form.
  19   """
  20
  21   for line in verse:
  22     # Remove spaces and newlines
  23     stripline = line.lstrip().rstrip()
  24
  25     # Stop if the line is not left indented, or empty
  26     if stripline == line.rstrip() or not stripline:
  27       break
  28
  29     # Extract the key:value pair
  30     splitline = stripline.split(' = ')
  31     key = splitline[0].rstrip()
  32     value = splitline[1].lstrip()
  33
  34     # Try to convert to a number
  35     try:
  36       intval = int(value)
  37       value = intval
  38     except ValueError:
  39       pass
  40
  41     # Try to convert boolean values
  42     if value == "False":
  43       value = False
  44
  45     if value == "True":
  46       value = True
  47
  48     if value == "None":
  49       value = None
  50
  51     # If desired, convert camelCase to dashed_form
  52     if convert_camel_case and key.lower() != key:
  53       dashed_form = ""
  54
  55       for c in key:
  56         if c.isupper():
  57           dashed_form += '_'
  58
  59         dashed_form += c.lower()
  60
  61       key = dashed_form
  62
  63     # Store the parsed and converted result
  64     config[key] = value
  65
  66 def read(lines, convert_camel_case=True):
  67   """Reads in the specified file
  68
  69   Understands 'True', 'False', 'None' and integer values.
  70   All camelCase keys are converted to dashed_form.
  71   The file is expected to have the following format:
  72   .*
  73   [GitStats]
  74     [key = value]*
  75   <any unindented or empty line>
  76   .*
  77
  78   Args:
  79     path: The location of the file to read in
  80
  81   Returns: A dictionary with the key:value pairs specified in the file.
  82   """
  83
  84   config = {}
  85
  86   while True:
  87     # Find our verse
  88     try:
  89       pos = lines.index("[GitStats]\n")
  90     except ValueError:
  91       try:
  92         pos = lines.index("[GitStats]")
  93       except ValueError:
  94         return config
  95
  96     # Kick off the header
  97     pos += 1
  98     lines = lines[pos:]
  99
 100     # Read in this verse, updates config with the found configurations
 101     _readVerse(lines, config, convert_camel_case)
 102
 103   return config
 104
 105 def _getDefaultConfigPaths():
 106   """Returns a list of config paths to use by default
 107   """
 108
 109   paths = []
 110
 111   path = "~/.gitconfig"
 112   path = os.path.expanduser(path)
 113   paths.append(path)
 114
 115   repo = Repo(".")
 116   path = os.path.join(repo.wd, '.git', 'config')
 117   paths.append(path)
 118
 119   paths.append("config")
 120
 121   return paths
 122
 123 def _readConfigPaths(paths, convert_camel_case):
 124   """Reads the config files at the specified paths
 125
 126   When multiple values for a key are read in, the one that
 127   is read in the last is used. (E.g., when reading in the
 128   config files, no effort is made to prevent existing
 129   values being overwritten).
 130
 131   Args:
 132     paths: The paths to the config files.
 133     convert_camel_case: Whether to convert camelCase to dashed_form.
 134   """
 135
 136   result = {}
 137
 138   # Check all the configuration files and parse them
 139   for path in paths:
 140     if not os.path.isfile(path):
 141       continue
 142
 143     file = open(path)
 144     lines = file.readlines()
 145
 146     config = read(lines, convert_camel_case)
 147
 148     # Add the found keys to our result
 149     for key, value in config.iteritems():
 150       result[key] = value
 151
 152   return result
 153
 154 def readDefaultConfigs(convert_camel_case=True):
 155   """Reads all default config files and returns the result
 156
 157   When a value is read in multiple times the one read in
 158   the last is used. The following files are tried in the
 159   listed order:
 160   ~/.gitconfig
 161   .git/config
 162   config
 163   """
 164
 165   paths = _getDefaultConfigPaths()
 166   result = _readConfigPaths(paths, convert_camel_case)
 167
 168   return result
 169
 170 def extractOptions(options, options_list):
 171   """Extracts options and returns the result
 172
 173   The options are extracted from the specified options and
 174   from the 'config' file.
 175   """
 176
 177   opts = readDefaultConfigs()
 178
 179   result = OptionList()
 180
 181   for opt in options_list:
 182     if getattr(options, opt, None) == None:
 183       val = opts.get(opt, None)
 184     else:
 185       val = getattr(options, opt)
 186
 187     if val == None and getattr(result, opt, None) != None:
 188       continue
 189
 190     setattr(result, opt,  val)
 191
 192   return result
 193
 194 def main(args):
 195   """Parses all config files and prints the result
 196
 197   Runs once with convert_camel_case on, and once with it off.
 198
 199   Params:
 200     args: Not used
 201   """
 202
 203   result = readDefaultConfigs()
 204
 205   print("convert_camel_case is ON:")
 206   for key, value in result.iteritems():
 207     print("%s: %s" % (key, str(value)))
 208
 209   result = readDefaultConfigs(False)
 210
 211   print("")
 212   print("convertCamelCase is OFF:")
 213   for key, value in result.iteritems():
 214     print("%s: %s" % (key, str(value)))
 215
 216 if __name__ == '__main__':
 217   import sys
 218   main(sys.argv)
 219