roxml 2.5.3 → 3.1.0

data/lib/roxml/definition.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'hash_definition')
+require 'lib/roxml/hash_definition'
 
 class Module
   def bool_attr_reader(*attrs)
@@ -11,48 +11,41 @@ class Module
 end
 
 module ROXML
+  class ContradictoryNamespaces < StandardError
+  end
+
   class Definition # :nodoc:
-    attr_reader :name, :type, :wrapper, :hash, :blocks, :accessor, :to_xml
+    attr_reader :name, :type, :wrapper, :hash, :blocks, :accessor, :to_xml, :attr_name, :namespace
     bool_attr_reader :name_explicit, :array, :cdata, :required, :frozen
 
-    class << self
-      def silence_xml_name_warning?
-        @silence_xml_name_warning || (ROXML.const_defined?('SILENCE_XML_NAME_WARNING') && ROXML::SILENCE_XML_NAME_WARNING)
-      end
-
-      def silence_xml_name_warning!
-        @silence_xml_name_warning = true
-      end
-    end
-
-    def initialize(sym, *args, &block)
-      @accessor = sym
-      if @accessor.to_s.ends_with?('_on')
-        ActiveSupport::Deprecation.warn "In 3.0, attributes with names ending with _on will default to Date type, rather than :text"
-      end
-      if @accessor.to_s.ends_with?('_at')
-        ActiveSupport::Deprecation.warn "In 3.0, attributes with names ending with _at will default to DateTime type, rather than :text"
-      end
-
-      opts = extract_options!(args)
-      opts[:as] ||= :bool if @accessor.to_s.ends_with?('?')
+    def initialize(sym, opts = {}, &block)
+      opts.assert_valid_keys(:from, :in, :as, :namespace,
+                             :else, :required, :frozen, :cdata, :to_xml)
+      @default = opts.delete(:else)
+      @to_xml = opts.delete(:to_xml)
+      @name_explicit = opts.has_key?(:from) && opts[:from].is_a?(String)
+      @cdata = opts.delete(:cdata)
+      @required = opts.delete(:required)
+      @frozen = opts.delete(:frozen)
+      @wrapper = opts.delete(:in)
+      @namespace = opts.delete(:namespace)
+
+      @accessor = sym.to_s
+      opts[:as] ||=
+        if @accessor.ends_with?('?')
+          :bool
+        elsif @accessor.ends_with?('_on')
+          Date
+        elsif @accessor.ends_with?('_at')
+          DateTime
+        end
 
-      @array = opts[:as].is_a?(Array) || extract_from_as(opts, :array, "Please use [] around your usual type declaration")
+      @array = opts[:as].is_a?(Array)
       @blocks = collect_blocks(block, opts[:as])
 
-      if opts.has_key?(:readonly)
-        raise ArgumentError, "There is no 'readonly' option. You probably mean to use :frozen => true"
-      end
-
-      @type = extract_type(args, opts)
-      if @type.respond_to?(:xml_name_without_deprecation?) && @type.xml_name_without_deprecation?
-        unless self.class.silence_xml_name_warning?
-          warn "WARNING: As of 2.3, a breaking change has been in the naming of sub-objects. " +
-               "ROXML now considers the xml_name of the sub-object before falling back to the accessor name of the parent. " +
-               "Use :from on the parent declaration to override this behavior. Set ROXML::SILENCE_XML_NAME_WARNING to avoid this message."
-          self.class.silence_xml_name_warning!
-        end
-        opts[:from] ||= @type.tag_name
+      @type = extract_type(opts[:as])
+      if @type.respond_to?(:roxml_tag_name)
+        opts[:from] ||= @type.roxml_tag_name
       end
 
       if opts[:from] == :content
@@ -62,22 +55,30 @@ module ROXML
       elsif opts[:from] == :attr
         @type = :attr
         opts[:from] = nil
+      elsif opts[:from] == :name
+        opts[:from] = '*'
       elsif opts[:from].to_s.starts_with?('@')
         @type = :attr
         opts[:from].sub!('@', '')
       end
 
-      @name = (opts[:from] || variable_name).to_s
+      @attr_name = accessor.to_s.chomp('?')
+      @name = (opts[:from] || @attr_name).to_s
       @name = @name.singularize if hash? || array?
       if hash? && (hash.key.name? || hash.value.name?)
         @name = '*'
       end
+      raise ContradictoryNamespaces if @name.include?(':') && (@namespace.present? || @namespace == false)
 
       raise ArgumentError, "Can't specify both :else default and :required" if required? && @default
     end
 
-    def variable_name
-      accessor.to_s.chomp('?')
+    def instance_variable_name
+      :"@#{attr_name}"
+    end
+
+    def setter
+      :"#{attr_name}="
     end
 
     def hash
@@ -127,23 +128,11 @@ module ROXML
       array ? results : results.first
     end
 
-    BLOCK_TO_FLOAT = lambda do |val|
-      all(val) do |v|
-        Float(v) unless v.blank?
-      end
-    end
-
-    BLOCK_TO_INT = lambda do |val|
-      all(val) do |v|
-        Integer(v) unless v.blank?
-      end
-    end
-
     def self.fetch_bool(value, default)
       value = value.to_s.downcase
-      if %w{true yes 1}.include? value
+      if %w{true yes 1 t}.include? value
         true
-      elsif %w{false no 0}.include? value
+      elsif %w{false no 0 f}.include? value
         false
       else
         default
@@ -152,10 +141,16 @@ module ROXML
     
     CORE_BLOCK_SHORTHANDS = {
       # Core Shorthands
-      :integer => BLOCK_TO_INT, # deprecated
-      Integer  => BLOCK_TO_INT,
-      :float   => BLOCK_TO_FLOAT, # deprecated
-      Float    => BLOCK_TO_FLOAT,
+      Integer  => lambda do |val|
+        all(val) do |v|
+          Integer(v) unless v.blank?
+        end
+      end,
+      Float    => lambda do |val|
+        all(val) do |v|
+          Float(v) unless v.blank?
+        end
+      end,
       Fixnum   => lambda do |val|
         all(val) do |v|
           v.to_i unless v.blank?
@@ -181,7 +176,7 @@ module ROXML
     def self.block_shorthands
       # dynamically load these shorthands at class definition time, but
       # only if they're already availbable
-      returning CORE_BLOCK_SHORTHANDS do |blocks|
+      CORE_BLOCK_SHORTHANDS.tap do |blocks|
         blocks.reverse_merge!(BigDecimal => lambda do |val|
           all(val) do |v|
             BigDecimal.new(v) unless v.blank?
@@ -203,11 +198,8 @@ module ROXML
     end
 
     def collect_blocks(block, as)
-      ActiveSupport::Deprecation.warn ":as => :float is deprecated.  Use :as => Float instead" if as == :float
-      ActiveSupport::Deprecation.warn ":as => :integer is deprecated.  Use :as => Integer instead" if as == :integer
-
       if as.is_a?(Array)
-        unless as.one? || as.empty?
+        if as.size > 1
           raise ArgumentError, "multiple :as types (#{as.map(&:inspect).join(', ')}) is not supported.  Use a block if you want more complicated behavior."
         end
 
@@ -221,103 +213,23 @@ module ROXML
       end
       as = self.class.block_shorthands.fetch(as) do
         unless as.respond_to?(:from_xml) || (as.respond_to?(:first) && as.first.respond_to?(:from_xml)) || (as.is_a?(Hash) && !(as.keys & [:key, :value]).empty?)
-          ActiveSupport::Deprecation.warn "#{as.inspect} is not a valid type declaration. ROXML will raise in this case in version 3.0" unless as.nil?
+          raise ArgumentError, "Invalid :as argument #{as}" unless as.nil?
         end
         nil
       end
       [as, block].compact
     end
 
-    def extract_options!(args)
-      opts = args.extract_options!
-      unless (opts.keys & HASH_KEYS).empty?
-        args.push(opts)
-        opts = {}
-      end
-
-      @default = opts.delete(:else)
-      @to_xml = opts.delete(:to_xml)
-      @name_explicit = opts.has_key?(:from) && opts[:from].is_a?(String)
-      @cdata = opts.delete(:cdata)
-      @required = opts.delete(:required)
-      @frozen = opts.delete(:frozen)
-      @wrapper = opts.delete(:in)
-
-      @cdata ||= extract_from_as(opts, :cdata, "Please use :cdata => true")
-
-      if opts[:as].is_a?(Array) && opts[:as].size > 1
-        ActiveSupport::Deprecation.warn ":as should point to a single item. #{opts[:as].join(', ')} should be declared some other way."
-      end
-
-      opts
-    end
-
-    def extract_from_as(opts, entry, message)
-      # remove with deprecateds...
-      if [*opts[:as]].include?(entry)
-        ActiveSupport::Deprecation.warn ":as => #{entry.inspect} is deprecated. #{message}"
-        if opts[:as] == entry
-          opts[:as] = nil
-        else
-          opts[:as].delete(entry)
-        end
-        true
-      end
-    end
-
-    def extract_type(args, opts)
-      types = (opts.keys & TYPE_KEYS)
-      # type arg
-      if args.one? && types.empty?
-        type = args.first
-        if type.is_a? Array
-          ActiveSupport::Deprecation.warn "Array declarations should be passed as the :as parameter, for future release."
-          @array = true
-          return type.first || :text
-        elsif type.is_a? Hash
-          ActiveSupport::Deprecation.warn "Hash declarations should be passed as the :as parameter, for future release."
-          return HashDefinition.new(type)
-        elsif type == :content
-          ActiveSupport::Deprecation.warn ":content as a type declaration is deprecated.  Use :from => '.' or :from => :content instead"
-          opts[:from] = :content
-          return :text
-        elsif type == :attr
-          ActiveSupport::Deprecation.warn ":attr as a type declaration is deprecated.  Use :from => '@attr_name' or :from => :attr instead"
-          opts[:from].sub!('@', '') if opts[:from].to_s.starts_with?('@') # this is added back next line...
-          opts[:from] = opts[:from].nil? ? :attr : "@#{opts[:from]}"
-          return :attr
-        else
-          ActiveSupport::Deprecation.warn "Type declarations should be passed as the :as parameter, for future release."
-          return type
-        end
-      end
-
-      unless args.empty?
-        raise ArgumentError, "too many arguments (#{(args + types).join(', ')}).  Should be name, type, and " +
-                             "an options hash, with the type and options optional"
-      end
-
-      if opts[:as].is_a?(Hash)
-        return HashDefinition.new(opts[:as])
-      elsif opts[:as].respond_to?(:from_xml)
-        return opts[:as]
-      elsif opts[:as].is_a?(Array) && opts[:as].first.respond_to?(:from_xml)
+    def extract_type(as)
+      if as.is_a?(Hash)
+        return HashDefinition.new(as)
+      elsif as.respond_to?(:from_xml)
+        return as
+      elsif as.is_a?(Array) && as.first.respond_to?(:from_xml)
         @array = true
-        return opts[:as].first
-      end
-
-      # type options
-      if types.one?
-        opts[:from] = opts.delete(types.first)
-        if opts[:from] == :content
-          opts[:from] = 'content'
-          ActiveSupport::Deprecation.warn ":content is now a reserved as an alias for '.'. Use the string 'content' instead"
-        end
-        types.first
-      elsif types.empty?
-        :text
+        return as.first
       else
-        raise ArgumentError, "more than one type option specified: #{types.join(', ')}"
+        :text
       end
     end
   end

data/lib/roxml/hash_definition.rb

@@ -1,60 +1,25 @@
 module ROXML
-  HASH_KEYS = [:attrs, :key, :value].freeze
-  TYPE_KEYS = [:attr, :text, :hash, :content].freeze
-
   class HashDefinition # :nodoc:
     attr_reader :key, :value
     attr_accessor :wrapper
 
     def initialize(opts)
-      unless (invalid_keys = opts.keys - HASH_KEYS).empty?
-        raise ArgumentError, "Invalid Hash description keys: #{invalid_keys.join(', ')}"
-      end
+      opts.assert_valid_keys(:key, :value)
 
-      if opts.has_key? :attrs
-        ActiveSupport::Deprecation.warn(":as => {:attrs} is going away in 3.0.  Use explicit :key and :value instead.")
-        @key   = to_hash_args(opts, :from => "@#{opts[:attrs][0]}")
-        @value = to_hash_args(opts, :from => "@#{opts[:attrs][1]}")
-      else
-        @key = to_hash_args opts, fetch_element(opts, :key)
-        @value = to_hash_args opts, fetch_element(opts, :value)
-      end
+      @key = Definition.new(nil, to_definition_options(opts, :key))
+      @value = Definition.new(nil, to_definition_options(opts, :value))
     end
 
   private
-    def fetch_element(opts, what)
+    def to_definition_options(opts, what)
       case opts[what]
       when Hash
-        if opts[what].keys.one?
-          ActiveSupport::Deprecation.warn(":as => {:key => {Type => 'name'} ... } is going away in 3.0.  Use explicit :key => {:from => 'name', :as => Type} instead.")
-          type = opts[what].keys.first
-          case type
-          when :attr
-            {:from => "@#{opts[what][type]}"}
-          when :text
-            {:from => opts[what][type]}
-          else
-            {:as => type, :from => opts[what][type]}
-          end
-        else
-          opts[what]
-        end
+        opts[what]
       when String, Symbol
         {:from => opts[what]}
       else
         raise ArgumentError, "unrecognized hash parameter: #{what} => #{opts[what]}"
       end
     end
-
-    def to_hash_args(args, opts)
-      args = [args] unless args.is_a? Array
-
-      if args.one? && !(args.first.keys & HASH_KEYS).empty?
-        Definition.new(nil, opts)
-      else
-        opts = args.extract_options!
-        raise opts.inspect
-      end
-    end
   end
 end

data/lib/roxml/xml.rb

@@ -1,18 +1,21 @@
 module ROXML
   unless const_defined? 'XML_PARSER'
+    PREFERRED_PARSERS = %w[nokogiri libxml].freeze
+    parsers = PREFERRED_PARSERS.dup
     begin
-      require 'libxml'
-      XML_PARSER = 'libxml' # :nodoc:
+      require parsers.first
+      XML_PARSER = parsers.first # :nodoc:
     rescue LoadError
-      warn <<WARNING
-ROXML is unable to locate libxml on your system, and so is falling back to
-the much slower REXML.  It's best to check this out and get libxml working if possible.
-WARNING
-      XML_PARSER = 'rexml' # :nodoc:
+      if parsers.size > 1
+        parsers.shift
+        retry
+      else
+        raise "Could not load either nokogiri or libxml"
+      end
     end
   end
 
-  require File.join(File.dirname(__FILE__), 'xml/parsers', XML_PARSER)
+  require File.join('lib/roxml/xml/parsers', XML_PARSER)
 
   module XML
     class Node
@@ -37,4 +40,4 @@ WARNING
   end
 end
 
-require File.join(File.dirname(__FILE__), 'xml/references')
+require 'lib/roxml/xml/references'

data/lib/roxml/xml/parsers/libxml.rb

@@ -9,37 +9,36 @@ module ROXML
     Error = LibXML::XML::Error
 
     module NamespacedSearch
-      def search(xpath)
-        begin
-          if namespaces.default && !xpath.include?(':')
-            find(namespaced(xpath),
-                 in_default_namespace(namespaces.default.href))
-          else
-            find(xpath)
-          end
-        rescue Exception => ex
-          raise ex, xpath
+      def search(xpath, roxml_namespaces = {})
+        if namespaces.default
+          roxml_namespaces = {:xmlns => namespaces.default.href}.merge(roxml_namespaces)
+        end
+        if roxml_namespaces.present?
+          find(xpath, roxml_namespaces.map {|prefix, href| [prefix, href].join(':') })
+        else
+          find(xpath)
         end
       end
 
     private
       def namespaced(xpath)
-        xpath.between('/') do |component|
+        xpath.split('/').map do |component|
           if component =~ /\w+/ && !component.include?(':') && !component.starts_with?('@')
-            in_default_namespace(component)
+            "xmlns:#{component}"
           else
             component
           end
-        end
-      end
-
-      def in_default_namespace(name)
-        "roxmldefaultnamespace:#{name}"
+        end.join('/')
       end
     end
 
     class Document
       include NamespacedSearch
+      
+      def default_namespace
+        default = namespaces.default
+        default.prefix || 'xmlns' if default
+      end
 
     private
       delegate :namespaces, :to => :root
@@ -53,6 +52,12 @@ module ROXML
           new_without_entity_escaping(name, content && CGI.escapeHTML(content), namespace)
         end
         alias_method_chain :new, :entity_escaping
+
+        alias :create :new
+      end
+
+      def default_namespace
+        doc.default_namespace
       end
 
       def add_child(child)