shortener 0.0.2 → 0.1.0

data/.gitignore

@@ -2,33 +2,12 @@
 log/*
 tmp/**/*
 bin/*
-
-config/database.yml
-db/*.sqlite3
-*~
-public/photos/*
-\#*\#
-#Ignore all log files and process ID files
 *.log
-*.pid
-
-#ignore all generated pshinx config files
-*.sphinx.conf
-
-#ignore all sphinx DB files
-*.spa
-*.spd
-*.sph
-*.spi                  
-*.spk
-*.spl
-*.spm
-*.spp
-
-#ignore radrails files and temp files
+*~
 .project
 .loadpath
 ._*
-
 .bundle
 *.gem
+*.swp
+Gemfile.lock

data/README.rdoc

@@ -1,29 +1,32 @@
 = Shortener
 
-Shortener makes it easy to create shortened URLs for your rails application.
+Shortener is a Rails Engine Gem that makes it easy to create and interpret shortened URLs on your own domain from within your Rails application. Once installed Shortener will generate, store URLS and "unshorten" shortened URLs for your applications visitors, all whilst collecting basic usage metrics.
+
+---
 
 == Overview
 
-The majority of the solution consists of two parts:
+The majority of the Shortener consists of three parts:
 
-* a model for storing the details of the shortened link (including the user the shortened link belongs to and counter that increments as the link is clicked);
-* a controller to accept incoming requests, grab the shortened link data out of the database and redirecting the visitors request to the target URL;
+* a model for storing the details of the shortened link;
+* a controller to accept incoming requests and redirecting them to the target URL;
+* a helper for generating shortened URLs from controllers and views.
 
-=== Some niceities of shortener:
+=== Some niceities of Shortener:
 
 * The controller does a 301 redirect, which is the recommended type of redirect for maintaining maximum google juice to the original URL;
-* A unique code of is generated for each shortened link, instead of using the id of the shortened link record. This means that we can get more unique combinations than if we just used numbers;
+* A unique alphanumeric code of generated for each shortened link, this means that we can get more unique combinations than if we just used numbers;
 * The link records a count of how many times it has been “un-shortened”;
-* The link can be linked to a user, this allows for stats of the link usage for a particular user and other interesting things;
+* The link can be associated with a user, this allows for stats of the link usage for a particular user and other interesting things;
 * The controller spawns a new thread to record information to the database, allowing the redirect to happen as quickly as possible;
 
-=== Future (possible) improvements:
+=== Future improvements:
 
 * There has not been an attempt to remove ambiguous characters (i.e. 1 l and capital i, or 0 and O etc.) from the unique key generated for the link. This means people might copy the link incorrectly if copying the link by hand;
 * The shortened links are found with a case-insensitive search on the unique key. This means that the system can’t take advantage of upper and lower case  to increase the number of unique combinations. This may have an effect for people copying the link by hand;
 * The system could pre-generate unique keys in advance, avoiding the database penalty when checking that a newly generated key is unique;
 * The system could store the shortened URL if the url is to be continually rendered;
-* Some implementations might want duplicate links to be generated each time a user requests it.
+* Some implementations might want duplicate links to be generated each time a user request a shortened link.
 
 
 == Installation
@@ -38,6 +41,10 @@ After you install Shortener run the generator:
   
 This generator will create a migration to create the shortened_urls table where your shortened URLs will be stored.
 
+Then add to your routes:
+
+  match '/:id' => "shortener/shortened_urls#show"
+
 == Usage
 
 To generate a Shortened URL object for the URL "http://dealush.com" within your controller / models do the following:
@@ -54,6 +61,28 @@ To generate and display a shortened URL in your application use the helper metho
   
 This will generate a shortened URL. store it to the db and return a string representing the shortened URL.
 
-== Notes
+=== Shortened URLs with owner
+
+You can link shortened URLs to an owner, to scope them. To do so, add the following line to the models which will act as owners:
+
+  class User < ActiveRecord::Base
+    has_shortened_urls
+  end
+
+This will allow you to pass the owner when generating URLs:
+
+  Shortener::ShortenedURL.generate("dealush.com", user)
+
+And to access those URLs:
+
+  user.shortened_urls
+
+== Origins
+
+Shortener is based on code from Dealush[http://dealush.com], for a bit of backstory to Shortener see this {blog post}[http://jamespmcgrath.com/a-simple-link-shortener-in-rails/].
+
+== Authors
+
+* {James McGrath}[https://github.com/jpmcgrath]
+* {Michael Reinsch}[https://github.com/mreinsch]
 
-This is the first release and still has some bugs. I will be releasing fixes for these bugs soon.

data/Rakefile

@@ -1,26 +1,12 @@
-# encoding: UTF-8
-require 'rubygems'
-begin
-  require 'bundler/setup'
-rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
-end
-
-require 'rake'
-require 'rake/rdoctask'
-
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
-end
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rdoc/task'
+Bundler::GemHelper.install_tasks
 
-task :default => :test
+task :default => :spec
+RSpec::Core::RakeTask.new
 
-Rake::RDocTask.new(:rdoc) do |rdoc|
+RDoc::Task.new :rdoc do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title    = 'Shortener'
   rdoc.options << '--line-numbers' << '--inline-source'

data/app/controllers/shortener/shortened_urls_controller.rb

@@ -1,27 +1,26 @@
-module Shortener
-  class ShortenedUrlsController < ::ApplicationController
-    
-    # find the real link for the shortened link key and redirect
-    def translate
-      # pull the link out of the db
-      sl = ShortenedUrl.find_by_unique_key(params[:unique_key])
-      
-      if sl
-        # don't want to wait for the increment to happen, make it snappy!
-        # this is the place to enhance the metrics captured
-        # for the system. You could log the request origin
-        # browser type, ip address etc.
-        Thread.new do
-          sl.increment!(:use_count)
-        end
-        # do a 301 redirect to the destination url
-        head :moved_permanently, :location => sl.url
-      else
-        # if we don't find the shortened link, redirect to the root
-        # make this configurable in future versions
-        head :moved_permanently, :location => root_url
+class Shortener::ShortenedUrlsController < ::ApplicationController
+
+  # find the real link for the shortened link key and redirect
+  def show
+    # pull the link out of the db
+    sl = ::Shortener::ShortenedUrl.find_by_unique_key(params[:id])
+
+    if sl
+      # don't want to wait for the increment to happen, make it snappy!
+      # this is the place to enhance the metrics captured
+      # for the system. You could log the request origin
+      # browser type, ip address etc.
+      Thread.new do
+        sl.increment!(:use_count)
+        ActiveRecord::Base.connection.close
       end
+      # do a 301 redirect to the destination url
+      redirect_to sl.url, :status => :moved_permanently
+    else
+      # if we don't find the shortened link, redirect to the root
+      # make this configurable in future versions
+      redirect_to '/'
     end
-    
   end
+
 end

data/app/helpers/shortener/shortener_helper.rb

@@ -1,24 +1,9 @@
 module Shortener::ShortenerHelper
-  
-  # generate a url from either a url string, or a shortened url object
-  def shortened_url(url_object, user=nil)
-    
-    short_url = nil
-    
-    if url_object.class != String #== ShortenedUrl
-      if user.nil?
-        short_url = url_object
-      else
-        # if the user has passed in a shortened url, with a user, then 
-        # work out the link for the shortened url and make another with the 
-        # passed user
-        short_url = Shortener::ShortenedUrl.generate(shortened_url(url_object), user)
-      end
-    else
-      short_url = Shortener::ShortenedUrl.generate(url_object, user)
-    end
-    
-    return short_url.nil? ? nil : shortener_translate_url(short_url.unique_key)
+
+  # generate a url from a url string
+  def short_url(url, owner=nil)
+    short_url = Shortener::ShortenedUrl.generate(url, owner)
+    short_url ? url_for(:controller => :"shortener/shortened_urls", :action => :show, :id => short_url.unique_key, :only_path => false) : url
   end
 
-end
+end

data/app/models/shortener/shortened_url.rb

@@ -1,80 +1,72 @@
-module Shortener
-  class ShortenedUrl < ActiveRecord::Base
-    
-    UNIQUE_KEY_LENGTH = 5
-    URL_PROTOCOL_HTTP = "http://"
-    
-    REGEX_HTTP_URL = /^\s*(http[s]?:\/\/)?[a-z0-9]+([-.]{1}[a-z0-9]+)*\.[a-z]{2,5}(([0-9]{1,5})?\/.*)?\s*$/i
-    REGEX_LINK_HAS_PROTOCOL = Regexp.new('\Ahttp:\/\/|\Ahttps:\/\/', Regexp::IGNORECASE)
-    REGEX_EMAIL = /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
-    
-    validates_format_of :url, :with => REGEX_HTTP_URL, :allow_blank => true
-    validates_presence_of :url
-    validates_uniqueness_of :unique_key
-    
-    belongs_to :user # allows the shortened link to be associated with a user
-    
-    before_validation :clean_destination_url, :init_unique_key, :on => :create
-    
-    
-    # ensure the url starts with it protocol
-    def clean_destination_url
-      if !self.url.blank? and self.url !~ REGEX_LINK_HAS_PROTOCOL
-        self.url.insert(0, URL_PROTOCOL_HTTP)
-      end
-    end
-    
-    def init_unique_key
-      # generate a unique key for the link
-      begin
-        # has about 50 million possible combos
-        self.unique_key = ShortenedUrl::generate_unique_key
-      end while ShortenedUrl::find_by_unique_key self.unique_key
+class Shortener::ShortenedUrl < ActiveRecord::Base
+
+  URL_PROTOCOL_HTTP = "http://"
+  REGEX_LINK_HAS_PROTOCOL = Regexp.new('\Ahttp:\/\/|\Ahttps:\/\/', Regexp::IGNORECASE)
+
+  validates :url, :presence => true
+
+  # allows the shortened link to be associated with a user
+  belongs_to :owner, :polymorphic => true
+
+  # ensure the url starts with it protocol and is normalized
+  def self.clean_url(url)
+    return nil if url.blank?
+    url = URL_PROTOCOL_HTTP + url.strip unless url =~ REGEX_LINK_HAS_PROTOCOL
+    URI.parse(url).normalize.to_s
+  end
+
+  # generate a shortened link from a url
+  # link to a user if one specified
+  # throw an exception if anything goes wrong
+  def self.generate!(orig_url, owner=nil)
+    # if we get a shortened_url object with a different owner, generate
+    # new one for the new owner. Otherwise return same object
+    if orig_url.is_a?(Shortener::ShortenedUrl)
+      return orig_url.owner == owner ? orig_url : generate!(orig_url.url, owner)
     end
-    
-    # generate a shortened link from a url
-    # link to a user if one specified
-    # throw an exception if anything goes wrong
-    def self.generate!(orig_url, user=nil)
-      # don't want to generate the link if it has already been generated
-      # so check the datastore
-      uid = user.nil? ? nil : user.id
-      sl = ShortenedUrl.find_by_url_and_user_id(orig_url, uid)
-      
-      return sl if sl
-      
-      # create the shortened link, storing it
-      sl = ShortenedUrl.create!(:url => orig_url, :user => user)
-      
-      # return the url
-      return sl
+
+    # don't want to generate the link if it has already been generated
+    # so check the datastore
+    cleaned_url = clean_url(orig_url)
+    scope = owner ? owner.shortened_urls : self
+    scope.find_or_create_by_url(cleaned_url)
+  end
+
+  # return shortened url on success, nil on failure
+  def self.generate(orig_url, owner=nil)
+    begin
+      generate!(orig_url, owner)
+    rescue
+      nil
     end
-    
-    # return shortened url on success, nil on failure
-    def self.generate(orig_url, user=nil)
-      
-      sl = nil
-      
-      begin
-        sl = ShortenedUrl::generate!(orig_url, user)
-      rescue
-        sl = nil
+  end
+
+  private
+
+  # we'll rely on the DB to make sure the unique key is really unique.
+  # if it isn't unique, the unique index will catch this and raise an error
+  def create
+    count = 0
+    begin
+      self.unique_key = generate_unique_key
+      super
+    rescue ActiveRecord::RecordNotUnique, ActiveRecord::StatementInvalid => err
+      if (count +=1) < 5
+        logger.info("retrying with different unique key")
+        retry
+      else
+        logger.info("too many retries, giving up")
+        raise
       end
-      
-      return sl
-    end
-    
-    
-    
-    private
-    
-    # generate a random string
-    # future mod to allow specifying a more expansive charst, like utf-8 chinese
-    def self.generate_unique_key(size = UNIQUE_KEY_LENGTH)
-      # not doing uppercase as url is case insensitive
-      charset = ('a'..'z').to_a + (0..9).to_a
-      (0...size).map{ charset.to_a[rand(charset.size)] }.join
     end
-      
   end
+
+  # generate a random string
+  # future mod to allow specifying a more expansive charst, like utf-8 chinese
+  def generate_unique_key
+    # not doing uppercase as url is case insensitive
+    charset = ::Shortener.key_chars
+    (0...::Shortener.unique_key_length).map{ charset[rand(charset.size)] }.join
+  end
+
 end

data/lib/generators/shortener/templates/migration.rb

@@ -1,22 +1,25 @@
 class CreateShortenedUrlsTable < ActiveRecord::Migration
-  def self.up
+  def change
     create_table :shortened_urls do |t|
-      
-      t.integer :user_id # we can link this to a user for interesting things
-      t.string :url, :null => false # the real url that we will redirect to
-      t.string :unique_key, :null => false # the unique key 
-      t.integer :use_count, :null => false, :default => 0 # how many times the link has been clicked
+      # we can link this to a user for interesting things
+      t.integer :owner_id
+      t.string :owner_type, :limit => 20
+
+      # the real url that we will redirect to
+      t.string :url, :null => false
+
+      # the unique key
+      t.string :unique_key, :limit => 10, :null => false
+
+      # how many times the link has been clicked
+      t.integer :use_count, :null => false, :default => 0
 
       t.timestamps
     end
-    
-    add_index :shortened_urls, :unique_key # we will lookup the links in the db with this 
-    add_index :shortened_urls, :user_id # and this
-  end
 
-  def self.down
-    remove_index :shortened_urls, :unique_key
-    remove_index :shortened_urls, :user_id
-    drop_table :shortened_urls
+    # we will lookup the links in the db by key and owners.
+    # also make sure the unique keys are actually unique
+    add_index :shortened_urls, :unique_key, :unique => true
+    add_index :shortened_urls, [:owner_id, :owner_type]
   end
 end

data/lib/shortener.rb

@@ -1,17 +1,28 @@
 require "active_support/dependencies"
 
 module Shortener
-  
-  # Our host application root path
-  # We set this when the engine is initialized
-  mattr_accessor :app_root
-  
-  # Yield self on setup for nice config blocks
-  def self.setup
-    yield self
+
+  autoload :ActiveRecordExtension, "shortener/active_record_extension"
+
+  CHARSETS = {
+    :alphanum => ('a'..'z').to_a + (0..9).to_a,
+    :alphanumcase => ('a'..'z').to_a + ('A'..'Z').to_a + (0..9).to_a }
+
+  # default key length: 5 characters
+  mattr_accessor :unique_key_length
+  self.unique_key_length = 5
+
+  # character set to chose from:
+  #  :alphanum     - a-z0-9     -  has about 60 million possible combos
+  #  :alphanumcase - a-zA-Z0-9  -  has about 900 million possible combos
+  mattr_accessor :charset
+  self.charset = :alphanum
+
+  def self.key_chars
+    CHARSETS[charset]
   end
-  
 end
 
-# Require our engine
-require "shortener/engine"
+# Require our railtie and engine
+require "shortener/railtie"
+require "shortener/engine"