muri 0.0.13 → 1.0.0

data/README.textile

@@ -8,7 +8,7 @@ MURI Currently supports:
 * Vimeo (single videos and albums)
 ** "API documentation":http://vimeo.com/api/docs/simple-api
 * Flickr (single images and sets)
-** "API documentation":http://www.flickr.com/services/api/
+** "API documentation":http://www.flickr.com/services/api/ or "[2]":http://developer.yahoo.com/flickr/
 * Imageshack
 * Photobucket
 ** "API documentation":http://photobucket.com/developer/documentation
@@ -41,10 +41,10 @@ Assuming the URI was successfully parsed (thus @a.valid? == true@), all media ty
 
 <pre>
 <code>
-  a.service         # 'Youtube'
-  a.media_id        # 'blahblahblah'
-  a.original_url    # 'http://www.youtube.com/watch?v=blahblahblah&feature=rec-LGOUT-exp_fresh+div-1r-1-HM'
-  a.uri             # URI object for 'http://www.youtube.com/watch?v=blahblahblah&feature=rec-LGOUT-exp_fresh+div-1r-1-HM'
+  a.media_service         # 'Youtube'
+  a.media_id              # 'blahblahblah'
+  a.media_original_url    # 'http://www.youtube.com/watch?v=blahblahblah&feature=rec-LGOUT-exp_fresh+div-1r-1-HM'
+  a.media_uri             # URI object for 'http://www.youtube.com/watch?v=blahblahblah&feature=rec-LGOUT-exp_fresh+div-1r-1-HM'
 </code>
 </pre>
 
@@ -53,7 +53,7 @@ Assuming the URI was successfully parsed (thus @a.valid? == true@), all media ty
 * All but Imageshack have a @media_api_id@, which is the ID which can be used in API calls to the related services. Typically the same as @media_id@.
 
 <pre>
-<code>  
+<code>
   a.media_api_id     # 'blahblahblah'
 </code>
 </pre>
@@ -76,7 +76,7 @@ d
 
 <pre>
 <code>
-  a.website           # 'http://www.youtube.com/watch?v=blahblahblah' 
+  a.media_website           # 'http://www.youtube.com/watch?v=blahblahblah'
 </code>
 </pre>
 
@@ -84,7 +84,7 @@ d
 
 <pre>
 <code>
-  a.content_type      # 'jpg' (Content Type also for Imageshack and Photobucket)
+  a.media_content_type      # 'jpg' (Content Type also for Imageshack and Photobucket)
 </code>
 </pre>
 

data/VERSION.yml

@@ -1,4 +1,4 @@
 ---
-:major: 0
+:major: 1
 :minor: 0
-:patch: 13
+:patch: 0

data/lib/muri/base.rb

@@ -1,112 +1,92 @@
-require 'uri'
 class Muri
 
+  attr_reader :uri, :errors
+
   # NoParser raised if no parser is found for URI
   class NoParser < StandardError; end
-  
-  # UnsupportedURI raised if parser is found, but URI path does not 
+
+  # UnsupportedURI raised if parser is found, but URI path does not
   #   match accepted formats
   class UnsupportedURI < ArgumentError; end
-    
-  PARSERS = {}
-  
-  include Filter::Youtube
-  include Filter::Flickr
-  include Filter::Vimeo
-  include Filter::Imageshack
-  include Filter::Photobucket
-  include Filter::Facebook
-  include Filter::Twitpic  
+
+  PARSERS = { }
+
+  # Defines is_#{service}? and is_#{service type constant}? methods, and sets service name constnat
+  ['Youtube', 'Flickr', 'Vimeo', 'Imageshack', 'Photobucket', 'Facebook', 'Twitpic'].each do |filter|
+    eval "include Filter::#{filter}"    
+    is_service = "is_#{filter.downcase}?"
+    define_method(is_service) { self.media_service == filter }
+    self.constants.reject { |c| c !~ /^#{filter.upcase}/ }.each do |exp|
+      define_method("is_#{exp.downcase}?") { self.media_api_type == eval(exp) && eval("self.#{is_service}") }
+    end
+    const_set "#{filter.upcase}_SERVICE_NAME", "#{filter}"
+  end
 
   def self.parse(url)
     self.new(url)
   end
-    
-  def initialize(url)
-    @info = { }
-    _parse(url)
-  end  
 
-  def to_yaml
-    @info.to_yaml
+  # Show a list of the available parsers
+  def self.parsers
+    PARSERS.keys
   end
   
-  def to_s
-    @info.to_s
+  def initialize(url)
+    @info = { }
+    _parse(url)
   end
   
+  # Determine if Muri object is valid (errors mean not valid)
   def valid?
-    @info[:media_id].nil? ? false : true
+    self.errors.nil?
   end
   
-  # Taken from uri/generic.rb
-  @@to_s = Kernel.instance_method(:to_s)
-  def inspect
-    @@to_s.bind(self).call.sub!(/>\z/) {" URL:#{self.original_url}>"}
+  def to_s
+    @info.to_s
   end
-  
-  def parsers
-    PARSERS.keys
+
+  # 'Borrowed' from uri/generic.rb
+  def inspect
+    Kernel.instance_method(:to_s).bind(self).call.sub!(/>\z/) {" URL:#{self.uri.to_s}>"}
   end
-  
+
   private
+  attr_writer :uri, :errors
+
+  def self.determine_feed_parser(uri)
+    PARSERS.keys.detect {|klass| klass.parsable?(uri)}
+  end
   
   def _parse(raw_url)
     begin
-      @url = URI.parse(raw_url)
-      if @url.scheme.nil?
+      self.uri = URI.parse(raw_url)
+      if self.uri.scheme.nil?
         raw_url = "http://#{raw_url}"
-        @url = URI.parse(raw_url)
+        self.uri = URI.parse(raw_url)
       end
-      if parser = determine_feed_parser
-        @info[:uri] = @url
-        @info[:original_url] = raw_url
+      if parser = Muri.determine_feed_parser(self.uri)
         send(PARSERS[parser])
       else
         raise NoParser
       end
     rescue NoParser, UnsupportedURI, URI::BadURIError, URI::InvalidURIError => e
-      @info[:errors] = "#{e.class}"
+      self.errors = "#{e.class}"
     end
   end
-  
-  def determine_feed_parser
-    PARSERS.keys.detect {|klass| klass.parsable?(@url)}
-  end
-      
-  def method_missing(func, args = nil)
-    @info[func.to_sym].nil? ? nil : @info[func.to_sym]
-  end
-  
-  protected
-  
-  #used by flickr. Ported from PHP.
-  def self.decode58(str)
-    decoded = 0
-    multi = 1
-    alphabet = "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
-    while str.length > 0
-      digit = str[(str.length - 1),1]
-      decoded += multi * alphabet.index(digit)
-      multi = multi * alphabet.length
-      str.chop!
+
+  def method_missing(method, *arguments, &block)
+    if method.to_s =~ /^media_(.+)/
+      process_option_method(method, *arguments)
+    else
+      super
     end
-    
-    decoded
   end
-  
-  #used by flickr. Ported from PHP.
-  def self.encode58(str)
-    alphabet = "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
-    base_count = alphabet.length
-    encoded = ''
-    while str >= base_count
-      div = str / base_count
-      mod = (str-(base_count * div))
-      encoded = alphabet[mod,1] + encoded
-      str = div
+
+  def process_option_method(method, *arguments)
+    if method.to_s =~ /^media_(.+)=/
+      @info[$1.to_sym] = arguments.first
+    elsif method.to_s =~ /^media_(.+)/
+      @info[$1.to_sym]
     end
-    encoded = (alphabet[str,1] + encoded) if str
-    encoded
   end
 end

data/lib/muri/filter.rb

@@ -0,0 +1,13 @@
+class Muri
+
+  protected
+
+  def self.param_parse(query)
+    return { } if query.nil?
+    params_flat = { }
+    params = CGI::parse(query)
+    params.each {|k,v| params_flat[k] = v.first}
+    params_flat
+  end
+
+end

data/lib/muri/filters/facebook.rb

@@ -1,68 +1,66 @@
-require 'cgi'
 class Muri
   module Filter
     module Facebook
-      
+
+      private
       FACEBOOK_PHOTO = "photo"
       #FACEBOOK_VIDEO = "video"
       FACEBOOK_ALBUM = "album"
-      
+      REGEX_FACEBOOK_PHOTO = /^\/photo\.php$/i
+      REGEX_FACEBOOK_ALBUM = /^\/album\.php$/i
+
       def self.included(base)
         base.class_eval do
           self::PARSERS[Muri::Filter::Facebook] = "facebook_parse"
         end
       end
-      
+
+      def self.parsable?(uri)
+        uri.host =~ /^(www\.)?facebook\.com$/i
+      end
+
       def facebook_parse
-        @info[:service] = 'Facebook'
-        params = @url.query.nil? ? {} : CGI::parse(@url.query)#.each {|k,v| b[k] = v.first}
+        self.media_service = FACEBOOK_SERVICE_NAME #'Facebook'
+        params = Muri.param_parse(self.uri.query)
+
         url_common = "http://www.facebook.com"
-        
-#         if @url.path =~ /^\/v\/([0-9]+)/
+
+#         if self.uri.path =~ /^\/v\/([0-9]+)/
 #           @info[:media_id] = $1
 #           @info[:media_url] = "#{url_common}/v/#{@info[:media_id]}"
-#           
+#
 #           # Currently no API for video, but media_id is best guess value for such content
 #           @info[:media_api_id] = @info[:media_id]
 #           @info[:media_api_type] = FACEBOOK_VIDEO
-        if ((@url.path =~ /^\/photo\.php$/i) && 
-            params.include?("pid") && params["pid"].first =~ /^([0-9]+)$/ && 
-            params.include?("id") && params["id"].first =~ /^([0-9]+)$/ && 
-            params.include?("l") && params["l"].first =~ /^([0-9a-z]+)$/i)
-          
-          @info[:media_api_type] = FACEBOOK_PHOTO
-          @info[:media_id] = params["pid"].first
-          media_creator = params["id"].first
-          share_key = params["l"].first
-          
-          @info[:website] = "#{url_common}/photo.php?pid=#{@info[:media_id]}&l=#{share_key}&id=#{media_creator}"
-        elsif ((@url.path =~ /^\/album\.php$/i) && 
-            params.include?("aid") && params["aid"].first =~ /^([0-9]+)$/ && 
-            params.include?("id") && params["id"].first =~ /^([0-9]+)$/ && 
-            params.include?("l") && params["l"].first =~ /^([0-9a-z]+)$/i)
-          
-          @info[:media_api_type] = FACEBOOK_ALBUM
-          @info[:media_id] = params["aid"].first
-          media_creator = params["id"].first
-          share_key = params["l"].first
-          
-          @info[:website] = "#{url_common}/album.php?aid=#{@info[:media_id]}&l=#{share_key}&id=#{media_creator}"
-        end
-        
-        if self.valid?
-          # The media_api_id is the PID which can be searched for in the facebook photos/albums table          
-          @info[:media_api_id] = (media_creator.to_i << 32) + @info[:media_id].to_i
+        if ((self.uri.path =~ REGEX_FACEBOOK_PHOTO) &&
+            params["pid"] =~ /^([0-9]+)$/ &&
+            params["id"] =~ /^([0-9]+)$/ &&
+            params["l"] =~ /^([0-9a-z]+)$/i)
+
+          self.media_api_type = FACEBOOK_PHOTO
+          self.media_id = params["pid"]
+          media_creator = params["id"]
+          share_key = params["l"]
+
+          self.media_website = "#{url_common}/photo.php?pid=#{self.media_id}&l=#{share_key}&id=#{media_creator}"
+        elsif ((self.uri.path =~ REGEX_FACEBOOK_ALBUM) &&
+            params["aid"] =~ /^([0-9]+)$/ &&
+            params["id"] =~ /^([0-9]+)$/ &&
+            params["l"] =~ /^([0-9a-z]+)$/i)
+
+          self.media_api_type = FACEBOOK_ALBUM
+          self.media_id = params["aid"]
+          media_creator = params["id"]
+          share_key = params["l"]
+
+          self.media_website = "#{url_common}/album.php?aid=#{self.media_id}&l=#{share_key}&id=#{media_creator}"
         else
           raise UnsupportedURI
         end
-        
-        self
-      end            
- 
-      def self.parsable?(uri)
-        uri.host =~ /^(www\.)?facebook\.com$/i
+
+        # The media_api_id is the PID which can be searched for in the facebook photos/albums table
+        self.media_api_id = (media_creator.to_i << 32) +self.media_id.to_i
       end
-      
     end
   end
 end
@@ -73,4 +71,4 @@ end
 #   id = user id
 #   l = photo share key
 # http://www.facebook.com/v/614695029223 (full) - deprecated
-# http://www.facebook.com/album.php?aid=2149275&id=15201063&l=99900807c3
+# http://www.facebook.com/album.php?aid=2149275&id=15201063&l=99900807c3

data/lib/muri/filters/flickr.rb

@@ -1,56 +1,84 @@
 class Muri
   module Filter
     module Flickr
-    
+
+      private
       FLICKR_PHOTO = "photo"
       FLICKR_SET = "set"
-      
+
+      REGEX_FLICKR_PHOTO_OR_SET = /^\/photos\/([a-z0-9\-\_\@]+?)\/(sets\/)?([0-9]+)/i
+      REGEX_FLICKR_STATIC_PHOTO = /^farm([1-3])\.static.flickr.com\/([0-9]+?)\/([0-9]+?)\_([a-z0-9]+?)((?:\_[a-z]){1,2}){0,1}\.([a-z]+)/i
+      REGEX_FLICKR_SHORTURL = /^flic\.kr\/p\/([a-z0-9]+)/i
+
       def self.included(base)
         base.class_eval do
           self::PARSERS[Muri::Filter::Flickr] = "flickr_parse"
         end
       end
-      
+
+      def self.parsable?(uri)
+        uri.host =~ /^(www\.)?(flic\.kr|(farm[0-9]\.static\.|)(flickr)\.com)/i
+      end
+
       def flickr_parse
-        @info[:service] = 'Flickr'
-        
-        if @url.path =~ /^\/photos\/([a-z0-9\-\_\@]+?)\/(sets\/)?([0-9]+)/i
+        self.media_service = FLICKR_SERVICE_NAME #'Flickr'
+
+        if self.uri.path =~ REGEX_FLICKR_PHOTO_OR_SET
           media_creator = $1
-          @info[:media_id] = $3
-          @info[:media_api_type] = $2.nil? ? FLICKR_PHOTO : FLICKR_SET
-        elsif (@url.host + @url.path) =~ /^farm([1-3])\.static.flickr.com\/([0-9]+?)\/([0-9]+?)\_([a-z0-9]+?)(\_[a-z]){0,1}\.([a-z]+)/i
+          self.media_id = $3
+          self.media_api_type = $2.nil? ? FLICKR_PHOTO : FLICKR_SET
+        elsif (self.uri.host + self.uri.path) =~ REGEX_FLICKR_STATIC_PHOTO
           farm = $1
           server_id = $2
-          @info[:media_id] = $3
-          @info[:media_api_type] = FLICKR_PHOTO
+          self.media_id = $3
+          self.media_api_type = FLICKR_PHOTO
           media_secret = $4
-          url_prefix = "http://farm#{farm}.static.flickr.com/#{server_id}/#{@info[:media_id]}_#{media_secret}"
-          @info[:media_url] = "#{url_prefix}.jpg"
-          @info[:media_thumbnail] = "#{url_prefix}_t.jpg"
-        elsif (@url.host + @url.path) =~ /^flic\.kr\/p\/([a-z0-9]+)/i
-          @info[:media_id] = self.class.decode58($1)
-          @info[:media_api_type] = FLICKR_PHOTO
-        end
-        
-        if self.valid?
-          @info[:media_api_id] = @info[:media_id]
-          if @info[:media_api_type] == FLICKR_PHOTO 
-            @info[:website] = "http://flic.kr/p/" + self.class.encode58(@info[:media_id].to_i)
-          elsif @info[:media_api_type] == FLICKR_SET
-            @info[:website] = "http://www.flickr.com/photos/#{media_creator}/sets/#{@info[:media_id]}"#/show takes direct
-          end
+          url_prefix = "http://farm#{farm}.static.flickr.com/#{server_id}/#{self.media_id}_#{media_secret}"
+          self.media_url = "#{url_prefix}.jpg"
+          self.media_thumbnail = "#{url_prefix}_t.jpg"
+        elsif (self.uri.host + self.uri.path) =~ REGEX_FLICKR_SHORTURL
+          self.media_id = Filter::Flickr.decode58($1)
+          self.media_api_type = FLICKR_PHOTO
         else
           raise UnsupportedURI
         end
-        
-        self
+
+        self.media_api_id = self.media_id
+        if self.is_flickr_photo?
+          self.media_website = "http://flic.kr/p/" + Filter::Flickr.encode58(self.media_id.to_i)
+        elsif self.is_flickr_set?
+          self.media_website = "http://www.flickr.com/photos/#{media_creator}/sets/#{self.media_id}" # appending /show takes direct to image through redirect
+        end
       end
       
-      def self.parsable?(uri)
-        uri.host =~ /^(www\.)?(flic\.kr|(farm[0-9]\.static\.|)(flickr)\.com)/i
-      end  
-  
-      
+      # Ported from PHP.
+      def self.decode58(str)
+        decoded = 0
+        multi = 1
+        alphabet = "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+        while str.length > 0
+          digit = str[(str.length - 1),1]
+          decoded += multi * alphabet.index(digit)
+          multi = multi * alphabet.length
+          str.chop!
+        end
+        decoded
+      end
+    
+      # Ported from PHP.
+      def self.encode58(str)
+        alphabet = "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+        base_count = alphabet.length
+        encoded = ''
+        while str >= base_count
+          div = str / base_count
+          mod = (str-(base_count * div))
+          encoded = alphabet[mod,1] + encoded
+          str = div
+        end
+        encoded = (alphabet[str,1] + encoded) if str
+        encoded
+      end
     end
   end
 end
@@ -61,7 +89,7 @@ end
 #               when '_m' then 'small'
 #               when '_b' then 'large'
 #               when '_o' then 'original'
-#               else nil
+#               else 'medium'
 #             end
 #           end
 #           @info[:content_type] = $6

data/lib/muri/filters/imageshack.rb

@@ -2,43 +2,40 @@ class Muri
   module Filter
     module Imageshack
 
+      private
+
       def self.included(base)
         base.class_eval do
           self::PARSERS[Muri::Filter::Imageshack] = "imageshack_parse"
         end
       end
-      
+
+      def self.parsable?(uri)
+        uri.host =~ /^img([0-9]*?)\.imageshack\.us$/i #/^(img([0-9]*?)\.imageshack\.us)|(yfrog\.com)/i
+      end
+
       def imageshack_parse
-        @info[:service] = 'Imageshack'
-        
-        @url.host =~ /^img([0-9]*?)\.imageshack\.us/i
+       self.media_service = IMAGESHACK_SERVICE_NAME #'Imageshack'
+
+        self.uri.host =~ /^img([0-9]*?)\.imageshack\.us/i
         server_id = $1
         url_common = "http://img#{server_id}.imageshack.us"
-        
-        if @url.path =~ /^\/i\/([a-z0-9]+?)\.([a-z0-9]+)(\/)?/i
-          @info[:media_id] = $1
-          @info[:content_type] = $2
-        elsif @url.path =~ /^\/img([0-9]*?)\/([0-9]+?)\/([a-z0-9]+?)\.([a-z0-9]+)/i
+
+        if self.uri.path =~ /^\/i\/([a-z0-9]+?)\.([a-z0-9]+)(\/)?/i
+          self.media_id = $1
+          self.media_content_type = $2
+        elsif self.uri.path =~ /^\/img([0-9]*?)\/([0-9]+?)\/([a-z0-9]+?)\.([a-z0-9]+)/i
           content_server_id = $2
-          @info[:media_id] = $3
-          @info[:content_type] = $4
-          @info[:media_url] = "#{url_common}/img#{server_id}/#{content_server_id}/#{@info[:media_id]}.#{@info[:content_type]}"
-        end
-        
-        # imageshack does not currently have API for retrieving individual video information
-        if self.valid?
-          @info[:website] = "#{url_common}/i/#{@info[:media_id]}.#{@info[:content_type]}/"
+          self.media_id = $3
+          self.media_content_type = $4
+          self.media_url = "#{url_common}/img#{server_id}/#{content_server_id}/#{self.media_id}.#{self.media_content_type}"
         else
-          raise UnsupportedURI          
+          raise UnsupportedURI
         end
-        
-        self
-      end       
-      
-      def self.parsable?(uri)
-        uri.host =~ /^img([0-9]*?)\.imageshack\.us$/i #/^(img([0-9]*?)\.imageshack\.us)|(yfrog\.com)/i
-      end  
-      
+
+        # imageshack does not currently have API for retrieving individual video information
+        self.media_website = "#{url_common}/i/#{self.media_id}.#{self.media_content_type}/"
+      end
     end
   end
 end