saxerator 0.9.5 → 0.9.8

data/lib/saxerator/sax_handler.rb

@@ -0,0 +1,9 @@
+module Saxerator
+  class SaxHandler
+    def characters(_text); end
+
+    def start_element(_name, _attrs = []); end
+
+    def end_element(_name); end
+  end
+end

data/lib/saxerator/version.rb

@@ -1,3 +1,3 @@
 module Saxerator
-  VERSION = "0.9.5"
+  VERSION = '0.9.8'.freeze
 end

data/saxerator.gemspec

@@ -17,6 +17,8 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = 'saxerator'
 
+  s.required_ruby_version     = '>= 2.1.0'
+
   s.files = [
     'LICENSE',
     'README.md',
@@ -33,7 +35,8 @@ Gem::Specification.new do |s|
   s.executables   = []
   s.require_paths = ['lib']
 
-  s.add_runtime_dependency 'nokogiri', '>= 1.4.0'
-
+  s.add_development_dependency 'nokogiri', '>= 1.4.0'
+  s.add_development_dependency 'ox'
+  s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec', '~> 3.1'
 end

data/spec/lib/builder/hash_builder_spec.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require 'spec_helper'
 
-describe "Saxerator (default) hash format" do
+describe 'Saxerator (default) hash format' do
   let(:xml) { fixture_file('nested_elements.xml') }
   subject(:entry) { Saxerator.parser(xml).for_tag(:entry).first }
 
@@ -9,10 +9,13 @@ describe "Saxerator (default) hash format" do
   specify { expect(entry['title']).to eq('How to eat an airplane') }
 
   # hash and cdata inside name
-  specify { expect(entry['author']).to eq({'name' => 'Soul<utter'}) }
+  specify { expect(entry['author']).to eq('name' => 'Soul<utter') }
 
   # array of hashes
-  specify { expect(entry['contributor']).to eq([{'name' => 'Jane Doe'}, {'name' => 'Leviticus Alabaster'}]) }
+  specify do
+    expect(entry['contributor'])
+      .to eq([{ 'name' => 'Jane Doe' }, { 'name' => 'Leviticus Alabaster' }])
+  end
 
   # attributes on a hash
   specify { expect(entry['contributor'][0].attributes['type']).to eq('primary') }
@@ -26,32 +29,32 @@ describe "Saxerator (default) hash format" do
   # name on a string
   specify { expect(entry['title'].name).to eq('title') }
 
-  describe "#to_s" do
-    it "preserves the element name" do
+  describe '#to_s' do
+    it 'preserves the element name' do
       expect(entry['title'].to_a.name).to eq('title')
     end
   end
 
-  describe "#to_h" do
-    it "preserves the element name" do
+  describe '#to_h' do
+    it 'preserves the element name' do
       expect(entry.to_h.name).to eq('entry')
     end
   end
 
-  describe "#to_a" do
-    it "preserves the element name on a parsed hash" do
+  describe '#to_a' do
+    it 'preserves the element name on a parsed hash' do
       expect(entry.to_a.name).to eq('entry')
     end
 
-    it "converts parsed hashes to nested key/value pairs (just like regular hashes)" do
+    it 'converts parsed hashes to nested key/value pairs (just like regular hashes)' do
       expect(entry.to_a.first).to eq(['id', '1'])
     end
 
-    it "preserves the element name on a parsed string" do
+    it 'preserves the element name on a parsed string' do
       expect(entry['title'].to_a.name).to eq('title')
     end
 
-    it "preserves the element name on an array" do
+    it 'preserves the element name on an array' do
       expect(entry['contributor'].to_a.name).to eq 'contributor'
     end
   end
@@ -60,21 +63,24 @@ describe "Saxerator (default) hash format" do
   specify { expect(entry['contributor'].name).to eq('contributor') }
 
   # character entity decoding
-  specify { expect(entry['content']).to eq("<p>Airplanes are very large — this can present difficulty in digestion.</p>") }
+  specify do
+    expect(entry['content'])
+      .to eq('<p>Airplanes are very large — this can present difficulty in digestion.</p>')
+  end
 
-  context "parsing an empty element" do
+  context 'parsing an empty element' do
     subject(:element) { entry['media:thumbnail'] }
 
-    it "behaves somewhat like nil" do
+    it 'behaves somewhat like nil' do
       expect(element).to be_nil
-      expect(!element).to eq true
-      expect(element.to_s).to eq ''
-      expect(element.to_h).to eq Hash.new
+      expect(!element).to be true
+      expect(element.to_s).to eq('')
+      expect(element.to_h).to eq({})
     end
 
     it { is_expected.to be_empty }
 
-    it "has attributes" do
+    it 'has attributes' do
       expect(element.attributes.keys).to eq ['url']
     end
 

data/spec/lib/builder/xml_builder_spec.rb

@@ -1,37 +1,18 @@
 # encoding: utf-8
 require 'spec_helper'
 
-describe "Saxerator xml format" do
+describe 'Saxerator xml format' do
   let(:xml) { fixture_file('nested_elements.xml') }
+
   subject(:entry) do
     Saxerator.parser(xml) do |config|
       config.output_type = :xml
     end.for_tag(:entry).first
   end
 
-  it { is_expected.to be_a(Nokogiri::XML::Node) }
-  it "looks like the original document" do
-    expected_xml = <<-eos
-<?xml version="1.0"?>
-<entry>
-  <id>1</id>
-  <published>2012-01-01T16:17:00-06:00</published>
-  <updated>2012-01-01T16:17:00-06:00</updated>
-  <link href="https://example.com/blog/how-to-eat-an-airplane"/>
-  <title>How to eat an airplane</title>
-  <content type="html">&lt;p&gt;Airplanes are very large &#x2014; this can present difficulty in digestion.&lt;/p&gt;</content>
-  <media:thumbnail url="http://www.gravatar.com/avatar/a9eb6ba22e482b71b266daadf9c9a080?s=80"/>
-  <author>
-    <name>Soul&lt;utter</name>
-  </author>
-  <contributor type="primary">
-    <name>Jane Doe</name>
-  </contributor>
-  <contributor>
-    <name>Leviticus Alabaster</name>
-  </contributor>
-</entry>
-    eos
-    expect(entry.to_xml).to eq(expected_xml)
+  it { is_expected.to be_a(REXML::Document) }
+  it 'looks like the original document' do
+    expected_xml = '<?xml version=\'1.0\' encoding=\'UTF-8\'?><entry><id>1</id><published>2012-01-01T16:17:00-06:00</published><updated>2012-01-01T16:17:00-06:00</updated><link href="https://example.com/blog/how-to-eat-an-airplane"/><title>How to eat an airplane</title><content type="html">&lt;p&gt;Airplanes are very large — this can present difficulty in digestion.&lt;/p&gt;</content><media:thumbnail url="http://www.gravatar.com/avatar/a9eb6ba22e482b71b266daadf9c9a080?s=80"/><author><name>Soul&lt;utter</name></author><contributor type="primary"><name>Jane Doe</name></contributor><contributor><name>Leviticus Alabaster</name></contributor></entry>'
+    expect(entry.to_s).to eq(expected_xml)
   end
-end
+end

data/spec/lib/dsl/all_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "Saxerator::FullDocument#all" do
+describe 'Saxerator::FullDocument#all' do
   subject(:parser) { Saxerator.parser(xml) }
 
   let(:xml) do
@@ -15,17 +15,22 @@ describe "Saxerator::FullDocument#all" do
     eos
   end
 
-  it "should allow you to parse an entire document" do
-    expect(parser.all).to eq 'blurb' => ['one', 'two', 'three'], 'notablurb' => 'four', 'empty' => {}
+  it 'allows you to parse an entire document' do
+    expect(parser.all)
+      .to eq 'blurb' => ['one', 'two', 'three'], 'notablurb' => 'four', 'empty' => {}
   end
 
-  context "with_put_attributes_in_hash" do
+  context 'with_put_attributes_in_hash' do
     subject(:parser) do
       Saxerator.parser(xml) { |config| config.put_attributes_in_hash! }
     end
 
-    it "should allow you to parse an entire document" do
-      expect(parser.all).to eq 'blurb' => ['one', 'two', 'three'], 'notablurb' => 'four', 'empty' => { "with" => "attribute" }
+    it 'allows you to parse an entire document' do
+      expect(parser.all).to eq(
+        'blurb' => ['one', 'two', 'three'],
+        'notablurb' => 'four',
+        'empty' => { 'with' => 'attribute' }
+      )
     end
   end
 end

data/spec/lib/dsl/at_depth_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "Saxerator::DSL#at_depth" do
+describe 'Saxerator::DSL#at_depth' do
   subject(:parser) { Saxerator.parser(xml) }
 
   let(:xml) do
@@ -18,17 +18,19 @@ describe "Saxerator::DSL#at_depth" do
     eos
   end
 
-  it "should parse elements at the requested tag depth" do
+  it 'parses elements at the requested tag depth' do
     expect(parser.at_depth(2).inject([], :<<)).to eq([
-      'How to eat an airplane', 'Leviticus Alabaster',
-      'To wallop a horse in the face', 'Jeanne Clarewood'
+      'How to eat an airplane',
+      'Leviticus Alabaster',
+      'To wallop a horse in the face',
+      'Jeanne Clarewood'
     ])
   end
 
-  it "should work in combination with #for_tag" do
+  it 'works in combination with #for_tag' do
     expect(parser.at_depth(2).for_tag(:name).inject([], :<<)).to eq([
-        'How to eat an airplane',
-        'To wallop a horse in the face'
+      'How to eat an airplane',
+      'To wallop a horse in the face'
     ])
   end
-end
+end

data/spec/lib/dsl/child_of_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe "Saxerator::DSL#child_of" do
+describe 'Saxerator::DSL#child_of' do
   subject(:parser) { Saxerator.parser(xml) }
 
   let(:xml) do
-     <<-eos
-    <root>
+    <<-eos
+      <root>
       <children>
         <name>Rudy McMannis</name>
         <children>
@@ -20,17 +20,17 @@ describe "Saxerator::DSL#child_of" do
     eos
   end
 
-  it "should only parse children of the specified tag" do
+  it 'only parses children of the specified tag' do
     expect(parser.child_of(:grandchildren).inject([], :<<)).to eq([
         'Mildred Marston'
     ])
   end
 
-  it "should work in combination with #for_tag" do
+  it 'works in combination with #for_tag' do
     expect(parser.for_tag(:name).child_of(:children).inject([], :<<)).to eq([
         'Rudy McMannis',
         'Tom McMannis',
         'Anne Welsh'
     ])
   end
-end
+end

data/spec/lib/dsl/for_tag_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "Saxerator::DSL#for_tag" do
+describe 'Saxerator::DSL#for_tag' do
   subject(:parser) { Saxerator.parser(xml) }
 
   let(:xml) do
@@ -14,7 +14,7 @@ describe "Saxerator::DSL#for_tag" do
     eos
   end
 
-  it "should only select the specified tag" do
+  it 'only selects the specified tag' do
     expect(parser.for_tag(:blurb).inject([], :<<)).to eq(['one', 'two', 'three'])
   end
-end
+end

data/spec/lib/dsl/for_tags_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "Saxerator::DSL#for_tags" do
+describe 'Saxerator::DSL#for_tags' do
   subject(:parser) { Saxerator.parser(xml) }
 
   let(:xml) do
@@ -13,11 +13,11 @@ describe "Saxerator::DSL#for_tags" do
     eos
   end
 
-  it "should only select the specified tags" do
+  it 'only selects the specified tags' do
     expect(parser.for_tags(%w(blurb1 blurb3)).inject([], :<<)).to eq(['one', 'three'])
   end
 
-  it "raises an ArgumentError for a non-Array argument" do
-    expect { parser.for_tags("asdf") }.to raise_error ArgumentError
+  it 'raises an ArgumentError for a non-Array argument' do
+    expect { parser.for_tags('asdf') }.to raise_error ArgumentError
   end
-end
+end

data/spec/lib/dsl/with_attribute_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "Saxerator::DSL#with_attribute" do
+describe 'Saxerator::DSL#with_attribute' do
   subject(:parser) { Saxerator.parser(xml) }
 
   let(:xml) do
@@ -15,14 +15,14 @@ describe "Saxerator::DSL#with_attribute" do
     eos
   end
 
-  it "should match tags with the specified attributes" do
+  it 'matches tags with the specified attributes' do
     expect(subject.with_attribute(:type).inject([], :<<)).to eq([
         'Leviticus Alabaster',
         'Eunice Diesel'
     ])
   end
 
-  it "should match tags with the specified attributes" do
+  it 'matches tags with the specified attributes' do
     expect(subject.with_attribute(:type, :primary).inject([], :<<)).to eq(['Leviticus Alabaster'])
   end
-end
+end

data/spec/lib/dsl/with_attributes_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "Saxerator::DSL#with_attributes" do
+describe 'Saxerator::DSL#with_attributes' do
   subject(:parser) { Saxerator.parser(xml) }
 
   let(:xml) do
@@ -16,17 +16,18 @@ describe "Saxerator::DSL#with_attributes" do
     eos
   end
 
-  it "matches tags with the exact specified attributes" do
-    expect(parser.with_attributes(:type => :primary, :ridiculous => 'true').inject([], :<<)).to eq([
+  it 'matches tags with the exact specified attributes' do
+    expect(parser.with_attributes(type: :primary, ridiculous: 'true').inject([], :<<)).to eq([
         'Leviticus Alabaster'
     ])
   end
 
-  it "matches tags which have the specified attributes" do
-    expect(parser.with_attributes(%w(type ridiculous)).inject([], :<<)).to eq(['Leviticus Alabaster', 'Eunice Diesel'])
+  it 'matches tags which have the specified attributes' do
+    expect(parser.with_attributes(%w(type ridiculous)).inject([], :<<))
+      .to eq(['Leviticus Alabaster', 'Eunice Diesel'])
   end
 
-  it "raises ArgumentError if you pass something other than a Hash or Array" do
+  it 'raises ArgumentError if you pass something other than a Hash or Array' do
     expect { parser.with_attributes('asdf') }.to raise_error ArgumentError
   end
-end
+end

data/spec/lib/dsl/within_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "Saxerator::DSL#within" do
+describe 'Saxerator::DSL#within' do
   subject(:parser) { Saxerator.parser(xml) }
 
   let(:xml) do
@@ -15,14 +15,15 @@ describe "Saxerator::DSL#within" do
     eos
   end
 
-  it "should only parse elements nested within the specified tag" do
+  it 'only parses elements nested within the specified tag' do
     expect(parser.within(:article).inject([], :<<)).to eq([
         'Is our children learning?',
         'Hazel Nutt'
     ])
   end
 
-  it "should work in combination with #for_tag" do
-    expect(parser.for_tag(:name).within(:article).inject([], :<<)).to eq(['Is our children learning?'])
+  it 'works in combination with #for_tag' do
+    expect(parser.for_tag(:name).within(:article).inject([], :<<))
+      .to eq(['Is our children learning?'])
   end
-end
+end

data/spec/lib/saxerator_spec.rb

@@ -1,19 +1,19 @@
-# encoding: utf-8
-
 require 'spec_helper'
 
-describe Saxerator do
-  context "#parser" do
-    subject(:parser) { Saxerator.parser(xml) }
+RSpec.describe Saxerator do
+  context '#parser' do
+    subject(:parser) do
+      Saxerator.parser(xml)
+    end
 
-    context "with a File argument" do
+    context 'with a File argument' do
       let(:xml) { fixture_file('flat_blurbs.xml') }
 
-      it "should be able to parse it" do
-        expect(parser.all).to eq({'blurb' => ['one', 'two', 'three']})
+      it 'can parse it' do
+        expect(parser.all).to eq('blurb' => %w(one two three))
       end
 
-      it "should allow multiple operations on the same parser" do
+      it 'allows multiple operations on the same parser' do
         # This exposes a bug where if a File is not reset only the first
         # Enumerable method works as expected
         expect(parser.for_tag(:blurb).first).to eq('one')
@@ -21,48 +21,50 @@ describe Saxerator do
       end
     end
 
-    context "with a String argument" do
+    context 'with a String argument' do
       let(:xml) do
         <<-eos
-          <book>
-            <name>Illiterates that can read</name>
-            <author>Eunice Diesel</author>
-          </book>
+        <book>
+          <name>Illiterates that can read</name>
+          <author>Eunice Diesel</author>
+        </book>
         eos
       end
 
-      it "should be able to parse it" do
-        expect(parser.all).to eq({ 'name' => 'Illiterates that can read', 'author' => 'Eunice Diesel' })
+      it 'can parse it' do
+        expect(parser.all).to eq('name' => 'Illiterates that can read', 'author' => 'Eunice Diesel')
       end
     end
   end
 
-  context "configuration" do
+  context 'configuration' do
     let(:xml) { '<foo><bar foo="bar">baz</bar></foo>' }
 
-    context "output type" do
+    context 'output type' do
       subject(:parser) do
-        Saxerator.parser(xml) { |config| config.output_type = output_type }
+        Saxerator.parser(xml) do |config|
+          config.output_type = output_type
+        end
       end
 
-      context "with config.output_type = :hash" do
+      context 'with config.output_type = :hash' do
         let(:output_type) { :hash }
         specify { expect(parser.all).to eq('bar' => 'baz') }
       end
 
-      context "with config.output_type = :xml" do
+      context 'with config.output_type = :xml' do
         let(:output_type) { :xml }
-        specify { expect(parser.all).to be_a Nokogiri::XML::Document }
+        specify { expect(parser.all).to be_a REXML::Document }
         specify { expect(parser.all.to_s).to include '<bar foo="bar">' }
       end
 
-      context "with an invalid config.output_type" do
+      context 'with an invalid config.output_type' do
         let(:output_type) { 'lmao' }
         specify { expect { parser }.to raise_error(ArgumentError) }
       end
     end
 
-    context "symbolize keys" do
+    context 'symbolize keys' do
       subject(:parser) do
         Saxerator.parser(xml) do |config|
           config.symbolize_keys!
@@ -70,50 +72,59 @@ describe Saxerator do
         end
       end
 
-      specify { expect(parser.all).to eq(:bar => 'baz') }
+      specify { expect(parser.all).to eq(bar: 'baz') }
       specify { expect(parser.all.name).to eq(:foo) }
 
       it 'will symbolize attributes' do
         parser.for_tag('bar').each do |tag|
-          expect(tag.attributes).to include(:foo => 'bar')
+          expect(tag.attributes).to include(foo: 'bar')
         end
       end
     end
 
-    context "with ignore namespaces" do
-      let(:xml) { <<-eos
-<ns1:foo xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ns1="http://foo.com" xmlns:ns3="http://bar.com">
-  <ns3:bar>baz</ns3:bar>
-  <ns3:bar bar="bar" ns1:foo="foo" class="class">bax</ns3:bar>
-</ns1:foo>
- eos
-}
+    context 'with ignore namespaces' do
+      let(:xml) do
+        <<-eos
+        <ns1:foo xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ns1="http://foo.com" xmlns:ns3="http://bar.com">
+        <ns3:bar>baz</ns3:bar>
+        <ns3:bar bar="bar" ns1:foo="foo" class="class">bax</ns3:bar>
+        </ns1:foo>
+        eos
+      end
 
       subject(:parser) do
-        Saxerator.parser(xml) { |config|
+        Saxerator.parser(xml) do |config|
           config.ignore_namespaces!
-        }
+        end
       end
 
-      specify {
+      specify do
         bar_count = 0
-        parser.for_tag("bar").each do |tag|
+        parser.for_tag('bar').each do |_|
           bar_count += 1
         end
         expect(bar_count).to eq(2)
-      }
+      end
     end
 
-    context "with strip namespaces" do
-      let(:xml) { "<ns1:foo><ns3:bar>baz</ns3:bar></ns1:foo>" }
+    context 'with strip namespaces' do
+      let(:xml) do
+        <<-XML
+        <ns1:foo xmlns:ns1="http://foo.com" xmlns:ns3="http://baz.com">
+        <ns3:bar>baz</ns3:bar>
+        </ns1:foo>
+        XML
+      end
       subject(:parser) do
-        Saxerator.parser(xml) { |config| config.strip_namespaces! }
+        Saxerator.parser(xml) do |config|
+          config.strip_namespaces!
+        end
       end
 
-      specify { expect(parser.all).to eq({'bar' => 'baz'}) }
+      specify { expect(parser.all).to eq('bar' => 'baz') }
       specify { expect(parser.all.name).to eq('foo') }
 
-      context "combined with symbolize keys" do
+      context 'combined with symbolize keys' do
         subject(:parser) do
           Saxerator.parser(xml) do |config|
             config.strip_namespaces!
@@ -121,30 +132,31 @@ describe Saxerator do
           end
         end
 
-        specify { expect(parser.all).to eq({:bar => 'baz'}) }
+        specify { expect(parser.all).to eq(bar: 'baz') }
       end
 
-      context "for specific namespaces" do
+      context 'for specific namespaces' do
         let(:xml) do
-          <<-XML.gsub /^ {10}/, ''
-          <ns1:foo>
-            <ns2:bar>baz</ns2:bar>
-            <ns3:bar>biz</ns3:bar>
+          <<-XML
+          <ns1:foo xmlns:ns1="http://foo.com" xmlns:ns2="http://bar.com" xmlns:ns3="http://baz.com">
+          <ns2:bar>baz</ns2:bar>
+          <ns3:bar>biz</ns3:bar>
           </ns1:foo>
           XML
         end
         subject(:parser) do
-          Saxerator.parser(xml) { |config| config.strip_namespaces! :ns1, :ns3 }
+          Saxerator.parser(xml) do |config|
+            config.strip_namespaces! :ns1, :ns3
+          end
         end
 
-        specify { expect(parser.all).to eq({'ns2:bar' => 'baz', 'bar' => 'biz'}) }
+        specify { expect(parser.all).to eq('ns2:bar' => 'baz', 'bar' => 'biz') }
         specify { expect(parser.all.name).to eq('foo') }
       end
     end
-
   end
 
-  context "configuration with put_attributes_in_hash!" do
+  context 'configuration with put_attributes_in_hash!' do
     let(:xml) { '<foo foo="bar"><bar>baz</bar></foo>' }
 
     subject(:parser) do
@@ -153,8 +165,8 @@ describe Saxerator do
       end
     end
 
-    it "should be able to parse it" do
-      expect(parser.all).to eq({ 'bar' => 'baz', 'foo' => 'bar' })
+    it 'can parse it' do
+      expect(parser.all).to eq('bar' => 'baz', 'foo' => 'bar')
     end
 
     context 'with configured output_type :xml' do
@@ -165,7 +177,7 @@ describe Saxerator do
         end
       end
 
-      context "should raise error with " do
+      context 'raises error with' do
         specify { expect { parser }.to raise_error(ArgumentError) }
       end
     end
@@ -179,7 +191,7 @@ describe Saxerator do
       end
 
       it 'will symbolize attribute hash keys' do
-        expect(parser.all).to include(:bar => 'baz', :foo => 'bar')
+        expect(parser.all.to_hash).to include(bar: 'baz', foo: 'bar')
       end
     end
   end