xml-to-hash 0.9.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 31d59b40fb3dc7a1871e7c57e920ada8ddb17409
-  data.tar.gz: 8ac9f306b1583f3337df70137d45b116a7f55cad
+  metadata.gz: 08fb0fa4983e65846ebd00cd4ce754b0c0a957e5
+  data.tar.gz: e9db1b95fbf058631078642e5828ef07e7af46e5
 SHA512:
-  metadata.gz: 1a34928339763a712c247ac5a4422d35145ad3bb19b0c2b1f40aa21b16255db10b5983831a12304948d94004b273fd68019d8900231fc686982f13b3fc564020
-  data.tar.gz: 65f3a4203ff7d1401b517a27b8a69bdaf69f07b756a82d2eb61991b3477ef0a75dea09b7919d389c27582610ee0bc47cc58173787a9c3fd4b8b297a28b630a01
+  metadata.gz: d5915f6d12e161143e5cb779d7318087b614cb0981b636ad0c8d19dade9117b7b0a837e292028cdda1b43ac2c1cd664ec0e973cdcc5d9c39df37a65bfa89a3d7
+  data.tar.gz: 2e568875fef31d96dca31cf52224608af28056991f60285cdcc1d2f53d7674809ce594983867c5862ed9c5aa4c19b0dc85c49880a2f93a605ab8b155c45143b8

data/README

@@ -0,0 +1,221 @@
+# XML to Hash
+
+This Ruby gem adds a `to_hash` method to Nokogiri XML nodes, allowing us to convert arbitrary XML nodes to a Ruby hash,
+and so also to serialize them to JSON.
+
+This gem also picks up attributes, processing instructions and doctype declarations. The resulting hash is wordy, but complete.
+
+As an added bonus, we include line numbers where possible.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'xml-to-hash'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install xml-to-hash
+
+## Usage
+
+```ruby
+include 'xml/to/hash'
+
+xml_string = STR_XML = <<-EOS
+                       <!DOCTYPE dtd-name [
+                          <!ENTITY entity_1 "Has been ëxpÄnded">
+                          <!ENTITY entity_system SYSTEM "mt_cook1.jpg">
+                          <!ENTITY name_public PUBLIC "entity_public_id" "URI">
+                          <!NOTATION notation-system SYSTEM "notation-id-system">
+                          <!NOTATION NoTaTiOn-PuBLiC PUBLIC "notation-id-public">
+                          <!ELEMENT div1 (head,
+                       (p | list | note)*,
+                       div2*)>
+                          <!ELEMENT photo (hello)>
+                          <!ATTLIST photo some-attribute CDATA #REQUIRED>
+                          <!ATTLIST
+                            photo photo_att ENTITY #IMPLIED
+                            photo NOTATION (notation-system | NoTaTiOn-PuBLiC | notation-system) #IMPLIED>
+                       ]>
+
+                       <myRoot xml:id="root" xml:lang="en">
+                             some text
+                             <!--
+                             In comments we can use ]]>
+                             <
+                             &,
+                       ',
+                       and ",
+                       but %MyParamEntity; will not be expanded-->
+                             <![CDATA[
+                             Character Data block <!-- <,
+                       & ' " -->  *and* %MyParamEntity;
+                             ]]>
+                             <?linebreak?>
+                             <deeper xmlns="lol://some-namespace" how-deep="very-deep">☠☠☠randomtext☠☠☠
+                             <even
+                               lol:my-attr="just an attribute"
+                               xmlns:lol=\'lol://my.name.space/\' deeper="true">&amp;</even></deeper>
+                       </myRoot>
+EOS
+
+xml = Nokogiri::XML STR_XML
+hash = xml.root.to_hash # Use xml.to_hash for information about the document, like DTD and stuff
+
+puts JSON.pretty_generate(hash)
+```
+
+produces
+
+```json
+{
+  "type": "element",
+  "name": "myRoot",
+  "attributes": [
+    {
+      "type": "attribute",
+      "name": "id",
+      "content": "root",
+      "line": 17,
+      "namespace": {
+        "href": "http://www.w3.org/XML/1998/namespace",
+        "prefix": "xml"
+      }
+    },
+    {
+      "type": "attribute",
+      "name": "lang",
+      "content": "en",
+      "line": 17,
+      "namespace": {
+        "href": "http://www.w3.org/XML/1998/namespace",
+        "prefix": "xml"
+      }
+    }
+  ],
+  "line": 17,
+  "children": [
+    {
+      "type": "text",
+      "content": "\n                             some text\n                             ",
+      "line": 19
+    },
+    {
+      "type": "comment",
+      "content": "\n                             In comments we can use ]]>\n                             <\n                             &,\n                       ',\n                       and \",\n                       but %MyParamEntity; will not be expanded",
+      "line": 25
+    },
+    {
+      "type": "text",
+      "content": "\n                             ",
+      "line": 26
+    },
+    {
+      "type": "cdata",
+      "name": "#cdata-section",
+      "content": "\n                             Character Data block <!-- <,\n                       & ' \" -->  *and* %MyParamEntity;\n                             ",
+      "line": 26
+    },
+    {
+      "type": "text",
+      "content": "\n                             ",
+      "line": 30
+    },
+    {
+      "type": "pi",
+      "name": "linebreak",
+      "line": 30
+    },
+    {
+      "type": "text",
+      "content": "\n                             ",
+      "line": 31
+    },
+    {
+      "type": "element",
+      "name": "deeper",
+      "attributes": [
+        {
+          "type": "attribute",
+          "name": "how-deep",
+          "content": "very-deep",
+          "line": 31
+        }
+      ],
+      "line": 31,
+      "namespace": {
+        "href": "lol://some-namespace"
+      },
+      "children": [
+        {
+          "type": "text",
+          "content": "☠☠☠randomtext☠☠☠\n                             ",
+          "line": 32
+        },
+        {
+          "type": "element",
+          "name": "even",
+          "attributes": [
+            {
+              "type": "attribute",
+              "name": "my-attr",
+              "content": "just an attribute",
+              "line": 34,
+              "namespace": {
+                "href": "lol://my.name.space/",
+                "prefix": "lol"
+              }
+            },
+            {
+              "type": "attribute",
+              "name": "deeper",
+              "content": "true",
+              "line": 34
+            }
+          ],
+          "line": 34,
+          "namespace": {
+            "href": "lol://some-namespace"
+          },
+          "children": [
+            {
+              "type": "text",
+              "content": "&",
+              "line": 34
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "type": "text",
+      "content": "\n                       ",
+      "line": 35
+    }
+  ]
+}
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/digitalheir/ruby-xml-to-hash. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](CODE_OF_CONDUCT).
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/lib/xml/to/hash.rb

@@ -1,18 +1,106 @@
-require 'xml/to/hash/version'
 require 'nokogiri'
 
 module Xml
+  # noinspection RubyClassModuleNamingConvention
   module To
     module Hash
+      VERSION = '1.0.1'
+
+      def add_children!(node, hash, blacklist=[])
+        unless node.respond_to? :node_type and blacklist.include? node.node_type
+          if node.children and node.children.length > 0
+            children_nodes=[]
+            node.children.each do |child|
+              children_nodes << child.to_hash
+            end
+            hash[:children]=children_nodes
+          end
+        end
+      end
     end
   end
 end
+
 module Nokogiri
   module XML
-    class Node
+    class Notation
+      def to_hash
+        hash = {
+        }
+        add_if_respond_to!(hash, :name)
+        add_if_respond_to!(hash, :public_id)
+        add_if_respond_to!(hash, :system_id)
+        hash
+      end
+
+      private
+      def add_if_respond_to!(hash, method)
+        if respond_to? method and self.send method
+          hash[method]= self.send method
+        end
+        hash
+      end
+    end
+    class Namespace
+      include Xml::To::Hash
 
+      def to_hash
+        hash = {
+            href: href
+        }
+        if prefix
+          hash[:prefix] = prefix
+        end
+        hash
+      end
+    end
+    class ElementContent
+      include Xml::To::Hash
+
+      def to_hash
+        hash = {}
+        if name
+          hash[:name] = name
+        end
+        if prefix
+          hash[:prefix] = prefix
+        end
+        if occur
+          case occur
+            when ONCE
+              hash[:occur] = :once
+            when OPT
+              hash[:occur] = :opt
+            when MULT
+              hash[:occur] = :mult
+            when PLUS
+              hash[:occur] = :plus
+            else
+              raise "Could not handle occur value #{occur}"
+          end
+        end
+        if type
+          case type
+            when PCDATA
+              hash[:type] = :pcdata
+            when ELEMENT
+              hash[:type] = :element
+            when SEQ
+              hash[:type] = :seq
+            when OR
+              hash[:type] = :or
+            else
+              raise "Could not handle type value #{occur}"
+          end
+        end
+        add_children! self, hash
+        hash
+      end
+    end
+    class Node
+      include Xml::To::Hash
       # Returns node type as symbol instead of integer
-      def self.get_type int
+      def self.get_type(int)
         case int
           # Element node type, see Nokogiri::XML::Node#element?
           when Nokogiri::XML::Node::ELEMENT_NODE
@@ -78,71 +166,119 @@ module Nokogiri
           when Nokogiri::XML::Node::DOCB_DOCUMENT_NODE
             return :docb_document
           else
-            return int
+            raise "Could not handle node type #{int}"
         end
       end
 
+      def set_attributes(hash)
+        hash = hash.clone
+        set_attributes!(hash)
+        hash
+      end
+
+      def set_attributes!(hash)
+        if respond_to? :attribute_nodes and attribute_nodes.length > 0
+          hash[:attributes] = []
+          attribute_nodes.each do |attr|
+            hash[:attributes] << attr.to_hash
+          end
+        end
+        hash
+      end
+
       # Serialize this Node to a hash
       #
       # Example:
-      #    >> Nokogiri::XML '<xml>hello</xml>'
+      #    >> Nokogiri::XML('<xml>hello</xml>').root.to_hash
       #    => {:type=>:element, :name=>"xml", :children=>[{:type=>:text, :content=>"hello"}]}
       def to_hash
-        Node.obj_for_node root
-      end
-
-      private
-      # Given a Nokigiri XML node, create a Ruby hash 
-      def self.obj_for_node node
-        ret = {
-            type: get_type(node.node_type),
-        }
-        if node.attributes and node.attributes.length > 0
-          ret[:attrs] = []
-          node.attributes
-          node.attributes.each do |key|
-            attr = key[1]
-            attr_o = {
-                name: key[0],
-                value: attr.content
-            }
-            if attr.namespace
-              attr_o[:namespace] = namespace_hash(attr.namespace)
+        def set_if_respond_to!(hash, meth, blacklist=[])
+          unless blacklist.include? node_type
+            if respond_to? meth
+              val = send(meth)
+              if val
+                if Node.get_type(node_type).to_s == val
+                  puts "Consider blacklisting #{val} for #{meth}"
+                end
+                if val.respond_to? :to_hash
+                  val = val.to_hash
+                end
+                hash[meth] = val
+              end
             end
-            ret[:attrs] << attr_o
           end
         end
-        # Treat elements a little bit differently 
-        case node.node_type
-          when Nokogiri::XML::Node::ELEMENT_NODE, Nokogiri::XML::Node::PI_NODE
-            ret[:name] = node.name
-          else
-            ret[:content]= node.content
-        end
-        if node.namespace
-          ret[:namespace] = namespace_hash(node.namespace)
-        end
 
-        # Recurse into children
-        if node.children and node.children.length > 0
-          unless node.element?
-            puts "W-What? Node had children, but was not an element (but a #{get_type node.node_type})"
+        # Helper functions
+        def set_object_array!(hash, meth)
+          if respond_to? meth and send(meth) and send(meth).length > 0
+            hash[meth] = []
+            array = send(meth)
+            case meth
+              when :entities, :elements, :notations
+                array = array.values
+              else
+            end
+            array.each do |el|
+              hash[meth] << el.to_hash
+            end
           end
-          ret[:children]=[]
-          node.children.each do |child|
-            ret[:children] << obj_for_node(child)
+          hash
+        end
+
+        def set_content!(hash, blacklist=[])
+          unless blacklist.include? node_type
+            if respond_to? :content and content
+              c = content
+              if c.class == String
+                hash[:content] = c
+              elsif c.is_a? Nokogiri::XML::ElementContent
+                hash[:content] = c.to_hash
+              else
+                raise "Could not handle content class #{c.class}"
+              end
+            end
           end
+          hash
         end
-        ret
-      end
 
-      def self.namespace_hash(namespace)
+        # Initialize hash
         hash = {
-            href: namespace.href
+            type: Node.get_type(node_type),
         }
-        if namespace.prefix
-          hash[:prefix] = namespace.prefix
+
+        # Treat elements a little bit differently
+        case node_type
+          when Nokogiri::XML::Node::DTD_NODE
+            set_object_array!(hash, :elements)
+            set_object_array!(hash, :entities)
+            set_object_array!(hash, :notations)
+          when Nokogiri::XML::Node::ELEMENT_DECL
+            puts 'lol'
+          when Nokogiri::XML::Node::ENTITY_DECL
+            set_if_respond_to! hash, :original_content
+          else
+        end
+
+        set_if_respond_to! hash, :name, [Node::DOCUMENT_NODE, Node::TEXT_NODE, Node::COMMENT_NODE]
+        set_if_respond_to! hash, :external_id # For DTD, entity declarations
+        set_if_respond_to! hash, :entity_type # For Entity declarations
+        set_if_respond_to! hash, :system_id # For Entity declarations
+        set_if_respond_to! hash, :attribute_type # For attribute declarations
+        set_if_respond_to! hash, :default # For attribute declarations
+        set_if_respond_to! hash, :enumeration # For attribute declarations
+        set_if_respond_to! hash, :element_type # For element declarations
+        set_if_respond_to! hash, :prefix # For element declarations
+
+        set_content! hash, [Node::DOCUMENT_NODE, Node::ELEMENT_NODE]
+        set_attributes! hash
+        set_if_respond_to! hash, :line
+        if respond_to? :namespace and namespace
+          hash[:namespace] = namespace.to_hash
         end
+
+        # Recurse into children
+        add_children! self, hash, [Nokogiri::XML::Node::DTD_NODE, Node::ATTRIBUTE_NODE]
         hash
       end
     end

data/xml-to-hash.gemspec

@@ -1,18 +1,20 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'xml/to/hash/version'
+require 'xml/to/hash'
 
 Gem::Specification.new do |spec|
   spec.name = 'xml-to-hash'
   spec.version = Xml::To::Hash::VERSION
   spec.authors = ['Maarten Trompper']
-  spec.email = ['m.f.a.trompper@uva.nl']
+  spec.email = ['maartentrompper@gmail.com']
 
-  spec.summary = %q{Transparently convert XML documents to Ruby hashes (...and JSON, and beyond)}
-  spec.description = %q{This gem add a to_hash method to Nokogiri XML nodes into a Ruby hash. We generate a hash, 
-in which all keys are constants. 
-NOTE: This gem ignores fancy stuff like doctypes and entity declarations.}
+  spec.summary = %q{Transparently convert XML documents to Ruby hashes (and JSON, and beyond)}
+  spec.description = %q{This gem add a `to_hash` method to Nokogiri XML nodes into a Ruby hash. In the resulting hash, all keys are constants.
+
+This gem also picks up attributes, processing instructions and doctype declarations. The resulting Hash is wordy, but complete.
+
+As an added bonus, we include line numbers where possible.}
   spec.homepage = 'https://github.com/digitalheir/ruby-xml-to-hash'
   spec.license = 'MIT'
 
@@ -33,5 +35,5 @@ NOTE: This gem ignores fancy stuff like doctypes and entity declarations.}
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 2.4'
 
-  spec.add_runtime_dependency 'nokogiri', '~> 1.6.6.2', '>= 1.6.6.2'
+  spec.add_runtime_dependency 'nokogiri', '~> 1', '>= 1.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xml-to-hash
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Maarten Trompper
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-06-12 00:00:00.000000000 Z
+date: 2015-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,25 +58,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.6.6.2
+        version: '1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.6.6.2
+        version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.6.6.2
+        version: '1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.6.6.2
-description: "This gem add a to_hash method to Nokogiri XML nodes into a Ruby hash.
-  We generate a hash, \nin which all keys are constants. \nNOTE: This gem ignores
-  fancy stuff like doctypes and entity declarations."
+        version: '1.6'
+description: |-
+  This gem add a `to_hash` method to Nokogiri XML nodes into a Ruby hash. In the resulting hash, all keys are constants.
+
+  This gem also picks up attributes, processing instructions and doctype declarations. The resulting Hash is wordy, but complete.
+
+  As an added bonus, we include line numbers where possible.
 email:
-- m.f.a.trompper@uva.nl
+- maartentrompper@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -84,15 +87,14 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
-- CODE_OF_CONDUCT.md
+- CODE_OF_CONDUCT
 - Gemfile
-- LICENSE.txt
-- README.md
+- LICENSE
+- README
 - Rakefile
 - bin/console
 - bin/setup
 - lib/xml/to/hash.rb
-- lib/xml/to/hash/version.rb
 - xml-to-hash.gemspec
 homepage: https://github.com/digitalheir/ruby-xml-to-hash
 licenses:
@@ -117,5 +119,5 @@ rubyforge_project:
 rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
-summary: Transparently convert XML documents to Ruby hashes (...and JSON, and beyond)
+summary: Transparently convert XML documents to Ruby hashes (and JSON, and beyond)
 test_files: []

data/README.md

@@ -1,159 +0,0 @@
-# XML to Hash
-
-Ruby gem to convert XML into Hash (and into JSON). 
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'xml-to-hash'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install xml-to-hash
-
-## Usage
-
-```ruby
-include 'xml/to/hash'
-
-xml_string = STR_XML = <<-EOS
-             <?xml version="1.0" encoding="UTF-8" ?>
-             <!DOCTYPE author [
-               <!ELEMENT author (#PCDATA)>
-               <!ENTITY MyParamEntity "Has been expanded">
-               <!ENTITY js "Me">
-             ]>
-             <myRoot>
-                   some text
-                   <!--
-                   In comments we can use ]]>
-                   <
-                   &, ', and ", but %MyParamEntity; will not be expanded-->
-                   <![CDATA[
-                   Character Data block <!-- <, & ' " -->  *and* %MyParamEntity;  
-                   ]]>
-                   <?linebreak?>
-                   <deeper xmlns="lol://some-namespace" how-deep="very-deep">randomtext
-                   <even 
-                     lol:my-attr="just an attribute" 
-                     xmlns:lol=\'lol://my.name.space/\' deeper="true">O</even></deeper>  
-             </myRoot>
-EOS
-
-xml = Nokogiri::XML STR_XML
-hash = xml.to_hash
-
-puts JSON.pretty_generate(hash)
-```
-
-produces
-
-```json
-{
-  "type": "element",
-  "name": "myRoot",
-  "children": [
-    {
-      "type": "text",
-      "content": "\n      some text\n      "
-    },
-    {
-      "type": "comment",
-      "content": "\n      In comments we can use ]]>\n      <\n      &, ', and \", but %MyParamEntity; will not be expanded"
-    },
-    {
-      "type": "text",
-      "content": "\n      "
-    },
-    {
-      "type": "cdata",
-      "content": "\n      Character Data block <!-- <, & ' \" -->  *and* %MyParamEntity;  \n      "
-    },
-    {
-      "type": "text",
-      "content": "\n      "
-    },
-    {
-      "type": "pi",
-      "name": "linebreak"
-    },
-    {
-      "type": "text",
-      "content": "\n      "
-    },
-    {
-      "type": "element",
-      "attrs": [
-        {
-          "name": "how-deep",
-          "value": "very-deep"
-        }
-      ],
-      "name": "deeper",
-      "namespace": {
-        "href": "lol://some-namespace"
-      },
-      "children": [
-        {
-          "type": "text",
-          "content": "randomtext\n      "
-        },
-        {
-          "type": "element",
-          "attrs": [
-            {
-              "name": "my-attr",
-              "value": "just an attribute",
-              "namespace": {
-                "href": "lol://my.name.space/",
-                "prefix": "lol"
-              }
-            },
-            {
-              "name": "deeper",
-              "value": "true"
-            }
-          ],
-          "name": "even",
-          "namespace": {
-            "href": "lol://some-namespace"
-          },
-          "children": [
-            {
-              "type": "text",
-              "content": "O"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "type": "text",
-      "content": "  \n"
-    }
-  ]
-}
-```
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/digitalheir/xml-to-hash. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
-
-
-## License
-
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/lib/xml/to/hash/version.rb

@@ -1,7 +0,0 @@
-module Xml
-  module To
-    module Hash
-      VERSION = '0.9.0'
-    end
-  end
-end