# 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 tqshape 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").tqfind_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 %|| 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_ #{HTMLUtils::escape(@reason_phrase)}

#{HTMLUtils::escape(@reason_phrase)}

#{HTMLUtils::escape(ex.message)}
_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 # we currently require a space after the operator, but that is not quite right either result = 8 / 4 result /= divisor # test cases for general delimited input # quoted strings %Q|this is a string| %Q{this is a string} %Q(this is a string) %Q %Q[this is a string] %|also a string| %{also a string} %(also a string) % %[also a string] # apostrophed strings %q|apostrophed| %q{apostrophed} %q(apostrophed) %q %q[apostrophed] # regular expressions %r{expression} %r(expression) %r %r[expression] %r|expression| # shell commands %x{ls -l} %x(ls -l) %x %x[ls -l] # sometimes it's useful to have the command on multiple lines %x{ls -l | grep test } # token array %w{one two three} %w(one two three) %w %w[one two three] # 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