xmlhasher_with_attributes 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 281d60e1c23ea6fa21cdc0435c782ac5929b4e9485af5f9c751dc63582d0db22
+  data.tar.gz: be498e7f638bf459709f228a8c04763c19680a973b951450b31a504336d79ca1
+SHA512:
+  metadata.gz: b0bac84ba10e88731588afb4229aa4f5277054324c578eb1487012aeaa3f9548d96d41d8df0970a673cd991ba2eb416f1c574c870170aa5a175f662bfa0b40af
+  data.tar.gz: 415fcbbdef80104bb05210e07141ce13ca557b87aa016c96c46c777f4d388ef4f0a7c2e81b9fd70768a216998d68ae871da96039d0d890631747ab75aafa58d3

data/.gitignore

@@ -0,0 +1,18 @@
+/.idea
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,19 @@
+language: ruby
+bundler_args: "--without development"
+before_install:
+  - gem install bundler
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - jruby-18mode
+  - jruby-19mode
+  - rbx
+  - rbx-19mode
+  - ree
+env:
+  - JRUBY_OPTS="-Xcext.enabled=true"
+script:
+  - gem build xmlhasher.gemspec
+  - gem install xmlhasher-*

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rake'
+
+group :test do
+  gem 'minitest'
+  gem 'test-unit'
+  gem 'simplecov', :require => false
+  gem 'coveralls', :require => false
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Gene Drabkin
+
+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/README.md

@@ -0,0 +1,84 @@
+# XmlHasher_with_attributes
+
+Fast XML to Ruby Hash converter
+
+This gem is a fork of a fork of [XmlHasher](https://github.com/cloocher/xmlhasher) (through [pawelma](https://github.com/pawelma/xmlhasher)).
+Regarding the original code, there's only one difference : it does not skip attributes if only content is provided.
+I did the work to publish the gem on rubygems.org with a different name to make it available.
+
+Example:
+```ruby
+XmlHasher.parse('<tag attribute="attr_val">content</tag>')
+
+# In original xmlhasher above command will return following hash:
+{
+  tag: "content"
+}
+
+# With xmlhasher_with_attributes hash will be equal:
+{
+  tag: {
+    attribute: "attr_val",
+    value: "content"
+  }
+}
+```
+
+## Installation
+
+* clone this repo
+* run
+```ruby
+bundle install
+rake install
+```
+
+* require
+```ruby
+require 'xmlhasher_with_attributes'
+```
+
+## Usage
+
+```ruby
+require 'xmlhasher_with_attributes'
+
+# XmlHasher global configuration
+#
+# snakecase - convert all keys to snake case notation
+# ignore_namespaces - remove XML namespaces
+# string_keys - represent keys as Strings instead of Symbols
+#
+# here is default configuration
+XmlHasher.configure do |config|
+  config.snakecase = true
+  config.ignore_namespaces = true
+  config.string_keys = false
+end
+
+# alternatively, specify configuration options when instantiating a Parser
+parser = XmlHasher::Parser.new(
+  :snakecase => true,
+  :ignore_namespaces => true
+  :string_keys => false
+)
+
+# by default, XmlHasher will convert all keys to symbols.  If you want all keys to be Strings, set :string_keys option to 'true'
+
+# parse XML file
+XmlHasher.parse(File.new('/path/to/my/file.xml'))
+
+# parse XML string
+XmlHasher.parse("<tag1><tag2>content</tag2></tag1>")
+# => {:tag1=>{:tag2=>"content"}}
+```
+
+## Requirements
+
+* Ruby 1.8.7 or higher
+
+## Copyright
+Copyright (c) 2013 Gene Drabkin.
+See [LICENSE][] for details.
+
+[license]: LICENSE.md

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib' << 'test'
+  t.pattern = 'test/*/*_test.rb'
+  t.verbose = true
+end
+
+task :default => :test

data/benchmark/benchmark.rb

@@ -0,0 +1,95 @@
+$:.push File.expand_path('../../lib', __FILE__)
+
+require 'benchmark'
+require 'xmlhasher'
+begin
+  require 'nori'
+rescue
+  puts "nori gem in not installed, run 'gem install nori'"
+end
+begin
+  require 'active_support/core_ext/hash/conversions'
+rescue
+  puts "active_support gem in not installed, run 'gem install activesupport'"
+end
+begin
+  require 'xmlsimple'
+rescue
+  puts "xmlsimple gem in not installed, run 'gem install xml-simple'"
+end
+begin
+  require 'nokogiri'
+rescue
+  puts "nokogiri gem in not installed, run 'gem install nokogiri'"
+end
+begin
+  require 'libxml'
+rescue
+  puts "libxml gem in not installed, run 'gem install libxml-ruby'"
+end
+
+
+runs = 100
+xml = File.read(File.expand_path('../../test/fixtures/institution.xml', __FILE__))
+puts 'Converting small xml from text to Hash:'
+Benchmark.bm 10 do |x|
+  ActiveSupport::XmlMini.backend = ActiveSupport::XmlMini_REXML
+  x.report 'activesupport(rexml)   ' do
+    runs.times { Hash.from_xml(xml) }
+  end
+
+  ActiveSupport::XmlMini.backend = 'LibXML'
+  x.report 'activesupport(libxml)  ' do
+    runs.times { Hash.from_xml(xml) }
+  end
+
+  ActiveSupport::XmlMini.backend = 'Nokogiri'
+  x.report 'activesupport(nokogiri)' do
+    runs.times { Hash.from_xml(xml) }
+  end
+
+  x.report 'xmlsimple              ' do
+    runs.times { XmlSimple.xml_in(xml) }
+  end
+
+  x.report 'nori                   ' do
+    runs.times { Nori.new(:advanced_typecasting => false).parse(xml) }
+  end
+
+  x.report 'xmlhasher              ' do
+    runs.times { XmlHasher.parse(xml) }
+  end
+end
+
+puts
+runs = 5
+path = File.expand_path('../../test/fixtures/institutions.xml', __FILE__)
+puts 'Converting large xml from file to Hash:'
+Benchmark.bm 5 do |x|
+  ActiveSupport::XmlMini.backend = ActiveSupport::XmlMini_REXML
+  x.report 'activesupport(rexml)   ' do
+    runs.times { Hash.from_xml(File.new(path)) }
+  end
+
+  ActiveSupport::XmlMini.backend = 'LibXML'
+  x.report 'activesupport(libxml)  ' do
+    #runs.times { Hash.from_xml(File.new(path)) } # Segmentation fault
+  end
+
+  ActiveSupport::XmlMini.backend = 'Nokogiri'
+  x.report 'activesupport(nokogiri)' do
+    runs.times { Hash.from_xml(File.new(path)) }
+  end
+
+  x.report 'xmlsimple              ' do
+    runs.times { XmlSimple.xml_in(path) }
+  end
+
+  x.report 'nori                   ' do
+    runs.times { Nori.new(:advanced_typecasting => false).parse(File.new(path).read) } # Nori doesn't support reading from a stream, load the file in memory
+  end
+
+  x.report 'xmlhasher              ' do
+    runs.times { XmlHasher.parse(File.new(path)) }
+  end
+end

data/lib/xmlhasher.rb

@@ -0,0 +1,25 @@
+require 'xmlhasher/configurable'
+require 'xmlhasher/handler'
+require 'xmlhasher/parser'
+require 'xmlhasher/node'
+require 'xmlhasher/util'
+require 'xmlhasher/version'
+
+module XmlHasher
+  class << self
+    include XmlHasher::Configurable
+
+    def parser
+      @parser ||= XmlHasher::Parser.new(options)
+    end
+
+    private
+
+    def method_missing(method_name, *args, &block)
+      return super unless parser.respond_to?(method_name)
+      parser.send(method_name, *args, &block)
+    end
+
+  end
+
+end

data/lib/xmlhasher/configurable.rb

@@ -0,0 +1,20 @@
+module XmlHasher
+  module Configurable
+
+    attr_writer :snakecase, :ignore_namespaces, :string_keys
+
+    KEYS = [:snakecase, :ignore_namespaces, :string_keys]
+
+    def configure
+      yield self
+      self
+    end
+
+    private
+
+    def options
+      XmlHasher::Configurable::KEYS.inject({}) { |hash, key| hash[key] = instance_variable_get(:"@#{key}"); hash }
+    end
+
+  end
+end

data/lib/xmlhasher/handler.rb

@@ -0,0 +1,55 @@
+require 'ox'
+require 'escape_utils'
+
+module XmlHasher
+  class Handler < ::Ox::Sax
+    def initialize(options = {})
+      @options = options
+      @stack = []
+    end
+
+    def to_hash
+      @hash || {}
+    end
+
+    def start_element(name)
+      @stack.push(Node.new(transform(name)))
+    end
+
+    def attr(name, value)
+      unless ignore_attribute?(name)
+        @stack.last.attributes[transform(name)] = escape(value) unless @stack.empty?
+      end
+    end
+
+    def text(value)
+      @stack.last.text = escape(value)
+    end
+
+    def end_element(name)
+      if @stack.size == 1
+        @hash = @stack.pop.to_hash
+      else
+        node = @stack.pop
+        @stack.last.children << node
+      end
+    end
+
+    private
+
+    def transform(name)
+      name = name.to_s.split(':').last if @options[:ignore_namespaces]
+      name = Util.snakecase(name) if @options[:snakecase]
+      name = name.to_sym unless @options[:string_keys]
+      name
+    end
+
+    def escape(value)
+      EscapeUtils.unescape_html(value)
+    end
+
+    def ignore_attribute?(name)
+      @options[:ignore_namespaces] ? !name.to_s[/^(xmlns|xsi)/].nil? : false
+    end
+  end
+end

data/lib/xmlhasher/node.rb

@@ -0,0 +1,39 @@
+module XmlHasher
+  class Node
+    attr_accessor :name, :attributes, :children, :text
+
+    def initialize(name)
+      @name = name
+      @attributes = {}
+      @children = []
+    end
+
+    def to_hash
+      h = {}
+      if text
+        if clean_attributes.empty?
+          h[name] = text
+        else
+          h[name] = clean_attributes.merge(value: text)
+        end
+      else
+        h[name] = clean_attributes
+        if children.size == 1
+          child = children.first
+          h[name].merge!(child.to_hash)
+        else
+          h[name].merge!(children.group_by { |c| c.name }.inject({}) { |r, (k, v)| v.length == 1 ? r.merge!(v.first.to_hash) : r[k] = v.map { |c| c.to_hash[c.name] }; r })
+        end
+      end
+      h[name] = nil if h[name].empty?
+      h
+    end
+
+    private
+
+    def clean_attributes
+      return @clean_attributes if defined? @clean_attributes
+      @clean_attributes = attributes.inject({}) { |r, (key, value)| r[key] = value if !value.nil? && !value.to_s.empty?; r }
+    end
+  end
+end

data/lib/xmlhasher/parser.rb

@@ -0,0 +1,22 @@
+require 'stringio'
+
+module XmlHasher
+  class Parser
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def parse(xml)
+      handler = Handler.new(@options)
+      Ox.sax_parse(handler, convert(xml))
+      handler.to_hash
+    end
+
+    private
+
+    def convert(xml)
+      xml.respond_to?(:read) || xml.respond_to?(:readpartial) ? xml : StringIO.new(xml)
+    end
+  end
+end