(in-package :stumpwm)
(eval-when (:load-toplevel :compile-toplevel :execute)
  (load "~/quicklisp/setup.lisp")
  (ql:quickload :swank))
(defcommand start-swank () ()
  (swank:start-server :port 4587 :dont-close t))
(set-prefix-key (kbd "s-space"))
(defparameter *browser-command* "/usr/bin/google-chrome-beta")
(defun cat (&rest strings)
  (apply 'concatenate 'string strings))
(defgeneric get-search-url (provider &rest strings)
  (:method-combination append :most-specific-last)
  (:method :around (provider &rest r)
   (declare (ignore r))
   (apply #'concatenate 'string (call-next-method)))
  (:method append (provider &rest r)
   (declare (ignore r))
   (list "https://duckduckgo.com/?q="))
  (:method append ((provider (eql nil)) &rest strings)
   (list* (car strings) (loop for string in (cdr strings) nconcing (list "+" string))))
  (:method append ((provider (eql :google)) &rest strings)
   (list* "%21google" (loop for string in strings nconcing (list "+" string)))))
(defmacro add-provider (name ddg-shortcut)
  `(defmethod get-search-url append ((provider (eql ,name)) &rest strings)
     (list* (concatenate 'string "%21" ,ddg-shortcut)
            (loop for string in strings nconcing (list "+" string)))))
(defmacro add-providers (&body definitions)
  `(progn
     ,@(loop for (name shortcut) in definitions
             collect `(add-provider ,name ,shortcut))))
(add-providers
  (:amazon "a")
  (:php "php")
  (:python "python")
  (:stack-overflow "sof")
  (:lisp "lisp")
  (:wikipedia "w"))
(defcommand google (provider search-string) ((:string "Search Provider? ") (:string "Search Google for: "))
  "Search google for a given string"
  (check-type search-string (or null string))
  (when search-string)
  (run-shell-command (cat *browser-command* " "
                          (get-search-url :google (substitute #\+ #\space search-string)))))
(defcommand do-search (provider search-string) ((:string "Provider: ") (:string "Search for: "))
  "Run a search against a specified provider"
  (check-type provider (or null string))
  (check-type search-string (or null string))
  (when (and provider search-string)
    (let ((provider (intern (string-upcase provider) :keyword)))
      (run-shell-command (cat *browser-command* " "
                              (get-search-url provider (substitute #\+ #\space search-string)))))))
(defcommand google (search-string) ((:string "Search Google for: "))
  "Search google for a given string"
  (check-type search-string (or null string))
  (when search-string
    (run-shell-command (cat *browser-command* " "
                            (get-search-url :google (substitute #\+ #\space search-string))))))
(defcommand duckduckgo (search-string) ((:string "Search DDG for: "))
  "Search duckduckgo gor a given string"
  (check-type search-string (or null string))
  (when search-string
    (run-shell-command (cat *browser-command* " "
                            (get-search-url nil (substitute #\+ #\space search-string))))))
(defcommand search-for-selection (provider) ((:string "Search Provider?"))
  "Search for the x selection with provider"
  (do-search provider (get-x-selection)))
(defparameter *selection-search-map* nil "selection search map")
(fill-keymap *selection-search-map*
             (kbd "g") "search-for-search google"
             (kbd "/") "search-for-search google"
             (kbd "s-/") "search-for-search google" 
             (kbd "l") "search-for-selection lisp")
(defparameter *search-map* nil "search map")
(fill-keymap *search-map*
             (kbd "a") "do-search amazon"
             (kbd "h") "do-search php"
             (kbd "p") "do-search python"
             (kbd "o") "do-search stack-overflow"
             (kbd "y") "do-search youtube"
             (kbd "l") "do-search lisp"
             (kbd "w") "do-search wikipedia"
             (kbd "d") "do-search duckduckgo"
             (kbd "g") "do-search google"
             (kbd "s") *selection-search-map*
             (kbd "/") "do-search google"
             (kbd "Return") "search-for-selection google"
             (kbd "s-/") "do-search google")
(define-key *top-map* (kbd "s-/") *search-map*)
(define-key *top-map* (kbd "s-TAB") "fnext")
(define-key *top-map* (kbd "s-ISO_Left_Tab") "fother")
; vim: set ft=lisp:

#!/bin/sh
cachedir=${XDG_CACHE_HOME:-"$HOME/.cache"}
if [ -d "$cachedir" ]; then
	cache=$cachedir/yeganesh_run
else
	cache=$HOME/.yeganesh_cache # if no xdg dir, fall back to dotfile in ~
fi
(
	IFS=:
	if stest -dqr -n "$cache" $PATH; then
		stest -flx $PATH | sort -u | tee "$cache" | /home/edwlan/.local/bin/yeganesh "$@"
	else
		/home/edwlan/.local/bin/yeganesh "$@" < "$cache"
	fi
) | ${SHELL:-"/bin/sh"} &

#!/usr/bin/python2
import subprocess
import random
import argparse
p = argparse.ArgumentParser()
p.add_argument('probability', nargs=2)
p.add_argument('program')
args = p.parse_args()
prob = map(float, args.probability)
prob = prob[0]/prob[1]
if random.random() < prob:
    subprocess.call(args.program)

#!/usr/bin/python -u
from __future__ import print_function
import heapq
def file_iter(fil):
    line = 0
    while line != '':
        line = fil.readline()
        yield line
def sorter(gen, len_):
    buffer = []
    for line in gen:
        heapq.heappush(buffer, line)
        if len(buffer) == len_:
            yield heapq.heappop(buffer)
if __name__ == '__main__':
    import sys
    for line in sorter(file_iter(sys.stdin), 10):
        print('>', line, end='')

#!/usr/bin/env python
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('files_to_ignore', nargs='*')
args = parser.parse_args()
try:
  lines = []
  if args.files_to_ignore != []:
    lines.extend(args.files_to_ignore)
  else:
    lines = []
    try:
      getline = lambda: raw_input('? ').strip()
      line = getline()
      while line != '.':
        lines.append(line)
        line = getline()
    except EOFError:
      pass
  with open('.gitignore', 'a') as f:
    for line in lines:
      print 'ignoring %s' % line
      print >> f, line
except KeyboardInterrupt:
  pass

#!/bin/python -u
import collections
import os
items = collections.OrderedDict()
import sys
def file_iter(fil):
    line = 0;
    while line != '':
        line = fil.readline()
        yield line
if __name__ == '__main__':
    for lin in file_iter(sys.stdin):
        head, _, tail = os.path.basename(lin).rpartition('__')
        items.setdefault(head, []).append(lin)
    for key in items:
        if len(items[key]) > 1:
            print '\n'.join(sorted(items[key]))

#!/usr/bin/env zsh
if tmux list-sessions; then
  echo -n "Choose session? "
  read SESS
  tmux attach -d -t $SESS
else
  tmux
fi

NeoBundle 'dbakker/vim-paragraph-motion'
 NeoBundle 'jceb/vim-editqf'

 "NeoBundle 'rking/ag.vim' "Ag search utility

 NeoBundle 'rking/ag.vim' "Ag search utility

  "let g:unite_source_grep_command = 'ag'
  "let g:unite_source_grep_default_opts =
  "      \ '--line-numbers --nocolor --nogroup --hidden --ignore ' .
  "      \ '''.hg'' --ignore ''.svn'' --ignore ''.git'' --ignore ''.bzr'' ' .
  "      \ '--ignore ''**/*.pyc'''
  "let g:unite_source_grep_recursive_opt = ''

  let g:unite_source_grep_command = 'ag'
  let g:unite_source_grep_default_opts =
        \ '--line-numbers --nocolor --nogroup --hidden --ignore ' .
        \ '''.hg'' --ignore ''.svn'' --ignore ''.git'' --ignore ''.bzr'' ' .
        \ '--ignore ''**/*.pyc'''
  let g:unite_source_grep_recursive_opt = ''