split-tree.py

   1 #!/usr/bin/env python
   2
   3 import os, re, shutil
   4
   5 def mkdirhier(dirname):
   6     print dirname
   7     os.system("mkdir -p %s" % dirname)
   8
   9 def try_make_dir(dirname):
  10     """
  11     Not yet a mkdirhier and not handling exception and not
  12     testing if that file is really a dir...
  13     """
  14     if os.path.exists(dirname):
  15         return
  16     os.mkdir(dirname)
  17
  18 def module_dir_name(module_name):
  19     return module_name.replace('_', '-')
  20
  21 def package_dir_name(module_name, package_suffix):
  22     base_name = module_dir_name(module_name)
  23     dir_name = "%s-%s" % (base_name, package_suffix)
  24     return os.path.join(base_name, dir_name)
  25
  26 def expand(base, name):
  27     return base.replace("${PN}", name)
  28
  29 def prepare_qtopia_tree(modules):
  30     """
  31     Create directories for the modules under the current working directory.
  32     """
  33     for (module_name, module) in modules:
  34         base_name = module_dir_name(module_name)
  35         try_make_dir(base_name)
  36         for package_name in module.keys():
  37             dir = package_dir_name(module_name, package_name)
  38             try_make_dir(dir)
  39             os.system("cd %s; git-init" % dir)
  40             os.system("cd %s; rm -rf *" % dir)
  41
  42
  43 def copy_qtopia_tree(modules, source_tree):
  44     """
  45     For every package copy the files given in the dir glob of the package
  46     from the source_tree to the new location.
  47     We substitute variables like ${PN} with the current package name, copy some
  48     default files (e.g. license and build system boilerplate) into the package.
  49
  50     We return a list of filenames relative to the source_tree that we have used
  51     to fill the package. We do not move from the source_tree for two reasons:
  52         1.) Two packages might need the same file
  53         2.) We might want to split the tree more than once
  54     """
  55     handled_files = {}
  56
  57     for (module_name, module) in modules:
  58         base_name = module_dir_name(module_name)
  59         try_make_dir(base_name)
  60         for package_name in module.keys():
  61             package_module = module[package_name]
  62             assert "dir" in package_module
  63
  64             if type(package_module["dir"]) == type([]):
  65                 source_dirs = package_module["dir"]
  66             else:
  67                 source_dirs = [package_module["dir"]]
  68
  69             # Copy all matching dirs to the destination
  70             dir_name = package_dir_name(module_name, package_name)
  71             for source_dir in source_dirs:
  72                 source_path = expand(source_dir, package_name)
  73                 source_exp = re.compile(source_path)
  74
  75                 found = False
  76                 for root, dirs, files in os.walk(source_tree):
  77                     if (source_path in root and (root.endswith(source_path) or root[root.find(source_path)+len(source_path)] == '/')) or \
  78                        ("regexp" in package_module and source_exp.search(root)):
  79                         found = True
  80                         try_make_dir(os.path.join(dir_name, "src"))
  81
  82                         base_path = root[root.find(source_path)+len(source_path)+1:]
  83
  84                         for dir in dirs:
  85                             try_make_dir(os.path.join(dir_name, base_path, dir))
  86                             try_make_dir(os.path.join(dir_name, "src", base_path, dir))
  87                         for file in files:
  88                             source_file = os.path.join(root, file)
  89                             (_, extension) = os.path.splitext(file)
  90                             file_name = file
  91                             if not "nosrc" in package_module and extension in [".cpp", ".c", ".h", ".ui", ".rc"]:
  92                                 file_name = os.path.join("src", file)
  93                                 destination_file = os.path.join(dir_name, "src", base_path, file)
  94                             elif extension in [".pro", ".pri"]:
  95                                 continue
  96                             else:
  97                                 destination_file = os.path.join(dir_name, base_path, file)
  98
  99                             handled_files[source_file] = 1
 100                             shutil.copyfile(source_file, destination_file)
 101
 102                 if not found:
 103                     print "Not found", dir_name, source_path
 104
 105             # Copy specific files
 106             if "files" in package_module:
 107                 for root, dirs, files in os.walk(source_tree):
 108                     for package_file in package_module["files"]:
 109                         file_glob = re.compile(expand(package_file, package_name))
 110                         for file in files:
 111                             path = os.path.join(root, file)
 112                             search = file_glob.search(path)
 113                             if search:
 114                                 print "Copying", path, dir_name
 115                                 new_path = os.path.join(dir_name, path[search.start()+1:])
 116                                 mkdirhier(os.path.dirname(new_path))
 117                                 shutil.copyfile(path, new_path)
 118                                 handled_files[path] = 1
 119
 120
 121     return handled_files
 122
 123 def patch_packages(modules):
 124     """
 125     Enrich the newly build packages with some more data or apply
 126     patches to them.
 127     """
 128     pass
 129
 130
 131 def verify_tree(touched_files, source_tree, files_to_ignore):
 132     """
 133     Compare which files we have touched with the ones available in the source tree
 134     """
 135     for root, dirs, files in os.walk(source_tree):
 136         for file in files:
 137             path = os.path.join(root, file)
 138             (_, extension) = os.path.splitext(file)
 139             if extension in [".pro", ".pri"]:
 140                 continue
 141             elif "qtopiacore/qt" in path:
 142                 continue
 143             if not path in touched_files:
 144                 found = False
 145                 for ignore in files_to_ignore:
 146                     if re.search(ignore, path):
 147                         found = True
 148
 149                 if not found:
 150                     print "Not handled the following file: '%s'" % path
 151
 152 def tar_packages(modules):
 153     """
 154     Tar all directories up so they can be put somewhere or imported into git.
 155     """
 156     for (module_name, module) in modules:
 157         for package_name in module.keys():
 158             dir = package_dir_name(module_name, package_name)
 159             os.system("cd %s; git-add *" % dir)
 160             os.system("cd %s; git-commit -a -m 'Updated the source tree'" % dir)
 161             ### use git-archive
 162
 163 def main(argv):
 164     import optparse
 165     parser = optparse.OptionParser(version="Qtopia Split Tree 0.1",
 166                                    usage = """%prog [options]
 167
 168 Split up a given Qtopia Source tree into smaller chunks and enrich them
 169 with patches and an alternative buildsystem
 170 """)
 171
 172     parser.add_option("-s", "--source", help="The Qtopia Source Tree", action="store", dest="source", default=None)
 173     options, args = parser.parse_args(argv)
 174
 175     if not options.source:
 176         print "You need to specify a Qtopia Source tree"
 177         sys.exit(-1)
 178
 179     # Now start to do the work
 180     # 1.) prepare
 181     # 2.) copy around
 182     # 3.) patch
 183     # 4.) Remove the copied files
 184     # 5.) check what is left and complain
 185     # 6.) tar them up?
 186     import config
 187
 188     modules = [(x,getattr(config,x)) for x in dir(config) if x.startswith('qtopia_')]
 189     prepare_qtopia_tree(modules)
 190     used_files = copy_qtopia_tree(modules, options.source)
 191     patch_packages(modules)
 192     verify_tree(used_files, options.source, config.IGNORE_LIST)
 193     tar_packages(modules)
 194
 195
 196 if __name__ == "__main__":
 197     import sys
 198     main(sys.argv)