Download the PHP package webflorist/htmlfactory without Composer

webflorist/htmlfactory

Convenient and powerful HTML-builder for Laravel (>=v5.5)

Description

This package provides functionality for building HTML in Laravel without the need to write any HTML.

This package allows you to:

• Use static factory methods for all relevant HTML-elements.
• Chain fluent method-calls to set HTML-attributes (that are valid for the current element).
• Fully use the benefits of IDEs (auto-completion).
• Style output for specific frontend-frameworks using Decorator-Classes
• Keep your views frontend-agnostic.
• Extend it's features using Decorators and Components.
• Produce accessibility-conform valid HTML 5 output.

This package is used as a foundation for webflorist/formfactory. Check out this package, if you want to create forms without much hassle in Laravel.

Installation

1. Require the package via composer: composer require webflorist/htmlfactory
2. Publish config: php artisan vendor:publish --provider="Webflorist\HtmlFactory\HtmlFactoryServiceProvider"
3. Set the decorators configuration in the newly published config-file (situated at app/config/htmlfactory.php).

Note that this package is configured for automatic discovery for Laravel. Thus the package's Service Provider Webflorist\HtmlFactory\HtmlFactoryServiceProvider and the Html-Facade Webflorist\HtmlFactory\HtmlFactoryFacade will be automatically registered with Laravel.

Configuration

The package can be configured via config/htmlfactory.php. There is only one setting at the moment:

• decorators: Set the group-IDs of the decorators, that should be loaded. As a result all corresponding decorators will be applied to the generated HTML-elements (e.g. 'bootstrap:v3').

Basic Concepts

Here are some definitions of basic concepts of this package to allow a better understanding of this document:

Please note, that whenever this document uses the term Element it is meant to also include Component-classes (except if stated otherwise), since they are technically also Element-classes.

Usage

A HTML-element or component is generated using the corresponding method of the Html-facade, or by simply instantiating the corresponding Element or Component class.

Since this package is built IDE-friendly way, you just have to type Html::in your auto-completion-enabled IDE and you should immediately get a list of available elements as well as the included components. (This auto-completion will of course not work with your own components.)

The final HTML-string is generated using the generate()-method. But since the Element-class of the HtmlFactory-package includes a magic __toString()-method doing exactly that, you can omit the generate()-method when using the Html-facade in a blade-template.

Basic example

Here is a very basic example for the generation of a div-element from within a laravel-blade-template:

Modifying the Element using fluent methods

Further modifications (e.g. adding HTML-attributes or content) can be made by chaining various fluent methods of the Element. In your auto-completion-enabled you just have to type e.g. Html::div()-> and you should immediately get a list of available methods for this element. Here is an overview of the provided methods:

Adding HTML-attributes

Now let's say, we want add some HTML-attributes to the Element:

• an id-attribute with value myId
• a data-attribute data-foo with the value bar
• a class called myClass

We can achieve this by applying the corresponding methods for these modifications:

As a rule-of-thumb, the methods to set HTML-attributes are identical to their name (e.g. the id attribute can be set with the id() method). Here are the exceptions to this rule:

• The setter-methods for attributes containing a hyphen (e.g. accept-charset) are the camelCased attribute-name (e.g. acceptCharset()).
• Attributes that can have multiple values have a corresponding method prefixed with add (and camelCased). An example would be addClass() for the class attribute (as used in the example above).
• data-attributes are set via the data()-method, which takes the data-attribute's suffix as it's first and the value as it's second parameter (as shown in the example above).

Note that since this package strives to only output valid HTML, the available methods differ from element to element. E.g. you can not use the method selected() on an div-element, because it is not allowed according to HTML-standards.

Values for all HTML-attributes can also be Closures. The Closures get handled the Element-object itself as it's only parameter. Here is an example:

Adding Vue-Directives

In addition to standard HTMl-attributes, you can also set all possible Vue directives via corresponding element-methods:

Furthermore shortcut-methods for vOn() are provided for the most common DOM events:

Adding Content

Of course ContainerElements can also have content. Let's look at this example:

The content() method takes a single child or an array of children as it's parameter. A child can either be another Element-object or a simple text-string. There are also the additional methods prependContent() and appendContent(), which adds content prior or after already existing content. Here is an overview of all content-related methods:

Inserting a sibling before or after the Element

The following methods allow you to insert a sibling (either plain-text or another Element) before or after the Element.

Wrapping an Element within another Element.

You can also apply a wrapper to an Element. Take a look at this example:

Applying a Blade-View to render the Element

You can also apply Blade-Views to your Elements using the view() method. The Element itself is available in the view as $el. To render it, call $el->renderHtml().

Here is an example:

Closure Decorators

Sometimes you may with to apply some complex decorations to a single element, or influence the Element after the global Decorator-Classes (see description below) were applied. You can use the Element-method decorate() for this. The method takes a Closure for it's only parameter and the Closure gets handed the Element itself as it's only attribtues

Check out this example:

Extendability

Components

There are cases, where you quickly want to create more complex HTML-elements, that already have certain attributes, content or wrappers preset, provide additional methods or even required certain construction-parameters. You might also want to make this component accessible via the Html-facade (e.g. via Html::myCustomComponent()). This can all be achieved by creating Components.

A component is basically a class, that extends one of the Element-classes or another Component class. There are already several components included in the Components folder. These include extensions of the InputElement as well as the ButtonElement to provide components for each of the possible 'types'.

Registering Components

For a component to be creatable with the Html-facade, the following conditions must be fulfilled:

• The component must implement the RegisteredComponentInterface enforcing the presence of the static getAccessor()-method, which should return the desired method-name, under which this component can be created via the Html-facade.
• The component must be registered with the HtmlFactory-service.

Registration is done by using one of the following methods:

• Register a single (fully qualified) class-name as a component.

  Example:

• Register components from the files in a directory.

  Example:

Regarding the $force-parameter: Normally HtmlFactory will throw an error, if another component is already installed with the same accessor. This can be circumvented by setting $force to true. (This way you can also overrule the included components.)

The best location to perform these registrations is within the boot()-method of your AppServiceProvider (or any other ServiceProvider).

Note that you don't need to implement the RegisteredComponentInterface or register the component, if you don't intend to make it instantiable via the Html-facade (e.g. if you use it with your own Service/Facade or instantiate the object with the new keyword).

Customizing components.

To customize your component, you can implement the following hook-methods:

(Be sure to call the parent-methods too if you overwrite these methods, especially when extending other components, so no functionality gets lost.)

Of course you can also create your own constructor (for example to add mandatory parameters). Just be sure to call the parent's constructor.

And of course you can also add additional fluent setters to be callable on the component in your views. The package already includes some traits, which provide some generic fluent setters and corresponding properties. You can find them at the namespace Webflorist\HtmlFactory\Components\Traits.

Examples

Let's take a look at the included SubmitButtonComponent as a very basic example:

The component implements the setUp()-method to set the attribute type to submit by default. Furthermore it also implements the RegisteredComponentInterface and defines submitButton as it's accessor. (Additionally all included components are registered within the boot-method of the HtmlFactoryServiceProvider.)

This enables the following usage:

The output of Html::submitButton() is thus identical to Html::button()->type('submit').

Check out the other included components for more examples!

Decorators

The second way to customize HtmlFactory's output is by using decorators. Decorators are classes, that define themselves, which Elements they are eligible to process. You can for example create a decorator, that adds a CSS-class to all ButtonElements. Decorators are also a great way to apply frontend-framework-specific modifications (e.g. add the form-control-class to field-elements when using bootstrap as the frontend-framework). The decorator itself can also state a group-ID, which results in the decorator only getting applied, if it's group-ID is present in the decorators config-string.

Decorators must expand the abstract class Webflorist\HtmlFactory\Decorators\Abstracts\Decorator, forcing it to implement the following abstract methods:

Registering Decorators

Decorators must be registered with the HtmlFactory-service by using one of the following methods:

• Register a single (fully qualified) class-name as a decorator.

  Example:

• Register decorators from the files in a directory.

  Example:

As with components, the best location to perform these registrations is within the boot()-method of your AppServiceProvider (or any other ServiceProvider).

Examples

HtmlFactory already comes with some included decorators. Let's take at the DecorateButtonElement-class:

It's functionality should be quite obvious. The decorator is only applied, if 'bootstrap:3' is present in the current config htmlfactory.decorators. Also it is only applied to elements or components that are identical to or descendants of Webflorist\HtmlFactory\Elements\ButtonElement. It's function is to add the bootstrap-specific CSS-class 'btn' to buttons.

Check out the other included decorators for more examples!