addons_xml_generator.py

script_name = "repo_prep.py"
revision_number = 5
homepage = 'http://forum.xbmc.org/showthread.php?tid=129401'
script_credits = 'All code copyleft (GNU GPL v3) by Unobtanium @ XBMC Forums'

"""
Please bump the version number one decimal point and add your name to credits when making changes.

This is an:
- addons.xml generator
- addons.xml.md5 generator
- optional auto-compressor (including handling of icons, fanart and changelog)

Compression of addons in repositories has many benefits, including:
 - Protects addon downloads from corruption.
 - Smaller addon filesize resulting in faster downloads and less space / bandwidth used on the repository.
 - Ability to "roll back" addon updates in XBMC to previous versions.

To enable the auto-compressor, set the compress_addons setting to True
NOTE: the settings.py of repository aggregator will override this setting.
If you do this you must make sure the "datadir zip" parameter in the addon.xml of your repository file is set to "true".
"""
import os
import shutil
import md5
import zipfile
import re

########## SETTINGS
# Set whether you want your addons compressed or not. Values are True or False
# NOTE: the settings.py of repository aggregator will override this
#compress_addons = True
compress_addons = False

#Optional set a custom directory of where your addons are. False will use the current directory.
# NOTE: the settings.py of repository aggregator will override this
repo_root = False
########## End SETTINGS

# check if repo-prep.py is being run standalone or called from another python file
if __name__ == "__main__":  standalone = True
else: standalone = False

# this 'if' block adds support for the repo aggregator script
# set the repository's root folder here, if the script user has not set a custom path.      
if standalone:
            if repo_root == False: repo_root = os.getcwd()
            print script_name + '  v' + str(revision_number)
            print script_credits
            print 'Homepage and updates: ' + homepage
            print ' '
            
else:
            #so that we can import stuff from parent dir (settings)
            import sys
            sys.path.append('..')
            
            import settings
            repo_root = settings.aggregate_repo_path
            # use repository aggregator settings.py to determine whether to compress
            compress_addons = settings.compress_addons


def is_addon_dir( addon ):
    # this function is used by both classes.
    # very very simple and weak check that it is an addon dir.
    # intended to be fast, not totally accurate.
    # skip any file or .svn folder
    if not os.path.isdir( addon ) or addon == ".svn": return False
    else: return True

                    
class Generator:
    """
        Generates a new addons.xml file from each addons addon.xml file
        and a new addons.xml.md5 hash file. Must be run from the root of
        the checked-out repo. Only handles single depth folder structure.
    """
    def __init__( self ):
    
        #paths
        self.addons_xml = os.path.join( repo_root, "addons.xml" )
        self.addons_xml_md5 = os.path.join( repo_root, "addons.xml.md5" )

        # call master function
        self._generate_addons_files()

    def _generate_addons_files( self ):
        # addon list
        addons = os.listdir( repo_root )

        # final addons text
        addons_xml = u"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<addons>\n"

        found_an_addon = False
      
        # loop thru and add each addons addon.xml file
        for addon in addons:
            try:
                # skip any file or .svn folder
                if is_addon_dir( addon ):

                        # create path
                        _path = os.path.join( addon, "addon.xml" )

                        if os.path.exists(_path): found_an_addon = True

                        # split lines for stripping
                        xml_lines = open( _path, "r" ).read().splitlines()

                        # new addon
                        addon_xml = ""

                        # loop thru cleaning each line
                        for line in xml_lines:
                            # skip encoding format line
                            if ( line.find( "<?xml" ) >= 0 ): continue
                            # add line
                            addon_xml += unicode( line.rstrip() + "\n", "UTF-8" )

                        # we succeeded so add to our final addons.xml text
                        addons_xml += addon_xml.rstrip() + "\n\n"

            except Exception, e:
                # missing or poorly formatted addon.xml
                print "Excluding %s for %s" % ( _path, e, )

        # clean and add closing tag
        addons_xml = addons_xml.strip() + u"\n</addons>\n"

        # only generate files if we found an addon.xml
        if found_an_addon:
                    # save files
                    self._save_file( addons_xml.encode( "UTF-8" ), self.addons_xml )
                    self._generate_md5_file()
       
                    # notify user
                    print "Updated addons xml and addons.xml.md5 files"
        else: print "Could not find any addons, so script has done nothing."

        


    def _generate_md5_file( self ):
        try:
            # create a new md5 hash
            m = md5.new( open( self.addons_xml ).read() ).hexdigest()

            # save file
            self._save_file( m, self.addons_xml_md5 )

        except Exception, e:
            # oops
            print "An error occurred creating addons.xml.md5 file!\n%s" % ( e, )

    def _save_file( self, data, the_path ):
        try:
            
            # write data to the file
            open( the_path, "w" ).write( data )

        except Exception, e:
            # oops
            print "An error occurred saving %s file!\n%s" % ( the_path, e, )



class Compressor:

   def __init__( self ):
       # variables used later on
       self.addon_name = None
       self.addon_path = None
       self.addon_folder_contents = None
       self.addon_xml = None
       self.addon_version_number = None
       self.addon_zip_path = None

       # run the master method of the class, when class is initialised.
       # only do so if we want addons compressed.
       if compress_addons: self.master()

   def master( self ):
       mydir = os.listdir( repo_root )
       for addon in mydir:

               # set variables
               self.addon_name = str(addon)
               self.addon_path = os.path.join( repo_root, addon )
               
               # skip any file or .svn folder.
               if is_addon_dir( self.addon_path ):
                                  
                       # set another variable
                       self.addon_folder_contents = os.listdir( self.addon_path )

                       # check if addon has a current zipped release in it.
                       addon_zip_exists = self._get_zipped_addon_path()

                       # checking for addon.xml and try reading it.
                       addon_xml_exists = self._read_addon_xml()

                       # generator class relies on addon.xml being in release folder. so if need be, fix a zipped addon release folder lacking an addon.xml
                       if addon_zip_exists:
                               if not addon_xml_exists:
                                       # extract the addon_xml from the zip archive into the addon release folder.
                                       self._extract_addon_xml_to_release_folder()

                       else:
                               if addon_xml_exists:
                                       # now addon.xml has been read, scrape version number from it. we need this when naming the zip (and if it exists the changelog)
                                       self._read_version_number()
                                       print 'Create compressed addon release for -- ' + self.addon_name + '  v' + self.addon_version_number
                                       self._create_compressed_addon_release()

   def _get_zipped_addon_path( self ):
       # get name of addon zip file. returns False if not found.
       for the_file in self.addon_folder_contents:
           if '.zip' in the_file:
                   if ( self.addon_name + '-') in the_file:
                           self.addon_zip_path = os.path.join ( self.addon_path, the_file )
                           return True
       # if loop is not broken by returning the addon path, zip was not found so return False
       self.addon_zip_path = None
       return False
    
   def _extract_addon_xml_to_release_folder():
           the_zip = zipfile.ZipFile( self.addon_zip_path, 'r' )
           for filename in the_zip.namelist():
                        if filename.find('addon.xml'):
                                the_zip.extract( filename, self.addon_path )
                                break
                        
   def _recursive_zipper( self, dir, zip_file ):
            #initialize zipping module
            zip = zipfile.ZipFile( zip_file, 'w', compression=zipfile.ZIP_DEFLATED )

            # get length of characters of what we will use as the root path       
            root_len = len( os.path.dirname(os.path.abspath(dir))   )

            #recursive writer
            for root, dirs, files in os.walk(dir):

                    # subtract the source file's root from the archive root - ie. make /Users/me/desktop/zipme.txt into just /zipme.txt 
                    archive_root = os.path.abspath(root)[root_len:]

                    for f in files:
                            fullpath = os.path.join( root, f )
                            archive_name = os.path.join( archive_root, f )
                            zip.write( fullpath, archive_name, zipfile.ZIP_DEFLATED )
            zip.close()
                   
   def _create_compressed_addon_release( self ):
       # create a zip of the addon into repo root directory, tagging it with '-x.x.x' release number scraped from addon.xml
       zipname = self.addon_name + '-' + self.addon_version_number + '.zip'
       zippath = os.path.join( repo_root, zipname )

       # zip full directories
       self._recursive_zipper( self.addon_path , zippath ) 

       # now move the zip into the addon folder, which we will now treat as the 'addon release directory'
       os.rename( zippath, os.path.join( self.addon_path, zipname ) )
      
       # in the addon release directory, delete every file apart from addon.xml, changelog, fanart, icon and the zip we just constructed. also rename changelog.
       for the_file in self.addon_folder_contents:
           
              the_path = os.path.join( self.addon_path, the_file )

              # delete directories
              if not os.path.isfile( the_path ):
                      shutil.rmtree( the_path )

              # list of files we specifically need to retain for the addon release folder (folder containing the zip                     
              elif not ( ('addon.xml' in the_file) or ('hangelog' in the_file) or ('fanart' in the_file) or ('icon' in the_file) or (zipname in the_file)):
                      os.remove( the_path )

               # tag the changelog with '-x.x.x' release number
              elif 'hangelog' in the_file: # hangelog so that it is detected irrespective of whether C is capitalised
                       changelog = 'changelog-' + self.addon_version_number + '.txt'
                       os.rename( the_path, os.path.join( self.addon_path, changelog ) )
    
   def _read_addon_xml( self ):
      # check for addon.xml and try and read it.
      addon_xml_path = os.path.join( self.addon_path, 'addon.xml' )
      if os.path.exists( addon_xml_path ):
                         
                    # load whole text into string
                    f = open( addon_xml_path, "r") 
                    self.addon_xml = f.read()
                    f.close()

                    # return True if we found and read the addon.xml 
                    return True
      # return False if we couldn't  find the addon.xml 
      else: return False

   def _read_version_number( self ):
      # find the header of the addon.
      headers = re.compile( "\<addon id\=(.+?)>", re.DOTALL ).findall( self.addon_xml )

      for header in headers:

          #if this is the header for the addon, proceed
          if self.addon_name in header:
                              # clean line of quotation characters so that it is easier to read.
                              header = re.sub( '"','', header )
                              header = re.sub( "'",'', header )
                              
                              # scrape the version number from the line
                              self.addon_version_number = (( re.compile( "version\=(.+?) " , re.DOTALL ).findall( header ) )[0]).strip()
              


def execute():
    Compressor()
    Generator()
    
# standalone is equivalent of if name == main   
if standalone: execute()