jro_apps/redmine Commit - r4855:026c9e87c064

scm: add scm specific human_attribute_name for input validation....

Toshi MARUYAMA -

r4855:026c9e87c064

parent child

Context file:

r4855:026c9e87c064

Collapse all files

app/models/repository/bazaar.rb +7 0

             # redMine - project management software
             # Copyright (C) 2006-2007  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
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'redmine/scm/adapters/bazaar_adapter'
             class Repository::Bazaar < Repository
               attr_protected :root_url
               validates_presence_of :url
+              ATTRIBUTE_KEY_NAMES = {
+                  "url"          => "Root directory",
+                }
+              def self.human_attribute_name(attribute_key_name)
+                ATTRIBUTE_KEY_NAMES[attribute_key_name] || super
+              end
               def self.scm_adapter_class
                 Redmine::Scm::Adapters::BazaarAdapter
               end
               def self.scm_name
                 'Bazaar'
               end
               def entries(path=nil, identifier=nil)
                 entries = scm.entries(path, identifier)
                 if entries
                   entries.each do |e|
                     next if e.lastrev.revision.blank?
                     # Set the filesize unless browsing a specific revision
                     if identifier.nil? && e.is_file?
                       full_path = File.join(root_url, e.path)
                       e.size = File.stat(full_path).size if File.file?(full_path)
                     end
                     c = Change.find(:first,
                                     :include => :changeset,
                                     :conditions => ["#{Change.table_name}.revision = ? and #{Changeset.table_name}.repository_id = ?", e.lastrev.revision, id],
                                     :order => "#{Changeset.table_name}.revision DESC")
                     if c
                       e.lastrev.identifier = c.changeset.revision
                       e.lastrev.name = c.changeset.revision
                       e.lastrev.author = c.changeset.committer
                     end
                   end
                 end
               end
               def fetch_changesets
                 scm_info = scm.info
                 if scm_info
                   # latest revision found in database
                   db_revision = latest_changeset ? latest_changeset.revision.to_i : 0
                   # latest revision in the repository
                   scm_revision = scm_info.lastrev.identifier.to_i
                   if db_revision < scm_revision
                     logger.debug "Fetching changesets for repository #{url}" if logger && logger.debug?
                     identifier_from = db_revision + 1
                     while (identifier_from <= scm_revision)
                       # loads changesets by batches of 200
                       identifier_to = [identifier_from + 199, scm_revision].min
                       revisions = scm.revisions('', identifier_to, identifier_from, :with_paths => true)
                       transaction do
                         revisions.reverse_each do |revision|
                           changeset = Changeset.create(:repository => self,
                                                        :revision => revision.identifier,
                                                        :committer => revision.author,
                                                        :committed_on => revision.time,
                                                        :scmid => revision.scmid,
                                                        :comments => revision.message)
                           revision.paths.each do |change|
                             Change.create(:changeset => changeset,
                                           :action => change[:action],
                                           :path => change[:path],
                                           :revision => change[:revision])
                           end
                         end
                       end unless revisions.nil?
                       identifier_from = identifier_to + 1
                     end
                   end
                 end
               end
             end

app/models/repository/cvs.rb +8 0

             # redMine - project management software
             # Copyright (C) 2006-2007  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
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'redmine/scm/adapters/cvs_adapter'
             require 'digest/sha1'
             class Repository::Cvs < Repository
               validates_presence_of :url, :root_url
+              ATTRIBUTE_KEY_NAMES = {
+                  "url"          => "CVSROOT",
+                  "root_url"     => "Module",
+                }
+              def self.human_attribute_name(attribute_key_name)
+                ATTRIBUTE_KEY_NAMES[attribute_key_name] || super
+              end
               def self.scm_adapter_class
                 Redmine::Scm::Adapters::CvsAdapter
               end
               def self.scm_name
                 'CVS'
               end
               def entry(path=nil, identifier=nil)
                 rev = identifier.nil? ? nil : changesets.find_by_revision(identifier)
                 scm.entry(path, rev.nil? ? nil : rev.committed_on)
               end
               def entries(path=nil, identifier=nil)
                 rev = identifier.nil? ? nil : changesets.find_by_revision(identifier)
                 entries = scm.entries(path, rev.nil? ? nil : rev.committed_on)
                 if entries
                   entries.each() do |entry|
                     unless entry.lastrev.nil? || entry.lastrev.identifier
                       change=changes.find_by_revision_and_path( entry.lastrev.revision, scm.with_leading_slash(entry.path) )
                       if change
                         entry.lastrev.identifier=change.changeset.revision
                         entry.lastrev.author=change.changeset.committer
                         entry.lastrev.revision=change.revision
                         entry.lastrev.branch=change.branch
                       end
                     end
                   end
                 end
                 entries
               end
               def cat(path, identifier=nil)
                 rev = identifier.nil? ? nil : changesets.find_by_revision(identifier)
                 scm.cat(path, rev.nil? ? nil : rev.committed_on)
               end
               def diff(path, rev, rev_to)
                 #convert rev to revision. CVS can't handle changesets here
                 diff=[]
                 changeset_from=changesets.find_by_revision(rev)
                 if rev_to.to_i > 0
                   changeset_to=changesets.find_by_revision(rev_to)
                 end
                 changeset_from.changes.each() do |change_from|
                   revision_from=nil
                   revision_to=nil
                   revision_from=change_from.revision if path.nil? || (change_from.path.starts_with? scm.with_leading_slash(path))
                   if revision_from
                     if changeset_to
                       changeset_to.changes.each() do |change_to|
                         revision_to=change_to.revision if change_to.path==change_from.path
                       end
                     end
                     unless revision_to
                       revision_to=scm.get_previous_revision(revision_from)
                     end
                     file_diff = scm.diff(change_from.path, revision_from, revision_to)
                     diff = diff + file_diff unless file_diff.nil?
                   end
                 end
                 return diff
               end
               def fetch_changesets
                 # some nifty bits to introduce a commit-id with cvs
                 # natively cvs doesn't provide any kind of changesets, there is only a revision per file.
                 # we now take a guess using the author, the commitlog and the commit-date.
                 # last one is the next step to take. the commit-date is not equal for all
                 # commits in one changeset. cvs update the commit-date when the *,v file was touched. so
                 # we use a small delta here, to merge all changes belonging to _one_ changeset
                 time_delta=10.seconds
                 fetch_since = latest_changeset ? latest_changeset.committed_on : nil
                 transaction do
                   tmp_rev_num = 1
                   scm.revisions('', fetch_since, nil, :with_paths => true) do |revision|
                     # only add the change to the database, if it doen't exists. the cvs log
                     # is not exclusive at all.
                     tmp_time = revision.time.clone
                     unless changes.find_by_path_and_revision(
             	           scm.with_leading_slash(revision.paths[0][:path]), revision.paths[0][:revision])
                       cmt = Changeset.normalize_comments(revision.message, repo_log_encoding)
                       cs = changesets.find(:first, :conditions=>{
                         :committed_on=>tmp_time - time_delta .. tmp_time + time_delta,
                         :committer=>revision.author,
                         :comments=>cmt
                       })
                       # create a new changeset....
                       unless cs
                         # we use a temporaray revision number here (just for inserting)
                         # later on, we calculate a continous positive number
                         tmp_time2 = tmp_time.clone.gmtime
                         branch = revision.paths[0][:branch]
                         scmid = branch + "-" + tmp_time2.strftime("%Y%m%d-%H%M%S")
                         cs = Changeset.create(:repository => self,
                                               :revision => "tmp#{tmp_rev_num}",
                                               :scmid => scmid,
                                               :committer => revision.author,
                                               :committed_on => tmp_time,
                                               :comments => revision.message)
                         tmp_rev_num += 1
                       end
                       #convert CVS-File-States to internal Action-abbrevations
                       #default action is (M)odified
                       action="M"
                       if revision.paths[0][:action]=="Exp" && revision.paths[0][:revision]=="1.1"
                         action="A" #add-action always at first revision (= 1.1)
                       elsif revision.paths[0][:action]=="dead"
                         action="D" #dead-state is similar to Delete
                       end
                       Change.create(:changeset => cs,
                       :action => action,
                       :path => scm.with_leading_slash(revision.paths[0][:path]),
                       :revision => revision.paths[0][:revision],
                       :branch => revision.paths[0][:branch]
                       )
                     end
                   end
                   # Renumber new changesets in chronological order
                   changesets.find(
                           :all, :order => 'committed_on ASC, id ASC', :conditions => "revision LIKE 'tmp%'"
                        ).each do |changeset|
                     changeset.update_attribute :revision, next_revision_number
                   end
                 end # transaction
                 @current_revision_number = nil
               end
               private
               # Returns the next revision number to assign to a CVS changeset
               def next_revision_number
                 # Need to retrieve existing revision numbers to sort them as integers
                 sql = "SELECT revision FROM #{Changeset.table_name} "
                 sql << "WHERE repository_id = #{id} AND revision NOT LIKE 'tmp%'"
                 @current_revision_number ||= (connection.select_values(sql).collect(&:to_i).max || 0)
                 @current_revision_number += 1
               end
             end

app/models/repository/darcs.rb +7 0

             # redMine - project management software
             # Copyright (C) 2006-2007  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
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'redmine/scm/adapters/darcs_adapter'
             class Repository::Darcs < Repository
               validates_presence_of :url
+              ATTRIBUTE_KEY_NAMES = {
+                  "url"          => "Root directory",
+                }
+              def self.human_attribute_name(attribute_key_name)
+                ATTRIBUTE_KEY_NAMES[attribute_key_name] || super
+              end
               def self.scm_adapter_class
                 Redmine::Scm::Adapters::DarcsAdapter
               end
               def self.scm_name
                 'Darcs'
               end
               def entry(path=nil, identifier=nil)
                 patch = identifier.nil? ? nil : changesets.find_by_revision(identifier)
                 scm.entry(path, patch.nil? ? nil : patch.scmid)
               end
               def entries(path=nil, identifier=nil)
                 patch = identifier.nil? ? nil : changesets.find_by_revision(identifier)
                 entries = scm.entries(path, patch.nil? ? nil : patch.scmid)
                 if entries
                   entries.each do |entry|
                     # Search the DB for the entry's last change
                     changeset = changesets.find_by_scmid(entry.lastrev.scmid) if entry.lastrev && !entry.lastrev.scmid.blank?
                     if changeset
                       entry.lastrev.identifier = changeset.revision
                       entry.lastrev.name = changeset.revision
                       entry.lastrev.time = changeset.committed_on
                       entry.lastrev.author = changeset.committer
                     end
                   end
                 end
                 entries
               end
               def cat(path, identifier=nil)
                 patch = identifier.nil? ? nil : changesets.find_by_revision(identifier.to_s)
                 scm.cat(path, patch.nil? ? nil : patch.scmid)
               end
               def diff(path, rev, rev_to)
                 patch_from = changesets.find_by_revision(rev)
                 return nil if patch_from.nil?
                 patch_to = changesets.find_by_revision(rev_to) if rev_to
                 if path.blank?
                   path = patch_from.changes.collect{|change| change.path}.join(' ')
                 end
                 patch_from ? scm.diff(path, patch_from.scmid, patch_to ? patch_to.scmid : nil) : nil
               end
               def fetch_changesets
                 scm_info = scm.info
                 if scm_info
                   db_last_id = latest_changeset ? latest_changeset.scmid : nil
                   next_rev = latest_changeset ? latest_changeset.revision.to_i + 1 : 1
                   # latest revision in the repository
                   scm_revision = scm_info.lastrev.scmid
                   unless changesets.find_by_scmid(scm_revision)
                     revisions = scm.revisions('', db_last_id, nil, :with_path => true)
                     transaction do
                       revisions.reverse_each do |revision|
                         changeset = Changeset.create(:repository => self,
                                                      :revision => next_rev,
                                                      :scmid => revision.scmid,
                                                      :committer => revision.author,
                                                      :committed_on => revision.time,
                                                      :comments => revision.message)
                         revision.paths.each do |change|
                           changeset.create_change(change)
                         end
                         next_rev += 1
                       end if revisions
                     end
                   end
                 end
               end
             end

app/models/repository/filesystem.rb +7 0

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # FileSystem adapter
             # File written by Paul Rivier, at Demotera.
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'redmine/scm/adapters/filesystem_adapter'
             class Repository::Filesystem < Repository
               attr_protected :root_url
               validates_presence_of :url
+              ATTRIBUTE_KEY_NAMES = {
+                  "url"          => "Root directory",
+                }
+              def self.human_attribute_name(attribute_key_name)
+                ATTRIBUTE_KEY_NAMES[attribute_key_name] || super
+              end
               def self.scm_adapter_class
                 Redmine::Scm::Adapters::FilesystemAdapter
               end
               def self.scm_name
                 'Filesystem'
               end
               def entries(path=nil, identifier=nil)
                 scm.entries(path, identifier)
               end
               def fetch_changesets
                 nil
               end
             end

app/models/repository/git.rb +7 0

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             # Copyright (C) 2007  Patrick Aljord patcito@ŋmail.com
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'redmine/scm/adapters/git_adapter'
             class Repository::Git < Repository
               attr_protected :root_url
               validates_presence_of :url
+              ATTRIBUTE_KEY_NAMES = {
+                  "url"          => "Path to repository",
+                }
+              def self.human_attribute_name(attribute_key_name)
+                ATTRIBUTE_KEY_NAMES[attribute_key_name] || super
+              end
               def self.scm_adapter_class
                 Redmine::Scm::Adapters::GitAdapter
               end
               def self.scm_name
                 'Git'
               end
               def repo_log_encoding
                 'UTF-8'
               end
               # Returns the identifier for the given git changeset
               def self.changeset_identifier(changeset)
                 changeset.scmid
               end
               # Returns the readable identifier for the given git changeset
               def self.format_changeset_identifier(changeset)
                 changeset.revision[0, 8]
               end
               def branches
                 scm.branches
               end
               def tags
                 scm.tags
               end
               def find_changeset_by_name(name)
                 return nil if name.nil? || name.empty?
                 e = changesets.find(:first, :conditions => ['revision = ?', name.to_s])
                 return e if e
                 changesets.find(:first, :conditions => ['scmid LIKE ?', "#{name}%"])
               end
               # With SCM's that have a sequential commit numbering, redmine is able to be
               # clever and only fetch changesets going forward from the most recent one
               # it knows about.  However, with git, you never know if people have merged
               # commits into the middle of the repository history, so we should parse
               # the entire log. Since it's way too slow for large repositories, we only
               # parse 1 week before the last known commit.
               # The repository can still be fully reloaded by calling #clear_changesets
               # before fetching changesets (eg. for offline resync)
               def fetch_changesets
                 c = changesets.find(:first, :order => 'committed_on DESC')
                 since = (c ? c.committed_on - 7.days : nil)
                 revisions = scm.revisions('', nil, nil, :all => true, :since => since)
                 return if revisions.nil? || revisions.empty?
                 recent_changesets = changesets.find(:all, :conditions => ['committed_on >= ?', since])
                 # Clean out revisions that are no longer in git
                 recent_changesets.each {|c| c.destroy unless revisions.detect {|r| r.scmid.to_s == c.scmid.to_s }}
                 # Subtract revisions that redmine already knows about
                 recent_revisions = recent_changesets.map{|c| c.scmid}
                 revisions.reject!{|r| recent_revisions.include?(r.scmid)}
                 # Save the remaining ones to the database
                 unless revisions.nil?
                   revisions.each do |rev|
                     transaction do
                       changeset = Changeset.new(
                           :repository => self,
                           :revision   => rev.identifier,
                           :scmid      => rev.scmid,
                           :committer  => rev.author,
                           :committed_on => rev.time,
                           :comments   => rev.message)
                       if changeset.save
                         rev.paths.each do |file|
                           Change.create(
                               :changeset => changeset,
                               :action    => file[:action],
                               :path      => file[:path])
                         end
                       end
                     end
                   end
                 end
               end
               def latest_changesets(path,rev,limit=10)
                 revisions = scm.revisions(path, nil, rev, :limit => limit, :all => false)
                 return [] if revisions.nil? || revisions.empty?
                 changesets.find(
                   :all,
                   :conditions => [
                     "scmid IN (?)",
                     revisions.map!{|c| c.scmid}
                   ],
                   :order => 'committed_on DESC'
                 )
               end
             end

app/models/repository/mercurial.rb +7 0

             # redMine - project management software
             # Copyright (C) 2006-2007  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
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'redmine/scm/adapters/mercurial_adapter'
             class Repository::Mercurial < Repository
               # sort changesets by revision number
               has_many :changesets, :order => "#{Changeset.table_name}.id DESC", :foreign_key => 'repository_id'
               attr_protected :root_url
               validates_presence_of :url
               FETCH_AT_ONCE = 100  # number of changesets to fetch at once
+              ATTRIBUTE_KEY_NAMES = {
+                  "url"          => "Root directory",
+                }
+              def self.human_attribute_name(attribute_key_name)
+                ATTRIBUTE_KEY_NAMES[attribute_key_name] || super
+              end
               def self.scm_adapter_class
                 Redmine::Scm::Adapters::MercurialAdapter
               end
               def self.scm_name
                 'Mercurial'
               end
               def repo_log_encoding
                 'UTF-8'
               end
               # Returns the readable identifier for the given mercurial changeset
               def self.format_changeset_identifier(changeset)
                 "#{changeset.revision}:#{changeset.scmid}"
               end
               # Returns the identifier for the given Mercurial changeset
               def self.changeset_identifier(changeset)
                 changeset.scmid
               end
               def branches
                 nil
               end
               def tags
                 nil
               end
               def diff_format_revisions(cs, cs_to, sep=':')
                 super(cs, cs_to, ' ')
               end
               # Finds and returns a revision with a number or the beginning of a hash
               def find_changeset_by_name(name)
                 return nil if name.nil? || name.empty?
                 if /[^\d]/ =~ name or name.to_s.size > 8
                   e = changesets.find(:first, :conditions => ['scmid = ?', name.to_s])
                 else
                   e = changesets.find(:first, :conditions => ['revision = ?', name.to_s])
                 end
                 return e if e
                 changesets.find(:first, :conditions => ['scmid LIKE ?', "#{name}%"])  # last ditch
               end
               # Returns the latest changesets for +path+; sorted by revision number
               # Default behavior is to search in cached changesets
               def latest_changesets(path, rev, limit=10)
                 if path.blank?
                   changesets.find(:all, :include => :user, :limit => limit)
                 else
                   changesets.find(:all, :select => "DISTINCT #{Changeset.table_name}.*",
                                   :joins => :changes,
                                   :conditions => ["#{Change.table_name}.path = ? OR #{Change.table_name}.path LIKE ? ESCAPE ?",
                                                   path.with_leading_slash,
                                                   "#{path.with_leading_slash.gsub(/[%_\\]/) { |s| "\\#{s}" }}/%", '\\'],
                                   :include => :user, :limit => limit)
                 end
               end
               def fetch_changesets
                 scm_rev = scm.info.lastrev.revision.to_i
                 db_rev = latest_changeset ? latest_changeset.revision.to_i : -1
                 return unless db_rev < scm_rev  # already up-to-date
                 logger.debug "Fetching changesets for repository #{url}" if logger
                 (db_rev + 1).step(scm_rev, FETCH_AT_ONCE) do |i|
                   transaction do
                     scm.each_revision('', i, [i + FETCH_AT_ONCE - 1, scm_rev].min) do |re|
                       cs = Changeset.create(:repository => self,
                                             :revision => re.revision,
                                             :scmid => re.scmid,
                                             :committer => re.author,
                                             :committed_on => re.time,
                                             :comments => re.message)
                       re.paths.each { |e| cs.create_change(e) }
                     end
                   end
                 end
                 self
               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