from optparse import Option, OptionParser, _match_abbrev

# This case-insensitive option parser relies on having a
# case-insensitive dictionary type available.  Here's one
# for Python 2.2.  Note that a *real* case-insensitive
# dictionary type would also have to implement __new__(),
# update(), and setdefault() -- but that's not the point
# of this exercise.

class caseless_dict (dict):
   def __setitem__ (self, key, value):
       dict.__setitem__(self, key.lower(), value)

   def __getitem__ (self, key):
       return dict.__getitem__(self, key.lower())

   def get (self, key, default=None):
       return dict.get(self, key.lower())

   def has_key (self, key):
       return dict.has_key(self, key.lower())


class CaselessOptionParser (OptionParser):

   def _create_option_list (self):
       self.option_list = []
       self._short_opt = caseless_dict()
       self._long_opt = caseless_dict()
       self._long_opts = []
       self.defaults = {}

   def _match_long_opt (self, opt):
       return _match_abbrev(opt.lower(), self._long_opt.keys())


if __name__ == "__main__":
   from optik.errors import OptionConflictError

   # test 1: no options to start with
   parser = CaselessOptionParser()
   try:
       parser.add_option("-H", dest="blah")
   except OptionConflictError:
       print "ok: got OptionConflictError for -H"
   else:
       print "not ok: no conflict between -h and -H"

   parser.add_option("-f", "--file", dest="file")
   #print repr(parser.get_option("-f"))
   #print repr(parser.get_option("-F"))
   #print repr(parser.get_option("--file"))
   #print repr(parser.get_option("--fIlE"))
   (options, args) = parser.parse_args(["--FiLe", "foo"])
   assert options.file == "foo", options.file
   print "ok: case insensitive long options work"

   (options, args) = parser.parse_args(["-F", "bar"])
   assert options.file == "bar", options.file
   print "ok: case insensitive short options work"