I have always struggled with how packages are versioned and published to the npm registry.
My main concern is that you probably want to also add a git tag to your source code when you are releasing a new version, but npm packages have their own versioning system, and include a &quot;version&quot; field in the package.json
Because of this, most of the workflows I have seen, usually involve:
<ol>
<li>Running <code>npm version ...</code>. This will update the &quot;version&quot; field in the package.json file.</li>
<li>Publishing the package to the npm registry, using the version set in previous step.</li>
<li>Committing to git, so that we track the change in package.json file.</li>
<li>Adding a git tag.</li>
<li>Pushing to git remote to track new commit and new tag.</li>
</ol>
<blockquote>
Steps 3 and 4 are frequently done automatically as part of <code>npm version</code>.
</blockquote>
For me this flow has two main problems:
<ul>
<li>
My personal preference is that everything is driven by git tags, making them the single source of truth.
This would allow to just have one manual step -&gt; <code>git tag -a v1.0.0 -m &quot;...&quot; &amp;&amp; git push origin --tags</code>. Then, this would trigger a number of potential automations, including publishing to the npm registry, but also others like creating a release with the appropriate release notes, building release artifacts, etc.
</li>
<li>
The &quot;version&quot; field in the package.json file can very easily become outdated, if you git-tag by mistake before publishing the package, or if pushing the changes fails after <code>npm version ...</code> has been run.
I&#x27;ve seen this happening more often than it seems.
</li>
</ul>
Because of this, my current take when publishing npm packages for my personal projects is:
<ol>
<li>
Get rid of the &quot;version&quot; field from the package.json file. It&#x27;s misleading in source code, as it can very easily be out of date.
The only case where it&#x27;s useful is when the package has been installed and is inside node_modules, as other packages will assume this field to exist and have the right value on it.
In this case it&#x27;s always going to be correct due to the<code>npm version ...</code> + <code>npm publish</code> tandem (see next point).
</li>
<li>
Creating the git tag is the only &quot;manual step&quot;. This triggers an automation running <code>npm version ${GIT_TAG} --git-tag-version=false &amp;&amp; npm publish</code> (this is simplified. You probably also need to build your project and other potential extra steps).
The version to publish is inferred from the git tag (<code>${GIT_TAG}</code> is just a placeholder), and only at this stage we will set the &quot;version&quot; inside package.json, just before the package is published.
</li>
<li>
Other automations that need to happen during releases, can be also triggered now, like publishing release notes, building artifacts, etc.
</li>
</ol>
<blockquote>
As an example, you can see <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/github-actions/blob/24de7a2b89a9eb11b0acfd184de7187698b051b6/.github/workflows/js-lib-publish.yml">this GitHub actions workflow</a>, which follows this approach.
</blockquote>

I have always struggled with how packages are versioned and published to the npm registry. My main concern is that you probably want to also add a git tag to your source code when you are releasing a new version, but npm packages have their own versioning system, and include a "version" field in…

My current take when publishing packages to the npm registry

A couple of weeks ago I migrated a React project using redux to <a target="_blank" rel="noopener noreferrer" href="https://redux-toolkit.js.org/">Redux Toolkit</a>.
Redux has always been my preferred state management tool for React (which doesn&#x27;t mean I &quot;love&quot; it), but one of its main problems is the amount of boilerplate code it requires.
Because of that I had a couple of helper functions, but there was still some things not properly handled, like proper type inference on reducers and actions (I use TypeScript).
A bit by accident (I think it was on Twitter), I found out about Redux Toolkit (RTK from now on), an official library from the redux team, which provides some opinionated helpers to reduce the amount of boilerplate, and I decided to give it a chance.
These are my impressions.
<h3>TL;DR</h3>
I first started to use it in a proof of concept, and I quickly loved it.
RTK does not &quot;replace&quot; any of the redux principles, so you can progressively adopt it, by replacing small bits of code. My plan was to use it just for some reducers, but I liked it so much that I ended up migrating the whole project in a series of consecutive pull requests.
<h3>A bit of context</h3>
Before the migration, I used to follow the <a target="_blank" rel="noopener noreferrer" href="https://github.com/erikras/ducks-modular-redux">ducks modular pattern</a>, which promotes putting all your action types, action creators and the reducer handling those actions on the same module.
This fits pretty well with RTK, as in most of the cases you will use <a target="_blank" rel="noopener noreferrer" href="https://redux-toolkit.js.org/api/createSlice">slices</a>, and end up exporting the reducer and action creators returned by it, from the same module.
If you use <a target="_blank" rel="noopener noreferrer" href="https://redux-toolkit.js.org/api/createAsyncThunk">async thunks</a>, they usually need to be used by that same slice, so it&#x27;s not a bad idea to export them also from there.
<h3>Why I love it</h3>
There are a couple of reasons for which I loved RTK right away. The main one is that they make an impressive work on making type inference in TypeScript work properly.
<ul>
<li>Slices detect the type of the initial state in order to know what is expected to be passed as <code>state</code> to reducers.</li>
<li>You can infer the type of your store from what is generated by <code>configureStore</code> or <code>combineReducers</code> functions, allowing you to also properly type the <code>dispatch</code> function.</li>
<li>Action creators are generated with the proper param types based on the reducers provided to <code>createSlice</code> or the callback provided to <code>createAsyncThunk</code>.</li>
<li><code>createSlice</code> can consume all the action creators generated by <code>createAsyncThunk</code>, and infer the proper payload for each one of them.</li>
</ul>
Thanks to this, the code is super predictable and potential bugs can be caught sooner.
<blockquote>
More details on how to use RTK with typescript https://redux-toolkit.js.org/usage/usage-with-typescript
</blockquote>
But this is not the only benefit. Other reasons that make it very nice to work with are:
<ul>
<li>It keeps the same concepts from Redux, but removing the boilerplate or your own helper functions if you have them (yes, I didn&#x27;t want to keep all those <code>switch</code> statements everywhere).</li>
<li>It is mostly transparent for the components dispatching the actions or consuming the state.</li>
<li>All the tests covering your reducers/actions/components should keep passing, as the outcome from RTK is the same as if you built everything manually.</li>
<li>It introduces a couple of extra helpers, like <a target="_blank" rel="noopener noreferrer" href="https://redux-toolkit.js.org/rtk-query/overview">RTK query</a> or the <a target="_blank" rel="noopener noreferrer" href="https://redux-toolkit.js.org/api/createListenerMiddleware">listener middleware</a>, which is very useful to dispatch actions as a result of other actions being dispatched.</li>
</ul>
<h3>Challenges I found</h3>
Of course, adopting a new tool always comes with some challenges.
The main &quot;problem&quot; I found is that RTK is a bit opinionated, but that&#x27;s precisely how they manage to reduce boilerplate code, and it&#x27;s also &quot;advertised&quot; in their website, so not a big surprise.
I usually prefer to be in control of everything (configuration over convention), but that&#x27;s just a personal preference, and sometimes it&#x27;s ok to accept a bit of magic for the sake of simplicity.
This caused the next challenges for my particular case:
<ul>
<li>
RTK assumes your project follows a strict <a target="_blank" rel="noopener noreferrer" href="https://redux.js.org/tutorials/fundamentals/part-7-standard-patterns#flux-standard-actions">Flux pattern</a>, meaning your actions always have the properties <code>type</code>, <code>payload</code> and optionally <code>meta</code> and <code>error</code>.
I was not following this pattern (my actions had the payload &quot;mixed&quot; on the first object level), so I had to adapt all my actions first, fix the tests, then migrate the reducer to RTK and make sure the tests kept passing.
<div></div>
</li>
<li>
Immutability is no longer promoted in reducers. Instead, the library requires <a target="_blank" rel="noopener noreferrer" href="https://immerjs.github.io/immer/">immer</a> internally, and using proxies they automatically ensure immutability, even if you &quot;mutate&quot; the state.
This feels a bit counterintuitive at first, because redux always promoted an immutable approach, and the use of immer is not obvious.
However, they have <a target="_blank" rel="noopener noreferrer" href="https://redux-toolkit.js.org/usage/immer-reducers#why-immer-is-built-in">good reasons</a> to do it, and if your reducers return a state object, you can still use the immutable approach. It&#x27;s up to you.
<div></div>
</li>
<li>
Action creators resulting of <code>createAsyncThunk</code> can only have one argument.
This is because the async thunk callback receives a second argument containing the <code>dispatch</code> and <code>getState</code> functions, as well as a couple of other goodies, enforcing this convention to avoid human errors.
<div></div>
</li>
<li>
You cannot dispatch other actions after the callback passed to <code>createAsyncThunk</code>, because it has to return the payload and RTK dispatches the action for you.
However, this is probably something you usually should not be doing, and in my case, I resolved it with the <a target="_blank" rel="noopener noreferrer" href="https://redux-toolkit.js.org/api/createListenerMiddleware">listener middleware</a>, listening for the second action in order to dispatch the second one.
</li>
</ul>
<h3>Conclusion</h3>
My conclusion is that RTK is definitely worth it if you use redux.
It makes code simpler, more predictable and better typed. However, it still requires knowing how redux works internally and what are its patterns, in order to understand why the library exposes the helpers it exposes and why.
For existing redux projects, you can migrate progressively, addressing the challenges bit by bit and not all at once, which simplifies its adoption.
For new projects in which you want to use redux, I would recommend starting right away with RTK.

A couple of weeks ago I migrated a React project using redux to Redux Toolkit. Redux has always been my preferred state management tool for React (which doesn't mean I "love" it), but one of its main problems is the amount of boilerplate code it requires.

Because of that I had a couple of helper…

My experience migrating to Redux Toolkit (RTK)

In 2019, GitHub published their own solution to run automated workflows called GitHub Actions, which allowed those hosting their code in GitHub, to be able to define and run their CI/CD pipelines in the same platform. When it was released, one of the main pain points to use it was that defining…

How to reduce duplication in your GitHub Actions workflows

Recently ReactJS v18 was released. I started to look into its improvements, and checked which of my projects could benefit from them.
The main react-based project I maintain at the moment of writing this article is <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-web-client">shlink-web-client</a>, so I naturally created a new branch and started the process.
The update was quite smooth, as most of the other dependencies I was using from the react ecosystem were already updated to support v18. All but one, <a target="_blank" rel="noopener noreferrer" href="https://enzymejs.github.io/enzyme/">enzyme</a>, the testing framework I was using to unit-test react components.
To be precise, I was able to continue running my tests, but some of them (those using <code>mount</code> instead of <code>shallow</code>) were still rendering components with the &quot;old&quot; React v17 approach, causing them to behave as in that version and a warning being printed in the console.
<h3>First fix attempt</h3>
The way enzyme integrates with the react version you are using is through an adapter library. The last official one supports only React v16, but someone released an <a target="_blank" rel="noopener noreferrer" href="https://github.com/wojtekmaj/enzyme-adapter-react-17">unofficial adapter for v17</a> which, with close to 650k weekly downloads, quickly became the way to go.
I checked if there was one for React 18, but sadly there wasn&#x27;t.
Also, the author of the adapter for v17 posted an article indicating <a target="_blank" rel="noopener noreferrer" href="https://dev.to/wojtekmaj/enzyme-is-dead-now-what-ekl">enzyme is dead</a>, he was not going to release one for v18, and publishing one for v17 was a mistake.
With those facts in mind, I started to face what was probably going to be the moment to migrate to <a target="_blank" rel="noopener noreferrer" href="https://testing-library.com/docs/react-testing-library/intro">react testing library</a>.
<h3>Migration strategy</h3>
I decided to follow a migration strategy similar to the one suggested in the article above, but with a couple of modifications:
<ul>
<li>I update to React 18 anyway, as tests still pass.</li>
<li>Migrate right away all tests using <code>mount</code>, as those are the ones behaving differently.</li>
<li>New tests should be written directly with react testing library (RTL from now on).</li>
<li>When an existing test needs to be changed, consider migrating it to RTL, and do it if there&#x27;s time.</li>
<li>Introduce some PR from time to time just migrating a handful of tests.</li>
<li>Once everything is migrated, get rid of everything related with enzyme.</li>
</ul>
<h3>First contact and impressions</h3>
I was a bit sceptical with RTL, as it was focused more on integration tests, instead of unit tests, which meant I had to completely change the mindset to write tests.
It also didn&#x27;t support shallow rendering, meaning that you will end up sometimes rendering a bigger component tree when testing container-like components, potentially causing side effects that could affect your test.
On the other hand there&#x27;s more and more people stating that <a target="_blank" rel="noopener noreferrer" href="https://kentcdodds.com/blog/why-i-never-use-shallow-rendering">shallow rendering is an anti-pattern</a>, and that&#x27;s probably the reason of enzyme getting &quot;discontinued&quot;.
Also, RTL has become the <a target="_blank" rel="noopener noreferrer" href="https://reactjs.org/docs/testing.html#tools">officially recommended framework</a> to test react components, it has become very popular, and it has even joined a wider group of testing libraries under the <a target="_blank" rel="noopener noreferrer" href="https://testing-library.com/"><code>@testing-library</code></a> organization.
The thing is that I started to use it, and I was quickly surprised with how it felt to work with it, and all the benefits it was bringing to my tests.
<h3>Benefits I have experienced</h3>
Once I started migrating the first tests I noticed some benefits:
<ul>
<li>Changing my mindset was actually easier than I thought. The docs are very well written, so it&#x27;s relatively easy to start using RTL.</li>
<li>My tests got simpler, and required less of those nasty global mocks that jest allows (I&#x27;m looking at you, <a target="_blank" rel="noopener noreferrer" href="https://jestjs.io/es-ES/docs/mock-functions#mocking-modules"><code>jest.mock</code></a>).</li>
<li>Tests were way less coupled with implementation details. I moved from testing the component props, to test what the user would see on the screen.</li>
<li>Related with previous point, I started to write my tests by looking at the screen instead of the component&#x27;s implementation.</li>
<li>Changes in source code led to fewer tests requiring to be changed.</li>
<li>A progressive migration was possible, where some tests still use enzyme and others are already using RTL.</li>
</ul>
And overall, it felt good and I have already dedicated a couple of PRs just to migrate more tests.
<h3>Challenges I faced</h3>
But of course, migrating to a new tool always comes with its own challenges, and this was not an exception. I&#x27;ll explain the main ones I have faced so far and how I tackled them:
<ul>
<li>
RTL lets you do some things in a couple of different ways, and the docs may not be super clear about what&#x27;s the recommended option.
For this I recommend reading <a target="_blank" rel="noopener noreferrer" href="https://acel.me/DCMb1">this article</a> from Kent C. Dodds, RTL&#x27;s author, which explains some common mistakes when using the library.
</li>
<li>
At first, I struggled a bit with asynchronous side effects and state changes in components, which can easily end up printing a warning like <code>Warning: An update to MyComponent inside a test was not wrapped in act</code>.
The warning also explains how you are supposed to solve this by wrapping your code in <code>act()</code>, but this warning comes from React, not RTL, and what it is not telling you is that RTL already wraps all needed operations in <code>act()</code>.
What this error usually mean is that you are not waiting for something to happen. <a target="_blank" rel="noopener noreferrer" href="https://acel.me/jnUdT">This other article</a>, also from Kent C. Dodds, explains everything you need to know about the things that can lead to this warning, and how to solve them.
</li>
<li>
Since you start testing from the user point of view, some use cases can be challenging to test without coupling with implementation details. For example, when you have a component which dynamically renders different images or icons, I used to directly check the component properties.
For this I found the best solution was to use <a target="_blank" rel="noopener noreferrer" href="https://jestjs.io/docs/snapshot-testing">jest snapshots</a>. I didn&#x27;t want to manually check which SVG was being rendered in the DOM, just that different ones were being used in every case.
<pre class="language-tsx"><code class="language-tsx">// I went from this...
test(&#x27;...&#x27;, () =&gt; {
 const wrapper = shallow(&lt;MyComp dynamicValue=&quot;foo&quot; /&gt;);
 expect(wrapper.find(FontAwesomeIcon).prop(&#x27;icon&#x27;)).toEqual(someIcon);
})

// To this
test(&#x27;...&#x27;, () =&gt; {
 const { container } = render(&lt;MyComp dynamicValue=&quot;foo&quot; /&gt;);
 expect(container.firstChild).toMatchSnapshot();
})
</code></pre>
</li>
<li>
Something very similar happens if you use some library that renders canvas. There&#x27;s no way to test that from a DOM point of view, which is what RTL does.
In my case I was using <a target="_blank" rel="noopener noreferrer" href="https://www.chartjs.org/">Chart.js</a> to render some charts, so I used <a target="_blank" rel="noopener noreferrer" href="https://github.com/hustcc/jest-canvas-mock">jest-canvas-mock</a>, which exposes a method on the canvas to see which are all the events invoked from the library.
Then I used snapshots again to verify they had the expected &quot;shape&quot;.
<pre class="language-tsx"><code class="language-tsx">// I went from this...
test(&#x27;...&#x27;, () =&gt; {
 const wrapper = shallow(&lt;MyCompWithCanvas /&gt;);
 expect(wrapper.find(Chart).prop(&#x27;data&#x27;).datasets).toEqual(...);
})

// To this
test(&#x27;...&#x27;, () =&gt; {
 const { container } = render(&lt;MyCompWithCanvas /&gt;);
 const events = container.querySelector(&#x27;canvas&#x27;)?.getContext(&#x27;2d&#x27;)?.__getEvents();

 expect(events).toBeTruthy();
 expect(events).toMatchSnapshot();
})
</code></pre>
</li>
</ul>
<h3>Conclusion</h3>
For better or worst, enzyme should no longer be considered an option. If you are starting a new project or are using it on small ones, consider migrating to RTL as soon as possible.
If you are using it in bigger projects, following the process described in this article will probably help you.
In any case, you will get surprised. React testing library is a great tool and provides many benefits over enzyme.
Its main issue is that it&#x27;s not a drop-in replacement for enzyme, so you will have to change a bit your mindset.

Recently ReactJS v18 was released. I started to look into its improvements, and checked which of my projects could benefit from them. The main react-based project I maintain at the moment of writing this article is shlink-web-client, so I naturally created a new branch and started the process.

The…

My experience migrating from enzyme to react testing library

Capturing code coverage for a test suite is a very useful way to know which parts of your source code are actually getting executed by tests. This is useful not only to know if you need to add more tests to your project (in case the coverage is too low), but also, if you want to apply technics like…

Capturing remote code coverage in API tests with PHPUnit

One of the trending topics in the PHP world nowadays is the one about microframeworks. It started some years ago with <a target="_blank" rel="noopener noreferrer" href="http://www.slimframework.com/">Slim</a> and <a target="_blank" rel="noopener noreferrer" href="http://silex.sensiolabs.org/">Silex</a>, but recently it has been an explossion of new microframeworks.
First, Slim&#x27;s team announced the third version of its own framework, which implemented the psr-7 HTTP standard by taking advantage of the middleware concept. The previos version works with Middleware too, but psr-7 looks to be designed to be used with middleware.
Then, Laravel launched the <a target="_blank" rel="noopener noreferrer" href="https://lumen.laravel.com/">Lumen</a> project, which is another microframework based on Laravel components, similar to Silex, which is based on Symfony components.
And finally, Zend framework&#x27;s team launched <a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zend-expressive">Zend Expressive</a>, which is similar to Slim 3 in the fact that it works with middleware and psr-7, built on top of <a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zend-stratigility">zend-stratigility</a> and <a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zend-diactoros">zend-diactoros</a>.
Recently, after playing with Slim 3 and Zend Expressive, I decided to use the last one to rebuild my website, which used to be a ZF2 application.
It is open source and you can find it <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/website-expressive">here</a>.
<h3>Why microframeworks</h3>
I have said several times that composer has completely changed PHP. Now it is possible to access to any package or component in any application, which is a really big advantage. You don&#x27;t have to stick to certain framework&#x27;s implementation if there is another one that you like better.
That&#x27;s made possible to start working with a framework that doesn&#x27;t have a solution for everything, and your poroject can still scale thanks to the fact that composer gives you access to almost anything.
There is where microframeworks have their power.
Also, having in mind that every time more and more packages depend on common abstractions (like the psr abstractions, psr-3 or psr-7, or the new <a target="_blank" rel="noopener noreferrer" href="https://github.com/container-interop/container-interop">container interop</a>), those small frameworks can work with many existing powerful components.
<h3>Why Zend Expressive</h3>
The first thing that I liked in Zend Expressive is that it doesn&#x27;t force you to use an implementaiton for common tasks.
The router, the templates engine and the service container are based on abstractions, which means that you can virtually use whichever fits you the most. It comes with support for two or three of each one, but you could integrate any third party component by implementing an interface.
Also, since this framework has been created by the ZF team, it comes with support for ZF2 components, which I am more used to. Specially I like to be able to use the <code>Zend\ServiceManager</code>, like in Slim 3.
<h3>Configuration driven apps</h3>
All of the microframeworks that I&#x27;ve already mentioned have something in common. They work on top of the main <code>Application</code> object, which usually implements methods to define routes and add middleware.
For example, in Slim 3, you can do something like this to dispatch a request:
<pre class="language-php"><code class="language-php">$app = new Slim\App();
$app-&gt;get(&#x27;/hello/:name&#x27;, function ($req, $res, $args) {
 echo &#x27;Hello, &#x27; . $args[&#x27;name&#x27;] . &#x27;!!&#x27;;
});
$app-&gt;run();
</code></pre>
The same thing can be done like this with Silex:
<pre class="language-php"><code class="language-php">$app = new Silex\Application(); 
$app-&gt;get(&#x27;/hello/{name}&#x27;, function ($name) use($app) { 
 return &#x27;Hello, &#x27; . $app-&gt;escape($name) . &#x27;!!&#x27;; 
}); 
$app-&gt;run(); 
</code></pre>
And also, with Expressive, you do it like this:
<pre class="language-php"><code class="language-php">$app = Zend\Expressive\AppFactory::create();
$app-&gt;get(&#x27;/hello/{name}&#x27;, function ($request, $response, $next) {
 $response-&gt;write(&#x27;Hello, &#x27; . $request-&gt;getAttribute(&#x27;name&#x27;) . &#x27;!!&#x27;);
 return $response;
});
$app-&gt;run();
</code></pre>
It is very similar in every case, and it is good enough for prototyping and small applications. However this is not my favourite approach. I prefer to use the service container as the main object, and fetch the <code>Application</code> in the front controller as a regular service. The best microframework to work like this is Expressive.
For example, in my website, the front controller looks like this.
<pre class="language-php"><code class="language-php">chdir(dirname(__DIR__));

// [...]

/** @var Interop\Container\ContainerInterface $container */
$container = include &#x27;config/container.php&#x27;;
/** @var Zend\Expressive\Application $app */
$app = $container-&gt;get(Zend\Expressive\Application::class);
$app-&gt;run();
</code></pre>
This approach allows me to define some configuration files that are consumed by factories while creating services, and the Application object is treated like another Service, injecting middlewares and routes from config files.
You don&#x27;t even have to define the factory yourself, since Expressive includes an <code>ApplicationFactory</code> that can be registered and it fetches the outstanding configuration for you.
Another cool thing in Expressive is that the <code>Application</code> itself is middleware, and so, it can pipe nested <code>Applications</code>. It also treats routes as a middleware that is registered to be resolved as a result of certain route, instead of being resolved for every route.
So, in Expressive, everything is middleware lazily fetched from a service container to dispatch HTTP requests.
<h3>Router</h3>
Currently, Expressive includes implementations to integrate with three routers. <a target="_blank" rel="noopener noreferrer" href="https://github.com/auraphp/Aura.Router">Aura.Router</a>, <a target="_blank" rel="noopener noreferrer" href="https://github.com/nikic/FastRoute">FastRoute</a> and <a target="_blank" rel="noopener noreferrer" href="https://framework.zend.com/manual/current/en/modules/zend.mvc.routing.html">ZF2 MVC router</a>. The first is used by default.
For small applications like my website, any of them should be good enough, but I needed routes to support optional params at the beginning of the path (the language). Neither Aura.Router or FastRoute do it, so I had to stick with ZF2&#x27;s router in combination with a custom Segment route that allows to skip certain parts of the route, otherwise I would have been forced to define the same route with different names, which would have made assembling routes with param inheritance much harder.
The fun thing is that Slim&#x27;s router does support optional route params at the beginning of the path, at least in version 2. Maybe I try to integrate it in the future with Expressive, since I don&#x27;t need all the power provided by ZF2&#x27;s router.
<blockquote>
Update 2015-09-20: I have finally created a Slim&#x27;s router integration library and I&#x27;m now using it. You can find it here <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/expressive-slim-router">https://github.com/acelaya/expressive-slim-router</a>.
</blockquote>
To make a router other than Aura.Router to be automatically injected in the Applicaiton when using the container&#x27;s <code>ApplicationFactory</code>, you need to register a service with the <code>Zend\Expressive\Router\RouterInterface</code> name.
<h3>Template engine</h3>
Similarly to the routers, Expressive works with an abstraction layer which eases the task of using any template engine with it. It comes with <a target="_blank" rel="noopener noreferrer" href="http://twig.sensiolabs.org/">Twig</a>, <a target="_blank" rel="noopener noreferrer" href="http://platesphp.com/engine/">Plates</a> and <a target="_blank" rel="noopener noreferrer" href="http://framework.zend.com/manual/current/en/modules/zend.view.quick-start.html">Zend\View</a> integration, using the second one by default, but it shouldn&#x27;t be hard to use anyone else, like <a target="_blank" rel="noopener noreferrer" href="http://laravel.com/docs/5.0/templates">Blade</a>.
I have used twig for my website, because I&#x27;ve been using it lately, and I really like it.
The template engine will be injected in the Applicaiton by fetching the <code>Zend\Expressive\Template\TemplateInterface</code> service.
<h3>Service container</h3>
The service container is very important in Expressive. All the services, middlewares and configurations are fetched from it. Expressive expects an <code>Interop\Container\ContainerInterface</code> object, which is implemented by the most used service containers (or dependency injection containers if you prefer so).
Documentation on how to use <a target="_blank" rel="noopener noreferrer" href="https://framework.zend.com/manual/current/en/modules/zend.service-manager.html">Zend\ServiceManager</a>, <a target="_blank" rel="noopener noreferrer" href="http://pimple.sensiolabs.org/">Pimple</a> and <a target="_blank" rel="noopener noreferrer" href="https://github.com/auraphp/Aura.Di">Aura.Di</a> is included in the project. Depending on how big you expect your application to become, you can use one or another, but you should be able to replace it in case of need.
If no container is provided, the Application will use the first one. Also, it has been my choice, and as I said earlier, everything in my website&#x27;s project is managed by the ServiceManager, even the <code>Application</code> object itself.
It&#x27;s one of my favourite PHP components and I use it whenever I can.
<h3>Error management</h3>
Another thing that any framework has to provide is a way to catch requests to invalid routes or uncaught exceptions and errors. In Expressive that&#x27;s made by the so called <code>FinalHandler</code>.
By default it just displays plain text errors, and returns the proper status code (404 or 500). If you want certain template to be rendered, you have to register a <code>TemplateErrorHandler</code> in your container, via the <code>Zend\Expressive\Container\TemplatedErrorHandlerFactory</code>. It will use a configuration block to know which template has to be rendered in each case, and use the registered template engine to render them.
In development, a <code>WhoopsErrorHandler</code> can be used too. It extends the functionality of the <code>TemplatedErrorHandler</code> by using <a target="_blank" rel="noopener noreferrer" href="https://filp.github.io/whoops/">Whoops</a> to display nice errors. Make sure to never use it in production.
<h3>Other considerations</h3>
You know now how to use the main components in the framework, but you need to know how <a target="_blank" rel="noopener noreferrer" href="http://www.php-fig.org/psr/psr-7/">psr-7</a> works and how to use middleware. You should read these articles if you are not familiar with those concepts, since the whole framework is built on top of them.
<ul>
<li><a target="_blank" rel="noopener noreferrer" href="https://mwop.net/blog/2015-01-26-psr-7-by-example.html">PSR-7 By Example</a></li>
<li><a target="_blank" rel="noopener noreferrer" href="https://mwop.net/blog/2015-01-08-on-http-middleware-and-psr-7.html">On HTTP, Middleware, and PSR-7</a></li>
</ul>
You should also take a look at the official documentation. It is not very long and it&#x27;s very well structured. <a target="_blank" rel="noopener noreferrer" href="http://zend-expressive.readthedocs.org/en/stable/">https://zend-expressive.readthedocs.org/en/stable/</a>
<h3>Conclusion</h3>
Those are all the things that can be done with Expressive. It could seem too basic, but it is also very extensible via composer. That&#x27;s its forte.
Probably, for my website I could have used any other microframework (Indeed I was planning to use Slim 3 before Expressive was launched), but I liked Expressive from the beginning and decided to go with it despite it is not stable yet.

One of the trending topics in the PHP world nowadays is the one about microframeworks. It started some years ago with Slim and Silex, but recently it has been an explossion of new microframeworks. First, Slim's team announced the third version of its own framework, which implemented the psr-7 HTTP…

My first approach to Zend Expressive

About a year ago I wrote two articles discussing the best way to work with modules with sub-namespaces in Zend Framework 2.
Here you can find <a href="/2014/05/21/create-modules-with-sub-namespaces-in-zend-framework-2/">Part 1</a> and <a target="_blank" rel="noopener noreferrer" href="http://alejandrocelaya.blog/2014/06/21/create-modules-with-sub-namespaces-in-zend-framework-2-part-ii/">Part 2</a>
The solution provided in those articles was functional, but it introduced some new problems to deal with. It happens that after some time working with sub-namespaced modules I have found the best way to solve those new problems, and I wanted to write this new article explaining it.
For this article I&#x27;m going to use the example namespace <code>ZasDev\AtomicReader</code>, which belongs to a real <a target="_blank" rel="noopener noreferrer" href="https://github.com/zasDev/atomic-reader">application</a> I&#x27;m working on. For example, in my <code>Auth</code> module, a real fully qualified class name could be <code>ZasDev\AtomicReader\Auth\Controller\LoginController</code>.
<h3>The problems</h3>
<h4>Autoloading</h4>
By default, ZF2 uses a psr-0-like way to perform autoloading. This would force us to create a new folder per namespace level in our module, but since <code>Module</code> classes &quot;are loaded&quot; from the root of the module and the rest of the classes are loaded from the nested src folder, it would be 2 new folders per namespace instead.
With the previously mentioned namespace, the module&#x27;s folder structure would be this.
<pre><code>modules
└── ZasDev
 └── AtomicReader
 └── Auth
 ├── config
 │ └── ...
 ├── view
 │ └── ...
 ├── src
 │   └── ZasDev
 │   └── AtomicReader
 │   └── Auth
 │   ├── Controller
 │   │   └── LoginController.php
 │   ├── Form
 │ │ └── ...
 │   └── Service
 │ └── ...
 └── Module.php
</code></pre>
There are people that think that is the correct way to work, but I don&#x27;t like to have so many &quot;empty&quot; folders.
<h4>View scripts resolution</h4>
As I mentioned in previous articles, the automatic view script resolution in Zend Framework 2 when a controller&#x27;s action returns a <code>ViewModel</code> instance is to use the action&#x27;s name as the script name, the controllers&#x27; class name as the parent folder, and the first level namespace as the root folder. That is a problem when all the modules have a common top-level namespace.
In the original articles we found that the solution was to use the <code>controller_map</code> option for the <code>view_manager</code> configuration like this.
<pre class="language-php"><code class="language-php">&lt;?php
return [
 &#x27;view_manager&#x27; =&gt; [
 &#x27;controller_map&#x27; =&gt; [
 &#x27;ZasDev&#x27; =&gt; true
 ]
 ]
];
</code></pre>
That will make the view resolver to use all the controller&#x27;s namespace levels as folders, which solves the original problem but generates a similar problem as in the autoloading case, by making us to have a lot of empty folders.
The last example would produce this folder structure for view scripts.
<pre><code>modules
└── ZasDev
 └── AtomicReader
 └── Auth
 ├── config
 │ └── ...
 ├── view
 │ └── zas-dev
 │ └── atomic-reader
 │ └── auth
 │ └── login
 │ └── index.phtml
 ├── src
 │ └── ...
 └── Module.php
</code></pre>
<h3>The solutions</h3>
It turns out that the solution to both problems is really easy.
This days everybody uses <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/">composer</a> on their PHP projects. Using composer&#x27;s autoloading we can solve the first problem.
By having this module&#x27;s folder structure, which is much more usable.
<pre><code>modules
└── Auth
 ├── config
 │ └── ...
 ├── view
 │ └── ...
 └── src
    ├── Controller
     │   └── LoginController.php
    ├── Form
 │ └── ...
    ├── Service
 │ └── ...
 └── Module.php
</code></pre>
We just need to define this psr-4 autoloading strategy in our composer.json and all the classes will be properly loaded.
<pre class="language-javascript"><code class="language-javascript">// composer.json
{
 &quot;autoload&quot; : {
 &quot;psr-4&quot; : {
 &quot;ZasDev\\AtomicReader\\Auth\\&quot; : &quot;modules/Auth/src&quot;
 }
 }
}
</code></pre>
And then just refresh the autoloader by running <code>composer dumpautoload</code>.
Repeat that for each module and that&#x27;s it. Also you won&#x27;t need to define the module&#x27;s autoloading in the <code>Module</code> class.
The problem with the view scripts resolution can be fixed by changing the <code>controller_map</code> configuration a little bit. It turns out that it allows to map module namespaces to folder structures, so that not all the levels are replaced by folders in the path resolution.
With this configuration, we will get controllers in the <code>ZasDev\AtomicReader\Auth</code> namespace to be resolved to the <code>auth</code> folder.
<pre class="language-php"><code class="language-php">&lt;?php
return [
 &#x27;view_manager&#x27; =&gt; [
 &#x27;controller_map&#x27; =&gt; [
 &#x27;ZasDev\AtomicReader\Auth&#x27; =&gt; &#x27;auth&#x27;,
 // ...
 ]
 ]
];
</code></pre>
And our complete module&#x27;s folder structure will end like this.
<pre><code>modules
└── Auth
 ├── config
 │ └── ...
 ├── view
 │ └── auth
 │ └── login
 │ └── index.phtml
 └── src
    ├── Controller
     │   └── LoginController.php
    ├── Form
 │ └── ...
    ├── Service
 │ └── ...
 └── Module.php
</code></pre>
<h3>Other approaches</h3>
Of course, even though I think this is the best solution, it is not the only one.
For the templates problem, you could use a <code>template_map</code> to get view scripts resolved, but during development that&#x27;s not the best scenario, since you will be forced to update that map every time you create a new template file.
Also, you could think that the first approach with a lot of folders is the best one. Be free to use it if you are more confortable with it.
Another solution would be to &quot;pack&quot; all the namespaces in a unique namespace that includes the vendor name, the applicaton name and the module name, like <code>ZasDevAtomicReaderAuth</code>, with classes like <code>ZasDevAtomicReaderAuth\Controller\LoginController</code>, but I don&#x27;t think that&#x27;s the best solution either.
Anyway, following this rules, you will be able to use sub-namespaces in modules in a very easy way.

About a year ago I wrote two articles discussing the best way to work with modules with sub-namespaces in Zend Framework 2. Here you can find Part 1 and Part 2

The solution provided in those articles was functional, but it introduced some new problems to deal with. It happens that after some time…

Working with sub-namespaced modules in Zend Framework 2 the right way

Doctrine is currently the most used ORM in PHP. It makes it very easy to work with databases in an object oriented way.
It comes with a set of built-in column types that map database types with PHP types. For example, the datetime column type, persists the value of an entity column as a datetime in the database and handles it as a <code>DateTime</code> object when the entity is hydrated.
Type conversions work both ways, so column types take care of casting database to PHP types and vice versa.
In this article I&#x27;m going to explain how to define custom column types so that we can persist our own objects into the database and hydrate them back.
<h3>PHP enums</h3>
One of the features that PHP lacks of, is a consistent enumerations API. You can always define a class full of constants, but PHP constants can only be scalars, so we can&#x27;t define custom methods. Also, it is not possible to limit the values of an enumeration or typehint arguments and return types when using those constants.
For this purpose I recently discovered the <a target="_blank" rel="noopener noreferrer" href="https://github.com/myclabs/php-enum">myclabs/php-enum</a> package. It provides a very good way to mimic Java enumerations in PHP.
Using this package, we can limit the values of properties in doctrine entities, but we need to tell doctrine how to persist those enumerations.
<h3>Custom Doctrine type</h3>
Let&#x27;s imagine we have this enum, and we want it to be a valid doctrine type.
<pre class="language-php"><code class="language-php">&lt;?php
namespace Acelaya\Enum;

use MyCLabs\Enum\Enum;

class Action extends Enum
{
 const CREATE = &#x27;create&#x27;;
 const READ = &#x27;read&#x27;;
 const UPDATE = &#x27;update&#x27;;
 const DELETE = &#x27;delete&#x27;;
}
</code></pre>
We also have this entity with a column of type <code>Acelaya\Enum\Action</code>.
<pre class="language-php"><code class="language-php">&lt;?php
namespace Acelaya\Entity;

use Acelaya\Enum\Action;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity()
 * @ORM\Table(name=&quot;my_entities&quot;)
 */
class MyEntity
{
 /**
 * @var int
 *
 * @ORM\Id
 * @ORM\Column(type=&quot;integer&quot;)
 * @ORM\GeneratedValue(strategy=&quot;AUTO&quot;)
 */
 protected $id;
 /**
 * @var string
 *
 * @ORM\Column()
 */
 protected $name;
 /**
 * @var Action
 *
 * @ORM\Column(type=&quot;php_enum_action&quot;)
 */
 protected $action;

 // Getters and setters...
}
</code></pre>
We have used the column type php_enum_action in the <code>Doctrine\ORM\Mapping\Column</code> annotation for the <code>$action</code> property. We now need to tell doctrine how to convert that type from PHP to database and how to hydrate the column back.
Defining a custom type in doctrine is as easy as creating a class extending <code>Doctrine\DBAL\Types\Type</code>, and overwriting the methods <code>getName</code>, <code>getSQLDeclaration</code>, <code>convertToPHPValue</code> and <code>convertToDatabaseValue</code>.
<pre class="language-php"><code class="language-php">&lt;?php
namespace Acelaya\Type;

use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Types\Type;
use Acelaya\Enum\Action;

class ActionEnumType extends Type
{ 
 /**
 * Gets the name of this type.
 *
 * @return string
 */
 public function getName()
 {
 return &#x27;php_enum_action&#x27;;
 }
 
 /**
 * Gets the SQL declaration snippet for a field of this type.
 *
 * @param array $fieldDeclaration The field declaration.
 * @param \Doctrine\DBAL\Platforms\AbstractPlatform $platform The currently used database platform.
 *
 * @return string
 */
 public function getSQLDeclaration(array $fieldDeclaration, AbstractPlatform $platform)
 {
 return &#x27;VARCHAR(256) COMMENT &quot;php_enum_action&quot;&#x27;;
 }
 
 public function convertToPHPValue($value, AbstractPlatform $platform)
 {
 if (! Action::isValid($value)) {
 throw new \InvalidArgumentException(sprintf(
 &#x27;The value &quot;%s&quot; is not valid for the enum &quot;%s&quot;. Expected one of [&quot;%s&quot;]&#x27;,
 $value,
 Action::class,
 implode(&#x27;&quot;, &quot;&#x27;, Action::keys())
 ));
 }
 return new Action($value);
 }
 
 public function convertToDatabaseValue($value, AbstractPlatform $platform)
 {
 return (string) $value;
 }
}
</code></pre>
This is what each method does:
<ul>
<li><code>getName</code>: It just returns the name of the type that is used in the <code>Doctrine\ORM\Mapping\Column</code> annotation.</li>
<li><code>getSQLDeclaration</code>: Returns the SQL code used to create a field that is going to store the value of the enum in the database. A simple VARCHAR is enough in our case.</li>
<li><code>convertToPHPValue</code>: Gets the value of the database and casts it to a PHP value. In this case it is going to get a string (from the VARCHAR field) and return an <code>Acelaya\Enum\Action</code> instance with the correct value. It also checks that the value from the database is valid for the enum.</li>
<li><code>convertToDatabaseValue</code>: Finally this method casts the objects of type <code>Acelaya\Enum\Action</code> to something that can be stored in a VARCHAR column. Since objects of type <code>MyCLabs\Enum\Enum</code> implement the <code>__toString()</code> method, which returns the value of the corresponding constant, this operation is as simple as casting the value to string.</li>
</ul>
We now have to register this custom type so that doctrine is able to handle it.
At your application&#x27;s bootstrap, make this call.
<pre class="language-php"><code class="language-php">// [...]

use Doctrine\DBAL\Types\Type;
use Acelaya\Type\ActionEnumType;

// [...]

Type::addType(&#x27;php_enum_action&#x27;, ActionEnumType::class);
</code></pre>
And that&#x27;s it! You can use your custom type wherever you want, and be sure that your entity properties will be objects properly persisted into the database.
<h3>The Doctrine enum type package</h3>
I couldn&#x27;t finish this article without mentioning a package that I published two days ago, the <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/doctrine-enum-type">acelaya/doctrine-enum-type</a>.
You have probably seen that the previous process needs to be done once per enum, since each custom type will need to return a different object type and have a different name.
This package eases that process, by providing a base abstract class, the <code>Acelaya\Doctrine\Type\AbstractPhpEnumType</code>, which implements the common parts. You will just need to define the name and the enum&#x27;s object type, and then register each type.
For example, using this package, the <code>Acelaya\Type\ActionEnumType</code> would have been like this:
<pre class="language-php"><code class="language-php">&lt;?php
namespace Acelaya\Type;

use Acelaya\Doctrine\Type\AbstractPhpEnumType;
use Acelaya\Enum\Action;

class ActionEnumType extends AbstractPhpEnumType
{
 /**
 * You have to define this so that type mapping is properly performed
 */
 protected $enumType = Action::class;

 /**
 * @return string
 */
 protected function getSpecificName()
 {
 return &#x27;action&#x27;;
 }
}
</code></pre>
The rest of the process is the same.

Doctrine is currently the most used ORM in PHP. It makes it very easy to work with databases in an object oriented way. It comes with a set of built-in column types that map database types with PHP types. For example, the datetime column type, persists the value of an entity column as a datetime in…

Working with custom column types in Doctrine. Enums.

About a month ago I released the Zend Framework 2 module ZF2-AcMailer version 5.0.0. This new major version includes some important improvements, and a new configuration system that allows multiple mail services to be registered. When this module was on its first version, I wrote an article explain…

Emails in Zend Framework 2 with ZF2-AcMailer version 5

<a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/">Composer</a> is The Tool in any modern PHP project. Nowadays I can&#x27;t imagine to work without it.
It is much more powerful than some people think, easily solving the integration of third party components in our projects, but there are some advanced features that are less known.
I&#x27;m going to try to explain some of the best practices and mechanisms bundled with composer.
<blockquote>
If you are not familiar with composer, some time ago I wrote an introduction article that you should read before continuing with this one. <a href="/2014/07/19/dependency-management-and-autoloading-in-php-projects-with-composer/">Dependency management and autoloading in php projects with composer</a>.
</blockquote>
<h3>Globally installing composer</h3>
It is a good practice to have composer installed globally, instead of having a binary file per project.
After downloading the <code>composer.phar</code> file from the <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/download/">composer</a> website, you can start using it by running <code>php composer.phar [...]</code>. Instead, we are going to place it in a global location so that we can run the command <code>composer [...]</code> from this moment on.
In UNIX systems, just make the file executable and move it to a folder that&#x27;s already in the path.
<pre class="language-bash"><code class="language-bash">sudo chmod +x composer.phar
sudo mv composer.phar /usr/local/bin/composer
</code></pre>
Under Windows systems, there is an installer that will make the work for you. Download it <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/doc/00-intro.md#installation-windows">here</a>.
Now, go to any location and run <code>composer</code>. You should see composer&#x27;s help.
<h3>Create the composer.json file</h3>
The first thing you should do when starting a new PHP project is to create the composer.json file. It is the main configuration file, where metadata, dependencies and autoloading are defined.
You probably don&#x27;t remember the main parts of this file, and end up copying the file from othe projects. There is no need to do that, just run <code>composer init</code> and the Composer config generator will be executed, guiding you over the process of creating the file.
<h3>Add dependencies to an existing composer.json file</h3>
In the documentation of many libraries, they tell you to manually edit your composer.json file to add new dependencies. That can be problematic, because you could have a syntax error, forget to add a trailing comma, etc.
The best practice to add dependencies to your composer.json file is to run the command <code>composer require vendor-name/library-name ~3.0</code>. That will add the new dependency to your file (avoiding syntax errors) and then install it.
If you don&#x27;t include the version name, composer will try to find out what&#x27;s the best version to use, by following <a target="_blank" rel="noopener noreferrer" href="http://semver.org/">Semantic Versioning</a>. If it is not able to know which version to use, it will ask you to decide.
<h3>Production environments</h3>
The management of dependencies and new classes is not the same in our development environment and the production environment. In development we need new classes to be automatically autoloaded, and we want to have certain dependencies, like phpunit or php code sniffer that are not of any use in production.
In development we will usually install or update dependencies by running <code>composer install</code> or <code>composer update</code>. That will include all dependencies in require and require-dev blocks, and generate an autoloader by following different strategies. Some of those autoloading strategies imply the iteration of directories in order to find class files.
That is ok for development, but in production we need something more efficient than that, and also, we don&#x27;t want require-dev dependencies to be installed.
To get this done, in a deployment process, we should run this command instead.
<pre class="language-bash"><code class="language-bash">composer install --no-dev --optimize-autoloader --prefer-dist --no-interaction
</code></pre>
This is what each flag makes:
<ul>
<li><code>--no-dev</code>: prevents dependencies defined in the requre-dev block to be installed.</li>
<li><code>--optimize-autoloader</code>: generates a classmap autoloader, that will map each class with the file that contains it, preventing unnecessary directory iterations.</li>
<li><code>--prefer-dist</code>: installs distributable versions of the libraries, instead of source code, when possible.</li>
<li><code>--no-interaction</code>: will always try to make the proper decission in case any &quot;conflict&quot; is produced, so that the process is completly unatended.</li>
</ul>
This is the command you should use when deploying a project, just after clonning a clean repository.
<h3>Private repositories</h3>
This is probably one of the most powerful features while working on many private projects that depend on each other.
By default, composer fetches dependencies from a single repository, <a target="_blank" rel="noopener noreferrer" href="https://packagist.org/">Packagist</a>, which needs to have access to a public repository (usually github). But what happens if my code is private, and I don&#x27;t want to (or can&#x27;t) open source it? May I use composer to install private dependencies? The answer is yes.
The composer.json file can include a repositories block, where we define other repositories (either public or private) where composer will try to find dependencies.
There are several repository types supported by composer, from a VCS repository to a plain local directory containing zip files.
<pre class="language-javascript"><code class="language-javascript">{
 &quot;repositories&quot;: [
 {
 &quot;type&quot;: &quot;vcs&quot;,
 &quot;url&quot;: &quot;https://my-repos.com/something-private&quot;
 },
 {
 &quot;type&quot;: &quot;pear&quot;,
 &quot;url&quot;: &quot;http://pear2.php.net&quot;
 },
 {
 &quot;type&quot;: &quot;artifact&quot;,
 &quot;url&quot;: &quot;path/to/directory/with/zips/&quot;
 }
 ]
}
</code></pre>
Composer will look for dependencies on each defined repository in order, and Packagist as a last resource.
Defining repositories is very flexible and a little bit complex in some cases, so I recommend you to read the <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/doc/05-repositories.md">documentation</a>.
<h3>CLI scripts</h3>
Sometimes a library includes some command line interface scripts that the user can use to automate configuring some stuff.
If you want to include your own CLI scripts and allow any user to find them when installing your library as a dependency, you will want to define them in the bin block.
<pre class="language-javascript"><code class="language-javascript">{
 &quot;bin&quot;: [
 &quot;scripts/generate-foo&quot;,
 &quot;scripts/create-bar&quot;,
 &quot;scripts/do-something&quot;
 ]
}
</code></pre>
It is just a list of script paths that composer will &quot;copy&quot; to the <code>vendor/bin</code> directory after installation (it doesn&#x27;t really copy them, it creates symlinks in UNIX systems and generates bat files under Windows).
This makes all the CLI scripts of all dependencies to be &quot;placed&quot; in the same location, so it is easier to find them.
This makes sense only in non-root projects (those that will be installed as dependencies of other projects and are not base applications).
<h3>Events</h3>
Composer will trigger some events during the process of installing dependencies, generating autoloaders and such. You can define some scripts or code snippets that will be automatically executed when those events are triggered.
These event listeners are defined in the scripts block. They can be either CLI commands or static class methods.
<pre class="language-javascript"><code class="language-javascript">{
 &quot;scripts&quot;: {
 &quot;post-package-install&quot;: &quot;Acelaya\\MyClass::postPkgInstall&quot;,
 &quot;post-install-cmd&quot;: [
 &quot;Acelaya\\MyClass::postInstall&quot;,
 &quot;phpunit -c app/&quot;
 ]
 }
}
</code></pre>
The complete list of events can be found in composer&#x27;s <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/doc/articles/scripts.md#event-names">documentation</a>. Take a look at them and see if you can optimize your workflow.
<h3>Applications installation</h3>
At this point we all know that we can use composer to install libraries at project level, but what happens with applications, known as root projects in composer&#x27;s terms.
We can also use composer to distribute complete applications, allowing them to be easily installed by using this command.
<pre class="language-bash"><code class="language-bash">composer create-project vendor-name/app-name
</code></pre>
This will download the application (as if we would have cloned the repository) and then install its dependencies. We could even take advantage of composer&#x27;s events, and initialize a database or create some non-tracked directories.
<h3>Conclusion</h3>
And that&#x27;s pretty much all.
Use composer, it will improve your PHP projects.

Composer is The Tool in any modern PHP project. Nowadays I can't imagine to work without it. It is much more powerful than some people think, easily solving the integration of third party components in our projects, but there are some advanced features that are less known.

I'm going to try to…

Composer advanced concepts

Some time ago I published an article talking about different Doctrine configurations when using the DoctrineORMModule in Zend Framework 2 applications, so that you can create multiple database connections, either by using one entity manager or more than one. Since then, many people have asked me…

Dynamically create doctrine entity managers in Zend Framework 2

Some time ago I wrote the most successful article of this blog, Advanced usage of ServiceManager in Zend Framework 2, explaining all the ways a service can be created by making use of Zend\ServiceManager, the service container component in Zend Framework 2. On this article I'm going to show a real…

Managing objects creation and dependency injection with Zend\ServiceManager

Any medium and large project has to deal at some point with the problem of translating the application itself to other languages. There are many tools and standards to do this, but one of my favourite components is <a target="_blank" rel="noopener noreferrer" href="https://zf2.readthedocs.org/en/latest/modules/zend.i18n.translating.html">Zend\I18n</a>.
Everybody who knows me is aware that I love Zend Framework, but unfortunately it&#x27;s been a while since the last time I worked on a project based on it.
But nowadays that is not a problem. <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/">Composer</a> allows you to install any component or library on any project, so I&#x27;m indeed constantly using many ZF2 components.
I&#x27;m going to explain how to use one of those components, Zend\I18n, to manage application translations, which is a component that internally uses the <code>intl</code> PHP extension, so make sure to have it installed.
<h3>Installation</h3>
As usual, this component is easily installable with composer by running this command.
composer require zendframework/zend-i18n:~2.2
If you want, I&#x27;ve created an example project that I&#x27;m going to use on this article. You can find it <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya-blog/internationalization">here</a>, just clone it and run <code>composer update</code>.
Then go to the public directory, run <code>php -S 0.0.0.0:8000</code> and navigate to <a href="http://localhost:8000" target="_blank">localhost:8000</a>
<blockquote>
If you are not familiar with composer, take a look at this <a href="/2014/07/19/dependency-management-and-autoloading-in-php-projects-with-composer/">article</a>.
</blockquote>
<h3>Translation files</h3>
The first we need to decide is the way we are going to store translations. There are many supported formats, from plain PHP arrays where we set a translation key and the text in a language, to <a target="_blank" rel="noopener noreferrer" href="https://www.gnu.org/software/gettext/">gettext</a> files that can be automatically updated with new strings to be translated, but we could also use xml or ini files.
The preferred method when using Zend\I18n is gettext (and it would be also my choice). It is easy to configure, uses super fast binary files in production and we don&#x27;t need to define translations immediately, we can leave it for then, so that it doesn&#x27;t break the development flow.
Gettext files are usually handled with an external tool, <a target="_blank" rel="noopener noreferrer" href="https://poedit.net/">poedit</a>, an open source cross-platform application that can inspect our project and find new translations, deleted translations and updated translations, syncing our translation files (usually those with <code>po</code> extension) so that we don&#x27;t need to remember where we added or updated internationalizable texts.
To do this we just need to tell the program the name of the functions we use to translate strings (usually <code>translate</code>, <code>gettext</code>, <code>_</code> and such) and the files it needs to scan for new translations.
It also compiles and generates the binary <code>.mo</code> files, which are the ones used by the application.
<h3>The translator</h3>
Once we have decided the format of the files that are going to store translations, we have to create the main <code>Zend\I18n\Translator\Translator</code> object that is going to be used to find translations by consuming certain configuration.
In the example, the <code>src/translator.php</code> file generates and returns a <code>Translator</code> instance. You will need to register your object in some kind of service container so that you can inject it anywhere. This example is so simple, that I just included the file in the index.php.
The <code>Translator</code> has a factory method that is able to consume a configuration to generate the instance. It looks like this.
<pre class="language-php"><code class="language-php">use Zend\I18n\Translator\Translator;

return Translator::factory([
 &#x27;locale&#x27; =&gt; &#x27;en&#x27;,
 &#x27;translation_file_patterns&#x27; =&gt; [
 [
 &#x27;base_dir&#x27; =&gt; __DIR__ . &#x27;/../languages&#x27;,
 &#x27;type&#x27; =&gt; &#x27;gettext&#x27;,
 &#x27;pattern&#x27; =&gt; &#x27;%s.mo&#x27;,
 ],
 [
 &#x27;base_dir&#x27; =&gt; __DIR__ . &#x27;/../more_languages&#x27;,
 &#x27;type&#x27; =&gt; &#x27;phpArray&#x27;,
 &#x27;pattern&#x27; =&gt; &#x27;%s.lang.php&#x27;,
 ],
 ],
]);
</code></pre>
In the configuration we have to define the default locale. It can be only one or an array with many of them, so that the translator can load another language if it is not able to find the first one. The locale can be changed later, but it is a good idea to have a language by default.
Then we have to define a list of places to find translation files. Each specification must include the directory which stores the files, the format of the translations in that directory (we can mix gettext with arrays and ini files if we want) and finally the pattern used to find certain translation file. The first mask will be replaced with the locale that is being used at each moment. This way, if we try to translate a message to the locale en, in the first directory, it will look for a file with the name <code>en.mo</code>
I have not included it in the example, but we could also set a cache storage to be used with each translations directory under the &#x27;cache&#x27; key, but then we will need to install <code>zendframework/zend-cache</code> too.
<h3>Translating texts</h3>
Our translator is now ready to be used. In the example, the <code>public/index.php</code> file makes use of the translator to translate a couple strings.
The translator works this way, when you call the methods <code>translate</code> or <code>translatePlural</code> with a string, it tries to find the translation in current locale. If it does, it will return it, otherwise it will return the original string.
This way we can use the default language (usually english) for keys and avoid to generate translation files for that language.
I have configured my <code>po</code> files so that poedit looks for the usage of the <code>translate</code> method inside the public directory, and assume the first argument is the string to be translated.
At the top of the file you will see that I get a <code>lang</code> query param to use it as the current locale. If it is not defined or you define one that is invalid, the default locale <code>en</code> will be used.
Now you can test it. It has three valid locales, en, es and fr. Use them to see the texts in English, Spanish and French. You can try to use an invalid locale too and you will see the texts in english.
The last string is not included in any translation file, so you will see it always in english.
<h3>Conclusion</h3>
This is it. The translator is a simple component to use on any PHP project. It has more power in Zend Framework based applications, since it can be created by using the ServiceManager, and includes view helpers and integration with forms, but even so it can be used in isolation.
I would like to discuss about advanced concpets of the translator, like text domains, plural forms and even some kind of front-end integration to use the same translation files under javascript environments, but that will be done in another article.

Any medium and large project has to deal at some point with the problem of translating the application itself to other languages. There are many tools and standards to do this, but one of my favourite components is Zend\I18n. Everybody who knows me is aware that I love Zend Framework, but…

Translations and internationalization in PHP projects with Zend\I18n

Setting up a development environment is not always easy, specially for web development. Sometimes you need to install and configure plenty of applications. A database server, a web server, server-side programming language binaries, mail server, job queue server, specific package managers, building tools, debug and profiling tools, etc.
Each one of them will need to be in a concrete version, and you will need to handle their dependencies too. You could think that&#x27;s a one time task, but what happens when you work on multiple projects at the same time. You need to install that for each one of them, and also make sure there are no conflicts with different environments.
There is a tool that eases this task, called <a target="_blank" rel="noopener noreferrer" href="https://www.vagrantup.com/">Vagrant</a>, that allows us to create a virtualized environments with all the tools, system packages and applications we need to use in a project. Each environment is running on its own virtual machine, so there is no conflicts between them.
The configuration of each virtual machine is defined in a file, that can be pushed to the VCS server, so that any other team member can use the same exact environment as you. By using that file, Vagrant creates a machine, downloads the OS and installs it, installs the packages and starts services, so that we can start working in no time.
This is a much more efficient way to work, since that configuration file (called Vagrantfile) can be reused multiple times.
<h3>Installing vagrant</h3>
Vagrant is a command line tool which eases the interaction with the virtual machines. Start a machine, halt a machine open a SSH connection or refresh the configuration by reading the Vagrantfile are easy tasks which only need a certain command to be executed.
There are packages for every major operating system that can be downloaded from <a target="_blank" rel="noopener noreferrer" href="https://www.vagrantup.com/downloads.html">here</a>.
You will also need to install <a target="_blank" rel="noopener noreferrer" href="https://www.virtualbox.org/wiki/Downloads">VirtualBox</a> to handle virtual machines. Others are supported too.
<h3>Creating the Vagrantfile</h3>
The Vagrantfile is the main configuration file for the virtual machine. It defines the operating system to be used, the system packages to be installed and how to do it, ports to be mapped to the host machine, folders to be shared, etc.
It is usually placed in the root directory of your project, since the folder containing it will be mapped to the folder <code>/vagrant</code> inside the virtual machine. This way the complete project will be available inside the virtual machine, for example to be served by a web server.
A simple example of a Vagrantfile could be this.
<pre class="language-ruby"><code class="language-ruby">Vagrant.configure(&quot;2&quot;) do |config|
 
 # This is the operating system to be installed. Ubuntu 12.04 in this case
 config.vm.box = &quot;hashicorp/precise32&quot;
 
 # The script &quot;bootstrap.sh&quot; will we run within the virtual machine once installed
 config.vm.provision :shell, path: &quot;bootstrap.sh&quot;
 
 # The port 8888 will be forwarded from the local machine to the virtual machine&#x27;s port 80
 config.vm.network :forwarded_port, host: 8888, guest: 80
 
end
</code></pre>
This is very easy to undertand. We are telling vagrant to install Ubuntu 12.04, start the machine and run the bootstrap.sh script, which could be used to define which system packages to install.
Then, we forward the port 8888 in the local machine to the port 80 in the virtual machine, so that we can see the application by accessing to <code>http://localhost:8888</code>.
You have an example project using this Vagrantfile <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya-blog/vagrant">here</a>. Clone it, go to the folder and run <code>vagrant up</code>. Once it finishes go to <a target="_blank" rel="noopener noreferrer" href="http://localhost:8888">http://localhost:8888</a> and you should see a nice Hello World! which is being served from the virtual machine.
However, this example is too simple. In real projects we usually have more complex requirements, and configuring the complete Vagrantfile is not so easy.
For this situations, we have multiple online assistants which can be used to create more complex Vagrantfiles. One of the best for PHP projects is <a target="_blank" rel="noopener noreferrer" href="https://puphpet.com">PuPHPet</a>, which is based on Puppet.
<h3>Setting up the machine</h3>
The first step is to go to <a target="_blank" rel="noopener noreferrer" href="https://puphpet.com">PuPHPet</a>&#x27;s webpage and follow the steps of the wizard. Select the operating system to be installed, the web server, the PHP version and such, the result depends on your needs. Once you finish this you will be able to download a complete configuration file.
Extract downloaded file wherever you want, open a console and go to the extracted folder. Now run <code>vagrant up</code> and the machine will be created and configured. This process may take some time, so be patient.
After a while, the virtual machine will be up an running. You can take a look at the extracted Vagrantfile and see that it is a little more complex than the first example.
If you include the Vagrantfile and the puphpet folder in your project&#x27;s VCS you will be able to reproduce the same environment anywhere you go just by clonning the repository.
<h3>Guest and host machine integrations</h3>
SSH access: One of the more common things we&#x27;ll need to do is to open a SSH connection against the virtual machine. To accomplish that task we just need to go to the folder where the Vagrantfile lives, or one of its subfolders and run <code>vagrant ssh</code>. Now you are able to do anything on the virtual machine as if it were your host machine.
Folders sync: Another thing we&#x27;ll probably need to do is to sync folders between the host machine and the guest machine. As I said earlier, the Vagrantfile parent folder is mapped by default to the <code>/vagrant</code> folder in the virtual machine, but we could change the folders in case of need.
To define a folder that should be synced, just place a line like this in your Vagrantfile.
<pre class="language-ruby"><code class="language-ruby">config.vm.synced_folder &quot;subfolder/&quot;, &quot;/anywhere/else/in/the/virtual/machine&quot;
</code></pre>
Port forwarding: This was seen in the first example. We could map a port in the host machine to another port in the virtual machine so that requests to the first one are forwarded to the other. We could also access the virtual machine IP or hostname directly, that depends on our needs.
<h3>Managing virtual machines</h3>
After some time working with vagrant you&#x27;ll probably have more than one virtual machine created and vagrant also provides some commands to handle them. By the way, the virtual machines in vagrant are called boxes.
We have seen that the <code>vagrant up</code> command creates a virtual machine, but it also turns on a previously halted box. To safely halt a virtual machine, just run <code>vagrant halt</code> and all the resources will be freed. We have also the <code>vagrant suspend</code> which, as you can guess, is used to suspend a box and <code>vagrant resume</code>, which resumes a suspended box.
Sometimes we will need to update a virtual machine. Updating the Vagrantfile and running the <code>vagrant up</code> command is not enugh for already created boxes, you will need to run <code>vagrant reload</code> so that the Vagrantfile is processed again. If you also need to refresh the provisions (the bootstrap.sh script in our first example) either run <code>vagrant provision</code> or <code>vagrant reload --provision</code> which will both reload the configuration and provision the machine.
Finally, when you need to delete a virtual machine, just run <code>vagrant destroy</code>.
You can also manage all the boxes you have installed, without having to be in the directory of a specific machine, by using the commands under <code>vagrant box</code>. Try <code>vagrant box help</code> to see what&#x27;s available.
<h3>Conclusion</h3>
This is pretty much it. This will let you encapsulate a PHP project inside a virtual machine, allowing you to use different applications and services on each one of them and &quot;tracking&quot; the state of the machine itself so that any collaborator can work in the same environment as you.
Of course there are other advanced usages for Vagrant, like deployment of machines to virtualization systems like Amazon Web Services, but that&#x27;s another articles subject.
For a complete vagrant documentation, follow this <a target="_blank" rel="noopener noreferrer" href="https://docs.vagrantup.com/v2/getting-started/index.html">link</a>.

Setting up a development environment is not always easy, specially for web development. Sometimes you need to install and configure plenty of applications. A database server, a web server, server-side programming language binaries, mail server, job queue server, specific package managers, building…

Setting up a PHP development environment with Vagrant

After a time working with Zend Framework 2 one is used to use the ServiceManager, which is one of the most powerful components in the framework. It eases the creation of objects and performing dependency injection, allowing us to define how objects are created just in one place and letting the Serv…

Alejandro Celaya | Blog

Software development, agile methodologies and open source software.

category Archive — "php"

— 2015 —

— 2014 —