666 lines
16 KiB
Ruby
666 lines
16 KiB
Ruby
# This file is a testcase for the highlighting of Ruby code
|
|
# It's not executable code, but a collection of code snippets
|
|
#
|
|
|
|
require 'Config'
|
|
require 'DO/Clients'
|
|
require 'DO/DBClients'
|
|
|
|
def CGI::escapeElement(string, *elements)
|
|
elements = elements[0] if elements[0].kind_of?(Array)
|
|
unless elements.empty?
|
|
string.gsub(/<\/?(?:#{elements.join("|")})(?!\w)(?:.|\n)*?>/ni) do
|
|
CGI::escapeHTML($&)
|
|
end
|
|
else
|
|
string
|
|
end
|
|
end
|
|
|
|
case inputLine
|
|
when "debug"
|
|
dumpDebugInfo
|
|
dumpSymbols
|
|
when /p\s+(\w+)/
|
|
dumpVariable($1)
|
|
when "quit", "exit"
|
|
exit
|
|
else
|
|
print "Illegal command: #{inputLine}"
|
|
end
|
|
|
|
|
|
kind = case year #hi there
|
|
when 1850..1889 then "Blues"
|
|
when 1890..1909 then "Ragtime"
|
|
when 1910..1929 then "New Orleans Jazz"
|
|
when 1930..1939 then "Swing"
|
|
when 1940..1950 then "Bebop"
|
|
else "Jazz"
|
|
end
|
|
|
|
# URL-encode a string.
|
|
# url_encoded_string = CGI::escape("'Stop!' said Fred")
|
|
# # => "%27Stop%21%27+said+Fred"
|
|
def CGI::escape(string)
|
|
string.gsub(/([^ a-zA-Z0-9_.-]+)/n) do
|
|
'%' + $1.unpack('H2' * $1.size).join('%').upcase
|
|
end.tr(' ', '+')
|
|
end
|
|
|
|
|
|
# Class ClientManager
|
|
#
|
|
# definition : Import, store and export the various data used by the application.
|
|
# This class is the sole interface between the application and the underlying database.
|
|
|
|
mon, day, year = $1, $2, $3 if /(\d\d)-(\d\d)-(\d\d)/
|
|
puts "a = #{a}" if fDebug
|
|
print total unless total == 0
|
|
|
|
while gets
|
|
next if /^#/ # Skip comments
|
|
parseLine unless /^$/ # Don't parse empty lines
|
|
end
|
|
|
|
if artist == "John Coltrane" #hi there
|
|
artist = "'Trane" #hi there
|
|
end unless nicknames == "no" #hi there
|
|
|
|
handle = if aSong.artist == "Gillespie" then #hi there
|
|
"Dizzy"
|
|
elsif aSong.artist == "Parker" then
|
|
"Bird"
|
|
else #hi there
|
|
"unknown"
|
|
end
|
|
|
|
if aSong.artist == "Gillespie" then handle = "Dizzy"
|
|
elsif aSong.artist == "Parker" then handle = "Bird"
|
|
else handle = "unknown"
|
|
end #hi there
|
|
|
|
if aSong.artist == "Gillespie" then
|
|
handle = "Dizzy"
|
|
elsif aSong.artist == "Parker" then
|
|
handle = "Bird"
|
|
else
|
|
handle = "unknown"
|
|
end
|
|
|
|
if aSong.artist == "Gillespie"
|
|
handle = "Dizzy"
|
|
elsif aSong.artist == "Parker"
|
|
handle = "Bird"
|
|
else
|
|
handle = "unknown"
|
|
end
|
|
|
|
case line
|
|
when /title=(.*)/
|
|
puts "Title is #$1"
|
|
when /track=(.*)/
|
|
puts "Track is #$1"
|
|
when /artist=(.*)/
|
|
puts "Artist is #$1"
|
|
end
|
|
|
|
case shape
|
|
when Square, Rectangle
|
|
# ...
|
|
when Circle
|
|
# ...
|
|
when Triangle
|
|
# ...
|
|
else
|
|
# ...
|
|
end
|
|
|
|
|
|
until playList.duration > 60 #hi there
|
|
playList.add(songList.pop)
|
|
end
|
|
|
|
3.times do
|
|
print "Ho! "
|
|
end
|
|
|
|
loop {
|
|
# block ...
|
|
}
|
|
|
|
songList.each do |aSong|
|
|
aSong.play
|
|
end
|
|
|
|
for aSong in songList
|
|
aSong.play
|
|
end
|
|
|
|
for i in ['fee', 'fi', 'fo', 'fum']
|
|
print i, " "
|
|
end
|
|
for i in 1..3
|
|
print i, " "
|
|
end
|
|
for i in File.open("ordinal").find_all { |l| l =~ /d$/}
|
|
print i.chomp, " "
|
|
end
|
|
|
|
class Periods
|
|
def each
|
|
yield "Classical"
|
|
yield "Jazz"
|
|
yield "Rock"
|
|
end
|
|
end
|
|
|
|
|
|
periods = Periods.new
|
|
for genre in periods
|
|
print genre, " "
|
|
end
|
|
|
|
while gets
|
|
next if /^\s*#/ # skip comments
|
|
break if /^END/ # stop at end
|
|
# substitute stuff in backticks and try again
|
|
redo if gsub!(/`(.*?)`/) { eval($1) }
|
|
# process line ...
|
|
end
|
|
|
|
i=0
|
|
loop do
|
|
i += 1
|
|
next if i < 3
|
|
print i
|
|
break if i > 4
|
|
end
|
|
|
|
for i in 1..100
|
|
print "Now at #{i}. Restart? "
|
|
retry if gets =~ /^y/i
|
|
end
|
|
|
|
def doUntil(cond)
|
|
yield
|
|
retry unless cond
|
|
end
|
|
|
|
i = 0
|
|
doUntil(i > 3) {
|
|
print i, " "
|
|
i += 1
|
|
}
|
|
|
|
def system_call
|
|
# ... code which throws SystemCallError
|
|
rescue SystemCallError
|
|
$stderr.print "IO failed: " + $!
|
|
opFile.close
|
|
File.delete(opName)
|
|
raise
|
|
end
|
|
|
|
class ClientManager
|
|
|
|
# constructor
|
|
def initialize(dbase)
|
|
@dbClient = DBClient.new(dbase)
|
|
@clients = Clients.new
|
|
end
|
|
|
|
def prout(a, b, xy="jj") 24 end
|
|
###############################################################
|
|
#
|
|
# CLIENTS SECTION
|
|
#
|
|
###############################################################
|
|
|
|
# update the clients object by retrieving the related data from the database
|
|
# returns the number of clients
|
|
def refreshClients
|
|
@clients.clean
|
|
unless @sqlQuery.nil? then
|
|
@sqlQuery.selectClient.each do |row|
|
|
@clients.addClient(row[0],row[1],row[2],row[3],row[4],row[5], row[6], row[7], row[8])
|
|
end
|
|
else
|
|
puts "SqlQuery wasn't created : cannot read data from database"
|
|
end
|
|
return @clients.length
|
|
end
|
|
|
|
# insert a client in the database and refreshes the local clients object
|
|
# we assume that none of the arguments is null
|
|
# we assume that the client, identified by raison_sociale doesn't already exists
|
|
def addClient(raison_sociale, division, departement, adresse, cp, ville, nom_contact, tel_contact)
|
|
id = "0"
|
|
unless @sqlQuery.nil? then
|
|
id = @sqlQuery.insertClient(raison_sociale, division, departement, adresse, cp, ville, nom_contact,tel_contact)
|
|
else
|
|
puts "SqlQuery wasn't created : database update cannot be performed"
|
|
end
|
|
@clients.addClient(id, raison_sociale, division, departement, adresse, cp, ville, nom_contact, tel_contact) # synchronize local object with DB
|
|
end
|
|
|
|
# deletes a client from the database and updates the local Clients object accordingly
|
|
def delClient(nomclient_brut)
|
|
raison_sociale, div, dep = Clients.getIdentifiers(nomclient_brut)
|
|
listeContratsExp, listeContratsSup, listeContratsProd, listePropositionsExp, listePropositionsSup = []
|
|
|
|
listeContratsExp = @contratsExpertise.getContratsFromClient(nomclient_brut)
|
|
listeContratsSup = @contratsSupport.getContratsFromClient(nomclient_brut)
|
|
listeContratsProd = @contratsProduits.getContratsFromClient(nomclient_brut)
|
|
listePropositionsExp = @propositionsExpertise.getPropositionsFromClient(nomclient_brut)
|
|
listePropositionsSup = @propositionsSupport.getPropositionsFromClient(nomclient_brut)
|
|
|
|
unless @sqlQuery.nil? then
|
|
@sqlQuery.deleteClient(raison_sociale, div, dep)
|
|
|
|
@sqlQuery.deleteContracts(Config::EXPERTISE,listeContratsExp)
|
|
@sqlQuery.deleteContracts(Config::SUPPORT,listeContratsSup)
|
|
@sqlQuery.deleteContracts(Config::PRODUIT,listeContratsProd)
|
|
@sqlQuery.deletePropositions(Config::EXPERTISE,listePropositionsExp)
|
|
@sqlQuery.deletePropositions(Config::SUPPORT,listePropositionsSup)
|
|
else
|
|
puts "SqlQuery wasn't created : database update cannot be performed"
|
|
end
|
|
@clients.delClient(raison_sociale,div,dep)
|
|
|
|
@contratsExpertise.deleteContracts(listeContratsExp)
|
|
@contratsSupport.deleteContracts(listeContratsSup)
|
|
@contratsProduits.deleteContracts(listeContratsProd)
|
|
@propositionsExpertise.deletePropositions(listePropositionsExp)
|
|
@propositionsSupport.deletePropositions(listePropositionsSup)
|
|
end
|
|
end
|
|
|
|
# Mixin module for HTML version 3 generation methods.
|
|
module Html3 # :nodoc:
|
|
|
|
# The DOCTYPE declaration for this version of HTML
|
|
def doctype
|
|
%|<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">|
|
|
end
|
|
|
|
# Initialise the HTML generation methods for this version.
|
|
def element_init
|
|
extend TagMaker
|
|
methods = ""
|
|
# - -
|
|
for element in %w[ A TT I B U STRIKE BIG SMALL SUB SUP EM STRONG
|
|
DFN CODE SAMP KBD VAR CITE FONT ADDRESS DIV center MAP
|
|
APPLET PRE XMP LISTING DL OL UL DIR MENU SELECT table TITLE
|
|
STYLE SCRIPT H1 H2 H3 H4 H5 H6 TEXTAREA FORM BLOCKQUOTE
|
|
CAPTION ]
|
|
methods += <<-BEGIN + nn_element_def(element) + <<-END
|
|
def #{element.downcase}(attributes = {})
|
|
BEGIN
|
|
end
|
|
END
|
|
end
|
|
|
|
# - O EMPTY
|
|
for element in %w[ IMG BASE BASEFONT BR AREA LINK PARAM HR INPUT
|
|
ISINDEX META ]
|
|
methods += <<-BEGIN + nOE_element_def(element) + <<-END
|
|
def #{element.downcase}(attributes = {})
|
|
BEGIN
|
|
end
|
|
END
|
|
end
|
|
|
|
# O O or - O
|
|
for element in %w[ HTML HEAD BODY P PLAINTEXT DT DD LI OPTION tr
|
|
th td ]
|
|
methods += <<-BEGIN + nO_element_def(element) + <<-END
|
|
def #{element.downcase}(attributes = {})
|
|
BEGIN
|
|
end
|
|
END
|
|
end
|
|
eval(methods)
|
|
end
|
|
|
|
end
|
|
|
|
# following snippet from Webrick's log.rb
|
|
# notice the erronous handling of the query method is_a?
|
|
def format(arg)
|
|
str = if arg.is_a?(Exception)
|
|
"#{arg.class}: #{arg.message}\n\t" <<
|
|
arg.backtrace.join("\n\t") << "\n"
|
|
elsif arg.respond_to?(:to_str)
|
|
arg.to_str
|
|
else
|
|
arg.inspect
|
|
end
|
|
end
|
|
|
|
# following snippet from Webrick's httputils.rb
|
|
# Splitting regexps on several lines might be bad form,
|
|
# but not illegal in Ruby.
|
|
# This should probably be supported in the highlighting
|
|
def split_header_value(str)
|
|
str.scan(/((?:"(?:\\.|[^"])+?"|[^",]+)+)
|
|
(?:,\s*|\Z)/xn).collect{|v| v[0] }
|
|
end
|
|
|
|
# snippet from Net::Telnet
|
|
string.gsub(/#{IAC}(
|
|
[#{IAC}#{AO}#{AYT}#{DM}#{IP}#{NOP}]|
|
|
[#{DO}#{DONT}#{WILL}#{WONT}]
|
|
[#{OPT_BINARY}-#{OPT_NEW_ENVIRON}#{OPT_EXOPL}]|
|
|
#{SB}[^#{IAC}]*#{IAC}#{SE}
|
|
)/xno)
|
|
|
|
# following snippet from Webrick's httpresponse.rb
|
|
# the HEREDOC is not recognized as such
|
|
@body << <<-_end_of_html_
|
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
|
|
<HTML>
|
|
<HEAD><TITLE>#{HTMLUtils::escape(@reason_phrase)}</TITLE></HEAD>
|
|
<BODY>
|
|
<H1>#{HTMLUtils::escape(@reason_phrase)}</H1>
|
|
#{HTMLUtils::escape(ex.message)}
|
|
<HR>
|
|
_end_of_html_
|
|
|
|
|
|
# snippet from Webrick's httpproxy.rb
|
|
# here we should make sure that the symbol definition ':' doesn't override
|
|
# the module operator '::'
|
|
Net::HTTP::version_1_2 if RUBY_VERSION < "1.7"
|
|
|
|
# snippet from Webrick's cookie.rb
|
|
# the beginning of the regexp is erronously highlighted like an operator
|
|
key, val = x.split(/=/,2)
|
|
|
|
# the following are division operators
|
|
# it's a bit tricky to keep the operator apart from the regexp
|
|
result = 8 / 4
|
|
result /= divisor
|
|
|
|
# 2008-06-01 regexp and division operator syntax has been fixed:
|
|
result = 8/4 # division
|
|
result = 8/foo # division
|
|
result = /8/ # regexp
|
|
result = 8//4/ # division and regexp
|
|
|
|
10/10 # division
|
|
10/ 10 # division
|
|
10 /10 # division
|
|
10 / 10 # division
|
|
|
|
foo/10 # division
|
|
foo/ 10 # division
|
|
foo /10/ # regexp
|
|
foo / 10 # division
|
|
|
|
foo/10/10 # both division
|
|
total/count/2 # both division
|
|
total/(count/2) # both division
|
|
|
|
@foo/10 # division
|
|
@foo /10 # division
|
|
|
|
"hello"/10 # division
|
|
"hello" / 10 # division
|
|
|
|
/regexp//10 # division
|
|
/regexp/ / 10 # division
|
|
|
|
Math::PI/10 # division
|
|
Math::foo /rx/ # regexp
|
|
|
|
# 2008-06-05 similar fix for modulo operator:
|
|
|
|
10%4 # modulo
|
|
10 %4 # modulo
|
|
10% 4 # modulo
|
|
10 % 4 # modulo
|
|
|
|
foo%4 # modulo
|
|
# foo %4 # illegal %string
|
|
foo% 4 # modulo
|
|
foo % 4 # modulo
|
|
|
|
foo % (4) # modulo
|
|
|
|
foo %(4) # %string
|
|
foo %q(4) # %string
|
|
foo %Q(4) # %string
|
|
foo %%4% # %string
|
|
|
|
foo = %|blah| # GDL input
|
|
foo % %|blah| # modulo and GDL
|
|
|
|
# mix in any way you want
|
|
result = 10//regexp//20/foo//regexp//20
|
|
|
|
# test cases for general delimited input
|
|
# quoted strings
|
|
%Q_this is a string \n#{123} [<({nested})>]_
|
|
%Q|this is a string \n#{123} [<({nested})>]|
|
|
%Q{this is a string \n#{123} [<({nested})>]}
|
|
%Q(this is a string \n#{123} [<({nested})>])
|
|
%Q<this is a string \n#{123} [<({nested})>]>
|
|
%Q[this is a string \n#{123} [<({nested})>]]
|
|
|
|
%_also a string \n#{123} [<({nested})>]_
|
|
%|also a string \n#{123} [<({nested})>]|
|
|
%{also a string \n#{123} [<({nested})>]}
|
|
%(also a string \n#{123} [<({nested})>])
|
|
%<also a string \n#{123} [<({nested})>]>
|
|
%[also a string \n#{123} [<({nested})>]]
|
|
|
|
# array
|
|
%W_this is a string \n#{123} [<({nested})>]_
|
|
%W|this is a string \n#{123} [<({nested})>]|
|
|
%W{this is a string \n#{123} [<({nested})>]}
|
|
%W(this is a string \n#{123} [<({nested})>])
|
|
%W<this is a string \n#{123} [<({nested})>]>
|
|
%W[this is a string \n#{123} [<({nested})>]]
|
|
|
|
# apostrophed strings
|
|
%q_apostrophed \n#{123} [<({nested})>]_
|
|
%q|apostrophed \n#{123} [<({nested})>]|
|
|
%q{apostrophed \n#{123} [<({nested})>]}
|
|
%q(apostrophed \n#{123} [<({nested})>])
|
|
%q<apostrophed \n#{123} [<({nested})>]>
|
|
%q[apostrophed \n#{123} [<({nested})>]]
|
|
|
|
# regular expressions
|
|
%r_expression \n#{123} [<({nested})>]_
|
|
%r|expression \n#{123} [<({nested})>]|
|
|
%r{expression \n#{123} [<({nested})>]}
|
|
%r(expression \n#{123} [<({nested})>])
|
|
%r<expression \n#{123} [<({nested})>]>
|
|
%r[expression \n#{123} [<({nested})>]]
|
|
|
|
# shell commands
|
|
%x_ls -l \n#{123} [<({nested})>]_
|
|
%x|ls -l \n#{123} [<({nested})>]|
|
|
%x{ls -l \n#{123} [<({nested})>]}
|
|
%x(ls -l \n#{123} [<({nested})>])
|
|
%x<ls -l \n#{123} [<({nested})>]>
|
|
%x[ls -l \n#{123} [<({nested})>]]
|
|
|
|
# sometimes it's useful to have the command on multiple lines
|
|
%x{ls -l |
|
|
grep test }
|
|
|
|
# alternative syntax
|
|
`ls -l`
|
|
`echo ' '`
|
|
|
|
# token array
|
|
%w_one two three \n#{123} [<({nested})>]_
|
|
%w|one two three \n#{123} [<({nested})>]|
|
|
%w{one two three \n#{123} [<({nested})>]}
|
|
%w(one two three \n#{123} [<({nested})>])
|
|
%w<one two three \n#{123} [<({nested})>]>
|
|
%w[one two three \n#{123} [<({nested})>]]
|
|
|
|
# symbol array
|
|
%s_one two three \n#{123} [<({nested})>]_
|
|
%s|one two three \n#{123} [<({nested})>]|
|
|
%s{one two three \n#{123} [<({nested})>]}
|
|
%s(one two three \n#{123} [<({nested})>])
|
|
%s<one two three \n#{123} [<({nested})>]>
|
|
%s[one two three \n#{123} [<({nested})>]]
|
|
|
|
# number
|
|
# binary
|
|
0b001
|
|
0B1101_13 # bad
|
|
# octal
|
|
0123
|
|
01238 # bad
|
|
# decimal
|
|
0 10 0d10 120_12 0d23_23
|
|
0_1_2 0_1_ # bad
|
|
# hex
|
|
0x218 0x1a_23
|
|
0x218g 0x1a_23g # bad
|
|
# complex
|
|
0i 12i 03i 12.3i
|
|
012_i 12.3_i 123ia # bad
|
|
# rational
|
|
0r 12r 03r 12.3r
|
|
012_r 12.3_r 123ra # bad
|
|
# rational
|
|
0ri 12ri 03ri 12.3ri
|
|
012_ri 12.3_ri 123ir 123ria # bad
|
|
|
|
# Global constant
|
|
ABC ABC1 ABC1ABC ABC_ABC_ ___12 _1 _1ABC
|
|
# Contant
|
|
Abc A1b Ab1 ABC1a
|
|
# ident
|
|
ABC? ABC1? ABC1ABC? ABC_ABC_? ___12? _1? _1ABC?
|
|
Abc? A1b? Ab1? ABC1a?
|
|
|
|
# snippet from Net::IMAP
|
|
# I object to putting String, Integer and Array into kernel methods.
|
|
# While these classes are builtin in Ruby, this is an implementation detail
|
|
# that should not be exposed to the user.
|
|
# If we want to handle all std-lib classes, fine. But then they should be in their
|
|
# own std-lib keyword category.
|
|
|
|
def send_data(data)
|
|
case data
|
|
when nil
|
|
put_string("NIL")
|
|
when String
|
|
send_string_data(data)
|
|
when Integer
|
|
send_number_data(data)
|
|
when Array
|
|
send_list_data(data)
|
|
when Time
|
|
send_time_data(data)
|
|
when Symbol
|
|
send_symbol_data(data)
|
|
else
|
|
data.send_data(self)
|
|
end
|
|
end
|
|
|
|
# snippet from Net::POP
|
|
# class names can have numbers in them as long as they don't begin with numbers
|
|
# Ruby doesn't internally really make much of a difference between a class name and a constant
|
|
|
|
# class aliases
|
|
POP = POP3
|
|
POPSession = POP3
|
|
POP3Session = POP3
|
|
|
|
# "member access"
|
|
POP::Session.COUNT.attribute.calc_with(2){ |arg| puts arg }
|
|
|
|
# snippet from Net::SMTP
|
|
# This breaks the code folding. I think we would need to
|
|
# handle the '\' that continues the statement to the next line
|
|
# in some way to make these kind of things not break something.
|
|
raise ArgumentError, 'both user and secret are required'\
|
|
unless user and secret
|
|
|
|
# string escapes must detect escaping the escape char
|
|
str = "\\"
|
|
str = "\\\\"
|
|
# this is not part of the string
|
|
%x{echo \\\}\\} # prints \}\
|
|
# this is not part of the command
|
|
|
|
# these are all symbols
|
|
:abc
|
|
:abc!
|
|
:abc?
|
|
:abc=
|
|
:[]
|
|
:[]=
|
|
:@abc
|
|
:@@abc
|
|
:$abc
|
|
|
|
# squiggly HEREDOC
|
|
<<~HEREDOC
|
|
Hello!!
|
|
HEREDOC
|
|
|
|
# HEREDOC with backticks
|
|
<<`HEREDOC`
|
|
echo "hello"
|
|
HEREDOC
|
|
|
|
# do not highlight HEREDOC markers after the "class" keyword
|
|
# (singleton class definition) (bug: #358273)
|
|
class <<Foo = Object.new
|
|
attr_accessor :foo
|
|
end
|
|
singleton_class = ( class <<foo; self; end )
|
|
|
|
# highlight regular expressions after ": " (bug: #361875)
|
|
get 'files/:slug/:filename', to: 'files#download', slug: /^[a-z]+$/, filename: %r|^[/\s]+$|
|
|
@@hello!: /regexp/
|
|
[]=: %r!regexp!
|
|
|
|
# refinements and its usage
|
|
module Constantize
|
|
refine String do
|
|
def constantize
|
|
::Kernel.const_get(self)
|
|
end
|
|
end
|
|
end
|
|
|
|
class MyClass
|
|
using Constantize
|
|
|
|
SOME_CONST = "Kate is cool!"
|
|
|
|
def self.method_using_refinement
|
|
"MyClass::SOME_CONST".constantize
|
|
end
|
|
end
|
|
|
|
puts MyClass.method_using_refinement
|
|
|
|
class Path
|
|
def +(other) end
|
|
alias / +
|
|
end
|
|
|
|
test_ok(if $x == $x then true else false end)
|
|
|
|
foo?(?a ? 1 : :a) # or
|
|
foo??a?1: :a
|
|
foo?(?a ? 1 : 2) # or
|
|
foo??a?1: 2
|
|
|
|
"#{{a:}}"
|
|
# break substitution
|
|
"#{1+1+?};if}"
|