xmlmunger 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bd96e736bb5dd412ad3f3557fd21e379bc5247d5
+  data.tar.gz: 15e5b2ea8a778a40fec73b4312d0741f415f2e16
+SHA512:
+  metadata.gz: a8a24f4d0e19944332a4c2c3a61c3942243dc2d37f188ce97058c1fcdc895b502ce89f0f15d60ed30f959b09dcca2e7f7bdb358f9faa4968ac9a01324a66ea6e
+  data.tar.gz: 5744a2c806e068c97b749e45c3ffbcdcd10bcf32a8115c7fef7d9cc9e1d6188e9516f8a4c8365c8a141f284915ae3c9ace7d9ca0f49f3087df6e7f932545aa5d

data/.gitignore

@@ -0,0 +1,8 @@
+*~
+pkg/*
+doc/*
+Gemfile.lock
+*.gem
+bin
+docs/_build
+coverage

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+before_install:
+  - gem install nokogiri -- --with-cflags='--std=gnu99'
+env: CODECLIMATE_REPO_TOKEN=540a9a9dd5d7371276ffd320c85d936726dd362b6b2c0333017c13ff5e133a7d 

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Dependencies in xmlmunger.gemspec
+gemspec development_group: :test

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2010-2014 Andrew Benton.
+
+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,7 @@
+xmlmunger
+=========
+
+Convert XML files into flat hashes with automatic naming via nested paths
+
+[![Build Status](https://travis-ci.org/robertzk/xmlmunger.svg?branch=master)](https://travis-ci.org/robertzk/xmlmunger)
+[![Code Climate](https://codeclimate.com/github/robertzk/xmlmunger.png)](https://codeclimate.com/github/robertzk/xmlmunger)

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test
+

data/lib/xmlmunger.rb

@@ -0,0 +1,36 @@
+require 'xmlmunger/version'
+require 'xmlmunger/nori_constants'
+require 'xmlmunger/nested_hash'
+require 'xmlmunger/list_heuristics'
+require 'xmlmunger/parser'
+
+module XMLMunger
+
+  # Add native support to testing libraries
+
+  module Test
+    module Unit
+      class TestCase
+        include ::XMLMunger
+      end
+    end
+  end
+
+  module MiniTest
+    class Unit
+      class TestCase
+        include ::XMLMunger
+      end
+    end
+  end
+
+
+  module RSpec
+    module Core
+      class ExampleGroup
+        include ::XMLMunger
+      end
+    end
+  end
+
+end

data/lib/xmlmunger/list_heuristics.rb

@@ -0,0 +1,242 @@
+require 'descriptive_statistics/safe'
+
+module XMLMunger
+  class StateError < StandardError; end
+  class ListHeuristics
+
+    def initialize(list)
+      raise ArgumentError, "Argument must be an array" unless list.is_a?(Array)
+      @list = list
+    end
+
+    def empty?
+      @empty ||= @list.count.zero?
+    end
+
+    def singleton?
+      @singleton ||= @list.count == 1
+    end
+
+    def multiple?
+      @multiple ||= @list.count > 1
+    end
+
+    def common_type(of = nil)
+          @common_types ||= {}
+                     of ||= @list
+      @common_types[of] ||= of.map{|x|x.class.ancestors}.reduce(:&).first
+    end
+
+    def skipped_types
+      @skipped_types ||= [:strings]
+    end
+
+    def shared_key_hashes?
+      @shared_key_hashes ||=
+        multiple? &&
+          common_type == Hash &&
+            (keys = @list.first.keys) &&
+              @list[1..-1].all? { |hash| hash.keys == keys }
+    end
+
+    def to_variable_hash
+      return {} if empty?
+      return {nil => @list.first} if singleton?
+      if shared_key_hashes?
+        merged = merge_hashes(@list)
+        typed = classify(merged)
+      else
+        type, data = identity(@list)
+        typed = { nil => { type: type, data: data } }
+      end
+      apply(typed)
+    end
+
+    private
+
+    # call data extraction functions
+    # returns a variable hash
+    def apply(input)
+      filter_types(input).reduce({}) do |out, (var,with)|
+        func = "extract_#{with[:type]}".to_sym
+        self.send(func, with[:data]).each do |key,val|
+          ind = [var,key].map(&:to_s).reject{ |s| s.empty? }.join('_')
+          out[ind] = val
+        end
+        out
+      end
+    end
+
+    # Allow caller to ignore certain data types
+    def filter_types(input)
+      input.reject { |k,v|
+        ( skipped_types + [:notype, :other] ).include?(v[:type])
+      }
+    end
+
+    # merge multiple hashes with the same keys
+    # resulting hash values are arrays of the input values
+    def merge_hashes(hashes)
+      keys = hashes.first.keys
+      container = Hash[*keys.map{|k|[k,[]]}.flatten(1)]
+      hashes.each { |hash| hash.each { |(k,v)| container[k] << v } }
+      container
+    end
+
+    # discover type information for each
+    # key,value pair of the input hash
+    def classify(hash)
+      hash.reduce({}) do |acc, (var, vals)|
+        type, data = identity(vals)
+        acc[var] = {
+          type: type,
+          data: data
+        }
+        acc
+      end
+    end
+
+    # assign the list of values into its proper type
+    # also return the appropriate transformation of the input list
+    TYPES = [:boolean?, :singleton?, :days?, :numeric?, :strings?, :notype?]
+    def identity(vals, memo = {})
+      TYPES.each do |key|
+        if compute(key, vals, memo)
+          type = key[0...-1].to_sym
+          val = compute(type, vals, memo)
+          return type, val
+        end
+      end
+      return :other, vals
+    end
+
+    # memoized computations for #identity
+    def compute(what, vals, store)
+      store[what] ||= case what
+        # ifs
+        when :singleton?
+          compute(:unique, vals, store).count == 1
+        when :boolean?
+          all_type?(vals, TrueClass, FalseClass)
+        when :days?
+          all_type?(vals, Date, Time)
+        when :numeric?
+          compute(:numeric, vals, store).all?
+        when :strings?
+          common_type(vals) <= String
+        when :notype?
+          common_type(vals) == Object
+        # thens
+        when :singleton
+          compute(:unique, vals, store).first
+        when :unique
+          vals.uniq
+        when :numeric
+          vals.map{ |x| to_numeric(x) }
+        when :days
+          dates = vals.map{ |x| x.to_date }
+          epoch = Date.new(1970,1,1)
+          dates.map { |d| (d - epoch).to_i }
+        else
+          vals
+      end
+    end
+
+    # Data Extraction Functions
+
+    def extract_singleton(item)
+      {nil => item}
+    end
+
+    def extract_boolean(vals)
+      has, vec = 0, 0
+      vals.each do |bool|
+        case bool
+        when FalseClass
+          has |= 1
+          vec -= 1
+        when TrueClass
+          has |= 2
+          vec += 1
+        end
+      end
+      {has: has, vec: vec}
+    end
+
+    def extract_strings(items)
+      h = Hash.new(0)
+      items.each{ |i| h[i] += 1 }
+      h.reduce({}) do |acc,(item,count)|
+        acc[var_name_for_string(item)] = count
+        acc
+      end
+    end
+
+    def extract_days(days)
+      sorted_days = days.sort
+      difference_comps(sorted_days)
+    end
+
+    def extract_numeric(numbers)
+      case
+      when is_sequence?(numbers,3), all_large?(numbers)
+        {} # do nothing; junk data
+      else
+        difference_comps(numbers)
+      end
+    end
+
+    # Utility Functions
+
+    def to_numeric(anything)
+      float = Float(anything)
+      int = Integer(anything) rescue float
+      float == int ? int : float
+    rescue
+      nil
+    end
+
+    def is_sequence?(nums, min_length = nil)
+      (min_length.nil? || nums.count >= min_length) &&
+        nums == (nums.min..nums.max).to_a
+    end
+
+    def all_large?(nums)
+      nums.all? { |n|
+        n > 1000000
+      }
+    end
+
+    def all_type?(objects, *types)
+      objects.all? { |obj|
+        types.any?{ |c| obj.is_a?(c) }
+      }
+    end
+
+    def difference_comps(data)
+      stats = {}
+      stats[:length] = data.count
+      stats[:min] = data.min
+      stats[:max] = data.max
+      if stats[:length] > 1
+        diffs = data.each_cons(2).map { |a,b| b-a }
+        diffs.extend(DescriptiveStatistics)
+        stats[:min_diff] = diffs.min
+        stats[:max_diff] = diffs.max
+        stats[:avg_diff] = diffs.median
+      end
+      stats
+    end
+
+    def var_name_for_string(key)
+      base = "is_"
+      if key.nil?
+        base += "nil"
+      else
+        base += key.to_s.strip.gsub(/\s+/, "_").downcase
+      end
+      base
+    end
+
+  end
+end

data/lib/xmlmunger/nested_hash.rb

@@ -0,0 +1,90 @@
+module XMLMunger
+
+  class NestedHash < Hash
+    #######
+    # Don't lose class type
+    #######
+    (Hash.instance_methods - Object.instance_methods).each do |m|
+      define_method(m) { |*args, &block|
+        result = super(*args, &block)
+        return NestedHash[result] if result.class == Hash
+        result
+      }
+    end
+
+    #######
+    # Map terminal hash values in a nested hash
+    # > nh = NestedHash[a: { c: 2 }, b: 1]
+    # => { a: { c: 2 }, b: 1 }
+    # > nh.transform { |value| value + 1 }
+    # => { a: { c: 3 }, b: 2 }
+    #######
+    def transform(&block)
+      # http://stackoverflow.com/questions/5189161/changing-every-value-in-a-hash-in-ruby
+      NestedHash[self.map { |key, value|
+        [key, case value.class.to_s
+          when 'Hash', 'NestedHash' then NestedHash[value].transform(&block)
+          else yield value
+        end]
+      }]
+    end
+
+    #######
+    # Map terminal hash values in a nested hash *with* route tracking
+    # > nh = NestedHash[a: { c: 2 }, b: 1]
+    # => { a: { c: 2 }, b: 1 }
+    # > nh.transform_with_route { |route, value| "#{route.join(' -> ')} -> #{value}" }
+    # => { a: { c: "a -> c -> 2" }, b: "b -> 1" }
+    #######
+    def transform_with_route(route = [], &block)
+      NestedHash[self.map { |key, value|
+        [key, case value.class.to_s
+          when 'Hash', 'NestedHash' then
+            NestedHash[value].transform_with_route(route.dup.concat([key]), &block)
+          else yield route.dup.concat([key]), value
+        end]
+      }]
+    end
+
+    #######
+    # Map terminal hash values in a nested hash to an array
+    # > nh = NestedHash[a: { c: 2 }, b: 1]
+    # => { a: { c: 2 }, b: 1 }
+    # > nh.map_values
+    # => [2, 1]
+    # > nh.map_values { |x| x + 1 }
+    # => [3, 2]
+    #######
+    def map_values(&block)
+      values = []
+      self.each { |key, value|
+        values.concat case value.class.to_s
+          when 'Hash', 'NestedHash' then NestedHash[value].map_values(&block)
+          else [block_given? ? yield(value) : value]
+        end
+      }
+      values
+    end
+
+    #######
+    # Map terminal hash values in a nested hash to an array *with* route tracking
+    # > nh = NestedHash[a: { c: 2 }, b: 1]
+    # => { a: { c: 2 }, b: 1 }
+    # > nh.map_values_with_route { |route, value| route << value**value }
+    # => [[:a, :c, 4], [:b, 1]]
+    #######
+    def map_values_with_route(route = [], &block)
+      values = []
+      self.each { |key, value|
+        route_copy = route.dup
+        values.concat case value.class.to_s
+          when 'Hash', 'NestedHash' then
+            NestedHash[value].map_values_with_route(route_copy.concat([key]), &block)
+          else [block_given? ? yield(route_copy.concat([key]), value) : route_copy.concat([key, value])]
+        end
+      }
+      values
+    end
+  end
+
+end

data/lib/xmlmunger/nori_constants.rb

@@ -0,0 +1,10 @@
+module XMLMunger
+
+  class NoriConstants
+    def self.default_options
+      { strip_namespaces: true,
+        convert_tags_to: lambda { |tag| tag.snakecase.to_sym } }
+    end
+  end
+
+end

data/lib/xmlmunger/parser.rb

@@ -0,0 +1,70 @@
+require 'nori'
+
+module XMLMunger
+
+  class Parser
+    attr_accessor :xml
+
+    def initialize xml, nori_options = {}
+      unless xml.is_a?(Hash)
+        unless xml.is_a?(String)
+          raise ArgumentError.new("Argument xml should be a Hash or String (XML file).")
+        end
+        @xml = ::Nori.new(NoriConstants.default_options.merge(nori_options)).parse(xml)
+      else
+        @xml = xml
+      end
+    end
+
+    def run options = {}
+      # prepare the options hash
+      raise TypeError.new("options argument must be a hash") unless options.is_a?(Hash)
+      options = default_options.merge options
+      # move to the starting point and traverse the xml
+      filtered = options[:filter].inject(xml) { |hash, key| hash[key] }
+      traverse = NestedHash[filtered].map_values_with_route do |route, value|
+        # skip attributes?
+        next if !options[:attributes] && route.any? { |r| r =~ /@/ }
+        # prohibited type?
+        next if options[:prohibited_types].any? { |type| value.is_a?(type) }
+        # extract data from lists
+        value = ListHeuristics.new(value).to_variable_hash if value.is_a?(Array)
+        [route, value]
+      end.compact
+      # create variable:value mapping
+      # need the second iteration in case of list data
+      parsed = NestedHash[traverse].map_values_with_route do |route, value|
+        key = make_key(route, options)
+        [key, value]
+      end
+      NestedHash[parsed]
+    end
+
+    protected
+
+    def default_options
+      {
+        prefix: '',
+        filter: [],
+        sep: '_',
+        strip_chars: '',  # Whether to strip any characters from route names
+        attributes: true, # Whether or not to parse XML tag attributes
+        prohibited_types: [Array]
+      }
+    end
+
+    private
+
+    def make_key(route, options)
+      route.
+        flatten.
+        map { |s| s.to_s.tr(options[:strip_chars], '') }.
+        reject { |s| s.empty? }.
+        join(options[:sep]).
+        prepend(options[:prefix])
+    end
+
+  end
+
+end
+

data/lib/xmlmunger/version.rb

@@ -0,0 +1,3 @@
+module XMLMunger
+  VERSION = '0.0.6'
+end

data/test/test_nested_hash.rb

@@ -0,0 +1,36 @@
+require 'test/unit'
+require 'xmlmunger'
+
+class NestedHashTest < Test::Unit::TestCase
+
+  def nested_hash
+    ::XMLMunger::NestedHash[a: {b: 1}, c: { d: {e: 2} }] 
+  end
+
+  def test_transform_nested_hash
+    nested_hash2 = nested_hash.transform { |value| value + 1 }
+    assert_equal nested_hash2[:a][:b], 2
+    assert_equal nested_hash2[:c][:d][:e], 3
+  end
+
+  def test_transform_nested_hash_with_route
+    nested_hash2 = nested_hash.transform_with_route { |route, value|
+      route.concat [value]
+    }
+    assert_equal nested_hash2[:a][:b], [:a, :b, 1]
+    assert_equal nested_hash2[:c][:d][:e], [:c, :d, :e, 2]
+  end
+
+  def test_map_nested_hash
+    nested_hash2 = nested_hash.map_values { |value| value }
+    assert_equal nested_hash2, [1, 2]
+  end
+
+  def test_map_nested_hash_with_route
+    nested_hash2 = nested_hash.map_values_with_route { |route, value|
+      route.concat [value]
+    }
+    assert_equal nested_hash2, [[:a, :b, 1], [:c, :d, :e, 2]]
+  end
+
+end

data/test/test_parser.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+require 'xmlmunger'
+
+class ParserTest < Test::Unit::TestCase
+
+  def test_simple_nested_parse
+    parser = ::XMLMunger::Parser.new('<x><y>1</y><z>2</z></x>')
+    hash = parser.run
+    assert_equal({"x_y"=>"1", "x_z"=>"2"}, hash)
+  end
+
+  def test_filter_option
+    parser = ::XMLMunger::Parser.new('<x><y>1</y><z>2</z></x>')
+    hash = parser.run(filter: [:x])
+    assert_equal({"y"=>"1", "z"=>"2"}, hash)
+  end
+
+  def test_prefix_option
+    parser = ::XMLMunger::Parser.new('<x><y>1</y><z>2</z></x>')
+    hash = parser.run(prefix: 'test_')
+    assert_equal({"test_x_y"=>"1", "test_x_z"=>"2"}, hash)
+  end
+
+  def test_sep_option
+    parser = ::XMLMunger::Parser.new('<x><y>1</y><z>2</z></x>')
+    hash = parser.run(sep: '-')
+    assert_equal({"x-y"=>"1", "x-z"=>"2"}, hash)
+  end
+
+  def test_prohibited_types_option
+    parser = ::XMLMunger::Parser.new('<x><y><z>1</z><z>1</z></y><z>2</z></x>')
+    hash = parser.run(prohibited_types: [Array])
+    assert_equal({"x_z"=>"2"}, hash)
+  end
+
+  def test_strip_chars_option
+    parser = ::XMLMunger::Parser.new('<x_y><z_w>2</z_w></x_y>')
+    hash = parser.run(strip_chars: '_')
+    assert_equal({"xy_zw" => "2"}, hash)
+  end
+
+  def test_attributes_option
+    parser = ::XMLMunger::Parser.new('<x a="1" />')
+    hash = parser.run(attributes: true)
+    assert_equal({"x_@a" => "1"}, hash)
+    hash = parser.run(attributes: false)
+    assert_equal({}, hash)
+    hash = parser.run(attributes: true, strip_chars: '@')
+    assert_equal({"x_a" => "1"}, hash)
+    hash = parser.run(attributes: false, strip_chars: '@')
+    assert_equal({}, hash)
+  end
+
+
+
+end
+

data/test/test_xmlmunger.rb

@@ -0,0 +1,7 @@
+if ENV['CODECLIMATE_REPO_TOKEN']
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+end
+require 'test/unit'
+load 'test_nested_hash.rb'
+load 'test_parser.rb'

data/xmlmunger.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+require './lib/xmlmunger/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'xmlmunger'
+  s.version     = XMLMunger::VERSION
+  s.date        = Date.today.to_s
+  s.summary     = 'Convert XML files into flat hashes with automatic naming via nested paths'
+  s.description = %(XML files typically come in nested structures. For data extraction purposes,
+    we frequently wish to have a flat hash instead. The naming then becomes tricky, because
+    there can be collision in the terminal nodes. However, if we use the chain of parent tags
+    joined with an underscore, this provides a unique name for every data point in the XML file.
+    The goal of this package is to make it very simple to convert XML files into flat hashes.
+  ).strip.gsub(/\s+/, " ")
+  s.authors     = ["Robert Krzyzanowski", "David Feldman"]
+  s.email       = 'rkrzyzanowski@gmail.com'
+  s.homepage    = 'http://avantcredit.com'
+  s.license     = 'MIT'
+  s.homepage    = 'https://github.com/robertzk/xmlmunger'
+
+  s.platform = Gem::Platform::RUBY
+  s.require_paths = %w[lib]
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  s.add_dependency 'nokogiri', '>= 1.6.1'
+  s.add_dependency 'nori', '>= 2.3.0'
+  s.add_dependency 'descriptive_statistics', '>= 1.1.5'
+
+  s.add_development_dependency 'rake', '>= 0.9.0'
+  s.add_development_dependency 'test-unit', '>= 1.2.3'
+  s.add_development_dependency 'codeclimate-test-reporter'
+
+  s.extra_rdoc_files = ['README.md', 'LICENSE']
+end
+

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: xmlmunger
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+platform: ruby
+authors:
+- Robert Krzyzanowski
+- David Feldman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+- !ruby/object:Gem::Dependency
+  name: nori
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+- !ruby/object:Gem::Dependency
+  name: descriptive_statistics
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.3
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  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: XML files typically come in nested structures. For data extraction purposes,
+  we frequently wish to have a flat hash instead. The naming then becomes tricky,
+  because there can be collision in the terminal nodes. However, if we use the chain
+  of parent tags joined with an underscore, this provides a unique name for every
+  data point in the XML file. The goal of this package is to make it very simple to
+  convert XML files into flat hashes.
+email: rkrzyzanowski@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/xmlmunger.rb
+- lib/xmlmunger/list_heuristics.rb
+- lib/xmlmunger/nested_hash.rb
+- lib/xmlmunger/nori_constants.rb
+- lib/xmlmunger/parser.rb
+- lib/xmlmunger/version.rb
+- test/test_nested_hash.rb
+- test/test_parser.rb
+- test/test_xmlmunger.rb
+- xmlmunger.gemspec
+homepage: https://github.com/robertzk/xmlmunger
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Convert XML files into flat hashes with automatic naming via nested paths
+test_files:
+- test/test_nested_hash.rb
+- test/test_parser.rb
+- test/test_xmlmunger.rb