shorturl 0.8.8 → 1.0.0

data/.gitignore

@@ -0,0 +1 @@
+doc/

data/{README → README.rdoc}

@@ -13,7 +13,6 @@ http://rubyforge.org/frs/?group_id=732 if you do not want to use the gem.
 
 == Supported services
 Here is the list of the services supported by ShortURL:
-* http://rubyurl.com
 * http://tinyurl.com
 * http://shorl.com
 * http://snipurl.com
@@ -34,6 +33,7 @@ Here is the list of the services supported by ShortURL:
 * http://moourl.com
 * http://urltea.com
 * http://vurl.me
+* http://bit.ly
 
 == Usage: 
 call-seq:
@@ -63,12 +63,39 @@ The second parameter represents the service you want to use.  These are:
 * <tt>:moourl</tt>
 * <tt>:urltea</tt>
 * <tt>:vurl</tt>
+* <tt>:bitly</tt>**
 
 
 You can use <tt>ShortURL.valid_services</tt> to obtain a
 list of the valid services (in case I forget to update the
 documentation)
 
+Bitly**
+-------
+
+   Their API changed to require an API key.  
+
+   Two painfree steps to fix this.
+
+   1) Get yours easily right now from: 
+
+   http://bitly.com/a/your_api_key
+
+
+   2) Save it in ~/.shorturl similar to this YAML template:
+ 
+--- Start of file ~/.shorturl ---
+   
+   ---
+   bitly:
+     username: O_adsfasdfasfasfd
+     key: R_afasdfasdfasdf
+
+--- END of file ~/.shorturl ---
+
+
+   You're done!  Have a martini.  Cheers.
+
 == Thanks
 - Marcel Molina Jr., Devin Mullins for some ideas
 - imperator from #ruby-lang (I don't know your real name, sorry) for

data/Rakefile

@@ -0,0 +1,42 @@
+require "rake"
+require "rake/testtask"
+require "rdoc/task"
+
+task :default => [ :test, :doc ]
+
+desc "Run the tests"
+Rake::TestTask.new("test") { |t|
+  t.libs << 'test'
+  t.pattern = "test/**/ts_*.rb"
+  t.verbose = true
+}
+
+desc "Write the documentation"
+RDoc::Task.new("doc") { |rdoc|
+  rdoc.rdoc_dir = "doc"
+  rdoc.title = "ShortURL Documentation"
+#  rdoc.options << "--line-numbers --inline-source"
+  rdoc.rdoc_files.include("README.rdoc")
+  rdoc.rdoc_files.include("TODO.rdoc")
+  rdoc.rdoc_files.include("LICENSE.txt")
+  rdoc.rdoc_files.include("ChangeLog.txt")
+  rdoc.rdoc_files.include("lib/*.rb")
+  rdoc.rdoc_files.exclude("test/*")
+}
+
+desc "Upload documentation to RubyForge"
+task :upload_doc do
+  sh "scp -r doc/* robbyrussell@rubyforge.org:/var/www/gforge-projects/shorturl"
+end
+
+
+desc "Statistics for the code"
+task :stats do
+  begin
+    require "code_statistics"
+    CodeStatistics.new(["Code", "lib"],
+                       ["Units", "test"]).to_s
+  rescue LoadError
+    puts "Couldn't load code_statistics (install rails)"
+  end
+end

data/examples/shorten.rb

@@ -11,9 +11,9 @@ end
 def main
   begin
     case ARGV.length
-    when 0: usage
-    when 1: puts ShortURL.shorten(ARGV[0])
-    else puts ShortURL.shorten(ARGV[0], ARGV[1].to_sym)
+    when 0 then usage
+    when 1 then puts ShortURL.shorten(ARGV[0])
+    else        puts ShortURL.shorten(ARGV[0], ARGV[1].to_sym)
     end
   rescue InvalidService
     puts "Invalid service"

data/lib/shorturl.rb

@@ -3,148 +3,45 @@
 #   Created by Vincent Foley on 2005-06-02
 #
 
-require "net/http"
-require "cgi"
+require "shorturl/services"
 require "uri"
-
-class ServiceNotAvailable < Exception
-end
-
-class InvalidService < Exception
-end
-
-class Service
-  attr_accessor :port, :code, :method, :action, :field, :block, :response_block
-
-  # Intialize the service with a hostname (required parameter) and you
-  # can override the default values for the HTTP port, expected HTTP
-  # return code, the form method to use, the form action, the form
-  # field which contains the long URL, and the block of what to do
-  # with the HTML code you get.
-  def initialize(hostname) # :yield: service
-    @hostname = hostname
-    @port = 80
-    @code = 200
-    @method = :post
-    @action = "/"
-    @field = "url"
-
-    if block_given?
-      yield self
-    end
+require "yaml"
+
+module ShortURL
+  CREDENTIALS_PATH = File.join(Gem.user_home,'.shorturl')
+
+  def self.credentials
+    @credentials ||= begin
+                       if File.file?(CREDENTIALS_PATH)
+                         YAML.load_file(CREDENTIALS_PATH)
+                       else
+                         {}
+                       end
+                     end
   end
 
-  # Now that our service is set up, call it with all the parameters to
-  # (hopefully) return only the shortened URL.
-  def call(url)
-    Net::HTTP.start(@hostname, @port) { |http|
-      response = case @method
-                 when :post: http.post(@action, "#{@field}=#{CGI.escape(url)}")
-                 when :get: http.get("#{@action}?#{@field}=#{CGI.escape(url)}")
-                 end
-      if response.code == @code.to_s
-        @response_block ? @response_block.call(response) : @block.call(response.read_body)
-      end
-    }
-  rescue Errno::ECONNRESET => e
-    raise ServiceNotAvailable, e.to_s, e.backtrace
+  def self.credentials_for(service)
+    credentials.fetch(service,{})
   end
-end
 
-class ShortURL
   # Hash table of all the supported services.  The key is a symbol
   # representing the service (usually the hostname minus the .com,
   # .net, etc.)  The value is an instance of Service with all the
   # parameters set so that when +instance+.call is invoked, the
   # shortened URL is returned.
-  @@services = {
-    :rubyurl => Service.new("rubyurl.com") { |s|
-      s.action = "/rubyurl/remote"
-      s.field = "website_url"
-      s.block = lambda { |body| URI.extract(body).grep(/rubyurl/)[0] }      
-    },
-    
-    :tinyurl => Service.new("tinyurl.com") { |s|
-      s.action = "/api-create.php"
-      s.method = :get
-      s.block = lambda { |body| URI.extract(body).grep(/tinyurl/)[0] }
-    },
-    
-    :shorl => Service.new("shorl.com") { |s|
-      s.action = "/create.php"
-      s.block = lambda { |body| URI.extract(body)[2] }
-    },
-
-    # SnipURL offers a restful HTTP API but it cannot be used without
-    # registration.
-    :snipurl => Service.new("snipurl.com") { |s|
-      s.action = "/site/index"
-      s.field = "url"
-
-      # As with other services, this is far from elegant and might break
-      # any time. Might just be better to do some HTML parsing instead.
-      s.block = lambda { |body| URI.extract(body).grep(/http:\/\/snipurl.com/)[0] }
-    },
-
-    :metamark => Service.new("metamark.net") { |s|
-      s.action = "/add"
-      s.field = "long_url"
-      s.block = lambda { |body| URI.extract(body).grep(/xrl.us/)[0] }
-    },
-
-    :minilink => Service.new("minilink.org") { |s|
-      s.method = :get
-      s.block = lambda { |body| URI.extract(body)[-1] }
-    },
-
-    :lns => Service.new("ln-s.net") { |s|
-      s.method = :get
-      s.action = "/home/api.jsp"
-      s.block = lambda { |body| URI.extract(body)[0] }
-    },
-
-    :shiturl => Service.new("shiturl.com") { |s|
-      s.method = :get
-      s.action = "/make.php"
-      s.block = lambda { |body| URI.extract(body).grep(/shiturl/)[0] }
-    },
-
-    :shortify => Service.new("shortify.wikinote.com") { |s|
-      s.method = :get
-      s.action = "/shorten.php"
-      s.block = lambda { |body| URI.extract(body).grep(/shortify/)[-1] }
-    },
-    
-    :moourl => Service.new("moourl.com") { |s|      
-      s.code = 302
-      s.action = "/create/"
-      s.method = :get      
-      s.field = "source"
-      s.response_block = lambda { |res| "http://moourl.com/" + res["location"].match(/\?moo=/).post_match }
-    },
-
-    :bitly => Service.new("bit.ly") { |s|
-      s.method = :get
-      s.action = "/index.php"
-      s.field  = "url"
-      s.block  = lambda { |body|
-        body.match(%r{<input id="shortened-url" value="(.*)" />}).captures[0]
-      }
-    },
-
-    :ur1 => Service.new("ur1.ca") { |s|
-      s.method = :post
-      s.action = "/"
-      s.field  = "longurl"
-      s.block  = lambda { |body| URI.extract(body).grep(/ur1/)[0] }
-    },
-
-    :vurl => Service.new("vurl.me") { |s|
-      s.method = :get
-      s.action = "/shorten"
-      s.field  = "url"
-      s.block  = lambda { |body| body }
-    }
+  SERVICES = {
+    :tinyurl => Services::TinyURL.new,
+    :shorl => Services::Shorl.new,
+    :snipurl => Services::SnipURL.new,
+    :metamark => Services::Metamark.new,
+    :minilink => Services::Minilink.new,
+    :lns => Services::Lns.new,
+    :shiturl => Services::ShitURL.new,
+    :shortify => Services::Shortify.new,
+    :moourl => Services::MooURL.new,
+    :bitly => Services::Bitly.new,
+    :ur1 => Services::Url.new,
+    :vurl => Services::Vurl.new,
 
     # :skinnylink => Service.new("skinnylink.com") { |s|
     #   s.block = lambda { |body| URI.extract(body).grep(/skinnylink/)[0] }
@@ -195,11 +92,8 @@ class ShortURL
 
   # Array containing symbols representing all the implemented URL
   # shortening services
-  @@valid_services = @@services.keys
-
-  # Returns @@valid_services
   def self.valid_services
-    @@valid_services
+    SERVICES.keys
   end
 
   # Main method of ShortURL, its usage is quite simple, just give an
@@ -209,7 +103,6 @@ class ShortURL
   #
   # Valid +service+ values:
   #
-  # * <tt>:rubyurl</tt>
   # * <tt>:tinyurl</tt>
   # * <tt>:shorl</tt>
   # * <tt>:snipurl</tt>
@@ -229,11 +122,11 @@ class ShortURL
   # * <tt>:orz</tt>
   #
   # call-seq:
-  #   ShortURL.shorten("http://mypage.com") => Uses RubyURL
-  #   ShortURL.shorten("http://mypage.com", :tinyurl)
-  def self.shorten(url, service = :rubyurl)
-    if valid_services.include? service
-      @@services[service].call(url)
+  #   ShortURL.shorten("http://mypage.com") => Uses TinyURL
+  #   ShortURL.shorten("http://mypage.com", :bitly)
+  def self.shorten(url, service = :tinyurl)
+    if SERVICES.has_key?(service)
+      SERVICES[service].call(url)
     else
       raise InvalidService
     end

data/lib/shorturl/exceptions.rb

@@ -0,0 +1,7 @@
+module ShortURL
+  class ServiceNotAvailable < Exception
+  end
+
+  class InvalidService < Exception
+  end
+end

data/lib/shorturl/service.rb

@@ -0,0 +1,62 @@
+require "shorturl/exceptions"
+require "net/http"
+require "net/https"
+require "cgi"
+
+module ShortURL
+  class Service
+    attr_accessor :port, :code, :method, :action, :field, :block, :response_block, :ssl
+
+    # Intialize the service with a hostname (required parameter) and you
+    # can override the default values for the HTTP port, expected HTTP
+    # return code, the form method to use, the form action, the form
+    # field which contains the long URL, and the block of what to do
+    # with the HTML code you get.
+    def initialize(hostname) # :yield: service
+      @hostname = hostname
+      @port = 80
+      @code = 200
+      @method = :post
+      @action = "/"
+      @field = "url"
+      @ssl = false
+
+      if block_given?
+        yield self
+      end
+    end
+
+    # Now that our service is set up, call it with all the parameters to
+    # (hopefully) return only the shortened URL.
+    def call(url)
+      http = Net::HTTP.new(@hostname, @port)
+      http.use_ssl = @ssl
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      http.start do
+        response = case @method
+                   when :post
+                     http.post(@action, "#{@field}=#{CGI.escape(url)}")
+                   when :get
+                     http.get("#{@action}?#{@field}=#{CGI.escape(url)}")
+                   end
+
+        if response.code == @code.to_s
+          on_response(response)
+        end
+      end
+    rescue Errno::ECONNRESET => e
+      raise ServiceNotAvailable, e.to_s, e.backtrace
+    end
+
+    # Extracts the shortened URL from a response body.
+    def on_body(body)
+      body
+    end
+
+    # Extracts the shortened URL from the response.
+    def on_response(response)
+      on_body(response.read_body)
+    end
+  end
+end

data/lib/shorturl/services.rb

@@ -0,0 +1,12 @@
+require "shorturl/services/tinyurl"
+require "shorturl/services/shorl"
+require "shorturl/services/snipurl"
+require "shorturl/services/metamark"
+require "shorturl/services/minilink"
+require "shorturl/services/lns"
+require "shorturl/services/shiturl"
+require "shorturl/services/shortify"
+require "shorturl/services/moourl"
+require "shorturl/services/bitly"
+require "shorturl/services/url"
+require "shorturl/services/vurl"

data/lib/shorturl/services/bitly.rb

@@ -0,0 +1,28 @@
+require "shorturl/service"
+
+module ShortURL
+  module Services
+    class Bitly < Service
+
+      def initialize
+        super("api-ssl.bitly.com")
+
+        @method = :get
+        @port = 443
+        @ssl = true
+        @action = "/v3/shorten/"
+
+        creds = ShortURL.credentials_for('bitly')
+        username = creds['username'] 
+        key = creds['key'] 
+
+        @field = "format=txt&login=#{username}&apiKey=#{key}&longUrl"
+      end
+
+      def on_body(body)
+        body
+      end
+
+    end
+  end
+end