jro_apps/redmine Commit - r4619:144ca23442a5

Coderay upgraded to 0.9.7 (#5344)....

Jean-Philippe Lang -

r4619:144ca23442a5

parent child

Context file:

r4619:144ca23442a5

Expand all files

vendor/gems/coderay-0.9.7/.specification created 644 +155 0

@@ -0,0 +1,155
	1	--- !ruby/object:Gem::Specification
	2	name: coderay
	3	version: !ruby/object:Gem::Version
	4	hash: 53
	5	prerelease: false
	6	segments:
	7	- 0
	8	- 9
	9	- 7
	10	version: 0.9.7
	11	platform: ruby
	12	authors:
	13	- murphy
	14	autorequire:
	15	bindir: bin
	16	cert_chain: []
	17
	18	date: 2011-01-15 00:00:00 +01:00
	19	default_executable:
	20	dependencies: []
	21
	22	description: \|
	23	Fast and easy syntax highlighting for selected languages, written in Ruby.
	24	Comes with RedCloth integration and LOC counter.
	25
	26	email: murphy@rubychan.de
	27	executables:
	28	- coderay
	29	- coderay_stylesheet
	30	extensions: []
	31
	32	extra_rdoc_files:
	33	- lib/README
	34	- FOLDERS
	35	files:
	36	- ./lib/coderay/duo.rb
	37	- ./lib/coderay/encoder.rb
	38	- ./lib/coderay/encoders/_map.rb
	39	- ./lib/coderay/encoders/comment_filter.rb
	40	- ./lib/coderay/encoders/count.rb
	41	- ./lib/coderay/encoders/debug.rb
	42	- ./lib/coderay/encoders/div.rb
	43	- ./lib/coderay/encoders/filter.rb
	44	- ./lib/coderay/encoders/html/css.rb
	45	- ./lib/coderay/encoders/html/numerization.rb
	46	- ./lib/coderay/encoders/html/output.rb
	47	- ./lib/coderay/encoders/html.rb
	48	- ./lib/coderay/encoders/json.rb
	49	- ./lib/coderay/encoders/lines_of_code.rb
	50	- ./lib/coderay/encoders/null.rb
	51	- ./lib/coderay/encoders/page.rb
	52	- ./lib/coderay/encoders/span.rb
	53	- ./lib/coderay/encoders/statistic.rb
	54	- ./lib/coderay/encoders/term.rb
	55	- ./lib/coderay/encoders/text.rb
	56	- ./lib/coderay/encoders/token_class_filter.rb
	57	- ./lib/coderay/encoders/xml.rb
	58	- ./lib/coderay/encoders/yaml.rb
	59	- ./lib/coderay/for_redcloth.rb
	60	- ./lib/coderay/helpers/file_type.rb
	61	- ./lib/coderay/helpers/gzip_simple.rb
	62	- ./lib/coderay/helpers/plugin.rb
	63	- ./lib/coderay/helpers/word_list.rb
	64	- ./lib/coderay/scanner.rb
	65	- ./lib/coderay/scanners/_map.rb
	66	- ./lib/coderay/scanners/c.rb
	67	- ./lib/coderay/scanners/cpp.rb
	68	- ./lib/coderay/scanners/css.rb
	69	- ./lib/coderay/scanners/debug.rb
	70	- ./lib/coderay/scanners/delphi.rb
	71	- ./lib/coderay/scanners/diff.rb
	72	- ./lib/coderay/scanners/groovy.rb
	73	- ./lib/coderay/scanners/html.rb
	74	- ./lib/coderay/scanners/java/builtin_types.rb
	75	- ./lib/coderay/scanners/java.rb
	76	- ./lib/coderay/scanners/java_script-0.9.6.rb
	77	- ./lib/coderay/scanners/java_script.rb
	78	- ./lib/coderay/scanners/json.rb
	79	- ./lib/coderay/scanners/nitro_xhtml.rb
	80	- ./lib/coderay/scanners/php.rb
	81	- ./lib/coderay/scanners/plaintext.rb
	82	- ./lib/coderay/scanners/python.rb
	83	- ./lib/coderay/scanners/rhtml.rb
	84	- ./lib/coderay/scanners/ruby/patterns.rb
	85	- ./lib/coderay/scanners/ruby.rb
	86	- ./lib/coderay/scanners/scheme.rb
	87	- ./lib/coderay/scanners/sql.rb
	88	- ./lib/coderay/scanners/xml.rb
	89	- ./lib/coderay/scanners/yaml.rb
	90	- ./lib/coderay/style.rb
	91	- ./lib/coderay/styles/_map.rb
	92	- ./lib/coderay/styles/cycnus.rb
	93	- ./lib/coderay/styles/murphy.rb
	94	- ./lib/coderay/token_classes.rb
	95	- ./lib/coderay/tokens.rb
	96	- ./lib/coderay.rb
	97	- ./Rakefile
	98	- ./test/functional/basic.rb
	99	- ./test/functional/basic.rbc
	100	- ./test/functional/for_redcloth.rb
	101	- ./test/functional/for_redcloth.rbc
	102	- ./test/functional/load_plugin_scanner.rb
	103	- ./test/functional/load_plugin_scanner.rbc
	104	- ./test/functional/suite.rb
	105	- ./test/functional/suite.rbc
	106	- ./test/functional/vhdl.rb
	107	- ./test/functional/vhdl.rbc
	108	- ./test/functional/word_list.rb
	109	- ./test/functional/word_list.rbc
	110	- ./lib/README
	111	- ./LICENSE
	112	- lib/README
	113	- FOLDERS
	114	- bin/coderay
	115	- bin/coderay_stylesheet
	116	has_rdoc: true
	117	homepage: http://coderay.rubychan.de
	118	licenses: []
	119
	120	post_install_message:
	121	rdoc_options:
	122	- -SNw2
	123	- -mlib/README
	124	- -t CodeRay Documentation
	125	require_paths:
	126	- lib
	127	required_ruby_version: !ruby/object:Gem::Requirement
	128	none: false
	129	requirements:
	130	- - ">="
	131	- !ruby/object:Gem::Version
	132	hash: 51
	133	segments:
	134	- 1
	135	- 8
	136	- 2
	137	version: 1.8.2
	138	required_rubygems_version: !ruby/object:Gem::Requirement
	139	none: false
	140	requirements:
	141	- - ">="
	142	- !ruby/object:Gem::Version
	143	hash: 3
	144	segments:
	145	- 0
	146	version: "0"
	147	requirements: []
	148
	149	rubyforge_project: coderay
	150	rubygems_version: 1.3.7
	151	signing_key:
	152	specification_version: 3
	153	summary: Fast syntax highlighting for selected languages.
	154	test_files:
	155	- ./test/functional/suite.rb

vendor/gems/coderay-0.9.7/FOLDERS created 644 +53 0

@@ -0,0 +1,53
	1	= CodeRay - Trunk folder structure
	2
	3	== bench - Benchmarking system
	4
	5	All benchmarking stuff goes here.
	6
	7	Test inputs are stored in files named <code>example.<lang></code>.
	8	Test outputs go to <code>bench/test.<encoder-default-file-extension></code>.
	9
	10	Run <code>bench/bench.rb</code> to get a usage description.
	11
	12	Run <code>rake bench</code> to perform an example benchmark.
	13
	14
	15	== bin - Scripts
	16
	17	Executional files for CodeRay.
	18
	19
	20	== demo - Demos and functional tests
	21
	22	Demonstrational scripts to show of CodeRay's features.
	23
	24	Run them as functional tests with <code>rake test:demos</code>.
	25
	26
	27	== etc - Lots of stuff
	28
	29	Some addidtional files for CodeRay, mainly graphics and Vim scripts.
	30
	31
	32	== gem_server - Gem output folder
	33
	34	For <code>rake gem</code>.
	35
	36
	37	== lib - CodeRay library code
	38
	39	This is the base directory for the CodeRay library.
	40
	41
	42	== rake_helpers - Rake helper libraries
	43
	44	Some files to enhance Rake, including the Autumnal Rdoc template and some scripts.
	45
	46
	47	== test - Tests
	48
	49	Tests for the scanners.
	50
	51	Each language has its own subfolder and sub-suite.
	52
	53	Run with <code>rake test</code>.

vendor/gems/coderay-0.9.7/Rakefile created 644 +35 0

@@ -0,0 +1,35
	1	require 'rake/rdoctask'
	2
	3	ROOT = '.'
	4	LIB_ROOT = File.join ROOT, 'lib'
	5	EXTRA_RDOC_FILES = %w(lib/README FOLDERS)
	6
	7	task :default => :test
	8
	9	if File.directory? 'rake_tasks'
	10
	11	# load rake tasks from subfolder
	12	for task_file in Dir['rake_tasks/*.rake'].sort
	13	load task_file
	14	end
	15
	16	else
	17
	18	# fallback tasks when rake_tasks folder is not present
	19	desc 'Run CodeRay tests (basic)'
	20	task :test do
	21	ruby './test/functional/suite.rb'
	22	ruby './test/functional/for_redcloth.rb'
	23	end
	24
	25	desc 'Generate documentation for CodeRay'
	26	Rake::RDocTask.new :doc do \|rd\|
	27	rd.title = 'CodeRay Documentation'
	28	rd.main = 'lib/README'
	29	rd.rdoc_files.add Dir['lib']
	30	rd.rdoc_files.add 'lib/README'
	31	rd.rdoc_files.add 'FOLDERS'
	32	rd.rdoc_dir = 'doc'
	33	end
	34
	35	end No newline at end of file

vendor/gems/coderay-0.9.7/bin/coderay created 644 +86 0

@@ -0,0 +1,86
	1	#!/usr/bin/env ruby
	2	# CodeRay Executable
	3	#
	4	# Version: 0.2
	5	# Author: murphy
	6
	7	require 'coderay'
	8
	9	if ARGV.empty?
	10	$stderr.puts <<-USAGE
	11	CodeRay #{CodeRay::VERSION} (http://coderay.rubychan.de)
	12
	13	Usage:
	14	coderay file [-<format>]
	15	coderay -<lang> [-<format>] [< file] [> output]
	16
	17	Defaults:
	18	lang: based on file extension
	19	format: ANSI colorized output for terminal, HTML page for files
	20
	21	Examples:
	22	coderay foo.rb # colorized output to terminal, based on file extension
	23	coderay foo.rb -loc # print LOC count, based on file extension and format
	24	coderay foo.rb > foo.html # HTML page output to file, based on extension
	25	coderay -ruby < foo.rb # colorized output to terminal, based on lang
	26	coderay -ruby -loc < foo.rb # print LOC count, based on lang
	27	coderay -ruby -page foo.rb # HTML page output to terminal, based on lang and format
	28	coderay -ruby -page foo.rb > foo.html # HTML page output to file, based on lang and format
	29	USAGE
	30	end
	31
	32	first, second = ARGV
	33
	34	def read
	35	file = ARGV.grep(/^(?!-)/).last
	36	if file
	37	if File.exist?(file)
	38	File.read file
	39	else
	40	$stderr.puts "No such file: #{file}"
	41	end
	42	else
	43	$stdin.read
	44	end
	45	end
	46
	47	if first
	48	if first[/-(\w+)/] == first
	49	lang = $1
	50	input = read
	51	tokens = :scan
	52	else
	53	file = first
	54	unless File.exist? file
	55	$stderr.puts "No such file: #{file}"
	56	exit 2
	57	end
	58	tokens = CodeRay.scan_file file
	59	end
	60	else
	61	$stderr.puts 'No lang/file given.'
	62	exit 1
	63	end
	64
	65	if second
	66	if second[/-(\w+)/] == second
	67	format = $1.to_sym
	68	else
	69	raise 'invalid format (must be -xxx)'
	70	end
	71	else
	72	if $stdout.tty?
	73	format = :term
	74	else
	75	$stderr.puts 'No format given; setting to default (HTML Page).'
	76	format = :page
	77	end
	78	end
	79
	80	if tokens == :scan
	81	output = CodeRay::Duo[lang => format].highlight input
	82	else
	83	output = tokens.encode format
	84	end
	85	out = $stdout
	86	out.puts output

vendor/gems/coderay-0.9.7/bin/coderay_stylesheet created 644 +4 0

@@ -0,0 +1,4
	1	#!/usr/bin/env ruby
	2	require 'coderay'
	3
	4	puts CodeRay::Encoders[:html]::CSS.new.stylesheet

vendor/gems/coderay-0.9.7/lib/coderay/scanners/java_script.rb created 644 +224 0

@@ -0,0 +1,224
	1	module CodeRay
	2	module Scanners
	3
	4	class JavaScript < Scanner
	5
	6	include Streamable
	7
	8	register_for :java_script
	9	file_extension 'js'
	10
	11	# The actual JavaScript keywords.
	12	KEYWORDS = %w[
	13	break case catch continue default delete do else
	14	finally for function if in instanceof new
	15	return switch throw try typeof var void while with
	16	]
	17	PREDEFINED_CONSTANTS = %w[
	18	false null true undefined
	19	]
	20
	21	MAGIC_VARIABLES = %w[ this arguments ] # arguments was introduced in JavaScript 1.4
	22
	23	KEYWORDS_EXPECTING_VALUE = WordList.new.add %w[
	24	case delete in instanceof new return throw typeof with
	25	]
	26
	27	# Reserved for future use.
	28	RESERVED_WORDS = %w[
	29	abstract boolean byte char class debugger double enum export extends
	30	final float goto implements import int interface long native package
	31	private protected public short static super synchronized throws transient
	32	volatile
	33	]
	34
	35	IDENT_KIND = WordList.new(:ident).
	36	add(RESERVED_WORDS, :reserved).
	37	add(PREDEFINED_CONSTANTS, :pre_constant).
	38	add(MAGIC_VARIABLES, :local_variable).
	39	add(KEYWORDS, :keyword)
	40
	41	ESCAPE = / [bfnrtv\n\\'"] \| x[a-fA-F0-9]{1,2} \| [0-7]{1,3} /x
	42	UNICODE_ESCAPE = / u[a-fA-F0-9]{4} \| U[a-fA-F0-9]{8} /x
	43	REGEXP_ESCAPE = / [bBdDsSwW] /x
	44	STRING_CONTENT_PATTERN = {
	45	"'" => /[^\\']+/,
	46	'"' => /[^\\"]+/,
	47	'/' => /[^\\\/]+/,
	48	}
	49	KEY_CHECK_PATTERN = {
	50	"'" => / (?> [^\\']* (?: \\. [^\\']* )* ) ' \s* : /mx,
	51	'"' => / (?> [^\\"]* (?: \\. [^\\"]* )* ) " \s* : /mx,
	52	}
	53
	54	def scan_tokens tokens, options
	55
	56	state = :initial
	57	string_delimiter = nil
	58	value_expected = true
	59	key_expected = false
	60	function_expected = false
	61
	62	until eos?
	63
	64	kind = nil
	65	match = nil
	66
	67	case state
	68
	69	when :initial
	70
	71	if match = scan(/ \s+ \| \\\n /x)
	72	value_expected = true if !value_expected && match.index(?\n)
	73	tokens << [match, :space]
	74	next
	75
	76	elsif scan(%r! // [^\n\\]* (?: \\. [^\n\\]* )* \| /\* (?: .? \/ \| .* ) !mx)
	77	value_expected = true
	78	kind = :comment
	79
	80	elsif check(/\.?\d/)
	81	key_expected = value_expected = false
	82	if scan(/0[xX][0-9A-Fa-f]+/)
	83	kind = :hex
	84	elsif scan(/(?>0[0-7]+)(?![89.eEfF])/)
	85	kind = :oct
	86	elsif scan(/\d+[fF]\|\d*\.\d+(?:[eE][+-]?\d+)?[fF]?\|\d+[eE][+-]?\d+[fF]?/)
	87	kind = :float
	88	elsif scan(/\d+/)
	89	kind = :integer
	90	end
	91
	92	elsif value_expected && match = scan(/<([[:alpha:]]\w) (?: [^\/>]\/> \| .*?<\/\1>)/xim)
	93	# FIXME: scan over nested tags
	94	xml_scanner.tokenize match
	95	value_expected = false
	96	next
	97
	98	elsif match = scan(/ [-+*=<>?:;,!&^\|(\[{~%]+ \| \.(?!\d) /x)
	99	value_expected = true
	100	last_operator = match[-1]
	101	key_expected = (last_operator == ?{) \|\| (last_operator == ?,)
	102	function_expected = false
	103	kind = :operator
	104
	105	elsif scan(/ [)\]}]+ /x)
	106	function_expected = key_expected = value_expected = false
	107	kind = :operator
	108
	109	elsif match = scan(/ [$a-zA-Z_][A-Za-z_0-9$]* /x)
	110	kind = IDENT_KIND[match]
	111	value_expected = (kind == :keyword) && KEYWORDS_EXPECTING_VALUE[match]
	112	# TODO: labels
	113	if kind == :ident
	114	if match.index(?$) # $ allowed inside an identifier
	115	kind = :predefined
	116	elsif function_expected
	117	kind = :function
	118	elsif check(/\s[=:]\sfunction\b/)
	119	kind = :function
	120	elsif key_expected && check(/\s*:/)
	121	kind = :key
	122	end
	123	end
	124	function_expected = (kind == :keyword) && (match == 'function')
	125	key_expected = false
	126
	127	elsif match = scan(/["']/)
	128	if key_expected && check(KEY_CHECK_PATTERN[match])
	129	state = :key
	130	else
	131	state = :string
	132	end
	133	tokens << [:open, state]
	134	string_delimiter = match
	135	kind = :delimiter
	136
	137	elsif value_expected && (match = scan(/\/(?=\S)/))
	138	tokens << [:open, :regexp]
	139	state = :regexp
	140	string_delimiter = '/'
	141	kind = :delimiter
	142
	143	elsif scan(/ \/ /x)
	144	value_expected = true
	145	key_expected = false
	146	kind = :operator
	147
	148	else
	149	getch
	150	kind = :error
	151
	152	end
	153
	154	when :string, :regexp, :key
	155	if scan(STRING_CONTENT_PATTERN[string_delimiter])
	156	kind = :content
	157	elsif match = scan(/["'\/]/)
	158	tokens << [match, :delimiter]
	159	if state == :regexp
	160	modifiers = scan(/[gim]+/)
	161	tokens << [modifiers, :modifier] if modifiers && !modifiers.empty?
	162	end
	163	tokens << [:close, state]
	164	string_delimiter = nil
	165	key_expected = value_expected = false
	166	state = :initial
	167	next
	168	elsif state != :regexp && (match = scan(/ \\ (?: #{ESCAPE} \| #{UNICODE_ESCAPE} ) /mox))
	169	if string_delimiter == "'" && !(match == "\\\\" \|\| match == "\\'")
	170	kind = :content
	171	else
	172	kind = :char
	173	end
	174	elsif state == :regexp && scan(/ \\ (?: #{ESCAPE} \| #{REGEXP_ESCAPE} \| #{UNICODE_ESCAPE} ) /mox)
	175	kind = :char
	176	elsif scan(/\\./m)
	177	kind = :content
	178	elsif scan(/ \\ \| $ /x)
	179	tokens << [:close, state]
	180	kind = :error
	181	key_expected = value_expected = false
	182	state = :initial
	183	else
	184	raise_inspect "else case \" reached; %p not handled." % peek(1), tokens
	185	end
	186
	187	else
	188	raise_inspect 'Unknown state', tokens
	189
	190	end
	191
	192	match \|\|= matched
	193	if $CODERAY_DEBUG and not kind
	194	raise_inspect 'Error token %p in line %d' %
	195	[[match, kind], line], tokens
	196	end
	197	raise_inspect 'Empty token', tokens unless match
	198
	199	tokens << [match, kind]
	200
	201	end
	202
	203	if [:string, :regexp].include? state
	204	tokens << [:close, state]
	205	end
	206
	207	tokens
	208	end
	209
	210	protected
	211
	212	def reset_instance
	213	super
	214	@xml_scanner.reset if defined? @xml_scanner
	215	end
	216
	217	def xml_scanner
	218	@xml_scanner \|\|= CodeRay.scanner :xml, :tokens => @tokens, :keep_tokens => true, :keep_state => false
	219	end
	220
	221	end
	222
	223	end
	224	end

vendor/gems/coderay-0.9.7/test/functional/basic.rb created 644 +122 0

@@ -0,0 +1,122
	1	require 'test/unit'
	2	require 'coderay'
	3
	4	class BasicTest < Test::Unit::TestCase
	5
	6	def test_version
	7	assert_nothing_raised do
	8	assert_match(/\A\d\.\d\.\d\z/, CodeRay::VERSION)
	9	end
	10	end
	11
	12	RUBY_TEST_CODE = 'puts "Hello, World!"'
	13
	14	RUBY_TEST_TOKENS = [
	15	['puts', :ident],
	16	[' ', :space],
	17	[:open, :string],
	18	['"', :delimiter],
	19	['Hello, World!', :content],
	20	['"', :delimiter],
	21	[:close, :string]
	22	]
	23	def test_simple_scan
	24	assert_nothing_raised do
	25	assert_equal RUBY_TEST_TOKENS, CodeRay.scan(RUBY_TEST_CODE, :ruby).to_ary
	26	end
	27	end
	28
	29	RUBY_TEST_HTML = 'puts <span class="s"><span class="dl">"</span>' +
	30	'<span class="k">Hello, World!</span><span class="dl">"</span></span>'
	31	def test_simple_highlight
	32	assert_nothing_raised do
	33	assert_equal RUBY_TEST_HTML, CodeRay.scan(RUBY_TEST_CODE, :ruby).html
	34	end
	35	end
	36
	37	def test_duo
	38	assert_equal(RUBY_TEST_CODE,
	39	CodeRay::Duo[:plain, :plain].highlight(RUBY_TEST_CODE))
	40	assert_equal(RUBY_TEST_CODE,
	41	CodeRay::Duo[:plain => :plain].highlight(RUBY_TEST_CODE))
	42	end
	43
	44	def test_duo_stream
	45	assert_equal(RUBY_TEST_CODE,
	46	CodeRay::Duo[:plain, :plain].highlight(RUBY_TEST_CODE, :stream => true))
	47	end
	48
	49	def test_comment_filter
	50	assert_equal <<-EXPECTED, CodeRay.scan(<<-INPUT, :ruby).comment_filter.text
	51	#!/usr/bin/env ruby
	52
	53	code
	54
	55	more code
	56	EXPECTED
	57	#!/usr/bin/env ruby
	58	=begin
	59	A multi-line comment.
	60	=end
	61	code
	62	# A single-line comment.
	63	more code # and another comment, in-line.
	64	INPUT
	65	end
	66
	67	def test_lines_of_code
	68	assert_equal 2, CodeRay.scan(<<-INPUT, :ruby).lines_of_code
	69	#!/usr/bin/env ruby
	70	=begin
	71	A multi-line comment.
	72	=end
	73	code
	74	# A single-line comment.
	75	more code # and another comment, in-line.
	76	INPUT
	77	rHTML = <<-RHTML
	78	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
	79	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
	80
	81	<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
	82	<head>
	83	<meta http-equiv="content-type" content="text/html;charset=UTF-8" />
	84	<title><%= controller.controller_name.titleize %>: <%= controller.action_name %></title>
	85	<%= stylesheet_link_tag 'scaffold' %>
	86	</head>
	87	<body>
	88
	89	<p style="color: green"><%= flash[:notice] %></p>
	90
	91	<div id="main">
	92	<%= yield %>
	93	</div>
	94
	95	</body>
	96	</html>
	97	RHTML
	98	assert_equal 0, CodeRay.scan(rHTML, :html).lines_of_code
	99	assert_equal 0, CodeRay.scan(rHTML, :php).lines_of_code
	100	assert_equal 0, CodeRay.scan(rHTML, :yaml).lines_of_code
	101	assert_equal 4, CodeRay.scan(rHTML, :rhtml).lines_of_code
	102	end
	103
	104	def test_rubygems_not_loaded
	105	assert_equal nil, defined? Gem
	106	end if ENV['check_rubygems'] && RUBY_VERSION < '1.9'
	107
	108	def test_list_of_encoders
	109	assert_kind_of(Array, CodeRay::Encoders.list)
	110	assert CodeRay::Encoders.list.include?('count')
	111	end
	112
	113	def test_list_of_scanners
	114	assert_kind_of(Array, CodeRay::Scanners.list)
	115	assert CodeRay::Scanners.list.include?('plaintext')
	116	end
	117
	118	def test_scan_a_frozen_string
	119	CodeRay.scan RUBY_VERSION, :ruby
	120	end
	121
	122	end

vendor/gems/coderay-0.9.7/test/functional/basic.rbc created 644 +2022 0

This diff has been collapsed as it changes many lines, (2022 lines changed) Show them Hide them
	@@ -0,0 +1,2022
		1	!RBIX
		2	0
		3	x
		4	M
		5	1
		6	n
		7	n
		8	x
		9	10
		10	__script__
		11	i
		12	53
		13	5
		14	7
		15	0
		16	64
		17	47
		18	49
		19	1
		20	1
		21	15
		22	5
		23	7
		24	2
		25	64
		26	47
		27	49
		28	1
		29	1
		30	15
		31	99
		32	7
		33	3
		34	45
		35	4
		36	5
		37	43
		38	6
		39	43
		40	7
		41	65
		42	49
		43	8
		44	3
		45	13
		46	99
		47	12
		48	7
		49	9
		50	12
		51	7
		52	10
		53	12
		54	65
		55	12
		56	49
		57	11
		58	4
		59	15
		60	49
		61	9
		62	0
		63	15
		64	2
		65	11
		66	I
		67	6
		68	I
		69	0
		70	I
		71	0
		72	I
		73	0
		74	n
		75	p
		76	12
		77	s
		78	9
		79	test/unit
		80	x
		81	7
		82	require
		83	s
		84	7
		85	coderay
		86	x
		87	9
		88	BasicTest
		89	x
		90	4
		91	Test
		92	n
		93	x
		94	4
		95	Unit
		96	x
		97	8
		98	TestCase
		99	x
		100	10
		101	open_class
		102	x
		103	14
		104	__class_init__
		105	M
		106	1
		107	n
		108	n
		109	x
		110	9
		111	BasicTest
		112	i
		113	263
		114	5
		115	66
		116	99
		117	7
		118	0
		119	7
		120	1
		121	65
		122	67
		123	49
		124	2
		125	0
		126	49
		127	3
		128	4
		129	15
		130	65
		131	7
		132	4
		133	7
		134	5
		135	64
		136	49
		137	6
		138	2
		139	15
		140	65
		141	7
		142	7
		143	7
		144	8
		145	64
		146	7
		147	9
		148	35
		149	2
		150	7
		151	10
		152	64
		153	7
		154	11
		155	35
		156	2
		157	7
		158	12
		159	7
		160	13
		161	35
		162	2
		163	7
		164	14
		165	64
		166	7
		167	15
		168	35
		169	2
		170	7
		171	16
		172	64
		173	7
		174	17
		175	35
		176	2
		177	7
		178	14
		179	64
		180	7
		181	15
		182	35
		183	2
		184	7
		185	18
		186	7
		187	13
		188	35
		189	2
		190	35
		191	7
		192	49
		193	6
		194	2
		195	15
		196	99
		197	7
		198	19
		199	7
		200	20
		201	65
		202	67
		203	49
		204	2
		205	0
		206	49
		207	3
		208	4
		209	15
		210	65
		211	7
		212	21
		213	7
		214	22
		215	64
		216	7
		217	23
		218	64
		219	81
		220	24
		221	49
		222	6
		223	2
		224	15
		225	99
		226	7
		227	25
		228	7
		229	26
		230	65
		231	67
		232	49
		233	2
		234	0
		235	49
		236	3
		237	4
		238	15
		239	99
		240	7
		241	27
		242	7
		243	28
		244	65
		245	67
		246	49
		247	2
		248	0
		249	49
		250	3
		251	4
		252	15
		253	99
		254	7
		255	29
		256	7
		257	30
		258	65
		259	67
		260	49
		261	2
		262	0
		263	49
		264	3
		265	4
		266	15
		267	99
		268	7
		269	31
		270	7
		271	32
		272	65
		273	67
		274	49
		275	2
		276	0
		277	49
		278	3
		279	4
		280	15
		281	99
		282	7
		283	33
		284	7
		285	34
		286	65
		287	67
		288	49
		289	2
		290	0
		291	49
		292	3
		293	4
		294	15
		295	45
		296	35
		297	36
		298	7
		299	37
		300	64
		301	49
		302	38
		303	1
		304	13
		305	9
		306	202
		307	15
		308	45
		309	39
		310	40
		311	7
		312	41
		313	64
		314	84
		315	42
		316	9
		317	219
		318	99
		319	7
		320	43
		321	7
		322	44
		323	65
		324	67
		325	49
		326	2
		327	0
		328	49
		329	3
		330	4
		331	8
		332	220
		333	1
		334	15
		335	99
		336	7
		337	45
		338	7
		339	46
		340	65
		341	67
		342	49
		343	2
		344	0
		345	49
		346	3
		347	4
		348	15
		349	99
		350	7
		351	47
		352	7
		353	48
		354	65
		355	67
		356	49
		357	2
		358	0
		359	49
		360	3
		361	4
		362	15
		363	99
		364	7
		365	49
		366	7
		367	50
		368	65
		369	67
		370	49
		371	2
		372	0
		373	49
		374	3
		375	4
		376	11
		377	I
		378	a
		379	I
		380	0
		381	I
		382	0
		383	I
		384	0
		385	n
		386	p
		387	51
		388	x
		389	12
		390	test_version
		391	M
		392	1
		393	n
		394	n
		395	x
		396	12
		397	test_version
		398	i
		399	8
		400	5
		401	56
		402	0
		403	47
		404	50
		405	1
		406	0
		407	11
		408	I
		409	2
		410	I
		411	0
		412	I
		413	0
		414	I
		415	0
		416	n
		417	p
		418	2
		419	M
		420	1
		421	p
		422	2
		423	x
		424	9
		425	for_block
		426	t
		427	n
		428	x
		429	12
		430	test_version
		431	i
		432	29
		433	5
		434	7
		435	0
		436	13
		437	70
		438	9
		439	19
		440	15
		441	44
		442	43
		443	1
		444	7
		445	2
		446	78
		447	49
		448	3
		449	2
		450	6
		451	0
		452	45
		453	4
		454	5
		455	43
		456	6
		457	47
		458	49
		459	7
		460	2
		461	11
		462	I
		463	5
		464	I
		465	0
		466	I
		467	0
		468	I
		469	0
		470	I
		471	-2
		472	p
		473	8
		474	n
		475	x
		476	6
		477	Regexp
		478	s
		479	14
		480	\A\d\.\d\.\d\z
		481	x
		482	3
		483	new
		484	x
		485	7
		486	CodeRay
		487	n
		488	x
		489	7
		490	VERSION
		491	x
		492	12
		493	assert_match
		494	p
		495	5
		496	I
		497	0
		498	I
		499	7
		500	I
		501	0
		502	I
		503	8
		504	I
		505	1d
		506	x
		507	55
		508	/Users/murphy/ruby/coderay-0.9/test/functional/basic.rb
		509	p
		510	0
		511	x
		512	21
		513	assert_nothing_raised
		514	p
		515	5
		516	I
		517	0
		518	I
		519	6
		520	I
		521	0
		522	I
		523	7
		524	I
		525	8
		526	x
		527	55
		528	/Users/murphy/ruby/coderay-0.9/test/functional/basic.rb
		529	p
		530	0
		531	x
		532	17
		533	method_visibility
		534	x
		535	15
		536	add_defn_method
		537	x
		538	14
		539	RUBY_TEST_CODE
		540	s
		541	20
		542	puts "Hello, World!"
		543	x
		544	9
		545	const_set
		546	x
		547	16
		548	RUBY_TEST_TOKENS
		549	s
		550	4
		551	puts
		552	x
		553	5
		554	ident
		555	s
		556	1
		557
		558	x
		559	5
		560	space
		561	x
		562	4
		563	open
		564	x
		565	6
		566	string
		567	s
		568	1
		569	"
		570	x
		571	9
		572	delimiter
		573	s
		574	13
		575	Hello, World!
		576	x
		577	7
		578	content
		579	x
		580	5
		581	close
		582	x
		583	16
		584	test_simple_scan
		585	M
		586	1
		587	n
		588	n
		589	x
		590	16
		591	test_simple_scan
		592	i
		593	8
		594	5
		595	56
		596	0
		597	47
		598	50
		599	1
		600	0
		601	11
		602	I
		603	2
		604	I
		605	0
		606	I
		607	0
		608	I
		609	0
		610	n
		611	p
		612	2
		613	M
		614	1
		615	p
		616	2
		617	x
		618	9
		619	for_block
		620	t
		621	n
		622	x
		623	16
		624	test_simple_scan
		625	i
		626	23
		627	5
		628	45
		629	0
		630	1
		631	45
		632	2
		633	3
		634	45
		635	4
		636	5
		637	7
		638	6
		639	49
		640	7
		641	2
		642	49
		643	8
		644	0
		645	47
		646	49
		647	9
		648	2
		649	11
		650	I
		651	6
		652	I
		653	0
		654	I
		655	0
		656	I
		657	0
		658	I
		659	-2
		660	p
		661	10
		662	x
		663	16
		664	RUBY_TEST_TOKENS
		665	n
		666	x
		667	7
		668	CodeRay
		669	n
		670	x
		671	14
		672	RUBY_TEST_CODE
		673	n
		674	x
		675	4
		676	ruby
		677	x
		678	4
		679	scan
		680	x
		681	6
		682	to_ary
		683	x
		684	12
		685	assert_equal
		686	p
		687	5
		688	I
		689	0
		690	I
		691	18
		692	I
		693	0
		694	I
		695	19
		696	I
		697	17
		698	x
		699	55
		700	/Users/murphy/ruby/coderay-0.9/test/functional/basic.rb
		701	p
		702	0
		703	x
		704	21
		705	assert_nothing_raised
		706	p
		707	5
		708	I
		709	0
		710	I
		711	17
		712	I
		713	0
		714	I
		715	18
		716	I
		717	8
		718	x
		719	55
		720	/Users/murphy/ruby/coderay-0.9/test/functional/basic.rb
		721	p
		722	0
		723	x
		724	14
		725	RUBY_TEST_HTML
		726	s
		727	51
		728	puts <span class="s"><span class="dl">"</span>
		729	s
		730	73
		731	<span class="k">Hello, World!</span><span class="dl">"</span></span>
		732	x
		733	1
		734	+
		735	x
		736	21
		737	test_simple_highlight
		738	M
		739	1
		740	n
		741	n
		742	x
		743	21
		744	test_simple_highlight
		745	i
		746	8
		747	5
		748	56
		749	0
		750	47
		751	50
		752	1
		753	0
		754	11
		755	I
		756	2
		757	I
		758	0
		759	I
		760	0
		761	I
		762	0
		763	n
		764	p
		765	2
		766	M
		767	1
		768	p
		769	2
		770	x
		771	9
		772	for_block
		773	t
		774	n
		775	x
		776	21
		777	test_simple_highlight
		778	i
		779	23
		780	5
		781	45
		782	0
		783	1
		784	45
		785	2
		786	3
		787	45
		788	4
		789	5
		790	7
		791	6
		792	49
		793	7
		794	2
		795	49
		796	8
		797	0
		798	47
		799	49
		800	9
		801	2
		802	11
		803	I
		804	6
		805	I
		806	0
		807	I
		808	0
		809	I
		810	0
		811	I
		812	-2
		813	p
		814	10
		815	x
		816	14
		817	RUBY_TEST_HTML
		818	n
		819	x
		820	7
		821	CodeRay
		822	n
		823	x
		824	14
		825	RUBY_TEST_CODE
		826	n
		827	x
		828	4
		829	ruby
		830	x
		831	4
		832	scan
		833	x
		834	4
		835	html
		836	x
		837	12
		838	assert_equal
		839	p
		840	5
		841	I
		842	0
		843	I
		844	20
		845	I
		846	0
		847	I
		848	21
		849	I
		850	17
		851	x
		852	55
		853	/Users/murphy/ruby/coderay-0.9/test/functional/basic.rb
		854	p
		855	0
		856	x
		857	21
		858	assert_nothing_raised
		859	p
		860	5
		861	I
		862	0
		863	I
		864	1f
		865	I
		866	0
		867	I
		868	20
		869	I
		870	8
		871	x
		872	55
		873	/Users/murphy/ruby/coderay-0.9/test/functional/basic.rb
		874	p
		875	0
		876	x
		877	8
		878	test_duo
		879	M
		880	1
		881	n
		882	n
		883	x
		884	8
		885	test_duo
		886	i
		887	66
		888	5
		889	45
		890	0
		891	1
		892	45
		893	2
		894	3
		895	43
		896	4
		897	7
		898	5
		899	7
		900	5
		901	49
		902	6
		903	2
		904	45
		905	0
		906	7
		907	49
		908	8
		909	1
		910	47
		911	49
		912	9
		913	2
		914	15
		915	5
		916	45
		917	0
		918	10
		919	45
		920	2
		921	11
		922	43
		923	4
		924	44
		925	43
		926	12
		927	79
		928	49
		929	13
		930	1
		931	13
		932	7
		933	5
		934	7
		935	5
		936	49
		937	14
		938	2
		939	15
		940	49
		941	6
		942	1
		943	45
		944	0
		945	15
		946	49
		947	8
		948	1
		949	47
		950	49
		951	9
		952	2
		953	11
		954	I
		955	7
		956	I
		957	0
		958	I
		959	0
		960	I
		961	0
		962	n
		963	p
		964	16
		965	x
		966	14
		967	RUBY_TEST_CODE
		968	n
		969	x
		970	7
		971	CodeRay
		972	n
		973	x
		974	3
		975	Duo
		976	x
		977	5
		978	plain
		979	x
		980	2
		981	[]
		982	n
		983	x
		984	9
		985	highlight
		986	x
		987	12
		988	assert_equal
		989	n
		990	n
		991	x
		992	4
		993	Hash
		994	x
		995	16
		996	new_from_literal
		997	x
		998	3
		999	[]=
		1000	n
		1001	p
		1002	15
		1003	I
		1004	0
		1005	I
		1006	25
		1007	I
		1008	0
		1009	I
		1010	26
		1011	I
		1012	4
		1013	I
		1014	27
		1015	I
		1016	16
		1017	I
		1018	26
		1019	I
		1020	1b
		1021	I
		1022	28
		1023	I
		1024	1f
		1025	I
		1026	29
		1027	I
		1028	3d
		1029	I
		1030	28
		1031	I
		1032	42
		1033	x
		1034	55
		1035	/Users/murphy/ruby/coderay-0.9/test/functional/basic.rb
		1036	p
		1037	0
		1038	x
		1039	15
		1040	test_duo_stream
		1041	M
		1042	1
		1043	n
		1044	n
		1045	x
		1046	15
		1047	test_duo_stream
		1048	i
		1049	42
		1050	5
		1051	45
		1052	0
		1053	1
		1054	45
		1055	2
		1056	3
		1057	43
		1058	4
		1059	7
		1060	5
		1061	7
		1062	5
		1063	49
		1064	6
		1065	2
		1066	45
		1067	0
		1068	7
		1069	44
		1070	43
		1071	8
		1072	79
		1073	49
		1074	9
		1075	1
		1076	13
		1077	7
		1078	10
		1079	2
		1080	49
		1081	11
		1082	2
		1083	15
		1084	49
		1085	12
		1086	2
		1087	47
		1088	49
		1089	13
		1090	2
		1091	11
		1092	I
		1093	8
		1094	I
		1095	0
		1096	I
		1097	0
		1098	I
		1099	0
		1100	n
		1101	p
		1102	14
		1103	x
		1104	14
		1105	RUBY_TEST_CODE
		1106	n
		1107	x
		1108	7
		1109	CodeRay
		1110	n
		1111	x
		1112	3
		1113	Duo
		1114	x
		1115	5
		1116	plain
		1117	x
		1118	2
		1119	[]
		1120	n
		1121	x
		1122	4
		1123	Hash
		1124	x
		1125	16
		1126	new_from_literal
		1127	x
		1128	6
		1129	stream
		1130	x
		1131	3
		1132	[]=
		1133	x
		1134	9
		1135	highlight
		1136	x
		1137	12
		1138	assert_equal
		1139	p
		1140	9
		1141	I
		1142	0
		1143	I
		1144	2c
		1145	I
		1146	0
		1147	I
		1148	2d
		1149	I
		1150	4
		1151	I
		1152	2e
		1153	I
		1154	25
		1155	I
		1156	2d
		1157	I
		1158	2a
		1159	x
		1160	55
		1161	/Users/murphy/ruby/coderay-0.9/test/functional/basic.rb
		1162	p
		1163	0
		1164	x
		1165	19
		1166	test_comment_filter
		1167	M
		1168	1
		1169	n
		1170	n
		1171	x
		1172	19
		1173	test_comment_filter
		1174	i
		1175	26
		1176	5
		1177	7
		1178	0
		1179	64
		1180	45
		1181	1
		1182	2
		1183	7
		1184	3
		1185	64
		1186	7
		1187	4
		1188	49
		1189	5
		1190	2
		1191	49
		1192	6
		1193	0
		1194	49
		1195	7
		1196	0
		1197	47
		1198	49
		1199	8
		1200	2
		1201	11
		1202	I
		1203	5
		1204	I
		1205	0
		1206	I
		1207	0
		1208	I
		1209	0
		1210	n
		1211	p
		1212	9
		1213	s
		1214	39
		1215	#!/usr/bin/env ruby
		1216
		1217	code
		1218
		1219	more code
		1220
		1221	x
		1222	7
		1223	CodeRay
		1224	n
		1225	s
		1226	127
		1227	#!/usr/bin/env ruby
		1228	=begin
		1229	A multi-line comment.
		1230	=end
		1231	code
		1232	# A single-line comment.
		1233	more code # and another comment, in-line.
		1234
		1235	x
		1236	4
		1237	ruby
		1238	x
		1239	4
		1240	scan
		1241	x
		1242	14
		1243	comment_filter
		1244	x
		1245	4
		1246	text
		1247	x
		1248	12
		1249	assert_equal
		1250	p
		1251	5
		1252	I
		1253	0
		1254	I
		1255	31
		1256	I
		1257	0
		1258	I
		1259	32
		1260	I
		1261	1a
		1262	x
		1263	55
		1264	/Users/murphy/ruby/coderay-0.9/test/functional/basic.rb
		1265	p
		1266	0
		1267	x
		1268	18
		1269	test_lines_of_code
		1270	M
		1271	1
		1272	n
		1273	n
		1274	x
		1275	18
		1276	test_lines_of_code
		1277	i
		1278	108
		1279	5
		1280	80
		1281	45
		1282	0
		1283	1
		1284	7
		1285	2
		1286	64
		1287	7
		1288	3
		1289	49
		1290	4
		1291	2
		1292	49
		1293	5
		1294	0
		1295	47
		1296	49
		1297	6
		1298	2
		1299	15
		1300	7
		1301	7
		1302	64
		1303	19
		1304	0
		1305	15
		1306	5
		1307	78
		1308	45
		1309	0
		1310	8
		1311	20
		1312	0
		1313	7
		1314	9
		1315	49
		1316	4
		1317	2
		1318	49
		1319	5
		1320	0
		1321	47
		1322	49
		1323	6
		1324	2
		1325	15
		1326	5
		1327	78
		1328	45
		1329	0
		1330	10
		1331	20
		1332	0
		1333	7
		1334	11
		1335	49
		1336	4
		1337	2
		1338	49
		1339	5
		1340	0
		1341	47
		1342	49
		1343	6
		1344	2
		1345	15
		1346	5
		1347	78
		1348	45
		1349	0
		1350	12
		1351	20
		1352	0
		1353	7
		1354	13
		1355	49
		1356	4
		1357	2
		1358	49
		1359	5
		1360	0
		1361	47
		1362	49
		1363	6
		1364	2
		1365	15
		1366	5
		1367	4
		1368	4
		1369	45
		1370	0
		1371	14
		1372	20
		1373	0
		1374	7
		1375	15
		1376	49
		1377	4
		1378	2
		1379	49
		1380	5
		1381	0
		1382	47
		1383	49
		1384	6
		1385	2
		1386	11
		1387	I
		1388	6
		1389	I
		1390	1
		1391	I
		1392	0
		1393	I
		1394	0
		1395	n
		1396	p
		1397	16
		1398	x
		1399	7
		1400	CodeRay
		1401	n
		1402	s
		1403	127
		1404	#!/usr/bin/env ruby
		1405	=begin
		1406	A multi-line comment.
		1407	=end
		1408	code
		1409	# A single-line comment.
		1410	more code # and another comment, in-line.
		1411
		1412	x
		1413	4
		1414	ruby
		1415	x
		1416	4
		1417	scan
		1418	x
		1419	13
		1420	lines_of_code
		1421	x
		1422	12
		1423	assert_equal
		1424	s
		1425	514
		1426	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
		1427	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
		1428
		1429	<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
		1430	<head>
		1431	<meta http-equiv="content-type" content="text/html;charset=UTF-8" />
		1432	<title><%= controller.controller_name.titleize %>: <%= controller.action_name %></title>
		1433	<%= stylesheet_link_tag 'scaffold' %>
		1434	</head>
		1435	<body>
		1436
		1437	<p style="color: green"><%= flash[:notice] %></p>
		1438
		1439	<div id="main">
		1440	<%= yield %>
		1441	</div>
		1442
		1443	</body>
		1444	</html>
		1445
		1446	n
		1447	x
		1448	4
		1449	html
		1450	n
		1451	x
		1452	3
		1453	php
		1454	n
		1455	x
		1456	4
		1457	yaml
		1458	n
		1459	x
		1460	5
		1461	rhtml
		1462	p
		1463	15
		1464	I
		1465	0
		1466	I
		1467	43
		1468	I
		1469	0
		1470	I
		1471	44
		1472	I
		1473	15
		1474	I
		1475	4d
		1476	I
		1477	1b
		1478	I
		1479	62
		1480	I
		1481	2f
		1482	I
		1483	63
		1484	I
		1485	43
		1486	I
		1487	64
		1488	I
		1489	57
		1490	I
		1491	65
		1492	I
		1493	6c
		1494	x
		1495	55
		1496	/Users/murphy/ruby/coderay-0.9/test/functional/basic.rb
		1497	p
		1498	1
		1499	x
		1500	5
		1501	rHTML
		1502	x
		1503	3
		1504	ENV
		1505	n
		1506	s
		1507	14
		1508	check_rubygems
		1509	x
		1510	2
		1511	[]
		1512	x
		1513	12
		1514	RUBY_VERSION
		1515	n
		1516	s
		1517	3
		1518	1.9
		1519	x
		1520	1
		1521	<
		1522	x
		1523	24
		1524	test_rubygems_not_loaded
		1525	M
		1526	1
		1527	n
		1528	n
		1529	x
		1530	24
		1531	test_rubygems_not_loaded
		1532	i
		1533	34
		1534	5
		1535	1
		1536	26
		1537	93
		1538	0
		1539	15
		1540	29
		1541	17
		1542	0
		1543	7
		1544	0
		1545	98
		1546	1
		1547	1
		1548	30
		1549	8
		1550	23
		1551	25
		1552	92
		1553	0
		1554	27
		1555	8
		1556	28
		1557	15
		1558	7
		1559	2
		1560	8
		1561	29
		1562	1
		1563	47
		1564	49
		1565	3
		1566	2
		1567	11
		1568	I
		1569	4
		1570	I
		1571	0
		1572	I
		1573	0
		1574	I
		1575	0
		1576	n
		1577	p
		1578	4
		1579	x
		1580	3
		1581	Gem
		1582	x
		1583	16
		1584	vm_const_defined
		1585	s
		1586	8
		1587	constant
		1588	x
		1589	12
		1590	assert_equal
		1591	p
		1592	5
		1593	I
		1594	0
		1595	I
		1596	68
		1597	I
		1598	0
		1599	I
		1600	69
		1601	I
		1602	22
		1603	x
		1604	55
		1605	/Users/murphy/ruby/coderay-0.9/test/functional/basic.rb
		1606	p
		1607	0
		1608	x
		1609	21
		1610	test_list_of_encoders
		1611	M
		1612	1
		1613	n
		1614	n
		1615	x
		1616	21
		1617	test_list_of_encoders
		1618	i
		1619	37
		1620	5
		1621	45
		1622	0
		1623	1
		1624	45
		1625	2
		1626	3
		1627	43
		1628	4
		1629	49
		1630	5
		1631	0
		1632	47
		1633	49
		1634	6
		1635	2
		1636	15
		1637	5
		1638	45
		1639	2
		1640	7
		1641	43
		1642	4
		1643	49
		1644	5
		1645	0
		1646	7
		1647	8
		1648	64
		1649	49
		1650	9
		1651	1
		1652	47
		1653	49
		1654	10
		1655	1
		1656	11
		1657	I
		1658	3
		1659	I
		1660	0
		1661	I
		1662	0
		1663	I
		1664	0
		1665	n
		1666	p
		1667	11
		1668	x
		1669	5
		1670	Array
		1671	n
		1672	x
		1673	7
		1674	CodeRay
		1675	n
		1676	x
		1677	8
		1678	Encoders
		1679	x
		1680	4
		1681	list
		1682	x
		1683	14
		1684	assert_kind_of
		1685	n
		1686	s
		1687	5
		1688	count
		1689	x
		1690	8
		1691	include?
		1692	x
		1693	6
		1694	assert
		1695	p
		1696	7
		1697	I
		1698	0
		1699	I
		1700	6c
		1701	I
		1702	0
		1703	I
		1704	6d
		1705	I
		1706	11
		1707	I
		1708	6e
		1709	I
		1710	25
		1711	x
		1712	55
		1713	/Users/murphy/ruby/coderay-0.9/test/functional/basic.rb
		1714	p
		1715	0
		1716	x
		1717	21
		1718	test_list_of_scanners
		1719	M
		1720	1
		1721	n
		1722	n
		1723	x
		1724	21
		1725	test_list_of_scanners
		1726	i
		1727	37
		1728	5
		1729	45
		1730	0
		1731	1
		1732	45
		1733	2
		1734	3
		1735	43
		1736	4
		1737	49
		1738	5
		1739	0
		1740	47
		1741	49
		1742	6
		1743	2
		1744	15
		1745	5
		1746	45
		1747	2
		1748	7
		1749	43
		1750	4
		1751	49
		1752	5
		1753	0
		1754	7
		1755	8
		1756	64
		1757	49
		1758	9
		1759	1
		1760	47
		1761	49
		1762	10
		1763	1
		1764	11
		1765	I
		1766	3
		1767	I
		1768	0
		1769	I
		1770	0
		1771	I
		1772	0
		1773	n
		1774	p
		1775	11
		1776	x
		1777	5
		1778	Array
		1779	n
		1780	x
		1781	7
		1782	CodeRay
		1783	n
		1784	x
		1785	8
		1786	Scanners
		1787	x
		1788	4
		1789	list
		1790	x
		1791	14
		1792	assert_kind_of
		1793	n
		1794	s
		1795	9
		1796	plaintext
		1797	x
		1798	8
		1799	include?
		1800	x
		1801	6
		1802	assert
		1803	p
		1804	7
		1805	I
		1806	0
		1807	I
		1808	71
		1809	I
		1810	0
		1811	I
		1812	72
		1813	I
		1814	11
		1815	I
		1816	73
		1817	I
		1818	25
		1819	x
		1820	55
		1821	/Users/murphy/ruby/coderay-0.9/test/functional/basic.rb
		1822	p
		1823	0
		1824	x
		1825	25
		1826	test_scan_a_frozen_string
		1827	M
		1828	1
		1829	n
		1830	n
		1831	x
		1832	25
		1833	test_scan_a_frozen_string
		1834	i
		1835	12
		1836	45
		1837	0
		1838	1
		1839	45
		1840	2
		1841	3
		1842	7
		1843	4
		1844	49
		1845	5
		1846	2
		1847	11
		1848	I
		1849	3
		1850	I
		1851	0
		1852	I
		1853	0
		1854	I
		1855	0
		1856	n
		1857	p
		1858	6
		1859	x
		1860	7
		1861	CodeRay
		1862	n
		1863	x
		1864	12
		1865	RUBY_VERSION
		1866	n
		1867	x
		1868	4
		1869	ruby
		1870	x
		1871	4
		1872	scan
		1873	p
		1874	5
		1875	I
		1876	0
		1877	I
		1878	76
		1879	I
		1880	0
		1881	I
		1882	77
		1883	I
		1884	c
		1885	x
		1886	55
		1887	/Users/murphy/ruby/coderay-0.9/test/functional/basic.rb
		1888	p
		1889	0
		1890	p
		1891	51
		1892	I
		1893	2
		1894	I
		1895	6
		1896	I
		1897	10
		1898	I
		1899	c
		1900	I
		1901	1a
		1902	I
		1903	e
		1904	I
		1905	1d
		1906	I
		1907	f
		1908	I
		1909	24
		1910	I
		1911	10
		1912	I
		1913	2b
		1914	I
		1915	11
		1916	I
		1917	31
		1918	I
		1919	12
		1920	I
		1921	38
		1922	I
		1923	13
		1924	I
		1925	3f
		1926	I
		1927	14
		1928	I
		1929	46
		1930	I
		1931	15
		1932	I
		1933	52
		1934	I
		1935	17
		1936	I
		1937	60
		1938	I
		1939	1d
		1940	I
		1941	63
		1942	I
		1943	1d
		1944	I
		1945	66
		1946	I
		1947	1e
		1948	I
		1949	6f
		1950	I
		1951	1f
		1952	I
		1953	7d
		1954	I
		1955	25
		1956	I
		1957	8b
		1958	I
		1959	2c
		1960	I
		1961	99
		1962	I
		1963	31
		1964	I
		1965	a7
		1966	I
		1967	43
		1968	I
		1969	b5
		1970	I
		1971	6a
		1972	I
		1973	cc
		1974	I
		1975	68
		1976	I
		1977	db
		1978	I
		1979	6a
		1980	I
		1981	dd
		1982	I
		1983	6c
		1984	I
		1985	eb
		1986	I
		1987	71
		1988	I
		1989	f9
		1990	I
		1991	76
		1992	I
		1993	107
		1994	x
		1995	55
		1996	/Users/murphy/ruby/coderay-0.9/test/functional/basic.rb
		1997	p
		1998	0
		1999	x
		2000	13
		2001	attach_method
		2002	p
		2003	7
		2004	I
		2005	0
		2006	I
		2007	1
		2008	I
		2009	9
		2010	I
		2011	2
		2012	I
		2013	12
		2014	I
		2015	4
		2016	I
		2017	35
		2018	x
		2019	55
		2020	/Users/murphy/ruby/coderay-0.9/test/functional/basic.rb
		2021	p
		2022	0

vendor/gems/coderay-0.9.7/test/functional/for_redcloth.rb created 644 +77 0

@@ -0,0 +1,77
	1	require 'test/unit'
	2	$:.unshift 'lib'
	3	require 'coderay'
	4
	5	begin
	6	require 'rubygems' unless defined? Gem
	7	gem 'RedCloth', '>= 4.0.3' rescue nil
	8	require 'redcloth'
	9	rescue LoadError
	10	warn 'RedCloth not found - skipping for_redcloth tests.'
	11	end
	12
	13	class BasicTest < Test::Unit::TestCase
	14
	15	def test_for_redcloth
	16	require 'coderay/for_redcloth'
	17	assert_equal "<p><span lang=\"ruby\" class=\"CodeRay\">puts <span style=\"background-color:#fff0f0;color:#D20\"><span style=\"color:#710\">"</span><span style=\"\">Hello, World!</span><span style=\"color:#710\">"</span></span></span></p>",
	18	RedCloth.new('@[ruby]puts "Hello, World!"@').to_html
	19	assert_equal <<-BLOCKCODE.chomp,
	20	<div lang="ruby" class="CodeRay">
	21	<div class="code"><pre>puts <span style="background-color:#fff0f0;color:#D20"><span style="color:#710">"</span><span style="">Hello, World!</span><span style="color:#710">"</span></span></pre></div>
	22	</div>
	23	BLOCKCODE
	24	RedCloth.new('bc[ruby]. puts "Hello, World!"').to_html
	25	end
	26
	27	def test_for_redcloth_no_lang
	28	require 'coderay/for_redcloth'
	29	assert_equal "<p><code>puts \"Hello, World!\"</code></p>",
	30	RedCloth.new('@puts "Hello, World!"@').to_html
	31	assert_equal <<-BLOCKCODE.chomp,
	32	<pre><code>puts \"Hello, World!\"</code></pre>
	33	BLOCKCODE
	34	RedCloth.new('bc. puts "Hello, World!"').to_html
	35	end
	36
	37	def test_for_redcloth_style
	38	require 'coderay/for_redcloth'
	39	assert_equal <<-BLOCKCODE.chomp,
	40	<pre style=\"color: red;\"><code style=\"color: red;\">puts \"Hello, World!\"</code></pre>
	41	BLOCKCODE
	42	RedCloth.new('bc{color: red}. puts "Hello, World!"').to_html
	43	end
	44
	45	def test_for_redcloth_escapes
	46	require 'coderay/for_redcloth'
	47	assert_equal '<p><span lang="ruby" class="CodeRay">></span></p>',
	48	RedCloth.new('@[ruby]>@').to_html
	49	assert_equal <<-BLOCKCODE.chomp,
	50	<div lang="ruby" class="CodeRay">
	51	<div class="code"><pre>&</pre></div>
	52	</div>
	53	BLOCKCODE
	54	RedCloth.new('bc[ruby]. &').to_html
	55	end
	56
	57	def test_for_redcloth_escapes2
	58	require 'coderay/for_redcloth'
	59	assert_equal "<p><span lang=\"c\" class=\"CodeRay\"><span style=\"color:#579\">#include</span> <span style=\"color:#B44;font-weight:bold\"><test.h></span></span></p>",
	60	RedCloth.new('@[c]#include <test.h>@').to_html
	61	end
	62
	63	# See http://jgarber.lighthouseapp.com/projects/13054/tickets/124-code-markup-does-not-allow-brackets.
	64	def test_for_redcloth_false_positive
	65	require 'coderay/for_redcloth'
	66	assert_equal '<p><code>[project]_dff.skjd</code></p>',
	67	RedCloth.new('@[project]_dff.skjd@').to_html
	68	# false positive, but expected behavior / known issue
	69	assert_equal "<p><span lang=\"ruby\" class=\"CodeRay\">_dff.skjd</span></p>",
	70	RedCloth.new('@[ruby]_dff.skjd@').to_html
	71	assert_equal <<-BLOCKCODE.chomp,
	72	<pre><code>[project]_dff.skjd</code></pre>
	73	BLOCKCODE
	74	RedCloth.new('bc. [project]_dff.skjd').to_html
	75	end
	76
	77	end if defined? RedCloth No newline at end of file

vendor/gems/coderay-0.9.7/test/functional/for_redcloth.rbc created 644 +1708 0

This diff has been collapsed as it changes many lines, (1708 lines changed) Show them Hide them
	@@ -0,0 +1,1708
		1	!RBIX
		2	0
		3	x
		4	M
		5	1
		6	n
		7	n
		8	x
		9	10
		10	__script__
		11	i
		12	249
		13	5
		14	7
		15	0
		16	64
		17	47
		18	49
		19	1
		20	1
		21	15
		22	99
		23	43
		24	2
		25	7
		26	3
		27	49
		28	4
		29	1
		30	7
		31	5
		32	64
		33	49
		34	6
		35	1
		36	15
		37	5
		38	7
		39	7
		40	64
		41	47
		42	49
		43	1
		44	1
		45	15
		46	26
		47	93
		48	0
		49	15
		50	29
		51	144
		52	0
		53	26
		54	93
		55	1
		56	15
		57	29
		58	55
		59	0
		60	7
		61	8
		62	98
		63	9
		64	1
		65	30
		66	8
		67	61
		68	25
		69	92
		70	1
		71	27
		72	8
		73	66
		74	15
		75	7
		76	10
		77	8
		78	67
		79	1
		80	9
		81	72
		82	1
		83	8
		84	80
		85	5
		86	7
		87	11
		88	64
		89	47
		90	49
		91	1
		92	1
		93	15
		94	26
		95	93
		96	2
		97	15
		98	29
		99	102
		100	0
		101	5
		102	7
		103	12
		104	64
		105	7
		106	13
		107	64
		108	47
		109	49
		110	14
		111	2
		112	30
		113	8
		114	129
		115	26
		116	93
		117	3
		118	15
		119	24
		120	13
		121	45
		122	15
		123	16
		124	12
		125	49
		126	17
		127	1
		128	10
		129	119
		130	8
		131	124
		132	15
		133	1
		134	25
		135	8
		136	129
		137	15
		138	92
		139	3
		140	27
		141	34
		142	92
		143	2
		144	27
		145	15
		146	5
		147	7
		148	18
		149	64
		150	47
		151	49
		152	1
		153	1
		154	30
		155	8
		156	178
		157	26
		158	93
		159	4
		160	15
		161	24
		162	13
		163	45
		164	19
		165	20
		166	12
		167	49
		168	17
		169	1
		170	10
		171	161
		172	8
		173	173
		174	15
		175	5
		176	7
		177	21
		178	64
		179	47
		180	49
		181	22
		182	1
		183	25
		184	8
		185	178
		186	15
		187	92
		188	4
		189	27
		190	34
		191	92
		192	0
		193	27
		194	15
		195	26
		196	93
		197	5
		198	15
		199	29
		200	197
		201	0
		202	7
		203	23
		204	98
		205	9
		206	1
		207	30
		208	8
		209	203
		210	25
		211	92
		212	5
		213	27
		214	8
		215	208
		216	15
		217	7
		218	10
		219	8
		220	209
		221	1
		222	9
		223	245
		224	99
		225	7
		226	24
		227	45
		228	25
		229	26
		230	43
		231	27
		232	43
		233	28
		234	65
		235	49
		236	29
		237	3
		238	13
		239	99
		240	12
		241	7
		242	30
		243	12
		244	7
		245	31
		246	12
		247	65
		248	12
		249	49
		250	32
		251	4
		252	15
		253	49
		254	30
		255	0
		256	8
		257	246
		258	1
		259	15
		260	2
		261	11
		262	I
		263	c
		264	I
		265	0
		266	I
		267	0
		268	I
		269	0
		270	n
		271	p
		272	33
		273	s
		274	9
		275	test/unit
		276	x
		277	7
		278	require
		279	x
		280	7
		281	Globals
		282	x
		283	2
		284	$:
		285	x
		286	2
		287	[]
		288	s
		289	3
		290	lib
		291	x
		292	2
		293	<<
		294	s
		295	7
		296	coderay
		297	x
		298	3
		299	Gem
		300	x
		301	16
		302	vm_const_defined
		303	s
		304	8
		305	constant
		306	s
		307	8
		308	rubygems
		309	s
		310	8
		311	RedCloth
		312	s
		313	8
		314	>= 4.0.3
		315	x
		316	3
		317	gem
		318	x
		319	13
		320	StandardError
		321	n
		322	x
		323	3
		324	===
		325	s
		326	8
		327	redcloth
		328	x
		329	9
		330	LoadError
		331	n
		332	s
		333	49
		334	RedCloth not found - skipping for_redcloth tests.
		335	x
		336	4
		337	warn
		338	x
		339	8
		340	RedCloth
		341	x
		342	9
		343	BasicTest
		344	x
		345	4
		346	Test
		347	n
		348	x
		349	4
		350	Unit
		351	x
		352	8
		353	TestCase
		354	x
		355	10
		356	open_class
		357	x
		358	14
		359	__class_init__
		360	M
		361	1
		362	n
		363	n
		364	x
		365	9
		366	BasicTest
		367	i
		368	86
		369	5
		370	66
		371	99
		372	7
		373	0
		374	7
		375	1
		376	65
		377	67
		378	49
		379	2
		380	0
		381	49
		382	3
		383	4
		384	15
		385	99
		386	7
		387	4
		388	7
		389	5
		390	65
		391	67
		392	49
		393	2
		394	0
		395	49
		396	3
		397	4
		398	15
		399	99
		400	7
		401	6
		402	7
		403	7
		404	65
		405	67
		406	49
		407	2
		408	0
		409	49
		410	3
		411	4
		412	15
		413	99
		414	7
		415	8
		416	7
		417	9
		418	65
		419	67
		420	49
		421	2
		422	0
		423	49
		424	3
		425	4
		426	15
		427	99
		428	7
		429	10
		430	7
		431	11
		432	65
		433	67
		434	49
		435	2
		436	0
		437	49
		438	3
		439	4
		440	15
		441	99
		442	7
		443	12
		444	7
		445	13
		446	65
		447	67
		448	49
		449	2
		450	0
		451	49
		452	3
		453	4
		454	11
		455	I
		456	5
		457	I
		458	0
		459	I
		460	0
		461	I
		462	0
		463	n
		464	p
		465	14
		466	x
		467	17
		468	test_for_redcloth
		469	M
		470	1
		471	n
		472	n
		473	x
		474	17
		475	test_for_redcloth
		476	i
		477	96
		478	5
		479	7
		480	0
		481	64
		482	47
		483	49
		484	1
		485	1
		486	15
		487	5
		488	7
		489	2
		490	64
		491	45
		492	3
		493	4
		494	13
		495	71
		496	5
		497	47
		498	9
		499	37
		500	47
		501	49
		502	6
		503	0
		504	13
		505	7
		506	7
		507	64
		508	47
		509	49
		510	8
		511	1
		512	15
		513	8
		514	43
		515	7
		516	7
		517	64
		518	49
		519	5
		520	1
		521	49
		522	9
		523	0
		524	47
		525	49
		526	10
		527	2
		528	15
		529	5
		530	7
		531	11
		532	64
		533	49
		534	12
		535	0
		536	45
		537	3
		538	13
		539	13
		540	71
		541	5
		542	47
		543	9
		544	82
		545	47
		546	49
		547	6
		548	0
		549	13
		550	7
		551	14
		552	64
		553	47
		554	49
		555	8
		556	1
		557	15
		558	8
		559	88
		560	7
		561	14
		562	64
		563	49
		564	5
		565	1
		566	49
		567	9
		568	0
		569	47
		570	49
		571	10
		572	2
		573	11
		574	I
		575	5
		576	I
		577	0
		578	I
		579	0
		580	I
		581	0
		582	n
		583	p
		584	15
		585	s
		586	20
		587	coderay/for_redcloth
		588	x
		589	7
		590	require
		591	s
		592	221
		593	<p><span lang="ruby" class="CodeRay">puts <span style="background-color:#fff0f0;color:#D20"><span style="color:#710">"</span><span style="">Hello, World!</span><span style="color:#710">"</span></span></span></p>
		594	x
		595	8
		596	RedCloth
		597	n
		598	x
		599	3
		600	new
		601	x
		602	8
		603	allocate
		604	s
		605	28
		606	@[ruby]puts "Hello, World!"@
		607	x
		608	10
		609	initialize
		610	x
		611	7
		612	to_html
		613	x
		614	12
		615	assert_equal
		616	s
		617	252
		618	<div lang="ruby" class="CodeRay">
		619	<div class="code"><pre>puts <span style="background-color:#fff0f0;color:#D20"><span style="color:#710">"</span><span style="">Hello, World!</span><span style="color:#710">"</span></span></pre></div>
		620	</div>
		621
		622	x
		623	5
		624	chomp
		625	n
		626	s
		627	30
		628	bc[ruby]. puts "Hello, World!"
		629	p
		630	17
		631	I
		632	0
		633	I
		634	f
		635	I
		636	0
		637	I
		638	10
		639	I
		640	9
		641	I
		642	11
		643	I
		644	d
		645	I
		646	12
		647	I
		648	2e
		649	I
		650	11
		651	I
		652	33
		653	I
		654	13
		655	I
		656	3a
		657	I
		658	18
		659	I
		660	5b
		661	I
		662	13
		663	I
		664	60
		665	x
		666	62
		667	/Users/murphy/ruby/coderay-0.9/test/functional/for_redcloth.rb
		668	p
		669	0
		670	x
		671	17
		672	method_visibility
		673	x
		674	15
		675	add_defn_method
		676	x
		677	25
		678	test_for_redcloth_no_lang
		679	M
		680	1
		681	n
		682	n
		683	x
		684	25
		685	test_for_redcloth_no_lang
		686	i
		687	96
		688	5
		689	7
		690	0
		691	64
		692	47
		693	49
		694	1
		695	1
		696	15
		697	5
		698	7
		699	2
		700	64
		701	45
		702	3
		703	4
		704	13
		705	71
		706	5
		707	47
		708	9
		709	37
		710	47
		711	49
		712	6
		713	0
		714	13
		715	7
		716	7
		717	64
		718	47
		719	49
		720	8
		721	1
		722	15
		723	8
		724	43
		725	7
		726	7
		727	64
		728	49
		729	5
		730	1
		731	49
		732	9
		733	0
		734	47
		735	49
		736	10
		737	2
		738	15
		739	5
		740	7
		741	11
		742	64
		743	49
		744	12
		745	0
		746	45
		747	3
		748	13
		749	13
		750	71
		751	5
		752	47
		753	9
		754	82
		755	47
		756	49
		757	6
		758	0
		759	13
		760	7
		761	14
		762	64
		763	47
		764	49
		765	8
		766	1
		767	15
		768	8
		769	88
		770	7
		771	14
		772	64
		773	49
		774	5
		775	1
		776	49
		777	9
		778	0
		779	47
		780	49
		781	10
		782	2
		783	11
		784	I
		785	5
		786	I
		787	0
		788	I
		789	0
		790	I
		791	0
		792	n
		793	p
		794	15
		795	s
		796	20
		797	coderay/for_redcloth
		798	x
		799	7
		800	require
		801	s
		802	40
		803	<p><code>puts "Hello, World!"</code></p>
		804	x
		805	8
		806	RedCloth
		807	n
		808	x
		809	3
		810	new
		811	x
		812	8
		813	allocate
		814	s
		815	22
		816	@puts "Hello, World!"@
		817	x
		818	10
		819	initialize
		820	x
		821	7
		822	to_html
		823	x
		824	12
		825	assert_equal
		826	s
		827	45
		828	<pre><code>puts "Hello, World!"</code></pre>
		829
		830	x
		831	5
		832	chomp
		833	n
		834	s
		835	24
		836	bc. puts "Hello, World!"
		837	p
		838	17
		839	I
		840	0
		841	I
		842	1b
		843	I
		844	0
		845	I
		846	1c
		847	I
		848	9
		849	I
		850	1d
		851	I
		852	d
		853	I
		854	1e
		855	I
		856	2e
		857	I
		858	1d
		859	I
		860	33
		861	I
		862	1f
		863	I
		864	3a
		865	I
		866	22
		867	I
		868	5b
		869	I
		870	1f
		871	I
		872	60
		873	x
		874	62
		875	/Users/murphy/ruby/coderay-0.9/test/functional/for_redcloth.rb
		876	p
		877	0
		878	x
		879	23
		880	test_for_redcloth_style
		881	M
		882	1
		883	n
		884	n
		885	x
		886	23
		887	test_for_redcloth_style
		888	i
		889	54
		890	5
		891	7
		892	0
		893	64
		894	47
		895	49
		896	1
		897	1
		898	15
		899	5
		900	7
		901	2
		902	64
		903	49
		904	3
		905	0
		906	45
		907	4
		908	5
		909	13
		910	71
		911	6
		912	47
		913	9
		914	40
		915	47
		916	49
		917	7
		918	0
		919	13
		920	7
		921	8
		922	64
		923	47
		924	49
		925	9
		926	1
		927	15
		928	8
		929	46
		930	7
		931	8
		932	64
		933	49
		934	6
		935	1
		936	49
		937	10
		938	0
		939	47
		940	49
		941	11
		942	2
		943	11
		944	I
		945	5
		946	I
		947	0
		948	I
		949	0
		950	I
		951	0
		952	n
		953	p
		954	12
		955	s
		956	20
		957	coderay/for_redcloth
		958	x
		959	7
		960	require
		961	s
		962	85
		963	<pre style="color: red;"><code style="color: red;">puts "Hello, World!"</code></pre>
		964
		965	x
		966	5
		967	chomp
		968	x
		969	8
		970	RedCloth
		971	n
		972	x
		973	3
		974	new
		975	x
		976	8
		977	allocate
		978	s
		979	36
		980	bc{color: red}. puts "Hello, World!"
		981	x
		982	10
		983	initialize
		984	x
		985	7
		986	to_html
		987	x
		988	12
		989	assert_equal
		990	p
		991	11
		992	I
		993	0
		994	I
		995	25
		996	I
		997	0
		998	I
		999	26
		1000	I
		1001	9
		1002	I
		1003	27
		1004	I
		1005	10
		1006	I
		1007	2a
		1008	I
		1009	31
		1010	I
		1011	27
		1012	I
		1013	36
		1014	x
		1015	62
		1016	/Users/murphy/ruby/coderay-0.9/test/functional/for_redcloth.rb
		1017	p
		1018	0
		1019	x
		1020	25
		1021	test_for_redcloth_escapes
		1022	M
		1023	1
		1024	n
		1025	n
		1026	x
		1027	25
		1028	test_for_redcloth_escapes
		1029	i
		1030	96
		1031	5
		1032	7
		1033	0
		1034	64
		1035	47
		1036	49
		1037	1
		1038	1
		1039	15
		1040	5
		1041	7
		1042	2
		1043	64
		1044	45
		1045	3
		1046	4
		1047	13
		1048	71
		1049	5
		1050	47
		1051	9
		1052	37
		1053	47
		1054	49
		1055	6
		1056	0
		1057	13
		1058	7
		1059	7
		1060	64
		1061	47
		1062	49
		1063	8
		1064	1
		1065	15
		1066	8
		1067	43
		1068	7
		1069	7
		1070	64
		1071	49
		1072	5
		1073	1
		1074	49
		1075	9
		1076	0
		1077	47
		1078	49
		1079	10
		1080	2
		1081	15
		1082	5
		1083	7
		1084	11
		1085	64
		1086	49
		1087	12
		1088	0
		1089	45
		1090	3
		1091	13
		1092	13
		1093	71
		1094	5
		1095	47
		1096	9
		1097	82
		1098	47
		1099	49
		1100	6
		1101	0
		1102	13
		1103	7
		1104	14
		1105	64
		1106	47
		1107	49
		1108	8
		1109	1
		1110	15
		1111	8
		1112	88
		1113	7
		1114	14
		1115	64
		1116	49
		1117	5
		1118	1
		1119	49
		1120	9
		1121	0
		1122	47
		1123	49
		1124	10
		1125	2
		1126	11
		1127	I
		1128	5
		1129	I
		1130	0
		1131	I
		1132	0
		1133	I
		1134	0
		1135	n
		1136	p
		1137	15
		1138	s
		1139	20
		1140	coderay/for_redcloth
		1141	x
		1142	7
		1143	require
		1144	s
		1145	52
		1146	<p><span lang="ruby" class="CodeRay">></span></p>
		1147	x
		1148	8
		1149	RedCloth
		1150	n
		1151	x
		1152	3
		1153	new
		1154	x
		1155	8
		1156	allocate
		1157	s
		1158	9
		1159	@[ruby]>@
		1160	x
		1161	10
		1162	initialize
		1163	x
		1164	7
		1165	to_html
		1166	x
		1167	12
		1168	assert_equal
		1169	s
		1170	84
		1171	<div lang="ruby" class="CodeRay">
		1172	<div class="code"><pre>&</pre></div>
		1173	</div>
		1174
		1175	x
		1176	5
		1177	chomp
		1178	n
		1179	s
		1180	11
		1181	bc[ruby]. &
		1182	p
		1183	17
		1184	I
		1185	0
		1186	I
		1187	2d
		1188	I
		1189	0
		1190	I
		1191	2e
		1192	I
		1193	9
		1194	I
		1195	2f
		1196	I
		1197	d
		1198	I
		1199	30
		1200	I
		1201	2e
		1202	I
		1203	2f
		1204	I
		1205	33
		1206	I
		1207	31
		1208	I
		1209	3a
		1210	I
		1211	36
		1212	I
		1213	5b
		1214	I
		1215	31
		1216	I
		1217	60
		1218	x
		1219	62
		1220	/Users/murphy/ruby/coderay-0.9/test/functional/for_redcloth.rb
		1221	p
		1222	0
		1223	x
		1224	26
		1225	test_for_redcloth_escapes2
		1226	M
		1227	1
		1228	n
		1229	n
		1230	x
		1231	26
		1232	test_for_redcloth_escapes2
		1233	i
		1234	51
		1235	5
		1236	7
		1237	0
		1238	64
		1239	47
		1240	49
		1241	1
		1242	1
		1243	15
		1244	5
		1245	7
		1246	2
		1247	64
		1248	45
		1249	3
		1250	4
		1251	13
		1252	71
		1253	5
		1254	47
		1255	9
		1256	37
		1257	47
		1258	49
		1259	6
		1260	0
		1261	13
		1262	7
		1263	7
		1264	64
		1265	47
		1266	49
		1267	8
		1268	1
		1269	15
		1270	8
		1271	43
		1272	7
		1273	7
		1274	64
		1275	49
		1276	5
		1277	1
		1278	49
		1279	9
		1280	0
		1281	47
		1282	49
		1283	10
		1284	2
		1285	11
		1286	I
		1287	5
		1288	I
		1289	0
		1290	I
		1291	0
		1292	I
		1293	0
		1294	n
		1295	p
		1296	11
		1297	s
		1298	20
		1299	coderay/for_redcloth
		1300	x
		1301	7
		1302	require
		1303	s
		1304	149
		1305	<p><span lang="c" class="CodeRay"><span style="color:#579">#include</span> <span style="color:#B44;font-weight:bold"><test.h></span></span></p>
		1306	x
		1307	8
		1308	RedCloth
		1309	n
		1310	x
		1311	3
		1312	new
		1313	x
		1314	8
		1315	allocate
		1316	s
		1317	22
		1318	@[c]#include <test.h>@
		1319	x
		1320	10
		1321	initialize
		1322	x
		1323	7
		1324	to_html
		1325	x
		1326	12
		1327	assert_equal
		1328	p
		1329	11
		1330	I
		1331	0
		1332	I
		1333	39
		1334	I
		1335	0
		1336	I
		1337	3a
		1338	I
		1339	9
		1340	I
		1341	3b
		1342	I
		1343	d
		1344	I
		1345	3c
		1346	I
		1347	2e
		1348	I
		1349	3b
		1350	I
		1351	33
		1352	x
		1353	62
		1354	/Users/murphy/ruby/coderay-0.9/test/functional/for_redcloth.rb
		1355	p
		1356	0
		1357	x
		1358	32
		1359	test_for_redcloth_false_positive
		1360	M
		1361	1
		1362	n
		1363	n
		1364	x
		1365	32
		1366	test_for_redcloth_false_positive
		1367	i
		1368	138
		1369	5
		1370	7
		1371	0
		1372	64
		1373	47
		1374	49
		1375	1
		1376	1
		1377	15
		1378	5
		1379	7
		1380	2
		1381	64
		1382	45
		1383	3
		1384	4
		1385	13
		1386	71
		1387	5
		1388	47
		1389	9
		1390	37
		1391	47
		1392	49
		1393	6
		1394	0
		1395	13
		1396	7
		1397	7
		1398	64
		1399	47
		1400	49
		1401	8
		1402	1
		1403	15
		1404	8
		1405	43
		1406	7
		1407	7
		1408	64
		1409	49
		1410	5
		1411	1
		1412	49
		1413	9
		1414	0
		1415	47
		1416	49
		1417	10
		1418	2
		1419	15
		1420	5
		1421	7
		1422	11
		1423	64
		1424	45
		1425	3
		1426	12
		1427	13
		1428	71
		1429	5
		1430	47
		1431	9
		1432	79
		1433	47
		1434	49
		1435	6
		1436	0
		1437	13
		1438	7
		1439	13
		1440	64
		1441	47
		1442	49
		1443	8
		1444	1
		1445	15
		1446	8
		1447	85
		1448	7
		1449	13
		1450	64
		1451	49
		1452	5
		1453	1
		1454	49
		1455	9
		1456	0
		1457	47
		1458	49
		1459	10
		1460	2
		1461	15
		1462	5
		1463	7
		1464	14
		1465	64
		1466	49
		1467	15
		1468	0
		1469	45
		1470	3
		1471	16
		1472	13
		1473	71
		1474	5
		1475	47
		1476	9
		1477	124
		1478	47
		1479	49
		1480	6
		1481	0
		1482	13
		1483	7
		1484	17
		1485	64
		1486	47
		1487	49
		1488	8
		1489	1
		1490	15
		1491	8
		1492	130
		1493	7
		1494	17
		1495	64
		1496	49
		1497	5
		1498	1
		1499	49
		1500	9
		1501	0
		1502	47
		1503	49
		1504	10
		1505	2
		1506	11
		1507	I
		1508	5
		1509	I
		1510	0
		1511	I
		1512	0
		1513	I
		1514	0
		1515	n
		1516	p
		1517	18
		1518	s
		1519	20
		1520	coderay/for_redcloth
		1521	x
		1522	7
		1523	require
		1524	s
		1525	38
		1526	<p><code>[project]_dff.skjd</code></p>
		1527	x
		1528	8
		1529	RedCloth
		1530	n
		1531	x
		1532	3
		1533	new
		1534	x
		1535	8
		1536	allocate
		1537	s
		1538	20
		1539	@[project]_dff.skjd@
		1540	x
		1541	10
		1542	initialize
		1543	x
		1544	7
		1545	to_html
		1546	x
		1547	12
		1548	assert_equal
		1549	s
		1550	57
		1551	<p><span lang="ruby" class="CodeRay">_dff.skjd</span></p>
		1552	n
		1553	s
		1554	17
		1555	@[ruby]_dff.skjd@
		1556	s
		1557	43
		1558	<pre><code>[project]_dff.skjd</code></pre>
		1559
		1560	x
		1561	5
		1562	chomp
		1563	n
		1564	s
		1565	22
		1566	bc. [project]_dff.skjd
		1567	p
		1568	23
		1569	I
		1570	0
		1571	I
		1572	40
		1573	I
		1574	0
		1575	I
		1576	41
		1577	I
		1578	9
		1579	I
		1580	42
		1581	I
		1582	d
		1583	I
		1584	43
		1585	I
		1586	2e
		1587	I
		1588	42
		1589	I
		1590	33
		1591	I
		1592	45
		1593	I
		1594	37
		1595	I
		1596	46
		1597	I
		1598	58
		1599	I
		1600	45
		1601	I
		1602	5d
		1603	I
		1604	47
		1605	I
		1606	64
		1607	I
		1608	4a
		1609	I
		1610	85
		1611	I
		1612	47
		1613	I
		1614	8a
		1615	x
		1616	62
		1617	/Users/murphy/ruby/coderay-0.9/test/functional/for_redcloth.rb
		1618	p
		1619	0
		1620	p
		1621	13
		1622	I
		1623	2
		1624	I
		1625	f
		1626	I
		1627	10
		1628	I
		1629	1b
		1630	I
		1631	1e
		1632	I
		1633	25
		1634	I
		1635	2c
		1636	I
		1637	2d
		1638	I
		1639	3a
		1640	I
		1641	39
		1642	I
		1643	48
		1644	I
		1645	40
		1646	I
		1647	56
		1648	x
		1649	62
		1650	/Users/murphy/ruby/coderay-0.9/test/functional/for_redcloth.rb
		1651	p
		1652	0
		1653	x
		1654	13
		1655	attach_method
		1656	p
		1657	23
		1658	I
		1659	0
		1660	I
		1661	1
		1662	I
		1663	9
		1664	I
		1665	2
		1666	I
		1667	18
		1668	I
		1669	3
		1670	I
		1671	21
		1672	I
		1673	6
		1674	I
		1675	51
		1676	I
		1677	7
		1678	I
		1679	85
		1680	I
		1681	8
		1682	I
		1683	95
		1684	I
		1685	9
		1686	I
		1687	a2
		1688	I
		1689	a
		1690	I
		1691	b6
		1692	I
		1693	4d
		1694	I
		1695	d3
		1696	I
		1697	d
		1698	I
		1699	f5
		1700	I
		1701	4d
		1702	I
		1703	f9
		1704	x
		1705	62
		1706	/Users/murphy/ruby/coderay-0.9/test/functional/for_redcloth.rb
		1707	p
		1708	0

vendor/gems/coderay-0.9.7/test/functional/load_plugin_scanner.rb created 644 +11 0

@@ -0,0 +1,11
	1	require 'test/unit'
	2	require 'coderay'
	3
	4	class PluginScannerTest < Test::Unit::TestCase
	5
	6	def test_load
	7	require File.join(File.dirname(__FILE__), 'vhdl')
	8	assert_equal 'VHDL', CodeRay.scanner(:vhdl).class.name
	9	end
	10
	11	end

vendor/gems/coderay-0.9.7/test/functional/load_plugin_scanner.rbc created 644 +317 0

@@ -0,0 +1,317
	1	!RBIX
	2	0
	3	x
	4	M
	5	1
	6	n
	7	n
	8	x
	9	10
	10	__script__
	11	i
	12	53
	13	5
	14	7
	15	0
	16	64
	17	47
	18	49
	19	1
	20	1
	21	15
	22	5
	23	7
	24	2
	25	64
	26	47
	27	49
	28	1
	29	1
	30	15
	31	99
	32	7
	33	3
	34	45
	35	4
	36	5
	37	43
	38	6
	39	43
	40	7
	41	65
	42	49
	43	8
	44	3
	45	13
	46	99
	47	12
	48	7
	49	9
	50	12
	51	7
	52	10
	53	12
	54	65
	55	12
	56	49
	57	11
	58	4
	59	15
	60	49
	61	9
	62	0
	63	15
	64	2
	65	11
	66	I
	67	6
	68	I
	69	0
	70	I
	71	0
	72	I
	73	0
	74	n
	75	p
	76	12
	77	s
	78	9
	79	test/unit
	80	x
	81	7
	82	require
	83	s
	84	7
	85	coderay
	86	x
	87	17
	88	PluginScannerTest
	89	x
	90	4
	91	Test
	92	n
	93	x
	94	4
	95	Unit
	96	x
	97	8
	98	TestCase
	99	x
	100	10
	101	open_class
	102	x
	103	14
	104	__class_init__
	105	M
	106	1
	107	n
	108	n
	109	x
	110	17
	111	PluginScannerTest
	112	i
	113	16
	114	5
	115	66
	116	99
	117	7
	118	0
	119	7
	120	1
	121	65
	122	67
	123	49
	124	2
	125	0
	126	49
	127	3
	128	4
	129	11
	130	I
	131	5
	132	I
	133	0
	134	I
	135	0
	136	I
	137	0
	138	n
	139	p
	140	4
	141	x
	142	9
	143	test_load
	144	M
	145	1
	146	n
	147	n
	148	x
	149	9
	150	test_load
	151	i
	152	48
	153	5
	154	45
	155	0
	156	1
	157	45
	158	0
	159	2
	160	65
	161	49
	162	3
	163	0
	164	49
	165	4
	166	1
	167	7
	168	5
	169	64
	170	49
	171	6
	172	2
	173	47
	174	49
	175	7
	176	1
	177	15
	178	5
	179	7
	180	8
	181	64
	182	45
	183	9
	184	10
	185	7
	186	11
	187	49
	188	12
	189	1
	190	49
	191	13
	192	0
	193	49
	194	14
	195	0
	196	47
	197	49
	198	15
	199	2
	200	11
	201	I
	202	4
	203	I
	204	0
	205	I
	206	0
	207	I
	208	0
	209	n
	210	p
	211	16
	212	x
	213	4
	214	File
	215	n
	216	n
	217	x
	218	11
	219	active_path
	220	x
	221	7
	222	dirname
	223	s
	224	4
	225	vhdl
	226	x
	227	4
	228	join
	229	x
	230	7
	231	require
	232	s
	233	4
	234	VHDL
	235	x
	236	7
	237	CodeRay
	238	n
	239	x
	240	4
	241	vhdl
	242	x
	243	7
	244	scanner
	245	x
	246	5
	247	class
	248	x
	249	4
	250	name
	251	x
	252	12
	253	assert_equal
	254	p
	255	7
	256	I
	257	0
	258	I
	259	6
	260	I
	261	0
	262	I
	263	7
	264	I
	265	19
	266	I
	267	8
	268	I
	269	30
	270	x
	271	69
	272	/Users/murphy/ruby/coderay-0.9/test/functional/load_plugin_scanner.rb
	273	p
	274	0
	275	x
	276	17
	277	method_visibility
	278	x
	279	15
	280	add_defn_method
	281	p
	282	3
	283	I
	284	2
	285	I
	286	6
	287	I
	288	10
	289	x
	290	69
	291	/Users/murphy/ruby/coderay-0.9/test/functional/load_plugin_scanner.rb
	292	p
	293	0
	294	x
	295	13
	296	attach_method
	297	p
	298	7
	299	I
	300	0
	301	I
	302	1
	303	I
	304	9
	305	I
	306	2
	307	I
	308	12
	309	I
	310	4
	311	I
	312	35
	313	x
	314	69
	315	/Users/murphy/ruby/coderay-0.9/test/functional/load_plugin_scanner.rb
	316	p
	317	0

vendor/gems/coderay-0.9.7/test/functional/suite.rb created 644 +12 0

@@ -0,0 +1,12
	1	require 'test/unit'
	2
	3	MYDIR = File.dirname(__FILE__)
	4
	5	$:.unshift 'lib'
	6	require 'coderay'
	7	puts "Running basic CodeRay #{CodeRay::VERSION} tests..."
	8
	9	suite = %w(basic load_plugin_scanner word_list)
	10	for test_case in suite
	11	load File.join(MYDIR, test_case + '.rb')
	12	end

vendor/gems/coderay-0.9.7/test/functional/suite.rbc created 644 +322 0

@@ -0,0 +1,322
	1	!RBIX
	2	0
	3	x
	4	M
	5	1
	6	n
	7	n
	8	x
	9	10
	10	__script__
	11	i
	12	95
	13	5
	14	7
	15	0
	16	64
	17	47
	18	49
	19	1
	20	1
	21	15
	22	65
	23	7
	24	2
	25	45
	26	3
	27	4
	28	65
	29	49
	30	5
	31	0
	32	49
	33	6
	34	1
	35	49
	36	7
	37	2
	38	15
	39	99
	40	43
	41	8
	42	7
	43	9
	44	49
	45	10
	46	1
	47	7
	48	11
	49	64
	50	49
	51	12
	52	1
	53	15
	54	5
	55	7
	56	13
	57	64
	58	47
	59	49
	60	1
	61	1
	62	15
	63	5
	64	7
	65	14
	66	45
	67	15
	68	16
	69	43
	70	17
	71	47
	72	49
	73	18
	74	0
	75	7
	76	19
	77	63
	78	3
	79	47
	80	49
	81	20
	82	1
	83	15
	84	7
	85	21
	86	64
	87	7
	88	22
	89	64
	90	7
	91	23
	92	64
	93	35
	94	3
	95	19
	96	0
	97	15
	98	20
	99	0
	100	56
	101	24
	102	50
	103	25
	104	0
	105	15
	106	2
	107	11
	108	I
	109	6
	110	I
	111	2
	112	I
	113	0
	114	I
	115	0
	116	n
	117	p
	118	26
	119	s
	120	9
	121	test/unit
	122	x
	123	7
	124	require
	125	x
	126	5
	127	MYDIR
	128	x
	129	4
	130	File
	131	n
	132	x
	133	11
	134	active_path
	135	x
	136	7
	137	dirname
	138	x
	139	9
	140	const_set
	141	x
	142	7
	143	Globals
	144	x
	145	2
	146	$:
	147	x
	148	2
	149	[]
	150	s
	151	3
	152	lib
	153	x
	154	2
	155	<<
	156	s
	157	7
	158	coderay
	159	s
	160	22
	161	Running basic CodeRay
	162	x
	163	7
	164	CodeRay
	165	n
	166	x
	167	7
	168	VERSION
	169	x
	170	4
	171	to_s
	172	s
	173	9
	174	tests...
	175	x
	176	4
	177	puts
	178	s
	179	5
	180	basic
	181	s
	182	19
	183	load_plugin_scanner
	184	s
	185	9
	186	word_list
	187	M
	188	1
	189	p
	190	2
	191	x
	192	9
	193	for_block
	194	t
	195	n
	196	x
	197	9
	198	__block__
	199	i
	200	28
	201	57
	202	22
	203	1
	204	1
	205	15
	206	5
	207	45
	208	0
	209	1
	210	45
	211	2
	212	3
	213	21
	214	1
	215	1
	216	7
	217	4
	218	64
	219	81
	220	5
	221	49
	222	6
	223	2
	224	47
	225	49
	226	7
	227	1
	228	11
	229	I
	230	6
	231	I
	232	0
	233	I
	234	1
	235	I
	236	1
	237	n
	238	p
	239	8
	240	x
	241	4
	242	File
	243	n
	244	x
	245	5
	246	MYDIR
	247	n
	248	s
	249	3
	250	.rb
	251	x
	252	1
	253	+
	254	x
	255	4
	256	join
	257	x
	258	4
	259	load
	260	p
	261	5
	262	I
	263	0
	264	I
	265	a
	266	I
	267	5
	268	I
	269	b
	270	I
	271	1c
	272	x
	273	55
	274	/Users/murphy/ruby/coderay-0.9/test/functional/suite.rb
	275	p
	276	0
	277	x
	278	4
	279	each
	280	p
	281	15
	282	I
	283	0
	284	I
	285	1
	286	I
	287	9
	288	I
	289	3
	290	I
	291	1a
	292	I
	293	5
	294	I
	295	29
	296	I
	297	6
	298	I
	299	32
	300	I
	301	7
	302	I
	303	47
	304	I
	305	9
	306	I
	307	55
	308	I
	309	a
	310	I
	311	5f
	312	x
	313	55
	314	/Users/murphy/ruby/coderay-0.9/test/functional/suite.rb
	315	p
	316	2
	317	x
	318	5
	319	suite
	320	x
	321	9
	322	test_case

vendor/gems/coderay-0.9.7/test/functional/vhdl.rb created 644 +126 0

@@ -0,0 +1,126
	1	class VHDL < CodeRay::Scanners::Scanner
	2
	3	register_for :vhdl
	4
	5	RESERVED_WORDS = [
	6	'access','after','alias','all','assert','architecture','begin',
	7	'block','body','buffer','bus','case','component','configuration','constant',
	8	'disconnect','downto','else','elsif','end','entity','exit','file','for',
	9	'function','generate','generic','group','guarded','if','impure','in',
	10	'inertial','inout','is','label','library','linkage','literal','loop',
	11	'map','new','next','null','of','on','open','others','out','package',
	12	'port','postponed','procedure','process','pure','range','record','register',
	13	'reject','report','return','select','severity','signal','shared','subtype',
	14	'then','to','transport','type','unaffected','units','until','use','variable',
	15	'wait','when','while','with','note','warning','error','failure','and',
	16	'or','xor','not','nor',
	17	'array'
	18	]
	19
	20	PREDEFINED_TYPES = [
	21	'bit','bit_vector','character','boolean','integer','real','time','string',
	22	'severity_level','positive','natural','signed','unsigned','line','text',
	23	'std_logic','std_logic_vector','std_ulogic','std_ulogic_vector','qsim_state',
	24	'qsim_state_vector','qsim_12state','qsim_12state_vector','qsim_strength',
	25	'mux_bit','mux_vector','reg_bit','reg_vector','wor_bit','wor_vector'
	26	]
	27
	28	PREDEFINED_CONSTANTS = [
	29
	30	]
	31
	32	IDENT_KIND = CodeRay::CaseIgnoringWordList.new(:ident).
	33	add(RESERVED_WORDS, :reserved).
	34	add(PREDEFINED_TYPES, :pre_type).
	35	add(PREDEFINED_CONSTANTS, :pre_constant)
	36
	37	ESCAPE = / [rbfntv\n\\'"] \| x[a-fA-F0-9]{1,2} \| [0-7]{1,3} /x
	38	UNICODE_ESCAPE = / u[a-fA-F0-9]{4} \| U[a-fA-F0-9]{8} /x
	39
	40	def scan_tokens tokens, options
	41
	42	state = :initial
	43
	44	until eos?
	45
	46	kind = nil
	47	match = nil
	48
	49	case state
	50
	51	when :initial
	52
	53	if scan(/ \s+ \| \\\n /x)
	54	kind = :space
	55
	56	elsif scan(/-- .*/x)
	57	kind = :comment
	58
	59	elsif scan(/ [-+*\/=<>?:;,!&^\|()\[\]{}~%]+ \| \.(?!\d) /x)
	60	kind = :operator
	61
	62	elsif match = scan(/ [A-Za-z_][A-Za-z_0-9]* /x)
	63	kind = IDENT_KIND[match.downcase]
	64
	65	elsif match = scan(/[a-z]?"/i)
	66	tokens << [:open, :string]
	67	state = :string
	68	kind = :delimiter
	69
	70	elsif scan(/ L?' (?: [^\'\n\\] \| \\ #{ESCAPE} )? '? /ox)
	71	kind = :char
	72
	73	elsif scan(/(?:\d+)(?![.eEfF])/)
	74	kind = :integer
	75
	76	elsif scan(/\d[fF]?\|\d*\.\d+(?:[eE][+-]?\d+)?[fF]?\|\d+[eE][+-]?\d+[fF]?/)
	77	kind = :float
	78
	79	else
	80	getch
	81	kind = :error
	82
	83	end
	84
	85	when :string
	86	if scan(/[^\\\n"]+/)
	87	kind = :content
	88	elsif scan(/"/)
	89	tokens << ['"', :delimiter]
	90	tokens << [:close, :string]
	91	state = :initial
	92	next
	93	elsif scan(/ \\ (?: #{ESCAPE} \| #{UNICODE_ESCAPE} ) /mox)
	94	kind = :char
	95	elsif scan(/ \\ \| $ /x)
	96	tokens << [:close, :string]
	97	kind = :error
	98	state = :initial
	99	else
	100	raise_inspect "else case \" reached; %p not handled." % peek(1), tokens
	101	end
	102
	103	else
	104	raise_inspect 'Unknown state', tokens
	105
	106	end
	107
	108	match \|\|= matched
	109	if $DEBUG and not kind
	110	raise_inspect 'Error token %p in line %d' %
	111	[[match, kind], line], tokens
	112	end
	113	raise_inspect 'Empty token', tokens unless match
	114
	115	tokens << [match, kind]
	116
	117	end
	118
	119	if state == :string
	120	tokens << [:close, :string]
	121	end
	122
	123	tokens
	124	end
	125
	126	end

vendor/gems/coderay-0.9.7/test/functional/vhdl.rbc created 644 +2334 0

This diff has been collapsed as it changes many lines, (2334 lines changed) Show them Hide them
	@@ -0,0 +1,2334
		1	!RBIX
		2	0
		3	x
		4	M
		5	1
		6	n
		7	n
		8	x
		9	10
		10	__script__
		11	i
		12	35
		13	99
		14	7
		15	0
		16	45
		17	1
		18	2
		19	43
		20	3
		21	43
		22	4
		23	65
		24	49
		25	5
		26	3
		27	13
		28	99
		29	12
		30	7
		31	6
		32	12
		33	7
		34	7
		35	12
		36	65
		37	12
		38	49
		39	8
		40	4
		41	15
		42	49
		43	6
		44	0
		45	15
		46	2
		47	11
		48	I
		49	6
		50	I
		51	0
		52	I
		53	0
		54	I
		55	0
		56	n
		57	p
		58	9
		59	x
		60	4
		61	VHDL
		62	x
		63	7
		64	CodeRay
		65	n
		66	x
		67	8
		68	Scanners
		69	x
		70	7
		71	Scanner
		72	x
		73	10
		74	open_class
		75	x
		76	14
		77	__class_init__
		78	M
		79	1
		80	n
		81	n
		82	x
		83	4
		84	VHDL
		85	i
		86	519
		87	5
		88	66
		89	5
		90	7
		91	0
		92	47
		93	49
		94	1
		95	1
		96	15
		97	65
		98	7
		99	2
		100	7
		101	3
		102	64
		103	7
		104	4
		105	64
		106	7
		107	5
		108	64
		109	7
		110	6
		111	64
		112	7
		113	7
		114	64
		115	7
		116	8
		117	64
		118	7
		119	9
		120	64
		121	7
		122	10
		123	64
		124	7
		125	11
		126	64
		127	7
		128	12
		129	64
		130	7
		131	13
		132	64
		133	7
		134	14
		135	64
		136	7
		137	15
		138	64
		139	7
		140	16
		141	64
		142	7
		143	17
		144	64
		145	7
		146	18
		147	64
		148	7
		149	19
		150	64
		151	7
		152	20
		153	64
		154	7
		155	21
		156	64
		157	7
		158	22
		159	64
		160	7
		161	23
		162	64
		163	7
		164	24
		165	64
		166	7
		167	25
		168	64
		169	7
		170	26
		171	64
		172	7
		173	27
		174	64
		175	7
		176	28
		177	64
		178	7
		179	29
		180	64
		181	7
		182	30
		183	64
		184	7
		185	31
		186	64
		187	7
		188	32
		189	64
		190	7
		191	33
		192	64
		193	7
		194	34
		195	64
		196	7
		197	35
		198	64
		199	7
		200	36
		201	64
		202	7
		203	37
		204	64
		205	7
		206	38
		207	64
		208	7
		209	39
		210	64
		211	7
		212	40
		213	64
		214	7
		215	41
		216	64
		217	7
		218	42
		219	64
		220	7
		221	43
		222	64
		223	7
		224	44
		225	64
		226	7
		227	45
		228	64
		229	7
		230	46
		231	64
		232	7
		233	47
		234	64
		235	7
		236	48
		237	64
		238	7
		239	49
		240	64
		241	7
		242	50
		243	64
		244	7
		245	51
		246	64
		247	7
		248	52
		249	64
		250	7
		251	53
		252	64
		253	7
		254	54
		255	64
		256	7
		257	55
		258	64
		259	7
		260	56
		261	64
		262	7
		263	57
		264	64
		265	7
		266	58
		267	64
		268	7
		269	59
		270	64
		271	7
		272	60
		273	64
		274	7
		275	61
		276	64
		277	7
		278	62
		279	64
		280	7
		281	63
		282	64
		283	7
		284	64
		285	64
		286	7
		287	65
		288	64
		289	7
		290	66
		291	64
		292	7
		293	67
		294	64
		295	7
		296	68
		297	64
		298	7
		299	69
		300	64
		301	7
		302	70
		303	64
		304	7
		305	71
		306	64
		307	7
		308	72
		309	64
		310	7
		311	73
		312	64
		313	7
		314	74
		315	64
		316	7
		317	75
		318	64
		319	7
		320	76
		321	64
		322	7
		323	77
		324	64
		325	7
		326	78
		327	64
		328	7
		329	79
		330	64
		331	7
		332	80
		333	64
		334	7
		335	81
		336	64
		337	7
		338	82
		339	64
		340	7
		341	83
		342	64
		343	7
		344	84
		345	64
		346	7
		347	85
		348	64
		349	7
		350	86
		351	64
		352	7
		353	87
		354	64
		355	7
		356	88
		357	64
		358	7
		359	89
		360	64
		361	7
		362	90
		363	64
		364	7
		365	91
		366	64
		367	35
		368	89
		369	49
		370	92
		371	2
		372	15
		373	65
		374	7
		375	93
		376	7
		377	94
		378	64
		379	7
		380	95
		381	64
		382	7
		383	96
		384	64
		385	7
		386	97
		387	64
		388	7
		389	98
		390	64
		391	7
		392	99
		393	64
		394	7
		395	100
		396	64
		397	7
		398	101
		399	64
		400	7
		401	102
		402	64
		403	7
		404	103
		405	64
		406	7
		407	104
		408	64
		409	7
		410	105
		411	64
		412	7
		413	106
		414	64
		415	7
		416	107
		417	64
		418	7
		419	108
		420	64
		421	7
		422	109
		423	64
		424	7
		425	110
		426	64
		427	7
		428	111
		429	64
		430	7
		431	112
		432	64
		433	7
		434	113
		435	64
		436	7
		437	114
		438	64
		439	7
		440	115
		441	64
		442	7
		443	116
		444	64
		445	7
		446	117
		447	64
		448	7
		449	118
		450	64
		451	7
		452	119
		453	64
		454	7
		455	120
		456	64
		457	7
		458	121
		459	64
		460	7
		461	122
		462	64
		463	7
		464	123
		465	64
		466	35
		467	30
		468	49
		469	92
		470	2
		471	15
		472	65
		473	7
		474	124
		475	35
		476	0
		477	49
		478	92
		479	2
		480	15
		481	65
		482	7
		483	125
		484	45
		485	126
		486	127
		487	43
		488	128
		489	13
		490	71
		491	129
		492	47
		493	9
		494	422
		495	47
		496	49
		497	130
		498	0
		499	13
		500	7
		501	131
		502	47
		503	49
		504	132
		505	1
		506	15
		507	8
		508	427
		509	7
		510	131
		511	49
		512	129
		513	1
		514	45
		515	2
		516	133
		517	7
		518	134
		519	49
		520	135
		521	2
		522	45
		523	93
		524	136
		525	7
		526	137
		527	49
		528	135
		529	2
		530	45
		531	124
		532	138
		533	7
		534	139
		535	49
		536	135
		537	2
		538	49
		539	92
		540	2
		541	15
		542	65
		543	7
		544	140
		545	7
		546	141
		547	13
		548	70
		549	9
		550	476
		551	15
		552	44
		553	43
		554	142
		555	7
		556	143
		557	80
		558	49
		559	129
		560	2
		561	6
		562	141
		563	49
		564	92
		565	2
		566	15
		567	65
		568	7
		569	144
		570	7
		571	145
		572	13
		573	70
		574	9
		575	501
		576	15
		577	44
		578	43
		579	142
		580	7
		581	146
		582	80
		583	49
		584	129
		585	2
		586	6
		587	145
		588	49
		589	92
		590	2
		591	15
		592	99
		593	7
		594	147
		595	7
		596	148
		597	65
		598	67
		599	49
		600	149
		601	0
		602	49
		603	150
		604	4
		605	11
		606	I
		607	5b
		608	I
		609	0
		610	I
		611	0
		612	I
		613	0
		614	n
		615	p
		616	151
		617	x
		618	4
		619	vhdl
		620	x
		621	12
		622	register_for
		623	x
		624	14
		625	RESERVED_WORDS
		626	s
		627	6
		628	access
		629	s
		630	5
		631	after
		632	s
		633	5
		634	alias
		635	s
		636	3
		637	all
		638	s
		639	6
		640	assert
		641	s
		642	12
		643	architecture
		644	s
		645	5
		646	begin
		647	s
		648	5
		649	block
		650	s
		651	4
		652	body
		653	s
		654	6
		655	buffer
		656	s
		657	3
		658	bus
		659	s
		660	4
		661	case
		662	s
		663	9
		664	component
		665	s
		666	13
		667	configuration
		668	s
		669	8
		670	constant
		671	s
		672	10
		673	disconnect
		674	s
		675	6
		676	downto
		677	s
		678	4
		679	else
		680	s
		681	5
		682	elsif
		683	s
		684	3
		685	end
		686	s
		687	6
		688	entity
		689	s
		690	4
		691	exit
		692	s
		693	4
		694	file
		695	s
		696	3
		697	for
		698	s
		699	8
		700	function
		701	s
		702	8
		703	generate
		704	s
		705	7
		706	generic
		707	s
		708	5
		709	group
		710	s
		711	7
		712	guarded
		713	s
		714	2
		715	if
		716	s
		717	6
		718	impure
		719	s
		720	2
		721	in
		722	s
		723	8
		724	inertial
		725	s
		726	5
		727	inout
		728	s
		729	2
		730	is
		731	s
		732	5
		733	label
		734	s
		735	7
		736	library
		737	s
		738	7
		739	linkage
		740	s
		741	7
		742	literal
		743	s
		744	4
		745	loop
		746	s
		747	3
		748	map
		749	s
		750	3
		751	new
		752	s
		753	4
		754	next
		755	s
		756	4
		757	null
		758	s
		759	2
		760	of
		761	s
		762	2
		763	on
		764	s
		765	4
		766	open
		767	s
		768	6
		769	others
		770	s
		771	3
		772	out
		773	s
		774	7
		775	package
		776	s
		777	4
		778	port
		779	s
		780	9
		781	postponed
		782	s
		783	9
		784	procedure
		785	s
		786	7
		787	process
		788	s
		789	4
		790	pure
		791	s
		792	5
		793	range
		794	s
		795	6
		796	record
		797	s
		798	8
		799	register
		800	s
		801	6
		802	reject
		803	s
		804	6
		805	report
		806	s
		807	6
		808	return
		809	s
		810	6
		811	select
		812	s
		813	8
		814	severity
		815	s
		816	6
		817	signal
		818	s
		819	6
		820	shared
		821	s
		822	7
		823	subtype
		824	s
		825	4
		826	then
		827	s
		828	2
		829	to
		830	s
		831	9
		832	transport
		833	s
		834	4
		835	type
		836	s
		837	10
		838	unaffected
		839	s
		840	5
		841	units
		842	s
		843	5
		844	until
		845	s
		846	3
		847	use
		848	s
		849	8
		850	variable
		851	s
		852	4
		853	wait
		854	s
		855	4
		856	when
		857	s
		858	5
		859	while
		860	s
		861	4
		862	with
		863	s
		864	4
		865	note
		866	s
		867	7
		868	warning
		869	s
		870	5
		871	error
		872	s
		873	7
		874	failure
		875	s
		876	3
		877	and
		878	s
		879	2
		880	or
		881	s
		882	3
		883	xor
		884	s
		885	3
		886	not
		887	s
		888	3
		889	nor
		890	s
		891	5
		892	array
		893	x
		894	9
		895	const_set
		896	x
		897	16
		898	PREDEFINED_TYPES
		899	s
		900	3
		901	bit
		902	s
		903	10
		904	bit_vector
		905	s
		906	9
		907	character
		908	s
		909	7
		910	boolean
		911	s
		912	7
		913	integer
		914	s
		915	4
		916	real
		917	s
		918	4
		919	time
		920	s
		921	6
		922	string
		923	s
		924	14
		925	severity_level
		926	s
		927	8
		928	positive
		929	s
		930	7
		931	natural
		932	s
		933	6
		934	signed
		935	s
		936	8
		937	unsigned
		938	s
		939	4
		940	line
		941	s
		942	4
		943	text
		944	s
		945	9
		946	std_logic
		947	s
		948	16
		949	std_logic_vector
		950	s
		951	10
		952	std_ulogic
		953	s
		954	17
		955	std_ulogic_vector
		956	s
		957	10
		958	qsim_state
		959	s
		960	17
		961	qsim_state_vector
		962	s
		963	12
		964	qsim_12state
		965	s
		966	19
		967	qsim_12state_vector
		968	s
		969	13
		970	qsim_strength
		971	s
		972	7
		973	mux_bit
		974	s
		975	10
		976	mux_vector
		977	s
		978	7
		979	reg_bit
		980	s
		981	10
		982	reg_vector
		983	s
		984	7
		985	wor_bit
		986	s
		987	10
		988	wor_vector
		989	x
		990	20
		991	PREDEFINED_CONSTANTS
		992	x
		993	10
		994	IDENT_KIND
		995	x
		996	7
		997	CodeRay
		998	n
		999	x
		1000	20
		1001	CaseIgnoringWordList
		1002	x
		1003	3
		1004	new
		1005	x
		1006	8
		1007	allocate
		1008	x
		1009	5
		1010	ident
		1011	x
		1012	10
		1013	initialize
		1014	n
		1015	x
		1016	8
		1017	reserved
		1018	x
		1019	3
		1020	add
		1021	n
		1022	x
		1023	8
		1024	pre_type
		1025	n
		1026	x
		1027	12
		1028	pre_constant
		1029	x
		1030	6
		1031	ESCAPE
		1032	n
		1033	x
		1034	6
		1035	Regexp
		1036	s
		1037	49
		1038	[rbfntv\n\\'"] \| x[a-fA-F0-9]{1,2} \| [0-7]{1,3}
		1039	x
		1040	14
		1041	UNICODE_ESCAPE
		1042	n
		1043	s
		1044	35
		1045	u[a-fA-F0-9]{4} \| U[a-fA-F0-9]{8}
		1046	x
		1047	11
		1048	scan_tokens
		1049	M
		1050	1
		1051	n
		1052	n
		1053	x
		1054	11
		1055	scan_tokens
		1056	i
		1057	688
		1058	7
		1059	0
		1060	19
		1061	2
		1062	15
		1063	5
		1064	47
		1065	49
		1066	1
		1067	0
		1068	10
		1069	660
		1070	1
		1071	19
		1072	3
		1073	15
		1074	1
		1075	19
		1076	4
		1077	15
		1078	20
		1079	2
		1080	13
		1081	7
		1082	0
		1083	12
		1084	49
		1085	2
		1086	1
		1087	9
		1088	331
		1089	15
		1090	5
		1091	7
		1092	3
		1093	13
		1094	70
		1095	9
		1096	51
		1097	15
		1098	44
		1099	43
		1100	4
		1101	7
		1102	5
		1103	80
		1104	49
		1105	6
		1106	2
		1107	6
		1108	3
		1109	47
		1110	49
		1111	7
		1112	1
		1113	9
		1114	63
		1115	7
		1116	8
		1117	19
		1118	3
		1119	8
		1120	329
		1121	5
		1122	7
		1123	9
		1124	13
		1125	70
		1126	9
		1127	82
		1128	15
		1129	44
		1130	43
		1131	4
		1132	7
		1133	10
		1134	80
		1135	49
		1136	6
		1137	2
		1138	6
		1139	9
		1140	47
		1141	49
		1142	7
		1143	1
		1144	9
		1145	94
		1146	7
		1147	11
		1148	19
		1149	3
		1150	8
		1151	329
		1152	5
		1153	7
		1154	12
		1155	13
		1156	70
		1157	9
		1158	113
		1159	15
		1160	44
		1161	43
		1162	4
		1163	7
		1164	13
		1165	80
		1166	49
		1167	6
		1168	2
		1169	6
		1170	12
		1171	47
		1172	49
		1173	7
		1174	1
		1175	9
		1176	125
		1177	7
		1178	14
		1179	19
		1180	3
		1181	8
		1182	329
		1183	5
		1184	7
		1185	15
		1186	13
		1187	70
		1188	9
		1189	144
		1190	15
		1191	44
		1192	43
		1193	4
		1194	7
		1195	16
		1196	80
		1197	49
		1198	6
		1199	2
		1200	6
		1201	15
		1202	47
		1203	49
		1204	7
		1205	1
		1206	19
		1207	4
		1208	9
		1209	167
		1210	45
		1211	17
		1212	18
		1213	20
		1214	4
		1215	49
		1216	19
		1217	0
		1218	49
		1219	20
		1220	1
		1221	19
		1222	3
		1223	8
		1224	329
		1225	5
		1226	7
		1227	21
		1228	13
		1229	70
		1230	9
		1231	186
		1232	15
		1233	44
		1234	43
		1235	4
		1236	7
		1237	22
		1238	79
		1239	49
		1240	6
		1241	2
		1242	6
		1243	21
		1244	47
		1245	49
		1246	7
		1247	1
		1248	19
		1249	4
		1250	9
		1251	217
		1252	20
		1253	0
		1254	7
		1255	23
		1256	7
		1257	24
		1258	35
		1259	2
		1260	49
		1261	25
		1262	1
		1263	15
		1264	7
		1265	24
		1266	19
		1267	2
		1268	15
		1269	7
		1270	26
		1271	19
		1272	3
		1273	8
		1274	329
		1275	5
		1276	7
		1277	27
		1278	13
		1279	70
		1280	9
		1281	247
		1282	15
		1283	44
		1284	43
		1285	4
		1286	7
		1287	28
		1288	45
		1289	29
		1290	30
		1291	47
		1292	49
		1293	31
		1294	0
		1295	7
		1296	32
		1297	63
		1298	3
		1299	80
		1300	49
		1301	6
		1302	2
		1303	6
		1304	27
		1305	47
		1306	49
		1307	7
		1308	1
		1309	9
		1310	259
		1311	7
		1312	33
		1313	19
		1314	3
		1315	8
		1316	329
		1317	5
		1318	7
		1319	34
		1320	13
		1321	70
		1322	9
		1323	278
		1324	15
		1325	44
		1326	43
		1327	4
		1328	7
		1329	35
		1330	78
		1331	49
		1332	6
		1333	2
		1334	6
		1335	34
		1336	47
		1337	49
		1338	7
		1339	1
		1340	9
		1341	290
		1342	7
		1343	36
		1344	19
		1345	3
		1346	8
		1347	329
		1348	5
		1349	7
		1350	37
		1351	13
		1352	70
		1353	9
		1354	309
		1355	15
		1356	44
		1357	43
		1358	4
		1359	7
		1360	38
		1361	78
		1362	49
		1363	6
		1364	2
		1365	6
		1366	37
		1367	47
		1368	49
		1369	7
		1370	1
		1371	9
		1372	321
		1373	7
		1374	39
		1375	19
		1376	3
		1377	8
		1378	329
		1379	5
		1380	48
		1381	40
		1382	15
		1383	7
		1384	41
		1385	19
		1386	3
		1387	8
		1388	564
		1389	13
		1390	7
		1391	24
		1392	12
		1393	49
		1394	2
		1395	1
		1396	9
		1397	553
		1398	15
		1399	5
		1400	7
		1401	42
		1402	13
		1403	70
		1404	9
		1405	360
		1406	15
		1407	44
		1408	43
		1409	4
		1410	7
		1411	43
		1412	78
		1413	49
		1414	6
		1415	2
		1416	6
		1417	42
		1418	47
		1419	49
		1420	7
		1421	1
		1422	9
		1423	372
		1424	7
		1425	44
		1426	19
		1427	3
		1428	8
		1429	551
		1430	5
		1431	7
		1432	45
		1433	13
		1434	70
		1435	9
		1436	391
		1437	15
		1438	44
		1439	43
		1440	4
		1441	7
		1442	46
		1443	78
		1444	49
		1445	6
		1446	2
		1447	6
		1448	45
		1449	47
		1450	49
		1451	7
		1452	1
		1453	9
		1454	432
		1455	20
		1456	0
		1457	7
		1458	46
		1459	64
		1460	7
		1461	26
		1462	35
		1463	2
		1464	49
		1465	25
		1466	1
		1467	15
		1468	20
		1469	0
		1470	7
		1471	47
		1472	7
		1473	24
		1474	35
		1475	2
		1476	49
		1477	25
		1478	1
		1479	15
		1480	7
		1481	0
		1482	19
		1483	2
		1484	15
		1485	1
		1486	8
		1487	656
		1488	8
		1489	551
		1490	5
		1491	7
		1492	48
		1493	13
		1494	70
		1495	9
		1496	472
		1497	15
		1498	44
		1499	43
		1500	4
		1501	7
		1502	49
		1503	45
		1504	29
		1505	50
		1506	47
		1507	49
		1508	31
		1509	0
		1510	7
		1511	51
		1512	45
		1513	52
		1514	53
		1515	47
		1516	49
		1517	31
		1518	0
		1519	7
		1520	54
		1521	63
		1522	5
		1523	4
		1524	6
		1525	49
		1526	6
		1527	2
		1528	6
		1529	48
		1530	47
		1531	49
		1532	7
		1533	1
		1534	9
		1535	484
		1536	7
		1537	33
		1538	19
		1539	3
		1540	8
		1541	551
		1542	5
		1543	7
		1544	55
		1545	13
		1546	70
		1547	9
		1548	503
		1549	15
		1550	44
		1551	43
		1552	4
		1553	7
		1554	56
		1555	80
		1556	49
		1557	6
		1558	2
		1559	6
		1560	55
		1561	47
		1562	49
		1563	7
		1564	1
		1565	9
		1566	532
		1567	20
		1568	0
		1569	7
		1570	47
		1571	7
		1572	24
		1573	35
		1574	2
		1575	49
		1576	25
		1577	1
		1578	15
		1579	7
		1580	41
		1581	19
		1582	3
		1583	15
		1584	7
		1585	0
		1586	19
		1587	2
		1588	8
		1589	551
		1590	5
		1591	7
		1592	57
		1593	64
		1594	5
		1595	79
		1596	47
		1597	49
		1598	58
		1599	1
		1600	49
		1601	59
		1602	1
		1603	20
		1604	0
		1605	47
		1606	49
		1607	60
		1608	2
		1609	8
		1610	564
		1611	15
		1612	5
		1613	7
		1614	61
		1615	64
		1616	20
		1617	0
		1618	47
		1619	49
		1620	60
		1621	2
		1622	15
		1623	20
		1624	4
		1625	13
		1626	10
		1627	576
		1628	15
		1629	5
		1630	48
		1631	62
		1632	19
		1633	4
		1634	15
		1635	99
		1636	43
		1637	63
		1638	7
		1639	64
		1640	49
		1641	20
		1642	1
		1643	13
		1644	9
		1645	597
		1646	15
		1647	20
		1648	3
		1649	10
		1650	596
		1651	2
		1652	8
		1653	597
		1654	3
		1655	9
		1656	625
		1657	5
		1658	7
		1659	65
		1660	64
		1661	20
		1662	4
		1663	20
		1664	3
		1665	35
		1666	2
		1667	5
		1668	48
		1669	66
		1670	35
		1671	2
		1672	49
		1673	59
		1674	1
		1675	20
		1676	0
		1677	47
		1678	49
		1679	60
		1680	2
		1681	8
		1682	626
		1683	1
		1684	15
		1685	20
		1686	4
		1687	9
		1688	634
		1689	1
		1690	8
		1691	644
		1692	5
		1693	7
		1694	67
		1695	64
		1696	20
		1697	0
		1698	47
		1699	49
		1700	60
		1701	2
		1702	15
		1703	20
		1704	0
		1705	20
		1706	4
		1707	20
		1708	3
		1709	35
		1710	2
		1711	49
		1712	25
		1713	1
		1714	15
		1715	68
		1716	8
		1717	5
		1718	1
		1719	15
		1720	20
		1721	2
		1722	7
		1723	24
		1724	83
		1725	68
		1726	9
		1727	683
		1728	20
		1729	0
		1730	7
		1731	47
		1732	7
		1733	24
		1734	35
		1735	2
		1736	49
		1737	25
		1738	1
		1739	8
		1740	684
		1741	1
		1742	15
		1743	20
		1744	0
		1745	11
		1746	I
		1747	c
		1748	I
		1749	5
		1750	I
		1751	2
		1752	I
		1753	2
		1754	n
		1755	p
		1756	69
		1757	x
		1758	7
		1759	initial
		1760	x
		1761	4
		1762	eos?
		1763	x
		1764	3
		1765	===
		1766	n
		1767	x
		1768	6
		1769	Regexp
		1770	s
		1771	12
		1772	\s+ \| \\\n
		1773	x
		1774	3
		1775	new
		1776	x
		1777	4
		1778	scan
		1779	x
		1780	5
		1781	space
		1782	n
		1783	s
		1784	5
		1785	-- .*
		1786	x
		1787	7
		1788	comment
		1789	n
		1790	s
		1791	42
		1792	[-+*\/=<>?:;,!&^\|()\[\]{}~%]+ \| \.(?!\d)
		1793	x
		1794	8
		1795	operator
		1796	n
		1797	s
		1798	24
		1799	[A-Za-z_][A-Za-z_0-9]*
		1800	x
		1801	10
		1802	IDENT_KIND
		1803	n
		1804	x
		1805	8
		1806	downcase
		1807	x
		1808	2
		1809	[]
		1810	n
		1811	s
		1812	7
		1813	[a-z]?"
		1814	x
		1815	4
		1816	open
		1817	x
		1818	6
		1819	string
		1820	x
		1821	2
		1822	<<
		1823	x
		1824	9
		1825	delimiter
		1826	n
		1827	s
		1828	24
		1829	L?' (?: [^\'\n\\] \| \\
		1830	x
		1831	6
		1832	ESCAPE
		1833	n
		1834	x
		1835	4
		1836	to_s
		1837	s
		1838	7
		1839	)? '?
		1840	x
		1841	4
		1842	char
		1843	n
		1844	s
		1845	18
		1846	(?:\d+)(?![.eEfF])
		1847	x
		1848	7
		1849	integer
		1850	n
		1851	s
		1852	59
		1853	\d[fF]?\|\d*\.\d+(?:[eE][+-]?\d+)?[fF]?\|\d+[eE][+-]?\d+[fF]?
		1854	x
		1855	5
		1856	float
		1857	x
		1858	5
		1859	getch
		1860	x
		1861	5
		1862	error
		1863	n
		1864	s
		1865	9
		1866	[^\\\n"]+
		1867	x
		1868	7
		1869	content
		1870	n
		1871	s
		1872	1
		1873	"
		1874	x
		1875	5
		1876	close
		1877	n
		1878	s
		1879	8
		1880	\\ (?:
		1881	n
		1882	s
		1883	3
		1884	\|
		1885	x
		1886	14
		1887	UNICODE_ESCAPE
		1888	n
		1889	s
		1890	3
		1891	)
		1892	n
		1893	s
		1894	8
		1895	\\ \| $
		1896	s
		1897	36
		1898	else case " reached; %p not handled.
		1899	x
		1900	4
		1901	peek
		1902	x
		1903	1
		1904	%
		1905	x
		1906	13
		1907	raise_inspect
		1908	s
		1909	13
		1910	Unknown state
		1911	x
		1912	7
		1913	matched
		1914	x
		1915	7
		1916	Globals
		1917	x
		1918	6
		1919	$DEBUG
		1920	s
		1921	25
		1922	Error token %p in line %d
		1923	x
		1924	4
		1925	line
		1926	s
		1927	11
		1928	Empty token
		1929	x
		1930	2
		1931	==
		1932	p
		1933	111
		1934	I
		1935	0
		1936	I
		1937	28
		1938	I
		1939	0
		1940	I
		1941	2a
		1942	I
		1943	5
		1944	I
		1945	2c
		1946	I
		1947	c
		1948	I
		1949	2e
		1950	I
		1951	10
		1952	I
		1953	2f
		1954	I
		1955	14
		1956	I
		1957	31
		1958	I
		1959	17
		1960	I
		1961	33
		1962	I
		1963	20
		1964	I
		1965	35
		1966	I
		1967	39
		1968	I
		1969	36
		1970	I
		1971	3f
		1972	I
		1973	38
		1974	I
		1975	58
		1976	I
		1977	39
		1978	I
		1979	5e
		1980	I
		1981	3b
		1982	I
		1983	77
		1984	I
		1985	3c
		1986	I
		1987	7d
		1988	I
		1989	3e
		1990	I
		1991	98
		1992	I
		1993	3f
		1994	I
		1995	a7
		1996	I
		1997	41
		1998	I
		1999	c2
		2000	I
		2001	42
		2002	I
		2003	ce
		2004	I
		2005	43
		2006	I
		2007	d3
		2008	I
		2009	44
		2010	I
		2011	d9
		2012	I
		2013	46
		2014	I
		2015	fd
		2016	I
		2017	47
		2018	I
		2019	103
		2020	I
		2021	49
		2022	I
		2023	11c
		2024	I
		2025	4a
		2026	I
		2027	122
		2028	I
		2029	4c
		2030	I
		2031	13b
		2032	I
		2033	4d
		2034	I
		2035	141
		2036	I
		2037	50
		2038	I
		2039	145
		2040	I
		2041	51
		2042	I
		2043	14c
		2044	I
		2045	55
		2046	I
		2047	155
		2048	I
		2049	56
		2050	I
		2051	16e
		2052	I
		2053	57
		2054	I
		2055	174
		2056	I
		2057	58
		2058	I
		2059	18d
		2060	I
		2061	59
		2062	I
		2063	19a
		2064	I
		2065	5a
		2066	I
		2067	1a6
		2068	I
		2069	5b
		2070	I
		2071	1ab
		2072	I
		2073	5c
		2074	I
		2075	1b0
		2076	I
		2077	5d
		2078	I
		2079	1de
		2080	I
		2081	5e
		2082	I
		2083	1e4
		2084	I
		2085	5f
		2086	I
		2087	1fd
		2088	I
		2089	60
		2090	I
		2091	209
		2092	I
		2093	61
		2094	I
		2095	20e
		2096	I
		2097	62
		2098	I
		2099	214
		2100	I
		2101	64
		2102	I
		2103	22a
		2104	I
		2105	68
		2106	I
		2107	235
		2108	I
		2109	6c
		2110	I
		2111	241
		2112	I
		2113	6d
		2114	I
		2115	257
		2116	I
		2117	6f
		2118	I
		2119	258
		2120	I
		2121	6e
		2122	I
		2123	25b
		2124	I
		2125	6f
		2126	I
		2127	271
		2128	I
		2129	6d
		2130	I
		2131	273
		2132	I
		2133	71
		2134	I
		2135	285
		2136	I
		2137	73
		2138	I
		2139	296
		2140	I
		2141	77
		2142	I
		2143	29e
		2144	I
		2145	78
		2146	I
		2147	2ab
		2148	I
		2149	77
		2150	I
		2151	2ad
		2152	I
		2153	7b
		2154	I
		2155	2b0
		2156	x
		2157	54
		2158	/Users/murphy/ruby/coderay-0.9/test/functional/vhdl.rb
		2159	p
		2160	5
		2161	x
		2162	6
		2163	tokens
		2164	x
		2165	7
		2166	options
		2167	x
		2168	5
		2169	state
		2170	x
		2171	4
		2172	kind
		2173	x
		2174	5
		2175	match
		2176	x
		2177	17
		2178	method_visibility
		2179	x
		2180	15
		2181	add_defn_method
		2182	p
		2183	65
		2184	I
		2185	2
		2186	I
		2187	3
		2188	I
		2189	a
		2190	I
		2191	5
		2192	I
		2193	d
		2194	I
		2195	6
		2196	I
		2197	22
		2198	I
		2199	7
		2200	I
		2201	3a
		2202	I
		2203	8
		2204	I
		2205	55
		2206	I
		2207	9
		2208	I
		2209	6d
		2210	I
		2211	a
		2212	I
		2213	85
		2214	I
		2215	b
		2216	I
		2217	a3
		2218	I
		2219	c
		2220	I
		2221	bb
		2222	I
		2223	d
		2224	I
		2225	d3
		2226	I
		2227	e
		2228	I
		2229	ee
		2230	I
		2231	f
		2232	I
		2233	109
		2234	I
		2235	10
		2236	I
		2237	115
		2238	I
		2239	11
		2240	I
		2241	11e
		2242	I
		2243	14
		2244	I
		2245	121
		2246	I
		2247	15
		2248	I
		2249	139
		2250	I
		2251	16
		2252	I
		2253	14e
		2254	I
		2255	17
		2256	I
		2257	15d
		2258	I
		2259	18
		2260	I
		2261	169
		2262	I
		2263	19
		2264	I
		2265	181
		2266	I
		2267	1c
		2268	I
		2269	184
		2270	I
		2271	1e
		2272	I
		2273	18a
		2274	I
		2275	20
		2276	I
		2277	1ab
		2278	I
		2279	21
		2280	I
		2281	1b0
		2282	I
		2283	20
		2284	I
		2285	1b3
		2286	I
		2287	22
		2288	I
		2289	1b8
		2290	I
		2291	20
		2292	I
		2293	1bb
		2294	I
		2295	23
		2296	I
		2297	1c0
		2298	I
		2299	20
		2300	I
		2301	1c7
		2302	I
		2303	25
		2304	I
		2305	1e0
		2306	I
		2307	26
		2308	I
		2309	1f9
		2310	I
		2311	28
		2312	I
		2313	207
		2314	x
		2315	54
		2316	/Users/murphy/ruby/coderay-0.9/test/functional/vhdl.rb
		2317	p
		2318	0
		2319	x
		2320	13
		2321	attach_method
		2322	p
		2323	3
		2324	I
		2325	0
		2326	I
		2327	1
		2328	I
		2329	23
		2330	x
		2331	54
		2332	/Users/murphy/ruby/coderay-0.9/test/functional/vhdl.rb
		2333	p
		2334	0

vendor/gems/coderay-0.9.7/test/functional/word_list.rb created 644 +79 0

@@ -0,0 +1,79
	1	require 'test/unit'
	2	require 'coderay'
	3
	4	class WordListTest < Test::Unit::TestCase
	5
	6	include CodeRay
	7
	8	# define word arrays
	9	RESERVED_WORDS = %w[
	10	asm break case continue default do else
	11	...
	12	]
	13
	14	PREDEFINED_TYPES = %w[
	15	int long short char void
	16	...
	17	]
	18
	19	PREDEFINED_CONSTANTS = %w[
	20	EOF NULL ...
	21	]
	22
	23	# make a WordList
	24	IDENT_KIND = WordList.new(:ident).
	25	add(RESERVED_WORDS, :reserved).
	26	add(PREDEFINED_TYPES, :pre_type).
	27	add(PREDEFINED_CONSTANTS, :pre_constant)
	28
	29	def test_word_list_example
	30	assert_equal :pre_type, IDENT_KIND['void']
	31	# assert_equal :pre_constant, IDENT_KIND['...'] # not specified
	32	end
	33
	34	def test_word_list
	35	list = WordList.new(:ident).add(['foobar'], :reserved)
	36	assert_equal :reserved, list['foobar']
	37	assert_equal :ident, list['FooBar']
	38	end
	39
	40	def test_word_list_cached
	41	list = WordList.new(:ident, true).add(['foobar'], :reserved)
	42	assert_equal :reserved, list['foobar']
	43	assert_equal :ident, list['FooBar']
	44	end
	45
	46	def test_case_ignoring_word_list
	47	list = CaseIgnoringWordList.new(:ident).add(['foobar'], :reserved)
	48	assert_equal :ident, list['foo']
	49	assert_equal :reserved, list['foobar']
	50	assert_equal :reserved, list['FooBar']
	51
	52	list = CaseIgnoringWordList.new(:ident).add(['FooBar'], :reserved)
	53	assert_equal :ident, list['foo']
	54	assert_equal :reserved, list['foobar']
	55	assert_equal :reserved, list['FooBar']
	56	end
	57
	58	def test_case_ignoring_word_list_cached
	59	list = CaseIgnoringWordList.new(:ident, true).add(['foobar'], :reserved)
	60	assert_equal :ident, list['foo']
	61	assert_equal :reserved, list['foobar']
	62	assert_equal :reserved, list['FooBar']
	63
	64	list = CaseIgnoringWordList.new(:ident, true).add(['FooBar'], :reserved)
	65	assert_equal :ident, list['foo']
	66	assert_equal :reserved, list['foobar']
	67	assert_equal :reserved, list['FooBar']
	68	end
	69
	70	def test_dup
	71	list = WordList.new(:ident).add(['foobar'], :reserved)
	72	assert_equal :reserved, list['foobar']
	73	list2 = list.dup
	74	list2.add(%w[foobar], :keyword)
	75	assert_equal :keyword, list2['foobar']
	76	assert_equal :reserved, list['foobar']
	77	end
	78
	79	end No newline at end of file

vendor/gems/coderay-0.9.7/test/functional/word_list.rbc created 644 +1763 0

This diff has been collapsed as it changes many lines, (1763 lines changed) Show them Hide them
	@@ -0,0 +1,1763
		1	!RBIX
		2	0
		3	x
		4	M
		5	1
		6	n
		7	n
		8	x
		9	10
		10	__script__
		11	i
		12	53
		13	5
		14	7
		15	0
		16	64
		17	47
		18	49
		19	1
		20	1
		21	15
		22	5
		23	7
		24	2
		25	64
		26	47
		27	49
		28	1
		29	1
		30	15
		31	99
		32	7
		33	3
		34	45
		35	4
		36	5
		37	43
		38	6
		39	43
		40	7
		41	65
		42	49
		43	8
		44	3
		45	13
		46	99
		47	12
		48	7
		49	9
		50	12
		51	7
		52	10
		53	12
		54	65
		55	12
		56	49
		57	11
		58	4
		59	15
		60	49
		61	9
		62	0
		63	15
		64	2
		65	11
		66	I
		67	6
		68	I
		69	0
		70	I
		71	0
		72	I
		73	0
		74	n
		75	p
		76	12
		77	s
		78	9
		79	test/unit
		80	x
		81	7
		82	require
		83	s
		84	7
		85	coderay
		86	x
		87	12
		88	WordListTest
		89	x
		90	4
		91	Test
		92	n
		93	x
		94	4
		95	Unit
		96	x
		97	8
		98	TestCase
		99	x
		100	10
		101	open_class
		102	x
		103	14
		104	__class_init__
		105	M
		106	1
		107	n
		108	n
		109	x
		110	12
		111	WordListTest
		112	i
		113	232
		114	5
		115	66
		116	5
		117	45
		118	0
		119	1
		120	47
		121	49
		122	2
		123	1
		124	15
		125	65
		126	7
		127	3
		128	7
		129	4
		130	64
		131	7
		132	5
		133	64
		134	7
		135	6
		136	64
		137	7
		138	7
		139	64
		140	7
		141	8
		142	64
		143	7
		144	9
		145	64
		146	7
		147	10
		148	64
		149	7
		150	11
		151	64
		152	35
		153	8
		154	49
		155	12
		156	2
		157	15
		158	65
		159	7
		160	13
		161	7
		162	14
		163	64
		164	7
		165	15
		166	64
		167	7
		168	16
		169	64
		170	7
		171	17
		172	64
		173	7
		174	18
		175	64
		176	7
		177	11
		178	64
		179	35
		180	6
		181	49
		182	12
		183	2
		184	15
		185	65
		186	7
		187	19
		188	7
		189	20
		190	64
		191	7
		192	21
		193	64
		194	7
		195	11
		196	64
		197	35
		198	3
		199	49
		200	12
		201	2
		202	15
		203	65
		204	7
		205	22
		206	45
		207	23
		208	24
		209	13
		210	71
		211	25
		212	47
		213	9
		214	115
		215	47
		216	49
		217	26
		218	0
		219	13
		220	7
		221	27
		222	47
		223	49
		224	28
		225	1
		226	15
		227	8
		228	120
		229	7
		230	27
		231	49
		232	25
		233	1
		234	45
		235	3
		236	29
		237	7
		238	30
		239	49
		240	31
		241	2
		242	45
		243	13
		244	32
		245	7
		246	33
		247	49
		248	31
		249	2
		250	45
		251	19
		252	34
		253	7
		254	35
		255	49
		256	31
		257	2
		258	49
		259	12
		260	2
		261	15
		262	99
		263	7
		264	36
		265	7
		266	37
		267	65
		268	67
		269	49
		270	38
		271	0
		272	49
		273	39
		274	4
		275	15
		276	99
		277	7
		278	40
		279	7
		280	41
		281	65
		282	67
		283	49
		284	38
		285	0
		286	49
		287	39
		288	4
		289	15
		290	99
		291	7
		292	42
		293	7
		294	43
		295	65
		296	67
		297	49
		298	38
		299	0
		300	49
		301	39
		302	4
		303	15
		304	99
		305	7
		306	44
		307	7
		308	45
		309	65
		310	67
		311	49
		312	38
		313	0
		314	49
		315	39
		316	4
		317	15
		318	99
		319	7
		320	46
		321	7
		322	47
		323	65
		324	67
		325	49
		326	38
		327	0
		328	49
		329	39
		330	4
		331	15
		332	99
		333	7
		334	48
		335	7
		336	49
		337	65
		338	67
		339	49
		340	38
		341	0
		342	49
		343	39
		344	4
		345	11
		346	I
		347	a
		348	I
		349	0
		350	I
		351	0
		352	I
		353	0
		354	n
		355	p
		356	50
		357	x
		358	7
		359	CodeRay
		360	n
		361	x
		362	7
		363	include
		364	x
		365	14
		366	RESERVED_WORDS
		367	s
		368	3
		369	asm
		370	s
		371	5
		372	break
		373	s
		374	4
		375	case
		376	s
		377	8
		378	continue
		379	s
		380	7
		381	default
		382	s
		383	2
		384	do
		385	s
		386	4
		387	else
		388	s
		389	3
		390	...
		391	x
		392	9
		393	const_set
		394	x
		395	16
		396	PREDEFINED_TYPES
		397	s
		398	3
		399	int
		400	s
		401	4
		402	long
		403	s
		404	5
		405	short
		406	s
		407	4
		408	char
		409	s
		410	4
		411	void
		412	x
		413	20
		414	PREDEFINED_CONSTANTS
		415	s
		416	3
		417	EOF
		418	s
		419	4
		420	NULL
		421	x
		422	10
		423	IDENT_KIND
		424	x
		425	8
		426	WordList
		427	n
		428	x
		429	3
		430	new
		431	x
		432	8
		433	allocate
		434	x
		435	5
		436	ident
		437	x
		438	10
		439	initialize
		440	n
		441	x
		442	8
		443	reserved
		444	x
		445	3
		446	add
		447	n
		448	x
		449	8
		450	pre_type
		451	n
		452	x
		453	12
		454	pre_constant
		455	x
		456	22
		457	test_word_list_example
		458	M
		459	1
		460	n
		461	n
		462	x
		463	22
		464	test_word_list_example
		465	i
		466	17
		467	5
		468	7
		469	0
		470	45
		471	1
		472	2
		473	7
		474	3
		475	64
		476	49
		477	4
		478	1
		479	47
		480	49
		481	5
		482	2
		483	11
		484	I
		485	4
		486	I
		487	0
		488	I
		489	0
		490	I
		491	0
		492	n
		493	p
		494	6
		495	x
		496	8
		497	pre_type
		498	x
		499	10
		500	IDENT_KIND
		501	n
		502	s
		503	4
		504	void
		505	x
		506	2
		507	[]
		508	x
		509	12
		510	assert_equal
		511	p
		512	5
		513	I
		514	0
		515	I
		516	1d
		517	I
		518	0
		519	I
		520	1e
		521	I
		522	11
		523	x
		524	59
		525	/Users/murphy/ruby/coderay-0.9/test/functional/word_list.rb
		526	p
		527	0
		528	x
		529	17
		530	method_visibility
		531	x
		532	15
		533	add_defn_method
		534	x
		535	14
		536	test_word_list
		537	M
		538	1
		539	n
		540	n
		541	x
		542	14
		543	test_word_list
		544	i
		545	73
		546	45
		547	0
		548	1
		549	13
		550	71
		551	2
		552	47
		553	9
		554	23
		555	47
		556	49
		557	3
		558	0
		559	13
		560	7
		561	4
		562	47
		563	49
		564	5
		565	1
		566	15
		567	8
		568	28
		569	7
		570	4
		571	49
		572	2
		573	1
		574	7
		575	6
		576	64
		577	35
		578	1
		579	7
		580	7
		581	49
		582	8
		583	2
		584	19
		585	0
		586	15
		587	5
		588	7
		589	7
		590	20
		591	0
		592	7
		593	6
		594	64
		595	49
		596	9
		597	1
		598	47
		599	49
		600	10
		601	2
		602	15
		603	5
		604	7
		605	4
		606	20
		607	0
		608	7
		609	11
		610	64
		611	49
		612	9
		613	1
		614	47
		615	49
		616	10
		617	2
		618	11
		619	I
		620	5
		621	I
		622	1
		623	I
		624	0
		625	I
		626	0
		627	n
		628	p
		629	12
		630	x
		631	8
		632	WordList
		633	n
		634	x
		635	3
		636	new
		637	x
		638	8
		639	allocate
		640	x
		641	5
		642	ident
		643	x
		644	10
		645	initialize
		646	s
		647	6
		648	foobar
		649	x
		650	8
		651	reserved
		652	x
		653	3
		654	add
		655	x
		656	2
		657	[]
		658	x
		659	12
		660	assert_equal
		661	s
		662	6
		663	FooBar
		664	p
		665	9
		666	I
		667	0
		668	I
		669	22
		670	I
		671	0
		672	I
		673	23
		674	I
		675	29
		676	I
		677	24
		678	I
		679	39
		680	I
		681	25
		682	I
		683	49
		684	x
		685	59
		686	/Users/murphy/ruby/coderay-0.9/test/functional/word_list.rb
		687	p
		688	1
		689	x
		690	4
		691	list
		692	x
		693	21
		694	test_word_list_cached
		695	M
		696	1
		697	n
		698	n
		699	x
		700	21
		701	test_word_list_cached
		702	i
		703	75
		704	45
		705	0
		706	1
		707	13
		708	71
		709	2
		710	47
		711	9
		712	24
		713	47
		714	49
		715	3
		716	0
		717	13
		718	7
		719	4
		720	2
		721	47
		722	49
		723	5
		724	2
		725	15
		726	8
		727	30
		728	7
		729	4
		730	2
		731	49
		732	2
		733	2
		734	7
		735	6
		736	64
		737	35
		738	1
		739	7
		740	7
		741	49
		742	8
		743	2
		744	19
		745	0
		746	15
		747	5
		748	7
		749	7
		750	20
		751	0
		752	7
		753	6
		754	64
		755	49
		756	9
		757	1
		758	47
		759	49
		760	10
		761	2
		762	15
		763	5
		764	7
		765	4
		766	20
		767	0
		768	7
		769	11
		770	64
		771	49
		772	9
		773	1
		774	47
		775	49
		776	10
		777	2
		778	11
		779	I
		780	5
		781	I
		782	1
		783	I
		784	0
		785	I
		786	0
		787	n
		788	p
		789	12
		790	x
		791	8
		792	WordList
		793	n
		794	x
		795	3
		796	new
		797	x
		798	8
		799	allocate
		800	x
		801	5
		802	ident
		803	x
		804	10
		805	initialize
		806	s
		807	6
		808	foobar
		809	x
		810	8
		811	reserved
		812	x
		813	3
		814	add
		815	x
		816	2
		817	[]
		818	x
		819	12
		820	assert_equal
		821	s
		822	6
		823	FooBar
		824	p
		825	9
		826	I
		827	0
		828	I
		829	28
		830	I
		831	0
		832	I
		833	29
		834	I
		835	2b
		836	I
		837	2a
		838	I
		839	3b
		840	I
		841	2b
		842	I
		843	4b
		844	x
		845	59
		846	/Users/murphy/ruby/coderay-0.9/test/functional/word_list.rb
		847	p
		848	1
		849	x
		850	4
		851	list
		852	x
		853	28
		854	test_case_ignoring_word_list
		855	M
		856	1
		857	n
		858	n
		859	x
		860	28
		861	test_case_ignoring_word_list
		862	i
		863	178
		864	45
		865	0
		866	1
		867	13
		868	71
		869	2
		870	47
		871	9
		872	23
		873	47
		874	49
		875	3
		876	0
		877	13
		878	7
		879	4
		880	47
		881	49
		882	5
		883	1
		884	15
		885	8
		886	28
		887	7
		888	4
		889	49
		890	2
		891	1
		892	7
		893	6
		894	64
		895	35
		896	1
		897	7
		898	7
		899	49
		900	8
		901	2
		902	19
		903	0
		904	15
		905	5
		906	7
		907	4
		908	20
		909	0
		910	7
		911	9
		912	64
		913	49
		914	10
		915	1
		916	47
		917	49
		918	11
		919	2
		920	15
		921	5
		922	7
		923	7
		924	20
		925	0
		926	7
		927	6
		928	64
		929	49
		930	10
		931	1
		932	47
		933	49
		934	11
		935	2
		936	15
		937	5
		938	7
		939	7
		940	20
		941	0
		942	7
		943	12
		944	64
		945	49
		946	10
		947	1
		948	47
		949	49
		950	11
		951	2
		952	15
		953	45
		954	0
		955	13
		956	13
		957	71
		958	2
		959	47
		960	9
		961	112
		962	47
		963	49
		964	3
		965	0
		966	13
		967	7
		968	4
		969	47
		970	49
		971	5
		972	1
		973	15
		974	8
		975	117
		976	7
		977	4
		978	49
		979	2
		980	1
		981	7
		982	12
		983	64
		984	35
		985	1
		986	7
		987	7
		988	49
		989	8
		990	2
		991	19
		992	0
		993	15
		994	5
		995	7
		996	4
		997	20
		998	0
		999	7
		1000	9
		1001	64
		1002	49
		1003	10
		1004	1
		1005	47
		1006	49
		1007	11
		1008	2
		1009	15
		1010	5
		1011	7
		1012	7
		1013	20
		1014	0
		1015	7
		1016	6
		1017	64
		1018	49
		1019	10
		1020	1
		1021	47
		1022	49
		1023	11
		1024	2
		1025	15
		1026	5
		1027	7
		1028	7
		1029	20
		1030	0
		1031	7
		1032	12
		1033	64
		1034	49
		1035	10
		1036	1
		1037	47
		1038	49
		1039	11
		1040	2
		1041	11
		1042	I
		1043	5
		1044	I
		1045	1
		1046	I
		1047	0
		1048	I
		1049	0
		1050	n
		1051	p
		1052	14
		1053	x
		1054	20
		1055	CaseIgnoringWordList
		1056	n
		1057	x
		1058	3
		1059	new
		1060	x
		1061	8
		1062	allocate
		1063	x
		1064	5
		1065	ident
		1066	x
		1067	10
		1068	initialize
		1069	s
		1070	6
		1071	foobar
		1072	x
		1073	8
		1074	reserved
		1075	x
		1076	3
		1077	add
		1078	s
		1079	3
		1080	foo
		1081	x
		1082	2
		1083	[]
		1084	x
		1085	12
		1086	assert_equal
		1087	s
		1088	6
		1089	FooBar
		1090	n
		1091	p
		1092	19
		1093	I
		1094	0
		1095	I
		1096	2e
		1097	I
		1098	0
		1099	I
		1100	2f
		1101	I
		1102	29
		1103	I
		1104	30
		1105	I
		1106	39
		1107	I
		1108	31
		1109	I
		1110	49
		1111	I
		1112	32
		1113	I
		1114	59
		1115	I
		1116	34
		1117	I
		1118	82
		1119	I
		1120	35
		1121	I
		1122	92
		1123	I
		1124	36
		1125	I
		1126	a2
		1127	I
		1128	37
		1129	I
		1130	b2
		1131	x
		1132	59
		1133	/Users/murphy/ruby/coderay-0.9/test/functional/word_list.rb
		1134	p
		1135	1
		1136	x
		1137	4
		1138	list
		1139	x
		1140	35
		1141	test_case_ignoring_word_list_cached
		1142	M
		1143	1
		1144	n
		1145	n
		1146	x
		1147	35
		1148	test_case_ignoring_word_list_cached
		1149	i
		1150	182
		1151	45
		1152	0
		1153	1
		1154	13
		1155	71
		1156	2
		1157	47
		1158	9
		1159	24
		1160	47
		1161	49
		1162	3
		1163	0
		1164	13
		1165	7
		1166	4
		1167	2
		1168	47
		1169	49
		1170	5
		1171	2
		1172	15
		1173	8
		1174	30
		1175	7
		1176	4
		1177	2
		1178	49
		1179	2
		1180	2
		1181	7
		1182	6
		1183	64
		1184	35
		1185	1
		1186	7
		1187	7
		1188	49
		1189	8
		1190	2
		1191	19
		1192	0
		1193	15
		1194	5
		1195	7
		1196	4
		1197	20
		1198	0
		1199	7
		1200	9
		1201	64
		1202	49
		1203	10
		1204	1
		1205	47
		1206	49
		1207	11
		1208	2
		1209	15
		1210	5
		1211	7
		1212	7
		1213	20
		1214	0
		1215	7
		1216	6
		1217	64
		1218	49
		1219	10
		1220	1
		1221	47
		1222	49
		1223	11
		1224	2
		1225	15
		1226	5
		1227	7
		1228	7
		1229	20
		1230	0
		1231	7
		1232	12
		1233	64
		1234	49
		1235	10
		1236	1
		1237	47
		1238	49
		1239	11
		1240	2
		1241	15
		1242	45
		1243	0
		1244	13
		1245	13
		1246	71
		1247	2
		1248	47
		1249	9
		1250	115
		1251	47
		1252	49
		1253	3
		1254	0
		1255	13
		1256	7
		1257	4
		1258	2
		1259	47
		1260	49
		1261	5
		1262	2
		1263	15
		1264	8
		1265	121
		1266	7
		1267	4
		1268	2
		1269	49
		1270	2
		1271	2
		1272	7
		1273	12
		1274	64
		1275	35
		1276	1
		1277	7
		1278	7
		1279	49
		1280	8
		1281	2
		1282	19
		1283	0
		1284	15
		1285	5
		1286	7
		1287	4
		1288	20
		1289	0
		1290	7
		1291	9
		1292	64
		1293	49
		1294	10
		1295	1
		1296	47
		1297	49
		1298	11
		1299	2
		1300	15
		1301	5
		1302	7
		1303	7
		1304	20
		1305	0
		1306	7
		1307	6
		1308	64
		1309	49
		1310	10
		1311	1
		1312	47
		1313	49
		1314	11
		1315	2
		1316	15
		1317	5
		1318	7
		1319	7
		1320	20
		1321	0
		1322	7
		1323	12
		1324	64
		1325	49
		1326	10
		1327	1
		1328	47
		1329	49
		1330	11
		1331	2
		1332	11
		1333	I
		1334	5
		1335	I
		1336	1
		1337	I
		1338	0
		1339	I
		1340	0
		1341	n
		1342	p
		1343	14
		1344	x
		1345	20
		1346	CaseIgnoringWordList
		1347	n
		1348	x
		1349	3
		1350	new
		1351	x
		1352	8
		1353	allocate
		1354	x
		1355	5
		1356	ident
		1357	x
		1358	10
		1359	initialize
		1360	s
		1361	6
		1362	foobar
		1363	x
		1364	8
		1365	reserved
		1366	x
		1367	3
		1368	add
		1369	s
		1370	3
		1371	foo
		1372	x
		1373	2
		1374	[]
		1375	x
		1376	12
		1377	assert_equal
		1378	s
		1379	6
		1380	FooBar
		1381	n
		1382	p
		1383	19
		1384	I
		1385	0
		1386	I
		1387	3a
		1388	I
		1389	0
		1390	I
		1391	3b
		1392	I
		1393	2b
		1394	I
		1395	3c
		1396	I
		1397	3b
		1398	I
		1399	3d
		1400	I
		1401	4b
		1402	I
		1403	3e
		1404	I
		1405	5b
		1406	I
		1407	40
		1408	I
		1409	86
		1410	I
		1411	41
		1412	I
		1413	96
		1414	I
		1415	42
		1416	I
		1417	a6
		1418	I
		1419	43
		1420	I
		1421	b6
		1422	x
		1423	59
		1424	/Users/murphy/ruby/coderay-0.9/test/functional/word_list.rb
		1425	p
		1426	1
		1427	x
		1428	4
		1429	list
		1430	x
		1431	8
		1432	test_dup
		1433	M
		1434	1
		1435	n
		1436	n
		1437	x
		1438	8
		1439	test_dup
		1440	i
		1441	110
		1442	45
		1443	0
		1444	1
		1445	13
		1446	71
		1447	2
		1448	47
		1449	9
		1450	23
		1451	47
		1452	49
		1453	3
		1454	0
		1455	13
		1456	7
		1457	4
		1458	47
		1459	49
		1460	5
		1461	1
		1462	15
		1463	8
		1464	28
		1465	7
		1466	4
		1467	49
		1468	2
		1469	1
		1470	7
		1471	6
		1472	64
		1473	35
		1474	1
		1475	7
		1476	7
		1477	49
		1478	8
		1479	2
		1480	19
		1481	0
		1482	15
		1483	5
		1484	7
		1485	7
		1486	20
		1487	0
		1488	7
		1489	6
		1490	64
		1491	49
		1492	9
		1493	1
		1494	47
		1495	49
		1496	10
		1497	2
		1498	15
		1499	20
		1500	0
		1501	49
		1502	11
		1503	0
		1504	19
		1505	1
		1506	15
		1507	20
		1508	1
		1509	7
		1510	6
		1511	64
		1512	35
		1513	1
		1514	7
		1515	12
		1516	49
		1517	8
		1518	2
		1519	15
		1520	5
		1521	7
		1522	12
		1523	20
		1524	1
		1525	7
		1526	6
		1527	64
		1528	49
		1529	9
		1530	1
		1531	47
		1532	49
		1533	10
		1534	2
		1535	15
		1536	5
		1537	7
		1538	7
		1539	20
		1540	0
		1541	7
		1542	6
		1543	64
		1544	49
		1545	9
		1546	1
		1547	47
		1548	49
		1549	10
		1550	2
		1551	11
		1552	I
		1553	6
		1554	I
		1555	2
		1556	I
		1557	0
		1558	I
		1559	0
		1560	n
		1561	p
		1562	13
		1563	x
		1564	8
		1565	WordList
		1566	n
		1567	x
		1568	3
		1569	new
		1570	x
		1571	8
		1572	allocate
		1573	x
		1574	5
		1575	ident
		1576	x
		1577	10
		1578	initialize
		1579	s
		1580	6
		1581	foobar
		1582	x
		1583	8
		1584	reserved
		1585	x
		1586	3
		1587	add
		1588	x
		1589	2
		1590	[]
		1591	x
		1592	12
		1593	assert_equal
		1594	x
		1595	3
		1596	dup
		1597	x
		1598	7
		1599	keyword
		1600	p
		1601	15
		1602	I
		1603	0
		1604	I
		1605	46
		1606	I
		1607	0
		1608	I
		1609	47
		1610	I
		1611	29
		1612	I
		1613	48
		1614	I
		1615	39
		1616	I
		1617	49
		1618	I
		1619	41
		1620	I
		1621	4a
		1622	I
		1623	4e
		1624	I
		1625	4b
		1626	I
		1627	5e
		1628	I
		1629	4c
		1630	I
		1631	6e
		1632	x
		1633	59
		1634	/Users/murphy/ruby/coderay-0.9/test/functional/word_list.rb
		1635	p
		1636	2
		1637	x
		1638	4
		1639	list
		1640	x
		1641	5
		1642	list2
		1643	p
		1644	45
		1645	I
		1646	2
		1647	I
		1648	6
		1649	I
		1650	b
		1651	I
		1652	9
		1653	I
		1654	e
		1655	I
		1656	a
		1657	I
		1658	23
		1659	I
		1660	b
		1661	I
		1662	2c
		1663	I
		1664	e
		1665	I
		1666	2f
		1667	I
		1668	f
		1669	I
		1670	3e
		1671	I
		1672	10
		1673	I
		1674	47
		1675	I
		1676	13
		1677	I
		1678	4a
		1679	I
		1680	14
		1681	I
		1682	59
		1683	I
		1684	18
		1685	I
		1686	78
		1687	I
		1688	19
		1689	I
		1690	7d
		1691	I
		1692	18
		1693	I
		1694	80
		1695	I
		1696	1a
		1697	I
		1698	85
		1699	I
		1700	18
		1701	I
		1702	88
		1703	I
		1704	1b
		1705	I
		1706	8d
		1707	I
		1708	18
		1709	I
		1710	94
		1711	I
		1712	1d
		1713	I
		1714	a2
		1715	I
		1716	22
		1717	I
		1718	b0
		1719	I
		1720	28
		1721	I
		1722	be
		1723	I
		1724	2e
		1725	I
		1726	cc
		1727	I
		1728	3a
		1729	I
		1730	da
		1731	I
		1732	46
		1733	I
		1734	e8
		1735	x
		1736	59
		1737	/Users/murphy/ruby/coderay-0.9/test/functional/word_list.rb
		1738	p
		1739	0
		1740	x
		1741	13
		1742	attach_method
		1743	p
		1744	7
		1745	I
		1746	0
		1747	I
		1748	1
		1749	I
		1750	9
		1751	I
		1752	2
		1753	I
		1754	12
		1755	I
		1756	4
		1757	I
		1758	35
		1759	x
		1760	59
		1761	/Users/murphy/ruby/coderay-0.9/test/functional/word_list.rb
		1762	p
		1763	0

config/environment.rb +1 0

             # Be sure to restart your web server when you modify this file.
             # Uncomment below to force Rails into production mode when
             # you don't control web/app server and can't set it the proper way
             # ENV['RAILS_ENV'] ||= 'production'
             # Specifies gem version of Rails to use when vendor/rails is not present
             RAILS_GEM_VERSION = '2.3.5' unless defined? RAILS_GEM_VERSION
             # Bootstrap the Rails environment, frameworks, and default configuration
             require File.join(File.dirname(__FILE__), 'boot')
             # Load Engine plugin if available
             begin
               require File.join(File.dirname(__FILE__), '../vendor/plugins/engines/boot')
             rescue LoadError
               # Not available
             end
             Rails::Initializer.run do |config|
               # Settings in config/environments/* take precedence those specified here
               # Skip frameworks you're not going to use
               # config.frameworks -= [ :action_web_service, :action_mailer ]
               # Add additional load paths for sweepers
               config.load_paths += %W( #{RAILS_ROOT}/app/sweepers )
               # Force all environments to use the same logger level
               # (by default production uses :info, the others :debug)
               # config.log_level = :debug
               # Enable page/fragment caching by setting a file-based store
               # (remember to create the caching directory and make it readable to the application)
               # config.action_controller.cache_store = :file_store, "#{RAILS_ROOT}/tmp/cache"
               # Activate observers that should always be running
               # config.active_record.observers = :cacher, :garbage_collector
               config.active_record.observers = :message_observer, :issue_observer, :journal_observer, :news_observer, :document_observer, :wiki_content_observer
               # Make Active Record use UTC-base instead of local time
               # config.active_record.default_timezone = :utc
               # Use Active Record's schema dumper instead of SQL when creating the test database
               # (enables use of different database adapters for development and test environments)
               # config.active_record.schema_format = :ruby
               # Deliveries are disabled by default. Do NOT modify this section.
               # Define your email configuration in email.yml instead.
               # It will automatically turn deliveries on
               config.action_mailer.perform_deliveries = false
               config.gem 'rubytree', :lib => 'tree'
+              config.gem 'coderay', :version => '~>0.9.7'
               # Load any local configuration that is kept out of source control
               # (e.g. gems, patches).
               if File.exists?(File.join(File.dirname(__FILE__), 'additional_environment.rb'))
                 instance_eval File.read(File.join(File.dirname(__FILE__), 'additional_environment.rb'))
               end
             end

vendor/gems/coderay-0.9.7/LICENSE ~~vendor/plugins/coderay-0.9.2/LICENSE~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/LICENSE to vendor/gems/coderay-0.9.7/LICENSE

vendor/gems/coderay-0.9.7/lib/README ~~vendor/plugins/coderay-0.9.2/lib/README~~ renamed +2 -1

             = CodeRay
             [- Tired of blue'n'gray? Try the original version of this documentation on
             coderay.rubychan.de[http://coderay.rubychan.de/doc/] (use Ctrl+Click to open it in its own frame.) -]
             == About
             CodeRay is a Ruby library for syntax highlighting.
             Syntax highlighting means: You put your code in, and you get it back colored;
             Keywords, strings, floats, comments - all in different colors.
             And with line numbers.
             *Syntax* *Highlighting*...
             * makes code easier to read and maintain
             * lets you detect syntax errors faster
             * helps you to understand the syntax of a language
             * looks nice
             * is what everybody should have on their website
             * solves all your problems and makes the girls run after you
-            Version: 0.9.2
+            Version: 0.9.7
             Author:: murphy (Kornelius Kalnbach)
             Contact:: murphy rubychan de
             Website:: coderay.rubychan.de[http://coderay.rubychan.de]
             License:: GNU LGPL; see LICENSE file in the main directory.
             == Installation
             You need RubyGems[http://rubyforge.org/frs/?group_id=126].
              % gem install coderay
             === Dependencies
             CodeRay needs Ruby 1.8.6 or later. It also runs with Ruby 1.9.1+ and JRuby 1.1+.
             == Example Usage
             (Forgive me, but this is not highlighted.)
              require 'coderay'
              tokens = CodeRay.scan "puts 'Hello, world!'", :ruby
              page = tokens.html :line_numbers => :inline, :wrap => :page
              puts page
             == Documentation
             See CodeRay.
             Please report errors in this documentation to <murphy rubychan de>.
             == Credits
             === Special Thanks to
             * licenser (Heinz N. Gies) for ending my QBasic career, inventing the Coder
               project and the input/output plugin system.
               CodeRay would not exist without him.
             * bovi (Daniel Bovensiepen) for helping me out on various occasions.
             === Thanks to
             * Caleb Clausen for writing RubyLexer (see
               http://rubyforge.org/projects/rubylexer) and lots of very interesting mail
               traffic
             * birkenfeld (Georg Brandl) and mitsuhiku (Arnim Ronacher) for PyKleur, now pygments.
               You guys rock!
             * Jamis Buck for writing Syntax (see http://rubyforge.org/projects/syntax)
               I got some useful ideas from it.
             * Doug Kearns and everyone else who worked on ruby.vim - it not only helped me
               coding CodeRay, but also gave me a wonderful target to reach for the Ruby
               scanner.
             * everyone who uses CodeBB on http://www.rubyforen.de and http://www.python-forum.de
             * iGEL, magichisoka, manveru, WoNáDo and everyone I forgot from rubyforen.de
             * Dethix from ruby-mine.de
             * zickzackw
             * Dookie (who is no longer with us...) and Leonidas from http://www.python-forum.de
             * Andreas Schwarz for finding out that CaseIgnoringWordList was not case
               ignoring! Such things really make you write tests.
             * closure for the first version of the Scheme scanner.
             * Stefan Walk for the first version of the JavaScript and PHP scanners.
             * Josh Goebel for another version of the JavaScript scanner, a SQL and a Diff scanner.
             * Jonathan Younger for pointing out the licence confusion caused by wrong LICENSE file.
             * Jeremy Hinegardner for finding the shebang-on-empty-file bug in FileType.
             * Charles Oliver Nutter and Yehuda Katz for helping me benchmark CodeRay on JRuby.
             * Andreas Neuhaus for pointing out a markup bug in coderay/for_redcloth.
             * 0xf30fc7 for the FileType patch concerning Delphi file extensions.
             * The folks at redmine.org - thank you for using and fixing CodeRay!
             * Keith Pitt for his SQL scanners
             * Rob Aldred for the terminal encoder
             * Trans for pointing out $DEBUG dependencies
             * Flameeyes for finding that Term::ANSIColor was obsolete
+            * Etienne Massip for reporting a serious bug in JavaScript scanner
             * matz and all Ruby gods and gurus
             * The inventors of: the computer, the internet, the true color display, HTML &
               CSS, VIM, Ruby, pizza, microwaves, guitars, scouting, programming, anime,
               manga, coke and green ice tea.
             Where would we be without all those people?
             === Created using
             * Ruby[http://ruby-lang.org/]
             * Chihiro (my Sony VAIO laptop); Henrietta (my old MacBook);
               Triella, born Rico (my new MacBook); as well as
               Seras and Hikari (my PCs)
             * RDE[http://homepage2.nifty.com/sakazuki/rde_e.html],
               VIM[http://vim.org] and TextMate[http://macromates.com]
             * Subversion[http://subversion.tigris.org/]
             * Redmine[http://redmine.org/]
             * Firefox[http://www.mozilla.org/products/firefox/],
               Firebug[http://getfirebug.com/], Safari[http://www.apple.com/safari/], and
               Thunderbird[http://www.mozilla.org/products/thunderbird/]
             * RubyGems[http://docs.rubygems.org/] and Rake[http://rake.rubyforge.org/]
             * TortoiseSVN[http://tortoisesvn.tigris.org/] using Apache via
               XAMPP[http://www.apachefriends.org/en/xampp.html]
             * RDoc (though I'm quite unsatisfied with it)
             * Microsoft Windows (yes, I confess!) and MacOS X
             * GNUWin32, MinGW and some other tools to make the shell under windows a bit
               less useless
             * Term::ANSIColor[http://term-ansicolor.rubyforge.org/]
             * PLEAC[http://pleac.sourceforge.net/] code examples
             === Free
             * As you can see, CodeRay was created under heavy use of *free* software.
             * So CodeRay is also *free*.
             * If you use CodeRay to create software, think about making this software
               *free*, too.
             * Thanks :)

vendor/gems/coderay-0.9.7/lib/coderay.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay.rb~~ renamed +1 -1

             # = CodeRay Library
             #
             # CodeRay is a Ruby library for syntax highlighting.
             #
             # I try to make CodeRay easy to use and intuitive, but at the same time fully featured, complete,
             # fast and efficient.
             #
             # See README.
             #
             # It consists mainly of
             # * the main engine: CodeRay (Scanners::Scanner, Tokens/TokenStream, Encoders::Encoder), PluginHost
             # * the scanners in CodeRay::Scanners
             # * the encoders in CodeRay::Encoders
             #
             # Here's a fancy graphic to light up this gray docu:
             #
             # http://cycnus.de/raindark/coderay/scheme.png
             #
             # == Documentation
             #
             # See CodeRay, Encoders, Scanners, Tokens.
             #
             # == Usage
             #
             # Remember you need RubyGems to use CodeRay, unless you have it in your load path. Run Ruby with
             # -rubygems option if required.
             #
             # === Highlight Ruby code in a string as html
             #
             #   require 'coderay'
             #   print CodeRay.scan('puts "Hello, world!"', :ruby).html
             #
             #   # prints something like this:
             #   puts <span class="s">&quot;Hello, world!&quot;</span>
             #
             #
             # === Highlight C code from a file in a html div
             #
             #   require 'coderay'
             #   print CodeRay.scan(File.read('ruby.h'), :c).div
             #   print CodeRay.scan_file('ruby.h').html.div
             #
             # You can include this div in your page. The used CSS styles can be printed with
             #
             #   % coderay_stylesheet
             #
             # === Highlight without typing too much
             #
             # If you are one of the hasty (or lazy, or extremely curious) people, just run this file:
             #
             #   % ruby -rubygems /path/to/coderay/coderay.rb > example.html
             #
             # and look at the file it created in your browser.
             #
             # = CodeRay Module
             #
             # The CodeRay module provides convenience methods for the engine.
             #
             # * The +lang+ and +format+ arguments select Scanner and Encoder to use. These are
             #   simply lower-case symbols, like <tt>:python</tt> or <tt>:html</tt>.
             # * All methods take an optional hash as last parameter, +options+, that is send to
             #   the Encoder / Scanner.
             # * Input and language are always sorted in this order: +code+, +lang+.
             #   (This is in alphabetical order, if you need a mnemonic ;)
             #
             # You should be able to highlight everything you want just using these methods;
             # so there is no need to dive into CodeRay's deep class hierarchy.
             #
             # The examples in the demo directory demonstrate common cases using this interface.
             #
             # = Basic Access Ways
             #
             # Read this to get a general view what CodeRay provides.
             #
             # == Scanning
             #
             #  Scanning means analysing an input string, splitting it up into Tokens.
             #  Each Token knows about what type it is: string, comment, class name, etc.
             #
             #  Each +lang+ (language) has its own Scanner; for example, <tt>:ruby</tt> code is
             #  handled by CodeRay::Scanners::Ruby.
             #
             # CodeRay.scan:: Scan a string in a given language into Tokens.
             #                This is the most common method to use.
             # CodeRay.scan_file:: Scan a file and guess the language using FileType.
             #
             # The Tokens object you get from these methods can encode itself; see Tokens.
             #
             # == Encoding
             #
             # Encoding means compiling Tokens into an output. This can be colored HTML or
             # LaTeX, a textual statistic or just the number of non-whitespace tokens.
             #
             # Each Encoder provides output in a specific +format+, so you select Encoders via
             # formats like <tt>:html</tt> or <tt>:statistic</tt>.
             #
             # CodeRay.encode:: Scan and encode a string in a given language.
             # CodeRay.encode_tokens:: Encode the given tokens.
             # CodeRay.encode_file:: Scan a file, guess the language using FileType and encode it.
             #
             # == Streaming
             #
             # Streaming saves RAM by running Scanner and Encoder in some sort of
             # pipe mode; see TokenStream.
             #
             # CodeRay.scan_stream:: Scan in stream mode.
             #
             # == All-in-One Encoding
             #
             # CodeRay.encode:: Highlight a string with a given input and output format.
             #
             # == Instanciating
             #
             # You can use an Encoder instance to highlight multiple inputs. This way, the setup
             # for this Encoder must only be done once.
             #
             # CodeRay.encoder:: Create an Encoder instance with format and options.
             # CodeRay.scanner:: Create an Scanner instance for lang, with '' as default code.
             #
             # To make use of CodeRay.scanner, use CodeRay::Scanner::code=.
             #
             # The scanning methods provide more flexibility; we recommend to use these.
             #
             # == Reusing Scanners and Encoders
             #
             # If you want to re-use scanners and encoders (because that is faster), see
             # CodeRay::Duo for the most convenient (and recommended) interface.
             module CodeRay
               $CODERAY_DEBUG ||= false
               # Version: Major.Minor.Teeny[.Revision]
               # Major: 0 for pre-stable, 1 for stable
               # Minor: feature milestone
               # Teeny: development state, 0 for pre-release
               # Revision: Subversion Revision number (generated on rake gem:make)
-              VERSION = '0.9.2'
+              VERSION = '0.9.7'
               require 'coderay/tokens'
               require 'coderay/token_classes'
               require 'coderay/scanner'
               require 'coderay/encoder'
               require 'coderay/duo'
               require 'coderay/style'
               class << self
                 # Scans the given +code+ (a String) with the Scanner for +lang+.
                 #
                 # This is a simple way to use CodeRay. Example:
                 #  require 'coderay'
                 #  page = CodeRay.scan("puts 'Hello, world!'", :ruby).html
                 #
                 # See also demo/demo_simple.
                 def scan code, lang, options = {}, &block
                   scanner = Scanners[lang].new code, options, &block
                   scanner.tokenize
                 end
                 # Scans +filename+ (a path to a code file) with the Scanner for +lang+.
                 #
                 # If +lang+ is :auto or omitted, the CodeRay::FileType module is used to
                 # determine it. If it cannot find out what type it is, it uses
                 # CodeRay::Scanners::Plaintext.
                 #
                 # Calls CodeRay.scan.
                 #
                 # Example:
                 #  require 'coderay'
                 #  page = CodeRay.scan_file('some_c_code.c').html
                 def scan_file filename, lang = :auto, options = {}, &block
                   file = IO.read filename
                   if lang == :auto
                     require 'coderay/helpers/file_type'
                     lang = FileType.fetch filename, :plaintext, true
                   end
                   scan file, lang, options = {}, &block
                 end
                 # Scan the +code+ (a string) with the scanner for +lang+.
                 #
                 # Calls scan.
                 #
                 # See CodeRay.scan.
                 def scan_stream code, lang, options = {}, &block
                   options[:stream] = true
                   scan code, lang, options, &block
                 end
                 # Encode a string in Streaming mode.
                 #
                 # This starts scanning +code+ with the the Scanner for +lang+
                 # while encodes the output with the Encoder for +format+.
                 # +options+ will be passed to the Encoder.
                 #
                 # See CodeRay::Encoder.encode_stream
                 def encode_stream code, lang, format, options = {}
                   encoder(format, options).encode_stream code, lang, options
                 end
                 # Encode a string.
                 #
                 # This scans +code+ with the the Scanner for +lang+ and then
                 # encodes it with the Encoder for +format+.
                 # +options+ will be passed to the Encoder.
                 #
                 # See CodeRay::Encoder.encode
                 def encode code, lang, format, options = {}
                   encoder(format, options).encode code, lang, options
                 end
                 # Highlight a string into a HTML <div>.
                 #
                 # CSS styles use classes, so you have to include a stylesheet
                 # in your output.
                 #
                 # See encode.
                 def highlight code, lang, options = { :css => :class }, format = :div
                   encode code, lang, format, options
                 end
                 # Encode pre-scanned Tokens.
                 # Use this together with CodeRay.scan:
                 #
                 #  require 'coderay'
                 #
                 #  # Highlight a short Ruby code example in a HTML span
                 #  tokens = CodeRay.scan '1 + 2', :ruby
                 #  puts CodeRay.encode_tokens(tokens, :span)
                 #
                 def encode_tokens tokens, format, options = {}
                   encoder(format, options).encode_tokens tokens, options
                 end
                 # Encodes +filename+ (a path to a code file) with the Scanner for +lang+.
                 #
                 # See CodeRay.scan_file.
                 # Notice that the second argument is the output +format+, not the input language.
                 #
                 # Example:
                 #  require 'coderay'
                 #  page = CodeRay.encode_file 'some_c_code.c', :html
                 def encode_file filename, format, options = {}
                   tokens = scan_file filename, :auto, get_scanner_options(options)
                   encode_tokens tokens, format, options
                 end
                 # Highlight a file into a HTML <div>.
                 #
                 # CSS styles use classes, so you have to include a stylesheet
                 # in your output.
                 #
                 # See encode.
                 def highlight_file filename, options = { :css => :class }, format = :div
                   encode_file filename, format, options
                 end
                 # Finds the Encoder class for +format+ and creates an instance, passing
                 # +options+ to it.
                 #
                 # Example:
                 #  require 'coderay'
                 #
                 #  stats = CodeRay.encoder(:statistic)
                 #  stats.encode("puts 17 + 4\n", :ruby)
                 #
                 #  puts '%d out of %d tokens have the kind :integer.' % [
                 #    stats.type_stats[:integer].count,
                 #    stats.real_token_count
                 #  ]
                 #  #-> 2 out of 4 tokens have the kind :integer.
                 def encoder format, options = {}
                   Encoders[format].new options
                 end
                 # Finds the Scanner class for +lang+ and creates an instance, passing
                 # +options+ to it.
                 #
                 # See Scanner.new.
                 def scanner lang, options = {}
                   Scanners[lang].new '', options
                 end
                 # Extract the options for the scanner from the +options+ hash.
                 #
                 # Returns an empty Hash if <tt>:scanner_options</tt> is not set.
                 #
                 # This is used if a method like CodeRay.encode has to provide options
                 # for Encoder _and_ scanner.
                 def get_scanner_options options
                   options.fetch :scanner_options, {}
                 end
               end
               # This Exception is raised when you try to stream with something that is not
               # capable of streaming.
               class NotStreamableError < Exception
                 def initialize obj
                   @obj = obj
                 end
                 def to_s
                   '%s is not Streamable!' % @obj.class
                 end
               end
               # A dummy module that is included by subclasses of CodeRay::Scanner an CodeRay::Encoder
               # to show that they are able to handle streams.
               module Streamable
               end
             end
             # Run a test script.
             if $0 == __FILE__
               $stderr.print 'Press key to print demo.'; gets
               # Just use this file as an example of Ruby code.
               code = File.read(__FILE__)[/module CodeRay.*/m]
               print CodeRay.scan(code, :ruby).html
             end

vendor/gems/coderay-0.9.7/lib/coderay/duo.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/duo.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/duo.rb to vendor/gems/coderay-0.9.7/lib/coderay/duo.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoder.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoder.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoder.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoder.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/_map.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/_map.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/_map.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/_map.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/comment_filter.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/comment_filter.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/comment_filter.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/comment_filter.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/count.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/count.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/count.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/count.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/debug.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/debug.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/debug.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/debug.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/div.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/div.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/div.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/div.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/filter.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/filter.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/filter.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/filter.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/html.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/html.rb~~ renamed +7 -3

             require 'set'
             module CodeRay
             module Encoders
               # = HTML Encoder
               #
               # This is CodeRay's most important highlighter:
               # It provides save, fast XHTML generation and CSS support.
               #
               # == Usage
               #
               #  require 'coderay'
               #  puts CodeRay.scan('Some /code/', :ruby).html  #-> a HTML page
               #  puts CodeRay.scan('Some /code/', :ruby).html(:wrap => :span)
               #  #-> <span class="CodeRay"><span class="co">Some</span> /code/</span>
               #  puts CodeRay.scan('Some /code/', :ruby).span  #-> the same
               #
               #  puts CodeRay.scan('Some code', :ruby).html(
               #    :wrap => nil,
               #    :line_numbers => :inline,
               #    :css => :style
               #  )
               #  #-> <span class="no">1</span>  <span style="color:#036; font-weight:bold;">Some</span> code
               #
               # == Options
               #
               # === :tab_width
               # Convert \t characters to +n+ spaces (a number.)
               # Default: 8
               #
               # === :css
               # How to include the styles; can be :class or :style.
               #
               # Default: :class
               #
               # === :wrap
               # Wrap in :page, :div, :span or nil.
               #
               # You can also use Encoders::Div and Encoders::Span.
               #
               # Default: nil
               #
               # === :title
               #
               # The title of the HTML page (works only when :wrap is set to :page.)
               #
               # Default: 'CodeRay output'
               #
               # === :line_numbers
               # Include line numbers in :table, :inline, :list or nil (no line numbers)
               #
               # Default: nil
               #
               # === :line_number_start
               # Where to start with line number counting.
               #
               # Default: 1
               #
               # === :bold_every
               # Make every +n+-th number appear bold.
               #
               # Default: 10
               #
               # === :highlight_lines
               #
               # Highlights certain line numbers.
               # Can be any Enumerable, typically just an Array or Range, of numbers.
               #
               # Bolding is deactivated when :highlight_lines is set. It only makes sense
               # in combination with :line_numbers.
               #
               # Default: nil
               #
               # === :hint
               # Include some information into the output using the title attribute.
               # Can be :info (show token type on mouse-over), :info_long (with full path)
               # or :debug (via inspect).
               #
               # Default: false
               class HTML < Encoder
                 include Streamable
                 register_for :html
                 FILE_EXTENSION = 'html'
                 DEFAULT_OPTIONS = {
                   :tab_width => 8,
                   :css => :class,
                   :style => :cycnus,
                   :wrap => nil,
                   :title => 'CodeRay output',
                   :line_numbers => nil,
                   :line_number_start => 1,
                   :bold_every => 10,
                   :highlight_lines => nil,
                   :hint => false,
                 }
                 helper :output, :css
                 attr_reader :css
               protected
                 HTML_ESCAPE = {  #:nodoc:
                   '&' => '&amp;',
                   '"' => '&quot;',
                   '>' => '&gt;',
                   '<' => '&lt;',
                 }
                 # This was to prevent illegal HTML.
                 # Strange chars should still be avoided in codes.
                 evil_chars = Array(0x00...0x20) - [?\n, ?\t, ?\s]
                 evil_chars.each { |i| HTML_ESCAPE[i.chr] = ' ' }
                 #ansi_chars = Array(0x7f..0xff)
                 #ansi_chars.each { |i| HTML_ESCAPE[i.chr] = '&#%d;' % i }
                 # \x9 (\t) and \xA (\n) not included
                 #HTML_ESCAPE_PATTERN = /[\t&"><\0-\x8\xB-\x1f\x7f-\xff]/
                 HTML_ESCAPE_PATTERN = /[\t"&><\0-\x8\xB-\x1f]/
                 TOKEN_KIND_TO_INFO = Hash.new { |h, kind|
                   h[kind] =
                     case kind
                     when :pre_constant
                       'Predefined constant'
                     else
                       kind.to_s.gsub(/_/, ' ').gsub(/\b\w/) { $&.capitalize }
                     end
                 }
                 TRANSPARENT_TOKEN_KINDS = [
                   :delimiter, :modifier, :content, :escape, :inline_delimiter,
                 ].to_set
                 # Generate a hint about the given +classes+ in a +hint+ style.
                 #
                 # +hint+ may be :info, :info_long or :debug.
                 def self.token_path_to_hint hint, classes
                   title =
                     case hint
                     when :info
                       TOKEN_KIND_TO_INFO[classes.first]
                     when :info_long
                       classes.reverse.map { |kind| TOKEN_KIND_TO_INFO[kind] }.join('/')
                     when :debug
                       classes.inspect
                     end
                   title ? " title=\"#{title}\"" : ''
                 end
                 def setup options
                   super
                   @HTML_ESCAPE = HTML_ESCAPE.dup
                   @HTML_ESCAPE["\t"] = ' ' * options[:tab_width]
                   @opened = [nil]
                   @css = CSS.new options[:style]
                   hint = options[:hint]
                   if hint and not [:debug, :info, :info_long].include? hint
                     raise ArgumentError, "Unknown value %p for :hint; \
                       expected :info, :debug, false, or nil." % hint
                   end
                   case options[:css]
                   when :class
                     @css_style = Hash.new do |h, k|
                       c = CodeRay::Tokens::ClassOfKind[k.first]
                       if c == :NO_HIGHLIGHT and not hint
                         h[k.dup] = false
                       else
                         title = if hint
                           HTML.token_path_to_hint(hint, k[1..-1] << k.first)
                         else
                           ''
                         end
                         if c == :NO_HIGHLIGHT
                           h[k.dup] = '<span%s>' % [title]
                         else
                           h[k.dup] = '<span%s class="%s">' % [title, c]
                         end
                       end
                     end
                   when :style
                     @css_style = Hash.new do |h, k|
                       if k.is_a? ::Array
                         styles = k.dup
                       else
                         styles = [k]
                       end
                       type = styles.first
                       classes = styles.map { |c| Tokens::ClassOfKind[c] }
                       if classes.first == :NO_HIGHLIGHT and not hint
                         h[k] = false
                       else
                         styles.shift if TRANSPARENT_TOKEN_KINDS.include? styles.first
                         title = HTML.token_path_to_hint hint, styles
                         style = @css[*classes]
                         h[k] =
                           if style
                             '<span%s style="%s">' % [title, style]
                           else
                             false
                           end
                       end
                     end
                   else
                     raise ArgumentError, "Unknown value %p for :css." % options[:css]
                   end
                 end
                 def finish options
                   not_needed = @opened.shift
                   @out << '</span>' * @opened.size
                   unless @opened.empty?
                     warn '%d tokens still open: %p' % [@opened.size, @opened]
                   end
                   @out.extend Output
                   @out.css = @css
                   @out.numerize! options[:line_numbers], options
                   @out.wrap! options[:wrap]
                   @out.apply_title! options[:title]
                   super
                 end
                 def token text, type = :plain
                   case text
                   when nil
                     # raise 'Token with nil as text was given: %p' % [[text, type]]
                   when String
                     if text =~ /#{HTML_ESCAPE_PATTERN}/o
                       text = text.gsub(/#{HTML_ESCAPE_PATTERN}/o) { |m| @HTML_ESCAPE[m] }
                     end
                     @opened[0] = type
                     if text != "\n" && style = @css_style[@opened]
                       @out << style << text << '</span>'
                     else
                       @out << text
                     end
                   # token groups, eg. strings
                   when :open
                     @opened[0] = type
                     @out << (@css_style[@opened] || '<span>')
                     @opened << type
                   when :close
                     if @opened.empty?
                       # nothing to close
                     else
                       if $CODERAY_DEBUG and (@opened.size == 1 or @opened.last != type)
                         raise 'Malformed token stream: Trying to close a token (%p) \
                           that is not open. Open are: %p.' % [type, @opened[1..-1]]
                       end
                       @out << '</span>'
                       @opened.pop
                     end
                   # whole lines to be highlighted, eg. a deleted line in a diff
                   when :begin_line
                     @opened[0] = type
                     if style = @css_style[@opened]
-                      @out << style.sub('<span', '<div')
+                      if style['class="']
+                        @out << style.sub('class="', 'class="line ')
+                      else
+                        @out << style.sub('>', ' class="line">')
+                      end
                     else
-                      @out << '<div>'
+                      @out << '<span class="line">'
                     end
                     @opened << type
                   when :end_line
                     if @opened.empty?
                       # nothing to close
                     else
                       if $CODERAY_DEBUG and (@opened.size == 1 or @opened.last != type)
                         raise 'Malformed token stream: Trying to close a line (%p) \
                           that is not open. Open are: %p.' % [type, @opened[1..-1]]
                       end
-                      @out << '</div>'
+                      @out << '</span>'
                       @opened.pop
                     end
                   else
                     raise 'unknown token kind: %p' % [text]
                   end
                 end
               end
             end
             end

vendor/gems/coderay-0.9.7/lib/coderay/encoders/html/css.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/html/css.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/html/css.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/html/css.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/html/numerization.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/html/numerization.rb~~ renamed +2 -2

             module CodeRay
             module Encoders
               class HTML
                 module Output
                   def numerize *args
                     clone.numerize!(*args)
                   end
             =begin      NUMERIZABLE_WRAPPINGS = {
                     :table => [:div, :page, nil],
                     :inline => :all,
                     :list => [:div, :page, nil]
                   }
                   NUMERIZABLE_WRAPPINGS.default = :all
             =end
                   def numerize! mode = :table, options = {}
                     return self unless mode
                     options = DEFAULT_OPTIONS.merge options
                     start = options[:line_number_start]
                     unless start.is_a? Integer
                       raise ArgumentError, "Invalid value %p for :line_number_start; Integer expected." % start
                     end
                     #allowed_wrappings = NUMERIZABLE_WRAPPINGS[mode]
                     #unless allowed_wrappings == :all or allowed_wrappings.include? options[:wrap]
                     #  raise ArgumentError, "Can't numerize, :wrap must be in %p, but is %p" % [NUMERIZABLE_WRAPPINGS, options[:wrap]]
                     #end
                     bold_every = options[:bold_every]
                     highlight_lines = options[:highlight_lines]
                     bolding =
                       if bold_every == false && highlight_lines == nil
                         proc { |line| line.to_s }
                       elsif highlight_lines.is_a? Enumerable
                         highlight_lines = highlight_lines.to_set
                         proc do |line|
                           if highlight_lines.include? line
                             "<strong class=\"highlighted\">#{line}</strong>"  # highlighted line numbers in bold
                           else
                             line.to_s
                           end
                         end
                       elsif bold_every.is_a? Integer
                         raise ArgumentError, ":bolding can't be 0." if bold_every == 0
                         proc do |line|
                           if line % bold_every == 0
                             "<strong>#{line}</strong>"  # every bold_every-th number in bold
                           else
                             line.to_s
                           end
                         end
                       else
                         raise ArgumentError, 'Invalid value %p for :bolding; false or Integer expected.' % bold_every
                       end
                     case mode
                     when :inline
                       max_width = (start + line_count).to_s.size
                       line_number = start
                       gsub!(/^/) do
                         line_number_text = bolding.call line_number
                         indent = ' ' * (max_width - line_number.to_s.size)  # TODO: Optimize (10^x)
                         res = "<span class=\"no\">#{indent}#{line_number_text}</span> "
                         line_number += 1
                         res
                       end
                     when :table
                       # This is really ugly.
                       # Because even monospace fonts seem to have different heights when bold,
                       # I make the newline bold, both in the code and the line numbers.
                       # FIXME Still not working perfect for Mr. Internet Exploder
                       line_numbers = (start ... start + line_count).to_a.map(&bolding).join("\n")
                       line_numbers << "\n"  # also for Mr. MS Internet Exploder :-/
                       line_numbers.gsub!(/\n/) { "<tt>\n</tt>" }
                       line_numbers_table_tpl = TABLE.apply('LINE_NUMBERS', line_numbers)
-                      gsub!(/<\/div>\n/) { '</div>' }
+                      gsub!("</div>\n", '</div>')
-                      gsub!(/\n/) { "<tt>\n</tt>" }
+                      gsub!("\n", "<tt>\n</tt>")
                       wrap_in! line_numbers_table_tpl
                       @wrapped_in = :div
                     when :list
                       opened_tags = []
                       gsub!(/^.*$\n?/) do |line|
                         line.chomp!
                         open = opened_tags.join
                         line.scan(%r!<(/)?span[^>]*>?!) do |close,|
                           if close
                             opened_tags.pop
                           else
                             opened_tags << $&
                           end
                         end
                         close = '</span>' * opened_tags.size
                         "<li>#{open}#{line}#{close}</li>\n"
                       end
                       chomp!("\n")
                       wrap_in! LIST
                       @wrapped_in = :div
                     else
                       raise ArgumentError, 'Unknown value %p for mode: expected one of %p' %
                         [mode, [:table, :list, :inline]]
                     end
                     self
                   end
                   def line_count
                     line_count = count("\n")
                     position_of_last_newline = rindex(?\n)
                     if position_of_last_newline
                       after_last_newline = self[position_of_last_newline + 1 .. -1]
                       ends_with_newline = after_last_newline[/\A(?:<\/span>)*\z/]
                       line_count += 1 if not ends_with_newline
                     end
                     line_count
                   end
                 end
               end
             end
             end

vendor/gems/coderay-0.9.7/lib/coderay/encoders/html/output.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/html/output.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/html/output.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/html/output.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/json.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/json.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/json.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/json.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/lines_of_code.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/lines_of_code.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/lines_of_code.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/lines_of_code.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/null.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/null.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/null.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/null.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/page.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/page.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/page.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/page.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/span.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/span.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/span.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/span.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/statistic.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/statistic.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/statistic.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/statistic.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/term.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/term.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/term.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/term.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/text.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/text.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/text.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/text.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/token_class_filter.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/token_class_filter.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/token_class_filter.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/token_class_filter.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/xml.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/xml.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/xml.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/xml.rb

vendor/gems/coderay-0.9.7/lib/coderay/encoders/yaml.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/encoders/yaml.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/encoders/yaml.rb to vendor/gems/coderay-0.9.7/lib/coderay/encoders/yaml.rb

vendor/gems/coderay-0.9.7/lib/coderay/for_redcloth.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/for_redcloth.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/for_redcloth.rb to vendor/gems/coderay-0.9.7/lib/coderay/for_redcloth.rb

vendor/gems/coderay-0.9.7/lib/coderay/helpers/file_type.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/helpers/file_type.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/helpers/file_type.rb to vendor/gems/coderay-0.9.7/lib/coderay/helpers/file_type.rb

vendor/gems/coderay-0.9.7/lib/coderay/helpers/gzip_simple.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/helpers/gzip_simple.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/helpers/gzip_simple.rb to vendor/gems/coderay-0.9.7/lib/coderay/helpers/gzip_simple.rb

vendor/gems/coderay-0.9.7/lib/coderay/helpers/plugin.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/helpers/plugin.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/helpers/plugin.rb to vendor/gems/coderay-0.9.7/lib/coderay/helpers/plugin.rb

vendor/gems/coderay-0.9.7/lib/coderay/helpers/word_list.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/helpers/word_list.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/helpers/word_list.rb to vendor/gems/coderay-0.9.7/lib/coderay/helpers/word_list.rb

vendor/gems/coderay-0.9.7/lib/coderay/scanner.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanner.rb~~ renamed +16 -10

             module CodeRay
               require 'coderay/helpers/plugin'
               # = Scanners
               #
               # This module holds the Scanner class and its subclasses.
               # For example, the Ruby scanner is named CodeRay::Scanners::Ruby
               # can be found in coderay/scanners/ruby.
               #
               # Scanner also provides methods and constants for the register
               # mechanism and the [] method that returns the Scanner class
               # belonging to the given lang.
               #
               # See PluginHost.
               module Scanners
                 extend PluginHost
                 plugin_path File.dirname(__FILE__), 'scanners'
                 require 'strscan'
                 # = Scanner
                 #
                 # The base class for all Scanners.
                 #
                 # It is a subclass of Ruby's great +StringScanner+, which
                 # makes it easy to access the scanning methods inside.
                 #
                 # It is also +Enumerable+, so you can use it like an Array of
                 # Tokens:
                 #
                 #   require 'coderay'
                 #
                 #   c_scanner = CodeRay::Scanners[:c].new "if (*p == '{') nest++;"
                 #
                 #   for text, kind in c_scanner
                 #     puts text if kind == :operator
                 #   end
                 #
                 #   # prints: (*==)++;
                 #
                 # OK, this is a very simple example :)
                 # You can also use +map+, +any?+, +find+ and even +sort_by+,
                 # if you want.
                 class Scanner < StringScanner
                   extend Plugin
                   plugin_host Scanners
                   # Raised if a Scanner fails while scanning
                   ScanError = Class.new(Exception)
                   require 'coderay/helpers/word_list'
                   # The default options for all scanner classes.
                   #
                   # Define @default_options for subclasses.
                   DEFAULT_OPTIONS = { :stream => false }
                   KINDS_NOT_LOC = [:comment, :doctype]
                   class << self
                     # Returns if the Scanner can be used in streaming mode.
                     def streamable?
                       is_a? Streamable
                     end
                     def normify code
                       code = code.to_s
-                      if code.respond_to? :force_encoding
+                      if code.respond_to?(:encoding) && (code.encoding.name != 'UTF-8' || !code.valid_encoding?)
-                        debug, $DEBUG = $DEBUG, false
+                        code = code.dup
-                        begin
+                        original_encoding = code.encoding
-                          code.force_encoding 'utf-8'
+                        code.force_encoding 'Windows-1252'
-                          code[/\z/]  # raises an ArgumentError when code contains a non-UTF-8 char
+                        unless code.valid_encoding?
-                        rescue ArgumentError
+                          code.force_encoding original_encoding
-                          code.force_encoding 'binary'
+                          if code.encoding.name == 'UTF-8'
-                        ensure
+                            code.encode! 'UTF-16BE', :invalid => :replace, :undef => :replace, :replace => '?'
-                          $DEBUG = debug
+                          end
+                          code.encode! 'UTF-8', :invalid => :replace, :undef => :replace, :replace => '?'
                         end
                       end
                       code.to_unix
                     end
                     def file_extension extension = nil
                       if extension
                         @file_extension = extension.to_s
                       else
                         @file_extension ||= plugin_id.to_s
                       end
                     end
                   end
             =begin
             ## Excluded for speed reasons; protected seems to make methods slow.
               # Save the StringScanner methods from being called.
               # This would not be useful for highlighting.
               strscan_public_methods =
                 StringScanner.instance_methods -
                 StringScanner.ancestors[1].instance_methods
               protected(*strscan_public_methods)
             =end
                   # Create a new Scanner.
                   #
                   # * +code+ is the input String and is handled by the superclass
                   #   StringScanner.
                   # * +options+ is a Hash with Symbols as keys.
                   #   It is merged with the default options of the class (you can
                   #   overwrite default options here.)
                   # * +block+ is the callback for streamed highlighting.
                   #
                   # If you set :stream to +true+ in the options, the Scanner uses a
                   # TokenStream with the +block+ as callback to handle the tokens.
                   #
                   # Else, a Tokens object is used.
                   def initialize code='', options = {}, &block
                     raise "I am only the basic Scanner class. I can't scan "\
                       "anything. :( Use my subclasses." if self.class == Scanner
                     @options = self.class::DEFAULT_OPTIONS.merge options
                     super Scanner.normify(code)
                     @tokens = options[:tokens]
                     if @options[:stream]
                       warn "warning in CodeRay::Scanner.new: :stream is set, "\
                         "but no block was given" unless block_given?
                       raise NotStreamableError, self unless kind_of? Streamable
                       @tokens ||= TokenStream.new(&block)
                     else
                       warn "warning in CodeRay::Scanner.new: Block given, "\
                         "but :stream is #{@options[:stream]}" if block_given?
                       @tokens ||= Tokens.new
                     end
                     @tokens.scanner = self
                     setup
                   end
                   def reset
                     super
                     reset_instance
                   end
                   def string= code
                     code = Scanner.normify(code)
-                    super code
+                    if defined?(RUBY_DESCRIPTION) && RUBY_DESCRIPTION['rubinius 1.0.1']
+                      reset_state
+                      @string = code
+                    else
+                      super code
+                    end
                     reset_instance
                   end
                   # More mnemonic accessor name for the input string.
                   alias code string
                   alias code= string=
                   # Returns the Plugin ID for this scanner.
                   def lang
                     self.class.plugin_id
                   end
                   # Scans the code and returns all tokens in a Tokens object.
                   def tokenize new_string=nil, options = {}
                     options = @options.merge(options)
                     self.string = new_string if new_string
                     @cached_tokens =
                       if @options[:stream]  # :stream must have been set already
                         reset unless new_string
                         scan_tokens @tokens, options
                         @tokens
                       else
                         scan_tokens @tokens, options
                       end
                   end
                   def tokens
                     @cached_tokens ||= tokenize
                   end
                   # Whether the scanner is in streaming mode.
                   def streaming?
                     !!@options[:stream]
                   end
                   # Traverses the tokens.
                   def each &block
                     raise ArgumentError,
                       'Cannot traverse TokenStream.' if @options[:stream]
                     tokens.each(&block)
                   end
                   include Enumerable
                   # The current line position of the scanner.
                   #
                   # Beware, this is implemented inefficiently. It should be used
                   # for debugging only.
                   def line
                     string[0..pos].count("\n") + 1
                   end
                   def column pos = self.pos
                     return 0 if pos <= 0
                     string = string()
                     if string.respond_to?(:bytesize) && (defined?(@bin_string) || string.bytesize != string.size)
                       @bin_string ||= string.dup.force_encoding('binary')
                       string = @bin_string
                     end
                     pos - (string.rindex(?\n, pos) || 0)
                   end
                   def marshal_dump
                     @options
                   end
                   def marshal_load options
                     @options = options
                   end
                 protected
                   # Can be implemented by subclasses to do some initialization
                   # that has to be done once per instance.
                   #
                   # Use reset for initialization that has to be done once per
                   # scan.
                   def setup
                   end
                   # This is the central method, and commonly the only one a
                   # subclass implements.
                   #
                   # Subclasses must implement this method; it must return +tokens+
                   # and must only use Tokens#<< for storing scanned tokens!
                   def scan_tokens tokens, options
                     raise NotImplementedError,
                       "#{self.class}#scan_tokens not implemented."
                   end
                   def reset_instance
                     @tokens.clear unless @options[:keep_tokens]
                     @cached_tokens = nil
                     @bin_string = nil if defined? @bin_string
                   end
                   # Scanner error with additional status information
                   def raise_inspect msg, tokens, state = 'No state given!', ambit = 30
                     raise ScanError, <<-EOE % [
             ***ERROR in %s: %s (after %d tokens)
             tokens:
             %s
             current line: %d  column: %d  pos: %d
             matched: %p  state: %p
             bol? = %p,  eos? = %p
             surrounding code:
             %p  ~~  %p
             ***ERROR***
                     EOE
                       File.basename(caller[0]),
                       msg,
                       tokens.size,
                       tokens.last(10).map { |t| t.inspect }.join("\n"),
                       line, column, pos,
                       matched, state, bol?, eos?,
                       string[pos - ambit, ambit],
                       string[pos, ambit],
                     ]
                   end
                 end
               end
             end
             class String
               # I love this hack. It seems to silence all dos/unix/mac newline problems.
               def to_unix
                 if index ?\r
                   gsub(/\r\n?/, "\n")
                 else
                   self
                 end
               end
             end

vendor/gems/coderay-0.9.7/lib/coderay/scanners/_map.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/_map.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/scanners/_map.rb to vendor/gems/coderay-0.9.7/lib/coderay/scanners/_map.rb

vendor/gems/coderay-0.9.7/lib/coderay/scanners/c.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/c.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/scanners/c.rb to vendor/gems/coderay-0.9.7/lib/coderay/scanners/c.rb

vendor/gems/coderay-0.9.7/lib/coderay/scanners/cpp.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/cpp.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/scanners/cpp.rb to vendor/gems/coderay-0.9.7/lib/coderay/scanners/cpp.rb

vendor/gems/coderay-0.9.7/lib/coderay/scanners/css.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/css.rb~~ renamed +2 -3

             module CodeRay
             module Scanners
               class CSS < Scanner
                 register_for :css
                 KINDS_NOT_LOC = [
                   :comment,
                   :class, :pseudo_class, :type,
                   :constant, :directive,
                   :key, :value, :operator, :color, :float,
                   :error, :important,
                 ]
                 module RE
-                  NonASCII = /[\x80-\xFF]/
                   Hex = /[0-9a-fA-F]/
                   Unicode = /\\#{Hex}{1,6}(?:\r\n|\s)?/ # differs from standard because it allows uppercase hex too
                   Escape = /#{Unicode}|\\[^\r\n\f0-9a-fA-F]/
-                  NMChar = /[-_a-zA-Z0-9]|#{NonASCII}|#{Escape}/
+                  NMChar = /[-_a-zA-Z0-9]|#{Escape}/
-                  NMStart = /[_a-zA-Z]|#{NonASCII}|#{Escape}/
+                  NMStart = /[_a-zA-Z]|#{Escape}/
                   NL = /\r\n|\r|\n|\f/
                   String1 = /"(?:[^\n\r\f\\"]|\\#{NL}|#{Escape})*"?/  # FIXME: buggy regexp
                   String2 = /'(?:[^\n\r\f\\']|\\#{NL}|#{Escape})*'?/  # FIXME: buggy regexp
                   String = /#{String1}|#{String2}/
                   HexColor = /#(?:#{Hex}{6}|#{Hex}{3})/
                   Color = /#{HexColor}/
                   Num = /-?(?:[0-9]+|[0-9]*\.[0-9]+)/
                   Name = /#{NMChar}+/
                   Ident = /-?#{NMStart}#{NMChar}*/
                   AtKeyword = /@#{Ident}/
                   Percentage = /#{Num}%/
                   reldimensions = %w[em ex px]
                   absdimensions = %w[in cm mm pt pc]
                   Unit = Regexp.union(*(reldimensions + absdimensions))
                   Dimension = /#{Num}#{Unit}/
                   Comment = %r! /\* (?: .*? \*/ | .* ) !mx
                   Function = /(?:url|alpha)\((?:[^)\n\r\f]|\\\))*\)?/
                   Id = /##{Name}/
                   Class = /\.#{Name}/
                   PseudoClass = /:#{Name}/
                   AttributeSelector = /\[[^\]]*\]?/
                 end
                 def scan_tokens tokens, options
                   value_expected = nil
                   states = [:initial]
                   until eos?
                     kind = nil
                     match = nil
                     if scan(/\s+/)
                       kind = :space
                     elsif case states.last
                       when :initial, :media
                         if scan(/(?>#{RE::Ident})(?!\()|\*/ox)
                           kind = :type
                         elsif scan RE::Class
                           kind = :class
                         elsif scan RE::Id
                           kind = :constant
                         elsif scan RE::PseudoClass
                           kind = :pseudo_class
                         elsif match = scan(RE::AttributeSelector)
                           # TODO: Improve highlighting inside of attribute selectors.
                           tokens << [:open, :string]
                           tokens << [match[0,1], :delimiter]
                           tokens << [match[1..-2], :content] if match.size > 2
                           tokens << [match[-1,1], :delimiter] if match[-1] == ?]
                           tokens << [:close, :string]
                           next
                         elsif match = scan(/@media/)
                           kind = :directive
                           states.push :media_before_name
                         end
                       when :block
                         if scan(/(?>#{RE::Ident})(?!\()/ox)
                           if value_expected
                             kind = :value
                           else
                             kind = :key
                           end
                         end
                       when :media_before_name
                         if scan RE::Ident
                           kind = :type
                           states[-1] = :media_after_name
                         end
                       when :media_after_name
                         if scan(/\{/)
                           kind = :operator
                           states[-1] = :media
                         end
                       when :comment
                         if scan(/(?:[^*\s]|\*(?!\/))+/)
                           kind = :comment
                         elsif scan(/\*\//)
                           kind = :comment
                           states.pop
                         elsif scan(/\s+/)
                           kind = :space
                         end
                       else
                         raise_inspect 'Unknown state', tokens
                       end
                     elsif scan(/\/\*/)
                       kind = :comment
                       states.push :comment
                     elsif scan(/\{/)
                       value_expected = false
                       kind = :operator
                       states.push :block
                     elsif scan(/\}/)
                       value_expected = false
                       if states.last == :block || states.last == :media
                         kind = :operator
                         states.pop
                       else
                         kind = :error
                       end
                     elsif match = scan(/#{RE::String}/o)
                       tokens << [:open, :string]
                       tokens << [match[0, 1], :delimiter]
                       tokens << [match[1..-2], :content] if match.size > 2
                       tokens << [match[-1, 1], :delimiter] if match.size >= 2
                       tokens << [:close, :string]
                       next
                     elsif match = scan(/#{RE::Function}/o)
                       tokens << [:open, :string]
                       start = match[/^\w+\(/]
                       tokens << [start, :delimiter]
                       if match[-1] == ?)
                         tokens << [match[start.size..-2], :content]
                         tokens << [')', :delimiter]
                       else
                         tokens << [match[start.size..-1], :content]
                       end
                       tokens << [:close, :string]
                       next
                     elsif scan(/(?: #{RE::Dimension} | #{RE::Percentage} | #{RE::Num} )/ox)
                       kind = :float
                     elsif scan(/#{RE::Color}/o)
                       kind = :color
                     elsif scan(/! *important/)
                       kind = :important
                     elsif scan(/rgb\([^()\n]*\)?/)
                       kind = :color
                     elsif scan(/#{RE::AtKeyword}/o)
                       kind = :directive
                     elsif match = scan(/ [+>:;,.=()\/] /x)
                       if match == ':'
                         value_expected = true
                       elsif match == ';'
                         value_expected = false
                       end
                       kind = :operator
                     else
                       getch
                       kind = :error
                     end
                     match ||= matched
                     if $CODERAY_DEBUG and not kind
                       raise_inspect 'Error token %p in line %d' %
                         [[match, kind], line], tokens
                     end
                     raise_inspect 'Empty token', tokens unless match
                     tokens << [match, kind]
                   end
                   tokens
                 end
               end
             end
             end

vendor/gems/coderay-0.9.7/lib/coderay/scanners/debug.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/debug.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/scanners/debug.rb to vendor/gems/coderay-0.9.7/lib/coderay/scanners/debug.rb

vendor/gems/coderay-0.9.7/lib/coderay/scanners/delphi.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/delphi.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/scanners/delphi.rb to vendor/gems/coderay-0.9.7/lib/coderay/scanners/delphi.rb

vendor/gems/coderay-0.9.7/lib/coderay/scanners/diff.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/diff.rb~~ renamed +11 -6

             module CodeRay
             module Scanners
               class Diff < Scanner
                 register_for :diff
                 title 'diff output'
                 def scan_tokens tokens, options
                   line_kind = nil
                   state = :initial
                   until eos?
                     kind = match = nil
                     if match = scan(/\n/)
                       if line_kind
                         tokens << [:end_line, line_kind]
                         line_kind = nil
                       end
                       tokens << [match, :space]
                       next
                     end
                     case state
                     when :initial
                       if match = scan(/--- |\+\+\+ |=+|_+/)
                         tokens << [:begin_line, line_kind = :head]
                         tokens << [match, :head]
                         next unless match = scan(/.+/)
                         kind = :plain
                       elsif match = scan(/Index: |Property changes on: /)
                         tokens << [:begin_line, line_kind = :head]
                         tokens << [match, :head]
                         next unless match = scan(/.+/)
                         kind = :plain
                       elsif match = scan(/Added: /)
                         tokens << [:begin_line, line_kind = :head]
                         tokens << [match, :head]
                         next unless match = scan(/.+/)
                         kind = :plain
                         state = :added
                       elsif match = scan(/\\ /)
                         tokens << [:begin_line, line_kind = :change]
                         tokens << [match, :change]
                         next unless match = scan(/.+/)
                         kind = :plain
-                      elsif scan(/(@@)((?>[^@\n]*))(@@)/)
+                      elsif match = scan(/@@(?>[^@\n]*)@@/)
-                        tokens << [:begin_line, line_kind = :change]
+                        if check(/\n|$/)
-                        tokens << [self[1], :change]
+                          tokens << [:begin_line, line_kind = :change]
-                        tokens << [self[2], :plain]
+                        else
-                        tokens << [self[3], :change]
+                          tokens << [:open, :change]
+                        end
+                        tokens << [match[0,2], :change]
+                        tokens << [match[2...-2], :plain]
+                        tokens << [match[-2,2], :change]
+                        tokens << [:close, :change] unless line_kind
                         next unless match = scan(/.+/)
                         kind = :plain
                       elsif match = scan(/\+/)
                         tokens << [:begin_line, line_kind = :insert]
                         tokens << [match, :insert]
                         next unless match = scan(/.+/)
                         kind = :plain
                       elsif match = scan(/-/)
                         tokens << [:begin_line, line_kind = :delete]
                         tokens << [match, :delete]
                         next unless match = scan(/.+/)
                         kind = :plain
                       elsif scan(/ .*/)
                         kind = :comment
                       elsif scan(/.+/)
-                        tokens << [:begin_line, line_kind = :head]
+                        tokens << [:begin_line, line_kind = :comment]
                         kind = :plain
                       else
                         raise_inspect 'else case rached'
                       end
                     when :added
                       if match = scan(/   \+/)
                         tokens << [:begin_line, line_kind = :insert]
                         tokens << [match, :insert]
                         next unless match = scan(/.+/)
                         kind = :plain
                       else
                         state = :initial
                         next
                       end
                     end
                     match ||= matched
                     if $CODERAY_DEBUG and not kind
                       raise_inspect 'Error token %p in line %d' %
                         [[match, kind], line], tokens
                     end
                     raise_inspect 'Empty token', tokens unless match
                     tokens << [match, kind]
                   end
                   tokens << [:end_line, line_kind] if line_kind
                   tokens
                 end
               end
             end
             end

vendor/gems/coderay-0.9.7/lib/coderay/scanners/groovy.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/groovy.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/scanners/groovy.rb to vendor/gems/coderay-0.9.7/lib/coderay/scanners/groovy.rb

vendor/gems/coderay-0.9.7/lib/coderay/scanners/html.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/html.rb~~ renamed +1 -1

             module CodeRay
             module Scanners
               # HTML Scanner
               class HTML < Scanner
                 include Streamable
                 register_for :html
                 KINDS_NOT_LOC = [
                   :comment, :doctype, :preprocessor,
                   :tag, :attribute_name, :operator,
                   :attribute_value, :delimiter, :content,
                   :plain, :entity, :error
                 ]
                 ATTR_NAME = /[\w.:-]+/
                 ATTR_VALUE_UNQUOTED = ATTR_NAME
                 TAG_END = /\/?>/
                 HEX = /[0-9a-fA-F]/
                 ENTITY = /
                   &
                   (?:
                     \w+
                   |
                     \#
                     (?:
                       \d+
                     |
                       x#{HEX}+
                     )
                   )
                   ;
                 /ox
                 PLAIN_STRING_CONTENT = {
                   "'" => /[^&'>\n]+/,
                   '"' => /[^&">\n]+/,
                 }
                 def reset
                   super
                   @state = :initial
                 end
               private
                 def setup
                   @state = :initial
                   @plain_string_content = nil
                 end
                 def scan_tokens tokens, options
                   state = @state
                   plain_string_content = @plain_string_content
                   until eos?
                     kind = nil
                     match = nil
                     if scan(/\s+/m)
                       kind = :space
                     else
                       case state
                       when :initial
                         if scan(/<!--.*?-->/m)
                           kind = :comment
                         elsif scan(/<!DOCTYPE.*?>/m)
                           kind = :doctype
                         elsif scan(/<\?xml.*?\?>/m)
                           kind = :preprocessor
                         elsif scan(/<\?.*?\?>|<%.*?%>/m)
                           kind = :comment
                         elsif scan(/<\/[-\w.:]*>/m)
                           kind = :tag
                         elsif match = scan(/<[-\w.:]+>?/m)
                           kind = :tag
                           state = :attribute unless match[-1] == ?>
                         elsif scan(/[^<>&]+/)
                           kind = :plain
                         elsif scan(/#{ENTITY}/ox)
                           kind = :entity
                         elsif scan(/[<>&]/)
                           kind = :error
                         else
                           raise_inspect '[BUG] else-case reached with state %p' % [state], tokens
                         end
                       when :attribute
-                        if scan(/#{TAG_END}/)
+                        if scan(/#{TAG_END}/o)
                           kind = :tag
                           state = :initial
                         elsif scan(/#{ATTR_NAME}/o)
                           kind = :attribute_name
                           state = :attribute_equal
                         else
                           kind = :error
                           getch
                         end
                       when :attribute_equal
                         if scan(/=/)
                           kind = :operator
                           state = :attribute_value
                         elsif scan(/#{ATTR_NAME}/o)
                           kind = :attribute_name
                         elsif scan(/#{TAG_END}/o)
                           kind = :tag
                           state = :initial
                         elsif scan(/./)
                           kind = :error
                           state = :attribute
                         end
                       when :attribute_value
                         if scan(/#{ATTR_VALUE_UNQUOTED}/o)
                           kind = :attribute_value
                           state = :attribute
                         elsif match = scan(/["']/)
                           tokens << [:open, :string]
                           state = :attribute_value_string
                           plain_string_content = PLAIN_STRING_CONTENT[match]
                           kind = :delimiter
                         elsif scan(/#{TAG_END}/o)
                           kind = :tag
                           state = :initial
                         else
                           kind = :error
                           getch
                         end
                       when :attribute_value_string
                         if scan(plain_string_content)
                           kind = :content
                         elsif scan(/['"]/)
                           tokens << [matched, :delimiter]
                           tokens << [:close, :string]
                           state = :attribute
                           next
                         elsif scan(/#{ENTITY}/ox)
                           kind = :entity
                         elsif scan(/&/)
                           kind = :content
                         elsif scan(/[\n>]/)
                           tokens << [:close, :string]
                           kind = :error
                           state = :initial
                         end
                       else
                         raise_inspect 'Unknown state: %p' % [state], tokens
                       end
                     end
                     match ||= matched
                     if $CODERAY_DEBUG and not kind
                       raise_inspect 'Error token %p in line %d' %
                         [[match, kind], line], tokens, state
                     end
                     raise_inspect 'Empty token', tokens unless match
                     tokens << [match, kind]
                   end
                   if options[:keep_state]
                     @state = state
                     @plain_string_content = plain_string_content
                   end
                   tokens
                 end
               end
             end
             end

vendor/gems/coderay-0.9.7/lib/coderay/scanners/java.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/java.rb~~ renamed +1 -1

             module CodeRay
             module Scanners
               class Java < Scanner
                 include Streamable
                 register_for :java
                 helper :builtin_types
                 # http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html
                 KEYWORDS = %w[
                   assert break case catch continue default do else
                   finally for if instanceof import new package
                   return switch throw try typeof while
                   debugger export
                 ]
                 RESERVED = %w[ const goto ]
                 CONSTANTS = %w[ false null true ]
                 MAGIC_VARIABLES = %w[ this super ]
                 TYPES = %w[
                   boolean byte char class double enum float int interface long
                   short void
                 ] << '[]'  # because int[] should be highlighted as a type
                 DIRECTIVES = %w[
                   abstract extends final implements native private protected public
                   static strictfp synchronized throws transient volatile
                 ]
                 IDENT_KIND = WordList.new(:ident).
                   add(KEYWORDS, :keyword).
                   add(RESERVED, :reserved).
                   add(CONSTANTS, :pre_constant).
                   add(MAGIC_VARIABLES, :local_variable).
                   add(TYPES, :type).
                   add(BuiltinTypes::List, :pre_type).
                   add(BuiltinTypes::List.select { |builtin| builtin[/(Error|Exception)$/] }, :exception).
                   add(DIRECTIVES, :directive)
                 ESCAPE = / [bfnrtv\n\\'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} /x
                 UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} | U[a-fA-F0-9]{8} /x
                 STRING_CONTENT_PATTERN = {
                   "'" => /[^\\']+/,
                   '"' => /[^\\"]+/,
                   '/' => /[^\\\/]+/,
                 }
                 IDENT = /[a-zA-Z_][A-Za-z_0-9]*/
                 def scan_tokens tokens, options
                   state = :initial
                   string_delimiter = nil
                   import_clause = class_name_follows = last_token_dot = false
                   until eos?
                     kind = nil
                     match = nil
                     case state
                     when :initial
                       if match = scan(/ \s+ | \\\n /x)
                         tokens << [match, :space]
                         next
                       elsif match = scan(%r! // [^\n\\]* (?: \\. [^\n\\]* )* | /\* (?: .*? \*/ | .* ) !mx)
                         tokens << [match, :comment]
                         next
                       elsif import_clause && scan(/ #{IDENT} (?: \. #{IDENT} )* /ox)
                         kind = :include
                       elsif match = scan(/ #{IDENT} | \[\] /ox)
                         kind = IDENT_KIND[match]
                         if last_token_dot
                           kind = :ident
                         elsif class_name_follows
                           kind = :class
                           class_name_follows = false
                         else
                           import_clause = true if match == 'import'
                           class_name_follows = true if match == 'class' || match == 'interface'
                         end
                       elsif scan(/ \.(?!\d) | [,?:()\[\]}] | -- | \+\+ | && | \|\| | \*\*=? | [-+*\/%^~&|<>=!]=? | <<<?=? | >>>?=? /x)
                         kind = :operator
                       elsif scan(/;/)
                         import_clause = false
                         kind = :operator
                       elsif scan(/\{/)
                         class_name_follows = false
                         kind = :operator
                       elsif check(/[\d.]/)
                         if scan(/0[xX][0-9A-Fa-f]+/)
                           kind = :hex
                         elsif scan(/(?>0[0-7]+)(?![89.eEfF])/)
                           kind = :oct
                         elsif scan(/\d+[fFdD]|\d*\.\d+(?:[eE][+-]?\d+)?[fFdD]?|\d+[eE][+-]?\d+[fFdD]?/)
                           kind = :float
                         elsif scan(/\d+[lL]?/)
                           kind = :integer
                         end
                       elsif match = scan(/["']/)
                         tokens << [:open, :string]
                         state = :string
                         string_delimiter = match
                         kind = :delimiter
                       elsif scan(/ @ #{IDENT} /ox)
                         kind = :annotation
                       else
                         getch
                         kind = :error
                       end
                     when :string
                       if scan(STRING_CONTENT_PATTERN[string_delimiter])
                         kind = :content
                       elsif match = scan(/["'\/]/)
                         tokens << [match, :delimiter]
                         tokens << [:close, state]
                         string_delimiter = nil
                         state = :initial
                         next
                       elsif state == :string && (match = scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox))
                         if string_delimiter == "'" && !(match == "\\\\" || match == "\\'")
                           kind = :content
                         else
                           kind = :char
                         end
                       elsif scan(/\\./m)
                         kind = :content
                       elsif scan(/ \\ | $ /x)
-                        tokens << [:close, :delimiter]
+                        tokens << [:close, state]
                         kind = :error
                         state = :initial
                       else
                         raise_inspect "else case \" reached; %p not handled." % peek(1), tokens
                       end
                     else
                       raise_inspect 'Unknown state', tokens
                     end
                     match ||= matched
                     if $CODERAY_DEBUG and not kind
                       raise_inspect 'Error token %p in line %d' %
                         [[match, kind], line], tokens
                     end
                     raise_inspect 'Empty token', tokens unless match
                     last_token_dot = match == '.'
                     tokens << [match, kind]
                   end
                   if state == :string
                     tokens << [:close, state]
                   end
                   tokens
                 end
               end
             end
             end

vendor/gems/coderay-0.9.7/lib/coderay/scanners/java/builtin_types.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/java/builtin_types.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/scanners/java/builtin_types.rb to vendor/gems/coderay-0.9.7/lib/coderay/scanners/java/builtin_types.rb

vendor/gems/coderay-0.9.7/lib/coderay/scanners/java_script-0.9.6.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/java_script.rb~~ renamed +1 -1

             module CodeRay
             module Scanners
               class JavaScript < Scanner
                 include Streamable
                 register_for :java_script
                 file_extension 'js'
                 # The actual JavaScript keywords.
                 KEYWORDS = %w[
                   break case catch continue default delete do else
                   finally for function if in instanceof new
                   return switch throw try typeof var void while with
                 ]
                 PREDEFINED_CONSTANTS = %w[
                   false null true undefined
                 ]
                 MAGIC_VARIABLES = %w[ this arguments ]  # arguments was introduced in JavaScript 1.4
                 KEYWORDS_EXPECTING_VALUE = WordList.new.add %w[
                   case delete in instanceof new return throw typeof with
                 ]
                 # Reserved for future use.
                 RESERVED_WORDS = %w[
                   abstract boolean byte char class debugger double enum export extends
                   final float goto implements import int interface long native package
                   private protected public short static super synchronized throws transient
                   volatile
                 ]
                 IDENT_KIND = WordList.new(:ident).
                   add(RESERVED_WORDS, :reserved).
                   add(PREDEFINED_CONSTANTS, :pre_constant).
                   add(MAGIC_VARIABLES, :local_variable).
                   add(KEYWORDS, :keyword)
                 ESCAPE = / [bfnrtv\n\\'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} /x
                 UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} | U[a-fA-F0-9]{8} /x
                 REGEXP_ESCAPE =  / [bBdDsSwW] /x
                 STRING_CONTENT_PATTERN = {
                   "'" => /[^\\']+/,
                   '"' => /[^\\"]+/,
                   '/' => /[^\\\/]+/,
                 }
                 KEY_CHECK_PATTERN = {
                   "'" => / [^\\']* (?: \\.? [^\\']* )* '? \s* : /x,
                   '"' => / [^\\"]* (?: \\.? [^\\"]* )* "? \s* : /x,
                 }
                 def scan_tokens tokens, options
                   state = :initial
                   string_delimiter = nil
                   value_expected = true
                   key_expected = false
                   function_expected = false
                   until eos?
                     kind = nil
                     match = nil
                     case state
                     when :initial
                       if match = scan(/ \s+ | \\\n /x)
                         value_expected = true if !value_expected && match.index(?\n)
                         tokens << [match, :space]
                         next
                       elsif scan(%r! // [^\n\\]* (?: \\. [^\n\\]* )* | /\* (?: .*? \*/ | .* ) !mx)
                         value_expected = true
                         kind = :comment
                       elsif check(/\.?\d/)
                         key_expected = value_expected = false
                         if scan(/0[xX][0-9A-Fa-f]+/)
                           kind = :hex
                         elsif scan(/(?>0[0-7]+)(?![89.eEfF])/)
                           kind = :oct
                         elsif scan(/\d+[fF]|\d*\.\d+(?:[eE][+-]?\d+)?[fF]?|\d+[eE][+-]?\d+[fF]?/)
                           kind = :float
                         elsif scan(/\d+/)
                           kind = :integer
                         end
                       elsif value_expected && match = scan(/<([[:alpha:]]\w*) (?: [^\/>]*\/> | .*?<\/\1>)/xim)
                         # FIXME: scan over nested tags
                         xml_scanner.tokenize match
                         value_expected = false
                         next
                       elsif match = scan(/ [-+*=<>?:;,!&^|(\[{~%]+ | \.(?!\d) /x)
                         value_expected = true
                         last_operator = match[-1]
                         key_expected = (last_operator == ?{) || (last_operator == ?,)
                         function_expected = false
                         kind = :operator
                       elsif scan(/ [)\]}]+ /x)
                         function_expected = key_expected = value_expected = false
                         kind = :operator
                       elsif match = scan(/ [$a-zA-Z_][A-Za-z_0-9$]* /x)
                         kind = IDENT_KIND[match]
                         value_expected = (kind == :keyword) && KEYWORDS_EXPECTING_VALUE[match]
                         # TODO: labels
                         if kind == :ident
                           if match.index(?$)  # $ allowed inside an identifier
                             kind = :predefined
                           elsif function_expected
                             kind = :function
                           elsif check(/\s*[=:]\s*function\b/)
                             kind = :function
                           elsif key_expected && check(/\s*:/)
                             kind = :key
                           end
                         end
                         function_expected = (kind == :keyword) && (match == 'function')
                         key_expected = false
                       elsif match = scan(/["']/)
                         if key_expected && check(KEY_CHECK_PATTERN[match])
                           state = :key
                         else
                           state = :string
                         end
                         tokens << [:open, state]
                         string_delimiter = match
                         kind = :delimiter
                       elsif value_expected && (match = scan(/\/(?=\S)/))
                         tokens << [:open, :regexp]
                         state = :regexp
                         string_delimiter = '/'
                         kind = :delimiter
                       elsif scan(/ \/ /x)
                         value_expected = true
                         key_expected = false
                         kind = :operator
                       else
                         getch
                         kind = :error
                       end
                     when :string, :regexp, :key
                       if scan(STRING_CONTENT_PATTERN[string_delimiter])
                         kind = :content
                       elsif match = scan(/["'\/]/)
                         tokens << [match, :delimiter]
                         if state == :regexp
                           modifiers = scan(/[gim]+/)
                           tokens << [modifiers, :modifier] if modifiers && !modifiers.empty?
                         end
                         tokens << [:close, state]
                         string_delimiter = nil
                         key_expected = value_expected = false
                         state = :initial
                         next
                       elsif state != :regexp && (match = scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox))
                         if string_delimiter == "'" && !(match == "\\\\" || match == "\\'")
                           kind = :content
                         else
                           kind = :char
                         end
                       elsif state == :regexp && scan(/ \\ (?: #{ESCAPE} | #{REGEXP_ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
                         kind = :char
                       elsif scan(/\\./m)
                         kind = :content
                       elsif scan(/ \\ | $ /x)
                         tokens << [:close, state]
                         kind = :error
                         key_expected = value_expected = false
                         state = :initial
                       else
                         raise_inspect "else case \" reached; %p not handled." % peek(1), tokens
                       end
                     else
                       raise_inspect 'Unknown state', tokens
                     end
                     match ||= matched
                     if $CODERAY_DEBUG and not kind
                       raise_inspect 'Error token %p in line %d' %
                         [[match, kind], line], tokens
                     end
                     raise_inspect 'Empty token', tokens unless match
                     tokens << [match, kind]
                   end
                   if [:string, :regexp].include? state
                     tokens << [:close, state]
                   end
                   tokens
                 end
               protected
                 def reset_instance
                   super
                   @xml_scanner.reset if defined? @xml_scanner
                 end
                 def xml_scanner
-                  @xml_scanner ||= CodeRay.scanner :xml, :tokens => @tokens, :keep_tokens => true, :keep_state => true
+                  @xml_scanner ||= CodeRay.scanner :xml, :tokens => @tokens, :keep_tokens => true, :keep_state => false
                 end
               end
             end
             end

vendor/gems/coderay-0.9.7/lib/coderay/scanners/json.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/json.rb~~ renamed +2 -6

             module CodeRay
             module Scanners
               class JSON < Scanner
                 include Streamable
                 register_for :json
                 file_extension 'json'
                 KINDS_NOT_LOC = [
                   :float, :char, :content, :delimiter,
                   :error, :integer, :operator, :value,
                 ]
-                CONSTANTS = %w( true false null )
-                IDENT_KIND = WordList.new(:key).add(CONSTANTS, :value)
                 ESCAPE = / [bfnrt\\"\/] /x
                 UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} /x
                 def scan_tokens tokens, options
                   state = :initial
                   stack = []
-                  string_delimiter = nil
                   key_expected = false
                   until eos?
                     kind = nil
                     match = nil
                     case state
                     when :initial
                       if match = scan(/ \s+ | \\\n /x)
                         tokens << [match, :space]
                         next
                       elsif match = scan(/ [:,\[{\]}] /x)
                         kind = :operator
                         case match
                         when '{' then stack << :object; key_expected = true
                         when '[' then stack << :array
                         when ':' then key_expected = false
                         when ',' then key_expected = true if stack.last == :object
                         when '}', ']' then stack.pop  # no error recovery, but works for valid JSON
                         end
                       elsif match = scan(/ true | false | null /x)
-                        kind = IDENT_KIND[match]
+                        kind = :value
                       elsif match = scan(/-?(?:0|[1-9]\d*)/)
                         kind = :integer
                         if scan(/\.\d+(?:[eE][-+]?\d+)?|[eE][-+]?\d+/)
                           match << matched
                           kind = :float
                         end
                       elsif match = scan(/"/)
                         state = key_expected ? :key : :string
                         tokens << [:open, state]
                         kind = :delimiter
                       else
                         getch
                         kind = :error
                       end
                     when :string, :key
                       if scan(/[^\\"]+/)
                         kind = :content
                       elsif scan(/"/)
                         tokens << ['"', :delimiter]
                         tokens << [:close, state]
                         state = :initial
                         next
                       elsif scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
                         kind = :char
                       elsif scan(/\\./m)
                         kind = :content
                       elsif scan(/ \\ | $ /x)
-                        tokens << [:close, :delimiter]
+                        tokens << [:close, state]
                         kind = :error
                         state = :initial
                       else
                         raise_inspect "else case \" reached; %p not handled." % peek(1), tokens
                       end
                     else
                       raise_inspect 'Unknown state', tokens
                     end
                     match ||= matched
                     if $CODERAY_DEBUG and not kind
                       raise_inspect 'Error token %p in line %d' %
                         [[match, kind], line], tokens
                     end
                     raise_inspect 'Empty token', tokens unless match
                     tokens << [match, kind]
                   end
                   if [:string, :key].include? state
                     tokens << [:close, state]
                   end
                   tokens
                 end
               end
             end
             end

vendor/gems/coderay-0.9.7/lib/coderay/scanners/nitro_xhtml.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/nitro_xhtml.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/scanners/nitro_xhtml.rb to vendor/gems/coderay-0.9.7/lib/coderay/scanners/nitro_xhtml.rb

vendor/gems/coderay-0.9.7/lib/coderay/scanners/php.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/php.rb~~ renamed +6 0

             module CodeRay
             module Scanners
               load :html
               # Original by Stefan Walk.
               class PHP < Scanner
                 register_for :php
                 file_extension 'php'
                 KINDS_NOT_LOC = HTML::KINDS_NOT_LOC
                 def setup
                   @html_scanner = CodeRay.scanner :html, :tokens => @tokens, :keep_tokens => true, :keep_state => true
                 end
                 def reset_instance
                   super
                   @html_scanner.reset
                 end
                 module Words
                   # according to http://www.php.net/manual/en/reserved.keywords.php
                   KEYWORDS = %w[
                     abstract and array as break case catch class clone const continue declare default do else elseif
                     enddeclare endfor endforeach endif endswitch endwhile extends final for foreach function global
                     goto if implements interface instanceof namespace new or private protected public static switch
                     throw try use var while xor
                     cfunction old_function
                   ]
                   TYPES = %w[ int integer float double bool boolean string array object resource ]
                   LANGUAGE_CONSTRUCTS = %w[
                     die echo empty exit eval include include_once isset list
                     require require_once return print unset
                   ]
                   CLASSES = %w[ Directory stdClass __PHP_Incomplete_Class exception php_user_filter Closure ]
                   # according to http://php.net/quickref.php on 2009-04-21;
                   # all functions with _ excluded (module functions) and selected additional functions
                   BUILTIN_FUNCTIONS = %w[
                     abs acos acosh addcslashes addslashes aggregate array arsort ascii2ebcdic asin asinh asort assert atan atan2
                     atanh basename bcadd bccomp bcdiv bcmod bcmul bcpow bcpowmod bcscale bcsqrt bcsub bin2hex bindec
                     bindtextdomain bzclose bzcompress bzdecompress bzerrno bzerror bzerrstr bzflush bzopen bzread bzwrite
                     calculhmac ceil chdir checkdate checkdnsrr chgrp chmod chop chown chr chroot clearstatcache closedir closelog
                     compact constant copy cos cosh count crc32 crypt current date dcgettext dcngettext deaggregate decbin dechex
                     decoct define defined deg2rad delete dgettext die dirname diskfreespace dl dngettext doubleval each
                     ebcdic2ascii echo empty end ereg eregi escapeshellarg escapeshellcmd eval exec exit exp explode expm1 extract
                     fclose feof fflush fgetc fgetcsv fgets fgetss file fileatime filectime filegroup fileinode filemtime fileowner
                     fileperms filepro filesize filetype floatval flock floor flush fmod fnmatch fopen fpassthru fprintf fputcsv
                     fputs fread frenchtojd fscanf fseek fsockopen fstat ftell ftok ftruncate fwrite getallheaders getcwd getdate
                     getenv gethostbyaddr gethostbyname gethostbynamel getimagesize getlastmod getmxrr getmygid getmyinode getmypid
                     getmyuid getopt getprotobyname getprotobynumber getrandmax getrusage getservbyname getservbyport gettext
                     gettimeofday gettype glob gmdate gmmktime gmstrftime gregoriantojd gzclose gzcompress gzdecode gzdeflate
                     gzencode gzeof gzfile gzgetc gzgets gzgetss gzinflate gzopen gzpassthru gzputs gzread gzrewind gzseek gztell
                     gzuncompress gzwrite hash header hebrev hebrevc hexdec htmlentities htmlspecialchars hypot iconv idate
                     implode include intval ip2long iptcembed iptcparse isset
                     jddayofweek jdmonthname jdtofrench jdtogregorian jdtojewish jdtojulian jdtounix jewishtojd join jpeg2wbmp
                     juliantojd key krsort ksort lcfirst lchgrp lchown levenshtein link linkinfo list localeconv localtime log
                     log10 log1p long2ip lstat ltrim mail main max md5 metaphone mhash microtime min mkdir mktime msql natcasesort
                     natsort next ngettext nl2br nthmac octdec opendir openlog
                     ord overload pack passthru pathinfo pclose pfsockopen phpcredits phpinfo phpversion pi png2wbmp popen pos pow
                     prev print printf putenv quotemeta rad2deg rand range rawurldecode rawurlencode readdir readfile readgzfile
                     readline readlink realpath recode rename require reset rewind rewinddir rmdir round rsort rtrim scandir
                     serialize setcookie setlocale setrawcookie settype sha1 shuffle signeurlpaiement sin sinh sizeof sleep snmpget
                     snmpgetnext snmprealwalk snmpset snmpwalk snmpwalkoid sort soundex split spliti sprintf sqrt srand sscanf stat
                     strcasecmp strchr strcmp strcoll strcspn strftime stripcslashes stripos stripslashes stristr strlen
                     strnatcasecmp strnatcmp strncasecmp strncmp strpbrk strpos strptime strrchr strrev strripos strrpos strspn
                     strstr strtok strtolower strtotime strtoupper strtr strval substr symlink syslog system tan tanh tempnam
                     textdomain time tmpfile touch trim uasort ucfirst ucwords uksort umask uniqid unixtojd unlink unpack
                     unserialize unset urldecode urlencode usleep usort vfprintf virtual vprintf vsprintf wordwrap
                     array_change_key_case array_chunk array_combine array_count_values array_diff array_diff_assoc
                     array_diff_key array_diff_uassoc array_diff_ukey array_fill array_fill_keys array_filter array_flip
                     array_intersect array_intersect_assoc array_intersect_key array_intersect_uassoc array_intersect_ukey
                     array_key_exists array_keys array_map array_merge array_merge_recursive array_multisort array_pad
                     array_pop array_product array_push array_rand array_reduce array_reverse array_search array_shift
                     array_slice array_splice array_sum array_udiff array_udiff_assoc array_udiff_uassoc array_uintersect
                     array_uintersect_assoc array_uintersect_uassoc array_unique array_unshift array_values array_walk
                     array_walk_recursive
                     assert_options base_convert base64_decode base64_encode
                     chunk_split class_exists class_implements class_parents
                     count_chars debug_backtrace debug_print_backtrace debug_zval_dump
                     error_get_last error_log error_reporting extension_loaded
                     file_exists file_get_contents file_put_contents load_file
                     func_get_arg func_get_args func_num_args function_exists
                     get_browser get_called_class get_cfg_var get_class get_class_methods get_class_vars
                     get_current_user get_declared_classes get_declared_interfaces get_defined_constants
                     get_defined_functions get_defined_vars get_extension_funcs get_headers get_html_translation_table
                     get_include_path get_included_files get_loaded_extensions get_magic_quotes_gpc get_magic_quotes_runtime
                     get_meta_tags get_object_vars get_parent_class get_required_filesget_resource_type
                     gc_collect_cycles gc_disable gc_enable gc_enabled
                     halt_compiler headers_list headers_sent highlight_file highlight_string
                     html_entity_decode htmlspecialchars_decode
                     in_array include_once inclued_get_data
                     is_a is_array is_binary is_bool is_buffer is_callable is_dir is_double is_executable is_file is_finite
                     is_float is_infinite is_int is_integer is_link is_long is_nan is_null is_numeric is_object is_readable
                     is_real is_resource is_scalar is_soap_fault is_string is_subclass_of is_unicode is_uploaded_file
                     is_writable is_writeable
                     locale_get_default locale_set_default
                     number_format override_function parse_str parse_url
                     php_check_syntax php_ini_loaded_file php_ini_scanned_files php_logo_guid php_sapi_name
                     php_strip_whitespace php_uname
                     preg_filter preg_grep preg_last_error preg_match preg_match_all preg_quote preg_replace
                     preg_replace_callback preg_split print_r
                     require_once register_shutdown_function register_tick_function
                     set_error_handler set_exception_handler set_file_buffer set_include_path
                     set_magic_quotes_runtime set_time_limit shell_exec
                     str_getcsv str_ireplace str_pad str_repeat str_replace str_rot13 str_shuffle str_split str_word_count
                     strip_tags substr_compare substr_count substr_replace
                     time_nanosleep time_sleep_until
                     token_get_all token_name trigger_error
                     unregister_tick_function use_soap_error_handler user_error
                     utf8_decode utf8_encode var_dump var_export
                     version_compare
                     zend_logo_guid zend_thread_id zend_version
                     create_function call_user_func_array
                     posix_access posix_ctermid posix_get_last_error posix_getcwd posix_getegid
                     posix_geteuid posix_getgid posix_getgrgid posix_getgrnam posix_getgroups
                     posix_getlogin posix_getpgid posix_getpgrp posix_getpid posix_getppid
                     posix_getpwnam posix_getpwuid posix_getrlimit posix_getsid posix_getuid
                     posix_initgroups posix_isatty posix_kill posix_mkfifo posix_mknod
                     posix_setegid posix_seteuid posix_setgid posix_setpgid posix_setsid
                     posix_setuid posix_strerror posix_times posix_ttyname posix_uname
                     pcntl_alarm pcntl_exec pcntl_fork pcntl_getpriority pcntl_setpriority
                     pcntl_signal pcntl_signal_dispatch pcntl_sigprocmask pcntl_sigtimedwait
                     pcntl_sigwaitinfo pcntl_wait pcntl_waitpid pcntl_wexitstatus pcntl_wifexited
                     pcntl_wifsignaled pcntl_wifstopped pcntl_wstopsig pcntl_wtermsig
                   ]
                   # TODO: more built-in PHP functions?
                   EXCEPTIONS = %w[
                     E_ERROR E_WARNING E_PARSE E_NOTICE E_CORE_ERROR E_CORE_WARNING E_COMPILE_ERROR E_COMPILE_WARNING
                     E_USER_ERROR E_USER_WARNING E_USER_NOTICE E_DEPRECATED E_USER_DEPRECATED E_ALL E_STRICT
                   ]
                   CONSTANTS = %w[
                     null true false self parent
                     __LINE__ __DIR__ __FILE__ __LINE__
                     __CLASS__ __NAMESPACE__ __METHOD__ __FUNCTION__
                     PHP_VERSION PHP_MAJOR_VERSION PHP_MINOR_VERSION PHP_RELEASE_VERSION PHP_VERSION_ID PHP_EXTRA_VERSION PHP_ZTS
                     PHP_DEBUG PHP_MAXPATHLEN PHP_OS PHP_SAPI PHP_EOL PHP_INT_MAX PHP_INT_SIZE DEFAULT_INCLUDE_PATH
                     PEAR_INSTALL_DIR PEAR_EXTENSION_DIR PHP_EXTENSION_DIR PHP_PREFIX PHP_BINDIR PHP_LIBDIR PHP_DATADIR
                     PHP_SYSCONFDIR PHP_LOCALSTATEDIR PHP_CONFIG_FILE_PATH PHP_CONFIG_FILE_SCAN_DIR PHP_SHLIB_SUFFIX
                     PHP_OUTPUT_HANDLER_START PHP_OUTPUT_HANDLER_CONT PHP_OUTPUT_HANDLER_END
                     __COMPILER_HALT_OFFSET__
                     EXTR_OVERWRITE EXTR_SKIP EXTR_PREFIX_SAME EXTR_PREFIX_ALL EXTR_PREFIX_INVALID EXTR_PREFIX_IF_EXISTS
                     EXTR_IF_EXISTS SORT_ASC SORT_DESC SORT_REGULAR SORT_NUMERIC SORT_STRING CASE_LOWER CASE_UPPER COUNT_NORMAL
                     COUNT_RECURSIVE ASSERT_ACTIVE ASSERT_CALLBACK ASSERT_BAIL ASSERT_WARNING ASSERT_QUIET_EVAL CONNECTION_ABORTED
                     CONNECTION_NORMAL CONNECTION_TIMEOUT INI_USER INI_PERDIR INI_SYSTEM INI_ALL M_E M_LOG2E M_LOG10E M_LN2 M_LN10
                     M_PI M_PI_2 M_PI_4 M_1_PI M_2_PI M_2_SQRTPI M_SQRT2 M_SQRT1_2 CRYPT_SALT_LENGTH CRYPT_STD_DES CRYPT_EXT_DES
                     CRYPT_MD5 CRYPT_BLOWFISH DIRECTORY_SEPARATOR SEEK_SET SEEK_CUR SEEK_END LOCK_SH LOCK_EX LOCK_UN LOCK_NB
                     HTML_SPECIALCHARS HTML_ENTITIES ENT_COMPAT ENT_QUOTES ENT_NOQUOTES INFO_GENERAL INFO_CREDITS
                     INFO_CONFIGURATION INFO_MODULES INFO_ENVIRONMENT INFO_VARIABLES INFO_LICENSE INFO_ALL CREDITS_GROUP
                     CREDITS_GENERAL CREDITS_SAPI CREDITS_MODULES CREDITS_DOCS CREDITS_FULLPAGE CREDITS_QA CREDITS_ALL STR_PAD_LEFT
                     STR_PAD_RIGHT STR_PAD_BOTH PATHINFO_DIRNAME PATHINFO_BASENAME PATHINFO_EXTENSION PATH_SEPARATOR CHAR_MAX
                     LC_CTYPE LC_NUMERIC LC_TIME LC_COLLATE LC_MONETARY LC_ALL LC_MESSAGES ABDAY_1 ABDAY_2 ABDAY_3 ABDAY_4 ABDAY_5
                     ABDAY_6 ABDAY_7 DAY_1 DAY_2 DAY_3 DAY_4 DAY_5 DAY_6 DAY_7 ABMON_1 ABMON_2 ABMON_3 ABMON_4 ABMON_5 ABMON_6
                     ABMON_7 ABMON_8 ABMON_9 ABMON_10 ABMON_11 ABMON_12 MON_1 MON_2 MON_3 MON_4 MON_5 MON_6 MON_7 MON_8 MON_9
                     MON_10 MON_11 MON_12 AM_STR PM_STR D_T_FMT D_FMT T_FMT T_FMT_AMPM ERA ERA_YEAR ERA_D_T_FMT ERA_D_FMT ERA_T_FMT
                     ALT_DIGITS INT_CURR_SYMBOL CURRENCY_SYMBOL CRNCYSTR MON_DECIMAL_POINT MON_THOUSANDS_SEP MON_GROUPING
                     POSITIVE_SIGN NEGATIVE_SIGN INT_FRAC_DIGITS FRAC_DIGITS P_CS_PRECEDES P_SEP_BY_SPACE N_CS_PRECEDES
                     N_SEP_BY_SPACE P_SIGN_POSN N_SIGN_POSN DECIMAL_POINT RADIXCHAR THOUSANDS_SEP THOUSEP GROUPING YESEXPR NOEXPR
                     YESSTR NOSTR CODESET LOG_EMERG LOG_ALERT LOG_CRIT LOG_ERR LOG_WARNING LOG_NOTICE LOG_INFO LOG_DEBUG LOG_KERN
                     LOG_USER LOG_MAIL LOG_DAEMON LOG_AUTH LOG_SYSLOG LOG_LPR LOG_NEWS LOG_UUCP LOG_CRON LOG_AUTHPRIV LOG_LOCAL0
                     LOG_LOCAL1 LOG_LOCAL2 LOG_LOCAL3 LOG_LOCAL4 LOG_LOCAL5 LOG_LOCAL6 LOG_LOCAL7 LOG_PID LOG_CONS LOG_ODELAY
                     LOG_NDELAY LOG_NOWAIT LOG_PERROR
                   ]
                   PREDEFINED = %w[
                     $GLOBALS $_SERVER $_GET $_POST $_FILES $_REQUEST $_SESSION $_ENV
                     $_COOKIE $php_errormsg $HTTP_RAW_POST_DATA $http_response_header
                     $argc $argv
                   ]
                   IDENT_KIND = CaseIgnoringWordList.new(:ident).
                     add(KEYWORDS, :reserved).
                     add(TYPES, :pre_type).
                     add(LANGUAGE_CONSTRUCTS, :reserved).
                     add(BUILTIN_FUNCTIONS, :predefined).
                     add(CLASSES, :pre_constant).
                     add(EXCEPTIONS, :exception).
                     add(CONSTANTS, :pre_constant)
                   VARIABLE_KIND = WordList.new(:local_variable).
                     add(PREDEFINED, :predefined)
                 end
                 module RE
                   PHP_START = /
                     <script\s+[^>]*?language\s*=\s*"php"[^>]*?> |
                     <script\s+[^>]*?language\s*=\s*'php'[^>]*?> |
                     <\?php\d? |
                     <\?(?!xml)
                   /xi
                   PHP_END = %r!
                     </script> |
                     \?>
                   !xi
                   HTML_INDICATOR = /<!DOCTYPE html|<(?:html|body|div|p)[> ]/i
                   IDENTIFIER = /[a-z_\x7f-\xFF][a-z0-9_\x7f-\xFF]*/i
                   VARIABLE = /\$#{IDENTIFIER}/
                   OPERATOR = /
                     \.(?!\d)=? |      # dot that is not decimal point, string concatenation
                     && | \|\| |       # logic
                     :: | -> | => |    # scope, member, dictionary
                     \\(?!\n) |        # namespace
                     \+\+ | -- |       # increment, decrement
                     [,;?:()\[\]{}] |  # simple delimiters
                     [-+*\/%&|^]=? |   # ordinary math, binary logic, assignment shortcuts
                     [~$] |            # whatever
                     =& |              # reference assignment
                     [=!]=?=? | <> |   # comparison and assignment
                     <<=? | >>=? | [<>]=?  # comparison and shift
                   /x
                 end
                 def scan_tokens tokens, options
+                  if string.respond_to?(:encoding)
+                    unless string.encoding == Encoding::ASCII_8BIT
+                      self.string = string.encode Encoding::ASCII_8BIT,
+                        :invalid => :replace, :undef => :replace, :replace => '?'
+                    end
+                  end
                   if check(RE::PHP_START) ||  # starts with <?
                    (match?(/\s*<\S/) && exist?(RE::PHP_START)) || # starts with tag and contains <?
                    exist?(RE::HTML_INDICATOR) ||
                    check(/.{1,100}#{RE::PHP_START}/om)  # PHP start after max 100 chars
                     # is HTML with embedded PHP, so start with HTML
                     states = [:initial]
                   else
                     # is just PHP, so start with PHP surrounded by HTML
                     states = [:initial, :php]
                   end
                   label_expected = true
                   case_expected = false
                   heredoc_delimiter = nil
                   delimiter = nil
                   modifier = nil
                   until eos?
                     match = nil
                     kind = nil
                     case states.last
                     when :initial  # HTML
                       if scan RE::PHP_START
                         kind = :inline_delimiter
                         label_expected = true
                         states << :php
                       else
                         match = scan_until(/(?=#{RE::PHP_START})/o) || scan_until(/\z/)
                         @html_scanner.tokenize match unless match.empty?
                         next
                       end
                     when :php
                       if match = scan(/\s+/)
                         tokens << [match, :space]
                         next
                       elsif scan(%r! (?m: \/\* (?: .*? \*\/ | .* ) ) | (?://|\#) .*? (?=#{RE::PHP_END}|$) !xo)
                         kind = :comment
                       elsif match = scan(RE::IDENTIFIER)
                         kind = Words::IDENT_KIND[match]
                         if kind == :ident && label_expected && check(/:(?!:)/)
                           kind = :label
                           label_expected = true
                         else
                           label_expected = false
                           if kind == :ident && match =~ /^[A-Z]/
                             kind = :constant
                           elsif kind == :reserved
                             case match
                             when 'class'
                               states << :class_expected
                             when 'function'
                               states << :function_expected
                             when 'case', 'default'
                               case_expected = true
                             end
                           elsif match == 'b' && check(/['"]/)  # binary string literal
                             modifier = match
                             next
                           end
                         end
                       elsif scan(/(?:\d+\.\d*|\d*\.\d+)(?:e[-+]?\d+)?|\d+e[-+]?\d+/i)
                         label_expected = false
                         kind = :float
                       elsif scan(/0x[0-9a-fA-F]+/)
                         label_expected = false
                         kind = :hex
                       elsif scan(/\d+/)
                         label_expected = false
                         kind = :integer
                       elsif scan(/'/)
                         tokens << [:open, :string]
                         if modifier
                           tokens << [modifier, :modifier]
                           modifier = nil
                         end
                         kind = :delimiter
                         states.push :sqstring
                       elsif match = scan(/["`]/)
                         tokens << [:open, :string]
                         if modifier
                           tokens << [modifier, :modifier]
                           modifier = nil
                         end
                         delimiter = match
                         kind = :delimiter
                         states.push :dqstring
                       elsif match = scan(RE::VARIABLE)
                         label_expected = false
                         kind = Words::VARIABLE_KIND[match]
                       elsif scan(/\{/)
                         kind = :operator
                         label_expected = true
                         states.push :php
                       elsif scan(/\}/)
                         if states.size == 1
                           kind = :error
                         else
                           states.pop
                           if states.last.is_a?(::Array)
                             delimiter = states.last[1]
                             states[-1] = states.last[0]
                             tokens << [matched, :delimiter]
                             tokens << [:close, :inline]
                             next
                           else
                             kind = :operator
                             label_expected = true
                           end
                         end
                       elsif scan(/@/)
                         label_expected = false
                         kind = :exception
                       elsif scan RE::PHP_END
                         kind = :inline_delimiter
                         states = [:initial]
                       elsif match = scan(/<<<(?:(#{RE::IDENTIFIER})|"(#{RE::IDENTIFIER})"|'(#{RE::IDENTIFIER})')/o)
                         tokens << [:open, :string]
                         warn 'heredoc in heredoc?' if heredoc_delimiter
                         heredoc_delimiter = Regexp.escape(self[1] || self[2] || self[3])
                         kind = :delimiter
                         states.push self[3] ? :sqstring : :dqstring
                         heredoc_delimiter = /#{heredoc_delimiter}(?=;?$)/
                       elsif match = scan(/#{RE::OPERATOR}/o)
                         label_expected = match == ';'
                         if case_expected
                           label_expected = true if match == ':'
                           case_expected = false
                         end
                         kind = :operator
                       else
                         getch
                         kind = :error
                       end
                     when :sqstring
                       if scan(heredoc_delimiter ? /[^\\\n]+/ : /[^'\\]+/)
                         kind = :content
                       elsif !heredoc_delimiter && scan(/'/)
                         tokens << [matched, :delimiter]
                         tokens << [:close, :string]
                         delimiter = nil
                         label_expected = false
                         states.pop
                         next
                       elsif heredoc_delimiter && match = scan(/\n/)
                         kind = :content
                         if scan heredoc_delimiter
                           tokens << ["\n", :content]
                           tokens << [matched, :delimiter]
                           tokens << [:close, :string]
                           heredoc_delimiter = nil
                           label_expected = false
                           states.pop
                           next
                         end
                       elsif scan(heredoc_delimiter ? /\\\\/ : /\\[\\'\n]/)
                         kind = :char
                       elsif scan(/\\./m)
                         kind = :content
                       elsif scan(/\\/)
                         kind = :error
                       end
                     when :dqstring
                       if scan(heredoc_delimiter ? /[^${\\\n]+/ : (delimiter == '"' ? /[^"${\\]+/ : /[^`${\\]+/))
                         kind = :content
                       elsif !heredoc_delimiter && scan(delimiter == '"' ? /"/ : /`/)
                         tokens << [matched, :delimiter]
                         tokens << [:close, :string]
                         delimiter = nil
                         label_expected = false
                         states.pop
                         next
                       elsif heredoc_delimiter && match = scan(/\n/)
                         kind = :content
                         if scan heredoc_delimiter
                           tokens << ["\n", :content]
                           tokens << [matched, :delimiter]
                           tokens << [:close, :string]
                           heredoc_delimiter = nil
                           label_expected = false
                           states.pop
                           next
                         end
                       elsif scan(/\\(?:x[0-9A-Fa-f]{1,2}|[0-7]{1,3})/)
                         kind = :char
                       elsif scan(heredoc_delimiter ? /\\[nrtvf\\$]/ : (delimiter == '"' ? /\\[nrtvf\\$"]/ : /\\[nrtvf\\$`]/))
                         kind = :char
                       elsif scan(/\\./m)
                         kind = :content
                       elsif scan(/\\/)
                         kind = :error
                       elsif match = scan(/#{RE::VARIABLE}/o)
                         kind = :local_variable
                         if check(/\[#{RE::IDENTIFIER}\]/o)
                           tokens << [:open, :inline]
                           tokens << [match, :local_variable]
                           tokens << [scan(/\[/), :operator]
                           tokens << [scan(/#{RE::IDENTIFIER}/o), :ident]
                           tokens << [scan(/\]/), :operator]
                           tokens << [:close, :inline]
                           next
                         elsif check(/\[/)
                           match << scan(/\[['"]?#{RE::IDENTIFIER}?['"]?\]?/o)
                           kind = :error
                         elsif check(/->#{RE::IDENTIFIER}/o)
                           tokens << [:open, :inline]
                           tokens << [match, :local_variable]
                           tokens << [scan(/->/), :operator]
                           tokens << [scan(/#{RE::IDENTIFIER}/o), :ident]
                           tokens << [:close, :inline]
                           next
                         elsif check(/->/)
                           match << scan(/->/)
                           kind = :error
                         end
                       elsif match = scan(/\{/)
                         if check(/\$/)
                           kind = :delimiter
                           states[-1] = [states.last, delimiter]
                           delimiter = nil
                           states.push :php
                           tokens << [:open, :inline]
                         else
                           kind = :string
                         end
                       elsif scan(/\$\{#{RE::IDENTIFIER}\}/o)
                         kind = :local_variable
                       elsif scan(/\$/)
                         kind = :content
                       end
                     when :class_expected
                       if scan(/\s+/)
                         kind = :space
                       elsif match = scan(/#{RE::IDENTIFIER}/o)
                         kind = :class
                         states.pop
                       else
                         states.pop
                         next
                       end
                     when :function_expected
                       if scan(/\s+/)
                         kind = :space
                       elsif scan(/&/)
                         kind = :operator
                       elsif match = scan(/#{RE::IDENTIFIER}/o)
                         kind = :function
                         states.pop
                       else
                         states.pop
                         next
                       end
                     else
                       raise_inspect 'Unknown state!', tokens, states
                     end
                     match ||= matched
                     if $CODERAY_DEBUG and not kind
                       raise_inspect 'Error token %p in line %d' %
                         [[match, kind], line], tokens, states
                     end
                     raise_inspect 'Empty token', tokens, states unless match
                     tokens << [match, kind]
                   end
                   tokens
                 end
               end
             end
             end

vendor/gems/coderay-0.9.7/lib/coderay/scanners/plaintext.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/plaintext.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/scanners/plaintext.rb to vendor/gems/coderay-0.9.7/lib/coderay/scanners/plaintext.rb

vendor/gems/coderay-0.9.7/lib/coderay/scanners/python.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/python.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/scanners/python.rb to vendor/gems/coderay-0.9.7/lib/coderay/scanners/python.rb

vendor/gems/coderay-0.9.7/lib/coderay/scanners/rhtml.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/rhtml.rb~~ renamed +6 -2

             module CodeRay
             module Scanners
               load :html
               load :ruby
               # RHTML Scanner
               class RHTML < Scanner
                 include Streamable
                 register_for :rhtml
                 title 'HTML ERB Template'
                 KINDS_NOT_LOC = HTML::KINDS_NOT_LOC
                 ERB_RUBY_BLOCK = /
                   <%(?!%)[=-]?
                   (?>
                     [^\-%]*    # normal*
                     (?>        # special
                       (?: %(?!>) | -(?!%>) )
                       [^\-%]*  # normal*
                     )*
                   )
                   (?: -?%> )?
                 /x
                 START_OF_ERB = /
                   <%(?!%)
                 /x
               private
                 def setup
                   @ruby_scanner = CodeRay.scanner :ruby, :tokens => @tokens, :keep_tokens => true
                   @html_scanner = CodeRay.scanner :html, :tokens => @tokens, :keep_tokens => true, :keep_state => true
                 end
                 def reset_instance
                   super
                   @html_scanner.reset
                 end
                 def scan_tokens tokens, options
                   until eos?
                     if (match = scan_until(/(?=#{START_OF_ERB})/o) || scan_until(/\z/)) and not match.empty?
                       @html_scanner.tokenize match
                     elsif match = scan(/#{ERB_RUBY_BLOCK}/o)
-                      start_tag = match[/\A<%[-=]?/]
+                      start_tag = match[/\A<%[-=#]?/]
                       end_tag = match[/-?%?>?\z/]
                       tokens << [:open, :inline]
                       tokens << [start_tag, :inline_delimiter]
                       code = match[start_tag.size .. -1 - end_tag.size]
-                      @ruby_scanner.tokenize code
+                      if start_tag == '<%#'
+                        tokens << [code, :comment]
+                      else
+                        @ruby_scanner.tokenize code
+                      end
                       tokens << [end_tag, :inline_delimiter] unless end_tag.empty?
                       tokens << [:close, :inline]
                     else
                       raise_inspect 'else-case reached!', tokens
                     end
                   end
                   tokens
                 end
               end
             end
             end

vendor/gems/coderay-0.9.7/lib/coderay/scanners/ruby.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/ruby.rb~~ renamed +52 -21

+            # encoding: utf-8
             module CodeRay
             module Scanners
               # This scanner is really complex, since Ruby _is_ a complex language!
               #
               # It tries to highlight 100% of all common code,
               # and 90% of strange codes.
               #
               # It is optimized for HTML highlighting, and is not very useful for
               # parsing or pretty printing.
               #
               # For now, I think it's better than the scanners in VIM or Syntax, or
               # any highlighter I was able to find, except Caleb's RubyLexer.
               #
               # I hope it's also better than the rdoc/irb lexer.
               class Ruby < Scanner
                 include Streamable
                 register_for :ruby
                 file_extension 'rb'
                 helper :patterns
                 if not defined? EncodingError
                   EncodingError = Class.new Exception
                 end
               private
                 def scan_tokens tokens, options
+                  if string.respond_to?(:encoding)
+                    unless string.encoding == Encoding::UTF_8
+                      self.string = string.encode Encoding::UTF_8,
+                        :invalid => :replace, :undef => :replace, :replace => '?'
+                    end
+                    unicode = false
+                  else
+                    unicode = exist?(/[^\x00-\x7f]/)
+                  end
                   last_token_dot = false
                   value_expected = true
                   heredocs = nil
                   last_state = nil
                   state = :initial
                   depth = nil
                   inline_block_stack = []
-                  unicode = string.respond_to?(:encoding) && string.encoding.name == 'UTF-8'
                   patterns = Patterns  # avoid constant lookup
                   until eos?
                     match = nil
                     kind = nil
                     if state.instance_of? patterns::StringState
             # {{{
                       match = scan_until(state.pattern) || scan_until(/\z/)
                       tokens << [match, :content] unless match.empty?
                       break if eos?
                       if state.heredoc and self[1]  # end of heredoc
                         match = getch.to_s
                         match << scan_until(/$/) unless eos?
                         tokens << [match, :delimiter]
                         tokens << [:close, state.type]
                         state = state.next_state
                         next
                       end
                       case match = getch
                       when state.delim
                         if state.paren
                           state.paren_depth -= 1
                           if state.paren_depth > 0
                             tokens << [match, :nesting_delimiter]
                             next
                           end
                         end
                         tokens << [match, :delimiter]
                         if state.type == :regexp and not eos?
                           modifiers = scan(/#{patterns::REGEXP_MODIFIERS}/ox)
                           tokens << [modifiers, :modifier] unless modifiers.empty?
                         end
                         tokens << [:close, state.type]
                         value_expected = false
                         state = state.next_state
                       when '\\'
                         if state.interpreted
                           if esc = scan(/ #{patterns::ESCAPE} /ox)
                             tokens << [match + esc, :char]
                           else
                             tokens << [match, :error]
                           end
                         else
                           case m = getch
                           when state.delim, '\\'
                             tokens << [match + m, :char]
                           when nil
                             tokens << [match, :error]
                           else
                             tokens << [match + m, :content]
                           end
                         end
                       when '#'
                         case peek(1)
                         when '{'
                           inline_block_stack << [state, depth, heredocs]
                           value_expected = true
                           state = :initial
                           depth = 1
                           tokens << [:open, :inline]
                           tokens << [match + getch, :inline_delimiter]
                         when '$', '@'
                           tokens << [match, :escape]
                           last_state = state  # scan one token as normal code, then return here
                           state = :initial
                         else
                           raise_inspect 'else-case # reached; #%p not handled' % peek(1), tokens
                         end
                       when state.paren
                         state.paren_depth += 1
                         tokens << [match, :nesting_delimiter]
                       when /#{patterns::REGEXP_SYMBOLS}/ox
                         tokens << [match, :function]
                       else
                         raise_inspect 'else-case " reached; %p not handled, state = %p' % [match, state], tokens
                       end
                       next
             # }}}
                     else
             # {{{
                       if match = scan(/[ \t\f]+/)
                         kind = :space
                         match << scan(/\s*/) unless eos? || heredocs
                         value_expected = true if match.index(?\n)
                         tokens << [match, kind]
                         next
                       elsif match = scan(/\\?\n/)
                         kind = :space
                         if match == "\n"
                           value_expected = true
                           state = :initial if state == :undef_comma_expected
                         end
                         if heredocs
                           unscan  # heredoc scanning needs \n at start
                           state = heredocs.shift
                           tokens << [:open, state.type]
                           heredocs = nil if heredocs.empty?
                           next
                         else
                           match << scan(/\s*/) unless eos?
                         end
                         tokens << [match, kind]
                         next
                       elsif bol? && match = scan(/\#!.*/)
                         tokens << [match, :doctype]
                         next
                       elsif match = scan(/\#.*/) or
                         ( bol? and match = scan(/#{patterns::RUBYDOC_OR_DATA}/o) )
                           kind = :comment
                           tokens << [match, kind]
                           next
                       elsif state == :initial
                         # IDENTS #
                         if match = scan(unicode ? /#{patterns::METHOD_NAME}/uo :
                                                   /#{patterns::METHOD_NAME}/o)
                           if last_token_dot
                             kind = if match[/^[A-Z]/] and not match?(/\(/) then :constant else :ident end
                           else
-                            kind = patterns::IDENT_KIND[match]
+                            if value_expected != :expect_colon && scan(/:(?= )/)
-                            if kind == :ident and match[/^[A-Z]/] and not match[/[!?]$/] and not match?(/\(/)
+                              tokens << [match, :key]
-                              kind = :constant
+                              match = ':'
-                            elsif kind == :reserved
+                              kind = :operator
-                              state = patterns::DEF_NEW_STATE[match]
+                            else
-                              value_expected = :set if patterns::KEYWORDS_EXPECTING_VALUE[match]
+                              kind = patterns::IDENT_KIND[match]
+                              if kind == :ident
+                                if match[/\A[A-Z]/] and not match[/[!?]$/] and not match?(/\(/)
+                                  kind = :constant
+                                end
+                              elsif kind == :reserved
+                                state = patterns::DEF_NEW_STATE[match]
+                                value_expected = :set if patterns::KEYWORDS_EXPECTING_VALUE[match]
+                              end
                             end
                           end
                           value_expected = :set if check(/#{patterns::VALUE_FOLLOWS}/o)
                         elsif last_token_dot and match = scan(/#{patterns::METHOD_NAME_OPERATOR}|\(/o)
                           kind = :ident
-                          value_expected = :set if check(/#{patterns::VALUE_FOLLOWS}/o)
+                          value_expected = :set if check(unicode ? /#{patterns::VALUE_FOLLOWS}/uo :
+                                                                   /#{patterns::VALUE_FOLLOWS}/o)
                         # OPERATORS #
                         elsif not last_token_dot and match = scan(/ \.\.\.? | (?:\.|::)() | [,\(\)\[\]\{\}] | ==?=? /x)
                           if match !~ / [.\)\]\}] /x or match =~ /\.\.\.?/
                             value_expected = :set
                           end
                           last_token_dot = :set if self[1]
                           kind = :operator
                           unless inline_block_stack.empty?
                             case match
                             when '{'
                               depth += 1
                             when '}'
                               depth -= 1
                               if depth == 0  # closing brace of inline block reached
                                 state, depth, heredocs = inline_block_stack.pop
                                 heredocs = nil if heredocs && heredocs.empty?
                                 tokens << [match, :inline_delimiter]
                                 kind = :inline
                                 match = :close
                               end
                             end
                           end
                         elsif match = scan(/ ['"] /mx)
                           tokens << [:open, :string]
                           kind = :delimiter
                           state = patterns::StringState.new :string, match == '"', match  # important for streaming
-                        elsif match = scan(/#{patterns::INSTANCE_VARIABLE}/o)
+                        elsif match = scan(unicode ? /#{patterns::INSTANCE_VARIABLE}/uo :
+                                                     /#{patterns::INSTANCE_VARIABLE}/o)
                           kind = :instance_variable
                         elsif value_expected and match = scan(/\//)
                           tokens << [:open, :regexp]
                           kind = :delimiter
                           interpreted = true
                           state = patterns::StringState.new :regexp, interpreted, match
                         # elsif match = scan(/[-+]?#{patterns::NUMERIC}/o)
                         elsif match = value_expected ? scan(/[-+]?#{patterns::NUMERIC}/o) : scan(/#{patterns::NUMERIC}/o)
                           kind = self[1] ? :float : :integer
-                        elsif match = scan(/#{patterns::SYMBOL}/o)
+                        elsif match = scan(unicode ? /#{patterns::SYMBOL}/uo :
+                                                     /#{patterns::SYMBOL}/o)
                           case delim = match[1]
                           when ?', ?"
                             tokens << [:open, :symbol]
                             tokens << [':', :symbol]
                             match = delim.chr
                             kind = :delimiter
                             state = patterns::StringState.new :symbol, delim == ?", match
                           else
                             kind = :symbol
                           end
-                        elsif match = scan(/ [-+!~^]=? | [*|&]{1,2}=? | >>? /x)
+                        elsif match = scan(/ -[>=]? | [+!~^]=? | [*|&]{1,2}=? | >>? /x)
                           value_expected = :set
                           kind = :operator
-                        elsif value_expected and match = scan(/#{patterns::HEREDOC_OPEN}/o)
+                        elsif value_expected and match = scan(unicode ? /#{patterns::HEREDOC_OPEN}/uo :
+                                                                        /#{patterns::HEREDOC_OPEN}/o)
                           indented = self[1] == '-'
                           quote = self[3]
                           delim = self[quote ? 4 : 2]
                           kind = patterns::QUOTE_TO_TYPE[quote]
                           tokens << [:open, kind]
                           tokens << [match, :delimiter]
                           match = :close
                           heredoc = patterns::StringState.new kind, quote != '\'', delim, (indented ? :indented : :linestart )
                           heredocs ||= []  # create heredocs if empty
                           heredocs << heredoc
                         elsif value_expected and match = scan(/#{patterns::FANCY_START_CORRECT}/o)
                           kind, interpreted = *patterns::FancyStringType.fetch(self[1]) do
                             raise_inspect 'Unknown fancy string: %%%p' % k, tokens
                           end
                           tokens << [:open, kind]
                           state = patterns::StringState.new kind, interpreted, self[2]
                           kind = :delimiter
-                        elsif value_expected and match = scan(/#{patterns::CHARACTER}/o)
+                        elsif value_expected and match = scan(unicode ? /#{patterns::CHARACTER}/uo :
+                                                                        /#{patterns::CHARACTER}/o)
                           kind = :integer
                         elsif match = scan(/ [\/%]=? | <(?:<|=>?)? | [?:;] /x)
                           value_expected = :set
                           kind = :operator
                         elsif match = scan(/`/)
                           if last_token_dot
                             kind = :operator
                           else
                             tokens << [:open, :shell]
                             kind = :delimiter
                             state = patterns::StringState.new :shell, true, match
                           end
-                        elsif match = scan(/#{patterns::GLOBAL_VARIABLE}/o)
+                        elsif match = scan(unicode ? /#{patterns::GLOBAL_VARIABLE}/uo :
+                                                     /#{patterns::GLOBAL_VARIABLE}/o)
                           kind = :global_variable
-                        elsif match = scan(/#{patterns::CLASS_VARIABLE}/o)
+                        elsif match = scan(unicode ? /#{patterns::CLASS_VARIABLE}/uo :
+                                                     /#{patterns::CLASS_VARIABLE}/o)
                           kind = :class_variable
                         else
-                          if !unicode
+                          if !unicode && !string.respond_to?(:encoding)
                             # check for unicode
                             debug, $DEBUG = $DEBUG, false
                             begin
                               if check(/./mu).size > 1
                                 # seems like we should try again with unicode
                                 unicode = true
                               end
                             rescue
                               # bad unicode char; use getch
                             ensure
                               $DEBUG = debug
                             end
                             next if unicode
                           end
                           kind = :error
-                          match = getch
+                          match = scan(unicode ? /./mu : /./m)
                         end
                       elsif state == :def_expected
                         state = :initial
                         if scan(/self\./)
                           tokens << ['self', :pre_constant]
                           tokens << ['.', :operator]
                         end
                         if match = scan(unicode ? /(?>#{patterns::METHOD_NAME_EX})(?!\.|::)/uo :
                                                   /(?>#{patterns::METHOD_NAME_EX})(?!\.|::)/o)
                           kind = :method
                         else
                           next
                         end
                       elsif state == :module_expected
                         if match = scan(/<</)
                           kind = :operator
                         else
                           state = :initial
-                          if match = scan(/ (?:#{patterns::IDENT}::)* #{patterns::IDENT} /ox)
+                          if match = scan(unicode ? /(?:#{patterns::IDENT}::)*#{patterns::IDENT}/uo :
+                                                    /(?:#{patterns::IDENT}::)*#{patterns::IDENT}/o)
                             kind = :class
                           else
                             next
                           end
                         end
                       elsif state == :undef_expected
                         state = :undef_comma_expected
-                        if match = scan(/#{patterns::METHOD_NAME_EX}/o)
+                        if match = scan(unicode ? /#{patterns::METHOD_NAME_EX}/uo :
+                                                  /#{patterns::METHOD_NAME_EX}/o)
                           kind = :method
-                        elsif match = scan(/#{patterns::SYMBOL}/o)
+                        elsif match = scan(unicode ? /#{patterns::SYMBOL}/uo :
+                                                     /#{patterns::SYMBOL}/o)
                           case delim = match[1]
                           when ?', ?"
                             tokens << [:open, :symbol]
                             tokens << [':', :symbol]
                             match = delim.chr
                             kind = :delimiter
                             state = patterns::StringState.new :symbol, delim == ?", match
                             state.next_state = :undef_comma_expected
                           else
                             kind = :symbol
                           end
                         else
                           state = :initial
                           next
                         end
                       elsif state == :alias_expected
                         match = scan(unicode ? /(#{patterns::METHOD_NAME_OR_SYMBOL})([ \t]+)(#{patterns::METHOD_NAME_OR_SYMBOL})/uo :
                                                /(#{patterns::METHOD_NAME_OR_SYMBOL})([ \t]+)(#{patterns::METHOD_NAME_OR_SYMBOL})/o)
                         if match
                           tokens << [self[1], (self[1][0] == ?: ? :symbol : :method)]
                           tokens << [self[2], :space]
                           tokens << [self[3], (self[3][0] == ?: ? :symbol : :method)]
                         end
                         state = :initial
                         next
                       elsif state == :undef_comma_expected
                         if match = scan(/,/)
                           kind = :operator
                           state = :undef_expected
                         else
                           state = :initial
                           next
                         end
                       end
             # }}}
                       unless kind == :error
-                        value_expected = value_expected == :set
+                        if value_expected = value_expected == :set
+                          value_expected = :expect_colon if match == '?' || match == 'when'
+                        end
                         last_token_dot = last_token_dot == :set
                       end
                       if $CODERAY_DEBUG and not kind
                         raise_inspect 'Error token %p in line %d' %
                           [[match, kind], line], tokens, state
                       end
                       raise_inspect 'Empty token', tokens unless match
                       tokens << [match, kind]
                       if last_state
                         state = last_state
                         last_state = nil
                       end
                     end
                   end
                   inline_block_stack << [state] if state.is_a? patterns::StringState
                   until inline_block_stack.empty?
                     this_block = inline_block_stack.pop
                     tokens << [:close, :inline] if this_block.size > 1
                     state = this_block.first
                     tokens << [:close, state.type]
                   end
                   tokens
                 end
               end
             end
             end
             # vim:fdm=marker

vendor/gems/coderay-0.9.7/lib/coderay/scanners/ruby/patterns.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/ruby/patterns.rb~~ renamed +18 -4

             # encoding: utf-8
             module CodeRay
             module Scanners
               module Ruby::Patterns  # :nodoc:
                 RESERVED_WORDS = %w[
                   and def end in or unless begin
                   defined? ensure module redo super until
                   BEGIN break do next rescue then
                   when END case else for retry
                   while alias class elsif if not return
                   undef yield
                 ]
                 DEF_KEYWORDS = %w[ def ]
                 UNDEF_KEYWORDS = %w[ undef ]
                 ALIAS_KEYWORDS = %w[ alias ]
-                MODULE_KEYWORDS = %w[class module]
+                MODULE_KEYWORDS = %w[ class module ]
                 DEF_NEW_STATE = WordList.new(:initial).
                   add(DEF_KEYWORDS, :def_expected).
                   add(UNDEF_KEYWORDS, :undef_expected).
                   add(ALIAS_KEYWORDS, :alias_expected).
                   add(MODULE_KEYWORDS, :module_expected)
                 PREDEFINED_CONSTANTS = %w[
                   nil true false self
-                  DATA ARGV ARGF __FILE__ __LINE__
+                  DATA ARGV ARGF
+                  __FILE__ __LINE__ __ENCODING__
                 ]
                 IDENT_KIND = WordList.new(:ident).
                   add(RESERVED_WORDS, :reserved).
                   add(PREDEFINED_CONSTANTS, :pre_constant)
-                IDENT = 'ä'[/[[:alpha:]]/] == 'ä' ? /[[:alpha:]_][[:alnum:]_]*/ : /[^\W\d]\w*/
+                if /\w/u === '∑'
+                  # MRI 1.8.6, 1.8.7
+                  IDENT = /[^\W\d]\w*/
+                else
+                  if //.respond_to? :encoding
+                    # MRI 1.9.1, 1.9.2
+                    IDENT = Regexp.new '[\p{L}\p{M}\p{Pc}\p{Sm}&&[^\x00-\x40\x5b-\x5e\x60\x7b-\x7f]][\p{L}\p{M}\p{N}\p{Pc}\p{Sm}&&[^\x00-\x2f\x3a-\x40\x5b-\x5e\x60\x7b-\x7f]]*'
+                  else
+                    # JRuby, Rubinius
+                    IDENT = /[^\x00-\x40\x5b-\x5e\x60\x7b-\x7f][^\x00-\x2f\x3a-\x40\x5b-\x5e\x60\x7b-\x7f]*/
+                  end
+                end
                 METHOD_NAME = / #{IDENT} [?!]? /ox
                 METHOD_NAME_OPERATOR = /
                   \*\*?           # multiplication and power
                   | [-+~]@?       # plus, minus, tilde with and without at sign
                   | [\/%&|^`]     # division, modulo or format strings, and, or, xor, system
                   | \[\]=?        # array getter and setter
                   | << | >>       # append or shift left, shift right
                   | <=?>? | >=?   # comparison, rocket operator
                   | ===? | =~     # simple equality, case equality, match
                   | ![~=@]?       # negation with and without at sign, not-equal and not-match
                 /ox
                 METHOD_NAME_EX = / #{IDENT} (?:[?!]|=(?!>))? | #{METHOD_NAME_OPERATOR} /ox
                 INSTANCE_VARIABLE = / @ #{IDENT} /ox
                 CLASS_VARIABLE = / @@ #{IDENT} /ox
                 OBJECT_VARIABLE = / @@? #{IDENT} /ox
                 GLOBAL_VARIABLE = / \$ (?: #{IDENT} | [1-9]\d* | 0\w* | [~&+`'=\/,;_.<>!@$?*":\\] | -[a-zA-Z_0-9] ) /ox
                 PREFIX_VARIABLE = / #{GLOBAL_VARIABLE} | #{OBJECT_VARIABLE} /ox
                 VARIABLE = / @?@? #{IDENT} | #{GLOBAL_VARIABLE} /ox
                 QUOTE_TO_TYPE = {
                   '`' => :shell,
                   '/'=> :regexp,
                 }
                 QUOTE_TO_TYPE.default = :string
                 REGEXP_MODIFIERS = /[mixounse]*/
                 REGEXP_SYMBOLS = /[|?*+(){}\[\].^$]/
                 DECIMAL = /\d+(?:_\d+)*/
                 OCTAL = /0_?[0-7]+(?:_[0-7]+)*/
                 HEXADECIMAL = /0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*/
                 BINARY = /0b[01]+(?:_[01]+)*/
                 EXPONENT = / [eE] [+-]? #{DECIMAL} /ox
                 FLOAT_SUFFIX = / #{EXPONENT} | \. #{DECIMAL} #{EXPONENT}? /ox
                 FLOAT_OR_INT = / #{DECIMAL} (?: #{FLOAT_SUFFIX} () )? /ox
                 NUMERIC = / (?: (?=0) (?: #{OCTAL} | #{HEXADECIMAL} | #{BINARY} ) | #{FLOAT_OR_INT} ) /ox
                 SYMBOL = /
                   :
                   (?:
                     #{METHOD_NAME_EX}
                   | #{PREFIX_VARIABLE}
                   | ['"]
                   )
                 /ox
                 METHOD_NAME_OR_SYMBOL = / #{METHOD_NAME_EX} | #{SYMBOL} /ox
                 SIMPLE_ESCAPE = /
                     [abefnrstv]
                   |  [0-7]{1,3}
                   | x[0-9A-Fa-f]{1,2}
                   | .?
                 /mx
                 CONTROL_META_ESCAPE = /
                   (?: M-|C-|c )
                   (?: \\ (?: M-|C-|c ) )*
                   (?: [^\\] | \\ #{SIMPLE_ESCAPE} )?
                 /mox
                 ESCAPE = /
                   #{CONTROL_META_ESCAPE} | #{SIMPLE_ESCAPE}
                 /mox
                 CHARACTER = /
                   \?
                   (?:
                     [^\s\\]
                   | \\ #{ESCAPE}
                   )
                 /mox
                 # NOTE: This is not completely correct, but
                 # nobody needs heredoc delimiters ending with \n.
+                # Also, delimiters starting with numbers are allowed.
+                # but they are more often than not a false positive.
                 HEREDOC_OPEN = /
                   << (-)?              # $1 = float
                   (?:
-                    ( [A-Za-z_0-9]+ )  # $2 = delim
+                    ( #{IDENT} )       # $2 = delim
                   |
                     ( ["'`\/] )        # $3 = quote, type
                     ( [^\n]*? ) \3     # $4 = delim
                   )
                 /mx
                 RUBYDOC = /
                   =begin (?!\S)
                   .*?
                   (?: \Z | ^=end (?!\S) [^\n]* )
                 /mx
                 DATA = /
                   __END__$
                   .*?
                   (?: \Z | (?=^\#CODE) )
                 /mx
                 # Checks for a valid value to follow. This enables
                 # value_expected in method calls without parentheses.
                 VALUE_FOLLOWS = /
                   (?>[ \t\f\v]+)
                   (?:
                     [%\/][^\s=]
                   | <<-?\S
                   | [-+] \d
                   | #{CHARACTER}
                   )
                 /x
                 KEYWORDS_EXPECTING_VALUE = WordList.new.add(%w[
                   and end in or unless begin
                   defined? ensure redo super until
                   break do next rescue then
                   when case else for retry
                   while elsif if not return
                   yield
                 ])
                 RUBYDOC_OR_DATA = / #{RUBYDOC} | #{DATA} /xo
                 RDOC_DATA_START = / ^=begin (?!\S) | ^__END__$ /x
                 FANCY_START_CORRECT = / % ( [qQwWxsr] | (?![a-zA-Z0-9]) ) ([^a-zA-Z0-9]) /mx
                 FancyStringType = {
                   'q' => [:string, false],
                   'Q' => [:string, true],
                   'r' => [:regexp, true],
                   's' => [:symbol, false],
                   'x' => [:shell, true]
                 }
                 FancyStringType['w'] = FancyStringType['q']
                 FancyStringType['W'] = FancyStringType[''] = FancyStringType['Q']
                 class StringState < Struct.new :type, :interpreted, :delim, :heredoc,
                   :paren, :paren_depth, :pattern, :next_state
                   CLOSING_PAREN = Hash[ *%w[
                     ( )
                     [ ]
                     < >
                     { }
                   ] ]
                   CLOSING_PAREN.each { |k,v| k.freeze; v.freeze }  # debug, if I try to change it with <<
                   OPENING_PAREN = CLOSING_PAREN.invert
                   STRING_PATTERN = Hash.new do |h, k|
                     delim, interpreted = *k
                     delim_pattern = Regexp.escape(delim.dup)  # dup: workaround for old Ruby
                     if closing_paren = CLOSING_PAREN[delim]
                       delim_pattern = delim_pattern[0..-1] if defined? JRUBY_VERSION  # JRuby fix
                       delim_pattern << Regexp.escape(closing_paren)
                     end
                     delim_pattern << '\\\\' unless delim == '\\'
                     special_escapes =
                       case interpreted
                       when :regexp_symbols
                         '| ' + REGEXP_SYMBOLS.source
                       when :words
                         '| \s'
                       end
                     h[k] =
                       if interpreted and not delim == '#'
                         / (?= [#{delim_pattern}] | \# [{$@] #{special_escapes} ) /mx
                       else
                         / (?= [#{delim_pattern}] #{special_escapes} ) /mx
                       end
                   end
                   HEREDOC_PATTERN = Hash.new do |h, k|
                     delim, interpreted, indented = *k
                     delim_pattern = Regexp.escape(delim.dup)  # dup: workaround for old Ruby
                     delim_pattern = / \n #{ '(?>[\ \t]*)' if indented } #{ Regexp.new delim_pattern } $ /x
                     h[k] =
                       if interpreted
                         / (?= #{delim_pattern}() | \\ | \# [{$@] ) /mx  # $1 set == end of heredoc
                       else
                         / (?= #{delim_pattern}() | \\ ) /mx
                       end
                   end
                   def initialize kind, interpreted, delim, heredoc = false
                     if heredoc
                       pattern = HEREDOC_PATTERN[ [delim, interpreted, heredoc == :indented] ]
                       delim = nil
                     else
                       pattern = STRING_PATTERN[ [delim, interpreted] ]
                       if paren = CLOSING_PAREN[delim]
                         delim, paren = paren, delim
                         paren_depth = 1
                       end
                     end
                     super kind, interpreted, delim, heredoc, paren, paren_depth, pattern, :initial
                   end
                 end unless defined? StringState
               end
             end
             end

vendor/gems/coderay-0.9.7/lib/coderay/scanners/scheme.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/scheme.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/scanners/scheme.rb to vendor/gems/coderay-0.9.7/lib/coderay/scanners/scheme.rb

vendor/gems/coderay-0.9.7/lib/coderay/scanners/sql.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/sql.rb~~ renamed +1 -1

             module CodeRay module Scanners
               # by Josh Goebel
               class SQL < Scanner
                 register_for :sql
                 RESERVED_WORDS = %w(
                   create database table index trigger drop primary key set select
                   insert update delete replace into
                   on from values before and or if exists case when
                   then else as group order by avg where
                   join inner outer union engine not
                   like end using collate show columns begin
                 )
                 PREDEFINED_TYPES = %w(
                   char varchar enum binary text tinytext mediumtext
                   longtext blob tinyblob mediumblob longblob timestamp
                   date time datetime year double decimal float int
                   integer tinyint mediumint bigint smallint unsigned bit
                   bool boolean hex bin oct
                 )
                 PREDEFINED_FUNCTIONS = %w( sum cast abs pi count min max avg )
                 DIRECTIVES = %w( auto_increment unique default charset )
                 PREDEFINED_CONSTANTS = %w( null true false )
                 IDENT_KIND = CaseIgnoringWordList.new(:ident).
                   add(RESERVED_WORDS, :reserved).
                   add(PREDEFINED_TYPES, :pre_type).
                   add(PREDEFINED_CONSTANTS, :pre_constant).
                   add(PREDEFINED_FUNCTIONS, :predefined).
                   add(DIRECTIVES, :directive)
                 ESCAPE = / [rbfntv\n\\\/'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} | . /mx
                 UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} | U[a-fA-F0-9]{8} /x
                 STRING_PREFIXES = /[xnb]|_\w+/i
                 def scan_tokens tokens, options
                   state = :initial
                   string_type = nil
                   string_content = ''
                   until eos?
                     kind = nil
                     match = nil
                     if state == :initial
                       if scan(/ \s+ | \\\n /x)
                         kind = :space
-                      elsif scan(/^(?:--\s?|#).*/)
+                      elsif scan(/(?:--\s?|#).*/)
                         kind = :comment
                       elsif scan(%r! /\* (?: .*? \*/ | .* ) !mx)
                         kind = :comment
                       elsif scan(/ [-+*\/=<>;,!&^|()\[\]{}~%] | \.(?!\d) /x)
                         kind = :operator
                       elsif scan(/(#{STRING_PREFIXES})?([`"'])/o)
                         prefix = self[1]
                         string_type = self[2]
                         tokens << [:open, :string]
                         tokens << [prefix, :modifier] if prefix
                         match = string_type
                         state = :string
                         kind = :delimiter
                       elsif match = scan(/ @? [A-Za-z_][A-Za-z_0-9]* /x)
                         kind = match[0] == ?@ ? :variable : IDENT_KIND[match.downcase]
                       elsif scan(/0[xX][0-9A-Fa-f]+/)
                         kind = :hex
                       elsif scan(/0[0-7]+(?![89.eEfF])/)
                         kind = :oct
                       elsif scan(/(?>\d+)(?![.eEfF])/)
                         kind = :integer
                       elsif scan(/\d[fF]|\d*\.\d+(?:[eE][+-]?\d+)?|\d+[eE][+-]?\d+/)
                         kind = :float
                       else
                         getch
                         kind = :error
                       end
                     elsif state == :string
                       if match = scan(/[^\\"'`]+/)
                         string_content << match
                         next
                       elsif match = scan(/["'`]/)
                         if string_type == match
                           if peek(1) == string_type  # doubling means escape
                             string_content << string_type << getch
                             next
                           end
                           unless string_content.empty?
                             tokens << [string_content, :content]
                             string_content = ''
                           end
                           tokens << [matched, :delimiter]
                           tokens << [:close, :string]
                           state = :initial
                           string_type = nil
                           next
                         else
                           string_content << match
                         end
                         next
                       elsif scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
                         unless string_content.empty?
                           tokens << [string_content, :content]
                           string_content = ''
                         end
                         kind = :char
                       elsif match = scan(/ \\ . /mox)
                         string_content << match
                         next
                       elsif scan(/ \\ | $ /x)
                         unless string_content.empty?
                           tokens << [string_content, :content]
                           string_content = ''
                         end
                         kind = :error
                         state = :initial
                       else
                         raise "else case \" reached; %p not handled." % peek(1), tokens
                       end
                     else
                       raise 'else-case reached', tokens
                     end
                     match ||= matched
                     unless kind
                       raise_inspect 'Error token %p in line %d' %
                         [[match, kind], line], tokens, state
                     end
                     raise_inspect 'Empty token', tokens unless match
                     tokens << [match, kind]
                   end
                   tokens
                 end
               end
             end end

vendor/gems/coderay-0.9.7/lib/coderay/scanners/xml.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/xml.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/scanners/xml.rb to vendor/gems/coderay-0.9.7/lib/coderay/scanners/xml.rb

vendor/gems/coderay-0.9.7/lib/coderay/scanners/yaml.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/scanners/yaml.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/scanners/yaml.rb to vendor/gems/coderay-0.9.7/lib/coderay/scanners/yaml.rb

vendor/gems/coderay-0.9.7/lib/coderay/style.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/style.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/style.rb to vendor/gems/coderay-0.9.7/lib/coderay/style.rb

vendor/gems/coderay-0.9.7/lib/coderay/styles/_map.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/styles/_map.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/styles/_map.rb to vendor/gems/coderay-0.9.7/lib/coderay/styles/_map.rb

vendor/gems/coderay-0.9.7/lib/coderay/styles/cycnus.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/styles/cycnus.rb~~ renamed +1 0

             module CodeRay
             module Styles
               class Cycnus < Style
                 register_for :cycnus
                 code_background = '#f8f8f8'
                 numbers_background = '#def'
                 border_color = 'silver'
                 normal_color = '#000'
                 CSS_MAIN_STYLES = <<-MAIN
             .CodeRay {
               background-color: #{code_background};
               border: 1px solid #{border_color};
               font-family: 'Courier New', 'Terminal', monospace;
               color: #{normal_color};
             }
             .CodeRay pre { margin: 0px }
             div.CodeRay { }
             span.CodeRay { white-space: pre; border: 0px; padding: 2px }
             table.CodeRay { border-collapse: collapse; width: 100%; padding: 2px }
             table.CodeRay td { padding: 2px 4px; vertical-align: top }
             .CodeRay .line_numbers, .CodeRay .no {
               background-color: #{numbers_background};
               color: gray;
               text-align: right;
             }
             .CodeRay .line_numbers tt { font-weight: bold }
             .CodeRay .line_numbers .highlighted { color: red }
+            .CodeRay .line { display: block; float: left; width: 100%; }
             .CodeRay .no { padding: 0px 4px }
             .CodeRay .code { width: 100% }
             ol.CodeRay { font-size: 10pt }
             ol.CodeRay li { white-space: pre }
             .CodeRay .code pre { overflow: auto }
                 MAIN
                 TOKEN_COLORS = <<-'TOKENS'
             .debug { color:white ! important; background:blue ! important; }
             .af { color:#00C }
             .an { color:#007 }
             .at { color:#f08 }
             .av { color:#700 }
             .aw { color:#C00 }
             .bi { color:#509; font-weight:bold }
             .c  { color:#888; }
             .ch { color:#04D }
             .ch .k { color:#04D }
             .ch .dl { color:#039 }
             .cl { color:#B06; font-weight:bold }
             .cm { color:#A08; font-weight:bold }
             .co { color:#036; font-weight:bold }
             .cr { color:#0A0 }
             .cv { color:#369 }
             .de { color:#B0B; }
             .df { color:#099; font-weight:bold }
             .di { color:#088; font-weight:bold }
             .dl { color:black }
             .do { color:#970 }
             .dt { color:#34b }
             .ds { color:#D42; font-weight:bold }
             .e  { color:#666; font-weight:bold }
             .en { color:#800; font-weight:bold }
             .er { color:#F00; background-color:#FAA }
             .ex { color:#C00; font-weight:bold }
             .fl { color:#60E; font-weight:bold }
             .fu { color:#06B; font-weight:bold }
             .gv { color:#d70; font-weight:bold }
             .hx { color:#058; font-weight:bold }
             .i  { color:#00D; font-weight:bold }
             .ic { color:#B44; font-weight:bold }
             .il { background: #ddd; color: black }
             .il .il { background: #ccc }
             .il .il .il { background: #bbb }
             .il .idl { background: #ddd; font-weight: bold; color: #666 }
             .idl { background-color: #bbb; font-weight: bold; color: #666; }
             .im { color:#f00; }
             .in { color:#B2B; font-weight:bold }
             .iv { color:#33B }
             .la { color:#970; font-weight:bold }
             .lv { color:#963 }
             .oc { color:#40E; font-weight:bold }
             .of { color:#000; font-weight:bold }
             .op { }
             .pc { color:#038; font-weight:bold }
             .pd { color:#369; font-weight:bold }
             .pp { color:#579; }
             .ps { color:#00C; font-weight:bold }
             .pt { color:#074; font-weight:bold }
             .r, .kw  { color:#080; font-weight:bold }
             .ke { color: #808; }
             .ke .dl { color: #606; }
             .ke .ch { color: #80f; }
             .vl { color: #088; }
             .rx { background-color:#fff0ff }
             .rx .k { color:#808 }
             .rx .dl { color:#404 }
             .rx .mod { color:#C2C }
             .rx .fu  { color:#404; font-weight: bold }
             .s { background-color:#fff0f0; color: #D20; }
             .s .s { background-color:#ffe0e0 }
             .s .s  .s { background-color:#ffd0d0 }
             .s .k { }
             .s .ch { color: #b0b; }
             .s .dl { color: #710; }
             .sh { background-color:#f0fff0; color:#2B2 }
             .sh .k { }
             .sh .dl { color:#161 }
             .sy { color:#A60 }
             .sy .k { color:#A60 }
             .sy .dl { color:#630 }
             .ta { color:#070 }
             .tf { color:#070; font-weight:bold }
             .ts { color:#D70; font-weight:bold }
             .ty { color:#339; font-weight:bold }
             .v  { color:#036 }
             .xt { color:#444 }
             .ins { background: #afa; }
             .del { background: #faa; }
             .chg { color: #aaf; background: #007; }
             .head { color: #f8f; background: #505 }
             .ins .ins { color: #080; font-weight:bold }
             .del .del { color: #800; font-weight:bold }
             .chg .chg { color: #66f; }
             .head .head { color: #f4f; }
                 TOKENS
               end
             end
             end

vendor/gems/coderay-0.9.7/lib/coderay/styles/murphy.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/styles/murphy.rb~~ renamed +2 0

             module CodeRay
             module Styles
               class Murphy < Style
                 register_for :murphy
                 code_background = '#001129'
                 numbers_background = code_background
                 border_color = 'silver'
                 normal_color = '#C0C0C0'
                 CSS_MAIN_STYLES = <<-MAIN
             .CodeRay {
               background-color: #{code_background};
               border: 1px solid #{border_color};
               font-family: 'Courier New', 'Terminal', monospace;
               color: #{normal_color};
             }
             .CodeRay pre { margin: 0px; }
             div.CodeRay { }
             span.CodeRay { white-space: pre; border: 0px; padding: 2px; }
             table.CodeRay { border-collapse: collapse; width: 100%; padding: 2px; }
             table.CodeRay td { padding: 2px 4px; vertical-align: top; }
             .CodeRay .line_numbers, .CodeRay .no {
               background-color: #{numbers_background};
               color: gray;
               text-align: right;
             }
             .CodeRay .line_numbers tt { font-weight: bold; }
+            .CodeRay .line_numbers .highlighted { color: red }
+            .CodeRay .line { display: block; float: left; width: 100%; }
             .CodeRay .no { padding: 0px 4px; }
             .CodeRay .code { width: 100%; }
             ol.CodeRay { font-size: 10pt; }
             ol.CodeRay li { white-space: pre; }
             .CodeRay .code pre { overflow: auto; }
                 MAIN
                 TOKEN_COLORS = <<-'TOKENS'
             .af { color:#00C; }
             .an { color:#007; }
             .av { color:#700; }
             .aw { color:#C00; }
             .bi { color:#509; font-weight:bold; }
             .c  { color:#555; background-color: black; }
             .ch { color:#88F; }
             .ch .k { color:#04D; }
             .ch .dl { color:#039; }
             .cl { color:#e9e; font-weight:bold; }
             .co { color:#5ED; font-weight:bold; }
             .cr { color:#0A0; }
             .cv { color:#ccf; }
             .df { color:#099; font-weight:bold; }
             .di { color:#088; font-weight:bold; }
             .dl { color:black; }
             .do { color:#970; }
             .ds { color:#D42; font-weight:bold; }
             .e  { color:#666; font-weight:bold; }
             .er { color:#F00; background-color:#FAA; }
             .ex { color:#F00; font-weight:bold; }
             .fl { color:#60E; font-weight:bold; }
             .fu { color:#5ed; font-weight:bold; }
             .gv { color:#f84; }
             .hx { color:#058; font-weight:bold; }
             .i  { color:#66f; font-weight:bold; }
             .ic { color:#B44; font-weight:bold; }
             .il { }
             .in { color:#B2B; font-weight:bold; }
             .iv { color:#aaf; }
             .la { color:#970; font-weight:bold; }
             .lv { color:#963; }
             .oc { color:#40E; font-weight:bold; }
             .of { color:#000; font-weight:bold; }
             .op { }
             .pc { color:#08f; font-weight:bold; }
             .pd { color:#369; font-weight:bold; }
             .pp { color:#579; }
             .pt { color:#66f; font-weight:bold; }
             .r  { color:#5de; font-weight:bold; }
             .r, .kw  { color:#5de; font-weight:bold }
             .ke { color: #808; }
             .rx { background-color:#221133; }
             .rx .k { color:#f8f; }
             .rx .dl { color:#f0f; }
             .rx .mod { color:#f0b; }
             .rx .fu  { color:#404; font-weight: bold; }
             .s  { background-color:#331122; }
             .s  .s { background-color:#ffe0e0; }
             .s  .s  .s { background-color:#ffd0d0; }
             .s  .k { color:#F88; }
             .s  .dl { color:#f55; }
             .sh { background-color:#f0fff0; }
             .sh .k { color:#2B2; }
             .sh .dl { color:#161; }
             .sy { color:#Fc8; }
             .sy .k { color:#Fc8; }
             .sy .dl { color:#F84; }
             .ta { color:#070; }
             .tf { color:#070; font-weight:bold; }
             .ts { color:#D70; font-weight:bold; }
             .ty { color:#339; font-weight:bold; }
             .v  { color:#036; }
             .xt { color:#444; }
             .ins { background: #afa; }
             .del { background: #faa; }
             .chg { color: #aaf; background: #007; }
             .head { color: #f8f; background: #505 }
             .ins .ins { color: #080; font-weight:bold }
             .del .del { color: #800; font-weight:bold }
             .chg .chg { color: #66f; }
             .head .head { color: #f4f; }
                 TOKENS
               end
             end
             end

vendor/gems/coderay-0.9.7/lib/coderay/token_classes.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/token_classes.rb~~ renamed 0 0

NO CONTENT: file renamed from vendor/plugins/coderay-0.9.2/lib/coderay/token_classes.rb to vendor/gems/coderay-0.9.7/lib/coderay/token_classes.rb

vendor/gems/coderay-0.9.7/lib/coderay/tokens.rb ~~vendor/plugins/coderay-0.9.2/lib/coderay/tokens.rb~~ renamed +17 -15

             module CodeRay
               # = Tokens
               #
               # The Tokens class represents a list of tokens returnd from
               # a Scanner.
               #
               # A token is not a special object, just a two-element Array
               # consisting of
+              # * the _token_ _text_ (the original source of the token in a String) or
+              #   a _token_ _action_ (:open, :close, :begin_line, :end_line)
               # * the _token_ _kind_ (a Symbol representing the type of the token)
-              # * the _token_ _text_ (the original source of the token in a String)
               #
               # A token looks like this:
               #
-              #   [:comment, '# It looks like this']
+              #   ['# It looks like this', :comment]
-              #   [:float, '3.1415926']
+              #   ['3.1415926', :float]
-              #   [:error, '$^']
+              #   ['$^', :error]
               #
-              # Some scanners also yield some kind of sub-tokens, represented by special
+              # Some scanners also yield sub-tokens, represented by special
-              # token texts, namely :open and :close .
+              # token actions, namely :open and :close.
               #
               # The Ruby scanner, for example, splits "a string" into:
               #
               #  [
               #   [:open, :string],
-              #   [:delimiter, '"'],
+              #   ['"', :delimiter],
-              #   [:content, 'a string'],
+              #   ['a string', :content],
-              #   [:delimiter, '"'],
+              #   ['"', :delimiter],
               #   [:close, :string]
               #  ]
               #
-              # Tokens is also the interface between Scanners and Encoders:
+              # Tokens is the interface between Scanners and Encoders:
               # The input is split and saved into a Tokens object. The Encoder
               # then builds the output from this object.
               #
               # Thus, the syntax below becomes clear:
               #
               #   CodeRay.scan('price = 2.59', :ruby).html
               #   # the Tokens object is here -------^
               #
               # See how small it is? ;)
               #
               # Tokens gives you the power to handle pre-scanned code very easily:
               # You can convert it to a webpage, a YAML file, or dump it into a gzip'ed string
               # that you put in your DB.
+              #
+              # It also allows you to generate tokens directly (without using a scanner),
+              # to load them from a file, and still use any Encoder that CodeRay provides.
               #
               # Tokens' subclass TokenStream allows streaming to save memory.
               class Tokens < Array
                 # The Scanner instance that created the tokens.
                 attr_accessor :scanner
                 # Whether the object is a TokenStream.
                 #
                 # Returns false.
                 def stream?
                   false
                 end
                 # Iterates over all tokens.
                 #
                 # If a filter is given, only tokens of that kind are yielded.
                 def each kind_filter = nil, &block
                   unless kind_filter
                     super(&block)
                   else
                     super() do |text, kind|
                       next unless kind == kind_filter
                       yield text, kind
                     end
                   end
                 end
                 # Iterates over all text tokens.
                 # Range tokens like [:open, :string] are left out.
                 #
                 # Example:
                 #   tokens.each_text_token { |text, kind| text.replace html_escape(text) }
                 def each_text_token
                   each do |text, kind|
                     next unless text.is_a? ::String
                     yield text, kind
                   end
                 end
                 # Encode the tokens using encoder.
                 #
                 # encoder can be
                 # * a symbol like :html oder :statistic
                 # * an Encoder class
                 # * an Encoder object
                 #
                 # options are passed to the encoder.
                 def encode encoder, options = {}
                   unless encoder.is_a? Encoders::Encoder
                     unless encoder.is_a? Class
                       encoder_class = Encoders[encoder]
                     end
                     encoder = encoder_class.new options
                   end
                   encoder.encode_tokens self, options
                 end
                 # Turn into a string using Encoders::Text.
                 #
                 # +options+ are passed to the encoder if given.
                 def to_s options = {}
                   encode :text, options
                 end
                 # Redirects unknown methods to encoder calls.
                 #
                 # For example, if you call +tokens.html+, the HTML encoder
                 # is used to highlight the tokens.
                 def method_missing meth, options = {}
                   Encoders[meth].new(options).encode_tokens self
                 end
                 # Returns the tokens compressed by joining consecutive
                 # tokens of the same kind.
                 #
                 # This can not be undone, but should yield the same output
                 # in most Encoders.  It basically makes the output smaller.
                 #
                 # Combined with dump, it saves space for the cost of time.
                 #
                 # If the scanner is written carefully, this is not required -
                 # for example, consecutive //-comment lines could already be
                 # joined in one comment token by the Scanner.
                 def optimize
                   last_kind = last_text = nil
                   new = self.class.new
                   for text, kind in self
                     if text.is_a? String
                       if kind == last_kind
                         last_text << text
                       else
                         new << [last_text, last_kind] if last_kind
                         last_text = text
                         last_kind = kind
                       end
                     else
                       new << [last_text, last_kind] if last_kind
                       last_kind = last_text = nil
                       new << [text, kind]
                     end
                   end
                   new << [last_text, last_kind] if last_kind
                   new
                 end
                 # Compact the object itself; see optimize.
                 def optimize!
                   replace optimize
                 end
                 # Ensure that all :open tokens have a correspondent :close one.
                 #
                 # TODO: Test this!
                 def fix
                   tokens = self.class.new
                   # Check token nesting using a stack of kinds.
                   opened = []
                   for type, kind in self
                     case type
                     when :open
                       opened.push [:close, kind]
                     when :begin_line
                       opened.push [:end_line, kind]
                     when :close, :end_line
                       expected = opened.pop
                       if [type, kind] != expected
                         # Unexpected :close; decide what to do based on the kind:
                         # - token was never opened: delete the :close (just skip it)
                         next unless opened.rindex expected
                         # - token was opened earlier: also close tokens in between
                         tokens << token until (token = opened.pop) == expected
                       end
                     end
                     tokens << [type, kind]
                   end
                   # Close remaining opened tokens
                   tokens << token while token = opened.pop
                   tokens
                 end
                 def fix!
                   replace fix
                 end
                 # TODO: Scanner#split_into_lines
                 #
                 # Makes sure that:
                 # - newlines are single tokens
                 #   (which means all other token are single-line)
                 # - there are no open tokens at the end the line
                 #
                 # This makes it simple for encoders that work line-oriented,
                 # like HTML with list-style numeration.
                 def split_into_lines
                   raise NotImplementedError
                 end
                 def split_into_lines!
                   replace split_into_lines
                 end
                 # Dumps the object into a String that can be saved
                 # in files or databases.
                 #
                 # The dump is created with Marshal.dump;
                 # In addition, it is gzipped using GZip.gzip.
                 #
                 # The returned String object includes Undumping
                 # so it has an #undump method. See Tokens.load.
                 #
                 # You can configure the level of compression,
                 # but the default value 7 should be what you want
                 # in most cases as it is a good compromise between
                 # speed and compression rate.
                 #
                 # See GZip module.
                 def dump gzip_level = 7
                   require 'coderay/helpers/gzip_simple'
                   dump = Marshal.dump self
                   dump = dump.gzip gzip_level
                   dump.extend Undumping
                 end
                 # The total size of the tokens.
                 # Should be equal to the input size before
                 # scanning.
                 def text_size
                   size = 0
                   each_text_token do |t, k|
                     size + t.size
                   end
                   size
                 end
-                # The total size of the tokens.
+                # Return all text tokens joined into a single string.
-                # Should be equal to the input size before
-                # scanning.
                 def text
                   map { |t, k| t if t.is_a? ::String }.join
                 end
                 # Include this module to give an object an #undump
                 # method.
                 #
                 # The string returned by Tokens.dump includes Undumping.
                 module Undumping
                   # Calls Tokens.load with itself.
                   def undump
                     Tokens.load self
                   end
                 end
                 # Undump the object using Marshal.load, then
                 # unzip it using GZip.gunzip.
                 #
                 # The result is commonly a Tokens object, but
                 # this is not guaranteed.
                 def Tokens.load dump
                   require 'coderay/helpers/gzip_simple'
                   dump = dump.gunzip
                   @dump = Marshal.load dump
                 end
               end
               # = TokenStream
               #
               # The TokenStream class is a fake Array without elements.
               #
               # It redirects the method << to a block given at creation.
               #
               # This allows scanners and Encoders to use streaming (no
               # tokens are saved, the input is highlighted the same time it
               # is scanned) with the same code.
               #
               # See CodeRay.encode_stream and CodeRay.scan_stream
               class TokenStream < Tokens
                 # Whether the object is a TokenStream.
                 #
                 # Returns true.
                 def stream?
                   true
                 end
                 # The Array is empty, but size counts the tokens given by <<.
                 attr_reader :size
                 # Creates a new TokenStream that calls +block+ whenever
                 # its << method is called.
                 #
                 # Example:
                 #
                 #   require 'coderay'
                 #
-                #   token_stream = CodeRay::TokenStream.new do |kind, text|
+                #   token_stream = CodeRay::TokenStream.new do |text, kind|
                 #     puts 'kind: %s, text size: %d.' % [kind, text.size]
                 #   end
                 #
-                #   token_stream << [:regexp, '/\d+/']
+                #   token_stream << ['/\d+/', :regexp]
                 #   #-> kind: rexpexp, text size: 5.
                 #
                 def initialize &block
                   raise ArgumentError, 'Block expected for streaming.' unless block
                   @callback = block
                   @size = 0
                 end
                 # Calls +block+ with +token+ and increments size.
                 #
                 # Returns self.
                 def << token
                   @callback.call(*token)
                   @size += 1
                   self
                 end
                 # This method is not implemented due to speed reasons. Use Tokens.
                 def text_size
                   raise NotImplementedError,
                     'This method is not implemented due to speed reasons.'
                 end
                 # A TokenStream cannot be dumped. Use Tokens.
                 def dump
                   raise NotImplementedError, 'A TokenStream cannot be dumped.'
                 end
                 # A TokenStream cannot be optimized. Use Tokens.
                 def optimize
                   raise NotImplementedError, 'A TokenStream cannot be optimized.'
                 end
               end
             end
             if $0 == __FILE__
               $VERBOSE = true
               $: << File.join(File.dirname(__FILE__), '..')
               eval DATA.read, nil, $0, __LINE__ + 4
             end
             __END__
             require 'test/unit'
             class TokensTest < Test::Unit::TestCase
               def test_creation
                 assert CodeRay::Tokens < Array
                 tokens = nil
                 assert_nothing_raised do
                   tokens = CodeRay::Tokens.new
                 end
                 assert_kind_of Array, tokens
               end
               def test_adding_tokens
                 tokens = CodeRay::Tokens.new
                 assert_nothing_raised do
                   tokens << ['string', :type]
                   tokens << ['()', :operator]
                 end
                 assert_equal tokens.size, 2
               end
               def test_dump_undump
                 tokens = CodeRay::Tokens.new
                 assert_nothing_raised do
                   tokens << ['string', :type]
                   tokens << ['()', :operator]
                 end
                 tokens2 = nil
                 assert_nothing_raised do
                   tokens2 = tokens.dump.undump
                 end
                 assert_equal tokens, tokens2
               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