nori 0.2.0

data/lib/nori/core_ext/object.rb

@@ -0,0 +1,13 @@
+module Nori
+  module CoreExt
+    module Object
+
+      def blank?
+        respond_to?(:empty?) ? empty? : !self
+      end unless method_defined?(:blank?)
+
+    end
+  end
+end
+
+Object.send :include, Nori::CoreExt::Object

data/lib/nori/core_ext/string.rb

@@ -0,0 +1,15 @@
+module Nori
+  module CoreExt
+    module String
+
+      def snake_case
+        return self.downcase if self =~ /^[A-Z]+$/
+        self.gsub(/([A-Z]+)(?=[A-Z][a-z]?)|\B[A-Z]/, '_\&') =~ /_*(.*)/
+        $+.downcase
+      end unless method_defined?(:snake_case)
+
+    end
+  end
+end
+
+String.send :include, Nori::CoreExt::String

data/lib/nori/parser.rb

@@ -0,0 +1,51 @@
+module Nori
+
+  # = Nori::Parser
+  #
+  # Manages the parser classes. Currently supports:
+  #
+  # * REXML
+  # * Nokogiri
+  module Parser
+
+    # The default parser.
+    DEFAULT = :rexml
+
+    # List of available parsers.
+    PARSERS = { :rexml => "REXML", :nokogiri => "Nokogiri" }
+
+    # Returns the parser to use. Defaults to <tt>Nori::Parser::REXML</tt>.
+    def self.use
+      @use ||= DEFAULT
+    end
+
+    # Sets the +parser+ to use. Raises an +ArgumentError+ unless the +parser+ exists.
+    def self.use=(parser)
+      validate_parser! parser
+      @use = parser
+    end
+
+    # Returns the parsed +xml+ using the parser to use. Raises an +ArgumentError+
+    # unless the optional or default +parser+ exists.
+    def self.parse(xml, parser = nil)
+      load_parser(parser).parse xml
+    end
+
+  private
+
+    # Raises an +ArgumentError+ unless the +parser+ exists.
+    def self.validate_parser!(parser)
+      raise ArgumentError, "Invalid Nori parser: #{parser}" unless PARSERS[parser]
+    end
+
+    # Requires and returns the +parser+ to use.
+    def self.load_parser(parser)
+      parser ||= use
+      validate_parser! parser
+
+      require "nori/parser/#{parser}"
+      const_get PARSERS[parser]
+    end
+
+  end
+end

data/lib/nori/parser/nokogiri.rb

@@ -0,0 +1,46 @@
+require "nokogiri"
+require "nori/xml_utility_node"
+
+module Nori
+  module Parser
+
+    # = Nori::Parser::Nokogiri
+    #
+    # Nokogiri SAX parser.
+    module Nokogiri
+
+      class Document < ::Nokogiri::XML::SAX::Document
+
+        def stack
+          @stack ||= []
+        end
+
+        def start_element(name, attrs = [])
+          stack.push Nori::XMLUtilityNode.new(name, Hash[*attrs.flatten])
+        end
+
+        def end_element(name)
+          if stack.size > 1
+            last = stack.pop
+            stack.last.add_node last
+          end
+        end
+
+        def characters(string)
+          stack.last.add_node(string) unless string.strip.length == 0 || stack.empty?
+        end
+
+        alias cdata_block characters
+
+      end
+
+      def self.parse(xml)
+        document = Document.new
+        parser = ::Nokogiri::XML::SAX::Parser.new document
+        parser.parse xml
+        document.stack.length > 0 ? document.stack.pop.to_hash : {}
+      end
+
+    end
+  end
+end

data/lib/nori/parser/rexml.rb

@@ -0,0 +1,39 @@
+require "rexml/parsers/baseparser"
+require "nori/xml_utility_node"
+
+module Nori
+  module Parser
+
+    # = Nori::Parser::REXML
+    #
+    # REXML pull parser.
+    module REXML
+
+      def self.parse(xml)
+        stack = []
+        parser = ::REXML::Parsers::BaseParser.new(xml)
+
+        while true
+          event = parser.pull
+          case event[0]
+          when :end_document
+            break
+          when :end_doctype, :start_doctype
+            # do nothing
+          when :start_element
+            stack.push Nori::XMLUtilityNode.new(event[1], event[2])
+          when :end_element
+            if stack.size > 1
+              temp = stack.pop
+              stack.last.add_node(temp)
+            end
+          when :text, :cdata
+            stack.last.add_node(event[1]) unless event[1].strip.length == 0 || stack.empty?
+          end
+        end
+        stack.length > 0 ? stack.pop.to_hash : {}
+      end
+    end
+
+  end
+end

data/lib/nori/version.rb

@@ -0,0 +1,5 @@
+module Nori
+
+  VERSION = "0.2.0"
+
+end

data/lib/nori/xml_utility_node.rb

@@ -0,0 +1,186 @@
+require "rexml/text"
+require "date"
+require "time"
+require "yaml"
+require "bigdecimal"
+
+module Nori
+
+  # This is a slighly modified version of the XMLUtilityNode from
+  # http://merb.devjavu.com/projects/merb/ticket/95 (has.sox@gmail.com)
+  #
+  # John Nunemaker:
+  # It's mainly just adding vowels, as I ht cd wth n vwls :)
+  # This represents the hard part of the work, all I did was change the
+  # underlying parser.
+  class XMLUtilityNode
+
+    def self.typecasts
+      @@typecasts
+    end
+
+    def self.typecasts=(obj)
+      @@typecasts = obj
+    end
+
+    def self.available_typecasts
+      @@available_typecasts
+    end
+
+    def self.available_typecasts=(obj)
+      @@available_typecasts = obj
+    end
+
+    self.typecasts = {}
+    self.typecasts["integer"]       = lambda { |v| v.nil? ? nil : v.to_i }
+    self.typecasts["boolean"]       = lambda { |v| v.nil? ? nil : (v.strip != "false") }
+    self.typecasts["datetime"]      = lambda { |v| v.nil? ? nil : Time.parse(v).utc }
+    self.typecasts["date"]          = lambda { |v| v.nil? ? nil : Date.parse(v) }
+    self.typecasts["dateTime"]      = lambda { |v| v.nil? ? nil : Time.parse(v).utc }
+    self.typecasts["decimal"]       = lambda { |v| v.nil? ? nil : BigDecimal(v.to_s) }
+    self.typecasts["double"]        = lambda { |v| v.nil? ? nil : v.to_f }
+    self.typecasts["float"]         = lambda { |v| v.nil? ? nil : v.to_f }
+    self.typecasts["symbol"]        = lambda { |v| v.nil? ? nil : v.to_sym }
+    self.typecasts["string"]        = lambda { |v| v.to_s }
+    self.typecasts["yaml"]          = lambda { |v| v.nil? ? nil : YAML.load(v) }
+    self.typecasts["base64Binary"]  = lambda { |v| v.unpack('m').first }
+
+    self.available_typecasts = self.typecasts.keys
+
+    def initialize(name, normalized_attributes = {})
+      # unnormalize attribute values
+      attributes = Hash[* normalized_attributes.map do |key, value|
+        [ key, unnormalize_xml_entities(value) ]
+      end.flatten]
+
+      @name         = name.tr("-", "_")
+      # leave the type alone if we don't know what it is
+      @type         = self.class.available_typecasts.include?(attributes["type"]) ? attributes.delete("type") : attributes["type"]
+
+      @nil_element  = attributes.delete("nil") == "true"
+      @attributes   = undasherize_keys(attributes)
+      @children     = []
+      @text         = false
+    end
+
+    attr_accessor :name, :attributes, :children, :type
+
+    def add_node(node)
+      @text = true if node.is_a? String
+      @children << node
+    end
+
+    def to_hash
+      if @type == "file"
+        f = StringIO.new((@children.first || '').unpack('m').first)
+        class << f
+          attr_accessor :original_filename, :content_type
+        end
+        f.original_filename = attributes['name'] || 'untitled'
+        f.content_type = attributes['content_type'] || 'application/octet-stream'
+        return {name => f}
+      end
+
+      if @text
+        t = typecast_value( unnormalize_xml_entities( inner_html ) )
+        t.class.send(:attr_accessor, :attributes)
+        t.attributes = attributes
+        return { name => t }
+      else
+        #change repeating groups into an array
+        groups = @children.inject({}) { |s,e| (s[e.name] ||= []) << e; s }
+
+        out = nil
+        if @type == "array"
+          out = []
+          groups.each do |k, v|
+            if v.size == 1
+              out << v.first.to_hash.entries.first.last
+            else
+              out << v.map{|e| e.to_hash[k]}
+            end
+          end
+          out = out.flatten
+
+        else # If Hash
+          out = {}
+          groups.each do |k,v|
+            if v.size == 1
+              out.merge!(v.first)
+            else
+              out.merge!( k => v.map{|e| e.to_hash[k]})
+            end
+          end
+          out.merge! attributes unless attributes.empty?
+          out = out.empty? ? nil : out
+        end
+
+        if @type && out.nil?
+          { name => typecast_value(out) }
+        else
+          { name => out }
+        end
+      end
+    end
+
+    # Typecasts a value based upon its type. For instance, if
+    # +node+ has #type == "integer",
+    # {{[node.typecast_value("12") #=> 12]}}
+    #
+    # @param value<String> The value that is being typecast.
+    #
+    # @details [:type options]
+    #   "integer"::
+    #     converts +value+ to an integer with #to_i
+    #   "boolean"::
+    #     checks whether +value+, after removing spaces, is the literal
+    #     "true"
+    #   "datetime"::
+    #     Parses +value+ using Time.parse, and returns a UTC Time
+    #   "date"::
+    #     Parses +value+ using Date.parse
+    #
+    # @return <Integer, TrueClass, FalseClass, Time, Date, Object>
+    #   The result of typecasting +value+.
+    #
+    # @note
+    #   If +self+ does not have a "type" key, or if it's not one of the
+    #   options specified above, the raw +value+ will be returned.
+    def typecast_value(value)
+      return value unless @type
+      proc = self.class.typecasts[@type]
+      proc.nil? ? value : proc.call(value)
+    end
+
+    # Take keys of the form foo-bar and convert them to foo_bar
+    def undasherize_keys(params)
+      params.keys.each do |key, value|
+        params[key.tr("-", "_")] = params.delete(key)
+      end
+      params
+    end
+
+    # Get the inner_html of the REXML node.
+    def inner_html
+      @children.join
+    end
+
+    # Converts the node into a readable HTML node.
+    #
+    # @return <String> The HTML node in text form.
+    def to_html
+      attributes.merge!(:type => @type ) if @type
+      "<#{name}#{attributes.to_xml_attributes}>#{@nil_element ? '' : inner_html}</#{name}>"
+    end
+
+    alias to_s to_html
+
+  private
+
+    # TODO: replace REXML
+    def unnormalize_xml_entities value
+      REXML::Text.unnormalize(value)
+    end
+  end
+
+end

data/nori.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "nori/version"
+
+Gem::Specification.new do |s|
+  s.name        = "nori"
+  s.version     = Nori::VERSION
+  s.authors     = ["Daniel Harrington", "John Nunemaker", "Wynn Netherland"]
+  s.email       = "me@rubiii.com"
+  s.homepage    = "http://github.com/rubiii/nori"
+  s.summary     = "XML to Hash translator"
+  s.description = s.summary
+
+  s.rubyforge_project = "nori"
+
+  s.add_development_dependency "nokogiri", ">= 1.4.0"
+  s.add_development_dependency "rspec",    "~> 2.4.0"
+  s.add_development_dependency "autotest"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/nori/core_ext/hash_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+describe Hash do
+
+  describe "#to_params" do
+
+    {
+      { "foo" => "bar", "baz" => "bat" } => "foo=bar&baz=bat",
+      { "foo" => [ "bar", "baz" ] } => "foo[]=bar&foo[]=baz",
+      { "foo" => [ {"bar" => "1"}, {"bar" => 2} ] } => "foo[][bar]=1&foo[][bar]=2",
+      { "foo" => { "bar" => [ {"baz" => 1}, {"baz" => "2"}  ] } } => "foo[bar][][baz]=1&foo[bar][][baz]=2",
+      { "foo" => {"1" => "bar", "2" => "baz"} } => "foo[1]=bar&foo[2]=baz"
+    }.each do |hash, params|
+      it "should covert hash: #{hash.inspect} to params: #{params.inspect}" do
+        hash.to_params.split('&').sort.should == params.split('&').sort
+      end
+    end
+
+    it "should not leave a trailing &" do
+      {
+        :name => 'Bob',
+        :address => {
+          :street => '111 Ruby Ave.',
+          :city => 'Ruby Central',
+          :phones => ['111-111-1111', '222-222-2222']
+        }
+      }.to_params.should_not =~ /&$/
+    end
+
+    it "should URL encode unsafe characters" do
+      {:q => "?&\" +"}.to_params.should == "q=%3F%26%22%20%2B"
+    end
+  end
+
+  describe "#normalize_param" do
+    it "should have specs"
+  end
+
+  describe "#to_xml_attributes" do
+
+    it "should turn the hash into xml attributes" do
+      attrs = { :one => "ONE", "two" => "TWO" }.to_xml_attributes
+      attrs.should =~ /one="ONE"/m
+      attrs.should =~ /two="TWO"/m
+    end
+
+    it "should preserve _ in hash keys" do
+      attrs = {
+        :some_long_attribute => "with short value",
+        :crash               => :burn,
+        :merb                => "uses extlib"
+      }.to_xml_attributes
+
+      attrs.should =~ /some_long_attribute="with short value"/
+      attrs.should =~ /merb="uses extlib"/
+      attrs.should =~ /crash="burn"/
+    end
+  end
+
+end