rack_dav 0.1.3 → 0.3.1

data/.gitignore

@@ -1,4 +1,6 @@
 *~
+/.bundle
 doc/*
 pkg/*
 test/repo
+/vendor/bundle

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+= Changelog
+
+== master
+
+* NEW: Added Rakefile, package and test tasks.
+
+* NEW: Added Gemfile and Bundler tasks.
+
+* CHANGED: Upgraded to RSpec 2.0.
+
+* CHANGED: Bump dependency to rack >= 1.2.0
+
+* CHANGED: Removed response.status override/casting in RackDAV::Handler
+  because already performed in Rack::Response#finish.
+
+* FIXED: rack_dav binary crashes if Mongrel is not installed.
+
+
+== Release 0.1.3
+
+* Unknown
+
+
+== Release 0.1.2
+
+* Unknown
+

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rack_dav.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,31 @@
+PATH
+  remote: .
+  specs:
+    rack_dav (0.3.0)
+      nokogiri
+      rack (~> 1.4.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    nokogiri (1.5.5)
+    rack (1.4.1)
+    rake (0.9.2.2)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.2)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.1)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  rack_dav!
+  rake (~> 0.9.0)
+  rspec (~> 2.11.0)

data/README.md

@@ -1,5 +1,5 @@
 ---
-title: RackDAV - Web Authoring for Rack
+RackDAV - Web Authoring for Rack
 ---
 
 RackDAV is Handler for [Rack][1], which allows content authoring over
@@ -8,10 +8,9 @@ possible by subclassing RackDAV::Resource.
 
 ## Install
 
-Just install the gem from github:
+Just install the gem from RubyGems:
 
-    $ gem sources -a http://gems.github.com
-    $ sudo gem install georgi-rack_dav
+    $ gem install rack_dav
 
 ## Quickstart
 
@@ -28,14 +27,12 @@ to without authentication.
 Using RackDAV inside a rack application is quite easy. A simple rackup
 script looks like this:
 
-    @@ruby
-
     require 'rubygems'
     require 'rack_dav'
-     
+    
     use Rack::CommonLogger
-     
-    run RackDAV::Handler.new('/path/to/docs')
+    
+    run RackDAV::Handler.new(:root => '/path/to/docs')
 
 ## Implementing your own WebDAV resource
 
@@ -47,23 +44,21 @@ find the real resource.
 
 RackDAV::Handler needs to be initialized with the actual resource class:
 
-    @@ruby
-
     RackDAV::Handler.new(:resource_class => MyResource)
 
 RackDAV needs some information about the resources, so you have to
 implement following methods:
-        
+
 * __children__: If this is a collection, return the child resources.
 
 * __collection?__: Is this resource a collection?
 
 * __exist?__: Does this recource exist?
-    
+
 * __creation\_date__: Return the creation time.
 
 * __last\_modified__: Return the time of last modification.
-    
+
 * __last\_modified=(time)__: Set the time of last modification.
 
 * __etag__: Return an Etag, an unique hash value for this resource.
@@ -87,9 +82,13 @@ to retrieve and change the resources:
 * __copy(dest)__: Copy this resource to given destination resource.
 
 * __move(dest)__: Move this resource to given destination resource.
-    
+
 * __make\_collection__: Create this resource as collection.
 
+* __lock(token, timeout, scope, type, owner)__: Lock this resource.
+  If scope, type and owner are nil, refresh the given lock.
+
+* __unlock(token)__: Unlock this resource
 
 Note, that it is generally possible, that a resource object is
 instantiated for a not yet existing resource.

data/Rakefile

@@ -0,0 +1,36 @@
+require 'bundler'
+require "rspec/core/rake_task"
+
+Bundler::GemHelper.install_tasks
+
+
+task :default => :spec
+
+# Run all the specs in the /spec folder
+RSpec::Core::RakeTask.new
+
+
+namespace :spec do
+  desc "Run RSpec against all Ruby versions"
+  task :rubies => "spec:rubies:default"
+
+  namespace :rubies do
+    RUBIES = %w( 1.8.7-p330 1.9.2-p0 jruby-1.5.6 ree-1.8.7-2010.02 )
+
+    task :default => :ensure_rvm do
+      sh "rvm #{RUBIES.join(",")} rake default"
+    end
+
+    task :ensure_rvm do
+      File.exist?(File.expand_path("~/.rvm/scripts/rvm")) || abort("RVM is not available")
+    end
+
+    RUBIES.each do |ruby|
+      desc "Run RSpec against Ruby #{ruby}"
+      task ruby => :ensure_rvm do
+        sh "rvm #{ruby} rake default"
+      end
+    end
+  end
+
+end

data/bin/rack_dav

@@ -1,20 +1,24 @@
 #!/usr/bin/env ruby
 
-require 'rubygems'
+$:.unshift(File.expand_path("../../lib", __FILE__))
+
 require 'rack_dav'
 
-app = Rack::Builder.new do
+root=ARGV[1] || Dir.pwd
+port = ARGV[0] || 3000
+
+app = Rack::Builder.new do 
   use Rack::ShowExceptions
   use Rack::CommonLogger
   use Rack::Reloader
   use Rack::Lint
-  
-  run RackDAV::Handler.new
+
+  run RackDAV::Handler.new(:root => root)
 
 end.to_app
 
 begin
-  Rack::Handler::Mongrel.run(app, :Port => 3000)
-rescue
-  Rack::Handler::WEBrick.run(app, :Port => 3000)
+  Rack::Handler::Mongrel.run(app, :Port => port)
+rescue LoadError
+  Rack::Handler::WEBrick.run(app, :Port => port)
 end

data/lib/rack_dav.rb

@@ -1,15 +1,13 @@
 require 'rubygems'
-require 'builder'
 require 'time'
 require 'uri'
 require 'rexml/document'
+require 'nokogiri'
 require 'webrick/httputils'
 
 require 'rack'
-require 'rack_dav/builder_namespace'
 require 'rack_dav/http_status'
 require 'rack_dav/resource'
 require 'rack_dav/file_resource'
 require 'rack_dav/handler'
 require 'rack_dav/controller'
-

data/lib/rack_dav/controller.rb

@@ -1,49 +1,56 @@
+require 'uri'
+
+require_relative 'string'
+
 module RackDAV
-  
+
   class Controller
     include RackDAV::HTTPStatus
-    
+
     attr_reader :request, :response, :resource
-    
+
     def initialize(request, response, options)
-      @request = request
+      @request  = request
       @response = response
-      @options = options
+      @options  = options
       @resource = resource_class.new(url_unescape(request.path_info), @options)
       raise Forbidden if request.path_info.include?('../')
     end
-    
+
     def url_escape(s)
-      s.gsub(/([^\/a-zA-Z0-9_.-]+)/n) do
-        '%' + $1.unpack('H2' * $1.size).join('%').upcase
-      end.tr(' ', '+')
+      URI.escape(s)
     end
 
     def url_unescape(s)
-      s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n) do
-        [$1.delete('%')].pack('H*')
-      end
-    end    
-    
+      URI.unescape(s).force_valid_encoding
+    end
+
     def options
-      response["Allow"] = 'OPTIONS,HEAD,GET,PUT,POST,DELETE,PROPFIND,PROPPATCH,MKCOL,COPY,MOVE,LOCK,UNLOCK'
-      response["Dav"] = "1,2"
+      response["Allow"] = 'OPTIONS,HEAD,GET,PUT,POST,DELETE,PROPFIND,PROPPATCH,MKCOL,COPY,MOVE'
+      response["Dav"] = "1"
+
+      if resource.lockable?
+        response["Allow"] << ",LOCK,UNLOCK"
+        response["Dav"]   << ",2"
+      end
+
       response["Ms-Author-Via"] = "DAV"
     end
-    
+
     def head
       raise NotFound if not resource.exist?
       response['Etag'] = resource.etag
       response['Content-Type'] = resource.content_type
+      response['Content-Length'] = resource.content_length.to_s
       response['Last-Modified'] = resource.last_modified.httpdate
     end
-    
+
     def get
       raise NotFound if not resource.exist?
       response['Etag'] = resource.etag
       response['Content-Type'] = resource.content_type
       response['Content-Length'] = resource.content_length.to_s
-      response['Last-Modified'] = resource.last_modified.httpdate      
+      response['Last-Modified'] = resource.last_modified.httpdate
       map_exceptions do
         resource.get(request, response)
       end
@@ -64,7 +71,7 @@ module RackDAV
 
     def delete
       delete_recursive(resource, errors = [])
-      
+
       if errors.empty?
         response.status = NoContent
       else
@@ -73,30 +80,30 @@ module RackDAV
         end
       end
     end
-    
+
     def mkcol
       map_exceptions do
         resource.make_collection
       end
       response.status = Created
     end
-    
+
     def copy
       raise NotFound if not resource.exist?
-      
+
       dest_uri = URI.parse(env['HTTP_DESTINATION'])
       destination = url_unescape(dest_uri.path)
 
       raise BadGateway if dest_uri.host and dest_uri.host != request.host
       raise Forbidden if destination == resource.path
-      
+
       dest = resource_class.new(destination, @options)
       dest = dest.child(resource.name) if dest.collection?
-      
+
       dest_existed = dest.exist?
-      
+
       copy_recursive(resource, dest, depth, errors = [])
-      
+
       if errors.empty?
         response.status = dest_existed ? NoContent : Created
       else
@@ -113,20 +120,20 @@ module RackDAV
 
       dest_uri = URI.parse(env['HTTP_DESTINATION'])
       destination = url_unescape(dest_uri.path)
-      
+
       raise BadGateway if dest_uri.host and dest_uri.host != request.host
       raise Forbidden if destination == resource.path
-      
+
       dest = resource_class.new(destination, @options)
       dest = dest.child(resource.name) if dest.collection?
-      
+
       dest_existed = dest.exist?
-      
+
       raise Conflict if depth <= 1
-      
+
       copy_recursive(resource, dest, depth, errors = [])
       delete_recursive(resource, errors)
-      
+
       if errors.empty?
         response.status = dest_existed ? NoContent : Created
       else
@@ -137,14 +144,14 @@ module RackDAV
     rescue URI::InvalidURIError => e
       raise BadRequest.new(e.message)
     end
-    
+
     def propfind
       raise NotFound if not resource.exist?
 
-      if not request_match("/propfind/allprop").empty?
+      if not request_match("/d:propfind/d:allprop").empty?
         names = resource.property_names
       else
-        names = request_match("/propfind/prop/*").map { |e| e.name }
+        names = request_match("/d:propfind/d:prop/d:*").map { |e| e.name }
         names = resource.property_names if names.empty?
         raise BadRequest if names.empty?
       end
@@ -153,18 +160,18 @@ module RackDAV
         for resource in find_resources
           resource.path.gsub!(/\/\//, '/')
           xml.response do
-          	xml.href "http://#{host}#{url_escape resource.path}"
+            xml.href "http://#{host}#{url_escape resource.path}"
             propstats xml, get_properties(resource, names)
           end
         end
       end
     end
-    
+
     def proppatch
       raise NotFound if not resource.exist?
 
-      prop_rem = request_match("/propertyupdate/remove/prop/*").map { |e| [e.name] }
-      prop_set = request_match("/propertyupdate/set/prop/*").map { |e| [e.name, e.text] }
+      prop_rem = request_match("/d:propertyupdate/d:remove/d:prop/d:*").map { |e| [e.name] }
+      prop_set = request_match("/d:propertyupdate/d:set/d:prop/d:*").map { |e| [e.name, e.text] }
 
       multistatus do |xml|
         for resource in find_resources
@@ -179,233 +186,308 @@ module RackDAV
     end
 
     def lock
+      raise MethodNotAllowed unless resource.lockable?
       raise NotFound if not resource.exist?
 
-      lockscope = request_match("/lockinfo/lockscope/*")[0].name
-      locktype = request_match("/lockinfo/locktype/*")[0].name
-      owner = request_match("/lockinfo/owner/href")[0]
-      locktoken = "opaquelocktoken:" + sprintf('%x-%x-%s', Time.now.to_i, Time.now.sec, resource.etag)
-
-      response['Lock-Token'] = locktoken
-
-      render_xml do |xml|
-        xml.prop('xmlns:D' => "DAV:") do
-          xml.lockdiscovery do
-            xml.activelock do
-              xml.lockscope { xml.tag! lockscope }
-              xml.locktype { xml.tag! locktype }
-              xml.depth 'Infinity'
-              if owner
-                xml.owner { xml.href owner.text }
-              end
-              xml.timeout "Second-60"
-              xml.locktoken do
-                xml.href locktoken
-              end
-            end
-          end
-        end
+      timeout = request_timeout
+      if timeout.nil? || timeout.zero?
+        timeout = 60
+      end
+
+      if request_document.content.empty?
+        refresh_lock timeout
+      else
+        create_lock timeout
       end
     end
 
     def unlock
-      raise NoContent
+      raise MethodNotAllowed unless resource.lockable?
+
+      locktoken = request_locktoken('LOCK_TOKEN')
+      raise BadRequest if locktoken.nil?
+
+      response.status = resource.unlock(locktoken) ? NoContent : Forbidden
     end
 
-    # ************************************************************
-    # private methods
-    
     private
 
-    def env
-      @request.env
-    end
-    
-    def host
-      env['HTTP_HOST']
-    end
-    
-    def resource_class
-      @options[:resource_class]
-    end
+      def env
+        @request.env
+      end
 
-    def depth
-      case env['HTTP_DEPTH']
-      when '0' then 0
-      when '1' then 1
-      else 100
+      def host
+        env['HTTP_HOST']
       end
-    end
 
-    def overwrite
-      env['HTTP_OVERWRITE'].to_s.upcase != 'F'
-    end
+      def resource_class
+        @options[:resource_class]
+      end
 
-    def find_resources
-      case env['HTTP_DEPTH']
-      when '0'
-        [resource]
-      when '1'
-        [resource] + resource.children
-      else
-        [resource] + resource.descendants
+      def depth
+        case env['HTTP_DEPTH']
+        when '0' then 0
+        when '1' then 1
+        else 100
+        end
       end
-    end
 
-    def delete_recursive(res, errors)
-      for child in res.children
-        delete_recursive(child, errors)
+      def overwrite
+        env['HTTP_OVERWRITE'].to_s.upcase != 'F'
       end
-      
-      begin
-        map_exceptions { res.delete } if errors.empty?
+
+      def find_resources
+        case env['HTTP_DEPTH']
+        when '0'
+          [resource]
+        when '1'
+          [resource] + resource.children
+        else
+          [resource] + resource.descendants
+        end
+      end
+
+      def delete_recursive(res, errors)
+        for child in res.children
+          delete_recursive(child, errors)
+        end
+
+        begin
+          map_exceptions { res.delete } if errors.empty?
+        rescue Status
+          errors << [res.path, $!]
+        end
+      end
+
+      def copy_recursive(res, dest, depth, errors)
+        map_exceptions do
+          if dest.exist?
+            if overwrite
+              delete_recursive(dest, errors)
+            else
+              raise PreconditionFailed
+            end
+          end
+          res.copy(dest)
+        end
       rescue Status
         errors << [res.path, $!]
-      end
-    end
-    
-    def copy_recursive(res, dest, depth, errors)
-      map_exceptions do
-        if dest.exist?
-          if overwrite
-            delete_recursive(dest, errors)
-          else
-            raise PreconditionFailed
+      else
+        if depth > 0
+          for child in res.children
+            dest_child = dest.child(child.name)
+            copy_recursive(child, dest_child, depth - 1, errors)
           end
         end
-        res.copy(dest)
       end
-    rescue Status
-      errors << [res.path, $!]
-    else
-      if depth > 0
-        for child in res.children
-          dest_child = dest.child(child.name)
-          copy_recursive(child, dest_child, depth - 1, errors)
+
+      def map_exceptions
+        yield
+      rescue
+        case $!
+        when URI::InvalidURIError then raise BadRequest
+        when Errno::EACCES then raise Forbidden
+        when Errno::ENOENT then raise Conflict
+        when Errno::EEXIST then raise Conflict
+        when Errno::ENOSPC then raise InsufficientStorage
+        else
+          raise
         end
       end
-    end
-    
-    def map_exceptions
-      yield
-    rescue
-      case $!
-      when URI::InvalidURIError then raise BadRequest
-      when Errno::EACCES then raise Forbidden
-      when Errno::ENOENT then raise Conflict
-      when Errno::EEXIST then raise Conflict      
-      when Errno::ENOSPC then raise InsufficientStorage
-      else
-        raise
+
+      def request_document
+        @request_document ||= Nokogiri::XML(request.body.read) {|config| config.strict }
+      rescue Nokogiri::XML::SyntaxError
+        raise BadRequest
       end
-    end
-    
-    def request_document
-      @request_document ||= REXML::Document.new(request.body.read)
-    rescue REXML::ParseException
-      raise BadRequest
-    end
 
-    def request_match(pattern)
-      REXML::XPath::match(request_document, pattern, '' => 'DAV:')
-    end
+      def request_match(pattern)
+        request_document.xpath(pattern, 'd' => 'DAV:')
+      end
 
-    def render_xml
-      xml = Builder::XmlMarkup.new(:indent => 2)
-      xml.instruct! :xml, :version => "1.0", :encoding => "UTF-8"
-      
-      xml.namespace('D') do
-        yield xml
-      end
-      
-      response.body = xml.target!
-      response["Content-Type"] = 'text/xml; charset="utf-8"'
-      response["Content-Length"] = response.body.size.to_s
-    end
-      
-    def multistatus
-      render_xml do |xml|
-        xml.multistatus('xmlns:D' => "DAV:") do
+      # Quick and dirty parsing of the WEBDAV Timeout header.
+      # Refuses infinity, rejects anything but Second- timeouts
+      #
+      # @return [nil] or [Fixnum]
+      #
+      # @api internal
+      #
+      def request_timeout
+        timeout = request.env['HTTP_TIMEOUT']
+        return if timeout.nil? || timeout.empty?
+
+        timeout = timeout.split /,\s*/
+        timeout.reject! {|t| t !~ /^Second-/}
+        timeout.first.sub('Second-', '').to_i
+      end
+
+      def request_locktoken(header)
+        token = request.env["HTTP_#{header}"]
+        return if token.nil? || token.empty?
+        token.scan /^\(?<?(.+?)>?\)?$/
+        return $1
+      end
+
+      # Creates a new XML document, yields given block
+      # and sets the response.body with the final XML content.
+      # The response length is updated accordingly.
+      #
+      # @return [void]
+      #
+      # @yield  [xml] Yields the Builder XML instance.
+      #
+      # @api internal
+      #
+      def render_xml
+        content = Nokogiri::XML::Builder.new(:encoding => "UTF-8") do |xml|
           yield xml
+        end.to_xml
+        response.body = [content]
+        response["Content-Type"] = 'text/xml; charset=utf-8'
+        response["Content-Length"] = Rack::Utils.bytesize(content).to_s
+      end
+
+      def multistatus
+        render_xml do |xml|
+          xml.multistatus('xmlns' => "DAV:") do
+            yield xml
+          end
         end
+
+        response.status = MultiStatus
       end
-      
-      response.status = MultiStatus
-    end
-    
-    def response_errors(xml, errors)
-      for path, status in errors
-        xml.response do
-          xml.href "http://#{host}#{path}"
-          xml.status "#{request.env['HTTP_VERSION']} #{status.status_line}"
+
+      def response_errors(xml, errors)
+        for path, status in errors
+          xml.response do
+            xml.href "http://#{host}#{path}"
+            xml.status "#{request.env['HTTP_VERSION']} #{status.status_line}"
+          end
         end
       end
-    end
 
-    def get_properties(resource, names)
-      stats = Hash.new { |h, k| h[k] = [] }
-      for name in names
-        begin
-          map_exceptions do
-            stats[OK] << [name, resource.get_property(name)]
+      def get_properties(resource, names)
+        stats = Hash.new { |h, k| h[k] = [] }
+        for name in names
+          begin
+            map_exceptions do
+              stats[OK] << [name, resource.get_property(name)]
+            end
+          rescue Status
+            stats[$!] << name
           end
-        rescue Status
-          stats[$!] << name
         end
+        stats
       end
-      stats
-    end
 
-    def set_properties(resource, pairs)
-      stats = Hash.new { |h, k| h[k] = [] }
-      for name, value in pairs
-        begin
-          map_exceptions do
-            stats[OK] << [name, resource.set_property(name, value)]
+      def set_properties(resource, pairs)
+        stats = Hash.new { |h, k| h[k] = [] }
+        for name, value in pairs
+          begin
+            map_exceptions do
+              stats[OK] << [name, resource.set_property(name, value)]
+            end
+          rescue Status
+            stats[$!] << name
           end
-        rescue Status
-          stats[$!] << name
         end
+        stats
       end
-      stats
-    end
-    
-    def propstats(xml, stats)
-      return if stats.empty?
-      for status, props in stats
-        xml.propstat do
-          xml.prop do
-            for name, value in props
-              if value.is_a?(REXML::Element)
-                xml.tag!(name) do
-                  rexml_convert(xml, value)
+
+      def propstats(xml, stats)
+        return if stats.empty?
+        for status, props in stats
+          xml.propstat do
+            xml.prop do
+              for name, value in props
+                if value.is_a?(Nokogiri::XML::Node)
+                  xml.send(name) do
+                    rexml_convert(xml, value)
+                  end
+                else
+                  xml.send(name, value)
                 end
-              else
-                xml.tag!(name, value)
               end
             end
+            xml.status "#{request.env['HTTP_VERSION']} #{status.status_line}"
           end
-          xml.status "#{request.env['HTTP_VERSION']} #{status.status_line}"
         end
       end
-    end
-    
-    def rexml_convert(xml, element)
-      if element.elements.empty?
-        if element.text
-          xml.tag!(element.name, element.text, element.attributes)
-        else
-          xml.tag!(element.name, element.attributes)
+
+      def create_lock(timeout)
+        lockscope = request_match("/d:lockinfo/d:lockscope/d:*").first
+        lockscope = lockscope.name if lockscope
+        locktype = request_match("/d:lockinfo/d:locktype/d:*").first
+        locktype = locktype.name if locktype
+        owner = request_match("/d:lockinfo/d:owner/d:href").first
+        owner = owner.text if owner
+        locktoken = "opaquelocktoken:" + sprintf('%x-%x-%s', Time.now.to_i, Time.now.sec, resource.etag)
+
+        # Quick & Dirty - FIXME: Lock should become a new Class
+        # and this dirty parameter passing refactored.
+        unless resource.lock(locktoken, timeout, lockscope, locktype, owner)
+          raise Forbidden
         end
-      else
-        xml.tag!(element.name, element.attributes) do
-          element.elements.each do |child|
-            rexml_convert(xml, child)
+
+        response['Lock-Token'] = locktoken
+
+        render_lockdiscovery locktoken, lockscope, locktype, timeout, owner
+      end
+
+      def refresh_lock(timeout)
+        locktoken = request_locktoken('IF')
+        raise BadRequest if locktoken.nil?
+
+        timeout, lockscope, locktype, owner = resource.lock(locktoken, timeout)
+        unless lockscope && locktype && timeout
+          raise Forbidden
+        end
+
+        render_lockdiscovery locktoken, lockscope, locktype, timeout, owner
+      end
+
+      # FIXME add multiple locks support
+      def render_lockdiscovery(locktoken, lockscope, locktype, timeout, owner)
+        render_xml do |xml|
+          xml.prop('xmlns' => "DAV:") do
+            xml.lockdiscovery do
+              render_lock(xml, locktoken, lockscope, locktype, timeout, owner)
+            end
           end
         end
       end
-    end
-    
+
+      def render_lock(xml, locktoken, lockscope, locktype, timeout, owner)
+        xml.activelock do
+          xml.lockscope { xml.tag! lockscope }
+          xml.locktype { xml.tag! locktype }
+          xml.depth 'Infinity'
+          if owner
+            xml.owner { xml.href owner }
+          end
+          xml.timeout "Second-#{timeout}"
+          xml.locktoken do
+            xml.href locktoken
+          end
+        end
+      end
+
+      def rexml_convert(xml, element)
+        if element.elements.empty?
+          if element.text
+            xml.send(element.name.to_sym, element.text, element.attributes)
+          else
+            xml.send(element.name.to_sym, element.attributes)
+          end
+        else
+          xml.send(element.name.to_sym, element.attributes) do
+            element.elements.each do |child|
+              rexml_convert(xml, child)
+            end
+          end
+        end
+      end
+
   end
 
-end 
+end