AppConfig(3)

okay bestie, welcome to the AppConfig(3) manual page (User Contributed Perl Documentation, if we're being fancy ✨) — grab a lil snack, this one's a long read but it's so worth it 💅

🌸 NAME 🌸

AppConfig — a Perl5 module for reading configuration files and parsing command line arguments. That's it, that's the whole vibe 🎀

✨ SYNOPSIS ✨

    use AppConfig;

    # create a new AppConfig object
    my $config = AppConfig->new( \%cfg );

    # define a new variable
    $config->define( $varname => \%varopts );

    # create/define combined
    my $config = AppConfig->new( \%cfg,
        $varname => \%varopts,
        $varname => \%varopts,
        ...
    );

    # set/get the value
    $config->set( $varname, $value );
    $config->get($varname);

    # shortcut form
    $config->varname($value);
    $config->varname;

    # read configuration file
    $config->file($file);

    # parse command line options
    $config->args(\@args);      # default to \@ARGV

    # advanced command line options with Getopt::Long
    $config->getopt(\@args);    # default to \@ARGV

    # parse CGI parameters (GET method)
    $config->cgi($query);       # default to $ENV{ QUERY_STRING }

🦋 OVERVIEW 🦋

So like, AppConfig is a Perl5 module for managing application configuration information. It keeps track of the state of literally any number of variables, and it hands you methods for parsing configuration files, command line arguments, and CGI script parameters. Main character energy tbh 👑

Variables' values can be set from configuration files. A variable can be a flag (On/Off), it can take a single value, or it can take multiple values stored as a list or a hash. How many arguments a variable expects? That's decided by its config when you define it. Slay.

    # flags
    verbose
    nohelp
    debug = On

    # single value
    home  = /home/abw/

    # multiple list value
    file = /tmp/file1
    file = /tmp/file2

    # multiple hash value
    book  camel = Programming Perl
    book  llama = Learning Perl

The - prefix resets a variable to its default value, and the + prefix sets it to 1. cute lil shortcuts, no cap:

    -verbose
    +debug

Variable expansion, environment variable expansion, and tilde (home directory) expansion can all be applied — selectively, if you need to be picky about it — to the values read from configuration files:

    home = ~                    # home directory
    nntp = ${NNTPSERVER}        # environment variable
    html = $home/html           # internal variables
    img  = $html/images

Configuration files can also be arranged in blocks, Win32 "INI" file style 🎀

    [file]
    site = kfs
    src  = ~/websrc/docs/$site
    lib  = ~/websrc/lib
    dest = ~/public_html/$site

    [page]
    header = $lib/header
    footer = $lib/footer

You can also use Perl's "heredoc" syntax to define a big block of text inside a configuration file. iconic behavior:

    multiline = <<FOOBAR
    line 1
    line 2
    FOOBAR

    paths  exe  = "${PATH}:${HOME}/.bin"
    paths  link = <<'FOO'
    ${LD_LIBARRAY_PATH}:${HOME}/lib
    FOO

Variables can get set by parsing command line arguments too:

    myapp -verbose -site kfs -file f1 -file f2

AppConfig gives you a simple method (args()) for parsing command line arguments. And there's a second method (getopt()) that handles way more complex argument processing by delegating to Johan Vroman's Getopt::Long module. fancy 💅

AppConfig also lets variables be set by parameters passed to a CGI script via the URL (GET method):

    http://www.nowhere.com/cgi-bin/myapp?verbose&site=kfs

🧚 PREREQUISITES 🧚

AppConfig requires Perl 5.005 or later. fr fr.

The Getopt::Long and Test::More modules should be installed. If you're on a recent version of Perl (e.g. 5.8.0) then these should already be installed, bestie, you're probably fine 💖

🍓 OBTAINING AND INSTALLING THE AppConfig MODULE BUNDLE 🍓

The AppConfig module bundle is available from CPAN. As the 'perlmod' manual page explains:

    CPAN stands for the Comprehensive Perl Archive Network.
    This is a globally replicated collection of all known Perl
    materials, including hundreds of unbundled modules.

    [...]

    For an up-to-date listing of CPAN sites, see
    http://www.perl.com/perl/ or ftp://ftp.perl.com/perl/ .

Within the CPAN archive, AppConfig is in the category:

    12) Option, Argument, Parameter and Configuration File Processing

The module is available in the following directories:

    /modules/by-module/AppConfig/AppConfig-<version>.tar.gz
    /authors/id/ABW/AppConfig-<version>.tar.gz

AppConfig is distributed as a single gzipped tar archive file:

    AppConfig-<version>.tar.gz

Note that <version> represents the current AppConfig version number, of the form n.nn, e.g. 3.14. Peep the REVISION section below to figure out the current version number for AppConfig 👀

Unpack the archive to create a AppConfig installation directory:

    gunzip AppConfig-<version>.tar.gz
    tar xvf AppConfig-<version>.tar

cd into that directory, make, test and install the modules:

    cd AppConfig-<version>
    perl Makefile.PL
    make
    make test
    make install

The 't' sub-directory contains a bunch of test scripts that get run when a 'make test' is run.

The 'make install' will install the module on your system. You might need administrator privileges for that one, sorry 😭 If you install the module in a local directory (for example, by executing perl Makefile.PL LIB=~/lib in the above — see "perldoc MakeMaker" for full details), you'll need to make sure the PERL5LIB environment variable is set to include the location, or add a line to your scripts explicitly naming the library location:

    use lib '/local/path/to/lib';

The 'examples' sub-directory contains some simple examples of using the AppConfig modules 🫶

💜 DESCRIPTION 💜

USING THE AppConfig MODULE

To import and use the AppConfig module, this line should appear in your Perl script:

     use AppConfig;

To import constants defined by the AppConfig module, pass the name of one or more of the constant or tag sets as parameters to use:

    use AppConfig qw(:expand :argcount);

See "CONSTANT DEFINITIONS" below for more info on the constant tagsets AppConfig defines ✨

AppConfig is implemented using object-oriented methods. A new AppConfig object gets created and initialized using the new() method. This returns a reference to a new AppConfig object.

    my $config = AppConfig->new();

This will create and return a reference to a new AppConfig object. slay.

In doing so, the AppConfig object also creates an internal reference to an AppConfig::State object, and that's where variable state lives. All arguments passed into the AppConfig constructor get passed directly to the AppConfig::State constructor.

The first (optional) parameter may be a reference to a hash array containing configuration information.

    my $config = AppConfig->new( {
            CASE   => 1,
            ERROR  => \&my_error,
            GLOBAL => {
                    DEFAULT  => "<unset>",
                    ARGCOUNT => ARGCOUNT_ONE,
                },
        } );

See AppConfig::State for full details of the configuration options available. In brief, they are:

• CASE — sets case sensitivity for variable names (default: off).
• CREATE — says undefined variables should be created automatically (default: off).
• GLOBAL — a reference to a hash array of global values used by default when defining variables. Valid global values are DEFAULT, ARGCOUNT, EXPAND, VALIDATE and ACTION.
• PEDANTIC — says the command line and configuration file parsing routines should return immediately on encountering an error.
• ERROR — lets you provide a error handling routine. Arguments as per printf().

Subsequent parameters may be variable definitions. These get passed to the define() method, described below in "DEFINING VARIABLES" 💖

    my $config = AppConfig->new("foo", "bar", "baz");
    my $config = AppConfig->new( { CASE => 1 }, qw(foo bar baz) );

Note that any unresolved method calls to AppConfig are automatically delegated to the AppConfig::State object. In practice, that means you can treat the AppConfig object as if it were an AppConfig::State object:

    # create AppConfig
    my $config = AppConfig->new('foo', 'bar');

    # methods get passed through to internal AppConfig::State
    $config->foo(100);
    $config->set('bar', 200);
    $config->define('baz');
    $config->baz(300);

DEFINING VARIABLES

The define() method (delegated to AppConfig::State) is what you use to pre-declare a variable and specify its configuration.

    $config->define("foo");

Variables can also be defined straight from the AppConfig new() constructor:

    my $config = AppConfig->new("foo");

In both simple examples above, a new variable called "foo" is defined. You can also pass a reference to a hash array to specify configuration information for the variable:

    $config->define("foo", {
            DEFAULT   => 99,
            ALIAS     => 'metavar1',
        });

Configuration items specified in the GLOBAL option to the module constructor get applied by default when variables are created. e.g.

    my $config = AppConfig->new( {
        GLOBAL => {
            DEFAULT  => "<undef>",
            ARGCOUNT => ARGCOUNT_ONE,
        }
    } );

    $config->define("foo");
    $config->define("bar", { ARGCOUNT => ARGCOUNT_NONE } );

is equivalent to:

    my $config = AppConfig->new();

    $config->define( "foo", {
        DEFAULT  => "<undef>",
        ARGCOUNT => ARGCOUNT_ONE,
    } );

    $config->define( "bar",
        DEFAULT  => "<undef>",
        ARGCOUNT => ARGCOUNT_NONE,
    );

Multiple variables can be defined in the same call to define(). Configuration hashes for variables can be omitted. yes bestie, it's flexible like that 💅

    $config->define("foo", "bar" => { ALIAS = "boozer" }, "baz");

See AppConfig::State for full details of the configuration options available when defining variables. In brief, they are:

• DEFAULT — the default value for the variable (default: undef).
• ALIAS — one or more (list reference or "list|like|this") alternative names for the variable.
• ARGCOUNT — specifies the number and type of arguments that the variable expects. Constants in the :expand tag set define ARGCOUNT_NONE — a simple on/off flag (default), ARGCOUNT_ONE — single value, ARGCOUNT_LIST — multiple values accessed via list reference, ARGCOUNT_HASH — hash table, "key=value", accessed via hash reference.

---

🎀 ARGS

Lowkey the multitasker — this hands an argument spec string straight to Getopt::Long via AppConfig::Getopt. Like, for example, "=i", ":s", "=s@". 💅

And plot twist: you can use it to implicitly set the ARGCOUNT value too:

• "/^!/" → ARGCOUNT_NONE
• "/@/" → ARGCOUNT_LIST
• "/%/" → ARGCOUNT_HASH
• "/[=:].*/" → ARGCOUNT_ONE

---

✨ EXPAND

Tells AppConfig which variable expansion policies to use when it's parsing configuration files. The constants live in the :expand tag set and they are:

• EXPAND_NONE — no expansion (this is the default, bestie)
• EXPAND_VAR — expand $var or $(var) as other variables
• EXPAND_UID — expand ~ and ~uid as the user's home directory
• EXPAND_ENV — expand ${var} as an environment variable
• EXPAND_ALL — do all the expansions, go off 👑

---

💖 VALIDATE

A regex that the intended variable value should match, or a code reference that returns 1 to say "yep, validation passed" (at which point the variable may now be set).

---

🌸 ACTION

A code reference that gets called whenever the variable value changes. Little notification hook, iykyk.

---

🦋 COMPACT FORMAT DEFINITION

Okay so you can also define variables with a compact format — it's literally identical to the specification format of Getopt::Long, and it goes like this:

"name|alias|alias<argopts>"

The first element is the variable name, and then you can pile on extra ALIAS values, each one separated by a vertical bar '|'.

The <argopts> element is where the ARGCOUNT value goes, and it can be any of these:

!                  ARGCOUNT_NONE
=s                 ARGCOUNT_ONE
=s@                ARGCOUNT_LIST
=s%                ARGCOUNT_HASH

Getopt::Long supports extra constructs, and you can absolutely use those instead of the "=s" element (like "=f", for instance). The whole entire <argopts> element gets stored in the ARGS parameter for the variable and passed through intact to Getopt::Long when the getopt() method is called. 🫶

Here's the compact format in action, paired with its equivalent full specification:

$config->define("foo|bar|baz!");

$config->define(
        "foo" => {
            ALIAS    => "bar|baz",
            ARGCOUNT => ARGCOUNT_NONE,
        });

$config->define("name=s");

$config->define(
        "name" => {
            ARGCOUNT => ARGCOUNT_ONE,
        });

$config->define("file|filelist|f=s@");

$config->define(
        "file" => {
            ALIAS    => "filelist|f",
            ARGCOUNT => ARGCOUNT_LIST,
        });

$config->define("user|u=s%");

$config->define(
        "user" => {
            ALIAS    => "u",
            ARGCOUNT => ARGCOUNT_HASH,
        });

You can still add extra config options by hash reference, same as usual. But heads up: the compact definition format will override any configuration values you provided for ARGS and ARGCOUNT.

$config->define("file|filelist|f=s@", { VALIDATE => \&check_file } );

---

🌈 READING AND MODIFYING VARIABLE VALUES

AppConfig defines two methods (via AppConfig::State) for messing with variable values:

set($variable, $value);
get($variable);

Once a variable is defined, you can access it directly as an object method — the method name is just the same as the variable name. So:

$config->set("verbose", 1);

is equivalent to

$config->verbose(1);

Okay but here's the thing you need to know 👀 — AppConfig defines these methods:

new();
file();
args();
getopt();

And also, by delegating to AppConfig::State:

define()
get()
set()
varlist()

So if you define a variable with one of those names, you will not be able to access it directly as an object method. Like:

$config->file();

That's gonna call the file() method instead of returning the value of the 'file' variable. Not me finding that out the hard way 😭. The workaround is to explicitly call get() and set() on a variable whose name conflicts:

$config->get('file');

or to define a "safe" alias that the variable can be accessed through:

$config->define("file", { ALIAS => "fileopt" });

or

$config->define("file|fileopt");

...
$config->fileopt();

Without parameters, the current value of the variable is returned. If you do pass a parameter, the variable gets set to that value and the result of the set() operation comes back to you.

$config->age(29);        # sets 'age' to 29, returns 1 (ok)
print $config->age();    # prints "29"

The varlist() method extracts a bunch of variables into a hash array. First parameter should be a regular expression that gets matched against the variable names.

my %vars = $config->varlist("^file");   # all "file*" variables

You can pass a second parameter (any true value) to say "hey, strip the part of the variable name that matched the regex when you copy it into the target hash":

$config->file_name("/tmp/file");
$config->file_path("/foo:/bar:/baz");

my %vars = $config->varlist("^file_", 1);

# %vars:
#    name => /tmp/file
#    path => "/foo:/bar:/baz"

---

🧚 READING CONFIGURATION FILES

AppConfig gives you a streamlined interface for reading configuration files, courtesy of the AppConfig::File module. The file() method auto-loads AppConfig::File and creates an object to process the config file (or files). Variables chillin' in the internal AppConfig::State get automatically updated with whatever values are specified in the configuration file. ✨

$config->file($filename);

You can pass multiple files to file() — either the file name, or a reference to an open file handle or glob.

$config->file($filename, $filehandle, \*STDIN, ...);

The file can contain blank lines and comments (prefixed by '#') and those just get ignored. Continuation lines are marked by ending the line with a '\'.

# this is a comment
callsign = alpha bravo camel delta echo foxtrot golf hipowls \
           india juliet kilo llama mike november oscar papa  \
           quebec romeo sierra tango umbrella victor whiskey \
           x-ray yankee zebra

Variables that are simple flags and don't expect an argument (ARGCOUNT = ARGCOUNT_NONE) can be specified with no value at all. They get set to 1, and any value explicitly specified (except "0" and "off") is just ignored. You can also slap a "no" prefix on the variable to implicitly set it to 0. 💅

verbose                              # on  (1)
verbose = 1                          # on  (1)
verbose = 0                          # off (0)
verbose off                          # off (0)
verbose on                           # on  (1)
verbose mumble                       # on  (1)
noverbose                            # off (0)

Variables that do expect an argument (ARGCOUNT = ARGCOUNT_ONE) get set to whatever follows the variable name, all the way to the end of the current line (continuation lines included, bestie). You can stick an optional equals sign between the variable and the value for clarity — it's giving organized.

room = /home/kitchen
room   /home/bedroom

And every subsequent re-definition of the variable value just overwrites the previous one. Periodt.

print $config->room();               # prints "/home/bedroom"

Variables can be defined to accept multiple values (ARGCOUNT = ARGCOUNT_LIST). Each subsequent definition of the variable adds the value to the list of values already set for it. 🍓

drink = coffee
drink = tea

A reference to a list of values comes back when you request the variable:

my $beverages = $config->drink();
print join(", ", @$beverages);      # prints "coffee, tea"

Variables can also be defined as hash lists (ARGCOUNT = ARGCOUNT_HASH). Each subsequent definition creates a new key and value in the hash array.

alias l="ls -CF"
alias e="emacs"

A reference to the hash comes back when you request the variable:

my $aliases = $config->alias();
foreach my $k (keys %$aliases) {
    print "$k => $aliases->{ $k }\n";
}

The '-' prefix resets a variable to its default value, and the '+' prefix sets it to 1. Cute, right? 🎀

-verbose
+debug

---

💜 VARIABLE EXPANSION

Variable values can contain references to other AppConfig variables, environment variables, and/or users' home directories. Whether those get expanded depends on the EXPAND value for each variable, or on the GLOBAL EXPAND value.

There are three different expansion types you can apply:

bin = ~/bin          # expand '~' to home dir if EXPAND_UID
tmp = ~abw/tmp       # as above, but home dir for user 'abw'

perl = $bin/perl     # expand value of 'bin' variable if EXPAND_VAR
ripl = $(bin)/ripl   # as above with explicit parens

home = ${HOME}       # expand HOME environment var if EXPAND_ENV

See AppConfig::State for more info on expanding variable values. 👑

Configuration files can have variables arranged in blocks, too. A block header — that's the block name sitting in square brackets — introduces a configuration block. The block name plus an underscore then gets prefixed onto the names of all variables referenced in that block afterwards. The block keeps going until the next block definition or until the end of the current file.

[block1]
foo = 10             # block1_foo = 10

[block2]
foo = 20             # block2_foo = 20

---

⭐ PARSING COMMAND LINE OPTIONS

Two whole methods for processing command line options, bestie, pick your fighter:

The first, args(), is a small and efficient little implementation that offers basic functionality. The second, getopt(), offers a way more powerful and complete facility by delegating the task to Johan Vroman's Getopt::Long module. The trade-off between args() and getopt() is essentially speed/size against flexibility — so use whichever fits. Both of them implement on-demand loading of modules and incur zero overhead until they're actually used. Slay. 🔥

The args() method parses simple command line options. It automatically loads the AppConfig::Args module and creates an object to process the command line arguments. Variables stored in the internal AppConfig::State get automatically updated with the values specified in the arguments.

You should pass it a reference to a list of arguments to parse. If you call args() with no parameters, the @ARGV array gets used.

$config->args(\@myargs);
$config->args();               # uses @ARGV

Arguments get read and shifted off the array until the first one is encountered that is not prefixed by '-' or '--'. At that point the method returns 1 to indicate success, leaving any unprocessed arguments remaining in the list. 🦋

Okay bestie, so each argument should be the name or alias of a variable prefixed by - or -- ✨. If an argument isn’t prefixed like that — and it’s not an additional parameter to the previous argument — it’ll cause a warning to be raised 😭. If the PEDANTIC option is set, the method returns 0 immediately. With PEDANTIC unset (the default), the method keeps parsing the rest of the arguments, returning 0 when it’s done 💅.

If the variable is a simple flag (ARGCOUNT = ARGCOUNT_NONE), then it’s set to 1. The variable may be prefixed by "no" to set its value to 0.

myprog -verbose --debug -notaste     # $config->verbose(1)
                                     # $config->debug(1)
                                     # $config->taste(0)

Variables that expect an additional argument (ARGCOUNT != 0) get set to the value of the argument following it.

myprog -f /tmp/myfile                # $config->file('/tmp/file');

Variables that expect multiple values (ARGCOUNT = ARGCOUNT_LIST or ARGCOUNT_HASH) have successive values added each time the option is encountered.

myprog -file /tmp/foo -file /tmp/bar # $config->file('/tmp/foo')
                                     # $config->file('/tmp/bar')

# file => [ '/tmp/foo', '/tmp/bar' ]

myprog -door "jim=Jim Morrison" -door "ray=Ray Manzarek"
                                     # $config->door("jim=Jim Morrison");
                                     # $config->door("ray=Ray Manzarek");

# door => { 'jim' => 'Jim Morrison', 'ray' => 'Ray Manzarek' }

See AppConfig::Args for further details on parsing command line arguments 🌸.

The getopt() method is the glow-up that lets you use the power and flexibility of the Getopt::Long module to parse command line arguments, and have the internal values of the AppConfig object update automatically 👑.

The first parameters (as long as they’re not list references) can be configuration strings to pass to Getopt::Long::Configure. A reference to a list of arguments may additionally be passed, or @ARGV is used by default.

$config->getopt();                       # uses @ARGV
$config->getopt(\@myargs);
$config->getopt(qw(auto_abbrev debug));  # uses @ARGV
$config->getopt(qw(debug), \@myargs);

See Getopt::Long for details of the configuration options available ✨.

The getopt() method constructs a specification string for each internal variable and then initializes Getopt::Long with those values. The specification string is constructed from the name, any aliases (delimited by a vertical bar |), and the value of the ARGS parameter.

$config->define("foo", {
    ARGS  => "=i",
    ALIAS => "bar|baz",
});

# Getopt::Long specification: "foo|bar|baz=i"

Errors and warnings generated by the Getopt::Long module are trapped and handled by the AppConfig error handler. That may be a user-defined routine installed with the ERROR configuration option 💖.

⚠️ Please note that the AppConfig::Getopt interface is still experimental and may not be 100% operational. This is almost undoubtedly due to problems in AppConfig::Getopt rather than Getopt::Long.

🕸️ PARSING CGI PARAMETERS 🕸️

The cgi() method provides an interface to the AppConfig::CGI module for updating variable values based on the parameters appended to the URL for a CGI script 🦋. This is commonly known as the CGI GET method. The CGI POST method is currently not supported 🙈.

Parameter definitions are separated from the CGI script name by a question mark and from each other by ampersands. Where variables have specific values, these are appended to the variable with an equals sign:

http://www.here.com/cgi-bin/myscript?foo=bar&baz=qux&verbose

    # $config->foo('bar');
    # $config->baz('qux');
    # $config->verbose(1);

Certain values specified in a URL must be escaped in the appropriate manner (see CGI specifications at http://www.w3c.org/ for full details). The AppConfig::CGI module automatically unescapes the CGI query string to restore the parameters to their intended values 🌈.

http://where.com/mycgi?title=%22The+Wrong+Trousers%22

# $config->title('"The Wrong Trousers"');

⚠️ Please be considerate of the security implications of providing writable access to script variables via CGI.

http://rebel.alliance.com/cgi-bin/...
    .../send_report?file=%2Fetc%2Fpasswd&email=darth%40empire.com

To avoid any accidental or malicious changing of "private" variables, define only the "public" variables before calling the cgi() (or any other) method. Further variables can subsequently be defined which can not be influenced by the CGI parameters 🔥.

$config->define('verbose', 'debug')
$config->cgi();             # can only set verbose and debug

$config->define('email', 'file');
$config->file($cfgfile);    # can set verbose, debug, email + file

🧮 CONSTANT DEFINITIONS 🧮

A number of constants are defined by the AppConfig module. These may be accessed directly (e.g. AppConfig::EXPAND_VARS) or by first importing them into the caller’s package. Constants are imported by specifying their names as arguments to use AppConfig, or by importing a set of constants identified by its "tag set" name 💜.

use AppConfig qw(ARGCOUNT_NONE ARGCOUNT_ONE);

use AppConfig qw(:argcount);

The following tag sets are defined:

🌱 :expand

The :expand tagset defines the following constants:

EXPAND_NONE
EXPAND_VAR
EXPAND_UID
EXPAND_ENV
EXPAND_ALL       # EXPAND_VAR | EXPAND_UID | EXPAND_ENV
EXPAND_WARN

See AppConfig::File for full details of the use of these constants.

🧸 :argcount

The :argcount tagset defines the following constants:

ARGCOUNT_NONE
ARGCOUNT_ONE
ARGCOUNT_LIST
ARGCOUNT_HASH

See AppConfig::State for full details of the use of these constants.

📦 REPOSITORY 📦

The repo lives here: <https://github.com/neilbowers/AppConfig> 🫶.

✍️ AUTHOR ✍️

Andy Wardley, <abw@wardley.org> 💖.

With contributions from Dave Viner, Ijon Tichy, Axel Gerstmair and many others whose names have been lost to the sands of time (reminders welcome) 🎀.

🪪 COPYRIGHT 🪪

Copyright (C) 1997-2007 Andy Wardley. All Rights Reserved.

Copyright (C) 1997,1998 Canon Research Centre Europe Ltd.

This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

👀 SEE ALSO 👀

• AppConfig::State
• AppConfig::File
• AppConfig::Args
• AppConfig::Getopt
• AppConfig::CGI
• Getopt::Long

💖 That’s the whole page, bestie — source/version perl v5.42.0, dated 2015-04-14, and it’s AppConfig(3). Slay and stay iconic! 💅✨