26 

    27 import shutil

    28 import tempfile

    38 from logilab.common.fileutils import ensure_fs_mode

    39 from logilab.common.shellutils import find

    43 from cubicweb.i18n import extract_from_tal, execute2

    50 

    51 

    52 __docformat__ = "restructuredtext en"

   442 

   443 class I18nCubeMessageExtractor(object):

   444     """This class encapsulates all the xgettext extraction logic

   445 

   446     ``generate_pot_file`` is the main entry point called by the ``i18ncube``

   447     command. A cube might decide to customize extractors to ignore a given

   448     directory or to extract messages from a new file type (e.g. .jinja2 files)

   449 

   450     For each file type, the class must define two methods:

   451 

   452     - ``collect_{filetype}()`` that must return the list of files

   453       xgettext should inspect,

   454 

   455     - ``extract_{filetype}(files)`` that calls xgettext and returns the

   456       path to the generated ``pot`` file

   457     """

   458     blacklist = STD_BLACKLIST

   459     formats = ['tal', 'js', 'py']

   460 

   461     def __init__(self, workdir, cubedir):

   462         self.workdir = workdir

   463         self.cubedir = cubedir

   464 

   465     def generate_pot_file(self):

   466         """main entry point: return the generated ``cube.pot`` file

   467 

   468         This function first generates all the pot files (schema, tal,

   469         py, js) and then merges them in a single ``cube.pot`` that will

   470         be used to eventually update the ``i18n/*.po`` files.

   471         """

   472         potfiles = self.generate_pot_files()

   473         potfile = osp.join(self.workdir, 'cube.pot')

   474         print('-> merging %i .pot files' % len(potfiles))

   475         cmd = ['msgcat', '-o', potfile]

   476         cmd.extend(potfiles)

   477         execute2(cmd)

   478         return potfile if osp.exists(potfile) else None

   479 

   480     def find(self, exts, blacklist=None):

   481         """collect files with extensions ``exts`` in the cube directory

   482         """

   483         if blacklist is None:

   484             blacklist = self.blacklist

   485         return find(self.cubedir, exts, blacklist=blacklist)

   486 

   487     def generate_pot_files(self):

   488         """generate and return the list of all ``pot`` files for the cube

   489 

   490         - static-messages.pot,

   491         - schema.pot,

   492         - one ``pot`` file for each inspected format (.py, .js, etc.)

   493         """

   494         print('-> extracting messages:', end=' ')

   495         potfiles = []

   496         # static messages

   497         if osp.exists(osp.join('i18n', 'entities.pot')):

   498             warn('entities.pot is deprecated, rename file '

   499                  'to static-messages.pot (%s)'

   500                  % osp.join('i18n', 'entities.pot'), DeprecationWarning)

   501             potfiles.append(osp.join('i18n', 'entities.pot'))

   502         elif osp.exists(osp.join('i18n', 'static-messages.pot')):

   503             potfiles.append(osp.join('i18n', 'static-messages.pot'))

   504         # messages from schema

   505         potfiles.append(self.schemapot())

   506         # messages from sourcecode

   507         for fmt in self.formats:

   508             collector = getattr(self, 'collect_{0}'.format(fmt))

   509             extractor = getattr(self, 'extract_{0}'.format(fmt))

   510             files = collector()

   511             if files:

   512                 potfile = extractor(files)

   513                 if potfile:

   514                     potfiles.append(potfile)

   515         return potfiles

   516 

   517     def schemapot(self):

   518         """generate the ``schema.pot`` file"""

   519         schemapot = osp.join(self.workdir, 'schema.pot')

   520         print('schema', end=' ')

   521         # explicit close necessary else the file may not be yet flushed when

   522         # we'll using it below

   523         schemapotstream = open(schemapot, 'w')

   524         generate_schema_pot(schemapotstream.write, self.cubedir)

   525         schemapotstream.close()

   526         return schemapot

   527 

   528     def _xgettext(self, files, output, k='_', extraopts=''):

   529         """shortcut to execute the xgettext command and return output file

   530         """

   531         tmppotfile = osp.join(self.workdir, output)

   532         cmd = ['xgettext', '--no-location', '--omit-header', '-k' + k,

   533                '-o', tmppotfile] + extraopts.split() + files

   534         execute2(cmd)

   535         if osp.exists(tmppotfile):

   536             return tmppotfile

   537 

   538     def collect_tal(self):

   539         print('TAL', end=' ')

   540         return self.find(('.py', '.pt'))

   541 

   542     def extract_tal(self, files):

   543         tali18nfile = osp.join(self.workdir, 'tali18n.py')

   544         extract_from_tal(files, tali18nfile)

   545         return self._xgettext(files, output='tal.pot')

   546 

   547     def collect_js(self):

   548         print('Javascript')

   549         return [jsfile for jsfile in self.find('.js')

   550                 if osp.basename(jsfile).startswith('cub')]

   551 

   552     def extract_js(self, files):

   553         return self._xgettext(files, output='js.pot',

   554                               extraopts='-L java --from-code=utf-8')

   555 

   556     def collect_py(self):

   557         print('-> creating cube-specific catalog')

   558         return self.find('.py')

   559 

   560     def extract_py(self, files):

   561         return self._xgettext(files, output='py.pot')

   562 

   563