muri 0.0.13 → 1.0.0

data/lib/muri/filters/photobucket.rb

@@ -1,82 +1,94 @@
-require 'cgi'
 class Muri
   module Filter
     module Photobucket
 
+      private
       PHOTOBUCKET_MEDIA = "media"
       PHOTOBUCKET_ALBUM = "album"
       PHOTOBUCKET_GROUP_ALBUM = "group_album"
 
+      REGEX_PHOTOBUCKET_IMAGE = /^\/albums\/(.+?)\/(?:(.*)\/)*(.+?)\.(.+?)$/i
+      REGEX_PHOTOBUCKET_ALBUM_OR_IMAGE = /^\/albums\/(.+?)\/(.[^\.]*?)\/?$/i
+      REGEX_PHOTOBUCKET_GROUP_IMAGE = /^\/groups\/(.+?)\/(.+?)\/(.+?)\.(.+)$/i
+      REGEX_PHOTOBUCKET_GROUP_ALBUM_OR_IMAGE = /^\/groups\/(\w+?)\/(\w+?)\/?$/i
+
       def self.included(base)
         base.class_eval do
           self::PARSERS[Muri::Filter::Photobucket] = "photobucket_parse"
         end
       end
+
+      def self.parsable?(uri)
+        uri.host =~ /^([a-z0-9]*?[^(media)])\.photobucket\.com$/i
+      end
       
       def photobucket_parse
-        @info[:service] = 'Photobucket'
-        
-        @url.host =~ /^([a-z0-9]*?[^(media)])\.photobucket\.com$/i
-        @info[:server_id] = $1.gsub(/([a-z]*)/i,"")
-        
-        if @url.path =~ /^\/albums\/(.+?)\/(.+?)\/(?:(.*)\/)*(.+?)\.(.+?)$/i #Images
-            # OLD: /^\/albums\/(.+?)\/(.+?)\/((?:.+?\/)*)(.+?)\.(.+)/i 
-          photobucket_id = $1
-          media_creator = $2          
-          album = $3.nil? ? '' : "#{$3}/"
-          @info[:media_id] = $4
-          @info[:content_type] = $5
-          url_common = "#{server_id}.photobucket.com/albums/#{photobucket_id}/#{media_creator}/#{album}"
-          direct_url_suffix = "#{url_common}#{@info[:media_id]}.#{@info[:content_type]}"
-          @info[:media_api_type] = PHOTOBUCKET_MEDIA
-          @info[:media_url] = "http://i#{direct_url_suffix}"
-          @info[:website] = "http://s#{url_common}?action=view&current=#{@info[:media_id]}.#{@info[:content_type]}"
-        elsif @url.path =~ /^\/albums\/(.+?)\/(.+?)\/(.[^\.]*?)\/?$/i #Albums
-            # OLD: /^\/albums\/(.+?)\/(.+?)\/((?:.[^\/]+?)+)(?:\/|$)/i
-          photobucket_id = $1
-          media_creator = $2
-          album = $3
-          @info[:media_id] = "#{media_creator}/#{album}"
-          url_common = "#{server_id}.photobucket.com/albums/#{photobucket_id}/#{media_creator}/#{album}"
-          @info[:media_api_type] = PHOTOBUCKET_ALBUM
-          @info[:website] = "http://s#{url_common}/"
-        elsif @url.path =~ /^\/groups\/(.+?)\/(.+?)\/(.+?)\.(.+)$/i #Group Images
-          group = $1
-          group_hash_value = $2
-          @info[:media_id] = $3
-          @info[:content_type] = $4
-          url_common = "#{server_id}.photobucket.com/groups/#{group}/#{group_hash_value}"
-          direct_url_suffix = "#{url_common}/#{@info[:media_id]}.#{@info[:content_type]}"
-          @info[:media_api_type] = PHOTOBUCKET_MEDIA
-          @info[:media_url] = "http://gi#{direct_url_suffix}"
-          @info[:website] = "http://gs#{url_common}/?action=view&current=#{@info[:media_id]}.#{@info[:content_type]}"
-        elsif @url.path =~ /^\/groups\/(\w+?)\/(\w+?)\/?$/i #Group Album
+        self.media_service = PHOTOBUCKET_SERVICE_NAME #'Photobucket'
+
+        self.uri.host =~ /^([a-z0-9]*?[^(media)])\.photobucket\.com$/i
+        self.media_server_id = $1.gsub(/([a-z]*)/i,"")
+        params = Muri.param_parse(self.uri.query)
+
+        if self.uri.path =~ REGEX_PHOTOBUCKET_IMAGE
+          self.media_id = $3
+          self.media_content_type = $4
+          photobucket_set_image_common($1, $2)
+        elsif self.uri.path =~ REGEX_PHOTOBUCKET_ALBUM_OR_IMAGE
+          pb_id = $1
+          album = $2
+          url_common = "#{self.media_server_id}.photobucket.com/albums/#{pb_id}/#{album}"
+          if (params["action"] =~ /^(view)$/i && params["current"] =~ /^(.+)\.([a-z0-9]+)$/i)
+            filename = params["current"].split(".")
+            self.media_id = filename.first
+            self.media_content_type = filename.last
+            photobucket_set_image_common(pb_id, album)
+          else
+            self.media_id = "#{album}"
+            self.media_api_type = PHOTOBUCKET_ALBUM
+            self.media_website = "http://s#{url_common}/"
+          end
+        elsif self.uri.path =~ REGEX_PHOTOBUCKET_GROUP_IMAGE
+          self.media_id = $3
+          self.media_content_type = $4
+          photobucket_set_group_image_common($1, $2)
+        elsif self.uri.path =~ REGEX_PHOTOBUCKET_GROUP_ALBUM_OR_IMAGE
           group = $1
-          group_hash_value = $2
-          url_common = "#{server_id}.photobucket.com/groups/#{group}/#{group_hash_value}"
-          @info[:media_id] = group_hash_value
-          @info[:website] = "http://gs#{url_common}/"
-          @info[:media_api_type] = PHOTOBUCKET_GROUP_ALBUM
-        end
-        
-        if self.valid?
-          if @info[:media_api_type] == PHOTOBUCKET_MEDIA
-            @info[:media_api_id] = @info[:media_url]
-            @info[:media_thumbnail] = "http://mobth#{direct_url_suffix}"
+          hash_value = $2
+          url_common = "#{self.media_server_id}.photobucket.com/groups/#{group}/#{hash_value}"
+          if (params["action"] =~ /^(view)$/i && params["current"] =~ /^(.+)\.([a-z0-9]+)$/i)
+            filename = params["current"].split(".")
+            self.media_id = filename.first
+            self.media_content_type = filename.last
+            photobucket_set_group_image_common(group, hash_value)
           else
-            @info[:media_api_id] = @info[:media_id]
+            self.media_id = hash_value
+            self.media_website = "http://gs#{url_common}/"
+            self.media_api_type = PHOTOBUCKET_GROUP_ALBUM
           end
         else
-          raise UnsupportedURI          
+          raise UnsupportedURI
         end
-        
-        self
-      end       
-      
-      def self.parsable?(uri)
-        uri.host =~ /^([a-z0-9]*?[^(media)])\.photobucket\.com$/i
-      end  
-      
+
+        self.media_api_id = self.is_photobucket_media? ? self.media_url : self.media_id
+      end
+
+      def photobucket_set_image_common(pb_id, album)
+        url_common = "#{self.media_server_id}.photobucket.com/albums/#{pb_id}/#{album}/"
+        url_suffix = "#{url_common}#{self.media_id}.#{self.media_content_type}"
+        self.media_api_type = PHOTOBUCKET_MEDIA
+        self.media_url = "http://i" + url_suffix
+        self.media_website = "http://s#{url_common}?action=view&current=#{self.media_id}.#{self.media_content_type}"
+        self.media_thumbnail = "http://mobth#{url_suffix}"
+      end
+
+      def photobucket_set_group_image_common(group, hash_value)
+        url_common = "#{self.media_server_id}.photobucket.com/groups/#{group}/#{hash_value}"
+        url_suffix = "#{url_common}/#{self.media_id}.#{self.media_content_type}"
+        self.media_api_type = PHOTOBUCKET_MEDIA
+        self.media_url = "http://gi" + url_suffix
+        self.media_website = "http://gs#{url_common}/?action=view&current=#{self.media_id}.#{self.media_content_type}"
+        self.media_thumbnail = "http://mobth#{url_suffix}"
+      end
     end
   end
 end

data/lib/muri/filters/twitpic.rb

@@ -1,41 +1,39 @@
 class Muri
   module Filter
     module Twitpic
-      
+
+      private
       TWITPIC_PHOTO = 'photo'
+
+      REGEX_TWITPIC_PHOTO = /^\/([a-z0-9]+)/i
       
       def self.included(base)
         base.class_eval do
           self::PARSERS[Muri::Filter::Twitpic] = "twitpic_parse"
         end
       end
-      
+
+      def self.parsable?(uri)
+        uri.host =~ /^twitpic\.com$/i
+      end
+
       def twitpic_parse
-        @info[:service] = 'Twitpic'
+        self.media_service = TWITPIC_SERVICE_NAME #'Twitpic'
         url_common = "http://twitpic.com"
-        
-        if @url.path =~ /^\/([a-z0-9]+)/i
-          @info[:media_id] = $1
-          @info[:website] = "#{url_common}/#{@info[:media_id]}"
-          @info[:media_url] = "#{url_common}/show/large/#{@info[:media_id]}"
-          @info[:media_thumbnail] = "#{url_common}/show/thumb/#{@info[:media_id]}"          
-          @info[:media_api_type] = TWITPIC_PHOTO
-        end
 
-        # Twitpic does not have an API to pull photo info. Media ID is best guess
-        if self.valid?
-          @info[:media_api_id] = @info[:media_id]
+        if self.uri.path =~ REGEX_TWITPIC_PHOTO
+          self.media_id = $1
+          self.media_website = "#{url_common}/#{self.media_id}"
+          self.media_url = "#{url_common}/show/large/#{self.media_id}"
+          self.media_thumbnail = "#{url_common}/show/thumb/#{self.media_id}"
+          self.media_api_type = TWITPIC_PHOTO
         else
           raise UnsupportedURI
         end
-        
-        self
-      end            
- 
-      def self.parsable?(uri)
-        uri.host =~ /^twitpic\.com$/i
+
+        # Twitpic does not have an API to pull photo info. Media ID is best guess
+        self.media_api_id = self.media_id
       end
-      
     end
   end
 end
@@ -43,4 +41,4 @@ end
 # http://twitpic.com/show/large/17d7th
 # http://twitpic.com/show/thumb/17d7th
 
-# http://twitpic.com/api.do
+# http://twitpic.com/api.do

data/lib/muri/filters/vimeo.rb

@@ -1,54 +1,62 @@
-require 'cgi'
 class Muri
   module Filter
     module Vimeo
-      
+
+      private
       VIMEO_VIDEO = "video"
       VIMEO_ALBUM = "album"
       
+      REGEX_VIMEO_VIDEO_OR_ALBUM = /^\/(album\/)?([0-9]+)\/?$/i
+      REGEX_VIMEO_GROUP_VIDEO = /^\/groups\/([0-9a-z\@\-\_]+)\/videos\/([0-9]+)\/?$/i
+      REGEX_VIMEO_SWF_VIDEO = /^\/moogaloop\.swf$/i
+
       def self.included(base)
         base.class_eval do
           self::PARSERS[Muri::Filter::Vimeo] = "vimeo_parse"
         end
       end
-      
+
+      def self.parsable?(uri)
+        uri.host =~ /^(www\.)?vimeo\.com$/i
+      end
+
       def vimeo_parse
-        @info[:service] = 'Vimeo'
-        params = @url.query.nil? ? {} : CGI::parse(@url.query)#.each {|k,v| b[k] = v.first}
-
-        if @url.path =~ /^\/(album\/)?([0-9]+)\/?$/i
-          @info[:media_id] = $2
-          @info[:media_api_type] = $1.nil? ? VIMEO_VIDEO : VIMEO_ALBUM
-        elsif @url.path =~ /^\/groups\/([0-9a-z\@\-\_]+)\/videos\/([0-9]+)\/?$/i
-          @info[:media_id] = $2
-          @info[:media_api_type] = VIMEO_VIDEO
-        elsif ((@url.path =~ /^\/moogaloop\.swf$/i) && (params.include?("clip_id")) && (params["clip_id"].first =~ /^([0-9]+)$/))
-          @info[:media_id] = params["clip_id"].first
-          @info[:media_api_type] = VIMEO_VIDEO
-        end
-        
-        if self.valid?
-          @info[:media_api_id] = @info[:media_id]
-          album = (@info[:media_api_type] == VIMEO_ALBUM) ? "album/" : ""
-          @info[:website] = "http://vimeo.com/#{album}#{@info[:media_id]}"
-          if @info[:media_api_type] == VIMEO_VIDEO
-            @info[:media_url] = "http://vimeo.com/moogaloop.swf?clip_id=#{@info[:media_id]}&server=vimeo.com&show_title=1&show_byline=1&show_portrait=0&color=&fullscreen=1"
-          end
+        self.media_service = VIMEO_SERVICE_NAME #'Vimeo'
+        params = Muri.param_parse(self.uri.query)
+
+        if self.uri.path =~ REGEX_VIMEO_VIDEO_OR_ALBUM
+          self.media_id = $2
+          self.media_api_type = $1.nil? ? VIMEO_VIDEO : VIMEO_ALBUM
+        elsif self.uri.path =~ REGEX_VIMEO_GROUP_VIDEO
+          self.media_id = $2
+          self.media_api_type = VIMEO_VIDEO
+        elsif ((self.uri.path =~ REGEX_VIMEO_SWF_VIDEO) && (params["clip_id"] =~ /^([0-9]+)$/))
+          self.media_id = params["clip_id"]
+          self.media_api_type = VIMEO_VIDEO
         else
           raise UnsupportedURI
         end
-        
-        self
-      end            
- 
-      def self.parsable?(uri)
-        uri.host =~ /^(www\.)?vimeo\.com$/i
+
+        self.media_api_id = self.media_id
+        self.media_website = Filter::Vimeo.vimeo_media_website self #:api_type => self.media_api_type, :id => self.media_id
+        if self.is_vimeo_video?
+          self.media_url = Filter::Vimeo.vimeo_media_url self #:id => self.media_id
+        end
+      end
+
+      def self.vimeo_media_url(obj)
+        "http://vimeo.com/moogaloop.swf?clip_id=#{obj.media_id}&server=vimeo.com&show_title=1&show_byline=1&show_portrait=0&color=&fullscreen=1"
+      end
+
+      def self.vimeo_media_website(obj)
+        str = "http://vimeo.com/"
+        str += "album/" if obj.media_api_type == VIMEO_ALBUM
+        str += obj.media_id
       end
-      
     end
   end
 end
 # http://www.vimeo.com/groups/beyondthestill/videos/9394829
-# http://vimeo.com/moogaloop.swf?clip_id=7312128&server=vimeo.com&show_title=1&show_byline=1&show_portrait=0&color=&fullscreen=1" 
+# http://vimeo.com/moogaloop.swf?clip_id=7312128&server=vimeo.com&show_title=1&show_byline=1&show_portrait=0&color=&fullscreen=1"
 # http://vimeo.com/7312128
-# http://vimeo.com/album/89702
+# http://vimeo.com/album/89702

data/lib/muri/filters/youtube.rb

@@ -1,55 +1,58 @@
-require 'cgi'
 class Muri
   module Filter
     module Youtube
 
+      private
       YOUTUBE_VIDEO = "video"
       YOUTUBE_PLAYLIST = "playlist"
+      
+      REGEX_YOUTUBE_VIDEO_WATCH = /^\/watch\/?$/i
+      REGEX_YOUTUBE_VIDEO_DIRECT = /\/v\/([a-z0-9\-\_]+)/i
+      REGEX_YOUTUBE_PLAYLIST_WATCH = /^\/view\_play\_list\/?$/i
+      REGEX_YOUTUBE_PLAYLIST_DIRECT = /^\/p\/([a-z0-9\-\_]+)/i
 
       def self.included(base)
-        base.class_eval do 
+        base.class_eval do
           self::PARSERS[Muri::Filter::Youtube] = "youtube_parse"
         end
       end
-      
+
+      def self.parsable?(uri)
+        uri.host =~ /^(www\.)?youtube\.com$/i
+      end
+
       def youtube_parse
-        @info[:service] = 'Youtube'
-        url_common = "http://www.youtube.com"
-        params = @url.query.nil? ? {} : CGI::parse(@url.query)#.each {|k,v| b[k] = v.first}
-        
-        if (@url.path =~ /^\/watch$/i) && params.include?("v")
-          @info[:media_id] = params["v"].first
-          @info[:media_api_type] = YOUTUBE_VIDEO
-        elsif (@url.path =~ /\/v\/([a-z0-9\-\_]+)/i)
-          @info[:media_id] = $1
-          @info[:media_api_type] = YOUTUBE_VIDEO
-        elsif (@url.path =~ /^\/p\/([a-z0-9\-\_]+)/i)
-          @info[:media_id] = $1
-          @info[:media_api_type] = YOUTUBE_PLAYLIST
-        elsif (@url.path =~ /^\/view\_play\_list$/i) && (params.include?('p'))
-          @info[:media_id] = params['p'].first
-          @info[:media_api_type] = YOUTUBE_PLAYLIST
-        end
+        self.media_service = YOUTUBE_SERVICE_NAME #'Youtube'
         
-        if self.valid?
-          if @info[:media_api_type] == YOUTUBE_VIDEO
-            @info[:website] = "#{url_common}/watch?v=#{@info[:media_id]}"
-            @info[:media_url] = "#{url_common}/v/#{@info[:media_id]}"
-            @info[:media_thumbnail] = "http://i.ytimg.com/vi/#{@info[:media_id]}/default.jpg"
-          elsif @info[:media_api_type] == YOUTUBE_PLAYLIST
-            @info[:website] = "#{url_common}/view_play_list?p=#{@info[:media_id]}"
-            @info[:media_url] = "#{url_common}/p/#{@info[:media_id]}"
-          end
-          @info[:media_api_id] = @info[:media_id]
+        url_common = "http://www.youtube.com"
+        params = Muri.param_parse(self.uri.query)
+
+        if (self.uri.path =~ REGEX_YOUTUBE_VIDEO_WATCH) && params['v']
+          self.media_id = params['v']
+          self.media_api_type = YOUTUBE_VIDEO
+        elsif (self.uri.path =~ REGEX_YOUTUBE_VIDEO_DIRECT)
+          self.media_id = $1
+          self.media_api_type = YOUTUBE_VIDEO
+        elsif (self.uri.path =~ REGEX_YOUTUBE_PLAYLIST_DIRECT)
+          self.media_id = $1
+          self.media_api_type = YOUTUBE_PLAYLIST
+        elsif (self.uri.path =~ REGEX_YOUTUBE_PLAYLIST_WATCH) && (params['p'])
+          self.media_id = params['p']
+          self.media_api_type = YOUTUBE_PLAYLIST
         else
           raise UnsupportedURI
         end
-        
-        self
-      end     
-      def self.parsable?(uri)
-        uri.host =~ /^(www\.)?youtube\.com$/i
-      end      
+
+        self.media_api_id = self.media_id
+        if self.is_youtube_video?
+          self.media_website = "#{url_common}/watch?v=#{self.media_id}"
+          self.media_url = "#{url_common}/v/#{self.media_id}"
+          self.media_thumbnail = "http://i.ytimg.com/vi/#{self.media_id}/default.jpg"
+        elsif self.is_youtube_playlist?
+          self.media_website = "#{url_common}/view_play_list?p=#{self.media_id}"
+          self.media_url = "#{url_common}/p/#{self.media_id}"
+        end
+      end
     end
   end
 end

data/lib/muri.rb

@@ -1,10 +1,12 @@
+require 'uri'
+require 'cgi'
+
 # Register built-in filters
 Dir["#{File.dirname(__FILE__) + '/muri/filters'}/**/*"].each do |filter|
   require "#{filter}"
 end
 
 # Just base now..more later(?)
-%w(base).each do |f|
+%w(filter base).each do |f|
   require File.dirname(__FILE__) + "/muri/#{f}"
 end
- 

data/muri.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{muri}
-  s.version = "0.0.13"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["William Schneider"]
-  s.date = %q{2010-03-23}
+  s.date = %q{2010-03-28}
   s.description = %q{Automatically get media information from the URL.}
   s.email = %q{bananastalktome@gmail.com}
   s.extra_rdoc_files = [
@@ -43,16 +43,16 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/bananastalktome/muri/}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{Media URI Parser}
   s.test_files = [
-    "test/error_test.rb",
-     "test/facebook_test.rb",
-     "test/flickr_test.rb",
-     "test/imageshack_test.rb",
-     "test/photobucket_test.rb",
+    "test/facebook_test.rb",
      "test/twitpic_test.rb",
+     "test/photobucket_test.rb",
      "test/vimeo_test.rb",
+     "test/imageshack_test.rb",
+     "test/error_test.rb",
+     "test/flickr_test.rb",
      "test/youtube_test.rb"
   ]
 

data/test/error_test.rb

@@ -29,13 +29,13 @@ describe "Parse Errors" do
     it "#{b} should return UnsupportedURI" do
       #lambda { Muri.parse b }.should raise_exception(Muri::UnsupportedURI)
       m = Muri.parse b
-      m.valid?.should == false
+      #m.valid?.should == false
       m.errors.should == "Muri::UnsupportedURI"
     end
   end
   
   it "should not bomb if no URI is provided" do
-    lambda { Muri.parse '' }.should_not raise_exception()
+    lambda { Muri.parse nil }.should_not raise_exception()
   end
   
 end

data/test/facebook_test.rb

@@ -2,13 +2,14 @@ require 'lib/muri.rb'
 
 shared_examples_for "Facebook parse" do
   it "should be Facebook service" do
-    @a.service.should == 'Facebook'
+    @a.media_service.should == 'Facebook'
   end
 
   it "should be valid" do
     @a.valid?.should == true
   end
 end
+
 shared_examples_for "Facebook parse photo" do
   it_should_behave_like "Facebook parse"
   it "should have media api type = FACEBOOK_PHOTO" do
@@ -16,47 +17,34 @@ shared_examples_for "Facebook parse photo" do
   end
 end
 
-# shared_examples_for "Facebook parse video" do
-#   it_should_behave_like "Facebook parse"
-#   it "should have media api type = FACEBOOK_VIDEO" do
-#     @a.media_api_type.should == Muri::FACEBOOK_VIDEO
-#   end
-# end
-
-# describe "Facebook parse first" do
-#   before(:all) do
-#     @a = Muri.parse 'http://www.facebook.com/v/614695029223'
-#   end
-#   it_should_behave_like "Facebook parse video"
-#   
-#   it "should have media id" do
-#     @a.media_id.should == '614695029223'
-#   end
-#   
-#   it "should have a media_url" do
-#     @a.media_url.should == 'http://www.facebook.com/v/614695029223'
-#   end
-#    
-#   it "should have media api id" do
-#     @a.media_api_id.should == '614695029223'
-#   end
-# end
-
-describe "Facebook parse second" do
-  before(:all) do
-    @a = Muri.parse 'http://www.facebook.com/photo.php?pid=34929102&l=a1abf8cd37&id=15201063'
-  end
-  it_should_behave_like "Facebook parse photo"
-
-  it "should have media id" do
-    @a.media_id.should == '34929102'
-  end
+{'http://www.facebook.com/photo.php?pid=34929102&l=a1abf8cd37&id=15201063' =>
+  { :media_id => '34929102',
+    :media_website => 'http://www.facebook.com/photo.php?pid=34929102&l=a1abf8cd37&id=15201063',
+    :media_api_id => 65288068484364750
+  }
+}.each do |url, values|
+  describe "Facebook parse #{url}" do
+    before(:all) do
+      @a = Muri.parse url
+    end
+    it_should_behave_like "Facebook parse photo"
   
-  it "should have a website" do
-    @a.website.should == 'http://www.facebook.com/photo.php?pid=34929102&l=a1abf8cd37&id=15201063'
+    if values[:media_id]
+      it "should have media id" do
+        @a.media_id.should == values[:media_id]
+      end
+    end
+    
+    if values[:media_website]
+      it "should have a website" do
+        @a.media_website.should == values[:media_website]
+      end
+    end
+     
+    if values[:media_api_id]
+      it "should have media api id" do
+        @a.media_api_id.should == values[:media_api_id]
+      end
+    end
   end
-   
-  it "should have media api id" do
-    @a.media_api_id.should == 65288068484364750
-  end  
 end