feedjira 1.3.1 → 1.4.0

data/spec/feedjira/parser/itunes_rss_item_spec.rb

@@ -8,56 +8,56 @@ describe Feedjira::Parser::ITunesRSSItem do
   end
 
   it "should parse the title" do
-    @item.title.should == "Shake Shake Shake Your Spices"
+    expect(@item.title).to eq "Shake Shake Shake Your Spices"
   end
 
   it "should parse the author" do
-    @item.itunes_author.should == "John Doe"
+    expect(@item.itunes_author).to eq "John Doe"
   end
 
   it "should parse the subtitle" do
-    @item.itunes_subtitle.should == "A short primer on table spices"
+    expect(@item.itunes_subtitle).to eq "A short primer on table spices"
   end
 
   it "should parse the summary" do
-    @item.itunes_summary.should == "This week we talk about salt and pepper shakers, comparing and contrasting pour rates, construction materials, and overall aesthetics. Come and join the party!"
+    expect(@item.itunes_summary).to eq "This week we talk about salt and pepper shakers, comparing and contrasting pour rates, construction materials, and overall aesthetics. Come and join the party!"
   end
 
   it "should parse the enclosure" do
-    @item.enclosure_length.should == "8727310"
-    @item.enclosure_type.should == "audio/x-m4a"
-    @item.enclosure_url.should == "http://example.com/podcasts/everything/AllAboutEverythingEpisode3.m4a"
+    expect(@item.enclosure_length).to eq "8727310"
+    expect(@item.enclosure_type).to eq "audio/x-m4a"
+    expect(@item.enclosure_url).to eq "http://example.com/podcasts/everything/AllAboutEverythingEpisode3.m4a"
   end
 
   it "should parse the guid as id" do
-    @item.id.should == "http://example.com/podcasts/archive/aae20050615.m4a"
+    expect(@item.id).to eq "http://example.com/podcasts/archive/aae20050615.m4a"
   end
 
   it "should parse the published date" do
-    @item.published.should == Time.parse_safely("Wed Jun 15 19:00:00 UTC 2005")
+    expect(@item.published).to eq Time.parse_safely("Wed Jun 15 19:00:00 UTC 2005")
   end
 
   it "should parse the duration" do
-    @item.itunes_duration.should == "7:04"
+    expect(@item.itunes_duration).to eq "7:04"
   end
 
   it "should parse the keywords" do
-    @item.itunes_keywords.should == "salt, pepper, shaker, exciting"
+    expect(@item.itunes_keywords).to eq "salt, pepper, shaker, exciting"
   end
 
   it "should parse the image" do
-    @item.itunes_image.should == "http://example.com/podcasts/everything/AllAboutEverything.jpg"
+    expect(@item.itunes_image).to eq "http://example.com/podcasts/everything/AllAboutEverything.jpg"
   end
 
   it "should parse the order" do
-    @item.itunes_order.should eq '12'
+    expect(@item.itunes_order).to eq '12'
   end
 
   it "should parse the closed captioned flag" do
-    @item.itunes_closed_captioned.should eq 'yes'
+    expect(@item.itunes_closed_captioned).to eq 'yes'
   end
 
   it "should parse the encoded content" do
-    @item.content.should == "<p><strong>TOPIC</strong>: Gooseneck Options</p>"
+    expect(@item.content).to eq "<p><strong>TOPIC</strong>: Gooseneck Options</p>"
   end
 end

data/spec/feedjira/parser/itunes_rss_owner_spec.rb

@@ -8,11 +8,11 @@ describe Feedjira::Parser::ITunesRSSOwner do
   end
 
   it "should parse the name" do
-    @owner.name.should == "John Doe"
+    expect(@owner.name).to eq "John Doe"
   end
 
   it "should parse the email" do
-    @owner.email.should == "john.doe@example.com"
+    expect(@owner.email).to eq "john.doe@example.com"
   end
 
 end

data/spec/feedjira/parser/itunes_rss_spec.rb

@@ -3,19 +3,19 @@ require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
 describe Feedjira::Parser::ITunesRSS do
   describe "#will_parse?" do
     it "should return true for an itunes RSS feed" do
-      Feedjira::Parser::ITunesRSS.should be_able_to_parse(sample_itunes_feed)
+      expect(Feedjira::Parser::ITunesRSS).to be_able_to_parse(sample_itunes_feed)
     end
 
     it "should return true for an itunes RSS feed with spaces between attribute names, equals sign, and values" do
-      Feedjira::Parser::ITunesRSS.should be_able_to_parse(sample_itunes_feed_with_spaces)
+      expect(Feedjira::Parser::ITunesRSS).to be_able_to_parse(sample_itunes_feed_with_spaces)
     end
 
     it "should return fase for an atom feed" do
-      Feedjira::Parser::ITunesRSS.should_not be_able_to_parse(sample_atom_feed)
+      expect(Feedjira::Parser::ITunesRSS).to_not be_able_to_parse(sample_atom_feed)
     end
 
     it "should return false for an rss feedburner feed" do
-      Feedjira::Parser::ITunesRSS.should_not be_able_to_parse(sample_rss_feed_burner_feed)
+      expect(Feedjira::Parser::ITunesRSS).to_not be_able_to_parse(sample_rss_feed_burner_feed)
     end
   end
 
@@ -25,38 +25,38 @@ describe Feedjira::Parser::ITunesRSS do
     end
 
     it "should parse the subtitle" do
-      @feed.itunes_subtitle.should == "A show about everything"
+      expect(@feed.itunes_subtitle).to eq "A show about everything"
     end
 
     it "should parse the author" do
-      @feed.itunes_author.should == "John Doe"
+      expect(@feed.itunes_author).to eq "John Doe"
     end
 
     it "should parse an owner" do
-      @feed.itunes_owners.size.should == 1
+      expect(@feed.itunes_owners.size).to eq 1
     end
 
     it "should parse an image" do
-      @feed.itunes_image.should == "http://example.com/podcasts/everything/AllAboutEverything.jpg"
+      expect(@feed.itunes_image).to eq "http://example.com/podcasts/everything/AllAboutEverything.jpg"
     end
 
     it "should parse categories" do
-      @feed.itunes_categories.size == 3
-      @feed.itunes_categories[0] == "Technology"
-      @feed.itunes_categories[1] == "Gadgets"
-      @feed.itunes_categories[2] == "TV & Film"
+      expect(@feed.itunes_categories.size).to eq 3
+      expect(@feed.itunes_categories[0]).to eq "Technology"
+      expect(@feed.itunes_categories[1]).to eq "Gadgets"
+      expect(@feed.itunes_categories[2]).to eq "TV & Film"
     end
 
     it "should parse the summary" do
-      @feed.itunes_summary.should == "All About Everything is a show about everything. Each week we dive into any subject known to man and talk about it as much as we can. Look for our Podcast in the iTunes Music Store"
+      expect(@feed.itunes_summary).to eq "All About Everything is a show about everything. Each week we dive into any subject known to man and talk about it as much as we can. Look for our Podcast in the iTunes Music Store"
     end
 
     it "should parse entries" do
-      @feed.entries.size.should == 3
+      expect(@feed.entries.size).to eq 3
     end
 
     it "should parse the new-feed-url" do
-      @feed.itunes_new_feed_url.should == "http://example.com/new.xml"
+      expect(@feed.itunes_new_feed_url).to eq "http://example.com/new.xml"
     end
   end
 end

data/spec/feedjira/parser/rss_entry_spec.rb

@@ -6,6 +6,7 @@ describe Feedjira::Parser::RSSEntry do
     # I don't really like doing it this way because these unit test should only rely on RSSEntry,
     # but this is actually how it should work. You would never just pass entry xml straight to the AtomEnry
     @entry = Feedjira::Parser::RSS.parse(sample_rss_feed).entries.first
+    Feedjira::Feed.add_common_feed_entry_element("wfw:commentRss", :as => :comment_rss)
   end
 
   after(:each) do
@@ -16,70 +17,64 @@ describe Feedjira::Parser::RSSEntry do
   end
 
   it "should parse the title" do
-    @entry.title.should == "Nokogiri’s Slop Feature"
+    expect(@entry.title).to eq "Nokogiri’s Slop Feature"
   end
 
   it "should parse the url" do
-    @entry.url.should == "http://tenderlovemaking.com/2008/12/04/nokogiris-slop-feature/"
+    expect(@entry.url).to eq "http://tenderlovemaking.com/2008/12/04/nokogiris-slop-feature/"
   end
 
   it "should parse the author" do
-    @entry.author.should == "Aaron Patterson"
+    expect(@entry.author).to eq "Aaron Patterson"
   end
 
   it "should parse the content" do
-    @entry.content.should == sample_rss_entry_content
+    expect(@entry.content).to eq sample_rss_entry_content
   end
 
   it "should provide a summary" do
-    @entry.summary.should == "Oops!  When I released nokogiri version 1.0.7, I totally forgot to talk about Nokogiri::Slop() feature that was added.  Why is it called \"slop\"?  It lets you sloppily explore documents.  Basically, it decorates your document with method_missing() that allows you to search your document via method calls.\nGiven this document:\n\ndoc = Nokogiri::Slop(<<-eohtml)\n<html>\n  <body>\n  [...]"
+    expect(@entry.summary).to eq "Oops!  When I released nokogiri version 1.0.7, I totally forgot to talk about Nokogiri::Slop() feature that was added.  Why is it called \"slop\"?  It lets you sloppily explore documents.  Basically, it decorates your document with method_missing() that allows you to search your document via method calls.\nGiven this document:\n\ndoc = Nokogiri::Slop(<<-eohtml)\n<html>\n  <body>\n  [...]"
   end
 
   it "should parse the published date" do
-    @entry.published.should == Time.parse_safely("Thu Dec 04 17:17:49 UTC 2008")
+    expect(@entry.published).to eq Time.parse_safely("Thu Dec 04 17:17:49 UTC 2008")
   end
 
   it "should parse the categories" do
-    @entry.categories.should == ['computadora', 'nokogiri', 'rails']
+    expect(@entry.categories).to eq ['computadora', 'nokogiri', 'rails']
   end
 
   it "should parse the guid as id" do
-    @entry.id.should == "http://tenderlovemaking.com/?p=198"
+    expect(@entry.id).to eq "http://tenderlovemaking.com/?p=198"
   end
 
   it "should support each" do
-    @entry.respond_to? :each
+    expect(@entry).to respond_to :each
   end
 
   it "should be able to list out all fields with each" do
     all_fields = []
-    @entry.each do |field, value|
-      all_fields << field
-    end
-    all_fields.sort == ['author', 'categories', 'content', 'id', 'published', 'summary', 'title', 'url']
-  end
-
-  it "should be able to list out all values with each" do
     title_value = ''
     @entry.each do |field, value|
+      all_fields << field
       title_value = value if field == 'title'
     end
-    title_value.should == "Nokogiri’s Slop Feature"
+    expect(all_fields.sort).to eq ["author", "categories", "comment_rss", "content", "entry_id", "published", "summary", "title", "url"]
+    expect(title_value).to eq "Nokogiri’s Slop Feature"
   end
 
   it "should support checking if a field exists in the entry" do
-    @entry.include?('title') && @entry.include?('author')
+    expect(@entry).to include 'title'
+    expect(@entry).to include 'author'
   end
 
   it "should allow access to fields with hash syntax" do
-    @entry['title'] == @entry.title
-    @entry['title'].should == "Nokogiri’s Slop Feature"
-    @entry['author'] == @entry.author
-    @entry['author'].should == "Aaron Patterson"
+    expect(@entry['title']).to eq "Nokogiri’s Slop Feature"
+    expect(@entry['author']).to eq "Aaron Patterson"
   end
 
   it "should allow setting field values with hash syntax" do
     @entry['title'] = "Foobar"
-    @entry.title.should == "Foobar"
+    expect(@entry.title).to eq "Foobar"
   end
 end

data/spec/feedjira/parser/rss_feed_burner_entry_spec.rb

@@ -6,6 +6,7 @@ describe Feedjira::Parser::RSSFeedBurnerEntry do
     # I don't really like doing it this way because these unit test should only rely on RSSEntry,
     # but this is actually how it should work. You would never just pass entry xml straight to the AtomEnry
     @entry = Feedjira::Parser::RSSFeedBurner.parse(sample_rss_feed_burner_feed).entries.first
+    Feedjira::Feed.add_common_feed_entry_element("wfw:commentRss", :as => :comment_rss)
   end
 
   after(:each) do
@@ -16,70 +17,64 @@ describe Feedjira::Parser::RSSFeedBurnerEntry do
   end
 
   it "should parse the title" do
-    @entry.title.should == "Angie’s List Sets Price Range IPO At $11 To $13 Per Share; Valued At Over $600M"
+    expect(@entry.title).to eq "Angie’s List Sets Price Range IPO At $11 To $13 Per Share; Valued At Over $600M"
   end
 
   it "should parse the original url" do
-    @entry.url.should == "http://techcrunch.com/2011/11/02/angies-list-prices-ipo-at-11-to-13-per-share-valued-at-over-600m/"
+    expect(@entry.url).to eq "http://techcrunch.com/2011/11/02/angies-list-prices-ipo-at-11-to-13-per-share-valued-at-over-600m/"
   end
 
   it "should parse the author" do
-    @entry.author.should == "Leena Rao"
+    expect(@entry.author).to eq "Leena Rao"
   end
 
   it "should parse the content" do
-    @entry.content.should == sample_rss_feed_burner_entry_content
+    expect(@entry.content).to eq sample_rss_feed_burner_entry_content
   end
 
   it "should provide a summary" do
-    @entry.summary.should == sample_rss_feed_burner_entry_description
+    expect(@entry.summary).to eq sample_rss_feed_burner_entry_description
   end
 
   it "should parse the published date" do
-    @entry.published.should == Time.parse_safely("Wed Nov 02 17:25:27 UTC 2011")
+    expect(@entry.published).to eq Time.parse_safely("Wed Nov 02 17:25:27 UTC 2011")
   end
 
   it "should parse the categories" do
-    @entry.categories.should == ["TC", "angie\\'s list"]
+    expect(@entry.categories).to eq ["TC", "angie\\'s list"]
   end
 
   it "should parse the guid as id" do
-    @entry.id.should == "http://techcrunch.com/?p=446154"
+    expect(@entry.id).to eq "http://techcrunch.com/?p=446154"
   end
 
   it "should support each" do
-    @entry.respond_to? :each
+    expect(@entry).to respond_to :each
   end
 
   it "should be able to list out all fields with each" do
     all_fields = []
-    @entry.each do |field, value|
-      all_fields << field
-    end
-    all_fields.sort == ['author', 'categories', 'content', 'id', 'published', 'summary', 'title', 'url']
-  end
-
-  it "should be able to list out all values with each" do
     title_value = ''
     @entry.each do |field, value|
+      all_fields << field
       title_value = value if field == 'title'
     end
-    title_value.should == "Angie’s List Sets Price Range IPO At $11 To $13 Per Share; Valued At Over $600M"
+    expect(all_fields.sort).to eq ["author", "categories", "comment_rss", "content", "entry_id", "image", "published", "summary", "title", "url"]
+    expect(title_value).to eq "Angie’s List Sets Price Range IPO At $11 To $13 Per Share; Valued At Over $600M"
   end
 
   it "should support checking if a field exists in the entry" do
-    @entry.include?('title') && @entry.include?('author')
+    expect(@entry).to include 'author'
+    expect(@entry).to include 'title'
   end
 
   it "should allow access to fields with hash syntax" do
-    @entry['title'] == @entry.title
-    @entry['title'].should == "Angie’s List Sets Price Range IPO At $11 To $13 Per Share; Valued At Over $600M"
-    @entry['author'] == @entry.author
-    @entry['author'].should == "Leena Rao"
+    expect(@entry['author']).to eq "Leena Rao"
+    expect(@entry['title']).to eq "Angie’s List Sets Price Range IPO At $11 To $13 Per Share; Valued At Over $600M"
   end
 
   it "should allow setting field values with hash syntax" do
     @entry['title'] = "Foobar"
-    @entry.title.should == "Foobar"
+    expect(@entry.title).to eq "Foobar"
   end
 end

data/spec/feedjira/parser/rss_feed_burner_spec.rb

@@ -3,23 +3,23 @@ require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
 describe Feedjira::Parser::RSSFeedBurner do
   describe "#will_parse?" do
     it "should return true for a feedburner rss feed" do
-      Feedjira::Parser::RSSFeedBurner.should be_able_to_parse(sample_rss_feed_burner_feed)
+      expect(Feedjira::Parser::RSSFeedBurner).to be_able_to_parse(sample_rss_feed_burner_feed)
     end
 
     it "should return false for a regular RSS feed" do
-       Feedjira::Parser::RSSFeedBurner.should_not be_able_to_parse(sample_rss_feed)
+       expect(Feedjira::Parser::RSSFeedBurner).to_not be_able_to_parse(sample_rss_feed)
      end
 
     it "should return false for a feedburner atom feed" do
-      Feedjira::Parser::RSSFeedBurner.should_not be_able_to_parse(sample_feedburner_atom_feed)
+      expect(Feedjira::Parser::RSSFeedBurner).to_not be_able_to_parse(sample_feedburner_atom_feed)
     end
 
     it "should return false for an rdf feed" do
-      Feedjira::Parser::RSSFeedBurner.should_not be_able_to_parse(sample_rdf_feed)
+      expect(Feedjira::Parser::RSSFeedBurner).to_not be_able_to_parse(sample_rdf_feed)
     end
 
     it "should return false for a regular atom feed" do
-      Feedjira::Parser::RSSFeedBurner.should_not be_able_to_parse(sample_atom_feed)
+      expect(Feedjira::Parser::RSSFeedBurner).to_not be_able_to_parse(sample_atom_feed)
     end
   end
 
@@ -29,29 +29,29 @@ describe Feedjira::Parser::RSSFeedBurner do
     end
 
     it "should parse the title" do
-      @feed.title.should == "TechCrunch"
+      expect(@feed.title).to eq "TechCrunch"
     end
 
     it "should parse the description" do
-      @feed.description.should == "TechCrunch is a group-edited blog that profiles the companies, products and events defining and transforming the new web."
+      expect(@feed.description).to eq "TechCrunch is a group-edited blog that profiles the companies, products and events defining and transforming the new web."
     end
 
     it "should parse the url" do
-      @feed.url.should == "http://techcrunch.com"
+      expect(@feed.url).to eq "http://techcrunch.com"
     end
 
     it "should parse the hub urls" do
-      @feed.hubs.count.should == 2
-      @feed.hubs.first.should == "http://pubsubhubbub.appspot.com/"
+      expect(@feed.hubs.count).to eq 2
+      expect(@feed.hubs.first).to eq "http://pubsubhubbub.appspot.com/"
     end
 
     it "should provide an accessor for the feed_url" do
-      @feed.respond_to?(:feed_url).should == true
-      @feed.respond_to?(:feed_url=).should == true
+      expect(@feed).to respond_to :feed_url
+      expect(@feed).to respond_to :feed_url=
     end
 
     it "should parse entries" do
-      @feed.entries.size.should == 20
+      expect(@feed.entries.size).to eq 20
     end
   end
 end

data/spec/feedjira/parser/rss_spec.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
 describe Feedjira::Parser::RSS do
   describe "#will_parse?" do
     it "should return true for an RSS feed" do
-      Feedjira::Parser::RSS.should be_able_to_parse(sample_rss_feed)
+      expect(Feedjira::Parser::RSS).to be_able_to_parse(sample_rss_feed)
     end
 
     # this is no longer true. combined rdf and rss into one
@@ -12,11 +12,11 @@ describe Feedjira::Parser::RSS do
     # end
 
     it "should return false for an atom feed" do
-      Feedjira::Parser::RSS.should_not be_able_to_parse(sample_atom_feed)
+      expect(Feedjira::Parser::RSS).to_not be_able_to_parse(sample_atom_feed)
     end
 
     it "should return false for an rss feedburner feed" do
-      Feedjira::Parser::RSS.should_not be_able_to_parse(sample_rss_feed_burner_feed)
+      expect(Feedjira::Parser::RSS).to_not be_able_to_parse(sample_rss_feed_burner_feed)
     end
   end
 
@@ -26,32 +26,32 @@ describe Feedjira::Parser::RSS do
     end
 
     it "should parse the version" do
-      @feed.version.should == "2.0"
+      expect(@feed.version).to eq "2.0"
     end
 
     it "should parse the title" do
-      @feed.title.should == "Tender Lovemaking"
+      expect(@feed.title).to eq "Tender Lovemaking"
     end
 
     it "should parse the description" do
-      @feed.description.should == "The act of making love, tenderly."
+      expect(@feed.description).to eq "The act of making love, tenderly."
     end
 
     it "should parse the url" do
-      @feed.url.should == "http://tenderlovemaking.com"
+      expect(@feed.url).to eq "http://tenderlovemaking.com"
     end
 
     it "should not parse hub urls" do
-      @feed.hubs.should == nil
+      expect(@feed.hubs).to be_nil
     end
 
     it "should provide an accessor for the feed_url" do
-      @feed.respond_to?(:feed_url).should == true
-      @feed.respond_to?(:feed_url=).should == true
+      expect(@feed).to respond_to :feed_url
+      expect(@feed).to respond_to :feed_url=
     end
 
     it "should parse entries" do
-      @feed.entries.size.should == 10
+      expect(@feed.entries.size).to eq 10
     end
   end
 end

data/spec/feedjira/preprocessor_spec.rb

@@ -7,13 +7,13 @@ describe Feedjira::Preprocessor do
     processor = Feedjira::Preprocessor.new xml
     escaped = processor.to_xml
 
-    escaped.should eq doc.to_xml
+    expect(escaped).to eq doc.to_xml
   end
 
   it 'escapes markup in xhtml content' do
     processor = Feedjira::Preprocessor.new sample_atom_xhtml_feed
     escaped = processor.to_xml
 
-    escaped.split("\n")[26].should match /<p>$/
+    expect(escaped.split("\n")[26]).to match /<p>$/
   end
 end

data/spec/sample_feeds/itunes.xml

@@ -19,7 +19,6 @@
 <itunes:image href="http://example.com/podcasts/everything/AllAboutEverything.jpg" />
 <itunes:category text="Technology">
 <itunes:category text="Gadgets"/>
-</itunes:category>
 <itunes:category text="TV &amp; Film"/>
  
 <item>

data/spec/spec_helper.rb

@@ -1,6 +1,8 @@
 require File.expand_path(File.dirname(__FILE__) + '/../lib/feedjira')
 require 'sample_feeds'
 
+SAXMachine.handler = ENV['HANDLER'].to_sym if ENV['HANDLER']
+
 RSpec.configure do |c|
   c.include SampleFeeds
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: feedjira
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Paul Dix
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-30 00:00:00.000000000 Z
+date: 2014-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sax-machine
@@ -19,56 +19,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: curb
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.1
+        version: '0.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.1
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: loofah
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.14.0
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.14.0
+        version: '3.0'
 description: A library designed to retrieve and parse feeds as quickly as possible
 email: feedjira@gmail.com
 executables: []
@@ -173,7 +173,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A feed fetching and parsing library