saxy 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e902b0cd867994419869833857f4c96bb6427f17
-  data.tar.gz: f4e5babf7a86675953869fbec446404fceb9ea0a
+  metadata.gz: 7aece0820f9857b94f42d54164325ea667652065
+  data.tar.gz: 3c98297e4859dd500d6ec283a164e694119943fb
 SHA512:
-  metadata.gz: aebfd829d32a73141a4c289cc4f557ed6c2c647248b659bbc037d9bca1e58196394dd42c9439841262062c29dfb49af953ce7e9cde99179d9ce5e1be2c87962d
-  data.tar.gz: c3d2f658bae270cc76da97881037fb598eb2b254760f349c304fc6943409c9fa1913d2cb65d3bada50c223354e49eed2a4183b5869f7d8b0c7a1debadfc08954
+  metadata.gz: 1cd890ce2423a1b7e19f7a5350e49d04b2863a1e0b03940a996aa33a9d998e5aa238b05200af20dc7466c9337269c260dd03ba7157ca9d8a16170248352b4fe0
+  data.tar.gz: 9d24f74bbd19185bfab0c164652c845befaf7be740264a21f32ecb979e7a6530d6c5ca7f077d57c8c408f5ba475c4bb183eee2bb3db0a0c57d4c8d81ea2c380f

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2012-2014 Monterail.com LLC
+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

data/README.md

@@ -1,12 +1,14 @@
 # Saxy
 
 [![Gem Version](https://badge.fury.io/rb/saxy.svg)](https://badge.fury.io/rb/saxy)
-[![Build Status](https://api.travis-ci.org/monterail/saxy.svg)](http://travis-ci.org/monterail/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.
 
 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.
 
+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
 
 Add this line to your application's Gemfile:
@@ -40,71 +42,82 @@ See `ruby-1.9.2` branch. Install with:
 
 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>
+````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>
+````
 
 You instantiate the parser by passing path to XML file or an IO-like object and object-identyfing tag name as its arguments.
 
-The following will parse the XML, find product definitions (inside `<product>` and `</product>` tags), build `Hash`s and yield them inside the block.
-Tag attributes become object attributes and attributes' name are underscored.
+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:
 
-    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`:
-
-    # > 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.
+````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 yielded Hash 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
+````
 
 ## Contributing
 

data/lib/saxy/element.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/string/inflections'
-
 module Saxy
   class Element
     attr_reader :attributes, :value
@@ -33,7 +31,18 @@ module Saxy
     end
 
     def attribute_name(name)
-      name.underscore.to_sym
+      underscore(name).to_sym
+    end
+
+    private
+
+    def underscore(word)
+      word = word.dup
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
     end
   end
 end

data/lib/saxy/version.rb

@@ -1,3 +1,3 @@
 module Saxy
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/saxy.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |gem|
   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.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) }
@@ -17,7 +17,7 @@ Gem::Specification.new do |gem|
 
   gem.required_ruby_version = ">= 1.9.3"
 
-  gem.add_dependency "activesupport"
   gem.add_dependency "nokogiri"
+
   gem.add_development_dependency "rspec"
 end

data/spec/saxy/element_spec.rb

@@ -5,26 +5,26 @@ 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"
+    expect(element.value).to eq("foobar")
   end
 
   it "should dump as string when no attributes are set" do
-    element.stub(:value).and_return("foo")
-    element.to_h.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)
+    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
@@ -32,18 +32,18 @@ describe Saxy::Element do
     element.append_value("value")
     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.to_h[: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.to_h[:foo].should == ["bar", "baz"]
+    expect(element.to_h[:foo]).to eq(["bar", "baz"])
   end
 end

data/spec/saxy/parser_spec.rb

@@ -10,43 +10,43 @@ describe Saxy::Parser 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 for parsing" do
     parser = Saxy::Parser.new(file_io, "product")
-    parser.each.to_a.size.should == 2
+    expect(parser.each.to_a.size).to eq(2)
   end
 
   it "should accept an IO-like for parsing" do
     parser = Saxy::Parser.new(io_like, "product")
-    parser.each.to_a.size.should == 2
+    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
@@ -55,7 +55,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
 
@@ -65,14 +65,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
@@ -81,7 +81,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
 
@@ -91,7 +91,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
 
@@ -101,36 +101,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.to_h)
+        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
@@ -138,7 +138,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")
@@ -147,16 +147,16 @@ 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.to_h[: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.")
+    expect { parser.error("Error message.") }.to raise_error(Saxy::ParsingError, "Error message.")
   end
 
   it "should return Enumerator when calling #each without a block" do
-    parser.each.should be_instance_of Enumerator
+    expect(parser.each).to be_an(Enumerator)
   end
 
 end

data/spec/saxy_spec.rb

@@ -9,29 +9,29 @@ 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"
+    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")
 
-    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[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" do
-    Saxy.parse(fixture_file("webstore.xml"), "product").each.should be_instance_of Enumerator
+    expect(Saxy.parse(fixture_file("webstore.xml"), "product").each).to be_an(Enumerator)
   end
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: saxy
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Michał Szajbe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-19 00:00:00.000000000 Z
+date: 2016-10-27 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  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
   requirement: !ruby/object:Gem::Requirement
@@ -82,7 +68,7 @@ files:
 - spec/saxy/parser_spec.rb
 - spec/saxy_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/monterail/saxy
+homepage: http://github.com/humante/saxy
 licenses: []
 metadata: {}
 post_install_message: 
@@ -101,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Memory-efficient XML parser. Finds object definitions and translates them