feedjira 2.0.0 → 2.2.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/parser.rb

@@ -1 +1 @@
-module Feedjira::Parser; end
+module Feedjira::Parser; end # rubocop:disable Style/Documentation

data/lib/feedjira/preprocessor.rb

@@ -1,3 +1,5 @@
+# rubocop:disable Style/Documentation
+# rubocop:disable Style/DocumentationMethod
 module Feedjira
   class Preprocessor
     def initialize(xml)
@@ -18,11 +20,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.2.0'.freeze
 end

data/lib/feedjira.rb

@@ -3,13 +3,21 @@ require 'faraday'
 require 'faraday_middleware'
 require 'sax-machine'
 require 'loofah'
+require 'logger'
 
 require 'feedjira/core_ext'
+require 'feedjira/configuration'
+require 'feedjira/date_time_utilities/date_time_epoch_parser'
+require 'feedjira/date_time_utilities/date_time_language_parser'
+require 'feedjira/date_time_utilities/date_time_pattern_parser'
+require 'feedjira/date_time_utilities'
+require 'feedjira/date_time_utilities'
 require 'feedjira/feed_entry_utilities'
 require 'feedjira/feed_utilities'
 require 'feedjira/feed'
 require 'feedjira/parser'
 require 'feedjira/parser/rss_entry'
+require 'feedjira/parser/rss_image'
 require 'feedjira/parser/rss'
 require 'feedjira/parser/atom_entry'
 require 'feedjira/parser/atom'
@@ -18,15 +26,22 @@ require 'feedjira/version'
 
 require 'feedjira/parser/rss_feed_burner_entry'
 require 'feedjira/parser/rss_feed_burner'
+require 'feedjira/parser/podlove_chapter'
 require 'feedjira/parser/itunes_rss_owner'
+require 'feedjira/parser/itunes_rss_category'
 require 'feedjira/parser/itunes_rss_item'
 require 'feedjira/parser/itunes_rss'
 require 'feedjira/parser/atom_feed_burner_entry'
 require 'feedjira/parser/atom_feed_burner'
 require 'feedjira/parser/google_docs_atom_entry'
 require 'feedjira/parser/google_docs_atom'
+require 'feedjira/parser/atom_youtube_entry'
+require 'feedjira/parser/atom_youtube'
 
+# Feedjira
 module Feedjira
   class NoParserAvailable < StandardError; end
   class FetchFailure < StandardError; end
+
+  extend Configuration
 end

data/spec/feedjira/configuration_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+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
+
+    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')
+    end
+  end
+end

data/spec/feedjira/date_time_utilities_spec.rb

@@ -0,0 +1,47 @@
+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
+
+    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')
+    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,161 @@ 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
+
+      # 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
+      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)
 
-      # 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 }
+      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