nori-ng-1.6 2.3.0

data/lib/nori/core_ext/hash.rb

@@ -0,0 +1,75 @@
+require "uri"
+
+class Nori
+  module CoreExt
+    module Hash
+
+      # @return <String> This hash as a query string
+      #
+      # @example
+      #   { :name => "Bob",
+      #     :address => {
+      #       :street => '111 Ruby Ave.',
+      #       :city => 'Ruby Central',
+      #       :phones => ['111-111-1111', '222-222-2222']
+      #     }
+      #   }.to_params
+      #     #=> "name=Bob&address[city]=Ruby Central&address[phones][]=111-111-1111&address[phones][]=222-222-2222&address[street]=111 Ruby Ave."
+      def to_params
+        map { |k, v| normalize_param(k,v) }.flatten.join('&')
+      end
+
+      # @param key<Object> The key for the param.
+      # @param value<Object> The value for the param.
+      #
+      # @return <String> This key value pair as a param
+      #
+      # @example normalize_param(:name, "Bob Jones") #=> "name=Bob%20Jones"
+      def normalize_param(key, value)
+        if value.is_a?(Array)
+          normalize_array_params(key, value)
+        elsif value.is_a?(Hash)
+          normalize_hash_params(key, value)
+        else
+          normalize_simple_type_params(key, value)
+        end
+      end
+
+      # @return <String> The hash as attributes for an XML tag.
+      #
+      # @example
+      #   { :one => 1, "two"=>"TWO" }.to_xml_attributes
+      #     #=> 'one="1" two="TWO"'
+      def to_xml_attributes
+        map do |k, v|
+          %{#{k.to_s.snakecase.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"}
+        end.join(' ')
+      end
+
+      private
+
+      def normalize_simple_type_params(key, value)
+        ["#{key}=#{encode_simple_value(value)}"]
+      end
+
+      def normalize_array_params(key, array)
+        array.map do |element|
+          normalize_param("#{key}[]", element)
+        end
+      end
+
+      def normalize_hash_params(key, hash)
+        hash.map do |nested_key, element|
+          normalize_param("#{key}[#{nested_key}]", element)
+        end
+      end
+
+      def encode_simple_value(value)
+        URI.encode(value.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+      end
+
+    end
+  end
+end
+
+Hash.send :include, Nori::CoreExt::Hash

data/lib/nori/core_ext/object.rb

@@ -0,0 +1,13 @@
+class 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,21 @@
+class Nori
+  module CoreExt
+    module String
+
+      # 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
+end
+
+String.send :include, Nori::CoreExt::String

data/lib/nori/core_ext.rb

@@ -0,0 +1,3 @@
+require "nori/core_ext/object"
+require "nori/core_ext/string"
+require "nori/core_ext/hash"

data/lib/nori/parser/nokogiri.rb

@@ -0,0 +1,47 @@
+require "nokogiri"
+
+class Nori
+  module Parser
+
+    # = Nori::Parser::Nokogiri
+    #
+    # Nokogiri SAX parser.
+    module Nokogiri
+
+      class Document < ::Nokogiri::XML::SAX::Document
+        attr_accessor :options
+
+        def stack
+          @stack ||= []
+        end
+
+        def start_element(name, attrs = [])
+          stack.push Nori::XMLUtilityNode.new(options, 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, options)
+        document = Document.new
+        document.options = options
+        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,51 @@
+require "rexml/parsers/baseparser"
+require "rexml/text"
+require "rexml/document"
+
+class Nori
+  module Parser
+
+    # = Nori::Parser::REXML
+    #
+    # REXML pull parser.
+    module REXML
+
+      def self.parse(xml, options)
+        stack = []
+        parser = ::REXML::Parsers::BaseParser.new(xml)
+
+        while true
+          event = unnormalize(parser.pull)
+          case event[0]
+          when :end_document
+            break
+          when :end_doctype, :start_doctype
+            # do nothing
+          when :start_element
+            stack.push Nori::XMLUtilityNode.new(options, 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
+
+      def self.unnormalize(event)
+        event.map! do |el|
+          if el.is_a?(String)
+            ::REXML::Text.unnormalize(el)
+          elsif el.is_a?(Hash)
+            el.each {|k,v| el[k] = ::REXML::Text.unnormalize(v)}
+          else
+            el
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nori/string_io_file.rb

@@ -0,0 +1,7 @@
+class Nori
+  class StringIOFile < StringIO
+
+    attr_accessor :original_filename, :content_type
+
+  end
+end

data/lib/nori/string_with_attributes.rb

@@ -0,0 +1,7 @@
+class Nori
+  class StringWithAttributes < String
+
+    attr_accessor :attributes
+
+  end
+end

data/lib/nori/version.rb

@@ -0,0 +1,5 @@
+class Nori
+
+  VERSION = "2.3.0"
+
+end

data/lib/nori/xml_utility_node.rb

@@ -0,0 +1,253 @@
+require "date"
+require "time"
+require "yaml"
+require "bigdecimal"
+
+require "nori/string_with_attributes"
+require "nori/string_io_file"
+
+class 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
+
+    # Simple xs:time Regexp.
+    # Valid xs:time formats
+    # 13:20:00          1:20 PM
+    # 13:20:30.5555     1:20 PM and 30.5555 seconds
+    # 13:20:00-05:00    1:20 PM, US Eastern Standard Time
+    # 13:20:00+02:00    1:20 PM, Central European Standard Time
+    # 13:20:00Z         1:20 PM, Coordinated Universal Time (UTC)
+    # 00:00:00          midnight
+    # 24:00:00          midnight
+
+    XS_TIME = /^\d{2}:\d{2}:\d{2}[Z\.\-\+]?\d*:?\d*$/
+
+    # Simple xs:date Regexp.
+    # Valid xs:date formats
+    # 2004-04-12           April 12, 2004
+    # -0045-01-01          January 1, 45 BC
+    # 12004-04-12          April 12, 12004
+    # 2004-04-12-05:00     April 12, 2004, US Eastern Standard Time, which is 5 hours behind Coordinated Universal Time (UTC)
+    # 2004-04-12+02:00     April 12, 2004, Central European Summer Time, which is 2 hours ahead of Coordinated Universal Time (UTC)
+    # 2004-04-12Z          April 12, 2004, Coordinated Universal Time (UTC)
+
+    XS_DATE = /^[-]?\d{4}-\d{2}-\d{2}[Z\-\+]?\d*:?\d*$/
+
+    # Simple xs:dateTime Regexp.
+    # Valid xs:dateTime formats
+    # 2004-04-12T13:20:00           1:20 pm on April 12, 2004
+    # 2004-04-12T13:20:15.5         1:20 pm and 15.5 seconds on April 12, 2004
+    # 2004-04-12T13:20:00-05:00     1:20 pm on April 12, 2004, US Eastern Standard Time
+    # 2004-04-12T13:20:00+02:00     1:20 pm on April 12, 2004, Central European Summer Time
+    # 2004-04-12T13:20:15.5-05:00   1:20 pm and 15.5 seconds on April 12, 2004, US Eastern Standard Time
+    # 2004-04-12T13:20:00Z          1:20 pm on April 12, 2004, Coordinated Universal Time (UTC)
+
+    XS_DATE_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[\.Z]?\d*[\-\+]?\d*:?\d*$/
+
+    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["string"]        = lambda { |v| v.to_s }
+    self.typecasts["base64Binary"]  = lambda { |v| v.unpack('m').first }
+
+    self.available_typecasts = self.typecasts.keys
+
+    def initialize(options, name, attributes = {})
+      @options = options
+      @name = Nori.hash_key(name, options)
+
+      # 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 = 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
+        attributes.delete(key) if @options[:delete_namespace_attributes] && key[/^(xmlns|xsi)/]
+      end
+      @attributes = undasherize_keys(attributes)
+      @children = []
+      @text = false
+    end
+
+    attr_accessor :name, :attributes, :children, :type
+
+    def prefixed_attributes
+      attributes.inject({}) do |memo, (key, value)|
+        memo[prefixed_attribute_name("@#{key}")] = value
+        memo
+      end
+    end
+
+    def prefixed_attribute_name(attribute)
+      return attribute unless @options[:convert_tags_to].respond_to? :call
+      @options[:convert_tags_to].call(attribute)
+    end
+
+    def add_node(node)
+      @text = true if node.is_a? String
+      @children << node
+    end
+
+    def to_hash
+      if @type == "file"
+        f = StringIOFile.new((@children.first || '').unpack('m').first)
+        f.original_filename = attributes['name'] || 'untitled'
+        f.content_type = attributes['content_type'] || 'application/octet-stream'
+        return { name => f }
+      end
+
+      if @text
+        t = typecast_value(inner_html)
+        t = advanced_typecasting(t) if t.is_a?(String) && @options[: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
+        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! prefixed_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
+
+    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 try_to_convert(value) {|x| DateTime.parse(x)}
+        when XS_DATE      then try_to_convert(value) {|x| Date.parse(x)}
+        when XS_TIME      then try_to_convert(value) {|x| Time.parse(x)}
+        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|
+        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
+
+    def try_to_convert(value, &block)
+      block.call(value)
+    rescue ArgumentError
+      value
+    end
+  end
+
+end

data/lib/nori.rb

@@ -0,0 +1,72 @@
+require "nori/version"
+require "nori/core_ext"
+require "nori/xml_utility_node"
+
+class Nori
+
+  def self.hash_key(name, options = {})
+    name = name.tr("-", "_")
+    name = name.split(":").last if options[:strip_namespaces]
+    name = options[:convert_tags_to].call(name) if options[:convert_tags_to].respond_to? :call
+    name
+  end
+
+  PARSERS = { :rexml => "REXML", :nokogiri => "Nokogiri" }
+
+  def initialize(options = {})
+    defaults = {
+      :strip_namespaces             => false,
+      :delete_namespace_attributes  => false,
+      :convert_tags_to              => nil,
+      :advanced_typecasting         => true,
+      :parser                       => :nokogiri
+    }
+
+    validate_options! defaults.keys, options.keys
+    @options = defaults.merge(options)
+  end
+
+  def find(hash, *path)
+    return hash if path.empty?
+
+    key = path.shift
+    key = self.class.hash_key(key, @options)
+
+    value = find_value(hash, key)
+    find(value, *path) if value
+  end
+
+  def parse(xml)
+    cleaned_xml = xml.strip
+    return {} if cleaned_xml.empty?
+
+    parser = load_parser @options[:parser]
+    parser.parse(cleaned_xml, @options)
+  end
+
+  private
+
+  def load_parser(parser)
+    require "nori/parser/#{parser}"
+    Parser.const_get PARSERS[parser]
+  end
+
+  def validate_options!(available_options, options)
+    spurious_options = options - available_options
+
+    unless spurious_options.empty?
+      raise ArgumentError, "Spurious options: #{spurious_options.inspect}\n" \
+                           "Available options are: #{available_options.inspect}"
+    end
+  end
+
+  def find_value(hash, key)
+    hash.each do |k, v|
+      key_without_namespace = k.to_s.split(':').last
+      return v if key_without_namespace == key.to_s
+    end
+
+    nil
+  end
+
+end

data/nori.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "nori/version"
+
+Gem::Specification.new do |s|
+  s.name        = "nori-ng-1.6"
+  s.version     = Nori::VERSION
+  s.authors     = ["Rafael Reggiani Manzo"]
+  s.email       = "rr.manzo@gmail.com"
+  s.homepage    = "https://github.com/rafamanzo/nori.git"
+  s.summary     = "This a fork from Daniel Harrington's Nori with nokogiri updated to 1.6"
+  s.description = s.summary
+
+  s.rubyforge_project = "nori"
+  s.license = "MIT"
+
+  s.add_development_dependency "rake",     "~> 10.0"
+  s.add_development_dependency "nokogiri", ">= 1.4.0"
+  s.add_development_dependency "rspec",    "~> 2.12"
+
+  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