vimgolf 0.4.5 → 0.5.0

data/emacs/ROADMAP.md

@@ -1,69 +0,0 @@
-# VimGolf Minor Mode Roadmap
-
-## Features
-
-1. Completing read of challenges by title rather than by challenge id
-
-2. `M-x vimgolf-browse`: Dired/Ibuffer/Magit-like interface to VimGolf challenges.
-
-    Bindings:
-
-    - Bindings should mimic Dired/Ibuffer wherever possible. Magit is listed primarily because I want TAB to open up the long description of the challenge.
-
-        At least:
-
-        - n/p
-        - ENTER/o: launch `vimgolf` with the correct arg.
-
-    Interface Mockup:
-
-        VimGolf in Emacs! Compete on vimgolf with the One True Editor.
-
-        Sort entries based on date - Sort some entries in a Ledger-file based on date.
-        PHP Array Syntax -> MailChimp Merge Syntax - I recently needed to send an e-m...
-        Refactor to Helpers
-                This Rails partial is almost all template escapes. Put it into a helper,
-                and refactor each case to methods so we can build out the controls for
-                each. (I've converted to tabs - fighting with Vimgolf's default config
-                shouldn't be part of the challenge.)
-
-        Alphabetize the directory - Put the contacts and their information in alphabe...
-        PHP <--> Java class conversion Part 2 - Same class but reverse!
-        PHP <--> Java class conversion Part 1 - Convert this tiny php class to adequa...
-        Multiplication table. - Create a multiplication table.
-        Complete the hex array data (Part II) - Do not use external tools(e.g. tac, s...
-        Interweave two blocks of text - Suppose you've got data on a list of things f...
-        .
-        .
-        .
-
-    --------------------------------------------------------------------------------
-
-    Commentary:
-
-    - Tab has been pressed on the Refactor to Helpers line and thus it's been expanded.
-
-    - The challenges `formatted text to markdown` and `Line Zipper` have both been completed and thus are hidden. Could provide a customization setting that turns this off completely, as well as an `M-x vimgolf-show-all` function to toggle the hiding.
-
-    - Fill column has been set to 80
-
-    - It would be fun if a local cache of the vimgolf data could be kept together so that you could record solutions or at least play offline.
-
-3. Real submission to vimgolf.
-
-    This could look like:
-
-    Pop-open buffer
-
-        You solved the formatted text to markdown challenge in 25 keystrokes! The best entry for this challenge was 23.
-
-        M-x qrr          ;; query-replace-regexp
-        SPC*2            ;; self-insert-command
-        dummy            ;; self-insert-command * 5
-        .
-        .
-        .
-
-    Mini-buffer
-
-        Submit to your solution to vimgolf? <y-or-n-predicate>

data/emacs/features/emacs.feature

@@ -1,24 +0,0 @@
-Feature: VimGolf Browser
-  In order to browse and select VimGolf entries
-  As a user
-  I want to use the VimGolf browser
-  
-  Scenario: Press TAB on entry to view description
-    Given I open the vimgolf browser
-    Then I should not see "Continuing from the last challenge"
-    When I press "TAB"
-    Then I should see "Continuing from the last challenge"
-    When I press "TAB"
-    Then I should not see "Continuing from the last challenge"
-    
-  Scenario: Move through the browse list
-    Given I open the vimgolf browser
-    Then the cursor should be before "Compl"
-    When I press "n"
-    Then the cursor should be before "Make "
-    When I press "n"
-    Then the cursor should be before "Conve"
-    When I press "p"
-    Then the cursor should be before "Make "
-    When I press "p"
-    Then the cursor should be before "Compl"

data/emacs/features/step-definitions/emacs-steps.el

@@ -1,53 +0,0 @@
-;; This file contains your project specific step definitions. All
-;; files in this directory whose names end with "-steps.el" will be
-;; loaded automatically by Ecukes.
-
-(Given "^I open the vimgolf browser$"
-       (lambda ()
-         (setq *vimgolf-browse-list*
-                '(("50128129201f450002000027"
-                   "Complete the circuit grid!"
-                   "Continuing from the last challenge, add additional rows to the grid. Change each of the names from 'A1'...'A10' to 'B1'...'B10', 'C1'...'C10', etc, and for each new row add 0.7 to the X values in the (X Y) at the end of each line. ")
-                  ("50127eba201f450002000024"
-                   "Make the circuit grid!"
-                   "Copy this command for a circuit layout program to create 10 total smd commands. Increment the number in quotes to name each pad, and add 0.7 to each of the (X Y) coordinates at the end of each line.")
-                  ("500855e60599d90002000073"
-                   "Convert pandoc unordered list to a numbered list"
-                   "I know it's possible to use #. in pandoc to auto-generate numbered lists, but then it's not easy to tell how many items there are when reading it in Markdown. How fast can you make the switch?")
-                  ("4fe62f8a8b2f800001000043"
-                   "Cleanining up 80 column concatenated text"
-                   "1. Put the whole query on one line, remove the concatenation operators
-                  ("4d1b4ac3c58eaa2a8a0005c2"
-                   "Ruby 1.9 compat"
-                   "Remember when Ruby supported `when <expr> :`? Well, it doesn't in 1.9, so let's make sure we use `then`, without ruining our lovely new hash syntax!")
-                  ))
-         (vimgolf-browse)))
-
-(When "^I show the description$"
-      (lambda ()
-        (vimgolf-show-description)))
-
-(Given "^I have \"\\(.+\\)\"$"
-       (lambda (something)
-         ;; Do something
-         ))
-
-(When "^I have \"\\(.+\\)\"$"
-      (lambda (something)
-        ;; Do something
-        ))
-
-(Then "^I should have \"\\(.+\\)\"$"
-      (lambda (something)
-        ;; Do something
-        ))
-
-(And "^I have \"\\(.+\\)\"$"
-     (lambda (something)
-       ;; Do something
-       ))
-
-(But "^I should not have \"\\(.+\\)\"$"
-     (lambda (something)
-       ;; Do something
-       ))

data/emacs/features/support/env.el

@@ -1,37 +0,0 @@
-;; This is an example of how you could set up this file. This setup
-;; requires a directory called util in the project root and that the
-;; util directory contains the testing tools ert and espuds.
-
-(let* ((features-directory
-        (file-name-directory
-         (directory-file-name (file-name-directory load-file-name))))
-       (project-directory
-        (file-name-directory
-         (directory-file-name features-directory))))
-  (setq emacs-root-path project-directory)
-  (setq emacs-util-path (expand-file-name "util" emacs-root-path)))
-
-(add-to-list 'load-path emacs-root-path)
-(add-to-list 'load-path (expand-file-name "espuds" emacs-util-path))
-(add-to-list 'load-path (expand-file-name "ert" emacs-util-path))
-
-(require 'vimgolf)
-(require 'espuds)
-(require 'ert)
-
-
-(Setup
- ;; Before anything has run
- )
-
-(Before
- ;; Before each scenario is run
- )
-
-(After
- ;; After each scenario is run
- )
-
-(Teardown
- ;; After when everything has been run
- )

data/emacs/todo.org

@@ -1,45 +0,0 @@
-* VimGolf TODO
-
-** Game Excersizes
-
-** Browser
-*** DONE Handle/fix character encoding
-    CLOSED: [2012-07-28 Sat 23:07]
-    :LOGBOOK:
-    - State "DONE"       from "TODO"       [2012-07-28 Sat 23:07] \\
-      Added a utility function to handling &lt, &gt, &amp, and &quot.
-    :END:
-    Things like < and >, etc.
-*** DONE Fix line endings
-    CLOSED: [2012-07-28 Sat 22:51]
-    :LOGBOOK:
-    - State "DONE"       from "TODO"       [2012-07-28 Sat 22:51] \\
-      Added a function to replace ^M with some replacement (default space).
-      Currently only running this function on entry descriptions.
-    :END:
-    Need to convert ^M characters
-*** DONE Add/fix line wrapping
-    CLOSED: [2012-07-28 Sat 22:04]
-    :LOGBOOK:
-    - State "DONE"       from "TODO"       [2012-07-28 Sat 22:04]
-    :END:
-    Can't assume that everyone's emacs will be set the same. Should really set a
-    particular fill-column and enforce it.
-*** DONE Truncate long titles
-    CLOSED: [2012-07-28 Sat 22:21]
-    :LOGBOOK:
-    - State "DONE"       from "IN PROGRESS" [2012-07-28 Sat 22:21]
-    - State "IN PROGRESS" from "TODO"       [2012-07-28 Sat 22:09]
-    :END:
-    Use ellipses to truncate titles that would normally be longer than the
-    fill-column width.
-*** DONE When first loading (via url-retrieve), list isn't showing after the call
-    CLOSED: [2012-07-28 Sat 23:11]
-    :LOGBOOK:
-    - State "DONE"       from "TODO"       [2012-07-28 Sat 23:11] \\
-      The list insertion was happening outside of the async callback. Now it happens
-      during the callback (if url-retrieve is used) and during the browse function
-      itself (if not).
-    :END:
-    I'm not sure if the call back isn't working or what. Manually refreshing
-    will display the list.

data/emacs/vimgolf.el

@@ -1,484 +0,0 @@
-;;; vimgolf.el --- VimGolf interface for the One True Editor
-;; Copyright (C) never, by no one
-
-;;; Author: Tim Visher <tim.visher@gmail.com>
-;;; Maintainer: Tim Visher <tim.visher@gmail.com>
-;;; Created: 2011-11-02
-;;; Version: 0.9.3
-;;; Keywords: games vimgolf vim
-
-;; This file is not part of GNU Emacs
-
-;;; Commentary:
-
-;; This is a simple package that allows Emacs users to compete on [VimGolf][1]
-;; using the One True Editor. Competition can be commenced utilizing `M-x
-;; vimgolf`. When finished with a challenge, `C-c C-v C-c` should finish your
-;; editing, ensure correctness, and submit your score and keystrokes to
-;; [VimGolf][1].
-;;
-;; On second thought, let's not go to Camelot. It's a silly place.
-;;
-;; Patches are accepted at https://github.com/timvisher/vimgolf
-;;
-;; [1]: http://vimgolf.com/
-
-;;; Installation:
-
-;; Use package.el. You'll need to add Marmalade to your archives:
-
-;; (require 'package)
-;; (add-to-list 'package-archives
-;;              '("marmalade" . "http://marmalade-repo.org/packages/"))
-
-;; If you use a version of Emacs prior to 24 that doesn't include
-;; package.el, you can get it from http://bit.ly/pkg-el23. If you have
-;; an older package.el installed from tromey.com, you should upgrade
-;; in order to support installation from multiple sources.
-
-;;; License:
-
-;; [CC BY-NC-SA 3.0](http://creativecommons.org/licenses/by-nc-sa/3.0/)
-
-;;; Contributors
-
-;; Tim Visher (@timvisher)
-;; Steve Purcell (@sanityinc)
-;; Adam Collard (@acollard)
-
-;;; Code:
-
-(defgroup vimgolf nil
-  "Compete on VimGolf with the One True Editor."
-  :prefix "vimgolf-"
-  :group 'applications)
-
-(defcustom vimgolf-key nil
-  "Your VimGolf API Key. Must be set in order to submit your solution."
-  :type 'string
-  :group 'vimgolf)
-
-(defcustom vimgolf-mode-hook '((lambda () (whitespace-mode t)))
-  "A list of functions to call upon the initialization of vimgolf-mode."
-  :type 'hook
-  :group 'vimgolf)
-
-(defvar vimgolf-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map (kbd "C-c C-v C-c") 'vimgolf-submit)
-    (define-key map (kbd "C-c C-v r") 'vimgolf-revert)
-    (define-key map (kbd "C-c C-v d") 'vimgolf-diff)
-    (define-key map (kbd "C-c C-v c") 'vimgolf-continue)
-    (define-key map (kbd "C-c C-v p") 'vimgolf-pause)
-    (define-key map (kbd "C-c C-v q") 'vimgolf-quit)
-    map))
-
-(define-minor-mode vimgolf-mode
-  "Toggle VimGolf mode.
-
-With no argument, this command toggles the mode. Non-null prefix
-argument turns on the mode. Null prefix argument turns off the
-mode.
-
-When VimGolf mode is enabled, several key bindings are defined
-with `C-c C-v` prefixes to help in playing VimGolf.
-
-\\{vimgolf-mode-map}"
-  ;; The initial value.
-  nil
-  ;; The indicator for the mode line.
-  " VimGolf"
-  ;; The minor mode bindings.
-  :keymap vimgolf-mode-map
-  :group 'vimgolf)
-
-(defvar vimgolf-challenge nil)
-(defvar vimgolf-challenge-history nil)
-
-(defvar vimgolf-prior-window-configuration nil)
-
-(defvar vimgolf-working-window-configuration nil)
-
-(defvar vimgolf-work-buffer-name "*vimgolf-work*")
-(defvar vimgolf-start-buffer-name "*vimgolf-start*")
-(defvar vimgolf-end-buffer-name "*vimgolf-end*")
-(defvar vimgolf-keystrokes-buffer-name "*vimgolf-keystrokes*")
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Keystroke logging
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defmacro vimgolf-with-saved-command-environment (&rest body)
-  `(let ((deactivate-mark nil)
-         (this-command this-command)
-         (last-command last-command))
-     ,@body))
-
-(defun vimgolf-capturable-keystroke-p ()
-  (not (or executing-kbd-macro
-           (member this-command
-                   '(digit-argument
-                     negative-argument
-                     universal-argument
-                     universal-argument-other-key
-                     universal-argument-minus
-                     universal-argument-more
-                     isearch-other-meta-char))
-           (string-prefix-p "vimgolf-" (symbol-name this-command)))))
-
-(defun vimgolf-capturable-dangling-keystroke-p ()
-  (member this-command
-          '(calc-dispatch)))
-
-(defvar vimgolf-keystrokes nil
-  "A list of (keys-vector . command) pairs for the keystrokes entered.
-
-Each entry is a cons cell containing a key sequence vector
-suitable for use with `key-description', and a symbol for the
-command that was executed as a result (which may be nil if an
-unknown key sequence was entered).")
-
-(defun vimgolf-maybe-capture-keystroke (pred)
-  "Store the keystrokes for `this-command' if result of calling function `PRED' is not nil."
-  (vimgolf-with-saved-command-environment
-   (when (funcall pred)
-     (setq vimgolf-keystrokes
-           (append vimgolf-keystrokes (list (cons (this-command-keys-vector)
-                                                  this-command)))))))
-
-(defun vimgolf-capture-keystroke ()
-  (vimgolf-maybe-capture-keystroke 'vimgolf-capturable-keystroke-p))
-
-(defun vimgolf-capture-dangling-keystroke ()
-  (vimgolf-maybe-capture-keystroke 'vimgolf-capturable-dangling-keystroke-p))
-
-(defun vimgolf-get-keystrokes-as-string (&optional separator)
-  (unless separator (setq separator " "))
-  (mapconcat 'key-description (mapcar 'car vimgolf-keystrokes) separator))
-
-(defun vimgolf-refresh-keystroke-log ()
-  "Refresh the contents of the keystrokes log buffer."
-  (let ((deactivate-mark nil))
-    (with-current-buffer (get-buffer-create vimgolf-keystrokes-buffer-name)
-      (vimgolf-mode t)
-      (erase-buffer)
-      (insert (format "Challenge ID: %s\n%s\n\n" vimgolf-challenge (vimgolf-challenge-url vimgolf-challenge))
-              (format "Keystrokes (%d):\n\n" (vimgolf-count-keystrokes))
-              (vimgolf-get-keystrokes-as-string)
-              "\n\nFull command log:\n\n")
-      (when vimgolf-keystrokes
-        (let* ((descrs-and-commands
-                (mapcar (lambda (entry) (cons (key-description (car entry)) (cdr entry))) vimgolf-keystrokes))
-               (maxlen (apply 'max (mapcar 'length (mapcar 'car descrs-and-commands))))
-               (fmt (format "%%-%ds  %%s" maxlen)))
-          (dolist (entry descrs-and-commands)
-            (insert (format fmt (car entry) (prin1-to-string (cdr entry) t)) "\n")))))))
-
-(defun vimgolf-enable-capture (enable)
-  "Enable keystroke logging if `ENABLE' is non-nil otherwise disable it."
-  (let ((f (if enable 'add-hook 'remove-hook)))
-    (funcall f 'pre-command-hook 'vimgolf-capture-keystroke)
-    (funcall f 'post-command-hook 'vimgolf-capture-dangling-keystroke)
-    (funcall f 'post-command-hook 'vimgolf-refresh-keystroke-log)))
-
-(defun vimgolf-count-keystrokes ()
-  (apply '+ (mapcar 'length (mapcar 'car vimgolf-keystrokes))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Managing and scoring challenges
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defun vimgolf-solution-correct-p ()
-  "Return t if the work text is identical to the solution, nil otherwise."
-  (let ((working (with-current-buffer vimgolf-work-buffer-name (buffer-string)))
-        (end (with-current-buffer vimgolf-end-buffer-name (buffer-string))))
-    (string= working end)))
-
-(defun vimgolf-wrong-solution ()
-  (message "Wrong!")
-  (vimgolf-diff))
-
-(defun vimgolf-right-solution ()
-  (delete-other-windows)
-  (switch-to-buffer vimgolf-keystrokes-buffer-name)
-  (message "Hurray! You solved %s in %d keystrokes!" vimgolf-challenge (vimgolf-count-keystrokes)))
-
-(defun vimgolf-submit ()
-  "Stop the challenge and attempt to submit the solution to VimGolf."
-  (interactive)
-  (vimgolf-enable-capture nil)
-  (if (vimgolf-solution-correct-p) (vimgolf-right-solution) (vimgolf-wrong-solution)))
-
-(defun vimgolf-clear-keystrokes ()
-  (setq vimgolf-keystrokes nil))
-
-(defun vimgolf-reset-work-buffer ()
-  "Reset the contents of the work buffer, and clear undo/macro history etc."
-  (with-current-buffer (get-buffer-create vimgolf-work-buffer-name)
-    (vimgolf-init-buffer (current-buffer)
-                         (with-current-buffer vimgolf-start-buffer-name
-                           (buffer-string)))
-    (when defining-kbd-macro
-      (end-kbd-macro))
-    (vimgolf-clear-keystrokes)
-    (setq buffer-undo-list nil)
-    (set-buffer-modified-p nil)))
-
-(defun vimgolf-revert ()
-  "Revert the work buffer to it's original state and reset keystrokes."
-  (interactive)
-  (vimgolf-reset-work-buffer)
-  (set-window-configuration vimgolf-working-window-configuration)
-  (message "If at first you don't succeed, try, try again."))
-
-(defun vimgolf-diff ()
-  "Pause the competition and view differences between the buffers."
-  (interactive)
-  (vimgolf-enable-capture nil)
-  (ediff-buffers (get-buffer-create vimgolf-work-buffer-name) (get-buffer-create vimgolf-end-buffer-name))
-  (message "Remember to `C-c C-v c` when you're done."))
-
-(defun vimgolf-continue ()
-  "Restore work and end buffers and begin recording keystrokes again."
-  (interactive)
-  (vimgolf-enable-capture t)
-  (set-window-configuration vimgolf-working-window-configuration)
-  (message "Golf away!"))
-
-(defun vimgolf-pause ()
-  "Stop recording keystrokes."
-  (interactive)
-  (vimgolf-enable-capture nil)
-  (message "Come `C-c C-v c` soon."))
-
-(defun vimgolf-quit ()
-  "Cancel the competition."
-  (interactive)
-  (vimgolf-enable-capture nil)
-  (vimgolf-kill-existing-session)
-  (set-window-configuration vimgolf-prior-window-configuration)
-  (message "I declare you, n00b!"))
-
-(defvar vimgolf-host "http://vimgolf.com/")
-
-;; (setq vimgolf-host "http://vimgolf.local:8888/")
-;; (setq vimgolf-host "http://vimgolf.com/")
-;; Overall VimGolf Rank ID: 4d2fb20e63b08b08b0000075
-;; Sort entries based on date ID: 4ea9bc988b36f70001000008
-;; HTML to Haml ID: 4d3c51f1aabf526ed6000030
-;; Assignment Allignment: 4d2c9d06eda6262e4e00007a
-
-(defvar vimgolf-challenge-extension ".yaml")
-
-(defun vimgolf-challenge-path (challenge-id)
-  (concat "challenges/" challenge-id))
-
-(defun vimgolf-challenge-url (challenge-id)
-  (concat vimgolf-host (vimgolf-challenge-path challenge-id) vimgolf-challenge-extension))
-
-(defun vimgolf-init-buffer (buffer text)
-  (with-current-buffer buffer
-    (erase-buffer)
-    (insert text)
-    (goto-char (point-min))
-    (vimgolf-mode t)))
-
-(defun vimgolf-kill-existing-session ()
-  "Kill any vimgolf-related buffers."
-  (dolist (buf (list vimgolf-start-buffer-name
-                     vimgolf-work-buffer-name
-                     vimgolf-end-buffer-name
-                     vimgolf-keystrokes-buffer-name))
-    (when (get-buffer buf)
-      (kill-buffer buf))))
-
-(defun vimgolf-read-next-data-chunk ()
-  "Return the next chunk of data as a string, leaving the point at the end of that chunk."
-  (let ((data-start-regexp "  data: |\\+\\{0,1\\}\n")
-        (data-end-regexp "\\([ 	]\\{4\\}\\|[ 	]\\{0\\}\\)\n  type: [-a-z]+"))
-    (unless (re-search-forward data-start-regexp nil t)
-      (error "Can't find data in response from vimgolf"))
-    (let ((start (point)))
-      (unless (re-search-forward data-end-regexp nil t)
-        (error "Unclosed data section in response from vimgolf"))
-      (let ((str (buffer-substring-no-properties start (match-beginning 0))))
-        (replace-regexp-in-string "^    " "" str)))))
-
-(defun vimgolf-setup (status challenge-id)
-  (vimgolf-clear-keystrokes)
-  (setq vimgolf-prior-window-configuration (current-window-configuration)
-        vimgolf-challenge challenge-id)
-  (goto-char (point-min))
-  (let* ((start-text (vimgolf-read-next-data-chunk))
-         (end-text (vimgolf-read-next-data-chunk)))
-
-    (vimgolf-kill-existing-session)
-
-    (let ((vimgolf-start-buffer (get-buffer-create vimgolf-start-buffer-name))
-          (vimgolf-work-buffer (get-buffer-create vimgolf-work-buffer-name))
-          (vimgolf-end-buffer (get-buffer-create vimgolf-end-buffer-name)))
-
-      (vimgolf-init-buffer vimgolf-start-buffer start-text)
-      (vimgolf-init-buffer vimgolf-end-buffer end-text)
-      (with-current-buffer vimgolf-end-buffer (setq buffer-read-only t))
-      (vimgolf-reset-work-buffer)
-
-      ;; Set up windows
-      (delete-other-windows)
-      (display-buffer vimgolf-end-buffer 'display-buffer-pop-up-window)
-      (set-window-buffer (selected-window) vimgolf-work-buffer)
-      (switch-to-buffer vimgolf-work-buffer)
-      (setq vimgolf-working-window-configuration (current-window-configuration))
-
-      (vimgolf-continue))))
-
-(defvar *vimgolf-browse-list* nil
-  "Holds a list of parsed VimGolf challenges.")
-
-(defun vimgolf-browse (&optional force-pull)
-  (interactive)
-  (if (or (eq *vimgolf-browse-list* nil)
-          force-pull)
-      (url-retrieve vimgolf-host 'vimgolf-parse-browse-html)
-    (vimgolf-browse-list)
-    (vimgolf-browse-next)))
-
-(defun vimgolf-browse-refresh ()
-  (interactive)
-  (vimgolf-browse t))
-
-(defun vimgolf-replace-control-m (string &optional replace)
-  (replace-regexp-in-string "
-
-(defun vimgolf-parse-html-entites (string)
-  (replace-regexp-in-string
-   "&lt;" "<"
-   (replace-regexp-in-string
-    "&gt;" ">"
-    (replace-regexp-in-string
-     "&amp;" "&"
-     (replace-regexp-in-string
-      "&quot" "\""
-      string)))))
-
-(defun vimgolf-parse-browse-html (status)
-  (with-current-buffer (current-buffer)
-    (let ((html (vimgolf-parse-html-entites
-                 (replace-regexp-in-string "\n" "" (buffer-string))))
-          (start 0))
-      (setq *vimgolf-browse-list* nil)
-      (while
-          (string-match
-           "<a href=\"/challenges/\\([a-zA-Z0-9]+\\)\">\\(.*?\\)</a>.*?<p>\\(.*?\\)</p>"
-           html)
-        (add-to-list '*vimgolf-browse-list*
-                     (cons (match-string 1 html)
-                           (list (match-string 2 html)
-                                 (vimgolf-replace-control-m
-                                  (match-string 3 html))))
-                     t)
-        (setq html (substring html (match-end 0))))
-      *vimgolf-browse-list*))
-  (vimgolf-browse-list)
-  (vimgolf-browse-next))
-
-(defun vimgolf-browse-list ()
-  (let ((browse-buffer (get-buffer-create "*VimGolf Browse*")))
-    (switch-to-buffer browse-buffer)
-    (setq buffer-read-only nil)
-    (kill-region (point-min) (point-max))
-    (insert "VimGolf Challenges")
-    (newline 2)
-    (dolist (challenge *vimgolf-browse-list*)
-      (let ((title (substring (cadr challenge)
-                              0
-                              (min (length (cadr challenge))
-                                   (- fill-column 3))))
-            (description (car (cdr (cdr challenge))))
-            (challenge-id (car challenge)))
-        (when (< (length title) (length (cadr challenge)))
-          (setq title (concat title "...")))
-        (insert-text-button title
-                            'action 'vimgolf-browse-select
-                            'follow-link t
-                            'challenge-id challenge-id 
-                            'help-echo description))
-      (newline)))
-  (beginning-of-buffer)
-  (vimgolf-browse-mode))
-
-(defun vimgolf-browse-select (arg)
-  (let ((challenge-id (get-text-property (point) 'challenge-id)))
-    (vimgolf challenge-id)))
-
-(defun vimgolf-message-title ()
-  (let ((challenge-id (get-text-property (point) 'challenge-id)))
-    (when challenge-id
-      (message (cadr (assoc challenge-id *vimgolf-browse-list*))))))
-
-(defun vimgolf-browse-next ()
-  (interactive)
-  (goto-char (next-single-property-change (point) 'challenge-id))
-  (unless (get-text-property (point) 'challenge-id)
-    (goto-char (next-single-property-change (point) 'challenge-id)))
-  (vimgolf-message-title))
-
-(defun vimgolf-browse-previous ()
-  (interactive)
-  (goto-char (previous-single-property-change (point) 'challenge-id))
-  (unless (get-text-property (point) 'challenge-id)
-    (goto-char (previous-single-property-change (point) 'challenge-id)))
-  (vimgolf-message-title))
-
-(defun vimgolf-show-description ()
-  (interactive)
-  (let ((challenge-id (get-text-property (point) 'challenge-id)))
-    (save-excursion
-      (setq buffer-read-only nil)
-      (if (text-property-any (point-min) (point-max) 'challenge-description challenge-id)
-          (progn
-            (beginning-of-buffer)
-            (while (not (eq (get-text-property (point) 'challenge-description) challenge-id))
-              (goto-char (next-single-property-change (point) 'challenge-description)))
-            (let ((start (point)))
-              (goto-char (next-single-property-change (point) 'challenge-description))
-              (delete-region start (point))
-              (delete-blank-lines)
-              (delete-blank-lines)))
-        (end-of-line)
-        (newline 3)
-        (forward-line -1)
-        (let ((start (point)))
-          (insert "  " (car (cddr (assoc challenge-id *vimgolf-browse-list*))))
-          (fill-region start (point))
-          (add-text-properties start (point) `(challenge-description ,challenge-id))))
-      (setq buffer-read-only t))))
-
-;;;###autoload
-(defun vimgolf (challenge-id)
-  "Open a VimGolf Challenge"
-  (interactive (list (read-from-minibuffer "Challenge ID: " nil nil nil 'vimgolf-challenge-history)))
-  (url-retrieve (vimgolf-challenge-url challenge-id) 'vimgolf-setup `(,challenge-id)))
-
-(defvar vimgolf-browse-mode-map (make-sparse-keymap)
-  "Keymap for vimgolf-mode.")
-
-(define-derived-mode vimgolf-browse-mode special-mode "vimgolf browse"
-  "A major mode for completing vimgolf challenges.
-
-\\{vimgolf-browse-mode-map}"
-  (define-key vimgolf-browse-mode-map (kbd "TAB") 'vimgolf-show-description)
-  (define-key vimgolf-browse-mode-map "g" 'vimgolf-browse-refresh)
-  (define-key vimgolf-browse-mode-map "n" 'vimgolf-browse-next)
-  (define-key vimgolf-browse-mode-map "p" 'vimgolf-browse-previous)
-)
-
-(put 'vimgolf-mode 'mode-class 'special)
-
-(provide 'vimgolf)
-
-;;; Local Variables:
-;;; tab-width:2
-;;; indent-tabs-mode:nil
-;;; End:
-;;; vimgolf.el ends here