SoundSoftware Code Site

# 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.

require 'cgi'

module Redmine

  module Scm

    module Adapters

      class CommandFailed < StandardError #:nodoc:

      end

      class AbstractAdapter #:nodoc:

        # raised if scm command exited with error, e.g. unknown revision.

        class ScmCommandAborted < CommandFailed; end

        class << self

          def client_command

            ""

          end

          def shell_quote_command

            if Redmine::Platform.mswin? && RUBY_PLATFORM == 'java'

              client_command

            else

              shell_quote(client_command)

            end

          end

          # Returns the version of the scm client

          # Eg: [1, 5, 0] or [] if unknown

          def client_version

            []

          end

          # Returns the version string of the scm client

          # Eg: '1.5.0' or 'Unknown version' if unknown

          def client_version_string

            v = client_version || 'Unknown version'

            v.is_a?(Array) ? v.join('.') : v.to_s

          end

          # Returns true if the current client version is above

          # or equals the given one

          # If option is :unknown is set to true, it will return

          # true if the client version is unknown

          def client_version_above?(v, options={})

            ((client_version <=> v) >= 0) || (client_version.empty? && options[:unknown])

          end

          def client_available

            true

          end

          def shell_quote(str)

            if Redmine::Platform.mswin?

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

            else

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

            end

          end

        end

        def initialize(url, root_url=nil, login=nil, password=nil,

                       path_encoding=nil)

          @url = url

          @login = login if login && !login.empty?

          @password = (password || "") if @login

          @root_url = root_url.blank? ? retrieve_root_url : root_url

        end

        def adapter_name

          'Abstract'

        end

        def supports_cat?

          true

        end

        def supports_annotate?

          respond_to?('annotate')

        end

        def root_url

          @root_url

        end

        def url

          @url

        end

        def path_encoding

          nil

        end

        # get info about the svn repository

        def info

          return nil

        end

        # Returns the entry identified by path and revision identifier

        # or nil if entry doesn't exist in the repository

        def entry(path=nil, identifier=nil)

          parts = path.to_s.split(%r{[\/\\]}).select {|n| !n.blank?}

          search_path = parts[0..-2].join('/')

          search_name = parts[-1]

          if search_path.blank? && search_name.blank?

            # Root entry

            Entry.new(:path => '', :kind => 'dir')

          else

            # Search for the entry in the parent directory

            es = entries(search_path, identifier)

            es ? es.detect {|e| e.name == search_name} : nil

          end

        end

        # Returns an Entries collection

        # or nil if the given path doesn't exist in the repository

        def entries(path=nil, identifier=nil, options={})

          return nil

        end

        def branches

          return nil

        end

        def tags

          return nil

        end

        def default_branch

          return nil

        end

        def properties(path, identifier=nil)

          return nil

        end

        def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})

          return nil

        end

        def diff(path, identifier_from, identifier_to=nil)

          return nil

        end

        def cat(path, identifier=nil)

          return nil

        end

        def with_leading_slash(path)

          path ||= ''

          (path[0,1]!="/") ? "/#{path}" : path

        end

        def with_trailling_slash(path)

          path ||= ''

          (path[-1,1] == "/") ? path : "#{path}/"

        end

        def without_leading_slash(path)

          path ||= ''

          path.gsub(%r{^/+}, '')

        end

        def without_trailling_slash(path)

          path ||= ''

          (path[-1,1] == "/") ? path[0..-2] : path

         end

        def shell_quote(str)

          self.class.shell_quote(str)

        end

      private

        def retrieve_root_url

          info = self.info

          info ? info.root_url : nil

        end

        def target(path, sq=true)

          path ||= ''

          base = path.match(/^\//) ? root_url : url

          str = "#{base}/#{path}".gsub(/[?<>\*]/, '')

          if sq

            str = shell_quote(str)

          end

          str

        end

        def logger

          self.class.logger

        end

        def shellout(cmd, options = {}, &block)

          self.class.shellout(cmd, options, &block)

        end

        def self.logger

          Rails.logger

        end

        def self.shellout(cmd, options = {}, &block)

          if logger && logger.debug?

            logger.debug "Shelling out: #{strip_credential(cmd)}"

          end

          if Rails.env == 'development'

            # Capture stderr when running in dev environment

            cmd = "#{cmd} 2>>#{shell_quote(Rails.root.join('log/scm.stderr.log').to_s)}"

          end

          begin

            mode = "r+"

            IO.popen(cmd, mode) do |io|

              io.set_encoding("ASCII-8BIT") if io.respond_to?(:set_encoding)

              io.close_write unless options[:write_stdin]

              block.call(io) if block_given?

            end

          ## If scm command does not exist,

          ## Linux JRuby 1.6.2 (ruby-1.8.7-p330) raises java.io.IOException

          ## in production environment.

          # rescue Errno::ENOENT => e

          rescue Exception => e

            msg = strip_credential(e.message)

            # The command failed, log it and re-raise

            logmsg = "SCM command failed, "

            logmsg += "make sure that your SCM command (e.g. svn) is "

            logmsg += "in PATH (#{ENV['PATH']})\n"

            logmsg += "You can configure your scm commands in config/configuration.yml.\n"

            logmsg += "#{strip_credential(cmd)}\n"

            logmsg += "with: #{msg}"

            logger.error(logmsg)

            raise CommandFailed.new(msg)

          end

        end

        # Hides username/password in a given command

        def self.strip_credential(cmd)

          q = (Redmine::Platform.mswin? ? '"' : "'")

          cmd.to_s.gsub(/(\-\-(password|username))\s+(#{q}[^#{q}]+#{q}|[^#{q}]\S+)/, '\\1 xxxx')

        end

        def strip_credential(cmd)

          self.class.strip_credential(cmd)

        end

        def scm_iconv(to, from, str)

          return nil if str.nil?

          return str if to == from

          if str.respond_to?(:force_encoding)

            str.force_encoding(from)

            begin

              str.encode(to)

            rescue Exception => err

              logger.error("failed to convert from #{from} to #{to}. #{err}")

              nil

            end

          else

            begin

              Iconv.conv(to, from, str)

            rescue Iconv::Failure => err

              logger.error("failed to convert from #{from} to #{to}. #{err}")

              nil

            end

          end

        end

        def parse_xml(xml)

          if RUBY_PLATFORM == 'java'

            xml = xml.sub(%r{<\?xml[^>]*\?>}, '')

          end

          ActiveSupport::XmlMini.parse(xml)

        end

      end

      class Entries < Array

        def sort_by_name

          dup.sort! {|x,y|

            if x.kind == y.kind

              x.name.to_s <=> y.name.to_s

            else

              x.kind <=> y.kind

            end

          }

        end

        def revisions

          revisions ||= Revisions.new(collect{|entry| entry.lastrev}.compact)

        end

      end

      class Info

        attr_accessor :root_url, :lastrev

        def initialize(attributes={})

          self.root_url = attributes[:root_url] if attributes[:root_url]

          self.lastrev = attributes[:lastrev]

        end

      end

      class Entry

        attr_accessor :name, :path, :kind, :size, :lastrev, :changeset

        def initialize(attributes={})

          self.name = attributes[:name] if attributes[:name]

          self.path = attributes[:path] if attributes[:path]

          self.kind = attributes[:kind] if attributes[:kind]

          self.size = attributes[:size].to_i if attributes[:size]

          self.lastrev = attributes[:lastrev]

        end

        def is_file?

          'file' == self.kind

        end

        def is_dir?

          'dir' == self.kind

        end

        def is_text?

          Redmine::MimeType.is_type?('text', name)

        end

        def author

          if changeset

            changeset.author.to_s

          elsif lastrev

            Redmine::CodesetUtil.replace_invalid_utf8(lastrev.author.to_s.split('<').first)

          end

        end

      end

      class Revisions < Array

        def latest

          sort {|x,y|

            unless x.time.nil? or y.time.nil?

              x.time <=> y.time

            else

              0

            end

          }.last

        end

      end

      class Revision

        attr_accessor :scmid, :name, :author, :time, :message,

                      :paths, :revision, :branch, :identifier,

                      :parents

        def initialize(attributes={})

          self.identifier = attributes[:identifier]

          self.scmid      = attributes[:scmid]

          self.name       = attributes[:name] || self.identifier

          self.author     = attributes[:author]

          self.time       = attributes[:time]

          self.message    = attributes[:message] || ""

          self.paths      = attributes[:paths]

          self.revision   = attributes[:revision]

          self.branch     = attributes[:branch]

          self.parents    = attributes[:parents]

        end

        # Returns the readable identifier.

        def format_identifier

          self.identifier.to_s

        end

        def ==(other)

          if other.nil?

            false

          elsif scmid.present?

            scmid == other.scmid

          elsif identifier.present?

            identifier == other.identifier

          elsif revision.present?

            revision == other.revision

          end

        end

      end

      class Annotate

        attr_reader :lines, :revisions

        def initialize

          @lines = []

          @revisions = []

        end

        def add_line(line, revision)

          @lines << line

          @revisions << revision

        end

        def content

          content = lines.join("\n")

        end

        def empty?

          lines.empty?

        end

      end

      class Branch < String

        attr_accessor :revision, :scmid

      end

    end

  end

end

/* Turkish initialisation for the jQuery UI date picker plugin. */

/* Written by Izzet Emre Erkan (kara@karalamalar.net). */

jQuery(function($){

	$.datepicker.regional['tr'] = {

		closeText: 'kapat',

		prevText: '<geri',

		nextText: 'ileri&#x3e',

		currentText: 'bugün',

		monthNames: ['Ocak','Şubat','Mart','Nisan','Mayıs','Haziran',

		'Temmuz','Ağustos','Eylül','Ekim','Kasım','Aralık'],

		monthNamesShort: ['Oca','Şub','Mar','Nis','May','Haz',

		'Tem','Ağu','Eyl','Eki','Kas','Ara'],

		dayNames: ['Pazar','Pazartesi','Salı','Çarşamba','Perşembe','Cuma','Cumartesi'],

		dayNamesShort: ['Pz','Pt','Sa','Ça','Pe','Cu','Ct'],

		dayNamesMin: ['Pz','Pt','Sa','Ça','Pe','Cu','Ct'],

		weekHeader: 'Hf',

		dateFormat: 'dd.mm.yy',

		firstDay: 1,

		isRTL: false,

		showMonthAfterYear: false,

		yearSuffix: ''};

	$.datepicker.setDefaults($.datepicker.regional['tr']);

});

desc "Run the Continous Integration tests for Redmine"

task :ci do

  # RAILS_ENV and ENV[] can diverge so force them both to test

  ENV['RAILS_ENV'] = 'test'

  RAILS_ENV = 'test'

  Rake::Task["ci:setup"].invoke

  Rake::Task["ci:build"].invoke

  Rake::Task["ci:teardown"].invoke

end

# Tasks can be hooked into by redefining them in a plugin

namespace :ci do

  desc "Setup Redmine for a new build."

  task :setup do

    Rake::Task["ci:dump_environment"].invoke

    Rake::Task["db:create"].invoke

    Rake::Task["db:migrate"].invoke

    Rake::Task["db:schema:dump"].invoke

    Rake::Task["test:scm:update"].invoke

  end

  desc "Build Redmine"

  task :build do

    Rake::Task["test"].invoke

  end

  # Use this to cleanup after building or run post-build analysis.

  desc "Finish the build"

  task :teardown do

  end

  desc "Creates and configures the databases for the CI server"

  task :database do

    path = 'config/database.yml'

    unless File.exists?(path)

      database = ENV['DATABASE_ADAPTER']

      ruby = ENV['RUBY_VER'].gsub('.', '').gsub('-', '')

      branch = ENV['BRANCH'].gsub('.', '').gsub('-', '')

      dev_db_name = "ci_#{branch}_#{ruby}_dev"

      test_db_name = "ci_#{branch}_#{ruby}_test"

      case database

      when 'mysql'

        raise "Error creating databases" unless

          system(%|mysql -u jenkins --password=jenkins -e 'create database #{dev_db_name} character set utf8;'|) &&

          system(%|mysql -u jenkins --password=jenkins -e 'create database #{test_db_name} character set utf8;'|)

        dev_conf =  { 'adapter' => (RUBY_VERSION >= '1.9' ? 'mysql2' : 'mysql'), 'database' => dev_db_name, 'host' => 'localhost', 'username' => 'jenkins', 'password' => 'jenkins', 'encoding' => 'utf8' }

        test_conf = { 'adapter' => (RUBY_VERSION >= '1.9' ? 'mysql2' : 'mysql'), 'database' => test_db_name, 'host' => 'localhost', 'username' => 'jenkins', 'password' => 'jenkins', 'encoding' => 'utf8' }

      when 'postgresql'

        raise "Error creating databases" unless

          system(%|psql -U jenkins -d postgres -c "create database #{dev_db_name} owner jenkins encoding 'UTF8';"|) &&

          system(%|psql -U jenkins -d postgres -c "create database #{test_db_name} owner jenkins encoding 'UTF8';"|)

        dev_conf =  { 'adapter' => 'postgresql', 'database' => dev_db_name, 'host' => 'localhost', 'username' => 'jenkins', 'password' => 'jenkins' }

        test_conf = { 'adapter' => 'postgresql', 'database' => test_db_name, 'host' => 'localhost', 'username' => 'jenkins', 'password' => 'jenkins' }

      when 'sqlite3'

        dev_conf =  { 'adapter' => 'sqlite3', 'database' => "db/#{dev_db_name}.sqlite3" }

        test_conf = { 'adapter' => 'sqlite3', 'database' => "db/#{test_db_name}.sqlite3" }

      else

        raise "Unknown database"

      end

      File.open(path, 'w') do |f|

        f.write YAML.dump({'development' => dev_conf, 'test' => test_conf})

      end

    end

  end

  desc "Dump the environment information to a BUILD_ENVIRONMENT ENV variable for debugging"

  task :dump_environment do

    ENV['BUILD_ENVIRONMENT'] = ['ruby -v', 'gem -v', 'gem list'].collect do |command|

      result = `#{command}`

      "$ #{command}\n#{result}"

    end.join("\n")

  end

end

<div class="contextual">

<%= link_to(l(:label_news_new),

            new_project_news_path(@project),

            :class => 'icon icon-add',

            :onclick => 'showAndScrollTo("add-news", "news_title"); return false;') if @project && User.current.allowed_to?(:manage_news, @project) %>

</div>

<div id="add-news" style="display:none;">

<h2><%=l(:label_news_new)%></h2>

<%= labelled_form_for @news, :url => project_news_index_path(@project),

                                           :html => { :id => 'news-form', :multipart => true } do |f| %>

<%= render :partial => 'news/form', :locals => { :f => f } %>

<%= submit_tag l(:button_create) %>

<%= preview_link preview_news_path(:project_id => @project), 'news-form' %> |

<%= link_to l(:button_cancel), "#", :onclick => '$("#add-news").hide()' %>

<% end if @project %>

<div id="preview" class="wiki"></div>

</div>

<h2><%=l(:label_news_plural)%></h2>

<% if @newss.empty? %>

<p class="nodata"><%= l(:label_no_data) %></p>

<% else %>

<% @newss.each do |news| %>

    <h3><%= avatar(news.author, :size => "24") %><%= link_to_project(news.project) + ': ' unless news.project == @project %>

    <%= link_to h(news.title), news_path(news) %>

    <%= "(#{l(:label_x_comments, :count => news.comments_count)})" if news.comments_count > 0 %></h3>

    <p class="author"><%= authoring news.created_on, news.author %></p>

    <div class="wiki">

    <%= textilizable(news, :description) %>

    </div>

<% end %>

<% end %>

<p class="pagination"><%= pagination_links_full @news_pages %></p>

<% other_formats_links do |f| %>

  <%= f.link_to 'Atom', :url => {:project_id => @project, :key => User.current.rss_key} %>

<% end %>

<% content_for :header_tags do %>

  <%= auto_discovery_link_tag(:atom, params.merge({:format => 'atom', :page => nil, :key => User.current.rss_key})) %>

  <%= stylesheet_link_tag 'scm' %>

<% end %>

<% html_title(l(:label_news_plural)) -%>

<div class="contextual">

<%= link_to(l(:button_edit), edit_user_path(@user), :class => 'icon icon-edit') if User.current.admin? %>

</div>

<h2><%= avatar @user, :size => "50" %> <%=h @user.name %></h2>

<div class="splitcontentleft">

<ul>

  <% unless @user.pref.hide_mail %>

    <li><%=l(:field_mail)%>: <%= mail_to(h(@user.mail), nil, :encode => 'javascript') %></li>

  <% end %>

  <% @user.visible_custom_field_values.each do |custom_value| %>

  <% if !custom_value.value.blank? %>

    <li><%=h custom_value.custom_field.name%>: <%=h show_value(custom_value) %></li>

  <% end %>

  <% end %>

    <li><%=l(:label_registered_on)%>: <%= format_date(@user.created_on) %></li>

  <% unless @user.last_login_on.nil? %>

    <li><%=l(:field_last_login_on)%>: <%= format_date(@user.last_login_on) %></li>

  <% end %>

</ul>

<% unless @memberships.empty? %>

<h3><%=l(:label_project_plural)%></h3>

<ul>

<% for membership in @memberships %>

  <li><%= link_to_project(membership.project) %>

    (<%=h membership.roles.sort.collect(&:to_s).join(', ') %>, <%= format_date(membership.created_on) %>)</li>

<% end %>

</ul>

<% end %>

<%= call_hook :view_account_left_bottom, :user => @user %>

</div>

<div class="splitcontentright">

<% unless @events_by_day.empty? %>

<h3><%= link_to l(:label_activity), :controller => 'activities',

                :action => 'index', :id => nil, :user_id => @user,

                :from => @events_by_day.keys.first %></h3>

<p>

<%=l(:label_reported_issues)%>: <%= Issue.count(:conditions => ["author_id=?", @user.id]) %>

</p>

<div id="activity">

<% @events_by_day.keys.sort.reverse.each do |day| %>

<h4><%= format_activity_day(day) %></h4>

<dl>

<% @events_by_day[day].sort {|x,y| y.event_datetime <=> x.event_datetime }.each do |e| -%>

  <dt class="<%= e.event_type %>">

  <span class="time"><%= format_time(e.event_datetime, false) %></span>

  <%= content_tag('span', h(e.project), :class => 'project') %>

  <%= link_to format_activity_title(e.event_title), e.event_url %></dt>

  <dd><span class="description"><%= format_activity_description(e.event_description) %></span></dd>

<% end -%>

</dl>

<% end -%>

</div>

<% other_formats_links do |f| %>

  <%= f.link_to 'Atom', :url => {:controller => 'activities', :action => 'index', :id => nil, :user_id => @user, :key => User.current.rss_key} %>

<% end %>

<% content_for :header_tags do %>

  <%= auto_discovery_link_tag(:atom, :controller => 'activities', :action => 'index', :user_id => @user, :format => :atom, :key => User.current.rss_key) %>

<% end %>

<% end %>

<%= call_hook :view_account_right_bottom, :user => @user %>

</div>

<% html_title @user.name %>

# 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.

require 'active_record'

require 'iconv'

require 'pp'

namespace :redmine do

  desc 'Trac migration script'

  task :migrate_from_trac => :environment do

    module TracMigrate

        TICKET_MAP = []

        DEFAULT_STATUS = IssueStatus.default

        assigned_status = IssueStatus.find_by_position(2)

        resolved_status = IssueStatus.find_by_position(3)

        feedback_status = IssueStatus.find_by_position(4)

        closed_status = IssueStatus.find :first, :conditions => { :is_closed => true }

        STATUS_MAPPING = {'new' => DEFAULT_STATUS,

                          'reopened' => feedback_status,

                          'assigned' => assigned_status,

                          'closed' => closed_status

                          }

        priorities = IssuePriority.all

        DEFAULT_PRIORITY = priorities[0]

        PRIORITY_MAPPING = {'lowest' => priorities[0],

                            'low' => priorities[0],

                            'normal' => priorities[1],

                            'high' => priorities[2],

                            'highest' => priorities[3],

                            # ---

                            'trivial' => priorities[0],

                            'minor' => priorities[1],

                            'major' => priorities[2],

                            'critical' => priorities[3],

                            'blocker' => priorities[4]

                            }

        TRACKER_BUG = Tracker.find_by_position(1)

        TRACKER_FEATURE = Tracker.find_by_position(2)

        DEFAULT_TRACKER = TRACKER_BUG

        TRACKER_MAPPING = {'defect' => TRACKER_BUG,

                           'enhancement' => TRACKER_FEATURE,

                           'task' => TRACKER_FEATURE,

                           'patch' =>TRACKER_FEATURE

                           }

        roles = Role.find(:all, :conditions => {:builtin => 0}, :order => 'position ASC')

        manager_role = roles[0]

        developer_role = roles[1]

        DEFAULT_ROLE = roles.last

        ROLE_MAPPING = {'admin' => manager_role,

                        'developer' => developer_role

                        }

      class ::Time

        class << self

          alias :real_now :now

          def now

            real_now - @fake_diff.to_i

          end

          def fake(time)

            @fake_diff = real_now - time

            res = yield

            @fake_diff = 0

           res

          end

        end

      end

      class TracComponent < ActiveRecord::Base

        self.table_name = :component

      end

      class TracMilestone < ActiveRecord::Base

        self.table_name = :milestone

        # If this attribute is set a milestone has a defined target timepoint

        def due

          if read_attribute(:due) && read_attribute(:due) > 0

            Time.at(read_attribute(:due)).to_date

          else

            nil

          end

        end

        # This is the real timepoint at which the milestone has finished.

        def completed

          if read_attribute(:completed) && read_attribute(:completed) > 0

            Time.at(read_attribute(:completed)).to_date

          else

            nil

          end

        end

        def description

          # Attribute is named descr in Trac v0.8.x

          has_attribute?(:descr) ? read_attribute(:descr) : read_attribute(:description)

        end

      end

      class TracTicketCustom < ActiveRecord::Base

        self.table_name = :ticket_custom

      end

      class TracAttachment < ActiveRecord::Base

        self.table_name = :attachment

        set_inheritance_column :none

        def time; Time.at(read_attribute(:time)) end

        def original_filename

          filename

        end

        def content_type

          ''

        end

        def exist?

          File.file? trac_fullpath

        end

        def open

          File.open("#{trac_fullpath}", 'rb') {|f|

            @file = f

            yield self

          }

        end

        def read(*args)

          @file.read(*args)

        end

        def description

          read_attribute(:description).to_s.slice(0,255)

        end

      private

        def trac_fullpath

          attachment_type = read_attribute(:type)

          trac_file = filename.gsub( /[^a-zA-Z0-9\-_\.!~*']/n ) {|x| sprintf('%%%02x', x[0]) }

          "#{TracMigrate.trac_attachments_directory}/#{attachment_type}/#{id}/#{trac_file}"

        end

      end

      class TracTicket < ActiveRecord::Base

        self.table_name = :ticket

        set_inheritance_column :none

        # ticket changes: only migrate status changes and comments

        has_many :ticket_changes, :class_name => "TracTicketChange", :foreign_key => :ticket

        has_many :customs, :class_name => "TracTicketCustom", :foreign_key => :ticket

        def attachments

          TracMigrate::TracAttachment.all(:conditions => ["type = 'ticket' AND id = ?", self.id.to_s])

        end

        def ticket_type

          read_attribute(:type)

        end

        def summary

          read_attribute(:summary).blank? ? "(no subject)" : read_attribute(:summary)

        end

        def description

          read_attribute(:description).blank? ? summary : read_attribute(:description)

        end

        def time; Time.at(read_attribute(:time)) end

        def changetime; Time.at(read_attribute(:changetime)) end

      end

      class TracTicketChange < ActiveRecord::Base

        self.table_name = :ticket_change

        def self.columns

          # Hides Trac field 'field' to prevent clash with AR field_changed? method (Rails 3.0)

          super.select {|column| column.name.to_s != 'field'}

        end

        def time; Time.at(read_attribute(:time)) end

      end

      TRAC_WIKI_PAGES = %w(InterMapTxt InterTrac InterWiki RecentChanges SandBox TracAccessibility TracAdmin TracBackup TracBrowser TracCgi TracChangeset \

                           TracEnvironment TracFastCgi TracGuide TracImport TracIni TracInstall TracInterfaceCustomization \

                           TracLinks TracLogging TracModPython TracNotification TracPermissions TracPlugins TracQuery \

                           TracReports TracRevisionLog TracRoadmap TracRss TracSearch TracStandalone TracSupport TracSyntaxColoring TracTickets \

                           TracTicketsCustomFields TracTimeline TracUnicode TracUpgrade TracWiki WikiDeletePage WikiFormatting \

                           WikiHtml WikiMacros WikiNewPage WikiPageNames WikiProcessors WikiRestructuredText WikiRestructuredTextLinks \

                           CamelCase TitleIndex)

      class TracWikiPage < ActiveRecord::Base

        self.table_name = :wiki

        set_primary_key :name

        def self.columns

          # Hides readonly Trac field to prevent clash with AR readonly? method (Rails 2.0)

          super.select {|column| column.name.to_s != 'readonly'}

        end

        def attachments

          TracMigrate::TracAttachment.all(:conditions => ["type = 'wiki' AND id = ?", self.id.to_s])

        end

        def time; Time.at(read_attribute(:time)) end

      end

      class TracPermission < ActiveRecord::Base

        self.table_name = :permission

      end

      class TracSessionAttribute < ActiveRecord::Base

        self.table_name = :session_attribute

      end

      def self.find_or_create_user(username, project_member = false)

        return User.anonymous if username.blank?

        u = User.find_by_login(username)

        if !u

          # Create a new user if not found

          mail = username[0, User::MAIL_LENGTH_LIMIT]

          if mail_attr = TracSessionAttribute.find_by_sid_and_name(username, 'email')

            mail = mail_attr.value

          end

          mail = "#{mail}@foo.bar" unless mail.include?("@")

          name = username

          if name_attr = TracSessionAttribute.find_by_sid_and_name(username, 'name')

            name = name_attr.value

          end

          name =~ (/(.*)(\s+\w+)?/)

          fn = $1.strip

          ln = ($2 || '-').strip

          u = User.new :mail => mail.gsub(/[^-@a-z0-9\.]/i, '-'),

                       :firstname => fn[0, limit_for(User, 'firstname')],

                       :lastname => ln[0, limit_for(User, 'lastname')]

          u.login = username[0, User::LOGIN_LENGTH_LIMIT].gsub(/[^a-z0-9_\-@\.]/i, '-')

          u.password = 'trac'

          u.admin = true if TracPermission.find_by_username_and_action(username, 'admin')

          # finally, a default user is used if the new user is not valid

          u = User.find(:first) unless u.save

        end

        # Make sure he is a member of the project

        if project_member && !u.member_of?(@target_project)

          role = DEFAULT_ROLE

          if u.admin

            role = ROLE_MAPPING['admin']

          elsif TracPermission.find_by_username_and_action(username, 'developer')

            role = ROLE_MAPPING['developer']

          end

          Member.create(:user => u, :project => @target_project, :roles => [role])

          u.reload

        end

        u

      end

      # Basic wiki syntax conversion

      def self.convert_wiki_text(text)

        # Titles

        text = text.gsub(/^(\=+)\s(.+)\s(\=+)/) {|s| "\nh#{$1.length}. #{$2}\n"}

        # External Links

        text = text.gsub(/\[(http[^\s]+)\s+([^\]]+)\]/) {|s| "\"#{$2}\":#{$1}"}

        # Ticket links:

        #      [ticket:234 Text],[ticket:234 This is a test]

        text = text.gsub(/\[ticket\:([^\ ]+)\ (.+?)\]/, '"\2":/issues/show/\1')

        #      ticket:1234

        #      #1 is working cause Redmine uses the same syntax.

        text = text.gsub(/ticket\:([^\ ]+)/, '#\1')

        # Milestone links:

        #      [milestone:"0.1.0 Mercury" Milestone 0.1.0 (Mercury)]

        #      The text "Milestone 0.1.0 (Mercury)" is not converted,

        #      cause Redmine's wiki does not support this.

        text = text.gsub(/\[milestone\:\"([^\"]+)\"\ (.+?)\]/, 'version:"\1"')

        #      [milestone:"0.1.0 Mercury"]

        text = text.gsub(/\[milestone\:\"([^\"]+)\"\]/, 'version:"\1"')

        text = text.gsub(/milestone\:\"([^\"]+)\"/, 'version:"\1"')

        #      milestone:0.1.0

        text = text.gsub(/\[milestone\:([^\ ]+)\]/, 'version:\1')

        text = text.gsub(/milestone\:([^\ ]+)/, 'version:\1')

        # Internal Links

        text = text.gsub(/\[\[BR\]\]/, "\n") # This has to go before the rules below

        text = text.gsub(/\[\"(.+)\".*\]/) {|s| "[[#{$1.delete(',./?;|:')}]]"}

        text = text.gsub(/\[wiki:\"(.+)\".*\]/) {|s| "[[#{$1.delete(',./?;|:')}]]"}

        text = text.gsub(/\[wiki:\"(.+)\".*\]/) {|s| "[[#{$1.delete(',./?;|:')}]]"}

        text = text.gsub(/\[wiki:([^\s\]]+)\]/) {|s| "[[#{$1.delete(',./?;|:')}]]"}

        text = text.gsub(/\[wiki:([^\s\]]+)\s(.*)\]/) {|s| "[[#{$1.delete(',./?;|:')}|#{$2.delete(',./?;|:')}]]"}

  # Links to pages UsingJustWikiCaps

  text = text.gsub(/([^!]|^)(^| )([A-Z][a-z]+[A-Z][a-zA-Z]+)/, '\\1\\2[[\3]]')

  # Normalize things that were supposed to not be links

  # like !NotALink

  text = text.gsub(/(^| )!([A-Z][A-Za-z]+)/, '\1\2')

        # Revisions links

        text = text.gsub(/\[(\d+)\]/, 'r\1')

        # Ticket number re-writing

        text = text.gsub(/#(\d+)/) do |s|

          if $1.length < 10

#            TICKET_MAP[$1.to_i] ||= $1

            "\##{TICKET_MAP[$1.to_i] || $1}"

          else

            s

          end

        end

        # We would like to convert the Code highlighting too

        # This will go into the next line.

        shebang_line = false

        # Reguar expression for start of code

        pre_re = /\{\{\{/

        # Code hightlighing...

        shebang_re = /^\#\!([a-z]+)/

        # Regular expression for end of code

        pre_end_re = /\}\}\}/

        # Go through the whole text..extract it line by line

        text = text.gsub(/^(.*)$/) do |line|

          m_pre = pre_re.match(line)

          if m_pre

            line = '<pre>'

          else

            m_sl = shebang_re.match(line)

            if m_sl

              shebang_line = true

              line = '<code class="' + m_sl[1] + '">'

            end

            m_pre_end = pre_end_re.match(line)

            if m_pre_end

              line = '</pre>'

              if shebang_line

                line = '</code>' + line

              end

            end

          end

          line

        end

        # Highlighting

        text = text.gsub(/'''''([^\s])/, '_*\1')

        text = text.gsub(/([^\s])'''''/, '\1*_')

        text = text.gsub(/'''/, '*')

        text = text.gsub(/''/, '_')

        text = text.gsub(/__/, '+')

        text = text.gsub(/~~/, '-')

        text = text.gsub(/`/, '@')

        text = text.gsub(/,,/, '~')

        # Lists

        text = text.gsub(/^([ ]+)\* /) {|s| '*' * $1.length + " "}

        text

      end

      def self.migrate

        establish_connection

        # Quick database test

        TracComponent.count

        migrated_components = 0

        migrated_milestones = 0

        migrated_tickets = 0

        migrated_custom_values = 0

        migrated_ticket_attachments = 0

        migrated_wiki_edits = 0

        migrated_wiki_attachments = 0

        #Wiki system initializing...

        @target_project.wiki.destroy if @target_project.wiki

        @target_project.reload

        wiki = Wiki.new(:project => @target_project, :start_page => 'WikiStart')

        wiki_edit_count = 0

        # Components

        print "Migrating components"

        issues_category_map = {}

        TracComponent.find(:all).each do |component|

        print '.'

        STDOUT.flush

          c = IssueCategory.new :project => @target_project,

                                :name => encode(component.name[0, limit_for(IssueCategory, 'name')])

        next unless c.save

        issues_category_map[component.name] = c

        migrated_components += 1

        end

        puts

        # Milestones

        print "Migrating milestones"

        version_map = {}

        TracMilestone.find(:all).each do |milestone|

          print '.'

          STDOUT.flush

          # First we try to find the wiki page...

          p = wiki.find_or_new_page(milestone.name.to_s)

          p.content = WikiContent.new(:page => p) if p.new_record?

          p.content.text = milestone.description.to_s

          p.content.author = find_or_create_user('trac')

          p.content.comments = 'Milestone'

          p.save

          v = Version.new :project => @target_project,

                          :name => encode(milestone.name[0, limit_for(Version, 'name')]),

                          :description => nil,

                          :wiki_page_title => milestone.name.to_s,

                          :effective_date => milestone.completed

          next unless v.save

          version_map[milestone.name] = v

          migrated_milestones += 1

        end

        puts

        # Custom fields

        # TODO: read trac.ini instead

        print "Migrating custom fields"

        custom_field_map = {}

        TracTicketCustom.find_by_sql("SELECT DISTINCT name FROM #{TracTicketCustom.table_name}").each do |field|

          print '.'

          STDOUT.flush

          # Redmine custom field name

          field_name = encode(field.name[0, limit_for(IssueCustomField, 'name')]).humanize

          # Find if the custom already exists in Redmine

          f = IssueCustomField.find_by_name(field_name)

          # Or create a new one

          f ||= IssueCustomField.create(:name => encode(field.name[0, limit_for(IssueCustomField, 'name')]).humanize,

                                        :field_format => 'string')

          next if f.new_record?

          f.trackers = Tracker.find(:all)

          f.projects << @target_project

          custom_field_map[field.name] = f

        end

        puts

        # Trac 'resolution' field as a Redmine custom field

        r = IssueCustomField.find(:first, :conditions => { :name => "Resolution" })

        r = IssueCustomField.new(:name => 'Resolution',

                                 :field_format => 'list',

                                 :is_filter => true) if r.nil?

        r.trackers = Tracker.find(:all)

        r.projects << @target_project

        r.possible_values = (r.possible_values + %w(fixed invalid wontfix duplicate worksforme)).flatten.compact.uniq

        r.save!

        custom_field_map['resolution'] = r

        # Tickets

        print "Migrating tickets"

          TracTicket.find_each(:batch_size => 200) do |ticket|

          print '.'

          STDOUT.flush

          i = Issue.new :project => @target_project,

                          :subject => encode(ticket.summary[0, limit_for(Issue, 'subject')]),

                          :description => convert_wiki_text(encode(ticket.description)),

                          :priority => PRIORITY_MAPPING[ticket.priority] || DEFAULT_PRIORITY,

                          :created_on => ticket.time

          i.author = find_or_create_user(ticket.reporter)

          i.category = issues_category_map[ticket.component] unless ticket.component.blank?

          i.fixed_version = version_map[ticket.milestone] unless ticket.milestone.blank?

          i.status = STATUS_MAPPING[ticket.status] || DEFAULT_STATUS

          i.tracker = TRACKER_MAPPING[ticket.ticket_type] || DEFAULT_TRACKER

          i.id = ticket.id unless Issue.exists?(ticket.id)

          next unless Time.fake(ticket.changetime) { i.save }

          TICKET_MAP[ticket.id] = i.id

          migrated_tickets += 1

          # Owner

            unless ticket.owner.blank?

              i.assigned_to = find_or_create_user(ticket.owner, true)

              Time.fake(ticket.changetime) { i.save }

            end

          # Comments and status/resolution changes

          ticket.ticket_changes.group_by(&:time).each do |time, changeset|

              status_change = changeset.select {|change| change.field == 'status'}.first

              resolution_change = changeset.select {|change| change.field == 'resolution'}.first

              comment_change = changeset.select {|change| change.field == 'comment'}.first

              n = Journal.new :notes => (comment_change ? convert_wiki_text(encode(comment_change.newvalue)) : ''),

                              :created_on => time

              n.user = find_or_create_user(changeset.first.author)

              n.journalized = i

              if status_change &&

                   STATUS_MAPPING[status_change.oldvalue] &&

                   STATUS_MAPPING[status_change.newvalue] &&

                   (STATUS_MAPPING[status_change.oldvalue] != STATUS_MAPPING[status_change.newvalue])

                n.details << JournalDetail.new(:property => 'attr',

                                               :prop_key => 'status_id',

                                               :old_value => STATUS_MAPPING[status_change.oldvalue].id,

                                               :value => STATUS_MAPPING[status_change.newvalue].id)

              end

              if resolution_change

                n.details << JournalDetail.new(:property => 'cf',

                                               :prop_key => custom_field_map['resolution'].id,

                                               :old_value => resolution_change.oldvalue,

                                               :value => resolution_change.newvalue)

              end

              n.save unless n.details.empty? && n.notes.blank?

          end

          # Attachments

          ticket.attachments.each do |attachment|

            next unless attachment.exist?

              attachment.open {

                a = Attachment.new :created_on => attachment.time

                a.file = attachment

                a.author = find_or_create_user(attachment.author)

                a.container = i

                a.description = attachment.description

                migrated_ticket_attachments += 1 if a.save

              }

          end

          # Custom fields

          custom_values = ticket.customs.inject({}) do |h, custom|

            if custom_field = custom_field_map[custom.name]

              h[custom_field.id] = custom.value

              migrated_custom_values += 1

            end

            h

          end

          if custom_field_map['resolution'] && !ticket.resolution.blank?

            custom_values[custom_field_map['resolution'].id] = ticket.resolution

          end

          i.custom_field_values = custom_values

          i.save_custom_field_values

        end

        # update issue id sequence if needed (postgresql)

        Issue.connection.reset_pk_sequence!(Issue.table_name) if Issue.connection.respond_to?('reset_pk_sequence!')

        puts

        # Wiki

        print "Migrating wiki"

        if wiki.save

          TracWikiPage.find(:all, :order => 'name, version').each do |page|

            # Do not migrate Trac manual wiki pages

            next if TRAC_WIKI_PAGES.include?(page.name)

            wiki_edit_count += 1

            print '.'

            STDOUT.flush

            p = wiki.find_or_new_page(page.name)

            p.content = WikiContent.new(:page => p) if p.new_record?

            p.content.text = page.text

            p.content.author = find_or_create_user(page.author) unless page.author.blank? || page.author == 'trac'

            p.content.comments = page.comment

            Time.fake(page.time) { p.new_record? ? p.save : p.content.save }

            next if p.content.new_record?

            migrated_wiki_edits += 1

            # Attachments

            page.attachments.each do |attachment|

              next unless attachment.exist?

              next if p.attachments.find_by_filename(attachment.filename.gsub(/^.*(\\|\/)/, '').gsub(/[^\w\.\-]/,'_')) #add only once per page

              attachment.open {

                a = Attachment.new :created_on => attachment.time

                a.file = attachment

                a.author = find_or_create_user(attachment.author)

                a.description = attachment.description

                a.container = p

                migrated_wiki_attachments += 1 if a.save

              }

            end

          end

          wiki.reload

          wiki.pages.each do |page|

            page.content.text = convert_wiki_text(page.content.text)

            Time.fake(page.content.updated_on) { page.content.save }

          end

        end

        puts

        puts

        puts "Components:      #{migrated_components}/#{TracComponent.count}"

        puts "Milestones:      #{migrated_milestones}/#{TracMilestone.count}"

        puts "Tickets:         #{migrated_tickets}/#{TracTicket.count}"

        puts "Ticket files:    #{migrated_ticket_attachments}/" + TracAttachment.count(:conditions => {:type => 'ticket'}).to_s

        puts "Custom values:   #{migrated_custom_values}/#{TracTicketCustom.count}"

        puts "Wiki edits:      #{migrated_wiki_edits}/#{wiki_edit_count}"

        puts "Wiki files:      #{migrated_wiki_attachments}/" + TracAttachment.count(:conditions => {:type => 'wiki'}).to_s

      end

      def self.limit_for(klass, attribute)

        klass.columns_hash[attribute.to_s].limit

      end

      def self.encoding(charset)

        @ic = Iconv.new('UTF-8', charset)

      rescue Iconv::InvalidEncoding

        puts "Invalid encoding!"

        return false

      end

      def self.set_trac_directory(path)

        @@trac_directory = path

        raise "This directory doesn't exist!" unless File.directory?(path)

        raise "#{trac_attachments_directory} doesn't exist!" unless File.directory?(trac_attachments_directory)

        @@trac_directory

      rescue Exception => e

        puts e

        return false

      end

      def self.trac_directory

        @@trac_directory

      end

      def self.set_trac_adapter(adapter)

        return false if adapter.blank?

        raise "Unknown adapter: #{adapter}!" unless %w(sqlite3 mysql postgresql).include?(adapter)

        # If adapter is sqlite or sqlite3, make sure that trac.db exists

        raise "#{trac_db_path} doesn't exist!" if %w(sqlite3).include?(adapter) && !File.exist?(trac_db_path)

        @@trac_adapter = adapter

      rescue Exception => e

        puts e

        return false

      end

      def self.set_trac_db_host(host)

        return nil if host.blank?

        @@trac_db_host = host

      end

      def self.set_trac_db_port(port)

        return nil if port.to_i == 0

        @@trac_db_port = port.to_i

      end

      def self.set_trac_db_name(name)

        return nil if name.blank?

        @@trac_db_name = name

      end

      def self.set_trac_db_username(username)

        @@trac_db_username = username

      end

      def self.set_trac_db_password(password)

        @@trac_db_password = password

      end

      def self.set_trac_db_schema(schema)

        @@trac_db_schema = schema

      end

      mattr_reader :trac_directory, :trac_adapter, :trac_db_host, :trac_db_port, :trac_db_name, :trac_db_schema, :trac_db_username, :trac_db_password

      def self.trac_db_path; "#{trac_directory}/db/trac.db" end

      def self.trac_attachments_directory; "#{trac_directory}/attachments" end

      def self.target_project_identifier(identifier)

        project = Project.find_by_identifier(identifier)

        if !project

          # create the target project

          project = Project.new :name => identifier.humanize,

                                :description => ''

          project.identifier = identifier

          puts "Unable to create a project with identifier '#{identifier}'!" unless project.save

          # enable issues and wiki for the created project

          project.enabled_module_names = ['issue_tracking', 'wiki']

        else

          puts

          puts "This project already exists in your Redmine database."

          print "Are you sure you want to append data to this project ? [Y/n] "

          STDOUT.flush

          exit if STDIN.gets.match(/^n$/i)

        end

        project.trackers << TRACKER_BUG unless project.trackers.include?(TRACKER_BUG)

        project.trackers << TRACKER_FEATURE unless project.trackers.include?(TRACKER_FEATURE)

        @target_project = project.new_record? ? nil : project

        @target_project.reload

      end

      def self.connection_params

        if trac_adapter == 'sqlite3'

          {:adapter => 'sqlite3',

           :database => trac_db_path}

        else

          {:adapter => trac_adapter,

           :database => trac_db_name,

           :host => trac_db_host,

           :port => trac_db_port,

           :username => trac_db_username,

           :password => trac_db_password,

           :schema_search_path => trac_db_schema

          }

        end

      end

      def self.establish_connection

        constants.each do |const|

          klass = const_get(const)

          next unless klass.respond_to? 'establish_connection'

          klass.establish_connection connection_params

        end

      end

    private

      def self.encode(text)

        @ic.iconv text

      rescue

        text

      end

    end

    puts

    if Redmine::DefaultData::Loader.no_data?

      puts "Redmine configuration need to be loaded before importing data."

      puts "Please, run this first:"

      puts

      puts "  rake redmine:load_default_data RAILS_ENV=\"#{ENV['RAILS_ENV']}\""

      exit

    end

    puts "WARNING: a new project will be added to Redmine during this process."

    print "Are you sure you want to continue ? [y/N] "

    STDOUT.flush

    break unless STDIN.gets.match(/^y$/i)

    puts

    def prompt(text, options = {}, &block)

      default = options[:default] || ''

      while true

        print "#{text} [#{default}]: "

        STDOUT.flush

        value = STDIN.gets.chomp!

        value = default if value.blank?

        break if yield value

      end

    end

    DEFAULT_PORTS = {'mysql' => 3306, 'postgresql' => 5432}

    prompt('Trac directory') {|directory| TracMigrate.set_trac_directory directory.strip}

    prompt('Trac database adapter (sqlite3, mysql2, postgresql)', :default => 'sqlite3') {|adapter| TracMigrate.set_trac_adapter adapter}

    unless %w(sqlite3).include?(TracMigrate.trac_adapter)

      prompt('Trac database host', :default => 'localhost') {|host| TracMigrate.set_trac_db_host host}

      prompt('Trac database port', :default => DEFAULT_PORTS[TracMigrate.trac_adapter]) {|port| TracMigrate.set_trac_db_port port}

      prompt('Trac database name') {|name| TracMigrate.set_trac_db_name name}

      prompt('Trac database schema', :default => 'public') {|schema| TracMigrate.set_trac_db_schema schema}

      prompt('Trac database username') {|username| TracMigrate.set_trac_db_username username}

      prompt('Trac database password') {|password| TracMigrate.set_trac_db_password password}

    end

    prompt('Trac database encoding', :default => 'UTF-8') {|encoding| TracMigrate.encoding encoding}

    prompt('Target project identifier') {|identifier| TracMigrate.target_project_identifier identifier}

    puts

    # Turn off email notifications

    Setting.notified_events = []

    TracMigrate.migrate

  end

end

OpenIdAuthentication

====================

Provides a thin wrapper around the excellent ruby-openid gem from JanRan. Be sure to install that first:

  gem install ruby-openid

To understand what OpenID is about and how it works, it helps to read the documentation for lib/openid/consumer.rb

from that gem.

The specification used is http://openid.net/specs/openid-authentication-2_0.html.

Prerequisites

=============

OpenID authentication uses the session, so be sure that you haven't turned that off.

Alternatively, you can use the file-based store, which just relies on on tmp/openids being present in RAILS_ROOT. But be aware that this store only works if you have a single application server. And it's not safe to use across NFS. It's recommended that you use the database store if at all possible. To use the file-based store, you'll also have to add this line to your config/environment.rb:

  OpenIdAuthentication.store = :file

This particular plugin also relies on the fact that the authentication action allows for both POST and GET operations.

If you're using RESTful authentication, you'll need to explicitly allow for this in your routes.rb.

The plugin also expects to find a root_url method that points to the home page of your site. You can accomplish this by using a root route in config/routes.rb:

  map.root :controller => 'articles'

This plugin relies on Rails Edge revision 6317 or newer.

Example

=======

This example is just to meant to demonstrate how you could use OpenID authentication. You might well want to add

salted hash logins instead of plain text passwords and other requirements on top of this. Treat it as a starting point,

not a destination.

Note that the User model referenced in the simple example below has an 'identity_url' attribute. You will want to add the same or similar field to whatever

model you are using for authentication.

Also of note is the following code block used in the example below:

  authenticate_with_open_id do |result, identity_url|

    ...

  end

In the above code block, 'identity_url' will need to match user.identity_url exactly. 'identity_url' will be a string in the form of 'http://example.com' -

If you are storing just 'example.com' with your user, the lookup will fail.

There is a handy method in this plugin called 'normalize_url' that will help with validating OpenID URLs.

  OpenIdAuthentication.normalize_url(user.identity_url)

The above will return a standardized version of the OpenID URL - the above called with 'example.com' will return 'http://example.com/'

It will also raise an InvalidOpenId exception if the URL is determined to not be valid.

Use the above code in your User model and validate OpenID URLs before saving them.

config/routes.rb