head

openlp/core/lib/renderer.py

@@ -284,6 +284,9 @@ class Renderer(object):
         elif item.is_capable(ItemCapabilities.CanSoftBreak):
             pages = []
             if u'[---]' in text:
+                # Remove two or more option slide breaks next to each other (causing infinite loop).
+                while u'\n[---]\n[---]\n' in text:
+                        text = text.replace(u'\n[---]\n[---]\n', u'\n[---]\n')
                 while True:
                     slides = text.split(u'\n[---]\n', 2)
                     # If there are (at least) two occurrences of [---] we use

openlp/plugins/bibles/lib/upgrade.py

@@ -37,6 +37,7 @@ from sqlalchemy import Table, func, select, insert
 __version__ = 1
 log = logging.getLogger(__name__)
 
+
 def upgrade_setup(metadata):
     """
     Set up the latest revision all tables, with reflection, needed for the
@@ -61,31 +62,37 @@ def upgrade_1(session, metadata, tables):
     metadata_table = metadata.tables[u'metadata']
     # Copy "Version" to "name" ("version" used by upgrade system)
     # TODO: Clean up in a subsequent release of OpenLP (like 2.0 final)
-    session.execute(insert(metadata_table).values(
+    if select([metadata_table.c.value], metadata_table.c.key == u'Version')\
-        key=u'name',
+            .as_scalar().execute().fetchall():
-        value=select(
+        session.execute(insert(metadata_table).values(
-            [metadata_table.c.value],
+            key=u'name',
-            metadata_table.c.key == u'Version'
+            value=select(
-        ).as_scalar()
+                [metadata_table.c.value],
-    ))
+                metadata_table.c.key == u'Version'
+            ).as_scalar()
+        ))
     # Copy "Copyright" to "copyright"
     # TODO: Clean up in a subsequent release of OpenLP (like 2.0 final)
-    session.execute(insert(metadata_table).values(
+    if select([metadata_table.c.value], metadata_table.c.key == u'Copyright')\
-        key=u'copyright',
+            .as_scalar().execute().fetchall():
-        value=select(
+        session.execute(insert(metadata_table).values(
-            [metadata_table.c.value],
+            key=u'copyright',
-            metadata_table.c.key == u'Copyright'
+            value=select(
-        ).as_scalar()
+                [metadata_table.c.value],
-    ))
+                metadata_table.c.key == u'Copyright'
+            ).as_scalar()
+        ))
     # Copy "Permissions" to "permissions"
     # TODO: Clean up in a subsequent release of OpenLP (like 2.0 final)
-    session.execute(insert(metadata_table).values(
+    if select([metadata_table.c.value], metadata_table.c.key == u'Permissions')\
-        key=u'permissions',
+            .as_scalar().execute().fetchall():
-        value=select(
+        session.execute(insert(metadata_table).values(
-            [metadata_table.c.value],
+            key=u'permissions',
-            metadata_table.c.key == u'Permissions'
+            value=select(
-        ).as_scalar()
+                [metadata_table.c.value],
-    ))
+                metadata_table.c.key == u'Permissions'
+            ).as_scalar()
+        ))
     # Copy "Bookname language" to "book_name_language"
     # TODO: Clean up in a subsequent release of OpenLP (like 2.0 final)
     value_count = session.execute(

openlp/plugins/songs/forms/editsongform.py

@@ -723,19 +723,32 @@ class EditSongForm(QtGui.QDialog, Ui_EditSongDialog):
                 return False
         cnt_errors = 0
         error_list = ''
-        verse_tag = []
+        verse_tags = []
-        verse_num = []
+        wrong_verse_tags = []
+        wrong_verse_nums = []
         for i in range(self.verseListWidget.rowCount()):
             item = self.verseListWidget.item(i, 0)
             tags = self.find_tags.findall(item.text())
+            verse_tags.append(unicode(item.data(QtCore.Qt.UserRole).toString()))
             if self._validate_tags(tags) == False:
                 field = unicode(item.data(QtCore.Qt.UserRole).toString())
-                verse_tag.append(VerseType.translated_name(field[0]))
+                wrong_verse_tags.append(VerseType.translated_name(field[0]))
-                verse_num.append(field[1:])
+                wrong_verse_nums.append(field[1:])
                 cnt_errors += 1;
+        for tag in verse_tags:
+            if verse_tags.count(tag) > 26:
+                # lp#1310523: OpenLyrics allows only a-z variants of one verse:
+                # http://openlyrics.info/dataformat.html#verse-name
+                critical_error_message_box(
+                    message=translate('SongsPlugin.EditSongForm',
+                    'You have %(count)s verses named %(name)s %(number)s. '
+                    'You can have at most 26 verses with the same name' %
+                    {'count': verse_tags.count(tag), 'name': VerseType.translated_name(tag[0]),
+                     'number': tag[1:]}))
+                return False
         if cnt_errors > 0:
             for i in range(cnt_errors):
-                error_list += '%s %s' % (verse_tag[i], verse_num[i])
+                error_list += '%s %s' % (wrong_verse_tags[i], wrong_verse_nums[i])
                 if i < cnt_errors-1:
                     error_list += ', '
             critical_error_message_box(

openlp/plugins/songs/lib/ewimport.py

@@ -188,7 +188,14 @@ class EasyWorshipSongImport(SongImport):
                         self.addAuthor(author_name.strip())
                 if words:
                     # Format the lyrics
-                    result = strip_rtf(words, self.encoding)
+                    result = None
+                    try:
+                        result = strip_rtf(words, self.encoding)
+                    except UnicodeDecodeError:
+                        # The unicode chars in the rtf was not escaped in the expected manner.
+                        self.logError(self.title, unicode(translate('SongsPlugin.EasyWorshipSongImport',
+                                                                    'Unexpected data formatting.')))
+                        continue
                     if result is None:
                         return
                     words, self.encoding = result

openlp/plugins/songs/lib/upgrade.py

@@ -30,18 +30,24 @@
 The :mod:`upgrade` module provides a way for the database and schema that is the
 backend for the Songs plugin
 """
+import logging
 
 from sqlalchemy import Column, Table, types
+from sqlalchemy.exc import NoSuchTableError, OperationalError
 from sqlalchemy.sql.expression import func
 from migrate.changeset.constraint import ForeignKeyConstraint
 
+log = logging.getLogger(__name__)
 __version__ = 3
 
+
 def upgrade_setup(metadata):
     """
     Set up the latest revision all tables, with reflection, needed for the
     upgrade process. If you want to drop a table, you need to remove it from
     here, and add it to your upgrade function.
+
+    :param metadata: The SQLAlchemy metadata object
     """
     tables = {
         u'authors': Table(u'authors', metadata, autoload=True),
@@ -66,16 +72,23 @@ def upgrade_1(session, metadata, tables):
     In order to facilitate this one-to-many relationship, a song_id column is
     added to the media_files table, and a weight column so that the media
     files can be ordered.
+
+    :param session: An SQLAlchemy Session object
+    :param metadata: An SQLAlchemy MetaData object
+    :param tables: A dictionary of tables
     """
-    Table(u'media_files_songs', metadata, autoload=True).drop(checkfirst=True)
+    try:
-    Column(u'song_id', types.Integer(), default=None)\
+        Table(u'media_files_songs', metadata, autoload=True).drop(checkfirst=True)
-        .create(table=tables[u'media_files'])
+        Column(u'song_id', types.Integer(), default=None)\
-    Column(u'weight', types.Integer(), default=0)\
+            .create(table=tables[u'media_files'])
-        .create(table=tables[u'media_files'])
+        Column(u'weight', types.Integer(), default=0)\
-    if metadata.bind.url.get_dialect().name != 'sqlite':
+            .create(table=tables[u'media_files'])
-        # SQLite doesn't support ALTER TABLE ADD CONSTRAINT
+        if metadata.bind.url.get_dialect().name != 'sqlite':
-        ForeignKeyConstraint([u'song_id'], [u'songs.id'],
+            # SQLite doesn't support ALTER TABLE ADD CONSTRAINT
-            table=tables[u'media_files']).create()
+            ForeignKeyConstraint([u'song_id'], [u'songs.id'],
+                table=tables[u'media_files']).create()
+    except (NoSuchTableError, OperationalError):
+        log.info(u'Upgrade 1 has already been run, continue with upgrade')
 
 
 def upgrade_2(session, metadata, tables):
@@ -83,11 +96,18 @@ def upgrade_2(session, metadata, tables):
     Version 2 upgrade.
 
     This upgrade adds a create_date and last_modified date to the songs table
+
+    :param session: An SQLAlchemy Session object
+    :param metadata: An SQLAlchemy MetaData object
+    :param tables: A dictionary of tables
     """
-    Column(u'create_date', types.DateTime(), default=func.now())\
+    try:
-        .create(table=tables[u'songs'])
+        Column(u'create_date', types.DateTime(), default=func.now())\
-    Column(u'last_modified', types.DateTime(), default=func.now())\
+            .create(table=tables[u'songs'])
-        .create(table=tables[u'songs'])
+        Column(u'last_modified', types.DateTime(), default=func.now())\
+            .create(table=tables[u'songs'])
+    except OperationalError:
+        log.info(u'Upgrade 2 has already been run, continue with upgrade')
 
 
 def upgrade_3(session, metadata, tables):
@@ -95,7 +115,13 @@ def upgrade_3(session, metadata, tables):
     Version 3 upgrade.
 
     This upgrade adds a temporary song flag to the songs table
-    """
-    Column(u'temporary', types.Boolean(), default=False)\
-        .create(table=tables[u'songs'])
 
+    :param session: An SQLAlchemy Session object
+    :param metadata: An SQLAlchemy MetaData object
+    :param tables: A dictionary of tables
+    """
+    try:
+        Column(u'temporary', types.Boolean(), default=False)\
+            .create(table=tables[u'songs'])
+    except OperationalError:
+        log.info(u'Upgrade 3 has already been run, continue with upgrade')

openlp/plugins/songs/lib/xml.py

@@ -360,9 +360,9 @@ class OpenLyrics(object):
             verse_tag = verse[0][u'type'][0].lower()
             verse_number = verse[0][u'label']
             verse_def = verse_tag + verse_number
-            verse_tags.append(verse_def)
             # Create the letter from the number of duplicates
-            verse[0][u'suffix'] = chr(96 + verse_tags.count(verse_def))
+            verse[0][u'suffix'] = chr(97 + (verse_tags.count(verse_def) % 26))
+            verse_tags.append(verse_def)
         # If the verse tag is a duplicate use the suffix letter
         for verse in verse_list:
             verse_tag = verse[0][u'type'][0].lower()

openlp/plugins/songusage/lib/upgrade.py

@@ -30,11 +30,15 @@
 The :mod:`upgrade` module provides a way for the database and schema that is the
 backend for the SongsUsage plugin
 """
+import logging
 
 from sqlalchemy import Column, Table, types
+from sqlalchemy.exc import OperationalError
 
+log = logging.getLogger(__name__)
 __version__ = 1
 
+
 def upgrade_setup(metadata):
     """
     Set up the latest revision all tables, with reflection, needed for the
@@ -53,7 +57,10 @@ def upgrade_1(session, metadata, tables):
 
     This upgrade adds two new fields to the songusage database
     """
-    Column(u'plugin_name', types.Unicode(20), default=u'') \
+    try:
-        .create(table=tables[u'songusage_data'], populate_default=True)
+        Column(u'plugin_name', types.Unicode(20), default=u'') \
-    Column(u'source', types.Unicode(10), default=u'') \
+            .create(table=tables[u'songusage_data'], populate_default=True)
-        .create(table=tables[u'songusage_data'], populate_default=True)
+        Column(u'source', types.Unicode(10), default=u'') \
+            .create(table=tables[u'songusage_data'], populate_default=True)
+    except OperationalError:
+        log.info(u'Upgrade 1 has already been run, continue with upgrade')