I called it: Universal Lint, ulint for short.

At the moment, Python, Javascript and Haskell files are supported, but adding new linters/extension is trivial.

Download it and use it!

It looks like requesting a non-existent video on Youtube causes a “500 Internal Server Error”!

Requesting a non-existing video on Youtube returns 500!

For example:

• Valid url: http://www.youtube.com/watch?v=b5CeNunbHto
• Invalid url: http://www.youtube.com/watch?v=wtf

Surely, a better response would be something like the one returned when  the videoId is misisng: http://www.youtube.com/watch?v=

Seems like predictions became true.

First of all, in order to have similar performance to grep, I had to convert my original program to use Haskell’s bytestrings. You can find the code here.

Testing files are generated with this script.

Here are the results obtained. grep is still faster for smallish files (I haven’t spent too much time tweaking hsgrep), but hsgrep scales much better and it wins for files larger than few megabytes!

My program is a rewrite of sgrep in Haskell: I called it HSGrep.

Code is available on github.

Thanks a lot for all your useful suggestions! As soon as possible, I’ll post some benchmarking here. (EDIT: benchmarks now available!)

After downloading the source code, build install and run it with:

$> cabal build
$> cabal install
$> hslint <string> <filename>

#!/usr/bin/python

import os
import sys
import re
import subprocess

devnull = open(os.devnull, 'w')

def call(cmd):
    p = subprocess.Popen(cmd.split(),
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE)
    out, err = p.communicate()
    return out.decode('utf-8'), err.decode('utf-8')

def execute(cmd, silent=False):
    if silent:
        params = {
                'stdout': devnull,
                'stderr': devnull,
                }
    else:
        params = {}

    retcode = subprocess.call(cmd.split(), **params)
    return retcode

def exists(cmd):
    return execute('which %s' % cmd, silent=True) == 0

def get_modified(ext):
    modified = re.compile('^(?:M|A).(?P<name>.*\.%s)' % ext)
    out, _ = call('git status --porcelain')
    modifieds = []
    for line in out.splitlines():
        match = modified.match(line.strip())
        if (match):
            modifieds.append(match.group('name'))
    return modifieds

def output(prg, out, err):
    print(' * %s:\n%s\n%s' % (prg, out, err))

def die(msg):
    print(msg)
    sys.exit(1)

def check_python():

    has_pep8 = exists('pep8')
    has_pyflakes = exists('pyflakes')
    if not (has_pep8 or has_pyflakes):
        die('Install PEP8 and PyFlakes!')

    modifieds = get_modified('py')
    rrcode = 0
    for file in modifieds:
        if has_pep8:
            out, err = call('pep8 %s' % file)
            if out or err:
                output('pep8', out, err)
                rrcode = rrcode | 1
        if has_pyflakes:
            retcode = execute('pyflakes %s' % file)
            rrcode = retcode | rrcode

    if rrcode != 0:
        sys.exit(rrcode)

def check_javascript():

    has_jsl = exists('gjslint')
    if not has_jsl:
        die('Install Closure-Lint!')

    modifieds = get_modified('js')
    rrcode = 0
    for file in modifieds:
        out, err = call('gjslint %s' % file)
        if out or err:
            output('gjslint', out, err)
            rrcode = rrcode | 1

    if rrcode != 0:
        sys.exit(rrcode)

def main():
    check_python()
    check_javascript()

if __name__ == '__main__':
    main()

It’s a work-in-progress, so you can find the most updated version here.

To use it, just drop it in your .git/hooks directory. At every git commit, it will run pep8 and pyflakes on .py files, and gjslint on .js files.

Here are the packages and config files I use:

• Haskell mode: interaction with Haddock, compiler integration, and other general settings.
• Indentation: proper source code indentation.
• More configs to enforce good style (no tabs, tabstops, etc.): 

  " Add to .vimrc
  " Need to have .vim/compiler/ghc.vim
  
  augroup HSK
          au Bufenter *.hs compiler ghc
          autocmd FileType haskell setlocal formatoptions+=t
          autocmd FileType haskell let b:ghc_staticoptions = '-Wall -Werror'
  augroup END
  
  

  view raw haskell-.vimrc.vim This Gist brought to you by GitHub.

  " Add to .vim/ftplugin/haskell.vim
  
  " From Good Haskell Style http://urchin.earth.li/~ian/style/haskell.html
  setlocal expandtab
  setlocal tabstop=8
  setlocal shiftwidth=8
  setlocal textwidth=79

  view raw haskell-ftplugin.vim This Gist brought to you by GitHub.

  " Add to .vim/syntax/haskell.vim
  
  " From Good Haskell Style http://urchin.earth.li/~ian/style/haskell.html
  
  syn cluster hsRegions add=hsImport,hsLineComment,hsBlockComment,hsPragma
  syn cluster hsRegions add=cPreCondit,cCppOut,cCppOut2,cCppSkip
  syn cluster hsRegions add=cIncluded,cDefine,cPreProc,cComment,cCppString
  
  syn match tab display "\t" containedin=@hsRegions
  hi link tab Error
  syn match trailingWhite display "[[:space:]]\+$" containedin=@hsRegions
  hi link trailingWhite Error

  view raw haskell-syntax.vim This Gist brought to you by GitHub.

You can also have them bundled all together.

• bookmarklet in Chrome can’t be drag-n-dropped to the toolbar. its javascript code is also hard to copy and paste to create the bookmarklet “manually”.
• install links for the chrome and firefox extensions redirect to empty pages.
• documentation for developer is coming soon (!)
• the top-right menu with the logged-in username and stuff is the most horrible I’ve ever seen: it changes its width on hover, the corners look interrupted (in Chrome, at least — I’m not bothered trying with other browsers)
• what the hell are stacks? grouping can be done with tags, already, and I don’t want that much space in the page taken by a “social” feature! who needs it?
• the list of links in the main personal page only shows 8 links on my screen… 8 links?! there’s way too much padding, too whitespaces, too much to scroll… it’s a bookmarking services, it should show you bookmarks in the most friendly way!
• image: why should I use an image for myself? and if I don’t use one, I got assigned one by default… please…

I’ll add more to the list in the future.

import Network.HTTP
import Control.Applicative

url = "http://www.haskell.org/haskellwiki/Haskell"

--  Imperative style
fetch_1 = do
	rsp <- Network.HTTP.simpleHTTP (getRequest url)
	body <- getResponseBody rsp
	return (take 1000 body)

--  With Functors' fmap
fetch_2 = do
	rsp <- Network.HTTP.simpleHTTP (getRequest url)
	fmap (take 1000) (getResponseBody rsp)

--  With Applicative's >>=
fetch_3 = fmap (take 1000) (Network.HTTP.simpleHTTP (getRequest url) >>= getResponseBody)

--  "fmap f x" is the same as "pure f <*> x" (Applicative's law)
fetch_4 = pure (take 1000) <*> (Network.HTTP.simpleHTTP (getRequest url) >>= getResponseBody)

--  "pure f <*> x" is the same as "f <$> x"
fetch_5 = (take 1000) <$> (Network.HTTP.simpleHTTP (getRequest url) >>= getResponseBody)

it’s a long time since I found so many new concepts while studying a new programming language…

unfortunately, the script stopped working after a pylint upgrade:

$ pylint --version
pylint 0.24.0,
astng 0.22.0, common 0.56.0
Python 2.7.2 (default, Jun 29 2011, 11:10:00)
[GCC 4.6.1]

you can download the fixed version here!

if interested, the patch looks like this:

diff pylint.vim.orig pylint.vim
69c69
< CompilerSet makeprg=(echo\ '[%]';\ pylint\ -r\ y\ %)
---
> CompilerSet makeprg=(echo\ '[%]';\ pylint\ -r\ y\ --output-format=parseable\ %)
74c74
< CompilerSet efm=%+P[%f],%t:\ %#%l:%m,%Z,%+IYour\ code%m,%Z,%-G%.%#
---
> CompilerSet efm=%f:%l:\ [%t]%m,%f:%l:%m

In [1]: import hashlib

In [2]: %timeit hashlib.md5('text text text').hexdigest()
1000000 loops, best of 3: 1.29 us per loop

In [3]: %timeit hashlib.sha1('text text text').hexdigest()
1000000 loops, best of 3: 1.4 us per loop

Result is: MD5 is faster, but only just, in Python 2.7.2. Considering that MD5 is broken, I think I’ll use SHA1…