jro_apps/redmine Commit - r1056:18066ba8bf68

Added a couple of mime types so that corresponding files can be viewed in the browser....

Jean-Philippe Lang -

r1056:18066ba8bf68

parent child

Context file:

r1056:18066ba8bf68

Collapse all files

vendor/plugins/coderay-0.7.6.227/lib/coderay/scanners/php.rb created 644 +165 0

@@ -0,0 +1,165
	1	module CodeRay module Scanners
	2
	3	class PHP < Scanner
	4
	5	register_for :php
	6
	7	RESERVED_WORDS = [
	8	'and', 'or', 'xor', '__FILE__', 'exception', '__LINE__', 'array', 'as', 'break', 'case',
	9	'class', 'const', 'continue', 'declare', 'default',
	10	'die', 'do', 'echo', 'else', 'elseif',
	11	'empty', 'enddeclare', 'endfor', 'endforeach', 'endif',
	12	'endswitch', 'endwhile', 'eval', 'exit', 'extends',
	13	'for', 'foreach', 'function', 'global', 'if',
	14	'include', 'include_once', 'isset', 'list', 'new',
	15	'print', 'require', 'require_once', 'return', 'static',
	16	'switch', 'unset', 'use', 'var', 'while',
	17	'__FUNCTION__', '__CLASS__', '__METHOD__', 'final', 'php_user_filter',
	18	'interface', 'implements', 'extends', 'public', 'private',
	19	'protected', 'abstract', 'clone', 'try', 'catch',
	20	'throw', 'cfunction', 'old_function'
	21	]
	22
	23	PREDEFINED_CONSTANTS = [
	24	'null', '$this', 'true', 'false'
	25	]
	26
	27	IDENT_KIND = WordList.new(:ident).
	28	add(RESERVED_WORDS, :reserved).
	29	add(PREDEFINED_CONSTANTS, :pre_constant)
	30
	31	ESCAPE = / [\$\wrbfnrtv\n\\\/'"] \| x[a-fA-F0-9]{1,2} \| [0-7]{1,3} /x
	32	UNICODE_ESCAPE = / u[a-fA-F0-9]{4} \| U[a-fA-F0-9]{8} /x
	33
	34	def scan_tokens tokens, options
	35
	36	state = :waiting_php
	37	string_type = nil
	38	regexp_allowed = true
	39
	40	until eos?
	41
	42	kind = :error
	43	match = nil
	44
	45	if state == :initial
	46
	47	if scan(/ \s+ \| \\\n /x)
	48	kind = :space
	49
	50	elsif scan(/\?>/)
	51	kind = :char
	52	state = :waiting_php
	53
	54	elsif scan(%r{ (//\|\#) [^\n\\]* (?: \\. [^\n\\]* )* \| /\* (?: .? \/ \| .* ) }mx)
	55	kind = :comment
	56	regexp_allowed = false
	57
	58	elsif match = scan(/ \# \s* if \s* 0 /x)
	59	match << scan_until(/ ^\# (?:elif\|else\|endif) .*? $ \| \z /xm) unless eos?
	60	kind = :comment
	61	regexp_allowed = false
	62
	63	elsif regexp_allowed and scan(/\//)
	64	tokens << [:open, :regexp]
	65	state = :regex
	66	kind = :delimiter
	67
	68	elsif scan(/ [-+*\/=<>?:;,!&^\|()\[\]{}~%] \| \.(?!\d) /x)
	69	kind = :operator
	70	regexp_allowed=true
	71
	72	elsif match = scan(/ [$@A-Za-z_][A-Za-z_0-9]* /x)
	73	kind = IDENT_KIND[match]
	74	regexp_allowed=false
	75
	76	elsif match = scan(/["']/)
	77	tokens << [:open, :string]
	78	string_type = matched
	79	state = :string
	80	kind = :delimiter
	81
	82	elsif scan(/0[xX][0-9A-Fa-f]+/)
	83	kind = :hex
	84	regexp_allowed=false
	85
	86	elsif scan(/(?:0[0-7]+)(?![89.eEfF])/)
	87	kind = :oct
	88	regexp_allowed=false
	89
	90	elsif scan(/(?:\d+)(?![.eEfF])/)
	91	kind = :integer
	92	regexp_allowed=false
	93
	94	elsif scan(/\d[fF]?\|\d*\.\d+(?:[eE][+-]?\d+)?[fF]?\|\d+[eE][+-]?\d+[fF]?/)
	95	kind = :float
	96	regexp_allowed=false
	97
	98	else
	99	getch
	100	end
	101
	102	elsif state == :regex
	103	if scan(/[^\\\/]+/)
	104	kind = :content
	105	elsif scan(/\\\/\|\\/)
	106	kind = :content
	107	elsif scan(/\//)
	108	tokens << [matched, :delimiter]
	109	tokens << [:close, :regexp]
	110	state = :initial
	111	next
	112	else
	113	getch
	114	kind = :content
	115	end
	116
	117	elsif state == :string
	118	if scan(/[^\\"']+/)
	119	kind = :content
	120	elsif scan(/["']/)
	121	if string_type==matched
	122	tokens << [matched, :delimiter]
	123	tokens << [:close, :string]
	124	state = :initial
	125	string_type=nil
	126	next
	127	else
	128	kind = :content
	129	end
	130	elsif scan(/ \\ (?: \S ) /mox)
	131	kind = :char
	132	elsif scan(/ \\ \| $ /x)
	133	kind = :error
	134	state = :initial
	135	else
	136	raise "else case \" reached; %p not handled." % peek(1), tokens
	137	end
	138
	139	elsif state == :waiting_php
	140	if scan(/<\?php/m)
	141	kind = :char
	142	state = :initial
	143	elsif scan(/[^<]+/)
	144	kind = :comment
	145	else
	146	kind = :comment
	147	getch
	148	end
	149	else
	150	raise 'else-case reached', tokens
	151
	152	end
	153
	154	match \|\|= matched
	155
	156	tokens << [match, kind]
	157
	158	end
	159	tokens
	160
	161	end
	162
	163	end
	164
	165	end end No newline at end of file

lib/redmine/mime_type.rb +6 -1

             # 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.
             module Redmine
               module MimeType
                 MIME_TYPES = {
-                  'text/plain' => 'txt',
+                  'text/plain' => 'txt,tpl,properties',
                   'text/css' => 'css',
                   'text/html' => 'html,htm,xhtml',
                   'text/x-c' => 'c,cpp,h',
+                  'text/x-java' => 'java',
                   'text/x-javascript' => 'js',
                   'text/x-html-template' => 'rhtml',
+                  'text/x-perl' => 'pl,pm',
+                  'text/x-php' => 'php,php3,php4,php5',
+                  'text/x-python' => 'py',
                   'text/x-ruby' => 'rb,rbw,ruby,rake',
+                  'text/x-sh' => 'sh',
                   'text/xml' => 'xml',
                   'text/yaml' => 'yml,yaml',
                   'image/gif' => 'gif',
                   'image/jpeg' => 'jpg,jpeg,jpe',
                   'image/png' => 'png',
                   'image/tiff' => 'tiff,tif'
                 }.freeze
                 EXTENSIONS = MIME_TYPES.inject({}) do |map, (type, exts)|
                   exts.split(',').each {|ext| map[ext] = type}
                   map
                 end
                 # returns mime type for name or nil if unknown
                 def self.of(name)
                   return nil unless name
                   m = name.to_s.match(/\.([^\.]+)$/)
                   EXTENSIONS[m[1]] if m
                 end
                 def self.main_mimetype_of(name)
                   mimetype = of(name)
                   mimetype.split('/').first if mimetype
                 end
                 # return true if mime-type for name is type/*
                 # otherwise false
                 def self.is_type?(type, name)
                   main_mimetype = main_mimetype_of(name)
                   type.to_s == main_mimetype
                 end
               end
             end

vendor/plugins/coderay-0.7.6.227/lib/coderay/helpers/file_type.rb +4 0

             module CodeRay
             # = FileType
             #
             # A simple filetype recognizer.
             #
             # Copyright (c) 2006 by murphy (Kornelius Kalnbach) <murphy rubychan de>
             #
             # License:: LGPL / ask the author
             # Version:: 0.1 (2005-09-01)
             #
             # == Documentation
             #
             #  # determine the type of the given
             #   lang = FileType[ARGV.first]
             #
             #   # return :plaintext if the file type is unknown
             #   lang = FileType.fetch ARGV.first, :plaintext
             #
             #   # try the shebang line, too
             #   lang = FileType.fetch ARGV.first, :plaintext, true
             module FileType
               UnknownFileType = Class.new Exception
               class << self
                 # Try to determine the file type of the file.
                 #
                 # +filename+ is a relative or absolute path to a file.
                 #
                 # The file itself is only accessed when +read_shebang+ is set to true.
                 # That means you can get filetypes from files that don't exist.
                 def [] filename, read_shebang = false
                   name = File.basename filename
                   ext = File.extname name
                   ext.sub!(/^\./, '')  # delete the leading dot
                   type =
                     TypeFromExt[ext] ||
                     TypeFromExt[ext.downcase] ||
                     TypeFromName[name] ||
                     TypeFromName[name.downcase]
                   type ||= shebang(filename) if read_shebang
                   type
                 end
                 def shebang filename
                   begin
                     File.open filename, 'r' do |f|
                       first_line = f.gets
                       first_line[TypeFromShebang]
                     end
                   rescue IOError
                     nil
                   end
                 end
                 # This works like Hash#fetch.
                 #
                 # If the filetype cannot be found, the +default+ value
                 # is returned.
                 def fetch filename, default = nil, read_shebang = false
                   if default and block_given?
                     warn 'block supersedes default value argument'
                   end
                   unless type = self[filename, read_shebang]
                     return yield if block_given?
                     return default if default
                     raise UnknownFileType, 'Could not determine type of %p.' % filename
                   end
                   type
                 end
               end
               TypeFromExt = {
                 'rb' => :ruby,
                 'rbw' => :ruby,
                 'rake' => :ruby,
                 'mab' => :ruby,
                 'cpp' => :c,
                 'c' => :c,
                 'h' => :c,
                 'js' => :javascript,
                 'xml' => :xml,
                 'htm' => :html,
                 'html' => :html,
+                'php' => :php,
+                'php3' => :php,
+                'php4' => :php,
+                'php5' => :php,
                 'xhtml' => :xhtml,
                 'raydebug' => :debug,
                 'rhtml' => :rhtml,
                 'ss' => :scheme,
                 'sch' => :scheme,
                 'yaml' => :yaml,
                 'yml' => :yaml,
               }
               TypeFromShebang = /\b(?:ruby|perl|python|sh)\b/
               TypeFromName = {
                 'Rakefile' => :ruby,
                 'Rantfile' => :ruby,
               }
             end
             end
             if $0 == __FILE__
               $VERBOSE = true
               eval DATA.read, nil, $0, __LINE__+4
             end
             __END__
             require 'test/unit'
             class TC_FileType < Test::Unit::TestCase
               def test_fetch
                 assert_raise FileType::UnknownFileType do
                   FileType.fetch ''
                 end
                 assert_throws :not_found do
                   FileType.fetch '.' do
                     throw :not_found
                   end
                 end
                 assert_equal :default, FileType.fetch('c', :default)
                 stderr, fake_stderr = $stderr, Object.new
                 $err = ''
                 def fake_stderr.write x
                   $err << x
                 end
                 $stderr = fake_stderr
                 FileType.fetch('c', :default) { }
                 assert_equal "block supersedes default value argument\n", $err
                 $stderr = stderr
               end
               def test_ruby
                 assert_equal :ruby, FileType['test.rb']
                 assert_equal :ruby, FileType['C:\\Program Files\\x\\y\\c\\test.rbw']
                 assert_equal :ruby, FileType['/usr/bin/something/Rakefile']
                 assert_equal :ruby, FileType['~/myapp/gem/Rantfile']
                 assert_equal :ruby, FileType['./lib/tasks\repository.rake']
                 assert_not_equal :ruby, FileType['test_rb']
                 assert_not_equal :ruby, FileType['Makefile']
                 assert_not_equal :ruby, FileType['set.rb/set']
                 assert_not_equal :ruby, FileType['~/projects/blabla/rb']
               end
               def test_c
                 assert_equal :c, FileType['test.c']
                 assert_equal :c, FileType['C:\\Program Files\\x\\y\\c\\test.h']
                 assert_not_equal :c, FileType['test_c']
                 assert_not_equal :c, FileType['Makefile']
                 assert_not_equal :c, FileType['set.h/set']
                 assert_not_equal :c, FileType['~/projects/blabla/c']
               end
               def test_html
                 assert_equal :html, FileType['test.htm']
                 assert_equal :xhtml, FileType['test.xhtml']
                 assert_equal :xhtml, FileType['test.html.xhtml']
                 assert_equal :rhtml, FileType['_form.rhtml']
               end
               def test_yaml
                 assert_equal :yaml, FileType['test.yml']
                 assert_equal :yaml, FileType['test.yaml']
                 assert_equal :yaml, FileType['my.html.yaml']
                 assert_not_equal :yaml, FileType['YAML']
               end
               def test_shebang
                 dir = './test'
                 if File.directory? dir
                   Dir.chdir dir do
                     assert_equal :c, FileType['test.c']
                   end
                 end
               end
             end

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