package LatexIndent::GetYamlSettings; # 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, either version 3 of the License, or # (at your option) any later version. # # 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. # # See http://www.gnu.org/licenses/. # # Chris Hughes, 2017 # # For all communication, please visit: https://github.com/cmhughes/latexindent.pl use strict; use warnings; use Data::Dumper; use LatexIndent::Switches qw/%switches $is_m_switch_active $is_t_switch_active $is_tt_switch_active/; use YAML::Tiny; # interpret defaultSettings.yaml and other potential settings files use File::Basename; # to get the filename and directory path use File::HomeDir; use Cwd; use Exporter qw/import/; use LatexIndent::LogFile qw/$logger/; our @EXPORT_OK = qw/yaml_read_settings yaml_modify_line_breaks_settings yaml_get_indentation_settings_for_this_object yaml_poly_switch_get_every_or_custom_value yaml_get_indentation_information yaml_get_object_attribute_for_indentation_settings yaml_alignment_at_ampersand_settings %mainSettings %previouslyFoundSettings/; # Read in defaultSettings.YAML file our $defaultSettings; # master yaml settings is a hash, global to this module our %mainSettings; use LatexIndent::UTF8CmdLineArgsFileOperation qw/copy_with_encode exist_with_encode open_with_encode zero_with_encode read_yaml_with_encode/; use utf8; # previously found settings is a hash, global to this module our %previouslyFoundSettings; # default values for align at ampersand routine our @alignAtAmpersandInformation = ( { name => "lookForAlignDelims", yamlname => "delims", default => 1 }, { name => "alignDoubleBackSlash", default => 1 }, { name => "spacesBeforeDoubleBackSlash", default => 1 }, { name => "multiColumnGrouping", default => 0 }, { name => "alignRowsWithoutMaxDelims", default => 1 }, { name => "spacesBeforeAmpersand", default => 1 }, { name => "spacesAfterAmpersand", default => 1 }, { name => "justification", default => "left" }, { name => "alignFinalDoubleBackSlash", default => 0 }, { name => "dontMeasure", default => 0 }, { name => "delimiterRegEx", default => "(? "delimiterJustification", default => "left" }, { name => "leadingBlankColumn", default => -1 }, { name => "lookForChildCodeBlocks", default => 1 }, { name => "alignContentAfterDoubleBackSlash", default => 0 }, { name => "spacesAfterDoubleBackSlash", default => 1 }, ); sub yaml_read_settings { my $self = shift; # read the default settings $defaultSettings = YAML::Tiny->read("$FindBin::RealBin/defaultSettings.yaml") if ( -e "$FindBin::RealBin/defaultSettings.yaml" ); # grab the logger object $logger->info("*YAML settings read: defaultSettings.yaml"); $logger->info("Reading defaultSettings.yaml from $FindBin::RealBin/defaultSettings.yaml"); my $myLibDir = dirname(__FILE__); my ( $name, $dir, $ext ) = fileparse( $INC{"LatexIndent/GetYamlSettings.pm"}, "pm" ); $dir =~ s/\/$//; # if latexindent.exe is invoked from TeXLive, then defaultSettings.yaml won't be in # the same directory as it; we need to navigate to it if ( !$defaultSettings ) { $logger->info( "Reading defaultSettings.yaml (2nd attempt) from $FindBin::RealBin/../../texmf-dist/scripts/latexindent/defaultSettings.yaml" ); $logger->info("and then, if necessary, $FindBin::RealBin/LatexIndent/defaultSettings.yaml"); if ( -e "$FindBin::RealBin/../../texmf-dist/scripts/latexindent/defaultSettings.yaml" ) { $defaultSettings = YAML::Tiny->read("$FindBin::RealBin/../../texmf-dist/scripts/latexindent/defaultSettings.yaml"); } elsif ( -e "$FindBin::RealBin/LatexIndent/defaultSettings.yaml" ) { $defaultSettings = YAML::Tiny->read("$FindBin::RealBin/LatexIndent/defaultSettings.yaml"); } elsif ( -e "$dir/defaultSettings.yaml" ) { $defaultSettings = YAML::Tiny->read("$dir/defaultSettings.yaml"); } elsif ( -e "$myLibDir/defaultSettings.yaml" ) { +$defaultSettings = YAML::Tiny->read("$myLibDir/defaultSettings.yaml"); } else { $logger->fatal("*Could not open defaultSettings.yaml"); $self->output_logfile(); exit(2); } } # need to exit if we can't get defaultSettings.yaml if ( !$defaultSettings ) { $logger->fatal("*Could not open defaultSettings.yaml"); $self->output_logfile(); exit(2); } # master yaml settings is a hash, global to this module our %mainSettings = %{ $defaultSettings->[0] }; &yaml_update_dumper_settings(); # scalar to read user settings my $userSettings; # array to store the paths to user settings my @absPaths; # we'll need the home directory a lot in what follows my $homeDir = File::HomeDir->my_home; $logger->info("*YAML reading settings") unless $switches{onlyDefault}; my $indentconfig = undef; if ( defined $ENV{LATEXINDENT_CONFIG} && !$switches{onlyDefault} ) { if ( -f $ENV{LATEXINDENT_CONFIG} ) { $indentconfig = $ENV{LATEXINDENT_CONFIG}; $logger->info('The $LATEXINDENT_CONFIG variable was detected.'); $logger->info( 'The value of $LATEXINDENT_CONFIG is: "' . $ENV{LATEXINDENT_CONFIG} . '"' ); } else { $logger->warn('*The $LATEXINDENT_CONFIG variable is assigned, but does not point to a file!'); $logger->warn( 'The value of $LATEXINDENT_CONFIG is: "' . $ENV{LATEXINDENT_CONFIG} . '"' ); } } if ( !defined $indentconfig && !$switches{onlyDefault} ) { # see all possible values of $^O here: https://perldoc.perl.org/perlport#Unix and https://perldoc.perl.org/perlport#DOS-and-Derivatives if ( $^O eq "linux" ) { if ( defined $ENV{XDG_CONFIG_HOME} && -f "$ENV{XDG_CONFIG_HOME}/latexindent/indentconfig.yaml" ) { $indentconfig = "$ENV{XDG_CONFIG_HOME}/latexindent/indentconfig.yaml"; $logger->info( 'The $XDG_CONFIG_HOME variable and the config file in "' . "$ENV{XDG_CONFIG_HOME}/latexindent/indentconfig.yaml" . '" were recognized' ); $logger->info( 'The value of $XDG_CONFIG_HOME is: "' . $ENV{XDG_CONFIG_HOME} . '"' ); } elsif ( -f "$homeDir/.config/latexindent/indentconfig.yaml" ) { $indentconfig = "$homeDir/.config/latexindent/indentconfig.yaml"; $logger->info( 'The config file in "' . "$homeDir/.config/latexindent/indentconfig.yaml" . '" will be read' ); } } elsif ( $^O eq "darwin" ) { if ( -f "$homeDir/Library/Preferences/latexindent/indentconfig.yaml" ) { $indentconfig = "$homeDir/Library/Preferences/latexindent/indentconfig.yaml"; $logger->info( 'The config file in "' . "$homeDir/Library/Preferences/latexindent/indentconfig.yaml" . '" will be read' ); } } elsif ( $^O eq "MSWin32" || $^O eq "cygwin" ) { if ( defined $ENV{LOCALAPPDATA} && -f "$ENV{LOCALAPPDATA}/latexindent/indentconfig.yaml" ) { $indentconfig = "$ENV{LOCALAPPDATA}/latexindent/indentconfig.yaml"; $logger->info( 'The $LOCALAPPDATA variable and the config file in "' . "$ENV{LOCALAPPDATA}" . '\latexindent\indentconfig.yaml" were recognized' ); $logger->info( 'The value of $LOCALAPPDATA is: "' . $ENV{LOCALAPPDATA} . '"' ); } elsif ( -f "$homeDir/AppData/Local/latexindent/indentconfig.yaml" ) { $indentconfig = "$homeDir/AppData/Local/latexindent/indentconfig.yaml"; $logger->info( 'The config file in "' . "$homeDir" . '\AppData\Local\latexindent\indentconfig.yaml" will be read' ); } } # if $indentconfig is still not defined, fallback to the location in $homeDir if ( !defined $indentconfig ) { # if all of these don't exist check home directly, with the non hidden file $indentconfig = ( -f "$homeDir/indentconfig.yaml" ) ? "$homeDir/indentconfig.yaml" : undef; # if indentconfig.yaml doesn't exist, check for the hidden file, .indentconfig.yaml if ( !defined $indentconfig ) { $indentconfig = ( -f "$homeDir/.indentconfig.yaml" ) ? "$homeDir/.indentconfig.yaml" : undef; } $logger->info( 'The config file in "' . "$indentconfig" . '" will be read' ) if defined $indentconfig; } } # messages for indentconfig.yaml and/or .indentconfig.yaml if ( defined $indentconfig and -f $indentconfig and !$switches{onlyDefault} ) { # read the absolute paths from indentconfig.yaml $userSettings = YAML::Tiny->read("$indentconfig"); # update the absolute paths if ( $userSettings and ( ref( $userSettings->[0] ) eq 'HASH' ) and $userSettings->[0]->{paths} ) { $logger->info("Reading path information from $indentconfig"); # output the contents of indentconfig to the log file $logger->info( Dump \%{ $userSettings->[0] } ); # change the encoding of the paths according to the field `encoding` if ( $userSettings and ( ref( $userSettings->[0] ) eq 'HASH' ) and $userSettings->[0]->{encoding} ) { use Encode; my $encoding = $userSettings->[0]->{encoding}; my $encodingObject = find_encoding($encoding); # Check if the encoding is valid. if ( ref($encodingObject) ) { $logger->info("*Encoding of the paths is $encoding"); foreach ( @{ $userSettings->[0]->{paths} } ) { my $temp = $encodingObject->encode("$_"); $logger->info("Transform file encoding: $_ -> $temp"); push( @absPaths, $temp ); } } else { $logger->warn("*encoding \"$encoding\" not found"); $logger->warn("Ignore this setting and will take the default encoding."); @absPaths = @{ $userSettings->[0]->{paths} }; } } else # No such setting, and will take the default { # $logger->info("*Encoding of the paths takes the default."); @absPaths = @{ $userSettings->[0]->{paths} }; } } else { $logger->warn( "*The paths field cannot be read from $indentconfig; this means it is either empty or contains invalid YAML" ); $logger->warn( "See https://latexindentpl.readthedocs.io/en/latest/sec-indent-config-and-settings.html for an example" ); } } else { if ( $switches{onlyDefault} ) { $logger->info("*-d switch active: only default settings requested"); $logger->info("not reading USER settings from $indentconfig") if ( defined $indentconfig && -e $indentconfig ); $logger->info("Ignoring the -l switch: $switches{readLocalSettings} (you used the -d switch)") if ( $switches{readLocalSettings} ); $logger->info("Ignoring the -y switch: $switches{yaml} (you used the -d switch)") if ( $switches{yaml} ); $switches{readLocalSettings} = 0; $switches{yaml} = 0; } else { # give the user instructions on where to put the config file $logger->info("Home directory is $homeDir"); $logger->info("latexindent.pl didn't find indentconfig.yaml or .indentconfig.yaml"); $logger->info( "see all possible locations: https://latexindentpl.readthedocs.io/en/latest/sec-appendices.html#indentconfig-options)" ); } } # default value of readLocalSettings # # latexindent -l myfile.tex # # means that we wish to use localSettings.yaml if ( defined( $switches{readLocalSettings} ) and ( $switches{readLocalSettings} eq '' ) ) { $logger->info('*-l switch used without filename, will search for the following files in turn:'); $logger->info('localSettings.yaml,latexindent.yaml,.localSettings.yaml,.latexindent.yaml'); $switches{readLocalSettings} = 'localSettings.yaml,latexindent.yaml,.localSettings.yaml,.latexindent.yaml'; } # local settings can be called with a + symbol, for example # -l=+myfile.yaml # -l "+ myfile.yaml" # -l=myfile.yaml+ # which translates to, respectively # -l=localSettings.yaml,myfile.yaml # -l=myfile.yaml,localSettings.yaml # Note: the following is *not allowed*: # -l+myfile.yaml # and # -l + myfile.yaml # will *only* load localSettings.yaml, and myfile.yaml will be ignored my @localSettings; $logger->info("*YAML settings read: -l switch") if $switches{readLocalSettings}; # remove leading, trailing, and intermediate space $switches{readLocalSettings} =~ s/^\h*//g; $switches{readLocalSettings} =~ s/\h*$//g; $switches{readLocalSettings} =~ s/\h*,\h*/,/g; if ( $switches{readLocalSettings} =~ m/\+/ ) { $logger->info( "+ found in call for -l switch: will add localSettings.yaml,latexindent.yaml,.localSettings.yaml,.latexindent.yaml" ); # + can be either at the beginning or the end, which determines if where the comma should go my $commaAtBeginning = ( $switches{readLocalSettings} =~ m/^\h*\+/ ? q() : "," ); my $commaAtEnd = ( $switches{readLocalSettings} =~ m/^\h*\+/ ? "," : q() ); $switches{readLocalSettings} =~ s/\h*\+\h*/$commaAtBeginning ."localSettings.yaml,latexindent.yaml,.localSettings.yaml,.latexindent.yaml" .$commaAtEnd/ex; $logger->info("New value of -l switch: $switches{readLocalSettings}"); } # local settings can be separated by , # e.g # -l = myyaml1.yaml,myyaml2.yaml # and in which case, we need to read them all if ( $switches{readLocalSettings} =~ m/,/ ) { $logger->info("Multiple localSettings found, separated by commas:"); @localSettings = split( /,/, $switches{readLocalSettings} ); $logger->info( join( ', ', @localSettings ) ); } else { push( @localSettings, $switches{readLocalSettings} ) if ( $switches{readLocalSettings} ); } my $workingFileLocation = dirname( ${$self}{fileName} ); # add local settings to the paths, if appropriate foreach (@localSettings) { # check for an extension (.yaml) my ( $name, $dir, $ext ) = fileparse( $_, "yaml" ); # if no extension is found, append the current localSetting with .yaml $_ = $_ . ( $_ =~ m/\.\z/ ? q() : "." ) . "yaml" if ( !$ext ); # if the -l switch is called on its own, or else with + # and latexindent.pl is called from a different directory, then # we need to account for this if ( $_ =~ m/^[.]?(localSettings|latexindent)\.yaml$/ ) { # check for existence in the directory of the file. if ( ( -e $workingFileLocation . "/" . $_ ) ) { $_ = $workingFileLocation . "/" . $_; # otherwise we fallback to the current directory } elsif ( ( -e cwd() . "/" . $_ ) ) { $_ = cwd() . "/" . $_; } } # diacritics in YAML names (highlighted in https://github.com/cmhughes/latexindent.pl/pull/439) #$_ = decode( "utf-8", $_ ); $_ = $_; # check for existence and non-emptiness if ( exist_with_encode($_) and !( zero_with_encode($_) ) ) { $logger->info("Adding $_ to YAML read paths"); push( @absPaths, "$_" ); } elsif ( !( exist_with_encode($_) ) ) { if (( $_ =~ m/localSettings|latexindent/s and !( -e 'localSettings.yaml' ) and !( -e '.localSettings.yaml' ) and !( -e 'latexindent.yaml' ) and !( -e '.latexindent.yaml' ) ) or $_ !~ m/localSettings|latexindent/s ) { $logger->warn("*yaml file not found: $_ not found. Proceeding without it."); } } } # heading for the log file $logger->info("*YAML settings, reading from the following files:") if @absPaths; # read in the settings from each file foreach my $settings (@absPaths) { # check that the settings file exists and that it isn't empty if ( exist_with_encode($settings) and !( zero_with_encode($settings) ) ) { $logger->info("Reading USER settings from $settings"); $userSettings = read_yaml_with_encode("$settings"); # update the absolute paths if ( $userSettings and ( ref( $userSettings->[0] ) eq 'HASH' ) and $userSettings->[0]->{paths} ) { $logger->info("Reading path information from $settings"); # output the contents of indentconfig to the log file $logger->info( Dump \%{ $userSettings->[0] } ); foreach ( @{ $userSettings->[0]->{paths} } ) { push( @absPaths, $_ ); } } # if we can read userSettings if ($userSettings) { # update the MASTER settings to include updates from the userSettings while ( my ( $firstLevelKey, $firstLevelValue ) = each %{ $userSettings->[0] } ) { # the update approach is slightly different for hashes vs scalars/arrays if ( ref($firstLevelValue) eq "HASH" ) { while ( my ( $secondLevelKey, $secondLevelValue ) = each %{ $userSettings->[0]{$firstLevelKey} } ) { if ( ref $secondLevelValue eq "HASH" ) { # if mainSettings already contains a *scalar* value in secondLevelKey # then we need to delete it (test-cases/headings-first.tex with indentRules1.yaml first demonstrated this) if ( defined $mainSettings{$firstLevelKey}{$secondLevelKey} and ref $mainSettings{$firstLevelKey}{$secondLevelKey} ne "HASH" ) { $logger->trace( "*mainSettings{$firstLevelKey}{$secondLevelKey} currently contains a *scalar* value, but it needs to be updated with a hash (see $settings); deleting the scalar" ) if ($is_t_switch_active); delete $mainSettings{$firstLevelKey}{$secondLevelKey}; } while ( my ( $thirdLevelKey, $thirdLevelValue ) = each %{$secondLevelValue} ) { if ( ref $thirdLevelValue eq "HASH" ) { # similarly for third level if ( defined $mainSettings{$firstLevelKey}{$secondLevelKey}{$thirdLevelKey} and ref $mainSettings{$firstLevelKey}{$secondLevelKey}{$thirdLevelKey} ne "HASH" ) { $logger->trace( "*mainSettings{$firstLevelKey}{$secondLevelKey}{$thirdLevelKey} currently contains a *scalar* value, but it needs to be updated with a hash (see $settings); deleting the scalar" ) if ($is_t_switch_active); delete $mainSettings{$firstLevelKey}{$secondLevelKey}{$thirdLevelKey}; } while ( my ( $fourthLevelKey, $fourthLevelValue ) = each %{$thirdLevelValue} ) { $mainSettings{$firstLevelKey}{$secondLevelKey}{$thirdLevelKey} {$fourthLevelKey} = $fourthLevelValue; } } else { $mainSettings{$firstLevelKey}{$secondLevelKey}{$thirdLevelKey} = $thirdLevelValue; } } } else { # settings such as commandCodeBlocks can have arrays, which may wish # to be amalgamated, rather than overwritten if ( ref($secondLevelValue) eq "ARRAY" and ${ ${ $mainSettings{$firstLevelKey}{$secondLevelKey} }[0] }{amalgamate} and !( ref( ${$secondLevelValue}[0] ) eq "HASH" and defined ${$secondLevelValue}[0]{amalgamate} and !${$secondLevelValue}[0]{amalgamate} ) ) { $logger->trace("*$firstLevelKey -> $secondLevelKey, amalgamate: 1") if ($is_t_switch_active); foreach ( @{$secondLevelValue} ) { $logger->trace("$_") if ($is_t_switch_active); push( @{ $mainSettings{$firstLevelKey}{$secondLevelKey} }, $_ ) unless ( ref($_) eq "HASH" ); } # remove duplicated entries, https://stackoverflow.com/questions/7651/how-do-i-remove-duplicate-items-from-an-array-in-perl my %seen = (); my @unique = grep { !$seen{$_}++ } @{ $mainSettings{$firstLevelKey}{$secondLevelKey} }; @{ $mainSettings{$firstLevelKey}{$secondLevelKey} } = @unique; $logger->trace( "*master settings for $firstLevelKey -> $secondLevelKey now look like:") if $is_t_switch_active; foreach ( @{ $mainSettings{$firstLevelKey}{$secondLevelKey} } ) { $logger->trace("$_") if ($is_t_switch_active); } } else { $mainSettings{$firstLevelKey}{$secondLevelKey} = $secondLevelValue; } } } } elsif ( ref($firstLevelValue) eq "ARRAY" ) { # update amalgamate in master settings if ( ref( ${$firstLevelValue}[0] ) eq "HASH" and defined ${$firstLevelValue}[0]{amalgamate} ) { ${ $mainSettings{$firstLevelKey}[0] }{amalgamate} = ${$firstLevelValue}[0]{amalgamate}; shift @{$firstLevelValue} if ${ $mainSettings{$firstLevelKey}[0] }{amalgamate}; } # if amalgamate is set to 1, then append if ( ref( $mainSettings{$firstLevelKey}[0] ) eq "HASH" and ${ $mainSettings{$firstLevelKey}[0] }{amalgamate} ) { # loop through the other settings foreach ( @{$firstLevelValue} ) { push( @{ $mainSettings{$firstLevelKey} }, $_ ); } } else { # otherwise overwrite $mainSettings{$firstLevelKey} = $firstLevelValue; } } else { $mainSettings{$firstLevelKey} = $firstLevelValue; } } # output settings to $logfile if ( $mainSettings{logFilePreferences}{showEveryYamlRead} ) { $logger->info( Dump \%{ $userSettings->[0] } ); } else { $logger->info( "Not showing settings in the log file (see showEveryYamlRead and showAmalgamatedSettings)."); } # warning to log file if modifyLineBreaks specified and m switch not active if ( ${ $userSettings->[0] }{modifyLineBreaks} and !$is_m_switch_active ) { $logger->warn("*modifyLineBreaks specified and m switch is *not* active"); $logger->warn("perhaps you intended to call"); $logger->warn(" latexindent.pl -m -l $settings ${$self}{fileName}"); } } else { # otherwise print a warning that we can not read userSettings.yaml $logger->warn("*$settings contains invalid yaml format- not reading from it"); } } else { # otherwise keep going, but put a warning in the log file $logger->warn("*$homeDir/indentconfig.yaml"); if ( zero_with_encode($settings) ) { $logger->info("specifies $settings but this file is EMPTY -- not reading from it"); } else { $logger->info( "specifies $settings but this file does not exist - unable to read settings from this file"); } } &yaml_update_dumper_settings(); } # read settings from -y|--yaml switch if ( $switches{yaml} ) { # report to log file $logger->info("*YAML settings read: -y switch"); # remove any horizontal space before or after , OR : OR ; or at the beginning or end of the switch value $switches{yaml} =~ s/\h*(,|(?info( "YAML setting: " . $_ ); } # it is possible to specify, for example, # # -y=indentAfterHeadings:paragraph:indentAfterThisHeading:1;level:1 # -y=specialBeginEnd:displayMath:begin:'\\\[';end: '\\\]';lookForThis: 1 # # which should be translated into # # indentAfterHeadings: # paragraph: # indentAfterThisHeading:1 # level:1 # # so we need to loop through the comma separated list and search # for semi-colons my $settingsCounter = 0; my @originalYamlSettings = @yamlSettings; foreach (@originalYamlSettings) { # increment the counter $settingsCounter++; # need to be careful in splitting at ';' # # motivation as detailed in https://github.com/cmhughes/latexindent.pl/issues/243 # # latexindent.pl -m -y='modifyLineBreaks:oneSentencePerLine:manipulateSentences: 1, # modifyLineBreaks:oneSentencePerLine:sentencesBeginWith:a-z: 1, # fineTuning:modifyLineBreaks:betterFullStop: "(?:\.|;|:(?![a-z]))|(?:(?trace("*Sub-field detected (; present) and the root is: $root") if $is_t_switch_active; # now we need to attach the $root back together with any subfields foreach (@subfield) { # splice the new field into @yamlSettings (reference: https://perlmaven.com/splice-to-slice-and-dice-arrays-in-perl) splice @yamlSettings, $settingsCounter, 0, $root . ":" . $_; # increment the counter $settingsCounter++; } $logger->info( "-y switch value interpreted as: " . join( ',', @yamlSettings ) ); } } # loop through each of the settings specified in the -y switch foreach (@yamlSettings) { my @keysValues; # as above, need to be careful in splitting at ':' # # motivation as detailed in https://github.com/cmhughes/latexindent.pl/issues/243 # # latexindent.pl -m -y='modifyLineBreaks:oneSentencePerLine:manipulateSentences: 1, # modifyLineBreaks:oneSentencePerLine:sentencesBeginWith:a-z: 1, # fineTuning:modifyLineBreaks:betterFullStop: "(?:\.|;|:(?![a-z]))|(?:(?info("quote found in -y switch"); $logger->info( "key: " . $splitAtQuote[0] ); # definition check $splitAtQuote[1] = '' if not defined $splitAtQuote[1]; # then log the value $logger->info( "value: " . $splitAtQuote[1] ); # split at : (@keysValues) = split( /(?info("double-quoted string found in -y switch: $raw_value, substitute to $value"); } elsif ( $value =~ m/^'(.*)'$/ ) { # single-quoted string my $raw_value = $value; $value = $1; # special treatment for tabs and newlines # translate: '\t', '\n' # only translate string starts with an odd number of escape characters '\' $value =~ s/(?info("single-quoted string found in -y switch: $raw_value, substitute to $value"); } if ( scalar(@keysValues) == 2 ) { # for example, -y="defaultIndent: ' '" my $key = $keysValues[0]; $logger->info("Updating mainSettings with $key: $value"); $mainSettings{$key} = $value; } elsif ( scalar(@keysValues) == 3 ) { # for example, -y="indentRules: one: '\t\t\t\t'" my $parent = $keysValues[0]; my $child = $keysValues[1]; $logger->info("Updating mainSettings with $parent: $child: $value"); $mainSettings{$parent}{$child} = $value; } elsif ( scalar(@keysValues) == 4 ) { # for example, -y='modifyLineBreaks : environments: EndStartsOnOwnLine:3' -m my $parent = $keysValues[0]; my $child = $keysValues[1]; my $grandchild = $keysValues[2]; delete $mainSettings{$parent}{$child} if (defined $mainSettings{$parent}{$child} and ref $mainSettings{$parent}{$child} ne "HASH" ); $logger->info("Updating mainSettings with $parent: $child: $grandchild: $value"); $mainSettings{$parent}{$child}{$grandchild} = $value; } elsif ( scalar(@keysValues) == 5 ) { # for example, -y='modifyLineBreaks : environments: one: EndStartsOnOwnLine:3' -m my $parent = $keysValues[0]; my $child = $keysValues[1]; my $grandchild = $keysValues[2]; my $greatgrandchild = $keysValues[3]; $logger->info("Updating mainSettings with $parent: $child: $grandchild: $greatgrandchild: $value"); $mainSettings{$parent}{$child}{$grandchild}{$greatgrandchild} = $value; } &yaml_update_dumper_settings(); } } # the following are incompatible: # # modifyLineBreaks: # oneSentencePerLine: # manipulateSentences: 1 # textWrapSentences: 1 # sentenceIndent: " "