chemicals 0.1.2

data/.gitignore

@@ -0,0 +1,17 @@
+*.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/CHANGELOG.md

@@ -0,0 +1,11 @@
+## 0.1.2
+
+* Template option `:symbolize_keys` that allows hash keys to string or symbols. Default to `true`.
+
+## 0.1.1
+
+* Performance improvement: Don't parse the source again if it is already a Nokogiri document (Parser).
+
+## 0.1.0
+
+* Entirely removed Hashie dependency. All keys are now symbolized in the Parser (bonus: smaller memory footprint).

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in commute.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'minitest' do
+  watch(%r|^spec/(.*)_spec\.rb|)
+  watch(%r|^lib/(.*)([^/]+)\.rb|)     { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r|^spec/spec_helper\.rb|)    { "spec" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Mattias Putman
+
+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,36 @@
+# Chemicals
+
+## TODO
+
+* Add simple object conversion (ex. String to Fixnum)
+* Add shorthand for parsing under same name of element/attribute:
+  `<person ch:as='#' />`
+* Add support for constant (are not parsed/rendered).
+* `as` with depth. ex: `ch:as='name/first_name'`
+* More granular matching of nodes. ex Matching a simgle node within a collection
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'chemicals'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install chemicals
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new :test do |t|
+  t.test_files = FileList['spec/*/**_spec.rb']
+end
+
+task :default => :test

data/chemicals.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/chemicals/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.authors       = ["Mattias Putman"]
+  s.email         = ["mattias.putman@gmail.com"]
+  s.description   = %q{Clever XML Parsing library}
+  s.summary       = %q{Clever XML Parsing library}
+  s.homepage      = ""
+
+  s.files         = `git ls-files`.split($\)
+  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.name          = "chemicals"
+  s.require_paths = ["lib"]
+  s.version       = Chemicals::VERSION
+
+  s.add_dependency 'nokogiri'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'guard'
+  s.add_development_dependency 'guard-minitest'
+end

data/lib/chemicals.rb

@@ -0,0 +1,5 @@
+require 'nokogiri'
+
+require 'chemicals/template'
+require 'chemicals/parser'
+require 'chemicals/renderer'

data/lib/chemicals/parser.rb

@@ -0,0 +1,97 @@
+module Chemicals
+  class Parser
+    def initialize template
+      @template = template
+    end
+
+    def parse source
+      @namespaces = {}
+      # get the document in nokogiri without blanks
+      # or if the source is already a nokogiri node, then assume it is without blanks.
+      root = if source.kind_of? Nokogiri::XML::Node
+        source.document.root
+      else
+        Nokogiri::XML(source.to_s) { |c| c.noblanks }.root
+      end
+      # delete all default namespaces and map the new ones in @namespaces
+      handle_namespace root
+      # map to a general namespace prefix => href hash
+      @namespaces = Hash[(@namespaces.values + root.namespace_definitions).map { |ns|
+        [ns.prefix, ns.href] if ns.prefix
+      }]
+      # begin parsing with the root node
+      parse_node root, @template.for(root.path, @namespaces)
+    end
+
+    private
+
+    def parse_node source, config
+      return nil unless config
+      # parse all child nodes and attribute nodes
+      parsed = (source.children.to_a + source.attribute_nodes).map do |node|
+        # parse node with the correspondent config (using node xpath)
+        parse_node(node, @template.for(node.path, @namespaces)) || {}
+      end
+      # reject nil values
+      parsed.reject! { |key, value| !value } if parsed.kind_of? Hash
+      # in arrays reject empty hashes
+      parsed.reject! { |value| value.empty? } if parsed.kind_of? Array
+      # we have a few cases here
+      parsed = case source
+        when Nokogiri::XML::Text
+          source.content
+        when Nokogiri::XML::Attr
+          source.content
+        when Nokogiri::XML::Element
+          # an array of arrays is flattened
+          if parsed.kind_of?(Array) && parsed.all? { |part| part.kind_of? Array }
+            parsed.flatten
+          # everything else is merged
+          else
+            parsed.inject { |result, part|
+              # internal arrays are added
+              result.merge!(part) { |key, old_value, new_value|
+                # This way mixed collections come together.
+                old_value + new_value
+              }
+            }
+          end
+        end
+      # If nothing got parsed but we expect a hash then make it a hash!
+      if parsed.empty? && config[:mode] == :merge
+        parsed = {}
+      end
+      # wrap in array if collecting
+      parsed = [parsed] if config[:mode] == :collect
+      # wrap in alias
+      parsed = {config[:as] => parsed} if config.has_key?(:as) && !config[:as].nil?
+      # return parsed version and reject all nil values!
+      parsed
+    end
+
+    def handle_namespace node
+      if node.namespace
+        # a namespace without a prefix is a default namespace
+        if !node.namespace.prefix
+          # not mapped this namespace?
+          unless @namespaces.has_key? node.namespace.href
+            # define the new namespace
+            node.document.root.add_namespace_definition "ns#{@namespaces.size}",
+              node.namespace.href
+            # add a mapping
+            @namespaces[node.namespace.href] = node.document.root.namespace_definitions.find { |ns|
+              ns.prefix && ns.href == node.namespace.href
+            }
+          end
+          # change the namespace
+          node.namespace = @namespaces[node.namespace.href]
+        # namespace with prefix
+        else
+          @namespaces[node.namespace.href] ||= node.namespace
+        end
+      end
+      # do the same for all child elements and attributes
+      (node.children.to_a + node.attribute_nodes).each { |child| handle_namespace child }
+    end
+  end
+end

data/lib/chemicals/renderer.rb

@@ -0,0 +1,72 @@
+module Chemicals
+  class Renderer
+
+    def initialize template
+      @template = template
+    end
+
+    def render source
+      # begin with a new document
+      document = Nokogiri::XML::Document.new
+      # add a temp node as a namespace referebce
+      document.root = Nokogiri::XML::Element.new 'temp', document
+      @template.add_namespaces document.root
+      # now render the entire document as the new root
+      document.root = render_node document, source, @template.raw.root
+      # again add all required namespaces to the real root
+      @template.add_namespaces document.root
+      # return the root
+      document.root
+    end
+
+    def render_node document, source, template, collect = true
+      # the template is already the template to apply this source on
+      # do nothing if there's no source
+      return nil unless source && config = @template.for(template.path)
+      # don't render the chemicals namespace
+      return nil if template.namespace && template.namespace.href == 'http://piesync.com/xml/chemicals'
+      # unwrap if necessary
+      source = source[config[:as].to_sym] if config.has_key?(:as) && !config[:as].nil? && collect
+      # is this a collect node? Rendering a collect node is the same as rendering the
+      # template for each part of the source (and render them as a non-collect node)
+      # The result are the rendered nodes.
+      if collect && config[:mode] == :collect
+        return source.map { |part| render_node document, part, template, false } if source
+      end
+      # render all children
+      rendered = (template.children.to_a + template.attribute_nodes).map do |child|
+        render_node document, source, child, true if source
+      end.flatten
+      # reject all nil values
+      rendered.reject! { |value| !value }
+      # we again have a few cases how to render
+      case template
+      when Nokogiri::XML::Attr
+        return unless source
+        node = Nokogiri::XML::Attr.new document, template.name
+        node.content = source
+      when Nokogiri::XML::Text
+        node = Nokogiri::XML::Text.new source, document if source
+      when Nokogiri::XML::Element
+        # don't render an element if it has no data in its children
+        return unless !rendered.empty?
+        node = Nokogiri::XML::Element.new template.name, document
+        rendered.each do |child|
+          # manually add attributes cause otherwise resulting in a segfault
+          if child.kind_of? Nokogiri::XML::Attr
+            node.set_attribute child.name, child.value
+            node.attribute(child.name).namespace = child.namespace
+          # add the non-attibutes
+          else
+            node.add_child child
+          end
+        end
+      end
+      # Add the correct namespaces!
+      node.namespace = document.root.namespace_definitions.find { |ns|
+        ns.href == template.namespace.href
+      } if node && !template.namespace.nil?
+      node
+    end
+  end
+end

data/lib/chemicals/template.rb

@@ -0,0 +1,94 @@
+module Chemicals
+  class Template
+
+    NS = 'http://piesync.com/xml/chemicals'
+
+    def initialize(template, options = {})
+      @template = Nokogiri::XML(template) { |c| c.noblanks }
+      @options = {
+        symbolize_keys: true
+      }.merge!(options)
+      @cache = {}
+    end
+
+    # returns the raw template
+    def raw
+      @template
+    end
+
+    # get the configuration for an xpath expression
+    def for path, namespaces = nil
+      @cache[path] ||= if namespaces
+        for_node @template.at(canonicalize(path), namespaces)
+      else
+        for_node @template.at(canonicalize(path))
+      end
+    end
+
+    # get the configuration for a config node
+    def for_node config_node
+      # nil if no config node
+      return nil unless config_node
+      return nil if @template.at(canonicalize(config_node.path)).nil?
+      # configuation is different in every case
+      config = case config_node
+        when Nokogiri::XML::Text
+          config_node.content == '@' ? {} : {
+            as: @options[:symbolize_keys] ? config_node.content.to_sym : config_node.content
+          }
+        when Nokogiri::XML::Attr
+          {
+            as: @options[:symbolize_keys] ? config_node.value.to_sym : config_node.value
+          }
+        when Nokogiri::XML::Element
+          as = attribute(config_node, :as)
+          {
+            as: as ? (@options[:symbolize_keys] ? as.to_sym : as) : nil,
+            mode: mode(config_node, as)
+          }
+      end
+    end
+
+    def mode config_node, as
+      mode = attribute(config_node, :mode)
+      if mode
+        mode.to_sym
+      elsif as # only merge if we parse this node.
+        :merge
+      else
+        nil
+      end
+    end
+
+    # add the required namespaces to a node
+    def add_namespaces node
+      raw.root.namespace_definitions.each do |ns|
+        node.add_namespace_definition ns.prefix, ns.href if ns.href != NS
+      end
+    end
+
+    # parse a document
+    def parse source
+      @parser ||= Parser.new self
+      @parser.parse source
+    end
+
+    # render a hash
+    def render source
+      @renderer ||= Renderer.new self
+      @renderer.render source
+    end
+
+    private
+
+    def attribute node, name
+      node.attribute_with_ns(name.to_s, NS).value if node.namespaced_key?(name.to_s, NS)
+    end
+
+    # canonicalize an xpath expression
+    def canonicalize xpath
+      # this means removing indexes
+      xpath.gsub(/\[[^\]]*\]/, '')
+    end
+  end
+end

data/lib/chemicals/version.rb

@@ -0,0 +1,3 @@
+module Chemicals
+  VERSION = "0.1.2"
+end

data/spec/chemicals/chemicals_spec.rb

@@ -0,0 +1,201 @@
+# encoding: utf-8
+
+require 'minitest/spec'
+require 'minitest/autorun'
+
+require 'chemicals'
+
+
+
+
+
+describe Chemicals::Renderer do
+  describe 'rendering a text node' do
+    it 'should render the element value directly in the text node when the text node is aliased as @' do
+      template, raw = ChemicalsSpecHelper.test_example :simple_text
+      template.render('John Doe').to_xml.must_equal ChemicalsSpecHelper.format(raw)
+    end
+
+    it 'should render the content unwrapped from its alias' do
+      template, raw = ChemicalsSpecHelper.test_example :simple_text_alias
+      template.render(name: 'John Doe').to_xml.must_equal ChemicalsSpecHelper.format(raw)
+    end
+  end
+
+  describe 'rendering an attribute' do
+    it 'should render attributes with aliases' do
+      template, raw = ChemicalsSpecHelper.test_example :simple_attributes
+      template.render(full_name: 'John Doe').to_xml.must_equal ChemicalsSpecHelper.format(raw)
+    end
+  end
+
+  describe 'rendering an element' do
+    it 'should unwrap contents in aliased elements' do
+      template, raw = ChemicalsSpecHelper.test_example :simple_element_alias
+      template.render(individual: 'John Doe').to_xml.must_equal ChemicalsSpecHelper.format(raw)
+    end
+
+    it 'should skip an element when no alias is provided' do
+      template, raw = ChemicalsSpecHelper.test_example :skip_element
+      template.render(individual: 'John Doe').to_xml.must_equal ChemicalsSpecHelper.format(raw)
+    end
+  end
+
+  describe 'rendering a collection of elements' do
+    it 'should render each element' do
+      template, raw = ChemicalsSpecHelper.test_example :simple_collection
+      template.render(emails: [
+        'john.doe@gmail.com',
+        'john@acme.com'
+      ]).to_xml.must_equal ChemicalsSpecHelper.format(raw)
+    end
+
+    it 'should render multiple collections independently' do
+      template, raw = ChemicalsSpecHelper.test_example :multiple_collections
+      template.render(
+        contact: {
+          emails: [
+            'john.doe@gmail.com',
+            'john@acme.com'
+          ],
+          phone_numbers: ['1', '2']
+        }).to_xml.must_equal ChemicalsSpecHelper.format(raw)
+    end
+
+    it 'should be able to render collections in the presence of other elements' do
+      template, raw = ChemicalsSpecHelper.test_example :mixed_collection
+      template.render( \
+        contact: {
+          emails: [
+            'john.doe@gmail.com',
+            'john@acme.com'
+          ],
+          name: 'John Doe'
+        }).to_xml.must_equal ChemicalsSpecHelper.format(raw)
+    end
+
+    it 'should be able to render multiple collections in the presence of other elements' do
+      template, raw = ChemicalsSpecHelper.test_example :mixed_collections
+      template.render(
+        contact: {
+          emails: [
+            { address: 'john.doe@gmail.com', label: 'work' },
+            { address: 'john@acme.com' }
+          ],
+          phones: ['1'],
+          name: 'John Doe'
+        }).to_xml.must_equal ChemicalsSpecHelper.format(raw)
+    end
+
+    it 'should be able to extreme parse multiple collections in the presence of other elements' do
+      template, raw = ChemicalsSpecHelper.test_example :mixed_collections_extreme
+      template.render(
+        [{
+          emails: [
+            { address: 'john.doe@gmail.com', label: 'work' },
+            { address:'john@acme.com' }
+          ],
+          phones: ['1'],
+          name: 'John Doe'
+        },
+        {
+          phones: ['1', '2', '3'],
+          addresses: [{ country: 'Belgium', country_code: 'BE',
+            street: 'Désiré Van Monckhovenstraat', housenumber: '123' }]
+        }]).to_xml.must_equal ChemicalsSpecHelper.format(raw)
+    end
+  end
+
+  it 'should render mixed elements, collections and text nodes' do
+    template, raw, raw_render = ChemicalsSpecHelper.test_example :mixed_elements_text
+    template.render(
+        [{
+          name: { given: 'John', family: 'Doe' },
+          emails: ['john.doe@gmail.com', 'john@acme.com'],
+          phones: [
+            { country: 'Belgium', number: '1' },
+            { country: 'USA', number: '2' }
+          ]
+        },
+        {
+          name: { given: 'Jane' },
+          emails: [ 'jane.doe@gmail.com' ]
+        }
+      ]).to_xml.must_equal ChemicalsSpecHelper.format(raw_render)
+  end
+
+  it 'should render mixed elements, collections, text nodes, attributes and ignore useless nodes' do
+      template, raw, raw_render = ChemicalsSpecHelper.test_example :mixed_elements_text_attributes
+      template.render([
+        {
+          name: { given: 'John', family: 'Doe' },
+          emails: [
+            { label: 'home', address: 'john.doe@gmail.com' },
+            { address: 'john@acme.com' }
+          ],
+          phones: [
+            { country: 'Belgium', number: '1', system: 'sap' },
+            { country: 'USA', number: '2' }
+          ]
+        },
+        {
+          name: { given: 'Jane' },
+          emails: [{ label: 'work', address: 'jane.doe@gmail.com' }]
+        }
+      ]).to_xml.must_equal ChemicalsSpecHelper.format(raw_render)
+  end
+
+  describe 'rendering attributes' do
+    it 'should render attributes with aliases' do
+      template, raw = ChemicalsSpecHelper.test_example :simple_attributes
+      template.render(full_name: 'John Doe').to_xml.must_equal ChemicalsSpecHelper.format(raw)
+
+    end
+
+    it 'should not render attributes not mentioned in the template' do
+      template, raw = ChemicalsSpecHelper.test_example :ignore_attribute
+      template.render({}).must_equal nil
+    end
+
+    it 'should mix attributes and aliased text nodes' do
+      template, raw = ChemicalsSpecHelper.test_example :text_attributes
+      template.render(age: '24', name: 'John Doe').to_xml.must_equal ChemicalsSpecHelper.format(raw)
+
+    end
+  end
+
+  it 'should be able to render chinese characters' do
+    template, raw = ChemicalsSpecHelper.test_example :chinese
+    template.render('你好世界').to_xml.must_equal ChemicalsSpecHelper.format(raw)
+  end
+
+  it 'should be able to render namespaces' do
+    template, raw = ChemicalsSpecHelper.test_example :namespaces
+    template.render(
+      name: { age: '24', first_name: 'John', last_name: 'Doe' }).to_xml.must_equal ChemicalsSpecHelper.format(raw)
+
+  end
+
+  it 'should be reasonably fast' do
+    template, raw = ChemicalsSpecHelper.test_example :mixed_elements_text
+    1000.times do
+      template.render(
+          [{
+            name: { given: 'John', family: 'Doe' },
+            emails: ['john.doe@gmail.com', 'john@acme.com'],
+            phones: [
+              { country: 'Belgium', number: '1' },
+              { country: 'USA', number: '2' }
+            ]
+          },
+          {
+            name: { given: 'Jane' },
+            emails: [ 'jane.doe@gmail.com' ]
+          }
+        ])
+    end
+  end
+end
+
+__END__
+