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><pre><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></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><pre><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></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.

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 mutation testing, having a properly generated code coverage report will dramatically speed up te execution and help you know if a non-killed mutant is relevant.<h3>Generating the code coverage</h3>Capturing code coverage is usually easy in the most common types of tests, like unit tests, where the source code is executed in the same process.Tools like <a target="_blank" rel="noopener noreferrer" href="https://phpunit.de/">PHPUnit</a>, one of the most extended PHP testing frameworks, ships with tools like <a target="_blank" rel="noopener noreferrer" href="https://github.com/sebastianbergmann/php-code-coverage">php-code-coverage</a>, designed to capture the code under execution, just by providing a couple of lines of configuration.However, generating a reliable code coverage report is not always that easy for other types of tests.In contexts like E2E tests, where you may spin-up an API on a different process, and make your tests just call this API via HTTP and assert on the responses, PHPUnit will not be able to capture the code coverage, because the source code is actually being loaded on a different process.<h3>Remote code coverage</h3>A couple of weeks ago, I faced the issue described above. I had a web service for which I had a decent API test suite, but I wanted to capture code coverage for two main reasons:<ul><li>Be able to merge this coverage with the one generated by other tests suites, to know what&#x27;s the &quot;total&quot; code coverage, regardless the test producing it.</li><li>Apply mutation testing to the API tests, as I was already doing that for the rest of the test suites in the project. For this, I also needed to know exactly what tests were covering every line of the source code.</li></ul>After some investigation, I couldn&#x27;t find a built-in feature, where PHPUnit itself was able to &quot;remotely&quot; capture te code under test, so I had to think on a way to manually use <code>php-code-coverage</code> by myself.<h3>Code coverage reports</h3>In order to be able to capture code coverage, I had to make sure the instances of the objects provided by <code>php-code-coverage</code> where &quot;spin-up&quot; with the server, and then, the code coverage report was dumped at the end.Also, you usually define the code to include/exclude from coverage in PHPUnit&#x27;s config, but since this time we are the ones creating the coverage objects, this was not possible.I tried a couple of different approaches (more on this at the end), but the most accurate one for me, was to define two routes in my server, that were dynamically configured only when running the server in the context of these tests, and were responsible for creating and dumping the code coverage.<pre><pre><code class="language-php">use PHPUnit\Runner\Version;
use SebastianBergmann\CodeCoverage\CodeCoverage;
use SebastianBergmann\CodeCoverage\Driver\Selector;
use SebastianBergmann\CodeCoverage\Filter;
use SebastianBergmann\CodeCoverage\Report\Html\Facade as Html;
use SebastianBergmann\CodeCoverage\Report\PHP;
use SebastianBergmann\CodeCoverage\Report\Xml\Facade as Xml;

// Define directories containing the code you want to cover
$filter = new Filter();
$filter-&gt;includeDirectory(...);
$filter-&gt;includeDirectory(...);
$coverage = new CodeCoverage((new Selector())-&gt;forLineCoverage($filter), $filter);

// This is &quot;pseudo-code&quot;. Defining the routes depends on the framework you use
$app-&gt;get(&#x27;/api-tests/start-coverage&#x27;, function () use (&amp;$coverage) {
 $coverage-&gt;start(&#x27;API tests&#x27;);
 return new EmptyResponse();
});
$app-&gt;get(&#x27;/api-tests/stop-coverage&#x27;, function () use (&amp;$coverage) {
 $basePath = &#x27;...&#x27;; // Wherever you want the reports to be dumped
 $coverage-&gt;stop();

 // I generated coverage reports in a couple of different formats
 (new PHP())-&gt;process($coverage, $basePath . &#x27;/coverage.cov&#x27;);
 (new Xml(Version::getVersionString()))-&gt;process($coverage, $basePath . &#x27;/coverage-xml&#x27;);
 (new Html())-&gt;process($coverage, $basePath . &#x27;/coverage-html&#x27;);

 return new EmptyResponse();
});
</code></pre></pre>Then, I added the next snippet to my PHPUnit <code>bootstrap.php</code> file, to make sure the endpoints configured above are invoked at the proper times:<pre><pre><code class="language-php">// when starting up the test suite, call the endpoint to start collecting coverage
$httpClient-&gt;request(&#x27;GET&#x27;, &#x27;http://localhost:8080/api-tests/start-coverage&#x27;);

// When the tests process shuts down, call the endpoint to stop the coverage
register_shutdown_function(function () use ($httpClient): void {
 $httpClient-&gt;request(&#x27;GET&#x27;, &#x27;http://localhost:8080/api-tests/stop-coverage&#x27;);
});
</code></pre></pre><blockquote>Learn more about how to configure PHPUnit&#x27;s <a target="_blank" rel="noopener noreferrer" href="https://phpunit.readthedocs.io/en/9.5/configuration.html#the-bootstrap-attribute">bootstrap script</a>.</blockquote>This was fine from a pure code coverage point of view, but if you try it yourself, you will notice the report says all the code has been covered by <code>API tests</code>, which is what we provide when calling <code>$coverage-&gt;start(&#x27;API tests&#x27;);</code><img src="/assets/img/remote-coverage/invalid-api-coverage.png" alt="Invalid API coverage"/>To properly do mutation testing we need to know which are the exact tests that cover every part of the code. That requirement took me to the next approach.<h3>Supporting mutation testing</h3>To be more precise with the generated reports, I needed some way to notify the server about the specific test performing the request.One way to do this is by sending a custom header when performing a request from your tests, and registering some event handler or middleware which starts the coverage for that request with the value coming from that header.With that, I evolved the configuration above, and added a middleware handler (the framework I use is <a target="_blank" rel="noopener noreferrer" href="https://www.php-fig.org/psr/psr-15/">PSR-15</a> based, but the framework of your choice will probably have a way to do this).<pre><pre><code class="language-php">use ...

$coverage = new CodeCoverage();

// This ensures the coverage is started and stopped on every request, using the &quot;x-coverage-id&quot; header as the ID.
$app-&gt;middleware(function (ServerRequestInterface $req, RequestHandlerInterface $handler) use (&amp;$coverage) {
$coverage?-&gt;start(&#x27;API Tests&#x27;);
 $coverage-&gt;start($req-&gt;getHeaderLine(&#x27;x-coverage-id&#x27;));

 try {
 return $handler-&gt;handle($req);
 } finally {
 $coverage-&gt;stop();
 }
});

// This route is no longer needed. You can also remove the request from your bootstrap script
// $app-&gt;get(&#x27;/api-tests/start-coverage&#x27;, ...);
$app-&gt;get(&#x27;/api-tests/stop-coverage&#x27;, ...);
</code></pre></pre>Then, inside your test you can do something like this:<pre><pre><code class="language-php">use PHPUnit\Framework\TestCase;

class MyApiTest extends TestCase
{
 private ClientInterface $httpClient;

 public function setUp(): void
 {
 $this-&gt;httpClient = ...;
 }

 public function testMyEndpoint(): void
 {
 $resp = $this-&gt;httpClient-&gt;request(&#x27;POST&#x27;, &#x27;...&#x27;, [
 &#x27;headers&#x27; =&gt; [
 &#x27;x-coverage-id&#x27; =&gt; static::class,
 ],
 ])

 // Asserts go here...
 }
}
</code></pre></pre>After this, the code coverage reports will properly show the actual tests covering them.<img src="/assets/img/remote-coverage/valid-api-coverage.png" alt="Valid API coverage"/><h3>Alternative approach</h3>The approach explained here is functional, but it&#x27;s a bit hacky. I had to do it like this because of limitations with how I serve the API with <a target="_blank" rel="noopener noreferrer" href="https://openswoole.com">openswoole</a>.However, instead of defining routes that need to be actively called to start/stop the code coverage (or just to dump the report, as in the second approach), you could try to register the shutdown function directly in the server side.If that works for you, it&#x27;s much more straightforward, and you won&#x27;t need to bother changing your tests bootstrap script.<h3>Conclusion</h3>Even though there&#x27;s room for improvement, this allows to generate code coverage reports for code that&#x27;s running on a different process.I plan to apply something similar for E2E tests for a command line app, so maybe I extend this article at some point.Also, I decided to write this article, because at the moment of having to implement this myself, I didn&#x27;t find too much useful information out there.I hope this helped you, and now you can collect code coverage reports on your API tests.

Capturing remote code coverage in API tests with PHPUnit

In the last couple of days I have been playing around with the idea of combining GitHub Actions and GitHub Pages to be able to dynamically build preview environments every time a pull request is opened against a repository hosting a client-side web app.The idea is that you can quickly preview the changes made by some contributor, without having to clone their branch and running everything locally, something specially useful for open source projects.In this article I will explain how to set everything up, and what are some considerations and problems you may face during the process.<h3>Enable github pages</h3>The first thing you need to do is enable your project to publish pages on some branch. I recommend creating a new branch for this, let&#x27;s say <code>preview-env</code>, and then enabling publishing on it.In order to do that go to your repository and then Settings -&gt; Pages, look for the Source section, and you should see something like this:<img src="/assets/img/preview-envs/github-pages-before-enabling.png" alt="GitHub pages before enabling"/>Click in the dropdown and select your new branch, <code>preview-env</code>. Then click Save.<img src="/assets/img/preview-envs/github-pages-after-enabling.png" alt="GitHub pages after enabling"/>After saving you will see a message at the top of this section telling you what&#x27;s the URL in which the pages are published. It always follows the same pattern. If your organization is <code>my-org</code> and your repository is <code>my-repo</code>, the url will be <code>https://my-org.github.io/my-repo/</code>.<h3>Configure the workflow</h3>Now we need to configure a workflow that will &quot;deploy&quot; the preview environment for the branch every time a new pull request is created or updated:Let&#x27;s imagine we have a React web app that is built with node.js. The configuration could look like this.<pre><pre><code class="language-yml"># .github/workflows/deploy-preview.yml
name: Deploy preview

on:
 pull_request: null

jobs:
 deploy:
 runs-on: ubuntu-20.04
 continue-on-error: true
 steps:
 - name: Checkout code
 uses: actions/checkout@v2
 - name: Use node.js 14.15
 uses: actions/setup-node@v1
 with:
 node-version: 14.15
 - name: Generate slug
 id: generate_slug
 run: echo &quot;##[set-output name=slug;]$(echo ${GITHUB_HEAD_REF#refs/heads/} | sed -r &#x27;s/[~\^]+//g&#x27; | sed -r &#x27;s/[^a-zA-Z0-9]+/-/g&#x27; | sed -r &#x27;s/^-+\|-+$//g&#x27; | tr A-Z a-z)&quot;
 - name: Build
 run: npm ci &amp;&amp; npm run build
 - name: Deploy
 uses: JamesIves/github-pages-deploy-action@4.1.1
 with:
 branch: preview-env
 folder: build
 target-folder: ${{ steps.generate_slug.outputs.slug }}
 - name: Publish env
 uses: marocchino/sticky-pull-request-comment@v2
 with:
 header: Preview environment
 message: |
 ## Preview environment
 https://my-org.github.io/my-repo/${{ steps.generate_slug.outputs.slug }}/
</code></pre></pre><blockquote>If you are not familiar with GitHub Actions yet, take a look at the <a target="_blank" rel="noopener noreferrer" href="https://docs.github.com/en/actions">official documentation</a>.</blockquote>This workflow will follow the next steps:<ul><li>Checkout the code from the repository.</li><li>Set-up node.js 14.15</li><li>Based on the branch name, generate a slug that we will use to have separated deployment folders for every pull request we receive. The slug is exposed to next steps as an output.</li><li>Build the project. This step will obviously depend on the needs of your project.</li><li>Using <a target="_blank" rel="noopener noreferrer" href="https://github.com/JamesIves/github-pages-deploy-action">JamesIves/github-pages-deploy-action</a>, deploy the contents we previously built in the GitHub page, under a sub-folder matching the slug we generated a few steps above, and under the branch <code>preview-env</code> (remember we enabled GitHub pages for this branch).</li><li>Finally, using <a target="_blank" rel="noopener noreferrer" href="https://github.com/marocchino/sticky-pull-request-comment">marocchino/sticky-pull-request-comment</a>, post a comment in the pull request with a link to the preview environment, so that you can just click on it and see the deployment.</li></ul>The steps may change depending on your needs and how you build your project. For example, I have an extra step to update a property in the <code>package.json</code> that is then used to allow serving the app in a sub-path instead of the root of the domain.You may also not build your site with node.js, as you could be using any of the multiple existing static site generators out there, but you get the idea.Finally, you have probably noticed the config includes <code>continue-on-error: true</code>. This will allow the pull request to be merged even if this process fails for some reason.<h3>Considerations when using forks</h3>While the configuration above will work perfectly when creating pull requests inside the same repository, there are some limitations when the pull request comes from a fork (which is the usual in OSS projects).For security reasons, the <code>GITHUB_TOKEN</code> injected in those cases doesn&#x27;t have write permissions, which will make the &quot;deploy&quot; step fail.Also, you cannot define your own token with more permissions and inject it as a secret, as the secrets are not exposed to workflows running on forks.However, with a couple small config changes, we can work around these limitations:<h4>Change event</h4>The first thing we need to do is use the <code>pull_request_target</code> event instead of the <code>pull_request</code> one.<pre><pre><code class="language-diff">on:
- pull_request: null
+ pull_request_target: null
</code></pre></pre>According to the documentation, this is equivalent to the <code>pull_request</code> event, but it runs in the scope of the base repository.Thanks to this, the <code>GITHUB_TOKEN</code> will come with write permissions, and we will have access to secrets if needed.<h4>Checkout the fork</h4>The second thing we are going to change is that we now need to specify the repository to checkout.In order to do that, we need to add two inputs to the &quot;Checkout code&quot; step, like this:<pre><pre><code class="language-diff"> steps:
 - name: Checkout code
 uses: actions/checkout@v2
+ with:
+ repository: ${{ github.event.pull_request.head.repo.full_name }}
+ ref: ${{ github.event.pull_request.head.ref }}
</code></pre></pre>This will ensure we checkout from the fork repository, instead of the base one, which is the default, as it&#x27;s the one where the <code>pull_request_target</code> event is scoped to.And that&#x27;s it. With these two changes you can now deploy preview environments for pull requests coming from forks.<blockquote>IMPORTANT! The limitations of the <code>pull_request</code> event are there for a reason. People could potentially get access to your secrets or manipulate your code. Proceed at your own risk.</blockquote><h3>Other considerations</h3>Other than the limitations for forks, there are a few other minor things to take into consideration.<ul><li>Changes in GitHub Pages do not reflect immediately. It may take up to a couple of minutes for the deployment to be available, but considering you will usually not review a PR right after it has been created, this should not be a big issue.</li><li>As you have seen, every time a pull request is created, the deployment will generate a new folder in your GitHub Pages branch. This may result in a lot of old folders to pile-up, so you may want to set up some way to clean them up periodically or after the pull request has been merged.</li><li>Due to the fact that GitHub Pages only allows static pages to be served, this process cannot be used with apps that require some kind of back-end or server-side logic.</li><li>If your project is already using GitHub Pages for something else (serve the project&#x27;s website or docs), that may conflict with this, preventing you from having this kind of preview envs.</li></ul>

Setting-up a preview environment for your client-side apps with GitHub Actions and GitHub Pages

I remember many years ago, when I released my first open source project, that every time I had a new release ready, I was never sure what should be the new version number.Versioning software is not as straightforward as it might look when you don&#x27;t have a lot of experience.In this article I&#x27;ll try to explain the <a target="_blank" rel="noopener noreferrer" href="https://semver.org/">SemVer</a> approach to version software, and some things you might want to take into account on top of that.<h3>Semantic Versioning</h3>The first thing you need is a solid set of rules that help you decide which should your next version be.I remember thinking &quot;is this version big enough as to jump from 1.0 to 2.0?&quot; or &quot;I have seen projects using three numbers for the version, X.Y.Z, should I do the same?&quot;Those questions are easier to answer if you stick to some standard that tells you what to do, and that will help others more easily understand your intention.My recommendation is to use <a target="_blank" rel="noopener noreferrer" href="https://semver.org/">Semantic Versioning</a>, as it defines a solid starting point, and it&#x27;s quite adopted by the community.Semantic Versioning states that you should use three numbers to identify versions, <code>MAJOR.MINOR.PATCH</code>, and follow these rules in order to decide which one to increase:<ul><li><code>PATCH</code>: the new release includes only bug fixes. People are encouraged to update to this release and no changes are needed in their code bases.</li><li><code>MINOR</code>: the new release includes new backwards-compatible features. People can update to this version without changing their code bases, and make use of the new features afterwards if they wish.</li><li><code>MAJOR</code>: the new release includes <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Backward_compatibility">backward compatibility</a> breaks. Changes in the code base will be needed when updating to this version.</li></ul><blockquote>These rules are easier to apply to libraries and frameworks than it is for apps and services. More about this later.</blockquote><h3>Try to keep backwards-compatibility</h3>Ok, we have some rules now. However, I have seen very frequently people mistaking what can be done with what should be done.Yes, if you introduce a breaking change, you can update the major version and that&#x27;s it. However, if you do it too frequently, people won&#x27;t be happy, and you will end up with a fragmented user base, that stop updating to newer versions.I remember using a library to deploy stuff that had a new major version every couple of months, changing things like &quot;The <code>host</code> function is now called <code>server</code>&quot;. Yes, ok, but why do I have to change my stuff so frequently.It&#x27;s usually better to try to implement things in a backwards-compatible way, and keep track of the things you want to change and do it all at a time.You can also deprecate things, and document the way you want those things to be done moving forward. That way you give people the chance to start changing their code and simplify a hypothetical upcoming major release.<h3>Provide clear upgrade paths</h3>As mentioned above, too frequent major version changes are not desirable, but sooner or later you will want to release a new major version for different reasons.<ul><li>Getting rid of that feature which is hard to maintain, introduces lots of bugs, and provides little value.</li><li>Supporting something new which is very hard to implement without breaking backwards compatibility.</li><li>Removing all those deprecated methods you have been dragging for months.</li><li>Fix design issues, where something was architected in the wrong way, and only spotted after some time.</li></ul>At the time this happens you will want your users to upgrade to the newer version, as you don&#x27;t want people to report bugs that only affect older versions, or to expect you to backport fixes to older versions because they haven&#x27;t updated to the new one.The best way to achieve this is to provide clear and simple upgrade paths:<ul><li>Prepare your releases for the things to come: If you want to introduce new ways of doing things, do it before the major release, and deprecate the older ones. For example, you can have a new method that gets called by an older one, while you mark the old one as deprecated.People will be more willing to update and change their code afterwards. By the time the major release is published, their code will be ready to upgrade.</li><li>Include a CHANGELOG file in your project, explaining the changes introduced in every version. A very good way to document a change log is the <a target="_blank" rel="noopener noreferrer" href="https://keepachangelog.com/">Keep a changelog</a> initiative.You can also use some other platform to document the change log, like GitHub releases.</li><li>Include documentation on how to upgrade to a major release: This is probably the most important one. Document all the steps that need to be followed and all the required changes to update from a release to the next major one.A good way to do this is by including an UPGRADE file in your project. You can see <a target="_blank" rel="noopener noreferrer" href="https://github.com/acmailer/acmailer/blob/main/UPGRADE.md">this example</a>.</li></ul><h3>Versioning libraries vs apps</h3>Semantic Versioning is a good standard to version software, but it plays much better with libraries and frameworks that are installed using some kind of package manager, than it does with apps and services that are not directly depended on.For example, how do you identify a backward compatibility break on a web user interface?With this kind of software there are more grey areas, and you will end up using your intuition.For example, not long ago I released a <a href="/2020/12/24/released-shlink-web-client-v3-0-0/">new major version</a> for a web app I maintain, and it was completely compatible with the previous one. However, it introduced a larger amount of features than usual, and big UI changes, so I decided it was worth the bump.Because of this there are projects that use different approaches to version apps. For example:<ul><li>Firefox and Chrome have 6-week cycles, and after each one of them they release a new major version no matter what.</li><li>Jetbrains publishes a few releases of their IDEs every year (I think 3) which always start with the year they were released on, like <code>2020.3.0</code>, and they increase the patch number for bugfixes.</li><li>Ubuntu releases 2 versions every year, one in April and one in October, and they are always identified by the year and month they were released on, like <code>19.04</code> or <code>20.10</code>.</li></ul><h3>Special versions</h3>There&#x27;s also a set of special versions that can be used to publish the so-called pre-release versions. These <a target="_blank" rel="noopener noreferrer" href="https://semver.org/#spec-item-9">are covered</a> by Semantic Versioning, but sometimes they are not so easy to understand.It is also very likely that you never have to use these, as only relatively big projects will need this level of granularity, but it&#x27;s still good to know what&#x27;s their purpose and what do they imply.<h4>0.x.y</h4>It is possible to release a version of your software where the major number is <code>0</code>. When this happens, it means your software is still in its early stages.It does not mean it&#x27;s necessarily unstable, but it means you are still introducing frequent changes on it, and therefore, it might be a bit more fragile than a version starting with a number greater than <code>0</code>.<h4>Alpha</h4>The intention of an alpha release is that a subset of people con test some new functionality, but you don&#x27;t want people to use it in productionAlpha versions are on their very early stages. Their public API is very likely to change, and they probably contain bugs.Semantic Versioning states that alpha versions are identified by this pattern: <code>MAJOR.MINOR.PATCH-alpha.NUMBER</code>, for example <code>2.0.0-alpha.1</code>.<h4>Beta</h4>Similar to alpha versions, beta versions are also prone to contain bugs, but their API will in theory not change. That means that you could potentially adapt your software to start using a beta version, and when the corresponding stable release is published, you shouldn&#x27;t need that many changes.Semantic Versioning defines a pattern similar to the one for alpha versions: <code>MAJOR.MINOR.PATCH-beta.NUMBER</code>, for example <code>2.0.0-beta.1</code>.<h4>Release candidate</h4>Release candidates (RC) are pre-release versions that you will want to publish for the general user-base to test an upcoming release. You want to publish a RC so that it&#x27;s battle tested by as many people as possible, in order to find possible bugs and edge cases.They should not contain many bugs, but some could be found. The public API should not change anymore.According to Semantic Versioning, the pattern to identify a RC is <code>MAJOR.MINOR.PATCH-rc.NUMBER</code>, for example <code>2.0.0-rc.1</code>.<h3>Conclusion</h3>We have seen some approaches and considerations to properly version your software.Versioning is not so straightforward when you don&#x27;t have a lot of experience, but as you have seen, you just need to know a small set of rules and use a bit your intuition.With those tools, you will be able to properly version your software.

What to take into account when versioning software

Two days ago I released the first major version in almost 2 years for <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-web-client">shlink-web-client</a>, a web UI for <a target="_blank" rel="noopener noreferrer" href="https://shlink.io">shlink</a>, my self-hosted URL shortener.This new version introduces several improvements to the project, and I thought it was worth writing a post to explain all of them in depth.<h3>New design</h3>The project has been using the same design almost since the beginning. It was clean, but it laked a bit of contrast and consistency in many sections.Now the main background is light-gray, with components composed in white cards with a slight box shadow, that makes them easier to spot inside the app.Also, the main area has now a max-width that prevents components from stretching too much on wide screens.<div class="row"><div class="col-md-6 "><img alt="Before" src="/assets/img/shlink-web-client-3/design-before.png" class="gallery-item"/>Before</div><div class="col-md-6 "><img alt="After" src="/assets/img/shlink-web-client-3/design-after.png" class="gallery-item"/>After</div></div><h3>Overview page</h3>Up until now, after connecting to a Shlink server, you went directly to the list of short URLs.With this new version, you now see an overview page first, which displays some general stats, a quick short URL creation form, and the latest 5 short URLs.From there, you can navigate to the full list of short URLs, with filtering capabilities, or go to the advanced short URL creation form.<div class="row"><div class="col-md-8 col-md-offset-2 "><img alt="Overview" src="/assets/img/shlink-web-client-3/overview.png" class="gallery-item"/>Overview</div></div><h3>Improved short URL creation form</h3>One of the sections with more room for improvement was the short URL creation form. It had all the inputs mixed, displaying just the &quot;long url&quot; one, with the option to un-collapsing the rest at will.The new design groups the inputs by context, which makes it more clear. It also displays the inputs all the time, since the &quot;quick form&quot; is now located in the overview page.<div class="row"><div class="col-md-6 "><img alt="Before" src="/assets/img/shlink-web-client-3/creation-form-before.png" class="gallery-item"/>Before</div><div class="col-md-6 "><img alt="After" src="/assets/img/shlink-web-client-3/creation-form-after.png" class="gallery-item"/>After</div></div><h3>Enhanced visits page</h3>The visits page had a problem, it was trying to display too much information in a single place.<ul><li>Visits over time</li><li>Visits from every platform</li><li>Visits from every location</li><li>A list of visits as a table</li></ul>The new approach splits those in subsections with their own sub-route each (<code>/by-location</code>, <code>/by-context</code>, etc). This helps to render a smaller amount of charts at once, since they are a bit CPU greedy.Also, only the visits from the last 30 days are loaded by default, making it load way faster for URLs with a lot of visits.<div class="row"><div class="col-md-6 "><img alt="Before" src="/assets/img/shlink-web-client-3/visits-before.png" class="gallery-item"/>Before</div><div class="col-md-6 "><img alt="After" src="/assets/img/shlink-web-client-3/visits-after.png" class="gallery-item"/>After</div></div><h3>Outer sections</h3>The app has some sections which are not related to a specific server, like creating/editing servers, or the settings page.These sections have also been adapted to the new style, and they also have a max-width for wide screens.<div class="row"><div class="col-md-6 "><img alt="Before" src="/assets/img/shlink-web-client-3/create-server-before.png" class="gallery-item"/>Before</div><div class="col-md-6 "><img alt="After" src="/assets/img/shlink-web-client-3/create-server-after.png" class="gallery-item"/>After</div></div><h3>Date range selector</h3>A new component allows selecting date ranges either by relative time ranges (last 30 days, last 90 days...) or by selecting absolute start and end dates.This component is used to filter both short URL lists and visits lists.<div class="row"><div class="col-md-6 col-md-offset-3"><img alt="Date range selector" src="/assets/img/shlink-web-client-3/date-range-selector.png" class=""/>Date range selector</div></div><h3>Domain selector</h3>Shlink has had multi-domain support for some versions, but changing the domain from the web client required to set the value manually, which is a bit error-prone.This version introduces a new component which allows selecting from domains already used in the past (which is what you will want in most of the cases), preventing accidental typos.It also allows setting new values in case you want to use a new domain that you never used before. This domain will then appear in the list the next time.<div class="row"><div class="col-md-6 "><img alt="Existing domains" src="/assets/img/shlink-web-client-3/domains-existing.png" class=""/>Existing domains</div><div class="col-md-6 "><img alt="New domain" src="/assets/img/shlink-web-client-3/domains-new.png" class=""/>New domain</div></div><h3>Other improvements</h3>The changes described so far were the major ones. However, v3.0.0 includes a few other minor improvements.<ul><li>Result and loading messages have been standardized: They are now more consistent and use the same set of components, which also ensures consistency in the future.</li><li>Error messages are now more descriptive: Instead of showing generic error messages when API calls fail, the actual error message is now always displayed, so that it&#x27;s easier to know what failed.</li><li>Dropped support for Shlink v1: All major versions come with some breaking changes that improve code maintainability. This one drops Shlink v1 support, which allows removing some conditional paths here and there.</li></ul>Other than the last point, Shlink v3.0.0 is mostly backwards compatible, so it&#x27;s safe to upgrade if you are already using Shlink v2.x<h3>Next steps</h3>Of course this doesn&#x27;t end here, and I have a lot of ideas to improve it even further.<ul><li>Dark theme: It&#x27;s what the cool kids do these days, and I have already done some experiments around it.</li><li>Shlink dashboard: Next gen web app for Shlink. You can read the whole reasoning in <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-web-client/issues/338">this issue</a>.</li><li>Filtering in lists added to URL: Many sections allow filtering lists, but the state is saved in memory, which means it gets lost if the page is refreshed, and it cannot be bookmarked. The intention is to make all filtering params to become part of the URL.</li><li>Exporting visits in CSV: It&#x27;s cool to see charts full of info, but sometimes admins need to feed other services with the data, and consuming the original API is not always an option. Exporting visits to a CSV file will be supported soon by shlink-web-client.</li></ul>

Released shlink-web-client v3.0.0

Docker is, without any doubt, the trending tool these days. Everybody wants to use it, because it is very useful, allowing to easily generate development environments for any kind of application.A couple months ago I started working with docker myself (it has taken me a while, I know), and now I can&#x27;t imagine working without it.I started using it at work, but now I&#x27;m migrating all of my OSS projects too.<h3>The first stopper</h3>Regardless docker is very cool, there is a problem when you start using it.I had my development environment perfectly configured, and all my tools properly integrated. I was able, among other things, to run any project tests from within PhpStorm, just by right-clicking any test class, test method or phpunit.xml file, and selecting the &quot;Run&quot; option.However, once you start using docker in the project, it is not that simple.<h3>Integration with PhpStorm</h3>Gladly, since PhpStorm is a very powerful tool, it supports integration with docker, which can be then used, among other things, to automatically run tests inside a container.<blockquote>From this point, I&#x27;m going to explain the process, assuming you have already installed docker in your system. If not, you need to install at least <a target="_blank" rel="noopener noreferrer" href="https://docs.docker.com/engine/installation/">docker engine</a> and <a target="_blank" rel="noopener noreferrer" href="https://docs.docker.com/compose/install/">docker compose</a>.</blockquote>The first thing you need to do is configure the connection with docker engine. Go to Settings -&gt; Build, Execution, Deployment -&gt; Docker.Click the green plus button and a new docker connection will be created. The only value you should need to change is the API URL:<ul><li>Linux: unix:///var/run/docker.sock</li><li>Windows and Mac: <a target="_blank" rel="noopener noreferrer" href="http://127.0.0.1:2376">http://127.0.0.1:2376</a> (The URL of the docker machine. If you are using the deprecated docker toolbox with boot2docker, you have to make sure which is the IP address of the virtual machine)</li></ul><img src="/assets/img/phpstorm-docker/phpstorm-docker.png" alt="Docker in PhpStorm"/>Apply changes and we are done here.<h3>Create the remote interpreter</h3>Now let&#x27;s create a remote interpreter. It will be used so that tools that need a php runtime are executed inside a docker container.Go to Settings -&gt; Languages &amp; Frameworks -&gt; PHP. In here, you select the default interpreter for your project.<img src="/assets/img/phpstorm-docker/interpreter.png" alt="Interpreter"/>Click the button with the three dots, which will open the dialog to create a new interpreter.<img src="/assets/img/phpstorm-docker/interpreter-dialog.png" alt="Interpreter dialog"/>In that dialog you will likely have a local interpreter. Click the green plus button, at the top-left corner, and select Remote.That will open the dialog to create a new remote interpreter. One of the options is to use a docker image from which PhpStorm will create a docker container that should contain a php interpreter.<img src="/assets/img/phpstorm-docker/docker-interpreter.png" alt="Docker iterpreter"/>In this dialog, just select the server (this is the connection with the docker engine, the one we created in the first step), then select the docker image you want to use. The dropdown will be filled with all the images in your machine.Finally select the interpreter path. Usually, <a target="_blank" rel="noopener noreferrer" href="https://hub.docker.com/_/php/">PHP-based docker images</a> have the php interpreter in the PATH, so just setting <code>php</code> should be enough.Save everything and we are done configuring the interpreter.<h3>Create the PHPUnit config</h3>Now that the interpreter is created, we have to define a phpunit configuration that uses it.Go to Settings -&gt; Languages &amp; Frameworks -&gt; PHP -&gt; PHPUnit, Use the green plus button at the top-left corner, select By Remote interpreter and a dialog window will be prompt.It only contains a dropdown where you have to select the remote interpreter we created in previous step.Select it and you&#x27;ll see a configuration similar to this.<img src="/assets/img/phpstorm-docker/phpunit.png" alt="PHPUnit configuration"/>As you can see, PhpStorm mounts the project dir as a volume inside the container, in the <code>/opt/project</code> dir, and based on that path, selects the path to composer&#x27;s autoloader script and the phpunit.xml script.If any of those params is not correct in your project, you can (and should) change it.And that&#x27;s it!Now, you can right-click any test class, test method or phpunit.xml file and select &quot;Run&quot;. PhpStorm will automatically connect with docker engine, set up a temporary container and run the tests inside of it.You&#x27;ll know it is working because of this:<img src="/assets/img/phpstorm-docker/tests-in-container.png" alt="Tests inside container"/><h3>Conclusion</h3>PhpStorm&#x27;s team is always working to add integrations with the latest development tools, making it the most powerful IDE for PHP.Now go, configure your environment and start using docker. It&#x27;s amazing!

Run PHPUnit tests inside a docker container from PhpStorm

<a target="_blank" rel="noopener noreferrer" href="https://letsencrypt.org/">Let&#x27;s Encrypt</a> is the latest internet trending. Its a relatively young Certification Authority which intends to provide free and automated SSL certificates so that everybody can set encryption to their sites and applications.It is a <a target="_blank" rel="noopener noreferrer" href="https://www.linuxfoundation.org/">Linux Foundation</a> project sponsored by most of the biggest Internet companies, such as Google, Facebook, Mozilla or Cisco.They provide tools to automatically generate, setup and renew SSL certificates, but those tools are still in early stages, and not all the integrations are easy.In this article I&#x27;m going to explain how to setup one of this certificates in an Amazon Web Services Elastic Load Balancer (ELB from now on).<h3>Generate the certificate</h3>There are very good tutorials out there on how to generate a certificate, so I&#x27;m not going to dedicate much to this.I usually follow the instructions from <a target="_blank" rel="noopener noreferrer" href="https://certbot.eff.org/">certbot</a>.In there, you have to choose the web server of your choice, in this case &quot;None of the above&quot;, and your operating system, for example Ubuntu 16.04 (the only difference with older Ubuntu versions is that you can install the CLI tool from the standard repositories, otherwise there is a previous step where you have to download the <code>certbot-auto</code> script and run it, but that&#x27;s it).Once you have installed the <code>letsencrypt</code> tool (or <code>certbot-auto</code>), you have to generate the certificate with the webroot plugin. This plugin just generates the certificate by providing the document root for each domain that will be included in the certificate.<pre><pre><code>letsencrypt certonly --webroot -w /var/www/mydomain -d mydomain.com -d www.mydomain.com -w /var/www/cool-site -d cool-site.com -d www.cool-site.com
</code></pre></pre>This will create a certificate valid for mydomain.com, <a target="_blank" rel="noopener noreferrer" href="http://www.mydomain.com">www.mydomain.com</a>, cool-site.com and <a target="_blank" rel="noopener noreferrer" href="http://www.cool-site.com">www.cool-site.com</a>.All of the domains get verified from let&#x27;s encrypt side by putting a temporary hidden file inside provided web root folders.In this case, the first two domains will be checked in the /var/www/mydomain folder, and the last two in /var/www/cool-site. If those domains are really served from there, the certificate will get properly created.The problem with this in an Elastic Load Balancer is that you are running this tool in one server, but you will have more than one balanced server. This could make the previous process fail if the wrong server responds to the let&#x27;s encrypt check request.To prevent this you will have to leave just one server temporarily. Don&#x27;t worry, it only takes a few seconds. Once the certificate is created you can add the rest of the servers again.<blockquote>There are other plugins which simplify deploying certificates in standalone web servers.</blockquote><blockquote>For example, the apache plugin automatically sets the configuration in the apache virtual host of your choice.</blockquote>If everything worked, you should now have 4 files in the <code>/etc/letsencrypt/live/mydomain.com</code> folder.<pre><pre><code>/etc/letsencrypt/live/mydomain.com
 |-- cert.pem
 |-- chain.pem
 |-- fullchain.pem
 |-- privkey.pem
</code></pre></pre><h3>Setup the certificate in an ELB</h3>Now that you have your certificate files, you need to upload them to the ELB.Go to the AWS web console, select the EC2 service and go to Load Balancers. Once there select the load balancer of your choice and go to the Listeners tab.<img src="/assets/img/load-balancers-listeners.png" alt="Load Balancer listeners"/>Now you have to click on the &quot;Change&quot; link, in the SSL Certificate column of the HTTPS protocol, in order to set the new certificate.<img src="/assets/img/load-balancers-set-certificate.png" alt="Load Balancer set SSL Certificate"/>In this window, select the third option, Upload a new SSL certificate to AWS... and set the name of your choice for it.Then, in the Private key field you have to place the contents of the <code>cert.pem</code> file, and in the Public key certificate field, the contents of the <code>fullchain.pem</code> file. You can leave the Certificate chain field empty.Save, and you are done. Your ELB is now serving HTTPS request by using the previously generated Let&#x27;s Encrypt certificate.<h3>Renewal</h3>Renewing this certificate is easy. Just run the command <code>letsencrypt renew</code> (or <code>certbot-auto renew</code>) in the same server used to create the certificate in the first place.That will generate the new certificate in the same location, and you can repeat the previous step with it.The main problem with Let&#x27;s Encrypt certificates is that they are valid for three months only. Auto renewal is a feature that they want to implement at some point, but it&#x27;s not available yet.By the moment, the best solution for standalone servers is creating a cron job that automatically runs the <code>letsencrypt renew</code> command, but for an ELB that won&#x27;t fix the problem.You will probably need to create some kind of script that automatically uploads the certificate to the ELB after being renewed, by using the AWS REST API or the CLI interface.<a target="_blank" rel="noopener noreferrer" href="http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-update-ssl-cert.html#us-update-lb-SSLcert-cli">This documentation</a> should be helpful. Pay special attention to the To replace an SSL certificate with a certificate uploaded to IAM section.

Setup a Let's Encrypt certificate in a AWS Elastic Load Balancer

<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><pre><code class="language-bash">sudo chmod +x composer.phar
sudo mv composer.phar /usr/local/bin/composer
</code></pre></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><pre><code class="language-bash">composer install --no-dev --optimize-autoloader --prefer-dist --no-interaction
</code></pre></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><pre><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></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><pre><code class="language-javascript">{
 &quot;bin&quot;: [
 &quot;scripts/generate-foo&quot;,
 &quot;scripts/create-bar&quot;,
 &quot;scripts/do-something&quot;
 ]
}
</code></pre></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><pre><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></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><pre><code class="language-bash">composer create-project vendor-name/app-name
</code></pre></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 advanced concepts

Some time ago I wrote the most successful article of this blog, <a href="/2014/10/09/advanced-usage-of-service-manager-in-zend-framework-2/">Advanced usage of ServiceManager in Zend Framework 2</a>, explaining all the ways a service can be created by making use of <code>Zend\ServiceManager</code>, the service container component in Zend Framework 2.On this article I&#x27;m going to show a real example where objects and services are all managed and created with a <code>ServiceManager</code> instance, which makes decoupling components and dependency injection very easy.It is not a Zend Framework 2 application, because the <code>ServiceManager</code> is so integrated there that its power could go unnoticed. Instead, I&#x27;m using a <a target="_blank" rel="noopener noreferrer" href="http://www.slimframework.com/">Slim</a> framework based application, which solves some common problems that has nothing to do with this article (like routing and request dispatching) and allows us to concentrate on what&#x27;s important.The project is just a simple application to perform a <a target="_blank" rel="noopener noreferrer" href="https://es.wikipedia.org/wiki/CRUD">CRUD</a> over two fictitious entities, users and items. Very simple.<h3>Getting the application</h3>As usual, I have hosted the example application on github. Clone it from <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya-blog/service-manager-example">here</a>, install dependencies by running <code>composer install</code> and start the built-in web server by running <code>php -S 0.0.0.0:8000 -t public</code>.<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>If you are used to modern PHP applications, the project structure shouldn&#x27;t be a problem. There is a <code>src</code> folder with the source code, a <code>public</code> folder which is the document root of the application, a <code>config</code> folder with some configuration files and a <code>tests</code> folder with the unit tests.<h3>Dependency injection</h3>Let&#x27;s start with some thoughts about dependency injection.In the past, when I had to learn dependency injection, I found out that many tutorials just explain that it is important to decouple componentes from the application, and pass elements to objects instead of letting them to create those elements inside themselves.That&#x27;s a good theory, but introduces another problem. Without dependency injection, creating an object is as easy as <code>new FooBar()</code>, and all dependencies will be automatically created on the inside, but with dependency injection I could end with something like this.<pre><pre><code class="language-php">$logger = new Logger(&#x27;/var/log/mylogs.log&#x27;);
$serviceOne = new ServiceOne(&#x27;foo&#x27;, &#x27;bar&#x27;);

$config = include __DIR__ . &#x27;/config/config_file.php&#x27;);
$serviceTwo = new ServiceTwo($serviceOne, $config[&#x27;param&#x27;], $config[&#x27;another_param&#x27;]);

$fooBar = new FooBar($serviceTwo, $logger);
</code></pre></pre>Now I have to pass two dependencies to my <code>FooBar</code> object. One of them also dependes on another object and a raw configuration. And this process could even be more complex.When I try to explain dependency injection, people usually tries to mentally adapt their old code and substitute the <code>new FooBar()</code> with the previous code snippet, and their reaction is usually &quot;Dependency injection is hard! I will need to duplicate a lot of code!&quot;.What those tutorials don&#x27;t explain is how to solve this new problem, and that we now should define the way the objects are created just in one place, and have some mechanism to access to that objects anywhere else once created.That task is usually performed by an object, the &quot;inversion of control&quot; container, in plenty of forms, a service locator, service container, dependency injection container...The <code>ServiceManager</code> is going to act as the &quot;inversion of control&quot; container of this project. Let&#x27;s see how.<h3>Solving the problem</h3>Now that we have identified the problem, let&#x27;s take a look at the example, and how the <code>ServiceManager</code> is capable of managing the whole application, making the task of creating objects much easier and without code duplication.<h4>Bootstrapping</h4>The project&#x27;s front controller is the <code>public/index.php</code> file, which only includes the <code>src/bootstrap.php</code> file. The first thing we do is create the <code>ServiceManager</code> instance (there is no need for more than one in the whole project) by consuming the configuration in <code>config/services.php</code>.<pre><pre><code class="language-php">$sm = new ServiceManager(new Config(include __DIR__ . &#x27;/../config/services.php&#x27;));

// ...
</code></pre></pre>After that, we use the <code>ServiceManager</code> to get the app instance, the main object in Slim framework.<pre><pre><code class="language-php">// ...

/** @var Slim $app */
$app = $sm-&gt;get(&#x27;app&#x27;);

// ...
</code></pre></pre>Thanks to the <code>ServiceManager</code>, we have obtained the app object with just one instruction, <code>$sm-&gt;get(&#x27;app&#x27;)</code>, as easy as doing <code>new \Slim\Slim()</code>, but the <code>ServiceManager</code> has customized and cached our object, we just had to previously tell it how to do it.If we go to the <code>config/services.php</code> file, we&#x27;ll see that there is an &#x27;app&#x27; service defined as an alias of the <code>Slim::class</code> service, which in turn is an invokable, which means that it will be constructed by the <code>ServiceManager</code> just by instantiating the object with no arguments in the constructor.But we said that the object has been customized. Where did that happen?If we go to the delegators block, we&#x27;ll see that there is defined one delegator for the <code>Slim::class</code> service. Delegators are called by the <code>ServiceManager</code>, allowing us to customize certain service when it is going to be created.Our SlimDelegator sets some configuration options in the Slim instance after it is created and before it is returned by the <code>ServiceManager</code>.<blockquote>The name of a service can be anything as long as it is unique. Using the fully qualified class name is just a convention when there is only one way to create the object returned.</blockquote>The final step of the bootstrap process is to use the app object to register a couple routes.<pre><pre><code class="language-php">// ...

// Homepage
$app-&gt;get(&#x27;/&#x27;, function () use ($app) {
 $app-&gt;render(&#x27;home.phtml&#x27;);
})-&gt;name(&#x27;home&#x27;);

// Users pages
$app-&gt;addControllerRoute(&#x27;/users/list&#x27;, UserController::class . &#x27;:list&#x27;)
 -&gt;name(&#x27;users-list&#x27;)
 -&gt;via(&#x27;GET&#x27;);
// ...

// Items pages
$app-&gt;addControllerRoute(&#x27;/items/list&#x27;, ItemController::class . &#x27;:list&#x27;)
 -&gt;name(&#x27;items-list&#x27;)
 -&gt;via(&#x27;GET&#x27;);
// ...
</code></pre></pre>The first route is the home page, which is only used to select between users and items.The rest of the routes are endpoints to perform each operation of both users and items CRUDs. They are resolved to a controller&#x27;s action.<h4>Controllers</h4>Since Slim does not support controllers I&#x27;ve used the <a target="_blank" rel="noopener noreferrer" href="https://github.com/fortrabbit/slimcontroller">slimcontroller</a> package which allows us to dynamically load controllers from Slim&#x27;s container.I&#x27;ve also used this useful <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/slim-container-sm">package</a> I created some days ago, which replaces Slim&#x27;s container with another object which wraps a <code>ServiceManager</code> which is similar but much more powerful. In combination with slimcontroller makes controllers to be loaded from the <code>ServiceManager</code>.That is to say, the last two routes will fetch a <code>UserController::class</code> or <code>ItemController::class</code> service from the <code>ServiceManager</code> and use it as the controller for that route.Those two controllers are defined in <code>config/services.php</code> as factories. A factory is the easiest way to perform dependency injection in a service.For example, the UserControllerFactory looks like this.<pre><pre><code class="language-php">namespace Acelaya\Controller;

use Acelaya\Service\UserService;
use Slim\Slim;
use Zend\ServiceManager\FactoryInterface;
use Zend\ServiceManager\ServiceLocatorInterface;

class UserControllerFactory implements FactoryInterface
{
 public function createService(ServiceLocatorInterface $serviceLocator)
 {
 /** @var UserService $userService */
 $userService = $serviceLocator-&gt;get(UserService::class);
 return new UserController($userService);
 }
}
</code></pre></pre>It creates the UserController instance and returns it, but it also injects its only dependency on it.That dependency is also fetched from the <code>ServiceManager</code>, because that <code>$serviceLocator</code> is the <code>ServiceManager</code> which injects itself in factories when calling the <code>createService</code> method. That is really usefull, because we can access services easily in a recursive way.At this point we don&#x27;t need to know how the <code>UserService::class</code> service is created, and we can focus on creating the UserController. That&#x27;s a good example of <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Single_responsibility_principle">Single Responsibility Principle</a>.The ItemController is created in a very similar way. You can take a look at the class <code>src/Controller/ItemControllerFactory.php</code>.But this is not all. Controllers extending the AbstractController depend also on a <code>Slim\Http\Request</code>, a <code>Slim\Http\Response</code> and a <code>Slim\View</code> that are not injected on their respective factories.For this purpose we have defined three initializers in the <code>config/services.php</code> file, which will inject those objects on any instance implementing certain interfaces. The AbstractController implements all the interfaces, so creating a UserController or ItemController will result in all the initializers to inject those dependencies via setters.This is one of the initializers, but the rest are very similar.<pre><pre><code class="language-php">namespace Acelaya\Mvc;

use Zend\ServiceManager\InitializerInterface;
use Zend\ServiceManager\ServiceLocatorInterface;

class RequestAwareInitializer implements InitializerInterface
{
 public function initialize($instance, ServiceLocatorInterface $serviceLocator)
 {
 if ($instance instanceof RequestAwareInterface) {
 $app = $serviceLocator-&gt;get(&#x27;app&#x27;);
 $instance-&gt;setRequest($app-&gt;request);
 }
 }
}
</code></pre></pre>We are fetching the app here. Since it is already created at this point, the <code>ServiceManager</code> will return the same instance.Now we know that any route starting with /users will end with a fully configured UserController fetched from the <code>ServiceManager</code>, and any route starting with /items will do the same with an ItemController.<h4>Other services</h4>We saw that creating any controller will fetch another service from the <code>ServiceManager</code>. Those are the <code>UserService::class</code> or the <code>ItemService::class</code> respectively.If we go to the <code>config/services.php</code> file we won&#x27;t find those services defined, but the <code>ServiceManager</code> is capable of creating them. And how is that?In the abstract_factories block, we have defined a ServiceAbstractFactory. Abstract factories are used as last resort to create services that are not explicitly defined.In our case both services extend the <code>AbstractService</code> and have the same dependencies. This abstract factory checks if the service that is going to be created extends that class, and in that case creates it by injecting another two dependencies fetched from the <code>ServiceManager</code> again (recursivity is awesome!), which will run their own factories.This abstract factory is in <code>src/Service/ServiceAbstractFactory.php</code>, if you want to take a look at its implementation.<h4>Everything is running</h4>And thats all the theory. The application works now in theory. Check it.The most powerful aspect of the <code>ServiceManager</code> is that objects are recursively created in different ways. The creation implementation is defined just in one place without code duplication.We have performed dependency injection and the code wasn&#x27;t harder to handle.<h3>Unit tests</h3>The project now works, but we can&#x27;t remember to manually test everything every time we refactor the code or add new features. That&#x27;s where unit tests come.Having a good test suite is hard, but it is even harder without dependency injection. Tests end running almost the whole application, with too many objects created under the hood when the subject under test is created.With dependency injection, we can inject fake harmless objects in the subject under test, making sure we are going to test just a small piece of code. Indeed, one of the most important reasons to use dependency injection is to be able to test your code without wanting to kill yourself.For example. On this project, both UserService and ItemService depend on an instance of <code>Doctrine\ORM\EntityManager</code>. That object performs operations against a database, but we don&#x27;t want to connect to the database every time we run our tests.If you take a look at <code>tests/Service/UserServiceTest.php</code> you will see how the EntityManager is faked by using phpunit&#x27;s mocks API.<pre><pre><code class="language-php">// ...

public function setUp()
{
 $repository = $this-&gt;getMock(&#x27;Doctrine\Common\Persistence\ObjectRepository&#x27;);
 $repository-&gt;expects($this-&gt;any())
 -&gt;method(&#x27;findAll&#x27;)
 -&gt;willReturn([]);

 $objectManager = $this-&gt;getMock(&#x27;Doctrine\Common\Persistence\ObjectManager&#x27;);
 $objectManager-&gt;expects($this-&gt;any())
 -&gt;method(&#x27;getRepository&#x27;)
 -&gt;willReturn($repository);
 $objectManager-&gt;expects($this-&gt;any())
 -&gt;method(&#x27;persist&#x27;)
 -&gt;willReturn(null);
 $objectManager-&gt;expects($this-&gt;any())
 -&gt;method(&#x27;flush&#x27;)
 -&gt;willReturn(null);
 $objectManager-&gt;expects($this-&gt;any())
 -&gt;method(&#x27;find&#x27;)
 -&gt;willReturn(new User());

 $this-&gt;userService = new UserService(
 $objectManager,
 new Logger(new Filesystem(new NullAdapter()), &#x27;fake.log&#x27;)
 );
}

// ...
</code></pre></pre>If I wasn&#x27;t injecting the EntityManager, the UserService would be tightly coupled with the database. Instead, the UserService expects an object of an abstract type to be injected on it, so it is decoupled with the system that saves the data.<h3>Conclusion</h3>You have seen a real example which uses the <code>ServiceManager</code>. There is no theory, you can check it yourself. I have used each object creation strategy at least once (invokables, factories, initializers, abstract_factories and delegators) so that you can see how it works.As I mentioned earlier, I already wrote a more theoretical article on the <code>ServiceManager</code> subject a while ago. You can find it <a href="/2014/10/09/advanced-usage-of-service-manager-in-zend-framework-2/">here</a> if you need it (indeed I recommend you to read it).I hope you use dependency injection in your projects from now on. There is no excuse not to do it, you just need to change your point of view.By the way, I have not explained everything of this project. If you start digging into the code and have any comment, feel free to post it here.

Managing objects creation and dependency injection with Zend\ServiceManager

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><pre><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></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><pre><code class="language-ruby">config.vm.synced_folder &quot;subfolder/&quot;, &quot;/anywhere/else/in/the/virtual/machine&quot;
</code></pre></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 PHP development environment with Vagrant

Some time ago, on January 2014, I decided to start writing a blog.Seemed like a good idea. I might be able to show my skills and learn new ones at the same time.I didn&#x27;t wanted to use a very complex tool for this purpose, or to create one of my own (why to reinvent the wheel?), so I decided that blogger or wordpress could be the right options.After weighing the pros and cons of both options I opted for wordpress, because it seemed more customizable, and having a <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Virtual_private_server">VPS</a> could ease the self-hosting task.At the begining it was a good solution, but finally proved to be hard to control. Not easy to customize the layout, very resource consuming, hard to optimize, etc.I looked for alternatives and found an interesting one without all the previous problems, <a target="_blank" rel="noopener noreferrer" href="https://sculpin.io/">Sculpin</a>.We discussed the tool in the <a target="_blank" rel="noopener noreferrer" href="https://twitter.com/symfony_zgz">Symfony Zaragoza</a> group, and I really loved it from the begining.<h3>First approach to Sculpin</h3>In the Github era, many static site generators have appeared, because Github allows us to host static sites for free. Those generators allows us to make a &quot;dynamic&quot; website which is compiled into a static site.There are many alternatives. From <a target="_blank" rel="noopener noreferrer" href="https://jekyllrb.com/">Jekyll</a>, the Github official static site generator written in ruby, to <a target="_blank" rel="noopener noreferrer" href="http://blog.getpelican.com/">Pelican</a>, another python-powered alternative.The problem is that I&#x27;m a PHP developer, and I&#x27;m not as confortable with those languages as I am with PHP, so I looked for a PHP alternative and Sculpin appeared.Sculpin uses Symfony components, and is fully integrated with composer. I like both tools so I finally decided to use it.For more information about how to use Sculpin, it has a very good [documentation](https://sculpin.io/getstarted/).<h3>Migrating from Wordpress</h3>There was a few features in wordpress that I didn&#x27;t wanted to loose and are not easy to implement in a static site, like comments, built-in search and RSS feed. I also didn&#x27;t wanted to loose the already indexed content, so I needed to keep the old URLs, at least those pointing to the articles.Luckily for me, there is a <a target="_blank" rel="noopener noreferrer" href="https://github.com/sculpin/sculpin-blog-skeleton">Sculpin Blog Skeleton</a> in github with many of the work already done. It includes an atom feed that is refreshed every time you compile your site.To get comments in my static blog, I have used <a target="_blank" rel="noopener noreferrer" href="https://disqus.com/">disqus</a>. It uses a very easy javascript api to host your comments which are associated to the article&#x27;s unique URL. Also, they allow to import comments from wordpress, so I could also keep the old comments.There are other platforms like this, but they don&#x27;t look as good as disqus.The built-in search was one of the hardest features to implement. I have used <a target="_blank" rel="noopener noreferrer" href="http://lunrjs.com/">lunr.js</a>, a javascript full text search engine, but I was not sure how to deal with it, so I finally found a Sculpin blog using it, and copy-pasted the needed code. Thanks to <a target="_blank" rel="noopener noreferrer" href="http://blog.andrewshell.com">Andrew Shell</a> for his code.After this I just needed to get the articles from wordpress.Sculpin uses <a target="_blank" rel="noopener noreferrer" href="http://twig.sensiolabs.org/">twig</a> templates and/or <a target="_blank" rel="noopener noreferrer" href="http://es.wikipedia.org/wiki/Markdown">markdown</a> to write articles, so it&#x27;s easy to copy-paste html documents on them. That&#x27;s what I did. A little customization and done.Keeping the URLs was easy, because I was using the y/m/d/foobar form in wordpress, and the Sculpin skeleton uses that format by default.Finally I was considering to host the blog in Github, but I decided to use my VPS, to use some htaccess tricks, like some rewrite rules in order to redirect old URLs to new ones and set a customized 404 page.The result is the blog you are now seeing.<h3>Conclusion</h3>My conclusion is that a dynamically generate static site is a good solution for a personal blog. It loads superfast, is very SEO friendly and is easily customizable, but it has an important problem. Only advanced users can use it.The lack of <a target="_blank" rel="noopener noreferrer" href="https://es.wikipedia.org/wiki/WYSIWYG">WYSIWYG</a> editor makes users with no experience on HTML/Markdown (at least) impossible to deal with this kind of sites.Also, the site needs to be deployed every time a new article is written.Apart from that, as I said, It&#x27;s a good solution, and Sculpin is a really good tool. If you are curious, you can see the pre-compiled version of this blog in github, <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/blog">here</a>.

Migrating from Wordpress to Sculpin

One of the common problems we have to confront when starting a new PHP project is how to handle the different dependencies we are going to have.One could think the easier solution is to download all the libraries we are going to need, put them in a <code>lib</code> directory and add them to the version control of the project, but this could be problematic. Let&#x27;s see why.The main problems of using this practice are this.<ul><li>Dependencies of dependencies: Our dependencies may have their own dependencies that we will also need to download.</li><li>Updates: What happens if we need a new feature in the last version of one dependendency? We are going to have to update it manually, and that can be a hard task. Baybe even the new version has new dependencies of its own that we will need to download.</li><li>Autoloading: How do we deal with autoloading the classes in the dependencies? Some of them may have its own autoloading system, but anyway, we are going to need to <code>include</code> all the autoloaders of each dependency.</li></ul>How do we solve all of this? The answer is <a target="_blank" rel="noopener noreferrer" href="http://getcomposer.org">Composer</a>.<h3>Starting with composer</h3>Composer has become the dependency manager in the main PHP projects. It uses its own library repository (<a target="_blank" rel="noopener noreferrer" href="https://packagist.org/">packagist</a>) to handle dependencies, but you can setup private repositories too.It uses a small configuration file, the <code>composer.json</code>, to know which are our dependencies, and it will download their dependencies recursively without us having to do anything special.We can define an autoloading strategy in that file too, and forget about that task for our project and our dependencies.This are some examples of famous PHP project&#x27;s <code>composer.json</code> files:<ul><li><a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zf2/blob/master/composer.json">Zend Framework</a></li><li><a target="_blank" rel="noopener noreferrer" href="https://github.com/symfony/symfony/blob/master/composer.json">Symfony</a></li><li><a target="_blank" rel="noopener noreferrer" href="https://github.com/doctrine/doctrine2/blob/master/composer.json">Doctrine</a></li><li><a target="_blank" rel="noopener noreferrer" href="https://github.com/aws/aws-sdk-php/blob/master/composer.json">AWS PHP SDK</a></li><li><a target="_blank" rel="noopener noreferrer" href="https://github.com/Seldaek/monolog/blob/master/composer.json">Monolog</a></li><li><a target="_blank" rel="noopener noreferrer" href="https://github.com/thephpleague/flysystem/blob/master/composer.json">Flysystem</a></li></ul>Now lets see a simpler composer file:<pre><pre><code class="language-json">{
 &quot;name&quot; : &quot;acelaya/zf2-acmailer&quot;,
 &quot;description&quot; : &quot;Mail sending module for Zend Framework 2&quot;,
 &quot;type&quot; : &quot;library&quot;,
 &quot;authors&quot; : [
 {
 &quot;name&quot; : &quot;Alejandro Celaya Alastrué&quot;,
 &quot;email&quot; : &quot;alejandro@alejandrocelaya.com&quot;,
 &quot;homepage&quot; : &quot;http://www.alejandrocelaya.com&quot;,
 &quot;role&quot; : &quot;Developer&quot;
 }
 ],
 &quot;keywords&quot; : [
 &quot;mail&quot;,
 &quot;zend&quot;,
 &quot;php&quot;
 ],
 &quot;homepage&quot; : &quot;https://github.com/acelaya/ZF2-AcMailer&quot;,
 &quot;license&quot; : [
 &quot;BSD&quot;
 ],
 &quot;require&quot; : {
 &quot;php&quot; : &quot;&gt;=5.3.0&quot;,
 &quot;zendframework/zendframework&quot;: &quot;&gt;=2.2.2&quot;
 },
 &quot;require-dev&quot;: {
 &quot;phpunit/phpunit&quot;: &quot;&gt;=3.7&quot;,
 &quot;squizlabs/php_codesniffer&quot;: &quot;1.*&quot;,
 &quot;phploc/phploc&quot;: &quot;*&quot;,
 &quot;pdepend/pdepend&quot; : &quot;1.1.0&quot;,
 &quot;phpmd/phpmd&quot; : &quot;1.4.*&quot;,
 &quot;sebastian/phpcpd&quot;: &quot;*&quot;,
 &quot;theseer/phpdox&quot;: &quot;0.6.5&quot;
 },
 &quot;autoload&quot; : {
 &quot;psr-0&quot; : {
 &quot;AcMailer&quot; : &quot;src/&quot;
 },
 &quot;classmap&quot; : [
 &quot;./Module.php&quot;
 ]
 }
}
</code></pre></pre>This is the composer file of my Zend Framework 2 module <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/ZF2-AcMailer">AcMailer</a>. Let&#x27;s explain it.The properties name, description, type, authors, keywords, homepage and license are just metadata to provide useful information to other users and ease finding the project in <a target="_blank" rel="noopener noreferrer" href="https://packagist.org/">packagist</a>.The require property is the place where we define our dependencies and the version we want to install. We can define here the minimum required PHP version and even the php modules we need (like <code>php-pdo</code>, <code>php-intl</code> and such).The require-dev property allows us to define other dependencies that won&#x27;t be necessery in a production environment, like testing or documentation tools.Finally the autoload property is where we define how our own classes are loaded. It is very easy to define a <code>psr-0</code> or <code>psr-4</code> autoloading strategy, but we can even define a <code>classmap</code> with a list of paths to files.<blockquote>You don&#x27;t have to remember the <code>composer.json</code> schema. You can interactively create it by running <code>php composer.phar init</code>.</blockquote><h3>Installing dependencies</h3>Once this is defined we just need the composer binary file (usually in phar format), that can be found <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/download/">here</a>, and run <code>php composer.phar install</code>.This will create a <code>vendor</code> folder in the root of our project, download our dependencies there, the dependencies of our dependencies, and set-up an autoloader that will be able to load all our dependencies and our own classes as well.After this it&#x27;s enough with a single <code>include</code> statement to <code>vendor/autoload.php</code> to be able to access any class.If later in the project we need to update an existing dependency, add new dependencies or change the autoloading, we just need to update the information in the <code>composer.json</code> file and run <code>php composer.phar update</code> to update dependencies and autoloader.<blockquote>It is recommended to include the composer binary in the PATH to be able to run <code>composer</code> instead of <code>php composer.phar</code>.</blockquote><blockquote>If you are using a VCS like <a target="_blank" rel="noopener noreferrer" href="https://git-scm.com/">git</a> in your project you will probably want to ignore your <code>vendor</code> folder.</blockquote><h3>Advanced usages</h3>This should be enough to start working with composer, but it is a much more powerful tool with more features. It is not a bad idea to take a quick read to its <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/doc/">documentation</a>, but let&#x27;s see the main advanced features.<ul><li>Classmap autoloader: By running <code>composer dumpautoload --optimize</code> we can generate a much faster autoloader which defines a class =&gt; file map array with all the classes handled by composer. This is the more suitable autoloader for production environments.</li><li>Production dependencies: If we include de modifier <code>--no-dev</code> while installing or updating dependencies, it will ignore (or remove) the require-dev dependencies. For example <code>composer update --no-dev</code></li><li>Private repositories: If you want to install dependencies from repositories other than <a target="_blank" rel="noopener noreferrer" href="https://packagist.org/">packagist</a>, you can do it by using the repositories property. It supports many types of repositories, from VCS to PEAR repositories. Complete documentation <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/doc/05-repositories.md">here</a>.</li><li>Global packages: If you want to install dependencies globally, just add the <code>global</code> keyword before the <code>install</code> or <code>update</code>. That will install the dependencies in the <code>~/.composer/vendor</code> directory instead of installing them in the local <code>vendor</code> directory. For example <code>composer global update</code>.</li></ul>And that&#x27;s all you need to know to start working with composer.Update 2015-04-25: I&#x27;ve written an article addressing advanced concepts that is a good continuation to this one. <a href="/2015/04/25/composer-advanced-concepts/">Composer advanced concepts</a>.

Dependency management and autoloading in php projects with composer

Last week I passed the <a target="_blank" rel="noopener noreferrer" href="http://www.zend.com/en/yellow-pages/ZEND021590">Zend Framework 2 Certified Architect</a> exam.I will try to explain how did I prepare it.<h3>Studying</h3>In late March I recived an email that my exam was going to be on May the seventh, so I saw that I was going to have 4-6 weeks to prepare it. I could have started earlier, but maybe I&#x27;m a little lazy.Since this was one of the first times the Zend Framework certification exam was based on version 2 (2.2), there was no documentation or examples in the internet, so I decided to just read the whole <a target="_blank" rel="noopener noreferrer" href="https://framework.zend.com/manual/2.2/en/user-guide/overview.html">documentation</a>. I was working with Zend Framework 2 in my job, so I could apply the theory in real projects.My main problem was that I needed to compatibilize the study with my work, so I started studying about an hour a day. Some days I didn&#x27;t studied, but some weekends I could spend more time on it.About two weeks after I started I saw I wasn&#x27;t going to be able to read all the documentation, so I started to read the components documentation in order of importance. This finally was proved to be a good system. I got no questions in my exam about <code>Zend\Barcode</code>, <code>Zend\Debug</code>, <code>Zend\Navigation</code> and such trivial components, but plenty of questions about <code>EventManager</code>, <code>ServiceManager</code>, <code>ModuleManager</code>, <code>Mvc</code> and <code>Forms</code>.I neither had any questions of ZendService components.<h3>Questions</h3>The <code>ServiceManager</code> was present in many questions, as well as any kind of plugin manager (<code>ControllerManager</code>, <code>ViewHelperManager</code>…)In those questions a piece of code was present where many services were registered in different ways, from a plain PHP array, from a <code>Zend\ServiceManager\Config</code> object or directly by calling methods from a <code>ServiceManager</code> instance.Then the <code>ServiceManager</code> instance was used to retrive services, and you were supposed to know which ones were the same instance, what type of object do they return or even which services return the same instance.The <code>EventManager</code> was also present in many forms. In some questions you were supposed to know the difference between the <code>EventManager</code> and the <code>SharedEventManager</code>, how to attach listeners or how to use <code>ListenerAggregates</code>.The <code>MvcEvent</code> appeared in many questions too, where you need to know about the <code>EventManager</code> and the <code>MVC</code> layer.A good bunch of questions was related with Forms, Validators and Filters.In those questions you may be asked about the <code>FormElementManager</code>, get an element where some filters were attached and know which would be the final output from a specific input, or get a form with many elements with validators and know if an input was going to make the form valid or not.These was the most important parts, but I also had questions about <code>Hydrators</code>, <code>Zend\Db</code>, the <code>ModuleManager</code> and how Modules are loaded, <code>Zend\View</code> with its events layer and the <code>PhpRenderer</code>, <code>Zend\I18n</code>, <code>Zend\Cache</code> or <code>Zend\Config</code>.<h3>Conclusions</h3>I made the exam with two other people I knew. The three of us thought that it wasn&#x27;t a very complicated exam, with no tricky questions (like <code>$foo = &quot;Bar&quot;; echo $fo;</code>), but you have to know the theory very well, how the framework works and how it is supposed to be used.It is important to know about factories, dependency injection and good practices.It would be good to work with Zend Framework 2 as long as you study, because that shows you how it behaves in real environments. Sometimes the Albums tutorial is not enough.I hope this article helps to anyone preparing the exam. I wish you luck.

How to prepare the Zend Framework 2 Certified Architect exam

Dependency management is very important in any kind of project. Any application will need to use third party libraries to avoid to reinvent the wheel.The problem is that getting each one of them from a different place takes time, and it&#x27;s not easy to be sure we get the correct version.To solve this in java projects we can use an automated dependency manager, like <a target="_blank" rel="noopener noreferrer" href="https://maven.apache.org/">Maven</a>, which is really a building system with dependcy management included. The problem with maven is that it could be hard to use, and not very intuitive.Instead of Maven, I rather prefer to use <a target="_blank" rel="noopener noreferrer" href="https://ant.apache.org/ivy/">Ivy</a>. It is a more simple and agile dependency management system, designed to be used with <a target="_blank" rel="noopener noreferrer" href="https://ant.apache.org/">Ant</a>, but it takes dependencies from Maven repositories, like <a target="_blank" rel="noopener noreferrer" href="https://mvnrepository.com/">Maven central</a>.<h3>Getting started</h3>To use Ivy we need to create an <code>ivy.xml</code> file in the project root directory. It will be used to define which dependencies are needed by our project, and will need to be downloaded at building time.This is the <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/subclient-subconnector">Subconnector</a> Ivy script.<pre><pre><code class="language-xml">&lt;ivy-module version=&quot;2.0&quot;&gt;
 &lt;info organisation=&quot;net.subclient&quot; module=&quot;subconnector&quot; /&gt;

 &lt;dependencies&gt;
 &lt;dependency org=&quot;junit&quot; name=&quot;junit&quot; rev=&quot;4.10&quot; /&gt;
 &lt;dependency org=&quot;com.google.code.gson&quot; name=&quot;gson&quot; rev=&quot;2.2.2&quot; /&gt;
 &lt;dependency org=&quot;log4j&quot; name=&quot;log4j&quot; rev=&quot;1.2.17&quot; /&gt;
 &lt;dependency org=&quot;org.apache.commons&quot; name=&quot;commons-lang3&quot; rev=&quot;3.1&quot;/&gt;
 &lt;/dependencies&gt;
&lt;/ivy-module&gt;
</code></pre></pre>As you can see, it is very simple. We just defined an info element with the basic project information, and a dependencies element with nested information of each of the dependencies of the project.For each one of them we have to know its organization, name and revision. With this we can be sure we will get the desired library and revision.But how do we know what to put in <code>org</code>, <code>name</code> and <code>rev</code> attributes? The <a target="_blank" rel="noopener noreferrer" href="https://mvnrepository.com/">maven central repository</a> webpage will help us with this.At the top search bar we can write the name of a library, for example gson. The first result corresponds to the gson artifacts in the maven central. By selecting the desired version we will get the dependency element for an Ivy script, as well as other dependency management systems, like Maven or <a target="_blank" rel="noopener noreferrer" href="https://gradle.org/">Gradle</a>.<img src="/assets/img/dependency.jpg" alt="Maven dependency example"/>We just need to copy and paste it. Nice and easy.<h3>Automate retrieving dependencies</h3>Once our Ivy script is ready, it is time to include retrieving dependencies in our building process. The easiest way to do it is to create an Ant target in our <code>build.xml</code> script, like this.<pre><pre><code class="language-xml">&lt;target name=&quot;retrieve-dependencies&quot;
 description=&quot;Retrieve dependencies with Apache IVY&quot;&gt;

 &lt;ivy:retrieve type=&quot;jar&quot; /&gt;

&lt;/target&gt;
</code></pre></pre>This will look for the ivy.xml script and download dependencies defined on it in a lib folder, but only binary jar files. If <code>type=&quot;jar&quot;</code> is removed, all docs, sources and binaries will be retrieved.Make sure to add Ivy binaries to Ant classpath to make it properly work. The <code>project</code> element in the build script will need also to look like this.<pre><pre><code class="language-xml">&lt;project basedir=&quot;.&quot; default=&quot;build&quot; name=&quot;Subconnector&quot; xmlns:ivy=&quot;antlib:org.apache.ivy.ant&quot;&gt;

 ...

&lt;/project&gt;
</code></pre></pre>Notice the <code>xmlns:ivy</code> attribute.Now we are ready to go.For an advanced Ivy configuration take a look at its <a target="_blank" rel="noopener noreferrer" href="https://ant.apache.org/ivy/history/2.3.0/index.html">official documentation</a>. It explains how to use custom repositories, how to set up a proxy server, how to change default local lib folder, etc.

Dependency management in Java projects with Ant and Ivy

<a target="_blank" rel="noopener noreferrer" href="http://nsis.sourceforge.net/Main_Page">NSIS</a> is a well known system used to create Windows installers for any type of application based on scripts.It is good system. Once we have defined our script we can automatically build it to create application installers in minutes, including creation of Windows register entries, installation folders, application shortcuts, etcThe problem is that only Windows binaries are officially provided to compile this kind of scripts. This can be a problem in a <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Continuous_integration">continuous integration</a> environment, where continuous integration servers use to be Linux based.At this article I am going to explain how to compile NSIS source code in Linux to get it working there and allow it to be invoked from automated tasks run in a continuous integration server.<h3>Download NSIS</h3>The first step is to download the windows distributable zip file and the source code. Both of them can be downloaded from their Sourceforge project: <a target="_blank" rel="noopener noreferrer" href="https://sourceforge.net/projects/nsis/files/?source=navbar">https://sourceforge.net/projects/nsis/files/?source=navbar</a>.At the moment of writing this article the last stable version is NSIS 2.46, so we will need to download nsis-2.46.zip and nsis-2.46-src.tar.bz2. We will put them in a folder were users who are going to need it are allowed to access. I am going to put it at <code>/home/alejandro/nsis</code>Now that we have downloaded both windwos distributable package and source code we are going to decompress them creating two folders, nsis-2.46 and nsis-2.46-src.<h3>System requirements</h3>NSIS official documentation says we need this tools to compile it:<ul><li>Python, version 1.6 or higher. I am using Python 2.7.3</li><li>Scons version 0.96.93 or higher. This application can be downloaded from their official website <a target="_blank" rel="noopener noreferrer" href="http://www.scons.org/download.php">http://www.scons.org/download.php</a></li><li>A C compiler, in our case <code>gcc</code> and <code>g++</code></li></ul>All of this tools can be easily installed from repository, and probably we already have some of them.The scons installer downloaded from their website comes in RPM format which could be a problem for systems not based in Ubuntu. For Debian I used the alien [<code>aptitude install alien</code>] tool, which converts RPM packages into DEB packages by running this command: <code>alien -k filename.rpm</code>Anyway, I uploaded the DEB resultant package for you to <a href="/assets/downloads/scons_2.3.0-1_all.deb_.zip">download</a> it.<h3>Compile NSIS</h3>Once all the requirements are clear we are going to compile the NSIS binary that is responsible for interpreting the scripts, the so called <code>makensis</code>.We have to be at the source code directory, in my case <code>/home/alejandro/nsis/nsis-2.46-src</code>, and we execute this command.<pre><pre><code>scons SKIPSTUBS=all SKIPPLUGINS=all SKIPUTILS=all SKIPMISC=all NSIS_CONFIG_CONST_DATA=no PREFIX=/path/where/distributable/was/extracted install-compiler
</code></pre></pre>Notice that install-compiler is an argument of the command that is placed at the end, and is not part of the distributable path.In my case, using my real path, the resulting command would be this:<pre><pre><code>scons SKIPSTUBS=all SKIPPLUGINS=all SKIPUTILS=all SKIPMISC=all NSIS_CONFIG_CONST_DATA=no PREFIX=/home/alejandro/nsis/nsis-2.46 install-compiler
</code></pre></pre>The execution of this command will compile the code, generating the <code>makensis</code> binary at the bin directory inside the distributable package folder, in my case <code>/home/alejandro/nsis/nsis-2.46/bin</code>.<h3>Test makensis and create an installer</h3>Now that we have makensis created its a good idea to make it available from anywhere, for example adding it to a bin directory, and make sure it can be executed.Using the paths from our example, running this commands will make the job.<pre><pre><code>chmod +x /home/alejandro/nsis/nsis-2.46/bin/makensis
ln -s /home/alejandro/nsis/nsis-2.46/bin/makensis /usr/local/bin/makensis
</code></pre></pre>Now it is time to test the command. Running <code>makensis</code> from anywhere should output something like this.<img src="/assets/img/nsis.png" alt="Nsis help"/>If we have an nsis script, runing the command makensis /path/to/script.nsi will compile the script, creating the installer. The syntax is the same used in windows.Atention! While running this command there could be this error.<pre><pre><code>Error: opening stub &quot;/home/alejandro/nsis/nsis-2.46/share/nsis/Stubs/zlib
Error initalizing CEXEBuild: error setting default stub
</code></pre></pre>This could happen because of a path error, but solving it is very simple, just go to the NSIS distributable folder, <code>/home/alejandro/nsis/nsis-2.46</code> in my case, and create the folder share [<code>mkdir share</code>], go to that folder an create a symbolic link running ln -s <code>/home/alejandro/nsis/nsis-2.46 nsis</code>.That should fix the problem.With this easy steps we have now a NSIS compilation system under a Linux machine ready to build and deploy Windows installers.

Alejandro Celaya | Blog

Software development, agile methodologies and open source projects.

category Archive — "tools"

— 2017 —

— 2016 —

— 2015 —

— 2014 —