murlsh 0.2.1

data/public/js/js.js

@@ -0,0 +1,229 @@
+var Murlsh = {};
+
+Murlsh.new_img = function(src, text) {
+  return $('<img />').attr({
+    src : src,
+    alt : text,
+    title : text
+  });
+};
+
+Murlsh.close = function() {
+  $(this).parent().remove();
+};
+
+Murlsh.closer_add = function(x) {
+  var html = (typeof x == 'object') ? $('<div />').append(x).html() : x;
+
+  $.jGrowl(html, {
+    closeTemplate : 'X',
+    glue :'before',
+    sticky : true
+    });
+};
+
+Murlsh.object_tag = function(data, height, width, params) {
+  var result = '<object data="' + data + '" height="' + height +
+    '" type="application/x-shockwave-flash" width="' + width + '">';
+  $.each(params, function(i, v) {
+    result += '<param name="' + v.name + '" value="' + v.value + '" />';
+  });
+  result += '</object>';
+  return result;
+};
+
+Murlsh.flickr_thumb = function(d) {
+  var base = 'http://farm' + d.photo.farm + '.static.flickr.com/' +
+    d.photo.server + '/' + d.photo.id + '_';
+  var zoom;
+  if (d.photo.originalsecret) {
+    zoom = base + d.photo.originalsecret + '_o.' + d.photo.originalformat;
+  } else {
+    zoom = base + d.photo.secret + '_m.jpg';
+  }
+
+  return Murlsh.new_img(base + d.photo.secret + '_s.jpg',
+    d.photo.title._content).addClass(
+    'thumb flickr').data('zoom', zoom);
+};
+
+Murlsh.flickr_click = function() {
+  Murlsh.closer_add(Murlsh.new_img($(this).data('zoom'), ''));
+};
+
+Murlsh.imageshack_thumb = function(prefix, ext) {
+  return Murlsh.new_img(prefix + 'th.' + ext, '').addClass('thumb imgshack');
+};
+
+Murlsh.imageshack_click = function() {
+  Murlsh.closer_add(Murlsh.new_img($(this).data('href'), ''));
+};
+
+Murlsh.vimeo_thumb = function(d) {
+  return Murlsh.new_img(d.thumbnail_url, d.title).addClass('thumb vimeo').attr({
+    height : d.thumbnail_height,
+    width : d.thumbnail_width
+  });
+};
+
+Murlsh.vimeo_click = function() {
+  Murlsh.closer_add($(this).data('embed_html'));
+};
+
+Murlsh.youtube_thumb = function(id) {
+  return Murlsh.new_img('http://img.youtube.com/vi/' + id + '/1.jpg',
+    'click to watch').addClass('thumb youtube').data('id', id);
+};
+
+Murlsh.youtube_click = function() {
+  var movie = 'http://www.youtube.com/v/' + $(this).data('id') +
+    '?hd=1&amp;hl=en&amp;fs=1&amp;showinfo=0&amp;showsearch=0';
+  Murlsh.closer_add(Murlsh.object_tag(movie, 344, 425, [{ name : 'movie', value : movie }]));
+};
+
+Murlsh.is_iphone = function() {
+  return navigator.userAgent.match(/i(phone|pod)/i);
+};
+
+Murlsh.add_extra = function() {
+  var this_a = $(this);
+
+  var href = $(this).attr('href');
+
+  var flickr_match =
+    /^http:\/\/(?:www\.)?flickr\.com\/photos\/[^\/]+?\/([0-9]+)/i.exec(
+    href);
+
+  var imageshack_match =
+    /^(http:\/\/img\d+\.imageshack\.us\/img\d+\/\d+\/\w+\.)(jpg|gif|png)$/i.exec(
+    href);
+
+  var mp3_match = /.*\.mp3$/i.exec(href);
+
+  var s3_match =
+    /^(http:\/\/static\.mmb\.s3\.amazonaws.com\/.*\.)(jpg|gif|png)$/i.exec(
+    href);
+
+  var vimeo_match = /^http:\/\/(?:www\.)?vimeo\.com\/([0-9]+)$/i.exec(href);
+
+  var youtube_match =
+    /^http:\/\/(?:(?:www|uk)\.)?youtube\.com\/watch\?v=(.+?)(?:&|$)/i.exec(
+    href);
+
+  var thumb;
+  var thumb_insert_func;
+
+  if (flickr_match) {
+    thumb_insert_func = function flickr_thumb_insert(d) {
+      var img = Murlsh.flickr_thumb(d);
+      if (Murlsh.is_iphone()) {
+        this_a.prepend(img);
+      } else {
+        this_a.before(img.click(Murlsh.flickr_click));
+      }
+    };
+    $.getJSON('http://api.flickr.com/services/rest/?api_key=d04e574aaf11bf2e1c03cba4ee7e5725&method=flickr.photos.getinfo&format=json&photo_id=' +
+      flickr_match[1] + '&jsoncallback=?', thumb_insert_func);
+  } else if (imageshack_match) {
+    thumb = Murlsh.imageshack_thumb(imageshack_match[1], imageshack_match[2]);
+    this_a.html('imageshack.us');
+    if (Murlsh.is_iphone()) {
+      this_a.prepend(thumb);
+    } else {
+      this_a.before(thumb.data('href', imageshack_match[0]).click(
+        Murlsh.imageshack_click));
+    }
+  } else if (mp3_match) {
+    var swf = 'swf/player_mp3_mini.swf';
+    $(this).before(Murlsh.object_tag(swf, 20, 200, [
+      { name : 'bgcolor', value : '#000000' },
+      { name : 'FlashVars', value : 'mp3=' + mp3_match[0] },
+      { name : 'movie', value : swf }
+    ]));
+  } else if (s3_match) {
+    thumb = Murlsh.imageshack_thumb(s3_match[1], s3_match[2]);
+    if (Murlsh.is_iphone()) {
+      this_a.html(thumb);
+    } else {
+      this_a.html('link');
+      this_a.before(thumb.data('href', s3_match[0]).click(
+        Murlsh.imageshack_click));
+    }
+  } else if (vimeo_match) {
+    thumb_insert_func = function vimeo_thumb_insert(d) {
+      var img = Murlsh.vimeo_thumb(d);
+      if (Murlsh.is_iphone()) {
+        this_a.prepend(img);
+      } else {
+        this_a.before(img.data('embed_html', d.html).click(
+          Murlsh.vimeo_click));
+      }
+    };
+    $.getJSON('http://vimeo.com/api/oembed.json?url=http%3A//vimeo.com/' +
+      vimeo_match[1] + '&callback=?', thumb_insert_func);
+  } else if (youtube_match) {
+    var img = Murlsh.youtube_thumb(youtube_match[1]);
+    if (Murlsh.is_iphone()) {
+      $(this).prepend(img);
+    } else {
+      $(this).before(img.click(Murlsh.youtube_click));
+    }
+  }
+};
+
+Murlsh.format_li = function(d) {
+  var li = $('<li />').append($('<a />').attr('href', d.url).text(
+    d.title));
+
+  if (d.name) {
+    li.prepend($('<div />').addClass('name').text(d.name));
+  }
+
+  var icon_size = 32;
+
+  if (d.email) {
+    li.prepend($('<div />').addClass('icon').append(
+      Murlsh.new_img(
+        'http://www.gravatar.com/avatar/' + d.email + '?s=' + icon_size,
+        d.name).attr({
+        width : icon_size,
+        height : icon_size
+      })));
+  }
+
+  return li;
+};
+
+Murlsh.orientation_changed = function() {
+  if (window.orientation === 0 || window.orientation == 180) {
+    $('#urls').width(290);
+  } else {
+    $('#urls').width(450);
+  }
+};
+
+window.onorientationchange = Murlsh.orientation_changed;
+
+$(document).ready(function() {
+  Murlsh.orientation_changed();
+  $('a').map(Murlsh.add_extra);
+  $('#urls li:even').addClass('even');
+
+  $('#submit').click(function() {
+    $.post('url', {
+      url : $('#url').val(),
+      auth : $('#auth').val()
+      }, function(d) {
+        $.each(d, function(i, v) {
+          var li = Murlsh.format_li(v);
+          $('#urls > li:first').after(li);
+          $(li).children('a:first').map(Murlsh.add_extra);
+        });
+        $('#url').val('');
+      }, 'json');
+  });
+
+  if ($.cookie('auth')) {
+    $('#auth').val($.cookie('auth'));
+  }
+});

data/test/auth_test.rb

@@ -0,0 +1,34 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'murlsh'
+
+require 'test/unit'
+
+class AuthTest < Test::Unit::TestCase
+
+  def setup
+    @f = '/tmp/murlsh_users_test'
+
+    @a = Murlsh::Auth.new(@f)
+
+    @a.add_user('test1', 'test1@test.com', 'secert1')
+    @a.add_user('test2', 'test2@test.com', 'secert2')
+    @a.add_user('test3', 'test3@test.com', 'secert3')
+  end
+
+  def teardown
+    File.delete(@f)
+  end
+
+  def test_auth_good
+    assert_equal({
+      :name => 'test1',
+      :email => Digest::MD5.hexdigest('test1@test.com') },
+      @a.auth('secert1'))
+  end
+
+  def test_bad
+    assert_equal(nil, @a.auth('not there'))
+  end
+
+end

data/test/get_charset_test.rb

@@ -0,0 +1,25 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'murlsh'
+
+require 'rubygems'
+require 'hpricot'
+
+require 'test/unit'
+
+class GetCharsetTest < Test::Unit::TestCase
+
+  def test_no_charset
+    doc = Hpricot(<<eos
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+ "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+<head></head>
+<body></body>
+</html>
+eos
+)
+    assert_nil(Murlsh.get_charset(doc))
+  end
+
+end

data/test/get_content_type_test.rb

@@ -0,0 +1,63 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'murlsh'
+
+require 'test/unit'
+require 'uri'
+
+class GetContentTypeTest < Test::Unit::TestCase
+
+  def test_nil
+    assert_equal('', Murlsh.get_content_type(nil))
+  end
+
+  def test_empty
+    assert_equal('', Murlsh.get_content_type(''))
+  end
+
+  def test_bad_url
+    assert_equal('', Murlsh.get_content_type('not a url'))
+  end
+
+  def test_bad_host
+    assert_equal('', Murlsh.get_content_type('http://a.b/test/'))
+  end
+
+  def test_bad_path
+    assert_equal('', Murlsh.get_content_type(
+      'http://matthewm.boedicker.org/does_not_exist/'))
+  end
+
+  def test_good
+    assert_match(/^text\/html/, Murlsh.get_content_type(
+      'http://www.google.com/'))
+  end
+
+  def test_already_parsed
+    assert_match(/^text\/html/, Murlsh.get_content_type(
+      URI('http://www.google.com/')))
+  end
+
+  def test_already_parsed_https
+    assert_match(/^text\/html/, Murlsh.get_content_type(
+      URI('https://msp.f-secure.com/web-test/common/test.html')))
+  end
+
+  def test_303
+    # youtube returns a 303
+    assert_match(/^text\/html/, Murlsh.get_content_type(
+      'http://www.youtube.com/watch?v=vfxCnZ4Dp3c'))
+  end
+
+  def test_failproof_true
+    assert_equal('', Murlsh.get_content_type('http://x.boedicker.org/',
+      :failproof => true))
+  end
+
+  def test_failproof_false
+    assert_raise SocketError do
+      Murlsh.get_content_type('http://x.boedicker.org/', :failproof => false)
+    end
+  end
+
+end

data/test/get_title_test.rb

@@ -0,0 +1,43 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'murlsh'
+
+require 'test/unit'
+
+class GetTitleTest < Test::Unit::TestCase
+
+  def noop(url)
+    assert_equal(url, Murlsh.get_title(url))
+  end
+
+  def test_nil
+    noop(nil)
+  end
+
+  def test_empty
+    noop('')
+  end
+
+  def test_invalid_url
+    noop('foo')
+  end
+
+  def test_invalid_host
+    noop('http://28fac7a1ac51976c90016509d97c89ba.edu/')
+  end
+
+  def test_good
+    assert_equal('Google', Murlsh.get_title('http://www.google.com/'))
+  end
+
+  def test_failproof_true
+    noop(Murlsh.get_title('http://x.boedicker.org/', :failproof => true))
+  end
+
+  def test_failproof_false
+    assert_raise SocketError do
+      Murlsh.get_title('http://x.boedicker.org/', :failproof => false)
+    end
+  end
+
+end

data/test/markup_test.rb

@@ -0,0 +1,144 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'murlsh'
+
+require 'test/unit'
+
+class MarkupMixer < Builder::XmlMarkup
+  include Murlsh::Markup
+end
+
+class MarkupTest < Test::Unit::TestCase
+
+  def setup
+    @m = MarkupMixer.new()
+  end
+
+  def attr_check(name, value, s)
+    assert_match(/#{name}="#{value}"/, s)
+  end
+
+  def test_javascript_single
+    @m.javascript('test.js')
+    assert_equal(
+      '<script type="text/javascript" src="test.js"></script>', @m.target!)
+  end
+
+  def test_javascript_multiple
+    @m.javascript(['test1.js', 'test2.js'])
+    assert_equal(
+        '<script type="text/javascript" src="test1.js"></script><script type="text/javascript" src="test2.js"></script>',
+      @m.target!)
+  end
+
+  def test_javascript_single_prefix
+    @m.javascript('test.js', :prefix => 'http://static.com/js/')
+    assert_equal(
+      '<script type="text/javascript" src="http://static.com/js/test.js"></script>',
+      @m.target!)
+  end
+
+  def test_javascript_multiple_prefix
+    @m.javascript(['test1.js', 'test2.js'], :prefix => 'js/')
+    assert_equal(
+        '<script type="text/javascript" src="js/test1.js"></script><script type="text/javascript" src="js/test2.js"></script>',
+      @m.target!)
+  end
+
+  def test_murlsh_img_prefix
+    @m.murlsh_img(:src => 'foo.png', :prefix => 'http://static.com/img/')
+    assert_equal('<img src="http://static.com/img/foo.png"/>', @m.target!)
+  end
+
+  def test_murlsh_img_size_one
+    @m.murlsh_img(:src => 'foo.png', :size => 32)
+    [
+      %w{height 32},
+      %w{src foo.png},
+      %w{width 32},
+    ].each { |t| attr_check(*t.push(@m.target!)) }
+  end
+
+  def test_murlsh_img_size_two
+    @m.murlsh_img(:src => 'foo.png', :size => [100, 200])
+    [
+      %w{height 200},
+      %w{src foo.png},
+      %w{width 100},
+    ].each { |t| attr_check(*t.push(@m.target!)) }
+  end
+
+  def test_murlsh_img_size_text
+    @m.murlsh_img(:src => 'foo.png', :text => 'test')
+    [
+      %w{alt test},
+      %w{src foo.png},
+      %w{title test},
+    ].each { |t| attr_check(*t.push(@m.target!)) }
+  end
+
+  def test_murlsh_img_href
+    @m.murlsh_img(:href => '/test/', :src => 'foo.png')
+    assert_equal('<a href="/test/"><img src="foo.png"/></a>', @m.target!)
+  end
+
+  def test_metas
+    @m.metas(:a => '1', :b => '2', :c => '3')
+    [
+      '<meta (name="a" content="1"|content="1" name="a")/>',
+      '<meta (name="b" content="2"|content="2" name="b")/>',
+      '<meta (name="c" content="3"|content="3" name="c")/>',
+    ].each { |r| assert_match(/#{r}/, @m.target!) }
+  end
+
+  def test_gravatar_none
+    @m.gravatar('xxx')
+    assert_equal('<img src="http://www.gravatar.com/avatar/xxx"/>', @m.target!)
+  end
+
+  def test_gravatar_valid_d
+    @m.gravatar('xxx', 'd' => 'identicon')
+    assert_equal('<img src="http://www.gravatar.com/avatar/xxx?d=identicon"/>',
+      @m.target!)
+  end
+
+  def test_gravatar_invalid_d
+    @m.gravatar('xxx', 'd' => 'bad')
+    assert_equal('<img src="http://www.gravatar.com/avatar/xxx"/>', @m.target!)
+  end
+
+  def test_gravatar_valid_r
+    @m.gravatar('xxx', 'r' => 'x')
+    assert_equal('<img src="http://www.gravatar.com/avatar/xxx?r=x"/>',
+      @m.target!)
+  end
+
+  def test_gravatar_invalid_r
+    @m.gravatar('xxx', 'r' => 'foo')
+    assert_equal('<img src="http://www.gravatar.com/avatar/xxx"/>', @m.target!)
+  end
+
+  def test_gravatar_valid_s
+    @m.gravatar('xxx', 's' => 100)
+    assert_equal('<img src="http://www.gravatar.com/avatar/xxx?s=100"/>',
+      @m.target!)
+  end
+
+  def test_gravatar_invalid_s
+    @m.gravatar('xxx', 's' => 1000)
+    assert_equal('<img src="http://www.gravatar.com/avatar/xxx"/>', @m.target!)
+  end
+
+  def test_gravatar_s_0
+    @m.gravatar('xxx', 's' => 0)
+    assert_equal('', @m.target!)
+  end
+
+  def test_gravatar_href
+    @m.gravatar('xxx', :href => '/test/')
+    assert_equal(
+      '<a href="/test/"><img src="http://www.gravatar.com/avatar/xxx"/></a>',
+      @m.target!)
+  end
+
+end

data/test/referrer_test.rb

@@ -0,0 +1,71 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'murlsh'
+
+require 'test/unit'
+
+class ReferrerTest < Test::Unit::TestCase
+
+  def setup
+    @qmap = {
+      /www\.foo\.com\/search/ => 'q',
+    }
+  end
+
+  def instantiate(url)
+    Murlsh::Referrer.new(url)
+  end
+
+  def test_url_nil
+    r = instantiate(nil)
+    assert_equal('', r.hostpath)
+    assert_equal({}, r.query_string)
+  end
+
+  def test_url_nil_block
+    r = instantiate(nil)
+    r.search_query(@qmap) { |x| flunk }
+  end
+
+  def test_url_empty
+    r = instantiate('')
+    assert_equal('', r.hostpath)
+    assert_equal({}, r.query_string)
+  end
+
+  def test_url_empty_block
+    r = instantiate('')
+    r.search_query(@qmap) { |x| flunk }
+  end
+
+  def test_hostpath_not_found
+    r = instantiate('http://www.bar.com/search?q=test&a=1&b=2&c=3')
+    assert_equal(nil, r.search_query(@qmap))
+  end
+
+  def test_hostpath_not_found_block
+    r = instantiate('http://www.bar.com/search?q=test&a=1&b=2&c=3')
+    r.search_query(@qmap) { |x| flunk }
+  end
+
+  def test_query_not_found
+    r = instantiate('http://www.foo.com/search?a=1&b=2&c=3')
+    assert_equal(nil, r.search_query(@qmap))
+  end
+
+  def test_query_not_found_block
+    r = instantiate('http://www.foo.com/search?a=1&b=2&c=3')
+    r.search_query(@qmap) { |x| flunk }
+  end
+
+  def test_good
+    r = instantiate('http://www.foo.com/search?q=test&a=1&b=2&c=3')
+    assert_equal('test', r.search_query(@qmap))
+  end
+
+  def test_good_block
+    r = instantiate('http://www.foo.com/search?q=test&a=1&b=2&c=3')
+    r.search_query(@qmap) { |x| assert_equal('test', x) }
+  end
+
+end