Merge pull request #116 from balshetzer/master

A variety of updates

Author: balshetzer

plover/assets/american_english_words.txt

@@ -3,6 +3,7 @@
 
 """Configuration management."""
 
+import ConfigParser
 from ConfigParser import RawConfigParser
 import os
 import shutil
@@ -127,20 +128,28 @@ def get_machine_type(self):
                          DEFAULT_MACHINE_TYPE)
 
     def set_machine_specific_options(self, machine_name, options):
-        if not self._config.has_section(machine_name):
-            self._config.add_section(machine_name)
+        if self._config.has_section(machine_name):
+            self._config.remove_section(machine_name)
+        self._config.add_section(machine_name)
         for k, v in options.items():
             self._config.set(machine_name, k, str(v))
 
     def get_machine_specific_options(self, machine_name):
+        def convert(p, v):
+            try:
+                return p[1](v)
+            except ValueError:
+                return p[0]
         machine = machine_registry.get(machine_name)
-        option_info = machine.get_option_info()
+        info = machine.get_option_info()
+        defaults = {k: v[0] for k, v in info.items()}
         if self._config.has_section(machine_name):
-            options = dict((o, self._config.get(machine_name, o)) 
-                           for o in self._config.options(machine_name))
-            return dict((k, option_info[k][1](v)) for k, v in options.items()
-                        if k in option_info)
-        return dict((k, v[0]) for k, v in option_info.items())
+            options = {o: self._config.get(machine_name, o) 
+                       for o in self._config.options(machine_name)
+                       if o in info}
+            options = {k: convert(info[k], v) for k, v in options.items()}
+            defaults.update(options)
+        return defaults
 
     def set_dictionary_file_names(self, filenames):
         if self._config.has_section(DICTIONARY_CONFIG_SECTION):

plover/config.py

@@ -559,7 +559,7 @@ def __call__(self):
         return cur
 
 
-def _read(port, stop, seq, request_buf, response_buf, stroke_buf, timeout=1):
+def _read(port, stop, seq, request_buf, response_buf, stroke_buf, block, byte, timeout=1):
     """Read the full contents of the current file from beginning to end.
 
     The file should be opened first.
@@ -580,7 +580,7 @@ def _read(port, stop, seq, request_buf, response_buf, stroke_buf, timeout=1):
     _ConnectionLostException: If we can't seem to talk to the machine.
 
     """
-    bytes_read, block, byte = 0, 0, 0
+    bytes_read = 0
     while True:
         packet = _make_read(request_buf, seq(), block, byte, length=512)
         response = _send_receive(port, stop, packet, response_buf,
@@ -590,7 +590,7 @@ def _read(port, stop, seq, request_buf, response_buf, stroke_buf, timeout=1):
                 (p1 == len(response) - 16)):          # Data.
             raise _ProtocolViolationException()
         if p1 == 0:
-            return buffer(stroke_buf, 0, bytes_read)
+            return block, byte, buffer(stroke_buf, 0, bytes_read)
         data = buffer(response, 14, p1)
         _write_to_buffer(stroke_buf, bytes_read, data)
         bytes_read += len(data)
@@ -631,10 +631,11 @@ def _loop(port, stop, callback, ready_callback, timeout=1):
     # Any checking needed on the response packet?
     _send_receive(port, stop, request, response_buf)
     # Do a full read to get to the current position in the realtime file.
-    _read(port, stop, seq, request_buf, response_buf, stroke_buf)
+    block, byte = 0, 0
+    block, byte, _ = _read(port, stop, seq, request_buf, response_buf, stroke_buf, block, byte)
     ready_callback()
     while True:
-        data = _read(port, stop, seq, request_buf, response_buf, stroke_buf)
+        block, byte, data = _read(port, stop, seq, request_buf, response_buf, stroke_buf, block, byte)
         strokes = _parse_strokes(data)
         for stroke in strokes:
             callback(stroke)

plover/machine/stentura.py

@@ -505,23 +505,28 @@ def test_read(self):
             requests, responses = make_readc_packets(data)
             port = MockPacketPort(responses, requests)
             seq = stentura._SequenceCounter()
-            response = stentura._read(port, event, seq, request_buf,
-                                      response_buf, stroke_buf)
+            block, byte = 0, 0
+            block, byte, response = stentura._read(port, event, seq, request_buf,
+                                      response_buf, stroke_buf, block, byte)
             self.assertEqual(data, str(response))
+            self.assertEqual(block, len(data) / 512)
+            self.assertEqual(byte, len(data) % 512)
 
     def test_loop(self):
         class Event(object):
             def __init__(self, count, data, stop=False):
                 self.count = count
                 self.data = data
                 self.stop = stop
+                
+            def __repr__(self):
+                return '<{}, {}, {}>'.format(self.count, self.data, self.stop)
 
         class MockPort(object):
             def __init__(self, events=[]):
                 self._file = ''
                 self._out = ''
                 self._is_open = False
-                self._read_pos = 0
                 self.event = threading.Event()
                 self.count = 0
                 self.events = [Event(*x) for x in
@@ -536,17 +541,15 @@ def write(self, request):
                 if p['action'] == stentura._OPEN:
                     self._out = make_response(p['seq'], p['action'])
                     self._is_open = True
-                    self._read_pos = 0
                 elif p['action'] == stentura._READC:
                     if not self._is_open:
                         raise Exception("no open")
                     length, block, byte = p['p3'], p['p4'], p['p5']
                     seq = p['seq']
                     action = stentura._READC
-                    start = self._read_pos + block * 512 + byte
+                    start = block * 512 + byte
                     end = start + length
                     data = self._file[start:end]
-                    self._read_pos += len(data)
                     self._out = make_response(seq, action, p1=len(data),
                                               data=data)
                 while self.events and self.events[0].count <= self.count:
@@ -584,7 +587,7 @@ def flushOutput(self):
             # Ignore data that's there before we started.
             (MockPort([(46, '', True)]).append(data2), []),
             # Ignore data that was there and also parse some strokes.
-            (MockPort([(5, data1), (36, '', True)]).append(data2), data1_trans)
+            (MockPort([(25, data1), (36, '', True)]).append(data2), data1_trans)
         ]
 
         for test in tests:

plover/machine/test_stentura.py

@@ -8,10 +8,12 @@
 from plover.config import ASSETS_DIR
 
 word_list_file_name = os.path.join(ASSETS_DIR, 'american_english_words.txt')
-WORDS = set()
+WORDS = dict()
 try:
     with open(word_list_file_name) as f:
-        WORDS = set(word.strip().lower() for word in f)
+        pairs = [word.strip().rsplit(' ', 1) for word in f]
+        pairs.sort(reverse=True, key=lambda x: int(x[1]))
+        WORDS = {p[0].lower(): int(p[1]) for p in pairs}
 except IOError as e:
     print e
 
@@ -59,43 +61,46 @@
 ]
 
 
-def try_rules(word, suffix, check=lambda x: True):
-    """Add suffix to word using RULES."""
+def make_candidates_from_rules(word, suffix, check=lambda x: True):
+    candidates = []
     for r in RULES:
         m = r[0].match(word + " ^ " + suffix)
         if m:   
             expanded = m.expand(r[1])
             if check(expanded):
-                return expanded
-    return None
-
+                candidates.append(expanded)
+    return candidates
 
 def _add_suffix(word, suffix):
     in_dict_f = lambda x: x in WORDS
+
+    candidates = []
 
     # Try 'ible' and see if it's in the dictionary.
     if suffix == 'able':
-        expanded = try_rules(word, 'ible', in_dict_f)
-        if expanded:
-            return expanded
+        candidates.extend(make_candidates_from_rules(word, 'ible', in_dict_f))
 
     # Try a simple join if it is in the dictionary.
-    expanded = word + suffix
-    if expanded in WORDS:
-        return expanded
+    simple = word + suffix
+    if in_dict_f(simple):
+        candidates.append(simple)
 
     # Try rules with dict lookup.
-    expanded = try_rules(word, suffix, in_dict_f)
-    if expanded:
-        return expanded
+    candidates.extend(make_candidates_from_rules(word, suffix, in_dict_f))
+
+    # For all candidates sort by prominence in dictionary and, since sort is
+    # stable, also by the order added to candidates list.
+    if candidates:
+        candidates.sort(key=lambda x: WORDS[x])
+        return candidates[0]
 
     # Try rules without dict lookup.
-    expanded = try_rules(word, suffix)
-    if expanded:
-        return expanded
+    candidates = make_candidates_from_rules(word, suffix)
+    if candidates:
+        return candidates[0]
 
     # If all else fails then just do a simple join.
-    return word + suffix
+    return simple
 
 def add_suffix(word, suffix):
     """Add a suffix to a word by applying the rules above

plover/orthography.py

@@ -1,6 +1,40 @@
-from Quartz import *
+from Quartz import (
+    CFMachPortCreateRunLoopSource,
+    CFRunLoopAddSource,
+    CFRunLoopGetCurrent,
+    CFRunLoopRun,
+    CFRunLoopStop,
+    CGEventCreateKeyboardEvent,
+    CGEventGetFlags,
+    CGEventGetIntegerValueField,
+    CGEventMaskBit,
+    CGEventPost,
+    CGEventSetFlags,
+    CGEventSourceCreate,
+    CGEventSourceGetSourceStateID,
+    CGEventTapCreate,
+    CGEventTapEnable,
+    kCFRunLoopCommonModes,
+    kCGEventFlagMaskAlternate,
+    kCGEventFlagMaskCommand,
+    kCGEventFlagMaskControl,
+    kCGEventFlagMaskNonCoalesced,
+    kCGEventFlagMaskShift,
+    kCGEventKeyDown,
+    kCGEventKeyUp,
+    kCGEventSourceStateID,
+    kCGEventTapOptionDefault,
+    kCGHeadInsertEventTap,
+    kCGKeyboardEventKeycode,
+    kCGSessionEventTap,
+)
 import threading
 import collections
+import ctypes
+import ctypes.util
+import objc
+import sys
+
 
 # This mapping only works on keyboards using the ANSI standard layout. Each
 # entry represents a sequence of keystrokes that are needed to achieve the
@@ -250,6 +284,26 @@ def is_keyboard_suppressed(self):
         return self._suppress_keyboard
 
 
+# "Narrow python" unicode objects store chracters in UTF-16 so we 
+# can't iterate over characters in the standard way. This workaround 
+# let's us iterate over full characters in the string.
+def characters(s):
+    encoded = s.encode('utf-32-be')
+    characters = []
+    for i in xrange(len(encoded)/4):
+        start = i * 4
+        end = start + 4
+        character = encoded[start:end].decode('utf-32-be')
+        yield character
+
+CGEventKeyboardSetUnicodeString = ctypes.cdll.LoadLibrary(ctypes.util.find_library('ApplicationServices')).CGEventKeyboardSetUnicodeString
+CGEventKeyboardSetUnicodeString.restype = None
+native_utf16 = 'utf-16-le' if sys.byteorder == 'little' else 'utf-16-be'
+
+def set_string(event, s):
+    buf = s.encode(native_utf16)
+    CGEventKeyboardSetUnicodeString(objc.pyobjc_id(event), len(buf) / 2, buf)
+
 class KeyboardEmulation(object):
 
     def __init__(self):
@@ -263,8 +317,13 @@ def send_backspaces(self, number_of_backspaces):
                 CGEventCreateKeyboardEvent(MY_EVENT_SOURCE, 51, False))
 
     def send_string(self, s):
-        for c in s:
-            self._send_sequence(down_up(KEYNAME_TO_KEYCODE[LITERALS[c]]))
+        for c in characters(s):
+            event = CGEventCreateKeyboardEvent(MY_EVENT_SOURCE, 0, True)
+            set_string(event, c)
+            CGEventPost(kCGSessionEventTap, event)
+            event = CGEventCreateKeyboardEvent(MY_EVENT_SOURCE, 0, False)
+            set_string(event, c)
+            CGEventPost(kCGSessionEventTap, event)
 
     def send_key_combination(self, combo_string):
         """Emulate a sequence of key combinations.

plover/oslayer/osxkeyboardcontrol.py

@@ -162,7 +162,7 @@ class KeyboardEmulation:
         "F16": "{F16}",
     }
 
-    SPECIAL_CHARS_PATTERN = re.compile(r'([{}[\]()+^%~])')
+    SPECIAL_CHARS_PATTERN = re.compile(r'([]{}()+^%~[])')
 
     def send_backspaces(self, number_of_backspaces):
         for _ in xrange(number_of_backspaces):

plover/oslayer/winkeyboardcontrol.py

@@ -126,23 +126,17 @@ def get_option_info():
                     'booloption1': (True, bool_converter),
                     'booloption2': (False, bool_converter)
                 }
+        defaults = {k: v[0] for k, v in FakeMachine.get_option_info().items()}
+
         machine_name = 'machine foo'
         registry = Registry()
         registry.register(machine_name, FakeMachine)
         with patch('plover.config.machine_registry', registry):
             c = config.Config()
 
             # Check default value.
-            expected = {
-                'stroption1': None,
-                'intoption1': 3,
-                'stroption2': 'abc',
-                'floatoption1': 1,
-                'booloption1': True,
-                'booloption2': False,
-            }
             actual = c.get_machine_specific_options(machine_name)
-            self.assertEqual(actual, expected)
+            self.assertEqual(actual, defaults)
 
             # Make sure setting a value is reflecting in the getter.
             options = {
@@ -153,12 +147,13 @@ def get_option_info():
             }
             c.set_machine_specific_options(machine_name, options)
             actual = c.get_machine_specific_options(machine_name)
-            self.assertEqual(actual, options)
+            expected = dict(defaults.items() + options.items())
+            self.assertEqual(actual, expected)
 
-            # Test loading a file.
+            # Test loading a file. Unknown option is ignored.
             s = '\n'.join(('[machine foo]', 'stroption1 = foo', 
                            'intoption1 = 3', 'booloption1 = True', 
-                           'booloption2 = False'))
+                           'booloption2 = False', 'unknown = True'))
             f = StringIO(s)
             c.load(f)
             expected = {
@@ -167,13 +162,27 @@ def get_option_info():
                 'booloption1': True,
                 'booloption2': False,
             }
+            expected = dict(defaults.items() + expected.items())
             actual = c.get_machine_specific_options(machine_name)
             self.assertEqual(actual, expected)
 
             # Test saving a file.
             f = StringIO()
             c.save(f)
             self.assertEqual(f.getvalue(), s + '\n\n')
+            
+            # Test reading invalid values.
+            s = '\n'.join(['[machine foo]', 'floatoption1 = None', 
+                           'booloption2 = True'])
+            f = StringIO(s)
+            c.load(f)
+            expected = {
+                'floatoption1': 1,
+                'booloption2': True,
+            }
+            expected = dict(defaults.items() + expected.items())
+            actual = c.get_machine_specific_options(machine_name)
+            self.assertEqual(actual, expected)
 
     def test_dictionary_option(self):
         c = config.Config()