Translate Laravel Languages with Google Sheets

 

Laravel Translation Sheet is a package by Nassif Bourguig for translating Laravel language files using Google Sheets. What I love about this idea/package, is how easy it makes the process of collaborating on language translations with a standard tool like Google Sheets.

Related: Building a Laravel Translation Package

The way that you interact with Google Sheets is through a series of artisan commands and the Google Sheets API:

# Setup and prep commands

php artisan translation_sheet:setup

php artisan translation_sheet:prepare

# Publish translation to Google Sheets

php artisan translation_sheet:push

Once the translations are ready to go, you can use the pull command to pull the translations from the spreadsheet and write to the language-specific files in your Laravel application:

php artisan translation_sheet:pull

Using the pull command syncs the translations from Google Sheets the configured language translation files. You are free to do a diff on them through version control, test them out, and finally commit them to your application.

Once you receive translations and have pulled them into your application, you can lock the sheet to avoid conflicts:

# Lock the sheet to avoid conflicts

php artisan translation_sheet:lock

You can learn more about Laravel Translation Sheet on GitHub at nikaia/translation-sheet. To learn how to install and use the package, check out the project’s README file.

Read More

Laravel Options Package

 

The Laravel Options package from Appstract is a global database key-value options store for Laravel. This package uses a simple options database table with a key and value field and an Option model available via a service provider.

Related: Storing Global Application Settings

Laravel Options has some helpers and a Facade for working with the options table, along with a common public API for creating, getting, setting, and deleting options by key:

// Get an option

option('someKey');

// Set option

option(['someKey' => 'someValue']);

// Check the option exists

option_exists('someKey');

The package ships with a console command to set global options via the command line:

php artisan option:set site_name "Laravel News"

Laravel Options takes away some boilerplate that you might have in your app to replicate a simple key-value store, but doesn’t have much functionality beyond setting simple key-values and you’ll be responsible for any data transformations.

For complete installation instructions check out appstract/laravel-options on GitHub.

Read More

Laravel Favicon Package

 

Laravel Favicon is a package by Marcel Pociot that enables you to create dynamic favicons based on your environment settings:

 
The package works by using a favicon() helper function in your template, which is then modified in the environments you configure:

<link rel="icon" type="image/png" sizes="32x32" href="{{ favicon(asset('favicon-32x32.png')) }}">

Here’s an example of the default enabled environment configuration at the time of writing to give you an idea the values you can specify:

'enabled_environments' => [

    'local' => [

        'text' => 'DEV',

        'color' => '#000000',

        'background_color' => '#ffffff',

    ],

],

It uses Intervention Image, which at the time of writing supports to processing extensions: gd and imagick. If you want to convert ICO files, you need to use the imagick configuration option.

The intended use of this package is for non-production environments. Environments that don’t have matching configuration values will return the original path/URI to the static icon.

Related: Laravel View X-Ray

You can learn more about the Laravel Favicon package at beyondcode/laravel-favicon. To learn how to install and use the package, check out the project’s README file.

Read More

Laravel Tinker Server Package

 

Laravel Tinker Server is a package by Marcel Pociot that enables you to tinker with your variables in real-time while working on your Laravel app. This package collects data via calls to a tinker() helper that ships with the package and allow you to then interact with those variables on the fly.

Related: Laravel Dump Server

The best way to demonstrate this package is the following gif from the project’s README file:

The primary usage for this is first starting up a tinker server in a new console session:

php artisan tinker-server

Then when you call tinker() from within your code it will be instantly available in an interactive REPL shell. Here’s a basic example from the README:

$user = App\User::find(1);

tinker($user);

Using XDebug

An alternative approach that I use which has similar benefits is setting breakpoints during an XDebug session. If you’re using a client like PhpStorm’s client/UI, you can interactively inspect variables within the scope of the call stack and run code via a console.

The nice thing about using XDebug is that it works for all PHP projects, where this approach is specific to Laravel. You can see this technique in our Learn how to set up Xdebug for PhpStorm and Laravel Valet video.

Learn More

You can learn more about the Laravel Tinker Server package at beyondcode/laravel-tinker-server. To learn how to install and use the package, check out the Laravel Tinker Server README file.

Read More

Snipe Migrations Laravel Package

 

Snipe Migrations is a Laravel package by Dustin Fraker for “blazing fast” database migrations for tests:

The package takes a snapshot of your mysql database and imports the schema to your test database rather than running all of your migrations when the test suite starts up.

On projects with many migration files, Snipe Migrations may have a huge speed improvement over migrating the database during setup.

It works by adding this method to your base test class that your other tests extend:

public function setUpTraits()

{

    parent::setUpTraits();

    $uses = array_flip(class_uses_recursive(static::class));

    if (isset($uses[DatabaseTransactions::class])) {

        (new Snipe())->importSnapshot();

    }

}

After you’ve added the setUpTraits() method, you then use it by importing the use DatabaseTransactions trait in your tests.

Learn More

In his writeup, Dustin talks about his reasons for creating Snipe Migrations. You should check out his full post about building the package, including a video at the end which goes over his use-case and how to set up the package.

You can learn more about the Snipe Migrations package at drfraker/snipe-migrations. To learn how to install and use the package, check out the Snipe Migration README file.

Congratulations on your first open-source Laravel package Dustin!

Read More

PHPUnit SpeedTrap

 

PHPUnit Speedtrap is a package by John Kary that reports on slow-running tests in your PHPUnit test suite. This package is inspired by Ruby RSpec’s --profile option that displays feedback about slow tests:

SpeedTrap reports on slow-running PHPUnit tests right in the console.

Many factors affect test execution time. A test not properly isolated from variable latency (database, network, etc.) and even basic load on the test machine will cause test execution times to fluctuate.

From the project’s readme, here’s an example of what you can expect:

I am not super familiar with tapping into PHPUnit, so I enjoyed diving into the package’s source code and learning how PHPUnit listeners work. In a phpunit.xml file you can enable this package with the following XML:

<listeners>

    <listener class="JohnKary\PHPUnit\Listener\SpeedTrapListener" />

</listeners>

A more extensive example includes customizable options for defining the “slowTreshold” and “reportLength”. You can customize what your test suite considers a “slow” test defined in milliseconds:

<listeners>

    <listener class="JohnKary\PHPUnit\Listener\SpeedTrapListener">

        <arguments>

            <array>

                <element key="slowThreshold">

                    <integer>500</integer>

                </element>

                <element key="reportLength">

                    <integer>5</integer>

                </element>

            </array>

        </arguments>

    </listener>

</listeners>

Along with the listener, the package demonstrates using an annotation to override these configuration options on the per-test level:

/**

 * @slowThreshold 5000

 */

public function testLongRunningProcess()

{

    // Code that takes a longer time to execute

}

You can learn more about the PHPUnit Speedtrap package at johnkary/phpunit-speedtrap and also check out these tips on speeding up your PHPUnit tests

Read More

Bagisto E-commerce Platform

 

Bagisto is an open-source E-commerce platform built on top of Laravel and Vue.js by Webkul.

Bagisto is an E-commerce ecosystem designed for all to build and scale your business. It’s a free and open-source framework which offers you a wide range of functionality and lets you have total control of your store.

Built on top of Laravel, it is coupled with easy product information management and fast time to market a product. The framework is very flexible and easy to use even for non-tech users.

At the time of writing, Bagisto’s main feature list includes:

• RTL Support
• Supports multiple channels, locales, and currencies
• Built-in access control layer
• Responsive storefront
• Admin Panel and Dashboard
• Custom product attributes
• Support for multiple store themes
• Multi-store inventory
• Order management system
• Customer cart, wishlist, and product reviews

Bagisto features an administration panel with a Dashboard, sales data, a catalog of products you can manage, and customer management:

Besides the features already available, the Bagisto’s roadmap includes:

• API Support (REST and GraphQL)
• Progressive web application
• Mobile application on the Google Play and Apple App Store
• Dropshipping
• Docker integration
• Elasticsearch integration
• Support for Redis, Varnish, Nginx, and Memcached
• Percona support
• Accelerated mobile pages (AMP) integration
• CI/CD Pipeline management
• New product types like subscriptions, bookings, and recurring billing.
• GDPR compliance

To learn more about Bagisto’s features and try a demo, check out bagisto.com. You can get started with the source code by checking out the repo on GitHub at bagisto/bagisto.

Read More

GitDown Parsing Markdown in PHP

 

GitDown is a simple package for parsing (GitHub-flavored) Markdown in PHP by Caleb Porzio. It works by sending the provided markdown to a public GitHub API that parses it as HTML.

If you aren’t using Laravel, you can still use this package by Here’s the basic usage in a Laravel project:

GitDown::parse($markdown);

// Will be cached forever. (suggested)

GitDown::parseAndCache($markdown);

// Will be cached for 24 hours. (minutes in Laravel < 5.8, seconds otherwise)

GitDown::parseAndCache($markdown, $seconds = 86400);

// Pass in your own custom caching strategy.

GitDown::parseAndCache($markdown, function ($parse) {

    return Cache::rememberForever(sha1($markdown), function () use ($parse) {

        return $parse();

    });

});

You don’t have to use Laravel to use GitDown—you can create a GitDown\GitDown instance and bring your own caching strategy:

$gitDown = new GitDown\GitDown(

    $token = 'foo',

    $context = 'your/repo',

    $allowIframes = false

);

$gitDown->parse($markdown);

// Pass in your own custom caching strategy.

$gitDown->parseAndCache($markdown, function ($parse) {

    return Cache::rememberForever(sha1($markdown), function () use ($parse) {

        return $parse();

    });

});

It’s important to remember that without caching the results, you are going to run into GitHub rate limiting quickly and your pages will load super-slow.

On the frontend, you can benefit from the @gitdown directive in Laravel projects to the <head> of your layout, wrapping the markdown content in a .markdown-body class:

<head>

    [...]

    @gitdown

</head>

<body>

    <div class="markdown-body">

        {!! GitDown::parseAndCache($content) !!}

    </div>

</body>

If you’re not using Laravel, you can use the following:

<style><?php echo GitDown\GitDown::styles(); ?></style>

Check out the project’s README for detailed instructions on rendering styles.

To learn more about GitDown and the gory details of why you might want to use it, read Caleb’s writeup Parsing Markdown: The Easy Way (With Code Highlighting).

You can learn more about this package, get full installation instructions, and view the source code on GitHub at calebporzio/gitdown.

Read More

Laravel Personal Data Export

 

Freek Van der Herten released a Spatie package called Laravel Personal Data Export last week to help you create zip files containing personal data in your Laravel applications:

This package makes it easy to let a user download an export containing all the personal data. Such an export consists of a zip file containing all the user properties and related info.

With privacy concerns rising on social media and other web applications, exporting user data might be something you want to consider. As seen in the package’s readme, you configure the file and data export by defining a selectPersonalData method the user model:

// in your User model

public function selectPersonalData(PersonalDataSelection $personalDataSelection) {

    $personalDataSelection

        ->add('user.json', ['name' => $this->name, 'email' => $this->email])

        ->addFile(storage_path("avatars/{$this->id}.jpg");

        ->addFile('other-user-data.xml', 's3');

}

The Laravel Personal Data Export package provides configuration for how many days the personal data will be available to the user, along with some other customizable options:

return [

    /*

     * The disk where the exports will be stored by default.

     */

    'disk' => 'personal-data-exports',

    /*

     * The amount of days the exports will be available.

     */

    'delete_after_days' => 5,

    /*

     * Determines whether the user should be logged in to be able

     * to access the export.

     */

    'authentication_required' => true,

    /*

     * The mailable which will be sent to the user when the export

     * has been created.

     */

    'mailable' => \Spatie\PersonalDataExport\Mail\PersonalDataExportCreatedMail::class,

];

This package takes care of the boilerplate of all the tasks involved in initiating the data export and then fulfilling it roughly in the following sequence:

First, the package generates the data when you dispatch a CreatePersonalDataExportJob in the application (a queued job by default).

Next, when the job runs, the exported data is zipped and copied to the configured disk. Finally, the user receives a notification email with the URL to the download.

Almost every piece (if not all) of the export process is customizable. You can check out this package on GitHub at spatie/laravel-personal-data-export.

Read More

Spatie Laravel Flash Package

 

Freek Van der Herten of Spatie released a lightweight package to flash messages in your Laravel apps:

This is a lightweight package to send flash messages in Laravel apps. A flash message is a message that is carried over to the next request by storing it in the session. This package only supports one single flash message at a time.

The API is simple to use; from a controller, you might have a flash message like the following:

public function store()

{

    // ...

    flash('The post was updated!', 'some-class');

    return back();

}

You can then use the following to check for/display the message:

@if(flash()->message)

    <div class="{{ flash()->class }}">

        {{ flash()->message }}

    </div>

@endif

Finally, if you are using something like Bootstrap or need some other way to identify a flash message as an error, success, etc., you can define a map of levels in your AppServiceProvider::boot():

\Spatie\Flash\Flash::levels([

    'success' => 'alert-success',

    'warning' => 'alert-warning',

    'error' => 'alert-error',

]);

With the levels defined, you can set a flash message like this:

flash()->success('The post was updated!');

// Or...

flash('The post was updated!', 'success');

Most Laravel developers are likely familiar with the laracasts/flash package—I use it on most of my projects—which is another excellent option. Spatie’s flash package is a very lightweight package with less features, so both projects are good tools to have in your toolbelt depending on your project’s needs.

To learn more about this package, read Freek’s blog post A Laravel package to flash messages. To start using this package, check out the source code and readme at spatie/laravel-flash on GitHub.

Read More

Laravel Postal Code Validation

 

Postal code validation for multiple countries can always be a pain, but thanks to the Laravel Postal Code Validation package by Choraimy Kroonstuiver, validating postal codes is a breeze:

$this->validate($request, [

    'postal_code' => 'postal_code:NL,BE',

]);

Here’s a fluent version of the rule:

$this->validate($request, [

    'postal_code' => [

        PostalCode::forCountry('NL')->andCountry('BE'),

    ],

]);

This package supports worldwide postal code validation, enabling your forms to support multiple postal codes or single out a specific postal code based on the user’s current locale for example.

As an interesting aside, I recently found this helpful list of regular expressions from the Common Locale Data Repository (CLDR) if you’re interested in regular expression postal code validation rules for every territory in the world. Here’s a Gist of the CLDR regex rules as a PHP array available on GitHub.

To start using this package, check out the source code and readme at axlon/laravel-postal-code-validation on GitHub.

Read More

Laravel Vouchers

 

Laravel Vouchers is a package by Marcel Pociot that allows users to redeem vouchers that are bound to models:

This package can associate vouchers with your Eloquent models. This might come in handy, if you need to associate voucher codes with content that is stored in your Eloquent models.

Here’s a basic example of how to create them and redeem them from the readme:

$videoCourse = VideoCourse::find(1);

$voucher = $videoCourse->createVoucher();

auth()->user()->redeemVoucher($voucher);

You can also create vouchers with the Vouchers facade:

$videoCourse = VideoCourse::find(1);

// Create 5 vouchers associated to the videoCourse model.

$vouchers = Vouchers::create($videoCourse, 5);

If you need to provide additional information for your voucher, you can pass an array of key/value data:

$videoCourse = VideoCourse::find(1);

$vouchers = $videoCourse->createVouchers(2, [

    'from' => 'Marcel',

    'message' => 'This one is for you. I hope you like it'

]);

$voucher = $user->redeem('ABC-DEF');

$from = $voucher->data->get('from');

$message = $voucher->data->get('message');

You redeem a voucher with the redeemCode() method:

$voucher = $user->redeemCode('ABCD-EFGH');

// Redeem a Voucher model instance

$user->redeemVoucher($voucher);

To learn more about this package, check out beyondcode/laravel-vouchers on GitHub.

Read More

MailEclipse: Laravel Mail Editor Package

MailEclipse is a mailable editor package for your Laravel applications to create and manage mailables using a web UI. You can use this package to develop mailables without using the command line, and edit templates associated with mailables using a WYSIWYG editor, among other features.

You can even edit your markdown mailable templates:

When creating a mailable template, you can pick from existing themes provided by this package:

The best way to get an idea of what this package does is to install it and try it out or check out this five-minute demo from the author:

Note: the video doesn’t provide sound, but does give an excellent overview and demo of MailEclipse features.

At the time of writing this package is a work in progress and under active development. Part of being under active development means that if you’re interested, you’re encouraged to try this package out and provide feedback.

To start using this package, check out the source code and readme at Qoraiche/laravel-mail-editor on GitHub.

Read More

Laravel Blade Filters Package

 

Blade Filters is a package by Gergo D. Nagy that adds the concept of filters to your blade templates. If you’re familiar with Django’s templating system or Symfony’s Twig templating language, the concept of a filter looks like this:

{{ 'john' | ucfirst }} // John

Alternatively, you could write the same thing like this in Blade without the concept of filters:

{{ ucfirst('john') }}

Chained usage is where I personally feel filters begin to shine over function calls:

{{ 'john' | ucfirst | substr:0,1 }} // J

{{ substr(ucfirst('john'), 0, 1) }}

More usefully, here’s how you’d use filters with a template variable:

{{ $currentUser->name | ucfirst | substr:0,1 }}

Finally, this package provides filters that leverage built-in Laravel APIs:

{{ 'This is a title' | slug }} // this-is-a-title

{{ 'This is a title' | title }} // This Is A Title

{{ 'foo_bar' | studly }} // FooBar

To learn more about this package—including installation instructions—check out the source code on GitHub at thepinecode/blade-filters. Also, the package author Gergo wrote a detailed article that explains how to build a custom ViewServiceProvider that you should check out!

Read More

Eloquent Cloner Package

Cloner is a trait for Laravel Eloquent models that lets you clone a model, and it’s relationships, including files. Even to another database.

Here’s a basic example of a model using the Cloneable trait:

1class Article extends Eloquent
2{
3    use \Bkwld\Cloner\Cloneable;
4}

Here’s how you can clone a model instance, even to another database:

1$clone = Article::first()->duplicate();
2
3// Cloned to another database by connection name
4$clone = Article::first()->duplicateTo('production');

A more advanced example includes defining which relationships cloned along with the model:

 1class Article extends Eloquent
 2{
 3    use \Bkwld\Cloner\Cloneable;
 4
 5    protected $cloneable_relations = ['photos', 'authors'];
 6
 7    public function photos() {
 8        return $this->hasMany('Photo');
 9    }
10
11    public function authors() {
12        return $this->belongsToMany('Author');
13    }
14}

Check out the documentation for full details on how you can also define how to clone files attached to a model. You can learn more about this app and check out the source code on GitHub at BKWLD/cloner.

Read More