SoundSoftware Code Site

#!/usr/bin/env ruby

require 'optparse'

require 'find'

require 'etc'

require 'rubygems'

Version = "1.4"

SUPPORTED_SCM = %w( Subversion Darcs Mercurial Bazaar Git Filesystem )

$verbose      = 0

$quiet        = false

$redmine_host = ''

$repos_base   = ''

$svn_owner    = 'root'

$svn_group    = 'root'

$use_groupid  = true

$svn_url      = false

$test         = false

$force        = false

$scm          = 'Subversion'

def log(text, options={})

  level = options[:level] || 0

  puts text unless $quiet or level > $verbose

  exit 1 if options[:exit]

end

def system_or_raise(command)

  raise "\"#{command}\" failed" unless system command

end

module SCM

  module Subversion

    def self.create(path)

      system_or_raise "svnadmin create #{path}"

    end

  end

  module Git

    def self.create(path)

      Dir.mkdir path

      Dir.chdir(path) do

        system_or_raise "git --bare init --shared"

        system_or_raise "git update-server-info"

      end

    end

  end

end

def read_key_from_file(filename)

  begin

    $api_key = File.read(filename).strip

  rescue Exception => e

    $stderr.puts "Unable to read the key from #{filename}: #{e.message}"

    exit 1

  end

end

def set_scm(scm)

  $scm = scm.capitalize

  unless SUPPORTED_SCM.include?($scm)

    log("Invalid SCM: #{$scm}\nValid SCM are: #{SUPPORTED_SCM.join(', ')}", :exit => true)

  end

end

optparse = OptionParser.new do |opts|

  opts.banner = "Usage: reposman.rb [OPTIONS...] -s [DIR] -r [HOST] -k [KEY]"

  opts.separator("")

  opts.separator("Manages your repositories with Redmine.")

  opts.separator("")

  opts.separator("Required arguments:") 

  opts.on("-s", "--svn-dir DIR",      "use DIR as base directory for svn repositories") {|v| $repos_base = v}

  opts.on("-r", "--redmine-host HOST","assume Redmine is hosted on HOST. Examples:",

                                       " -r redmine.example.net",

                                       " -r http://redmine.example.net",

                                       " -r https://redmine.example.net") {|v| $redmine_host = v}

  opts.on("-k", "--key KEY",           "use KEY as the Redmine API key",

                                       "(you can use --key-file option as an alternative)") {|v| $api_key = v}

  opts.separator("")

  opts.separator("Options:")

  opts.on("-o", "--owner OWNER",       "owner of the repository. using the rails login", 

                                       "allows users to browse the repository within",

                                       "Redmine even for private projects. If you want to",

                                       "share repositories through Redmine.pm, you need",

                                       "to use the apache owner.") {|v| $svn_owner = v; $use_groupid = false}

  opts.on("-g", "--group GROUP",       "group of the repository (default: root)") {|v| $svn_group = v; $use_groupid = false}

  opts.on("-u", "--url URL",           "the base url Redmine will use to access your",

                                       "repositories. This option is used to register",

                                       "the repositories in Redmine automatically. The",

                                       "project identifier will be appended to this url.",

                                       "Examples:",

                                       " -u https://example.net/svn",

                                       " -u file:///var/svn/",

                                       "if this option isn't set, reposman won't register",

                                       "the repositories in Redmine") {|v| $svn_url = v}

  opts.on(      "--scm SCM",           "the kind of SCM repository you want to create",

                                       "(and register) in Redmine (default: Subversion).",

                                       "reposman is able to create Git and Subversion",

                                       "repositories.",

                                       "For all other kind, you must specify a --command",

                                       "option") {|v| set_scm(v)}

  opts.on("-c", "--command COMMAND",   "use this command instead of `svnadmin create` to",

                                       "create a repository. This option can be used to",

                                       "create repositories other than subversion and git",

                                       "kind.",

                                       "This command override the default creation for",

                                       "git and subversion.") {|v| $command = v}

  opts.on(      "--key-file FILE",     "path to a file that contains the Redmine API key",

                                       "(use this option instead of --key if you don't", 

                                       "want the key to appear in the command line)") {|v| read_key_from_file(v)}

  opts.on("-t", "--test",              "only show what should be done") {$test = true}

  opts.on("-f", "--force",             "force repository creation even if the project", "repository is already declared in Redmine") {$force = true}

  opts.on("-v", "--verbose",           "verbose") {$verbose += 1}

  opts.on("-V", "--version",           "show version and exit") {puts Version; exit}

  opts.on("-h", "--help",              "show help and exit") {puts opts; exit 1}

  opts.on("-q", "--quiet",             "no log") {$quiet = true}

  opts.separator("")

  opts.separator("Examples:")

  opts.separator("  reposman.rb --svn-dir=/var/svn --redmine-host=redmine.host")

  opts.separator("  reposman.rb -s /var/git -r redmine.host -u http://git.host --scm git")

  opts.separator("")

  opts.separator("You can find more information on the redmine's wiki:\nhttp://www.redmine.org/projects/redmine/wiki/HowTos")

  opts.summary_width = 25

end

optparse.parse!

if $test

  log("running in test mode")

end

# Make sure command is overridden if SCM vendor is not handled internally (for the moment Subversion and Git)

if $command.nil?

  begin

    scm_module = SCM.const_get($scm)

  rescue

    log("Please use --command option to specify how to create a #{$scm} repository.", :exit => true)

  end

end

$svn_url += "/" if $svn_url and not $svn_url.match(/\/$/)

if ($redmine_host.empty? or $repos_base.empty?)

  puts "Some arguments are missing. Use reposman.rb --help for getting help."

  exit 1

end

unless File.directory?($repos_base)

  log("directory '#{$repos_base}' doesn't exists", :exit => true)

end

begin

  require 'active_resource'

rescue LoadError

  log("This script requires activeresource.\nRun 'gem install activeresource' to install it.", :exit => true)

end

class Project < ActiveResource::Base

  self.headers["User-agent"] = "Redmine repository manager/#{Version}"

  self.format = :xml

end

log("querying Redmine for projects...", :level => 1);

$redmine_host.gsub!(/^/, "http://") unless $redmine_host.match("^https?://")

$redmine_host.gsub!(/\/$/, '')

Project.site = "#{$redmine_host}/sys";

begin

  # Get all active projects that have the Repository module enabled

  projects = Project.find(:all, :params => {:key => $api_key})

rescue ActiveResource::ForbiddenAccess

  log("Request was denied by your Redmine server. Make sure that 'WS for repository management' is enabled in application settings and that you provided the correct API key.")

rescue => e

  log("Unable to connect to #{Project.site}: #{e}", :exit => true)

end

if projects.nil?

  log('No project found, perhaps you forgot to "Enable WS for repository management"', :exit => true)

end

log("retrieved #{projects.size} projects", :level => 1)

def set_owner_and_rights(project, repos_path, &block)

  if mswin?

    yield if block_given?

  else

    uid, gid = Etc.getpwnam($svn_owner).uid, ($use_groupid ? Etc.getgrnam(project.identifier).gid : Etc.getgrnam($svn_group).gid)

    right = project.is_public ? 0775 : 0770

    yield if block_given?

    Find.find(repos_path) do |f|

      File.chmod right, f

      File.chown uid, gid, f

    end

  end

end

def other_read_right?(file)

  (File.stat(file).mode & 0007).zero? ? false : true

end

def owner_name(file)

  mswin? ?

    $svn_owner :

    Etc.getpwuid( File.stat(file).uid ).name

end

def mswin?

  (RUBY_PLATFORM =~ /(:?mswin|mingw)/) || (RUBY_PLATFORM == 'java' && (ENV['OS'] || ENV['os']) =~ /windows/i)

end

projects.each do |project|

  log("treating project #{project.name}", :level => 1)

  if project.identifier.empty?

    log("\tno identifier for project #{project.name}")

    next

  elsif not project.identifier.match(/^[a-z0-9\-_]+$/)

    log("\tinvalid identifier for project #{project.name} : #{project.identifier}");

    next;

  end

  repos_path = File.join($repos_base, project.identifier).gsub(File::SEPARATOR, File::ALT_SEPARATOR || File::SEPARATOR)

  if File.directory?(repos_path)

    # we must verify that repository has the good owner and the good

    # rights before leaving

    other_read = other_read_right?(repos_path)

    owner      = owner_name(repos_path)

    next if project.is_public == other_read and owner == $svn_owner

    if $test

      log("\tchange mode on #{repos_path}")

      next

    end

    begin

      set_owner_and_rights(project, repos_path)

    rescue Errno::EPERM => e

      log("\tunable to change mode on #{repos_path} : #{e}\n")

      next

    end

    log("\tmode change on #{repos_path}");

  else

    # if repository is already declared in redmine, we don't create

    # unless user use -f with reposman

    if $force == false and project.respond_to?(:repository)

      log("\trepository for project #{project.identifier} already exists in Redmine", :level => 1)

      next

    end

    project.is_public ? File.umask(0002) : File.umask(0007)

    if $test

      log("\tcreate repository #{repos_path}")

      log("\trepository #{repos_path} registered in Redmine with url #{$svn_url}#{project.identifier}") if $svn_url;

      next

    end

    begin

      set_owner_and_rights(project, repos_path) do

        if scm_module.nil?

          system_or_raise "#{$command} #{repos_path}"

        else

          scm_module.create(repos_path)

        end

      end

    rescue => e

      log("\tunable to create #{repos_path} : #{e}\n")

      next

    end

    if $svn_url

      begin

        project.post(:repository, :vendor => $scm, :repository => {:url => "#{$svn_url}#{project.identifier}"}, :key => $api_key)

        log("\trepository #{repos_path} registered in Redmine with url #{$svn_url}#{project.identifier}");

      rescue => e

        log("\trepository #{repos_path} not registered in Redmine: #{e.message}");

      end

    end

    log("\trepository #{repos_path} created");

  end

end

# Redmine - project management software

# Copyright (C) 2006-2012  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.

module Redmine

  module Utils

    class << self

      # Returns the relative root url of the application

      def relative_url_root

        ActionController::Base.respond_to?('relative_url_root') ?

          ActionController::Base.relative_url_root.to_s :

          ActionController::Base.config.relative_url_root.to_s

      end

      # Sets the relative root url of the application

      def relative_url_root=(arg)

        if ActionController::Base.respond_to?('relative_url_root=')

          ActionController::Base.relative_url_root=arg

        else

          ActionController::Base.config.relative_url_root = arg

        end

      end

      # Generates a n bytes random hex string

      # Example:

      #   random_hex(4) # => "89b8c729"

      def random_hex(n)

        SecureRandom.hex(n)

      end

    end

    module Shell

      def shell_quote(str)

        if Redmine::Platform.mswin?

          '"' + str.gsub(/"/, '\\"') + '"'

        else

          "'" + str.gsub(/'/, "'\"'\"'") + "'"

        end

      end

    end

    module DateCalculation

      # Returns the number of working days between from and to

      def working_days(from, to)

        days = (to - from).to_i

        if days > 0

          weeks = days / 7

          result = weeks * (7 - non_working_week_days.size)

          days_left = days - weeks * 7

          start_cwday = from.cwday

          days_left.times do |i|

            unless non_working_week_days.include?(((start_cwday + i - 1) % 7) + 1)

              result += 1

            end

          end

          result

        else

          0

        end

      end

      # Adds working days to the given date

      def add_working_days(date, working_days)

        if working_days > 0

          weeks = working_days / (7 - non_working_week_days.size)

          result = weeks * 7

          days_left = working_days - weeks * (7 - non_working_week_days.size)

          cwday = date.cwday

          while days_left > 0

            cwday += 1

            unless non_working_week_days.include?(((cwday - 1) % 7) + 1)

              days_left -= 1

            end

            result += 1

          end

          next_working_date(date + result)

        else

          date

        end

      end

      # Returns the date of the first day on or after the given date that is a working day

      def next_working_date(date)

        cwday = date.cwday

        days = 0

        while non_working_week_days.include?(((cwday + days - 1) % 7) + 1)

          days += 1

        end

        date + days

      end

      # Returns the index of non working week days (1=monday, 7=sunday)

      def non_working_week_days

        @non_working_week_days ||= begin

          days = Setting.non_working_week_days

          if days.is_a?(Array) && days.size < 7

            days.map(&:to_i)

          else

            []

          end

        end

      end

    end

  end

end

Return-Path: <JSmith@somenet.foo>

Received: from osiris ([127.0.0.1])

	by OSIRIS

	with hMailServer ; Sun, 22 Jun 2008 12:28:07 +0200

Message-ID: <000501c8d452$a95cd7e0$0a00a8c0@osiris>

From: "John Smith" <JSmith@somenet.foo>

To: <redmine@somenet.foo>

Subject: New ticket on a given project with a very long subject line which exceeds 255 chars and should not be ignored but chopped off. And if the subject line is still not long enough, we just add more text. And more text. Wow, this is really annoying. Especially, if you have nothing to say...

Date: Sun, 22 Jun 2008 12:28:07 +0200

MIME-Version: 1.0

Content-Type: text/plain;

	format=flowed;

	charset="iso-8859-1";

	reply-type=original

Content-Transfer-Encoding: 7bit

X-Priority: 3

X-MSMail-Priority: Normal

X-Mailer: Microsoft Outlook Express 6.00.2900.2869

X-MimeOLE: Produced By Microsoft MimeOLE V6.00.2900.2869

Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas imperdiet 

turpis et odio. Integer eget pede vel dolor euismod varius. Phasellus 

blandit eleifend augue. Nulla facilisi. Duis id diam. Class aptent taciti 

sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. In 

in urna sed tellus aliquet lobortis. Morbi scelerisque tortor in dolor. Cras 

sagittis odio eu lacus. Aliquam sem tortor, consequat sit amet, vestibulum 

id, iaculis at, lectus. Fusce tortor libero, congue ut, euismod nec, luctus 

eget, eros. Pellentesque tortor enim, feugiat in, dignissim eget, tristique 

sed, mauris --- Pellentesque habitant morbi tristique senectus et netus et 

malesuada fames ac turpis egestas. Quisque sit amet libero. In hac habitasse 

platea dictumst.

--- This line starts with a delimiter and should not be stripped

This paragraph is before delimiters.

BREAK

This paragraph is between delimiters.

---

This paragraph is after the delimiter so it shouldn't appear.

Nulla et nunc. Duis pede. Donec et ipsum. Nam ut dui tincidunt neque 

sollicitudin iaculis. Duis vitae dolor. Vestibulum eget massa. Sed lorem. 

Nullam volutpat cursus erat. Cras felis dolor, lacinia quis, rutrum et, 

dictum et, ligula. Sed erat nibh, gravida in, accumsan non, placerat sed, 

massa. Sed sodales, ante fermentum ultricies sollicitudin, massa leo 

pulvinar dui, a gravida orci mi eget odio. Nunc a lacus.

Project: onlinestore

Status: Resolved

due date: 2010-12-31

Start Date:2010-01-01

Assigned to: John Smith

<div class="autoscroll">

<table class="filecontent syntaxhl">

<tbody>

<% line_num = 1 %>

<% syntax_highlight_lines(filename, Redmine::CodesetUtil.to_utf8_by_setting(content)).each do |line| %>

  <tr>

    <th class="line-num" id="L<%= line_num %>">

      <a href="#L<%= line_num %>"><%= line_num %></a>

    </th>

    <td class="line-code">

      <pre><%= line.html_safe %></pre>

    </td>

  </tr>

  <% line_num += 1 %>

<% end %>

</tbody>

</table>

</div>