AXTyper 0.7.0

data/.yardopts.typer

@@ -0,0 +1,10 @@
+--no-cache
+--no-output
+--verbose
+--markup markdown
+--markup-provider redcarpet
+--readme README.markdown.typer
+lib/**/*.rb
+ext/**/*.m
+-
+docs/KeyboardEvents.markdown

data/README.markdown.typer

@@ -0,0 +1,74 @@
+# AXTyper
+
+This gem is a component of AXElements. It provides an interface for
+posting keyboard events to the system as well as a mixin for parsing
+a string into a series of events.
+
+## Demo
+
+The basics:
+
+```ruby
+    require 'accessibility/string'
+
+    include Accessibility::String
+
+    keyboard_events_for("Hey, there!").each do |event|
+      KeyCoder.post_event event
+    end
+```
+
+Something a bit more advanced:
+
+```ruby
+    require 'accessibility/string'
+
+    include Accessibility::String
+
+    keyboard_events_for("\\COMMAND+\t").each do |event|
+      KeyCoder.post_event event
+    end
+```
+
+## Testing
+
+Running the AXElements test suite for only the AXTyper related tests
+can be accomplished with the `test:string` task.
+
+```shell
+    rake test:string
+```
+
+## TODO
+
+The API for posting events is ad-hoc for the sake of demonstration;
+AXElements exposes this functionality via `Kernel#type`. The standalone
+API provided here could be improved.
+
+## License
+
+Copyright (c) 2012 Marketcircle Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Marketcircle Inc. nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL Marketcircle Inc. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/docs/KeyboardEvents.markdown

@@ -0,0 +1,119 @@
+# Keyboard Events
+
+Keyboard events are a system provided by Apple that allows you to
+simulate keyboard input. The API for this in the `ApplicationServices`
+framework, but there is an analogue in the `Acessibility` APIs which
+has the additional option of directing the input to a specific application.
+
+Using accessibility actions and setting attributes you can already
+perform most of the interactions that would be possible with the
+keyboard simulation. However, there are some things that you will need
+to, or it will just make more sense to, simulate keyboard input. For
+example, to make use of hot keys you would have to add extra actions
+or attributes to a control in the application; that would be more
+work, possibly prone to error, than simply simulating the hot key from
+outside the application. In other situations you may specifically want
+to test out keyboard navigation and so actions would not be a good
+substitute. It may be that the APIs that AXElements provides for
+typing just make more sense when writing tests or scripts.
+
+## Typing with the DSL
+
+The {Accessibility::DSL} mixin exposes keyboard events through the
+`type` method. A simple example would look like this:
+
+    type "Hello, #{ENV['USER']}! How are you today?\n"
+
+And watch your computer come to life! The `type` command takes an
+additional optional parameter that we'll get to later. The first
+parameter is just a string that you want AXElements to type out. How
+to format the string should be obvious for the most part, but some
+things like the command key and arrows might not be so obvious.
+
+## Formatting Strings
+
+Letters and numbers should be written just as you would for any other
+string. Any of the standard symbols can also be plainly added to a
+string that you want to have typed. Here are some examples:
+
+    type "UPPER CASE LETTERS"
+    type "lower case letters"
+    type "1337 message @/\/|) 57|_||=|="
+    type "A proper sentence can be typed out (all at once)."
+
+### Regular Escape Sequences
+
+Things like newlines and tabs should be formatted just like they would
+ in a regular string. That is, normal string escape sequences should
+ "just work" with AXElements. Here are some more examples:
+
+    type "Have a bad \b\b\b\b\b good day!"
+    type "First line.\nSecond line."
+    type "I \t like \t to \t use \t tabs \t a \t lot."
+    type "Explicit\sSpaces."
+
+### Custom Escape Sequences
+
+Unfortunately, there is no built in escape sequence for deleting to
+the right or pressing command keys like `F1`. AXElements defines some
+extra escape sequences in order to easily represent the remaining
+keys.
+
+These custom escape sequences __shoud start with two `\` characters__,
+as in this example:
+
+    type "\\F1"
+
+A custom escape sequence __should terminate with a space or the end of
+the string__, as in this example:
+
+    type "\\PAGEDOWN notice the space afterwards\\PAGEUP but not before"
+
+The full list of supported custom escape sequences is listed in
+{Accessibility::StringParser::ESCAPES}. Some escapes have an alias,
+such as the right arrow key which can be escaped as `"\\RIGHT"` or as
+`"\\->"`.
+
+### Hot Keys
+
+To support pressing multiple keys at the same time, also known as hot
+keys, you must start with the custom escape sequence for the
+combination and instead of ending with a space you should put a `+`
+character to chain the next key. The entire sequence should be ended
+with a space or nil. Some common examples are opening a file or
+quitting an application:
+
+    type "\\COMMAND+o"
+    type "\\CONTROL+a Typing at the start of the line"
+    type "\\COMMAND+\\SHIFT+s"
+
+You might also note that `CMD+SHIFT+s` could also be:
+
+    type "\\COMMAND+S"
+
+Since a capital `S` will cause the shift key to be held down.
+
+## Protips
+
+In order make sure that certain sequences of characters are properly
+escaped, it is recommended to simply always use double quoted
+strings.
+
+### Posting To A Specific Application
+
+The second argument to the `type` command can be an {AX::Application}
+object. If you do not include the argument, the events will be posted
+to the system, which usually means the application that currently is
+active. Note that you cannot be more specific than the application
+that you want to send the events to, within the application, the
+control that has keyboard focus will receive the events.
+
+### Changing Typing Speed
+
+You can set the typing speed at load time by setting the environment
+variable `KEY_RATE`. See {Accessibility::Core::KEY\_RATE} for details on
+possible values. An example of using it would be:
+
+    KEY_RATE=SLOW irb -rubygems -rax_elements
+    KEY_RATE=0.25 rspec gui_spec.rb
+

data/ext/accessibility/key_coder/extconf.rb

@@ -0,0 +1,12 @@
+require 'mkmf'
+
+$CFLAGS << ' -std=c99 -Wall -Werror -ObjC'
+$LIBS   << ' -framework Cocoa -framework Carbon -framework ApplicationServices'
+
+if RUBY_ENGINE == 'macruby'
+  $CFLAGS << ' -fobjc-gc'
+else
+  $CFLAGS << ' -DNOT_MACRUBY -fblocks'
+end
+
+create_makefile('accessibility/key_coder')

data/ext/accessibility/key_coder/key_coder.c

@@ -0,0 +1,87 @@
+/*
+ *  key_coder.c
+ *  KeyCoder
+ *
+ *  Created by Mark Rada on 11-07-27.
+ *  Copyright 2011 Marketcircle Incorporated. All rights reserved.
+ */
+
+
+#import <Cocoa/Cocoa.h>
+#import <Carbon/Carbon.h>
+#import <ApplicationServices/ApplicationServices.h>
+#include "ruby.h"
+
+static VALUE
+rb_keycoder_dynamic_mapping()
+{
+
+  VALUE map = rb_hash_new();
+
+#ifdef NOT_MACRUBY
+  @autoreleasepool {
+#endif
+
+  TISInputSourceRef keyboard = TISCopyCurrentKeyboardLayoutInputSource();
+  CFDataRef layout_data = (CFDataRef)TISGetInputSourceProperty(keyboard, kTISPropertyUnicodeKeyLayoutData);
+  const UCKeyboardLayout* layout = (const UCKeyboardLayout*)CFDataGetBytePtr(layout_data);
+
+  void (^key_coder)(int) = ^(int key_code) {
+    UniChar      string[255];
+    UniCharCount string_length = 0;
+    UInt32       dead_key_state = 0;
+    UCKeyTranslate(
+                   layout,
+		   key_code,
+		   kUCKeyActionDown,
+		   0,
+		   LMGetKbdType(),  // kb type
+		   0,               // OptionBits keyTranslateOptions,
+		   &dead_key_state,
+		   255,
+		   &string_length,
+		   string
+		  );
+
+    NSString* nsstring = [NSString stringWithCharacters:string length:string_length];
+    rb_hash_aset(map, rb_str_new_cstr([nsstring UTF8String]), INT2FIX(key_code));
+  };
+
+  // skip 65-92 since they are hard coded and do not change
+  for (int key_code = 0; key_code < 65; key_code++)
+    key_coder(key_code);
+  for (int key_code = 93; key_code < 127; key_code++)
+    key_coder(key_code);
+
+#ifdef NOT_MACRUBY
+  CFRelease(keyboard);
+  }; // Close the autorelease pool
+#else
+  CFMakeCollectable(keyboard);
+#endif
+
+  return map;
+}
+
+
+static VALUE
+rb_keycoder_post_event(VALUE self, VALUE event)
+{
+  VALUE code  = rb_ary_entry(event, 0);
+  VALUE state = rb_ary_entry(event, 1);
+
+  CGEventRef event_ref = CGEventCreateKeyboardEvent(NULL, FIX2LONG(code), state);
+  CGEventPost(kCGHIDEventTap, event_ref);
+
+  usleep(9000);
+  return Qtrue;
+}
+
+
+void
+Init_key_coder()
+{
+  VALUE rb_cKeyCoder = rb_define_class("KeyCoder", rb_cObject);
+  rb_define_singleton_method(rb_cKeyCoder, "dynamic_mapping", rb_keycoder_dynamic_mapping, 0);
+  rb_define_singleton_method(rb_cKeyCoder, "post_event", rb_keycoder_post_event, 1);
+}

data/lib/accessibility/string.rb

@@ -0,0 +1,488 @@
+# -*- coding: utf-8 -*-
+
+require   'accessibility/version'
+require   'accessibility/key_coder'
+framework 'ApplicationServices' if defined? MACRUBY_VERSION
+
+##
+# Parses strings of human readable text into a series of events meant to
+# be processed by {Accessibility::Core#post:to:} or {KeyCoder.post_event}.
+#
+# Supports most, if not all, latin keyboard layouts, maybe some
+# international layouts as well.
+module Accessibility::String
+
+  ##
+  # Generate keyboard events for the given string. Strings should be in a
+  # human readable with a few exceptions. Command key (e.g. control, option,
+  # command) should be written in string as they appear in
+  # {Accessibility::String::EventGenerator::CUSTOM}.
+  #
+  # For more details on event generation, read the
+  # {file:docs/KeyboardEvents.markdown Keyboard Events} documentation.
+  #
+  # @param [String]
+  # @return [Array<Array(Fixnum,Boolean)>]
+  def keyboard_events_for string
+    EventGenerator.new(Lexer.new(string).lex).generate
+  end
+
+  ##
+  # Tokenizer for strings. This class will take a string and break
+  # it up into chunks for the event generator. The structure generated
+  # here is an array that contains strings and recursively other arrays
+  # of strings and arrays of strings.
+  #
+  # @example
+  #
+  #   Lexer.new("Hai").lex          # => ['H','a','i']
+  #   Lexer.new("\\CAPSLOCK").lex   # => [["\\CAPSLOCK"]]
+  #   Lexer.new("\\COMMAND+a").lex  # => [["\\COMMAND", ['a']]]
+  #   Lexer.new("One\nTwo").lex     # => ['O','n','e',"\n",'T','w','o']
+  #
+  class Lexer
+
+    ##
+    # Once a string is lexed, this contains the tokenized structure.
+    #
+    # @return [Array<String,Array<String,...>]
+    attr_accessor :tokens
+
+    # @param [#to_s]
+    def initialize string
+      @chars  = string.to_s
+      @tokens = []
+    end
+
+    ##
+    # Tokenize the string that the lexer was initialized with and
+    # return the sequence of tokens that were lexed.
+    #
+    # @return [Array<String,Array<String,...>]
+    def lex
+      length = @chars.length
+      @index = 0
+      while @index < length
+        @tokens << if custom?
+                     lex_custom
+                   else
+                     lex_char
+                   end
+        @index += 1
+      end
+      @tokens
+    end
+
+
+    private
+
+    ##
+    # Is it a real custom escape? Kind of a lie, there is one
+    # case it does not handle--they get handled in the generator,
+    # but maybe they should be handled here?
+    # - An upper case letter or symbol following `"\\"` that is
+    #   not mapped
+    def custom?
+      @chars[@index] == CUSTOM_ESCAPE &&
+        (next_char = @chars[@index+1]) &&
+         next_char == next_char.upcase &&
+         next_char != SPACE
+    end
+
+    # @return [Array]
+    def lex_custom
+      start = @index
+      loop do
+        char = @chars[@index]
+        if char == PLUS
+          if @chars[@index-1] == CUSTOM_ESCAPE
+            @index += 1
+            return custom_subseq start
+          else
+            tokens  = custom_subseq start
+            @index += 1
+            return tokens << lex_custom
+          end
+        elsif char == SPACE
+          return custom_subseq start
+        elsif char == nil
+          raise ArgumentError, "Bad escape sequence" if start == @index
+          return custom_subseq start
+        else
+          @index += 1
+        end
+      end
+    end
+
+    # @return [Array]
+    def custom_subseq start
+      [@chars[start...@index]]
+    end
+
+    # @return [String]
+    def lex_char
+      @chars[@index]
+    end
+
+    # @private
+    SPACE         = " "
+    # @private
+    PLUS          = "+"
+    # @private
+    CUSTOM_ESCAPE = "\\"
+  end
+
+
+  ##
+  # @todo Add a method to generate just keydown or just keyup events.
+  #       Requires separating code lookup from event creation.
+  #
+  # Generate a sequence of keyboard events given a sequence of tokens.
+  # The token format is defined by the {Lexer} class output; it is best
+  # to use that class to generate the tokens.
+  #
+  # @example
+  #
+  #   # Upper case 'A'
+  #   EventGenerator.new(["A"]).generate  # => [[56,true],[70,true],[70,false],[56,false]]
+  #
+  #   # Press the caps lock button, turn it on
+  #   EventGenerator.new([["\\CAPS"]]).generate # => [[0x39,true],[0x39,false]]
+  #
+  #   # Hotkey, press and hold command key and then 'a', then release both
+  #   EventGenerator.new([["\\CMD",["a"]]]).generate # => [[55,true],[70,true],[70,false],[55,false]]
+  #
+  #   # Press the return/enter key
+  #   EventGenerator.new(["\n"]).generate # => [[10,true],[10,false]]
+  #
+  class EventGenerator
+
+    ##
+    # Regenerate the portion of the key mapping that is set dynamically
+    # based on keyboard layout (e.g. US, Dvorak, etc.).
+    #
+    # This method should be called whenever the keyboard layout changes.
+    # This can be called automatically by registering for a notification
+    # in a run looped environment.
+    def self.regenerate_dynamic_mapping
+      # KeyCoder is declared in the Objective-C extension
+      MAPPING.merge! KeyCoder.dynamic_mapping
+      # Also add an alias to the mapping
+      MAPPING["\n"] = MAPPING["\r"]
+    end
+
+    ##
+    # Dynamic mapping of characters to keycodes. The map is generated at
+    # startup time in order to support multiple keyboard layouts.
+    #
+    # @return [Hash{String=>Fixnum}]
+    MAPPING = {}
+
+    # Initialize the table
+    regenerate_dynamic_mapping
+
+    ##
+    # @note These mappings are all static and come from `/System/Library/Frameworks/Carbon.framework/Versions/A/Frameworks/HIToolbox.framework/Versions/A/Headers/Events.h`
+    #
+    # Map of custom escape sequences to their hardcoded keycode value.
+    #
+    # @return [Hash{String=>Fixnum}]
+    CUSTOM = {
+      "\\ESCAPE"        => 0x35,
+      "\\ESC"           => 0x35,
+      "\\COMMAND"       => 0x37,
+      "\\CMD"           => 0x37,
+      "\\SHIFT"         => 0x38,
+      "\\LSHIFT"        => 0x38,
+      "\\CAPS"          => 0x39,
+      "\\CAPSLOCK"      => 0x39,
+      "\\OPTION"        => 0x3A,
+      "\\OPT"           => 0x3A,
+      "\\ALT"           => 0x3A,
+      "\\CONTROL"       => 0x3B,
+      "\\CTRL"          => 0x3B,
+      "\\RSHIFT"        => 0x3C,
+      "\\ROPTION"       => 0x3D,
+      "\\ROPT"          => 0x3D,
+      "\\RALT"          => 0x3D,
+      "\\RCONTROL"      => 0x3E,
+      "\\RCTRL"         => 0x3E,
+      "\\FUNCTION"      => 0x3F,
+      "\\FN"            => 0x3F,
+      "\\VOLUMEUP"      => 0x48,
+      "\\VOLUP"         => 0x48,
+      "\\VOLUMEDOWN"    => 0x49,
+      "\\VOLDOWN"       => 0x49,
+      "\\MUTE"          => 0x4A,
+      "\\F1"            => 0x7A,
+      "\\F2"            => 0x78,
+      "\\F3"            => 0x63,
+      "\\F4"            => 0x76,
+      "\\F5"            => 0x60,
+      "\\F6"            => 0x61,
+      "\\F7"            => 0x62,
+      "\\F8"            => 0x64,
+      "\\F9"            => 0x65,
+      "\\F10"           => 0x6D,
+      "\\F11"           => 0x67,
+      "\\F12"           => 0x6F,
+      "\\F13"           => 0x69,
+      "\\F14"           => 0x6B,
+      "\\F15"           => 0x71,
+      "\\F16"           => 0x6A,
+      "\\F17"           => 0x40,
+      "\\F18"           => 0x4F,
+      "\\F19"           => 0x50,
+      "\\F20"           => 0x5A,
+      "\\HELP"          => 0x72,
+      "\\HOME"          => 0x73,
+      "\\END"           => 0x77,
+      "\\PAGEUP"        => 0x74,
+      "\\PAGEDOWN"      => 0x79,
+      "\\DELETE"        => 0x75,
+      "\\LEFT"          => 0x7B,
+      "\\<-"            => 0x7B,
+      "\\RIGHT"         => 0x7C,
+      "\\->"            => 0x7C,
+      "\\DOWN"          => 0x7D,
+      "\\UP"            => 0x7E,
+      "\\0"             => 0x52,
+      "\\1"             => 0x53,
+      "\\2"             => 0x54,
+      "\\3"             => 0x55,
+      "\\4"             => 0x56,
+      "\\5"             => 0x57,
+      "\\6"             => 0x58,
+      "\\7"             => 0x59,
+      "\\8"             => 0x5B,
+      "\\9"             => 0x5C,
+      "\\Decimal"       => 0x41,
+      "\\."             => 0x41,
+      "\\Plus"          => 0x45,
+      "\\+"             => 0x45,
+      "\\Multiply"      => 0x43,
+      "\\*"             => 0x43,
+      "\\Minus"         => 0x4E,
+      "\\-"             => 0x4E,
+      "\\Divide"        => 0x4B,
+      "\\/"             => 0x4B,
+      "\\Equals"        => 0x51,
+      "\\="             => 0x51,
+      "\\Enter"         => 0x4C,
+      "\\Clear"         => 0x47,
+    }
+
+    ##
+    # Mapping of shifted (characters written when holding shift) characters
+    # to keycodes.
+    #
+    # @return [Hash{String=>Fixnum}]
+    SHIFTED = {
+      '~'               => '`',
+      '!'               => '1',
+      '@'               => '2',
+      '#'               => '3',
+      '$'               => '4',
+      '%'               => '5',
+      '^'               => '6',
+      '&'               => '7',
+      '*'               => '8',
+      '('               => '9',
+      ')'               => '0',
+      '{'               => '[',
+      '}'               => ']',
+      '?'               => '/',
+      '+'               => '=',
+      '|'               => "\\",
+      ':'               => ';',
+      '_'               => '-',
+      '"'               => "'",
+      '<'               => ',',
+      '>'               => '.',
+      'A'               => 'a',
+      'B'               => 'b',
+      'C'               => 'c',
+      'D'               => 'd',
+      'E'               => 'e',
+      'F'               => 'f',
+      'G'               => 'g',
+      'H'               => 'h',
+      'I'               => 'i',
+      'J'               => 'j',
+      'K'               => 'k',
+      'L'               => 'l',
+      'M'               => 'm',
+      'N'               => 'n',
+      'O'               => 'o',
+      'P'               => 'p',
+      'Q'               => 'q',
+      'R'               => 'r',
+      'S'               => 's',
+      'T'               => 't',
+      'U'               => 'u',
+      'V'               => 'v',
+      'W'               => 'w',
+      'X'               => 'x',
+      'Y'               => 'y',
+      'Z'               => 'z',
+    }
+
+    ##
+    # Mapping of optioned (characters written when holding option/alt)
+    # characters to keycodes.
+    #
+    # @return [Hash{String=>Fixnum}]
+    OPTIONED = {
+      '¡'               => '1',
+      '™'               => '2',
+      '£'               => '3',
+      '¢'               => '4',
+      '∞'               => '5',
+      '§'               => '6',
+      '¶'               => '7',
+      '•'               => '8',
+      'ª'               => '9',
+      'º'               => '0',
+      '“'               => '[',
+      '‘'               => ']',
+      'æ'               => "'",
+      '≤'               => ',',
+      '≥'               => '.',
+      'π'               => 'p',
+      '¥'               => 'y',
+      'ƒ'               => 'f',
+      '©'               => 'g',
+      '®'               => 'r',
+      '¬'               => 'l',
+      '÷'               => '/',
+      '≠'               => '=',
+      '«'               => "\\",
+      'å'               => 'a',
+      'ø'               => 'o',
+      '´'               => 'e',
+      '¨'               => 'u',
+      'ˆ'               => 'i',
+      '∂'               => 'd',
+      '˙'               => 'h',
+      '†'               => 't',
+      '˜'               => 'n',
+      'ß'               => 's',
+      '–'               => '-',
+      '…'               => ';',
+      'œ'               => 'q',
+      '∆'               => 'j',
+      '˚'               => 'k',
+      '≈'               => 'x',
+      '∫'               => 'b',
+      'µ'               => 'm',
+      '∑'               => 'w',
+      '√'               => 'v',
+      'Ω'               => 'z',
+    }
+
+
+    ##
+    # Once {generate} is called, this contains the sequence of
+    # events.
+    #
+    # @return [Array<Array(Fixnum,Boolean)>]
+    attr_reader :events
+
+    # @param [Array<String,Array<String,Array...>>]
+    def initialize tokens
+      @tokens = tokens
+      # *3 since the output array will be at least *2 the
+      # number of tokens passed in, but will often be larger
+      # due to shifted/optioned characters and custom escapes;
+      # though a better number could be derived from
+      # analyzing common input...
+      @events = Array.new tokens.size*3
+    end
+
+    ##
+    # Generate the events for the tokens the event generator
+    # was initialized with. Returns the generated events.
+    #
+    # @return [Array<Array(Fixnum,Boolean)>]
+    def generate
+      @index = 0
+      gen_all @tokens
+      @events.compact!
+      @events
+    end
+
+
+    private
+
+    def add event
+      @events[@index] = event
+      @index += 1
+    end
+
+    def gen_all tokens
+      tokens.each do |token|
+        if token.kind_of? Array
+          gen_nested token.first, token[1..-1]
+        else
+          gen_single token
+        end
+      end
+    end
+
+    def gen_nested head, tail
+      if code = CUSTOM[head] || SHIFTED[head] || OPTIONED[head] || MAPPING[head]
+        add [code, true]
+        gen_all tail
+        add [code, false]
+      else # handling a special case
+        gen_all head.split(EMPTY_STRING)
+      end
+    end
+
+    def gen_single token
+      ((code =  MAPPING[token]) &&  gen_dynamic(code)) ||
+      ((code =  SHIFTED[token]) &&  gen_shifted(code)) ||
+      ((code = OPTIONED[token]) && gen_optioned(code)) ||
+      raise(ArgumentError, "#{token.inspect} has no mapping, bail!")
+    end
+
+    def gen_shifted code
+      add SHIFT_DOWN
+      gen_dynamic MAPPING[code]
+      add SHIFT_UP
+    end
+
+    def gen_optioned code
+      add OPTION_DOWN
+      gen_dynamic MAPPING[code]
+      add OPTION_UP
+    end
+
+    def gen_dynamic code
+      add [code,  true]
+      add [code, false]
+    end
+
+    # @private
+    EMPTY_STRING = ''
+    # @private
+    OPTION_DOWN  = [58, true]
+    # @private
+    OPTION_UP    = [58, false]
+    # @private
+    SHIFT_DOWN   = [56, true]
+    # @private
+    SHIFT_UP     = [56, false]
+  end
+
+end
+
+
+##
+# @note This will only work if a run loop is running
+#
+# Register to be notified if the keyboard layout changes at runtime
+# NSDistributedNotificationCenter.defaultCenter.addObserver Accessibility::String::EventGenerator,
+#                                                selector: 'regenerate_dynamic_mapping',
+#                                                    name: KTISNotifySelectedKeyboardInputSourceChanged,
+#                                                  object: nil

data/lib/accessibility/version.rb

@@ -0,0 +1,7 @@
+module Accessibility
+  # @return [String]
+  VERSION   = '0.7.0'
+
+  # @return [String]
+  CODE_NAME = 'Clefairy'
+end

data/test/runner.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+gem     'minitest'
+require 'minitest/autorun'
+
+# preprocessor powers, assemble!
+if ENV['BENCH']
+  require 'minitest/benchmark'
+else
+  require'minitest/pride'
+end
+
+
+class MiniTest::Unit::TestCase
+
+  # You may need this to help track down an issue if a test is crashing MacRuby
+  # def self.test_order
+  #   :alpha
+  # end
+
+  def self.bench_range
+    bench_exp 100, 100_000
+  end
+
+end

data/test/unit/accessibility/test_string.rb

@@ -0,0 +1,233 @@
+# -*- coding: utf-8 -*-
+
+require 'accessibility/string'
+
+class TestAccessibilityStringLexer < MiniTest::Unit::TestCase
+
+  def lex string
+    Accessibility::String::Lexer.new(string).lex
+  end
+
+  def test_lex_simple_string
+    assert_equal [],                                                    lex('')
+    assert_equal ['"',"J","u","s","t"," ","W","o","r","k","s",'"',"™"], lex('"Just Works"™')
+    assert_equal ["M","i","l","k",","," ","s","h","a","k","e","."],     lex("Milk, shake.")
+    assert_equal ["D","B","7"],                                         lex("DB7")
+  end
+
+  def test_lex_single_custom_escape
+    assert_equal [["\\CMD"]], lex("\\CMD")
+    assert_equal [["\\1"]],   lex("\\1")
+    assert_equal [["\\F1"]],  lex("\\F1")
+    assert_equal [["\\*"]],   lex("\\*")
+  end
+
+  def test_lex_hotkey_custom_escape
+    assert_equal [["\\COMMAND",[","]]],             lex("\\COMMAND+,")
+    assert_equal [["\\COMMAND",["\\SHIFT",["s"]]]], lex("\\COMMAND+\\SHIFT+s")
+    assert_equal [["\\COMMAND",["\\+"]]],           lex("\\COMMAND+\\+")
+    assert_equal [["\\FN",["\\F10"]]],              lex("\\FN+\\F10")
+  end
+
+  def test_lex_ruby_escapes
+    assert_equal ["\n","\r","\t","\b"],                                lex("\n\r\t\b")
+    assert_equal ["O","n","e","\n","T","w","o"],                       lex("One\nTwo")
+    assert_equal ["L","i","e","\b","\b","\b","d","e","l","i","s","h"], lex("Lie\b\b\bdelish")
+  end
+
+  def test_lex_complex_string
+    assert_equal ["T","e","s","t",["\\CMD",["s"]]],                          lex("Test\\CMD+s")
+    assert_equal ["Z","O","M","G"," ","1","3","3","7","!","!","1"],          lex("ZOMG 1337!!1")
+    assert_equal ["F","u","u","!","@","#","%",["\\CMD",["a"]],"\b"],         lex("Fuu!@#%\\CMD+a \b")
+    assert_equal [["\\CMD",["a"]],"\b","A","l","l"," ","g","o","n","e","!"], lex("\\CMD+a \bAll gone!")
+  end
+
+  def test_lex_backslash # make sure we handle these edge cases predictably
+    assert_equal ["\\"],             lex("\\")
+    assert_equal ["\\"," "],         lex("\\ ")
+    assert_equal ["\\","h","m","m"], lex("\\hmm")
+    assert_equal [["\\HMM"]],        lex("\\HMM") # the one missed case
+  end
+
+  def test_lex_plus_escape
+    assert_equal [["\\+"]], lex("\\+")
+  end
+
+  def test_lex_bad_custom_escape_sequence
+    assert_raises ArgumentError do
+      lex("\\COMMAND+")
+    end
+  end
+
+end
+
+
+class TestAccessibilityStringEventGenerator < MiniTest::Unit::TestCase
+
+  def gen tokens
+    Accessibility::String::EventGenerator.new(tokens).generate
+  end
+
+  def map; @@map ||= KeyCoder.dynamic_mapping; end
+
+  def t; true; end
+  def f; false; end
+
+  def a; @@a ||= map['a']; end
+  def c; @@c ||= map['c']; end
+  def e; @@e ||= map['e']; end
+  def h; @@h ||= map['h']; end
+  def i; @@i ||= map['i']; end
+  def k; @@k ||= map['k']; end
+  def m; @@m ||= map["m"]; end
+
+  def two;  @@two  ||= map['2']; end
+  def four; @@four ||= map['4']; end
+
+  def retern; @@retern ||= map["\r"]; end
+  def tab;    @@tab    ||= map["\t"]; end
+  def space;  @@space  ||= map["\s"]; end
+
+  def dash;  @@dash  ||= map["-"]; end
+  def comma; @@comma ||= map[","]; end
+  def apos;  @@apos  ||= map["'"]; end
+  def at;    @@at    ||= map["2"]; end
+  def paren; @@paren ||= map["9"]; end
+  def chev;  @@chev  ||= map["."]; end
+
+  def sigma; @@sigma ||= map["w"]; end
+  def tm;    @@tm    ||= map["2"]; end
+  def gbp;   @@gbp   ||= map["3"]; end
+  def omega; @@omega ||= map["z"]; end
+
+  def bslash; @@blash ||= map["\\"]; end
+
+  # key code for the left shift key
+  def sd; [56,t];  end
+  def su; [56,f]; end
+
+  # key code for the left option key
+  def od; [58,t];  end
+  def ou; [58,f]; end
+
+  # key code for the left command key
+  def cd; [0x37,t]; end
+  def cu; [0x37,f]; end
+
+  # key code for right arrow key
+  def rd; [0x7c,t]; end
+  def ru; [0x7c,f]; end
+
+  # key code for left control key
+  def ctrld; [0x3B,t]; end
+  def ctrlu; [0x3B,f]; end
+
+
+  def test_generate_lowercase
+    assert_equal [[a,t],[a,f]],                                     gen(['a'])
+    assert_equal [[c,t],[c,f],[k,t],[k,f]],                         gen(['c','k'])
+    assert_equal [[e,t],[e,f],[e,t],[e,f]],                         gen(['e','e'])
+    assert_equal [[c,t],[c,f],[a,t],[a,f],[k,t],[k,f],[e,t],[e,f]], gen(['c','a','k','e'])
+  end
+
+  def test_generate_uppercase
+    assert_equal [sd,[a,t],[a,f],su],                                     gen(['A'])
+    assert_equal [sd,[c,t],[c,f],su,sd,[k,t],[k,f],su],                   gen(['C','K'])
+    assert_equal [sd,[e,t],[e,f],su,sd,[e,t],[e,f],su],                   gen(['E','E'])
+    assert_equal [sd,[c,t],[c,f],su,sd,[a,t],[a,f],su,sd,[k,t],[k,f],su], gen(['C','A','K'])
+  end
+
+  def test_generate_numbers
+    assert_equal [[two,t],[two,f]],                   gen(['2'])
+    assert_equal [[four,t],[four,f],[two,t],[two,f]], gen(['4','2'])
+    assert_equal [[two,t],[two,f],[two,t],[two,f]],   gen(['2','2'])
+  end
+
+  def test_generate_ruby_escapes
+    assert_equal [[retern,t],[retern,f]], gen(["\r"])
+    assert_equal [[retern,t],[retern,f]], gen(["\n"])
+    assert_equal [[tab,t],[tab,f]],       gen(["\t"])
+    assert_equal [[space,t],[space,f]],   gen(["\s"])
+    assert_equal [[space,t],[space,f]],   gen([" "])
+  end
+
+  def test_generate_symbols
+    assert_equal [[dash,t],[dash,f]],         gen(["-"])
+    assert_equal [[comma,t],[comma,f]],       gen([","])
+    assert_equal [[apos,t],[apos,f]],         gen(["'"])
+    assert_equal [sd,[at,t],[at,f],su],       gen(["@"])
+    assert_equal [sd,[paren,t],[paren,f],su], gen(["("])
+    assert_equal [sd,[chev,t],[chev,f],su],   gen([">"])
+  end
+
+  def test_generate_unicode # holding option
+    assert_equal [od,[sigma,t],[sigma,f],ou], gen(["∑"])
+    assert_equal [od,[tm,t],[tm,f],ou],       gen(["™"])
+    assert_equal [od,[gbp,t],[gbp,f],ou],     gen(["£"])
+    assert_equal [od,[omega,t],[omega,f],ou], gen(["Ω"])
+  end
+
+  def test_generate_backslashes
+    assert_equal [[bslash,t],[bslash,f]],                                     gen(["\\"])
+    assert_equal [[bslash,t],[bslash,f],[space,t],[space,f]],                 gen(["\\"," "])
+    assert_equal [[bslash,t],[bslash,f],[h,t],[h,f],[m,t],[m,f]],             gen(["\\",'h','m'])
+    # is this the job of the parser or the lexer?
+    assert_equal [[bslash,t],[bslash,f],sd,[h,t],[h,f],su,sd,[m,t],[m,f],su], gen([["\\HM"]])
+  end
+
+  def test_generate_a_custom_escape
+    assert_equal [cd,cu],       gen([["\\COMMAND"]])
+    assert_equal [cd,cu],       gen([["\\CMD"]])
+    assert_equal [ctrld,ctrlu], gen([["\\CONTROL"]])
+    assert_equal [ctrld,ctrlu], gen([["\\CTRL"]])
+  end
+
+  def test_generate_hotkey
+    assert_equal [ctrld,[a,t],[a,f],ctrlu], gen([["\\CONTROL",["a"]]])
+    assert_equal [cd,sd,rd,ru,su,cu],       gen([["\\COMMAND",['\SHIFT',['\->']]]])
+  end
+
+  def test_generate_real_use # a regression
+    assert_equal [ctrld,[a,t],[a,f],ctrlu,[h,t],[h,f]], gen([["\\CTRL",["a"]],"h"])
+  end
+
+  def test_bails_for_unmapped_token
+    e = assert_raises ArgumentError do
+      gen(["☃"]) # cannot generate snowmen :(
+    end
+    assert_match /bail/i, e.message
+  end
+
+  def test_generate_arbitrary_nested_array_sequence
+    assert_equal [[c,t],[a,t],[k,t],[e,t],[e,f],[k,f],[a,f],[c,f]], gen([["c",["a",["k",["e"]]]]])
+  end
+
+end
+
+
+# NOTE: DO NOT TEST POSTING EVENTS HERE
+# We only want to test posting events if all the tests in this file pass,
+# otherwise the posted events may be unpredictable depending on what fails.
+# Test event posting in the integration tests.
+class TestAccessibilityString < MiniTest::Unit::TestCase
+  include Accessibility::String
+
+  # basic test to make sure the lexer and generator get along
+  def test_keyboard_events_for
+    events = keyboard_events_for 'cheezburger'
+    assert_kind_of Array, events
+    refute_empty events
+
+    assert_equal true, events[0][1]
+    assert_equal false, events[1][1]
+  end
+
+  def test_dynamic_map_initialized
+    refute_empty Accessibility::String::EventGenerator::MAPPING
+  end
+
+  def test_can_parse_empty_string
+    assert_equal [], keyboard_events_for('')
+  end
+
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: AXTyper
+version: !ruby/object:Gem::Version
+  prerelease: 
+  version: 0.7.0
+platform: ruby
+authors:
+- Mark Rada
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-29 00:00:00 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: "2.11"
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: "2.11"
+- !ruby/object:Gem::Dependency
+  name: yard
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.5
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.5
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: "1.17"
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: "1.17"
+description: 'Simulate keyboard input via the Mac OS X Accessibility Framework. This
+
+  gem is a component of AXElements.
+
+'
+email: mrada@marketcircle.com
+executables: []
+extensions:
+- ext/accessibility/key_coder/extconf.rb
+extra_rdoc_files:
+- README.markdown.typer
+- .yardopts.typer
+- docs/KeyboardEvents.markdown
+files:
+- lib/accessibility/version.rb
+- lib/accessibility/string.rb
+- ext/accessibility/key_coder/key_coder.c
+- ext/accessibility/key_coder/extconf.rb
+- test/unit/accessibility/test_string.rb
+- test/runner.rb
+- README.markdown.typer
+- .yardopts.typer
+- docs/KeyboardEvents.markdown
+homepage: http://github.com/Marketcircle/AXElements
+licenses:
+- BSD 3-clause
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: "0"
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.20
+signing_key: 
+specification_version: 3
+summary: Keyboard simulation via accessibility
+test_files:
+- test/unit/accessibility/test_string.rb
+- test/runner.rb