MakeItSo: makeitso/makeitso.py comparison

comparison makeitso/makeitso.py @ 34:46c2d0a7335a

continued refactor to have template classes

author	Jeff Hammel <jhammel@mozilla.com>
date	Sat, 01 Jan 2011 21:21:53 -0800
parents	190f310f2f5e
children	7e47ff4b0cd3

comparison

equal deleted inserted replaced

-:190f310f2f5e
+:46c2d0a7335a
 # regular expressions for finding the shebang
 shebang_re = '#!.*makeitso.*'
 shebang_re = re.compile(shebang_re)
-def base_uri(uri):
+### URIs
+def parent_uri(uri):
+"""parent resource of a URI"""
 if '://' in uri:
-return 'uri'.rsplit('/', 1)[0] + '/'
+return uri.rsplit('/', 1)[0] + '/'
 else:
-here = os.path.dirname(os.path.abspath('me'))
+here = os.path.dirname(os.path.abspath(uri))
 here = here.rstrip(os.path.sep) + os.path.sep
 return here
+def basename(uri):
+"""return the basename of a URI"""
+if '://' in uri:
+return uri.rsplit('/', 1)[1]
+else:
+return os.path.basename(uri)
 def include(uri):
 f, headers = urllib.urlretrieve(uri)
 return file(f).read()
 ### things that deal with variables
-# XXX duplicated in URITemplate namespace....don't need two
-defaults = {'include': include}
 class MissingVariablesException(Exception):
 """exception for (non-interactive) missing variables"""
-def __init__(self, message, missing):
+def __init__(self, missing):
 self.missing = missing
+message = 'Missing variables: %s' % ', '.join(missing)
+Exception.__init__(self, message)
 def get_missing(name_error):
 """
 This is a horrible hack because python doesn't do the proper thing
 via eval and return the name of the variable;  instead, it just gives
 ### template classes
 class ContentTemplate(tempita.Template):
 """MakeItSo's extension of tempita's Template class"""
 defaults = {'include': include}
-def __init__(self, content, interactive=True):
-tempita.Template.__init__(self, content)
+def __init__(self, content, name=None, interactive=True, **variables):
+# default variables
+self.defaults = self.__class__.defaults.copy()
+self.defaults.update(variables)
 # TODO: automagically tell if the program is interactive or not
-self.interactive = True
+self.interactive = interactive
-raise NotImplementedError
+tempita.Template.__init__(self, content, name=name)
-class URITemplate(tempita.Template):
+def missing(self, **variables):
-def __init__(self, interactive=True):
+"""return additional variables needed"""
-raise NotImplementedError
+vars = variables.copy()
+missing = set([])
-class DirectoryTemplate(tempita.Template):
+while True:
-def __init__(self):
+try:
-raise NotImplementedError
+tempita.Template.substitute(self, **vars)
+return missing
-def missing_variables(template, variables):
+except NameError, e:
-"""return additional variables needed"""
+missed = get_missing(e)
-vars = variables.copy()
+missing.add(missed)
-missing = set([])
+vars[missed] = ''
-while True:
+return missing
-try:
-template.substitute(**vars)
+def variables(self):
-return missing
+"""return the variables needed for a template"""
-except NameError, e:
+return self.missing()
-missed = get_missing(e)
-missing.add(missed)
+def substitute(self, **variables):
-vars[missed] = ''
+"""interactive (for now) substitution"""
-return missing
+vars = self.defaults.copy()
+vars.update(variables)
-def template_variables(template):
+missing = self.missing(vars)
-"""return the variables needed for a template"""
+if missing:
-return missing_variables(template, {})
+if self.interactive:
+vars.update(self.read_variables(missing))
-def read_variables(variables):
+else:
-retval = {}
+raise MissingVariablesException(missing)
-for i in variables:
+self._substitute(**vars)
-print 'Enter %s: ' % i,
-retval[i] = raw_input()
+def _substitute(self, **variables):
-return retval
+return tempita.Template.substitute(self, **variables)
-### functions for substitution
+def read_variables(self, variables):
+"""read variables from stdin"""
-def substitute(content, variables=None):
+# TODO: variables should (optionally) be richer objects
-"""interactive (for now) substitution"""
+retval = {}
+for i in variables:
-# remove makeitso shebang if it has one
+print 'Enter %s: ' % i,
-if shebang_re.match(content):
+retval[i] = raw_input()
-content = os.linesep.join(content.splitlines()[1:])
+return retval
-variables = variables or defaults.copy()
-template = tempita.Template(content)
+class URITemplate(ContentTemplate):
-missing = missing_variables(template, variables)
+"""template for a file or URL"""
-if missing:
-# TODO: add a switch for interactive or not
+def __init__(self, uri, output=None, interactive=True, **variables):
-variables.update(read_variables(missing))
+self.output = output or sys.stdout
-return template.substitute(**variables)
+content = include(uri)
-def substitute_directory(directory, output=None, variables=None):
-# TODO: interpolate directory names
+# remove makeitso shebang if it has one
+if shebang_re.match(content):
-###
+content = os.linesep.join(content.splitlines()[1:])
+variables['here'] = parent_uri(uri)
+ContentTemplate.__init__(self, content, name=uri,
+interactive=interactive,
+**variables)
+def substitute(self, **variables):
+output = ContentTemplate.substitute(self, **variables)
+f = self.output
+if isinstance(f, basestring):
+if os.path.isdir(f):
+f = os.path.join(f, basename(self.name))
+f = file(f, 'w')
+print >> f, output
+class DirectoryTemplate(ContentTemplate):
+"""template for a directory structure"""
+def __init__(self, directory, output=None, interactive=True, **variables):
+"""
+- output : output directory; if None will render in place
+"""
+assert os.path.isdir(directory)
+self.name = directory
+self.interactive = interactive
+self.output = output
+if output is not None:
+if os.path.exists(output):
+assert os.path.isdir(output), "%s: Must be a directory" % self.name
+self.defaults = ContentTemplate.defaults.copy()
+self.defaults.update(variables)
+def missing(self, **variables):
+variables = variables.copy()
+missing = set([])
+for dirpath, dirnames, filenames in os.walk(self.name):
+# find variables from directory names
+for d in dirnames:
+missed = ContentTemplate(d).missing(**variables)
+missing.update(missed)
+variables.update(dict([(i, '') for i in missed]))
+# find variables from files
+for f in filenames:
+path = os.path.join(dirpath, f)
+template = URITemplate(path)
+missed = template.missing(**variables)
+missing.update(missed)
+variables.update(dict([(i, '') for i in missed]))
+return missing
+def _substitute(self, **variables):
+# make output directory if necessary
+output = self.output
+if output and not os.path.exists(output):
+os.makedirs(output)
+for dirname, dirnames, filenames in os.walk(self.name):
+# interpolate directory names
+for d in dirnames:
+path = os.path.join(dirname, interpolated)
+interpolated = ContentTemplate(path).substitute(**variables)
+if os.path.exists(interpolated):
+# ensure its a directory
+pass
+else:
+os.makedirs(interpolated)
+class PolyTemplate(ContentTemplate):
+"""
+template for several files/directories
+"""
+def __init__(self, templates, output=None, interactive=True, **variables):
+assert templates, "No templates given!"
+self.templates = []
+self.output = output
+for template in templates:
+if os.path.isdir(template):
+self.templates.append(DirectoryTemplate(template, output=output, **variables))
+else:
+self.templates.append(URITemplate(template, output=output, **variables))
+def missing(self, **variables):
+vars = variables.copy()
+missing = set([])
+for template in self.templates:
+missed = template.missing(**vars)
+missing.update(missed)
+vars.update(dict([(i, '') for i in missed]))
+return missing
+def _substitute(self, **variables):
+# determine where the hell to put these things
+if self.output is None:
+dirs = [i for i in templates if os.path.isdir(i)]
+if not ((len(dirs) == 0) or len(dirs) == len(templates)):
+raise AssertionError("Must specify output when mixing directories and URIs")
+# TODO: check for missing
+if len(self.templates) > 1 and not os.path.exists(self.output):
+os.makedirs(self.output)
+for template in self.templates:
+template.substitute(**variables)
+### command line stuff
 def invocation(url, **variables):
 """returns a string appropriate for TTW invocation"""
 variables_string = ' '.join(['%s=%s' % (i,j) for i,j in variables.items()])
 return 'python <(curl %s) %s %s' % (location, url, variables_string)
 help='starting delimeter')
 parser.add_option('-]', '--end-braces', dest='end_braces',
 help='starting delimeter')
 # options about where to put things
-parser.add_option('--in-place', dest='in_place',
-action='store_true', default=False,
-help='interpret files in place') # TODO: unused
 parser.add_option('-o', '--output', dest='output',
 help='where to put the output (filename or directory)')
-#
+# options for getting information
 parser.add_option('--commandline', dest='commandline',
 action='store_true', default=False,
 help="print the commandline to invoke this script TTW")
 parser.add_option('--variables', dest='variables',
 action='store_true', default=False,
 help='print the variables in a template')
 options, args = parser.parse_args(args)
 # print the variables for the templates
 if options.variables:
 if not args:
 parser.print_usage()
 parser.exit()
 # find all variables
-variables = set()
+template = PolyTemplate(templates=args)
-for arg in args:
+variables = template.variables()
-content = file(arg).read()
-template = tempita.Template(content)
-variables.update(template_variables(template))
 # print them
-for variable in variables:
+for variable in sorted(variables):
 print variable
 return
 # template variables
-variables = defaults.copy()
 _vars = []
 _args = []
 for arg in args:
 if '=' in arg:
 key, value = arg.split('=')
 print invocation('[URI]', **variables)
 return
 # get the content
 if args:
-for arg in args:
+template = PolyTemplate(templates=args,
-var_copy = variables.copy()
+output=options.output,
-var_copy['here'] = base_uri(arg)
+variables=variables)
-content = include(arg)
-print substitute(content, variables=var_copy)
 else:
+template = ContentTemplate(sys.stdin.read(), variables=variables)
 content = sys.stdin.read()
-print substitute(content, variables=variables)
 # cleanup
 cleanup()
 if __name__ == '__main__':

Mercurial > hg > MakeItSo

comparison makeitso/makeitso.py @ 34:46c2d0a7335a