html2rss 0.16.0 → 0.18.0

data/lib/html2rss/item_extractors/html.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Html2rss
-  module ItemExtractors
-    ##
-    # Returns the HTML content of the specified element.
-    #
-    # Example HTML structure:
-    #
-    #     <p>Lorem <b>ipsum</b> dolor ...</p>
-    #
-    # YAML usage example:
-    #
-    #    selectors:
-    #      description:
-    #        selector: p
-    #        extractor: html
-    #
-    # Would return:
-    #    '<p>Lorem <b>ipsum</b> dolor ...</p>'
-    #
-    # 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.selector)
-      end
-
-      ##
-      # Retrieves and returns the HTML content of the element.
-      #
-      # @return [String] The HTML content.
-      def get
-        @element.to_s
-      end
-    end
-  end
-end

data/lib/html2rss/item_extractors/static.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Html2rss
-  module ItemExtractors
-    ##
-    # Returns a static value provided in the options.
-    #
-    # Example usage in YAML:
-    #
-    #    selectors:
-    #      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
-
-      ##
-      # Retrieves and returns the static value.
-      #
-      # @return [String, Symbol] The static value provided in options.
-      def get
-        @options.static
-      end
-    end
-  end
-end

data/lib/html2rss/item_extractors/text.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Html2rss
-  module ItemExtractors
-    ##
-    # Return the text content of the attribute. This is the default extractor used,
-    # when no extractor is explicitly given.
-    #
-    # Example HTML structure:
-    #
-    #     <p>Lorem <b>ipsum</b> dolor ...</p>
-    #
-    # YAML usage example:
-    #
-    #    selectors:
-    #      description:
-    #        selector: p
-    #        extractor: text
-    #
-    # 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.selector)
-      end
-
-      ##
-      # Retrieves and returns the text content of the element.
-      #
-      # @return [String] The text content.
-      def get
-        @element.text.to_s.strip.gsub(/\s+/, ' ')
-      end
-    end
-  end
-end

data/lib/html2rss/item_extractors.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-module Html2rss
-  ##
-  # Provides a namespace for item extractors.
-  module ItemExtractors
-    ##
-    # The Error class to be thrown when an unknown extractor name is requested.
-    class UnknownExtractorName < Html2rss::Error; 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
-
-    ##
-    # 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
-
-    ##
-    # 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

@@ -1,56 +0,0 @@
-# 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/item.rb

@@ -1,83 +0,0 @@
-# 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/utils.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require 'addressable/uri'
-require 'json'
-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, Addressable::URI]
-    # @return [Addressable::URI]
-    def self.build_absolute_url_from_relative(url, base_url)
-      url = Addressable::URI.parse(url)
-      return url if url.absolute?
-
-      base_uri = Addressable::URI.parse(base_url)
-      base_uri.path = '/' if base_uri.path.empty?
-
-      base_uri.join(url).normalize
-    end
-
-    ##
-    # Removes any space, parses and normalizes the given url.
-    # @param url [String]
-    # @return [Addressable::URI, nil] 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
-    end
-
-    ##
-    # Allows override of time zone locally inside supplied block; resets previous time zone when done.
-    #
-    # @param time_zone [String]
-    # @param default_time_zone [String]
-    # @yield block to execute with the given time zone
-    # @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
-
-    ##
-    # Builds a titleized representation of the URL with prefixed host.
-    # @param url [Addressable::URI]
-    # @return [String]
-    def self.titleized_channel_url(url)
-      nicer_path = CGI.unescapeURIComponent(url.path).split('/').reject(&:empty?)
-      host = url.host
-
-      nicer_path.any? ? "#{host}: #{nicer_path.map(&:capitalize).join(' ')}" : host
-    end
-
-    ##
-    # Builds a titleized representation of the URL.
-    # @param url [Addressable::URI]
-    # @return [String]
-    def self.titleized_url(url)
-      return '' if url.path.empty?
-
-      nicer_path = CGI.unescapeURIComponent(url.path)
-                      .split('/')
-                      .flat_map do |part|
-        part.gsub(/[^a-zA-Z0-9\.]/, ' ').gsub(/\s+/, ' ').split
-      end
-
-      nicer_path.map!(&:capitalize)
-      File.basename nicer_path.join(' '), '.*'
-    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 [Addressable::URI]
-    # @return [String] guessed content type, defaults to 'application/octet-stream'
-    def self.guess_content_type_from_url(url)
-      url = url.path.split('?').first
-
-      content_type = MIME::Types.type_for(File.extname(url).delete('.'))
-      content_type.first&.to_s || 'application/octet-stream'
-    end
-  end
-end