support define_macros / undef_macros in setup.cfg

Lib/packaging/command/install_distinfo.py

 """Create the PEP 376-compliant .dist-info directory."""
 
 # Forked from the former install_egg_info command by Josip Djolonga
 
 import os
 import csv
 import hashlib
 from shutil import rmtree
 
 from packaging import logger
@@ skipping 18 matching lines @@
         ('no-resources', None,
          "do not generate a RESOURCES file"),
     ]
 
     boolean_options = ['requested', 'no-record', 'no-resources']
 
     negative_opt = {'no-requested': 'requested'}
 
     def initialize_options(self):
         self.install_dir = None
+        self.install_base = None
         self.installer = None
         self.requested = None
         self.no_record = None
         self.no_resources = None
         self.outfiles = []
 
     def finalize_options(self):
         self.set_undefined_options('install_dist',
-                                   'installer', 'requested', 'no_record')
+                                   'installer', 'requested', 'no_record', 'install_base')
 
         self.set_undefined_options('install_lib', 'install_dir')
 
         if self.installer is None:
             # FIXME distutils or packaging?
             # + document default in the option help text above and in install
             self.installer = 'distutils'
         if self.requested is None:
             self.requested = True
         if self.no_record is None:
             self.no_record = False
         if self.no_resources is None:
             self.no_resources = False
 
         metadata = self.distribution.metadata
 
         basename = metadata.get_fullname(filesafe=True) + ".dist-info"
 
-        self.install_dir = os.path.join(self.install_dir, basename)
-
+        self.distinfo_dir = os.path.join(self.install_dir, basename)
+        
+    @staticmethod
+    def pep376path(fpath, install_base, install_dir):
+        """Return PEP-376 path (but always with platform path separators)"""        
+        if install_base is None: # needed for unit tests
+            return install_dir
+        # install_base is 'prefix' from PEP-376
+        install_base = install_base.rstrip(os.path.sep) + os.path.sep
+        # install_dir is 'base location' from PEP-376
+        install_dir = install_dir.rstrip(os.path.sep) + os.path.sep                        
+        install_dir_in_base = install_dir.startswith(install_base)
+        if fpath.startswith(install_dir) or \
+            fpath.startswith(install_base) and install_dir_in_base:
+            rpath = os.path.relpath(fpath, install_dir)
+        else:
+            rpath = os.path.abspath(fpath)
+        return rpath
+                        
     def run(self):
-        target = self.install_dir
+        target = self.distinfo_dir
 
         if os.path.isdir(target) and not os.path.islink(target):
             if not self.dry_run:
                 rmtree(target)
         elif os.path.exists(target):
-            self.execute(os.unlink, (self.install_dir,),
+            self.execute(os.unlink, (self.distinfo_dir,),
                          "removing " + target)
 
         self.execute(os.makedirs, (target,), "creating " + target)
+        
+        if not self.dry_run:
+            install_data = self.get_finalized_command('install_data')
+            while install_data.extra_dist_info:
+                install_data.extra_dist_info.pop()()
 
-        metadata_path = os.path.join(self.install_dir, 'METADATA')
+        metadata_path = os.path.join(self.distinfo_dir, 'METADATA')
         self.execute(self.distribution.metadata.write, (metadata_path,),
                      "creating " + metadata_path)
         self.outfiles.append(metadata_path)
 
-        installer_path = os.path.join(self.install_dir, 'INSTALLER')
+        installer_path = os.path.join(self.distinfo_dir, 'INSTALLER')
         logger.info('creating %s', installer_path)
         if not self.dry_run:
             with open(installer_path, 'w') as f:
                 f.write(self.installer)
         self.outfiles.append(installer_path)
 
         if self.requested:
-            requested_path = os.path.join(self.install_dir, 'REQUESTED')
+            requested_path = os.path.join(self.distinfo_dir, 'REQUESTED')
             logger.info('creating %s', requested_path)
             if not self.dry_run:
                 open(requested_path, 'wb').close()
             self.outfiles.append(requested_path)
 
         if not self.no_resources:
             install_data = self.get_finalized_command('install_data')
             if install_data.get_resources_out() != []:
-                resources_path = os.path.join(self.install_dir,
+                resources_path = os.path.join(self.distinfo_dir,
                                               'RESOURCES')
                 logger.info('creating %s', resources_path)
                 if not self.dry_run:
                     with open(resources_path, 'w') as f:
                         writer = csv.writer(f, delimiter=',',
                                             lineterminator='\n',
                                             quotechar='"')
                         for row in install_data.get_resources_out():
                             writer.writerow(row)
 
                 self.outfiles.append(resources_path)
 
         if not self.no_record:
-            record_path = os.path.join(self.install_dir, 'RECORD')
+            record_path = os.path.join(self.distinfo_dir, 'RECORD')
             logger.info('creating %s', record_path)
             if not self.dry_run:
                 with open(record_path, 'w', encoding='utf-8') as f:
                     writer = csv.writer(f, delimiter=',',
                                         lineterminator='\n',
                                         quotechar='"')
 
-                    install = self.get_finalized_command('install_dist')
+                    install = self.get_finalized_command('install_dist')                    
 
                     for fpath in install.get_outputs():
+                        rpath = self.pep376path(fpath, self.install_base, self.install_dir)
                         if fpath.endswith('.pyc') or fpath.endswith('.pyo'):
                             # do not put size and md5 hash, as in PEP-376
-                            writer.writerow((fpath, '', ''))
+                            writer.writerow((rpath, '', ''))
                         else:
                             size = os.path.getsize(fpath)
                             with open(fpath, 'rb') as fp:
                                 hash = hashlib.md5()
                                 hash.update(fp.read())
                             md5sum = hash.hexdigest()
-                            writer.writerow((fpath, md5sum, size))
+                            writer.writerow((rpath, md5sum, size))
 
                     # add the RECORD file itself
-                    writer.writerow((record_path, '', ''))
+                    writer.writerow((self.pep376path(record_path, self.install_base, self.install_dir), '', ''))
             self.outfiles.append(record_path)
 
     def get_outputs(self):
         return self.outfiles