ruby-oembed 0.8.13 → 0.8.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f3a0f4bb2b17461615d009c0c8c69a81945a9a3
-  data.tar.gz: 1c7e0e0eb6f4b41120016a709d4540e82dd36f71
+  metadata.gz: f272f1578d7a957040f57d7be37efd0d5f3d0c38
+  data.tar.gz: aa9c139bd3f26aeafd8a591331a0e3c3ba8160ea
 SHA512:
-  metadata.gz: afb3f8190d9f8ca421bcf35746af78c901f558a3dd585a86b39ad871bf53176e9066005f3a954a354dadb0a9d361d3776bee832b0e8e5b4c69f6703ba7b10f46
-  data.tar.gz: 40d0f01fd1717af0dc8c4036b25b0dbcc9327ca96e8698cd431b102d16c9a33b62d1dcbf0d59d4e5a4278104859ab4f825f0f2e2fd7682e9464819c7efcf1e5e
+  metadata.gz: d0793e3de5c2a4ffc40c75cefceab7890bf6ab43b24cd8e5f9da7ac37f8732074170f80cf384d63e7f656a391e526f254d06535c3aec4d5456c60b7a3c36bf3b
+  data.tar.gz: 25b144a3c8c6682ae9e1d5c99a1cede9cf8013ce9cbc83e05b50f0401eca8e11ad1bfab7e986cef2a08cca2cf5c49ad3d83ae98f849f17525bb1d9d2d802ab7a

data/CHANGELOG.rdoc

@@ -1,5 +1,11 @@
 = CHANGELOG
 
+== 0.8.14 - 25 April 2015
+
+* Change built-in Vimeo provider to use https oembed endpoint; Pull #44 (Jonne Haß)
+* Change built-in Flickr provider to use https oembed endpoint; Pull #46 (Javan Makhmali)
+* Change built-in Flickr provider to recognize https URLs and short flic.kr URLs (Javan Makhmali & Marcos Wright-Kuhns)
+
 == 0.8.13 - 23 April 2015
 
 * Change built-in Instagram provider to recognize https URLs; Pull #35 (Philipp Bosch)

data/lib/oembed/providers.rb

@@ -144,9 +144,11 @@ module OEmbed
     add_official_provider(Youtube)
 
     # Provider for flickr.com
-    # http://developer.yahoo.com/blogs/ydn/posts/2008/05/oembed_embeddin/
-    Flickr = OEmbed::Provider.new("http://www.flickr.com/services/oembed/")
+    Flickr = OEmbed::Provider.new("https://www.flickr.com/services/oembed/")
     Flickr << "http://*.flickr.com/*"
+    Flickr << "https://*.flickr.com/*"
+    Flickr << "http://flic.kr/*"
+    Flickr << "https://flic.kr/*"
     add_official_provider(Flickr)
 
     # Provider for viddler.com
@@ -173,8 +175,8 @@ module OEmbed
     add_official_provider(Hulu)
 
     # Provider for vimeo.com
-    # http://developer.vimeo.com/apis/oembed
-    Vimeo = OEmbed::Provider.new("http://vimeo.com/api/oembed.{format}")
+    # https://developer.vimeo.com/apis/oembed
+    Vimeo = OEmbed::Provider.new("https://vimeo.com/api/oembed.{format}")
     Vimeo << "http://*.vimeo.com/*"
     Vimeo << "https://*.vimeo.com/*"
     add_official_provider(Vimeo)

data/lib/oembed/version.rb

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

data/spec/provider_spec.rb

@@ -30,16 +30,16 @@ describe OEmbed::Provider do
   end
 
   it "should require a valid endpoint for a new instance" do
-    proc { OEmbed::Provider.new("http://foo.com/oembed/") }.
-    should_not raise_error
+    expect { OEmbed::Provider.new("http://foo.com/oembed/") }.
+    not_to raise_error
 
-    proc { OEmbed::Provider.new("https://foo.com/oembed/") }.
-    should_not raise_error
+    expect { OEmbed::Provider.new("https://foo.com/oembed/") }.
+    not_to raise_error
   end
 
   it "should allow a {format} string in the endpoint for a new instance" do
-    proc { OEmbed::Provider.new("http://foo.com/oembed.{format}/get") }.
-    should_not raise_error
+    expect { OEmbed::Provider.new("http://foo.com/oembed.{format}/get") }.
+    not_to raise_error
   end
 
   it "should raise an ArgumentError given an invalid endpoint for a new instance" do
@@ -50,66 +50,66 @@ describe OEmbed::Provider do
       "http://not a uri",
       nil, 1,
     ].each do |endpoint|
-      proc { OEmbed::Provider.new(endpoint) }.
-      should raise_error(ArgumentError)
+      expect { OEmbed::Provider.new(endpoint) }.
+      to raise_error(ArgumentError)
     end
   end
 
   it "should allow no URI schema to be given" do
     provier = OEmbed::Provider.new("http://foo.com/oembed")
 
-    provier.include?("http://foo.com/1").should be_truthy
-    provier.include?("http://bar.foo.com/1").should be_truthy
-    provier.include?("http://bar.foo.com/show/1").should be_truthy
-    provier.include?("https://bar.foo.com/1").should be_truthy
-    provier.include?("http://asdf.com/1").should be_truthy
-    provier.include?("asdf").should be_truthy
+    expect(provier).to include("http://foo.com/1")
+    expect(provier).to include("http://bar.foo.com/1")
+    expect(provier).to include("http://bar.foo.com/show/1")
+    expect(provier).to include("https://bar.foo.com/1")
+    expect(provier).to include("http://asdf.com/1")
+    expect(provier).to include("asdf")
   end
 
   it "should allow a String as a URI schema" do
     provier = OEmbed::Provider.new("http://foo.com/oembed")
     provier << "http://bar.foo.com/*"
 
-    provier.include?("http://bar.foo.com/1").should be_truthy
-    provier.include?("http://bar.foo.com/show/1").should be_truthy
+    expect(provier).to include("http://bar.foo.com/1")
+    expect(provier).to include("http://bar.foo.com/show/1")
 
-    provier.include?("https://bar.foo.com/1").should be_falsey
-    provier.include?("http://foo.com/1").should be_falsey
+    expect(provier).to_not include("https://bar.foo.com/1")
+    expect(provier).to_not include("http://foo.com/1")
   end
 
   it "should allow multiple path wildcards in a String URI schema" do
     provier = OEmbed::Provider.new("http://foo.com/oembed")
     provier << "http://bar.foo.com/*/show/*"
 
-    provier.include?("http://bar.foo.com/photo/show/1").should be_truthy
-    provier.include?("http://bar.foo.com/video/show/2").should be_truthy
-    provier.include?("http://bar.foo.com/help/video/show/2").should be_truthy
+    expect(provier).to include("http://bar.foo.com/photo/show/1")
+    expect(provier).to include("http://bar.foo.com/video/show/2")
+    expect(provier).to include("http://bar.foo.com/help/video/show/2")
 
-    provier.include?("https://bar.foo.com/photo/show/1").should be_falsey
-    provier.include?("http://foo.com/video/show/2").should be_falsey
-    provier.include?("http://bar.foo.com/show/1").should be_falsey
-    provier.include?("http://bar.foo.com/1").should be_falsey
+    expect(provier).to_not include("https://bar.foo.com/photo/show/1")
+    expect(provier).to_not include("http://foo.com/video/show/2")
+    expect(provier).to_not include("http://bar.foo.com/show/1")
+    expect(provier).to_not include("http://bar.foo.com/1")
   end
 
   it "should NOT allow multiple domain wildcards in a String URI schema", :pending => true do
     provier = OEmbed::Provider.new("http://foo.com/oembed")
 
-    proc { provier << "http://*.com/*" }.
-    should raise_error(ArgumentError)
+    expect { provier << "http://*.com/*" }.
+    to raise_error(ArgumentError)
 
-    provier.include?("http://foo.com/1").should be_falsey
+    expect(provier).to_not include("http://foo.com/1")
   end
 
   it "should allow a sub-domain wildcard in String URI schema" do
     provier = OEmbed::Provider.new("http://foo.com/oembed")
     provier << "http://*.foo.com/*"
 
-    provier.include?("http://bar.foo.com/1").should be_truthy
-    provier.include?("http://foo.foo.com/2").should be_truthy
-    provier.include?("http://foo.com/3").should be_truthy
+    expect(provier).to include("http://bar.foo.com/1")
+    expect(provier).to include("http://foo.foo.com/2")
+    expect(provier).to include("http://foo.com/3")
 
-    provier.include?("https://bar.foo.com/1").should be_falsey
-    provier.include?("http://my.bar.foo.com/1").should be_falsey
+    expect(provier).to_not include("https://bar.foo.com/1")
+    expect(provier).to_not include("http://my.bar.foo.com/1")
 
     provier << "http://my.*.foo.com/*"
   end
@@ -118,66 +118,66 @@ describe OEmbed::Provider do
     provier = OEmbed::Provider.new("http://foo.com/oembed")
     provier << "http://*.my.*.foo.com/*"
 
-    provier.include?("http://my.bar.foo.com/1").should be_truthy
-    provier.include?("http://my.foo.com/2").should be_truthy
-    provier.include?("http://bar.my.bar.foo.com/3").should be_truthy
+    expect(provier).to include("http://my.bar.foo.com/1")
+    expect(provier).to include("http://my.foo.com/2")
+    expect(provier).to include("http://bar.my.bar.foo.com/3")
 
-    provier.include?("http://bar.foo.com/1").should be_falsey
-    provier.include?("http://foo.bar.foo.com/1").should be_falsey
+    expect(provier).to_not include("http://bar.foo.com/1")
+    expect(provier).to_not include("http://foo.bar.foo.com/1")
   end
 
   it "should NOT allow a scheme wildcard in a String URI schema", :pending => true do
     provier = OEmbed::Provider.new("http://foo.com/oembed")
 
-    proc { provier << "*://foo.com/*" }.
-    should raise_error(ArgumentError)
+    expect { provier << "*://foo.com/*" }.
+    to raise_error(ArgumentError)
 
-    provier.include?("http://foo.com/1").should be_falsey
+    expect(provier).to_not include("http://foo.com/1")
   end
 
   it "should allow a scheme other than http in a String URI schema" do
     provier = OEmbed::Provider.new("http://foo.com/oembed")
     provier << "https://foo.com/*"
 
-    provier.include?("https://foo.com/1").should be_truthy
+    expect(provier).to include("https://foo.com/1")
 
     gopher_url = "gopher://foo.com/1"
-    provier.include?(gopher_url).should be_falsey
+    expect(provier).to_not include(gopher_url)
     provier << "gopher://foo.com/*"
-    provier.include?(gopher_url).should be_truthy
+    expect(provier).to include(gopher_url)
   end
 
   it "should allow a Regexp as a URI schema" do
     provier = OEmbed::Provider.new("http://foo.com/oembed")
     provier << %r{^https?://([^\.]*\.)?foo.com/(show/)?\d+}
 
-    provier.include?("http://bar.foo.com/1").should be_truthy
-    provier.include?("http://bar.foo.com/show/1").should be_truthy
-    provier.include?("http://foo.com/1").should be_truthy
-    provier.include?("https://bar.foo.com/1").should be_truthy
+    expect(provier).to include("http://bar.foo.com/1")
+    expect(provier).to include("http://bar.foo.com/show/1")
+    expect(provier).to include("http://foo.com/1")
+    expect(provier).to include("https://bar.foo.com/1")
 
-    provier.include?("http://bar.foo.com/video/1").should be_falsey
-    provier.include?("gopher://foo.com/1").should be_falsey
+    expect(provier).to_not include("http://bar.foo.com/video/1")
+    expect(provier).to_not include("gopher://foo.com/1")
   end
 
   it "should by default use OEmbed::Formatter.default" do
-    @flickr.format.should == @default
+    expect(@flickr.format).to eq(@default)
   end
 
   it "should allow xml" do
-    @qik.format.should == :xml
+    expect(@qik.format).to eq(:xml)
   end
 
   it "should allow json" do
-    @viddler.format.should == :json
+    expect(@viddler.format).to eq(:json)
   end
 
   it "should allow random formats on initialization" do
-    proc {
+    expect {
       yaml_provider = OEmbed::Provider.new("http://foo.com/api/oembed.{format}", :yml)
       yaml_provider << "http://foo.com/*"
     }.
-    should_not raise_error
+    not_to raise_error
   end
 
   it "should not allow random formats to be parsed" do
@@ -185,43 +185,43 @@ describe OEmbed::Provider do
     yaml_provider << "http://foo.com/*"
     yaml_url = "http://foo.com/video/1"
 
-    yaml_provider.should_receive(:raw).
+    expect(yaml_provider).to receive(:raw).
       with(yaml_url, {:format=>:yml}).
       and_return(valid_response(:json))
 
-    proc { yaml_provider.get(yaml_url) }.
-    should raise_error(OEmbed::FormatNotSupported)
+    expect { yaml_provider.get(yaml_url) }.
+    to raise_error(OEmbed::FormatNotSupported)
   end
 
   it "should add URL schemes" do
-    @flickr.urls.should == [%r{^http://([^\.]+\.)?flickr\.com/(.*?)}]
-    @qik.urls.should == [%r{^http://qik\.com/video/(.*?)},
-                         %r{^http://qik\.com/(.*?)}]
+    expect(@flickr.urls).to eq([%r{^http://([^\.]+\.)?flickr\.com/(.*?)}])
+    expect(@qik.urls).to eq([%r{^http://qik\.com/video/(.*?)},
+                         %r{^http://qik\.com/(.*?)}])
   end
 
   it "should match URLs" do
-    @flickr.include?(example_url(:flickr)).should be_truthy
-    @qik.include?(example_url(:qik)).should be_truthy
+    expect(@flickr).to include(example_url(:flickr))
+    expect(@qik).to include(example_url(:qik))
   end
 
   it "should raise error if the URL is invalid" do
-    proc{ @flickr.send(:build, example_url(:fake)) }.should raise_error(OEmbed::NotFound)
-    proc{ @qik.send(:build, example_url(:fake)) }.should raise_error(OEmbed::NotFound)
+    expect{ @flickr.send(:build, example_url(:fake)) }.to raise_error(OEmbed::NotFound)
+    expect{ @qik.send(:build, example_url(:fake)) }.to raise_error(OEmbed::NotFound)
   end
 
   describe "#build" do
     it "should return a proper URL" do
       uri = @flickr.send(:build, example_url(:flickr))
-      uri.host.should == "www.flickr.com"
-      uri.path.should == "/services/oembed/"
-      uri.query.include?("format=#{@flickr.format}").should be_truthy
-      uri.query.include?("url=#{CGI.escape 'http://flickr.com/photos/bees/2362225867/'}").should be_truthy
+      expect(uri.host).to eq("www.flickr.com")
+      expect(uri.path).to eq("/services/oembed/")
+      expect(uri.query).to include("format=#{@flickr.format}")
+      expect(uri.query).to include("url=#{CGI.escape 'http://flickr.com/photos/bees/2362225867/'}")
 
       uri = @qik.send(:build, example_url(:qik))
-      uri.host.should == "qik.com"
-      uri.path.should == "/api/oembed.xml"
-      uri.query.include?("format=#{@qik.format}").should be_falsey
-      uri.query.should == "url=#{CGI.escape 'http://qik.com/video/49565'}"
+      expect(uri.host).to eq("qik.com")
+      expect(uri.path).to eq("/api/oembed.xml")
+      expect(uri.query).to_not include("format=#{@qik.format}")
+      expect(uri.query).to eq("url=#{CGI.escape 'http://qik.com/video/49565'}")
     end
 
     it "should accept parameters" do
@@ -231,26 +231,26 @@ describe OEmbed::Provider do
         :format => :xml,
         :another => "test")
 
-      uri.query.include?("maxwidth=600").should be_truthy
-      uri.query.include?("maxheight=200").should be_truthy
-      uri.query.include?("format=xml").should be_truthy
-      uri.query.include?("another=test").should be_truthy
+      expect(uri.query).to include("maxwidth=600")
+      expect(uri.query).to include("maxheight=200")
+      expect(uri.query).to include("format=xml")
+      expect(uri.query).to include("another=test")
     end
 
     it "should build correctly when format is in the endpoint URL" do
       uri = @qik.send(:build, example_url(:qik), :format => :json)
-      uri.path.should == "/api/oembed.json"
+      expect(uri.path).to eq("/api/oembed.json")
     end
 
     it "should build correctly with query parameters in the endpoint URL" do
       provider = OEmbed::Provider.new('http://www.youtube.com/oembed?scheme=https')
       provider << 'http://*.youtube.com/*'
       url = 'http://youtube.com/watch?v=M3r2XDceM6A'
-      provider.include?(url).should be_truthy
+      expect(provider).to include(url)
 
       uri = provider.send(:build, url)
-      uri.query.include?("scheme=https").should be_truthy
-      uri.query.include?("url=#{CGI.escape url}").should be_truthy
+      expect(uri.query).to include("scheme=https")
+      expect(uri.query).to include("url=#{CGI.escape url}")
     end
 
     it "should not include the :timeout parameter in the query string" do
@@ -258,15 +258,15 @@ describe OEmbed::Provider do
         :timeout => 5,
         :another => "test")
 
-      uri.query.include?("timeout=5").should be_falsey
-      uri.query.include?("another=test").should be_truthy
+      expect(uri.query).to_not include("timeout=5")
+      expect(uri.query).to include("another=test")
     end
   end
 
   describe "#raw" do
     it "should return the body on 200" do
       res = @flickr.send(:raw, example_url(:flickr))
-      res.should == example_body(:flickr)
+      expect(res).to eq(example_body(:flickr))
     end
 
     it "should return the body on 200 even over https" do
@@ -275,7 +275,8 @@ describe OEmbed::Provider do
       @vimeo_ssl << "https://*.vimeo.com/*"
 
       expect {
-        @vimeo_ssl.send(:raw, example_url(:vimeo_ssl)).should == example_body(:vimeo_ssl)
+        res = @vimeo_ssl.send(:raw, example_url(:vimeo_ssl))
+        expect(res).to eq(example_body(:vimeo_ssl))
       }.not_to raise_error
     end
 
@@ -313,18 +314,18 @@ describe OEmbed::Provider do
 
   describe "#get" do
     it "should send the specified format" do
-      @flickr.should_receive(:raw).
+      expect(@flickr).to receive(:raw).
         with(example_url(:flickr), {:format=>:json}).
         and_return(valid_response(:json))
       @flickr.get(example_url(:flickr), :format=>:json)
 
-      @flickr.should_receive(:raw).
+      expect(@flickr).to receive(:raw).
         with(example_url(:flickr), {:format=>:xml}).
         and_return(valid_response(:xml))
       @flickr.get(example_url(:flickr), :format=>:xml)
 
       expect {
-        @flickr.should_receive(:raw).
+        expect(@flickr).to receive(:raw).
           with(example_url(:flickr), {:format=>:yml}).
           and_return(valid_response(:json))
         @flickr.get(example_url(:flickr), :format=>:yml)
@@ -332,47 +333,47 @@ describe OEmbed::Provider do
     end
 
     it "should return OEmbed::Response" do
-      @flickr.stub(:raw).and_return(valid_response(@default))
-      @flickr.get(example_url(:flickr)).should be_a(OEmbed::Response)
+      allow(@flickr).to receive(:raw).and_return(valid_response(@default))
+      expect(@flickr.get(example_url(:flickr))).to be_a(OEmbed::Response)
     end
 
     it "should be calling OEmbed::Response#create_for internally" do
-      @flickr.stub(:raw).and_return(valid_response(@default))
-      OEmbed::Response.should_receive(:create_for).
+      allow(@flickr).to receive(:raw).and_return(valid_response(@default))
+      expect(OEmbed::Response).to receive(:create_for).
         with(valid_response(@default), @flickr, example_url(:flickr), @default.to_s)
       @flickr.get(example_url(:flickr))
 
-      @qik.stub(:raw).and_return(valid_response(:xml))
-      OEmbed::Response.should_receive(:create_for).
+      allow(@qik).to receive(:raw).and_return(valid_response(:xml))
+      expect(OEmbed::Response).to receive(:create_for).
         with(valid_response(:xml), @qik, example_url(:qik), 'xml')
       @qik.get(example_url(:qik))
 
-      @viddler.stub(:raw).and_return(valid_response(:json))
-      OEmbed::Response.should_receive(:create_for).
+      allow(@viddler).to receive(:raw).and_return(valid_response(:json))
+      expect(OEmbed::Response).to receive(:create_for).
         with(valid_response(:json), @viddler, example_url(:viddler), 'json')
       @viddler.get(example_url(:viddler))
     end
 
     it "should send the provider's format if none is specified" do
-      @flickr.should_receive(:raw).
+      expect(@flickr).to receive(:raw).
         with(example_url(:flickr), :format => @default).
         and_return(valid_response(@default))
       @flickr.get(example_url(:flickr))
 
-      @qik.should_receive(:raw).
+      expect(@qik).to receive(:raw).
         with(example_url(:qik), :format=>:xml).
         and_return(valid_response(:xml))
       @qik.get(example_url(:qik))
 
-      @viddler.should_receive(:raw).
+      expect(@viddler).to receive(:raw).
         with(example_url(:viddler), :format=>:json).
         and_return(valid_response(:json))
       @viddler.get(example_url(:viddler))
     end
 
     it "handles the :timeout option" do
-      Net::HTTP.any_instance.should_receive(:open_timeout=).with(5)
-      Net::HTTP.any_instance.should_receive(:read_timeout=).with(5)
+      expect_any_instance_of(Net::HTTP).to receive(:open_timeout=).with(5)
+      expect_any_instance_of(Net::HTTP).to receive(:read_timeout=).with(5)
       @flickr.get(example_url(:flickr), :timeout => 5)
     end
   end

data/spec/providers_spec.rb

@@ -127,9 +127,9 @@ describe OEmbed::Providers do
       OEmbed::Providers.register_all
       all_example_urls.each do |url|
         provider = OEmbed::Providers.find(url)
-        provider.should_receive(:raw).
+        expect(provider).should_receive(:raw).
           with(url, {})
-        provider.should_receive(:get).
+        expect(provider).should_receive(:get).
           with(url, {})
         OEmbed::Providers.raw(url)
         OEmbed::Providers.get(url)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-oembed
 version: !ruby/object:Gem::Version
-  version: 0.8.13
+  version: 0.8.14
 platform: ruby
 authors:
 - Magnus Holm
@@ -184,7 +184,7 @@ rdoc_options:
 - "--main"
 - README.rdoc
 - "--title"
-- ruby-oembed-0.8.13
+- ruby-oembed-0.8.14
 - "--inline-source"
 - "--exclude"
 - tasks