jro_apps/redmine Commit - r518:8614c00c8a3e

Text files can now be viewed online when browsing the repository....

Jean-Philippe Lang -

r518:8614c00c8a3e

parent child

Context file:

r518:8614c00c8a3e

Collapse all files

app/views/repositories/entry.rhtml created 644 +23 0

@@ -0,0 +1,23
	1	<h2><%= render :partial => 'navigation', :locals => { :path => @path, :kind => 'file', :revision => @rev } %></h2>
	2
	3	<table class="list">
	4	<thead>
	5	<tr>
	6	<th colspan="2" class="list-filename"><%= @path %></th>
	7	</tr>
	8	</thead>
	9	<tbody>
	10	<% line_num = 1 %>
	11	<% @content.each_line do \|line\| %>
	12	<tr>
	13	<th class="line-num"><%= line_num %></th>
	14	<td class="line-code"><%= h(line).gsub(/\s/, ' ') %></td>
	15	</tr>
	16	<% line_num += 1 %>
	17	<% end %>
	18	<tbody>
	19	</table>
	20
	21	<% content_for :header_tags do %>
	22	<%= stylesheet_link_tag "scm" %>
	23	<% end %>

lib/redmine/mime_type.rb created 644 +58 0

@@ -0,0 +1,58
	1	# redMine - project management software
	2	# Copyright (C) 2006-2007 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	module Redmine
	19	module MimeType
	20
	21	MIME_TYPES = {
	22	'text/plain' => 'txt',
	23	'text/css' => 'css',
	24	'text/html' => 'html,htm,xhtml',
	25	'text/x-javascript' => 'js',
	26	'text/x-html-template' => 'rhtml',
	27	'text/x-ruby' => 'rb,ruby',
	28	'image/gif' => 'gif',
	29	'image/jpeg' => 'jpg,jpeg,jpe',
	30	'image/png' => 'png',
	31	'image/tiff' => 'tiff,tif'
	32	}.freeze
	33
	34	EXTENSIONS = MIME_TYPES.inject({}) do \|map, (type, exts)\|
	35	exts.split(',').each {\|ext\| map[ext] = type}
	36	map
	37	end
	38
	39	# returns mime type for name or nil if unknown
	40	def self.of(name)
	41	return nil unless name
	42	m = name.to_s.match(/\.([^\.]+)$/)
	43	EXTENSIONS[m[1]] if m
	44	end
	45
	46	def self.main_mimetype_of(name)
	47	mimetype = of(name)
	48	mimetype.split('/').first if mimetype
	49	end
	50
	51	# return true if mime-type for name is type/*
	52	# otherwise false
	53	def self.is_type?(type, name)
	54	main_mimetype = main_mimetype_of(name)
	55	type.to_s == main_mimetype
	56	end
	57	end
	58	end

app/controllers/repositories_controller.rb +4 -4

             # redMine - project management software
             # Copyright (C) 2006-2007  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'
             class RepositoriesController < ApplicationController
               layout 'base'
               before_filter :find_project
               before_filter :authorize, :except => [:stats, :graph]
               before_filter :check_project_privacy, :only => [:stats, :graph]
               def show
                 # get entries for the browse frame
                 @entries = @repository.scm.entries('')
                 show_error and return unless @entries
                 # check if new revisions have been committed in the repository
                 scm_latestrev = @entries.revisions.latest
                 if Setting.autofetch_changesets? && scm_latestrev && ((@repository.latest_changeset.nil?) || (@repository.latest_changeset.revision < scm_latestrev.identifier.to_i))
                   @repository.fetch_changesets
                   @repository.reload
                 end
                 @changesets = @repository.changesets.find(:all, :limit => 5, :order => "committed_on DESC")
               end
               def browse
                 @entries = @repository.scm.entries(@path, @rev)
                 show_error and return unless @entries
               end
               def revisions
                 unless @path == ''
                   @entry = @repository.scm.entry(@path, @rev)
                   show_error and return unless @entry
                 end
                 @repository.changesets_with_path @path do
                   @changeset_count = @repository.changesets.count
                   @changeset_pages = Paginator.new self, @changeset_count,
 ,
               								      params['page']
                   @changesets = @repository.changesets.find(:all,
               						:limit  =>  @changeset_pages.items_per_page,
               						:offset =>  @changeset_pages.current.offset)
                 end
                 render :action => "revisions", :layout => false if request.xhr?
               end
               def entry
-                if 'raw' == params[:format]
+                @content = @repository.scm.cat(@path, @rev)
-                  content = @repository.scm.cat(@path, @rev)
+                show_error and return unless @content
-                  show_error and return unless content
+                if 'raw' == params[:format]
-                  send_data content, :filename => @path.split('/').last
+                  send_data @content, :filename => @path.split('/').last
                 end
               end
               def revision
                 @changeset = @repository.changesets.find_by_revision(@rev)
                 show_error and return unless @changeset
               end
               def diff
                 @rev_to = (params[:rev_to] && params[:rev_to].to_i > 0) ? params[:rev_to].to_i : (@rev - 1)
                 @diff_type = ('sbs' == params[:type]) ? 'sbs' : 'inline'
                 @cache_key = "repositories/diff/#{@repository.id}/" + Digest::MD5.hexdigest("#{@path}-#{@rev}-#{@rev_to}-#{@diff_type}")
                 unless read_fragment(@cache_key)
                   @diff = @repository.scm.diff(@path, @rev, @rev_to, type)
                   show_error and return unless @diff
                 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_project
                 @project = Project.find(params[:id])
                 @repository = @project.repository
                 render_404 and return false unless @repository
                 @path = params[:path].squeeze('/').gsub(/^\//, '') if params[:path]
                 @path ||= ''
                 @rev = params[:rev].to_i if params[:rev] and params[:rev].to_i > 0
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def show_error
                 flash.now[:notice] = l(:notice_scm_error)
                 render :nothing => true, :layout => true
               end
               def graph_commits_per_month(repository)
                 @date_to = Date.today
                 @date_from = @date_to << 12
                 commits_by_day = repository.changesets.count(:all, :group => :commit_date, :conditions => ["commit_date BETWEEN ? AND ?", @date_from, @date_to])
                 commits_by_month = [0] * 12
                 commits_by_day.each {|c| commits_by_month[c.first.to_date.months_ago] += c.last }
                 changes_by_day = repository.changes.count(:all, :group => :commit_date)
                 changes_by_month = [0] * 12
                 changes_by_day.each {|c| changes_by_month[c.first.to_date.months_ago] += c.last }
                 fields = []
                 month_names = l(:actionview_datehelper_select_month_names_abbr).split(',')
 .times {|m| fields << month_names[((Date.today.month - 1 - m) % 12)]}
                 graph = SVG::Graph::Bar.new(
                   :height => 300,
                   :width => 500,
                   :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)
                 commits_by_author = repository.changesets.count(:all, :group => :committer)
                 commits_by_author.sort! {|x, y| x.last <=> y.last}
                 changes_by_author = repository.changes.count(:all, :group => :committer)
                 h = changes_by_author.inject({}) {|o, i| o[i.first] = i.last; o}
                 fields = commits_by_author.collect {|r| r.first}
                 commits_data = commits_by_author.collect {|r| r.last}
                 changes_data = commits_by_author.collect {|r| h[r.first] || 0}
                 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
                 graph = SVG::Graph::BarHorizontal.new(
                   :height => 300,
                   :width => 500,
                   :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
             class Date
               def months_ago(date = Date.today)
                 (date.year - self.year)*12 + (date.month - self.month)
               end
               def weeks_ago(date = Date.today)
                 (date.year - self.year)*52 + (date.cweek - self.cweek)
               end
             end

app/models/svn_repos.rb +5 0

             # redMine - project management software
             # Copyright (C) 2006-2007  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 'rexml/document'
             require 'cgi'
             module SvnRepos
               class CommandFailed < StandardError #:nodoc:
               end
               class Base
                 def initialize(url, root_url=nil, login=nil, password=nil)
                   @url = url
                   @login = login if login && !login.empty?
                   @password = (password || "") if @login
                   @root_url = root_url.blank? ? retrieve_root_url : root_url
                 end
                 def root_url
                   @root_url
                 end
                 def url
                   @url
                 end
                 # get info about the svn repository
                 def info
                   cmd = "svn info --xml #{target('')}"
                   cmd << " --username #{@login} --password #{@password}" if @login
                   info = nil
                   shellout(cmd) do |io|
                     begin
                       doc = REXML::Document.new(io)
                       #root_url = doc.elements["info/entry/repository/root"].text
                       info = Info.new({:root_url => doc.elements["info/entry/repository/root"].text,
                                        :lastrev => Revision.new({
                                          :identifier => doc.elements["info/entry/commit"].attributes['revision'],
                                          :time => Time.parse(doc.elements["info/entry/commit/date"].text),
                                          :author => (doc.elements["info/entry/commit/author"] ? doc.elements["info/entry/commit/author"].text : "")
                                        })
                                      })
                     rescue
                     end
                   end
                   return nil if $? && $?.exitstatus != 0
                   info
                 rescue Errno::ENOENT => e
                   return nil
                 end
                 # Returns the entry identified by path and revision identifier
                 # or nil if entry doesn't exist in the repository
                 def entry(path=nil, identifier=nil)
                   e = entries(path, identifier)
                   e ? e.first : nil
                 end
                 # Returns an Entries collection
                 # or nil if the given path doesn't exist in the repository
                 def entries(path=nil, identifier=nil)
                   path ||= ''
                   identifier = 'HEAD' unless identifier and identifier > 0
                   entries = Entries.new
                   cmd = "svn list --xml #{target(path)}@#{identifier}"
                   cmd << " --username #{@login} --password #{@password}" if @login
                   shellout(cmd) do |io|
                     begin
                       doc = REXML::Document.new(io)
                       doc.elements.each("lists/list/entry") do |entry|
                         entries << Entry.new({:name => entry.elements['name'].text,
                                     :path => ((path.empty? ? "" : "#{path}/") + entry.elements['name'].text),
                                     :kind => entry.attributes['kind'],
                                     :size => (entry.elements['size'] and entry.elements['size'].text).to_i,
                                     :lastrev => Revision.new({
                                       :identifier => entry.elements['commit'].attributes['revision'],
                                       :time => Time.parse(entry.elements['commit'].elements['date'].text),
                                       :author => (entry.elements['commit'].elements['author'] ? entry.elements['commit'].elements['author'].text : "")
                                       })
                                     })
                       end
                     rescue
                     end
                   end
                   return nil if $? && $?.exitstatus != 0
                   entries.sort_by_name
                 rescue Errno::ENOENT => e
                   raise CommandFailed
                 end
                 def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})
                   path ||= ''
                   identifier_from = 'HEAD' unless identifier_from and identifier_from.to_i > 0
                   identifier_to = 1 unless identifier_to and identifier_to.to_i > 0
                   revisions = Revisions.new
                   cmd = "svn log --xml -r #{identifier_from}:#{identifier_to}"
                   cmd << " --username #{@login} --password #{@password}" if @login
                   cmd << " --verbose " if  options[:with_paths]
                   cmd << target(path)
                   shellout(cmd) do |io|
                     begin
                       doc = REXML::Document.new(io)
                       doc.elements.each("log/logentry") do |logentry|
                         paths = []
                         logentry.elements.each("paths/path") do |path|
                           paths << {:action => path.attributes['action'],
                                     :path => path.text,
                                     :from_path => path.attributes['copyfrom-path'],
                                     :from_revision => path.attributes['copyfrom-rev']
                                     }
                         end
                         paths.sort! { |x,y| x[:path] <=> y[:path] }
                         revisions << Revision.new({:identifier => logentry.attributes['revision'],
                                       :author => (logentry.elements['author'] ? logentry.elements['author'].text : ""),
                                       :time => Time.parse(logentry.elements['date'].text),
                                       :message => logentry.elements['msg'].text,
                                       :paths => paths
                                     })
                       end
                     rescue
                     end
                   end
                   return nil if $? && $?.exitstatus != 0
                   revisions
                 rescue Errno::ENOENT => e
                   raise CommandFailed
                 end
                 def diff(path, identifier_from, identifier_to=nil, type="inline")
                   path ||= ''
                   if identifier_to and identifier_to.to_i > 0
                     identifier_to = identifier_to.to_i
                   else
                     identifier_to = identifier_from.to_i - 1
                   end
                   cmd = "svn diff -r "
                   cmd << "#{identifier_to}:"
                   cmd << "#{identifier_from}"
                   cmd << "#{target(path)}@#{identifier_from}"
                   cmd << " --username #{@login} --password #{@password}" if @login
                   diff = []
                   shellout(cmd) do |io|
                     io.each_line do |line|
                       diff << line
                     end
                   end
                   return nil if $? && $?.exitstatus != 0
                   DiffTableList.new diff, type
                 rescue Errno::ENOENT => e
                   raise CommandFailed
                 end
                 def cat(path, identifier=nil)
                   identifier = (identifier and identifier.to_i > 0) ? identifier.to_i : "HEAD"
                   cmd = "svn cat #{target(path)}@#{identifier}"
                   cmd << " --username #{@login} --password #{@password}" if @login
                   cat = nil
                   shellout(cmd) do |io|
+                    io.binmode
                     cat = io.read
                   end
                   return nil if $? && $?.exitstatus != 0
                   cat
                 rescue Errno::ENOENT => e
                   raise CommandFailed
                 end
               private
                 def retrieve_root_url
                   info = self.info
                   info ? info.root_url : nil
                 end
                 def target(path)
                   path ||= ""
                   base = path.match(/^\//) ? root_url : url
                   " \"" << "#{base}/#{path}".gsub(/["'?<>\*]/, '') << "\""
                 end
                 def logger
                   RAILS_DEFAULT_LOGGER
                 end
                 def shellout(cmd, &block)
                   logger.debug "Shelling out: #{cmd}" if logger && logger.debug?
                   IO.popen(cmd, "r+") do |io|
                     io.close_write
                     block.call(io) if block_given?
                   end
                 end
               end
               class Entries < Array
                 def sort_by_name
                   sort {|x,y|
                     if x.kind == y.kind
                       x.name <=> y.name
                     else
                       x.kind <=> y.kind
                     end
                   }
                 end
                 def revisions
                   revisions ||= Revisions.new(collect{|entry| entry.lastrev})
                 end
               end
               class Info
                 attr_accessor :root_url, :lastrev
                 def initialize(attributes={})
                   self.root_url = attributes[:root_url] if attributes[:root_url]
                   self.lastrev = attributes[:lastrev]
                 end
               end
               class Entry
                 attr_accessor :name, :path, :kind, :size, :lastrev
                 def initialize(attributes={})
                   self.name = attributes[:name] if attributes[:name]
                   self.path = attributes[:path] if attributes[:path]
                   self.kind = attributes[:kind] if attributes[:kind]
                   self.size = attributes[:size].to_i if attributes[:size]
                   self.lastrev = attributes[:lastrev]
                 end
                 def is_file?
                   'file' == self.kind
                 end
                 def is_dir?
                   'dir' == self.kind
                 end
+                def is_text?
+                  Redmine::MimeType.is_type?('text', name)
+                end
               end
               class Revisions < Array
                 def latest
                   sort {|x,y| x.time <=> y.time}.last
                 end
               end
               class Revision
                 attr_accessor :identifier, :author, :time, :message, :paths
                 def initialize(attributes={})
                   self.identifier = attributes[:identifier]
                   self.author = attributes[:author]
                   self.time = attributes[:time]
                   self.message = attributes[:message] || ""
                   self.paths = attributes[:paths]
                 end
               end
               # A line of Diff
               class Diff
                 attr_accessor :nb_line_left
                 attr_accessor :line_left
                 attr_accessor :nb_line_right
                 attr_accessor :line_right
                 attr_accessor :type_diff_right
                 attr_accessor :type_diff_left
                 def initialize ()
                   self.nb_line_left = ''
                   self.nb_line_right = ''
                   self.line_left = ''
                   self.line_right = ''
                   self.type_diff_right = ''
                   self.type_diff_left = ''
                 end
                 def inspect
                   puts '### Start Line Diff ###'
                   puts self.nb_line_left
                   puts self.line_left
                   puts self.nb_line_right
                   puts self.line_right
                 end
               end
               class DiffTableList < Array
                 def initialize (diff, type="inline")
                     diff_table = DiffTable.new type
                     diff.each do |line|
                         if line =~ /^Index: (.*)$/
                             self << diff_table if diff_table.length > 1
                             diff_table = DiffTable.new type
                         end
                         a = diff_table.add_line line
                     end
                     self << diff_table
                 end
               end
               # Class for create a Diff
               class DiffTable < Hash
                 attr_reader :file_name, :line_num_l, :line_num_r
                 # Initialize with a Diff file and the type of Diff View
                 # The type view must be inline or sbs (side_by_side)
                 def initialize (type="inline")
                   @parsing = false
                   @nb_line = 1
                   @start = false
                   @before = 'same'
                   @second = true
                   @type = type
                 end
                 # Function for add a line of this Diff
                 def add_line(line)
                   unless @parsing
                     if line =~ /^Index: (.*)$/
                       @file_name = $1
                       return false
                     elsif line =~ /^@@ (\+|\-)(\d+)(,\d+)? (\+|\-)(\d+)(,\d+)? @@/
                       @line_num_l = $2.to_i
                       @line_num_r = $5.to_i
                       @parsing = true
                     end
                   else
                     if line =~ /^_+$/
                       self.delete(self.keys.sort.last)
                       @parsing = false
                       return false
                     elsif line =~ /^@@ (\+|\-)(\d+)(,\d+)? (\+|\-)(\d+)(,\d+)? @@/
                       @line_num_l = $2.to_i
                       @line_num_r = $5.to_i
                     else
                       @nb_line += 1 if parse_line(line, @type)
                     end
                   end
                   return true
                 end
                 def inspect
                   puts '### DIFF TABLE ###'
                   puts "file : #{file_name}"
                   self.each do |d|
                     d.inspect
                   end
                 end
               private
                 # Test if is a Side By Side type
                 def sbs?(type, func)
                   if @start and type == "sbs"
                     if @before == func and @second
                       tmp_nb_line = @nb_line
                       self[tmp_nb_line] = Diff.new
                     else
                         @second = false
                         tmp_nb_line = @start
                         @start += 1
                         @nb_line -= 1
                     end
                   else
                     tmp_nb_line = @nb_line
                     @start = @nb_line
                     self[tmp_nb_line] = Diff.new
                     @second = true
                   end
                   unless self[tmp_nb_line]
                     @nb_line += 1
                     self[tmp_nb_line] = Diff.new
                   else
                     self[tmp_nb_line]
                   end
                 end
                 # Escape the HTML for the diff
                 def escapeHTML(line)
                     CGI.escapeHTML(line).gsub(/\s/, '&nbsp;')
                 end
                 def parse_line (line, type="inline")
                   if line[0, 1] == "+"
                     diff = sbs? type, 'add'
                     @before = 'add'
                     diff.line_left = escapeHTML line[1..-1]
                     diff.nb_line_left = @line_num_l
                     diff.type_diff_left = 'diff_in'
                     @line_num_l += 1
                     true
                   elsif line[0, 1] == "-"
                     diff = sbs? type, 'remove'
                     @before = 'remove'
                     diff.line_right = escapeHTML line[1..-1]
                     diff.nb_line_right = @line_num_r
                     diff.type_diff_right = 'diff_out'
                     @line_num_r += 1
                     true
                   elsif line[0, 1] =~ /\s/
                     @before = 'same'
                     @start = false
                     diff = Diff.new
                     diff.line_right = escapeHTML line[1..-1]
                     diff.nb_line_right = @line_num_r
                     diff.line_left = escapeHTML line[1..-1]
                     diff.nb_line_left = @line_num_l
                     self[@nb_line] = diff
                     @line_num_l += 1
                     @line_num_r += 1
                     true
                   else
                     false
                   end
                 end
               end
             end

app/views/repositories/revisions.rhtml +6 -1

             <div class="contextual">
             <% form_tag do %>
             <p><%= l(:label_revision) %>: <%= text_field_tag 'rev', @rev, :size => 5 %>
             <%= submit_tag 'OK' %></p>
             <% end %>
             </div>
             <h2><%= render :partial => 'navigation', :locals => { :path => @path, :kind => (@entry ? @entry.kind : nil), :revision => @rev } %></h2>
             <% if @entry && @entry.is_file? %>
             <h3><%=h @entry.name %></h3>
-            <p><%= link_to l(:button_download), {:action => 'entry', :id => @project, :path => @path, :rev => @rev, :format => 'raw' }, :class => "icon file" %> (<%= number_to_human_size @entry.size %>)</p>
+            <p>
+            <% if @entry.is_text? %>
+            <%= link_to l(:button_view), {:action => 'entry', :id => @project, :path => @path, :rev => @rev } %> |
+            <% end %>
+            <%= link_to l(:button_download), {:action => 'entry', :id => @project, :path => @path, :rev => @rev, :format => 'raw' } %>
+            (<%= number_to_human_size @entry.size %>)</p>
             <% end %>
             <h3><%= l(:label_revision_plural) %></h3>
             <%= render :partial => 'revisions', :locals => {:project => @project, :path => @path, :changesets => @changesets, :entry => @entry }%>
             <p><%= pagination_links_full @changeset_pages %>
             [ <%= @changeset_pages.current.first_item %> - <%= @changeset_pages.current.last_item %> / <%= @changeset_count %> ]</p>
             <% content_for :header_tags do %>
             <%= stylesheet_link_tag "scm" %>
             <% end %>

lib/redmine.rb +1 0

             require 'redmine/version'
+            require 'redmine/mime_type'
             require 'redmine/acts_as_watchable/init'

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