X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=scripts%2Fconvert-ly.py;h=0cd473d456a1cf5fd86e8e972449319a9707226f;hb=b94ad43c250b87cf4ad352cc47e2f81692904ad3;hp=9c3ebeee831259632f5f265e13c39cb9b9032fd4;hpb=1bcd0c6e8f193767c6b4bd21db7e4f4a229a9029;p=lilypond.git diff --git a/scripts/convert-ly.py b/scripts/convert-ly.py index 9c3ebeee83..0cd473d456 100644 --- a/scripts/convert-ly.py +++ b/scripts/convert-ly.py @@ -1,130 +1,153 @@ #!@TARGET_PYTHON@ -# + # convert-ly.py -- Update old LilyPond input files (fix name?) +# converting rules are found in python/convertrules.py + +# This file is part of LilyPond, the GNU music typesetter. # -# source file of the GNU LilyPond music typesetter -# -# (c) 1998--2006 Han-Wen Nienhuys +# Copyright (C) 1998--2009 Han-Wen Nienhuys # Jan Nieuwenhuizen # -# converting rules are found in python/convertrules.py +# LilyPond is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# LilyPond 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 LilyPond. If not, see . import os import sys -import string import re - -datadir = '@local_lilypond_datadir@' -if not os.path.isdir (datadir): - datadir = '@lilypond_datadir@' - -sys.path.insert (0, os.path.join (datadir, 'python')) - -# dynamic relocation, for GUB binaries. -bindir = os.path.abspath (os.path.split (sys.argv[0])[0]) -for p in ['share', 'lib']: - datadir = os.path.abspath (bindir + '/../%s/lilypond/current/python/' % p) - sys.path.insert (0, datadir) +""" +@relocate-preamble@ +""" import lilylib as ly global _;_=ly._ -from convertrules import * +ly.require_python_version () + +import convertrules lilypond_version_re_str = '\\\\version *\"([0-9.]+)"' lilypond_version_re = re.compile (lilypond_version_re_str) -help_summary = _ ( -'''Update LilyPond input to newer version. By default, update from the -version taken from the \\version command, to the current LilyPond version. - -Examples: - - convert-ly -e old.ly - convert-ly --from=2.3.28 --to 2.5.21 foobar.ly +help_summary = ( +_ ('''Update LilyPond input to newer version. By default, update from the +version taken from the \\version command, to the current LilyPond version.''') ++ _ ("Examples:") ++ ''' + $ convert-ly -e old.ly + $ convert-ly --from=2.3.28 --to=2.5.21 foobar.ly > foobar-new.ly ''') copyright = ('Jan Nieuwenhuizen ', - 'Han-Wen Nienhuys ') + 'Han-Wen Nienhuys ') program_name = os.path.basename (sys.argv[0]) program_version = '@TOPLEVEL_VERSION@' -add_version = 1 +authors = ('Jan Nieuwenhuizen ', + 'Han-Wen Nienhuys ') + +error_file_write = ly.stderr_write def warning (s): - sys.stderr.write (program_name + ": " + _ ("warning: %s") % s + '\n') + ly.stderr_write (program_name + ": " + _ ("warning: %s") % s + '\n') def error (s): - sys.stderr.write (program_name + ": " + _ ("error: %s") % s + '\n') + ly.stderr_write (program_name + ": " + _ ("error: %s") % s + '\n') def identify (port=sys.stderr): - port.write ('%s (GNU LilyPond) %s\n' % (program_name, program_version)) + ly.encoded_write (port, '%s (GNU LilyPond) %s\n' % (program_name, program_version)) def warranty (): identify () - sys.stdout.write (''' -Copyright (c) %s by + ly.encoded_write (sys.stdout, ''' +%s - Han-Wen Nienhuys - Jan Nieuwenhuizen +%s %s %s -''' ( '2001--2006', - _('Distributed under terms of the GNU General Public License.'), - _('It comes with NO WARRANTY.'))) +''' % ( _ ('Copyright (c) %s by') % '2001--2009', + ' '.join (authors), + _ ('Distributed under terms of the GNU General Public License.'), + _ ('It comes with NO WARRANTY.'))) +def get_option_parser (): + p = ly.get_option_parser (usage=_ ("%s [OPTION]... FILE") % 'convert-ly', + description=help_summary, + add_help_option=False) + p.version="@TOPLEVEL_VERSION@" + p.add_option("--version", + action="version", + help=_ ("show version number and exit")) -def get_option_parser (): - p = ly.get_option_parser (usage='convert-ly [OPTIONS] FILE', - version="@TOPLEVEL_VERSION@", - description=help_summary) + p.add_option("-h", "--help", + action="help", + help=_ ("show this help and exit")) p.add_option ('-f', '--from', action="store", metavar=_ ("VERSION"), dest="from_version", - help=_('start from VERSION [default: \\version found in file]'), + help=_ ("start from VERSION [default: \\version found in file]"), default='') - p.add_option ('-e', '--edit', help=_('edit in place'), + p.add_option ('-e', '--edit', help=_ ("edit in place"), action='store_true') + p.add_option ('-n', '--no-version', - help=_ ('do not add \\version command if missing'), + help=_ ("do not add \\version command if missing"), action='store_true', dest='skip_version_add', default=False) + + p.add_option ('-c', '--current-version', + help=_ ("force updating \\version number to %s") % program_version, + action='store_true', + dest='force_current_version', + default=False) p.add_option ("-s", '--show-rules', - help=_('print rules [default: --from=0, --to=@TOPLEVEL_VERSION@]'), + help=_ ("show rules [default: -f 0, -t %s]") % program_version, dest='show_rules', action='store_true', default=False) p.add_option ('-t', '--to', - help=_('convert to VERSION [default: @TOPLEVEL_VERSION@]'), - metavar=_('VERSION'), + help=_ ("convert to VERSION [default: %s]") % program_version, + metavar=_ ('VERSION'), action='store', dest="to_version", default='') - - p.add_option_group ('bugs', - description='''Report bugs via http://post.gmane.org/post.php''' - '''?group=gmane.comp.gnu.lilypond.bugs\n''') + p.add_option ('-w', '--warranty', help=_ ("show warranty and copyright"), + action='store_true', + ), + p.add_option_group ('', + description=( + _ ("Report bugs via %s") + % 'http://post.gmane.org/post.php' + '?group=gmane.comp.gnu.lilypond.bugs') + '\n') return p def str_to_tuple (s): - return tuple (map (int, string.split (s, '.'))) + return tuple ([int(n) for n in s.split ('.')]) def tup_to_str (t): - return string.join (map (lambda x: '%s' % x, list (t)), '.') + return '.'.join (['%s' % x for x in t]) def version_cmp (t1, t2): for x in [0, 1, 2]: @@ -135,16 +158,16 @@ def version_cmp (t1, t2): def get_conversions (from_version, to_version): def is_applicable (v, f = from_version, t = to_version): return version_cmp (v[0], f) > 0 and version_cmp (v[0], t) <= 0 - return filter (is_applicable, conversions) + return filter (is_applicable, convertrules.conversions) def latest_version (): - return conversions[-1][0] + return convertrules.conversions[-1][0] def show_rules (file, from_version, to_version): - for x in conversions: + for x in convertrules.conversions: if (not from_version or x[0] > from_version) \ and (not to_version or x[0] <= to_version): - file.write ('%s: %s\n' % (tup_to_str (x[0]), x[2])) + ly.encoded_write (file, '%s: %s\n' % (tup_to_str (x[0]), x[2])) def do_conversion (str, from_version, to_version): """Apply conversions from FROM_VERSION to TO_VERSION. Return @@ -152,33 +175,30 @@ tuple (LAST,STR), with the last succesful conversion and the resulting string.""" conv_list = get_conversions (from_version, to_version) - if error_file: - error_file.write (_ ("Applying conversion: ")) + error_file_write (_ ("Applying conversion: ")) last_conversion = () try: for x in conv_list: - error_file.write (tup_to_str (x[0])) + error_file_write (tup_to_str (x[0])) if x != conv_list[-1]: - error_file.write (', ') + error_file_write (', ') str = x[1] (str) last_conversion = x[0] - except FatalConversionError: - error_file.write (_ ("error while converting")) - error_file.write ('\n') - error_file.write (_ ("Aborting")) - error_file.write ('\n') - - + except convertrules.FatalConversionError: + error_file_write ('\n' + + _ ("Error while converting") + + '\n' + + _ ("Stopping at last successful rule") + + '\n') return (last_conversion, str) -def guess_lilypond_version (filename): - s = open (filename).read () - m = lilypond_version_re.search (s) +def guess_lilypond_version (input): + m = lilypond_version_re.search (input) if m: return m.group (1) else: @@ -191,15 +211,22 @@ class UnknownVersion: pass def do_one_file (infile_name): - sys.stderr.write (_ ("Processing `%s\'... ") % infile_name) + ly.stderr_write (_ ("Processing `%s\'... ") % infile_name) sys.stderr.write ('\n') + if infile_name: + infile = open (infile_name, 'r') + input = infile.read () + infile.close () + else: + input = sys.stdin.read () + from_version = None to_version = None if global_options.from_version: from_version = global_options.from_version else: - guess = guess_lilypond_version (infile_name) + guess = guess_lilypond_version (input) if not guess: raise UnknownVersion () from_version = str_to_tuple (guess) @@ -210,24 +237,20 @@ def do_one_file (infile_name): to_version = latest_version () - if infile_name: - infile = open (infile_name, 'r') - else: - infile = sys.stdin - - - (last, result) = do_conversion (infile.read (), from_version, to_version) - infile.close () + (last, result) = do_conversion (input, from_version, to_version) if last: + if global_options.force_current_version and last == to_version: + last = str_to_tuple (program_version) + newversion = r'\version "%s"' % tup_to_str (last) if lilypond_version_re.search (result): result = re.sub (lilypond_version_re_str, '\\' + newversion, result) - elif add_version: + elif not global_options.skip_version_add: result = newversion + '\n' + result - error_file.write ('\n') + error_file_write ('\n') if global_options.edit: try: @@ -248,6 +271,9 @@ def do_options (): opt_parser = get_option_parser() (options, args) = opt_parser.parse_args () + if options.warranty: + warranty () + sys.exit (0) if options.from_version: options.from_version = str_to_tuple (options.from_version) @@ -278,14 +304,14 @@ def main (): if f == '-': f = '' elif not os.path.isfile (f): - error (_ ("can't open file: `%s'") % f) + error (_ ("cannot open file: `%s'") % f) if len (files) == 1: sys.exit (1) continue try: do_one_file (f) except UnknownVersion: - error (_ ("can't determine version for `%s'. Skipping") % f) + error (_ ("cannot determine version for `%s'. Skipping") % f) sys.stderr.write ('\n')