Implement Patsub ${x/pat/replace} and strip ops ${x#prefix}, etc.

There are two strategies, depending on the pattern.

1) Fixed strings use Python's string methods, e.g.
startswith/endswith/replace/slice.

2) Glob patterns are converted to Python regexes.  (Character classes
aren't currently supported.)

Then we use the regex engine for position information and
greedy/non-greedy matches.

Also:

- Added tests.
- Fix parsing.
- TODO: Unicode

Addresses issue #26.

core/glob_.py

@@ -3,6 +3,8 @@
glob_.py
"""

import re

import libc

from core.util import log
@@ -55,56 +57,88 @@ def GlobEscape(s):
  return escaped


def GlobToExtendedRegex(g):
  """Convert a glob to a libc extended regexp.
# We need to handle glob patterns, but fnmatch doesn't give you the positions
# of matches.  So we convert globs to regexps.

  For ${s//pat*/__}.
# There are two regex engines we can use.  Each has advantages and
# disadvantages:

  We need to use regcomp/regex because fnmatch doesn't give you the positions
  of matches.
# Python regex:
# - Supports Greedy vs. Non-greedy (necessary for strip ops, but not patsub)
# - Doesn't rely on global variables for unicode.  I think libc string
#   functions use LOCALE?

# ERE:
# - Linear time algorithm
# - Save code space
# - Supports the same character classes as glob.

  Why not use Python?  To avoid backtracking?  I think we should just Python
  here.  Because we want Unicode to be consistent too.
  
  What other string ops are there?

def GlobToExtendedRegex(g):
  """Convert a glob to a libc extended regexp.

  Returns:
    A ERE string, or None if it's the pattern is a constant string rather than
    a glob.
  """
  # NOTE: character classes are retained literally, since EREs have the same
  # char class syntax?
  # Could be used for ${s//pat*/__}, but NOT # ## % %%.
  # We'll use Python everywhere for simplicity.
  raise NotImplementedError


def GlobToPythonRegex(g, longest=True):
def GlobToPythonRegex(s, greedy=True):
  """Convert a glob to a libc extended regexp.

  Args:
    longest: whether * should be '.*' (greedy) or '.*?' (non-greedy)

  We need Python's engine for greedy and non-greedy matches.  libc doesn't have
  that.

  For string ops like ${s#'*b'}
    greedy: whether * should be '.*' (greedy) or '.*?' (non-greedy)

  NOTE: character classes aren't supported.

  Returns:
    A Python regex string, or None if it's the pattern is a constant string
    rather than a glob.

    regex, err?
  """
  return None
  # TODO:
  # - Iterate through each characater
  # - Check for escapes
  # - If it 

  if longest:
    pass
  star_pat = '.*' if greedy else '.*?'

  is_glob = False
  err = None

  i = 0
  n = len(s)
  out = []
  while i < n:
    c = s[i]
    if c == '\\':  # glob escape like \* or \?
      i += 1
      out.append(s[i])
    elif c == '*':
      is_glob = True
      out.append(star_pat)
    elif c == '?':
      is_glob = True
      out.append('.')
    # TODO: Should we enter a different state and parse these?
    elif c == '[':
      err = True  # TODO: better error
      break
    elif c == ']':
      err = True
    else:
      # e.g. . -> \.
      out.append(re.escape(c))

    i += 1

  if err:
    return None, err
  else:
    pass
  return '^' + '$'
    if is_glob:
      regex = ''.join(out)
    else:
      regex = None
    return regex, err


def _GlobUnescape(s):  # used by cmd_exec

core/glob_test.py

@@ -77,12 +77,35 @@ def testPatSubRegexes(self):
    # x=~/git/oil
    # ${x//git*/X/}

    # NOTE: This should be regcomp
    r = re.compile('(^.*)git.*(.*)')

    result = r.sub(r'\1' + 'X' + r'\2', '~/git/oil')
    # git*
    r1 = re.compile('git.*')
    result = r1.sub('X', '~/git/oil')
    self.assertEqual('~/X', result)

    r2 = re.compile('[a-z]')
    result = r2.sub('X', 'a-b-c')
    self.assertEqual('X-X-X', result)

    # Substitute the first one only
    r2 = re.compile('[a-z]')
    result = r2.sub('X', 'a-b-c', count=1)
    self.assertEqual('X-b-c', result)

  def testGlobToPythonRegex(self):
    CASES = [
        # glob input, (regex, err)
        ('*.py', '.*\.py', None),
        ('*.?', '.*\..', None),
        ('abc', None, None),
        ('[[:space:]]', None, True),
    ]
    for glob, expected_regex, expected_err in CASES:
      regex, err = glob_.GlobToPythonRegex(glob)
      self.assertEqual(expected_regex, regex,
          '%s: expected %r, got %r' % (glob, expected_regex, regex))
      self.assertEqual(expected_err, err,
          '%s: expected %r, got %r' % (glob, expected_err, err))

  def testPatSubRegexesLibc(self):
    r = libc.regex_parse('^(.*)git.*(.*)')
    print(r)
@@ -94,8 +117,5 @@ def testPatSubRegexesLibc(self):
    # We have to keep advancing the string until there are no more matches.





if __name__ == '__main__':
  unittest.main()