Download the PHP package ebolution/laravel-core without Composer

On this page you can find all versions of the php package ebolution/laravel-core. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.

FAQ

After the download, you have to make one include require_once('vendor/autoload.php');. After that you have to import the classes with use statements.

Example:
If you use only one package a project is not needed. But if you use more then one package, without a project it is not possible to import the classes with use statements.

In general, it is recommended to use always a project to download your libraries. In an application normally there is more than one library needed.
Some PHP packages are not free to download and because of that hosted in private repositories. In this case some credentials are needed to access such packages. Please use the auth.json textarea to insert credentials, if a package is coming from a private repository. You can look here for more information.

  • Some hosting areas are not accessible by a terminal or SSH. Then it is not possible to use Composer.
  • To use Composer is sometimes complicated. Especially for beginners.
  • Composer needs much resources. Sometimes they are not available on a simple webspace.
  • If you are using private repositories you don't need to share your credentials. You can set up everything on our site and then you provide a simple download link to your team member.
  • Simplify your Composer build process. Use our own command line tool to download the vendor folder as binary. This makes your build process faster and you don't need to expose your credentials for private repositories.
Please rate this library. Is it a good library?

Example code of ebolution/laravel-core

Informations about the package laravel-core

Core

Base features and tools to use in the application

Features

1) Process timer

This feature offers a mechanism to log information about a running process using a common format. When the method start is called, a starting message is logged including a unique identifier defined for this process.

When the method stop is called, a finishing message is logged, including the total processing time and the identifier as well, so a match between start and finish of the same process can be stated in latter reviews.

Where to log?

As different processes can be logged in different ways, this feature provides a mechanism to support its own on-demmand logging channels. The summarized sequence would be this:

  1. The implementations of ProcessTimerInterface must include an implementation of LoggerFactoryInterface
  2. The objects produced by LoggerFactoryInterface are instances of Ebolution\Logger\Infrastructure\Logger, and it requires an implementation of BuilderInterface.
  3. The specific implementation of BuilderInterface hosts the details about the logger used by the Process timer.

Maybe it's easier to try an example:

  1. Create a command in app/Console/Commands using the command artisan make:command FooProcessTimer.
  2. Replace the signature of the command to: foo:process-timer
  3. Create the Logging directory in app mkdir app/Logging
  4. Create a new class ProcessTimer that extends Ebolution\Core\Infrastructure\Repositories\ProcessTimer (which implements ProcessTimerInterface) `
  5. Create a class LoggerFactory that extends from Ebolution\Logger\Infrastructure\LoggerFactory `
  6. Create a new class LoggerBuilder that extends from Ebolution\Logger\Domain\LoggerBuilder. Here is where the on-demand logger is defined. In this example, the log messages are written to a file, but many other options are available. If you want a different behavior, just override the methods in this class. Make sure to provide a
    path for you log file (required) and, also a prefix to add to the logs (optional). `
  7. As this approach is heavily based on dependency injection, we need to inform Laravel what concrete implementations we want to pass to each class instead of just interfaces, if it's the case. So, create a class DependencyServicesProvider extending Illuminate\Support\ServiceProvider and declare the right injection for classes LoggerFactory and ProcessTimer. `
  8. Finally, go to config/app.php and declare the newly created service provider into the providers section. `
  9. Go back to App\Console\Commands\FooProcessTimer and create a constructor injecting the newly created ProcessTimer class (please notice that we use properties promotion here). `
  10. Now the timer itself, we need to call the start and stop methods when the command is executed. Please notice that start expect for a name for this process. `

Now we are ready to see if everything is on its place executing the command artisan foo:process-timer, and going to storage/logs/foo.log to check the output.

All the instructions above are meant to follow a classic development pattern, however, we recommend to follow the modular approach using in combination with the Ebolution_ModuleManager module. The logic is the same, but the location of the files is different.

Of course this is a ten steps process, we're open to optimize, automatize and improve it. Just don't hesitate to make your suggestions :D

All versions of laravel-core with dependencies

PHP Build Version
Package Version
Composer command for our command line client (download client) This client runs in each environment. You don't need a specific PHP version etc. The first 20 API calls are free. Standard composer command

The package ebolution/laravel-core contains the following files

Loading the files please wait ...