feedjira 1.6.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56dba4b7304c841ff2e72ab32bd84cf6ee0343b6
-  data.tar.gz: 6e9d913bca548ba6686b6a93eda55429bff17e15
+  metadata.gz: a75fe90b3327d3110c7ba5e5ebe8acdbfc9e4c10
+  data.tar.gz: d4313aca74f021751d583f61c140a18aea2381b7
 SHA512:
-  metadata.gz: 5713f551eea78fd7d0f5f2ea538caa502aa39e518079593f50ba863425fbb81257b4fdd6ac416109b8fd5ef5a04c433d27423870a8d7dccf048496952b88a345
-  data.tar.gz: 05240d42fc374ec2b559d54de8a9d603efbdc155d60eb70d9505789348e88977dce7c48628374e70a464a4cc7c2e6185b7e241af3a0d01d1df93b62dc639f696
+  metadata.gz: 4004f548a5b6a3215294d5b8ebd81496c4603eaab3ba3c2f1b269815010fcbdc12cef8660a10ddd398159a09cb30443131e9c83b6973bf9cad9a746d78728c29
+  data.tar.gz: f426881efa2533cdef5bb34eb0ff57bc86259abfd26eb916fadc79dea1b30f4b95262ffc53d1539494fc306a845b4b68cd35377d79d41bcfd73976a8387fa12d

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Feedjira Changelog
 
+## 2.0.0
+
+* General
+  * Replaced curb with faraday
+  * Removed update funcionality
+
 ## 1.6.0
 
 * Enhancements

data/feedjira.gemspec

@@ -19,9 +19,10 @@ Gem::Specification.new do |s|
 
   s.platform = Gem::Platform::RUBY
 
-  s.add_dependency 'sax-machine', '~> 1.0'
-  s.add_dependency 'curb',        '~> 0.8'
-  s.add_dependency 'loofah',      '~> 2.0'
+  s.add_dependency 'sax-machine',        '~> 1.0'
+  s.add_dependency 'faraday',            '~> 0.9'
+  s.add_dependency 'faraday_middleware', '~> 0.9'
+  s.add_dependency 'loofah',             '~> 2.0'
 
   s.add_development_dependency 'rspec', '~> 3.0'
 end

data/lib/feedjira.rb

@@ -1,5 +1,6 @@
 require 'zlib'
-require 'curb'
+require 'faraday'
+require 'faraday_middleware'
 require 'sax-machine'
 require 'loofah'
 
@@ -27,4 +28,5 @@ require 'feedjira/parser/google_docs_atom'
 
 module Feedjira
   class NoParserAvailable < StandardError; end
+  class FetchFailure < StandardError; end
 end

data/lib/feedjira/feed.rb

@@ -1,32 +1,9 @@
 module Feedjira
   class Feed
-    USER_AGENT = 'feedjira http://feedjira.com'
-
-    # Passes raw XML and callbacks to a parser.
-    # === Parameters
-    # [parser<Object>] The parser to pass arguments to - must respond to
-    # `parse` and should return a Feed object.
-    # [xml<String>] The XML that you would like parsed.
-    # === Returns
-    # An instance of the parser feed type.
     def self.parse_with(parser, xml, &block)
       parser.parse xml, &block
     end
 
-    # Takes a raw XML feed and attempts to parse it. If no parser is available a Feedjira::NoParserAvailable exception is raised.
-    # You can pass a block to be called when there's an error during the parsing.
-    # === Parameters
-    # [xml<String>] The XML that you would like parsed.
-    # === Returns
-    # An instance of the determined feed type. By default, one of these:
-    # * Feedjira::Parser::RSSFeedBurner
-    # * Feedjira::Parser::GoogleDocsAtom
-    # * Feedjira::Parser::AtomFeedBurner
-    # * Feedjira::Parser::Atom
-    # * Feedjira::Parser::ITunesRSS
-    # * Feedjira::Parser::RSS
-    # === Raises
-    # Feedjira::NoParserAvailable : If no valid parser classes could be found for the feed.
     def self.parse(xml, &block)
       if parser = determine_feed_parser_for_xml(xml)
         parse_with parser, xml, &block
@@ -35,31 +12,15 @@ module Feedjira
       end
     end
 
-    # Determines the correct parser class to use for parsing the feed.
-    #
-    # === Parameters
-    # [xml<String>] The XML that you would like determine the parser for.
-    # === Returns
-    # The class name of the parser that can handle the XML.
     def self.determine_feed_parser_for_xml(xml)
       start_of_doc = xml.slice(0, 2000)
       feed_classes.detect {|klass| klass.able_to_parse?(start_of_doc)}
     end
 
-    # Adds a new feed parsing class that will be used for parsing.
-    #
-    # === Parameters
-    # [klass<Constant>] The class/constant that you want to register.
-    # === Returns
-    # A updated array of feed parser class names.
     def self.add_feed_class(klass)
       feed_classes.unshift klass
     end
 
-    # Provides a list of registered feed parsing classes.
-    #
-    # === Returns
-    # A array of class names.
     def self.feed_classes
       @feed_classes ||= [
         Feedjira::Parser::RSSFeedBurner,
@@ -71,61 +32,29 @@ module Feedjira
       ]
     end
 
-    # Makes all registered feeds types look for the passed in element to parse.
-    # This is actually just a call to element (a SAXMachine call) in the class.
-    #
-    # === Parameters
-    # [element_tag<String>] The element tag
-    # [options<Hash>] Valid keys are same as with SAXMachine
     def self.add_common_feed_element(element_tag, options = {})
       feed_classes.each do |k|
         k.element element_tag, options
       end
     end
 
-    # Makes all registered feeds types look for the passed in elements to parse.
-    # This is actually just a call to elements (a SAXMachine call) in the class.
-    #
-    # === Parameters
-    # [element_tag<String>] The element tag
-    # [options<Hash>] Valid keys are same as with SAXMachine
     def self.add_common_feed_elements(element_tag, options = {})
       feed_classes.each do |k|
         k.elements element_tag, options
       end
     end
 
-    # Makes all registered entry types look for the passed in element to parse.
-    # This is actually just a call to element (a SAXMachine call) in the class.
-    #
-    # === Parameters
-    # [element_tag<String>]
-    # [options<Hash>] Valid keys are same as with SAXMachine
     def self.add_common_feed_entry_element(element_tag, options = {})
       call_on_each_feed_entry :element, element_tag, options
     end
 
-    # Makes all registered entry types look for the passed in elements to parse.
-    # This is actually just a call to element (a SAXMachine call) in the class.
-    #
-    # === Parameters
-    # [element_tag<String>]
-    # [options<Hash>] Valid keys are same as with SAXMachine
     def self.add_common_feed_entry_elements(element_tag, options = {})
       call_on_each_feed_entry :elements, element_tag, options
     end
 
-    # Call a method on all feed entries classes.
-    #
-    # === Parameters
-    # [method<Symbol>] The method name
-    # [parameters<Array>] The method parameters
     def self.call_on_each_feed_entry(method, *parameters)
       feed_classes.each do |k|
-        # iterate on the collections defined in the sax collection
         k.sax_config.collection_elements.each_value do |vl|
-          # vl is a list of CollectionConfig mapped to an attribute name
-          # we'll look for the one set as 'entries' and add the new element
           vl.find_all{|v| (v.accessor == 'entries') && (v.data_class.class == Class)}.each do |v|
               v.data_class.send(method, *parameters)
           end
@@ -133,325 +62,24 @@ module Feedjira
       end
     end
 
-    # Setup curl from options.
-    # Possible parameters:
-    # * :user_agent          - overrides the default user agent.
-    # * :language            - accept language value.
-    # * :compress            - any value to enable compression
-    # * :enable_cookies      - boolean
-    # * :cookiefile          - file to read cookies
-    # * :cookies             - contents of cookies header
-    # * :http_authentication - array containing username, then password
-    # * :proxy_url           - proxy url
-    # * :proxy_port          - proxy port
-    # * :max_redirects       - max number of redirections
-    # * :timeout             - timeout
-    # * :ssl_verify_host     - boolean
-    # * :ssl_verify_peer     - boolean
-    # * :ssl_version         - the ssl version to use, see OpenSSL::SSL::SSLContext::METHODS for options
-    def self.setup_easy(curl, options={})
-      curl.headers["Accept-encoding"]   = 'gzip, deflate' if options.has_key?(:compress)
-      curl.headers["User-Agent"]        = (options[:user_agent] || USER_AGENT)
-      curl.headers["Accept-Language"]   = options[:language] if options.has_key?(:language)
-      curl.enable_cookies               = options[:enable_cookies] if options.has_key?(:enable_cookies)
-      curl.cookiefile                   = options[:cookiefile] if options.has_key?(:cookiefile)
-      curl.cookies                      = options[:cookies] if options.has_key?(:cookies)
-
-      curl.userpwd = options[:http_authentication].join(':') if options.has_key?(:http_authentication)
-      curl.proxy_url = options[:proxy_url] if options.has_key?(:proxy_url)
-      curl.proxy_port = options[:proxy_port] if options.has_key?(:proxy_port)
-      curl.max_redirects = options[:max_redirects] if options[:max_redirects]
-      curl.timeout = options[:timeout] if options[:timeout]
-      curl.ssl_verify_host = options[:ssl_verify_host] if options.has_key?(:ssl_verify_host)
-      curl.ssl_verify_peer = options[:ssl_verify_peer] if options.has_key?(:ssl_verify_peer)
-      curl.ssl_version = options[:ssl_version] if options.has_key?(:ssl_version)
-
-      curl.follow_location = true
-    end
-
-    # Fetches and returns the raw XML for each URL provided.
-    #
-    # === Parameters
-    # [urls<String> or <Array>] A single feed URL, or an array of feed URLs.
-    # [options<Hash>] Valid keys for this argument as as followed:
-    #                 :if_modified_since - Time object representing when the feed was last updated.
-    #                 :if_none_match - String that's normally an etag for the request that was stored previously.
-    #                 :on_success - Block that gets executed after a successful request.
-    #                 :on_failure - Block that gets executed after a failed request.
-    #                 * all parameters defined in setup_easy
-    # === Returns
-    # A String of XML if a single URL is passed.
-    #
-    # A Hash if multiple URL's are passed. The key will be the URL, and the value the XML.
-    def self.fetch_raw(urls, options = {})
-      url_queue = [*urls]
-      multi = Curl::Multi.new
-      responses = {}
-      url_queue.each do |url|
-        easy = Curl::Easy.new(url) do |curl|
-          setup_easy curl, options
-
-          curl.headers["If-Modified-Since"] = options[:if_modified_since].httpdate if options.has_key?(:if_modified_since)
-          curl.headers["If-None-Match"]     = options[:if_none_match] if options.has_key?(:if_none_match)
-
-          curl.on_success do |c|
-            responses[url] = decode_content(c)
-          end
-
-          curl.on_complete do |c, err|
-            responses[url] = c.response_code unless responses.has_key?(url)
-          end
-        end
-        multi.add(easy)
-      end
-
-      multi.perform
-      urls.is_a?(String) ? responses.values.first : responses
-    end
-
-    # Fetches and returns the parsed XML for each URL provided.
-    #
-    # === Parameters
-    # [urls<String> or <Array>] A single feed URL, or an array of feed URLs.
-    # [options<Hash>] Valid keys for this argument as as followed:
-    # * :user_agent - String that overrides the default user agent.
-    # * :if_modified_since - Time object representing when the feed was last updated.
-    # * :if_none_match - String, an etag for the request that was stored previously.
-    # * :on_success - Block that gets executed after a successful request.
-    # * :on_failure - Block that gets executed after a failed request.
-    # === Returns
-    # A Feed object if a single URL is passed.
-    #
-    # A Hash if multiple URL's are passed. The key will be the URL, and the value the Feed object.
-    def self.fetch_and_parse(urls, options = {})
-      url_queue = [*urls]
-      multi = Curl::Multi.new
-      responses = {}
-
-      # I broke these down so I would only try to do 30 simultaneously because
-      # I was getting weird errors when doing a lot. As one finishes it pops another off the queue.
-      url_queue.slice!(0, 30).each do |url|
-        add_url_to_multi(multi, url, url_queue, responses, options)
-      end
+    def self.fetch_and_parse(url)
+      response = connection(url).get
+      raise FetchFailure.new("Fetch failed - #{response.status}") unless response.success?
+      xml = response.body
+      parser_klass = determine_feed_parser_for_xml xml
+      raise NoParserAvailable.new("No valid parser for XML.") unless parser_klass
 
-      multi.perform
-      return urls.is_a?(String) ? responses.values.first : responses
+      feed = parse_with parser_klass, xml
+      feed.feed_url = url
+      feed.etag = response.headers['etag'].to_s.gsub(/"/, '')
+      feed.last_modified = response.headers['last-modified']
+      feed
     end
 
-    # Decodes the XML document if it was compressed.
-    #
-    # === Parameters
-    # [curl_request<Curl::Easy>] The Curl::Easy response object from the request.
-    # === Returns
-    # A decoded string of XML.
-    def self.decode_content(c)
-      if c.header_str.match(/Content-Encoding: gzip/i)
-        begin
-          gz =  Zlib::GzipReader.new(StringIO.new(c.body_str))
-          xml = gz.read
-          gz.close
-        rescue Zlib::GzipFile::Error
-          # Maybe this is not gzipped?
-          xml = c.body_str
-        end
-      elsif c.header_str.match(/Content-Encoding: deflate/i)
-        xml = Zlib::Inflate.inflate(c.body_str)
-      else
-        xml = c.body_str
-      end
-
-      xml
-    end
-
-    # Updates each feed for each Feed object provided.
-    #
-    # === Parameters
-    # [feeds<Feed> or <Array>] A single feed object, or an array of feed objects.
-    # [options<Hash>] Valid keys for this argument as as followed:
-    #                 * :on_success - Block that gets executed after a successful request.
-    #                 * :on_failure - Block that gets executed after a failed request.
-    #                 * all parameters defined in setup_easy
-    # === Returns
-    # A updated Feed object if a single URL is passed.
-    #
-    # A Hash if multiple Feeds are passed. The key will be the URL, and the value the updated Feed object.
-    def self.update(feeds, options = {})
-      feed_queue = [*feeds]
-      multi = Curl::Multi.new
-      responses = {}
-
-      feed_queue.slice!(0, 30).each do |feed|
-        add_feed_to_multi(multi, feed, feed_queue, responses, options)
-      end
-
-      multi.perform
-      feeds.is_a?(Array) ? responses : responses.values.first
-    end
-
-    # An abstraction for adding a feed by URL to the passed Curb::multi stack.
-    #
-    # === Parameters
-    # [multi<Curl::Multi>] The Curl::Multi object that the request should be added too.
-    # [url<String>] The URL of the feed that you would like to be fetched.
-    # [url_queue<Array>] An array of URLs that are queued for request.
-    # [responses<Hash>] Existing responses that you want the response from the request added to.
-    # [feeds<String> or <Array>] A single feed object, or an array of feed objects.
-    # [options<Hash>] Valid keys for this argument as as followed:
-    #                 * :on_success - Block that gets executed after a successful request.
-    #                 * :on_failure - Block that gets executed after a failed request.
-    #                 * all parameters defined in setup_easy
-    # === Returns
-    # The updated Curl::Multi object with the request details added to it's stack.
-    def self.add_url_to_multi(multi, url, url_queue, responses, options)
-      easy = Curl::Easy.new(url) do |curl|
-        setup_easy curl, options
-        curl.headers["If-Modified-Since"] = options[:if_modified_since].httpdate if options.has_key?(:if_modified_since)
-        curl.headers["If-None-Match"]     = options[:if_none_match] if options.has_key?(:if_none_match)
-
-        curl.on_success do |c|
-          xml = decode_content(c)
-          klass = determine_feed_parser_for_xml(xml)
-
-          if klass
-            begin
-              feed = parse_with klass, xml, &on_parser_failure(url)
-
-              feed.feed_url = c.last_effective_url
-              feed.etag = etag_from_header(c.header_str)
-              feed.last_modified = last_modified_from_header(c.header_str)
-              responses[url] = feed
-              options[:on_success].call(url, feed) if options.has_key?(:on_success)
-            rescue Exception => e
-              call_on_failure(c, e, options[:on_failure])
-            end
-          else
-            call_on_failure(c, "Can't determine a parser", options[:on_failure])
-          end
-        end
-
-        #
-        # trigger on_failure for 404s
-        #
-        curl.on_complete do |c|
-          add_url_to_multi(multi, url_queue.shift, url_queue, responses, options) unless url_queue.empty?
-          responses[url] = c.response_code unless responses.has_key?(url)
-        end
-
-        curl.on_redirect do |c|
-          if c.response_code == 304 # it's not modified. this isn't an error condition
-            options[:on_success].call(url, nil) if options.has_key?(:on_success)
-          end
-        end
-
-        curl.on_missing do |c|
-          if c.response_code == 404 && options.has_key?(:on_failure)
-            call_on_failure(c, 'Server returned a 404', options[:on_failure])
-          end
-        end
-
-        curl.on_failure do |c, err|
-          responses[url] = c.response_code
-          call_on_failure(c, err, options[:on_failure])
-        end
-      end
-      multi.add(easy)
-    end
-
-    # An abstraction for adding a feed by a Feed object to the passed Curb::multi stack.
-    #
-    # === Parameters
-    # [multi<Curl::Multi>] The Curl::Multi object that the request should be added too.
-    # [feed<Feed>] A feed object that you would like to be fetched.
-    # [url_queue<Array>] An array of feed objects that are queued for request.
-    # [responses<Hash>] Existing responses that you want the response from the request added to.
-    # [feeds<String>] or <Array> A single feed object, or an array of feed objects.
-    # [options<Hash>] Valid keys for this argument as as followed:
-    #                 * :on_success - Block that gets executed after a successful request.
-    #                 * :on_failure - Block that gets executed after a failed request.
-    #                 * all parameters defined in setup_easy
-    # === Returns
-    # The updated Curl::Multi object with the request details added to it's stack.
-    def self.add_feed_to_multi(multi, feed, feed_queue, responses, options)
-      easy = Curl::Easy.new(feed.feed_url) do |curl|
-        setup_easy curl, options
-        curl.headers["If-Modified-Since"] = feed.last_modified.httpdate if feed.last_modified
-        curl.headers["If-Modified-Since"] = options[:if_modified_since] if options[:if_modified_since] && (!feed.last_modified || (Time.parse(options[:if_modified_since].to_s) > feed.last_modified))
-        curl.headers["If-None-Match"]     = feed.etag if feed.etag
-
-        curl.on_success do |c|
-          begin
-            updated_feed = Feed.parse c.body_str, &on_parser_failure(feed.feed_url)
-
-            updated_feed.feed_url = c.last_effective_url
-            updated_feed.etag = etag_from_header(c.header_str)
-            updated_feed.last_modified = last_modified_from_header(c.header_str)
-            feed.update_from_feed(updated_feed)
-            responses[feed.feed_url] = feed
-            options[:on_success].call(feed) if options.has_key?(:on_success)
-          rescue Exception => e
-            call_on_failure(c, e, options[:on_failure])
-          end
-        end
-
-        curl.on_failure do |c, err| # response code 50X
-          responses[feed.feed_url] = c.response_code
-          call_on_failure(c, 'Server returned a 404', options[:on_failure])
-        end
-
-        curl.on_redirect do |c, err| # response code 30X
-          if c.response_code == 304
-            options[:on_success].call(feed) if options.has_key?(:on_success)
-          else
-            responses[feed.feed_url] = c.response_code
-            call_on_failure(c, err, options[:on_failure])
-          end
-        end
-
-        curl.on_complete do |c|
-          add_feed_to_multi(multi, feed_queue.shift, feed_queue, responses, options) unless feed_queue.empty?
-          responses[feed.feed_url] = feed unless responses.has_key?(feed.feed_url)
-        end
-      end
-      multi.add(easy)
-    end
-
-    # Determines the etag from the request headers.
-    #
-    # === Parameters
-    # [header<String>] Raw request header returned from the request
-    # === Returns
-    # A string of the etag or nil if it cannot be found in the headers.
-    def self.etag_from_header(header)
-      header =~ /.*ETag:\s(.*)\r/
-      $1
-    end
-
-    # Determines the last modified date from the request headers.
-    #
-    # === Parameters
-    # [header<String>] Raw request header returned from the request
-    # === Returns
-    # A Time object of the last modified date or nil if it cannot be found in the headers.
-    def self.last_modified_from_header(header)
-      header =~ /.*Last-Modified:\s(.*)\r/
-      Time.parse_safely($1) if $1
-    end
-
-    class << self
-      private
-
-      def on_parser_failure(url)
-        Proc.new { |message| raise "Error while parsing [#{url}] #{message}" }
-      end
-
-      def call_on_failure(c, error, on_failure)
-        if on_failure
-          if on_failure.arity == 2
-            on_failure.call(c, error)
-          else
-            warn "on_failure proc with invalid parameters number #{on_failure.arity} instead of 2, ignoring it"
-          end
-        end
+    def self.connection(url)
+      Faraday.new(url: url) do |conn|
+        conn.use FaradayMiddleware::FollowRedirects, limit: 3
+        conn.adapter :net_http
       end
     end
   end

data/lib/feedjira/version.rb

@@ -1,3 +1,3 @@
 module Feedjira
-  VERSION = '1.6.0'
+  VERSION = '2.0.0'
 end

data/spec/feedjira/feed_spec.rb

@@ -9,6 +9,32 @@ class FailParser
 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
+    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
+    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'
+    end
+  end
 
   describe "#add_common_feed_element" do
     before(:all) do
@@ -151,76 +177,6 @@ describe Feedjira::Feed do
 
   end
 
-  describe "#setup_easy" do
-    class MockCurl
-      attr_accessor :follow_location, :userpwd, :proxy_url, :proxy_port, :max_redirects, :timeout, :ssl_verify_host, :ssl_verify_peer, :ssl_version, :enable_cookies, :cookiefile, :cookies
-
-      def headers
-        @headers ||= {}
-      end
-    end
-
-    let(:curl) { MockCurl.new }
-
-    it "sets defaults on curl" do
-      Feedjira::Feed.setup_easy curl
-
-      expect(curl.headers["User-Agent"]).to eq Feedjira::Feed::USER_AGENT
-      expect(curl.follow_location).to eq true
-    end
-
-    it "allows user agent over-ride" do
-      Feedjira::Feed.setup_easy(curl, user_agent: '007')
-      expect(curl.headers["User-Agent"]).to eq '007'
-    end
-
-    it "allows to set language" do
-      Feedjira::Feed.setup_easy(curl, language: 'en-US')
-      expect(curl.headers["Accept-Language"]).to eq 'en-US'
-    end
-
-    it "enables compression" do
-      Feedjira::Feed.setup_easy(curl, compress: true)
-      expect(curl.headers["Accept-encoding"]).to eq 'gzip, deflate'
-    end
-
-    it "enables compression even when you act like you don't want it" do
-      Feedjira::Feed.setup_easy(curl, compress: false)
-      expect(curl.headers["Accept-encoding"]).to eq 'gzip, deflate'
-    end
-
-    it "sets up http auth" do
-      Feedjira::Feed.setup_easy(curl, http_authentication: ['user', 'pass'])
-      expect(curl.userpwd).to eq 'user:pass'
-    end
-
-    it "passes known options to curl" do
-      known_options = {
-        enable_cookies: true,
-        cookiefile: 'cookies.txt',
-        cookies: 'asdf',
-        proxy_url: 'http://proxy.url.com',
-        proxy_port: '1234',
-        max_redirects: 2,
-        timeout: 500,
-        ssl_verify_host: true,
-        ssl_verify_peer: true,
-        ssl_version: :omg
-      }
-
-      Feedjira::Feed.setup_easy curl, known_options
-
-      known_options.each do |option|
-        key, value = option
-        expect(curl.send(key)).to eq value
-      end
-    end
-
-    it "ignores unknown options" do
-      expect { Feedjira::Feed.setup_easy curl, foo: :bar }.to_not raise_error
-    end
-  end
-
   describe "when adding feed types" do
     it "should prioritize added types over the built in ones" do
       feed_text = "Atom asdf"
@@ -239,530 +195,4 @@ describe Feedjira::Feed do
       Feedjira::Feed.feed_classes.reject! {|o| o == new_feed_type }
     end
   end
-
-  describe '#etag_from_header' do
-    before(:each) do
-      @header = "HTTP/1.0 200 OK\r\nDate: Thu, 29 Jan 2009 03:55:24 GMT\r\nServer: Apache\r\nX-FB-Host: chi-write6\r\nLast-Modified: Wed, 28 Jan 2009 04:10:32 GMT\r\nETag: ziEyTl4q9GH04BR4jgkImd0GvSE\r\nP3P: CP=\"ALL DSP COR NID CUR OUR NOR\"\r\nConnection: close\r\nContent-Type: text/xml;charset=utf-8\r\n\r\n"
-    end
-
-    it "should return the etag from the header if it exists" do
-      expect(Feedjira::Feed.etag_from_header(@header)).to eq "ziEyTl4q9GH04BR4jgkImd0GvSE"
-    end
-
-    it "should return nil if there is no etag in the header" do
-      expect(Feedjira::Feed.etag_from_header("foo")).to be_nil
-    end
-
-  end
-
-  describe '#last_modified_from_header' do
-    before(:each) do
-      @header = "HTTP/1.0 200 OK\r\nDate: Thu, 29 Jan 2009 03:55:24 GMT\r\nServer: Apache\r\nX-FB-Host: chi-write6\r\nLast-Modified: Wed, 28 Jan 2009 04:10:32 GMT\r\nETag: ziEyTl4q9GH04BR4jgkImd0GvSE\r\nP3P: CP=\"ALL DSP COR NID CUR OUR NOR\"\r\nConnection: close\r\nContent-Type: text/xml;charset=utf-8\r\n\r\n"
-    end
-
-    it "should return the last modified date from the header if it exists" do
-      expect(Feedjira::Feed.last_modified_from_header(@header)).to eq Time.parse_safely("Wed, 28 Jan 2009 04:10:32 GMT")
-    end
-
-    it "should return nil if there is no last modified date in the header" do
-      expect(Feedjira::Feed.last_modified_from_header("foo")).to be_nil
-    end
-  end
-
-  describe "fetching feeds" do
-    before(:each) do
-      @paul_feed = { :xml => load_sample("PaulDixExplainsNothing.xml"), :url => "http://feeds.feedburner.com/PaulDixExplainsNothing" }
-      @trotter_feed = { :xml => load_sample("TrotterCashionHome.xml"), :url => "http://feeds2.feedburner.com/trottercashion" }
-      @invalid_feed = { :xml => 'This feed is invalid', :url => "http://feeds.feedburner.com/InvalidFeed" }
-    end
-
-    describe "#fetch_raw" do
-      before(:each) do
-        @cmock = double('cmock', :header_str => '', :body_str => @paul_feed[:xml] )
-        @multi = double('curl_multi', :add => true, :perform => true)
-        @curl_easy = double('curl_easy')
-        @curl = double('curl', :headers => {}, :follow_location= => true, :on_failure => true, :on_complete => true)
-        allow(@curl).to receive(:on_success).and_yield(@cmock)
-
-        allow(Curl::Multi).to receive(:new).and_return(@multi)
-        allow(Curl::Easy).to receive(:new).and_yield(@curl).and_return(@curl_easy)
-      end
-
-      it "should set user agent if it's passed as an option" do
-        Feedjira::Feed.fetch_raw(@paul_feed[:url], :user_agent => 'Custom Useragent')
-        expect(@curl.headers['User-Agent']).to eq 'Custom Useragent'
-      end
-
-      it "should set user agent to default if it's not passed as an option" do
-        Feedjira::Feed.fetch_raw(@paul_feed[:url])
-        expect(@curl.headers['User-Agent']).to eq Feedjira::Feed::USER_AGENT
-      end
-
-      it "should set if modified since as an option if passed" do
-        Feedjira::Feed.fetch_raw(@paul_feed[:url], :if_modified_since => Time.parse_safely("Wed, 28 Jan 2009 04:10:32 GMT"))
-        expect(@curl.headers["If-Modified-Since"]).to eq 'Wed, 28 Jan 2009 04:10:32 GMT'
-      end
-
-      it "should set if none match as an option if passed" do
-        Feedjira::Feed.fetch_raw(@paul_feed[:url], :if_none_match => 'ziEyTl4q9GH04BR4jgkImd0GvSE')
-        expect(@curl.headers["If-None-Match"]).to eq 'ziEyTl4q9GH04BR4jgkImd0GvSE'
-      end
-
-      it 'should set userpwd for http basic authentication if :http_authentication is passed' do
-        expect(@curl).to receive(:userpwd=).with('username:password')
-        Feedjira::Feed.fetch_raw(@paul_feed[:url], :http_authentication => ['username', 'password'])
-      end
-
-      it 'should set accepted encodings' do
-        Feedjira::Feed.fetch_raw(@paul_feed[:url], :compress => true)
-        expect(@curl.headers["Accept-encoding"]).to eq 'gzip, deflate'
-      end
-
-      it "should return raw xml" do
-        raw_xml = Feedjira::Feed.fetch_raw @paul_feed[:url]
-        expect(raw_xml).to match /^#{Regexp.escape('<?xml version="1.0" encoding="UTF-8"?>')}/
-      end
-
-      it "should take multiple feed urls and return a hash of urls and response xml" do
-        multi = double('curl_multi', :add => true, :perform => true)
-        allow(Curl::Multi).to receive(:new).and_return(multi)
-
-        paul_response = double('paul_response', :header_str => '', :body_str => @paul_feed[:xml] )
-        trotter_response = double('trotter_response', :header_str => '', :body_str => @trotter_feed[:xml] )
-
-        paul_curl = double('paul_curl', :headers => {}, :follow_location= => true, :on_failure => true, :on_complete => true)
-        allow(paul_curl).to receive(:on_success).and_yield(paul_response)
-
-        trotter_curl = double('trotter_curl', :headers => {}, :follow_location= => true, :on_failure => true, :on_complete => true)
-        allow(trotter_curl).to receive(:on_success).and_yield(trotter_response)
-
-        expect(Curl::Easy).to receive(:new).with(@paul_feed[:url]).ordered.and_yield(paul_curl)
-        expect(Curl::Easy).to receive(:new).with(@trotter_feed[:url]).ordered.and_yield(trotter_curl)
-
-        results = Feedjira::Feed.fetch_raw([@paul_feed[:url], @trotter_feed[:url]])
-        expect(results.keys).to include(@paul_feed[:url])
-        expect(results.keys).to include(@trotter_feed[:url])
-        expect(results[@paul_feed[:url]]).to match /Paul Dix/
-        expect(results[@trotter_feed[:url]]).to match /Trotter Cashion/
-      end
-
-      it "should always return a hash when passed an array" do
-        results = Feedjira::Feed.fetch_raw([@paul_feed[:url]])
-        expect(results.class).to eq Hash
-      end
-    end
-
-    describe "#add_url_to_multi" do
-      before(:each) do
-        allow_message_expectations_on_nil
-        @multi = Curl::Multi.get([@paul_feed[:url]], {:follow_location => true}, {:pipeline => true})
-        allow(@multi).to receive(:add)
-        @easy_curl = Curl::Easy.new(@paul_feed[:url])
-
-        allow(Curl::Easy).to receive(:new).and_yield(@easy_curl)
-      end
-
-      it "should set user agent if it's passed as an option" do
-        Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, :user_agent => 'My cool application')
-        expect(@easy_curl.headers["User-Agent"]).to eq 'My cool application'
-      end
-
-      it "should set user agent to default if it's not passed as an option" do
-        Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, {})
-        expect(@easy_curl.headers["User-Agent"]).to eq Feedjira::Feed::USER_AGENT
-      end
-
-      it "should set if modified since as an option if passed" do
-        Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, :if_modified_since => Time.parse_safely("Jan 25 2009 04:10:32 GMT"))
-        expect(@easy_curl.headers["If-Modified-Since"]).to eq 'Sun, 25 Jan 2009 04:10:32 GMT'
-      end
-
-      it 'should set follow location to true' do
-        expect(@easy_curl).to receive(:follow_location=).with(true)
-        Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, {})
-      end
-
-      it 'should set userpwd for http basic authentication if :http_authentication is passed' do
-        Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, :http_authentication => ['myusername', 'mypassword'])
-        expect(@easy_curl.userpwd).to eq 'myusername:mypassword'
-      end
-
-      it 'should set accepted encodings' do
-        Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, {:compress => true})
-        expect(@easy_curl.headers["Accept-encoding"]).to eq 'gzip, deflate'
-      end
-
-      it "should set if_none_match as an option if passed" do
-        Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, :if_none_match => 'ziEyTl4q9GH04BR4jgkImd0GvSE')
-        expect(@easy_curl.headers["If-None-Match"]).to eq 'ziEyTl4q9GH04BR4jgkImd0GvSE'
-      end
-
-      describe 'on success' do
-        before(:each) do
-          @feed = double('feed', :feed_url= => true, :etag= => true, :last_modified= => true)
-          allow(Feedjira::Feed).to receive(:decode_content).and_return(@paul_feed[:xml])
-          allow(Feedjira::Feed).to receive(:determine_feed_parser_for_xml).and_return(Feedjira::Parser::AtomFeedBurner)
-          allow(Feedjira::Parser::AtomFeedBurner).to receive(:parse).and_return(@feed)
-          allow(Feedjira::Feed).to receive(:etag_from_header).and_return('ziEyTl4q9GH04BR4jgkImd0GvSE')
-          allow(Feedjira::Feed).to receive(:last_modified_from_header).and_return('Wed, 28 Jan 2009 04:10:32 GMT')
-        end
-
-        it 'should decode the response body' do
-          expect(Feedjira::Feed).to receive(:decode_content).with(@easy_curl).and_return(@paul_feed[:xml])
-          Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, {})
-          @easy_curl.on_success.call(@easy_curl)
-        end
-
-        it 'should determine the xml parser class' do
-          expect(Feedjira::Feed).to receive(:determine_feed_parser_for_xml).with(@paul_feed[:xml]).and_return(Feedjira::Parser::AtomFeedBurner)
-          Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, {})
-          @easy_curl.on_success.call(@easy_curl)
-        end
-
-        it 'should parse the xml' do
-          expect(Feedjira::Parser::AtomFeedBurner).to receive(:parse).
-            with(@paul_feed[:xml]).and_return(@feed)
-          Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, {})
-          @easy_curl.on_success.call(@easy_curl)
-        end
-
-        describe 'when a compatible xml parser class is found' do
-          it 'should set the last effective url to the feed url' do
-            expect(@easy_curl).to receive(:last_effective_url).and_return(@paul_feed[:url])
-            expect(@feed).to receive(:feed_url=).with(@paul_feed[:url])
-            Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, {})
-            @easy_curl.on_success.call(@easy_curl)
-          end
-
-          it 'should set the etags on the feed' do
-            expect(@feed).to receive(:etag=).with('ziEyTl4q9GH04BR4jgkImd0GvSE')
-            Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, {})
-            @easy_curl.on_success.call(@easy_curl)
-          end
-
-          it 'should set the last modified on the feed' do
-            expect(@feed).to receive(:last_modified=).with('Wed, 28 Jan 2009 04:10:32 GMT')
-            Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, {})
-            @easy_curl.on_success.call(@easy_curl)
-          end
-
-          it 'should add the feed to the responses' do
-            responses = {}
-            Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], responses, {})
-            @easy_curl.on_success.call(@easy_curl)
-
-            expect(responses.length).to eq 1
-            expect(responses['http://feeds.feedburner.com/PaulDixExplainsNothing']).to eq @feed
-          end
-
-          it 'should call proc if :on_success option is passed' do
-            success = lambda { |url, feed| }
-            expect(success).to receive(:call).with(@paul_feed[:url], @feed)
-            Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, { :on_success => success })
-            @easy_curl.on_success.call(@easy_curl)
-          end
-
-          describe 'when the parser raises an exception' do
-            it 'invokes the on_failure callback with that exception' do
-              failure = double 'Failure callback', arity: 2
-              expect(failure).to receive(:call).with(@easy_curl, an_instance_of(Hell))
-
-              expect(Feedjira::Parser::AtomFeedBurner).to receive(:parse).and_raise Hell
-              Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, { on_failure: failure })
-
-              @easy_curl.on_success.call(@easy_curl)
-            end
-          end
-
-          describe 'when the parser invokes its on_failure callback' do
-            before(:each) do
-              allow(Feedjira::Feed).to receive(:determine_feed_parser_for_xml).and_return FailParser
-            end
-
-            it 'invokes the on_failure callback' do
-              failure = double 'Failure callback', arity: 2
-              expect(failure).to receive(:call).with(@easy_curl, an_instance_of(RuntimeError))
-
-              Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, { on_failure: failure })
-              @easy_curl.on_success.call(@easy_curl)
-            end
-          end
-        end
-
-        describe 'when no compatible xml parser class is found' do
-          it 'invokes the on_failure callback' do
-            failure = double 'Failure callback', arity: 2
-            expect(failure).to receive(:call).with(@easy_curl, "Can't determine a parser")
-
-            allow(Feedjira::Feed).to receive(:determine_feed_parser_for_xml).and_return nil
-            Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, { on_failure: failure })
-
-            @easy_curl.on_success.call(@easy_curl)
-          end
-        end
-      end
-
-      describe 'on failure' do
-        before(:each) do
-          @headers = "HTTP/1.0 500 Something Bad\r\nDate: Thu, 29 Jan 2009 03:55:24 GMT\r\nServer: Apache\r\nX-FB-Host: chi-write6\r\nLast-Modified: Wed, 28 Jan 2009 04:10:32 GMT\r\n"
-          @body = 'Sorry, something broke'
-
-          allow(@easy_curl).to receive(:response_code).and_return(500)
-          allow(@easy_curl).to receive(:header_str).and_return(@headers)
-          allow(@easy_curl).to receive(:body_str).and_return(@body)
-        end
-
-        it 'should call proc if :on_failure option is passed' do
-          failure = double 'Failure callback', arity: 2
-          expect(failure).to receive(:call).with(@easy_curl, nil)
-          Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, { :on_failure => failure })
-          @easy_curl.on_failure.call(@easy_curl)
-        end
-
-        it 'should return the http code in the responses' do
-          responses = {}
-          Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], responses, {})
-          @easy_curl.on_failure.call(@easy_curl)
-
-          expect(responses.length).to eq 1
-          expect(responses[@paul_feed[:url]]).to eq 500
-        end
-      end
-
-      describe 'on complete for 404s' do
-        before(:each) do
-          @headers = "HTTP/1.0 404 Not Found\r\nDate: Thu, 29 Jan 2009 03:55:24 GMT\r\nServer: Apache\r\nX-FB-Host: chi-write6\r\nLast-Modified: Wed, 28 Jan 2009 04:10:32 GMT\r\n"
-          @body = 'Page could not be found.'
-
-          allow(@easy_curl).to receive(:response_code).and_return(404)
-          allow(@easy_curl).to receive(:header_str).and_return(@headers)
-          allow(@easy_curl).to receive(:body_str).and_return(@body)
-        end
-
-        it 'should call proc if :on_failure option is passed' do
-          complete = double 'Failure callback', arity: 2
-          expect(complete).to receive(:call).with(@easy_curl, 'Server returned a 404')
-          Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], {}, { :on_failure => complete })
-          @easy_curl.on_missing.call(@easy_curl)
-        end
-
-        it 'should return the http code in the responses' do
-          responses = {}
-          Feedjira::Feed.add_url_to_multi(@multi, @paul_feed[:url], [], responses, {})
-          @easy_curl.on_complete.call(@easy_curl)
-
-          expect(responses.length).to eq 1
-          expect(responses[@paul_feed[:url]]).to eq 404
-        end
-      end
-    end
-
-    describe "#add_feed_to_multi" do
-      before(:each) do
-        allow_message_expectations_on_nil
-        @multi = Curl::Multi.get([@paul_feed[:url]], {:follow_location => true}, {:pipeline => true})
-        allow(@multi).to receive(:add)
-        @easy_curl = Curl::Easy.new(@paul_feed[:url])
-        @feed = Feedjira::Feed.parse(sample_feedburner_atom_feed)
-
-        allow(Curl::Easy).to receive(:new).and_yield(@easy_curl)
-      end
-
-      it "should set user agent if it's passed as an option" do
-        Feedjira::Feed.add_feed_to_multi(@multi, @feed, [], {}, :user_agent => 'My cool application')
-        expect(@easy_curl.headers["User-Agent"]).to eq 'My cool application'
-      end
-
-      it "should set user agent to default if it's not passed as an option" do
-        Feedjira::Feed.add_feed_to_multi(@multi, @feed, [], {}, {})
-        expect(@easy_curl.headers["User-Agent"]).to eq Feedjira::Feed::USER_AGENT
-      end
-
-      it "should set if modified since as an option if passed" do
-        modified_time = Time.parse_safely("Wed, 28 Jan 2009 04:10:32 GMT")
-        Feedjira::Feed.add_feed_to_multi(@multi, @feed, [], {}, {:if_modified_since => modified_time})
-        expect(modified_time).to be > @feed.last_modified
-
-        expect(@easy_curl.headers["If-Modified-Since"]).to eq modified_time
-      end
-
-      it 'should set follow location to true' do
-        expect(@easy_curl).to receive(:follow_location=).with(true)
-        Feedjira::Feed.add_feed_to_multi(@multi, @feed, [], {}, {})
-      end
-
-      it 'should set userpwd for http basic authentication if :http_authentication is passed' do
-        Feedjira::Feed.add_feed_to_multi(@multi, @feed, [], {}, :http_authentication => ['myusername', 'mypassword'])
-        expect(@easy_curl.userpwd).to eq 'myusername:mypassword'
-      end
-
-      it "should set if_none_match as an option if passed" do
-        @feed.etag = 'ziEyTl4q9GH04BR4jgkImd0GvSE'
-        Feedjira::Feed.add_feed_to_multi(@multi, @feed, [], {}, {})
-        expect(@easy_curl.headers["If-None-Match"]).to eq 'ziEyTl4q9GH04BR4jgkImd0GvSE'
-      end
-
-      describe 'on success' do
-        before(:each) do
-          @new_feed = @feed.clone
-          allow(@feed).to receive(:update_from_feed)
-          allow(Feedjira::Feed).to receive(:decode_content).and_return(@paul_feed[:xml])
-          allow(Feedjira::Feed).to receive(:determine_feed_parser_for_xml).and_return(Feedjira::Parser::AtomFeedBurner)
-          allow(Feedjira::Parser::AtomFeedBurner).to receive(:parse).and_return(@new_feed)
-          allow(Feedjira::Feed).to receive(:etag_from_header).and_return('ziEyTl4q9GH04BR4jgkImd0GvSE')
-          allow(Feedjira::Feed).to receive(:last_modified_from_header).and_return('Wed, 28 Jan 2009 04:10:32 GMT')
-        end
-
-        it 'should parse the updated feed' do
-          expect(Feedjira::Parser::AtomFeedBurner).to receive(:parse).and_return(@new_feed)
-          Feedjira::Feed.add_feed_to_multi(@multi, @feed, [], {}, {})
-          @easy_curl.on_success.call(@easy_curl)
-        end
-
-        it 'should set the last effective url to the feed url' do
-          expect(@easy_curl).to receive(:last_effective_url).and_return(@paul_feed[:url])
-          expect(@new_feed).to receive(:feed_url=).with(@paul_feed[:url])
-          Feedjira::Feed.add_feed_to_multi(@multi, @feed, [], {}, {})
-          @easy_curl.on_success.call(@easy_curl)
-        end
-
-        it 'should set the etags on the feed' do
-          expect(@new_feed).to receive(:etag=).with('ziEyTl4q9GH04BR4jgkImd0GvSE')
-          Feedjira::Feed.add_feed_to_multi(@multi, @feed, [], {}, {})
-          @easy_curl.on_success.call(@easy_curl)
-        end
-
-        it 'should set the last modified on the feed' do
-          expect(@new_feed).to receive(:last_modified=).with('Wed, 28 Jan 2009 04:10:32 GMT')
-          Feedjira::Feed.add_feed_to_multi(@multi, @feed, [], {}, {})
-          @easy_curl.on_success.call(@easy_curl)
-        end
-
-        it 'should add the feed to the responses' do
-          responses = {}
-          Feedjira::Feed.add_feed_to_multi(@multi, @feed, [], responses, {})
-          @easy_curl.on_success.call(@easy_curl)
-
-          expect(responses.length).to eq 1
-          expect(responses['http://feeds.feedburner.com/PaulDixExplainsNothing']).to eq @feed
-        end
-
-        it 'should call proc if :on_success option is passed' do
-          success = lambda { |feed| }
-          expect(success).to receive(:call).with(@feed)
-          Feedjira::Feed.add_feed_to_multi(@multi, @feed, [], {}, { :on_success => success })
-          @easy_curl.on_success.call(@easy_curl)
-        end
-
-        it 'should call update from feed on the old feed with the updated feed' do
-          expect(@feed).to receive(:update_from_feed).with(@new_feed)
-          Feedjira::Feed.add_feed_to_multi(@multi, @feed, [], {}, {})
-          @easy_curl.on_success.call(@easy_curl)
-        end
-
-        describe 'when the parser invokes its on_failure callback' do
-          before(:each) do
-            allow(Feedjira::Feed).to receive(:determine_feed_parser_for_xml).and_return FailParser
-          end
-
-          it 'invokes the on_failure callback' do
-            failure = double 'Failure callback', arity: 2
-            expect(failure).to receive(:call)
-
-            Feedjira::Feed.add_feed_to_multi(@multi, @feed, [], {}, { on_failure: failure })
-            @easy_curl.on_success.call(@easy_curl)
-          end
-        end
-      end
-
-      describe 'on failure' do
-        before(:each) do
-          @headers = "HTTP/1.0 404 Not Found\r\nDate: Thu, 29 Jan 2009 03:55:24 GMT\r\nServer: Apache\r\nX-FB-Host: chi-write6\r\nLast-Modified: Wed, 28 Jan 2009 04:10:32 GMT\r\n"
-          @body = 'Page could not be found.'
-
-          allow(@easy_curl).to receive(:response_code).and_return(404)
-          allow(@easy_curl).to receive(:header_str).and_return(@headers)
-          allow(@easy_curl).to receive(:body_str).and_return(@body)
-        end
-
-        it 'should call on success callback if the response code is 304' do
-          success = lambda { |feed| }
-          expect(success).to receive(:call).with(@feed)
-          expect(@easy_curl).to receive(:response_code).and_return(304)
-          Feedjira::Feed.add_feed_to_multi(@multi, @feed, [], {}, { :on_success => success })
-          @easy_curl.on_redirect.call(@easy_curl)
-        end
-
-        it 'should return the http code in the responses' do
-          responses = {}
-          Feedjira::Feed.add_feed_to_multi(@multi, @feed, [], responses, {})
-          @easy_curl.on_failure.call(@easy_curl)
-
-          expect(responses.length).to eq 1
-          expect(responses[@paul_feed[:url]]).to eq 404
-        end
-      end
-    end
-
-    describe "#fetch_and_parse" do
-      it "passes options to multicurl" do
-        options = { user_agent: '007' }
-
-        expect(Feedjira::Feed).to receive(:add_url_to_multi).
-          with(anything, anything, anything, anything, options)
-
-        Feedjira::Feed.fetch_and_parse(sample_rss_feed, options)
-      end
-    end
-
-    describe "#decode_content" do
-      before(:each) do
-        @curl_easy = double('curl_easy', :body_str => '<xml></xml>')
-      end
-
-      it 'should decode the response body using gzip if the Content-Encoding: is gzip' do
-        allow(@curl_easy).to receive(:header_str).and_return('Content-Encoding: gzip')
-        string_io = double('stringio', :read => @curl_easy.body_str, :close => true)
-        expect(StringIO).to receive(:new).and_return(string_io)
-        expect(Zlib::GzipReader).to receive(:new).with(string_io).and_return(string_io)
-        Feedjira::Feed.decode_content(@curl_easy)
-      end
-
-      it 'should decode the response body using gzip if the Content-Encoding: is gzip even when the case is wrong' do
-        allow(@curl_easy).to receive(:header_str).and_return('content-encoding: gzip')
-        string_io = double('stringio', :read => @curl_easy.body_str, :close => true)
-        expect(StringIO).to receive(:new).and_return(string_io)
-        expect(Zlib::GzipReader).to receive(:new).with(string_io).and_return(string_io)
-        Feedjira::Feed.decode_content(@curl_easy)
-      end
-
-      it 'should deflate the response body using inflate if the Content-Encoding: is deflate' do
-        allow(@curl_easy).to receive(:header_str).and_return('Content-Encoding: deflate')
-        expect(Zlib::Inflate).to receive(:inflate).with(@curl_easy.body_str)
-        Feedjira::Feed.decode_content(@curl_easy)
-      end
-
-      it 'should deflate the response body using inflate if the Content-Encoding: is deflate event if the case is wrong' do
-        allow(@curl_easy).to receive(:header_str).and_return('content-encoding: deflate')
-        expect(Zlib::Inflate).to receive(:inflate).with(@curl_easy.body_str)
-        Feedjira::Feed.decode_content(@curl_easy)
-      end
-
-      it 'should return the response body if it is not encoded' do
-        allow(@curl_easy).to receive(:header_str).and_return('')
-        expect(Feedjira::Feed.decode_content(@curl_easy)).to eq '<xml></xml>'
-      end
-    end
-
-    describe "#update" do
-      it "passes options to multicurl" do
-        options = { user_agent: '007' }
-
-        expect(Feedjira::Feed).to receive(:add_feed_to_multi).
-          with(anything, anything, anything, anything, options)
-
-        Feedjira::Feed.update([nil], options)
-      end
-    end
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: feedjira
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Paul Dix
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-28 00:00:00.000000000 Z
+date: 2015-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sax-machine
@@ -28,19 +28,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: curb
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: loofah
   requirement: !ruby/object:Gem::Requirement
@@ -173,7 +187,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: A feed fetching and parsing library