saxy 0.2.3 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 923e7d1c218d9e304ee18fb87f6f2a1a9d06d384
-  data.tar.gz: 79b769b7699aee8503635fdfdc10b09afb9665a2
+  metadata.gz: 52a8b74342fe631ae2787bd38fedcb3600b24730
+  data.tar.gz: 37ef8a7e143494b48ba13c3d7470c84e459d0bf7
 SHA512:
-  metadata.gz: edc331020d4c82df9b1d84656699b1060a6a9ee2324032a4a792208b1a991dadfc23c1668db1f2719c30afe967dd2f57f06bf2eafc61e410808a62bcbef44f8d
-  data.tar.gz: e140b6138c76e6fa602f4ce4a5a284b0b0213235057ea78da5202871bd85fce1e0df0441010eea5b1aee915c188b8520885a66fa9aa518c595e65a5d61ee502d
+  metadata.gz: 468d1551a3fdafc0c0b37cdffb5482f1ecd5cf2fac2c8f63b23c7d75dc38c1d13b47ac8a7d195b8031251d62a5ea13492674cf418f25cf732d30e073a8f99f9b
+  data.tar.gz: d026bfaa8643b1eeb12ce00eecc13e4f1d27e531308706e14d05f1a9bc2d22755a5e2479482d5024ce298732373ea62498314d083fe4a2fa2aa8e5da3399c6a9

data/.gitignore

@@ -3,7 +3,7 @@
 .bundle
 .config
 .yardoc
-Gemfile.lock
+*emfile.lock
 InstalledFiles
 _yardoc
 coverage

data/.travis.yml

@@ -1,14 +1,20 @@
 script: "bundle exec rspec ./spec/"
+sudo: false
 language: ruby
 rvm:
+  - 2.5
+  - 2.4
+  - 2.3
+  - 2.2
+  - 2.1
   - 2.0.0
   - 1.9.3
-  - 1.9.2
+gemfile:
+  - gemfiles/nokogiri_1.6.gemfile
+  - gemfiles/nokogiri_latest.gemfile
 matrix:
-  include:
-    - rvm: 1.8.7
-      gemfile: gemfiles/1.8
-    - rvm: ree
-      gemfile: gemfiles/1.8
-
-
+  exclude:
+    - rvm: 2.0.0
+      gemfile: gemfiles/nokogiri_latest.gemfile
+    - rvm: 1.9.3
+      gemfile: gemfiles/nokogiri_latest.gemfile

data/Appraisals

@@ -0,0 +1,7 @@
+appraise "nokogiri 1.6" do
+  gem "nokogiri", "~> 1.6.0"
+end
+
+appraise "nokogiri latest" do
+  gem "nokogiri"
+end

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Saxy Changelog
+
+## 0.7.1
+
+* Fixed whitespace stripping from elements' contents, now only leading and trailing whitespace is stripped (reported by @wzcolon, thanks!).
+* Added `error_handler` option to make it possible to handle errors on-the-fly instead of raising them.
+
+## 0.7.0
+
+* [BREAKING] Yielded hashes now have strings as keys instead of symbols (performance and security fix).
+
+## 0.6.1
+
+* Fixed passing options from `Saxy.parse` to parser's initializer
+
+## 0.6.0
+
+* [BREAKING] `Saxy::ParsingError` now inherits from `StandardError`, not `Exception`.
+* [BREAKING] Forced encoding is now an option instead of third argument of `Saxy.parse` method.
+* Added `recovery` and `replace_entities` options that are internally passed to `Nokogiri::XML::SAX::ParserContext`
+* Added `context` method to `Saxy::ParsingError` that holds parser context at the time of error.
+
+## 0.5.2
+
+* Added optional `encoding` argument to `Saxy.parse`
+
+## 0.5.1
+
+* Removed `activesupport` dependency
+
+## 0.5.0
+
+* [BREAKING] Dropped support for ruby 1.9.2 and lower
+* [BREAKING] Yields hashes instead of `OpenStruct`s
+* Added support for `IO`-like objects

data/LICENSE.txt

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2012-2016 Humante LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,10 +1,13 @@
 # Saxy
 
-[![Build Status](https://secure.travis-ci.org/monterail/saxy.png)](http://travis-ci.org/monterail/saxy)
+[![Gem Version](https://badge.fury.io/rb/saxy.svg)](https://badge.fury.io/rb/saxy)
+[![Build Status](https://api.travis-ci.org/humante/saxy.svg)](http://travis-ci.org/humante/saxy)
 
-Memory-efficient XML parser. Finds object definitions in XML and translates them into Ruby objects.
+Memory-efficient XML parser. Finds object definitions in XML and translates them into Ruby hashes.
 
-It uses SAX parser under the hood, which means that it doesn't load the whole XML file into memory. It goes once though it and yields objects along the way.
+It uses SAX parser (provided by Nokogiri gem) under the hood, which means that it doesn't load the whole XML file into memory. It goes once through it and yields hashes along the way.
+
+In result the memory footprint of the parser remains small and more or less constant irrespective of the size of the XML file, be it few KB or hundreds of GB.
 
 ## Installation
 
@@ -20,63 +23,146 @@ Or install it yourself as:
 
     $ gem install saxy
 
+## Requirements
+
+As of `0.5.0` version `saxy` requires ruby 1.9.3 or higher. Previous versions of the gem work with ruby 1.8 and 1.9.2 (see below), but they are not maintained anymore.
+
+### Ruby 1.8 support
+
+See `ruby-1.8` branch. Install with:
+
+    gem 'saxy', '~> 0.3.0'
+
+### Ruby 1.9.2 support
+
+See `ruby-1.9.2` branch. Install with:
+
+    gem 'saxy', '~> 0.4.0'
+
+## Changelog
+
+See `CHANGELOG.md` file.
+
 ## Usage
 
-Assume the XML file:
-
-    <?xml version='1.0' encoding='UTF-8'?>
-    <webstore>
-      <name>Amazon</name>
-      <products>
-        <product>
-          <name>Kindle - The world's best-selling e-reader.</name>
-          <images>
-            <thumbSize width="80" height="60">http://amazon.com/kindle_thumb.jpg</thumbSize>
-          </images>
-        </product>
-        <product>
-          <name>Kindle Touch - Simple-to-use touchscreen with built-in WIFI.</name>
-          <images>
-            <thumbSize width="120" height="90">http://amazon.com/kindle_touch_thumb.jpg</thumbSize>
-          </images>
-        </product>
-      </products>
-    </webstore>
-
-You instantiate the parser by passing path to XML file and object-identyfing tag name as its arguments.
-
-The following will parse the XML, find product definitions (inside `<product>` and `</product>` tags), build `OpenStruct`s and yield them inside the block.
-Tag attributes become object attributes and attributes' name are underscored.
-
-    Saxy.parse("filename.xml", "product").each do |product|
-      puts product.name
-      puts product.images.thumb_size.contents
-      puts "#{product.images.thumb_size.width}x#{product.images.thumb_size.height}"
-    end
-
-    # =>
-      Kindle - The world's best-selling e-reader.
-      http://amazon.com/kindle_thumb.jpg
-      80x60
-      Kindle Touch - Simple-to-use touchscreen with built-in WIFI.
-      http://amazon.com/kindle_touch_thumb.jpg
-      120x90
+You instantiate the parser by passing path to XML file or an IO-like object, object-identifying tag name and options hash (optionally) as its arguments.
+
+```ruby
+parser = Saxy.parse(path_or_io, object_tag, options = {})
+```
+
+Then iterate over it using `each` (or any of convenient methods provided by `Enumerable` mix-in).
+
+```ruby
+parser.each do |object|
+  ...
+end
+```
+
+### Options
+
+* `encoding` - Forces the parser to work in given encoding
+* `recovery` - Should this parser recover from structural errors? It will not stop processing file on structural errors if set to `true`.
+* `replace_entities` - Should this parser replace entities? `&amp;` will get converted to `&` if set to `true`.
+* `error_handler` - If set to a callable, parser will call it with any error it encounters instead of raising exceptions.
+
+Combination of `error_handler` and `recovery` options allows for continued processing when encountering recoverable errors (e.g. unescaped [predefined entities](https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Predefined_entities_in_XML)).
+
+```ruby
+error_handler = proc { |e| $stderr.puts "#{e.message} at line #{e.context.line}, column #{e.context.column}." }
+Saxy.parse(path_or_io, object_tag, error_handler: error_handler, recovery: true) { ... }
+```
+
+## Example
+
+Assume the XML file (an imaginary product feed):
+
+````xml
+<?xml version='1.0' encoding='UTF-8'?>
+<webstore>
+  <name>Amazon</name>
+  <products>
+    <product>
+      <name>Kindle - The world's best-selling e-reader.</name>
+      <images>
+        <thumbSize width="80" height="60">http://amazon.com/kindle_thumb.jpg</thumbSize>
+      </images>
+    </product>
+    <product>
+      <name>Kindle Touch - Simple-to-use touchscreen with built-in WIFI.</name>
+      <images>
+        <thumbSize width="120" height="90">http://amazon.com/kindle_touch_thumb.jpg</thumbSize>
+      </images>
+    </product>
+  </products>
+</webstore>
+````
+
+The following will parse the XML, find product definitions (inside `<product>` and `</product>` tags), build `Hash`es and yield them inside the block.
+
+Usage with a file path:
+
+````ruby
+Saxy.parse("filename.xml", "product").each do |product|
+  puts product["name"]
+  puts product["images"]["thumb_size"]["contents"]
+  puts "#{product["images"]["thumb_size"]["width"]}x#{product["images"]["thumb_size"]["height"]}"
+end
+
+# =>
+"Kindle - The world's best-selling e-reader."
+"http://amazon.com/kindle_thumb.jpg"
+"80x60"
+"Kindle Touch - Simple-to-use touchscreen with built-in WIFI."
+"http://amazon.com/kindle_touch_thumb.jpg"
+"120x90"
+````
+
+Usage with an IO-like object `ARGF` or `$stdin`:
+
+````ruby
+# > cat filename.xml | ruby this_script.rb
+Saxy.parse(ARGF, "product").each do |product|
+  puts product["name"]
+end
+
+# =>
+"Kindle - The world's best-selling e-reader."
+````
 
 Saxy supports Enumerable, so you can use its goodies to your comfort without building intermediate arrays:
 
-    Saxy.parse("filename.xml", "product").map do |object|
-      # map OpenStructs to ActiveRecord instances, etc.
-    end
+````ruby
+Saxy.parse("filename.xml", "product").map do |object|
+  # map yielded Hash to ActiveRecord instances, etc.
+end
+````
 
 You can also grab an Enumerator for external use (e.g. lazy evaluation, etc.):
 
-    enumerator = Saxy.parse("filename.xml", "product").each
-    lazy       = Saxy.parse("filename.xml", "product").lazy # Ruby 2.0
+````ruby
+enumerator = Saxy.parse("filename.xml", "product").each
+lazy       = Saxy.parse("filename.xml", "product").lazy # Ruby 2.0
+````
 
 Multiple definitions of child objects are grouped in arrays:
 
-    webstore = Saxy.parse("filename.xml", "webstore").first
-    webstore.products.product.size # => 2
+````ruby
+webstore = Saxy.parse("filename.xml", "webstore").first
+webstore["products"]["product"].size # => 2
+````
+
+## Debugging
+
+Invalid XML files happen a lot and error messages are not always extremely helpful. In case of a parsing error, some additional information can be retrieved from parser's context.
+
+```ruby
+  begin
+    Saxy.parse(...) { ... }
+  rescue e => Saxy::ParsingError
+    puts "#{e.message} at #{e.context.line} line and #{e.context.column}"
+  end
+```
 
 ## Contributing
 
@@ -85,3 +171,11 @@ Multiple definitions of child objects are grouped in arrays:
 3. Commit your changes (`git commit -am 'Added some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+## License
+
+See `LICENSE.txt` file.
+
+## Author
+
+Michał Szajbe, [@szajbus](https://twitter.com/szajbus), [szajbe.pl](http://szajbe.pl)

data/gemfiles/nokogiri_1.6.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "nokogiri", "~> 1.6.0"
+
+gemspec :path => "../"

data/gemfiles/nokogiri_latest.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "nokogiri"
+
+gemspec :path => "../"

data/lib/saxy/element.rb

@@ -1,8 +1,6 @@
-require 'active_support/core_ext/string/inflections'
-
 module Saxy
   class Element
-    attr_reader :attributes, :value
+    attr_reader :attributes
 
     def initialize
       @attributes = {}
@@ -11,33 +9,46 @@ module Saxy
 
     def set_attribute(name, value)
       name = attribute_name(name)
+
       attributes[name] ||= []
       attributes[name] << value
     end
 
     def append_value(string)
-      unless (string = string.strip).empty?
+      if @value || !string.strip.empty?
         @value ||= ""
         @value << string
       end
     end
 
-    def as_object
-      if attributes.any?
-        object = OpenStruct.new
-        attributes.each do |name, value|
-          value = value.first if value.size == 1
-          object.send("#{name}=", value)
-        end
-        object.contents = value
-        object
-      else
-        value
+    def value
+      @value && @value.strip
+    end
+
+    def to_h
+      return value unless attributes.any?
+
+      data = attributes.reduce({}) do |memo, (name, value)|
+        memo[name] = value.size == 1 ? value.first : value
+        memo
       end
+
+      data["contents"] = value
+      data
     end
 
     def attribute_name(name)
-      name.underscore
+      underscore(name)
+    end
+
+    private
+
+    def underscore(word)
+      word
+        .gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .tr("-", "_")
+        .downcase
     end
   end
 end

data/lib/saxy/parser.rb

@@ -16,8 +16,14 @@ module Saxy
     # Will yield objects inside the callback after they're built
     attr_reader :callback
 
-    def initialize(xml_file, object_tag)
-      @xml_file, @object_tag = xml_file, object_tag
+    # Parser context
+    attr_reader :context
+
+    # Parser options
+    attr_reader :options
+
+    def initialize(object, object_tag, options={})
+      @object, @object_tag, @options = object, object_tag, options
       @tags, @elements = [], []
     end
 
@@ -35,8 +41,9 @@ module Saxy
 
     def end_element(tag)
       tags.pop
+
       if element = elements.pop
-        object = element.as_object
+        object = element.to_h
 
         if current_element
           current_element.set_attribute(tag, object)
@@ -55,7 +62,13 @@ module Saxy
     end
 
     def error(message)
-      raise ParsingError.new(message)
+      error = ParsingError.new(message, context)
+
+      if options[:error_handler].respond_to?(:call)
+        options[:error_handler].call(error)
+      else
+        raise error
+      end
     end
 
     def current_element
@@ -63,19 +76,28 @@ module Saxy
     end
 
     def each(&blk)
-      if blk
-        @callback = blk
+      return to_enum unless blk
 
-        parser = Nokogiri::XML::SAX::Parser.new(self)
+      @callback = blk
 
-        if @xml_file.is_a?(IO)
-          parser.parse_io(@xml_file)
-        else
-          parser.parse_file(@xml_file)
-        end
+      args   = [self, options[:encoding]].compact
+      parser = Nokogiri::XML::SAX::Parser.new(*args)
+
+      if @object.respond_to?(:read) && @object.respond_to?(:close)
+        parser.parse_io(@object, &context_blk)
       else
-        to_enum
+        parser.parse_file(@object, &context_blk)
       end
     end
+
+    def context_blk
+      proc { |context|
+        [:recovery, :replace_entities].each do |key|
+          context.send("#{key}=", options[key]) if options.has_key?(key)
+        end
+
+        @context = context
+      }
+    end
   end
 end

data/lib/saxy/parsing_error.rb

@@ -1,4 +1,10 @@
 module Saxy
-  class ParsingError < ::Exception
+  class ParsingError < ::StandardError
+    attr_reader :context
+
+    def initialize(message, context)
+      @context = context
+      super(message)
+    end
   end
-end
+end

data/lib/saxy/version.rb

@@ -1,3 +1,3 @@
 module Saxy
-  VERSION = "0.2.3"
+  VERSION = "0.7.1"
 end

data/lib/saxy.rb

@@ -2,8 +2,8 @@ require 'saxy/version'
 
 module Saxy
   class << self
-    def parse(xml_file, object_tag, &blk)
-      parser = Parser.new(xml_file, object_tag)
+    def parse(object, object_tag, options={}, &blk)
+      parser = Parser.new(object, object_tag, options)
 
       if blk
         parser.each(blk)
@@ -12,13 +12,9 @@ module Saxy
       end
     end
 
-    def ruby_18?
-      @ruby_18 ||= RUBY_VERSION =~ /^1\.8/
-    end
   end
 end
 
 require 'saxy/element'
-require 'saxy/ostruct'
 require 'saxy/parser'
 require 'saxy/parsing_error'

data/saxy.gemspec

@@ -4,9 +4,9 @@ require File.expand_path('../lib/saxy/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["Michał Szajbe"]
   gem.email         = ["michal.szajbe@gmail.com"]
-  gem.description   = %q{Saxy finds object definitions in XML files and translates them into Ruby objects. It uses SAX parser under the hood, which means that it doesn't load the whole XML file into memory. It goes once though it and yields objects along the way.}
+  gem.description   = %q{Saxy finds object definitions in XML files and translates them into Ruby objects. It uses SAX parser under the hood, which means that it doesn't load the whole XML file into memory. It goes once through it and yields objects along the way.}
   gem.summary       = %q{Memory-efficient XML parser. Finds object definitions and translates them into Ruby objects.}
-  gem.homepage      = "http://github.com/monterail/saxy"
+  gem.homepage      = "http://github.com/humante/saxy"
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
@@ -15,7 +15,10 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Saxy::VERSION
 
-  gem.add_dependency "activesupport"
+  gem.required_ruby_version = ">= 1.9.3"
+
   gem.add_dependency "nokogiri"
+
   gem.add_development_dependency "rspec"
+  gem.add_development_dependency "appraisal"
 end

data/spec/fixtures/invalid.xml

@@ -0,0 +1,9 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<webstore>
+  <products>
+    <product>
+      <uid>FFCF177</uid>
+      <name>Unescaped & ampersand</name>
+    </product>
+  </products>
+</webstore>

data/spec/saxy/element_spec.rb

@@ -5,45 +5,47 @@ describe Saxy::Element do
 
   it "should not append empty string as value" do
     element.append_value("")
-    element.value.should be_nil
+    expect(element.value).to be_nil
   end
 
-  it "should append stripped value" do
-    element.append_value(" foo ")
-    element.append_value(" bar ")
-    element.value.should == "foobar"
+  it "should strip leading and trailing whitespace" do
+    element.append_value(" one two ")
+    element.append_value("&")
+    element.append_value(" three\nfour")
+    element.append_value("\t\t")
+    expect(element.value).to eq("one two & three\nfour")
   end
 
   it "should dump as string when no attributes are set" do
-    element.stub(:value).and_return("foo")
-    element.as_object.should == "foo"
+    expect(element).to receive(:value).and_return("foo")
+    expect(element.to_h).to eq("foo")
   end
 
   it "should dump as object when attributes are set" do
-    element.stub(:attributes).and_return("foo" => 1, "bar" => 2)
-    object = element.as_object
+    expect(element).to receive(:attributes).at_least(:once).and_return("foo" => 1, "bar" => 2)
+    object = element.to_h
 
-    object.foo.should == 1
-    object.bar.should == 2
+    expect(object["foo"]).to eq(1)
+    expect(object["bar"]).to eq(2)
   end
 
   it "should dump as object with value when attributes and contents are set" do
     element.set_attribute("foo", "bar")
     element.append_value("value")
-    object = element.as_object
+    object = element.to_h
 
-    object.foo.should == "bar"
-    object.contents.should == "value"
+    expect(object["foo"]).to eq("bar")
+    expect(object["contents"]).to eq("value")
   end
 
   it "should add attributes under underscored names" do
     element.set_attribute("FooBar", "baz")
-    element.as_object.foo_bar.should == "baz"
+    expect(element.to_h["foo_bar"]).to eq("baz")
   end
 
   it "should create array if adding multiple attributtes with the same name" do
     element.set_attribute("foo", "bar")
     element.set_attribute("foo", "baz")
-    element.as_object.foo.should == ["bar", "baz"]
+    expect(element.to_h["foo"]).to eq(["bar", "baz"])
   end
 end

data/spec/saxy/parser_spec.rb

@@ -4,43 +4,62 @@ describe Saxy::Parser do
   include FixturesHelper
 
   let(:parser) { Saxy::Parser.new(fixture_file("webstore.xml"), "product") }
+  let(:file_io) { File.new(fixture_file("webstore.xml")) }
+  let(:io_like) { IOLike.new(file_io) }
 
-  it "should accept string filename as xml_file" do
+  it "should accept string filename for parsing" do
     xml_file = fixture_file("webstore.xml")
     parser = Saxy::Parser.new(xml_file, "product")
-    parser.each.to_a.size.should == 2
+    expect(parser.each.to_a.size).to eq(2)
   end
 
-  it "should accept IO as xml_file" do
-    xml_file = File.new(fixture_file("webstore.xml"))
-    parser = Saxy::Parser.new(xml_file, "product")
-    parser.each.to_a.size.should == 2
+  it "should accept IO for parsing" do
+    parser = Saxy::Parser.new(file_io, "product")
+    expect(parser.each.to_a.size).to eq(2)
+  end
+
+  it "should accept optional force-encoding" do
+    parser = Saxy::Parser.new(file_io, "product", encoding: "UTF-8")
+    expect(Nokogiri::XML::SAX::Parser).to receive(:new).with(parser, "UTF-8").and_call_original
+    expect(parser.each.to_a.size).to eq(2)
+  end
+
+  it "should pass options to parser context" do
+    parser = Saxy::Parser.new(file_io, "product", recovery: true, replace_entities: true)
+    parser.each.to_a
+    expect(parser.context.recovery).to be_truthy
+    expect(parser.context.replace_entities).to be_truthy
+  end
+
+  it "should accept an IO-like for parsing" do
+    parser = Saxy::Parser.new(io_like, "product")
+    expect(parser.each.to_a.size).to eq(2)
   end
 
   it "should have empty tag stack" do
-    parser.tags.should == %w( )
+    expect(parser.tags).to eq(%w( ))
   end
 
   it "should push/pop tag names on/from tag stack when going down/up the XML tree" do
-    parser.tags.should == %w( )
+    expect(parser.tags).to eq(%w( ))
 
     parser.start_element('webstore')
-    parser.tags.should == %w( webstore )
+    expect(parser.tags).to eq(%w( webstore ))
 
     parser.start_element('products')
-    parser.tags.should == %w( webstore products )
+    expect(parser.tags).to eq(%w( webstore products ))
 
     parser.start_element('product')
-    parser.tags.should == %w( webstore products product )
+    expect(parser.tags).to eq(%w( webstore products product ))
 
     parser.end_element('product')
-    parser.tags.should == %w( webstore products )
+    expect(parser.tags).to eq(%w( webstore products ))
 
     parser.end_element('products')
-    parser.tags.should == %w( webstore )
+    expect(parser.tags).to eq(%w( webstore ))
 
     parser.end_element('webstore')
-    parser.tags.should == %w( )
+    expect(parser.tags).to eq(%w( ))
   end
 
   context "when detecting object tag opening" do
@@ -49,7 +68,7 @@ describe Saxy::Parser do
     end
 
     it "should add new element to stack" do
-      parser.elements.size.should == 1
+      expect(parser.elements.size).to eq(1)
     end
   end
 
@@ -59,14 +78,14 @@ describe Saxy::Parser do
     end
 
     it "should not add new element to stack" do
-      parser.elements.should be_empty
+      expect(parser.elements).to be_empty
     end
   end
 
   context "with non-empty element stack" do
     before do
       parser.start_element("product")
-      parser.elements.should_not be_empty
+      expect(parser.elements).to_not be_empty
     end
 
     context "when detecting object tag opening" do
@@ -75,7 +94,7 @@ describe Saxy::Parser do
       end
 
       it "should add new element to stack" do
-        parser.elements.size.should == 2
+        expect(parser.elements.size).to eq(2)
       end
     end
 
@@ -85,7 +104,7 @@ describe Saxy::Parser do
       end
 
       it "should not add new element to stack" do
-        parser.elements.size.should == 2
+        expect(parser.elements.size).to eq(2)
       end
     end
 
@@ -95,36 +114,36 @@ describe Saxy::Parser do
       end
 
       it "should pop element from stack" do
-        parser.elements.should be_empty
+        expect(parser.elements).to be_empty
       end
     end
 
     context "with callback defined" do
       before do
         @callback = lambda { |object| object }
-        parser.stub(:callback).and_return(@callback)
+        allow(parser).to receive(:callback).and_return(@callback)
       end
 
       it "should yield the object inside the callback after detecting object tag closing" do
-        @callback.should_receive(:call).with(parser.current_element.as_object)
+        expect(@callback).to receive(:call).with(parser.current_element.to_h)
         parser.end_element("product")
       end
 
       it "should not yield the object inside the callback after detecting other tag closing" do
         parser.start_element("other")
-        @callback.should_not_receive(:call)
+        expect(@callback).to_not receive(:call)
         parser.end_element("other")
       end
     end
 
     it "should append cdata block's contents to top element's value when detecting cdata block" do
-      parser.current_element.should_receive(:append_value).with("foo")
+      expect(parser.current_element).to receive(:append_value).with("foo")
       parser.cdata_block("foo")
     end
 
     it "should append characters to top element's value when detecting characters block" do
-      parser.current_element.should_receive(:append_value).with("foo")
-      parser.current_element.should_receive(:append_value).with("bar")
+      expect(parser.current_element).to receive(:append_value).with("foo")
+      expect(parser.current_element).to receive(:append_value).with("bar")
       parser.characters("foo")
       parser.characters("bar")
     end
@@ -132,7 +151,7 @@ describe Saxy::Parser do
     it "should set element's attribute after processing tags" do
       element = parser.current_element
 
-      element.should_receive(:set_attribute).with("foo", "bar")
+      expect(element).to receive(:set_attribute).with("foo", "bar")
 
       parser.start_element("foo")
       parser.characters("bar")
@@ -141,19 +160,33 @@ describe Saxy::Parser do
 
     it "should set element's attributes when opening tag with attributes" do
       parser.start_element("foo", [["bar", "baz"]])
-      parser.current_element.as_object.bar.should == "baz"
+      expect(parser.current_element.to_h["bar"]).to eq("baz")
     end
   end
 
-  it "should raise Saxy::ParsingError on error" do
-    lambda { parser.error("Error message.") }.should raise_error(Saxy::ParsingError, "Error message.")
+  context "when error handler is not set" do
+    let(:parser) { Saxy::Parser.new(fixture_file("invalid.xml"), "product") }
+
+    it "should raise Saxy::ParsingError on error" do
+      expect { parser.each.to_a }.to raise_error { |error|
+        expect(error).to be_a(Saxy::ParsingError)
+        expect(error.message).to match(/xmlParseEntityRef: no name/)
+        expect(error.context).to be_a(Nokogiri::XML::SAX::ParserContext)
+      }
+    end
   end
 
-  it "should return Enumerator when calling #each without a block", :unless => RUBY_1_8 do
-    parser.each.should be_instance_of Enumerator
+  context "when error handler is set" do
+    let(:handler) { proc { |error| error } }
+    let(:parser) { Saxy::Parser.new(fixture_file("invalid.xml"), "product", error_handler: handler) }
+
+    it "should call error handler passing Saxy::ParsingError instance" do
+      expect(handler).to receive(:call).with(Saxy::ParsingError)
+      parser.each.to_a
+    end
   end
 
-  it "should return Enumerator when calling #each without a block", :if => RUBY_1_8 do
-    parser.each.should be_instance_of Enumerable::Enumerator
+  it "should return Enumerator when calling #each without a block" do
+    expect(parser.each).to be_an(Enumerator)
   end
 end

data/spec/saxy_spec.rb

@@ -9,33 +9,34 @@ describe Saxy do
       arr
     end
 
-    products[0].uid.should == "FFCF177"
-    products[0].name.should == "Kindle"
-    products[0].description.should == "The world's best-selling e-reader."
-    products[0].price.should == "$109"
-    products[0].images.thumb.should == "http://amazon.com/kindle_thumb.jpg"
-    products[0].images.large.should == "http://amazon.com/kindle.jpg"
-
-    products[1].uid.should == "YD26NT"
-    products[1].name.should == "Kindle Touch"
-    products[1].description.should == "Simple-to-use touchscreen with built-in WIFI."
-    products[1].price.should == "$79"
-    products[1].images.thumb.should == "http://amazon.com/kindle_touch_thumb.jpg"
-    products[1].images.large.should == "http://amazon.com/kindle_touch.jpg"
+    expect(products[0]["uid"]).to eq("FFCF177")
+    expect(products[0]["name"]).to eq("Kindle")
+    expect(products[0]["description"]).to eq("The world's best-selling e-reader.")
+    expect(products[0]["price"]).to eq("$109")
+    expect(products[0]["images"]["thumb"]).to eq("http://amazon.com/kindle_thumb.jpg")
+    expect(products[0]["images"]["large"]).to eq("http://amazon.com/kindle.jpg")
+
+    expect(products[1]["uid"]).to eq("YD26NT")
+    expect(products[1]["name"]).to eq("Kindle Touch")
+    expect(products[1]["description"]).to eq("Simple-to-use touchscreen with built-in WIFI.")
+    expect(products[1]["price"]).to eq("$79")
+    expect(products[1]["images"]["thumb"]).to eq("http://amazon.com/kindle_touch_thumb.jpg")
+    expect(products[1]["images"]["large"]).to eq("http://amazon.com/kindle_touch.jpg")
   end
 
   it "should group multiple definitions of child objects into arrays" do
     webstore = Saxy.parse(fixture_file("webstore.xml"), "webstore").first
 
-    webstore.products.product.should be_instance_of Array
-    webstore.products.product.size.should == 2
+    expect(webstore["products"]["product"]).to be_an(Array)
+    expect(webstore["products"]["product"].size).to eq(2)
   end
 
-  it "should return Enumerator when calling #parse without a block", :unless => RUBY_1_8 do
-    Saxy.parse(fixture_file("webstore.xml"), "product").each.should be_instance_of Enumerator
+  it "should return Enumerator when calling #parse without a block" do
+    expect(Saxy.parse(fixture_file("webstore.xml"), "product").each).to be_an(Enumerator)
   end
 
-  it "should return Enumerator when calling #parse without a block", :if => RUBY_1_8 do
-    Saxy.parse(fixture_file("webstore.xml"), "product").each.should be_instance_of Enumerable::Enumerator
+  it "should pass options to Parser's initializer" do
+    expect(Saxy::Parser).to receive(:new).with("filename", "object_tag", { foo: 'bar' }).and_call_original
+    Saxy.parse("filename", "object_tag", { foo: 'bar' })
   end
-end
+end

data/spec/spec_helper.rb

@@ -3,5 +3,4 @@ require 'bundler/setup'
 require 'saxy'
 
 require 'fixtures_helper'
-
-RUBY_1_8 = (RUBY_VERSION =~ /^1\.8/)
+require 'support/io_like'

data/spec/support/io_like.rb

@@ -0,0 +1,9 @@
+class IOLike
+  extend Forwardable
+
+  def_delegators :@io, :read, :close
+
+  def initialize(io)
+    @io = io
+  end
+end

metadata

@@ -1,60 +1,60 @@
 --- !ruby/object:Gem::Specification
 name: saxy
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.7.1
 platform: ruby
 authors:
 - Michał Szajbe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-25 00:00:00.000000000 Z
+date: 2018-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: nokogiri
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Saxy finds object definitions in XML files and translates them into Ruby
   objects. It uses SAX parser under the hood, which means that it doesn't load the
-  whole XML file into memory. It goes once though it and yields objects along the
+  whole XML file into memory. It goes once through it and yields objects along the
   way.
 email:
 - michal.szajbe@gmail.com
@@ -62,29 +62,32 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Appraisals
+- CHANGELOG.md
 - Gemfile
-- LICENSE
+- LICENSE.txt
 - README.md
 - Rakefile
-- gemfiles/gemfile-1.8
+- gemfiles/nokogiri_1.6.gemfile
+- gemfiles/nokogiri_latest.gemfile
 - lib/saxy.rb
 - lib/saxy/element.rb
-- lib/saxy/ostruct.rb
 - lib/saxy/parser.rb
 - lib/saxy/parsing_error.rb
 - lib/saxy/version.rb
 - saxy.gemspec
+- spec/fixtures/invalid.xml
 - spec/fixtures/webstore.xml
 - spec/fixtures_helper.rb
 - spec/saxy/element_spec.rb
-- spec/saxy/ostruct_spec.rb
 - spec/saxy/parser_spec.rb
 - spec/saxy_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/monterail/saxy
+- spec/support/io_like.rb
+homepage: http://github.com/humante/saxy
 licenses: []
 metadata: {}
 post_install_message: 
@@ -93,27 +96,27 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Memory-efficient XML parser. Finds object definitions and translates them
   into Ruby objects.
 test_files:
+- spec/fixtures/invalid.xml
 - spec/fixtures/webstore.xml
 - spec/fixtures_helper.rb
 - spec/saxy/element_spec.rb
-- spec/saxy/ostruct_spec.rb
 - spec/saxy/parser_spec.rb
 - spec/saxy_spec.rb
 - spec/spec_helper.rb
-has_rdoc: 
+- spec/support/io_like.rb

data/LICENSE

@@ -1,22 +0,0 @@
-Copyright (c) 2012 Michał Szajbe
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/gemfiles/gemfile-1.8

@@ -1,6 +0,0 @@
-source "https://rubygems.org"
-
-gem "activesupport", "< 4.0.0"
-gem "saxy", :path => "../"
-gemspec :path => "../"
-

data/lib/saxy/ostruct.rb

@@ -1,11 +0,0 @@
-require 'ostruct'
-
-module Saxy
-  class OpenStruct < ::OpenStruct
-    if Saxy.ruby_18?
-      define_method :id do
-        @table[:id]
-      end
-    end
-  end
-end

data/spec/saxy/ostruct_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe Saxy::OpenStruct do
-  let(:object) { Saxy::OpenStruct.new }
-
-  if Saxy.ruby_18?
-    context "in Ruby 1.8" do
-      it "should correctly set id attribute" do
-        object.id = 1
-        object.id.should == 1
-      end
-    end
-  end
-end