X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=scripts%2Fconvert-ly.py;h=f1d90f2641e63dd559792683197858f2722b1717;hb=bc95f4434f760d41191341ab4508b2064eb19025;hp=cf67f9f2400d0fbdb42ecf2d08299c5f283648fd;hpb=9a6392ad41c7cd1d811971b20b613129c65e10a6;p=lilypond.git diff --git a/scripts/convert-ly.py b/scripts/convert-ly.py index cf67f9f240..f1d90f2641 100644 --- a/scripts/convert-ly.py +++ b/scripts/convert-ly.py @@ -1,18 +1,28 @@ #!@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--2010 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 """ @@ -22,6 +32,8 @@ import re import lilylib as ly global _;_=ly._ +ly.require_python_version () + import convertrules lilypond_version_re_str = '\\\\version *\"([0-9.]+)"' @@ -33,8 +45,8 @@ _ ('''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 + $ convert-ly -e old.ly + $ convert-ly --from=2.3.28 --to=2.5.21 foobar.ly > foobar-new.ly ''') copyright = ('Jan Nieuwenhuizen ', @@ -43,34 +55,47 @@ copyright = ('Jan Nieuwenhuizen ', program_name = os.path.basename (sys.argv[0]) program_version = '@TOPLEVEL_VERSION@' +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--2010', + ' '.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', - version="@TOPLEVEL_VERSION@", - description=help_summary) + description=help_summary, + add_help_option=False) + + p.version="@TOPLEVEL_VERSION@" + p.add_option("--version", + action="version", + help=_ ("show version number and exit")) + + p.add_option("-h", "--help", + action="help", + help=_ ("show this help and exit")) p.add_option ('-f', '--from', action="store", @@ -81,38 +106,48 @@ def get_option_parser (): 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"), 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=_ ("show 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@]"), + 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]: @@ -132,7 +167,7 @@ def show_rules (file, from_version, to_version): 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 @@ -140,32 +175,30 @@ tuple (LAST,STR), with the last succesful conversion and the resulting string.""" conv_list = get_conversions (from_version, to_version) - if convertrules.error_file: - convertrules.error_file.write (_ ("Applying conversion: ")) + error_file_write (_ ("Applying conversion: ")) last_conversion = () try: for x in conv_list: - convertrules.error_file.write (tup_to_str (x[0])) + error_file_write (tup_to_str (x[0])) if x != conv_list[-1]: - convertrules.error_file.write (', ') + error_file_write (', ') str = x[1] (str) last_conversion = x[0] except convertrules.FatalConversionError: - convertrules.error_file.write ('\n' - + _ ("Error while converting") - + '\n' - + _ ("Stopping at last succesful rule") - + '\n') + 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: @@ -178,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) @@ -197,16 +237,12 @@ 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, @@ -214,7 +250,7 @@ def do_one_file (infile_name): elif not global_options.skip_version_add: result = newversion + '\n' + result - convertrules.error_file.write ('\n') + error_file_write ('\n') if global_options.edit: try: @@ -235,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)