feedjira 2.0.0 → 2.2.0

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,64 @@ 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 'strip whitespace' do
+    context 'strip_whitespace config is true' do
+      it 'strips all XML whitespace' do
+        Feedjira.configure { |config| config.strip_whitespace = true }
+
+        expect(@klass.strip_whitespace("\nfoobar\n")).to eq('foobar')
+
+        Feedjira.configure { |config| config.strip_whitespace = false }
+      end
+    end
+
+    context 'strip_whitespace config is false' do
+      it 'lstrips XML whitespace' do
+        expect(@klass.strip_whitespace("\nfoobar\n")).to eq("foobar\n")
+      end
+    end
+  end
+
+  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 +73,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 +97,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 +224,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 +234,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 +262,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
 

data/spec/feedjira/parser/atom_entry_spec.rb

@@ -1,58 +1,64 @@
-require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+require 'spec_helper'
 
 describe Feedjira::Parser::AtomEntry do
   before(:each) do
-    # I don't really like doing it this way because these unit test should only rely on AtomEntry,
-    # but this is actually how it should work. You would never just pass entry xml straight to the AtomEnry
+    # I don't really like doing it this way because these unit test should only
+    # rely on AtomEntry, but this is actually how it should work. You would
+    # never just pass entry xml straight to the AtomEnry
     @entry = Feedjira::Parser::Atom.parse(sample_atom_feed).entries.first
   end
 
-  it "should parse the title" do
-    expect(@entry.title).to eq "AWS Job: Architect & Designer Position in Turkey"
+  it 'should parse the title' do
+    title = 'AWS Job: Architect & Designer Position in Turkey'
+    expect(@entry.title).to eq title
   end
 
-  it "should parse the url" do
-    expect(@entry.url).to eq "http://aws.typepad.com/aws/2009/01/aws-job-architect-designer-position-in-turkey.html"
+  it 'should parse the url' do
+    expect(@entry.url).to eq 'http://aws.typepad.com/aws/2009/01/aws-job-architect-designer-position-in-turkey.html'
   end
 
-  it "should parse the url even when" do
-    entries = Feedjira::Parser::Atom.parse(load_sample("atom_with_link_tag_for_url_unmarked.xml")).entries
-    expect(entries.first.url).to eq "http://www.innoq.com/blog/phaus/2009/07/ja.html"
+  it 'should parse the url even when' do
+    xml = load_sample('atom_with_link_tag_for_url_unmarked.xml')
+    entries = Feedjira::Parser::Atom.parse(xml).entries
+    expect(entries.first.url).to eq 'http://www.innoq.com/blog/phaus/2009/07/ja.html'
   end
 
-  it "should parse the author" do
-    expect(@entry.author).to eq "AWS Editor"
+  it 'should parse the author' do
+    expect(@entry.author).to eq 'AWS Editor'
   end
 
-  it "should parse the content" do
+  it 'should parse the content' do
     expect(@entry.content).to eq sample_atom_entry_content
   end
 
-  it "should provide a summary" do
-    expect(@entry.summary).to eq "Late last year an entrepreneur from Turkey visited me at Amazon HQ in Seattle. We talked about his plans to use AWS as part of his new social video portal startup. I won't spill any beans before he's ready to..."
+  it 'should provide a summary' do
+    summary = "Late last year an entrepreneur from Turkey visited me at Amazon HQ in Seattle. We talked about his plans to use AWS as part of his new social video portal startup. I won't spill any beans before he's ready to..." # rubocop:disable Metrics/LineLength
+    expect(@entry.summary).to eq summary
   end
 
-  it "should parse the published date" do
-    expect(@entry.published).to eq Time.parse_safely("Fri Jan 16 18:21:00 UTC 2009")
+  it 'should parse the published date' do
+    published = Time.parse_safely 'Fri Jan 16 18:21:00 UTC 2009'
+    expect(@entry.published).to eq published
   end
 
-  it "should parse the categories" do
-    expect(@entry.categories).to eq ['Turkey', 'Seattle']
+  it 'should parse the categories' do
+    expect(@entry.categories).to eq %w(Turkey Seattle)
   end
 
-  it "should parse the updated date" do
-    expect(@entry.updated).to eq Time.parse_safely("Fri Jan 16 18:21:00 UTC 2009")
+  it 'should parse the updated date' do
+    updated = Time.parse_safely 'Fri Jan 16 18:21:00 UTC 2009'
+    expect(@entry.updated).to eq updated
   end
 
-  it "should parse the id" do
-    expect(@entry.id).to eq "tag:typepad.com,2003:post-61484736"
+  it 'should parse the id' do
+    expect(@entry.id).to eq 'tag:typepad.com,2003:post-61484736'
   end
 
-  it "should support each" do
+  it 'should support each' do
     expect(@entry).to respond_to :each
   end
 
-  it "should be able to list out all fields with each" do
+  it 'should be able to list out all fields with each' do
     all_fields = []
     title_value = ''
 
@@ -61,22 +67,36 @@ describe Feedjira::Parser::AtomEntry do
       title_value = value if field == 'title'
     end
 
-    expect(all_fields.sort).to eq ["author", "categories", "content", "entry_id", "links", "published", "summary", "title", "updated", "url"]
-    expect(title_value).to eq "AWS Job: Architect & Designer Position in Turkey"
+    expect(title_value).to eq 'AWS Job: Architect & Designer Position in Turkey'
+
+    expected_fields = %w(
+      author
+      categories
+      content
+      entry_id
+      links
+      published
+      summary
+      title
+      updated
+      url
+    )
+    expect(all_fields.sort).to eq expected_fields
   end
 
-  it "should support checking if a field exists in the entry" do
+  it 'should support checking if a field exists in the entry' do
     expect(@entry).to include 'author'
     expect(@entry).to include 'title'
   end
 
-  it "should allow access to fields with hash syntax" do
-    expect(@entry['title']).to eq "AWS Job: Architect & Designer Position in Turkey"
-    expect(@entry['author']).to eq "AWS Editor"
+  it 'should allow access to fields with hash syntax' do
+    title = 'AWS Job: Architect & Designer Position in Turkey'
+    expect(@entry['title']).to eq title
+    expect(@entry['author']).to eq 'AWS Editor'
   end
 
-  it "should allow setting field values with hash syntax" do
-    @entry['title'] = "Foobar"
-    expect(@entry.title).to eq "Foobar"
+  it 'should allow setting field values with hash syntax' do
+    @entry['title'] = 'Foobar'
+    expect(@entry.title).to eq 'Foobar'
   end
 end

data/spec/feedjira/parser/atom_feed_burner_entry_spec.rb

@@ -1,47 +1,54 @@
-require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+require 'spec_helper'
 
 describe Feedjira::Parser::AtomFeedBurnerEntry do
   before(:each) do
-    # I don't really like doing it this way because these unit test should only rely on AtomEntry,
-    # but this is actually how it should work. You would never just pass entry xml straight to the AtomEnry
-    @entry = Feedjira::Parser::AtomFeedBurner.parse(sample_feedburner_atom_feed).entries.first
+    Feedjira::Parser::AtomFeedBurner.preprocess_xml = false
+    # I don't really like doing it this way because these unit test should only
+    # rely on AtomEntry, but this is actually how it should work. You would
+    # never just pass entry xml straight to the AtomEnry
+    feed = Feedjira::Parser::AtomFeedBurner.parse sample_feedburner_atom_feed
+    @entry = feed.entries.first
   end
 
-  it "should parse the title" do
-    expect(@entry.title).to eq "Making a Ruby C library even faster"
+  it 'should parse the title' do
+    expect(@entry.title).to eq 'Making a Ruby C library even faster'
   end
 
-  it "should be able to fetch a url via the 'alternate' rel if no origLink exists" do
-    entry = Feedjira::Parser::AtomFeedBurner.parse(File.read("#{File.dirname(__FILE__)}/../../sample_feeds/PaulDixExplainsNothingAlternate.xml")).entries.first
+  it "should be able to fetch a url via the 'alternate' rel if no origLink exists" do # rubocop:disable Metrics/LineLength
+    xml = File.read("#{File.dirname(__FILE__)}/../../sample_feeds/PaulDixExplainsNothingAlternate.xml") # rubocop:disable Metrics/LineLength
+    entry = Feedjira::Parser::AtomFeedBurner.parse(xml).entries.first
     expect(entry.url).to eq 'http://feeds.feedburner.com/~r/PaulDixExplainsNothing/~3/519925023/making-a-ruby-c-library-even-faster.html'
   end
 
-  it "should parse the url" do
-    expect(@entry.url).to eq "http://www.pauldix.net/2009/01/making-a-ruby-c-library-even-faster.html"
+  it 'should parse the url' do
+    expect(@entry.url).to eq 'http://www.pauldix.net/2009/01/making-a-ruby-c-library-even-faster.html'
   end
 
-  it "should parse the url when there is no alternate" do
-    entry = Feedjira::Parser::AtomFeedBurner.parse(File.read("#{File.dirname(__FILE__)}/../../sample_feeds/FeedBurnerUrlNoAlternate.xml")).entries.first
+  it 'should parse the url when there is no alternate' do
+    xml = File.read("#{File.dirname(__FILE__)}/../../sample_feeds/FeedBurnerUrlNoAlternate.xml") # rubocop:disable Metrics/LineLength
+    entry = Feedjira::Parser::AtomFeedBurner.parse(xml).entries.first
     expect(entry.url).to eq 'http://example.com/QQQQ.html'
   end
 
-  it "should parse the author" do
-    expect(@entry.author).to eq "Paul Dix"
+  it 'should parse the author' do
+    expect(@entry.author).to eq 'Paul Dix'
   end
 
-  it "should parse the content" do
+  it 'should parse the content' do
     expect(@entry.content).to eq sample_feedburner_atom_entry_content
   end
 
-  it "should provide a summary" do
-    expect(@entry.summary).to eq "Last week I released the first version of a SAX based XML parsing library called SAX-Machine. It uses Nokogiri, which uses libxml, so it's pretty fast. However, I felt that it could be even faster. The only question was how..."
+  it 'should provide a summary' do
+    summary = "Last week I released the first version of a SAX based XML parsing library called SAX-Machine. It uses Nokogiri, which uses libxml, so it's pretty fast. However, I felt that it could be even faster. The only question was how..." # rubocop:disable Metrics/LineLength
+    expect(@entry.summary).to eq summary
   end
 
-  it "should parse the published date" do
-    expect(@entry.published).to eq Time.parse_safely("Thu Jan 22 15:50:22 UTC 2009")
+  it 'should parse the published date' do
+    published = Time.parse_safely 'Thu Jan 22 15:50:22 UTC 2009'
+    expect(@entry.published).to eq published
   end
 
-  it "should parse the categories" do
+  it 'should parse the categories' do
     expect(@entry.categories).to eq ['Ruby', 'Another Category']
   end
 end