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 File.expand_path('../../test_helper', __FILE__)

class RepositoriesGitControllerTest < ActionController::TestCase

  tests RepositoriesController

  fixtures :projects, :users, :roles, :members, :member_roles,

           :repositories, :enabled_modules

  REPOSITORY_PATH = Rails.root.join('tmp/test/git_repository').to_s

  REPOSITORY_PATH.gsub!(/\//, "\\") if Redmine::Platform.mswin?

  PRJ_ID     = 3

  CHAR_1_HEX = "\xc3\x9c"

  NUM_REV = 28

  ## Git, Mercurial and CVS path encodings are binary.

  ## Subversion supports URL encoding for path.

  ## Redmine Mercurial adapter and extension use URL encoding.

  ## Git accepts only binary path in command line parameter.

  ## So, there is no way to use binary command line parameter in JRuby.

  JRUBY_SKIP     = (RUBY_PLATFORM == 'java')

  JRUBY_SKIP_STR = "TODO: This test fails in JRuby"

  def setup

    @ruby19_non_utf8_pass =

      (RUBY_VERSION >= '1.9' && Encoding.default_external.to_s != 'UTF-8')

    User.current = nil

    @project    = Project.find(PRJ_ID)

    @repository = Repository::Git.create(

                      :project       => @project,

                      :url           => REPOSITORY_PATH,

                      :path_encoding => 'ISO-8859-1'

                      )

    assert @repository

    @char_1        = CHAR_1_HEX.dup

    if @char_1.respond_to?(:force_encoding)

      @char_1.force_encoding('UTF-8')

    end

  end

  def test_create_and_update

    @request.session[:user_id] = 1

    assert_difference 'Repository.count' do

      post :create, :project_id => 'subproject1',

                    :repository_scm => 'Git',

                    :repository => {

                       :url => '/test',

                       :is_default => '0',

                       :identifier => 'test-create',

                       :extra_report_last_commit => '1',

                     }

    end

    assert_response 302

    repository = Repository.first(:order => 'id DESC')

    assert_kind_of Repository::Git, repository

    assert_equal '/test', repository.url

    assert_equal true, repository.extra_report_last_commit

    put :update, :id => repository.id,

                 :repository => {

                     :extra_report_last_commit => '0'

                 }

    assert_response 302

    repo2 = Repository.find(repository.id)

    assert_equal false, repo2.extra_report_last_commit

  end

  if File.directory?(REPOSITORY_PATH)

    ## Ruby uses ANSI api to fork a process on Windows.

    ## Japanese Shift_JIS and Traditional Chinese Big5 have 0x5c(backslash) problem

    ## and these are incompatible with ASCII.

    ## Git for Windows (msysGit) changed internal API from ANSI to Unicode in 1.7.10

    ## http://code.google.com/p/msysgit/issues/detail?id=80

    ## So, Latin-1 path tests fail on Japanese Windows

    WINDOWS_PASS = (Redmine::Platform.mswin? &&

                         Redmine::Scm::Adapters::GitAdapter.client_version_above?([1, 7, 10]))

    WINDOWS_SKIP_STR = "TODO: This test fails in Git for Windows above 1.7.10"

    def test_get_new

      @request.session[:user_id] = 1

      @project.repository.destroy

      get :new, :project_id => 'subproject1', :repository_scm => 'Git'

      assert_response :success

      assert_template 'new'

      assert_kind_of Repository::Git, assigns(:repository)

      assert assigns(:repository).new_record?

    end

    def test_browse_root

      assert_equal 0, @repository.changesets.count

      @repository.fetch_changesets

      @project.reload

      assert_equal NUM_REV, @repository.changesets.count

      get :show, :id => PRJ_ID

      assert_response :success

      assert_template 'show'

      assert_not_nil assigns(:entries)

      assert_equal 9, assigns(:entries).size

      assert assigns(:entries).detect {|e| e.name == 'images' && e.kind == 'dir'}

      assert assigns(:entries).detect {|e| e.name == 'this_is_a_really_long_and_verbose_directory_name' && e.kind == 'dir'}

      assert assigns(:entries).detect {|e| e.name == 'sources' && e.kind == 'dir'}

      assert assigns(:entries).detect {|e| e.name == 'README' && e.kind == 'file'}

      assert assigns(:entries).detect {|e| e.name == 'copied_README' && e.kind == 'file'}

      assert assigns(:entries).detect {|e| e.name == 'new_file.txt' && e.kind == 'file'}

      assert assigns(:entries).detect {|e| e.name == 'renamed_test.txt' && e.kind == 'file'}

      assert assigns(:entries).detect {|e| e.name == 'filemane with spaces.txt' && e.kind == 'file'}

      assert assigns(:entries).detect {|e| e.name == ' filename with a leading space.txt ' && e.kind == 'file'}

      assert_not_nil assigns(:changesets)

      assert assigns(:changesets).size > 0

    end

    def test_browse_branch

      assert_equal 0, @repository.changesets.count

      @repository.fetch_changesets

      @project.reload

      assert_equal NUM_REV, @repository.changesets.count

      get :show, :id => PRJ_ID, :rev => 'test_branch'

      assert_response :success

      assert_template 'show'

      assert_not_nil assigns(:entries)

      assert_equal 4, assigns(:entries).size

      assert assigns(:entries).detect {|e| e.name == 'images' && e.kind == 'dir'}

      assert assigns(:entries).detect {|e| e.name == 'sources' && e.kind == 'dir'}

      assert assigns(:entries).detect {|e| e.name == 'README' && e.kind == 'file'}

      assert assigns(:entries).detect {|e| e.name == 'test.txt' && e.kind == 'file'}

      assert_not_nil assigns(:changesets)

      assert assigns(:changesets).size > 0

    end

    def test_browse_tag

      assert_equal 0, @repository.changesets.count

      @repository.fetch_changesets

      @project.reload

      assert_equal NUM_REV, @repository.changesets.count

       [

        "tag00.lightweight",

        "tag01.annotated",

       ].each do |t1|

        get :show, :id => PRJ_ID, :rev => t1

        assert_response :success

        assert_template 'show'

        assert_not_nil assigns(:entries)

        assert assigns(:entries).size > 0

        assert_not_nil assigns(:changesets)

        assert assigns(:changesets).size > 0

      end

    end

    def test_browse_directory

      assert_equal 0, @repository.changesets.count

      @repository.fetch_changesets

      @project.reload

      assert_equal NUM_REV, @repository.changesets.count

      get :show, :id => PRJ_ID, :path => repository_path_hash(['images'])[:param]

      assert_response :success

      assert_template 'show'

      assert_not_nil assigns(:entries)

      assert_equal ['edit.png'], assigns(:entries).collect(&:name)

      entry = assigns(:entries).detect {|e| e.name == 'edit.png'}

      assert_not_nil entry

      assert_equal 'file', entry.kind

      assert_equal 'images/edit.png', entry.path

      assert_not_nil assigns(:changesets)

      assert assigns(:changesets).size > 0

    end

    def test_browse_at_given_revision

      assert_equal 0, @repository.changesets.count

      @repository.fetch_changesets

      @project.reload

      assert_equal NUM_REV, @repository.changesets.count

      get :show, :id => PRJ_ID, :path => repository_path_hash(['images'])[:param],

          :rev => '7234cb2750b63f47bff735edc50a1c0a433c2518'

      assert_response :success

      assert_template 'show'

      assert_not_nil assigns(:entries)

      assert_equal ['delete.png'], assigns(:entries).collect(&:name)

      assert_not_nil assigns(:changesets)

      assert assigns(:changesets).size > 0

    end

    def test_changes

      get :changes, :id => PRJ_ID,

          :path => repository_path_hash(['images', 'edit.png'])[:param]

      assert_response :success

      assert_template 'changes'

      assert_tag :tag => 'h2', :content => 'edit.png'

    end

    def test_entry_show

      get :entry, :id => PRJ_ID,

          :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param]

      assert_response :success

      assert_template 'entry'

      # Line 19

      assert_tag :tag => 'th',

                 :content => '11',

                 :attributes => { :class => 'line-num' },

                 :sibling => { :tag => 'td', :content => /WITHOUT ANY WARRANTY/ }

    end

    def test_entry_show_latin_1

      if @ruby19_non_utf8_pass

        puts_ruby19_non_utf8_pass()

      elsif WINDOWS_PASS

        puts WINDOWS_SKIP_STR

      elsif JRUBY_SKIP

        puts JRUBY_SKIP_STR

      else

        with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do

          ['57ca437c', '57ca437c0acbbcb749821fdf3726a1367056d364'].each do |r1|

            get :entry, :id => PRJ_ID,

                :path => repository_path_hash(['latin-1-dir', "test-#{@char_1}.txt"])[:param],

                :rev => r1

            assert_response :success

            assert_template 'entry'

            assert_tag :tag => 'th',

                   :content => '1',

                   :attributes => { :class => 'line-num' },

                   :sibling => { :tag => 'td',

                                 :content => /test-#{@char_1}.txt/ }

          end

        end

      end

    end

    def test_entry_download

      get :entry, :id => PRJ_ID,

          :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param],

          :format => 'raw'

      assert_response :success

      # File content

      assert @response.body.include?('WITHOUT ANY WARRANTY')

    end

    def test_directory_entry

      get :entry, :id => PRJ_ID,

          :path => repository_path_hash(['sources'])[:param]

      assert_response :success

      assert_template 'show'

      assert_not_nil assigns(:entry)

      assert_equal 'sources', assigns(:entry).name

    end

    def test_diff

      assert_equal true, @repository.is_default

      assert_nil @repository.identifier

      assert_equal 0, @repository.changesets.count

      @repository.fetch_changesets

      @project.reload

      assert_equal NUM_REV, @repository.changesets.count

      # Full diff of changeset 2f9c0091

      ['inline', 'sbs'].each do |dt|

        get :diff,

            :id   => PRJ_ID,

            :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7',

            :type => dt

        assert_response :success

        assert_template 'diff'

        # Line 22 removed

        assert_tag :tag => 'th',

                   :content => /22/,

                   :sibling => { :tag => 'td',

                                 :attributes => { :class => /diff_out/ },

                                 :content => /def remove/ }

        assert_tag :tag => 'h2', :content => /2f9c0091/

      end

    end

    def test_diff_with_rev_and_path

      assert_equal 0, @repository.changesets.count

      @repository.fetch_changesets

      @project.reload

      assert_equal NUM_REV, @repository.changesets.count

      with_settings :diff_max_lines_displayed => 1000 do

        # Full diff of changeset 2f9c0091

        ['inline', 'sbs'].each do |dt|

          get :diff,

              :id   => PRJ_ID,

              :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7',

              :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param],

              :type => dt

          assert_response :success

          assert_template 'diff'

          # Line 22 removed

          assert_tag :tag => 'th',

                     :content => '22',

                     :sibling => { :tag => 'td',

                                   :attributes => { :class => /diff_out/ },

                                   :content => /def remove/ }

          assert_tag :tag => 'h2', :content => /2f9c0091/

        end

      end

    end

    def test_diff_truncated

      assert_equal 0, @repository.changesets.count

      @repository.fetch_changesets

      @project.reload

      assert_equal NUM_REV, @repository.changesets.count

      with_settings :diff_max_lines_displayed => 5 do

        # Truncated diff of changeset 2f9c0091

        with_cache do

          with_settings :default_language => 'en' do

            get :diff, :id   => PRJ_ID, :type => 'inline',

                :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7'

            assert_response :success

            assert @response.body.include?("... This diff was truncated")

          end

          with_settings :default_language => 'fr' do

            get :diff, :id   => PRJ_ID, :type => 'inline',

                :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7'

            assert_response :success

            assert ! @response.body.include?("... This diff was truncated")

            assert @response.body.include?("... Ce diff")

          end

        end

      end

    end

    def test_diff_two_revs

      assert_equal 0, @repository.changesets.count

      @repository.fetch_changesets

      @project.reload

      assert_equal NUM_REV, @repository.changesets.count

      ['inline', 'sbs'].each do |dt|

        get :diff,

            :id     => PRJ_ID,

            :rev    => '61b685fbe55ab05b5ac68402d5720c1a6ac973d1',

            :rev_to => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7',

            :type   => dt

        assert_response :success

        assert_template 'diff'

        diff = assigns(:diff)

        assert_not_nil diff

        assert_tag :tag => 'h2', :content => /2f9c0091:61b685fb/

        assert_tag :tag => "form",

                   :attributes => {

                     :action => "/projects/subproject1/repository/revisions/" +

                                   "61b685fbe55ab05b5ac68402d5720c1a6ac973d1/diff"

                   }

        assert_tag :tag => 'input',

                   :attributes => {

                     :id => "rev_to",

                     :name => "rev_to",

                     :type => "hidden",

                     :value => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7'

                   }

      end

    end

    def test_diff_path_in_subrepo

      repo = Repository::Git.create(

                      :project       => @project,

                      :url           => REPOSITORY_PATH,

                      :identifier => 'test-diff-path',

                      :path_encoding => 'ISO-8859-1'

                      );

      assert repo

      assert_equal false, repo.is_default

      assert_equal 'test-diff-path', repo.identifier

      get :diff,

          :id     => PRJ_ID,

          :repository_id => 'test-diff-path',

          :rev    => '61b685fbe55ab05b',

          :rev_to => '2f9c0091c754a91a',

          :type   => 'inline'

      assert_response :success

      assert_template 'diff'

      diff = assigns(:diff)

      assert_not_nil diff

      assert_tag :tag => "form",

                 :attributes => {

                   :action => "/projects/subproject1/repository/test-diff-path/" + 

                                "revisions/61b685fbe55ab05b/diff"

                 }

      assert_tag :tag => 'input',

                 :attributes => {

                   :id => "rev_to",

                   :name => "rev_to",

                   :type => "hidden",

                   :value => '2f9c0091c754a91a'

                 }

    end

    def test_diff_latin_1

      if @ruby19_non_utf8_pass

        puts_ruby19_non_utf8_pass()

      else

        with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do

          ['57ca437c', '57ca437c0acbbcb749821fdf3726a1367056d364'].each do |r1|

            ['inline', 'sbs'].each do |dt|

              get :diff, :id => PRJ_ID, :rev => r1, :type => dt

              assert_response :success

              assert_template 'diff'

              assert_tag :tag => 'thead',

                         :descendant => {

                           :tag => 'th',

                           :attributes => { :class => 'filename' } ,

                           :content => /latin-1-dir\/test-#{@char_1}.txt/ ,

                          },

                         :sibling => {

                           :tag => 'tbody',

                           :descendant => {

                              :tag => 'td',

                              :attributes => { :class => /diff_in/ },

                              :content => /test-#{@char_1}.txt/

                           }

                         }

            end

          end

        end

      end

    end

    def test_diff_should_show_filenames

      get :diff, :id => PRJ_ID, :rev => 'deff712f05a90d96edbd70facc47d944be5897e3', :type => 'inline'

      assert_response :success

      assert_template 'diff'

      # modified file

      assert_select 'th.filename', :text => 'sources/watchers_controller.rb'

      # deleted file

      assert_select 'th.filename', :text => 'test.txt'

    end

    def test_save_diff_type

      user1 = User.find(1)

      user1.pref[:diff_type] = nil

      user1.preference.save

      user = User.find(1)

      assert_nil user.pref[:diff_type]

      @request.session[:user_id] = 1 # admin

      get :diff,

          :id   => PRJ_ID,

          :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7'

      assert_response :success

      assert_template 'diff'

      user.reload

      assert_equal "inline", user.pref[:diff_type]

      get :diff,

          :id   => PRJ_ID,

          :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7',

          :type => 'sbs'

      assert_response :success

      assert_template 'diff'

      user.reload

      assert_equal "sbs", user.pref[:diff_type]

    end

    def test_annotate

      get :annotate, :id => PRJ_ID,

          :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param]

      assert_response :success

      assert_template 'annotate'

      # Line 23, changeset 2f9c0091

      assert_select 'tr' do

        assert_select 'th.line-num', :text => '23'

        assert_select 'td.revision', :text => /2f9c0091/

        assert_select 'td.author', :text => 'jsmith'

        assert_select 'td', :text => /remove_watcher/

      end

    end

    def test_annotate_at_given_revision

      assert_equal 0, @repository.changesets.count

      @repository.fetch_changesets

      @project.reload

      assert_equal NUM_REV, @repository.changesets.count

      get :annotate, :id => PRJ_ID, :rev => 'deff7',

          :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param]

      assert_response :success

      assert_template 'annotate'

      assert_tag :tag => 'h2', :content => /@ deff712f/

    end

    def test_annotate_binary_file

      get :annotate, :id => PRJ_ID,

          :path => repository_path_hash(['images', 'edit.png'])[:param]

      assert_response 500

      assert_tag :tag => 'p', :attributes => { :id => /errorExplanation/ },

                              :content => /cannot be annotated/

    end

    def test_annotate_error_when_too_big

      with_settings :file_max_size_displayed => 1 do

        get :annotate, :id => PRJ_ID,

            :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param],

            :rev => 'deff712f'

        assert_response 500

        assert_tag :tag => 'p', :attributes => { :id => /errorExplanation/ },

                                :content => /exceeds the maximum text file size/

        get :annotate, :id => PRJ_ID,

            :path => repository_path_hash(['README'])[:param],

            :rev => '7234cb2'

        assert_response :success

        assert_template 'annotate'

      end

    end

    def test_annotate_latin_1

      if @ruby19_non_utf8_pass

        puts_ruby19_non_utf8_pass()

      elsif WINDOWS_PASS

        puts WINDOWS_SKIP_STR

      elsif JRUBY_SKIP

        puts JRUBY_SKIP_STR

      else

        with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do

          ['57ca437c', '57ca437c0acbbcb749821fdf3726a1367056d364'].each do |r1|

            get :annotate, :id => PRJ_ID,

                :path => repository_path_hash(['latin-1-dir', "test-#{@char_1}.txt"])[:param],

                :rev => r1

            assert_tag :tag => 'th',

                       :content => '1',

                       :attributes => { :class => 'line-num' },

                       :sibling => { :tag => 'td',

                                     :content => /test-#{@char_1}.txt/ }

          end

        end

      end

    end

    def test_revisions

      assert_equal 0, @repository.changesets.count

      @repository.fetch_changesets

      @project.reload

      assert_equal NUM_REV, @repository.changesets.count

      get :revisions, :id => PRJ_ID

      assert_response :success

      assert_template 'revisions'

      assert_tag :tag => 'form',

                 :attributes => {

                   :method => 'get',

                   :action => '/projects/subproject1/repository/revision'

                 }

    end

    def test_revision

      assert_equal 0, @repository.changesets.count

      @repository.fetch_changesets

      @project.reload

      assert_equal NUM_REV, @repository.changesets.count

      ['61b685fbe55ab05b5ac68402d5720c1a6ac973d1', '61b685f'].each do |r|

        get :revision, :id => PRJ_ID, :rev => r

        assert_response :success

        assert_template 'revision'

      end

    end

    def test_empty_revision

      assert_equal 0, @repository.changesets.count

      @repository.fetch_changesets

      @project.reload

      assert_equal NUM_REV, @repository.changesets.count

      ['', ' ', nil].each do |r|

        get :revision, :id => PRJ_ID, :rev => r

        assert_response 404

        assert_error_tag :content => /was not found/

      end

    end

    def test_destroy_valid_repository

      @request.session[:user_id] = 1 # admin

      assert_equal 0, @repository.changesets.count

      @repository.fetch_changesets

      @project.reload

      assert_equal NUM_REV, @repository.changesets.count

      assert_difference 'Repository.count', -1 do

        delete :destroy, :id => @repository.id

      end

      assert_response 302

      @project.reload

      assert_nil @project.repository

    end

    def test_destroy_invalid_repository

      @request.session[:user_id] = 1 # admin

      @project.repository.destroy

      @repository = Repository::Git.create!(

                      :project       => @project,

                      :url           => "/invalid",

                      :path_encoding => 'ISO-8859-1'

                      )

      @repository.fetch_changesets

      @repository.reload

      assert_equal 0, @repository.changesets.count

      assert_difference 'Repository.count', -1 do

        delete :destroy, :id => @repository.id

      end

      assert_response 302

      @project.reload

      assert_nil @project.repository

    end

    private

    def puts_ruby19_non_utf8_pass

      puts "TODO: This test fails in Ruby 1.9 " +

           "and Encoding.default_external is not UTF-8. " +

           "Current value is '#{Encoding.default_external.to_s}'"

    end

  else

    puts "Git test repository NOT FOUND. Skipping functional tests !!!"

    def test_fake; assert true end

  end

  private

  def with_cache(&block)

    before = ActionController::Base.perform_caching

    ActionController::Base.perform_caching = true

    block.call

    ActionController::Base.perform_caching = before

  end

end

/* ***** BEGIN LICENSE BLOCK *****

 * This file is part of DotClear.

 * Copyright (c) 2005 Nicolas Martin & Olivier Meunier and contributors. All

 * rights reserved.

 *

 * DotClear 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.

 * 

 * DotClear 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 DotClear; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * ***** END LICENSE BLOCK *****

*/

/* Modified by JP LANG for textile formatting */

function jsToolBar(textarea) {

	if (!document.createElement) { return; }

	if (!textarea) { return; }

	if ((typeof(document["selection"]) == "undefined")

	&& (typeof(textarea["setSelectionRange"]) == "undefined")) {

		return;

	}

	this.textarea = textarea;

	this.editor = document.createElement('div');

	this.editor.className = 'jstEditor';

	this.textarea.parentNode.insertBefore(this.editor,this.textarea);

	this.editor.appendChild(this.textarea);

	this.toolbar = document.createElement("div");

	this.toolbar.className = 'jstElements';

	this.editor.parentNode.insertBefore(this.toolbar,this.editor);

	// Dragable resizing

	if (this.editor.addEventListener && navigator.appVersion.match(/\bMSIE\b/))

	{

		this.handle = document.createElement('div');

		this.handle.className = 'jstHandle';

		var dragStart = this.resizeDragStart;

		var This = this;

		this.handle.addEventListener('mousedown',function(event) { dragStart.call(This,event); },false);

		// fix memory leak in Firefox (bug #241518)

		window.addEventListener('unload',function() { 

				var del = This.handle.parentNode.removeChild(This.handle);

				delete(This.handle);

		},false);

		this.editor.parentNode.insertBefore(this.handle,this.editor.nextSibling);

	}

	this.context = null;

	this.toolNodes = {}; // lorsque la toolbar est dessinée , cet objet est garni 

					// de raccourcis vers les éléments DOM correspondants aux outils.

}

function jsButton(title, fn, scope, className) {

    if(typeof jsToolBar.strings == 'undefined') {

      this.title = title || null;

    } else {

      this.title = jsToolBar.strings[title] || title || null;

    }

	this.fn = fn || function(){};

	this.scope = scope || null;

	this.className = className || null;

}

jsButton.prototype.draw = function() {

	if (!this.scope) return null;

	var button = document.createElement('button');

	button.setAttribute('type','button');

	button.tabIndex = 200;

	if (this.className) button.className = this.className;

	button.title = this.title;

	var span = document.createElement('span');

	span.appendChild(document.createTextNode(this.title));

	button.appendChild(span);

	if (this.icon != undefined) {

		button.style.backgroundImage = 'url('+this.icon+')';

	}

	if (typeof(this.fn) == 'function') {

		var This = this;

		button.onclick = function() { try { This.fn.apply(This.scope, arguments) } catch (e) {} return false; };

	}

	return button;

}

function jsSpace(id) {

	this.id = id || null;

	this.width = null;

}

jsSpace.prototype.draw = function() {

	var span = document.createElement('span');

	if (this.id) span.id = this.id;

	span.appendChild(document.createTextNode(String.fromCharCode(160)));

	span.className = 'jstSpacer';

	if (this.width) span.style.marginRight = this.width+'px';

	return span;

} 

function jsCombo(title, options, scope, fn, className) {

	this.title = title || null;

	this.options = options || null;

	this.scope = scope || null;

	this.fn = fn || function(){};

	this.className = className || null;

}

jsCombo.prototype.draw = function() {

	if (!this.scope || !this.options) return null;

	var select = document.createElement('select');

	if (this.className) select.className = className;

	select.title = this.title;

	for (var o in this.options) {

		//var opt = this.options[o];

		var option = document.createElement('option');

		option.value = o;

		option.appendChild(document.createTextNode(this.options[o]));

		select.appendChild(option);

	}

	var This = this;

	select.onchange = function() {

		try { 

			This.fn.call(This.scope, this.value);

		} catch (e) { alert(e); }

		return false;

	}

	return select;

}

jsToolBar.prototype = {

	base_url: '',

	mode: 'wiki',

	elements: {},

	help_link: '',

	getMode: function() {

		return this.mode;

	},

	setMode: function(mode) {

		this.mode = mode || 'wiki';

	},

	switchMode: function(mode) {

		mode = mode || 'wiki';

		this.draw(mode);

	},

	setHelpLink: function(link) {

		this.help_link = link;

	},

	button: function(toolName) {

		var tool = this.elements[toolName];

		if (typeof tool.fn[this.mode] != 'function') return null;

		var b = new jsButton(tool.title, tool.fn[this.mode], this, 'jstb_'+toolName);

		if (tool.icon != undefined) b.icon = tool.icon;

		return b;

	},

	space: function(toolName) {

		var tool = new jsSpace(toolName)

		if (this.elements[toolName].width !== undefined)

			tool.width = this.elements[toolName].width;

		return tool;

	},

	combo: function(toolName) {

		var tool = this.elements[toolName];

		var length = tool[this.mode].list.length;

		if (typeof tool[this.mode].fn != 'function' || length == 0) {

			return null;

		} else {

			var options = {};

			for (var i=0; i < length; i++) {

				var opt = tool[this.mode].list[i];

				options[opt] = tool.options[opt];

			}

			return new jsCombo(tool.title, options, this, tool[this.mode].fn);

		}

	},

	draw: function(mode) {

		this.setMode(mode);

		// Empty toolbar

		while (this.toolbar.hasChildNodes()) {

			this.toolbar.removeChild(this.toolbar.firstChild)

		}

		this.toolNodes = {}; // vide les raccourcis DOM/**/

		var h = document.createElement('div');

		h.className = 'help'

		h.innerHTML = this.help_link;

		'<a href="/help/wiki_syntax.html" onclick="window.open(\'/help/wiki_syntax.html\', \'\', \'resizable=yes, location=no, width=300, height=640, menubar=no, status=no, scrollbars=yes\'); return false;">Aide</a>';

		this.toolbar.appendChild(h);

		// Draw toolbar elements

		var b, tool, newTool;

		for (var i in this.elements) {

			b = this.elements[i];

			var disabled =

			b.type == undefined || b.type == ''

			|| (b.disabled != undefined && b.disabled)

			|| (b.context != undefined && b.context != null && b.context != this.context);

			if (!disabled && typeof this[b.type] == 'function') {

				tool = this[b.type](i);

				if (tool) newTool = tool.draw();

				if (newTool) {

					this.toolNodes[i] = newTool; //mémorise l'accès DOM pour usage éventuel ultérieur

					this.toolbar.appendChild(newTool);

				}

			}

		}

	},

	singleTag: function(stag,etag) {

		stag = stag || null;

		etag = etag || stag;

		if (!stag || !etag) { return; }

		this.encloseSelection(stag,etag);

	},

	encloseLineSelection: function(prefix, suffix, fn) {

		this.textarea.focus();

		prefix = prefix || '';

		suffix = suffix || '';

		var start, end, sel, scrollPos, subst, res;

		if (typeof(document["selection"]) != "undefined") {

			sel = document.selection.createRange().text;

		} else if (typeof(this.textarea["setSelectionRange"]) != "undefined") {

			start = this.textarea.selectionStart;

			end = this.textarea.selectionEnd;

			scrollPos = this.textarea.scrollTop;

			// go to the start of the line

			start = this.textarea.value.substring(0, start).replace(/[^\r\n]*$/g,'').length;

			// go to the end of the line

            end = this.textarea.value.length - this.textarea.value.substring(end, this.textarea.value.length).replace(/^[^\r\n]*/, '').length;

			sel = this.textarea.value.substring(start, end);

		}

		if (sel.match(/ $/)) { // exclude ending space char, if any

			sel = sel.substring(0, sel.length - 1);

			suffix = suffix + " ";

		}

		if (typeof(fn) == 'function') {

			res = (sel) ? fn.call(this,sel) : fn('');

		} else {

			res = (sel) ? sel : '';

		}

		subst = prefix + res + suffix;

		if (typeof(document["selection"]) != "undefined") {

			document.selection.createRange().text = subst;

			var range = this.textarea.createTextRange();

			range.collapse(false);

			range.move('character', -suffix.length);

			range.select();

		} else if (typeof(this.textarea["setSelectionRange"]) != "undefined") {

			this.textarea.value = this.textarea.value.substring(0, start) + subst +

			this.textarea.value.substring(end);

			if (sel) {

				this.textarea.setSelectionRange(start + subst.length, start + subst.length);

			} else {

				this.textarea.setSelectionRange(start + prefix.length, start + prefix.length);

			}

			this.textarea.scrollTop = scrollPos;

		}

	},

	encloseSelection: function(prefix, suffix, fn) {

		this.textarea.focus();

		prefix = prefix || '';

		suffix = suffix || '';

		var start, end, sel, scrollPos, subst, res;

		if (typeof(document["selection"]) != "undefined") {

			sel = document.selection.createRange().text;

		} else if (typeof(this.textarea["setSelectionRange"]) != "undefined") {

			start = this.textarea.selectionStart;

			end = this.textarea.selectionEnd;

			scrollPos = this.textarea.scrollTop;

			sel = this.textarea.value.substring(start, end);

		}

		if (sel.match(/ $/)) { // exclude ending space char, if any

			sel = sel.substring(0, sel.length - 1);

			suffix = suffix + " ";

		}

		if (typeof(fn) == 'function') {

			res = (sel) ? fn.call(this,sel) : fn('');

		} else {

			res = (sel) ? sel : '';

		}

		subst = prefix + res + suffix;

		if (typeof(document["selection"]) != "undefined") {

			document.selection.createRange().text = subst;

			var range = this.textarea.createTextRange();

			range.collapse(false);

			range.move('character', -suffix.length);

			range.select();

//			this.textarea.caretPos -= suffix.length;

		} else if (typeof(this.textarea["setSelectionRange"]) != "undefined") {

			this.textarea.value = this.textarea.value.substring(0, start) + subst +

			this.textarea.value.substring(end);

			if (sel) {

				this.textarea.setSelectionRange(start + subst.length, start + subst.length);

			} else {

				this.textarea.setSelectionRange(start + prefix.length, start + prefix.length);

			}

			this.textarea.scrollTop = scrollPos;

		}

	},

	stripBaseURL: function(url) {

		if (this.base_url != '') {

			var pos = url.indexOf(this.base_url);

			if (pos == 0) {

				url = url.substr(this.base_url.length);

			}

		}

		return url;

	}

};

/** Resizer

-------------------------------------------------------- */

jsToolBar.prototype.resizeSetStartH = function() {

	this.dragStartH = this.textarea.offsetHeight + 0;

};

jsToolBar.prototype.resizeDragStart = function(event) {

	var This = this;

	this.dragStartY = event.clientY;

	this.resizeSetStartH();

	document.addEventListener('mousemove', this.dragMoveHdlr=function(event){This.resizeDragMove(event);}, false);

	document.addEventListener('mouseup', this.dragStopHdlr=function(event){This.resizeDragStop(event);}, false);

};

jsToolBar.prototype.resizeDragMove = function(event) {

	this.textarea.style.height = (this.dragStartH+event.clientY-this.dragStartY)+'px';

};

jsToolBar.prototype.resizeDragStop = function(event) {

	document.removeEventListener('mousemove', this.dragMoveHdlr, false);

	document.removeEventListener('mouseup', this.dragStopHdlr, false);

};

# encoding: utf-8

#

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

  # Displays view/delete links to the attachments of the given object

  # Options:

  #   :author -- author names are not displayed if set to false

  #   :thumbails -- display thumbnails if enabled in settings

  def link_to_attachments(container, options = {})

    options.assert_valid_keys(:author, :thumbnails)

    if container.attachments.any?

      options = {:deletable => container.attachments_deletable?, :author => true}.merge(options)

      render :partial => 'attachments/links',

        :locals => {:attachments => container.attachments, :options => options, :thumbnails => (options[:thumbnails] && Setting.thumbnails_enabled?)}

    end

  end

  def render_api_attachment(attachment, api)

    api.attachment do

      api.id attachment.id

      api.filename attachment.filename

      api.filesize attachment.filesize

      api.content_type attachment.content_type

      api.description attachment.description

      api.content_url url_for(:controller => 'attachments', :action => 'download', :id => attachment, :filename => attachment.filename, :only_path => false)

      api.author(:id => attachment.author.id, :name => attachment.author.name) if attachment.author

      api.created_on attachment.created_on

    end

  end

end

require 'SVG/Graph/Plot'

module SVG

  module Graph

    # === For creating SVG plots of scalar temporal data

    # 

    # = Synopsis

    # 

    #   require 'SVG/Graph/TimeSeriess'

    # 

    #   # Data sets are x,y pairs

    #   data1 = ["6/17/72", 11,    "1/11/72", 7,    "4/13/04 17:31", 11, 

    #           "9/11/01", 9,    "9/1/85", 2,    "9/1/88", 1,    "1/15/95", 13]

    #   data2 = ["8/1/73", 18,    "3/1/77", 15,    "10/1/98", 4, 

    #           "5/1/02", 14,    "3/1/95", 6,    "8/1/91", 12,    "12/1/87", 6, 

    #           "5/1/84", 17,    "10/1/80", 12]

    #

    #   graph = SVG::Graph::TimeSeries.new( {

    #     :width => 640,

    #     :height => 480,

    #     :graph_title => title,

    #     :show_graph_title => true,

    #     :no_css => true,

    #     :key => true,

    #     :scale_x_integers => true,

    #     :scale_y_integers => true,

    #     :min_x_value => 0,

    #     :min_y_value => 0,

    #     :show_data_labels => true,

    #     :show_x_guidelines => true,

    #     :show_x_title => true,

    #     :x_title => "Time",

    #     :show_y_title => true,

    #     :y_title => "Ice Cream Cones",

    #     :y_title_text_direction => :bt,

    #     :stagger_x_labels => true,

    #     :x_label_format => "%m/%d/%y",

    #   })

    #   

    #   graph.add_data({

    #   	:data => projection

    # 	  :title => 'Projected',

    #   })

    # 

    #   graph.add_data({

    #   	:data => actual,

    # 	  :title => 'Actual',

    #   })

    #   

    #   print graph.burn()

    #

    # = Description

    # 

    # Produces a graph of temporal scalar data.

    # 

    # = Examples

    #

    # http://www.germane-software/repositories/public/SVG/test/timeseries.rb

    # 

    # = Notes

    # 

    # The default stylesheet handles upto 10 data sets, if you

    # use more you must create your own stylesheet and add the

    # additional settings for the extra data sets. You will know

    # if you go over 10 data sets as they will have no style and

    # be in black.

    #

    # Unlike the other types of charts, data sets must contain x,y pairs:

    #

    #   [ "12:30", 2 ]          # A data set with 1 point: ("12:30",2)

    #   [ "01:00",2, "14:20",6] # A data set with 2 points: ("01:00",2) and 

    #                           #                           ("14:20",6)  

    #

    # Note that multiple data sets within the same chart can differ in length, 

    # and that the data in the datasets needn't be in order; they will be ordered

    # by the plot along the X-axis.

    # 

    # The dates must be parseable by ParseDate, but otherwise can be

    # any order of magnitude (seconds within the hour, or years)

    # 

    # = See also

    # 

    # * SVG::Graph::Graph

    # * SVG::Graph::BarHorizontal

    # * SVG::Graph::Bar

    # * SVG::Graph::Line

    # * SVG::Graph::Pie

    # * SVG::Graph::Plot

    #

    # == Author

    #

    # Sean E. Russell <serATgermaneHYPHENsoftwareDOTcom>

    #

    # Copyright 2004 Sean E. Russell

    # This software is available under the Ruby license[LICENSE.txt]

    #

    class TimeSeries < Plot

      # In addition to the defaults set by Graph::initialize and

      # Plot::set_defaults, sets:

      # [x_label_format] '%Y-%m-%d %H:%M:%S'

      # [popup_format]  '%Y-%m-%d %H:%M:%S'

      def set_defaults

        super

        init_with(

          #:max_time_span     => '',

          :x_label_format     => '%Y-%m-%d %H:%M:%S',

          :popup_format       => '%Y-%m-%d %H:%M:%S'

        )

      end

      # The format string use do format the X axis labels.

      # See Time::strformat

      attr_accessor :x_label_format

      # Use this to set the spacing between dates on the axis.  The value

      # must be of the form 

      # "\d+ ?(days|weeks|months|years|hours|minutes|seconds)?"

      # 

      # EG:

      #

      #   graph.timescale_divisions = "2 weeks"

      #

      # will cause the chart to try to divide the X axis up into segments of

      # two week periods.

      attr_accessor :timescale_divisions

      # The formatting used for the popups.  See x_label_format

      attr_accessor :popup_format

      # Add data to the plot.

      #

      #   d1 = [ "12:30", 2 ]          # A data set with 1 point: ("12:30",2)

      #   d2 = [ "01:00",2, "14:20",6] # A data set with 2 points: ("01:00",2) and 

      #                                #                           ("14:20",6)  

      #   graph.add_data( 

      #     :data => d1,

      #     :title => 'One'

      #   )

      #   graph.add_data(

      #     :data => d2,

      #     :title => 'Two'

      #   )

      #

      # Note that the data must be in time,value pairs, and that the date format

      # may be any date that is parseable by ParseDate.

      def add_data data

        @data = [] unless @data

        raise "No data provided by #{@data.inspect}" unless data[:data] and

                                                    data[:data].kind_of? Array

        raise "Data supplied must be x,y pairs!  "+

          "The data provided contained an odd set of "+

          "data points" unless data[:data].length % 2 == 0

        return if data[:data].length == 0

        x = []

        y = []

        data[:data].each_index {|i|

          if i%2 == 0

            t = DateTime.parse( data[:data][i] ).to_time

            x << t.to_i

          else

            y << data[:data][i]

          end

        }

        sort( x, y )

        data[:data] = [x,y]

        @data << data

      end

      protected

      def min_x_value=(value)

        @min_x_value = DateTime.parse( value ).to_time

      end

      def format x, y

        Time.at( x ).strftime( popup_format )

      end

      def get_x_labels

        get_x_values.collect { |v| Time.at(v).strftime( x_label_format ) }

      end

      private

      def get_x_values

        rv = []

        min, max, scale_division = x_range

        if timescale_divisions

          timescale_divisions =~ /(\d+) ?(day|week|month|year|hour|minute|second)?/

          division_units = $2 ? $2 : "day"

          amount = $1.to_i

          if amount

            step =  nil

            case division_units

            when "month"

              cur = min

              while cur < max

                rv << cur

                arr = Time.at( cur ).to_a

                arr[4] += amount

                if arr[4] > 12

                  arr[5] += (arr[4] / 12).to_i

                  arr[4] = (arr[4] % 12)

                end

                cur = Time.local(*arr).to_i

              end

            when "year"

              cur = min

              while cur < max

                rv << cur

                arr = Time.at( cur ).to_a

                arr[5] += amount

                cur = Time.local(*arr).to_i

              end

            when "week"

              step = 7 * 24 * 60 * 60 * amount

            when "day"

              step = 24 * 60 * 60 * amount

            when "hour"

              step = 60 * 60 * amount

            when "minute"

              step = 60 * amount

            when "second"

              step = amount

            end

            min.step( max, step ) {|v| rv << v} if step

            return rv

          end

        end

        min.step( max, scale_division ) {|v| rv << v}

        return rv

      end

    end

  end

end