File Coverage

blib/lib/WebDyne/Constant.pm

Criterion	Covered	Total	%
statement	119	157	75.8
branch	27	42	64.2
condition	15	26	57.6
subroutine	13	14	92.8
pod	0	5	0.0
total	174	244	71.3

#
#  This file is part of WebDyne.
#
#  This software is copyright (c) 2026 by Andrew Speer .
#
#  This is free software; you can redistribute it and/or modify it under
#  the same terms as the Perl 5 programming language system itself.
#
#  Full license text is available at:
#
#
#
package WebDyne::Constant;


#  Pragma
#
use strict qw(vars);
use vars   qw($VERSION %Constant %Package);
use warnings;
no warnings qw(uninitialized);


#  External modules
#
use WebDyne::Util;
use File::Spec;
use Data::Dumper;
$Data::Dumper::Indent=1;
require Opcode;


#  Version information
#
$VERSION='2.075';


#  Get mod_perl version taking intio account legacy strings. Clear $@ after evals
#
eval {require mod_perl2 if (defined($ENV{'MOD_PERL_API_VERSION'}) && ($ENV{'MOD_PERL_API_VERSION'} == 2))} ||
eval {require Apache2 if (defined($ENV{'MOD_PERL'}) && ($ENV{'MOD_PERL'}=~/1.99/))} ||
eval {require mod_perl if $ENV{'MOD_PERL'}};
eval {} if $@;
my $MP_version=$mod_perl::VERSION || $mod_perl2::VERSION || $ENV{MOD_PERL_API_VERSION};
my $MP2=(defined($MP_version) && ($MP_version  > 1.99)) ? 1 : 0;


#  Temp location to hold vars we propagate into multiple constants below.
#
my %constant_temp;


#  Hash of constants
#
%Constant=(


    #  Array structure index abstraction. Do not change or bad
    #  things will happen.
    #
    WEBDYNE_NODE_NAME_IX         => 0,
    WEBDYNE_NODE_ATTR_IX         => 1,
    WEBDYNE_NODE_CHLD_IX         => 2,
    WEBDYNE_NODE_SBST_IX         => 3,
    WEBDYNE_NODE_LINE_IX         => 4,
    WEBDYNE_NODE_LINE_TAG_END_IX => 5,
    WEBDYNE_NODE_SRCE_IX         => 6,


    #  Container structure
    #
    WEBDYNE_CONTAINER_META_IX => 0,
    WEBDYNE_CONTAINER_DATA_IX => 1,


    #  Where compiled scripts are stored. Scripts are stored in
    #  here with a the inode of the source file as the cache
    #  file name.
    #
    WEBDYNE_CACHE_DN => &cache_dn,


    #  Empty cache files at startup ? Default is yes (psp files wil be
    #  recompiled again after a server restart)
    #
    WEBDYNE_STARTUP_CACHE_FLUSH => 1,


    #  How often to check cache for excess entries, clean to
    #  low_water if > high_water entries, based on last used
    #  time or frequency.
    #
    #  clean_method 0				= clean based on last used time (oldest
    #  get cleaned)
    #
    #  clean_method 1				= clean based on frequency of use (least
    #  used get cleaned)
    #
    WEBDYNE_CACHE_CHECK_FREQ   => 256,
    WEBDYNE_CACHE_HIGH_WATER   => 64,
    WEBDYNE_CACHE_LOW_WATER    => 32,
    WEBDYNE_CACHE_CLEAN_METHOD => 1,


    #  Type of eval code to run - use Safe module, or direct. Direct
    #  is default, but may allow subversion of code
    #
    #  1					= Safe # Not tested much - don't assume it is really safe !
    #  0					= Direct (UnSafe)
    #
    WEBDYNE_EVAL_SAFE => 0,


    #  Prefix eval code with strict pragma. Can be undef'd to remove
    #  this behaviour, or altered to suit local taste
    #
    WEBDYNE_EVAL_USE_STRICT => 'use strict qw(vars);',


    #  Global opcode set, only these opcodes can be used if using a
    #  safe eval type. Uncomment the full_opset line if you want to
    #  be able to use all perl opcodes. Ignored if using direct eval
    #
    #WEBDYNE_EVAL_SAFE_OPCODE_AR		=>	[&Opcode::full_opset()],
    #WEBDYNE_EVAL_SAFE_OPCODE_AR			=>	[&Opcode::opset(':default')],
    WEBDYNE_EVAL_SAFE_OPCODE_AR => [':default'],


    #  Use strict var checking, eg will check that a when ${varname} param
    #  exists with a HTML page that the calling perl code (a) supplies a
    #  "varname" hash parm, and (b) that param is not undef
    #
    WEBDYNE_STRICT_VARS => 1,


    #  When a perl method loaded by a user calls another method within
    #  that just-loaded package (eg sub foo { shift()->bar() }), the
    #  WebDyne AUTOLOAD method gets called to work out where "bar" is,
    #  as it is not in the WebDyne ISA stack.
    #
    #  By default, this gets done every time the routine is called,
    #  which can add up when done many times. By setting the var below
    #  to 1, the AUTOLOAD method will pollute the WebDyne class with
    #  a code ref to the method in question, saving a run through
    #  AUTOLOAD if it is ever called again. The downside - it is
    #  forever, and if your module has a method of the same name as
    #  one in the WebDyne class, it will clobber the WebDyne one, probably
    #  bringing the whole lot crashing down around your ears.
    #
    #  The upside. A speedup of about 10% on modules that use AUTOLOAD
    #  heavily
    #
    WEBDYNE_AUTOLOAD_POLLUTE => 0,


    #  Dump flag. Set to 1 if you want the  tag to display the
    #  current CGI status
    #
    WEBDYNE_DUMP_FLAG => 0,


    #  Encoding
    #
    WEBDYNE_HTML_CHARSET => do {
        $constant_temp{'webdyne_html_charset'}='UTF-8'
    },


    #  Content-type for text/html. Combined with charset to produce Content-type header
    #
    WEBDYNE_CONTENT_TYPE_HTML => do {
        $constant_temp{'webdyne_content_type_html'}='text/html'
    },
    WEBDYNE_CONTENT_TYPE_HTML_ENCODED => do {
        $constant_temp{'webdyne_content_type_html_encoded'}=sprintf('%s; charset=%s', @constant_temp{qw(webdyne_content_type_html webdyne_html_charset)})
    },


    #  Content-type for text/plain. As above
    #
    WEBDYNE_CONTENT_TYPE_TEXT => do {
        $constant_temp{'webdyne_content_type_text'}='text/plain'
    },
    WEBDYNE_CONTENT_TYPE_TEXT_ENCODED =>
        sprintf('%s; charset=%s', @constant_temp{qw(webdyne_content_type_text webdyne_html_charset)}),


    #  And JSON
    #
    WEBDYNE_CONTENT_TYPE_JSON => do {
        $constant_temp{'webdyne_content_type_json'}='application/json'
    },
    WEBDYNE_CONTENT_TYPE_JSON_ENCODED =>
        sprintf('%s; charset=%s', @constant_temp{qw(webdyne_content_type_json webdyne_html_charset)}),


    #  Script types which are executable so we won't subst strings in them
    #
    WEBDYNE_SCRIPT_TYPE_EXECUTABLE_HR => { map { $_=>1 } qw(
        text/javascript
        application/javascript
        module
    )},


    #  DTD to use when generating HTML
    #
    WEBDYNE_DTD  => '',
    WEBDYNE_META => {

        # Set to 'chareset=UTF-8' => undef to get result we want
        'charset='.$constant_temp{'webdyne_html_charset'} => undef,

        # Set viewport by default
        'viewport' => 'width=device-width, initial-scale=1.0'
    },


    #  Include a Content-Type meta tag ?
    #
    WEBDYNE_CONTENT_TYPE_HTML_META => 0,


    #  Default  tag paramaters, eg { lang	=>'en-US' }
    #
    WEBDYNE_HTML_PARAM => {lang => 'en' },


    #  Default params for  tag
    #
    #  E.g. WEBDYNE_START_HTML_PARAM => {  include_style=>['foo.css', 'bar.css'] },

    #
    WEBDYNE_START_HTML_PARAM => {},


    #  Make include/other sections in start_html tag static, i.e. load them at compile
    #  time and they never change. Make undef to force re-include every page load
    #
    WEBDYNE_START_HTML_PARAM_STATIC => 1,


    #  Shortcut attributes for start_html
    #
    WEBDYNE_START_HTML_SHORTCUT_HR => {

        pico    => { style  => 'https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.min.css' },
        htmx    => { script => 'https://cdn.jsdelivr.net/npm/htmx.org@2.0.8/dist/htmx.min.js' }

        #  Commented out for now, left as syntax examples
        #

        #bootstrap	=> {
        #    style => 'https://cdn.jsdelivr.net/npm/bootstrap@5.3.8/dist/css/bootstrap.min.css',
        #    script => 'https://cdn.jsdelivr.net/npm/bootstrap@5.3.8/dist/js/bootstrap.bundle.min.js'
        #},
        #alpine		=> { script => 'https://cdn.jsdelivr.net/npm/alpinejs@3.x.x/dist/cdn.min.js#defer' },
        #tailwind	=> { style => 'https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4' },
        #alpine_ajax	=> { script => [
        #    'https://cdn.jsdelivr.net/npm/@imacrayon/alpine-ajax@0.12.6/dist/cdn.min.js#defer',
        #    'https://cdn.jsdelivr.net/npm/alpinejs@3.14.1/dist/cdn.min.js#defer'
        #]}

    },


    #  Anything that should be added in  section. Will be inserted verbatim before
    #  . No interpolation or variables, simple text string only. Useful for setting
    #  global stylesheet, e.g.
    #
    #  WEBDYNE_HEAD_INSERT =>  ''
    #
    #  Will be added to all  sections universally.
    #
    WEBDYNE_HEAD_INSERT => '',


    #  Ignore ignorable whitespace in compile. Play around with these settings if
    #  you don't like the formatting of the compiled HTML. See HTML::TreeBuilder
    #  man page for details here
    #
    WEBDYNE_COMPILE_IGNORE_WHITESPACE   => 1,
    WEBDYNE_COMPILE_NO_SPACE_COMPACTING => 0,


    # Other Compile settings
    #
    WEBDYNE_COMPILE_P_STRICT            => 1,
    WEBDYNE_COMPILE_IMPLICIT_BODY_P_TAG => 1,


    #  Store and render comments ?
    #
    WEBDYNE_STORE_COMMENTS => 1,


    #  Send no-cache headers ?
    #
    WEBDYNE_NO_CACHE => 1,


    #  Render blocks outside of perl code
    #
    #WEBDYNE_DELAYED_BLOCK_RENDER		=>	1,


    #  Are warnings fatal ?
    #
    WEBDYNE_WARNINGS_FATAL => 0,


    #  CGI disable uploads default, max post size default
    #
    WEBDYNE_CGI_DISABLE_UPLOADS => 0,
    WEBDYNE_CGI_POST_MAX        => (512*1024),    #512Kb


    #  Expand CGI parameters found in CGI values, e.g. button with submit=1&name=2 will get those
    #  CGI params set.
    #
    WEBDYNE_CGI_PARAM_EXPAND => 1,


    #  Disable CGI autoescape of form fields ?
    #
    WEBDYNE_CGI_AUTOESCAPE => 0,


    #  Error handling. Use text errors rather than HTML ?
    #
    WEBDYNE_ERROR_TEXT => 0,


    #  Show errors ? Extended shows additional information with granularity as per following
    #  section.
    #
    WEBDYNE_ERROR_SHOW          => 1,
    WEBDYNE_ERROR_SHOW_EXTENDED => 0,


    #  Show error, source file context, number of lines pre and post. Only applicable
    #  for extended + HTML error output.
    #
    WEBDYNE_ERROR_SOURCE_CONTEXT_SHOW       => 1,
    WEBDYNE_ERROR_SOURCE_CONTEXT_LINES_PRE  => 4,
    WEBDYNE_ERROR_SOURCE_CONTEXT_LINES_POST => 4,

    #  Max length of source line to show in ouput. 0 for unlimited.
    WEBDYNE_ERROR_SOURCE_CONTEXT_LINE_FRAGMENT_MAX => 80,

    #  Show filename (FULL for full filesystem path)
    WEBDYNE_ERROR_SOURCE_FILENAME_SHOW => 1,
    WEBDYNE_ERROR_SOURCE_FILENAME_FULL => 0,

    #  Show backtrace, show full or brief backtrace
    WEBDYNE_ERROR_BACKTRACE_SHOW  => 1,
    WEBDYNE_ERROR_BACKTRACE_SHORT => 0,
    #  Skip (eval) and __ANON__ methods unless set to 1
    WEBDYNE_ERROR_BACKTRACE_FULL  => 0,

    #  Show eval trace. Uses SOURCE_CONTEXT_LINES to determine number of lines to show
    WEBDYNE_ERROR_EVAL_CONTEXT_SHOW => 1,

    #  CGI and other info
    WEBDYNE_ERROR_CGI_PARAM_SHOW        => 1,
    WEBDYNE_ERROR_ENV_SHOW              => 1,
    WEBDYNE_ERROR_WEBDYNE_CONSTANT_SHOW => 1,

    #  URI and version
    WEBDYNE_ERROR_URI_SHOW     => 1,
    WEBDYNE_ERROR_VERSION_SHOW => 1,
    WEBDYNE_ERROR_INTERNAL_SHOW => 0,

    #  Internal indexes for error eval handler array
    #
    #WEBDYNE_ERROR_EVAL_TEXT_IX     => 0,
    #WEBDYNE_ERROR_EVAL_EMBEDDED_IX => 1,
    #WEBDYNE_ERROR_EVAL_LINE_NO_IX  => 2,


    #  Alternate error message if WEBDYNE_ERROR_SHOW disabled
    #
    WEBDYNE_ERROR_SHOW_ALTERNATE =>
        'error display disabled - enable WEBDYNE_ERROR_SHOW to show errors, or review web server error log.',

    #  Default title
    #
    WEBDYNE_HTML_DEFAULT_TITLE => 'Untitled Document',


    #  HTML Tiny mode, XML or HTML
    #
    WEBDYNE_HTML_TINY_MODE => 'html',


    #  Development mode - recompile loaded modules
    #
    WEBDYNE_RELOAD => 0,


    #  Use JSON canonical. pretty mode ?
    #
    WEBDYNE_JSON_CANONICAL => 1,
    WEBDYNE_JSON_PRETTY => 0,


    #  Enable the API mode ?
    #
    WEBDYNE_API_ENABLE => 1,


    #  Enable Alpine/Vue hack
    #
    WEBDYNE_ALPINE_VUE_ATTRIBUTE_HACK_ENABLE => 'x-on',


    #  Request headers for HTMX and Alpine Ajax
    #
    WEBDYNE_HTTP_HEADER_AJAX_HR => { map { $_=> 1} @{$_=[qw(
        hx-request
        x-alpine-request
    )]}},
    WEBDYNE_HTTP_HEADER_AJAX_AR => $_,


    #  Force run of  tag even if no hx-request header
    #
    WEBDYNE_HTMX_FORCE => 0,


    #  Headers
    #
    WEBDYNE_HTTP_HEADER => {

        #'Content-Type'              => sprintf('%s; charset=%s', @constant_temp{qw(webdyne_content_type_html webdyne_html_charset)}),
        'Content-Type'              => $constant_temp{'webdyne_content_type_html_encoded'},
        'Cache-Control'             => 'no-cache, no-store, must-revalidate',
        'Pragma'                    => 'no-cache',
        'Expires'                   => '0',
        'X-Content-Type-Options'    => 'nosniff',
        'X-Frame-Options'           => 'SAMEORIGIN'

        #  Set other options here, e.g.
        #
        #'Strict-Transport-Security' => 'max-age=31536000; includeSubDomains; preload',
        #'Content-Security-Policy'   => "default-src 'self'; style-src 'self' https://cdn.jsdelivr.net https://fonts.googleapis.com/ 'unsafe-inline'; font-src https://fonts.gstatic.com",
        #'Referrer-Policy'           => 'strict-origin-when-cross-origin',

    },


    #  Webdyne PSGI serves static files ?
    #
    WEBDYNE_PSGI_STATIC => 1,


    #  WebDyne default extension and length, used in susbtr as faster than regex. Update - too slow, retiring and going to fixed
    #  string .psp extension
    #
    WEBDYNE_PSP_EXT 	=> ($constant_temp{'webdyne_psp_ext'}='.psp'),
    WEBDYNE_PSP_EXT_RE  => qr/\Q$constant_temp{'webdyne_psp_ext'}\E/,


    #  Very minimal MIME type hash used by lookup_file function
    #
    WEBDYNE_MIME_TYPE_HR => {
        'html' => 'text/html',
        'htm'  => 'text/html',
        'txt'  => 'text/plain',
        'jpg'  => 'image/jpeg',
        'jpeg' => 'image/jpeg',
        'png'  => 'image/png',
        'gif'  => 'image/gif',
        'css'  => 'text/css',
        'js'   => 'application/javascript',
        'json' => 'application/json',
        'pdf'  => 'application/pdf',
        'svg'  => 'image/svg+xml',
        'yml'  => 'application/x-yaml',
        'yaml' => 'application/x-yaml',
        'xml'  => 'application/xml',
        'toml' => 'application/toml',
        'md'   => 'text/markdown'
    },


    #  Other file extenstions the PSGI indexer is allowed to open
    #
    WEBDYNE_INDEX_EXT_ALLOWED_HR => { map {$_=>1} qw(
        psp
        pm
        pl
    )},


    #  And raw file names. Should be regexp, todo
    #
    WEBDYNE_INDEX_FN_ALLOWED_HR => { map {$_=>1} qw(
        LICENSE
        MANIFEST
        Makefile
        cpanfile
        cpanfile.snapshot
        Dockerfile
    )},


    #  Dir_config can be loaded from here if not in Apache
    #
    WEBDYNE_DIR_CONFIG => undef,


    #  Dir_config can be loaded from each directory via webdyne.conf.pl
    #  if desired, only under Plack at the moment
    #
    WEBDYNE_DIR_CONFIG_CWD_LOAD => 1,


    #  Local constant path names. Used as marker only, updated dynamically
    #  by &local_constant_load;
    #
    WEBDYNE_CONF_HR => undef,


    #  Config file name
    #
    WEBDYNE_CONF_FN => 'webdyne.conf.pl',


    #  Tidy output ? Will require HTML::Tidy5 and all dependencies to be installed
    #
    WEBDYNE_HTML_TIDY => 0,


    #  HTML::Tidy5 config
    #
    WEBDYNE_HTML_TIDY_CONFIG_HR => {

        'indent'            => 0,      # enable indentation
        'indent-spaces'     => 2,     # 2 spaces per indent level
        'wrap'              => 0,      # don't wrap lines
        'tidy-mark'         => 'no',   # don't add a tidy comment
        'clean'             => 'no',   # don't clean embedded styles
        'drop-empty-elements' => 'no',  # don't remove empty elements
        'hide-comments'     => 'no',        # keep HTML comments
        'fix-uri'           => 'no',        # don't alter URIs
        'output-html'       => 'yes',       # output as HTML
        'show-warnings'     => 'no',        # suppress warnings

    },


    #  Add some linefeeds via "\n" to output
    #
    WEBDYNE_HTML_NEWLINE => 0,


    #  Mod_perl level. Do not change unless you know what you are
    #  doing.
    #
    MP2      => $MP2,
    MOD_PERL => $MP_version,


);


sub local_constant_fn {


    #  Where local constants reside
    #
    my @local_constant_fn;
    my $local_constant_fn=$Constant{'WEBDYNE_CONF_FN'};
    if ($^O=~/MSWin[32|64]/) {
        my $dn=$ENV{'WEBDYNE_HOME'} || $ENV{'WEBDYNE'} || $ENV{'WINDIR'};
        push @local_constant_fn, ($ENV{'WEBDYNE_CONF'} ||
            File::Spec->catfile($dn, $local_constant_fn))
    }
    else {
        push @local_constant_fn, ($ENV{'WEBDYNE_CONF'} ||
            File::Spec->catfile(
                File::Spec->rootdir(), 'etc', $local_constant_fn
        ))
    }
    unless ($ENV{'WEBDYNE_CONF'}) {
        push @local_constant_fn, glob(sprintf('~/.%s', $local_constant_fn));
    }
    0 && debug('local_constant_fn: %s, env: %s', Dumper(\@local_constant_fn, \%ENV));
    return \@local_constant_fn;

}


sub cache_dn {


    #  Where the cache directory should be located
    #
    my $cache_dn;
    if ($ENV{'PAR_TEMP'}) {
        $cache_dn=$ENV{'PAR_TEMP'}
    }


    #  Used to set like this - now leave the installer to
    #  find and set an appropriate location
    #
    #else {
    #require File::Temp;
    #$cache_dn=&File::Temp::tempdir( CLEANUP=> 1 );
    #}
    #elsif ($prefix) {
    #  $cache_dn=File::Spec->catdir($prefix, 'cache');
    #}
    #elsif ($^O=~/MSWin[32|64]/) {
    #  $cache_dn=File::Spec->catdir($ENV{'SYSTEMROOT'}, qw(TEMP webdyne))
    #}
    #else {
    #  $cache_dn=File::Spec->catdir(
    #    File::Spec->rootdir(), qw(var cache webdyne));
    #}
    return $cache_dn

}


sub hashref {

    my $class=shift();
    return \%{"${class}::Constant"};

}



sub local_constant_load {


    #  Load constants from override files.
    #
    my ($class, $local_constant_fn)=@_;
    0 && debug("class: $class, local_constant_fn: $local_constant_fn");


    #  Var to hold hash ref we load
    #
    my $constant_hr;


    #  Now load, making sure we don't reload already loaded file - with bonus of creating
    #  var that tracks/shows loaded files - WEBDYNE_CONF_HR
    #
    0 && debug("attempt load local_constant_fn: $local_constant_fn");
    if (-f $local_constant_fn && !$Constant{'WEBDYNE_CONF_HR'}{$local_constant_fn}++) {
    #if (-f $local_constant_fn && !$Package{'file'}{$local_constant_fn}++) {
        0 && debug("file exists, about to load from: $local_constant_fn (%s)", File::Spec->rel2abs($local_constant_fn));
        $Constant{'WEBDYNE_CONF_HR'}{$local_constant_fn}++;
        $constant_hr=do(File::Spec->rel2abs($local_constant_fn)) ||
            warn("unable to read local constant file, $!");
    }


    #  Now from environment vars - override anything in config file
    #
    my %constant_class=%{"${class}::Constant"};
    foreach my $key (keys %constant_class) {
        if (defined $ENV{$key}) {
            my $val=$ENV{$key};
            0 && debug("using environment value $val for key: $key");
            $constant_hr->{$class}{$key}=$val;
        }
    }


    #  Load up Apache config - only if running under mod_perl
    #
    if (my $server_or=&server_or()) {
        my $table_or=$server_or->dir_config();
        while (my ($key, $val)=each %{$table_or}) {
            0 && debug("installing value $val for Apache directive: $key");
            $constant_hr->{$class}{$key}=$val if exists $constant_class{$key}
        }
    }


    #  Done - return constant hash ref
    #
    return $constant_hr;

}


sub server_or {


    #  Get the apache server object if available
    #
    unless (exists($Package{'server_or'})) {


        #  Var to hold any server object found
        #
        my $server_or;


        #  Only do checks if running under mod_perl
        #
        if ($MP_version) {


            #  Ignore die's for the moment so don't get caught by error handler
            #
            0 && debug("detected mod_perl version $MP_version - loading Apache directives");
            local $SIG{'__DIE__'}=undef;
            my $server_or;
            eval {
                #  Modern mod_perl 2
                require Apache2::ServerUtil;
                require APR::Table;
                $server_or=Apache2::ServerUtil->server();
            };
            $@ && eval {

                #  Interim mod_perl 1.99x
                require Apache::ServerUtil;
                require APR::Table;
                $server_or=Apache::ServerUtil->server();
            };
            $@ && eval {

                #  mod_perl 1x ?
                require Apache::Table;
                $server_or=Apache->server();
            };

            #  Clear any eval errors, set via dir_config now (overrides env)
            #
            $@ && do {
                eval {undef}; errclr()
            };
            0 && debug("loaded server_or: $server_or");

        }
        else {
            0 && debug('skip server_or load, not running under mod_perl');
        }


        #  Save away so don't have to do this again
        #
        $Package{'server_or'}=$server_or;

    }


    #  Return it
    #
    return $Package{'server_or'};

}


sub import {


    #  Get caller
    #
    my ($class, $local_constant_fn)=@_;


    #  Check for dump flag, reserved word
    #
    my $dump_fg;
    if (($local_constant_fn ||= '') eq 'dump') {
        $dump_fg++;
        $local_constant_fn=undef;
    }


    #  Get array of local files also
    #
    my $local_constant_fn_ar=&local_constant_fn();
    0 && debug("local_constant_fn_ar: %s", Dumper($local_constant_fn_ar));


    #  Load files if neccessary, get hash of constants to be applied
    #
    my @class_constant_hr;
    foreach my $fn (grep {$_} (@{$local_constant_fn_ar}, $local_constant_fn)) {


        #  Don't process twice
        #
        my $fn_hr=$Package{'import'}{$fn} ||= do {

            #  Need to load in file, haven't seen it yet/
            #
            0 && debug("loading file: $fn");


            #  If here need to read hash ref in from file
            #
            &local_constant_load($class, $fn);

        };
        0 && debug("local_constant_load hr: $fn_hr, %s", Dumper($fn_hr));


        #  Any constants for this class into array for loading
        #
        if (my $class_constant_hr=$fn_hr->{$class}) {


            #   Yes, save for later processing
            #
            0 && debug("adding class_constant_hr: $class_constant_hr for processing, %s", Dumper($class_constant_hr));
            push @class_constant_hr, $class_constant_hr;

        }
        else {

            0 && debug("skip $fn, no class: $class component in hash ref");

        }

    }


    #  Debug what we have
    #
    0 && debug('class_constant_hr: %s', Dumper(\@class_constant_hr));


    #  Get hash ref of Constants file from class calling us - calling
    #  module needs to declare a %Class:Name::Constant variable in
    #  global space.
    #
    my $class_constant_hr=\%{"${class}::Constant"};


    #  We want to load variable into namespace. Get the parent class and who is
    #  calling us/
    #
    (my $class_parent=$class)=~s/::Constant$//;
    my $caller = caller(0);
    0 && debug("caller: $caller");


    #  Remember caller
    #
    $Package{'caller'}{$class}{$caller}++;


    #  Now start iterating over and loading
    #
    foreach $caller (keys %{$Package{'caller'}{$class}}) {
        foreach my $constant_hr ($class_constant_hr, @class_constant_hr) {


            #  Now iterate across all callers and load vars into namespace. Turn off warnings as
            #  we may have to redefine some variables
            #
            no warnings qw(once redefine);
            0 && debug("importing for caller: $caller");


            #  Don't load hash ref into caller if already done. This probably needs to be reworked ..
            #
            if (my $var_test= (keys(%{$constant_hr}))[0] ) {
                0 && debug("picking var: $var_test as test, exists *{${caller}::${var_test}}: %s", defined(*{"${caller}::${var_test}"}));
                if ($Package{'caller'}{$caller}{$constant_hr}++ && defined(*{"${caller}::${var_test}"})) {
                    0 && debug("skip, already applied $constant_hr to caller: $caller");
                    next;
                }
                else {
                    0 && debug('continue');
                }
            }
            else {
                0 && debug('no test var found in constant_hr: %s', Dumper($constant_hr));
            }


            #  Start iterating over all constants in class
            #
            while (my($k, $v)=each %{$class_constant_hr}) {

                #  Override ?
                #
                if (defined($constant_hr->{$k}) && ($constant_hr ne $class_constant_hr)) {

                    #  Yes
                    #
                    0 && debug('override constant_hr $k value: %s with file value: %s', $v, $constant_hr->{$k});
                    $v=$class_constant_hr->{$k}=$constant_hr->{$k};

                }
                0 && debug("caller: $caller, class: $class  set:$k value:$v");


                #  Used to do just
                #
                # *{"${caller}::${k}"}=\$v;
                #
                #  Make a bit more sophisticated so if the
                #  var is updated anywhere it is used all
                #  modules see + put a hash called Constant in
                #  the parent module so we don't have to do
                #
                #  %WebDyne::Constant::Constant
                #
                #  now just
                #
                #  %WebDyne::Constant
                #
                if ($caller eq $class_parent) {
                    *{"${caller}::${k}"}=\$v;
                    #*{"${caller}::Constant"}=$hr; # Pulled for moment, bit polluting without ability to ref constant scalars in hash values
                }
                else {
                    if (defined *{"${class_parent}::${k}"}) {
                        *{"${caller}::${k}"} = *{"${class_parent}::${k}"};
                    }
                    else {
                        *{"${caller}::${k}"} = \$v;
                    }
                    #  Used to be this
                    #*{"${caller}::${k}"}=\${"${class_parent}::${k}"};
                }
                0 && debug("caller: $caller, set:$k value:$v");
                #next if ref($v); # Not needed, stop Regexp conversion
                if ($v=~/^\d+$/) {
                    0 && debug("using sub() ${caller}::${k}=$v");
                    *{"${caller}::${k}"}=eval("sub () { $v }");
                }
                else {
                    0 && debug("fall through, using sub() ${caller}::${k}=q($v)");
                    *{"${caller}::${k}"}=eval("sub () { q($v) }");
                }

            }
        }
    }


    #  Check if just dumping for view, or actually loading into caller
    #  namespace
    #
    if ($dump_fg) {

        #  We just to want to see what they are
        #
        local $Data::Dumper::Indent=1;
        local $Data::Dumper::Terse=1;
        local $Data::Dumper::Sortkeys=1;
        CORE::print Dumper($class_constant_hr);
        exit 0;
    }

}


1;


__END__