Initial commit

vendor/hermes/README.md

@@ -0,0 +1,2 @@
+# Hermes
+Hermes is a small package to handle routing and autoloading designed in conjunction with [The Tempus Project](https://thetempusproject.com).

vendor/hermes/bin/autoload.php

@@ -0,0 +1,44 @@
+<?php
+/**
+ * autoload.php
+ *
+ * Uses the Hermes autoloader if it has been defined.
+ *
+ * @version 3.0
+ * @author  Joey Kimsey <Joey@thetempusproject.com>
+ * @link    https://TheTempusProject.com/TempusDebugger
+ * @license https://opensource.org/licenses/MIT [MIT LICENSE]
+ */
+namespace TheTempusProject\Canary;
+
+use TheTempusProject\Hermes\Classes\Autoloader;
+
+if ( !defined( 'HERMES_ROOT_DIRECTORY' ) ) {
+    define( 'HERMES_ROOT_DIRECTORY', dirname( __DIR__ ) . DIRECTORY_SEPARATOR );
+}
+
+if ( ! defined('HERMES_CONFIG_DIRECTORY' ) ) {
+    define('HERMES_CONFIG_DIRECTORY', HERMES_ROOT_DIRECTORY . 'config' . DIRECTORY_SEPARATOR);
+}
+
+if ( ! defined('HERMES_CONSTANTS_LOADED' ) ) {
+    require_once HERMES_CONFIG_DIRECTORY . 'constants.php';
+}
+
+if ( ! class_exists( 'TheTempusProject\Hermes\Classes\Autoloader' ) ) {
+    require_once HERMES_CLASSES_DIRECTORY . 'autoloader.php';
+}
+
+$autoloader = new Autoloader;
+$autoloader->setRootFolder( HERMES_ROOT_DIRECTORY );
+$autoloader->addNamespace(
+    'TheTempusProject\Hermes\Classes',
+    'classes'
+);
+$autoloader->addNamespace(
+    'TheTempusProject\Hermes\Functions',
+    'functions'
+);
+$autoloader->register();
+
+define( 'HERMES_AUTOLOADED', true );

vendor/hermes/classes/autoloader.php

@@ -0,0 +1,168 @@
+<?php
+/**
+ * classes/autoloader.php
+ *
+ * This should provide a simple way to add autoloading.
+ *
+ * @version 3.0
+ * @author  Joey Kimsey <Joey@thetempusproject.com>
+ * @link    https://TheTempusProject.com/Core
+ * @license https://opensource.org/licenses/MIT [MIT LICENSE]
+ */
+namespace TheTempusProject\Hermes\Classes;
+
+class Autoloader {
+    protected static $namespaces = [];
+    protected $rootFolder = '';
+
+    /**
+     * Automatically requires all the files within a given directory.
+     *
+     * @param {string} [$directory]
+     * @param {bool} [$includeRoot]
+     */
+    public function includeFolder( $directory = '', $includeRoot = true ) {
+        $base_dir = str_replace( '\\', DIRECTORY_SEPARATOR, $directory );
+        $base_dir = str_replace( '/', DIRECTORY_SEPARATOR, $base_dir );
+        $base_dir = rtrim( $base_dir, DIRECTORY_SEPARATOR ) . DIRECTORY_SEPARATOR;
+        // should require all the files in the specific folder
+        if ( $includeRoot ) {
+            $base_dir = $this->rootFolder . $base_dir;
+        }
+        if ( !is_dir( $base_dir ) ) {
+            return false;
+        }
+        $files = scandir( $base_dir );
+        array_shift( $files );
+        array_shift( $files );
+        foreach ( $files as $key => $value ) {
+            if ( stripos( $value, '.php' ) ) {
+                include_once $base_dir . $value;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Adds a namespace and corresponding directory to the autoload list.
+     *
+     * @param {string} [$namespace]
+     * @param {string} [$directory]
+     * @param {bool} [$includeRoot]
+     */
+    public function addNamespace( $namespace, $directory = '', $includeRoot = true ) {
+        // normalize namespace prefix
+        $prefix = trim( $namespace, '\\' ) . '\\';
+
+        // normalize directory
+        $base_dir = str_replace( '\\', DIRECTORY_SEPARATOR, $directory );
+        $base_dir = str_replace( '/', DIRECTORY_SEPARATOR, $base_dir );
+        $base_dir = rtrim( $base_dir, DIRECTORY_SEPARATOR ) . DIRECTORY_SEPARATOR;
+
+        if ( $base_dir === DIRECTORY_SEPARATOR ) {
+            $base_dir = '';
+        }
+
+        if ( empty( self::$namespaces[ $prefix ] ) ) {
+            self::$namespaces[ $prefix ] = [];
+        }
+
+        // retain the base directory for the namespace prefix
+        if ( $includeRoot ) {
+            $base_dir = $this->rootFolder . $base_dir;
+        }
+        array_push( self::$namespaces[ $prefix ], $base_dir );
+    }
+
+    /**
+     * This is the main method for the autoloader. It will cycle through
+     * possible locations and load the first available file.
+     *
+     * @param {string} [$class]
+     */
+    public function loadClass( $class ) {
+        $class = trim( $class, '\\' );
+        $namespace_array = explode( '\\', $class );
+        $class_name = array_pop( $namespace_array );
+        $namespace = implode( '\\', $namespace_array ) . '\\';
+
+        if ( empty( self::$namespaces[ $namespace ] ) ) {
+            return false;
+        }
+
+        $file = convertClassNameToFileName( $class_name );
+
+        $possible_locations = [];
+        foreach ( self::$namespaces[ $namespace ] as $key => $folder ) {
+            if ( file_exists( $folder . $file ) ) {
+                $possible_locations[] = $folder . $file;
+            }
+        }
+
+        // foreach ( $possible_locations as $location ) {
+        //     // report the locations
+        // }
+        if ( !empty( $possible_locations ) ) {
+            require_once $possible_locations[0];
+        }
+    }
+
+    public static function testLoad( $class ) {
+        $class = trim( $class, '\\' );
+        $namespace_array = explode( '\\', $class );
+        $class_name = array_pop( $namespace_array );
+        $namespace = implode( '\\', $namespace_array ) . '\\';
+
+        if ( class_exists( $class ) ) {
+            return true;
+        }
+
+        if ( empty( self::$namespaces[ $namespace ] ) ) {
+            return false;
+        }
+
+        $file = convertClassNameToFileName( $class_name );
+
+        $possible_locations = [];
+        foreach ( self::$namespaces[ $namespace ] as $key => $folder ) {
+            if ( file_exists( $folder . $file ) ) {
+                $possible_locations[] = $folder . $file;
+            }
+        }
+
+        if ( !empty( $possible_locations ) ) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Sets the root folder for file paths.
+     *
+     * @param {string} [$folder]
+     */
+    public function setRootFolder( $folder ) {
+        $this->rootFolder = rtrim( $folder, DIRECTORY_SEPARATOR ) . DIRECTORY_SEPARATOR;
+    }
+
+    /**
+     * Registers a new autoloader that should serve the currently defined namespaces.
+     */
+    public function register() {
+        spl_autoload_register( [ $this, 'loadClass' ] );
+    }
+
+    /**
+     * Retrieves the currently defined namespaces.
+     */
+    public function getNamespaces() {
+        return self::$namespaces;
+    }
+
+    /**
+     * Retrieves the currently defined root folder.
+     */
+    public function getRootFolder() {
+        return $this->rootFolder;
+    }
+}

vendor/hermes/config/constants.php

@@ -0,0 +1,17 @@
+<?php
+
+// Directories
+if ( !defined( 'HERMES_ROOT_DIRECTORY' ) ) {
+    define( 'HERMES_ROOT_DIRECTORY', dirname( __DIR__ ) . DIRECTORY_SEPARATOR );
+}
+if ( ! defined('HERMES_CONFIG_DIRECTORY' ) ) {
+    define('HERMES_CONFIG_DIRECTORY', HERMES_ROOT_DIRECTORY . 'config' . DIRECTORY_SEPARATOR);
+}
+if (!defined('HERMES_CLASSES_DIRECTORY')) {
+    define('HERMES_CLASSES_DIRECTORY', HERMES_ROOT_DIRECTORY . 'classes' . DIRECTORY_SEPARATOR);
+}
+if (!defined('HERMES_REDIRECTS_ENABLED')) {
+    define('HERMES_REDIRECTS_ENABLED', true);
+}
+# Tell the app all constants have been loaded.
+define( 'HERMES_CONSTANTS_LOADED', true );

vendor/hermes/functions/redirect.php

@@ -0,0 +1,64 @@
+<?php
+/**
+ * functions/redirect.php
+ *
+ * This class is used for header modification and page redirection.
+ *
+ * @version 3.0
+ * @author  Joey Kimsey <Joey@thetempusproject.com>
+ * @link    https://TheTempusProject.com/Core
+ * @license https://opensource.org/licenses/MIT [MIT LICENSE]
+ */
+namespace TheTempusProject\Hermes\Functions;
+
+class Redirect {
+    /**
+     * The main redirect function. This will automatically call the
+     * error controller if the value passed to it is numerical. It will
+     * automatically populate the url based on the config and add the
+     * $data string at the end
+     *
+     * @param string|int $data - The desired redirect location (string for location and integer for error page).
+     */
+    public static function to( $data ) {
+        if ( ! HERMES_REDIRECTS_ENABLED ) {
+            return;
+        }
+        if ( is_numeric( $data ) ) {
+            header( 'Location: ' . Route::getAddress() . 'Errors/' . $data );
+        }
+        $url = Route::getAddress() . $data;
+        if ( filter_var( $url, FILTER_VALIDATE_URL ) != false ) {
+            header( 'Location: ' . $url );
+        }
+    }
+
+    public static function home() {
+        if ( ! HERMES_REDIRECTS_ENABLED ) {
+            return;
+        }
+        header( 'Location: ' . Route::getAddress() );
+    }
+
+    public static function external( $data ) {
+        if ( ! HERMES_REDIRECTS_ENABLED ) {
+            return;
+        }
+        $url = filter_var( $data, FILTER_SANITIZE_URL );
+        if ( filter_var( $url, FILTER_VALIDATE_URL ) != false ) {
+            header( 'Location: ' . $data );
+        }
+    }
+
+    /**
+     * Refreshes the current page.
+     *
+     * @return null
+     */
+    public static function reload() {
+        if ( ! HERMES_REDIRECTS_ENABLED ) {
+            exit();
+        }
+        header( 'Refresh:0' );
+    }
+}

vendor/hermes/functions/route.php

@@ -0,0 +1,104 @@
+<?php
+/**
+ * functions/routes.php
+ *
+ * This class is used to return file and directory locations.
+ *
+ * @version 3.0
+ * @author  Joey Kimsey <Joey@thetempusproject.com>
+ * @link    https://TheTempusProject.com/Core
+ * @license https://opensource.org/licenses/MIT [MIT LICENSE]
+ */
+
+namespace TheTempusProject\Hermes\Functions;
+
+class Route {
+    public static function testRouting() {
+        // $url = Routes::getAddress( true ) . DEFAULT_CONTROLLER_CLASS . '/' . DEFAULT_CONTROLLER_METHOD;
+        // echo '<pre>' . var_export( $url, true ) . '</pre>';
+        // $host = gethostbyname( $url );
+        // echo '<pre>' . var_export( $url, true ) . '</pre>';
+        // $host = dns_get_record( $url );
+        // echo '<pre>' . var_export( $url, true ) . '</pre>';
+        // $headers = @get_headers( $url );
+        // echo '<pre>' . var_export( $headers, true ) . '</pre>';
+        // $file = true;
+        // echo '<pre>' . var_export( $file, true ) . '</pre>';
+        // exit;
+        return true;
+        $headers = get_headers( $url );
+        if ( empty( $headers ) ) {
+            return false;
+        }
+        $response_code = substr( $headers[0], 9, 3 );
+        if ( $response_code != '200' ) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Determines if the server is using a secure transfer protocol or not.
+     *
+     * @return string - The string representation of the server's transfer protocol
+     */
+    public static function getProtocol() {
+        if ( !empty( $_SERVER['HTTPS'] ) && $_SERVER['HTTPS'] !== 'off' ) {
+            return 'https';
+        }
+        if ( $_SERVER['SERVER_PORT'] == 443 ) {
+            return 'https';
+        }
+        return 'http';
+    }
+
+    public static function getHost( $internal = false ) {
+        $host = $_SERVER['HTTP_HOST'];
+        if ( true === $internal ) {
+            // if ( 'docker' === getenv( 'APP_ENV' ) ) {
+            //     if ( Check::isNginx() ) {
+            //         $host = 'webone';
+            //     } elseif ( Check::isApache() ) {
+            //         $host = 'webtwo';
+            //     } else {
+            //         $host = '127.0.0.1';
+            //     }
+            // }
+        }
+        return $host;
+    }
+
+    /**
+     * Finds the root directory of the application.
+     *
+     * @return string - The applications root directory.
+     */
+    public static function getRoot() {
+        $fullArray = explode( '/', $_SERVER['PHP_SELF'] );
+        array_pop( $fullArray ); // removes the current file name (index.php)
+        $route = implode( '/', $fullArray ) . '/';
+        return $route;
+    }
+    /**
+     * finds the physical location of the application
+     *
+     * @return string - The root file location for the application.
+     */
+    public static function getAddress( $internal = false ) {
+        return self::getProtocol() . '://' . self::getHost( $internal ) . self::getRoot();
+    }
+
+    public static function getRequestUrl( $includeParams = true ) {
+        return self::getProtocol() . '://' . self::getHost() . self::getUri( $includeParams );
+    }
+
+    public static function getUri( $includeParams = true ) {
+        if ( true === $includeParams ) {
+            $out = $_SERVER['REQUEST_URI'];
+        } else  {
+            $explodedSelect = explode( '?', $_SERVER['REQUEST_URI'] );
+            $out = $explodedSelect[0];
+        }
+        return $out;
+    }
+}