# 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}"