ROXML 3.0.0

data/lib/roxml/definition.rb

@@ -0,0 +1,236 @@
+require 'lib/roxml/hash_definition'
+
+class Module
+  def bool_attr_reader(*attrs)
+    attrs.each do |attr|
+      define_method :"#{attr}?" do
+        instance_variable_get(:"@#{attr}") || false
+      end
+    end
+  end
+end
+
+module ROXML
+  class ContradictoryNamespaces < StandardError
+  end
+
+  class Definition # :nodoc:
+    attr_reader :name, :type, :wrapper, :hash, :blocks, :accessor, :to_xml, :attr_name, :namespace
+    bool_attr_reader :name_explicit, :array, :cdata, :required, :frozen
+
+    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)
+      @blocks = collect_blocks(block, opts[:as])
+
+      @type = extract_type(opts[:as])
+      if @type.respond_to?(:roxml_tag_name)
+        opts[:from] ||= @type.roxml_tag_name
+      end
+
+      if opts[:from] == :content
+        opts[:from] = '.'
+      elsif opts[:from] == :name
+        opts[:from] = '*'
+      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
+
+      @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 instance_variable_name
+      :"@#{attr_name}"
+    end
+
+    def setter
+      :"#{attr_name}="
+    end
+
+    def hash
+      if hash?
+        @type.wrapper ||= name
+        @type
+      end
+    end
+
+    def hash?
+      @type.is_a?(HashDefinition)
+    end
+
+    def name?
+      @name == '*'
+    end
+
+    def content?
+      @name == '.'
+    end
+
+    def default
+      if @default.nil?
+        @default = [] if array?
+        @default = {} if hash?
+      end
+      @default.duplicable? ? @default.dup : @default
+    end
+
+    def to_ref(inst)
+      case type
+      when :attr          then XMLAttributeRef
+      when :text          then XMLTextRef
+      when HashDefinition then XMLHashRef
+      when Symbol         then raise ArgumentError, "Invalid type argument #{type}"
+      else                     XMLObjectRef
+      end.new(self, inst)
+    end
+
+  private
+    def self.all(items, &block)
+      array = items.is_a?(Array)
+      results = (array ? items : [items]).map do |item|
+        yield item
+      end
+
+      array ? results : results.first
+    end
+
+    def self.fetch_bool(value, default)
+      value = value.to_s.downcase
+      if %w{true yes 1 t}.include? value
+        true
+      elsif %w{false no 0 f}.include? value
+        false
+      else
+        default
+      end
+    end
+    
+    CORE_BLOCK_SHORTHANDS = {
+      # Core Shorthands
+      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?
+        end
+      end,
+      Time     => lambda do |val|
+        all(val) {|v| Time.parse(v) unless v.blank? }
+      end,
+
+      :bool    => nil,
+      :bool_standalone => lambda do |val|
+        all(val) do |v|
+          fetch_bool(v, nil)
+        end
+      end,
+      :bool_combined => lambda do |val|
+        all(val) do |v|
+          fetch_bool(v, v)
+        end
+      end
+    }
+
+    def self.block_shorthands
+      # dynamically load these shorthands at class definition time, but
+      # only if they're already availbable
+      CORE_BLOCK_SHORTHANDS.tap do |blocks|
+        blocks.reverse_merge!(BigDecimal => lambda do |val|
+          all(val) do |v|
+            BigDecimal.new(v) unless v.blank?
+          end
+        end) if defined?(BigDecimal)
+
+        blocks.reverse_merge!(DateTime => lambda do |val|
+          if defined?(DateTime)
+            all(val) {|v| DateTime.parse(v) unless v.blank? }
+          end
+        end) if defined?(DateTime)
+
+        blocks.reverse_merge!(Date => lambda do |val|
+          if defined?(Date)
+            all(val) {|v| Date.parse(v) unless v.blank? }
+          end
+        end) if defined?(Date)
+      end
+    end
+
+    def collect_blocks(block, as)
+      if as.is_a?(Array)
+        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
+
+        as = as.first
+      end
+
+      if as == :bool
+        # if a second block is present, and we can't coerce the xml value
+        # to bool, we need to be able to pass it to the user-provided block
+        as = (block ? :bool_combined : :bool_standalone)
+      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?)
+          raise ArgumentError, "Invalid :as argument #{as}" unless as.nil?
+        end
+        nil
+      end
+      [as, block].compact
+    end
+
+    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 as.first
+      else
+        :text
+      end
+    end
+  end
+end

data/lib/roxml/hash_definition.rb

@@ -0,0 +1,25 @@
+module ROXML
+  class HashDefinition # :nodoc:
+    attr_reader :key, :value
+    attr_accessor :wrapper
+
+    def initialize(opts)
+      opts.assert_valid_keys(:key, :value)
+
+      @key = Definition.new(nil, to_definition_options(opts, :key))
+      @value = Definition.new(nil, to_definition_options(opts, :value))
+    end
+
+  private
+    def to_definition_options(opts, what)
+      case opts[what]
+      when Hash
+        opts[what]
+      when String, Symbol
+        {:from => opts[what]}
+      else
+        raise ArgumentError, "unrecognized hash parameter: #{what} => #{opts[what]}"
+      end
+    end
+  end
+end

data/lib/roxml/xml.rb

@@ -0,0 +1,43 @@
+module ROXML
+  unless const_defined? 'XML_PARSER'
+    PREFERRED_PARSERS = %w[nokogiri libxml].freeze
+    parsers = PREFERRED_PARSERS.dup
+    begin
+      require parsers.first
+      XML_PARSER = parsers.first # :nodoc:
+    rescue LoadError
+      if parsers.size > 1
+        parsers.shift
+        retry
+      else
+        raise "Could not load either nokogiri or libxml"
+      end
+    end
+  end
+
+  require File.join('lib/roxml/xml/parsers', XML_PARSER)
+
+  module XML
+    class Node
+      def self.from(data)
+        case data
+        when XML::Node
+          data
+        when XML::Document
+          data.root
+        when File, IO
+          Parser.parse_io(data).root
+        else
+          if (defined?(URI) && data.is_a?(URI::Generic)) ||
+             (defined?(Pathname) && data.is_a?(Pathname))
+            Parser.parse_file(data.to_s).root
+          else
+            Parser.parse(data).root
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'lib/roxml/xml/references'

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

@@ -0,0 +1,91 @@
+require 'libxml'
+require 'cgi'
+
+module ROXML
+  module XML # :nodoc:all
+    Document = LibXML::XML::Document
+    Node = LibXML::XML::Node
+    Parser = LibXML::XML::Parser
+    Error = LibXML::XML::Error
+
+    module NamespacedSearch
+      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.split('/').map do |component|
+          if component =~ /\w+/ && !component.include?(':') && !component.starts_with?('@')
+            "xmlns:#{component}"
+          else
+            component
+          end
+        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
+    end
+
+    class Node
+      include NamespacedSearch
+
+      class << self
+        def new_with_entity_escaping(name, content = nil, namespace = nil)
+          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)
+        # libxml 1.1.3 changed child_add from returning child to returning self
+        self << child
+        child
+      end
+
+      alias_method :set_libxml_content, :content=
+      def content=(string)
+        set_libxml_content(string.gsub('&', '&amp;'))
+      end
+    end
+
+    class Parser
+      class << self
+        def parse(str_data)
+          string(str_data).parse
+        end
+
+        def parse_file(path)
+          file(path).parse
+        end
+
+        def parse_io(stream)
+          io(stream).parse
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+require 'nokogiri'
+
+module ROXML
+  module XML # :nodoc:all
+    Document = Nokogiri::XML::Document
+    Element = Nokogiri::XML::Element
+    Node = Nokogiri::XML::Node
+
+    module Error; end
+
+    class Parser
+      class << self
+        def parse(string)
+          Nokogiri::XML(string)
+        end
+
+        def parse_file(path) #:nodoc:
+          path = path.sub('file:', '') if path.starts_with?('file:')
+          parse(open(path))
+        end
+
+        def parse_io(stream) #:nodoc:
+          parse(stream)
+        end
+      end
+    end
+
+    class Document
+      def save(path)
+        open(path, 'w') do |file|
+          file << serialize
+        end
+      end
+
+      def default_namespace
+        'xmlns' if root.namespaces['xmlns']
+      end
+    end
+
+    module NodeExtensions
+      def search(xpath, roxml_namespaces = {})
+        xpath = "./#{xpath}"
+        (roxml_namespaces.present? ? super(xpath, roxml_namespaces) : super(xpath)).map {|i| i }
+      end
+
+      def attributes
+        self
+      end
+
+      def default_namespace
+        document.default_namespace
+      end
+    end
+
+    class Element
+      include NodeExtensions
+
+      def empty?
+        children.empty?
+      end
+    end
+
+    class Node
+      class << self
+        def new_cdata(content)
+          Nokogiri::XML::CDATA.new(Document.new, content)
+        end
+
+        def create(name)
+          new(name, Document.new)
+        end
+      end
+      include NodeExtensions
+      alias :remove! :remove
+    end
+  end
+end