vimgolf 0.4.8 → 0.4.9

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,488 +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.10.0
-;;; 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)
-;; Siddhanathan Shanmugam (@siddhanathan)
-
-;;; Code:
-
-(require 'json)
-
-(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 ".json")
-
-(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-get-text (var response)
-  (format "%s" (assoc-default 'data (assq var response))))
-
-(defun vimgolf-retrieve-challenge (challenge-id)
-  (interactive)
-  (with-current-buffer
-      (url-retrieve-synchronously (vimgolf-challenge-url challenge-id))
-    (goto-char url-http-end-of-headers)
-    (json-read)))
-
-(defun vimgolf-setup (status challenge-id)
-  (let ((url-mime-encoding-string "identity"))
-    (setq vimgolf-response (vimgolf-retrieve-challenge 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-get-text 'in vimgolf-response))
-         (end-text   (vimgolf-get-text 'out vimgolf-response)))
-    (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