/**
 * Parse and replace (set) settings within settings.ini
 * Syntax of settings.ini, command = value, ; comment
 *
 * @author  reZo <reZo@rezolabs.com>
 * @license GNU GPL (latest version)
 */
 
class Settings {
 
   private:
      // settings map to store command / value
      std::map<std::string, std::string> settings;
      // input file descriptor
      std::ifstream iSettings;
      // output file descriptor
      std::ofstream oSettings;
      // filename
      std::string filename;
      void parse (std::string line);
 
   public:
      void load (std::string file);
      void set (std::string command, std::string value);
      std::string get (std::string command);
} Settings;
 
/**
 * Open file for parsing
 *
 * @param std::string file filename to open
 */
 
void Settings::load (std::string file) {
 
   std::string line;
   filename = file;
 
   iSettings.open (filename.data(), std::ios::in);
 
   if (!iSettings.is_open())
      return;
 
   while (!iSettings.eof()) {
      getline (iSettings, line);
      parse (line);
   }
 
   iSettings.close();
}
 
/**
 * Get value from settings map<std::string, std::string>
 *
 * @param  std::string commmand name of command of which value to return
 * @return std::string value
 */
 
std::string Settings::get (std::string command) {
 
   return settings[command];
}
 
/**
 * Use iterator object from map object to compare command index std::string
 *
 * @param std::string command holds command to change value of
 * @param std::string value   value command will be replaced with
 */
 
void Settings::set (std::string command, std::string value) {
 
   oSettings.open (filename.data(), std::ios::out);
 
   std::map<std::string, std::string>::iterator line;
 
   for (line = settings.begin(); line != settings.end(); line++) {
      if (((*line).first).compare(command) == 0)
         oSettings << command  << " = " << value;
      else
         oSettings << (*line).first << " = " << (*line).second << "\n";
   }
 
   settings[command] = value;
 
   oSettings.close();
}
 
/**
 * Parse command and value from @param std::string line into settings map<std::string,
 * std::string>
 *
 * @param std::string line the line to parse
 *
 * Uses ; for comment
 */
 
void Settings::parse (std::string line) {
 
   if (line.substr(0, 1).compare(";") == 0 || line.compare("") == 0)
      return;
 
   std::string command, value;
   std::string::size_type location;
 
   location = line.find (" = ", 0);
 
   if (location != std::string::npos) {
      command = line.substr(0, location);
      value = line.substr(location + 3, line.length());
   }
 
   settings[command] = value;
}

/**
 * CLI Argument Parser
 *
 * @author  reZo <reZo@rezolabs.com>
 * @license GNU General Public License
 * @version 14th April 2008
 *
 * @bug -k=v && --key=value accepts x{1,} = chars
 */
 
/**
 * Prototype's
 */
 
#ifdef win32
#define snprintf sprintf_s
#define strtok strtok_s
#endif
 
extern struct configuration configuration;
 
void argumentShort (char *key, char *value);
void argumentLong (char *key, char *value);
#ifdef WIN32
void argumentWin32 (char *key, char *value);
#endif
void argumentUsageAndHelp (const char *programName);
char *argumentGetKey (char *key);
char *argumentGetValue (char *key);
int arguments (int argc, char *argv[]);
 
/**
 * Send argv[i] && argv[i+1] off to there correct parser's
 */
 
int arguments (int argc, char *argv[]) {
 
   if (argc == 1)
      argumentUsageAndHelp(argv[0]);
 
   int i;
 
   for (i = 1; i < argc; i++) {
      char *current = (char*) malloc(sizeof(char*) * strlen(argv[i]));
      snprintf(current, strlen(argv[i]), "%s", argv[i]);
      if (*(current) == '-' && *(current+1) == '-')
         argumentLong(argv[i], argv[i+1]);
      else if (*(current) == '-' && *(current+1) != '-')
         argumentShort(argv[i], argv[i+1]);
#ifdef WIN32
      else if (*(current) == '/')
         argumentWin32(argv[i], argv[i+1]);
#endif
   }
 
   return 0;
}
 
/**
 * CLI usage and help
 */
 
void argumentUsageAndHelp (const char *programName) {
 
   fprintf(stderr, "usage: %s (options)\n\n", programName);
#ifdef WIN32
   fprintf(stderr, "Windows help\n");
#else
   fprintf(stderr, "Non Windows help\n");
#endif
   fprintf(stderr, "\nReport bugs to <reZo@rezolabs.com>\n");
 
   exit(-1);
}
 
#ifdef WIN32
 
/**
 * Parse windows style CLI argument's
 */
 
void argumentWin32 (char *key, char *value) {
 
   if (strlen(key) <= 1) {
      fprintf(stderr, "Invalid CLI argument length (win32).\n");
      exit(-1);
   }
 
   /**
    * Settings that do not require usage of value argument
    */
 
   if (strncmp(key, "/?", 2) && strlen(key) == 2 && value == NULL)
      printf("%s argument with no value, setting to default\n", key);
 
   if (value == NULL)
      return;
 
   /**
    * Settings that require usage of value argument
    */
 
   if (strncmp(key, "/example", 5) == 0 && strlen(key) == 8)
      printf("%s %s\n", key, value);
}
 
#endif
 
/**
 * Parse short unix style CLI argument's
 *
 * @accept -k
 *         -k value
 *         -k=value
 */
 
void argumentShort (char *key, char *value) {
 
   if (strlen(key) <= 1) {
      fprintf(stderr, "Invalid CLI argument length (short).\n");
      exit(-1);
   }
 
   /**
    * Settings that do not require usage of value argument
    */
 
   if (strncmp(key, "-e", 2) == 0 && strlen(key) == 2 && value == NULL)
      printf("%s argument with no value, setting to default\n", key);
 
   /**
    * Check if we're dealing with -k=value if value is NULL
    */
 
   if (value == NULL) {
      if (strchr(key, '=') != NULL) {
         value = argumentGetValue(key);
         key = argumentGetKey(key);
      }
      else return;
   }
 
   if (strncmp(key, "-e", 2) == 0 && strlen(key) == 2)
      printf("%s %s\n", key, value);
}
 
/**
 * Parse long unix style CLI argument's
 *
 * @accept --key
 *         --key value
 *         --key=value
 */
 
void argumentLong (char *key, char *value) {
 
   if (strlen(key) <= 2) {
      fprintf(stderr, "Invalid CLI argument length (long)\n");
      exit(-1);
   }
 
   /**
    * Settings that do not require usage of value argument
    */
 
   if (strncmp(key, "--example", 9) == 0 && strlen(key) == 9 && value == NULL)
      printf("%s with no value, setting to default\n", key);
 
   /**
    * Check if we're dealing with --key=value if value is NULL
    */
 
   if (value == NULL) {
      if (strchr(key, '=') != NULL) {
         value = argumentGetValue(key);
         key = argumentGetKey(key);
      }
      else
         return;
   }
 
   if (strncmp(key, "--example", 6) == 0 && strlen(key) == 6)
      printf("%s %s\n", key, value);
}
 
/**
 * Extract key from -k=value or --key=value syntax
 */
 
char *argumentGetKey (char *key) {
 
   return strtok(key, "=");
}
 
/**
 * Extract value from -k=value or --key=value syntax
 */
 
char *argumentGetValue (char *key) {
 
   char *value;
 
   value = strtok(key, "=");
   value = strtok(NULL, "=");
 
   return value;
}

#!/usr/bin/python
 
from optparse import OptionParser
from hashlib import md5
import sys, glob, os, re, MySQLdb, pysvn
 
class svnc:
 
   """
   set default arguments for CLI variables
   """
 
   def __init__ (self):
      self.options = False
      self.list = []
      self.parseCLI()
      self.db = {}
 
      # TODO get connection information from self.parseCLI() CLI args
      db = MySQLdb.connect(host   = 'localhost',
                           user   = 'svnc',
                           passwd = 'svnc',
                           db     = 'svnc')
 
      self.cursor = db.cursor()
 
   """
   parse CLI arguments
   # FIXME looping multiple times
   """
 
   def parseCLI (self):
      parser = OptionParser()
      parser.add_option_version = 'pre-alpha'
      parser.add_option('-d', '--daemon', dest='daemon', default=False, metavar='(yes|no)', help='run as daemon')
      parser.add_option('-c', '--checkout', dest='checkout', metavar='/path/to/checkout/', help='path to repository checkout')
      parser.add_option('-e', '--extensions', dest='extensions', metavar='ext,ext,...', help='extensions to check')
      parser.add_option('-u', '--username', dest='username', metavar='username', help='username for svn repository login')
      parser.add_option('-p', '--password', dest='password', metavar='password', help='password for svn repository login')
      parser.add_option('-q', '--quiet', dest='quiet', metavar='quiet', help='display nothing to stdout')
      (self.options, args) = parser.parse_args()
      try:
         self.options.extensions = self.options.extensions.split(',')
      except AttributeError:
         parser.print_help()
         sys.exit(1)
 
   """
   get value parsed from CLI
   """
 
   def get (self, key):
      return eval("self.options.%s" % key)
 
   def scan (self, path):
      files = []
      for i in os.listdir(path):
         name = os.path.join(path, i)
         if os.path.isfile('%s' % name):
            # check for extensions
            for extension in self.options.extensions:
               if  name[-2:] == extension:
                  files.append(name)
         elif os.path.isdir('%s' % name):
            for j in self.scan(name):
               files.append(j)
      return files
 
   """
   extract @commit comment from filename
   """
 
   def extract (self, filename):
      contents = open(filename).read()
      # regex @commit till and excluding n (raw for r)
      match = re.search(r"@commit(.*)", contents)
      if match:
         return { 'comment' : match.group(1).strip(), 'filename' : filename, 'hash' : md5(contents).hexdigest() }
 
   """
   checks for legit changes within self.list
   removes any non-legit files
   """
 
   def check (self, current):
 
      self.cursor.execute('SELECT hash, comment FROM svnc WHERE filename = "%s"' % current['filename'])
      client = pysvn.Client()
      row = self.cursor.fetchone()
 
      # add file to database
      if self.cursor.rowcount == 0 or row == None:
         print current['filename'], "not currently in database, adding."
         self.cursor.execute('INSERT INTO svnc (filename, hash, comment) VALUES ("%s", "%s", "%s")' % (current['filename'], current['hash'], current['comment']))
         # TODO before adding to svn repository, check if it already belongs to one
         #entry = client.info(current['filename'].rsplit("/", 1)[0])
         if client.add(current['filename']) == pysvn._pysvn_2_5.ClientError:
            print current['filename'], "does not belong to a SVN checkout."
            return
         return
 
      # return if there has been no comment changes
      if row[1] == current['comment']:
         return
 
      # replace new comment with old
      # check md5 checksum
      replacedChecksum = md5(re.sub('@commit %s' % current['comment'], '@commit %s' % row[1], open(current['filename'], 'r').read())).hexdigest()
      currentChecksum = md5(open(current['filename'], 'r').read()).hexdigest()
 
      if replacedChecksum != currentChecksum:
         print current['filename'], "has changed, commiting changes to SVN repository."
         self.cursor.execute('UPDATE svnc SET comment = "%s", hash = "%s" WHERE filename = "%s"' % (current['comment'], replacedChecksum, current['filename']))
         client.checkin([current['filename']], current['comment'])
 
# Let's run it!
sc = svnc
for i in sc().scan(sc().get("checkout")):
   if sc().extract(i) != None:
      sc().check(sc().extract(i))