This is a quick hand method to use Spitfire's main App class as a singleton.
spitfire() : SpitFire
It allows you to quickly access many of the components the framework provides to make it easier to read and maintain the code being created.
Registers a new Application in Spitfire, allowing it to handle requests directed to it.
app(string $name, string $namespace) : App
The name of the Application
The namespace in which the requests will be sent to the application.
The App created by the system, use this to pass parameters and configuration to the application.
Ths function will boot a kernel, instancing it and executing the necessary scripts to initialize it.
boot(class-string<\KernelInterface> $kernel) : KernelInterface
The name of the kernel to boot
Raises an exception whenever the application runs into an scenario that was not expected. This function functions in a very similar manner to an assertion (with the exception of this being executed in production).
assume(bool $condition, string|Closure|Exception $failure) : void
The second parameter contains the name of the exception to be raised on failure, an exception instance or a closure to be executed, which should then either end execution or throw an exception itself.
This is intended to reduce the boilerplate on code that looks like this: if (!$condition) { throw new Exception(); }
The code becomes a bit more readable and drops the negation, making it look like this: assume($condition, Exception::class);
Overall reducing the strain of visually analyzing the code.
If the condition is true, the code will continue being executed
This function allows the developer to stop the execution of the application.
fail(int $status[, string $message = '' ]) : void
It raises a failure exception that will prevent the code from continuing and display a message to the end user that explains the situation.
Whenever your application runs into a more specific issue, you should avoid using this and instead raise a custom exception that offers the user support to resolve the issue or additional information.
Shorthand function to create / retrieve the model the application is using to store data. We could consider this a little DB handler factory.
db() : DB
Creates a view. This function will automatically locate the appropriate file containing the template for the view, generate a template and render it to generate a response.
view(string|null $identifier, array<string|int, mixed> $data) : StreamInterface
Right now it does a very simplistic job, intializing a pug engine that will allow us to generate an output.
This function provides a shorthand way of creating a response to a request, this is very useful in combination with the view() function, allowing you to respond from a controller with something like this:
response(StreamInterface $stream[, int $code = 200 ][, array<string|int, array<string|int, string>> $headers = [] ]) : Response
return response(view('home'));
Or something along the lines of:
`return response(view('notfound'), 404);
Escapes quotes from HTML. This will replace both ' and " with ' and " respectively. This does not escape the other HTML entities, for that refer to _e();
_q(type $str) : type
Usually you should use this function like _q(_e($str));
Escapes the HTML from a string. This function will not escape the quotes, please refer to the _q wrapper for that.
_e(string $str) : string
Helper to convert URLs in text to actual links. By default, the application will translate the URL to a pure HTML link, but you can pass a callable to the system to change the output.
_u(string $str[, Closure|callable $cb = null ]) : string
Returns HTML escaped string and if desired it adds ellipsis. If the string is numeric it will reduce unnecessary decimals.
__(string $str[, int $maxlength = false ]) : string
Translation helper.
_t() : string|DomainGroup
Depending on the arguments this function receives, it will have one of several behaviors.
If the first argument is a spitfire\locale\Locale and the function receives a optional second parameter, then it will assign the locale to either the global domain / the domain provided in the second parameter.
Otherwise, if the first parameter is a string, it will call the default locale's say method. Which will translate the string using the standard locale.
If no parameters are provided, this function returns a DomainGroup object, which provides access to the currency and date functions as well as the other domains that the system has for translations.
console() : mixed
Tests a value against a provided set of rules, if the
validate(mixed $value, mixed $rules) : void
Retrieves the current path from the request. This will retrieve the path without query string or document root.
getPathInfo() : string
_def(mixed &$a, mixed $b) : mixed
This function is a shorthand for "new Collection" which also allows fluent usage of the collection in certain environments where the PHP version still limits that behavior.
collect([mixed $elements = [] ]) : Collection
Creates a new URL. Use this class to generate dynamic URLs or to pass URLs as parameters. For consistency (double base prefixes and this kind of misshaps aren't funny) use this object to pass or receive URLs as paramaters.
url() : mixed
Please note that when passing a URL that contains the URL as a string like "/hello/world?a=b&c=d" you cannot pass any other parameters. It implies that you already have a full URL.
You can pass any amount of parameters to this class, the constructor will try to automatically parse the URL as good as possible.
The clamp function is a math function that receives three arguments, a minimum, a bias and a maximum. Clamp will either return the bias or the closest value whenever the bias is outside the range of maximum and minimum.
clamp(number $min, number $bias, number $max) : number
The first and the last parameter delimit the range. The second parameter is the bias being tested.
within(1, 50, 100); //Outputs: 50
within(1, 500, 100); //Outputs: 100
within(1, -50, 100); //Outputs: 1
This is the deprecated naming for the clamp function.
within(number $min, number $val, number $max) : number
media() : mixed
storage() : DriveDispatcher|NodeInterface
mime(mixed $file) : mixed
Allows the application to manage a central event dispatching system, instead of relying on every component to build a custom one. If your component doesn't wish to share it's hooks and plugins please @see Target
event([Event $event = null ]) : EventDispatcher
lock([FileLockFactory $set = null ]) : FileLockFactory
asset(string $name[, string $scope = 'assets/' ]) : string
A directory to scope this to. If an application builds it's own assets and generates a manifest file, it will be located here. The mix-manifest file is required to be located in the root of this directory.
Note that the scope must be relative to the public directory, if this is not the case, the system will generate bad URLs or fail to locate the manifests.
If, for example, your application publishes it's assets to the assets/vendor/myapp older within public folder, this is exactly the string it should pass
Convenience method for accessing the TaskFactory for deferring tasks. You can pass a task class to be deferred, a bunch of settings and a time to execute this task at.
defer(string $task, mixed $options, int $defer[, int $ttl = 10 ]) : void
Please refer to the documentation to enable the daemon required to process the queue.
Returns an application configuration. Note that configuration in Spitfire is tiered, configuration and environments.
config(string $key[, mixed $fallback = null ]) : mixed
You as the developer should establish the configuration so the components you add to your application work as expected, and should expose the environment to the person deploying the application so they can customize the behavior.
The key in the configuration
The value to return if the configuration does not contain the key
The data for this configuration entry
This function should ONLY be invoked from the config files. This data is not cached, and therefore not always available during runtime.
env(string $param) : string|null
Reads a value from the current environment.
Allows the application to reliably determine whether it is running in a console or on a web server environment.
cli() : bool