0004-Redmine-management-of-Git-repositories.patch - Redmine

         @blocks = @user.pref[:my_page_layout] || DEFAULT_LAYOUT
       end
       def remove_key
         if params[:id]
           AuthorizedKeysEntry.remove_entry_by_key(params[:id])
           redirect_to :action => 'account'
         end
       end
       # Edit user's account
       def account
         @user = User.current
-...
           @user.mail_notification = (params[:notification_option] == 'all')
           @user.pref.attributes = params[:pref]
           @user.pref[:no_self_notified] = (params[:no_self_notified] == '1')
           if params[:new_key]
             begin
               key = AuthorizedKeysEntry.new(params[:new_key],@user.login)
               key.save
             rescue ArgumentError => e
               @user.errors.add('Key', e.message)
             end
           end
           if @user.save
             @user.pref.save
             @user.notified_project_ids = (params[:notification_option] == 'selected' ? params[:notified_project_ids] : [])

       end
       def git_field_tags(form, repository)
           content_tag('p', form.text_field(:url, :label => 'Path to .git directory', :size => 60, :required => true, :disabled => (repository && !repository.root_url.blank?)))
           if Setting.serve_git_repositories? and (repository == nil or repository.url.blank?)
               content_tag('p', form.text_field(:url, :value => GitManager.repositories_root + '/' + repository.project.identifier + '.git'), :label => 'Path to .git directory', :size => 60, :required => true)
           else
               content_tag('p', form.text_field(:url, :label => 'Path to .git directory', :size => 60, :required => true, :disabled => (repository && !repository.root_url.blank?)))
           end
       end
       def cvs_field_tags(form, repository)

     require "strscan"
     class AuthorizedKeysEntry
       COMMENT=/^#/
       BLANK=/^\s+$/
       KEY_TYPES=['ssh-1','ssh-dss','ssh-rsa']
       # For ssh1 keys bits and exponent parts go into @key(key content) variable
       PARSERS = {'ssh-1' => /^(?:(.+) )?(\d+ \d+ [^ ]+)(?: (.+))$/,
                'ssh-dss' => /^(?:(.+) )?ssh-dss ([^ ]+)(?: (.+))$/,
                'ssh-rsa' => /^(?:(.+) )?ssh-rsa ([^ ]+)(?: (.+))$/}
       KEY_DISPLAYNAMES={'ssh-1' => '', 'ssh-dss' => 'ssh-dss ', 'ssh-rsa' => 'ssh-rsa ' }
       KEY_FORMAT=/\A[\w\/\+\=]+\z/
       IDENTIFIER_FORMAT=/\A[\w@\.\-]+\z/
       @@authorized_keys_filename="~/.ssh/authorized_keys"
       attr_reader :identifier, :key, :key_type
       attr_accessor :options
       # Create object from string from authorized_keys
       def initialize(authorized_keys_string = nil,identifier = nil)
         @identifier = identifier if identifier
         @key = ''
         @options = []
         create_from_authorized_keys(authorized_keys_string) if authorized_keys_string != nil
       end
       def self.authorized_keys_filename=(filename)
         @@authorized_keys_filename=filename
       end
       def self.authorized_keys_filename
         @@authorized_keys_filename
       end
       def save
         @options = GitManager::get_authorized_keys_options_for_login(identifier)
         AuthorizedKeysEntry.add_entry(self)
       end
       def self.find_by_identifier(identifier)
         result = Array.new
         read_entries.each do |entry|
           result << entry if entry.identifier == identifier
         end
         return result
       end
       def to_s
         s = ""
         s += @options.join(",") + " " unless @options.empty?
         s += KEY_DISPLAYNAMES[@key_type] + @key
         s += " " + @identifier if @identifier
         return s
       end
       def self.remove_entry_by_key(key)
         entries = self.read_entries
         entries = entries.delete_if { |e| e.key[0,40] == key[0,40] }
         self.save_entries(entries)
       end
       def self.add_entry(entry)
         entries = self.read_entries
         entries << entry
         self.save_entries(entries)
       end
       private
       def get_key_type(line)
         KEY_TYPES.each do |k|
           return k if PARSERS[k].match(line)
         end
         return nil
       end
       def create_from_authorized_keys(line)
         @key_type = get_key_type(line)
         raise ArgumentError, "Invalid format of authorized_keys entry " + line if @key_type == nil
         m = PARSERS[@key_type].match(line)
         @options, @key = m[1], m[2]
         @identifier = m[3] unless @identifier
         @options = AuthorizedKeysEntry.parse_options(@options)
       end
       def self.parse_options(options)
         result = []
         return result if options == nil
         scanner = StringScanner.new(options)
         while !scanner.eos?
           scanner.skip(/[ \t]*/)
           # scan a long option
           if out = scanner.scan(/[-a-z0-9A-Z_]+=\".*?\"/) or out = scanner.scan(/[-a-z0-9A-Z_]+/)
             result << out
           else
             # found an unscannable token, let's abort
             break
           end
           # eat a comma
           scanner.skip(/[\t]*,[\t]*/)
         end
         return result
       end
       # Reads all entries from a file
       def self.read_entries
         entries = Array.new
         filename = File.expand_path(@@authorized_keys_filename)
         if !File.exists?(filename)
           return entries
         end
         File.open(filename) do |file|
           file.flock(File::LOCK_SH)
           begin
             file.each_line do |line|
               next if COMMENT.match(line) or BLANK.match(line)
               entries << AuthorizedKeysEntry.new(line)
             end
           ensure
             file.flock(File::LOCK_UN)
           end
         end
         entries
       end
       # Saves all entries to a file
       def self.save_entries(entries)
         filename = File.expand_path(@@authorized_keys_filename)
         FileUtils.mkdir_p(File.dirname(filename))
         File.open(filename, "w") do |write_file|
           write_file.flock(File::LOCK_EX)
           entries.each do |entry|
             write_file << entry.to_s + "\n"
           end
           write_file.flock(File::LOCK_UN)
         end
       end
     end

         scan_comment_for_issue_ids
       end
       require 'pp'
       def scan_comment_for_issue_ids
         return if comments.blank?
       # returns issue ids found in message
       # three arrays are returned, references issues, fixed ones and wrong numbers (not Issues)
       def self.find_issue_ids(message, project)
         return [[],[]] if message.blank?
         # keywords used to reference issues
         ref_keywords = Setting.commit_ref_keywords.downcase.split(",").collect(&:strip)
         # keywords used to fix issues
         fix_keywords = Setting.commit_fix_keywords.downcase.split(",").collect(&:strip)
         # status and optional done ratio applied
         fix_status = IssueStatus.find_by_id(Setting.commit_fix_status_id)
         done_ratio = Setting.commit_fix_done_ratio.blank? ? nil : Setting.commit_fix_done_ratio.to_i
         kw_regexp = (ref_keywords + fix_keywords).collect{|kw| Regexp.escape(kw)}.join("|")
         return if kw_regexp.blank?
         return [[],[]] if kw_regexp.blank?
         referenced_issues = []
         fixed_issues = []
         wrong_issue_ids = []
         if ref_keywords.delete('*')
           # find any issue ID in the comments
           target_issue_ids = []
           comments.scan(%r{([\s\(,-]|^)#(\d+)(?=[[:punct:]]|\s|<|$)}).each { |m| target_issue_ids << m[1] }
           referenced_issues += repository.project.issues.find_all_by_id(target_issue_ids)
           message.scan(%r{([\s\(,-]|^)#(\d+)(?=[[:punct:]]|\s|<|$)}).each { |m| target_issue_ids << m[1] }
           found_issues = project.issues.find_all_by_id(target_issue_ids)
           referenced_issues += found_issues
           found_issues.each { |issue| target_issue_ids.delete(issue.id.to_s) }
           wrong_issue_ids += target_issue_ids
         end
         comments.scan(Regexp.new("(#{kw_regexp})[\s:]+(([\s,;&]*#?\\d+)+)", Regexp::IGNORECASE)).each do |match|
         message.scan(Regexp.new("(#{kw_regexp})[\s:]+(([\s,;&]*#?\\d+)+)", Regexp::IGNORECASE)).each do |match|
           action = match[0]
           target_issue_ids = match[1].scan(/\d+/)
           target_issues = repository.project.issues.find_all_by_id(target_issue_ids)
           if fix_status && fix_keywords.include?(action.downcase)
             # update status of issues
             logger.debug "Issues fixed by changeset #{self.revision}: #{issue_ids.join(', ')}." if logger && logger.debug?
             target_issues.each do |issue|
               # the issue may have been updated by the closure of another one (eg. duplicate)
               issue.reload
               # don't change the status is the issue is closed
               next if issue.status.is_closed?
               csettext = "r#{self.revision}"
               if self.scmid && (! (csettext =~ /^r[0-9]+$/))
                 csettext = "commit:\"#{self.scmid}\""
               end
               journal = issue.init_journal(user || User.anonymous, l(:text_status_changed_by_changeset, csettext))
               issue.status = fix_status
               issue.done_ratio = done_ratio if done_ratio
               issue.save
               Mailer.deliver_issue_edit(journal) if Setting.notified_events.include?('issue_updated')
             end
           target_issues = project.issues.find_all_by_id(target_issue_ids)
           target_issues.each { |issue| target_issue_ids.delete(issue.id.to_s) }
           wrong_issue_ids += target_issue_ids
           if fix_keywords.include?(action.downcase)
             fixed_issues += target_issues
           else
             referenced_issues += target_issues
           end
           referenced_issues += target_issues
         end
         self.issues = referenced_issues.uniq
         return [referenced_issues.uniq, fixed_issues.uniq, wrong_issue_ids.uniq]
       end
       def scan_comment_for_issue_ids
         return if comments.blank?
         # status and optional done ratio applied
         fix_status = IssueStatus.find_by_id(Setting.commit_fix_status_id)
         done_ratio = Setting.commit_fix_done_ratio.blank? ? nil : Setting.commit_fix_done_ratio.to_i
         referenced_issues, fixed_issues, wrong_issues = Changeset.find_issue_ids(comments, repository.project)
         # update status of issues
         logger.debug "Issues fixed by changeset #{self.revision}: #{issue_ids.join(', ')}." if logger && logger.debug?
         fixed_issues.each do |issue|
           # the issue may have been updated by the closure of another one (eg. duplicate)
           issue.reload
           # don't change the status is the issue is closed
           next if issue.status.is_closed?
           csettext = "r#{self.revision}"
           if self.scmid && (! (csettext =~ /^r[0-9]+$/))
             csettext = "commit:\"#{self.scmid}\""
           end
           journal = issue.init_journal(user || User.anonymous, l(:text_status_changed_by_changeset, csettext))
           issue.status = fix_status
           issue.done_ratio = done_ratio if done_ratio
           issue.save
           Mailer.deliver_issue_edit(journal) if Setting.notified_events.include?('issue_updated')
         end
         self.issues = (referenced_issues + fixed_issues).uniq
       end
       # Returns the previous changeset

     class GitChecks::Committer < GitManager::CommitCheck
       def self.check(revision, branch, user, role, project, git)
         # Check: committer name and email
         if revision.author != "#{user.name} <#{user.mail}>"
           return [ "Commit author name or email is wrong",
     	       "    Execute following commands and _recreate_ commit:",
                    "    git config --global user.name \"#{user.name}\"",
     	       "    git config --global user.email #{user.mail}",
+          ]
         end
         return []
       end
     end

     class GitChecks::DeleteBranch < GitManager::RefCheck
       def self.check(old_rev, new_rev, new_rev_type, branch, user, role, project, git)
         if new_rev_type == "delete"
           return "Deleting branch can be done only by repository manager"
         end
         return []
       end
     end

     class GitChecks::FastForward < GitManager::RefCheck
       def self.check(old_rev, new_rev, new_rev_type, branch, user, role, project, git)
         # Check: fast forward
         if old_rev != git.class::EMPTY_COMMIT and git.merge_base(old_rev, new_rev) != old_rev
           return "Only fast-forward commits are allowed"
         end
         return []
       end
     end

     class GitChecks::InitialCommit < GitManager::RefCheck
       def self.check(old_rev, new_rev, new_rev_type, branch, user, role, project, git)
         if old_rev == git.class::EMPTY_COMMIT and !role.allowed_to?(:manage_repository)
           return "Initial commit can be done only by repository manager"
         end
         return []
       end
     end

     class GitChecks::Issue < GitManager::CommitCheck
       def self.check(revision, branch, user, role, project, git)
         referenced_issues, fixes_issues, wrong_issues = Changeset.find_issue_ids(revision.message, project)
         issues = referenced_issues + fixes_issues
         errors = []
         if !wrong_issues.empty?
           errors << "Some issue numbers are wrong: #{wrong_issues.join(',')}"
         end
         issues.each do |issue_number|
           issue = Issue.find(issue_number)
           if issue.closed?
             errors << "Issue \##{issue.id} is closed. Reopen it and commit again"
           end
           if issue.assigned_to != user
             if issue.assigned_to != nil
               owner_info = "It belongs to #{issue.assigned_to.firstname} #{issue.assigned_to.lastname}"
             else
               owner_info = "It is unassigned"
             end
             errors << "Issue \##{issue.id} is not assigned to You. #{owner_info}"
           end
         end
         return errors
       end
     end

     require 'net/http'
     require 'uri'
     require 'redmine/scm/adapters/git_adapter'
     class GitManager
       COMMANDS_READONLY = [
         'git-upload-pack',
+      ]
       COMMANDS_WRITE = [
         'git-receive-pack',
+      ]
       # TODO: make configurable
       REPOSITORIES_ROOT='~/repositories/'
       REDMINE_LOGIN_ENV_NAME='REDMINE_LOGIN'
       def self.repositories_root
         return File.expand_path(REPOSITORIES_ROOT)
       end
       # Executed by SSH when somebody logs into Redmine's SSH account
       # using public key.
       # Restricts the user to access only Git repositories he is allowed to.
       def self.serve
         begin
           command = serve_get_original_command
           user = serve_get_user
           git_command, project_identifier = parse_git_command(command)
           project, repository = find_project_and_repo(project_identifier)
           role = user.role_for_project(project)
           if COMMANDS_READONLY.include?(git_command)
             if !role.allowed_to?(:view_changesets)
               raise "User #{user} (#{role.name}) is not allowed to read project #{project}\n"
             end
             if !repository.scm.info
               raise "Empty repository. Push some commit first"
             end
           elsif COMMANDS_WRITE.include?(git_command)
             if !role.allowed_to?(:commit_access)
               raise "User #{user} (#{role.name}) is not allowed to write to project #{project}\n"
             end
             if !repository.scm.info
               warn "Creating new repository.\n"
               repository.scm.init(project.description)
             end
           else
             raise "Unknown command '#{verb}'"
           end
         rescue
           warn "Error: #{$!}.\n"
           exit 1
         end
         ENV[REDMINE_LOGIN_ENV_NAME]=user.login
         exec 'git', 'shell', '-c', "#{git_command} '#{repository.url}'"
       end
       def self.get_authorized_keys_options_for_login(login)
         return [ 'command="ruby ' + RAILS_ROOT + '/script/runner GitManager.serve \'' + login + '\' -e ' + ENV["RAILS_ENV"] +
     	  '"', 'no-port-forwarding','no-X11-forwarding','no-agent-forwarding','no-pty' ]
       end
       private
       def self.serve_get_original_command
         command = ENV["SSH_ORIGINAL_COMMAND"]
         if command == nil or command==""
           raise "SSH_ORIGINAL_COMMAND not set. Use Git to access this account"
         end
         if command=~/\n/
           raise "Command contains new line character"
         end
         return command
       end
       def self.serve_get_user
         login = ARGV[0]
         if login == nil or login==""
           raise "Needs login as parameter"
         end
         user = User.find_by_login(login)
         if user == nil
           raise "User not found #{login}"
         end
         return user
       end
       def self.parse_git_command(command)
         verb, args = command.split(" ",2)
         if verb == 'git'
            subverb, args = args.split(" ",2)
            verb = "%s-%s" % [ verb, subverb ]
         end
         project_identifier = args.gsub("'","")
         return verb, project_identifier
       end
       def self.find_project_and_repo(project_identifier)
         project = Project.find_by_identifier(project_identifier)
         if project == nil
           raise "Project not found \"#{project_identifier}\""
         end
         repository = project.repository
         if repository == nil
           raise "Project #{project} does not have repository\n"
         end
         if repository.class != Repository::Git
           raise "Project #{project} has non git repository #{repository.type}"
         end
         return project, repository
       end
       public
       class RefCheck
         @@checks = []
         # Check Git ref, subclassess should override
         def check(old_rev, new_rev, new_rev_type, branch, user, role, project, git)
           return true
         end
         def self.inherited(subclass)
           @@checks << subclass
         end
         def self.get_checks
           return @@checks
         end
       end
       class CommitCheck
         @@checks = []
         # Check Git ref, subclassess should override
         def check(revision, branch, user, role, project, git)
           return true
         end
         def self.inherited(subclass)
           @@checks << subclass
         end
         def self.get_checks
           return @@checks
         end
       end
       def self.load_checks
         files = Dir.glob(RAILS_ROOT + "/app/models/git_checks/*.rb")
         files.each do |f|
           f.sub!(/\A#{RAILS_ROOT}/,'')
           f.split('/')[3..-1].join('/').split('.').first.camelize.constantize
         end
       end
       load_checks
       def self.check_commits
         login = ENV[REDMINE_LOGIN_ENV_NAME]
         if login == nil
           warn "Redmine: Local user, not running checks"
           exit 0
         end
         begin
           user = User.find_by_login(login)
           raise "User not found" if user == nil
           repository = Repository.find_by_url(Dir.getwd)
           raise "Repository not managed by Redmine" if repository == nil
           raise "Non git repository" if repository.class != Repository::Git
           project = repository.project
           role = user.role_for_project(project)
           git = repository.scm
           warn ""
           warn "-------------------------------------------------------------"
           warn "Redmine is checking your changes for correctness..."
           warn "Authenticated as #{user.name} (#{role.name} in #{project.name})"
           error_found = false
           warn "Changes:"
           STDIN.each_line do |line|
             old_rev, new_rev, branch = line.split(" ")
             if new_rev == git.class::EMPTY_COMMIT
               new_rev_type = "delete"
             else
               new_rev_type = git.get_object_type(new_rev)
             end
             revisions = nil
             if new_rev_type == "commit"
               revisions = git.revisions("", old_rev, new_rev)
             end
             warn "    Ref: #{branch} type: #{new_rev_type}"
     	errors = []
     	# TODO: make checks configurable
             RefCheck.get_checks.each do |check|
               result = check.check(old_rev, new_rev, new_rev_type, branch, user, role, project, git)
               if result.kind_of?(Array)
                 errors += result
     	  else
                 errors << result
               end
             end
             errors.each do |error|
               warn "            Error: #{error}"
             end
     	error_found = true if !errors.empty?
             if revisions != nil
     	  revisions.each do |revision|
     	    warn "        Commit: #{revision.identifier}"
     	    errors = []
                 CommitCheck.get_checks.each do |check|
                   result = check.check(revision, branch, user, role, project, git)
                   if result.kind_of?(Array)
                     errors += result
     	      else
                     errors << result
                   end
                 end
                 errors.each do |error|
                   warn "            Error: #{error}"
                 end
     	    error_found = true if !errors.empty?
               end
             end
           end
         end
         if error_found
           if !role.allowed_to?(:manage_repository)
             warn "Some commits were rejected. Correct them and try the push again."
             warn "-------------------------------------------------------------"
     	warn ""
             exit 1
           else
             warn "You are repository manager. Checks results are ignored. "
             warn "-------------------------------------------------------------"
     	exit 0
           end
         end
         warn "Changes look OK"
         warn "-------------------------------------------------------------"
         exit 0
       end
     end

       validates_length_of :password, :minimum => 4, :allow_nil => true
       validates_confirmation_of :password, :allow_nil => true
       def ssh_key_entries
         AuthorizedKeysEntry.find_by_identifier(login)
       end
       def before_create
         self.mail_notification = false
         true
-...
         # update hashed_password if password was set
         self.hashed_password = User.hash_password(self.password) if self.password
       end
       def reload(*args)
         @name = nil
-...
       def self.hash_password(clear_password)
         Digest::SHA1.hexdigest(clear_password || "")
       end
     end
     class AnonymousUser < User

     <p><%= f.text_field :lastname, :required => true %></p>
     <p><%= f.text_field :mail, :required => true %></p>
     <p><%= f.select :language, lang_options_for_select %></p>
     <% if Setting.serve_git_repositories? %>
       <table>
       <% @user.ssh_key_entries.each do |e| %>
         <tr><td><%= e.identifier + " " + e.key[0,30] %>... </td><td><%= link_to 'Remove', {:action => 'remove_key', :id =>  e.key[0,40]}, :confirm => "Are you sure?" %></td></tr>
       <% end %>
     </table>
       <p><%= text_area_tag :new_key, '' %></p>
     <% end %>
     </div>
     <%= submit_tag l(:button_save) %>

     <%= hidden_field_tag 'settings[enabled_scm][]', '' %>
     </p>
     <% # TODO: Should be disabled when Git SCM is not enabled
     %>
     <p><label><%= l(:setting_serve_git_repositories) %></label>
     <%= check_box_tag 'settings[serve_git_repositories]', 1, Setting.serve_git_repositories? %>
     <%= hidden_field_tag 'settings[serve_git_repositories]', 0 %>
     </p>
     <p><label><%= l(:setting_repositories_encodings) %></label>
     <%= text_field_tag 'settings[repositories_encodings]', Setting.repositories_encodings, :size => 60 %><br /><em><%= l(:text_comma_separated) %></em></p>

       default: 1
     sys_api_enabled:
       default: 0
     serve_git_repositories:
       default: 0
     commit_ref_keywords:
       default: 'refs,references,IssueID'
     commit_fix_keywords:

     field_firstname: Име
     field_lastname: Фамилия
     field_mail: Email
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Файл
     field_filesize: Големина
     field_downloads: Downloads
-...
     setting_feeds_limit: Лимит на Feeds
     setting_autofetch_changesets: Автоматично обработване на ревизиите
     setting_sys_api_enabled: Разрешаване на WS за управление
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Отбелязващи ключови думи
     setting_commit_fix_keywords: Приключващи ключови думи
     setting_autologin: Автоматичен вход

     field_firstname: Nom
     field_lastname: Cognom
     field_mail: Correu electrònic
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Fitxer
     field_filesize: Mida
     field_downloads: Baixades
-...
     setting_default_projects_public: Els projectes nous són públics per defecte
     setting_autofetch_changesets: Omple automàticament les publicacions
     setting_sys_api_enabled: Habilita el WS per a la gestió del dipòsit
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Paraules claus per a la referència
     setting_commit_fix_keywords: Paraules claus per a la correcció
     setting_autologin: Entrada automàtica

     field_firstname: Jméno
     field_lastname: Příjmení
     field_mail: Email
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Soubor
     field_filesize: Velikost
     field_downloads: Staženo
-...
     setting_default_projects_public: Nové projekty nastavovat jako veřejné
     setting_autofetch_changesets: Autofetch commits
     setting_sys_api_enabled: Povolit WS pro správu repozitory
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Klíčová slova pro odkazy
     setting_commit_fix_keywords: Klíčová slova pro uzavření
     setting_autologin: Automatické přihlašování

     field_firstname: Fornavn
     field_lastname: Efternavn
     field_mail: E-mail
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Fil
     field_filesize: Størrelse
     field_downloads: Downloads
-...
     setting_sys_api_enabled: Aktiver webservice til versionsstyring
     setting_commit_ref_keywords: Nøgleord for sagsreferencer
     setting_commit_fix_keywords: Nøgleord for lukning af sager
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_autologin: Autologin
     setting_date_format: Datoformat
     setting_time_format: Tidsformat

     field_firstname: Vorname
     field_lastname: Nachname
     field_mail: E-Mail
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Datei
     field_filesize: Größe
     field_downloads: Downloads
-...
     setting_default_projects_public: Neue Projekte sind standardmäßig öffentlich
     setting_autofetch_changesets: Changesets automatisch abrufen
     setting_sys_api_enabled: Webservice zur Verwaltung der Projektarchive benutzen
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Schlüsselwörter (Beziehungen)
     setting_commit_fix_keywords: Schlüsselwörter (Status)
     setting_autologin: Automatische Anmeldung

     field_firstname: Firstname
     field_lastname: Lastname
     field_mail: Email
     field_new_key: SSH Public Key
     field_filename: File
     field_filesize: Size
     field_downloads: Downloads
-...
     setting_default_projects_public: New projects are public by default
     setting_autofetch_changesets: Autofetch commits
     setting_sys_api_enabled: Enable WS for repository management
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Referencing keywords
     setting_commit_fix_keywords: Fixing keywords
     setting_autologin: Autologin

     field_lastname: Apellido
     field_login: Identificador
     field_mail: Correo electrónico
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_mail_notification: Notificaciones por correo
     field_max_length: Longitud máxima
     field_min_length: Longitud mínima
-...
     setting_self_registration: Registro permitido
     setting_sequential_project_identifiers: Generar identificadores de proyecto
     setting_sys_api_enabled: Habilitar SW para la gestión del repositorio
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_text_formatting: Formato de texto
     setting_time_format: Formato de hora
     setting_user_format: Formato de nombre de usuario

     field_firstname: Etunimi
     field_lastname: Sukunimi
     field_mail: Sähköposti
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Tiedosto
     field_filesize: Koko
     field_downloads: Latausta
-...
     setting_feeds_limit: Syötteen sisällön raja
     setting_autofetch_changesets: Automaattisten muutosjoukkojen haku
     setting_sys_api_enabled: Salli WS tietovaraston hallintaan
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Viittaavat hakusanat
     setting_commit_fix_keywords: Korjaavat hakusanat
     setting_autologin: Automaatinen kirjautuminen

     field_firstname: Prénom
     field_lastname: Nom
     field_mail: Email
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Fichier
     field_filesize: Taille
     field_downloads: Téléchargements
-...
     setting_default_projects_public: Définir les nouveaux projects comme publics par défaut
     setting_autofetch_changesets: Récupération auto. des commits
     setting_sys_api_enabled: Activer les WS pour la gestion des dépôts
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Mot-clés de référencement
     setting_commit_fix_keywords: Mot-clés de résolution
     setting_autologin: Autologin

     field_firstname: שם פרטי
     field_lastname: שם משפחה
     field_mail: דוא"ל
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: קובץ
     field_filesize: גודל
     field_downloads: הורדות
-...
     setting_feeds_limit: גבול תוכן הזנות
     setting_autofetch_changesets: משיכה אוטומתי של עידכונים
     setting_sys_api_enabled: אפשר WS לניהול המאגר
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: מילות מפתח מקשרות
     setting_commit_fix_keywords: מילות מפתח מתקנות
     setting_autologin: חיבור אוטומטי

     field_firstname: Keresztnév
     field_lastname: Vezetéknév
     field_mail: E-mail
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Fájl
     field_filesize: Méret
     field_downloads: Letöltések
-...
     setting_default_projects_public: Az új projektek alapértelmezés szerint nyilvánosak
     setting_autofetch_changesets: Commitok automatikus lehúzása
     setting_sys_api_enabled: WS engedélyezése a tárolók kezeléséhez
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Hivatkozó kulcsszavak
     setting_commit_fix_keywords: Javítások kulcsszavai
     setting_autologin: Automatikus bejelentkezés

     field_firstname: Nome
     field_lastname: Cognome
     field_mail: Email
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: File
     field_filesize: Dimensione
     field_downloads: Download
-...
     setting_feeds_limit: Limite contenuti del feed
     setting_autofetch_changesets: Acquisisci automaticamente le commit
     setting_sys_api_enabled: Abilita WS per la gestione del repository
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Referencing keywords
     setting_commit_fix_keywords: Fixing keywords
     setting_autologin: Login automatico

     field_firstname: 名前
     field_lastname: 苗字
     field_mail: メールアドレス
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: ファイル
     field_filesize: サイズ
     field_downloads: ダウンロード
-...
     setting_feeds_limit: フィード内容の上限
     setting_autofetch_changesets: コミットを自動取得する
     setting_sys_api_enabled: リポジトリ管理用のWeb Serviceを有効にする
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: 参照用キーワード
     setting_commit_fix_keywords: 修正用キーワード
     setting_autologin: 自動ログイン

     field_firstname: 이름
     field_lastname: 성
     field_mail: 메일
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: 파일
     field_filesize: 크기
     field_downloads: 다운로드
-...
     setting_feeds_limit: 내용 피드(RSS Feed) 제한 개수
     setting_autofetch_changesets: 커밋된 변경묶음을 자동으로 가져오기
     setting_sys_api_enabled: 저장소 관리자에 WS 를 허용
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: 일감 참조에 사용할 키워드들
     setting_commit_fix_keywords: 일감 해결에 사용할 키워드들
     setting_autologin: 자동 로그인

     field_firstname: Vardas
     field_lastname: Pavardė
     field_mail: Email
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Byla
     field_filesize: Dydis
     field_downloads: Atsiuntimai
-...
     setting_default_projects_public: Naujas projektas viešas pagal nutylėjimą
     setting_autofetch_changesets: Automatinis pakeitimų siuntimas
     setting_sys_api_enabled: Įgalinkite WS sandėlio vadybai
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Nurodymo reikšminiai žodžiai
     setting_commit_fix_keywords: Fiksavimo reikšminiai žodžiai
     setting_autologin: Autoregistracija

     field_onthefly: On-the-fly aanmaken van een gebruiker
     field_start_date: Start
     field_done_ratio: %% Gereed
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_auth_source: Authenticatiemethode
     field_hide_mail: Verberg mijn e-mailadres
     field_comments: Commentaar
-...
     label_issue_watchers: Monitoren
     setting_commit_logs_encoding: Encodering van commit berichten
     button_quote: Citaat
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_sequential_project_identifiers: Genereer sequentiële projectidentiteiten
     notice_unable_delete_version: Niet mogelijk om deze versie te verwijderen.
     label_renamed: hernoemd

     field_firstname: Fornavn
     field_lastname: Etternavn
     field_mail: E-post
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Fil
     field_filesize: Størrelse
     field_downloads: Nedlastinger
-...
     setting_default_projects_public: Nye prosjekter er offentlige som standard
     setting_autofetch_changesets: Autohenting av innsendinger
     setting_sys_api_enabled: Aktiver webservice for depot-administrasjon
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Nøkkelord for referanse
     setting_commit_fix_keywords: Nøkkelord for retting
     setting_autologin: Autoinnlogging

     field_lastname: Nazwisko
     field_login: Login
     field_mail: Email
     field_ssh_key: Klucz publiczny SSH
     field_ssh_key_type: Typ klucza SSH
     field_mail_notification: Powiadomienia Email
     field_max_length: Maksymalna długość
     field_min_length: Minimalna długość
-...
     setting_self_registration: Własna rejestracja umożliwiona
     setting_sequential_project_identifiers: Generuj sekwencyjne identyfikatory projektów
     setting_sys_api_enabled: Włączenie WS do zarządzania repozytorium
     setting_serve_git_repositories: Udostępnij repozytoria GIT poprzez konto SSH Redmine
     setting_text_formatting: Formatowanie tekstu
     setting_time_format: Format czasu
     setting_user_format: Personalny format wyświetlania

     field_firstname: Nome
     field_lastname: Sobrenome
     field_mail: Email
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Arquivo
     field_filesize: Tamanho
     field_downloads: Downloads
-...
     setting_default_projects_public: Novos projetos são públicos por padrão
     setting_autofetch_changesets: Auto-obter commits
     setting_sys_api_enabled: Ativa WS para gerenciamento do repositório
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Palavras de referência
     setting_commit_fix_keywords: Palavras de fechamento
     setting_autologin: Auto-login

     field_firstname: Nome
     field_lastname: Apelido
     field_mail: E-mail
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Ficheiro
     field_filesize: Tamanho
     field_downloads: Downloads
-...
     setting_default_projects_public: Projectos novos são públicos por omissão
     setting_autofetch_changesets: Buscar automaticamente commits
     setting_sys_api_enabled: Activar Web Service para gestão do repositório
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Palavras-chave de referência
     setting_commit_fix_keywords: Palavras-chave de fecho
     setting_autologin: Login automático

     field_firstname: Nume
     field_lastname: Prenume
     field_mail: Email
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Fisier
     field_filesize: Marimea fisierului
     field_downloads: Download
-...
     setting_feeds_limit: Limita continut feed
     setting_autofetch_changesets: Autofetch commits
     setting_sys_api_enabled: Setare WS pentru managementul stocului (repository)
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Cuvinte cheie de referinta
     setting_commit_fix_keywords: Cuvinte cheie de rezolvare
     setting_autologin: Autentificare automata

     field_lastname: Фамилия
     field_login: Пользователь
     field_mail: Email
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_mail_notification: Уведомления по email
     field_max_length: Максимальная длина
     field_min_length: Минимальная длина
-...
     setting_self_registration: Возможна саморегистрация
     setting_sequential_project_identifiers: Генерировать последовательные идентификаторы проектов
     setting_sys_api_enabled: Разрешить WS для управления хранилищем
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_text_formatting: Форматирование текста
     setting_time_format: Формат времени
     setting_user_format: Формат отображения имени

     field_firstname: Meno
     field_lastname: Priezvisko
     field_mail: Email
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Súbor
     field_filesize: Veľkosť
     field_downloads: Stiahnuté
-...
     setting_default_projects_public: Nové projekty nastavovať ako verejné
     setting_autofetch_changesets: Automatický prenos zmien
     setting_sys_api_enabled: Povolit WS pre správu repozitory
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Klúčové slová pre odkazy
     setting_commit_fix_keywords: Klúčové slová pre uzavretie
     setting_autologin: Automatické prihlasovanie
-...
     permission_edit_own_messages: Edit own messages
     permission_delete_own_messages: Delete own messages
     text_repository_usernames_mapping: "Select or update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."
     label_user_activity: "%s's activity"
     label_updated_time_by: Updated by %s %s ago
     text_diff_truncated: '... This diff was truncated because it exceeds the maximum size that can be displayed.'
     setting_diff_max_lines_displayed: Max number of diff lines displayed
     text_plugin_assets_writable: Plugin assets directory writable
     warning_attachments_not_saved: "%d file(s) could not be saved."
     button_create_and_continue: Create and continue
     label_user_activity: "%s's activity"
     label_updated_time_by: Updated by %s %s ago
     text_diff_truncated: '... This diff was truncated because it exceeds the maximum size that can be displayed.'
     setting_diff_max_lines_displayed: Max number of diff lines displayed
     text_plugin_assets_writable: Plugin assets directory writable
     warning_attachments_not_saved: "%d file(s) could not be saved."
     button_create_and_continue: Create and continue

     field_firstname: Ime
     field_lastname: Prezime
     field_mail: Email
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Fajl
     field_filesize: Veličina
     field_downloads: Preuzimanja
-...
     setting_feeds_limit: Feed content limit
     setting_autofetch_changesets: Autofetch commits
     setting_sys_api_enabled: Ukljuci WS za menadžment spremišta
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Referentne ključne reči
     setting_commit_fix_keywords: Fiksne ključne reči
     setting_autologin: Automatsko prijavljivanje

     field_firstname: Förnamn
     field_lastname: Efternamn
     field_mail: Mail
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Fil
     field_filesize: Storlek
     field_downloads: Nerladdningar
-...
     setting_default_projects_public: Nya projekt är publika som standard
     setting_autofetch_changesets: Automatisk hämtning av commits
     setting_sys_api_enabled: Aktivera WS för repository-hantering
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Referens-nyckelord
     setting_commit_fix_keywords: Fix-nyckelord
     setting_autologin: Automatisk inloggning

     field_firstname: ชื่อ
     field_lastname: นามสกุล
     field_mail: อีเมล์
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: แฟ้ม
     field_filesize: ขนาด
     field_downloads: ดาวน์โหลด
-...
     setting_default_projects_public: โครงการใหม่มีค่าเริ่มต้นเป็น สาธารณะ
     setting_autofetch_changesets: ดึง commits อัตโนมัติ
     setting_sys_api_enabled: เปิดใช้ WS สำหรับการจัดการที่เก็บต้นฉบับ
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: คำสำคัญ Referencing
     setting_commit_fix_keywords: คำสำคัญ Fixing
     setting_autologin: เข้าระบบอัตโนมัติ

     field_firstname: Ad
     field_lastname: Soyad
     field_mail: E-Posta
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Dosya
     field_filesize: Boyut
     field_downloads: İndirilenler
-...
     setting_default_projects_public: Yeni projeler varsayılan olarak herkese açık
     setting_autofetch_changesets: Otomatik gönderi al
     setting_sys_api_enabled: Depo yönetimi için WS'yi etkinleştir
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Başvuru Kelimeleri
     setting_commit_fix_keywords: Sabitleme kelimeleri
     setting_autologin: Otomatik Giriş

     field_firstname: Ім'я
     field_lastname: Прізвище
     field_mail: Ел. пошта
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Файл
     field_filesize: Розмір
     field_downloads: Завантаження
-...
     setting_feeds_limit: Обмеження змісту подачі
     setting_autofetch_changesets: Автоматично доставати доповнення
     setting_sys_api_enabled: Дозволити WS для управління репозиторієм
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Ключові слова для посилання
     setting_commit_fix_keywords: Призначення ключових слів
     setting_autologin: Автоматичний вхід

     field_firstname: Tên lót + Tên
     field_lastname: Họ
     field_mail: Email
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: Tập tin
     field_filesize: Cỡ
     field_downloads: Tải về
-...
     setting_default_projects_public: Dự án mặc định là công cộng
     setting_autofetch_changesets: Autofetch commits
     setting_sys_api_enabled: Enable WS for repository management
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: Từ khóa tham khảo
     setting_commit_fix_keywords: Từ khóa chỉ vấn đề đã giải quyết
     setting_autologin: Tự động đăng nhập

     field_firstname: 名字
     field_lastname: 姓氏
     field_mail: 電子郵件
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: 檔案名稱
     field_filesize: 大小
     field_downloads: 下載次數
-...
     setting_autofetch_changesets: 自動取得送交版次
     setting_default_projects_public: 新建立之專案預設為「公開」
     setting_sys_api_enabled: 啟用管理版本庫之網頁服務 (Web Service)
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: 送交用於參照項目之關鍵字
     setting_commit_fix_keywords: 送交用於修正項目之關鍵字
     setting_autologin: 自動登入

     field_firstname: 名字
     field_lastname: 姓氏
     field_mail: 邮件地址
     field_ssh_key: SSH Public Key
     field_ssh_key_type: SSH Public Key Type
     field_filename: 文件
     field_filesize: 大小
     field_downloads: 下载次数
-...
     setting_default_projects_public: 新建项目默认为公开项目
     setting_autofetch_changesets: 自动获取程序变更
     setting_sys_api_enabled: 启用用于版本库管理的Web Service
     setting_serve_git_repositories: Serve GIT repositories using Redmine's SSH account
     setting_commit_ref_keywords: 用于引用问题的关键字
     setting_commit_fix_keywords: 用于解决问题的关键字
     setting_autologin: 自动登录

lib/redmine/scm/adapters/git_adapter.rb
24	24

Project

General

Profile

Redmine

Patch #2525 » 0004-Redmine-management-of-Git-repositories.patch