feedjira 2.0.0 → 2.1.0

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

data/spec/feedjira/parser/atom_feed_burner_spec.rb

@@ -1,67 +1,69 @@
-require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+require 'spec_helper'
 
-describe Feedjira::Parser::AtomFeedBurner do
-  describe "#will_parse?" do
-    it "should return true for a feedburner atom feed" do
-      expect(Feedjira::Parser::AtomFeedBurner).to be_able_to_parse(sample_feedburner_atom_feed)
+module Feedjira::Parser
+  describe '#will_parse?' do
+    it 'should return true for a feedburner atom feed' do
+      expect(AtomFeedBurner).to be_able_to_parse(sample_feedburner_atom_feed)
     end
 
-    it "should return false for an rdf feed" do
-      expect(Feedjira::Parser::AtomFeedBurner).to_not be_able_to_parse(sample_rdf_feed)
+    it 'should return false for an rdf feed' do
+      expect(AtomFeedBurner).to_not be_able_to_parse(sample_rdf_feed)
     end
 
-    it "should return false for a regular atom feed" do
-      expect(Feedjira::Parser::AtomFeedBurner).to_not be_able_to_parse(sample_atom_feed)
+    it 'should return false for a regular atom feed' do
+      expect(AtomFeedBurner).to_not be_able_to_parse(sample_atom_feed)
     end
 
-    it "should return false for an rss feedburner feed" do
-      expect(Feedjira::Parser::AtomFeedBurner).to_not be_able_to_parse(sample_rss_feed_burner_feed)
+    it 'should return false for an rss feedburner feed' do
+      expect(AtomFeedBurner).to_not be_able_to_parse sample_rss_feed_burner_feed
     end
   end
 
-  describe "parsing" do
+  describe 'parsing' do
     before(:each) do
-      @feed = Feedjira::Parser::AtomFeedBurner.parse(sample_feedburner_atom_feed)
+      @feed = AtomFeedBurner.parse(sample_feedburner_atom_feed)
     end
 
-    it "should parse the title" do
-      expect(@feed.title).to eq "Paul Dix Explains Nothing"
+    it 'should parse the title' do
+      expect(@feed.title).to eq 'Paul Dix Explains Nothing'
     end
 
-    it "should parse the description" do
-      expect(@feed.description).to eq "Entrepreneurship, programming, software development, politics, NYC, and random thoughts."
+    it 'should parse the description' do
+      description = 'Entrepreneurship, programming, software development, politics, NYC, and random thoughts.' # rubocop:disable Metrics/LineLength
+      expect(@feed.description).to eq description
     end
 
-    it "should parse the url" do
-      expect(@feed.url).to eq "http://www.pauldix.net/"
+    it 'should parse the url' do
+      expect(@feed.url).to eq 'http://www.pauldix.net/'
     end
 
-    it "should parse the feed_url" do
-      expect(@feed.feed_url).to eq "http://feeds.feedburner.com/PaulDixExplainsNothing"
+    it 'should parse the feed_url' do
+      expect(@feed.feed_url).to eq 'http://feeds.feedburner.com/PaulDixExplainsNothing'
     end
 
-    it "should parse no hub urls" do
+    it 'should parse no hub urls' do
       expect(@feed.hubs.count).to eq 0
     end
 
-    it "should parse hub urls" do
-      feed_with_hub = Feedjira::Parser::AtomFeedBurner.parse(load_sample("TypePadNews.xml"))
+    it 'should parse hub urls' do
+      AtomFeedBurner.preprocess_xml = false
+      feed_with_hub = AtomFeedBurner.parse(load_sample('TypePadNews.xml'))
       expect(feed_with_hub.hubs.count).to eq 1
     end
 
-    it "should parse entries" do
+    it 'should parse entries' do
       expect(@feed.entries.size).to eq 5
     end
   end
 
-  describe "preprocessing" do
-    it "retains markup in xhtml content" do
-      Feedjira::Parser::AtomFeedBurner.preprocess_xml = true
+  describe 'preprocessing' do
+    it 'retains markup in xhtml content' do
+      AtomFeedBurner.preprocess_xml = true
 
-      feed = Feedjira::Parser::AtomFeedBurner.parse sample_feed_burner_atom_xhtml_feed
+      feed = AtomFeedBurner.parse sample_feed_burner_atom_xhtml_feed
       entry = feed.entries.first
 
-      expect(entry.content).to match /\A\<p/
+      expect(entry.content).to match(/\A\<p/)
     end
   end
 end

data/spec/feedjira/parser/atom_spec.rb

@@ -1,102 +1,104 @@
-require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+require 'spec_helper'
 
-describe Feedjira::Parser::Atom do
-  describe "#will_parse?" do
-    it "should return true for an atom feed" do
-      expect(Feedjira::Parser::Atom).to be_able_to_parse(sample_atom_feed)
+module Feedjira::Parser
+  describe '#will_parse?' do
+    it 'should return true for an atom feed' do
+      expect(Atom).to be_able_to_parse(sample_atom_feed)
     end
 
-    it "should return false for an rdf feed" do
-      expect(Feedjira::Parser::Atom).to_not be_able_to_parse(sample_rdf_feed)
+    it 'should return false for an rdf feed' do
+      expect(Atom).to_not be_able_to_parse(sample_rdf_feed)
     end
 
-    it "should return false for an rss feedburner feed" do
-      expect(Feedjira::Parser::Atom).to_not be_able_to_parse(sample_rss_feed_burner_feed)
+    it 'should return false for an rss feedburner feed' do
+      expect(Atom).to_not be_able_to_parse(sample_rss_feed_burner_feed)
     end
 
-    it "should return true for an atom feed that has line breaks in between attributes in the <feed> node" do
-      expect(Feedjira::Parser::Atom).to be_able_to_parse(sample_atom_feed_line_breaks)
+    it 'should return true for an atom feed that has line breaks in between attributes in the <feed> node' do # rubocop:disable Metrics/LineLength
+      expect(Atom).to be_able_to_parse(sample_atom_feed_line_breaks)
     end
   end
 
-  describe "parsing" do
+  describe 'parsing' do
     before(:each) do
-      @feed = Feedjira::Parser::Atom.parse(sample_atom_feed)
+      @feed = Atom.parse(sample_atom_feed)
     end
 
-    it "should parse the title" do
-      expect(@feed.title).to eq "Amazon Web Services Blog"
+    it 'should parse the title' do
+      expect(@feed.title).to eq 'Amazon Web Services Blog'
     end
 
-    it "should parse the description" do
-      expect(@feed.description).to eq "Amazon Web Services, Products, Tools, and Developer Information..."
+    it 'should parse the description' do
+      description = 'Amazon Web Services, Products, Tools, and Developer Information...' # rubocop:disable Metrics/LineLength
+      expect(@feed.description).to eq description
     end
 
-    it "should parse the url" do
-      expect(@feed.url).to eq "http://aws.typepad.com/aws/"
+    it 'should parse the url' do
+      expect(@feed.url).to eq 'http://aws.typepad.com/aws/'
     end
 
-    it "should parse the url even when it doesn't have the type='text/html' attribute" do
-      feed = Feedjira::Parser::Atom.parse(load_sample("atom_with_link_tag_for_url_unmarked.xml"))
-      expect(feed.url).to eq "http://www.innoq.com/planet/"
+    it "should parse the url even when it doesn't have the type='text/html' attribute" do # rubocop:disable Metrics/LineLength
+      xml = load_sample 'atom_with_link_tag_for_url_unmarked.xml'
+      feed = Atom.parse xml
+      expect(feed.url).to eq 'http://www.innoq.com/planet/'
     end
 
-    it "should parse the feed_url even when it doesn't have the type='application/atom+xml' attribute" do
-      feed = Feedjira::Parser::Atom.parse(load_sample("atom_with_link_tag_for_url_unmarked.xml"))
-      expect(feed.feed_url).to eq "http://www.innoq.com/planet/atom.xml"
+    it "should parse the feed_url even when it doesn't have the type='application/atom+xml' attribute" do # rubocop:disable Metrics/LineLength
+      feed = Atom.parse(load_sample('atom_with_link_tag_for_url_unmarked.xml'))
+      expect(feed.feed_url).to eq 'http://www.innoq.com/planet/atom.xml'
     end
 
-    it "should parse the feed_url" do
-      expect(@feed.feed_url).to eq "http://aws.typepad.com/aws/atom.xml"
+    it 'should parse the feed_url' do
+      expect(@feed.feed_url).to eq 'http://aws.typepad.com/aws/atom.xml'
     end
 
-    it "should parse no hub urls" do
+    it 'should parse no hub urls' do
       expect(@feed.hubs.count).to eq 0
     end
 
-    it "should parse the hub urls" do
-      feed_with_hub = Feedjira::Parser::Atom.parse(load_sample("SamRuby.xml"))
+    it 'should parse the hub urls' do
+      feed_with_hub = Atom.parse(load_sample('SamRuby.xml'))
       expect(feed_with_hub.hubs.count).to eq 1
-      expect(feed_with_hub.hubs.first).to eq "http://pubsubhubbub.appspot.com/"
+      expect(feed_with_hub.hubs.first).to eq 'http://pubsubhubbub.appspot.com/'
     end
 
-    it "should parse entries" do
+    it 'should parse entries' do
       expect(@feed.entries.size).to eq 10
     end
   end
 
-  describe "preprocessing" do
-    it "retains markup in xhtml content" do
-      Feedjira::Parser::Atom.preprocess_xml = true
+  describe 'preprocessing' do
+    it 'retains markup in xhtml content' do
+      Atom.preprocess_xml = true
 
-      feed = Feedjira::Parser::Atom.parse sample_atom_xhtml_feed
+      feed = Atom.parse sample_atom_xhtml_feed
       entry = feed.entries.first
 
-      expect(entry.title).to match /\<i/
-      expect(entry.summary).to match /\<b/
-      expect(entry.content).to match /\A\<p/
+      expect(entry.title).to match(/\<i/)
+      expect(entry.summary).to match(/\<b/)
+      expect(entry.content).to match(/\A\<p/)
     end
 
-    it "should not duplicate content when there are divs in content" do
-      Feedjira::Parser::Atom.preprocess_xml = true
+    it 'should not duplicate content when there are divs in content' do
+      Atom.preprocess_xml = true
 
-      feed = Feedjira::Parser::Atom.parse sample_duplicate_content_atom_feed
+      feed = Atom.parse sample_duplicate_content_atom_feed
       content = Nokogiri::HTML(feed.entries[1].content)
       expect(content.css('img').length).to eq 11
     end
   end
 
-  describe "parsing url and feed url based on rel attribute" do
+  describe 'parsing url and feed url based on rel attribute' do
     before :each do
-      @feed = Feedjira::Parser::Atom.parse(sample_atom_middleman_feed)
+      @feed = Atom.parse(sample_atom_middleman_feed)
     end
 
-    it "should parse url" do
-      expect(@feed.url).to eq "http://feedjira.com/blog"
+    it 'should parse url' do
+      expect(@feed.url).to eq 'http://feedjira.com/blog'
     end
 
-    it "should parse feed url" do
-      expect(@feed.feed_url).to eq "http://feedjira.com/blog/feed.xml"
+    it 'should parse feed url' do
+      expect(@feed.feed_url).to eq 'http://feedjira.com/blog/feed.xml'
     end
   end
 end