feedjira 2.2.0 → 3.1.2

data/lib/feedjira/parser/rss_image.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Feedjira
   module Parser
     # Parser for dealing with RSS images

data/lib/feedjira/preprocessor.rb

@@ -1,5 +1,5 @@
-# rubocop:disable Style/Documentation
-# rubocop:disable Style/DocumentationMethod
+# frozen_string_literal: true
+
 module Feedjira
   class Preprocessor
     def initialize(xml)
@@ -20,11 +20,11 @@ module Feedjira
     end
 
     def content_nodes
-      doc.search 'entry > content[type="xhtml"], entry > summary[type="xhtml"], entry > title[type="xhtml"]' # rubocop:disable Metrics/LineLength
+      doc.search 'entry > content[type="xhtml"], entry > summary[type="xhtml"], entry > title[type="xhtml"]'
     end
 
     def raw_html(node)
-      node.search('./div').inner_html
+      node.search("./div").inner_html
     end
 
     def doc

data/lib/feedjira/rss_entry_utilities.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Feedjira
+  module RSSEntryUtilities
+    def self.included(mod)
+      mod.class_exec do
+        element :title
+
+        element :"content:encoded", as: :content
+        element :"a10:content", as: :content
+        element :description, as: :summary
+
+        element :link, as: :url
+        element :"a10:link", as: :url, value: :href
+
+        element :author
+        element :"dc:creator", as: :author
+        element :"a10:name", as: :author
+
+        element :pubDate, as: :published
+        element :pubdate, as: :published
+        element :issued, as: :published
+        element :"dc:date", as: :published
+        element :"dc:Date", as: :published
+        element :"dcterms:created", as: :published
+
+        element :"dcterms:modified", as: :updated
+        element :"a10:updated", as: :updated
+
+        element :guid, as: :entry_id, class: Feedjira::Parser::GloballyUniqueIdentifier
+        element :"dc:identifier", as: :dc_identifier
+
+        element :"media:thumbnail", as: :image, value: :url
+        element :"media:content", as: :image, value: :url
+        element :enclosure, as: :image, value: :url
+
+        elements :category, as: :categories
+      end
+    end
+
+    def entry_id
+      @entry_id&.guid
+    end
+
+    def url
+      @url || @entry_id&.url
+    end
+
+    def id
+      entry_id || @dc_identifier || @url
+    end
+  end
+end

data/lib/feedjira/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Feedjira
-  VERSION = '2.2.0'.freeze
+  VERSION = "3.1.2"
 end

data/spec/feedjira/configuration_spec.rb

@@ -1,25 +1,20 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe Feedjira::Configuration do
-  describe '.configure' do
-    it 'sets follow_redirect_limit config' do
-      Feedjira.configure { |config| config.follow_redirect_limit = 10 }
-      expect(Feedjira.follow_redirect_limit).to eq(10)
-    end
-
-    it 'sets request_timeout config' do
-      Feedjira.configure { |config| config.request_timeout = 45 }
-      expect(Feedjira.request_timeout).to eq(45)
-    end
+require "spec_helper"
 
-    it 'sets strip_whitespace config' do
+describe Feedjira::Configuration do
+  describe ".configure" do
+    it "sets strip_whitespace config" do
       Feedjira.configure { |config| config.strip_whitespace = true }
       expect(Feedjira.strip_whitespace).to be true
     end
 
-    it 'sets user_agent config' do
-      Feedjira.configure { |config| config.user_agent = 'Test User Agent' }
-      expect(Feedjira.user_agent).to eq('Test User Agent')
+    it "allows parsers to be modified" do
+      CustomParser = Class.new
+
+      Feedjira.configure { |config| config.parsers.unshift(CustomParser) }
+      expect(Feedjira.parsers.first).to eq(CustomParser)
+      Feedjira.reset_configuration!
     end
   end
 end

data/spec/feedjira/date_time_utilities_spec.rb

@@ -1,4 +1,6 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe Feedjira::FeedUtilities do
   before(:each) do
@@ -7,41 +9,41 @@ 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
 
-    it 'should parse a US Format into Time' do
-      time = @klass.new.parse_datetime('8/23/2016 12:29:58 PM')
+    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')
+      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')
+    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')
+      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')
+    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')
+      expect(time).to eq Time.parse_safely("Wed Aug 31 14:37:00 UTC 2016")
     end
 
-    it 'should parse epoch into Time' do
-      time = @klass.new.parse_datetime('1472654220')
+    it "should parse epoch into Time" do
+      time = @klass.new.parse_datetime("1472654220")
       expect(time.class).to eq Time
-      expect(time).to eq Time.parse_safely('Wed Aug 31 14:37:00 UTC 2016')
+      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

@@ -1,4 +1,6 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe Feedjira::FeedUtilities do
   before(:each) do
@@ -7,23 +9,23 @@ 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)
+      @feed = Feedjira.parse(sample_atom_feed)
       @entry = @feed.entries.first
     end
 
@@ -31,15 +33,15 @@ 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
       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
 
       scrubbed_content = Loofah.scrub_fragment(new_content, :prune).to_s
@@ -48,10 +50,10 @@ describe Feedjira::FeedUtilities do
       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,263 +1,51 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-# rubocop:disable Style/BlockDelimiters
+require "spec_helper"
 
 class Hell < StandardError; end
 
 class FailParser
-  def self.parse(_, &on_failure)
-    on_failure.call 'this parser always fails.'
+  def self.parse(_xml, &on_failure)
+    on_failure.call "this parser always fails."
   end
 end
 
 describe Feedjira::Feed do
-  describe '.fetch_and_parse' do
-    it 'raises an error when the fetch fails' do
-      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
-      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
-      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.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
-      tag = 'wfw:commentRss'
+      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
-      entry = Feedjira::Feed.parse(sample_wfw_feed).entries.first
-      expect(entry.comment_rss).to eq 'this is the new val'
+    it "should parse the added element out of Atom feeds entries" do
+      entry = Feedjira.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
-
-  describe '#parse_with' do
-    let(:xml) { '<xml></xml>' }
-
-    it 'invokes the parser and passes the xml' do
-      parser = double 'Parser', parse: nil
-      expect(parser).to receive(:parse).with xml
-      Feedjira::Feed.parse_with parser, xml
-    end
-
-    context 'with a callback block' do
-      it 'passes the callback to the parser' do
-        callback = ->(*) { raise Hell }
-
-        expect do
-          Feedjira::Feed.parse_with FailParser, xml, &callback
-        end.to raise_error Hell
-      end
-    end
-  end
-
-  describe '#parse' do
-    context "when there's an available parser" do
-      it 'should parse an rdf feed' do
-        feed = Feedjira::Feed.parse(sample_rdf_feed)
-        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
-        feed = Feedjira::Feed.parse(sample_rss_feed)
-        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
-        feed = Feedjira::Feed.parse(sample_atom_feed)
-        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
-        feed = Feedjira::Feed.parse(sample_feedburner_atom_feed)
-        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
-        feed = Feedjira::Feed.parse(sample_itunes_feed)
-        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
-
-      # rubocop:disable Metrics/LineLength
-      it 'does not fail if multiple published dates exist and some are unparseable' do
-        expect(Feedjira.logger).to receive(:warn).once
-
-        feed = Feedjira::Feed.parse(sample_invalid_date_format_feed)
-        expect(feed.title).to eq 'Invalid date format feed'
-        published = Time.parse_safely 'Mon, 16 Oct 2017 15:10:00 GMT'
-        expect(feed.entries.first.published).to eq published
-        expect(feed.entries.size).to eq 2
-      end
-      # rubocop:enable Metrics/LineLength
-    end
-
-    context "when there's no available parser" 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
-      feed = Feedjira::Feed.parse(sample_rss_feed_burner_feed)
-      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 '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 '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 '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 '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 '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 '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 '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
-      xml = 'Atom asdf'
-      allow(Feedjira::Parser::Atom).to receive(:able_to_parse?).and_return(true)
-      new_parser = Class.new do
-        def self.able_to_parse?(_)
-          true
-        end
-      end
-
-      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
-
-      Feedjira::Feed.reset_parsers!
-    end
-  end
-
-  describe 'when parsers are configured' do
-    it 'does not use default parsers' do
-      xml = 'Atom asdf'
-      new_parser = Class.new do
-        def self.able_to_parse?(_)
-          true
-        end
-      end
-
-      Feedjira.configure { |config| config.parsers = [new_parser] }
-
-      parser = Feedjira::Feed.determine_feed_parser_for_xml(xml)
-      expect(parser).to eq(new_parser)
-
-      Feedjira.reset_configuration!
-      Feedjira::Feed.reset_parsers!
-    end
-  end
 end
-
-# rubocop:enable Style/BlockDelimiters