jro_apps/redmine Commit - r14942:2fbce6515d6f

Add inline image preview/display for attachments and repository entries (#22058)....

Jean-Philippe Lang -

r14942:2fbce6515d6f

parent child

Context file:

r14942:2fbce6515d6f

Collapse all files

app/views/attachments/image.html.erb created 644 +3 0

@@ -0,0 +1,3
	1	<%= render :layout => 'layouts/file' do %>
	2	<%= render :partial => 'common/image', :locals => {:path => download_named_attachment_url(@attachment, @attachment.filename), :alt => @attachment.filename} %>
	3	<% end %>

app/views/common/_image.html.erb created 644 +1 0

	@@ -0,0 +1,1
				1	<%= image_tag path, :alt => alt, :class => 'filecontent image' %>

app/controllers/attachments_controller.rb +2 0

             # Redmine - project management software
             # Copyright (C) 2006-2016  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 AttachmentsController < ApplicationController
               before_filter :find_attachment, :only => [:show, :download, :thumbnail, :destroy]
               before_filter :find_editable_attachments, :only => [:edit, :update]
               before_filter :file_readable, :read_authorize, :only => [:show, :download, :thumbnail]
               before_filter :delete_authorize, :only => :destroy
               before_filter :authorize_global, :only => :upload
               accept_api_auth :show, :download, :thumbnail, :upload
               def show
                 respond_to do |format|
                   format.html {
                     if @attachment.is_diff?
                       @diff = File.read(@attachment.diskfile, :mode => "rb")
                       @diff_type = params[:type] || User.current.pref[:diff_type] || 'inline'
                       @diff_type = 'inline' unless %w(inline sbs).include?(@diff_type)
                       # Save diff type as user preference
                       if User.current.logged? && @diff_type != User.current.pref[:diff_type]
                         User.current.pref[:diff_type] = @diff_type
                         User.current.preference.save
                       end
                       render :action => 'diff'
                     elsif @attachment.is_text? && @attachment.filesize <= Setting.file_max_size_displayed.to_i.kilobyte
                       @content = File.read(@attachment.diskfile, :mode => "rb")
                       render :action => 'file'
+                    elsif @attachment.is_image?
+                      render :action => 'image'
                     else
                       download
                     end
                   }
                   format.api
                 end
               end
               def download
                 if @attachment.container.is_a?(Version) || @attachment.container.is_a?(Project)
                   @attachment.increment_download
                 end
                 if stale?(:etag => @attachment.digest)
                   # images are sent inline
                   send_file @attachment.diskfile, :filename => filename_for_content_disposition(@attachment.filename),
                                                   :type => detect_content_type(@attachment),
                                                   :disposition => (@attachment.image? ? 'inline' : 'attachment')
                 end
               end
               def thumbnail
                 if @attachment.thumbnailable? && tbnail = @attachment.thumbnail(:size => params[:size])
                   if stale?(:etag => tbnail)
                     send_file tbnail,
                       :filename => filename_for_content_disposition(@attachment.filename),
                       :type => detect_content_type(@attachment),
                       :disposition => 'inline'
                   end
                 else
                   # No thumbnail for the attachment or thumbnail could not be created
                   render :nothing => true, :status => 404
                 end
               end
               def upload
                 # Make sure that API users get used to set this content type
                 # as it won't trigger Rails' automatic parsing of the request body for parameters
                 unless request.content_type == 'application/octet-stream'
                   render :nothing => true, :status => 406
                   return
                 end
                 @attachment = Attachment.new(:file => request.raw_post)
                 @attachment.author = User.current
                 @attachment.filename = params[:filename].presence || Redmine::Utils.random_hex(16)
                 @attachment.content_type = params[:content_type].presence
                 saved = @attachment.save
                 respond_to do |format|
                   format.js
                   format.api {
                     if saved
                       render :action => 'upload', :status => :created
                     else
                       render_validation_errors(@attachment)
                     end
                   }
                 end
               end
               def edit
               end
               def update
                 if params[:attachments].is_a?(Hash)
                   if Attachment.update_attachments(@attachments, params[:attachments])
                     redirect_back_or_default home_path
                     return
                   end
                 end
                 render :action => 'edit'
               end
               def destroy
                 if @attachment.container.respond_to?(:init_journal)
                   @attachment.container.init_journal(User.current)
                 end
                 if @attachment.container
                   # Make sure association callbacks are called
                   @attachment.container.attachments.delete(@attachment)
                 else
                   @attachment.destroy
                 end
                 respond_to do |format|
                   format.html { redirect_to_referer_or project_path(@project) }
                   format.js
                 end
               end
               private
               def find_attachment
                 @attachment = Attachment.find(params[:id])
                 # Show 404 if the filename in the url is wrong
                 raise ActiveRecord::RecordNotFound if params[:filename] && params[:filename] != @attachment.filename
                 @project = @attachment.project
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def find_editable_attachments
                 klass = params[:object_type].to_s.singularize.classify.constantize rescue nil
                 unless klass && klass.reflect_on_association(:attachments)
                   render_404
                   return
                 end
                 @container = klass.find(params[:object_id])
                 if @container.respond_to?(:visible?) && !@container.visible?
                   render_403
                   return
                 end
                 @attachments = @container.attachments.select(&:editable?)
                 if @container.respond_to?(:project)
                   @project = @container.project
                 end
                 render_404 if @attachments.empty?
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Checks that the file exists and is readable
               def file_readable
                 if @attachment.readable?
                   true
                 else
                   logger.error "Cannot send attachment, #{@attachment.diskfile} does not exist or is unreadable."
                   render_404
                 end
               end
               def read_authorize
                 @attachment.visible? ? true : deny_access
               end
               def delete_authorize
                 @attachment.deletable? ? true : deny_access
               end
               def detect_content_type(attachment)
                 content_type = attachment.content_type
                 if content_type.blank? || content_type == "application/octet-stream"
                   content_type = Redmine::MimeType.of(attachment.filename)
                 end
                 content_type.to_s
               end
             end

app/controllers/repositories_controller.rb +3 -1

             # Redmine - project management software
             # Copyright (C) 2006-2016  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 'SVG/Graph/Bar'
             require 'SVG/Graph/BarHorizontal'
             require 'digest/sha1'
             require 'redmine/scm/adapters'
             class ChangesetNotFound < Exception; end
             class InvalidRevisionParam < Exception; end
             class RepositoriesController < ApplicationController
               menu_item :repository
               menu_item :settings, :only => [:new, :create, :edit, :update, :destroy, :committers]
               default_search_scope :changesets
               before_filter :find_project_by_project_id, :only => [:new, :create]
               before_filter :find_repository, :only => [:edit, :update, :destroy, :committers]
               before_filter :find_project_repository, :except => [:new, :create, :edit, :update, :destroy, :committers]
               before_filter :find_changeset, :only => [:revision, :add_related_issue, :remove_related_issue]
               before_filter :authorize
               accept_rss_auth :revisions
               rescue_from Redmine::Scm::Adapters::CommandFailed, :with => :show_error_command_failed
               def new
                 scm = params[:repository_scm] || (Redmine::Scm::Base.all & Setting.enabled_scm).first
                 @repository = Repository.factory(scm)
                 @repository.is_default = @project.repository.nil?
                 @repository.project = @project
               end
               def create
                 attrs = pickup_extra_info
                 @repository = Repository.factory(params[:repository_scm])
                 @repository.safe_attributes = params[:repository]
                 if attrs[:attrs_extra].keys.any?
                   @repository.merge_extra_info(attrs[:attrs_extra])
                 end
                 @repository.project = @project
                 if request.post? && @repository.save
                   redirect_to settings_project_path(@project, :tab => 'repositories')
                 else
                   render :action => 'new'
                 end
               end
               def edit
               end
               def update
                 attrs = pickup_extra_info
                 @repository.safe_attributes = attrs[:attrs]
                 if attrs[:attrs_extra].keys.any?
                   @repository.merge_extra_info(attrs[:attrs_extra])
                 end
                 @repository.project = @project
                 if @repository.save
                   redirect_to settings_project_path(@project, :tab => 'repositories')
                 else
                   render :action => 'edit'
                 end
               end
               def pickup_extra_info
                 p       = {}
                 p_extra = {}
                 params[:repository].each do |k, v|
                   if k =~ /^extra_/
                     p_extra[k] = v
                   else
                     p[k] = v
                   end
                 end
                 {:attrs => p, :attrs_extra => p_extra}
               end
               private :pickup_extra_info
               def committers
                 @committers = @repository.committers
                 @users = @project.users.to_a
                 additional_user_ids = @committers.collect(&:last).collect(&:to_i) - @users.collect(&:id)
                 @users += User.where(:id => additional_user_ids).to_a unless additional_user_ids.empty?
                 @users.compact!
                 @users.sort!
                 if request.post? && params[:committers].is_a?(Hash)
                   # Build a hash with repository usernames as keys and corresponding user ids as values
                   @repository.committer_ids = params[:committers].values.inject({}) {|h, c| h[c.first] = c.last; h}
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to settings_project_path(@project, :tab => 'repositories')
                 end
               end
               def destroy
                 @repository.destroy if request.delete?
                 redirect_to settings_project_path(@project, :tab => 'repositories')
               end
               def show
                 @repository.fetch_changesets if @project.active? && Setting.autofetch_changesets? && @path.empty?
                 @entries = @repository.entries(@path, @rev)
                 @changeset = @repository.find_changeset_by_name(@rev)
                 if request.xhr?
                   @entries ? render(:partial => 'dir_list_content') : render(:nothing => true)
                 else
                   (show_error_not_found; return) unless @entries
                   @changesets = @repository.latest_changesets(@path, @rev)
                   @properties = @repository.properties(@path, @rev)
                   @repositories = @project.repositories
                   render :action => 'show'
                 end
               end
               alias_method :browse, :show
               def changes
                 @entry = @repository.entry(@path, @rev)
                 (show_error_not_found; return) unless @entry
                 @changesets = @repository.latest_changesets(@path, @rev, Setting.repository_log_display_limit.to_i)
                 @properties = @repository.properties(@path, @rev)
                 @changeset = @repository.find_changeset_by_name(@rev)
               end
               def revisions
                 @changeset_count = @repository.changesets.count
                 @changeset_pages = Paginator.new @changeset_count,
                                                  per_page_option,
                                                  params['page']
                 @changesets = @repository.changesets.
                   limit(@changeset_pages.per_page).
                   offset(@changeset_pages.offset).
                   includes(:user, :repository, :parents).
                   to_a
                 respond_to do |format|
                   format.html { render :layout => false if request.xhr? }
                   format.atom { render_feed(@changesets, :title => "#{@project.name}: #{l(:label_revision_plural)}") }
                 end
               end
               def raw
                 entry_and_raw(true)
               end
               def entry
                 entry_and_raw(false)
               end
               def entry_and_raw(is_raw)
                 @entry = @repository.entry(@path, @rev)
                 (show_error_not_found; return) unless @entry
                 # If the entry is a dir, show the browser
                 (show; return) if @entry.is_dir?
                 @content = @repository.cat(@path, @rev)
                 (show_error_not_found; return) unless @content
-                if is_raw ||
+                if !is_raw && Redmine::MimeType.is_type?('image', @path)
+                  # simply render
+                elsif is_raw ||
                      (@content.size && @content.size > Setting.file_max_size_displayed.to_i.kilobyte) ||
                      ! is_entry_text_data?(@content, @path)
                   # Force the download
                   send_opt = { :filename => filename_for_content_disposition(@path.split('/').last) }
                   send_type = Redmine::MimeType.of(@path)
                   send_opt[:type] = send_type.to_s if send_type
                   send_opt[:disposition] = (Redmine::MimeType.is_type?('image', @path) && !is_raw ? 'inline' : 'attachment')
                   send_data @content, send_opt
                 else
                   # Prevent empty lines when displaying a file with Windows style eol
                   # TODO: UTF-16
                   # Is this needs? AttachmentsController reads file simply.
                   @content.gsub!("\r\n", "\n")
                   @changeset = @repository.find_changeset_by_name(@rev)
                 end
               end
               private :entry_and_raw
               def is_entry_text_data?(ent, path)
                 # UTF-16 contains "\x00".
                 # It is very strict that file contains less than 30% of ascii symbols
                 # in non Western Europe.
                 return true if Redmine::MimeType.is_type?('text', path)
                 # Ruby 1.8.6 has a bug of integer divisions.
                 # http://apidock.com/ruby/v1_8_6_287/String/is_binary_data%3F
                 return false if ent.is_binary_data?
                 true
               end
               private :is_entry_text_data?
               def annotate
                 @entry = @repository.entry(@path, @rev)
                 (show_error_not_found; return) unless @entry
                 @annotate = @repository.scm.annotate(@path, @rev)
                 if @annotate.nil? || @annotate.empty?
                   (render_error l(:error_scm_annotate); return)
                 end
                 ann_buf_size = 0
                 @annotate.lines.each do |buf|
                   ann_buf_size += buf.size
                 end
                 if ann_buf_size > Setting.file_max_size_displayed.to_i.kilobyte
                   (render_error l(:error_scm_annotate_big_text_file); return)
                 end
                 @changeset = @repository.find_changeset_by_name(@rev)
               end
               def revision
                 respond_to do |format|
                   format.html
                   format.js {render :layout => false}
                 end
               end
               # Adds a related issue to a changeset
               # POST /projects/:project_id/repository/(:repository_id/)revisions/:rev/issues
               def add_related_issue
                 issue_id = params[:issue_id].to_s.sub(/^#/,'')
                 @issue = @changeset.find_referenced_issue_by_id(issue_id)
                 if @issue && (!@issue.visible? || @changeset.issues.include?(@issue))
                   @issue = nil
                 end
                 if @issue
                   @changeset.issues << @issue
                 end
               end
               # Removes a related issue from a changeset
               # DELETE /projects/:project_id/repository/(:repository_id/)revisions/:rev/issues/:issue_id
               def remove_related_issue
                 @issue = Issue.visible.find_by_id(params[:issue_id])
                 if @issue
                   @changeset.issues.delete(@issue)
                 end
               end
               def diff
                 if params[:format] == 'diff'
                   @diff = @repository.diff(@path, @rev, @rev_to)
                   (show_error_not_found; return) unless @diff
                   filename = "changeset_r#{@rev}"
                   filename << "_r#{@rev_to}" if @rev_to
                   send_data @diff.join, :filename => "#{filename}.diff",
                                         :type => 'text/x-patch',
                                         :disposition => 'attachment'
                 else
                   @diff_type = params[:type] || User.current.pref[:diff_type] || 'inline'
                   @diff_type = 'inline' unless %w(inline sbs).include?(@diff_type)
                   # Save diff type as user preference
                   if User.current.logged? && @diff_type != User.current.pref[:diff_type]
                     User.current.pref[:diff_type] = @diff_type
                     User.current.preference.save
                   end
                   @cache_key = "repositories/diff/#{@repository.id}/" +
                                   Digest::MD5.hexdigest("#{@path}-#{@rev}-#{@rev_to}-#{@diff_type}-#{current_language}")
                   unless read_fragment(@cache_key)
                     @diff = @repository.diff(@path, @rev, @rev_to)
                     show_error_not_found unless @diff
                   end
                   @changeset = @repository.find_changeset_by_name(@rev)
                   @changeset_to = @rev_to ? @repository.find_changeset_by_name(@rev_to) : nil
                   @diff_format_revisions = @repository.diff_format_revisions(@changeset, @changeset_to)
                 end
               end
               def stats
               end
               def graph
                 data = nil
                 case params[:graph]
                 when "commits_per_month"
                   data = graph_commits_per_month(@repository)
                 when "commits_per_author"
                   data = graph_commits_per_author(@repository)
                 end
                 if data
                   headers["Content-Type"] = "image/svg+xml"
                   send_data(data, :type => "image/svg+xml", :disposition => "inline")
                 else
                   render_404
                 end
               end
               private
               def find_repository
                 @repository = Repository.find(params[:id])
                 @project = @repository.project
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               REV_PARAM_RE = %r{\A[a-f0-9]*\Z}i
               def find_project_repository
                 @project = Project.find(params[:id])
                 if params[:repository_id].present?
                   @repository = @project.repositories.find_by_identifier_param(params[:repository_id])
                 else
                   @repository = @project.repository
                 end
                 (render_404; return false) unless @repository
                 @path = params[:path].is_a?(Array) ? params[:path].join('/') : params[:path].to_s
                 @rev = params[:rev].blank? ? @repository.default_branch : params[:rev].to_s.strip
                 @rev_to = params[:rev_to]
                 unless @rev.to_s.match(REV_PARAM_RE) && @rev_to.to_s.match(REV_PARAM_RE)
                   if @repository.branches.blank?
                     raise InvalidRevisionParam
                   end
                 end
               rescue ActiveRecord::RecordNotFound
                 render_404
               rescue InvalidRevisionParam
                 show_error_not_found
               end
               def find_changeset
                 if @rev.present?
                   @changeset = @repository.find_changeset_by_name(@rev)
                 end
                 show_error_not_found unless @changeset
               end
               def show_error_not_found
                 render_error :message => l(:error_scm_not_found), :status => 404
               end
               # Handler for Redmine::Scm::Adapters::CommandFailed exception
               def show_error_command_failed(exception)
                 render_error l(:error_scm_command_failed, exception.message)
               end
               def graph_commits_per_month(repository)
                 @date_to = Date.today
                 @date_from = @date_to << 11
                 @date_from = Date.civil(@date_from.year, @date_from.month, 1)
                 commits_by_day = Changeset.
                   where("repository_id = ? AND commit_date BETWEEN ? AND ?", repository.id, @date_from, @date_to).
                   group(:commit_date).
                   count
                 commits_by_month = [0] * 12
                 commits_by_day.each {|c| commits_by_month[(@date_to.month - c.first.to_date.month) % 12] += c.last }
                 changes_by_day = Change.
                   joins(:changeset).
                   where("#{Changeset.table_name}.repository_id = ? AND #{Changeset.table_name}.commit_date BETWEEN ? AND ?", repository.id, @date_from, @date_to).
                   group(:commit_date).
                   count
                 changes_by_month = [0] * 12
                 changes_by_day.each {|c| changes_by_month[(@date_to.month - c.first.to_date.month) % 12] += c.last }
                 fields = []
 .times {|m| fields << month_name(((Date.today.month - 1 - m) % 12) + 1)}
                 graph = SVG::Graph::Bar.new(
                   :height => 300,
                   :width => 800,
                   :fields => fields.reverse,
                   :stack => :side,
                   :scale_integers => true,
                   :step_x_labels => 2,
                   :show_data_values => false,
                   :graph_title => l(:label_commits_per_month),
                   :show_graph_title => true
                 )
                 graph.add_data(
                   :data => commits_by_month[0..11].reverse,
                   :title => l(:label_revision_plural)
                 )
                 graph.add_data(
                   :data => changes_by_month[0..11].reverse,
                   :title => l(:label_change_plural)
                 )
                 graph.burn
               end
               def graph_commits_per_author(repository)
                 #data
                 stats = repository.stats_by_author
                 fields, commits_data, changes_data = [], [], []
                 stats.each do |name, hsh|
                   fields << name
                   commits_data << hsh[:commits_count]
                   changes_data << hsh[:changes_count]
                 end
                 #expand to 10 values if needed
                 fields = fields + [""]*(10 - fields.length) if fields.length<10
                 commits_data = commits_data + [0]*(10 - commits_data.length) if commits_data.length<10
                 changes_data = changes_data + [0]*(10 - changes_data.length) if changes_data.length<10
                 # Remove email address in usernames
                 fields = fields.collect {|c| c.gsub(%r{<.+@.+>}, '') }
                 #prepare graph
                 graph = SVG::Graph::BarHorizontal.new(
                   :height => 30 * commits_data.length,
                   :width => 800,
                   :fields => fields,
                   :stack => :side,
                   :scale_integers => true,
                   :show_data_values => false,
                   :rotate_y_labels => false,
                   :graph_title => l(:label_commits_per_author),
                   :show_graph_title => true
                 )
                 graph.add_data(
                   :data => commits_data,
                   :title => l(:label_revision_plural)
                 )
                 graph.add_data(
                   :data => changes_data,
                   :title => l(:label_change_plural)
                 )
                 graph.burn
               end
             end

app/models/attachment.rb +4 0

             # Redmine - project management software
             # Copyright (C) 2006-2016  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 "digest/md5"
             require "fileutils"
             class Attachment < ActiveRecord::Base
               belongs_to :container, :polymorphic => true
               belongs_to :author, :class_name => "User"
               validates_presence_of :filename, :author
               validates_length_of :filename, :maximum => 255
               validates_length_of :disk_filename, :maximum => 255
               validates_length_of :description, :maximum => 255
               validate :validate_max_file_size, :validate_file_extension
               attr_protected :id
               acts_as_event :title => :filename,
                             :url => Proc.new {|o| {:controller => 'attachments', :action => 'download', :id => o.id, :filename => o.filename}}
               acts_as_activity_provider :type => 'files',
                                         :permission => :view_files,
                                         :author_key => :author_id,
                                         :scope => select("#{Attachment.table_name}.*").
                                                   joins("LEFT JOIN #{Version.table_name} ON #{Attachment.table_name}.container_type='Version' AND #{Version.table_name}.id = #{Attachment.table_name}.container_id " +
                                                         "LEFT JOIN #{Project.table_name} ON #{Version.table_name}.project_id = #{Project.table_name}.id OR ( #{Attachment.table_name}.container_type='Project' AND #{Attachment.table_name}.container_id = #{Project.table_name}.id )")
               acts_as_activity_provider :type => 'documents',
                                         :permission => :view_documents,
                                         :author_key => :author_id,
                                         :scope => select("#{Attachment.table_name}.*").
                                                   joins("LEFT JOIN #{Document.table_name} ON #{Attachment.table_name}.container_type='Document' AND #{Document.table_name}.id = #{Attachment.table_name}.container_id " +
                                                         "LEFT JOIN #{Project.table_name} ON #{Document.table_name}.project_id = #{Project.table_name}.id")
               cattr_accessor :storage_path
               @@storage_path = Redmine::Configuration['attachments_storage_path'] || File.join(Rails.root, "files")
               cattr_accessor :thumbnails_storage_path
               @@thumbnails_storage_path = File.join(Rails.root, "tmp", "thumbnails")
               before_create :files_to_final_location
               after_rollback :delete_from_disk, :on => :create
               after_commit :delete_from_disk, :on => :destroy
               # Returns an unsaved copy of the attachment
               def copy(attributes=nil)
                 copy = self.class.new
                 copy.attributes = self.attributes.dup.except("id", "downloads")
                 copy.attributes = attributes if attributes
                 copy
               end
               def validate_max_file_size
                 if @temp_file && self.filesize > Setting.attachment_max_size.to_i.kilobytes
                   errors.add(:base, l(:error_attachment_too_big, :max_size => Setting.attachment_max_size.to_i.kilobytes))
                 end
               end
               def validate_file_extension
                 if @temp_file
                   extension = File.extname(filename)
                   unless self.class.valid_extension?(extension)
                     errors.add(:base, l(:error_attachment_extension_not_allowed, :extension => extension))
                   end
                 end
               end
               def file=(incoming_file)
                 unless incoming_file.nil?
                   @temp_file = incoming_file
                   if @temp_file.size > 0
                     if @temp_file.respond_to?(:original_filename)
                       self.filename = @temp_file.original_filename
                       self.filename.force_encoding("UTF-8")
                     end
                     if @temp_file.respond_to?(:content_type)
                       self.content_type = @temp_file.content_type.to_s.chomp
                     end
                     self.filesize = @temp_file.size
                   end
                 end
               end
               def file
                 nil
               end
               def filename=(arg)
                 write_attribute :filename, sanitize_filename(arg.to_s)
                 filename
               end
               # Copies the temporary file to its final location
               # and computes its MD5 hash
               def files_to_final_location
                 if @temp_file && (@temp_file.size > 0)
                   self.disk_directory = target_directory
                   self.disk_filename = Attachment.disk_filename(filename, disk_directory)
                   logger.info("Saving attachment '#{self.diskfile}' (#{@temp_file.size} bytes)") if logger
                   path = File.dirname(diskfile)
                   unless File.directory?(path)
                     FileUtils.mkdir_p(path)
                   end
                   md5 = Digest::MD5.new
                   File.open(diskfile, "wb") do |f|
                     if @temp_file.respond_to?(:read)
                       buffer = ""
                       while (buffer = @temp_file.read(8192))
                         f.write(buffer)
                         md5.update(buffer)
                       end
                     else
                       f.write(@temp_file)
                       md5.update(@temp_file)
                     end
                   end
                   self.digest = md5.hexdigest
                 end
                 @temp_file = nil
                 if content_type.blank? && filename.present?
                   self.content_type = Redmine::MimeType.of(filename)
                 end
                 # Don't save the content type if it's longer than the authorized length
                 if self.content_type && self.content_type.length > 255
                   self.content_type = nil
                 end
               end
               # Deletes the file from the file system if it's not referenced by other attachments
               def delete_from_disk
                 if Attachment.where("disk_filename = ? AND id <> ?", disk_filename, id).empty?
                   delete_from_disk!
                 end
               end
               # Returns file's location on disk
               def diskfile
                 File.join(self.class.storage_path, disk_directory.to_s, disk_filename.to_s)
               end
               def title
                 title = filename.to_s
                 if description.present?
                   title << " (#{description})"
                 end
                 title
               end
               def increment_download
                 increment!(:downloads)
               end
               def project
                 container.try(:project)
               end
               def visible?(user=User.current)
                 if container_id
                   container && container.attachments_visible?(user)
                 else
                   author == user
                 end
               end
               def editable?(user=User.current)
                 if container_id
                   container && container.attachments_editable?(user)
                 else
                   author == user
                 end
               end
               def deletable?(user=User.current)
                 if container_id
                   container && container.attachments_deletable?(user)
                 else
                   author == user
                 end
               end
               def image?
                 !!(self.filename =~ /\.(bmp|gif|jpg|jpe|jpeg|png)$/i)
               end
               def thumbnailable?
                 image?
               end
               # Returns the full path the attachment thumbnail, or nil
               # if the thumbnail cannot be generated.
               def thumbnail(options={})
                 if thumbnailable? && readable?
                   size = options[:size].to_i
                   if size > 0
                     # Limit the number of thumbnails per image
                     size = (size / 50) * 50
                     # Maximum thumbnail size
                     size = 800 if size > 800
                   else
                     size = Setting.thumbnails_size.to_i
                   end
                   size = 100 unless size > 0
                   target = File.join(self.class.thumbnails_storage_path, "#{id}_#{digest}_#{size}.thumb")
                   begin
                     Redmine::Thumbnail.generate(self.diskfile, target, size)
                   rescue => e
                     logger.error "An error occured while generating thumbnail for #{disk_filename} to #{target}\nException was: #{e.message}" if logger
                     return nil
                   end
                 end
               end
               # Deletes all thumbnails
               def self.clear_thumbnails
                 Dir.glob(File.join(thumbnails_storage_path, "*.thumb")).each do |file|
                   File.delete file
                 end
               end
               def is_text?
                 Redmine::MimeType.is_type?('text', filename)
               end
+              def is_image?
+                Redmine::MimeType.is_type?('image', filename)
+              end
               def is_diff?
                 self.filename =~ /\.(patch|diff)$/i
               end
               # Returns true if the file is readable
               def readable?
                 File.readable?(diskfile)
               end
               # Returns the attachment token
               def token
                 "#{id}.#{digest}"
               end
               # Finds an attachment that matches the given token and that has no container
               def self.find_by_token(token)
                 if token.to_s =~ /^(\d+)\.([0-9a-f]+)$/
                   attachment_id, attachment_digest = $1, $2
                   attachment = Attachment.where(:id => attachment_id, :digest => attachment_digest).first
                   if attachment && attachment.container.nil?
                     attachment
                   end
                 end
               end
               # Bulk attaches a set of files to an object
               #
               # Returns a Hash of the results:
               # :files => array of the attached files
               # :unsaved => array of the files that could not be attached
               def self.attach_files(obj, attachments)
                 result = obj.save_attachments(attachments, User.current)
                 obj.attach_saved_attachments
                 result
               end
               # Updates the filename and description of a set of attachments
               # with the given hash of attributes. Returns true if all
               # attachments were updated.
               #
               # Example:
               #   Attachment.update_attachments(attachments, {
               #     4 => {:filename => 'foo'},
               #     7 => {:filename => 'bar', :description => 'file description'}
               #   })
               #
               def self.update_attachments(attachments, params)
                 params = params.transform_keys {|key| key.to_i}
                 saved = true
                 transaction do
                   attachments.each do |attachment|
                     if p = params[attachment.id]
                       attachment.filename = p[:filename] if p.key?(:filename)
                       attachment.description = p[:description] if p.key?(:description)
                       saved &&= attachment.save
                     end
                   end
                   unless saved
                     raise ActiveRecord::Rollback
                   end
                 end
                 saved
               end
               def self.latest_attach(attachments, filename)
                 attachments.sort_by(&:created_on).reverse.detect do |att|
                   filename.casecmp(att.filename) == 0
                 end
               end
               def self.prune(age=1.day)
                 Attachment.where("created_on < ? AND (container_type IS NULL OR container_type = '')", Time.now - age).destroy_all
               end
               # Moves an existing attachment to its target directory
               def move_to_target_directory!
                 return unless !new_record? & readable?
                 src = diskfile
                 self.disk_directory = target_directory
                 dest = diskfile
                 return if src == dest
                 if !FileUtils.mkdir_p(File.dirname(dest))
                   logger.error "Could not create directory #{File.dirname(dest)}" if logger
                   return
                 end
                 if !FileUtils.mv(src, dest)
                   logger.error "Could not move attachment from #{src} to #{dest}" if logger
                   return
                 end
                 update_column :disk_directory, disk_directory
               end
               # Moves existing attachments that are stored at the root of the files
               # directory (ie. created before Redmine 2.3) to their target subdirectories
               def self.move_from_root_to_target_directory
                 Attachment.where("disk_directory IS NULL OR disk_directory = ''").find_each do |attachment|
                   attachment.move_to_target_directory!
                 end
               end
               # Returns true if the extension is allowed, otherwise false
               def self.valid_extension?(extension)
                 extension = extension.downcase.sub(/\A\.+/, '')
                 denied, allowed = [:attachment_extensions_denied, :attachment_extensions_allowed].map do |setting|
                   Setting.send(setting).to_s.split(",").map {|s| s.strip.downcase.sub(/\A\.+/, '')}.reject(&:blank?)
                 end
                 if denied.present? && denied.include?(extension)
                   return false
                 end
                 unless allowed.blank? || allowed.include?(extension)
                   return false
                 end
                 true
               end
               private
               # Physically deletes the file from the file system
               def delete_from_disk!
                 if disk_filename.present? && File.exist?(diskfile)
                   File.delete(diskfile)
                 end
               end
               def sanitize_filename(value)
                 # get only the filename, not the whole path
                 just_filename = value.gsub(/\A.*(\\|\/)/m, '')
                 # Finally, replace invalid characters with underscore
                 just_filename.gsub(/[\/\?\%\*\:\|\"\'<>\n\r]+/, '_')
               end
               # Returns the subdirectory in which the attachment will be saved
               def target_directory
                 time = created_on || DateTime.now
                 time.strftime("%Y/%m")
               end
               # Returns an ASCII or hashed filename that do not
               # exists yet in the given subdirectory
               def self.disk_filename(filename, directory=nil)
                 timestamp = DateTime.now.strftime("%y%m%d%H%M%S")
                 ascii = ''
                 if filename =~ %r{^[a-zA-Z0-9_\.\-]*$}
                   ascii = filename
                 else
                   ascii = Digest::MD5.hexdigest(filename)
                   # keep the extension if any
                   ascii << $1 if filename =~ %r{(\.[a-zA-Z0-9]+)$}
                 end
                 while File.exist?(File.join(storage_path, directory.to_s, "#{timestamp}_#{ascii}"))
                   timestamp.succ!
                 end
                 "#{timestamp}_#{ascii}"
               end
             end

app/views/attachments/_links.html.erb +1 -1

             <div class="attachments">
             <div class="contextual">
               <%= link_to(l(:label_edit_attachments),
                           container_attachments_edit_path(container),
                           :title => l(:label_edit_attachments),
                           :class => 'icon-only icon-edit'
                          ) if options[:editable] %>
             </div>
             <% for attachment in attachments %>
             <p><%= link_to_attachment attachment, :class => 'icon icon-attachment', :download => true -%>
-              <% if attachment.is_text? %>
+              <% if attachment.is_text? || attachment.is_image? %>
                 <%= link_to l(:button_view),
                             { :controller => 'attachments', :action => 'show',
                               :id => attachment, :filename => attachment.filename },
                             :class => 'icon-only icon-magnifier',
                             :title => l(:button_view) %>
               <% end %>
               <%= " - #{attachment.description}" unless attachment.description.blank? %>
               <span class="size">(<%= number_to_human_size attachment.filesize %>)</span>
               <% if options[:deletable] %>
                 <%= link_to l(:button_delete), attachment_path(attachment),
                             :data => {:confirm => l(:text_are_you_sure)},
                             :method => :delete,
                             :class => 'delete icon-only icon-del',
                             :title => l(:button_delete) %>
               <% end %>
               <% if options[:author] %>
                 <span class="author"><%= attachment.author %>, <%= format_time(attachment.created_on) %></span>
               <% end %>
               </p>
             <% end %>
             <% if defined?(thumbnails) && thumbnails %>
               <% images = attachments.select(&:thumbnailable?) %>
               <% if images.any? %>
               <div class="thumbnails">
                 <% images.each do |attachment| %>
                   <div><%= thumbnail_tag(attachment) %></div>
                 <% end %>
               </div>
               <% end %>
             <% end %>
             </div>

app/views/repositories/entry.html.erb +4 0

             <%= call_hook(:view_repositories_show_contextual, { :repository => @repository, :project => @project }) %>
             <div class="contextual">
               <%= render :partial => 'navigation' %>
             </div>
             <h2><%= render :partial => 'breadcrumbs', :locals => { :path => @path, :kind => 'file', :revision => @rev } %></h2>
             <%= render :partial => 'link_to_functions' %>
+            <% if Redmine::MimeType.is_type?('image', @path) %>
+              <%= render :partial => 'common/image', :locals => {:path => url_for(params.merge(:action => 'raw')), :alt => @path} %>
+            <% else %>
             <%= render :partial => 'common/file', :locals => {:filename => @path, :content => @content} %>
+            <% end %>
             <% content_for :header_tags do %>
             <%= stylesheet_link_tag "scm" %>
             <% end %>

public/stylesheets/scm.css +2 0

             table.revision-info td {
                 margin:  0px;
                 padding: 0px;
             }
             div.revision-graph { position: absolute; min-width: 1px; }
             div.changeset-changes ul { margin: 0; padding: 0; }
             div.changeset-changes ul > ul { margin-left: 18px; padding: 0; }
             li.change {
                 list-style-type:none;
                 background-image: url(../images/bullet_black.png);
                 background-position: 1px 1px;
                 background-repeat: no-repeat;
                 padding-top: 1px;
                 padding-bottom: 1px;
                 padding-left: 20px;
                 margin: 0;
             }
             li.change.folder { background-image: url(../images/folder_open.png); }
             li.change.folder.change-A { background-image: url(../images/folder_open_add.png); }
             li.change.folder.change-M { background-image: url(../images/folder_open_orange.png); }
             li.change.change-A { background-image: url(../images/bullet_add.png); }
             li.change.change-M { background-image: url(../images/bullet_orange.png); }
             li.change.change-C { background-image: url(../images/bullet_blue.png); }
             li.change.change-R { background-image: url(../images/bullet_purple.png); }
             li.change.change-D { background-image: url(../images/bullet_delete.png); }
             li.change .copied-from { font-style: italic; color: #999; font-size: 0.9em; }
             li.change .copied-from:before { content: " - "}
             #changes-legend { float: right; font-size: 0.8em; margin: 0; }
             #changes-legend li { float: left; background-position: 5px 0; }
             table.filecontent { border: 1px solid #e2e2e2;  border-collapse: collapse; width:98%; background-color: #fafafa; }
             table.filecontent tbody {font-family:Consolas, Menlo, "Liberation Mono", Courier, monospace; font-size:12px;}
             table.filecontent th { border: 1px solid #e2e2e2; background-color: #eee; }
             table.filecontent th.filename { background-color: #e4e4d4; text-align: left; padding:5px;}
             table.filecontent tr.spacing th { text-align:center; }
             table.filecontent tr.spacing td { height: 0.4em; background: #EAF2F5;}
             table.filecontent th.line-num {
                 border: 1px solid #e2e2e2;
                 text-align: right;
                 width: 2%;
                 padding: 0 3px 0 0;
                 color: #999;
                 user-select: none;
                 -moz-user-select: none;
                 -o-user-select: none;
                 -ms-user-select: none;
                 -webkit-user-select: none;
                 font-weight:normal;
             }
             table.filecontent th.line-num a {
                 text-decoration: none;
                 color: inherit;
             }
             table.filecontent td.line-code {padding: 0 0 0 4px;}
             table.filecontent td.line-code pre {
                 margin: 0px;
                 white-space: pre-wrap;
                 font-family:Consolas, Menlo, "Liberation Mono", Courier, monospace; font-size:12px;
             }
             table.filecontent tr:target th.line-num { background-color:#E0E0E0; color: #777; }
             table.filecontent tr:target td.line-code { background-color:#DDEEFF; }
+            img.filecontent.image { max-width: 100%; }
             /* 12 different colors for the annonate view */
             table.annotate tr.bloc-0 {background: #FFFFBF;}
             table.annotate tr.bloc-1 {background: #EABFFF;}
             table.annotate tr.bloc-2 {background: #BFFFFF;}
             table.annotate tr.bloc-3 {background: #FFD9BF;}
             table.annotate tr.bloc-4 {background: #E6FFBF;}
             table.annotate tr.bloc-5 {background: #BFCFFF;}
             table.annotate tr.bloc-6 {background: #FFBFEF;}
             table.annotate tr.bloc-7 {background: #FFE6BF;}
             table.annotate tr.bloc-8 {background: #FFE680;}
             table.annotate tr.bloc-9 {background: #AA80FF;}
             table.annotate tr.bloc-10 {background: #FFBFDC;}
             table.annotate tr.bloc-11 {background: #BFE4FF;}
             table.annotate td.revision {
                 padding:0;
                 text-align: center;
                 width: 2%;
                 padding-left: 1em;
                 background: inherit;
             }
             table.annotate td.author {
                 padding:0;
                 text-align: center;
                 border-right: 1px solid #d7d7d7;
                 white-space: nowrap;
                 padding-left: 1em;
                 padding-right: 1em;
                 width: 3%;
                 background: inherit;
             }
             table.annotate td.line-code { background-color: #fafafa; }
             div.action_M { background: #fd8 }
             div.action_D { background: #f88 }
             div.action_A { background: #bfb }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages