rss 0.2.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b4c9e9539fc75445348d13247c59875480824315e591a4158caf8938438bee34
+  data.tar.gz: 4b923e608e3079bd8bffe3c5c8dcc5ad347a5bb1e53808ac0f74a0db0177a36e
+SHA512:
+  metadata.gz: 1734f6dc142b58b73635d354bf78fe9273b7252c2f5fa8bc49859ead33ba27c520009c2d85985ef2f730ff83963f3e06a556a304d3d25adacca139b0c8aa1068
+  data.tar.gz: daaff41773cd97a209eff268b587a38191b824eb130005d5a740431279a8828a0cf57157c24cdecd8d6c01032e2271941cc5151559f6cca08352b3e7f40d8a48

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,6 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.1
+  - ruby-head
+before_install: gem install bundler -v 1.16.2

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in rss.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/README.md

@@ -0,0 +1,88 @@
+# RSS
+
+Really Simple Syndication (RSS) is a family of formats that describe 'feeds,' specially constructed XML documents that allow an interested person to subscribe and receive updates from a particular web service. This portion of the standard library provides tooling to read and create these feeds.
+
+The standard library supports RSS 0.91, 1.0, 2.0, and Atom, a related format. Here are some links to the standards documents for these formats:
+
+* RSS
+  * 0.9.1[http://www.rssboard.org/rss-0-9-1-netscape]
+  * 1.0[http://web.resource.org/rss/1.0/]
+  * 2.0[http://www.rssboard.org/rss-specification]
+* Atom[http://tools.ietf.org/html/rfc4287]
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rss'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rss
+
+## Usage
+
+### Consuming RSS
+
+If you'd like to read someone's RSS feed with your Ruby code, you've come to the right place. It's really easy to do this, but we'll need the help of open-uri:
+
+```
+  require 'rss'
+  require 'open-uri'
+
+  url = 'http://www.ruby-lang.org/en/feeds/news.rss'
+  open(url) do |rss|
+    feed = RSS::Parser.parse(rss)
+    puts "Title: #{feed.channel.title}"
+    feed.items.each do |item|
+      puts "Item: #{item.title}"
+    end
+  end
+```
+
+As you can see, the workhorse is RSS::Parser#parse, which takes the source of the feed and a parameter that performs validation on the feed. We get back an object that has all of the data from our feed, accessible through methods. This example shows getting the title out of the channel element, and looping through the list of items.
+
+### Producing RSS
+
+Producing our own RSS feeds is easy as well. Let's make a very basic feed:
+
+```
+  require "rss"
+
+  rss = RSS::Maker.make("atom") do |maker|
+    maker.channel.author = "matz"
+    maker.channel.updated = Time.now.to_s
+    maker.channel.about = "http://www.ruby-lang.org/en/feeds/news.rss"
+    maker.channel.title = "Example Feed"
+
+    maker.items.new_item do |item|
+      item.link = "http://www.ruby-lang.org/en/news/2010/12/25/ruby-1-9-2-p136-is-released/"
+      item.title = "Ruby 1.9.2-p136 is released"
+      item.updated = Time.now.to_s
+    end
+  end
+
+  puts rss
+```
+
+As you can see, this is a very Builder-like DSL. This code will spit out an Atom feed with one item. If we needed a second item, we'd make another block with maker.items.new_item and build a second one.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/rss.
+
+## License
+
+The gem is available as open source under the terms of the [BSD-2-Clause](LICENSE.txt).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rss"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rss.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: false
+##
+# = RSS reading and writing
+#
+# Really Simple Syndication (RSS) is a family of formats that describe 'feeds,'
+# specially constructed XML documents that allow an interested person to
+# subscribe and receive updates from a particular web service. This portion of
+# the standard library provides tooling to read and create these feeds.
+#
+# The standard library supports RSS 0.91, 1.0, 2.0, and Atom, a related format.
+# Here are some links to the standards documents for these formats:
+#
+# * RSS
+#   * 0.9.1[http://www.rssboard.org/rss-0-9-1-netscape]
+#   * 1.0[http://web.resource.org/rss/1.0/]
+#   * 2.0[http://www.rssboard.org/rss-specification]
+# * Atom[http://tools.ietf.org/html/rfc4287]
+#
+# == Consuming RSS
+#
+# If you'd like to read someone's RSS feed with your Ruby code, you've come to
+# the right place. It's really easy to do this, but we'll need the help of
+# open-uri:
+#
+#   require 'rss'
+#   require 'open-uri'
+#
+#   url = 'http://www.ruby-lang.org/en/feeds/news.rss'
+#   open(url) do |rss|
+#     feed = RSS::Parser.parse(rss)
+#     puts "Title: #{feed.channel.title}"
+#     feed.items.each do |item|
+#       puts "Item: #{item.title}"
+#     end
+#   end
+#
+# As you can see, the workhorse is RSS::Parser#parse, which takes the source of
+# the feed and a parameter that performs validation on the feed. We get back an
+# object that has all of the data from our feed, accessible through methods.
+# This example shows getting the title out of the channel element, and looping
+# through the list of items.
+#
+# == Producing RSS
+#
+# Producing our own RSS feeds is easy as well. Let's make a very basic feed:
+#
+#   require "rss"
+#
+#   rss = RSS::Maker.make("atom") do |maker|
+#     maker.channel.author = "matz"
+#     maker.channel.updated = Time.now.to_s
+#     maker.channel.about = "http://www.ruby-lang.org/en/feeds/news.rss"
+#     maker.channel.title = "Example Feed"
+#
+#     maker.items.new_item do |item|
+#       item.link = "http://www.ruby-lang.org/en/news/2010/12/25/ruby-1-9-2-p136-is-released/"
+#       item.title = "Ruby 1.9.2-p136 is released"
+#       item.updated = Time.now.to_s
+#     end
+#   end
+#
+#   puts rss
+#
+# As you can see, this is a very Builder-like DSL. This code will spit out an
+# Atom feed with one item. If we needed a second item, we'd make another block
+# with maker.items.new_item and build a second one.
+#
+# == Copyright
+#
+# Copyright (c) 2003-2007 Kouhei Sutou <kou@cozmixng.org>
+#
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+# There is an additional tutorial by the author of RSS at:
+# http://www.cozmixng.org/~rwiki/?cmd=view;name=RSS+Parser%3A%3ATutorial.en
+
+module RSS
+end
+
+require 'rss/1.0'
+require 'rss/2.0'
+require 'rss/atom'
+require 'rss/content'
+require 'rss/dublincore'
+require 'rss/image'
+require 'rss/itunes'
+require 'rss/slash'
+require 'rss/syndication'
+require 'rss/taxonomy'
+require 'rss/trackback'
+
+require "rss/maker"

data/lib/rss/0.9.rb

@@ -0,0 +1,462 @@
+# frozen_string_literal: false
+require_relative "parser"
+
+module RSS
+
+  ##
+  # = RSS 0.9 support
+  #
+  # RSS has three different versions. This module contains support for version
+  # 0.9.1[http://www.rssboard.org/rss-0-9-1-netscape].
+  #
+  # == Producing RSS 0.9
+  #
+  # Producing our own RSS feeds is easy as well. Let's make a very basic feed:
+  #
+  #  require "rss"
+  #
+  #  rss = RSS::Maker.make("0.91") do |maker|
+  #    maker.channel.language = "en"
+  #    maker.channel.author = "matz"
+  #    maker.channel.updated = Time.now.to_s
+  #    maker.channel.link = "http://www.ruby-lang.org/en/feeds/news.rss"
+  #    maker.channel.title = "Example Feed"
+  #    maker.channel.description = "A longer description of my feed."
+  #    maker.image.url = "http://www.ruby-lang.org/images/logo.gif"
+  #    maker.image.title = "An image"
+  #    maker.items.new_item do |item|
+  #      item.link = "http://www.ruby-lang.org/en/news/2010/12/25/ruby-1-9-2-p136-is-released/"
+  #      item.title = "Ruby 1.9.2-p136 is released"
+  #      item.updated = Time.now.to_s
+  #    end
+  #  end
+  #
+  #  puts rss
+  #
+  # As you can see, this is a very Builder-like DSL. This code will spit out an
+  # RSS 0.9 feed with one item. If we needed a second item, we'd make another
+  # block with maker.items.new_item and build a second one.
+  module RSS09
+    NSPOOL = {}
+    ELEMENTS = []
+
+    def self.append_features(klass)
+      super
+
+      klass.install_must_call_validator('', "")
+    end
+  end
+
+  class Rss < Element
+
+    include RSS09
+    include RootElementMixin
+
+    %w(channel).each do |name|
+      install_have_child_element(name, "", nil)
+    end
+
+    attr_writer :feed_version
+    alias_method(:rss_version, :feed_version)
+    alias_method(:rss_version=, :feed_version=)
+
+    def initialize(feed_version, version=nil, encoding=nil, standalone=nil)
+      super
+      @feed_type = "rss"
+    end
+
+    def items
+      if @channel
+        @channel.items
+      else
+        []
+      end
+    end
+
+    def image
+      if @channel
+        @channel.image
+      else
+        nil
+      end
+    end
+
+    def textinput
+      if @channel
+        @channel.textInput
+      else
+        nil
+      end
+    end
+
+    def setup_maker_elements(maker)
+      super
+      items.each do |item|
+        item.setup_maker(maker.items)
+      end
+      image.setup_maker(maker) if image
+      textinput.setup_maker(maker) if textinput
+    end
+
+    private
+    def _attrs
+      [
+        ["version", true, "feed_version"],
+      ]
+    end
+
+    class Channel < Element
+
+      include RSS09
+
+      [
+        ["title", nil, :text],
+        ["link", nil, :text],
+        ["description", nil, :text],
+        ["language", nil, :text],
+        ["copyright", "?", :text],
+        ["managingEditor", "?", :text],
+        ["webMaster", "?", :text],
+        ["rating", "?", :text],
+        ["pubDate", "?", :date, :rfc822],
+        ["lastBuildDate", "?", :date, :rfc822],
+        ["docs", "?", :text],
+        ["cloud", "?", :have_attribute],
+        ["skipDays", "?", :have_child],
+        ["skipHours", "?", :have_child],
+        ["image", nil, :have_child],
+        ["item", "*", :have_children],
+        ["textInput", "?", :have_child],
+      ].each do |name, occurs, type, *args|
+        __send__("install_#{type}_element", name, "", occurs, name, *args)
+      end
+      alias date pubDate
+      alias date= pubDate=
+
+      private
+      def maker_target(maker)
+        maker.channel
+      end
+
+      def setup_maker_elements(channel)
+        super
+        [
+          [skipDays, "day"],
+          [skipHours, "hour"],
+        ].each do |skip, key|
+          if skip
+            skip.__send__("#{key}s").each do |val|
+              target_skips = channel.__send__("skip#{key.capitalize}s")
+              new_target = target_skips.__send__("new_#{key}")
+              new_target.content = val.content
+            end
+          end
+        end
+      end
+
+      def not_need_to_call_setup_maker_variables
+        %w(image textInput)
+      end
+
+      class SkipDays < Element
+        include RSS09
+
+        [
+          ["day", "*"]
+        ].each do |name, occurs|
+          install_have_children_element(name, "", occurs)
+        end
+
+        class Day < Element
+          include RSS09
+
+          content_setup
+
+          def initialize(*args)
+            if Utils.element_initialize_arguments?(args)
+              super
+            else
+              super()
+              self.content = args[0]
+            end
+          end
+
+        end
+
+      end
+
+      class SkipHours < Element
+        include RSS09
+
+        [
+          ["hour", "*"]
+        ].each do |name, occurs|
+          install_have_children_element(name, "", occurs)
+        end
+
+        class Hour < Element
+          include RSS09
+
+          content_setup(:integer)
+
+          def initialize(*args)
+            if Utils.element_initialize_arguments?(args)
+              super
+            else
+              super()
+              self.content = args[0]
+            end
+          end
+        end
+
+      end
+
+      class Image < Element
+
+        include RSS09
+
+        %w(url title link).each do |name|
+          install_text_element(name, "", nil)
+        end
+        [
+          ["width", :integer],
+          ["height", :integer],
+          ["description"],
+        ].each do |name, type|
+          install_text_element(name, "", "?", name, type)
+        end
+
+        def initialize(*args)
+          if Utils.element_initialize_arguments?(args)
+            super
+          else
+            super()
+            self.url = args[0]
+            self.title = args[1]
+            self.link = args[2]
+            self.width = args[3]
+            self.height = args[4]
+            self.description = args[5]
+          end
+        end
+
+        private
+        def maker_target(maker)
+          maker.image
+        end
+      end
+
+      class Cloud < Element
+
+        include RSS09
+
+        [
+          ["domain", "", true],
+          ["port", "", true, :integer],
+          ["path", "", true],
+          ["registerProcedure", "", true],
+          ["protocol", "", true],
+        ].each do |name, uri, required, type|
+          install_get_attribute(name, uri, required, type)
+        end
+
+        def initialize(*args)
+          if Utils.element_initialize_arguments?(args)
+            super
+          else
+            super()
+            self.domain = args[0]
+            self.port = args[1]
+            self.path = args[2]
+            self.registerProcedure = args[3]
+            self.protocol = args[4]
+          end
+        end
+      end
+
+      class Item < Element
+
+        include RSS09
+
+        [
+          ["title", '?', :text],
+          ["link", '?', :text],
+          ["description", '?', :text],
+          ["category", '*', :have_children, "categories"],
+          ["source", '?', :have_child],
+          ["enclosure", '?', :have_child],
+        ].each do |tag, occurs, type, *args|
+          __send__("install_#{type}_element", tag, "", occurs, tag, *args)
+        end
+
+        private
+        def maker_target(items)
+          if items.respond_to?("items")
+            # For backward compatibility
+            items = items.items
+          end
+          items.new_item
+        end
+
+        def setup_maker_element(item)
+          super
+          @enclosure.setup_maker(item) if @enclosure
+          @source.setup_maker(item) if @source
+        end
+
+        class Source < Element
+
+          include RSS09
+
+          [
+            ["url", "", true]
+          ].each do |name, uri, required|
+            install_get_attribute(name, uri, required)
+          end
+
+          content_setup
+
+          def initialize(*args)
+            if Utils.element_initialize_arguments?(args)
+              super
+            else
+              super()
+              self.url = args[0]
+              self.content = args[1]
+            end
+          end
+
+          private
+          def maker_target(item)
+            item.source
+          end
+
+          def setup_maker_attributes(source)
+            source.url = url
+            source.content = content
+          end
+        end
+
+        class Enclosure < Element
+
+          include RSS09
+
+          [
+            ["url", "", true],
+            ["length", "", true, :integer],
+            ["type", "", true],
+          ].each do |name, uri, required, type|
+            install_get_attribute(name, uri, required, type)
+          end
+
+          def initialize(*args)
+            if Utils.element_initialize_arguments?(args)
+              super
+            else
+              super()
+              self.url = args[0]
+              self.length = args[1]
+              self.type = args[2]
+            end
+          end
+
+          private
+          def maker_target(item)
+            item.enclosure
+          end
+
+          def setup_maker_attributes(enclosure)
+            enclosure.url = url
+            enclosure.length = length
+            enclosure.type = type
+          end
+        end
+
+        class Category < Element
+
+          include RSS09
+
+          [
+            ["domain", "", false]
+          ].each do |name, uri, required|
+            install_get_attribute(name, uri, required)
+          end
+
+          content_setup
+
+          def initialize(*args)
+            if Utils.element_initialize_arguments?(args)
+              super
+            else
+              super()
+              self.domain = args[0]
+              self.content = args[1]
+            end
+          end
+
+          private
+          def maker_target(item)
+            item.new_category
+          end
+
+          def setup_maker_attributes(category)
+            category.domain = domain
+            category.content = content
+          end
+
+        end
+
+      end
+
+      class TextInput < Element
+
+        include RSS09
+
+        %w(title description name link).each do |name|
+          install_text_element(name, "", nil)
+        end
+
+        def initialize(*args)
+          if Utils.element_initialize_arguments?(args)
+            super
+          else
+            super()
+            self.title = args[0]
+            self.description = args[1]
+            self.name = args[2]
+            self.link = args[3]
+          end
+        end
+
+        private
+        def maker_target(maker)
+          maker.textinput
+        end
+      end
+
+    end
+
+  end
+
+  RSS09::ELEMENTS.each do |name|
+    BaseListener.install_get_text_element("", name, name)
+  end
+
+  module ListenerMixin
+    private
+    def initial_start_rss(tag_name, prefix, attrs, ns)
+      check_ns(tag_name, prefix, ns, "", false)
+
+      @rss = Rss.new(attrs['version'], @version, @encoding, @standalone)
+      @rss.do_validate = @do_validate
+      @rss.xml_stylesheets = @xml_stylesheets
+      @last_element = @rss
+      pr = Proc.new do |text, tags|
+        @rss.validate_for_stream(tags, @ignore_unknown_element) if @do_validate
+      end
+      @proc_stack.push(pr)
+    end
+
+  end
+
+end