ruby-oembed 0.8.11 → 0.8.12

data/lib/oembed/providers.rb

@@ -136,7 +136,7 @@ module OEmbed
     #     OEmbed::Providers::Youtube.endpoint += "?iframe=0"
     # * To require https embed code
     #     OEmbed::Providers::Youtube.endpoint += "?scheme=https"
-    Youtube = OEmbed::Provider.new("http://www.youtube.com/oembed")
+    Youtube = OEmbed::Provider.new("http://www.youtube.com/oembed?scheme=https")
     Youtube << "http://*.youtube.com/*"
     Youtube << "https://*.youtube.com/*"
     Youtube << "http://*.youtu.be/*"
@@ -179,6 +179,19 @@ module OEmbed
     Vimeo << "https://*.vimeo.com/*"
     add_official_provider(Vimeo)
 
+    # Provider for twitter.com
+    # https://dev.twitter.com/rest/reference/get/statuses/oembed
+    Twitter = OEmbed::Provider.new("https://api.twitter.com/1/statuses/oembed.{format}")
+    Twitter << "https://*.twitter.com/*/status/*"
+    add_official_provider(Twitter)
+
+    # Provider for vine.co
+    # https://dev.twitter.com/web/vine/oembed
+    Vine = OEmbed::Provider.new("https://vine.co/oembed.{format}")
+    Vine << "http://*.vine.co/v/*"
+    Vine << "https://*.vine.co/v/*"
+    add_official_provider(Vine)
+
     # Provider for instagram.com
     # http://instagr.am/developer/embedding/
     Instagram = OEmbed::Provider.new("http://api.instagram.com/oembed", :json)
@@ -199,6 +212,12 @@ module OEmbed
     Yfrog << "http://yfrog.com/*"
     add_official_provider(Yfrog)
 
+    # Provider for imgur.com
+    Imgur = OEmbed::Provider.new("https://api.imgur.com/oembed.{format}")
+    Imgur << "https://*.imgur.com/gallery/*"
+    Imgur << "http://*.imgur.com/gallery/*"
+    add_official_provider(Imgur)
+
     # provider for mlg-tv
     # http://tv.majorleaguegaming.com/oembed
     MlgTv = OEmbed::Provider.new("http://tv.majorleaguegaming.com/oembed")

data/lib/oembed/version.rb

@@ -2,7 +2,7 @@ module OEmbed
   class Version
     MAJOR = 0
     MINOR = 8
-    PATCH = 11
+    PATCH = 12
     STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
 
     class << self

data/spec/formatter/ducktype_backend_spec.rb

@@ -9,7 +9,7 @@ class WorkingDuck
     end
     def parse_error; RuntimeError; end
   end
-  
+
   # A WorkingDuck instance should work as a Backend
   def decode(value)
     self.class.decode(value)
@@ -29,33 +29,33 @@ describe "OEmbed::Formatter::JSON::Backends::DuckType" do
   include OEmbedSpecHelper
 
   it "should work with WorkingDuck Class" do
-    lambda {
+    expect {
       OEmbed::Formatter::JSON.backend = WorkingDuck
-    }.should_not raise_error
-    OEmbed::Formatter::JSON.backend.should equal(WorkingDuck)
+    }.not_to raise_error
+    expect(OEmbed::Formatter::JSON.backend).to be WorkingDuck
   end
-  
+
   it "should work with a WorkingDuck instance" do
     instance = WorkingDuck.new
-    lambda {
+    expect {
       OEmbed::Formatter::JSON.backend = instance
-    }.should_not raise_error
-    OEmbed::Formatter::JSON.backend.should equal(instance)
+    }.to_not raise_error
+    expect(OEmbed::Formatter::JSON.backend).to be instance
   end
-  
+
   it "should fail with FailingDuckDecode Class" do
-    lambda {
+    expect {
       OEmbed::Formatter::JSON.backend = FailingDuckDecode
-    }.should raise_error(LoadError)
-    OEmbed::Formatter::JSON.backend.should_not equal(FailingDuckDecode)
+    }.to raise_error(LoadError)
+    expect(OEmbed::Formatter::JSON.backend).to_not be(FailingDuckDecode)
   end
-  
+
   it "should fail with a FailingDuckDecode instance" do
     instance = FailingDuckDecode.new
-    lambda {
+    expect {
       OEmbed::Formatter::JSON.backend = instance
-    }.should raise_error(LoadError)
-    OEmbed::Formatter::JSON.backend.should_not equal(instance)
+    }.to raise_error(LoadError)
+    expect(OEmbed::Formatter::JSON.backend).to_not be(instance)
   end
 end
 
@@ -63,32 +63,32 @@ describe "OEmbed::Formatter::XML::Backends::DuckType" do
   include OEmbedSpecHelper
 
   it "should work with WorkingDuck Class" do
-    lambda {
+    expect {
       OEmbed::Formatter::XML.backend = WorkingDuck
-    }.should_not raise_error
-    OEmbed::Formatter::XML.backend.should equal(WorkingDuck)
+    }.to_not raise_error
+    expect(OEmbed::Formatter::XML.backend).to be(WorkingDuck)
   end
-  
+
   it "should work with a WorkingDuck instance" do
     instance = WorkingDuck.new
-    lambda {
+    expect {
       OEmbed::Formatter::XML.backend = instance
-    }.should_not raise_error
-    OEmbed::Formatter::XML.backend.should equal(instance)
+    }.to_not raise_error
+    expect(OEmbed::Formatter::XML.backend).to be(instance)
   end
-  
+
   it "should fail with FailingDuckDecode Class" do
-    lambda {
+    expect {
       OEmbed::Formatter::XML.backend = FailingDuckDecode
-    }.should raise_error(LoadError)
-    OEmbed::Formatter::XML.backend.should_not equal(FailingDuckDecode)
+    }.to raise_error(LoadError)
+    expect(OEmbed::Formatter::XML.backend).to_not be(FailingDuckDecode)
   end
-  
+
   it "should fail with a FailingDuckDecode instance" do
     instance = FailingDuckDecode.new
-    lambda {
+    expect {
       OEmbed::Formatter::XML.backend = instance
-    }.should raise_error(LoadError)
-    OEmbed::Formatter::XML.backend.should_not equal(instance)
+    }.to raise_error(LoadError)
+    expect(OEmbed::Formatter::XML.backend).to_not be(instance)
   end
 end

data/spec/formatter/json/jsongem_backend_spec.rb

@@ -4,55 +4,56 @@ describe "OEmbed::Formatter::JSON::Backends::JSONGem" do
   include OEmbedSpecHelper
 
   before(:all) do
-    lambda {
+    expect {
       OEmbed::Formatter::JSON.backend = 'JSONGem'
-    }.should raise_error(LoadError)
-    
+    }.to raise_error(LoadError)
+
     require 'json'
-    
-    lambda {
+
+    expect {
       OEmbed::Formatter::JSON.backend = 'JSONGem'
-    }.should_not raise_error
+    }.to_not raise_error
   end
 
   it "should support JSON" do
-    proc { OEmbed::Formatter.supported?(:json) }.
-    should_not raise_error
+    expect {
+      OEmbed::Formatter.supported?(:json)
+    }.to_not raise_error
   end
-  
+
   it "should be using the JSONGem backend" do
-    OEmbed::Formatter::JSON.backend.should == OEmbed::Formatter::JSON::Backends::JSONGem
+    expect(OEmbed::Formatter::JSON.backend).to eq(OEmbed::Formatter::JSON::Backends::JSONGem)
   end
-  
+
   it "should decode a JSON String" do
     decoded = OEmbed::Formatter.decode(:json, valid_response(:json))
     # We need to compare keys & values separately because we don't expect all
     # non-string values to be recognized correctly.
-    decoded.keys.should == valid_response(:object).keys
-    decoded.values.map{|v|v.to_s}.should == valid_response(:object).values.map{|v|v.to_s}
+    expect(decoded.keys).to eq(valid_response(:object).keys)
+    expect(decoded.values.map{|v|v.to_s}).to eq(valid_response(:object).values.map{|v|v.to_s})
   end
-  
+
   it "should raise an OEmbed::ParseError when decoding an invalid JSON String" do
-    lambda {
+    expect {
       decode = OEmbed::Formatter.decode(:json, invalid_response('unclosed_container', :json))
-    }.should raise_error(OEmbed::ParseError)
-    lambda {
+    }.to raise_error(OEmbed::ParseError)
+    expect {
       decode = OEmbed::Formatter.decode(:json, invalid_response('unclosed_tag', :json))
-    }.should raise_error(OEmbed::ParseError)
-    lambda {
+    }.to raise_error(OEmbed::ParseError)
+    expect {
       decode = OEmbed::Formatter.decode(:json, invalid_response('invalid_syntax', :json))
-    }.should raise_error(OEmbed::ParseError)
+    }.to raise_error(OEmbed::ParseError)
   end
-  
+
   it "should raise an OEmbed::ParseError when decoding fails with an unexpected error" do
     error_to_raise = ArgumentError
-    OEmbed::Formatter::JSON.backend.parse_error.should_not be_kind_of(error_to_raise)
-    
-    ::JSON.should_receive(:parse).
-      and_raise(error_to_raise.new("unknown error"))
-    
-    lambda {
+    expect(OEmbed::Formatter::JSON.backend.parse_error).to_not be_kind_of(error_to_raise)
+
+    expect(::JSON).to receive(:parse).
+      and_throw(error_to_raise.new("unknown error"))
+
+    expect {
       decode = OEmbed::Formatter.decode(:json, valid_response(:json))
-    }.should raise_error(OEmbed::ParseError)
+    }.to raise_error(OEmbed::ParseError)
   end
 end

data/spec/formatter/json/yaml_backend_spec.rb

@@ -4,51 +4,52 @@ describe "OEmbed::Formatter::JSON::Backends::Yaml" do
   include OEmbedSpecHelper
 
   before(:all) do
-    lambda {
+    expect {
       OEmbed::Formatter::JSON.backend = 'Yaml'
-    }.should_not raise_error
-    
-    (!!defined?(YAML)).should == true
+    }.to_not raise_error
+
+    expect(!!defined?(YAML)).to eq(true)
   end
 
   it "should support JSON" do
-    proc { OEmbed::Formatter.supported?(:json) }.
-    should_not raise_error
+    expect {
+      OEmbed::Formatter.supported?(:json)
+    }.to_not raise_error
   end
-  
+
   it "should be using the Yaml backend" do
-    OEmbed::Formatter::JSON.backend.should == OEmbed::Formatter::JSON::Backends::Yaml
+    expect(OEmbed::Formatter::JSON.backend).to eq(OEmbed::Formatter::JSON::Backends::Yaml)
   end
-  
+
   it "should decode a JSON String" do
     decoded = OEmbed::Formatter.decode(:json, valid_response(:json))
     # We need to compare keys & values separately because we don't expect all
     # non-string values to be recognized correctly.
-    decoded.keys.should == valid_response(:object).keys
-    decoded.values.map{|v|v.to_s}.should == valid_response(:object).values.map{|v|v.to_s}
+    expect(decoded.keys).to eq(valid_response(:object).keys)
+    expect(decoded.values.map{|v|v.to_s}).to eq(valid_response(:object).values.map{|v|v.to_s})
   end
-  
+
   it "should raise an OEmbed::ParseError when decoding an invalid JSON String" do
-    lambda {
+    expect {
       decode = OEmbed::Formatter.decode(:json, invalid_response('unclosed_container', :json))
-    }.should raise_error(OEmbed::ParseError)
-    lambda {
+    }.to raise_error(OEmbed::ParseError)
+    expect {
       decode = OEmbed::Formatter.decode(:json, invalid_response('unclosed_tag', :json))
-    }.should raise_error(OEmbed::ParseError)
-    lambda {
+    }.to raise_error(OEmbed::ParseError)
+    expect {
       decode = OEmbed::Formatter.decode(:json, invalid_response('invalid_syntax', :json))
-    }.should raise_error(OEmbed::ParseError)
+    }.to raise_error(OEmbed::ParseError)
   end
-  
+
   it "should raise an OEmbed::ParseError when decoding fails with an unexpected error" do
     error_to_raise = ArgumentError
-    OEmbed::Formatter::JSON.backend.parse_error.should_not be_kind_of(error_to_raise)
-    
-    OEmbed::Formatter::JSON.backend.should_receive(:convert_json_to_yaml).
-      and_raise(error_to_raise.new("unknown error"))
-    
-    lambda {
+    expect(OEmbed::Formatter::JSON.backend.parse_error).to_not be_kind_of(error_to_raise)
+
+    expect(OEmbed::Formatter::JSON.backend).to receive(:convert_json_to_yaml).
+      and_throw(error_to_raise.new("unknown error"))
+
+    expect {
       decode = OEmbed::Formatter.decode(:json, valid_response(:json))
-    }.should raise_error(OEmbed::ParseError)
+    }.to raise_error(OEmbed::ParseError)
   end
 end

data/spec/formatter/xml/nokogiri_backend_spec.rb

@@ -4,55 +4,56 @@ describe "OEmbed::Formatter::XML::Backends::Nokogiri" do
   include OEmbedSpecHelper
 
   before(:all) do
-    lambda {
+    expect {
       OEmbed::Formatter::XML.backend = 'Nokogiri'
-    }.should raise_error(LoadError)
-    
+    }.to raise_error(LoadError)
+
     require 'nokogiri'
-    
-    lambda {
+
+    expect {
       OEmbed::Formatter::XML.backend = 'Nokogiri'
-    }.should_not raise_error
+    }.to_not raise_error
   end
 
   it "should support XML" do
-    proc { OEmbed::Formatter.supported?(:xml) }.
-    should_not raise_error
+    expect {
+      OEmbed::Formatter.supported?(:xml)
+    }.to_not raise_error
   end
-  
+
   it "should be using the Nokogiri backend" do
-    OEmbed::Formatter::XML.backend.should == OEmbed::Formatter::XML::Backends::Nokogiri
+    expect(OEmbed::Formatter::XML.backend).to eq(OEmbed::Formatter::XML::Backends::Nokogiri)
   end
-  
+
   it "should decode an XML String" do
     decoded = OEmbed::Formatter.decode(:xml, valid_response(:xml))
     # We need to compare keys & values separately because we don't expect all
     # non-string values to be recognized correctly.
-    decoded.keys.should == valid_response(:object).keys
-    decoded.values.map{|v|v.to_s}.should == valid_response(:object).values.map{|v|v.to_s}
+    expect(decoded.keys).to eq(valid_response(:object).keys)
+    expect(decoded.values.map{|v|v.to_s}).to eq(valid_response(:object).values.map{|v|v.to_s})
   end
-  
+
   it "should raise an OEmbed::ParseError when decoding an invalid XML String" do
-    lambda {
+    expect {
       decode = OEmbed::Formatter.decode(:xml, invalid_response('unclosed_container', :xml))
-    }.should raise_error(OEmbed::ParseError)
-    lambda {
+    }.to raise_error(OEmbed::ParseError)
+    expect {
       decode = OEmbed::Formatter.decode(:xml, invalid_response('unclosed_tag', :xml))
-    }.should raise_error(OEmbed::ParseError)
-    lambda {
+    }.to raise_error(OEmbed::ParseError)
+    expect {
       decode = OEmbed::Formatter.decode(:xml, invalid_response('invalid_syntax', :xml))
-    }.should raise_error(OEmbed::ParseError)
+    }.to raise_error(OEmbed::ParseError)
   end
-  
+
   it "should raise an OEmbed::ParseError when decoding fails with an unexpected error" do
     error_to_raise = ArgumentError
-    OEmbed::Formatter::XML.backend.parse_error.should_not be_kind_of(error_to_raise)
-    
-    ::Nokogiri::XML::Document.should_receive(:parse).
+    expect(OEmbed::Formatter::XML.backend.parse_error).to_not be_kind_of(error_to_raise)
+
+    expect(::Nokogiri::XML::Document).to receive(:parse).
       and_raise(error_to_raise.new("unknown error"))
-    
-    lambda {
+
+    expect {
       decode = OEmbed::Formatter.decode(:xml, valid_response(:xml))
-    }.should raise_error(OEmbed::ParseError)
+    }.to raise_error(OEmbed::ParseError)
   end
 end

data/spec/formatter/xml/rexml_backend_spec.rb

@@ -4,51 +4,52 @@ describe "OEmbed::Formatter::XML::Backends::REXML" do
   include OEmbedSpecHelper
 
   before(:all) do
-    lambda {
+    expect {
       OEmbed::Formatter::XML.backend = 'REXML'
-    }.should_not raise_error
-    
-    (!!defined?(REXML)).should == true
+    }.to_not raise_error
+
+    expect((!!defined?(REXML))).to eq(true)
   end
 
   it "should support XML" do
-    proc { OEmbed::Formatter.supported?(:xml) }.
-    should_not raise_error
+    expect {
+      OEmbed::Formatter.supported?(:xml)
+    }.to_not raise_error
   end
-  
+
   it "should be using the XmlSimple backend" do
-    OEmbed::Formatter::XML.backend.should == OEmbed::Formatter::XML::Backends::REXML
+    expect(OEmbed::Formatter::XML.backend).to eq(OEmbed::Formatter::XML::Backends::REXML)
   end
-  
+
   it "should decode an XML String" do
     decoded = OEmbed::Formatter.decode(:xml, valid_response(:xml))
     # We need to compare keys & values separately because we don't expect all
     # non-string values to be recognized correctly.
-    decoded.keys.should == valid_response(:object).keys
-    decoded.values.map{|v|v.to_s}.should == valid_response(:object).values.map{|v|v.to_s}
+    expect(decoded.keys).to eq(valid_response(:object).keys)
+    expect(decoded.values.map{|v|v.to_s}).to eq(valid_response(:object).values.map{|v|v.to_s})
   end
-  
+
   it "should raise an OEmbed::ParseError when decoding an invalid XML String" do
-    lambda {
+    expect {
       decode = OEmbed::Formatter.decode(:xml, invalid_response('unclosed_container', :xml))
-    }.should raise_error(OEmbed::ParseError)
-    lambda {
+    }.to raise_error(OEmbed::ParseError)
+    expect {
       decode = OEmbed::Formatter.decode(:xml, invalid_response('unclosed_tag', :xml))
-    }.should raise_error(OEmbed::ParseError)
-    lambda {
+    }.to raise_error(OEmbed::ParseError)
+    expect {
       decode = OEmbed::Formatter.decode(:xml, invalid_response('invalid_syntax', :xml))
-    }.should raise_error(OEmbed::ParseError)
+    }.to raise_error(OEmbed::ParseError)
   end
-  
+
   it "should raise an OEmbed::ParseError when decoding fails with an unexpected error" do
     error_to_raise = ArgumentError
-    OEmbed::Formatter::XML.backend.parse_error.should_not be_kind_of(error_to_raise)
-    
-    ::REXML::Document.should_receive(:new).
+    expect(OEmbed::Formatter::XML.backend.parse_error).to_not be_kind_of(error_to_raise)
+
+    expect(::REXML::Document).to receive(:new).
       and_raise(error_to_raise.new("unknown error"))
-    
-    lambda {
+
+    expect {
       decode = OEmbed::Formatter.decode(:xml, valid_response(:xml))
-    }.should raise_error(OEmbed::ParseError)
+    }.to raise_error(OEmbed::ParseError)
   end
 end

data/spec/formatter/xml/xmlsimple_backend_spec.rb

@@ -4,55 +4,56 @@ describe "OEmbed::Formatter::XML::Backends::XmlSimple" do
   include OEmbedSpecHelper
 
   before(:all) do
-    lambda {
+    expect {
       OEmbed::Formatter::XML.backend = 'XmlSimple'
-    }.should raise_error(LoadError)
-    
+    }.to raise_error(LoadError)
+
     require 'xmlsimple'
-    
-    lambda {
+
+    expect {
       OEmbed::Formatter::XML.backend = 'XmlSimple'
-    }.should_not raise_error
+    }.to_not raise_error
   end
 
   it "should support XML" do
-    proc { OEmbed::Formatter.supported?(:xml) }.
-    should_not raise_error
+    expect {
+      OEmbed::Formatter.supported?(:xml)
+    }.to_not raise_error
   end
-  
+
   it "should be using the XmlSimple backend" do
-    OEmbed::Formatter::XML.backend.should == OEmbed::Formatter::XML::Backends::XmlSimple
+    expect(OEmbed::Formatter::XML.backend).to eq(OEmbed::Formatter::XML::Backends::XmlSimple)
   end
-  
+
   it "should decode an XML String" do
     decoded = OEmbed::Formatter.decode(:xml, valid_response(:xml))
     # We need to compare keys & values separately because we don't expect all
     # non-string values to be recognized correctly.
-    decoded.keys.should == valid_response(:object).keys
-    decoded.values.map{|v|v.to_s}.should == valid_response(:object).values.map{|v|v.to_s}
+    expect(decoded.keys).to eq(valid_response(:object).keys)
+    expect(decoded.values.map{|v|v.to_s}).to eq(valid_response(:object).values.map{|v|v.to_s})
   end
-  
+
   it "should raise an OEmbed::ParseError when decoding an invalid XML String" do
-    lambda {
+    expect {
       decode = OEmbed::Formatter.decode(:xml, invalid_response('unclosed_container', :xml))
-    }.should raise_error(OEmbed::ParseError)
-    lambda {
+    }.to raise_error(OEmbed::ParseError)
+    expect {
       decode = OEmbed::Formatter.decode(:xml, invalid_response('unclosed_tag', :xml))
-    }.should raise_error(OEmbed::ParseError)
-    lambda {
+    }.to raise_error(OEmbed::ParseError)
+    expect {
       decode = OEmbed::Formatter.decode(:xml, invalid_response('invalid_syntax', :xml))
-    }.should raise_error(OEmbed::ParseError)
+    }.to raise_error(OEmbed::ParseError)
   end
-  
+
   it "should raise an OEmbed::ParseError when decoding fails with an unexpected error" do
     error_to_raise = ArgumentError
-    OEmbed::Formatter::XML.backend.parse_error.should_not be_kind_of(error_to_raise)
-    
-    ::XmlSimple.should_receive(:xml_in).
+    expect(OEmbed::Formatter::XML.backend.parse_error).to_not be_kind_of(error_to_raise)
+
+    expect(::XmlSimple).to receive(:xml_in).
       and_raise(error_to_raise.new("unknown error"))
-    
-    lambda {
+
+    expect {
       decode = OEmbed::Formatter.decode(:xml, valid_response(:xml))
-    }.should raise_error(OEmbed::ParseError)
+    }.to raise_error(OEmbed::ParseError)
   end
 end

data/spec/formatter_spec.rb

@@ -4,32 +4,34 @@ describe OEmbed::Formatter do
   include OEmbedSpecHelper
 
   it "should support JSON" do
-    proc { OEmbed::Formatter.supported?(:json) }.
-    should_not raise_error
+    expect {
+      OEmbed::Formatter.supported?(:json)
+    }.to_not raise_error
   end
 
   it "should default to JSON" do
-    OEmbed::Formatter.default.should == 'json'
+    expect(OEmbed::Formatter.default).to eq('json')
   end
 
   it "should decode a JSON String" do
     decoded = OEmbed::Formatter.decode(:json, valid_response(:json))
     # We need to compare keys & values separately because we don't expect all
     # non-string values to be recognized correctly.
-    decoded.keys.should == valid_response(:object).keys
-    decoded.values.map{|v|v.to_s}.should == valid_response(:object).values.map{|v|v.to_s}
+    expect(decoded.keys).to eq(valid_response(:object).keys)
+    expect(decoded.values.map{|v|v.to_s}).to eq(valid_response(:object).values.map{|v|v.to_s})
   end
 
   it "should support XML" do
-    proc { OEmbed::Formatter.supported?(:xml) }.
-    should_not raise_error
+    expect {
+      OEmbed::Formatter.supported?(:xml)
+    }.to_not raise_error
   end
 
   it "should decode an XML String" do
     decoded = OEmbed::Formatter.decode(:xml, valid_response(:xml))
     # We need to compare keys & values separately because we don't expect all
     # non-string values to be recognized correctly.
-    decoded.keys.should == valid_response(:object).keys
-    decoded.values.map{|v|v.to_s}.should == valid_response(:object).values.map{|v|v.to_s}
+    expect(decoded.keys).to eq(valid_response(:object).keys)
+    expect(decoded.values.map{|v|v.to_s}).to eq(valid_response(:object).values.map{|v|v.to_s})
   end
 end