libxml-feed 0.0.1

data/lib/xml/libxml/feed.rb

@@ -0,0 +1,15 @@
+begin
+    require 'rubygems'
+    gem 'libxml-ruby'
+rescue LoadError => e
+end
+
+require 'xml/libxml'
+require 'xml/libxml/feed/parser'
+require 'xml/libxml/feed/builder'
+
+module XML
+    module Feed
+        VERSION = "0.0.1"
+    end
+end

data/lib/xml/libxml/feed/builder.rb

@@ -0,0 +1,10 @@
+module XML
+    module Feed
+        module Builder
+            def self.method_missing(method, *args)
+                require "xml/libxml/feed/builders/#{method.to_s.downcase}"
+                return self.const_get(method.to_s.capitalize).new(*args)
+            end
+        end
+    end
+end

data/lib/xml/libxml/feed/builders/rss.rb

@@ -0,0 +1,144 @@
+class XML::Feed::Builder::Rss
+    class Channels
+        include Enumerable
+
+        attr_reader :doc
+
+        def initialize(doc)
+            @doc = doc
+        end
+
+        def create
+            node = Channel.new(@doc)
+            yield node 
+            @doc.root << node.node
+        end
+
+        def each
+            @doc.root.find('/rss/channel').each do |x|
+                yield Channel.new(@doc, x)
+            end
+        end
+
+        def [](x)
+            return Channel.new(@doc, @doc.root.find('/rss/channel').to_a[x])
+        end
+    end
+
+    class Channel
+        attr_reader :doc
+        attr_reader :node
+
+        def initialize(doc, node=nil)
+            @doc = doc
+            @node = node
+            @node = XML::Node.new("channel") unless @node
+        end
+
+        def items
+            return Items.new(@doc, @node)
+        end
+
+        alias item items
+    end
+
+    class Items
+        include Enumerable
+
+        def initialize(doc, channel)
+            @doc = doc
+            @channel = channel
+        end
+
+        def create
+            node = Item.new(@channel)
+            yield node
+            @channel << node.node
+        end
+
+        def each
+            @channel.find('./item').each do |x|
+                yield Item.new(@channel, x)
+            end
+        end
+
+        def [](x)
+            return Item.new(@channel, @channel.find('./item').to_a[x])
+        end
+    end
+
+    class Item
+        attr_reader :channel
+        attr_reader :node
+
+        def initialize(channel, node=nil)
+            @channel = channel
+            @node    = node
+
+            @node = XML::Node.new('item') unless @node
+            @params = Hash.new
+        end
+
+        # basic parameters that just get enclosed by a <tag>. More involved
+        # stuff should create it's own pair of methods.
+        def method_missing(method, *args)
+            meth = method.to_s 
+            if meth =~ /=$/ # assignment
+                my_meth = meth.sub(/=$/, '')
+
+                node = XML::Node.new(my_meth)
+                node.content = args[0].to_s
+                @node << node
+                return node
+            end
+
+            # if we're reading, we want to collect each node that matches our method name.
+            # the problem is, XML::XPath::Object#find doesn't work on detached nodes, which ours
+            # is at this state. So we have to search manually.
+           
+            array = []    
+
+            @node.each do |x|
+                if x.name == meth 
+                    array.push x
+                end
+            end
+
+            return array.length > 1 ? array : array[0]
+        end
+    end
+end
+
+class XML::Feed::Builder::Rss
+
+    attr_accessor :version
+    attr_accessor :doc
+
+    def initialize(version, parser=nil)
+        @version = version
+        @parser  = parser
+
+        build_document
+    end
+
+    def to_xml
+        @doc.to_s
+    end
+
+    def channel
+        return Channels.new(@doc)
+    end
+
+    protected
+
+    def build_document
+        if @parser
+            @doc = @parser.doc
+        else
+            @doc = XML::Document.new
+            @doc.root = XML::Node.new("rss")
+        end
+
+        @doc.root["version"] = @version
+    end
+end

data/lib/xml/libxml/feed/parser.rb

@@ -0,0 +1,87 @@
+module XML
+    module Feed
+        module Parser
+            def self.method_missing(method, *args)
+                require "xml/libxml/feed/parsers/#{method.to_s.downcase}"
+                return self.const_get(method.to_s.capitalize).new(*args)
+            end
+
+            class InvalidHandle < Exception
+            end
+
+            class ValidationError < Exception
+            end
+            
+            class Tag
+                attr_reader :property
+                attr_reader :data
+
+                def initialize(name, data, properties)
+                    if properties
+                        @property = properties.to_h.dup 
+                    else
+                        @property = { }
+                    end
+
+                    if data
+                        @data = data
+                    else
+                        @data = ""
+                    end
+
+                    @name = name.dup
+                end
+
+                def to_s
+                    @data.to_s
+                end
+
+                alias to_str to_s
+            end
+
+            class Base 
+                attr_reader :xml
+                attr_reader :version
+                attr_reader :validated
+                attr_reader :doc
+
+                def initialize(version, io, auto_validate=true)
+                    @version = version
+
+                    case io
+                    when IO
+                        @xml = io.read
+                        io.close
+                    when StringIO
+                        @xml = io.read
+                        io.close
+                    when String
+                        @xml = io.dup
+                    else
+                        raise XML::Feed::Parser::InvalidHandle, "Must be IO, StringIO, or String object"
+                    end
+
+                    @xml.freeze
+                    @version.freeze
+                    @validated = false
+
+                    if @xml.length == 0
+                        raise XML::Feed::Parser::InvalidHandle, "Resulting XML String must have a length greater than 0"
+                    end
+
+                    @doc = XML::Parser.string(@xml).parse
+
+                    if auto_validate 
+                        validate!
+                    end
+                end
+
+                protected 
+
+                def validation_error(error_string)
+                    raise ValidationError, error_string
+                end
+            end
+        end
+    end
+end

data/lib/xml/libxml/feed/parsers/rss.rb

@@ -0,0 +1,113 @@
+module XML
+    module Feed
+        module Parser
+            class Rss < XML::Feed::Parser::Base
+                require 'xml/libxml/feed/parsers/rss/channel'
+                require 'xml/libxml/feed/parsers/rss/item'
+
+                def initialize(version, io, auto_validate=true)
+                    super
+                end
+
+                def validate!
+                    case @version
+                    when '2.0'
+                        validate_20
+                    else
+                        validation_error "Validating RSS version #{@version} is not supported (yet!)"
+                    end
+
+                    @validated = true
+                end
+
+                def channel
+                    channels = []
+                    @doc.find('/rss/channel').each do |x|
+                        channels.push(Channel.new(x))
+                    end
+
+                    return channels
+                end
+
+                protected
+
+                #
+                # Given a node, an xpath expression to apply to that node, the
+                # error_message is thrown via validation_error() if the block
+                # evaluates to a false value or it raises an exception itself.
+                #
+                def validate_xpath(node, xpath, error_message, &block)
+                    node = node.find(xpath)
+
+                    result = true
+
+                    if node and node.first
+                        begin 
+                            result = yield node.first.content
+                        rescue Exception => e
+                            validation_error error_message
+                        end
+                    end
+
+                    validation_error error_message unless result
+                end
+
+                # all the validation rules for RSS 2.0 that are fit to print.
+                def validate_20
+                    validation_error "Document Root is not named 'rss'" unless @doc.root.name.downcase == "rss"
+                    validation_error "Document Version does not exist"  unless @doc.root["version"]
+                    validation_error "Document Version is not '2.0'"    unless @doc.root["version"] == "2.0"
+                    validation_error "Channel elements do not exist"    if     @doc.find('/rss/channel').length == 0
+
+                    @doc.find('/rss/channel').each_with_index do |node, i|
+
+                        validate_20_channel(node, i)
+
+                        if items = node.find('./item')
+                            items.each_with_index do |item, item_i|
+                                validation_error "Item must contain a title or description" unless item.find('./title').first or item.find('./description').first
+                                validate_xpath(item, './pubDate', "Channel #{i} item #{item_i} element pubDate does not parse as a rfc822 time") do |x|
+                                    Time.rfc2822(x)
+                                end
+                                validate_xpath(item, './link', "Channel #{i} item #{item_i} element link does not parse as a URI") do |x|
+                                    URI.parse(x)
+                                end
+                            end
+                        end
+                    end
+                end
+
+                def validate_20_channel(node, i)
+                    %w(title link description).each do |x|
+                        validation_error "Channel node #{i} does not have a #{x} element"   unless node.find('./' + x).length > 0
+                        validation_error "Channel node #{i} has more than one #{x} element" if node.find('./' + x).length > 1
+                    end
+                    %w(link docs).each do |uri|
+                        validate_xpath(node, "./#{uri}", "Channel #{i} element #{uri} does not parse as a URI") do |x|
+                            URI.parse(x)
+                        end
+                    end
+                    %w(pubDate lastBuildDate).each do |t|
+                        validate_xpath(node, "./#{t}", "Channel #{i} element #{t} does not parse as a rfc822 time") do |x|
+                            Time.rfc2822(x)
+                        end
+                    end
+                    validate_xpath(node, './ttl', 'Channel #{i} element ttl is not an integer') do |x|
+                        x.to_i.to_s == x
+                    end
+                    if node.find('./cloud')
+                        #warn "Cloud support is currently not implemented"
+                    end
+                    if image = node.find('./image')
+                        %w(url link).each do |ele|
+                            validate_xpath(node, "./image/#{ele}", "Channel #{i} element image/#{ele} does not parse as a URI") do |x|
+                                URI.parse(x)
+                            end
+                        end
+                        validation_error "Title element must exist in Channel #{i} element image" unless node.find('./title').length > 0
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/xml/libxml/feed/parsers/rss/channel.rb

@@ -0,0 +1,14 @@
+require 'xml/libxml/feed/parsers/rss/common'
+
+class XML::Feed::Parser::Rss::Channel
+    include XML::Feed::Parser::Rss::Common
+
+    def item
+        items = []
+        @node.find('./item').each do |x|
+            items.push XML::Feed::Parser::Rss::Item.new(x)
+        end
+
+        return items
+    end
+end

data/lib/xml/libxml/feed/parsers/rss/common.rb

@@ -0,0 +1,47 @@
+module XML::Feed::Parser::Rss::Common
+    attr_reader :node
+
+    def initialize(node)
+        @node = node
+    end
+
+    def method_missing(methId, *args)
+        requested = @node.find("./#{methId.to_s}")
+        if requested.first
+            if requested.length > 1
+                array = []
+                requested.each do |x|
+                    array.push XML::Feed::Parser::Tag.new(x.name, type_node(x), x.properties)
+                end
+
+                return array
+            else
+                r = requested.first
+                return XML::Feed::Parser::Tag.new(r.name, type_node(r), r.properties)
+            end
+        end
+
+        return nil
+    end
+
+    protected
+
+    def type_node(node)
+        case node.name
+        when 'pubDate'
+            Time.rfc2822(node.content)
+        when 'lastBuildDate'
+            Time.rfc2822(node.content)
+        when 'docs'
+            URI.parse(node.content)
+        when 'link'
+            URI.parse(node.content)
+        when 'url'
+            URI.parse(node.content)
+        when 'ttl'
+            node.content.to_i
+        else
+            node.content
+        end
+    end
+end

data/lib/xml/libxml/feed/parsers/rss/item.rb

@@ -0,0 +1,5 @@
+require 'xml/libxml/feed/parsers/rss/common'
+
+class XML::Feed::Parser::Rss::Item
+    include XML::Feed::Parser::Rss::Common
+end

data/test/test_builder_interface.rb

@@ -0,0 +1,127 @@
+require 'test/unit'
+require 'xml/libxml/feed'
+require 'stringio'
+
+class TestBuilderInterface < Test::Unit::TestCase
+
+    def test_loader
+        builder = nil
+        assert_nothing_raised do
+            builder = XML::Feed::Builder.rss('2.0')
+        end
+
+        assert_instance_of(XML::Feed::Builder::Rss, builder)
+
+        # test with a parser
+        parser = nil
+        assert_nothing_raised do
+            parser = XML::Feed::Parser.rss('2.0', File.open('test/data/valid-2.0-rss.xml'), true)
+        end
+
+        assert_instance_of(XML::Feed::Parser::Rss, parser)
+
+        assert_nothing_raised do
+            builder = XML::Feed::Builder.rss('2.0', parser)
+        end
+
+        assert_instance_of(XML::Feed::Builder::Rss, builder)
+    end
+
+    def test_output
+        builder = nil
+
+        assert_nothing_raised do
+            builder = XML::Feed::Builder.rss("2.0")
+        end
+
+        assert_equal("<?xml version=\"1.0\"?>\n<rss version=\"2.0\"/>\n", builder.to_xml)
+
+        parser = nil
+
+        #
+        # Tests that the builder and parser interoperate.
+        #
+
+        assert_nothing_raised do
+            parser = XML::Feed::Parser.rss('2.0', File.open('test/data/valid-2.0-rss.xml'), true)
+        end
+
+        assert_nothing_raised do
+            builder = XML::Feed::Builder.rss("2.0", parser)
+        end
+
+        assert_equal(parser.doc.to_s, builder.to_xml)
+
+        #
+        # Tests that we can build a basic set of rss data.
+        #
+
+        assert_nothing_raised do
+            builder = XML::Feed::Builder.rss("2.0")
+        end
+
+        assert_nothing_raised do
+            builder.channel.create do |x|
+                x.items.create do |y|
+                    y.title = "Bar"
+                    y.description = "Foo"
+                    y.link = URI.parse("http://funky.cold.medina.com")
+                end
+            end
+        end
+
+        assert_equal(
+            "<?xml version=\"1.0\"?>\n<rss version=\"2.0\">\n  <channel>\n    <item>\n      <title>Bar</title>\n      <description>Foo</description>\n      <link>http://funky.cold.medina.com</link>\n    </item>\n  </channel>\n</rss>\n",
+             builder.to_xml
+        )
+
+        #
+        # Tests that we can create a basic set of RSS data in an item and append it to parsed data.
+        #
+
+        assert_nothing_raised do
+            builder = XML::Feed::Builder.rss("2.0", parser)
+        end
+
+        assert_nothing_raised do
+            builder.channel[0].items.create do |y|
+                y.title = "Bar"
+                y.description = "Foo"
+                y.link = URI.parse("http://funky.cold.medina.com")
+            end
+        end
+
+        assert_equal(File.open("test/data/valid-2.0-rss-build1.xml").read.gsub(/\r/, ''), builder.to_xml)
+
+        #
+        # Tests that we can create elements in an item that have properties.       
+        # 
+
+        assert_nothing_raised do
+            parser = XML::Feed::Parser.rss('2.0', File.open('test/data/valid-2.0-rss.xml'), true)
+            builder = XML::Feed::Builder.rss("2.0", parser)
+        end
+
+        assert_nothing_raised do
+            builder.channel[0].items.create do |y|
+                y.title = "Bar"
+                y.description = "Foo"
+                y.link = URI.parse("http://funky.cold.medina.com")
+                y.category = "my_category"
+                y.category["domain"] = "alt.swedish.chef.bork.bork.bork"
+            end
+        end
+
+        assert_equal(File.open("test/data/valid-2.0-rss-build2.xml").read.gsub(/\r/, ''), builder.to_xml)
+
+        # tests two things:
+        # 1) title only returns one object, and therefore isn't boxed
+        # 2) tests that we get data that is parsed as well as created
+       
+        assert_kind_of(XML::Node, builder.channel[0].item[0].title)
+        assert_equal(builder.channel[0].item[0].title.content, "Seventh Heaven! Ryan Hurls Another No Hitter")
+
+        assert_kind_of(XML::Node, builder.channel[0].item[-1].title)
+        assert_equal(builder.channel[0].item[-1].title.content, "Bar")
+    end
+end

data/test/test_parser_interface.rb

@@ -0,0 +1,71 @@
+require 'test/unit'
+require 'xml/libxml/feed'
+require 'stringio'
+
+class TestParserInterface < Test::Unit::TestCase
+    def test_loader
+        parser = nil
+        assert_nothing_raised do 
+            parser = XML::Feed::Parser.rss('2.0', "<rss></rss>", false)
+        end
+
+        assert_instance_of(XML::Feed::Parser::Rss, parser)
+    end
+
+    # tests various forms of IO that can be passed to the constructors for the default parsers
+    def test_IO_acceptance
+        assert_nothing_raised do
+            XML::Feed::Parser.rss('2.0', '<rss></rss>', false)
+        end
+
+        assert_nothing_raised do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/basic.xml', 'r'), false)
+        end
+
+        assert_nothing_raised do
+            XML::Feed::Parser.rss('2.0', StringIO.new("<rss></rss>"), false)
+        end
+
+        assert_raise(XML::Feed::Parser::InvalidHandle) do
+            XML::Feed::Parser.rss('2.0', Array.new, false)
+        end
+
+        assert_raise(XML::Feed::Parser::InvalidHandle) do
+            XML::Feed::Parser.rss('2.0', '', false)
+        end
+    end
+
+    def test_base_accessors
+        parser = nil
+
+        assert_nothing_raised do
+            parser = XML::Feed::Parser.rss('2.0', '<rss></rss>', false)
+        end
+
+        assert_equal('<rss></rss>', parser.xml)
+        assert_equal('2.0', parser.version)
+
+        assert_nothing_raised do
+            parser = XML::Feed::Parser.rss('1.0', File.open('test/data/basic.xml', 'r'), false)
+        end
+
+        assert_equal(File.open('test/data/basic.xml').read, parser.xml)
+        assert_equal('1.0', parser.version)
+        
+        assert_nothing_raised do
+            parser = XML::Feed::Parser.rss('2.0', StringIO.new('<rss></rss>'), false)
+        end
+
+        assert_equal('<rss></rss>', parser.xml)
+        assert_equal('2.0', parser.version)
+        assert(!parser.validated)
+
+        assert_nothing_raised do
+            parser = XML::Feed::Parser.rss('2.0', File.open('test/data/valid-2.0-rss.xml', 'r'), true)
+        end
+
+        assert_equal(File.open('test/data/valid-2.0-rss.xml').read, parser.xml)
+        assert_equal('2.0', parser.version)
+        assert(parser.validated)
+    end
+end

data/test/test_rss_parser.rb

@@ -0,0 +1,165 @@
+require 'test/unit'
+require 'xml/libxml/feed'
+
+class TestRssParser < Test::Unit::TestCase
+
+    def test_rss_interface
+        parser = nil
+
+        assert_nothing_raised do
+            parser = XML::Feed::Parser.rss('2.0', File.open('test/data/valid-2.0-rss.xml'), true)
+        end
+        
+        assert(parser.channel)
+        assert_kind_of(Array, parser.channel)
+        assert_kind_of(XML::Feed::Parser::Rss::Channel, parser.channel[0])
+
+        assert(parser.channel[0].pubDate)
+        assert_kind_of(XML::Feed::Parser::Tag, parser.channel[0].pubDate)
+        assert_kind_of(Time, parser.channel[0].pubDate.data)
+        assert_kind_of(Hash, parser.channel[0].pubDate.property)
+
+        assert(parser.channel[0].lastBuildDate)
+        assert_kind_of(XML::Feed::Parser::Tag, parser.channel[0].lastBuildDate)
+        assert_kind_of(Time, parser.channel[0].lastBuildDate.data)
+        assert_kind_of(Hash, parser.channel[0].lastBuildDate.property)
+
+        assert(parser.channel[0].link)
+        assert_kind_of(XML::Feed::Parser::Tag, parser.channel[0].link)
+        assert_kind_of(URI, parser.channel[0].link.data)
+        assert_kind_of(Hash, parser.channel[0].link.property)
+
+        assert(parser.channel[0].docs)
+        assert_kind_of(XML::Feed::Parser::Tag, parser.channel[0].docs)
+        assert_kind_of(URI, parser.channel[0].docs.data)
+        assert_kind_of(Hash, parser.channel[0].docs.property)
+
+        assert(parser.channel[0].ttl)
+        assert_kind_of(XML::Feed::Parser::Tag, parser.channel[0].ttl)
+        assert_kind_of(Numeric, parser.channel[0].ttl.data)
+        assert_kind_of(Hash, parser.channel[0].ttl.property)
+
+        assert(parser.channel[0].item)
+        assert_kind_of(Array, parser.channel[0].item)
+
+        parser.channel[0].item.each do |item|
+            assert_kind_of(XML::Feed::Parser::Rss::Item, item)
+            if item.link
+                assert_kind_of(XML::Feed::Parser::Tag, item.link)
+                assert_nothing_raised do
+                    "string" + item.link
+                end
+                assert_kind_of(URI, item.link.data)
+                assert_kind_of(Hash, item.link.property)
+            end
+            if item.description
+                assert_kind_of(XML::Feed::Parser::Tag, item.description)
+                assert_nothing_raised do
+                    "string" + item.description
+                end
+                assert_kind_of(String, item.description.data)
+                assert_kind_of(Hash, item.description.property)
+            end
+            if item.title
+                assert_kind_of(XML::Feed::Parser::Tag, item.title)
+                assert_nothing_raised do
+                    "string" + item.title
+                end
+                assert_kind_of(String, item.title.data)
+                assert_kind_of(Hash, item.title.property)
+            end
+        end
+    end
+
+    def test_validate_rss
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('1.0', File.open('test/data/valid-2.0-rss.xml'), true)
+        end
+    end
+
+    def test_validate_rss_20
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/basic.xml'), true)
+        end
+
+        # test a valid one first
+        assert_nothing_raised do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/valid-2.0-rss.xml'), true)
+        end
+        
+        # test without the version
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/bad-root-2.0-rss.xml'), true)
+        end
+
+        # test without the version
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/missing-version-2.0-rss.xml'), true)
+        end
+        
+        # invalid version
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/invalid-version-2.0-rss.xml'), true)
+        end
+        
+        # missing channel 
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/missing-channel-2.0-rss.xml'), true)
+        end
+        
+        # missing channel title
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/missing-channel-title-2.0-rss.xml'), true)
+        end
+        
+        # missing channel link 
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/missing-channel-link-2.0-rss.xml'), true)
+        end
+        
+        # missing channel description 
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/missing-channel-description-2.0-rss.xml'), true)
+        end
+
+        # duplicate channel title 
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/duplicate-channel-title-2.0-rss.xml'), true)
+        end
+
+        # duplicate channel link 
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/duplicate-channel-link-2.0-rss.xml'), true)
+        end
+        
+        # duplicate channel description 
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/duplicate-channel-description-2.0-rss.xml'), true)
+        end
+        
+        # bad URI
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/bad-uri-2.0-rss.xml'), true)
+        end
+        
+        # bad pubDate
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/bad-pubdate-2.0-rss.xml'), true)
+        end
+        
+        # bad ttl
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/bad-ttl-2.0-rss.xml'), true)
+        end
+
+        # bad image 
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/bad-image-2.0-rss.xml'), true)
+        end
+       
+        # bad item
+        assert_raise(XML::Feed::Parser::ValidationError) do
+            XML::Feed::Parser.rss('2.0', File.open('test/data/bad-item-2.0-rss.xml'), true)
+        end
+    end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: libxml-feed
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2008-01-05 00:00:00 -08:00
+summary: Provides a alternative and faster feed (RSS, Atom, et al) parsing layer through libxml's parsing framework
+require_paths: 
+- lib
+email: erik@hollensbe.org
+homepage: 
+rubyforge_project: libxml-tools
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Erik Hollensbe
+files: 
+- lib/xml
+- lib/xml/libxml
+- lib/xml/libxml/feed
+- lib/xml/libxml/feed/builder.rb
+- lib/xml/libxml/feed/builders
+- lib/xml/libxml/feed/builders/rss.rb
+- lib/xml/libxml/feed/parser.rb
+- lib/xml/libxml/feed/parsers
+- lib/xml/libxml/feed/parsers/rss
+- lib/xml/libxml/feed/parsers/rss/channel.rb
+- lib/xml/libxml/feed/parsers/rss/common.rb
+- lib/xml/libxml/feed/parsers/rss/item.rb
+- lib/xml/libxml/feed/parsers/rss.rb
+- lib/xml/libxml/feed.rb
+- test/data
+- test/test_builder_interface.rb
+- test/test_parser_interface.rb
+- test/test_rss_parser.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: libxml-ruby
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: