html2rss 0.9.0 → 0.11.0

data/lib/html2rss/item_extractors/html.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Html2rss
   module ItemExtractors
     ##
-    # Return the HTML of the attribute.
+    # Returns the HTML content of the specified element.
     #
-    # Imagine this HTML structure:
+    # Example HTML structure:
     #
     #     <p>Lorem <b>ipsum</b> dolor ...</p>
     #
@@ -17,15 +19,25 @@ module Html2rss
     # Would return:
     #    '<p>Lorem <b>ipsum</b> dolor ...</p>'
     #
-    # Always make sure to sanitize the HTML during post processing with
-    # {AttributePostProcessors::SanitizeHtml}[rdoc-ref:Html2rss::AttributePostProcessors::SanitizeHtml].
+    # Always ensure to sanitize the HTML during post-processing with
+    # {AttributePostProcessors::SanitizeHtml}.
     class Html
+      # The available options for the html extractor.
+      Options = Struct.new('HtmlOptions', :selector, keyword_init: true)
+
+      ##
+      # Initializes the Html extractor.
+      #
+      # @param xml [Nokogiri::XML::Element]
+      # @param options [Options]
       def initialize(xml, options)
-        @element = ItemExtractors.element(xml, options)
+        @element = ItemExtractors.element(xml, options.selector)
       end
 
       ##
-      # @return [String]
+      # Retrieves and returns the HTML content of the element.
+      #
+      # @return [String] The HTML content.
       def get
         @element.to_s
       end

data/lib/html2rss/item_extractors/static.rb

@@ -1,27 +1,38 @@
+# frozen_string_literal: true
+
 module Html2rss
   module ItemExtractors
     ##
-    # YAML usage example:
+    # Returns a static value provided in the options.
+    #
+    # Example usage in YAML:
     #
     #    selectors:
-    #      autor:
+    #      author:
     #        extractor: static
     #        static: Foobar
     #
     # Would return:
     #    'Foobar'
     class Static
+      # The available option for the static extractor.
+      Options = Struct.new('StaticOptions', :static, keyword_init: true)
+
+      ##
+      # Initializes the Static extractor.
+      #
+      # @param _xml [nil, Nokogiri::XML::Element] Unused parameter for compatibility with other extractors.
+      # @param options [Options] Options containing the static value.
       def initialize(_xml, options)
         @options = options
       end
 
-      # Returns what options[:static] holds.
+      ##
+      # Retrieves and returns the static value.
       #
-      #    options = { static: 'Foobar' }
-      #    Static.new(xml, options).get
-      #    # => 'Foobar'
+      # @return [String, Symbol] The static value provided in options.
       def get
-        @options[:static]
+        @options.static
       end
     end
   end

data/lib/html2rss/item_extractors/text.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Html2rss
   module ItemExtractors
     ##
-    # Return the text of the attribute. This is the default extractor used,
+    # Return the text content of the attribute. This is the default extractor used,
     # when no extractor is explicitly given.
     #
-    # Imagine this HTML structure:
+    # Example HTML structure:
     #
     #     <p>Lorem <b>ipsum</b> dolor ...</p>
     #
@@ -18,14 +20,24 @@ module Html2rss
     # Would return:
     #    'Lorem ipsum dolor ...'
     class Text
+      # The available options for the text extractor.
+      Options = Struct.new('TextOptions', :selector, keyword_init: true)
+
+      ##
+      # Initializes the Text extractor.
+      #
+      # @param xml [Nokogiri::XML::Element]
+      # @param options [Options]
       def initialize(xml, options)
-        @element = ItemExtractors.element(xml, options)
+        @element = ItemExtractors.element(xml, options.selector)
       end
 
       ##
-      # @return [String]
+      # Retrieves and returns the text content of the element.
+      #
+      # @return [String] The text content.
       def get
-        @element.text.to_s.strip.split.join(' ')
+        @element.text.to_s.strip.gsub(/\s+/, ' ')
       end
     end
   end

data/lib/html2rss/item_extractors.rb

@@ -1,23 +1,88 @@
+# frozen_string_literal: true
+
 module Html2rss
   ##
   # Provides a namespace for item extractors.
   module ItemExtractors
-    DEFAULT = 'text'.freeze
-    private_constant :DEFAULT
+    ##
+    # The Error class to be thrown when an unknown extractor name is requested.
+    class UnknownExtractorName < Html2rss::Error; end
 
-    def self.get_extractor(name)
-      @get_extractor ||= Hash.new do |extractors, key|
-        extractors[key] = Utils.get_class_from_name(key || DEFAULT, 'ItemExtractors')
-      end
+    ##
+    # Maps the extractor name to the class implementing the extractor.
+    #
+    # The key is the name to use in the feed config.
+    NAME_TO_CLASS = {
+      attribute: Attribute,
+      href: Href,
+      html: Html,
+      static: Static,
+      text: Text
+    }.freeze
 
-      @get_extractor[name]
+    ##
+    # Maps the extractor class to its corresponding options class.
+    ITEM_OPTION_CLASSES = Hash.new do |hash, klass|
+      hash[klass] = klass.const_get(:Options)
     end
 
+    DEFAULT_EXTRACTOR = :text
+
     ##
-    # @return [Nokogiri::XML::Element]
-    def self.element(xml, options)
-      selector = options[:selector]
+    # Retrieves an element from Nokogiri XML based on the selector.
+    #
+    # @param xml [Nokogiri::XML::Document]
+    # @param selector [String, nil]
+    # @return [Nokogiri::XML::ElementSet] selected XML elements
+    def self.element(xml, selector)
       selector ? xml.css(selector) : xml
     end
+
+    ##
+    # Creates an instance of the requested item extractor.
+    #
+    # @param attribute_options [Hash<Symbol, Object>]
+    #   Should contain at least `:extractor` (the name) and required options for that extractor.
+    # @param xml [Nokogiri::XML::Document]
+    # @return [Object] instance of the specified item extractor class
+    def self.item_extractor_factory(attribute_options, xml)
+      extractor_name = attribute_options[:extractor]&.to_sym || DEFAULT_EXTRACTOR
+      extractor_class = find_extractor_class(extractor_name)
+      options_instance = build_options_instance(extractor_class, attribute_options)
+      create_extractor_instance(extractor_class, xml, options_instance)
+    end
+
+    ##
+    # Finds the extractor class based on the name.
+    #
+    # @param extractor_name [Symbol] the name of the extractor
+    # @return [Class] the class implementing the extractor
+    # @raise [UnknownExtractorName] if the extractor class is not found
+    def self.find_extractor_class(extractor_name)
+      NAME_TO_CLASS[extractor_name] || raise(UnknownExtractorName,
+                                             "Unknown extractor name '#{extractor_name}' requested in NAME_TO_CLASS")
+    end
+
+    ##
+    # Builds the options instance for the extractor class.
+    #
+    # @param extractor_class [Class] the class implementing the extractor
+    # @param attribute_options [Hash<Symbol, Object>] the attribute options
+    # @return [Object] an instance of the options class for the extractor
+    def self.build_options_instance(extractor_class, attribute_options)
+      options = attribute_options.slice(*extractor_class::Options.members)
+      ITEM_OPTION_CLASSES[extractor_class].new(options)
+    end
+
+    ##
+    # Creates an instance of the extractor class.
+    #
+    # @param extractor_class [Class] the class implementing the extractor
+    # @param xml [Nokogiri::XML::Document] the XML document
+    # @param options_instance [Object] the options instance
+    # @return [Object] an instance of the extractor class
+    def self.create_extractor_instance(extractor_class, xml, options_instance)
+      extractor_class.new(xml, options_instance)
+    end
   end
 end

data/lib/html2rss/object_to_xml_converter.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'json'
+
+module Html2rss
+  ##
+  # A naive implementation of "Object to XML": converts a Ruby object to XML format.
+  class ObjectToXmlConverter
+    OBJECT_TO_XML_TAGS = {
+      hash: ['<object>', '</object>'],
+      enumerable: ['<array>', '</array>']
+    }.freeze
+
+    ##
+    # @param object [Object] any Ruby object (Hash, Array, String, Symbol, etc.)
+    def initialize(object)
+      @object = object
+    end
+
+    ##
+    # Converts the object to XML format.
+    #
+    # @return [String] representing the object in XML
+    def call
+      object_to_xml(@object)
+    end
+
+    private
+
+    def object_to_xml(object)
+      case object
+      when Hash
+        hash_to_xml(object)
+      when Enumerable
+        enumerable_to_xml(object)
+      else
+        CGI.escapeHTML(object.to_s)
+      end
+    end
+
+    def hash_to_xml(object)
+      prefix, suffix = OBJECT_TO_XML_TAGS[:hash]
+      inner_xml = object.map { |key, value| "<#{key}>#{object_to_xml(value)}</#{key}>" }.join
+
+      "#{prefix}#{inner_xml}#{suffix}"
+    end
+
+    def enumerable_to_xml(object)
+      prefix, suffix = OBJECT_TO_XML_TAGS[:enumerable]
+      inner_xml = object.map { |value| object_to_xml(value) }.join
+
+      "#{prefix}#{inner_xml}#{suffix}"
+    end
+  end
+end

data/lib/html2rss/rss_builder/channel.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Html2rss
+  module RssBuilder
+    ##
+    # Builds the <channel> tag (with the provided maker).
+    class Channel
+      ##
+      # @param maker [RSS::Maker::RSS20::Channel]
+      # @param config [Html2rss::Config]
+      # @param tags [Set<Symbol>]
+      # @return nil
+      def self.add(maker, config, tags)
+        tags.each { |tag| maker.public_send(:"#{tag}=", config.public_send(tag)) }
+
+        maker.generator = "html2rss V. #{::Html2rss::VERSION}"
+        maker.lastBuildDate = Time.now
+      end
+    end
+  end
+end

data/lib/html2rss/rss_builder/item.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'mime/types'
+
+module Html2rss
+  module RssBuilder
+    ##
+    # Builds an <item> tag (with the provided maker).
+    class Item
+      # Tags which should be processed every time and require non-trivial assignments/treatments.
+      SPECIAL_TAGS = %i[categories enclosure guid].freeze
+
+      ##
+      # Adds the item to the Item Maker
+      #
+      # @param maker [RSS::Maker::RSS20::Items::Item]
+      # @param item [Html2rss::Item]
+      # @param tags [Set<Symbol>]
+      # @return nil
+      def self.add(maker, item, tags)
+        tags.each do |tag|
+          next if SPECIAL_TAGS.include?(tag)
+
+          maker.public_send(:"#{tag}=", item.public_send(tag))
+        end
+
+        SPECIAL_TAGS.each do |tag|
+          send(:"add_#{tag}", item, maker)
+        end
+      end
+
+      ##
+      # Adds the <category> tags, if there should be any.
+      #
+      # @param item [Html2rss::Item]
+      # @param maker [RSS::Maker::RSS20::Items::Item]
+      # @return nil
+      def self.add_categories(item, maker)
+        item.categories.each { |category| maker.categories.new_category.content = category }
+      end
+      private_class_method :add_categories
+
+      ##
+      # Adds an enclosure, if there should be one.
+      #
+      # @param item [Html2rss::Item]
+      # @param maker [RSS::Maker::RSS20::Items::Item]
+      # @return nil
+      def self.add_enclosure(item, maker)
+        return unless item.enclosure?
+
+        set_enclosure_attributes(item.enclosure, maker.enclosure)
+      end
+      private_class_method :add_enclosure
+
+      ##
+      # Sets the attributes of an RSS enclosure.
+      #
+      # @param item_enclosure [Html2rss::Enclosure]
+      # @param rss_enclosure [RSS::Maker::RSS20::Items::Enclosure]
+      # @return nil
+      def self.set_enclosure_attributes(item_enclosure, rss_enclosure)
+        rss_enclosure.type = item_enclosure.type
+        rss_enclosure.length = item_enclosure.bits_length
+        rss_enclosure.url = item_enclosure.url
+      end
+      private_class_method :set_enclosure_attributes
+
+      ##
+      # Adds a non-permalink GUID to the item.
+      #
+      # @param item [Html2rss::Item]
+      # @param maker [RSS::Maker::RSS20::Items::Item]
+      # @return nil
+      def self.add_guid(item, maker)
+        guid = maker.guid
+        guid.content = item.guid
+        guid.isPermaLink = false
+      end
+      private_class_method :add_guid
+    end
+  end
+end

data/lib/html2rss/rss_builder/stylesheet.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Html2rss
+  module RssBuilder
+    ##
+    # Adds XML stylesheet tags (with the provided maker).
+    class Stylesheet
+      ##
+      # Adds the stylesheet XML tags to the RSS.
+      #
+      # @param maker [RSS::Maker::RSS20] RSS maker object.
+      # @param stylesheets [Array<Html2rss::Config::Stylesheet>] Array of stylesheet configurations.
+      # @return [nil]
+      def self.add(maker, stylesheets)
+        stylesheets.each do |stylesheet|
+          add_stylesheet(maker, stylesheet)
+        end
+      end
+
+      ##
+      # Adds a single Stylesheet to the RSS.
+      #
+      # @param maker [RSS::Maker::RSS20] RSS maker object.
+      # @param stylesheet [Html2rss::Config::Stylesheet] Stylesheet configuration.
+      # @return [nil]
+      def self.add_stylesheet(maker, stylesheet)
+        maker.xml_stylesheets.new_xml_stylesheet do |xss|
+          xss.href = stylesheet.href
+          xss.type = stylesheet.type
+          xss.media = stylesheet.media
+        end
+      end
+
+      private_class_method :add_stylesheet
+    end
+  end
+end

data/lib/html2rss/rss_builder.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'rss'
+
+module Html2rss
+  ##
+  # Builds the RSS 2.0 feed, which consists of the '<channel>' and the '<item>'s
+  # tags in the RSS.
+  module RssBuilder
+    # Possible tags inside a RSS 2.0 <channel> tag.
+    CHANNEL_TAGS = %i[language author title description link ttl].freeze
+    # Possible tags inside a RSS 2.0 <item> tag.
+    ITEM_TAGS = %i[title link description author comments updated].freeze
+
+    ##
+    # Builds an RSS 2.0 feed based on the provided configuration.
+    #
+    # @param config [Html2rss::Config] Configuration object containing feed details.
+    # @return [RSS::Rss] RSS feed object.
+    def self.build(config)
+      RSS::Maker.make('2.0') do |maker|
+        add_stylesheets(maker, config.stylesheets)
+        add_channel(maker, config)
+        add_items(maker, config)
+      end
+    end
+
+    ##
+    # Adds stylesheets to the RSS maker.
+    #
+    # @param maker [RSS::Maker] RSS maker instance.
+    # @param stylesheets [Array<String>] Array of stylesheets to add.
+    def self.add_stylesheets(maker, stylesheets)
+      Stylesheet.add(maker, stylesheets)
+    end
+
+    ##
+    # Adds channel information to the RSS maker.
+    #
+    # @param maker [RSS::Maker] RSS maker instance.
+    # @param config [Html2rss::Config] Configuration object containing feed details.
+    def self.add_channel(maker, config)
+      channel = maker.channel
+      CHANNEL_TAGS.each do |tag|
+        Channel.add(channel, config, [tag])
+      end
+    end
+
+    ##
+    # Adds items to the RSS maker based on configuration.
+    #
+    # @param maker [RSS::Maker] RSS maker instance.
+    # @param config [Html2rss::Config] Configuration object containing feed details.
+    def self.add_items(maker, config)
+      item_attributes = extract_item_attributes(config)
+      items = fetch_items(config)
+      items.reverse! if config.items_order == :reverse
+
+      items.each do |item|
+        add_item(maker, item, item_attributes)
+      end
+    end
+
+    ##
+    # Adds a single item to the RSS maker.
+    #
+    # @param maker [RSS::Maker] RSS maker instance.
+    # @param item [Html2rss::Item] Item to add.
+    # @param item_attributes [Array<Symbol>] Array of item attributes.
+    # @return [nil]
+    def self.add_item(maker, item, item_attributes)
+      new_item = maker.items.new_item
+      Item.add(new_item, item, item_attributes)
+    end
+
+    ##
+    # Extracts item attributes from configuration.
+    #
+    # @param config [Html2rss::Config] Configuration object containing feed details.
+    # @return [Array<Symbol>] Array of item attributes.
+    def self.extract_item_attributes(config)
+      config.item_selector_names & ITEM_TAGS
+    end
+
+    ##
+    # Fetches items from the URL specified in configuration.
+    #
+    # @param config [Html2rss::Config] Configuration object containing feed details.
+    # @return [Array<Html2rss::Item>] Array of items.
+    def self.fetch_items(config)
+      Html2rss::Item.from_url(config.url, config)
+    end
+
+    private_class_method :extract_item_attributes, :fetch_items, :add_item
+  end
+end

data/lib/html2rss/utils.rb

@@ -1,40 +1,115 @@
-require 'active_support/core_ext/hash'
+# frozen_string_literal: true
+
 require 'addressable/uri'
-require 'builder'
+require 'faraday'
+require 'faraday/follow_redirects'
 require 'json'
-require 'nokogiri'
+require 'regexp_parser'
+require 'tzinfo'
+require 'mime/types'
+require_relative 'object_to_xml_converter'
 
 module Html2rss
   ##
   # The collecting tank for utility methods.
   module Utils
+    ##
+    # @param url [String, Addressable::URI]
+    # @param base_url [String]
+    # @return [Addressable::URI]
     def self.build_absolute_url_from_relative(url, base_url)
-      url = URI(url) if url.is_a?(String)
+      url = Addressable::URI.parse(url.to_s) unless url.is_a?(Addressable::URI)
 
       return url if url.absolute?
 
-      URI(base_url).tap do |uri|
-        uri.path = url.path.to_s.start_with?('/') ? url.path : "/#{url.path}"
-        uri.query = url.query
-        uri.fragment = url.fragment if url.fragment
-      end
+      base_uri = Addressable::URI.parse(base_url)
+      base_uri.path = '/' if base_uri.path.empty?
+
+      base_uri.join(url).normalize
     end
 
-    def self.object_to_xml(object)
-      object.to_xml(skip_instruct: true, skip_types: true)
+    ##
+    # Removes any space, parses and normalizes the given url.
+    # @param url [String]
+    # @return [String, nil] sanitized and normalized URL, or nil if input is empty
+    def self.sanitize_url(url)
+      url = url.to_s.gsub(/\s+/, ' ').strip
+      return if url.empty?
+
+      Addressable::URI.parse(url).normalize.to_s
     end
 
-    def self.get_class_from_name(snake_cased_name, module_name)
-      camel_cased_name = snake_cased_name.split('_').map(&:capitalize).join
-      class_name = ['Html2rss', module_name, camel_cased_name].join('::')
-      Object.const_get(class_name)
+    ##
+    # Allows override of time zone locally inside supplied block; resets previous time zone when done.
+    #
+    # @param time_zone [String]
+    # @param default_time_zone [String]
+    # @return [Object] whatever the given block returns
+    def self.use_zone(time_zone, default_time_zone: Time.now.getlocal.zone)
+      raise ArgumentError, 'a block is required' unless block_given?
+
+      time_zone = TZInfo::Timezone.get(time_zone)
+
+      prev_tz = ENV.fetch('TZ', default_time_zone)
+      ENV['TZ'] = time_zone.name
+      yield
+    ensure
+      ENV['TZ'] = prev_tz if prev_tz
     end
 
-    def self.sanitize_url(url)
-      squished_url = url.to_s.split(' ').join
-      return if squished_url.to_s == ''
+    ##
+    # Builds a titleized representation of the URL.
+    # @param url [String, Addressable::URI]
+    # @return [String]
+    def self.titleized_url(url)
+      uri = Addressable::URI.parse(url)
+      host = uri.host
+
+      nicer_path = uri.path.split('/').reject(&:empty?)
+      nicer_path.any? ? "#{host}: #{nicer_path.map(&:capitalize).join(' ')}" : host
+    end
+
+    ##
+    # @param url [String, Addressable::URI]
+    # @param convert_json_to_xml [true, false] Should JSON be converted to XML
+    # @param headers [Hash] additional HTTP request headers to use for the request
+    # @return [String] body of the HTTP response
+    def self.request_body_from_url(url, convert_json_to_xml: false, headers: {})
+      response = Faraday.new(url:, headers:) do |faraday|
+        faraday.use Faraday::FollowRedirects::Middleware
+        faraday.adapter Faraday.default_adapter
+      end.get
+
+      body = response.body
+
+      convert_json_to_xml ? ObjectToXmlConverter.new(JSON.parse(body)).call : body
+    end
+
+    ##
+    # Parses the given String and builds a Regexp out of it.
+    #
+    # It will remove one pair of surrounding slashes ('/') from the String
+    # to maintain backwards compatibility before building the Regexp.
+    #
+    # @param string [String]
+    # @return [Regexp]
+    def self.build_regexp_from_string(string)
+      raise ArgumentError, 'must be a string!' unless string.is_a?(String)
+
+      string = string[1..-2] if string.start_with?('/') && string.end_with?('/')
+      Regexp::Parser.parse(string, options: ::Regexp::EXTENDED | ::Regexp::IGNORECASE).to_re
+    end
+
+    ##
+    # Guesses the content type based on the file extension of the URL.
+    #
+    # @param url [String, Addressable::URI]
+    # @return [String] guessed content type, defaults to 'application/octet-stream'
+    def self.guess_content_type_from_url(url)
+      url = url.to_s.split('?').first
 
-      Addressable::URI.parse(squished_url).normalize.to_s
+      content_type = MIME::Types.type_for(File.extname(url).delete('.'))
+      content_type.first&.to_s || 'application/octet-stream'
     end
   end
 end

data/lib/html2rss/version.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
+##
+# The Html2rss namespace.
 module Html2rss
-  VERSION = '0.9.0'.freeze
+  VERSION = '0.11.0'
   public_constant :VERSION
 end