jro_apps/redmine Commit - r3310:ea3e2b112180

Changes SubversionAdapter to use ActiveSupport::XmlMini API for XML parsing....

Jean-Philippe Lang -

r3310:ea3e2b112180

parent child

Context file:

r3310:ea3e2b112180

Collapse all files

lib/redmine/scm/adapters/subversion_adapter.rb +49 -34

-            # redMine - project management software
+            # Redmine - project management software
-            # Copyright (C) 2006-2007  Jean-Philippe Lang
+            # Copyright (C) 2006-2010  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'redmine/scm/adapters/abstract_adapter'
-            require 'rexml/document'
             require 'uri'
             module Redmine
                       cmd << credentials_string
                       info = nil
                       shellout(cmd) do |io|
+                        output = io.read
                         begin
-                          doc = REXML::Document.new(io)
+                          doc = ActiveSupport::XmlMini.parse(output)
                           #root_url = doc.elements["info/entry/repository/root"].text
-                          info = Info.new({:root_url => doc.elements["info/entry/repository/root"].text,
+                          info = Info.new({:root_url => doc['info']['entry']['repository']['root']['__content__'],
                                            :lastrev => Revision.new({
-                                             :identifier => doc.elements["info/entry/commit"].attributes['revision'],
+                                             :identifier => doc['info']['entry']['commit']['revision'],
-                                             :time => Time.parse(doc.elements["info/entry/commit/date"].text).localtime,
+                                             :time => Time.parse(doc['info']['entry']['commit']['date']['__content__']).localtime,
-                                             :author => (doc.elements["info/entry/commit/author"] ? doc.elements["info/entry/commit/author"].text : "")
+                                             :author => (doc['info']['entry']['commit']['author'] ? doc['info']['entry']['commit']['author']['__content__'] : "")
                                            })
                                          })
                         rescue
                       shellout(cmd) do |io|
                         output = io.read
                         begin
-                          doc = REXML::Document.new(output)
+                          doc = ActiveSupport::XmlMini.parse(output)
-                          doc.elements.each("lists/list/entry") do |entry|
+                          each_xml_element(doc['lists']['list'], 'entry') do |entry|
-                            commit = entry.elements['commit']
+                            commit = entry['commit']
-                            commit_date = commit.elements['date']
+                            commit_date = commit['date']
                             # Skip directory if there is no commit date (usually that
                             # means that we don't have read access to it)
-                            next if entry.attributes['kind'] == 'dir' && commit_date.nil?
+                            next if entry['kind'] == 'dir' && commit_date.nil?
-                            name = entry.elements['name'].text
+                            name = entry['name']['__content__']
                             entries << Entry.new({:name => URI.unescape(name),
                                         :path => ((path.empty? ? "" : "#{path}/") + name),
-                                        :kind => entry.attributes['kind'],
+                                        :kind => entry['kind'],
-                                        :size => ((s = entry.elements['size']) ? s.text.to_i : nil),
+                                        :size => ((s = entry['size']) ? s['__content__'].to_i : nil),
                                         :lastrev => Revision.new({
-                                          :identifier => commit.attributes['revision'],
+                                          :identifier => commit['revision'],
-                                          :time => Time.parse(commit_date.text).localtime,
+                                          :time => Time.parse(commit_date['__content__'].to_s).localtime,
-                                          :author => ((a = commit.elements['author']) ? a.text : nil)
+                                          :author => ((a = commit['author']) ? a['__content__'] : nil)
                                           })
                                         })
                           end
                       shellout(cmd) do |io|
                         output = io.read
                         begin
-                          doc = REXML::Document.new(output)
+                          doc = ActiveSupport::XmlMini.parse(output)
-                          doc.elements.each("properties/target/property") do |property|
+                          each_xml_element(doc['properties']['target'], 'property') do |property|
-                            properties[ property.attributes['name'] ] = property.text
+                            properties[ property['name'] ] = property['__content__'].to_s
                           end
                         rescue
                         end
                       cmd << " --limit #{options[:limit].to_i}" if options[:limit]
                       cmd << ' ' + target(URI.escape(path))
                       shellout(cmd) do |io|
+                        output = io.read
                         begin
-                          doc = REXML::Document.new(io)
+                          doc = ActiveSupport::XmlMini.parse(output)
-                          doc.elements.each("log/logentry") do |logentry|
+                          each_xml_element(doc['log'], 'logentry') do |logentry|
                             paths = []
-                            logentry.elements.each("paths/path") do |path|
+                            each_xml_element(logentry['paths'], 'path') do |path|
-                              paths << {:action => path.attributes['action'],
+                              paths << {:action => path['action'],
-                                        :path => path.text,
+                                        :path => path['__content__'],
-                                        :from_path => path.attributes['copyfrom-path'],
+                                        :from_path => path['copyfrom-path'],
-                                        :from_revision => path.attributes['copyfrom-rev']
+                                        :from_revision => path['copyfrom-rev']
                                         }
-                            end
+                            end if logentry['paths'] && logentry['paths']['path']
                             paths.sort! { |x,y| x[:path] <=> y[:path] }
-                            revisions << Revision.new({:identifier => logentry.attributes['revision'],
+                            revisions << Revision.new({:identifier => logentry['revision'],
-                                          :author => (logentry.elements['author'] ? logentry.elements['author'].text : ""),
+                                          :author => (logentry['author'] ? logentry['author']['__content__'] : ""),
-                                          :time => Time.parse(logentry.elements['date'].text).localtime,
+                                          :time => Time.parse(logentry['date']['__content__'].to_s).localtime,
-                                          :message => logentry.elements['msg'].text,
+                                          :message => logentry['msg']['__content__'],
                                           :paths => paths
                                         })
                           end
                       str << " --no-auth-cache --non-interactive"
                       str
                     end
+                    # Helper that iterates over the child elements of a xml node
+                    # MiniXml returns a hash when a single child is found or an array of hashes for multiple children
+                    def each_xml_element(node, name)
+                      if node && node[name]
+                        if node[name].is_a?(Hash)
+                          yield node[name]
+                        else
+                          node[name].each do |element|
+                            yield element
+                          end
+                        end
+                      end
+                    end
                   end
                 end
               end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages