nori 0.2.4 → 1.0.0

data/CHANGELOG.md

@@ -1,12 +1,33 @@
-== 0.2.4 (2011-06-21)
+== 1.0.0 (2011-06-20)
 
-* Fix: Make sure to always load both StringWithAttributes and StringIOFile
-  to prevent NameError's.
+* Notice: As of v1.0.0, Nori will follow [Semantic Versioning](http://semver.org).
 
-== 0.2.3 (2011-05-26)
+* Feature: Added somewhat advanced typecasting:
 
-* Fix: Use extended core classes StringWithAttributes and StringIOFile instead of
-  creating singletons to prevent serialization problems.
+  What this means:
+
+  * "true" and "false" are converted to TrueClass and FalseClass
+  * Strings matching an xs:time, xs:date and xs:dateTime are converted
+    to Time, Date and DateTime objects.
+
+  You can disable this feature via:
+
+      Nori.advanced_typecasting = false
+
+* Feature: Added an option to strip the namespaces from every tag.
+  This feature might raise problems and is therefore disabled by default.
+
+      Nori.strip_namespaces = true
+
+* Feature: Added an option to specify a custom formula to convert tags.
+  Here's an example:
+
+      Nori.configure do |config|
+        config.convert_tags_to { |tag| tag.snake_case.to_sym }
+      end
+
+      xml = '<userResponse><accountStatus>active</accountStatus></userResponse>'
+      parse(xml).should == { :user_response => { :account_status => "active" }
 
 == 0.2.2 (2011-05-16)
 

data/README.md

@@ -19,3 +19,46 @@ Nori.parser = :nokogiri
 
 Make sure Nokogiri is in your LOAD_PATH when parsing XML, because Nori tries to load it  
 when it's needed.
+
+
+Typecasting
+-----------
+
+Besides regular typecasting, Nori features somewhat "advanced" typecasting:
+
+* "true" and "false" String values are converted to `TrueClass` and `FalseClass`.
+* String values matching xs:time, xs:date and xs:dateTime are converted
+  to `Time`, `Date` and `DateTime` objects.
+
+You can disable this feature via:
+
+``` ruby
+Nori.advanced_typecasting = false
+```
+
+
+Namespaces
+----------
+
+Nori can strip the namespaces from your XML tags. This feature might raise  
+problems and is therefore disabled by default. Enable it via:
+
+``` ruby
+Nori.strip_namespaces = true
+```
+
+
+XML tags -> Hash keys
+---------------------
+
+Nori lets you specify a custom formula to convert XML tags to Hash keys.  
+Let me give you an example:
+
+``` ruby
+Nori.configure do |config|
+  config.convert_tags_to { |tag| tag.snake_case.to_sym }
+end
+
+xml = '<userResponse><accountStatus>active</accountStatus></userResponse>'
+Nori.parse(xml)  # => { :user_response => { :account_status => "active" }
+```

data/lib/nori.rb

@@ -1,19 +1,58 @@
 require "nori/version"
 require "nori/core_ext"
 require "nori/parser"
-require "nori/xml_utility_node"
 
 module Nori
+  extend self
 
   # Translates the given +xml+ to a Hash. Accepts an optional +parser+ to use.
-  def self.parse(xml, parser = nil)
+  def parse(xml, parser = nil)
     return {} if xml.blank?
     Parser.parse xml, parser
   end
 
   # Sets the +parser+ to use.
-  def self.parser=(parser)
+  def parser=(parser)
     Parser.use = parser
   end
 
+  # Yields +self+ for configuration.
+  def configure
+    yield self
+  end
+
+  # Sets whether to use advanced typecasting.
+  attr_writer :advanced_typecasting
+
+  # Returns whether to use advanced typecasting.
+  # Defaults to +true+.
+  def advanced_typecasting?
+    @advanced_typecasting != false
+  end
+
+  # Sets whether to strip namespaces.
+  attr_writer :strip_namespaces
+
+  # Returns whether to strip namespaces.
+  # Defaults to +false+.
+  def strip_namespaces?
+    @strip_namespaces
+  end
+
+  # Expects a +block+ which receives a tag to convert.
+  # Accepts +nil+ for a reset to the default behavior of not converting tags.
+  def convert_tags_to(reset = nil, &block)
+    @convert_tag = reset || block
+  end
+
+  # Transforms a given +tag+ using the specified conversion formula.
+  def convert_tag(tag)
+    @convert_tag.call(tag)
+  end
+
+  # Returns whether to convert tags.
+  def convert_tags?
+    @convert_tag
+  end
+
 end

data/lib/nori/core_ext/hash.rb

@@ -59,7 +59,7 @@ module Nori
       #     #=> 'one="1" two="TWO"'
       def to_xml_attributes
         map do |k, v|
-          %{#{k.to_s.snake_case.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"}
+          %{#{k.to_s.snakecase.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"}
         end.join(' ')
       end
 

data/lib/nori/core_ext/string.rb

@@ -2,11 +2,17 @@ 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)
+      # Returns the String in snake_case.
+      def snakecase
+        str = dup
+        str.gsub! /::/, '/'
+        str.gsub! /([A-Z]+)([A-Z][a-z])/, '\1_\2'
+        str.gsub! /([a-z\d])([A-Z])/, '\1_\2'
+        str.tr! ".", "_"
+        str.tr! "-", "_"
+        str.downcase!
+        str
+      end unless method_defined?(:snakecase)
 
     end
   end

data/lib/nori/parser/nokogiri.rb

@@ -1,4 +1,5 @@
 require "nokogiri"
+require "nori/xml_utility_node"
 
 module Nori
   module Parser

data/lib/nori/parser/rexml.rb

@@ -1,4 +1,5 @@
 require "rexml/parsers/baseparser"
+require "nori/xml_utility_node"
 
 module Nori
   module Parser

data/lib/nori/version.rb

@@ -1,5 +1,5 @@
 module Nori
 
-  VERSION = "0.2.4"
+  VERSION = "1.0.0"
 
 end

data/lib/nori/xml_utility_node.rb

@@ -18,6 +18,15 @@ module Nori
   # underlying parser.
   class XMLUtilityNode
 
+    # Simple xs:time Regexp.
+    XS_TIME = /\d{2}:\d{2}:\d{2}/
+
+    # Simple xs:date Regexp.
+    XS_DATE = /\d{4}-\d{2}-\d{2}/
+
+    # Simple xs:dateTime Regexp.
+    XS_DATE_TIME = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/
+
     def self.typecasts
       @@typecasts
     end
@@ -56,20 +65,23 @@ module Nori
         [ key, unnormalize_xml_entities(value) ]
       end.flatten]
 
-      @name         = name.tr("-", "_")
+      @name = name.tr("-", "_")
+      @name = @name.split(":").last if Nori.strip_namespaces?
+      @name = Nori.convert_tag(@name) if Nori.convert_tags?
+
       # 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"]
+      @type = self.class.available_typecasts.include?(attributes["type"]) ? attributes.delete("type") : attributes["type"]
 
-      @nil_element  = false
+      @nil_element = false
       attributes.keys.each do |key|
         if result = /^((.*):)?nil$/.match(key)
           @nil_element = attributes.delete(key) == "true"
           attributes.delete("xmlns:#{result[2]}") if result[1]
         end
       end
-      @attributes   = undasherize_keys(attributes)
-      @children     = []
-      @text         = false
+      @attributes = undasherize_keys(attributes)
+      @children = []
+      @text = false
     end
 
     attr_accessor :name, :attributes, :children, :type
@@ -96,10 +108,13 @@ module Nori
 
       if @text
         t = typecast_value unnormalize_xml_entities(inner_html)
+        t = advanced_typecasting(t) if t.is_a?(String) && Nori.advanced_typecasting?
+
         if t.is_a?(String)
           t = StringWithAttributes.new(t)
           t.attributes = attributes
         end
+
         return { name => t }
       else
         #change repeating groups into an array
@@ -167,6 +182,20 @@ module Nori
       proc.nil? ? value : proc.call(value)
     end
 
+    def advanced_typecasting(value)
+      split = value.split
+      return value if split.size > 1
+
+      case split.first
+        when "true"       then true
+        when "false"      then false
+        when XS_DATE_TIME then DateTime.parse(value)
+        when XS_DATE      then Date.parse(value)
+        when XS_TIME      then Time.parse(value)
+        else                   value
+      end
+    end
+
     # Take keys of the form foo-bar and convert them to foo_bar
     def undasherize_keys(params)
       params.keys.each do |key, value|

data/spec/nori/core_ext/string_spec.rb

@@ -2,31 +2,31 @@ require "spec_helper"
 
 describe String do
 
-  describe "#snake_case" do
+  describe "#snakecase" do
     it "lowercases one word CamelCase" do
-      "Merb".snake_case.should == "merb"
+      "Merb".snakecase.should == "merb"
     end
 
-    it "makes one underscore snake_case two word CamelCase" do
-      "MerbCore".snake_case.should == "merb_core"
+    it "makes one underscore snakecase two word CamelCase" do
+      "MerbCore".snakecase.should == "merb_core"
     end
 
     it "handles CamelCase with more than 2 words" do
-      "SoYouWantContributeToMerbCore".snake_case.should == "so_you_want_contribute_to_merb_core"
+      "SoYouWantContributeToMerbCore".snakecase.should == "so_you_want_contribute_to_merb_core"
     end
 
     it "handles CamelCase with more than 2 capital letter in a row" do
-      "CNN".snake_case.should == "cnn"
-      "CNNNews".snake_case.should == "cnn_news"
-      "HeadlineCNNNews".snake_case.should == "headline_cnn_news"
+      "CNN".snakecase.should == "cnn"
+      "CNNNews".snakecase.should == "cnn_news"
+      "HeadlineCNNNews".snakecase.should == "headline_cnn_news"
     end
 
     it "does NOT change one word lowercase" do
-      "merb".snake_case.should == "merb"
+      "merb".snakecase.should == "merb"
     end
 
     it "leaves snake_case as is" do
-      "merb_core".snake_case.should == "merb_core"
+      "merb_core".snakecase.should == "merb_core"
     end
   end
 

data/spec/nori/nori_spec.rb

@@ -78,12 +78,82 @@ describe Nori do
       it "should prefix attributes with an @-sign to avoid problems with overwritten values" do
         xml =<<-XML
           <multiRef id="id1">
-            <approved>true</approved>
+            <login>grep</login>
             <id>76737</id>
           </multiRef>
         XML
 
-        parse(xml)["multiRef"].should == { "approved" => "true", "@id" => "id1", "id" => "76737" }
+        parse(xml)["multiRef"].should == { "login" => "grep", "@id" => "id1", "id" => "76737" }
+      end
+
+      context "without advanced typecasting" do
+        around do |example|
+          Nori.advanced_typecasting = false
+          example.run
+          Nori.advanced_typecasting = true
+        end
+
+        it "should not transform 'true'" do
+          parse("<value>true</value>")["value"].should == "true"
+        end
+
+        it "should not transform 'false'" do
+          parse("<value>false</value>")["value"].should == "false"
+        end
+
+        it "should not transform Strings matching the xs:time format" do
+          parse("<value>09:33:55Z</value>")["value"].should == "09:33:55Z"
+        end
+
+        it "should not transform Strings matching the xs:date format" do
+          parse("<value>1955-04-18-05:00</value>")["value"].should == "1955-04-18-05:00"
+        end
+
+        it "should not transform Strings matching the xs:dateTime format" do
+          parse("<value>1955-04-18T11:22:33-05:00</value>")["value"].should == "1955-04-18T11:22:33-05:00"
+        end
+      end
+
+      context "with advanced typecasting" do
+        around do |example|
+          Nori.advanced_typecasting = true
+          example.run
+          Nori.advanced_typecasting = false
+        end
+
+        it "should transform 'true' to TrueClass" do
+          parse("<value>true</value>")["value"].should == true
+        end
+
+        it "should transform 'false' to FalseClass" do
+          parse("<value>false</value>")["value"].should == false
+        end
+
+        it "should transform Strings matching the xs:time format to Time objects" do
+          parse("<value>09:33:55Z</value>")["value"].should == Time.parse("09:33:55Z")
+        end
+
+        it "should transform Strings matching the xs:date format to Date objects" do
+          parse("<value>1955-04-18-05:00</value>")["value"].should == Date.parse("1955-04-18-05:00")
+        end
+
+        it "should transform Strings matching the xs:dateTime format to DateTime objects" do
+          parse("<value>1955-04-18T11:22:33-05:00</value>")["value"].should ==
+            DateTime.parse("1955-04-18T11:22:33-05:00")
+        end
+
+        it "should not transform Strings containing an xs:time String and more" do
+          parse("<value>09:33:55Z is a time</value>")["value"].should == "09:33:55Z is a time"
+        end
+
+        it "should not transform Strings containing an xs:date String and more" do
+          parse("<value>1955-04-18-05:00 is a date</value>")["value"].should == "1955-04-18-05:00 is a date"
+        end
+
+        it "should not transform Strings containing an xs:dateTime String and more" do
+          parse("<value>1955-04-18T11:22:33-05:00 is a dateTime</value>")["value"].should ==
+            "1955-04-18T11:22:33-05:00 is a dateTime"
+        end
       end
 
       context "Parsing xml with text and attributes" do
@@ -191,6 +261,46 @@ describe Nori do
         parse(xml)['tag_1'].keys.should include('@attr_1')
       end
 
+      context "with strip_namespaces set to true" do
+        around do |example|
+          Nori.strip_namespaces = true
+          example.run
+          Nori.strip_namespaces = false
+        end
+
+        it "should strip the namespace from every tag" do
+          xml = '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"></soap:Envelope>'
+          parse(xml).should have_key("Envelope")
+        end
+
+        it "converts namespaced entries to array elements" do
+          xml = <<-XML
+            <history
+                xmlns:ns10="http://ns10.example.com"
+                xmlns:ns11="http://ns10.example.com">
+              <ns10:case><ns10:name>a_name</ns10:name></ns10:case>
+              <ns11:case><ns11:name>another_name</ns11:name></ns11:case>
+            </history>
+          XML
+
+          expected_case = [{ "name" => "a_name" }, { "name" => "another_name" }]
+          parse(xml)["history"]["case"].should == expected_case
+        end
+      end
+
+      context "with convert_tags_to set to a custom formula" do
+        around do |example|
+          Nori.convert_tags_to { |tag| tag.snakecase.to_sym }
+          example.run
+          Nori.convert_tags_to(nil)
+        end
+
+        it "transforms the tags to snakecase Symbols" do
+          xml = '<userResponse><accountStatus>active</accountStatus></userResponse>'
+          parse(xml).should == { :user_response => { :account_status => "active" } }
+        end
+      end
+
       it "should render nested content correctly" do
         xml = "<root><tag1>Tag1 Content <em><strong>This is strong</strong></em></tag1></root>"
         parse(xml)['root']['tag1'].should == "Tag1 Content <em><strong>This is strong</strong></em>"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: nori
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 23
   prerelease: 
   segments: 
+  - 1
   - 0
-  - 2
-  - 4
-  version: 0.2.4
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Daniel Harrington
@@ -17,8 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-21 00:00:00 +02:00
-default_executable: 
+date: 2011-06-20 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: nokogiri
@@ -104,7 +103,6 @@ files:
 - spec/nori/nori_spec.rb
 - spec/nori/parser_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: http://github.com/rubiii/nori
 licenses: []
 
@@ -134,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: nori
-rubygems_version: 1.4.1
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: XML to Hash translator