# http://adminsq3.blogspot.com

es:
  bugcloud: "Nube"

#! /usr/bin/python
import sys
filename = sys.argv[1]

f=open(filename, 'r')
contents=f.read()
url_list = contents.split('\n')

def get_filename(file):
    return file[file.rfind('/')+1:]

def filename_compare(x, y):
    file_x = get_filename(x)
    file_y = get_filename(y)
    if file_x > file_y:
        return 1
    elif file_x == file_y:
        return 0
    else:
        return -1

url_list.sort(filename_compare)

for url in url_list:
    if url != '':
        print url

eg. ./script/generate scaffold Scm::Orders

controller_plural_name__________________orders
controller_file_name____________________orders
controller_table_name___________________orders
controller_class_path___________________scm
controller_class_name___________________Scm::Orders
controller_file_path____________________scm/orders
controller_class_nesting________________Scm
controller_name_________________________Scm::Orders
controller_class_nesting_depth__________1
controller_underscore_name______________orders
controller_singular_name________________Order
name____________________________________Scm::Order
class_name______________________________Scm::Order
model_name______________________________Order
singular_name___________________________order
plural_name_____________________________orders
table_name______________________________scm_orders
class_path______________________________scm
file_path_______________________________scm/order
class_nesting___________________________Scm
class_nesting_depth_____________________1

#!/usr/bin/env ruby
require 'hildon'
    
class Test 
  def initialize
    @p = Hildon::Program.new
    @w = Hildon::Window.new
    @w.signal_connect("destroy") { Gtk.main_quit }
    @p.add_window( @w )
  end
  
  

  def notes
    w = Gtk::Window.new 
    vbox = Gtk::VBox.new( false, 0)
    w.add( vbox )

    

    note1 = Gtk::Button.new("Confirmation Note")
    vbox.pack_start( note1,true,true,0 )

    note1.signal_connect("clicked") {
      n = Hildon::Note.new_confirmation( w, "this is a confirmation note" )
      n.run
      n.destroy
    }
    
    

    note1 = Gtk::Button.new("Confirmation Note add buttons")
    vbox.pack_start( note1,true,true,0 )

    note1.signal_connect("clicked") {
    n = Hildon::Note.new_information( w, "sorry .. not implemented yet !!" )
      n.run
      n.destroy
    }

    

    note1 = Gtk::Button.new("Information Note with icon")
    vbox.pack_start( note1,true,true,0 )

    note1.signal_connect("clicked") {
    n = Hildon::Note.new_confirmation_with_icon_name( w, "this is a information note",Gtk::Stock::CDROM)
      n.run
      n.destroy
    }

    

    note1 = Gtk::Button.new("Information Note with progress bar")
    vbox.pack_start( note1,true,true,0 )

    note1.signal_connect("clicked") {
      pbar = Gtk::ProgressBar.new 
      n = Hildon::Note.new_cancel_with_progress_bar( w, "this is an information note with progrss bar", pbar )
      n.run
      n.destroy
    }
    
    

    note1 = Gtk::Button.new("Information Note")
    vbox.pack_start( note1,true,true,0 )

    note1.signal_connect("clicked") {
      n = Hildon::Note.new_information( w, "this is a information note" )
      n.run
      n.destroy
    }

    

    note1 = Gtk::Button.new("Information Note with Icon")
    vbox.pack_start( note1,true,true,0 )

    note1.signal_connect("clicked") {
    n = Hildon::Note.new_information_with_icon_name( w, "this is a information note",Gtk::Stock::NETWORK )
      n.run
      n.destroy
    }

    note1 = Gtk::Button.new("Exit")
    vbox.pack_start( note1,true,true,0 )

    note1.signal_connect("clicked") {
      w.destroy
    }
    w.show_all
  end #notes

  

  def colors
    w = Gtk::Window.new 
    vbox = Gtk::VBox.new( false, 0)
    w.add( vbox )

    colour = Gtk::ColorSelection

    button = Gtk::Button.new("Color Dialog")
    vbox.pack_start( button,true,true,0 )

    button.signal_connect("clicked") {
      popup = Hildon::ColorChooserDialog.new
      popup.run
      color = popup.get_color
      # popup.set_color( color )
      popup.destroy 
	
    }

    button = Hildon::ColorChooser.new
    vbox.pack_start( button,true,true,0 )
    color = button.get_color
    button.set_color( color )

    button = Hildon::ColorButton.new
    #   color = button.get_color
    #  button.set_color( color )
    vbox.pack_start( button,true,true,0 )

    w.show_all
  end #colors

  def banners
    w = Gtk::Window.new 
    vbox = Gtk::VBox.new( false, 0)
    w.add( vbox )

    note1 = Gtk::Button.new("Information")
    vbox.pack_start( note1,true,true,0 )

    note1.signal_connect("clicked") {
      begin
	n = Hildon::Banner.show_information( w, Gtk::Stock::CDROM,"this is information" )
      rescue Exception => e
	puts "this is information"
      end      
    }

    note1 = Gtk::Button.new("Markup")
    vbox.pack_start( note1,true,true,0 )

    note1.signal_connect("clicked") {
      begin
	n = Hildon::Banner.show_information_with_markup( w, Gtk::Stock::CDROM,"this is markup" )
      rescue Exception => e
	puts "this is markup"
      end
    }

    note1 = Gtk::Button.new("Animation")
    vbox.pack_start( note1,true,true,0 )

    note1.signal_connect("clicked") {
      n = Hildon::Banner.show_animation( w, "animation name","animation title")
    }

    note1 = Gtk::Button.new("Progress")
    vbox.pack_start( note1,true,true,0 )

    note1.signal_connect("clicked") {
      pbar = Gtk::ProgressBar.new 
      n = Hildon::Banner.show_progress( w, pbar,"progress title" )
    }



    note1 = Gtk::Button.new("Exit")
    vbox.pack_start( note1,true,true,0 )
    note1.signal_connect("clicked") {
      w.destroy
    }
    w.show_all
  end #banners


  

  def bars
    w = Gtk::Window.new 
    vbox = Gtk::VBox.new( false, 0)
    w.add( vbox )

    bar = Hildon::Controlbar.new
    bar.set_min 1
    bar.set_max 9
    bar.set_value 5
    val = bar.get_value
    vbox.pack_start( bar,true,true,0 )
    
    bar = Hildon::Hvolumebar.new
    vbox.pack_start( bar,true,true,0 )
    bar.get_mute
    bar.set_mute true
    level = bar.get_level
    bar.set_level( level + 0.1 )
    
    bar = Hildon::Seekbar.new
    vbox.pack_start( bar,true,true,0 )
    
    bar.set_total_time(15 )
    
    bar.set_position( 5 )
    level = bar.get_fraction
    bar.set_fraction( level  )
    val = bar.get_total_time
    level = bar.get_position

    w.show_all
  end #bars
    
  

  def misc
    w = Gtk::Window.new 
    vbox = Gtk::VBox.new( false, 0)
    w.add( vbox )

    

    button = Gtk::Button.new("Sort Dialog")
    vbox.pack_start( button,true,true,0 )
    
    button.signal_connect("clicked") {
      popup = Hildon::SortDialog.new( w)

      popup.run
      popup.destroy 	
    }
    
    

    button = Gtk::Button.new("Wizard")
    vbox.pack_start( button,true,true,0 )
    
    button.signal_connect("clicked") {
      x = Gtk::Notebook.new 
      popup = Hildon::WizardDialog.new(w, "Wizard", x)

      popup.run
      popup.destroy 	
    }
    

    w.show_all
  end #misc
       
       
  

  def codes
    w = Gtk::Window.new 
    vbox = Gtk::VBox.new( false, 0)
    w.add( vbox )
    
    

    button = Gtk::Button.new("Set Password")
    vbox.pack_start( button,true,true,0 )
    
    button.signal_connect("clicked") {
      popup = Hildon::SetPasswordDialog.new( w, false, "default")

      popup.run
      popup.destroy 	
    }
    
    

    button = Gtk::Button.new("Get Password")
    vbox.pack_start( button,true,true,0 )
    
    button.signal_connect("clicked") {
      popup = Hildon::GetPasswordDialog.new( w, false, "default")

      popup.run
      popup.destroy 	
    }
    
    

    button = Gtk::Button.new("Login")
    vbox.pack_start( button,true,true,0 )
    
    button.signal_connect("clicked") {
      popup = Hildon::LoginDialog.new( w, "username", "password")

      popup.run
      popup.destroy 	
    }
    
    

    button = Gtk::Button.new("Code")
    vbox.pack_start( button,true,true,0 )
    
    button.signal_connect("clicked") {
      popup = Hildon::CodeDialog.new

      popup.run
      popup.destroy 	
    }
    
    w.show_all
  end #codes
	  

  

  def pickers
    w = Gtk::Window.new 
    vbox = Gtk::VBox.new( false, 0)
    w.add( vbox )  

    button = Gtk::Button.new("Time Picker")
    vbox.pack_start( button,true,true,0 )

    button.signal_connect("clicked") {
      t = Hildon::TimePicker.new @w
      t.set_time( 12, 37 )
      t.run
      t.destroy
    }
    
    pick = Hildon::WeekdayPicker.new
    vbox.pack_start( pick,true,true,0 )
    
    pick = Hildon::NumberEditor.new( 10, 20 )
    vbox.pack_start( pick,true,true,0 )
    
    editor = Hildon::TimeEditor.new 
    editor.set_time( 12, 37, 23 )
    vbox.pack_start( editor,true,true,0 )
    editor.get_time
    
    editor = Hildon::DateEditor.new 
    editor.set_date( 25, 05, 2008 )
    vbox.pack_start( editor,true,true,0 )
    editor.get_date
    
    
    pick = Hildon::RangeEditor.new
    pick.set_range( 2, 18 )
    vbox.pack_start( pick,true,true,0 )
    
    w.show_all    
  end #pickers
   
  

  def top_level
    vbox = Gtk::VBox.new( false, 0)
    @w.add( vbox )

    button = Gtk::Button.new("Notes")
    vbox.pack_start( button,true,true,0 )
    button.signal_connect("clicked") {
      notes
    }

    button = Gtk::Button.new("Banners")
    vbox.pack_start( button,true,true,0 )
    button.signal_connect("clicked") {
      banners
    }

    button = Gtk::Button.new("Colours")
    vbox.pack_start( button,true,true,0 )
    button.signal_connect("clicked") {
	colors
    }

    button = Gtk::Button.new("Bars")
    vbox.pack_start( button,true,true,0 )
    button.signal_connect("clicked") {
	bars
    }
    button = Gtk::Button.new("Misc")
    vbox.pack_start( button,true,true,0 )
    button.signal_connect("clicked") {
	misc
    }

    button = Gtk::Button.new("Pickers")
    vbox.pack_start( button,true,true,0 )
    button.signal_connect("clicked") {
	pickers
    }

    button = Gtk::Button.new("Code Dialogs")
    vbox.pack_start( button,true,true,0 )
    button.signal_connect("clicked") {
	codes
    }

    

    button = Gtk::Button.new("Calendar Popup")
    vbox.pack_start( button,true,true,0 )
    button.signal_connect("clicked") {
      popup = Hildon::CalendarPopup.new(@w,25,5,2008)
      popup.run
      popup.destroy 
    }

    

    button = Gtk::Button.new("Font Dialog")
    vbox.pack_start( button,true,true,0 )
    button.signal_connect("clicked") {
      popup = Hildon::FontSelectionDialog.new( button ,"howdy" )
      popup.set_preview_text( "reality bites" )
      popup.run
      popup.destroy 
    }

    button = Gtk::Button.new("Exit Program")
    vbox.pack_start( button,true,true,0 )
    button.signal_connect("clicked") {
      Gtk.main_quit 
    }
  end # top_level

  def run
    @w.show_all
    Gtk.main
  end #run
      
end # Test

t = Test.new 
t.top_level
t.run

/**
 * Tries to determine Servers' SCRIPT_URL, if it doesn't exist.
 * The missing superglobal $_SERVER array element will be fixed.
 *
 * Example: client requests ... 
 * http://www.hostname.com/testpage.html?param=value&foo=bar
 *
 * ...$_SERVER['SCRIPT_URL'] is (or becomes)
 * "/testpage.html"
 *
 * @return string 
 * @author Carsten Witt <carsten.witt@gmail.com>
 * @version 20100206
 */
function get_script_url() 
{
    $script_url = null;

    if (!empty($_SERVER['SCRIPT_URL']))   
        $script_url = $_SERVER['SCRIPT_URL'];

    elseif (!empty($_SERVER['REDIRECT_URL'])) 
        $script_url = $_SERVER['REDIRECT_URL'];

    elseif (!empty($_SERVER['REQUEST_URI'])) {
        $p = parse_url($_SERVER['REQUEST_URI']);
        $script_url = $p['path'];
    }
    
    else die (__FILE__." / ".__FUNCTION__.':<br />Couldn\'t determine $_SERVER["SCRIPT_URL"].');

    $_SERVER['SCRIPT_URL'] = $script_url;
    
    return $script_url;
    
} // get_script_url()

Oniguruma Regular Expressions Version 5.6.0    2007/04/03

syntax: ONIG_SYNTAX_RUBY (default)


1. Syntax elements

  \       escape (enable or disable meta character meaning)
  |       alternation
  (...)   group
  [...]   character class  


2. Characters

  \t           horizontal tab (0x09)
  \v           vertical tab   (0x0B)
  \n           newline        (0x0A)
  \r           return         (0x0D)
  \b           back space     (0x08)
  \f           form feed      (0x0C)
  \a           bell           (0x07)
  \e           escape         (0x1B)
  \nnn         octal char            (encoded byte value)
  \xHH         hexadecimal char      (encoded byte value)
  \x{7HHHHHHH} wide hexadecimal char (character code point value)
  \cx          control char          (character code point value)
  \C-x         control char          (character code point value)
  \M-x         meta  (x|0x80)        (character code point value)
  \M-\C-x      meta control char     (character code point value)

 (* \b is effective in character class [...] only)


3. Character types

  .        any character (except newline)

  \w       word character

           Not Unicode:
             alphanumeric, "_" and multibyte char. 

           Unicode:
             General_Category -- (Letter|Mark|Number|Connector_Punctuation)

  \W       non word char

  \s       whitespace char

           Not Unicode:
             \t, \n, \v, \f, \r, \x20

           Unicode:
             0009, 000A, 000B, 000C, 000D, 0085(NEL), 
             General_Category -- Line_Separator
                              -- Paragraph_Separator
                              -- Space_Separator

  \S       non whitespace char

  \d       decimal digit char

           Unicode: General_Category -- Decimal_Number

  \D       non decimal digit char

  \h       hexadecimal digit char   [0-9a-fA-F]

  \H       non hexadecimal digit char


  Character Property

    * \p{property-name}
    * \p{^property-name}    (negative)
    * \P{property-name}     (negative)

    property-name:

     + works on all encodings
       Alnum, Alpha, Blank, Cntrl, Digit, Graph, Lower,
       Print, Punct, Space, Upper, XDigit, Word, ASCII,

     + works on EUC_JP, Shift_JIS
       Hiragana, Katakana

     + works on UTF8, UTF16, UTF32
       Any, Assigned, C, Cc, Cf, Cn, Co, Cs, L, Ll, Lm, Lo, Lt, Lu,
       M, Mc, Me, Mn, N, Nd, Nl, No, P, Pc, Pd, Pe, Pf, Pi, Po, Ps,
       S, Sc, Sk, Sm, So, Z, Zl, Zp, Zs, 
       Arabic, Armenian, Bengali, Bopomofo, Braille, Buginese,
       Buhid, Canadian_Aboriginal, Cherokee, Common, Coptic,
       Cypriot, Cyrillic, Deseret, Devanagari, Ethiopic, Georgian,
       Glagolitic, Gothic, Greek, Gujarati, Gurmukhi, Han, Hangul,
       Hanunoo, Hebrew, Hiragana, Inherited, Kannada, Katakana,
       Kharoshthi, Khmer, Lao, Latin, Limbu, Linear_B, Malayalam,
       Mongolian, Myanmar, New_Tai_Lue, Ogham, Old_Italic, Old_Persian,
       Oriya, Osmanya, Runic, Shavian, Sinhala, Syloti_Nagri, Syriac,
       Tagalog, Tagbanwa, Tai_Le, Tamil, Telugu, Thaana, Thai, Tibetan,
       Tifinagh, Ugaritic, Yi



4. Quantifier

  greedy

    ?       1 or 0 times
    *       0 or more times
    +       1 or more times
    {n,m}   at least n but not more than m times
    {n,}    at least n times
    {,n}    at least 0 but not more than n times ({0,n})
    {n}     n times

  reluctant

    ??      1 or 0 times
    *?      0 or more times
    +?      1 or more times
    {n,m}?  at least n but not more than m times  
    {n,}?   at least n times
    {,n}?   at least 0 but not more than n times (== {0,n}?)

  possessive (greedy and does not backtrack after repeated)

    ?+      1 or 0 times
    *+      0 or more times
    ++      1 or more times

    ({n,m}+, {n,}+, {n}+ are possessive op. in ONIG_SYNTAX_JAVA only)

    ex. /a*+/ === /(?>a*)/


5. Anchors

  ^       beginning of the line
  $       end of the line
  \b      word boundary
  \B      not word boundary
  \A      beginning of string
  \Z      end of string, or before newline at the end
  \z      end of string
  \G      matching start position 


6. Character class

  ^...    negative class (lowest precedence operator)
  x-y     range from x to y
  [...]   set (character class in character class)
  ..&&..  intersection (low precedence at the next of ^)

    ex. [a-w&&[^c-g]z] ==> ([a-w] AND ([^c-g] OR z)) ==> [abh-w]

  * If you want to use '[', '-', ']' as a normal character
    in a character class, you should escape these characters by '\'.


  POSIX bracket ([:xxxxx:], negate [:^xxxxx:])

    Not Unicode Case:

      alnum    alphabet or digit char
      alpha    alphabet
      ascii    code value: [0 - 127]
      blank    \t, \x20
      cntrl
      digit    0-9
      graph    include all of multibyte encoded characters
      lower
      print    include all of multibyte encoded characters
      punct
      space    \t, \n, \v, \f, \r, \x20
      upper
      xdigit   0-9, a-f, A-F
      word     alphanumeric, "_" and multibyte characters


    Unicode Case:

      alnum    Letter | Mark | Decimal_Number
      alpha    Letter | Mark
      ascii    0000 - 007F
      blank    Space_Separator | 0009
      cntrl    Control | Format | Unassigned | Private_Use | Surrogate
      digit    Decimal_Number
      graph    [[:^space:]] && ^Control && ^Unassigned && ^Surrogate
      lower    Lowercase_Letter
      print    [[:graph:]] | [[:space:]]
      punct    Connector_Punctuation | Dash_Punctuation | Close_Punctuation |
               Final_Punctuation | Initial_Punctuation | Other_Punctuation |
               Open_Punctuation
      space    Space_Separator | Line_Separator | Paragraph_Separator |
               0009 | 000A | 000B | 000C | 000D | 0085
      upper    Uppercase_Letter
      xdigit   0030 - 0039 | 0041 - 0046 | 0061 - 0066
               (0-9, a-f, A-F)
      word     Letter | Mark | Decimal_Number | Connector_Punctuation



7. Extended groups

  (?#...)            comment

  (?imx-imx)         option on/off
                         i: ignore case
                         m: multi-line (dot(.) match newline)
                         x: extended form
  (?imx-imx:subexp)  option on/off for subexp

  (?:subexp)         not captured group
  (subexp)           captured group

  (?=subexp)         look-ahead
  (?!subexp)         negative look-ahead
  (?<=subexp)        look-behind
  (?<!subexp)        negative look-behind

                     Subexp of look-behind must be fixed character length.
                     But different character length is allowed in top level
                     alternatives only.
                     ex. (?<=a|bc) is OK. (?<=aaa(?:b|cd)) is not allowed.

                     In negative-look-behind, captured group isn't allowed, 
                     but shy group(?:) is allowed.

  (?>subexp)         atomic group
                     don't backtrack in subexp.

  (?<name>subexp), (?'name'subexp)
                     define named group
                     (All characters of the name must be a word character.)

                     Not only a name but a number is assigned like a captured
                     group.

                     Assigning the same name as two or more subexps is allowed.
                     In this case, a subexp call can not be performed although
                     the back reference is possible.


8. Back reference

  \n          back reference by group number (n >= 1)
  \k<name>    back reference by group name
  \k'name'    back reference by group name

  In the back reference by the multiplex definition name,
  a subexp with a large number is referred to preferentially.
  (When not matched, a group of the small number is referred to.)

  * Back reference by group number is forbidden if named group is defined 
    in the pattern and ONIG_OPTION_CAPTURE_GROUP is not setted.


  back reference with nest level

    \k<name+n>     n: 0, 1, 2, ...
    \k<name-n>     n: 0, 1, 2, ...
    \k'name+n'     n: 0, 1, 2, ...
    \k'name-n'     n: 0, 1, 2, ...

    Destinate relative nest level from back reference position.    

    ex 1.

      /\A(?<a>|.|(?:(?<b>.)\g<a>\k<b+0>))\z/.match("reer")

    ex 2.

      r = Regexp.compile(<<'__REGEXP__'.strip, Regexp::EXTENDED)
      (?<element> \g<stag> \g<content>* \g<etag> ){0}
      (?<stag> < \g<name> \s* > ){0}
      (?<name> [a-zA-Z_:]+ ){0}
      (?<content> [^<&]+ (\g<element> | [^<&]+)* ){0}
      (?<etag> </ \k<name+1> >){0}
      \g<element>
      __REGEXP__

      p r.match('<foo>f<bar>bbb</bar>f</foo>').captures



9. Subexp call ("Tanaka Akira special")

  \g<name>    call by group name
  \g'name'    call by group name
  \g<n>       call by group number (n >= 1)
  \g'n'       call by group number (n >= 1)

  * left-most recursive call is not allowed.
     ex. (?<name>a|\g<name>b)   => error
         (?<name>a|b\g<name>c)  => OK

  * Call by group number is forbidden if named group is defined in the pattern
    and ONIG_OPTION_CAPTURE_GROUP is not setted.

  * If the option status of called group is different from calling position
    then the group's option is effective.

    ex. (?-i:\g<name>)(?i:(?<name>a)){0}  match to "A"


10. Captured group

  Behavior of the no-named group (...) changes with the following conditions.
  (But named group is not changed.)

  case 1. /.../     (named group is not used, no option)

     (...) is treated as a captured group.

  case 2. /.../g    (named group is not used, 'g' option)

     (...) is treated as a no-captured group (?:...).

  case 3. /..(?<name>..)../   (named group is used, no option)

     (...) is treated as a no-captured group (?:...).
     numbered-backref/call is not allowed.

  case 4. /..(?<name>..)../G  (named group is used, 'G' option)

     (...) is treated as a captured group.
     numbered-backref/call is allowed.

  where
    g: ONIG_OPTION_DONT_CAPTURE_GROUP
    G: ONIG_OPTION_CAPTURE_GROUP

  ('g' and 'G' options are argued in ruby-dev ML)



-----------------------------
A-1. Syntax depend options

   + ONIG_SYNTAX_RUBY
     (?m): dot(.) match newline

   + ONIG_SYNTAX_PERL and ONIG_SYNTAX_JAVA
     (?s): dot(.) match newline
     (?m): ^ match after newline, $ match before newline


A-2. Original extensions

   + hexadecimal digit char type  \h, \H
   + named group                  (?<name>...), (?'name'...)
   + named backref                \k<name>
   + subexp call                  \g<name>, \g<group-num>


A-3. Lacked features compare with perl 5.8.0

   + \N{name}
   + \l,\u,\L,\U, \X, \C
   + (?{code})
   + (??{code})
   + (?(condition)yes-pat|no-pat)

   * \Q...\E
     This is effective on ONIG_SYNTAX_PERL and ONIG_SYNTAX_JAVA.


A-4. Differences with Japanized GNU regex(version 0.12) of Ruby 1.8

   + add character property (\p{property}, \P{property})
   + add hexadecimal digit char type (\h, \H)
   + add look-behind
     (?<=fixed-char-length-pattern), (?<!fixed-char-length-pattern)
   + add possessive quantifier. ?+, *+, ++
   + add operations in character class. [], &&
     ('[' must be escaped as an usual char in character class.)
   + add named group and subexp call.
   + octal or hexadecimal number sequence can be treated as 
     a multibyte code char in character class if multibyte encoding
     is specified.
     (ex. [\xa1\xa2], [\xa1\xa7-\xa4\xa1])
   + allow the range of single byte char and multibyte char in character
     class.
     ex. /[a-<<any EUC-JP character>>]/ in EUC-JP encoding.
   + effect range of isolated option is to next ')'.
     ex. (?:(?i)a|b) is interpreted as (?:(?i:a|b)), not (?:(?i:a)|b).
   + isolated option is not transparent to previous pattern.
     ex. a(?i)* is a syntax error pattern.
   + allowed incompleted left brace as an usual string.
     ex. /{/, /({)/, /a{2,3/ etc...
   + negative POSIX bracket [:^xxxx:] is supported.
   + POSIX bracket [:ascii:] is added.
   + repeat of look-ahead is not allowed.
     ex. /(?=a)*/, /(?!b){5}/
   + Ignore case option is effective to numbered character.
     ex. /\x61/i =~ "A"
   + In the range quantifier, the number of the minimum is omissible.
     /a{,n}/ == /a{0,n}/
     The simultanious abbreviation of the number of times of the minimum
     and the maximum is not allowed. (/a{,}/)
   + /a{n}?/ is not a non-greedy operator.
     /a{n}?/ == /(?:a{n})?/
   + invalid back reference is checked and cause error.
     /\1/, /(a)\2/
   + Zero-length match in infinite repeat stops the repeat,
     then changes of the capture group status are checked as stop condition.
     /(?:()|())*\1\2/ =~ ""
     /(?:\1a|())*/ =~ "a"


A-5. Disabled functions by default syntax

   + capture history

     (?@...) and (?@<name>...)

     ex. /(?@a)*/.match("aaa") ==> [<0-1>, <1-2>, <2-3>]

     see sample/listcap.c file.


A-6. Problems

   + Invalid encoding byte sequence is not checked in UTF-8.

     * Invalid first byte is treated as a character.
       /./u =~ "\xa3"

     * Incomplete byte sequence is not checked.
       /\w+/ =~ "a\xf3\x8ec"

// END

^ Directory of.*\.svn(.*$|$)\n(^.*\n)*?(^.*bytes$\n)\n

gedit `ruby -e "puts %q(m/notes%s.txt) % Time.now.strftime('%d%m%y')"`

public static void prueba(int a, String b) {

return 0;

}

require 'nokogiri'

Nokogiri.new()

buffer = File.open('deko6.svg','r').read
doc = Nokogiri::XML(buffer)
File.open('fudge.xml','w') {|f| doc.write_xml_to f}