Merge pull request #1429 from tomjaspers/sort-ignore-case

Sort can ignore case if configured to do so

Author: sampsyo

beets/config_default.yaml

@@ -67,6 +67,7 @@ time_format: '%Y-%m-%d %H:%M:%S'
 
 sort_album: albumartist+ album+
 sort_item: artist+ album+ disc+ track+
+sort_case_insensitive: yes
 
 paths:
     default: $albumartist/$album%aunique{}/$track $title

beets/dbcore/query.py

@@ -18,7 +18,7 @@
                         unicode_literals)
 
 import re
-from operator import attrgetter, mul
+from operator import mul
 from beets import util
 from datetime import datetime, timedelta
 
@@ -717,16 +717,23 @@ class FieldSort(Sort):
     """An abstract sort criterion that orders by a specific field (of
     any kind).
     """
-    def __init__(self, field, ascending=True):
+    def __init__(self, field, ascending=True, case_insensitive=True):
         self.field = field
         self.ascending = ascending
+        self.case_insensitive = case_insensitive
 
     def sort(self, objs):
         # TODO: Conversion and null-detection here. In Python 3,
         # comparisons with None fail. We should also support flexible
         # attributes with different types without falling over.
-        return sorted(objs, key=attrgetter(self.field),
-                      reverse=not self.ascending)
+
+        def key(item):
+            field_val = getattr(item, self.field)
+            if self.case_insensitive and isinstance(field_val, unicode):
+                field_val = field_val.lower()
+            return field_val
+
+        return sorted(objs, key=key, reverse=not self.ascending)
 
     def __repr__(self):
         return u'<{0}: {1}{2}>'.format(
@@ -749,7 +756,8 @@ class FixedFieldSort(FieldSort):
     """
     def order_clause(self):
         order = "ASC" if self.ascending else "DESC"
-        return "{0} {1}".format(self.field, order)
+        collate = 'COLLATE NOCASE' if self.case_insensitive else ''
+        return "{0} {1} {2}".format(self.field, collate, order)
 
 
 class SlowFieldSort(FieldSort):

beets/dbcore/queryparse.py

@@ -19,7 +19,7 @@
 import re
 import itertools
 from . import query
-
+import beets
 
 PARSE_QUERY_PART_REGEX = re.compile(
     # Non-capturing optional segment for the keyword.
@@ -138,13 +138,15 @@ def construct_sort_part(model_cls, part):
     assert direction in ('+', '-'), "part must end with + or -"
     is_ascending = direction == '+'
 
+    case_insensitive = beets.config['sort_case_insensitive'].get(bool)
     if field in model_cls._sorts:
-        sort = model_cls._sorts[field](model_cls, is_ascending)
+        sort = model_cls._sorts[field](model_cls, is_ascending,
+                                       case_insensitive)
     elif field in model_cls._fields:
-        sort = query.FixedFieldSort(field, is_ascending)
+        sort = query.FixedFieldSort(field, is_ascending, case_insensitive)
     else:
         # Flexible or computed.
-        sort = query.SlowFieldSort(field, is_ascending)
+        sort = query.SlowFieldSort(field, is_ascending, case_insensitive)
     return sort
 
 

beets/library.py

@@ -197,25 +197,29 @@ class SmartArtistSort(dbcore.query.Sort):
     """Sort by artist (either album artist or track artist),
     prioritizing the sort field over the raw field.
     """
-    def __init__(self, model_cls, ascending=True):
+    def __init__(self, model_cls, ascending=True, case_insensitive=True):
         self.album = model_cls is Album
         self.ascending = ascending
+        self.case_insensitive = case_insensitive
 
     def order_clause(self):
         order = "ASC" if self.ascending else "DESC"
-        if self.album:
-            field = 'albumartist'
-        else:
-            field = 'artist'
+        field = 'albumartist' if self.album else 'artist'
+        collate = 'COLLATE NOCASE' if self.case_insensitive else ''
         return ('(CASE {0}_sort WHEN NULL THEN {0} '
                 'WHEN "" THEN {0} '
-                'ELSE {0}_sort END) {1}').format(field, order)
+                'ELSE {0}_sort END) {1} {2}').format(field, collate, order)
 
     def sort(self, objs):
         if self.album:
-            key = lambda a: a.albumartist_sort or a.albumartist
+            field = lambda a: a.albumartist_sort or a.albumartist
+        else:
+            field = lambda i: i.artist_sort or i.artist
+
+        if self.case_insensitive:
+            key = lambda x: field(x).lower()
         else:
-            key = lambda i: i.artist_sort or i.artist
+            key = field
         return sorted(objs, key=key, reverse=not self.ascending)
 
 

docs/changelog.rst

@@ -23,6 +23,11 @@ New features:
 * The autotagger's **matching algorithm is faster**. We now use the
   `Jellyfish`_ library to compute string similarity, which is better optimized
   than our hand-rolled edit distance implementation. :bug:`1389`
+* **Sorting is now case insensitive** by default. This means that artists will
+  be sorted lexicographically regardless of case, e.g., *Bar foo Qux*.
+  Previously this would have resulted in *Bar Qux foo*. This behavior can be
+  configured via the :ref:`sort_case_insensitive` configuration option.
+  See :ref:`query-sort`. :bug:`1429`
 * :doc:`/plugins/fetchart`: There are new settings to control what constitutes
   **"acceptable" images**. The `minwidth` option constrains the minimum image
   width in pixels and the `enforce_ratio` option requires that images be

docs/reference/config.rst

@@ -204,6 +204,15 @@ sort_album
 Default sort order to use when fetching items from the database. Defaults to
 ``albumartist+ album+``. Explicit sort orders override this default.
 
+.. _sort_case_insensitive:
+
+sort_case_insensitive
+~~~~~~~~~~~~~~~~~~~~~
+Either ``yes`` or ``no``, indicating whether the case should be ignored when
+sorting lexicographic fields. When set to ``no``, lower-case values will be
+placed after upper-case values (e.g., *Bar Qux foo*), while ``yes`` would
+result in the more expected *Bar foo Qux*. Default: ``yes``.
+
 .. _original_date:
 
 original_date

docs/reference/query.rst

@@ -223,5 +223,11 @@ The ``artist`` and ``albumartist`` keys are special: they attempt to use their
 corresponding ``artist_sort`` and ``albumartist_sort`` fields for sorting
 transparently (but fall back to the ordinary fields when those are empty).
 
+Lexicographic sorts are case insensitive by default, resulting in the following
+sort order: ``Bar foo Qux``. This behavior can be changed with the
+:ref:`sort_case_insensitive` configuration option. Case sensitive sort will
+result in lower-case values being placed after upper-case values, e.g.,
+``Bar Qux foo``.
+
 You can set the default sorting behavior with the :ref:`sort_item` and
 :ref:`sort_album` configuration options.

test/test_sort.py

@@ -32,65 +32,65 @@ def setUp(self):
         self.lib = beets.library.Library(':memory:')
 
         albums = [_common.album() for _ in range(3)]
-        albums[0].album = "album A"
+        albums[0].album = "Album A"
         albums[0].genre = "Rock"
         albums[0].year = "2001"
-        albums[0].flex1 = "flex1-1"
-        albums[0].flex2 = "flex2-A"
-        albums[0].albumartist = "foo"
+        albums[0].flex1 = "Flex1-1"
+        albums[0].flex2 = "Flex2-A"
+        albums[0].albumartist = "Foo"
         albums[0].albumartist_sort = None
-        albums[1].album = "album B"
+        albums[1].album = "Album B"
         albums[1].genre = "Rock"
         albums[1].year = "2001"
-        albums[1].flex1 = "flex1-2"
-        albums[1].flex2 = "flex2-A"
-        albums[1].albumartist = "bar"
+        albums[1].flex1 = "Flex1-2"
+        albums[1].flex2 = "Flex2-A"
+        albums[1].albumartist = "Bar"
         albums[1].albumartist_sort = None
-        albums[2].album = "album C"
+        albums[2].album = "Album C"
         albums[2].genre = "Jazz"
         albums[2].year = "2005"
-        albums[2].flex1 = "flex1-1"
-        albums[2].flex2 = "flex2-B"
-        albums[2].albumartist = "baz"
+        albums[2].flex1 = "Flex1-1"
+        albums[2].flex2 = "Flex2-B"
+        albums[2].albumartist = "Baz"
         albums[2].albumartist_sort = None
         for album in albums:
             self.lib.add(album)
 
         items = [_common.item() for _ in range(4)]
-        items[0].title = 'foo bar'
-        items[0].artist = 'one'
-        items[0].album = 'baz'
+        items[0].title = 'Foo bar'
+        items[0].artist = 'One'
+        items[0].album = 'Baz'
         items[0].year = 2001
         items[0].comp = True
-        items[0].flex1 = "flex1-0"
-        items[0].flex2 = "flex2-A"
+        items[0].flex1 = "Flex1-0"
+        items[0].flex2 = "Flex2-A"
         items[0].album_id = albums[0].id
         items[0].artist_sort = None
-        items[1].title = 'baz qux'
-        items[1].artist = 'two'
-        items[1].album = 'baz'
+        items[1].title = 'Baz qux'
+        items[1].artist = 'Two'
+        items[1].album = 'Baz'
         items[1].year = 2002
         items[1].comp = True
-        items[1].flex1 = "flex1-1"
-        items[1].flex2 = "flex2-A"
+        items[1].flex1 = "Flex1-1"
+        items[1].flex2 = "Flex2-A"
         items[1].album_id = albums[0].id
         items[1].artist_sort = None
-        items[2].title = 'beets 4 eva'
-        items[2].artist = 'three'
-        items[2].album = 'foo'
+        items[2].title = 'Beets 4 eva'
+        items[2].artist = 'Three'
+        items[2].album = 'Foo'
         items[2].year = 2003
         items[2].comp = False
-        items[2].flex1 = "flex1-2"
-        items[2].flex2 = "flex1-B"
+        items[2].flex1 = "Flex1-2"
+        items[2].flex2 = "Flex1-B"
         items[2].album_id = albums[1].id
         items[2].artist_sort = None
-        items[3].title = 'beets 4 eva'
-        items[3].artist = 'three'
-        items[3].album = 'foo2'
+        items[3].title = 'Beets 4 eva'
+        items[3].artist = 'Three'
+        items[3].album = 'Foo2'
         items[3].year = 2004
         items[3].comp = False
-        items[3].flex1 = "flex1-2"
-        items[3].flex2 = "flex1-C"
+        items[3].flex1 = "Flex1-2"
+        items[3].flex2 = "Flex1-C"
         items[3].album_id = albums[2].id
         items[3].artist_sort = None
         for item in items:
@@ -132,8 +132,8 @@ def test_sort_two_field_asc(self):
         results = self.lib.items(q, sort)
         self.assertLessEqual(results[0]['album'], results[1]['album'])
         self.assertLessEqual(results[1]['album'], results[2]['album'])
-        self.assertEqual(results[0]['album'], 'baz')
-        self.assertEqual(results[1]['album'], 'baz')
+        self.assertEqual(results[0]['album'], 'Baz')
+        self.assertEqual(results[1]['album'], 'Baz')
         self.assertLessEqual(results[0]['year'], results[1]['year'])
         # same thing with query string
         q = 'album+ year+'
@@ -148,7 +148,7 @@ def test_sort_asc(self):
         sort = dbcore.query.SlowFieldSort("flex1", True)
         results = self.lib.items(q, sort)
         self.assertLessEqual(results[0]['flex1'], results[1]['flex1'])
-        self.assertEqual(results[0]['flex1'], 'flex1-0')
+        self.assertEqual(results[0]['flex1'], 'Flex1-0')
         # same thing with query string
         q = 'flex1+'
         results2 = self.lib.items(q)
@@ -162,7 +162,7 @@ def test_sort_desc(self):
         self.assertGreaterEqual(results[0]['flex1'], results[1]['flex1'])
         self.assertGreaterEqual(results[1]['flex1'], results[2]['flex1'])
         self.assertGreaterEqual(results[2]['flex1'], results[3]['flex1'])
-        self.assertEqual(results[0]['flex1'], 'flex1-2')
+        self.assertEqual(results[0]['flex1'], 'Flex1-2')
         # same thing with query string
         q = 'flex1-'
         results2 = self.lib.items(q)
@@ -179,8 +179,8 @@ def test_sort_two_field(self):
         results = self.lib.items(q, sort)
         self.assertGreaterEqual(results[0]['flex2'], results[1]['flex2'])
         self.assertGreaterEqual(results[1]['flex2'], results[2]['flex2'])
-        self.assertEqual(results[0]['flex2'], 'flex2-A')
-        self.assertEqual(results[1]['flex2'], 'flex2-A')
+        self.assertEqual(results[0]['flex2'], 'Flex2-A')
+        self.assertEqual(results[1]['flex2'], 'Flex2-A')
         self.assertLessEqual(results[0]['flex1'], results[1]['flex1'])
         # same thing with query string
         q = 'flex2- flex1+'
@@ -269,8 +269,8 @@ def test_sort_two_field_asc(self):
         results = self.lib.albums(q, sort)
         self.assertLessEqual(results[0]['flex2'], results[1]['flex2'])
         self.assertLessEqual(results[1]['flex2'], results[2]['flex2'])
-        self.assertEqual(results[0]['flex2'], 'flex2-A')
-        self.assertEqual(results[1]['flex2'], 'flex2-A')
+        self.assertEqual(results[0]['flex2'], 'Flex2-A')
+        self.assertEqual(results[1]['flex2'], 'Flex2-A')
         self.assertLessEqual(results[0]['flex1'], results[1]['flex1'])
         # same thing with query string
         q = 'flex2+ flex1+'
@@ -358,6 +358,87 @@ def test_config_opposite_sort_album(self):
         self.assertGreater(results[0].albumartist, results[1].albumartist)
 
 
+class CaseSensitivityTest(DummyDataTestCase, _common.TestCase):
+    """If case_insensitive is false, lower-case values should be placed
+    after all upper-case values. E.g., `Foo Qux bar`
+    """
+
+    def setUp(self):
+        super(CaseSensitivityTest, self).setUp()
+
+        album = _common.album()
+        album.album = "album"
+        album.genre = "alternative"
+        album.year = "2001"
+        album.flex1 = "flex1"
+        album.flex2 = "flex2-A"
+        album.albumartist = "bar"
+        album.albumartist_sort = None
+        self.lib.add(album)
+
+        item = _common.item()
+        item.title = 'another'
+        item.artist = 'lowercase'
+        item.album = 'album'
+        item.year = 2001
+        item.comp = True
+        item.flex1 = "flex1"
+        item.flex2 = "flex2-A"
+        item.album_id = album.id
+        item.artist_sort = None
+        self.lib.add(item)
+
+        self.new_album = album
+        self.new_item = item
+
+    def tearDown(self):
+        self.new_item.remove(delete=True)
+        self.new_album.remove(delete=True)
+        super(CaseSensitivityTest, self).tearDown()
+
+    def test_smart_artist_case_insensitive(self):
+        config['sort_case_insensitive'] = True
+        q = 'artist+'
+        results = list(self.lib.items(q))
+        self.assertEqual(results[0].artist, 'lowercase')
+        self.assertEqual(results[1].artist, 'One')
+
+    def test_smart_artist_case_sensitive(self):
+        config['sort_case_insensitive'] = False
+        q = 'artist+'
+        results = list(self.lib.items(q))
+        self.assertEqual(results[0].artist, 'One')
+        self.assertEqual(results[-1].artist, 'lowercase')
+
+    def test_fixed_field_case_insensitive(self):
+        config['sort_case_insensitive'] = True
+        q = 'album+'
+        results = list(self.lib.albums(q))
+        self.assertEqual(results[0].album, 'album')
+        self.assertEqual(results[1].album, 'Album A')
+
+    def test_fixed_field_case_sensitive(self):
+        config['sort_case_insensitive'] = False
+        q = 'album+'
+        results = list(self.lib.albums(q))
+        self.assertEqual(results[0].album, 'Album A')
+        self.assertEqual(results[-1].album, 'album')
+
+    def test_flex_field_case_insensitive(self):
+        config['sort_case_insensitive'] = True
+        q = 'flex1+'
+        results = list(self.lib.items(q))
+        self.assertEqual(results[0].flex1, 'flex1')
+        self.assertEqual(results[1].flex1, 'Flex1-0')
+
+    def test_flex_field_case_sensitive(self):
+        config['sort_case_insensitive'] = False
+        q = 'flex1+'
+        results = list(self.lib.items(q))
+        self.assertEqual(results[0].flex1, 'Flex1-0')
+        self.assertEqual(results[-1].flex1, 'flex1')
+
+
 def suite():
     return unittest.TestLoader().loadTestsFromName(__name__)