def embed(): """Embed the required modules in the current project.""" # select the libraries tm = None ms = [] for m in sys.modules.values(): try: if m != None: if m.__name__ == "maat": tm = m ms.append(m) elif m.__name__.startswith("maat."): ms.append(m) except AttributeError: pass # get maat directory mpath = common.Path(env.top.path) / "maat" # copy the modules for m in ms: p = m.__file__ if p.endswith(".pyc"): p = p[:-1] lowlevel.copy(common.Path(p), mpath)
def copy(frm, to, filter = common.Filter()): """Perform a copy of a file or a recursive copy of a directory.""" makedir(to) try: if not frm.is_dir(): shutil.copyfile(str(frm), str(to / frm.get_file())) else: parent = frm.parent() for dir, dirs, files in os.walk(str(frm)): # create directory org_dpath = common.Path(dir) tgt_dpath = to / common.Path(dir).relative_to(parent) if not tgt_dpath.exists(): os.mkdir(str(tgt_dpath)) # copy files for file in files: org_fpath = org_dpath / file tgt_fpath = to / common.Path(dir).relative_to(parent) / file if filter.accept(org_fpath): shutil.copyfile(str(org_fpath), str(tgt_fpath)) # copy directories for d in dirs: org_path = org_dpath / d if not filter.accept(org_path): dirs.remove(d) except (IOError, OSError) as e: env.error(str(e))
def gen(dir, rext, dep): """Generate recipes to build res. A generation string is found between file src and res. Each intermediate file has for name the kernel of res (generated files will be put in the res directory). Returns the list of files to build (last file having rext as extension).""" dir = common.Path(dir) dep = common.Path(dep) # prepare the kernel b = dep.get_base() dext = dep.get_ext() n = b.get_file() kern = dir / n # initialize lookup process if not ext_db.has_key(dext): common.script_error("don't know how to build '%s' from '%s'" % (rext, dep)) #raise Common.MaatError("DEBUG:") ext = ext_db[dext] prev = dep # end when dep is found ress = [] while ext.ext != rext: gen = ext.gens[rext] next = kern + gen.res.ext gen.gen(next, prev) ress.append(next) prev = next ext = gen.res # return result return ress
def write(self, out): a = action.make_actions( self.fun([File(common.Path("*" + self.res.ext))], [File(common.Path("*" + self.dep.ext))])) cmds = [] a.commands(cmds) for c in cmds: out.write("\t%s\n" % c)
def set_env(e): global curenv global curdir env.cur = e curenv = e curdir = common.Path(e.path) e.path.set_cur()
def phony(goal, deps, *actions): """Build a goal with the following dependencies that does not match a real file.""" path = common.Path(env.cur.path) / goal file = get_file(str(path)) if file.recipe: common.script_error("a goal named '%s' already exist!" % goal) else: file.set_phony() return ActionRecipe(goal, deps, *actions).ress[0]
def test(self, ctx): self.perform(ctx) if self.dir != None: old_dir = os.getcwd() try: os.chdir(self.dir) except OSError as e: raise common.MaatError("cannot change to '%s': %s" % (self.dir, e)) if self.out: out = common.Path(self.out) maat.mkdir(str(out.parent())) out_stream = open(str(out), "w") else: out_stream = NULL if self.err: err = common.Path(self.err) maat.mkdir(str(err.parent())) err_stream = open(str(err), "w") else: err_stream = NULL if self.inp: in_stream = open(str(self.input), "r") else: in_stream = NULL cmd = action.make_line(self.args) if maat.verbose: ctx.print_info("running %s" % cmd) rc = subprocess.call(cmd, stdin=in_stream, stdout=out_stream, stderr=err_stream, shell=True) if self.check(rc): self.success(ctx) else: self.failure(ctx, "return code = %d, command = %s" % (rc, cmd)) if self.dir != None: os.chdir(old_dir)
def get_goal(path): """Get the goal matching the given path in the DB. Apply localization rules relative to a particular make.py if the path is not absolute. If the goal cannot be found, raise a MaatError.""" # apply localisation rule if not os.path.isabs(str(path)): fpath = env.cur.path / path else: fpath = common.Path(path) fpath = fpath.norm() # find the file if str(fpath) in file_db: return file_db[str(fpath)] else: raise common.MaatError("goal %s does not exist" % path)
def get_file(path): """Get the file matching the given path in the DB. Apply localization rules relative to a particular make.py if the path is not absolute.""" # apply localisation rule if not os.path.isabs(str(path)): path = env.cur.path / path else: path = common.Path(path) path = path.norm() # find the file if str(path) in file_db: return file_db[str(path)] else: return File(path)
def actual(self): """Get the actual path of the file. For target file, this path is relative to BPATH variable.""" if not self.actual_path: if not self.is_target: self.actual_path = self.path else: bpath = self["BPATH"] if not bpath: self.actual_path = self.path else: bpath = env.top.path / bpath bpath = common.Path(bpath) if self.path.prefixed_by(env.top.path): self.actual_path = bpath / self.path.relative_to( env.top.path) else: self.actual_path = bpath / self.path return self.actual_path
def path(p): """Convert simple string to Maat path.""" if p == None or isinstance(p, common.Path): return p else: return common.Path(str(p))
def suffix(p): """Get extension of a path or a list of paths.""" if isinstance(p, list): return [common.Path(x).get_ext() for x in p] else: return common.Path(p).get_ext()
def isdir(path): """Test if the given path is a directory.""" return common.Path(path).is_dir()
def join(a1, a2): """Join two parts of a file path.""" return common.Path(a1) / a2
def curdir(): """Get the current working directory.""" return common.Path(os.getcwd())
# This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. """Implementation of environment in Maat.""" import glob import os import os.path import sys import maat.common as common topdir = common.Path(os.getcwd()) # top directory def curdir(): """Get the current working directory.""" return common.Path(os.getcwd()) # environments class Env: """Base class of environments.""" path = "" name = "" def __init__(self, name, path=topdir): self.name = name
def push_env(self): """Install the environment to build the target.""" if self.target.recipe: maat.push_env(self.target.recipe.env) common.Path(self.target.recipe.cwd).set_cur()
def __init__(self, name, blocking=False, deps=[]): recipe.File.__init__(self, common.Path("config/%s" % name)) self.name = name self.blocking = blocking self.deps = [] self.result = None
def __init__(self, paths, target): self.paths = [common.Path(arg) for arg in args] self.target = common.Path(target)
def __init__(self, src, tgt): self.src = common.Path(src) self.tgt = common.Path(tgt)
def __init__(self, path, content): self.path = common.Path(path) self.content = str(content)