vimgolf 0.4.5 → 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0b23232451856233bb686ed2dc5936c491ca41a8c467b4e950f55a2d23f70064
+  data.tar.gz: 268b52ce2fd8286b75d1c974659d960178db0bd9a532cb65c541105d38d49328
+SHA512:
+  metadata.gz: 79484a6f2863cf654efa511bf8fee8dc4e771c445c43007c6bd1a6c80d1fcfedc601d8af59457e2ad0ef6bafbaa59955f168fa78af92da49715b5e67953e6729
+  data.tar.gz: 327f122659a3af5ba371a140a55544adef6612862eace4b71bc8da4b392587f4730613b68ac31edeffa0192eaa50d05ce0f7b2aab48a2b72b9d6626b137acca6

data/README.md

@@ -1,4 +1,4 @@
-# [VimGolf.com](http://www.vimgolf.com) Client
+# [VimGolf.com](http://www.vimgolf.com) CLI Client
 
 Real Vim ninjas count every keystroke - do you? Head on over to vimgolf.com, pick a challenge, and show us what you've got!
 
@@ -14,16 +14,8 @@ When you launch a challenge from the command line, it will be downloaded from th
 $> gem install vimgolf
 
 (Go to vimgolf.com, sign in, and grab your API key)
-$> vimgolf setup 
+$> vimgolf setup
 
 (Pick a challenge on vimgolf.com)
 $> vimgolf put [challenge ID]
 ```
-
-**Emacs**: yes, it is true, you can [play vimgolf in emacs too](https://github.com/igrigorik/vimgolf/tree/master/emacs)!
-
-Patches, tips and ideas are welcome!
-
-## License
-
-(MIT License) - Copyright (c) 2010 Ilya Grigorik

data/lib/vimgolf.rb

@@ -1,9 +1,12 @@
+require 'rubygems'
 require 'fileutils'
 require 'net/http'
 require 'strscan'
 require 'json'
 require 'yaml'
 require 'thor'
+require 'shellwords'
+require 'tempfile'
 
 require 'vimgolf/version'
 require 'vimgolf/config'

data/lib/vimgolf/challenge.rb

@@ -1,6 +1,6 @@
 module VimGolf
   class Challenge
-    attr_reader :id, :type
+    attr_reader :id, :type, :otype, :remote
 
     def self.path(path)
       @@path = path if path
@@ -11,14 +11,41 @@ module VimGolf
       @id = id
     end
 
+    def local(infile, outfile)
+      @remote = false
+      @input_path = File.expand_path(infile)
+      @output_path = File.expand_path(outfile)
+      @type = File.basename(@input_path) # extension? use the whole thing
+      @otype = File.basename(@output_path)
+
+      work_files
+    end
+
+    def work_files
+      @vimrc_path = File.expand_path('../vimgolf.vimrc', __FILE__)
+
+      # keep these Tempfile's around so they don't unlink
+      @work = Tempfile.new(['vimgolf', ".#{@type}"])
+      @log = Tempfile.new('golflog')
+      # close tmp files, but don't unlink
+      @work.close
+      @log.close
+
+      @work_path = @work.path()
+      @log_path = @log.path()
+    end
+
     def download
+      @remote = true
       begin
-        url = URI.parse("#{GOLFHOST}/challenges/#{@id}.json")
-        req = Net::HTTP::Get.new(url.path)
-
-        proxy_url, proxy_user, proxy_pass = get_proxy
-        proxy = Net::HTTP::Proxy(proxy_url.host, proxy_url.port, proxy_user, proxy_pass)
-        res = proxy.start(url.host, url.port) { |http| http.request(req) }
+        url = URI("#{GOLFHOST}/challenges/#{@id}.json")
+        res = Net::HTTP.start(
+          url.hostname,
+          url.port,
+          use_ssl: url.scheme == 'https'
+        ) do |http|
+          http.request_get(url)
+        end
 
         @data = JSON.parse(res.body)
 
@@ -34,9 +61,14 @@ module VimGolf
         @data['in']['data'].gsub!(/\r\n/, "\n")
         @data['out']['data'].gsub!(/\r\n/, "\n")
 
-        @type = @data['in']['type']
+        # be sure to sanitize the types
+        @type = @data['in']['type'].gsub(/[^\w-]/, '.')
+        @otype = @data['out']['type'].gsub(/[^\w-]/, '.')
+        @input_path = path + ".input.#{@type}"
+        @output_path = path + ".output.#{@otype}"
+
         save
-        start
+        work_files
       rescue Exception => e
         debug(e)
         raise "Uh oh, couldn't download or parse challenge, please verify your challenge id & client version."
@@ -44,65 +76,58 @@ module VimGolf
     end
 
     def start
-      File.open(work_path, "w")  {|f| f.puts @data['in']['data']}
+      FileUtils.cp(@input_path, @work_path)
     end
 
     def save
       File.open(input_path, "w")  {|f| f.puts @data['in']['data']}
       File.open(output_path, "w") {|f| f.puts @data['out']['data']}
-      File.open(vimrc_path, "w")  {|f| f.puts @data['vimrc']}
     end
 
     def upload
       begin
-        url = URI.parse("#{GOLFHOST}/entry.json")
-
-        proxy_url, proxy_user, proxy_pass = get_proxy
-        proxy = Net::HTTP::Proxy(proxy_url.host, proxy_url.port, proxy_user, proxy_pass)
-
-        proxy.start(url.host, url.port) do |http|
-          request = Net::HTTP::Post.new(url.request_uri)
-          request.set_form_data({"challenge_id" => @id, "apikey" => Config.load['key'], "entry" => IO.read(log_path)})
-          request["Accept"] = "application/json"
-
-          res = http.request(request)
-          res = JSON.parse(res.body)
+        url = URI("#{GOLFHOST}/entry.json")
+        res = Net::HTTP.start(
+          url.hostname,
+          url.port,
+          use_ssl: url.scheme == 'https'
+        ) do |http|
+          http.request_post(
+            url,
+            URI.encode_www_form(
+              "challenge_id" => @id,
+              "apikey" => Config.load['key'],
+              "entry" => IO.binread(log_path)
+            ),
+            "Accept" => "application/json"
+          )
+        end
 
-          raise if !res.is_a? Hash
-          res['status'].to_sym
+        res = JSON.parse(res.body)
 
-        end
+        raise if !res.is_a? Hash
+        res['status'].to_sym
       rescue Exception => e
         debug(e)
         raise "Uh oh, entry upload has failed, please check your key."
       end
     end
 
-    def input_path;  path + ".#{@type}"; end
-    def work_path;   path + ".work.#{@type}"; end
-    def output_path; path + ".output"; end
-    def log_path;    path + ".log";    end
-    def vimrc_path;  path + ".golfrc"; end
+    attr_reader :input_path
+    attr_reader :work_path
+    attr_reader :output_path
+    attr_reader :log_path
+    attr_reader :vimrc_path
+
+    def correct?
+      FileUtils.compare_file(@work_path, @output_path)
+    end
 
     def path
       @@path + "/#{@id}"
     end
 
     private
-      def get_proxy
-        begin
-          proxy_url = URI.parse(PROXY)
-        rescue Exception => e
-          VimGolf.ui.error "Invalid proxy uri in http_proxy environment variable - will try to run with out proxy"
-          proxy_url = URI.parse("");
-        end
-
-        proxy_url.port ||= 80
-        proxy_user, proxy_pass = proxy_url.userinfo.split(/:/) if proxy_url.userinfo
-
-        return proxy_url, proxy_user, proxy_pass
-      end
-
       def debug(msg)
         p [caller.first, msg] if GOLFDEBUG
       end

data/lib/vimgolf/cli.rb

@@ -1,11 +1,9 @@
 module VimGolf
 
   GOLFDEBUG    = ENV['GOLFDEBUG'].to_sym rescue false
-  GOLFHOST     = ENV['GOLFHOST']     || "http://vimgolf.com"
-  GOLFDIFF     = ENV['GOLFDIFF']     || 'diff'
+  GOLFHOST     = ENV['GOLFHOST']     || "https://www.vimgolf.com"
   GOLFSHOWDIFF = ENV['GOLFSHOWDIFF'] || 'vim -d -n'
   GOLFVIM      = ENV['GOLFVIM']      || 'vim'
-  PROXY        = ENV['http_proxy']   || ''
 
   class Error
   end
@@ -27,12 +25,34 @@ module VimGolf
   class CLI < Thor
     include Thor::Actions
 
-    def self.start(*)
+    def self.initialize_ui
+      return if @ui_initialized
       Thor::Base.shell = VimGolf::CLI::UI
       VimGolf.ui = VimGolf::CLI::UI.new
+      @ui_initialized = true
+    end
+
+    def self.reset_ui
+      return unless @ui_initialized
+      Thor::Base.shell = Thor::Shell::Color
+      VimGolf.ui = nil
+      @ui_initialized = false
+    end
+
+    def self.start(*)
+      initialize_ui
       super
     end
 
+    desc "version", "print version of Vimgolf client"
+    long_desc <<-DESC
+    Print version of the Vimgolf client.
+    DESC
+
+    def version
+      VimGolf.ui.info "Client #{Vimgolf::VERSION}"
+    end
+
     desc "setup", "configure your VimGolf credentials"
     long_desc <<-DESC
     To participate in the challenge please go to vimgolf.com and register an
@@ -43,7 +63,12 @@ module VimGolf
       DESC
 
     def setup
-      key = VimGolf.ui.ask "Please specify your VimGolf API key (register on vimgolf.com to get it):"
+      VimGolf.ui.info "\nLet's setup your VimGolf key..."
+      VimGolf.ui.warn "1) Open vimgolf.com in your browser."
+      VimGolf.ui.warn "2) Click \"Sign in with Twitter\"."
+      VimGolf.ui.warn "3) Once signed in, copy your key (black box, top right)."
+
+      key = VimGolf.ui.ask "\nPaste your VimGolf key:"
 
       if key =~ /[\w\d]{32}/
         FileUtils.mkdir_p Config.path
@@ -56,39 +81,72 @@ module VimGolf
       end
     end
 
-    desc "put [ID]", "launch Vim session"
+    desc "put CHALLENGE_ID", "launch vimgolf.com challenge"
     long_desc <<-DESC
     Launch a VimGolf session for the specified challenge ID. To find a currently
     active challenge ID, please visit vimgolf.com!
     DESC
 
-    def put(id = nil)
+    def put(id)
+      FileUtils.mkdir_p Config.put_path
       VimGolf.ui.warn "Downloading Vimgolf challenge: #{id}"
       VimGolf::Challenge.path(Config.put_path)
       challenge = Challenge.new(id)
       challenge.download
 
+      play(challenge)
+    end
+
+    desc "local INFILE OUTFILE", "launch local challenge"
+    long_desc <<-DESC
+    Launch a local VimGolf challenge. A temporary copy of INFILE is made; the original files will not be touched.
+    DESC
+
+    def local(infile, outfile)
+      # make sure our files are sane
+      if !(File.file?(infile) and File.file?(outfile))
+        VimGolf.ui.error "INFILE and OUTFILE must exist and be regular files."
+        exit 1
+      end
+
+      challenge = Challenge.new(infile) # use the filename as id
+      challenge.local(infile, outfile)
+
+      play(challenge)
+    end
+
+    private
+
+    def play(challenge)
       begin
-        VimGolf.ui.warn "Launching VimGolf session for challenge: #{id}"
-        # - n - no swap file, memory only editing
-        # - +0 - always start on line 0
-        # - --noplugin - don't load any plugins, lets be fair!
-        # -i NONE - don't load .viminfo (for saved macros and the like)
-        # - u - load vimgolf .vimrc to level the playing field
-        vimcmd = "#{GOLFVIM} -Z -n --noplugin -i NONE +0 -u \"#{challenge.vimrc_path}\" -W \"#{challenge.log_path}\" \"#{challenge.work_path}\""
+        challenge.start
+        VimGolf.ui.warn "Launching VimGolf session for challenge: #{challenge.id}"
+        # -Z         - restricted mode, utilities not allowed
+        # -n         - no swap file, memory only editing
+        # --noplugin - don't load any plugins, lets be fair!
+        # --nofork   - otherwise GOLFVIM=gvim forks and returns immediately
+        # -i NONE    - don't load .viminfo (for saved macros and the like)
+        # +0         - always start on line 0
+        # -u vimrc   - load vimgolf .vimrc to level the playing field
+        # -U NONE    - don't load .gvimrc
+        # -W logfile - keylog file (overwrites if already exists)
+        vimcmd = GOLFVIM.shellsplit + %W{-Z -n --noplugin -i NONE +0 -u #{challenge.vimrc_path} -U NONE -W #{challenge.log_path} #{challenge.work_path}}
+        if GOLFVIM == "gvim"
+          vimcmd += %W{ --nofork}
+        end
         debug(vimcmd)
-        system(vimcmd)
+        system(*vimcmd) # assembled as an array, bypasses the shell
 
         if $?.exitstatus.zero?
-          diff_files = "\"#{challenge.work_path}\" \"#{challenge.output_path}\""
-          diff = `#{GOLFDIFF} #{diff_files}`
-          log = Keylog.new(IO.read(challenge.log_path))
+          log = Keylog.new(IO.binread(challenge.log_path))
+
+          VimGolf.ui.info "\nHere are your keystrokes:"
+          VimGolf.ui.print_log log
 
           # Handle incorrect solutions
-          if diff.size > 0
+          if !challenge.correct?()
             VimGolf.ui.error "\nUh oh, looks like your entry does not match the desired output."
             VimGolf.ui.error "Your score for this failed attempt was: #{log.score}"
-
             loop do
               VimGolf.ui.warn "[d] Show diff"
               VimGolf.ui.warn "[r] Retry the current challenge"
@@ -99,10 +157,9 @@ module VimGolf
                                   :choices   => [:diff, :retry, :quit]
               when :diff
                 VimGolf.ui.warn "Showing vimdiff of your attempt (left) and correct output (right)"
-                system("#{GOLFSHOWDIFF} #{diff_files}")
+                system(*GOLFSHOWDIFF.shellsplit + [challenge.work_path, challenge.output_path])
               when :retry
                 VimGolf.ui.warn "Retrying current challenge..."
-                challenge.start
                 raise RetryException
               when :quit
                 raise Interrupt
@@ -114,23 +171,32 @@ module VimGolf
           VimGolf.ui.info "\nSuccess! Your output matches. Your score: #{log.score}"
 
           loop do
-            VimGolf.ui.warn "[w] Upload result and retry the challenge"
-            VimGolf.ui.warn "[x] Upload result and quit"
+            choices = []
+            begin
+              Config.load # raises error if user hasn't finished setup
+              choices = [:w, :x]
+              VimGolf.ui.warn "[w] Upload result and retry the challenge"
+              VimGolf.ui.warn "[x] Upload result and quit"
+            rescue
+              choices = [:setup]
+              VimGolf.ui.warn "[s] Set up vimgolf.com key to submit result"
+            end if challenge.remote
             VimGolf.ui.warn "[r] Do not upload result and retry the challenge"
             VimGolf.ui.warn "[q] Do not upload result and quit"
 
             case VimGolf.ui.ask_question "Choice> ",
                                 :type    => :warn,
-                                :choices => [:w, :x, :retry, :quit]
+                                :choices => choices + [:retry, :quit]
             when :w
               next unless upload?(challenge)
-              challenge.start
               raise RetryException
             when :x
               next unless upload?(challenge)
               raise Interrupt
+            when :setup
+              setup
+              next # we can hopefully submit this time
             when :retry
-              challenge.start
               raise RetryException
             when :quit
               raise Interrupt
@@ -139,8 +205,9 @@ module VimGolf
 
         else
           error = <<-MSG
-          Uh oh, Vim did not exit properly. If the problem persists, please
-          report the error on github.com/igrigorik/vimgolf
+	  Uh oh, Vim did not exit properly.
+	  Please ensure you can execute 'Vim' from the commandline.
+	  If the problem persists, please report the error on github.com/igrigorik/vimgolf
           MSG
 
           VimGolf.ui.error error
@@ -157,8 +224,6 @@ module VimGolf
       VimGolf.ui.error "If the error persists, please report it to github.com/igrigorik/vimgolf"
     end
 
-    private
-
     def upload?(challenge)
       VimGolf.ui.warn "Uploading to VimGolf..."
 

data/lib/vimgolf/keylog.rb

@@ -1,225 +1,271 @@
+# encoding: ASCII-8BIT
+# Force encoding of string literals. Must match solution text.
+
 module VimGolf
   class Keylog
     include Enumerable
 
-    alias_method :convert , :to_s
-    alias_method :score   , :count
-
-    def initialize(input)
-      @input = input
+    def initialize(input, time=Time.now.utc)
+      # Force encoding of solution text. Must match string literals.
+      # .force_encoding CHANGES THE ORIGINAL STRING!
+      @input = input.force_encoding(Encoding::ASCII_8BIT)
+      @time = time
     end
 
     def to_s(sep = '')
       to_a.join(sep)
     end
 
+    alias_method :convert , :to_s
+    alias_method :score   , :count
+
     def each
       scanner = StringScanner.new(@input)
-      output = ""
-
-      until scanner.eos?
-        c = scanner.get_byte
-        n = c.unpack('C').first
-
-        out_char = \
-        case n
-
-          # Special platform-independent encoding stuff
-          when 0x80
-            code = scanner.get_byte + scanner.get_byte
-
-            # This list has been populated by looking at
-            # :h terminal-options and vim source files:
-            # keymap.h and misc2.c
-            case code
-              when "k1"; "<F1>"
-              when "k2"; "<F2>"
-              when "k3"; "<F3>"
-              when "k4"; "<F4>"
-              when "k5"; "<F5>"
-              when "k6"; "<F6>"
-              when "k7"; "<F7>"
-              when "k8"; "<F8>"
-              when "k9"; "<F9>"
-              when "k;"; "<F10>"
-              when "F1"; "<F11>"
-              when "F2"; "<F12>"
-              when "F3"; "<F13>"
-              when "F4"; "<F14>"
-              when "F5"; "<F15>"
-              when "F6"; "<F16>"
-              when "F7"; "<F17>"
-              when "F8"; "<F18>"
-              when "F9"; "<F19>"
-
-              when "%1"; "<Help>"
-              when "&8"; "<Undo>"
-              when "#2"; "<S-Home>"
-              when "*7"; "<S-End>"
-              when "K1"; "<kHome>"
-              when "K4"; "<kEnd>"
-              when "K3"; "<kPageUp>"
-              when "K5"; "<kPageDown>"
-              when "K6"; "<kPlus>"
-              when "K7"; "<kMinus>"
-              when "K8"; "<kDivide>"
-              when "K9"; "<kMultiply>"
-              when "KA"; "<kEnter>"
-              when "KB"; "<kPoint>"
-              when "KC"; "<k0>"
-              when "KD"; "<k1>"
-              when "KE"; "<k2>"
-              when "KF"; "<k3>"
-              when "KG"; "<k4>"
-              when "KH"; "<k5>"
-              when "KI"; "<k6>"
-              when "KJ"; "<k7>"
-              when "KK"; "<k8>"
-              when "KL"; "<k9>"
-
-              when "kP"; "<PageUp>"
-              when "kN"; "<PageDown>"
-              when "kh"; "<Home>"
-              when "@7"; "<End>"
-              when "kI"; "<Insert>"
-              when "kD"; "<Del>"
-              when "kb"; "<BS>"
-
-              when "ku"; "<Up>"
-              when "kd"; "<Down>"
-              when "kl"; "<Left>"
-              when "kr"; "<Right>"
-              when "#4"; "<S-Left>"
-              when "%i"; "<S-Right>"
-
-              when "kB"; "<S-Tab>"
-              when "\xffX"; "<C-@>"
-
-              when "\xfd\x4"; "<S-Up>"
-              when "\xfd\x5"; "<S-Down>"
-              when "\xfd\x6"; "<S-F1>"
-              when "\xfd\x7"; "<S-F2>"
-              when "\xfd\x8"; "<S-F3>"
-              when "\xfd\x9"; "<S-F4>"
-              when "\xfd\xa"; "<S-F5>"
-              when "\xfd\xb"; "<S-F6>"
-              when "\xfd\xc"; "<S-F7>"
-              when "\xfd\xd"; "<S-F9>"
-              when "\xfd\xe"; "<S-F10>"
-              when "\xfd\xf"; "<S-F10>"
-              when "\xfd\x10"; "<S-F11>"
-              when "\xfd\x11"; "<S-F12>"
-              when "\xfd\x12"; "<S-F13>"
-              when "\xfd\x13"; "<S-F14>"
-              when "\xfd\x14"; "<S-F15>"
-              when "\xfd\x15"; "<S-F16>"
-              when "\xfd\x16"; "<S-F17>"
-              when "\xfd\x17"; "<S-F18>"
-              when "\xfd\x18"; "<S-F19>"
-              when "\xfd\x19"; "<S-F20>"
-              when "\xfd\x1a"; "<S-F21>"
-              when "\xfd\x1b"; "<S-F22>"
-              when "\xfd\x1c"; "<S-F23>"
-              when "\xfd\x1d"; "<S-F24>"
-              when "\xfd\x1e"; "<S-F25>"
-              when "\xfd\x1f"; "<S-F26>"
-              when "\xfd\x20"; "<S-F27>"
-              when "\xfd\x21"; "<S-F28>"
-              when "\xfd\x22"; "<S-F29>"
-              when "\xfd\x23"; "<S-F30>"
-              when "\xfd\x24"; "<S-F31>"
-              when "\xfd\x25"; "<S-F32>"
-              when "\xfd\x26"; "<S-F33>"
-              when "\xfd\x27"; "<S-F34>"
-              when "\xfd\x28"; "<S-F35>"
-              when "\xfd\x29"; "<S-F36>"
-              when "\xfd\x2a"; "<S-F37>"
-              when "\xfd\x2b"; "<Mouse>"
-              when "\xfd\x2c"; "<LeftMouse>"
-              when "\xfd\x2d"; "<LeftDrag>"
-              when "\xfd\x2e"; "<LeftRelease>"
-              when "\xfd\x2f"; "<MiddleMouse>"
-              when "\xfd\x30"; "<MiddleDrag>"
-              when "\xfd\x31"; "<MiddleRelease>"
-              when "\xfd\x32"; "<RightMouse>"
-              when "\xfd\x33"; "<RightDrag>"
-              when "\xfd\x34"; "<RightRelease>"
-              #when "\xfd\x35"; "KE_IGNORE"
-              #when "\xfd\x36"; "KE_TAB"
-              #when "\xfd\x37"; "KE_S_TAB_OLD"
-              #when "\xfd\x38"; "KE_SNIFF"
-              #when "\xfd\x39"; "KE_XF1"
-              #when "\xfd\x3a"; "KE_XF2"
-              #when "\xfd\x3b"; "KE_XF3"
-              #when "\xfd\x3c"; "KE_XF4"
-              #when "\xfd\x3d"; "KE_XEND"
-              #when "\xfd\x3e"; "KE_ZEND"
-              #when "\xfd\x3f"; "KE_XHOME"
-              #when "\xfd\x40"; "KE_ZHOME"
-              #when "\xfd\x41"; "KE_XUP"
-              #when "\xfd\x42"; "KE_XDOWN"
-              #when "\xfd\x43"; "KE_XLEFT"
-              #when "\xfd\x44"; "KE_XRIGHT"
-              #when "\xfd\x45"; "KE_LEFTMOUSE_NM"
-              #when "\xfd\x46"; "KE_LEFTRELEASE_NM"
-              #when "\xfd\x47"; "KE_S_XF1"
-              #when "\xfd\x48"; "KE_S_XF2"
-              #when "\xfd\x49"; "KE_S_XF3"
-              #when "\xfd\x4a"; "KE_S_XF4"
-              when "\xfd\x4b"; "<MouseDown>"
-              when "\xfd\x4c"; "<MouseUp>"
-              when "\xfd\x4d"; "<MouseLeft>"
-              when "\xfd\x4e"; "<MouseRight>"
-              #when "\xfd\x4f"; "KE_KINS"
-              #when "\xfd\x50"; "KE_KDEL"
-              #when "\xfd\x51"; "KE_CSI"
-              #when "\xfd\x52"; "KE_SNR"
-              #when "\xfd\x53"; "KE_PLUG"
-              #when "\xfd\x54"; "KE_CMDWIN"
-              when "\xfd\x55"; "<C-Left>"
-              when "\xfd\x56"; "<C-Right>"
-              when "\xfd\x57"; "<C-Home>"
-              when "\xfd\x58"; "<C-End>"
-              #when "\xfd\x59"; "KE_X1MOUSE"
-              #when "\xfd\x5a"; "KE_X1DRAG"
-              #when "\xfd\x5b"; "KE_X1RELEASE"
-              #when "\xfd\x5c"; "KE_X2MOUSE"
-              #when "\xfd\x5d"; "KE_X2DRAG"
-              #when "\xfd\x5e"; "KE_X2RELEASE"
-              #when "\xfd\x5f"; "KE_DROP"
-              #when "\xfd\x5e"; "KE_CURSORHOLD"
-              #when "\xfd\x61"; "KE_NOP"
-              when "\xfd\x62"; nil # Focus Gained (GVIM)
-              when "\xfd\x63"; nil # Focus Lost (GVIM)
-
-              else
-                #puts "Unknown Vim code: #{code.inspect}"
-                '<%02x-%02x>' % code.unpack('CC')
-            end
-
-            # Control characters with special names
-          when 0; "<Nul>"
-          when 9; "<Tab>"
-          when 10; "<NL>"
-          when 13; "<CR>"
-          when 27; "<Esc>"
-
-          when 127; "<Del>"
-
-            # Otherwise, use <C-x> format
-          when 0..31; "<C-#{(n + 64).chr}>"
-
-            # The rest of ANSI is printable
-          when 32..126; c
-
-          else
-            #puts "Unexpected extended ASCII: #{'%#04x' % n}"
-            '<%#04x>' % n
 
+      # A Vim keycode is either a single byte, or a 3-byte sequence starting
+      # with 0x80.
+      while (c = scanner.get_byte)
+        n = c.ord
+        if n == 0x80
+          b2, b3 = scanner.get_byte, scanner.get_byte
+          if b2 == "\xfd" && b3 >= "\x38" && @time.between?(*NO_SNIFF_DATE_RANGE)
+            # Should we account for KE_SNIFF removal?
+            b3 = (b3.ord + 1).chr
+          end
+          code = KC_MBYTE[b2+b3]
+          yield code if code # ignore "nil" keystrokes (like window focus)
+        else
+          yield KC_1BYTE[n]
         end
-
-        yield out_char if out_char
       end
     end
+
+    # Quick lookup array for single-byte keycodes
+    KC_1BYTE = []
+    (0..255).each {|n| KC_1BYTE.push("<%#04x>" % n)} # Fallback for non-ASCII
+    (1..127).each {|n| KC_1BYTE[n] = "<C-#{(n ^ 0x40).chr}>"}
+    (32..126).each {|c| KC_1BYTE[c] = c.chr } # Printing chars
+    KC_1BYTE[0x1b] = "<Esc>" # Special names for a few control chars
+    KC_1BYTE[0x0d] = "<CR>"
+    KC_1BYTE[0x0a] = "<NL>"
+    KC_1BYTE[0x09] = "<Tab>"
+
+    # Between these dates, assume KE_SNIFF is removed.
+    NO_SNIFF_DATE_RANGE = [Time.utc(2016, 4), Time.utc(2017, 7)]
+
+    KC_MBYTE = Hash.new do |_h,k|
+      '<' + k.bytes.map {|b| "%02x" % b}.join('-') + '>' # For missing keycodes
+    end.update({
+      # This list has been populated by looking at
+      # :h terminal-options and vim source files:
+      # keymap.h and misc2.c
+      "k1" => "<F1>",
+      "k2" => "<F2>",
+      "k3" => "<F3>",
+      "k4" => "<F4>",
+      "k5" => "<F5>",
+      "k6" => "<F6>",
+      "k7" => "<F7>",
+      "k8" => "<F8>",
+      "k9" => "<F9>",
+      "k;" => "<F10>",
+      "F1" => "<F11>",
+      "F2" => "<F12>",
+      "F3" => "<F13>",
+      "F4" => "<F14>",
+      "F5" => "<F15>",
+      "F6" => "<F16>",
+      "F7" => "<F17>",
+      "F8" => "<F18>",
+      "F9" => "<F19>",
+
+      "%1" => "<Help>",
+      "&8" => "<Undo>",
+      "#2" => "<S-Home>",
+      "*7" => "<S-End>",
+      "K1" => "<kHome>",
+      "K4" => "<kEnd>",
+      "K3" => "<kPageUp>",
+      "K5" => "<kPageDown>",
+      "K6" => "<kPlus>",
+      "K7" => "<kMinus>",
+      "K8" => "<kDivide>",
+      "K9" => "<kMultiply>",
+      "KA" => "<kEnter>",
+      "KB" => "<kPoint>",
+      "KC" => "<k0>",
+      "KD" => "<k1>",
+      "KE" => "<k2>",
+      "KF" => "<k3>",
+      "KG" => "<k4>",
+      "KH" => "<k5>",
+      "KI" => "<k6>",
+      "KJ" => "<k7>",
+      "KK" => "<k8>",
+      "KL" => "<k9>",
+
+      "kP" => "<PageUp>",
+      "kN" => "<PageDown>",
+      "kh" => "<Home>",
+      "@7" => "<End>",
+      "kI" => "<Insert>",
+      "kD" => "<Del>",
+      "kb" => "<BS>",
+
+      "ku" => "<Up>",
+      "kd" => "<Down>",
+      "kl" => "<Left>",
+      "kr" => "<Right>",
+      "#4" => "<S-Left>",
+      "%i" => "<S-Right>",
+
+      "kB" => "<S-Tab>",
+      "\xffX" => "<C-@>",
+
+      # This is how you escape literal 0x80
+      "\xfeX" => "<0x80>",
+
+      # These rarely-used modifiers should be combined with the next
+      # stroke (like <S-Space>), but let's put them here for now
+      "\xfc\x02" => "<S->",
+      "\xfc\x04" => "<C->",
+      "\xfc\x06" => "<C-S->",
+      "\xfc\x08" => "<A->",
+      "\xfc\x0a" => "<A-S->",
+      "\xfc\x0c" => "<C-A>",
+      "\xfc\x0e" => "<C-A-S->",
+      "\xfc\x10" => "<M->",
+      "\xfc\x12" => "<M-S->",
+      "\xfc\x14" => "<M-C->",
+      "\xfc\x16" => "<M-C-S->",
+      "\xfc\x18" => "<M-A->",
+      "\xfc\x1a" => "<M-A-S->",
+      "\xfc\x1c" => "<M-C-A>",
+      "\xfc\x1e" => "<M-C-A-S->",
+
+      # KS_EXTRA keycodes (starting with 0x80 0xfd) are defined by an enum in
+      # Vim's keymap.h. Sometimes, a new Vim adds or removes a keycode, which
+      # changes the binary representation of every keycode after it. Very
+      # annoying.
+      "\xfd\x4" => "<S-Up>",
+      "\xfd\x5" => "<S-Down>",
+      "\xfd\x6" => "<S-F1>",
+      "\xfd\x7" => "<S-F2>",
+      "\xfd\x8" => "<S-F3>",
+      "\xfd\x9" => "<S-F4>",
+      "\xfd\xa" => "<S-F5>",
+      "\xfd\xb" => "<S-F6>",
+      "\xfd\xc" => "<S-F7>",
+      "\xfd\xd" => "<S-F9>",
+      "\xfd\xe" => "<S-F10>",
+      "\xfd\xf" => "<S-F10>",
+      "\xfd\x10" => "<S-F11>",
+      "\xfd\x11" => "<S-F12>",
+      "\xfd\x12" => "<S-F13>",
+      "\xfd\x13" => "<S-F14>",
+      "\xfd\x14" => "<S-F15>",
+      "\xfd\x15" => "<S-F16>",
+      "\xfd\x16" => "<S-F17>",
+      "\xfd\x17" => "<S-F18>",
+      "\xfd\x18" => "<S-F19>",
+      "\xfd\x19" => "<S-F20>",
+      "\xfd\x1a" => "<S-F21>",
+      "\xfd\x1b" => "<S-F22>",
+      "\xfd\x1c" => "<S-F23>",
+      "\xfd\x1d" => "<S-F24>",
+      "\xfd\x1e" => "<S-F25>",
+      "\xfd\x1f" => "<S-F26>",
+      "\xfd\x20" => "<S-F27>",
+      "\xfd\x21" => "<S-F28>",
+      "\xfd\x22" => "<S-F29>",
+      "\xfd\x23" => "<S-F30>",
+      "\xfd\x24" => "<S-F31>",
+      "\xfd\x25" => "<S-F32>",
+      "\xfd\x26" => "<S-F33>",
+      "\xfd\x27" => "<S-F34>",
+      "\xfd\x28" => "<S-F35>",
+      "\xfd\x29" => "<S-F36>",
+      "\xfd\x2a" => "<S-F37>",
+      "\xfd\x2b" => "<Mouse>",
+      "\xfd\x2c" => "<LeftMouse>",
+      "\xfd\x2d" => "<LeftDrag>",
+      "\xfd\x2e" => "<LeftRelease>",
+      "\xfd\x2f" => "<MiddleMouse>",
+      "\xfd\x30" => "<MiddleDrag>",
+      "\xfd\x31" => "<MiddleRelease>",
+      "\xfd\x32" => "<RightMouse>",
+      "\xfd\x33" => "<RightDrag>",
+      "\xfd\x34" => "<RightRelease>",
+      "\xfd\x35" => nil, # KE_IGNORE
+      #"\xfd\x36" => "KE_TAB",
+      #"\xfd\x37" => "KE_S_TAB_OLD",
+
+      # Vim 7.4.1433 removed KE_SNIFF. Unfortunately, this changed the
+      # offset of every keycode after it.
+      # Vim 8.0.0697 added back a KE_SNIFF_UNUSED to fill in for the
+      # removed KE_SNIFF.
+      # Keycodes after this point should be accurate for vim < 7.4.1433
+      # and vim > 8.0.0697.
+      #"\xfd\x38" => "KE_SNIFF",
+      #"\xfd\x39" => "KE_XF1",
+      #"\xfd\x3a" => "KE_XF2",
+      #"\xfd\x3b" => "KE_XF3",
+      #"\xfd\x3c" => "KE_XF4",
+      #"\xfd\x3d" => "KE_XEND",
+      #"\xfd\x3e" => "KE_ZEND",
+      #"\xfd\x3f" => "KE_XHOME",
+      #"\xfd\x40" => "KE_ZHOME",
+      #"\xfd\x41" => "KE_XUP",
+      #"\xfd\x42" => "KE_XDOWN",
+      #"\xfd\x43" => "KE_XLEFT",
+      #"\xfd\x44" => "KE_XRIGHT",
+      #"\xfd\x45" => "KE_LEFTMOUSE_NM",
+      #"\xfd\x46" => "KE_LEFTRELEASE_NM",
+      #"\xfd\x47" => "KE_S_XF1",
+      #"\xfd\x48" => "KE_S_XF2",
+      #"\xfd\x49" => "KE_S_XF3",
+      #"\xfd\x4a" => "KE_S_XF4",
+      "\xfd\x4b" => "<ScrollWheelUp>",
+      "\xfd\x4c" => "<ScrollWheelDown>",
+
+      # Horizontal scroll wheel support was added in Vim 7.3c. These
+      # 2 entries shifted the rest of the KS_EXTRA mappings down 2.
+      # Though Vim 7.2 is rare today, it was common soon after
+      # vimgolf.com was launched. In cases where the 7.3 code is
+      # never used but the 7.2 code was common, it makes sense to use
+      # the 7.2 code. There are conflicts though, so some legacy
+      # keycodes have to stay wrong.
+      "\xfd\x4d" => "<ScrollWheelRight>",
+      "\xfd\x4e" => "<ScrollWheelLeft>",
+      "\xfd\x4f" => "<kInsert>",
+      "\xfd\x50" => "<kDel>",
+      "\xfd\x51" => "<0x9b>", # :help <CSI>
+      #"\xfd\x52" => "KE_SNR",
+      #"\xfd\x53" => "KE_PLUG", # never used
+      "\xfd\x53" => "<C-Left>", # 7.2 compat
+      #"\xfd\x54" => "KE_CMDWIN", # never used
+      "\xfd\x54" => "<C-Right>", # 7.2 compat
+      "\xfd\x55" => "<C-Left>", # 7.2 <C-Home> conflict
+      "\xfd\x56" => "<C-Right>", # 7.2 <C-End> conflict
+      "\xfd\x57" => "<C-Home>",
+      "\xfd\x58" => "<C-End>",
+      #"\xfd\x59" => "KE_X1MOUSE",
+      #"\xfd\x5a" => "KE_X1DRAG",
+      #"\xfd\x5b" => "KE_X1RELEASE",
+      #"\xfd\x5c" => "KE_X2MOUSE",
+      #"\xfd\x5d" => "KE_X2DRAG",
+      #"\xfd\x5e" => "KE_X2RELEASE",
+      "\xfd\x5e" => nil, # 7.2 compat (I think?)
+      #"\xfd\x5f" => "KE_DROP",
+      #"\xfd\x60" => "KE_CURSORHOLD",
+
+      # If you use gvim, you'll get an entry in your keylog every time the
+      # window gains or loses focus. These "keystrokes" should not show and
+      # should not be counted.
+      "\xfd\x60" => nil, # 7.2 Focus Gained compat
+      "\xfd\x61" => nil, # Focus Gained (GVIM) (>7.4.1433)
+      "\xfd\x62" => nil, # Focus Gained (GVIM)
+      "\xfd\x63" => nil, # Focus Lost (GVIM)
+    })
   end
 end