feedjira 2.0.0 → 2.1.0

data/lib/feedjira/parser/rss_image.rb

@@ -0,0 +1,15 @@
+module Feedjira
+  module Parser
+    # Parser for dealing with RSS images
+    class RSSImage
+      include SAXMachine
+
+      element :description
+      element :height
+      element :link
+      element :title
+      element :url
+      element :width
+    end
+  end
+end

data/lib/feedjira/preprocessor.rb

@@ -18,11 +18,11 @@ module Feedjira
     end
 
     def content_nodes
-      doc.search 'entry > content[type="xhtml"], entry > summary[type="xhtml"], entry > title[type="xhtml"]'
+      doc.search 'entry > content[type="xhtml"], entry > summary[type="xhtml"], entry > title[type="xhtml"]' # rubocop:disable Metrics/LineLength
     end
 
     def raw_html(node)
-      CGI.unescape_html node.search('./div').inner_html
+      node.search('./div').inner_html
     end
 
     def doc

data/lib/feedjira/version.rb

@@ -1,3 +1,3 @@
 module Feedjira
-  VERSION = '2.0.0'
+  VERSION = '2.1.0'.freeze
 end

data/spec/feedjira/date_time_utilities_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Feedjira::FeedUtilities do
+  before(:each) do
+    @klass = Class.new do
+      include Feedjira::DateTimeUtilities
+    end
+  end
+
+  describe 'handling dates' do
+    it 'should parse an ISO 8601 formatted datetime into Time' do
+      time = @klass.new.parse_datetime('2008-02-20T8:05:00-010:00')
+      expect(time.class).to eq Time
+      expect(time).to eq Time.parse_safely('Wed Feb 20 18:05:00 UTC 2008')
+    end
+
+    it 'should parse a ISO 8601 with milliseconds into Time' do
+      time = @klass.new.parse_datetime('2013-09-17T08:20:13.931-04:00')
+      expect(time.class).to eq Time
+      expect(time).to eq Time.parse_safely('Tue Sep 17 12:20:13 UTC 2013')
+    end
+
+    it 'should parse a US Format into Time' do
+      time = @klass.new.parse_datetime('8/23/2016 12:29:58 PM')
+      expect(time.class).to eq Time
+      expect(time).to eq Time.parse_safely('Wed Aug 23 12:29:58 UTC 2016')
+    end
+
+    it 'should parse a Spanish Format into Time' do
+      time = @klass.new.parse_datetime('Wed, 31 Ago 2016 11:08:22 GMT')
+      expect(time.class).to eq Time
+      expect(time).to eq Time.parse_safely('Wed Aug 31 11:08:22 UTC 2016')
+    end
+
+    it 'should parse Format with japanese symbols into Time' do
+      time = @klass.new.parse_datetime('水, 31 8 2016 07:37:00 PDT')
+      expect(time.class).to eq Time
+      expect(time).to eq Time.parse_safely('Wed Aug 31 14:37:00 UTC 2016')
+    end
+  end
+end

data/spec/feedjira/feed_entry_utilities_spec.rb

@@ -7,21 +7,21 @@ describe Feedjira::FeedUtilities do
     end
   end
 
-  describe "handling dates" do
-    it "should parse an ISO 8601 formatted datetime into Time" do
-      time = @klass.new.parse_datetime("2008-02-20T8:05:00-010:00")
+  describe 'handling dates' do
+    it 'should parse an ISO 8601 formatted datetime into Time' do
+      time = @klass.new.parse_datetime('2008-02-20T8:05:00-010:00')
       expect(time.class).to eq Time
-      expect(time).to eq Time.parse_safely("Wed Feb 20 18:05:00 UTC 2008")
+      expect(time).to eq Time.parse_safely('Wed Feb 20 18:05:00 UTC 2008')
     end
 
-    it "should parse a ISO 8601 with milliseconds into Time" do
-      time = @klass.new.parse_datetime("2013-09-17T08:20:13.931-04:00")
+    it 'should parse a ISO 8601 with milliseconds into Time' do
+      time = @klass.new.parse_datetime('2013-09-17T08:20:13.931-04:00')
       expect(time.class).to eq Time
-      expect(time).to eq Time.parse_safely("Tue Sep 17 12:20:13 UTC 2013")
+      expect(time).to eq Time.parse_safely('Tue Sep 17 12:20:13 UTC 2013')
     end
   end
 
-  describe "sanitizing" do
+  describe 'sanitizing' do
     before(:each) do
       @feed = Feedjira::Feed.parse(sample_atom_feed)
       @entry = @feed.entries.first
@@ -31,23 +31,27 @@ describe Feedjira::FeedUtilities do
       expect { @klass.new.sanitize! }.to_not raise_error
     end
 
-    it "should provide a sanitized title" do
-      new_title = "<script>this is not safe</script>" + @entry.title
+    it 'should provide a sanitized title' do
+      new_title = '<script>this is not safe</script>' + @entry.title
       @entry.title = new_title
-      expect(@entry.title.sanitize).to eq Loofah.scrub_fragment(new_title, :prune).to_s
+      scrubbed_title = Loofah.scrub_fragment(new_title, :prune).to_s
+      expect(@entry.title.sanitize).to eq scrubbed_title
     end
 
-    it "should sanitize content in place" do
-      new_content = "<script>" + @entry.content
+    it 'should sanitize content in place' do
+      new_content = '<script>' + @entry.content
       @entry.content = new_content.dup
-      expect(@entry.content.sanitize!).to eq Loofah.scrub_fragment(new_content, :prune).to_s
-      expect(@entry.content).to eq Loofah.scrub_fragment(new_content, :prune).to_s
+
+      scrubbed_content = Loofah.scrub_fragment(new_content, :prune).to_s
+
+      expect(@entry.content.sanitize!).to eq scrubbed_content
+      expect(@entry.content).to eq scrubbed_content
     end
 
-    it "should sanitize things in place" do
-      @entry.title   += "<script>"
-      @entry.author  += "<script>"
-      @entry.content += "<script>"
+    it 'should sanitize things in place' do
+      @entry.title   += '<script>'
+      @entry.author  += '<script>'
+      @entry.content += '<script>'
 
       cleaned_title   = Loofah.scrub_fragment(@entry.title, :prune).to_s
       cleaned_author  = Loofah.scrub_fragment(@entry.author, :prune).to_s

data/spec/feedjira/feed_spec.rb

@@ -1,4 +1,6 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
+
+# rubocop:disable Style/BlockDelimiters
 
 class Hell < StandardError; end
 
@@ -11,63 +13,72 @@ end
 describe Feedjira::Feed do
   describe '.fetch_and_parse' do
     it 'raises an error when the fetch fails' do
-      url = 'http://www.example.com/feed.xml'
-      expect {
-        Feedjira::Feed.fetch_and_parse url
-      }.to raise_error Feedjira::FetchFailure
+      VCR.use_cassette('fetch_failure') do
+        url = 'http://www.example.com/feed.xml'
+        expect {
+          Feedjira::Feed.fetch_and_parse url
+        }.to raise_error Feedjira::FetchFailure
+      end
     end
 
     it 'raises an error when no parser can be found' do
-      url = 'http://feedjira.com'
-      expect {
-        Feedjira::Feed.fetch_and_parse url
-      }.to raise_error Feedjira::NoParserAvailable
+      VCR.use_cassette('parse_error') do
+        url = 'http://feedjira.com'
+        expect {
+          Feedjira::Feed.fetch_and_parse url
+        }.to raise_error Feedjira::NoParserAvailable
+      end
     end
 
     it 'fetches and parses the feed' do
-      url = 'http://feedjira.com/blog/feed.xml'
-      feed = Feedjira::Feed.fetch_and_parse url
-
-      expect(feed.class).to eq Feedjira::Parser::Atom
-      expect(feed.entries.count).to eq 3
-      expect(feed.feed_url).to eq url
-      expect(feed.etag).to eq 'a22ad-3190-5037e71966e80'
-      expect(feed.last_modified).to eq 'Sat, 20 Sep 2014 12:34:50 GMT'
+      VCR.use_cassette('success') do
+        url = 'http://feedjira.com/blog/feed.xml'
+        expected_time = DateTime.parse('Fri, 07 Oct 2016 14:37:00 GMT').to_time
+        feed = Feedjira::Feed.fetch_and_parse url
+
+        expect(feed.class).to eq Feedjira::Parser::Atom
+        expect(feed.entries.count).to eq 4
+        expect(feed.feed_url).to eq url
+        expect(feed.etag).to eq('393e-53e4757c9db00-gzip')
+        expect(feed.last_modified).to eq(expected_time)
+      end
     end
   end
 
-  describe "#add_common_feed_element" do
+  describe '#add_common_feed_element' do
     before(:all) do
-      Feedjira::Feed.add_common_feed_element("generator")
+      Feedjira::Feed.add_common_feed_element('generator')
     end
 
-    it "should parse the added element out of Atom feeds" do
-      expect(Feedjira::Feed.parse(sample_wfw_feed).generator).to eq "TypePad"
+    it 'should parse the added element out of Atom feeds' do
+      expect(Feedjira::Feed.parse(sample_wfw_feed).generator).to eq 'TypePad'
     end
 
-    it "should parse the added element out of Atom Feedburner feeds" do
+    it 'should parse the added element out of Atom Feedburner feeds' do
       expect(Feedjira::Parser::Atom.new).to respond_to(:generator)
     end
 
-    it "should parse the added element out of RSS feeds" do
+    it 'should parse the added element out of RSS feeds' do
       expect(Feedjira::Parser::RSS.new).to respond_to(:generator)
     end
   end
 
-  describe "#add_common_feed_entry_element" do
+  describe '#add_common_feed_entry_element' do
     before(:all) do
-      Feedjira::Feed.add_common_feed_entry_element("wfw:commentRss", :as => :comment_rss)
+      tag = 'wfw:commentRss'
+      Feedjira::Feed.add_common_feed_entry_element tag, as: :comment_rss
     end
 
-    it "should parse the added element out of Atom feeds entries" do
-      expect(Feedjira::Feed.parse(sample_wfw_feed).entries.first.comment_rss).to eq "this is the new val"
+    it 'should parse the added element out of Atom feeds entries' do
+      entry = Feedjira::Feed.parse(sample_wfw_feed).entries.first
+      expect(entry.comment_rss).to eq 'this is the new val'
     end
 
-    it "should parse the added element out of Atom Feedburner feeds entries" do
+    it 'should parse the added element out of Atom Feedburner feeds entries' do
       expect(Feedjira::Parser::AtomEntry.new).to respond_to(:comment_rss)
     end
 
-    it "should parse the added element out of RSS feeds entries" do
+    it 'should parse the added element out of RSS feeds entries' do
       expect(Feedjira::Parser::RSSEntry.new).to respond_to(:comment_rss)
     end
   end
@@ -92,107 +103,131 @@ describe Feedjira::Feed do
     end
   end
 
-  describe "#parse" do # many of these tests are redundant with the specific feed type tests, but I put them here for completeness
+  describe '#parse' do
     context "when there's an available parser" do
-      it "should parse an rdf feed" do
+      it 'should parse an rdf feed' do
         feed = Feedjira::Feed.parse(sample_rdf_feed)
-        expect(feed.title).to eq "HREF Considered Harmful"
-        expect(feed.entries.first.published).to eq Time.parse_safely("Tue Sep 02 19:50:07 UTC 2008")
+        expect(feed.title).to eq 'HREF Considered Harmful'
+        published = Time.parse_safely('Tue Sep 02 19:50:07 UTC 2008')
+        expect(feed.entries.first.published).to eq published
         expect(feed.entries.size).to eq 10
       end
 
-      it "should parse an rss feed" do
+      it 'should parse an rss feed' do
         feed = Feedjira::Feed.parse(sample_rss_feed)
-        expect(feed.title).to eq "Tender Lovemaking"
-        expect(feed.entries.first.published).to eq Time.parse_safely("Thu Dec 04 17:17:49 UTC 2008")
+        expect(feed.title).to eq 'Tender Lovemaking'
+        published = Time.parse_safely 'Thu Dec 04 17:17:49 UTC 2008'
+        expect(feed.entries.first.published).to eq published
         expect(feed.entries.size).to eq 10
       end
 
-      it "should parse an atom feed" do
+      it 'should parse an atom feed' do
         feed = Feedjira::Feed.parse(sample_atom_feed)
-        expect(feed.title).to eq "Amazon Web Services Blog"
-        expect(feed.entries.first.published).to eq Time.parse_safely("Fri Jan 16 18:21:00 UTC 2009")
+        expect(feed.title).to eq 'Amazon Web Services Blog'
+        published = Time.parse_safely 'Fri Jan 16 18:21:00 UTC 2009'
+        expect(feed.entries.first.published).to eq published
         expect(feed.entries.size).to eq 10
       end
 
-      it "should parse an feedburner atom feed" do
+      it 'should parse an feedburner atom feed' do
         feed = Feedjira::Feed.parse(sample_feedburner_atom_feed)
-        expect(feed.title).to eq "Paul Dix Explains Nothing"
-        expect(feed.entries.first.published).to eq Time.parse_safely("Thu Jan 22 15:50:22 UTC 2009")
+        expect(feed.title).to eq 'Paul Dix Explains Nothing'
+        published = Time.parse_safely 'Thu Jan 22 15:50:22 UTC 2009'
+        expect(feed.entries.first.published).to eq published
         expect(feed.entries.size).to eq 5
       end
 
-      it "should parse an itunes feed" do
+      it 'should parse an itunes feed' do
         feed = Feedjira::Feed.parse(sample_itunes_feed)
-        expect(feed.title).to eq "All About Everything"
-        expect(feed.entries.first.published).to eq Time.parse_safely("Wed, 15 Jun 2005 19:00:00 GMT")
+        expect(feed.title).to eq 'All About Everything'
+        published = Time.parse_safely 'Wed, 15 Jun 2005 19:00:00 GMT'
+        expect(feed.entries.first.published).to eq published
         expect(feed.entries.size).to eq 3
       end
     end
 
     context "when there's no available parser" do
-      it "raises Feedjira::NoParserAvailable" do
+      it 'raises Feedjira::NoParserAvailable' do
         expect {
           Feedjira::Feed.parse("I'm an invalid feed")
         }.to raise_error(Feedjira::NoParserAvailable)
       end
     end
 
-    it "should parse an feedburner rss feed" do
+    it 'should parse an feedburner rss feed' do
       feed = Feedjira::Feed.parse(sample_rss_feed_burner_feed)
-      expect(feed.title).to eq "TechCrunch"
-      expect(feed.entries.first.published).to eq Time.parse_safely("Wed Nov 02 17:25:27 UTC 2011")
+      expect(feed.title).to eq 'TechCrunch'
+      published = Time.parse_safely 'Wed Nov 02 17:25:27 UTC 2011'
+      expect(feed.entries.first.published).to eq published
       expect(feed.entries.size).to eq 20
     end
   end
 
-  describe "#determine_feed_parser_for_xml" do
-    it 'should return the Feedjira::Parser::GoogleDocsAtom calss for a Google Docs atom feed' do
-      expect(Feedjira::Feed.determine_feed_parser_for_xml(sample_google_docs_list_feed)).to eq Feedjira::Parser::GoogleDocsAtom
+  describe '#determine_feed_parser_for_xml' do
+    it 'with Google Docs atom feed it returns the GoogleDocsAtom parser' do
+      xml = sample_google_docs_list_feed
+      actual_parser = Feedjira::Feed.determine_feed_parser_for_xml xml
+      expect(actual_parser).to eq Feedjira::Parser::GoogleDocsAtom
     end
 
-    it "should return the expect(Feedjira::Parser::Atom class for an atom feed" do
-      expect(Feedjira::Feed.determine_feed_parser_for_xml(sample_atom_feed)).to eq Feedjira::Parser::Atom
+    it 'with an atom feed it returns the Atom parser' do
+      xml = sample_atom_feed
+      actual_parser = Feedjira::Feed.determine_feed_parser_for_xml xml
+      expect(actual_parser).to eq Feedjira::Parser::Atom
     end
 
-    it "should return the expect(Feedjira::Parser::AtomFeedBurner class for an atom feedburner feed" do
-      expect(Feedjira::Feed.determine_feed_parser_for_xml(sample_feedburner_atom_feed)).to eq Feedjira::Parser::AtomFeedBurner
+    it 'with an atom feedburner feed it returns the AtomFeedBurner parser' do
+      xml = sample_feedburner_atom_feed
+      actual_parser = Feedjira::Feed.determine_feed_parser_for_xml xml
+      expect(actual_parser).to eq Feedjira::Parser::AtomFeedBurner
     end
 
-    it "should return the expect(Feedjira::Parser::RSS class for an rdf/rss 1.0 feed" do
-      expect(Feedjira::Feed.determine_feed_parser_for_xml(sample_rdf_feed)).to eq Feedjira::Parser::RSS
+    it 'with an rdf feed it returns the RSS parser' do
+      xml = sample_rdf_feed
+      actual_parser = Feedjira::Feed.determine_feed_parser_for_xml xml
+      expect(actual_parser).to eq Feedjira::Parser::RSS
     end
 
-    it "should return the expect(Feedjira::Parser::RSSFeedBurner class for an rss feedburner feed" do
-      expect(Feedjira::Feed.determine_feed_parser_for_xml(sample_rss_feed_burner_feed)).to eq Feedjira::Parser::RSSFeedBurner
+    it 'with an rss feedburner feed it returns the RSSFeedBurner parser' do
+      xml = sample_rss_feed_burner_feed
+      actual_parser = Feedjira::Feed.determine_feed_parser_for_xml xml
+      expect(actual_parser).to eq Feedjira::Parser::RSSFeedBurner
     end
 
-    it "should return the expect(Feedjira::Parser::RSS object for an rss 2.0 feed" do
-      expect(Feedjira::Feed.determine_feed_parser_for_xml(sample_rss_feed)).to eq Feedjira::Parser::RSS
+    it 'with an rss 2.0 feed it returns the RSS parser' do
+      xml = sample_rss_feed
+      actual_parser = Feedjira::Feed.determine_feed_parser_for_xml xml
+      expect(actual_parser).to eq Feedjira::Parser::RSS
     end
 
-    it "should return a expect(Feedjira::Parser::RSS object for an itunes feed" do
-      expect(Feedjira::Feed.determine_feed_parser_for_xml(sample_itunes_feed)).to eq Feedjira::Parser::ITunesRSS
+    it 'with an itunes feed it returns the RSS parser' do
+      xml = sample_itunes_feed
+      actual_parser = Feedjira::Feed.determine_feed_parser_for_xml xml
+      expect(actual_parser).to eq Feedjira::Parser::ITunesRSS
     end
-
   end
 
-  describe "when adding feed types" do
-    it "should prioritize added types over the built in ones" do
-      feed_text = "Atom asdf"
+  describe 'when adding feed types' do
+    it 'should prioritize added types over the built in ones' do
+      xml = 'Atom asdf'
       allow(Feedjira::Parser::Atom).to receive(:able_to_parse?).and_return(true)
-      new_feed_type = Class.new do
-        def self.able_to_parse?(val)
+      new_parser = Class.new do
+        def self.able_to_parse?(_)
           true
         end
       end
 
-      expect(new_feed_type).to be_able_to_parse(feed_text)
-      Feedjira::Feed.add_feed_class(new_feed_type)
-      expect(Feedjira::Feed.determine_feed_parser_for_xml(feed_text)).to eq new_feed_type
+      expect(new_parser).to be_able_to_parse(xml)
+
+      Feedjira::Feed.add_feed_class(new_parser)
+
+      parser = Feedjira::Feed.determine_feed_parser_for_xml xml
+      expect(parser).to eq new_parser
 
       # this is a hack so that this doesn't break the rest of the tests
-      Feedjira::Feed.feed_classes.reject! {|o| o == new_feed_type }
+      Feedjira::Feed.feed_classes.reject! { |o| o == new_parser }
     end
   end
 end
+
+# rubocop:enable Style/BlockDelimiters

data/spec/feedjira/feed_utilities_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
 describe Feedjira::FeedUtilities do
   before(:each) do
@@ -8,47 +8,46 @@ describe Feedjira::FeedUtilities do
     end
   end
 
-  describe "preprocessing" do
-    context "when the flag is not set" do
-      it "does not call the preprocessing method" do
+  describe 'preprocessing' do
+    context 'when the flag is not set' do
+      it 'does not call the preprocessing method' do
         @klass.preprocess_xml = false
         expect(@klass).to_not receive :preprocess
         @klass.parse sample_rss_feed
       end
     end
 
-    context "when the flag is set" do
-      it "calls the preprocessing method" do
+    context 'when the flag is set' do
+      it 'calls the preprocessing method' do
         @klass.preprocess_xml = true
-        expect(@klass).to receive(:preprocess).
-          and_return sample_rss_feed
+        expect(@klass).to receive(:preprocess).and_return sample_rss_feed
         @klass.parse sample_rss_feed
       end
     end
   end
 
-  describe "instance methods" do
-    it "should provide an updated? accessor" do
+  describe 'instance methods' do
+    it 'should provide an updated? accessor' do
       feed = @klass.new
       expect(feed).to_not be_updated
       feed.updated = true
       expect(feed).to be_updated
     end
 
-    it "should provide a new_entries accessor" do
+    it 'should provide a new_entries accessor' do
       feed = @klass.new
       expect(feed.new_entries).to eq []
       feed.new_entries = [:foo]
       expect(feed.new_entries).to eq [:foo]
     end
 
-    it "should provide an etag accessor" do
+    it 'should provide an etag accessor' do
       feed = @klass.new
-      feed.etag = "foo"
-      expect(feed.etag).to eq "foo"
+      feed.etag = 'foo'
+      expect(feed.etag).to eq 'foo'
     end
 
-    it "should provide a last_modified accessor" do
+    it 'should provide a last_modified accessor' do
       feed = @klass.new
       time = Time.now
       feed.last_modified = time
@@ -56,21 +55,21 @@ describe Feedjira::FeedUtilities do
       expect(feed.last_modified.class).to eq Time
     end
 
-    it "should return new_entries? as true when entries are put into new_entries" do
+    it 'should return new_entries? as true when entries are put into new_entries' do # rubocop:disable Metrics/LineLength
       feed = @klass.new
       feed.new_entries << :foo
-      expect(feed).to have_new_entries
+      expect(feed.new_entries?).to eq true
     end
 
-    it "should return a last_modified value from the entry with the most recent published date if the last_modified date hasn't been set" do
+    it "should return a last_modified value from the entry with the most recent published date if the last_modified date hasn't been set" do # rubocop:disable Metrics/LineLength
       feed = Feedjira::Parser::Atom.new
-      entry =Feedjira::Parser::AtomEntry.new
+      entry = Feedjira::Parser::AtomEntry.new
       entry.published = Time.now.to_s
       feed.entries << entry
       expect(feed.last_modified).to eq entry.published
     end
 
-    it "should not throw an error if one of the entries has published date of nil" do
+    it 'should not throw an error if one of the entries has published date of nil' do # rubocop:disable Metrics/LineLength
       feed = Feedjira::Parser::Atom.new
       entry = Feedjira::Parser::AtomEntry.new
       entry.published = Time.now.to_s
@@ -80,122 +79,125 @@ describe Feedjira::FeedUtilities do
     end
   end
 
-  describe "#update_from_feed" do
-    describe "updating feed attributes" do
+  describe '#update_from_feed' do
+    describe 'updating feed attributes' do
       before(:each) do
-        # I'm using the Atom class when I know I should be using a different one. However, this update_from_feed
-        # method would only be called against a feed item.
+        # I'm using the Atom class when I know I should be using a different
+        # one. However, this update_from_feed method would only be called
+        # against a feed item.
         @feed = Feedjira::Parser::Atom.new
-        @feed.title    = "A title"
-        @feed.url      = "http://pauldix.net"
-        @feed.feed_url = "http://feeds.feedburner.com/PaulDixExplainsNothing"
+        @feed.title    = 'A title'
+        @feed.url      = 'http://pauldix.net'
+        @feed.feed_url = 'http://feeds.feedburner.com/PaulDixExplainsNothing'
         @feed.updated  = false
         @updated_feed = @feed.dup
       end
 
-      it "should update the title if changed" do
-        @updated_feed.title = "new title"
+      it 'should update the title if changed' do
+        @updated_feed.title = 'new title'
         @feed.update_from_feed(@updated_feed)
         expect(@feed.title).to eq @updated_feed.title
         expect(@feed).to be_updated
       end
 
-      it "should not update the title if the same" do
+      it 'should not update the title if the same' do
         @feed.update_from_feed(@updated_feed)
         expect(@feed).to_not be_updated
       end
 
-      it "should update the feed_url if changed" do
-        @updated_feed.feed_url = "a new feed url"
+      it 'should update the feed_url if changed' do
+        @updated_feed.feed_url = 'a new feed url'
         @feed.update_from_feed(@updated_feed)
         expect(@feed.feed_url).to eq @updated_feed.feed_url
         expect(@feed).to be_updated
       end
 
-      it "should not update the feed_url if the same" do
+      it 'should not update the feed_url if the same' do
         @feed.update_from_feed(@updated_feed)
         expect(@feed).to_not be_updated
       end
 
-      it "should update the url if changed" do
-        @updated_feed.url = "a new url"
+      it 'should update the url if changed' do
+        @updated_feed.url = 'a new url'
         @feed.update_from_feed(@updated_feed)
         expect(@feed.url).to eq @updated_feed.url
       end
 
-      it "should not update the url if not changed" do
+      it 'should not update the url if not changed' do
         @feed.update_from_feed(@updated_feed)
         expect(@feed).to_not be_updated
       end
     end
 
-    describe "updating entries" do
+    describe 'updating entries' do
       before(:each) do
-        # I'm using the Atom class when I know I should be using a different one. However, this update_from_feed
-        # method would only be called against a feed item.
+        # I'm using the Atom class when I know I should be using a different
+        # one. However, this update_from_feed method would only be called
+        # against a feed item.
         @feed = Feedjira::Parser::Atom.new
-        @feed.title    = "A title"
-        @feed.url      = "http://pauldix.net"
-        @feed.feed_url = "http://feeds.feedburner.com/PaulDixExplainsNothing"
+        @feed.title    = 'A title'
+        @feed.url      = 'http://pauldix.net'
+        @feed.feed_url = 'http://feeds.feedburner.com/PaulDixExplainsNothing'
         @feed.updated  = false
         @updated_feed = @feed.dup
         @old_entry = Feedjira::Parser::AtomEntry.new
-        @old_entry.url = "http://pauldix.net/old.html"
+        @old_entry.url = 'http://pauldix.net/old.html'
         @old_entry.published = Time.now.to_s
-        @old_entry.entry_id = "entry_id_old"
+        @old_entry.entry_id = 'entry_id_old'
         @new_entry = Feedjira::Parser::AtomEntry.new
-        @new_entry.url = "http://pauldix.net/new.html"
+        @new_entry.url = 'http://pauldix.net/new.html'
         @new_entry.published = (Time.now + 10).to_s
-        @new_entry.entry_id = "entry_id_new"
+        @new_entry.entry_id = 'entry_id_new'
         @feed.entries << @old_entry
         @updated_feed.entries << @new_entry
         @updated_feed.entries << @old_entry
       end
 
-      it "should update last-modified from the latest entry date" do
+      it 'should update last-modified from the latest entry date' do
         @feed.update_from_feed(@updated_feed)
         expect(@feed.last_modified).to eq @new_entry.published
       end
 
-      it "should put new entries into new_entries" do
+      it 'should put new entries into new_entries' do
         @feed.update_from_feed(@updated_feed)
         expect(@feed.new_entries).to eq [@new_entry]
       end
 
-      it "should also put new entries into the entries collection" do
+      it 'should also put new entries into the entries collection' do
         @feed.update_from_feed(@updated_feed)
         expect(@feed.entries).to include(@new_entry)
         expect(@feed.entries).to include(@old_entry)
       end
     end
 
-    describe "#update_from_feed" do
+    describe '#update_from_feed' do
       let(:recent_entry_id) { 'entry_id' }
       let(:old_entry_id) { nil }
 
       before(:each) do
-        # I'm using the Atom class when I know I should be using a different one. However, this update_from_feed
-        # method would only be called against a feed item.
+        # I'm using the Atom class when I know I should be using a different
+        # one. However, this update_from_feed method would only be called
+        # against a feed item.
         @feed = Feedjira::Parser::Atom.new
-        @feed.title    = "A title"
-        @feed.url      = "http://pauldix.net"
-        @feed.feed_url = "http://feeds.feedburner.com/PaulDixExplainsNothing"
+        @feed.title    = 'A title'
+        @feed.url      = 'http://pauldix.net'
+        @feed.feed_url = 'http://feeds.feedburner.com/PaulDixExplainsNothing'
         @feed.updated  = false
         @updated_feed = @feed.dup
 
         @old_entry = Feedjira::Parser::AtomEntry.new
-        @old_entry.url = "http://pauldix.net/old.html"
+        @old_entry.url = 'http://pauldix.net/old.html'
         @old_entry.entry_id = old_entry_id
         @old_entry.published = (Time.now - 10).to_s
 
         @entry = Feedjira::Parser::AtomEntry.new
         @entry.published = (Time.now + 10).to_s
         @entry.entry_id = recent_entry_id
-        @entry.url = "http://pauldix.net/entry.html"
+        @entry.url = 'http://pauldix.net/entry.html'
 
         # only difference is a changed url
         @entry_changed_url = @entry.dup
-        @entry_changed_url.url = "http://pauldix.net/updated.html"
+        @entry_changed_url.url = 'http://pauldix.net/updated.html'
 
         # entry with changed url must be first
         @feed.entries << @entry
@@ -204,8 +206,8 @@ describe Feedjira::FeedUtilities do
         @updated_feed.entries << @old_entry
       end
 
-      context "changing the url of an existing entry" do
-        it "should not put the complete feed into new_entries" do
+      context 'changing the url of an existing entry' do
+        it 'should not put the complete feed into new_entries' do
           @feed.update_from_feed(@updated_feed)
           expect(@feed.new_entries).to_not include(@entry_changed_url)
           expect(@feed.new_entries).to_not include(@old_entry)
@@ -214,11 +216,11 @@ describe Feedjira::FeedUtilities do
         end
       end
 
-      context "feed not have entry id and only difference is a url" do
+      context 'feed not have entry id and only difference is a url' do
         let(:recent_entry_id) { nil }
         let(:old_entry_id) { nil }
 
-        it "should put the complete feed into new_entries" do
+        it 'should put the complete feed into new_entries' do
           @feed.update_from_feed(@updated_feed)
           expect(@feed.new_entries).to include(@entry_changed_url)
           expect(@feed.new_entries).to include(@old_entry)
@@ -242,7 +244,7 @@ describe Feedjira::FeedUtilities do
       let(:feed_two) { double 'Feed Two', entries: [entry_two] }
 
       before do
-        stub_const("Feedjira::FeedUtilities::UPDATABLE_ATTRIBUTES", [])
+        stub_const('Feedjira::FeedUtilities::UPDATABLE_ATTRIBUTES', [])
         feed_one.entries << entry_one
       end