Add QuickSilver port

Author: bcse

README.md

@@ -1,39 +1,41 @@
 String Score
 ============
 
-Port of [LiquidMetal](https://github.com/rmm5t/liquidmetal) from JavaScript to Python.
-
 An algorithm provides scores between 0.0 (no match) to 1.0 (perfect match) for a comparison of two strings.
 
+The algorithm is designed for auto-completion. For string similarity, please check [Levenshtein distance](https://en.wikipedia.org/wiki/Levenshtein_distance) ([Wagner–Fischer algorithm](https://en.wikipedia.org/wiki/Wagner-Fischer_algorithm)).
+
 Usage
 -----
 
 Include the library:
 
 ```python
-import stringscore
+from stringscore import liquidmetal
 ```
 
 Score any string against an abbreviation:
 
 ```python
->>> stringscore.score('FooBar',  'foo')
+>>> liquidmetal.score('FooBar', 'foo')
 0.95
->>> stringscore.score('FooBar',  'fb')
+>>> liquidmetal.score('FooBar', 'fb')
 0.916666666667
->>> stringscore.score('Foo Bar', 'fb')
+>>> liquidmetal.score('Foo Bar', 'fb')
 0.928571428571
->>> stringscore.score('Foo Bar', 'baz')
+>>> liquidmetal.score('Foo Bar', 'baz')
 0.0
->>> stringscore.score('Foo Bar', '')
+>>> liquidmetal.score('Foo Bar', '')
 0.8
 ```
 
 Similar Works
 -------------
 
-- Quicksilver's [scoreForAbbreviation](https://github.com/quicksilver/Quicksilver/blob/master/Quicksilver/Code-QuickStepFoundation/NSString_BLTRExtensions.m#L53) algorithm by Alcor
+- Quicksilver's [scoreForAbbreviation](https://github.com/quicksilver/Quicksilver/blob/master/Quicksilver/Code-QuickStepFoundation/NSString_BLTRExtensions.m#L53) algorithm by Alcor (Blacktree, Inc)
+- [LiquidMetal](https://github.com/rmm5t/liquidmetal) by Ryan McGeary
 - [string_score](https://github.com/joshaven/string_score) by Joshaven Potter
+- [jQuery.fuzzyMatch](https://github.com/rapportive-oss/jquery-fuzzymatch) by [Rapportive](http://rapportive.com/)
 
 License
 -------
@@ -43,5 +45,6 @@ String Score is released under the [MIT License](http://opensource.org/licenses/
 Credits
 -------
 
+Copyright © 2003 Blacktree, Inc (Original author of [Quicksilver](https://github.com/quicksilver/Quicksilver))  
 Copyright © 2009 Ryan McGeary (Author of [LiquidMetal](https://github.com/rmm5t/liquidmetal))  
 Copyright © 2013 Grey Lee

setup.py

@@ -1,11 +1,12 @@
 from distutils.core import setup
 setup(name='stringscore',
-      version='1.2.1',
+      version='1.0',
       description='An algorithm provides scores between 0.0 (no match) to 1.0 (perfect match) for a comparison of two strings.',
       classifiers=[
         'Development Status :: 3 - Alpha',
         'Intended Audience :: Developers',
         'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
         'Programming Language :: Python',
         'Programming Language :: Python :: 2',
         'Programming Language :: Python :: 2.5',
@@ -22,5 +23,6 @@
       url='https://github.com/bcse/stringscore',
       license='MIT License',
       packages=['stringscore'],
+      package_dir={'stringscore': 'stringscore'},
       platforms=['any'],
       )

stringscore/__init__.py

@@ -0,0 +1,12 @@
+"""
+String Score
+~~~~~~~~~~~~
+
+An algorithm provides scores between 0.0 (no match) to 1.0 (perfect match) for a comparison of two strings.
+
+:copyright: (c) 2013 by Grey Lee.
+:license: MIT License.
+"""
+
+__version__ = '1.0'
+__author__ = 'Grey Lee <bcse@bcse.tw>'

stringscore.py stringscore/liquidmetal.pystringscore.py renamed to stringscore/liquidmetal.py

@@ -1,18 +1,5 @@
-"""
-String Score
-~~~~~~~~~~~~
-
-Port of [LiquidMetal](https://github.com/rmm5t/liquidmetal) from JavaScript to Python.
-
-An algorithm provides scores between 0.0 (no match) to 1.0 (perfect match) for a comparison of two strings.
-
-:copyright: (c) 2013 by Grey Lee.
-:license: MIT License.
-"""
-
-__version__ = '1.2.1'
-__author__ = 'Grey Lee <bcse@bcse.tw>'
-
+# Ported from LiquidMetal
+# https://github.com/rmm5t/liquidmetal
 
 SCORE_NO_MATCH = 0.0
 SCORE_MATCH = 1.0
@@ -130,4 +117,4 @@ def fill_array(array, value, begin, end):
         if len(abbrev) > len(string):
             string, abbrev = abbrev, string
         score(string, abbrev)
-    print 'Benchmark: %ss' % (clock() - t0)
+    print('Benchmark: %ss' % (clock() - t0))

stringscore/quicksilver.py

@@ -0,0 +1,75 @@
+# Ported from Quicksilver's scoreForAbbreviation algorithm
+# https://github.com/quicksilver/Quicksilver/
+
+SCORE_NO_MATCH = 0.0
+SCORE_MATCH = 1.0
+SCORE_TRAILING = 0.9
+SCORE_BUFFER = 0.15
+WHITESPACE_CHARACTERS = ' \t'
+
+
+def score(string, abbrev):
+    abbrev = abbrev.lower()
+    abbrev_len = len(abbrev)
+    string_len = len(string)
+
+    # deduct some points for all remaining letters
+    if abbrev_len == 0:
+        return SCORE_TRAILING
+    if abbrev_len > string_len:
+        return SCORE_NO_MATCH
+
+    # Search for steadily smaller portions of the abbreviation
+    for i in range(abbrev_len, 0, -1):
+        try:
+            index = string.lower().index(abbrev[:i])
+        except ValueError:
+            continue  # Not found
+
+        if index + abbrev_len > string_len:
+            continue
+
+        next_string = string[index + i:]
+        next_abbrev = abbrev[i:]
+
+        # Search what is left of the string with the rest of the abbreviation
+        remaining_score = score(next_string, next_abbrev)
+
+        if remaining_score > 0:
+            result_score = index + i
+
+            # ignore skipped characters if is first letter of a word
+            if index > 0:  # if some letters were skipped
+                if string[index - 1] in WHITESPACE_CHARACTERS:
+                    for j in range(index - 1):
+                        c = string[j]
+                        result_score -= SCORE_MATCH \
+                                        if c in WHITESPACE_CHARACTERS \
+                                        else SCORE_BUFFER
+                elif 'A' <= string[index] <= 'Z':
+                    for j in range(index):
+                        c = string[j]
+                        result_score -= SCORE_MATCH \
+                                        if 'A' <= c <= 'Z' \
+                                        else SCORE_BUFFER
+                else:
+                    result_score -= index
+
+            result_score += remaining_score * len(next_string)
+            result_score /= string_len
+            return result_score
+
+    return SCORE_NO_MATCH
+
+
+if __name__ == '__main__':
+    from time import clock
+    t0 = clock()
+    test_string = 'a'
+    for string in open('/usr/share/dict/words'):
+        abbrev = test_string
+        test_string = string
+        if len(abbrev) > len(string):
+            string, abbrev = abbrev, string
+        score(string, abbrev)
+    print('Benchmark: %ss' % (clock() - t0))

test_stringscore.py

@@ -1,16 +1,17 @@
 import unittest
 
-import stringscore
+from stringscore import liquidmetal
+from stringscore import quicksilver
 
 
-class StringScoreTestCase(unittest.TestCase):
+class LiquidMetalTestCase(unittest.TestCase):
 
     def test_score(self):
-        n = stringscore.SCORE_NO_MATCH
-        m = stringscore.SCORE_MATCH
-        t = stringscore.SCORE_TRAILING
-        s = stringscore.SCORE_TRAILING_BUT_STARTED
-        b = stringscore.SCORE_BUFFER
+        n = liquidmetal.SCORE_NO_MATCH
+        m = liquidmetal.SCORE_MATCH
+        t = liquidmetal.SCORE_TRAILING
+        s = liquidmetal.SCORE_TRAILING_BUT_STARTED
+        b = liquidmetal.SCORE_BUFFER
 
         tests = {
             ('', ''): [t],
@@ -46,10 +47,49 @@ def test_score(self):
         }
 
         for k, v in tests.items():
-            score = round(stringscore.score(*k), 12)
+            score = round(liquidmetal.score(*k), 12)
             expected_score = round(sum(v) / len(v), 12)
             self.assertEqual(score, expected_score)
 
 
+class QuickSilverTestCase(unittest.TestCase):
+
+    def test_score(self):
+        tests = [
+            (('', ''), 0.9),
+            (('', 'a'), 0.0),
+            (('a', ''), 0.9),
+            (('a', 'toolong'), 0.0),
+            (('a', 'a'), 1.0),
+            (('a', 'b'), 0.0),
+            (('abc', ''), 0.9),
+            (('abc', 'a'), 0.933333333333),
+            (('abc', 'b'), 0.633333333333),
+            (('abc', 'c'), 0.333333333333),
+            (('abc', 'd'), 0.0),
+            (('A', 'a'), 1.0),
+            (('A', 'b'), 0.0),
+            (('FooBar', ''), 0.9),
+            (('FooBar', 'foo'), 0.95),
+            (('FooBar', 'fb'), 0.916666666667),
+            (('foobar', 'fb'), 0.633333333333),
+            (('FooBar', 'b'), 0.75),
+            (('FooBar', 'ooar'), 0.666666666667),
+            (('FooBar', 'bab'), 0.0),
+            (('Foo Bar', ''), 0.9),
+            (('Foo Bar', 'foo'), 0.942857142857),
+            (('Foo Bar', 'fb'), 0.928571428571),
+            (('Foo-Bar', 'fb'), 0.907142857143),
+            (('Foo_Bar', 'fb'), 0.907142857143),
+            (('Foo Bar', 'b'), 0.907142857143),
+            (('Foo Bar', 'ooar'), 0.571428571429),
+            (('Foo Bar', 'bab'), 0.0),
+            (('gnu\'s Not Unix', 'nu'), 0.85),
+        ]
+
+        for k, v in tests:
+            self.assertEqual(round(quicksilver.score(*k), 12), v)
+
+
 if __name__ == '__main__':
     unittest.main()