initial commit of scm support:

* svn browsing
* diff viewing

git-svn-id: http://redmine.rubyforge.org/svn/branches/work@102 e93f8b46-1217-0410-a6f0-8f06a7374b81

scm/app/models/project.rb

@@ -25,12 +25,14 @@ class Project < ActiveRecord::Base
   has_many :documents, :dependent => true
   has_many :news, :dependent => true, :include => :author
   has_many :issue_categories, :dependent => true, :order => "issue_categories.name"
+  has_one :repository, :dependent => true
   has_and_belongs_to_many :custom_fields, :class_name => 'IssueCustomField', :join_table => 'custom_fields_projects', :association_foreign_key => 'custom_field_id'
   acts_as_tree :order => "name", :counter_cache => true
 
   validates_presence_of :name, :description
   validates_uniqueness_of :name
   validates_associated :custom_values, :on => :update
+  validates_associated :repository
   validates_format_of :name, :with => /^[\w\s\'\-]*$/i
 
   # returns 5 last created projects

scm/app/models/repository.rb

@@ -0,0 +1,11 @@
+class Repository < ActiveRecord::Base
+  belongs_to :project
+  validates_presence_of :url
+  validates_format_of :url, :with => /^(http|https|svn):\/\/.+/i
+  
+  @scm = nil
+    
+  def scm
+    @scm ||= SvnRepos::Base.new url
+  end
+end

scm/app/models/svn_repos.rb

@@ -0,0 +1,184 @@
+require 'rexml/document'
+
+module SvnRepos
+
+  class CommandFailed < StandardError #:nodoc:
+  end
+
+  class Base
+    @url = nil
+    @login = nil
+    @password = nil
+    
+    def initialize(url, login=nil, password=nil)
+      @url = url
+      @login = login if login && !login.empty?
+      @password = (password || "") if @login    
+    end
+    
+    # Returns the entry identified by path and revision identifier
+    # or nil if entry doesn't exist in the repository
+    def entry(path=nil, identifier=nil)
+      path ||= ''
+      identifier = 'HEAD' unless identifier and identifier > 0
+      entry = nil
+      cmd = "svn info --xml -r #{identifier} #{target(path)}"
+      IO.popen(cmd) do |io|
+        begin
+          doc = REXML::Document.new(io)
+          doc.elements.each("info/entry") do |info|
+            entry = Entry.new({:name => info.attributes['path'],
+                           :path => path,
+                           :kind => info.attributes['kind'],
+                           :lastrev => Revision.new({
+                             :identifier => info.elements['commit'].attributes['revision'],
+                             :author => info.elements['commit'].elements['author'].text,
+                             :time => Time.parse(info.elements['commit'].elements['date'].text)
+                             })
+                           })
+          end
+        rescue
+        end
+      end
+      return nil if $? && $?.exitstatus != 0
+      entry
+    rescue Errno::ENOENT
+      raise RepositoryCmdFailed
+    end
+    
+    # Returns an Entries collection
+    # or nil if the given path doesn't exist in the repository
+    def entries(path=nil, identifier=nil)
+      path ||= ''
+      identifier = 'HEAD' unless identifier and identifier > 0
+      entries = Entries.new
+      cmd = "svn list --xml -r #{identifier} #{target(path)}"
+      IO.popen(cmd) do |io|
+        begin
+          doc = REXML::Document.new(io)
+          doc.elements.each("lists/list/entry") do |entry|
+            entries << Entry.new({:name => entry.elements['name'].text,
+                        :path => ((path.empty? ? "" : "#{path}/") + entry.elements['name'].text),
+                        :kind => entry.attributes['kind'],
+                        :size => (entry.elements['size'] and entry.elements['size'].text).to_i,
+                        :lastrev => Revision.new({
+                          :identifier => entry.elements['commit'].attributes['revision'],
+                          :time => Time.parse(entry.elements['commit'].elements['date'].text),
+                          :author => entry.elements['commit'].elements['author'].text
+                          })
+                        })
+          end
+        rescue
+        end
+      end
+      return nil if $? && $?.exitstatus != 0
+      entries.sort_by_name
+    rescue Errno::ENOENT => e
+      raise CommandFailed
+    end
+
+    def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})
+      path ||= ''
+      identifier_from = 'HEAD' unless identifier_from and identifier_from.to_i > 0
+      identifier_to = 1 unless identifier_to and identifier_to.to_i > 0
+      revisions = []
+      cmd = "svn log --xml -r #{identifier_from}:#{identifier_to} "
+      cmd << "--verbose " if  options[:with_paths]
+      cmd << target(path)
+      IO.popen(cmd) do |io|
+        begin
+          doc = REXML::Document.new(io)
+          doc.elements.each("log/logentry") do |logentry|
+            paths = []
+            logentry.elements.each("paths/path") do |path|
+              paths << {:action => path.attributes['action'],
+                        :path => path.text
+                        }
+            end
+            revisions << Revision.new({:identifier => logentry.attributes['revision'],
+                          :author => logentry.elements['author'].text,
+                          :time => Time.parse(logentry.elements['date'].text),
+                          :message => logentry.elements['msg'].text,
+                          :paths => paths
+                        })
+          end
+        rescue
+        end
+      end
+      return nil if $? && $?.exitstatus != 0
+      revisions
+    rescue Errno::ENOENT => e
+      raise CommandFailed    
+    end
+    
+    def diff(path, identifier_from, identifier_to=nil)
+      path ||= ''
+      if identifier_to and identifier_to.to_i > 0
+        identifier_to = identifier_to.to_i 
+      else
+        identifier_to = identifier_from.to_i - 1
+      end
+      cmd = "svn diff -r "
+      cmd << "#{identifier_to}:"
+      cmd << "#{identifier_from}"
+      cmd << target(path)
+      diff = []
+      IO.popen(cmd) do |io|
+        io.each_line do |line|
+          diff << line
+        end
+      end
+      return nil if $? && $?.exitstatus != 0
+      diff
+    rescue Errno::ENOENT => e
+      raise CommandFailed    
+    end
+  
+  private
+    def target(path)
+      " \"" << "#{@url}/#{path}".gsub(/["'<>]/, '') << "\""
+    end
+  end
+  
+  class Entries < Array
+    def sort_by_name
+      sort {|x,y| 
+        if x.kind == y.kind
+          x.name <=> y.name
+        else
+          x.kind <=> y.kind
+        end
+      }   
+    end
+  end
+  
+  class Entry
+    attr_accessor :name, :path, :kind, :size, :lastrev
+    def initialize(attributes={})
+      self.name = attributes[:name] if attributes[:name]
+      self.path = attributes[:path] if attributes[:path]
+      self.kind = attributes[:kind] if attributes[:kind]
+      self.size = attributes[:size].to_i if attributes[:size]
+      self.lastrev = attributes[:lastrev]
+    end
+    
+    def is_file?
+      'file' == self.kind
+    end
+    
+    def is_dir?
+      'dir' == self.kind
+    end
+  end
+  
+  class Revision
+    attr_accessor :identifier, :author, :time, :message, :paths
+    def initialize(attributes={})
+      self.identifier = attributes[:identifier]
+      self.author = attributes[:author]
+      self.time = attributes[:time]
+      self.message = attributes[:message] || ""
+      self.paths = attributes[:paths]
+    end
+  end
+end