SoundSoftware Code Site

require 'SVG/Graph/Graph'

module SVG

  module Graph

    # === For creating SVG plots of scalar data

    # 

    # = Synopsis

    # 

    #   require 'SVG/Graph/Plot'

    # 

    #   # Data sets are x,y pairs

    #   # Note that multiple data sets 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.

    #   projection = [

    #     6, 11,    0, 5,   18, 7,   1, 11,   13, 9,   1, 2,   19, 0,   3, 13,

    #     7, 9 

    #   ]

    #   actual = [

    #     0, 18,    8, 15,    9, 4,   18, 14,   10, 2,   11, 6,  14, 12,   

    #     15, 6,   4, 17,   2, 12

    #   ]

    #   

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

    #   	:height => 500,

    #    	:width => 300,

    #     :key => true,

    #     :scale_x_integers => true,

    #     :scale_y_integerrs => true,

    #   })

    #   

    #   graph.add_data({

    #   	:data => projection

    # 	  :title => 'Projected',

    #   })

    # 

    #   graph.add_data({

    #   	:data => actual,

    # 	  :title => 'Actual',

    #   })

    #   

    #   print graph.burn()

    # 

    # = Description

    # 

    # Produces a graph of scalar data.

    # 

    # This object aims to allow you to easily create high quality

    # SVG[http://www.w3c.org/tr/svg] scalar plots. You can either use the

    # default style sheet or supply your own. Either way there are many options

    # which can be configured to give you control over how the graph is

    # generated - with or without a key, data elements at each point, title,

    # subtitle etc.

    #

    # = Examples

    # 

    # http://www.germane-software/repositories/public/SVG/test/plot.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:

    #

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

    #   [ 1,2, 5,6] # A data set with 2 points: (1,2) and (5,6)  

    # 

    # = See also

    # 

    # * SVG::Graph::Graph

    # * SVG::Graph::BarHorizontal

    # * SVG::Graph::Bar

    # * SVG::Graph::Line

    # * SVG::Graph::Pie

    # * SVG::Graph::TimeSeries

    #

    # == Author

    #

    # Sean E. Russell <serATgermaneHYPHENsoftwareDOTcom>

    #

    # Copyright 2004 Sean E. Russell

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

    #

    class Plot < Graph

      # In addition to the defaults set by Graph::initialize, sets

      # [show_data_values] true

      # [show_data_points] true

      # [area_fill] false

      # [stacked] false

      def set_defaults

        init_with(

                  :show_data_values  => true,

                  :show_data_points  => true,

                  :area_fill         => false,

                  :stacked           => false

                 )

                 self.top_align = self.right_align = self.top_font = self.right_font = 1

      end

      # Determines the scaling for the X axis divisions.

      #

      #   graph.scale_x_divisions = 2

      #

      # would cause the graph to attempt to generate labels stepped by 2; EG:

      # 0,2,4,6,8...

      attr_accessor :scale_x_divisions

      # Determines the scaling for the Y axis divisions.

      #

      #   graph.scale_y_divisions = 0.5

      #

      # would cause the graph to attempt to generate labels stepped by 0.5; EG:

      # 0, 0.5, 1, 1.5, 2, ...

      attr_accessor :scale_y_divisions 

      # Make the X axis labels integers

      attr_accessor :scale_x_integers 

      # Make the Y axis labels integers

      attr_accessor :scale_y_integers 

      # Fill the area under the line

      attr_accessor :area_fill 

      # Show a small circle on the graph where the line

      # goes from one point to the next.

      attr_accessor :show_data_points

      # Set the minimum value of the X axis

      attr_accessor :min_x_value 

      # Set the minimum value of the Y axis

      attr_accessor :min_y_value

      # Adds data to the plot.  The data must be in X,Y pairs; EG

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

      #   [ 1,2, 5,6] # A data set with 2 points: (1,2) and (5,6)  

      def add_data data

        @data = [] unless @data

        raise "No data provided by #{conf.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|

          (i%2 == 0 ? x : y) << data[:data][i]

        }

        sort( x, y )

        data[:data] = [x,y]

        @data << data

      end

      protected

      def keys

        @data.collect{ |x| x[:title] }

      end

      def calculate_left_margin

        super

        label_left = get_x_labels[0].to_s.length / 2 * font_size * 0.6

        @border_left = label_left if label_left > @border_left

      end

      def calculate_right_margin

        super

        label_right = get_x_labels[-1].to_s.length / 2 * font_size * 0.6

        @border_right = label_right if label_right > @border_right

      end

      X = 0

      Y = 1

      def x_range

        max_value = @data.collect{|x| x[:data][X][-1] }.max

        min_value = @data.collect{|x| x[:data][X][0] }.min

        min_value = min_value<min_x_value ? min_value : min_x_value if min_x_value

        range = max_value - min_value

        right_pad = range == 0 ? 10 : range / 20.0

        scale_range = (max_value + right_pad) - min_value

        scale_division = scale_x_divisions || (scale_range / 10.0)

        if scale_x_integers

          scale_division = scale_division < 1 ? 1 : scale_division.round

        end

        [min_value, max_value, scale_division]

      end

      def get_x_values

        min_value, max_value, scale_division = x_range

        rv = []

        min_value.step( max_value, scale_division ) {|v| rv << v}

        return rv

      end

      alias :get_x_labels :get_x_values

      def field_width

        values = get_x_values

        max = @data.collect{|x| x[:data][X][-1]}.max

        dx = (max - values[-1]).to_f / (values[-1] - values[-2])

        (@graph_width.to_f - font_size*2*right_font) /

          (values.length + dx - right_align)

      end

      def y_range

        max_value = @data.collect{|x| x[:data][Y].max }.max

        min_value = @data.collect{|x| x[:data][Y].min }.min

        min_value = min_value<min_y_value ? min_value : min_y_value if min_y_value

        range = max_value - min_value

        top_pad = range == 0 ? 10 : range / 20.0

        scale_range = (max_value + top_pad) - min_value

        scale_division = scale_y_divisions || (scale_range / 10.0)

        if scale_y_integers

          scale_division = scale_division < 1 ? 1 : scale_division.round

        end

        return [min_value, max_value, scale_division]

      end

      def get_y_values

        min_value, max_value, scale_division = y_range

        rv = []

        min_value.step( max_value, scale_division ) {|v| rv << v}

        return rv

      end

      alias :get_y_labels :get_y_values

      def field_height

        values = get_y_values

        max = @data.collect{|x| x[:data][Y].max }.max

        if values.length == 1

          dx = values[-1]

        else

          dx = (max - values[-1]).to_f / (values[-1] - values[-2])

        end

        (@graph_height.to_f - font_size*2*top_font) /

          (values.length + dx - top_align)

      end

      def draw_data

        line = 1

        x_min, x_max, x_div = x_range

        y_min, y_max, y_div = y_range

        x_step = (@graph_width.to_f - font_size*2) / (x_max-x_min)

        y_step = (@graph_height.to_f -  font_size*2) / (y_max-y_min)

        for data in @data

          x_points = data[:data][X]

          y_points = data[:data][Y]

          lpath = "L"

          x_start = 0

          y_start = 0

          x_points.each_index { |idx|

            x = (x_points[idx] -  x_min) * x_step

            y = @graph_height - (y_points[idx] -  y_min) * y_step

            x_start, y_start = x,y if idx == 0

            lpath << "#{x} #{y} "

          }

          if area_fill

            @graph.add_element( "path", {

              "d" => "M#{x_start} #@graph_height #{lpath} V#@graph_height Z",

              "class" => "fill#{line}"

            })

          end

          @graph.add_element( "path", {

            "d" => "M#{x_start} #{y_start} #{lpath}",

            "class" => "line#{line}"

          })

          if show_data_points || show_data_values

            x_points.each_index { |idx|

              x = (x_points[idx] -  x_min) * x_step

              y = @graph_height - (y_points[idx] -  y_min) * y_step

              if show_data_points

                @graph.add_element( "circle", {

                  "cx" => x.to_s,

                  "cy" => y.to_s,

                  "r" => "2.5",

                  "class" => "dataPoint#{line}"

                })

                add_popup(x, y, format( x_points[idx], y_points[idx] )) if add_popups

              end

              make_datapoint_text( x, y-6, y_points[idx] ) if show_data_values

            }

          end

          line += 1

        end

      end

      def format x, y

        "(#{(x * 100).to_i / 100}, #{(y * 100).to_i / 100})"

      end

      def get_css

        return <<EOL

/* default line styles */

.line1{

	fill: none;

	stroke: #ff0000;

	stroke-width: 1px;	

}

.line2{

	fill: none;

	stroke: #0000ff;

	stroke-width: 1px;	

}

.line3{

	fill: none;

	stroke: #00ff00;

	stroke-width: 1px;	

}

.line4{

	fill: none;

	stroke: #ffcc00;

	stroke-width: 1px;	

}

.line5{

	fill: none;

	stroke: #00ccff;

	stroke-width: 1px;	

}

.line6{

	fill: none;

	stroke: #ff00ff;

	stroke-width: 1px;	

}

.line7{

	fill: none;

	stroke: #00ffff;

	stroke-width: 1px;	

}

.line8{

	fill: none;

	stroke: #ffff00;

	stroke-width: 1px;	

}

.line9{

	fill: none;

	stroke: #ccc6666;

	stroke-width: 1px;	

}

.line10{

	fill: none;

	stroke: #663399;

	stroke-width: 1px;	

}

.line11{

	fill: none;

	stroke: #339900;

	stroke-width: 1px;	

}

.line12{

	fill: none;

	stroke: #9966FF;

	stroke-width: 1px;	

}

/* default fill styles */

.fill1{

	fill: #cc0000;

	fill-opacity: 0.2;

	stroke: none;

}

.fill2{

	fill: #0000cc;

	fill-opacity: 0.2;

	stroke: none;

}

.fill3{

	fill: #00cc00;

	fill-opacity: 0.2;

	stroke: none;

}

.fill4{

	fill: #ffcc00;

	fill-opacity: 0.2;

	stroke: none;

}

.fill5{

	fill: #00ccff;

	fill-opacity: 0.2;

	stroke: none;

}

.fill6{

	fill: #ff00ff;

	fill-opacity: 0.2;

	stroke: none;

}

.fill7{

	fill: #00ffff;

	fill-opacity: 0.2;

	stroke: none;

}

.fill8{

	fill: #ffff00;

	fill-opacity: 0.2;

	stroke: none;

}

.fill9{

	fill: #cc6666;

	fill-opacity: 0.2;

	stroke: none;

}

.fill10{

	fill: #663399;

	fill-opacity: 0.2;

	stroke: none;

}

.fill11{

	fill: #339900;

	fill-opacity: 0.2;

	stroke: none;

}

.fill12{

	fill: #9966FF;

	fill-opacity: 0.2;

	stroke: none;

}

/* default line styles */

.key1,.dataPoint1{

	fill: #ff0000;

	stroke: none;

	stroke-width: 1px;	

}

.key2,.dataPoint2{

	fill: #0000ff;

	stroke: none;

	stroke-width: 1px;	

}

.key3,.dataPoint3{

	fill: #00ff00;

	stroke: none;

	stroke-width: 1px;	

}

.key4,.dataPoint4{

	fill: #ffcc00;

	stroke: none;

	stroke-width: 1px;	

}

.key5,.dataPoint5{

	fill: #00ccff;

	stroke: none;

	stroke-width: 1px;	

}

.key6,.dataPoint6{

	fill: #ff00ff;

	stroke: none;

	stroke-width: 1px;	

}

.key7,.dataPoint7{

	fill: #00ffff;

	stroke: none;

	stroke-width: 1px;	

}

.key8,.dataPoint8{

	fill: #ffff00;

	stroke: none;

	stroke-width: 1px;	

}

.key9,.dataPoint9{

	fill: #cc6666;

	stroke: none;

	stroke-width: 1px;	

}

.key10,.dataPoint10{

	fill: #663399;

	stroke: none;

	stroke-width: 1px;	

}

.key11,.dataPoint11{

	fill: #339900;

	stroke: none;

	stroke-width: 1px;	

}

.key12,.dataPoint12{

	fill: #9966FF;

	stroke: none;

	stroke-width: 1px;	

}

EOL

      end

    end

  end

end

<fieldset id="date-range" class="collapsible">

<legend onclick="toggleFieldset(this);"><%= l(:label_date_range) %></legend>

<div>

<p>

<%= label_tag "period_type_list", l(:description_date_range_list), :class => "hidden-for-sighted" %>

<%= radio_button_tag 'period_type', '1', !@free_period, :onclick => '$("#from,#to").attr("disabled", true);$("#period").removeAttr("disabled");', :id => "period_type_list"%>

<%= select_tag 'period', options_for_period_select(params[:period]),

                         :onchange => 'this.form.submit();',

                         :onfocus => '$("#period_type_1").attr("checked", true);',

                         :disabled => @free_period %>

</p>

<p>

<%= label_tag "period_type_interval", l(:description_date_range_interval), :class => "hidden-for-sighted" %>

<%= radio_button_tag 'period_type', '2', @free_period, :onclick => '$("#from,#to").removeAttr("disabled");$("#period").attr("disabled", true);', :id => "period_type_interval" %>

<%= l(:label_date_from_to,

        :start => ((label_tag "from", l(:description_date_from), :class => "hidden-for-sighted") + 

            text_field_tag('from', @from, :size => 10, :disabled => !@free_period) + calendar_for('from')),

        :end => ((label_tag "to", l(:description_date_to), :class => "hidden-for-sighted") +

            text_field_tag('to', @to, :size => 10, :disabled => !@free_period) + calendar_for('to'))).html_safe %>

</p>

</div>

</fieldset>

<p class="buttons">

  <%= link_to_function l(:button_apply), '$("#query_form").submit()', :class => 'icon icon-checked' %>

  <%= link_to l(:button_clear), {:controller => controller_name, :action => action_name, :project_id => @project, :issue_id => @issue}, :class => 'icon icon-reload' %>

</p>

<div class="tabs">

<% url_params = @free_period ? { :from => @from, :to => @to } : { :period => params[:period] } %>

<ul>

    <li><%= link_to(l(:label_details), url_params.merge({:controller => 'timelog', :action => 'index', :project_id => @project, :issue_id => @issue }),

                                       :class => (action_name == 'index' ? 'selected' : nil)) %></li>

    <li><%= link_to(l(:label_report), url_params.merge({:controller => 'timelog', :action => 'report', :project_id => @project, :issue_id => @issue}),

                                       :class => (action_name == 'report' ? 'selected' : nil)) %></li>

</ul>

</div>

<%= javascript_tag do %>

$('#from, #to').change(function(){

  $('#period_type_interval').attr('checked', true); $('#from,#to').removeAttr('disabled'); $('#period').attr('disabled', true);

});

<% end %>

# Redmine - project management software

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

#

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

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

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

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

#

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

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

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

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

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

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

class MyController < ApplicationController

  before_filter :require_login

  helper :issues

  helper :users

  helper :custom_fields

  BLOCKS = { 'issuesassignedtome' => :label_assigned_to_me_issues,

             'issuesreportedbyme' => :label_reported_issues,

             'issueswatched' => :label_watched_issues,

             'news' => :label_news_latest,

             'calendar' => :label_calendar,

             'documents' => :label_document_plural,

             'timelog' => :label_spent_time

           }.merge(Redmine::Views::MyPage::Block.additional_blocks).freeze

  DEFAULT_LAYOUT = {  'left' => ['issuesassignedtome'],

                      'right' => ['issuesreportedbyme']

                   }.freeze

  def index

    page

    render :action => 'page'

  end

  # Show user's page

  def page

    @user = User.current

    @blocks = @user.pref[:my_page_layout] || DEFAULT_LAYOUT

  end

  # Edit user's account

  def account

    @user = User.current

    @pref = @user.pref

    if request.post?

      @user.safe_attributes = params[:user]

      @user.pref.attributes = params[:pref]

      @user.pref[:no_self_notified] = (params[:no_self_notified] == '1')

      if @user.save

        @user.pref.save

        @user.notified_project_ids = (@user.mail_notification == 'selected' ? params[:notified_project_ids] : [])

        set_language_if_valid @user.language

        flash[:notice] = l(:notice_account_updated)

        redirect_to :action => 'account'

        return

      end

    end

  end

  # Destroys user's account

  def destroy

    @user = User.current

    unless @user.own_account_deletable?

      redirect_to :action => 'account'

      return

    end

    if request.post? && params[:confirm]

      @user.destroy

      if @user.destroyed?

        logout_user

        flash[:notice] = l(:notice_account_deleted)

      end

      redirect_to home_path

    end

  end

  # Manage user's password

  def password

    @user = User.current

    unless @user.change_password_allowed?

      flash[:error] = l(:notice_can_t_change_password)

      redirect_to :action => 'account'

      return

    end

    if request.post?

      if @user.check_password?(params[:password])

        @user.password, @user.password_confirmation = params[:new_password], params[:new_password_confirmation]

        if @user.save

          flash[:notice] = l(:notice_account_password_updated)

          redirect_to :action => 'account'

        end

      else

        flash[:error] = l(:notice_account_wrong_password)

      end

    end

  end

  # Create a new feeds key

  def reset_rss_key

    if request.post?

      if User.current.rss_token

        User.current.rss_token.destroy

        User.current.reload

      end

      User.current.rss_key

      flash[:notice] = l(:notice_feeds_access_key_reseted)

    end

    redirect_to :action => 'account'

  end

  # Create a new API key

  def reset_api_key

    if request.post?

      if User.current.api_token

        User.current.api_token.destroy

        User.current.reload

      end

      User.current.api_key

      flash[:notice] = l(:notice_api_access_key_reseted)

    end

    redirect_to :action => 'account'

  end

  # User's page layout configuration

  def page_layout

    @user = User.current

    @blocks = @user.pref[:my_page_layout] || DEFAULT_LAYOUT.dup

    @block_options = []

    BLOCKS.each do |k, v|

      unless %w(top left right).detect {|f| (@blocks[f] ||= []).include?(k)}

        @block_options << [l("my.blocks.#{v}", :default => [v, v.to_s.humanize]), k.dasherize]

      end

    end

  end

  # Add a block to user's page

  # The block is added on top of the page

  # params[:block] : id of the block to add

  def add_block

    block = params[:block].to_s.underscore

    if block.present? && BLOCKS.key?(block)

      @user = User.current

      layout = @user.pref[:my_page_layout] || {}

      # remove if already present in a group

      %w(top left right).each {|f| (layout[f] ||= []).delete block }

      # add it on top

      layout['top'].unshift block

      @user.pref[:my_page_layout] = layout

      @user.pref.save

    end

    redirect_to :action => 'page_layout'

  end

  # Remove a block to user's page

  # params[:block] : id of the block to remove

  def remove_block

    block = params[:block].to_s.underscore

    @user = User.current

    # remove block in all groups

    layout = @user.pref[:my_page_layout] || {}

    %w(top left right).each {|f| (layout[f] ||= []).delete block }

    @user.pref[:my_page_layout] = layout

    @user.pref.save

    redirect_to :action => 'page_layout'

  end

  # Change blocks order on user's page

  # params[:group] : group to order (top, left or right)

  # params[:list-(top|left|right)] : array of block ids of the group

  def order_blocks

    group = params[:group]

    @user = User.current

    if group.is_a?(String)

      group_items = (params["blocks"] || []).collect(&:underscore)

      group_items.each {|s| s.sub!(/^block_/, '')}

      if group_items and group_items.is_a? Array

        layout = @user.pref[:my_page_layout] || {}

        # remove group blocks if they are presents in other groups

        %w(top left right).each {|f|

          layout[f] = (layout[f] || []) - group_items

        }

        layout[group] = group_items

        @user.pref[:my_page_layout] = layout

        @user.pref.save

      end

    end

    render :nothing => true

  end

end

# Redmine - project management software

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

#

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

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

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

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

#

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

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

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

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

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

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

class Wiki < ActiveRecord::Base

  include Redmine::SafeAttributes

  belongs_to :project

  has_many :pages, :class_name => 'WikiPage', :dependent => :destroy, :order => 'title'

  has_many :redirects, :class_name => 'WikiRedirect', :dependent => :delete_all

  acts_as_watchable

  validates_presence_of :start_page

  validates_format_of :start_page, :with => /^[^,\.\/\?\;\|\:]*$/

  safe_attributes 'start_page'

  def visible?(user=User.current)

    !user.nil? && user.allowed_to?(:view_wiki_pages, project)

  end

  # Returns the wiki page that acts as the sidebar content

  # or nil if no such page exists

  def sidebar

    @sidebar ||= find_page('Sidebar', :with_redirect => false)

  end

  # find the page with the given title

  # if page doesn't exist, return a new page

  def find_or_new_page(title)

    title = start_page if title.blank?

    find_page(title) || WikiPage.new(:wiki => self, :title => Wiki.titleize(title))

  end

  # find the page with the given title

  def find_page(title, options = {})

    @page_found_with_redirect = false

    title = start_page if title.blank?

    title = Wiki.titleize(title)

    page = pages.first(:conditions => ["LOWER(title) = LOWER(?)", title])

    if !page && !(options[:with_redirect] == false)

      # search for a redirect

      redirect = redirects.first(:conditions => ["LOWER(title) = LOWER(?)", title])

      if redirect

        page = find_page(redirect.redirects_to, :with_redirect => false)

        @page_found_with_redirect = true

      end

    end

    page

  end

  # Returns true if the last page was found with a redirect

  def page_found_with_redirect?

    @page_found_with_redirect

  end

  # Finds a page by title

  # The given string can be of one of the forms: "title" or "project:title"

  # Examples:

  #   Wiki.find_page("bar", project => foo)

  #   Wiki.find_page("foo:bar")

  def self.find_page(title, options = {})

    project = options[:project]

    if title.to_s =~ %r{^([^\:]+)\:(.*)$}

      project_identifier, title = $1, $2

      project = Project.find_by_identifier(project_identifier) || Project.find_by_name(project_identifier)

    end

    if project && project.wiki

      page = project.wiki.find_page(title)

      if page && page.content

        page

      end

    end

  end

  # turn a string into a valid page title

  def self.titleize(title)

    # replace spaces with _ and remove unwanted caracters

    title = title.gsub(/\s+/, '_').delete(',./?;|:') if title

    # upcase the first letter

    title = (title.slice(0..0).upcase + (title.slice(1..-1) || '')) if title

    title

  end

end

# Redmine - project management software

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

#

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

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

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

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

#

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

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

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

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

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

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

require 'diff'

require 'enumerator'

class WikiPage < ActiveRecord::Base

  include Redmine::SafeAttributes

  belongs_to :wiki

  has_one :content, :class_name => 'WikiContent', :foreign_key => 'page_id', :dependent => :destroy

  acts_as_attachable :delete_permission => :delete_wiki_pages_attachments

  acts_as_tree :dependent => :nullify, :order => 'title'

  acts_as_watchable

  acts_as_event :title => Proc.new {|o| "#{l(:label_wiki)}: #{o.title}"},

                :description => :text,

                :datetime => :created_on,

                :url => Proc.new {|o| {:controller => 'wiki', :action => 'show', :project_id => o.wiki.project, :id => o.title}}

  acts_as_searchable :columns => ['title', "#{WikiContent.table_name}.text"],

                     :include => [{:wiki => :project}, :content],

                     :permission => :view_wiki_pages,

                     :project_key => "#{Wiki.table_name}.project_id"

  attr_accessor :redirect_existing_links

  validates_presence_of :title

  validates_format_of :title, :with => /^[^,\.\/\?\;\|\s]*$/

  validates_uniqueness_of :title, :scope => :wiki_id, :case_sensitive => false

  validates_associated :content

  validate :validate_parent_title

  before_destroy :remove_redirects

  before_save    :handle_redirects

  # eager load information about last updates, without loading text

  scope :with_updated_on, {

    :select => "#{WikiPage.table_name}.*, #{WikiContent.table_name}.updated_on, #{WikiContent.table_name}.version",

    :joins => "LEFT JOIN #{WikiContent.table_name} ON #{WikiContent.table_name}.page_id = #{WikiPage.table_name}.id"

  }

  # Wiki pages that are protected by default

  DEFAULT_PROTECTED_PAGES = %w(sidebar)

  safe_attributes 'parent_id', 'parent_title',

    :if => lambda {|page, user| page.new_record? || user.allowed_to?(:rename_wiki_pages, page.project)}

  def initialize(attributes=nil, *args)

    super

    if new_record? && DEFAULT_PROTECTED_PAGES.include?(title.to_s.downcase)

      self.protected = true

    end

  end

  def visible?(user=User.current)

    !user.nil? && user.allowed_to?(:view_wiki_pages, project)

  end

  def title=(value)

    value = Wiki.titleize(value)

    @previous_title = read_attribute(:title) if @previous_title.blank?

    write_attribute(:title, value)

  end

  def handle_redirects

    self.title = Wiki.titleize(title)

    # Manage redirects if the title has changed

    if !@previous_title.blank? && (@previous_title != title) && !new_record?

      # Update redirects that point to the old title

      wiki.redirects.find_all_by_redirects_to(@previous_title).each do |r|

        r.redirects_to = title

        r.title == r.redirects_to ? r.destroy : r.save

      end

      # Remove redirects for the new title

      wiki.redirects.find_all_by_title(title).each(&:destroy)

      # Create a redirect to the new title

      wiki.redirects << WikiRedirect.new(:title => @previous_title, :redirects_to => title) unless redirect_existing_links == "0"

      @previous_title = nil

    end

  end

  def remove_redirects

    # Remove redirects to this page

    wiki.redirects.find_all_by_redirects_to(title).each(&:destroy)

  end

  def pretty_title

    WikiPage.pretty_title(title)

  end

  def content_for_version(version=nil)

    result = content.versions.find_by_version(version.to_i) if version

    result ||= content

    result

  end

  def diff(version_to=nil, version_from=nil)

    version_to = version_to ? version_to.to_i : self.content.version

    content_to = content.versions.find_by_version(version_to)

    content_from = version_from ? content.versions.find_by_version(version_from.to_i) : content_to.try(:previous)

    return nil unless content_to && content_from

    if content_from.version > content_to.version

      content_to, content_from = content_from, content_to

    end

    (content_to && content_from) ? WikiDiff.new(content_to, content_from) : nil

  end

  def annotate(version=nil)

    version = version ? version.to_i : self.content.version

    c = content.versions.find_by_version(version)

    c ? WikiAnnotate.new(c) : nil

  end

  def self.pretty_title(str)

    (str && str.is_a?(String)) ? str.tr('_', ' ') : str

  end

  def project

    wiki.project

  end

  def text

    content.text if content

  end

  def updated_on

    unless @updated_on

      if time = read_attribute(:updated_on)

        # content updated_on was eager loaded with the page

        begin

          @updated_on = (self.class.default_timezone == :utc ? Time.parse(time.to_s).utc : Time.parse(time.to_s).localtime)

        rescue

        end

      else

        @updated_on = content && content.updated_on

      end

    end

    @updated_on

  end

  # Returns true if usr is allowed to edit the page, otherwise false

  def editable_by?(usr)

    !protected? || usr.allowed_to?(:protect_wiki_pages, wiki.project)

  end

  def attachments_deletable?(usr=User.current)

    editable_by?(usr) && super(usr)

  end

  def parent_title

    @parent_title || (self.parent && self.parent.pretty_title)

  end

  def parent_title=(t)

    @parent_title = t

    parent_page = t.blank? ? nil : self.wiki.find_page(t)

    self.parent = parent_page

  end

  # Saves the page and its content if text was changed

  def save_with_content

    ret = nil

    transaction do

      if new_record?

        # Rails automatically saves associated content

        ret = save

      else

        ret = save && (content.text_changed? ? content.save : true)

      end

      raise ActiveRecord::Rollback unless ret

    end

    ret

  end

  protected

  def validate_parent_title

    errors.add(:parent_title, :invalid) if !@parent_title.blank? && parent.nil?

    errors.add(:parent_title, :circular_dependency) if parent && (parent == self || parent.ancestors.include?(self))

    errors.add(:parent_title, :not_same_project) if parent && (parent.wiki_id != wiki_id)

  end

end

class WikiDiff < Redmine::Helpers::Diff

  attr_reader :content_to, :content_from

  def initialize(content_to, content_from)

    @content_to = content_to

    @content_from = content_from

    super(content_to.text, content_from.text)

  end

end

class WikiAnnotate

  attr_reader :lines, :content

  def initialize(content)

    @content = content

    current = content

    current_lines = current.text.split(/\r?\n/)

    @lines = current_lines.collect {|t| [nil, nil, t]}

    positions = []

    current_lines.size.times {|i| positions << i}

    while (current.previous)

      d = current.previous.text.split(/\r?\n/).diff(current.text.split(/\r?\n/)).diffs.flatten

      d.each_slice(3) do |s|

        sign, line = s[0], s[1]

        if sign == '+' && positions[line] && positions[line] != -1

          if @lines[positions[line]][0].nil?

            @lines[positions[line]][0] = current.version

            @lines[positions[line]][1] = current.author

          end

        end

      end

      d.each_slice(3) do |s|

        sign, line = s[0], s[1]

        if sign == '-'

          positions.insert(line, -1)

        else

          positions[line] = nil

        end

      end

      positions.compact!

      # Stop if every line is annotated

      break unless @lines.detect { |line| line[0].nil? }

      current = current.previous

    end

    @lines.each { |line|

      line[0] ||= current.version

      # if the last known version is > 1 (eg. history was cleared), we don't know the author

      line[1] ||= current.author if current.version == 1

    }

  end

end