LilyPond-Ruby 0.0.2.1 → 0.1.2

data/share/lilypond/2.24.1/python/book_base.py

@@ -0,0 +1,331 @@
+# book_base.py
+# -*- coding: utf-8 -*-
+#
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# Copyright (C) 2020--2022 Han-Wen Nienhuys <hanwen@xs4all.nl>,
+#               2010 Reinhold Kainhofer <reinhold@kainhofer.com>
+#
+# 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 <http://www.gnu.org/licenses/>.
+
+import os
+import re
+import sys
+
+import book_snippets as BookSnippet
+import book_snippets
+import lilylib as ly
+
+progress = ly.progress
+warning = ly.warning
+error = ly.error
+
+########################################################################
+# Helper functions
+########################################################################
+
+
+def find_file(name, include_path, raise_error=True):
+    for i in include_path:
+        full = os.path.join(i, name)
+        if os.path.exists(full):
+            return full
+
+    if raise_error:
+        error(_("file not found: %s") % name + '\n')
+        sys.exit(1)
+    return ''
+
+
+def verbatim_html(s):
+    return re.sub('>', '&gt;',
+                  re.sub('<', '&lt;',
+                         re.sub('&', '&amp;', s)))
+
+
+# Taken from `convertrules.py`.
+def brace_matcher(n):
+    # poor man's matched brace scanning, gives up
+    # after n+1 levels.  Matches any string with balanced
+    # braces inside; add the outer braces yourself if needed.
+    # Nongreedy.
+    return r"[^{}]*?(?:{"*n+r"[^{}]*?"+r"}[^{}]*?)*?"*n
+
+
+########################################################################
+# Option handling
+########################################################################
+
+# TODO: Definitions just once in all files!!!
+LINE_WIDTH = 'line-width'
+
+# TODO: Implement the intertext snippet option:
+#         'intertext': r',?\s*intertext=\".*?\"',
+
+default_snippet_opts = {'alt': "[image of music]"}
+
+
+########################################################################
+# format handling
+########################################################################
+
+all_formats = []
+
+
+def register_format(fmt):
+    all_formats.append(fmt)
+
+
+########################################################################
+# Snippet handling
+########################################################################
+
+# Use this for sorting the keys of the defined snippet types (the dict
+# is unsorted, so we need to return sorted keys to ensure processing
+# in a pre-defined order)
+# Containing blocks must be first, see find_toplevel_snippets.
+snippet_type_order = [
+    'multiline_comment',
+    'verbatim',
+    'verb',
+    'lilypond_block',
+    'singleline_comment',
+    'lilypond_file',
+    'include',
+    'lilypond',
+    'lilypondversion',
+]
+
+########################################################################
+# Base class for all output formats
+########################################################################
+
+
+class BookOutputFormat:
+    def __init__(self):
+        self.format = None
+        self.default_extension = None
+
+        # snippet_type string => regex string
+
+        # Possible keys are:
+        #     'multiline_comment', 'verbatim', 'lilypond_block', 'singleline_comment',
+        #     'lilypond_file', 'include', 'lilypond', 'lilypondversion'
+        #     'musicxml_file',
+
+        self.snippet_res = {}
+        self.output = {}
+        self.handled_extensions = []
+        self.image_formats = "ps,png"
+        self.global_options = {}
+        self.document_language = ''
+        self.default_snippet_options = default_snippet_opts
+        self.snippet_option_separator = r"\s*,\s*"
+
+    def supported_snippet_types(self):
+        """List of snippet types (strings)"""
+        # Sort according to snippet_type_order, unknown keys come last
+        keys = list(self.snippet_res.keys())
+        # First the entries in snippet_type_order in that order (if present)
+        # then all entries not in snippet_type_order in given order
+        res = [x for x in snippet_type_order if x in keys] + \
+            [x for x in keys if x not in snippet_type_order]
+        return res
+
+    def snippet_regexp(self, snippettype):
+        """return regex string for snippettype"""
+        return self.snippet_res.get(snippettype, None)
+
+    def can_handle_format(self, format):
+        return format == self.format
+
+    def can_handle_extension(self, extension):
+        return extension in self.handled_extensions
+
+    def add_options(self, option_parser):
+        pass
+
+    def process_options(self, global_options):
+        pass
+
+    def process_options_pdfnotdefault(self, global_options):
+        # prevent PDF from being switched on by default.
+        formats = ['eps']
+        if global_options.create_pdf:
+            global_options.process_cmd += ' -dinclude-eps-fonts -dgs-load-fonts '
+            formats.append('pdf')
+            if global_options.latex_program == 'latex':
+                global_options.latex_program = 'pdflatex'
+        if '-dseparate-page-formats' not in global_options.process_cmd:
+            global_options.process_cmd += ' -dseparate-page-formats=%s ' % (','.join(formats))
+
+    def snippet_class(self, type):
+        return BookSnippet.snippet_type_to_class.get(type, BookSnippet.Snippet)
+
+    def get_document_language(self, source):
+        return ''
+
+    def init_default_snippet_options(self, source):
+        self.document_language = self.get_document_language(source)
+        if LINE_WIDTH not in self.default_snippet_options:
+            line_width = self.get_line_width(source)
+            if line_width:
+                self.default_snippet_options[LINE_WIDTH] = line_width
+
+    def get_line_width(self, source):
+        return None
+
+    def split_snippet_options(self, option_string):
+        if option_string:
+            return re.split(self.snippet_option_separator, option_string)
+        return []
+
+    def input_fullname(self, input_filename):
+        return find_file(input_filename, self.global_options.include_path)
+
+    def adjust_snippet_command(self, cmd):
+        return cmd
+
+    def process_chunks(self, chunks):
+        return chunks
+
+    def snippet_output(self, basename, snippet):
+        warning(_("Output function not implemented"))
+        return ''
+
+    def output_simple(self, type, snippet):
+        return self.output.get(type, '') % snippet.get_replacements()
+
+    def output_simple_replacements(self, type, variables):
+        return self.output.get(type, '') % variables
+
+    def output_print_filename(self, basename, snippet):
+        s = ''
+        rep = snippet.get_replacements()
+        if book_snippets.PRINTFILENAME in snippet.option_dict:
+            rep['base'] = basename
+            rep['filename'] = os.path.basename(snippet.filename)
+            rep['ext'] = snippet.ext
+            s = self.output[book_snippets.PRINTFILENAME] % rep
+
+        return s
+
+    def required_files(self, snippet, base, full, required_files):
+        return []
+
+    def required_files_png(self, snippet, base, full, required_files):
+        # UGH - junk global_options
+        res = []
+        if (base + '.eps' in required_files and not snippet.global_options.skip_png_check):
+            page_count = BookSnippet.ps_page_count(full + '.eps')
+            if page_count <= 1:
+                res.append(base + '.png')
+            else:
+                for page in range(1, page_count + 1):
+                    res.append(base + '-page%d.png' % page)
+        return res
+
+
+def find_linestarts(s):
+    """Return a list of indices indicating the first char of a line."""
+    nls = [0]
+    start = 0
+    end = len(s)
+    while True:
+        i = s.find('\n', start)
+        if i < 0:
+            break
+
+        i = i + 1
+        nls.append(i)
+        start = i
+
+    nls.append(len(s))
+    return nls
+
+
+def find_toplevel_snippets(input_string, formatter, global_options):
+    res = {}
+    types = formatter.supported_snippet_types()
+    for t in types:
+        res[t] = re.compile(formatter.snippet_regexp(t))
+
+    snippets = []
+    index = 0
+    found = dict([(t, None) for t in types])
+
+    line_starts = find_linestarts(input_string)
+    line_start_idx = 0
+    # We want to search for multiple regexes, without searching
+    # the string multiple times for one regex.
+    # Hence, we use earlier results to limit the string portion
+    # where we search.
+    # Since every part of the string is traversed at most once for
+    # every type of snippet, this is linear.
+    while True:
+        first = None
+        endex = 1 << 30
+        for type in types:
+            if not found[type] or found[type][0] < index:
+                found[type] = None
+
+                m = res[type].search(input_string, index, endex)
+                if not m:
+                    continue
+
+                klass = formatter.snippet_class(type)
+
+                start = m.start('match')
+                line_number = line_start_idx
+                while line_starts[line_number] < start:
+                    line_number += 1
+
+                line_number += 1
+                snip = klass(type, m, formatter, line_number, global_options)
+
+                found[type] = (start, snip)
+
+            if (found[type]
+                and (not first
+                     or found[type][0] < found[first][0])):
+                first = type
+
+                # FIXME.
+
+                # Limiting the search space is a cute
+                # idea, but this *requires* to search
+                # for possible containing blocks
+                # first, at least as long as we do not
+                # search for the start of blocks, but
+                # always/directly for the entire
+                # @block ... @end block.
+
+                endex = found[first][0]
+
+        if not first:
+            snippets.append(BookSnippet.Substring(
+                input_string, index, len(input_string), line_start_idx))
+            break
+
+        while start > line_starts[line_start_idx+1]:
+            line_start_idx += 1
+
+        (start, snip) = found[first]
+        snippets.append(BookSnippet.Substring(
+            input_string, index, start, line_start_idx + 1))
+        snippets.append(snip)
+        found[first] = None
+        index = start + len(snip.match.group('match'))
+
+    return snippets

data/share/lilypond/2.24.1/python/book_docbook.py

@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+# book_docbook.py
+#
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# Copyright (C) 2020--2022 Han-Wen Nienhuys <hanwen@xs4all.nl>,
+#               2010 Reinhold Kainhofer <reinhold@kainhofer.com>
+#
+# 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 <http://www.gnu.org/licenses/>.
+
+
+import os
+
+import book_base
+import book_snippets
+
+
+# Recognize special sequences in the input.
+#
+#   (?P<name>regex) -- Assign result of REGEX to NAME.
+#   *? -- Match non-greedily.
+#   (?!...) -- Match if `...' doesn't match next (without consuming
+#              the string).
+#
+#   (?m) -- Multiline regex: Make ^ and $ match at each line.
+#   (?s) -- Make the dot match all characters including newline.
+#   (?x) -- Ignore whitespace in patterns.
+# See book_base.BookOutputFormat for  possible keys
+Docbook_snippet_res = {
+    'lilypond':
+    r'''(?smx)
+          <(?P<inline>(inline)?)mediaobject>\s*
+          (?P<match>
+          <textobject.*?>\s*
+          <programlisting\s+language=["']lilypond["'].*?(role=["'](?P<options>.*?)["'])?>
+          (?P<code>.*?)
+          </programlisting\s*>\s*
+          </textobject\s*>\s*)
+          </(inline)?mediaobject>''',
+
+    'lilypond_block':
+    r'''(?smx)
+          <(?P<inline>(inline)?)mediaobject>\s*
+          (?P<match>
+          <textobject.*?>\s*
+          <programlisting\s+language=["']lilypond["'].*?(role=["'](?P<options>.*?)["'])?>
+          (?P<code>.*?)
+          </programlisting\s*>\s*
+          </textobject\s*>\s*)
+          </(inline)?mediaobject>''',
+
+    'lilypond_file':
+    r'''(?smx)
+          <(?P<inline>(inline)?)mediaobject>\s*
+          (?P<match>
+          <imageobject.*?>\s*
+          <imagedata\s+
+           fileref=["'](?P<filename>.*?\.ly)["']\s*
+           (role=["'](?P<options>.*?)["'])?\s*
+           (/>|>\s*</imagedata>)\s*
+          </imageobject>\s*)
+          </(inline)?mediaobject>''',
+
+    'multiline_comment':
+    r'''(?smx)
+          (?P<match>
+          \s*(?!@c\s+)
+          (?P<code><!--\s.*?!-->)
+          \s)''',
+}
+
+
+Docbook_output = {
+    book_snippets.FILTER: r'''<mediaobject>
+  <textobject>
+    <programlisting language="lilypond"
+                    role="%(options)s">
+%(code)s
+    </programlisting>
+  </textobject>
+</mediaobject>''',
+
+    # TODO: this looks wrong: in PDF, we should use per-system output
+    book_snippets.OUTPUT: r'''<imageobject role="latex">
+  <imagedata fileref="%(base)s.pdf" format="PDF"/>
+</imageobject>
+<imageobject role="html">
+  <imagedata fileref="%(base)s.png" format="PNG"/>
+</imageobject>''',
+
+    book_snippets.PRINTFILENAME: r'''<textobject>
+  <simpara>
+    <ulink url="%(base)s%(ext)s">
+      <filename>
+        %(filename)s
+      </filename>
+    </ulink>
+  </simpara>
+</textobject>''',
+
+    book_snippets.VERBATIM: r'''<textobject>
+  <programlisting language="lilypond" role="processed">%(verb)s</programlisting>
+</textobject>''',
+
+    book_snippets.VERSION: r'''%(program_version)s''',
+}
+
+
+class BookDocbookOutputFormat (book_base.BookOutputFormat):
+    def __init__(self):
+        book_base.BookOutputFormat.__init__(self)
+        self.format = "docbook"
+        self.default_extension = ".xml"
+        self.snippet_res = Docbook_snippet_res
+        self.output = Docbook_output
+        self.handled_extensions = ['.lyxml']
+        self.snippet_option_separator = r'\s+'
+
+    def adjust_snippet_command(self, cmd):
+        if '-dseparate-page-formats' not in cmd:
+            cmd += ' -dseparate-page-formats=pdf '
+        if '-dtall-page-formats' not in cmd:
+            cmd += ' -dtall-page-formats=eps,pdf,png '
+        return cmd
+
+    def snippet_output(self, basename, snippet):
+        s = ''
+        rep = snippet.get_replacements()
+        for image in snippet.get_images():
+            rep['image'] = image
+            (rep['base'], rep['ext']) = os.path.splitext(image)
+            s += self.output[book_snippets.OUTPUT] % rep
+            s += self.output_print_filename(basename, snippet)
+            s += '\n'
+        if book_snippets.VERBATIM in snippet.option_dict:
+            rep['verb'] = book_base.verbatim_html(snippet.verb_ly())
+            s += self.output[book_snippets.VERBATIM] % rep
+            s += '\n'
+            
+        return s
+
+
+book_base.register_format(BookDocbookOutputFormat())

data/share/lilypond/2.24.1/python/book_html.py

@@ -0,0 +1,178 @@
+# book_html.py
+# -*- coding: utf-8 -*-
+#
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# Copyright (C) 2020--2022 Han-Wen Nienhuys <hanwen@xs4all.nl>,
+#               2010 Reinhold Kainhofer <reinhold@kainhofer.com>
+#
+# 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 <http://www.gnu.org/licenses/>.
+
+import copy
+import os
+import re
+
+import book_base
+import book_snippets
+
+# See `book_latex.py` for some regex documentation.
+
+HTML_snippet_res = {
+    'lilypond':
+    r'''(?smx)
+          (?P<match>
+            <lilypond
+            ( \s+ (?P<options> [^:<>]*? ) )?
+            \s* : \s*
+            (?P<code> .*? )
+            \s* />
+          )''',
+
+    'lilypond_block':
+    r'''(?smx)
+          (?P<match>
+            <lilypond \s*
+            (?P<options> [^:<>]*? )
+            \s* >
+            (?P<code> .*? )
+            </lilypond \s* >
+          )''',
+
+    'lilypond_file':
+    r'''(?smx)
+          (?P<match>
+            <lilypondfile \s*
+            (?P<options> [^:<>]*? )
+            \s* >
+            \s* (?P<filename> .*? ) \s*
+            </lilypondfile \s* >
+          )''',
+
+    'multiline_comment':
+    r'''(?smx)(?P<match>\s*(?!@c\s+)(?P<code><!--\s.*?!-->)\s)''',
+
+    'musicxml_file':
+    r'''(?mx)
+          (?P<match>
+          <musicxmlfile\s*(?P<options>.*?)\s*>
+          \s*(?P<filename>.*?)\s*
+          </musicxmlfile\s*>)''',
+
+    'verb':
+    r'''(?x)(?P<match>(?P<code><pre>.*?</pre>))''',
+
+    'verbatim':
+    r'''(?xs)(?P<match>(?P<code><pre>\s.*?</pre>\s))''',
+
+    'lilypondversion':
+    r'''(?mx)(?P<match><lilypondversion\s*/>)''',
+}
+
+
+HTML_output = {
+    book_snippets.FILTER: r'''<lilypond %(options)s>
+%(code)s
+</lilypond>
+''',
+
+    book_snippets.AFTER: r'''</a>''',
+
+    book_snippets.BEFORE: r'''<a href="%(base)s%(ext)s">''',
+
+    book_snippets.OUTPUT: r'''
+  <img align="middle"
+       border="0"
+       src="%(image)s"
+       alt="%(alt)s">''',
+
+    book_snippets.PRINTFILENAME: '<p><tt><a href="%(base)s%(ext)s">%(filename)s</a></tt></p>',
+
+    book_snippets.QUOTE: r'''<blockquote>%(str)s</blockquote>''',
+
+    book_snippets.PARA: r'''<p>%(str)s</p>''',
+
+    book_snippets.VERBATIM: r'''<pre>%(verb)s</pre>
+''',
+
+    book_snippets.VERSION: r'''%(program_version)s''',
+}
+
+
+class BookHTMLOutputFormat (book_base.BookOutputFormat):
+    def __init__(self):
+        book_base.BookOutputFormat.__init__(self)
+        self.format = "html"
+        self.default_extension = ".html"
+        self.snippet_res = HTML_snippet_res
+        self.output = HTML_output
+        self.handled_extensions = ['.html', '.xml', '.htmly']
+        self.snippet_option_separator = r'\s+'
+
+    def split_snippet_options(self, option_string):
+        if option_string:
+            options = re.findall(r'''[-\w\.-:]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|\S+))?''',
+                                 option_string)
+            options = [re.sub(r'''^([^=]+=\s*)(?P<q>["'])(.*)(?P=q)''', r'\g<1>\g<3>', opt)
+                       for opt in options]
+            return options
+        return []
+
+    def adjust_snippet_command(self, cmd):
+        if '-dtall-page-formats' not in cmd:
+            cmd += ' -dtall-page-formats=eps,png '
+        return cmd
+
+    def output_images(self, basename, snippet):
+        s = ''
+        rep = snippet.get_replacements()
+        rep['base'] = basename
+        rep['filename'] = os.path.basename(snippet.filename)
+        rep['ext'] = snippet.ext
+
+        s += self.output[book_snippets.BEFORE] % rep
+        for image in snippet.get_images():
+            rep1 = copy.copy(rep)
+            rep1['image'] = image
+            (rep1['base'], rep1['ext']) = os.path.splitext(image)
+            rep1['alt'] = snippet.option_dict[book_snippets.ALT]
+            s += self.output[book_snippets.OUTPUT] % rep1
+        s += self.output[book_snippets.AFTER] % rep
+        return s
+
+    def snippet_output(self, basename, snippet):
+        s = ''
+        s += self.output_print_filename(basename, snippet)
+        rep = snippet.get_replacements()
+
+        substr = ''
+        if book_snippets.VERBATIM in snippet.option_dict:
+            rep['verb'] = book_base.verbatim_html(snippet.verb_ly())
+            substr = self.output[book_snippets.VERBATIM] % rep
+
+        subsubstr = self.output_images(basename, snippet)
+        if book_snippets.INLINE not in snippet.option_dict:
+            subsubstr = self.output[book_snippets.PARA] % {'str': subsubstr}
+        substr += subsubstr
+
+        if book_snippets.QUOTE in snippet.option_dict:
+            substr = self.output[book_snippets.QUOTE] % {'str': substr}
+        s += substr
+
+        return s
+
+    def required_files(self, snippet, base, full, required_files):
+        return self.required_files_png(snippet, base, full, required_files)
+
+
+book_base.register_format(BookHTMLOutputFormat())