SoundSoftware Code Site

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

if RUBY_VERSION < '1.9'

  require 'iconv'

end

        if str.respond_to?(:force_encoding)

          begin

            str.force_encoding(encoding)

            utf8 = str.encode('UTF-8')

            return utf8 if utf8.valid_encoding?

          rescue

            # do nothing here and try the next encoding

          end

        else

          begin

            return Iconv.conv('UTF-8', encoding, str)

          rescue Iconv::Failure

            # do nothing here and try the next encoding

          end

# Copyright (C) 2006-2013  Jean-Philippe Lang

      'email_delivery' => nil,

      'max_concurrent_ajax_uploads' => 2

# Copyright (C) 2006-2013  Jean-Philippe Lang

class DateValidator < ActiveModel::EachValidator

  def validate_each(record, attribute, value)

    before_type_cast = record.attributes_before_type_cast[attribute.to_s]

    if before_type_cast.is_a?(String) && before_type_cast.present?

      # TODO: #*_date_before_type_cast returns a Mysql::Time with ruby1.8+mysql gem

      unless before_type_cast =~ /\A\d{4}-\d{2}-\d{2}( 00:00:00)?\z/ && value

        record.errors.add attribute, :not_a_date

      end

    end

  end

end

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

          !Role.where(:builtin => 0).exists? &&

            !Tracker.exists? &&

            !IssueStatus.exists? &&

            !Enumeration.exists?

            Tracker.all.each { |t|

              IssueStatus.all.each { |os|

                IssueStatus.all.each { |ns|

            Tracker.all.each { |t|

            Tracker.all.each { |t|

# Copyright (C) 2006-2013  Jean-Philippe Lang

if RUBY_VERSION < '1.9'

  require 'iconv'

end

            utf16txt = to_utf16(txt)

        # Encodes an UTF-8 string to UTF-16BE

        def to_utf16(str)

          if str.respond_to?(:encode)

            str.encode('UTF-16BE')

          else

            Iconv.conv('UTF-16BE', 'UTF-8', str)

          end

        end

            utf16txt = to_utf16(txt)

      def render_table_header(pdf, query, col_width, row_height, table_width)

        pdf.Rect(base_x, base_y, table_width, max_height, 'FD');

        issues_to_pdf_draw_borders(pdf, base_x, base_y, base_y + max_height, 0, col_width)

        left_margin   = 10

        table_width = page_width - right_margin - left_margin

          col_width = calc_col_width(issues, query, table_width, pdf)

        # use full width if the description is displayed

          col_width = col_width.map {|w| w * (page_width - right_margin - left_margin) / table_width}

        render_table_header(pdf, query, col_width, row_height, table_width)

            pdf.RDMCell(table_width, row_height * 2, group_label, 1, 1, 'L')

            render_table_header(pdf, query, col_width, row_height, table_width)

          issues_to_pdf_draw_borders(pdf, base_x, base_y, base_y + max_height, 0, col_width)

      #

      #  parameter "col_id_width" is not used. it is kept for compatibility.

                                     col_id_width, col_widths)

        col_x = top_x

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

      # Relation types that are rendered

      DRAW_TYPES = {

        IssueRelation::TYPE_BLOCKS   => { :landscape_margin => 16, :color => '#F34F4F' },

        IssueRelation::TYPE_PRECEDES => { :landscape_margin => 20, :color => '#628FEA' }

      }.freeze

      # Returns a hash of the relations between the issues that are present on the gantt

      # and that should be displayed, grouped by issue ids.

      def relations

        return @relations if @relations

        if issues.any?

          issue_ids = issues.map(&:id)

          @relations = IssueRelation.

            where(:issue_from_id => issue_ids, :issue_to_id => issue_ids, :relation_type => DRAW_TYPES.keys).

            group_by(&:issue_from_id)

        else

          @relations = {}

        end

      end

          html_class << ' version-closed' unless version.open?

          if version.start_date && version.due_date && version.completed_pourcent

            progress_date = calc_progress_date(version.start_date,

                                               version.due_date, version.completed_pourcent)

            html_class << ' behind-start-date' if progress_date < self.date_from

            html_class << ' over-end-date' if progress_date > self.date_to

          end

          html_subject(options, subject, :css => "version-name",

                       :id => "version-#{version.id}")

        if version.is_a?(Version) && version.due_date && version.start_date

                               version.due_date, version.completed_percent,

          label = "#{h version} #{h version.completed_percent.to_i.to_s}%"

            html_task(options, coords, :css => "version task",

                      :label => label, :markers => true, :version => version)

          css_classes << ' issue-closed' if issue.closed?

          if issue.start_date && issue.due_before && issue.done_ratio

            progress_date = calc_progress_date(issue.start_date,

                                               issue.due_before, issue.done_ratio)

            css_classes << ' behind-start-date' if progress_date < self.date_from

            css_classes << ' over-end-date' if progress_date > self.date_to

          end

                       :title => issue.subject, :id => "issue-#{issue.id}") + "\n"

            progress_date = calc_progress_date(start_date, end_date, progress)

      def calc_progress_date(start_date, end_date, progress)

        start_date + (end_date - start_date + 1) * (progress / 100.0)

      end

      # TODO: Sorts a collection of issues by start_date, due_date, id for gantt rendering

        output = view.content_tag(:div, subject,

                                  :title => options[:title],

                                  :id => options[:id])

      def issue_relations(issue)

        rels = {}

        if relations[issue.id]

          relations[issue.id].each do |relation|

            (rels[relation.relation_type] ||= []) << relation.issue_to_id

          end

        end

        rels

      end

          html_id = "task-todo-issue-#{options[:issue].id}" if options[:issue]

          html_id = "task-todo-version-#{options[:version].id}" if options[:version]

          content_opt = {:style => style,

                         :class => "#{options[:css]} task_todo",

                         :id => html_id}

          if options[:issue]

            rels = issue_relations(options[:issue])

            if rels.present?

              content_opt[:data] = {"rels" => rels.to_json}

            end

          end

          output << view.content_tag(:div, '&nbsp;'.html_safe, content_opt)

            html_id = "task-done-issue-#{options[:issue].id}" if options[:issue]

            html_id = "task-done-version-#{options[:version].id}" if options[:version]

                                       :class => "#{options[:css]} task_done",

                                       :id => html_id)

# Copyright (C) 2006-2013  Jean-Philippe Lang

      attr_reader :criteria, :columns, :hours, :total_hours, :periods

      def initialize(project, issue, criteria, columns, time_entry_scope)

        @scope = time_entry_scope

          @scope.sum(:hours,

              :include => [:issue, :activity],

              :group => @criteria.collect{|criteria| @available_criteria[criteria][:sql]} + time_columns,

              :joins => @criteria.collect{|criteria| @available_criteria[criteria][:joins]}.compact).each do |hash, hours|

              row['week'] = "#{row['spent_on'].cwyear}-#{row['tweek']}"

          min = @hours.collect {|row| row['spent_on']}.min

          @from = min ? min.to_date : Date.today

          max = @hours.collect {|row| row['spent_on']}.max

          @to = max ? max.to_date : Date.today

              @periods << "#{date_from.to_date.cwyear}-#{date_from.to_date.cweek}"

                                 'user' => {:sql => "#{TimeEntry.table_name}.user_id",

                                             :label => :label_user},

        # Add time entry custom fields

        custom_fields = TimeEntryCustomField.all

        # Add project custom fields

        custom_fields += ProjectCustomField.all

        # Add issue custom fields

        custom_fields += (@project.nil? ? IssueCustomField.for_all : @project.all_issue_custom_fields)

        # Add time entry activity custom fields

        custom_fields += TimeEntryActivityCustomField.all

          @available_criteria["cf_#{cf.id}"] = {:sql => "#{cf.join_alias}.value",

                                                 :joins => cf.join_for_order_statement,

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

      # * Checking the url target (project only)

        if project && user && !user.allowed_to?(node.url, project)

          return false

        end

        return true

# Copyright (C) 2006-2013  Jean-Philippe Lang

# encoding: utf-8

#

# Redmine - project management software

# Copyright (C) 2006-2013  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

module Redmine

  module Pagination

    class Paginator

      attr_reader :item_count, :per_page, :page, :page_param

      def initialize(*args)

        if args.first.is_a?(ActionController::Base)

          args.shift

          ActiveSupport::Deprecation.warn "Paginator no longer takes a controller instance as the first argument. Remove it from #new arguments."

        end

        item_count, per_page, page, page_param = *args

        @item_count = item_count

        @per_page = per_page

        page = (page || 1).to_i

        if page < 1

          page = 1

        end

        @page = page

        @page_param = page_param || :page

      end

      def offset

        (page - 1) * per_page

      end

      def first_page

        if item_count > 0

          1

        end

      end

      def previous_page

        if page > 1

          page - 1

        end

      end

      def next_page

        if last_item < item_count

          page + 1

        end

      end

      def last_page

        if item_count > 0

          (item_count - 1) / per_page + 1

        end

      end

      def first_item

        item_count == 0 ? 0 : (offset + 1)

      end

      def last_item

        l = first_item + per_page - 1

        l > item_count ? item_count : l

      end

      def linked_pages

        pages = []

        if item_count > 0

          pages += [first_page, page, last_page]

          pages += ((page-2)..(page+2)).to_a.select {|p| p > first_page && p < last_page}

        end

        pages = pages.compact.uniq.sort

        if pages.size > 1

          pages

        else

          []

        end

      end

      def items_per_page

        ActiveSupport::Deprecation.warn "Paginator#items_per_page will be removed. Use #per_page instead."

        per_page

      end

      def current

        ActiveSupport::Deprecation.warn "Paginator#current will be removed. Use .offset instead of .current.offset."

        self

      end

    end

    # Paginates the given scope or model. Returns a Paginator instance and

    # the collection of objects for the current page.

    #

    # Options:

    #   :parameter     name of the page parameter

    #

    # Examples:

    #   @user_pages, @users = paginate User.where(:status => 1)

    #

    def paginate(scope, options={})

      options = options.dup

      finder_options = options.extract!(

        :conditions,

        :order,

        :joins,

        :include,

        :select

      )

      if scope.is_a?(Symbol) || finder_options.values.compact.any?

        return deprecated_paginate(scope, finder_options, options)

      end

      paginator = paginator(scope.count, options)

      collection = scope.limit(paginator.per_page).offset(paginator.offset).to_a

      return paginator, collection

    end

    def deprecated_paginate(arg, finder_options, options={})

      ActiveSupport::Deprecation.warn "#paginate with a Symbol and/or find options is depreceted and will be removed. Use a scope instead."

      klass = arg.is_a?(Symbol) ? arg.to_s.classify.constantize : arg

      scope = klass.scoped(finder_options)

      paginate(scope, options)

    end

    def paginator(item_count, options={})

      options.assert_valid_keys :parameter, :per_page

      page_param = options[:parameter] || :page

      page = (params[page_param] || 1).to_i

      per_page = options[:per_page] || per_page_option

      Paginator.new(item_count, per_page, page, page_param)

    end

    module Helper

      include Redmine::I18n

      # Renders the pagination links for the given paginator.

      #

      # Options:

      #   :per_page_links    if set to false, the "Per page" links are not rendered

      #

      def pagination_links_full(*args)

        pagination_links_each(*args) do |text, parameters, options|

          if block_given?

            yield text, parameters, options

          else

            link_to text, params.merge(parameters), options

          end

        end

      end

      # Yields the given block with the text and parameters

      # for each pagination link and returns a string that represents the links

      def pagination_links_each(paginator, count=nil, options={}, &block)

        options.assert_valid_keys :per_page_links

        per_page_links = options.delete(:per_page_links)

        per_page_links = false if count.nil?

        page_param = paginator.page_param

        html = ''

        if paginator.previous_page

          # \xc2\xab(utf-8) = «

          text = "\xc2\xab " + l(:label_previous)

          html << yield(text, {page_param => paginator.previous_page}, :class => 'previous') + ' '

        end

        previous = nil

        paginator.linked_pages.each do |page|

          if previous && previous != page - 1

            html << content_tag('span', '...', :class => 'spacer') + ' '

          end

          if page == paginator.page

            html << content_tag('span', page.to_s, :class => 'current page')

          else

            html << yield(page.to_s, {page_param => page}, :class => 'page')

          end

          html << ' '

          previous = page

        end

        if paginator.next_page

          # \xc2\xbb(utf-8) = »

          text = l(:label_next) + " \xc2\xbb"

          html << yield(text, {page_param => paginator.next_page}, :class => 'next') + ' '

        end

        html << content_tag('span', "(#{paginator.first_item}-#{paginator.last_item}/#{paginator.item_count})", :class => 'items') + ' '

        if per_page_links != false && links = per_page_links(paginator, &block)

          html << content_tag('span', links.to_s, :class => 'per-page')

        end

        html.html_safe

      end

      # Renders the "Per page" links.

      def per_page_links(paginator, &block)

        values = per_page_options(paginator.per_page, paginator.item_count)

        if values.any?

          links = values.collect do |n|

            if n == paginator.per_page

              content_tag('span', n.to_s)

            else

              yield(n, :per_page => n, paginator.page_param => nil)

            end

          end

          l(:label_display_per_page, links.join(', ')).html_safe

        end

      end

      def per_page_options(selected=nil, item_count=nil)

        options = Setting.per_page_options_array

        if item_count && options.any?

          if item_count > options.first

            max = options.detect {|value| value >= item_count} || item_count

          else

            max = item_count

          end

          options = options.select {|value| value <= max || value == selected}

        end

        if options.empty? || (options.size == 1 && options.first == selected)

          []

        else

          options

        end

      end

    end

  end

end

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

    def to_param

      id

    end

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

if RUBY_VERSION < '1.9'

  require 'iconv'

end

        # Path to the file where scm stderr output is logged

        # Returns nil if the log file is not writable

        def self.stderr_log_file

          if @stderr_log_file.nil?

            writable = false

            path = Redmine::Configuration['scm_stderr_log_file'].presence

            path ||= Rails.root.join("log/#{Rails.env}.scm.stderr.log").to_s

            if File.exists?(path)

              if File.file?(path) && File.writable?(path) 

                writable = true

              else

                logger.warn("SCM log file (#{path}) is not writable")

              end

            else

              begin

                File.open(path, "w") {}

                writable = true

              rescue => e

                logger.warn("SCM log file (#{path}) cannot be created: #{e.message}")

              end

            end

            @stderr_log_file = writable ? path : false

          end

          @stderr_log_file || nil

        end

            # Capture stderr in a log file

            if stderr_log_file

              cmd = "#{cmd} 2>>#{shell_quote(stderr_log_file)}"

            end

# Copyright (C) 2006-2013  Jean-Philippe Lang

              name_locale, slash, revision = $3.strip, $4, $5.strip

                                    :kind => (slash.blank? ? 'file' : 'dir'),

                                    :lastrev => Revision.new(:revision => revision)

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

          @scms || []

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

      diff.each do |line_raw|

        line = Redmine::CodesetUtil.to_utf8_by_setting(line_raw)

        unless diff_table.add_line(line)

        if line =~ %r{^[^\+\-\s@\\]}

        if (! "".respond_to?(:force_encoding)) && starting < line_left.size

          while line_left[starting].ord.between?(128, 191) && starting > 0

            starting -= 1

          end

        end

        if (! "".respond_to?(:force_encoding)) && ending > (-1 * line_left.size)

          while line_left[ending].ord.between?(128, 191) && ending > -1

            ending -= 1

          end

        end

      html = line_to_html_raw(line, offsets)

      html.force_encoding('UTF-8') if html.respond_to?(:force_encoding)

      html

    end

    def line_to_html_raw(line, offsets)

# Copyright (C) 2006-2013  Jean-Philippe Lang

    MINOR = 3

    TINY  = 1

# Copyright (C) 2006-2013  Jean-Philippe Lang

# Copyright (C) 2006-2013  Jean-Philippe Lang

require 'redmine/views/builders/json'

require 'redmine/views/builders/xml'