update es folder links

guide/en/structure/package.md

@@ -180,7 +180,7 @@ everything is in good shape. For more details, please refer to the [Testing](../
 #### Versioning <span id="versioning"></span>
 
 You should give each release of your extension a version number (e.g. `1.0.1`). We recommend you follow the
-[semantic versioning](http://semver.org) practice when determining what version numbers should be used.
+[semantic versioning](https://semver.org) practice when determining what version numbers should be used.
 
 
 #### Releasing <span id="releasing"></span>
@@ -197,7 +197,7 @@ In the release of your package, in addition to code files, you should also consi
 help other people learn about and use your extension:
 
 * A readme file in the package root directory: it describes what your extension does and how to install and use it.
-  We recommend you write it in [Markdown](http://daringfireball.net/projects/markdown/) format and name the file
+  We recommend you write it in [Markdown](https://daringfireball.net/projects/markdown/) format and name the file
   as `README.md`.
 * A changelog file in the package root directory: it lists what changes are made in each release. The file
   may be written in Markdown format and named as `CHANGELOG.md`.

guide/es/README.md

@@ -1,6 +1,6 @@
 # La Guía Definitiva de Yii 3.0
 
-Esta guía se publica bajo los [Términos de documentación de Yii](http://www.yiiframework.com/doc/terms/).
+Esta guía se publica bajo los [Términos de documentación de Yii](https://www.yiiframework.com/doc/terms/).
 
 Introducción
 ------------
@@ -9,7 +9,7 @@
 * [Actualizar desde la Version 2.0](intro/upgrade-from-v2.md)
 
 
 Primeros Pasos
 ---------------
 
 * [Qué Necesitas Saber](start/prerequisites.md)
@@ -22,7 +22,7 @@
 * [Adentrarse en Yii](start/looking-ahead.md)
 
 
 Estructura De Una Aplicación
 ---------------------
 
 * [Información General de Estructura de Una Aplicación](structure/overview.md)
@@ -34,21 +34,21 @@
 * [Lógica de Intercambio (middleware)](structure/middleware.md)
 * [Paquetes](structure/package.md)
 
 Conceptos Clave
 ------------
 
 * [Autocarga de Clases (Autoloading)](concept/autoloading.md)
 * [Contenedor de Inyección de Dependencia](concept/di-container.md)
 * [Configuración](concept/configuration.md)
 * [Alias](concept/aliases.md)
 * [Eventos](concept/events.md)
 
 Gestión de las Peticiones
 -----------------
 
 * [Información General de Gestión de las Peticiones](runtime/overview.md)
 * [Bootstrapping](runtime/bootstrapping.md)
 * [Enrutamiento y Creación de las URL](runtime/routing.md)
 * [Peticiones (Requests)](runtime/request.md)
 * [Respuestas (Responses)](runtime/response.md)
 * [Sesiones (Sessions)](runtime/sessions.md)
@@ -68,15 +68,15 @@
 * [Motores de Plantillas](views/template-engines.md)
 
 
 Trabajar con Bases de Datos
 ----------------------
 
 * [Objeto de Acceso a Datos](db-dao.md): Conexión a una base de datos, consultas básicas, transacciones y manipulación de esquemas
 * [Constructor de Consultas](db-query-builder.md): Consulta de la base de datos utilizando una capa simple de abstracción
 * [Active Record](db-active-record.md): ORM Active Record, recuperación y manipulación de registros y definición de relaciones
 * [Migraciones](db-migrations.md): Control de versiones de bases de datos en el entorno de desarrollo en equipo
 
 Obtener Datos de los Usuarios
 -----------------------
 
 * [Crear Formularios](input/forms.md)
@@ -85,7 +85,7 @@
 * [Obtener Datos de Formularios Tabulados (Tabular Input)](input/tabular-input.md)
 
 
 Visualizar Datos
 ---------------
 
 * [Formato de Datos](output/formatting.md)
@@ -115,7 +115,7 @@
 * [Caché HTTP](caching/http.md)
 
 
 Servicios Web RESTful
 --------------------
 
 * [Inicio Rápido](rest/quick-start.md)
@@ -127,7 +127,7 @@
 * [Gestión de Versiones](rest/versioning.md)
 * [Manejo de Errores](rest/error-handling.md)
 
 Herramientas de Desarrollo
 -----------------
 
 * [Depurador y Barra de Herramientas de Depuración](https://www.yiiframework.com/extension/yiisoft/yii2-debug/doc/guide)
@@ -135,7 +135,7 @@
 * [Generación de Documentación de API](https://www.yiiframework.com/extension/yiisoft/yii2-apidoc)
 
 
 Pruebas (Testing)
 -------
 
 * [Información General de Pruebas](testing/overview.md)
@@ -146,7 +146,7 @@
 * [Datos de Prueba (Fixtures)](testing/fixtures.md)
 
 
 Temas Especiales
 --------------
 
 * [Creación de una Aplicación Desde Cero](tutorial/start-from-scratch.md)
@@ -171,7 +171,7 @@
 * [Bootstrap Widgets](https://www.yiiframework.com/extension/yiisoft/yii2-bootstrap/doc/guide)
 
 
 Clases Auxiliares
 -------
 
 * [Información General de Clases Auxiliares](helper-overview.md)

guide/es/concept/di-container.md

@@ -2,7 +2,7 @@
 
 ## Depdendency injection <span id="dependency-injection"></span>
 
 There are two ways of re-using things in OOP: inheritance and composition.
 
 Inheritance is simple:
 
@@ -28,9 +28,9 @@
 }
 ```
 
 The issue here is that these two are becoming unnecessarily coupled or inter-dependent making them more fragile.
 
 Another way to handle it is composition:
 
 ```php
 interface CacheInterface
@@ -66,20 +66,20 @@
 }
 ```
 
 In the above we've avoided unnecessary inheritance and used interface to reduce coupling. You can replace cache
 implementation without changing `CachedWidget` so it is becoming more stable.
 
 The process of getting an instance of `CacheInterface` into `CachedWidget` is called dependency injection.
 There are multiple ways to perform it:
 
 - Constructor injection. Best for mandatory dependencies.
 - Method injection. Best for optional dependencies.
 - Property injection. Better to be avoided in PHP except maybe data transfer objects.
 
 
 ## DI container <span id="di-container"></span>
 
 Injecting basic dependencies is simple and easy. You're choosing a place where you don't care about dependencies,
 which is usually action handler, which you aren't going to unit-test ever, create instances of dependencies needed
 and pass these to dependent classes.
 
@@ -96,16 +96,16 @@
 That's what dependency containers are for.
 
 A dependency injection (DI) container is an object that knows how to instantiate and configure objects and
-all their dependent objects. [Martin Fowler's article](http://martinfowler.com/articles/injection.html) has well
+all their dependent objects. [Martin Fowler's article](https://martinfowler.com/articles/injection.html) has well
 explained why DI container is useful. Here we will mainly explain the usage of the DI container provided by Yii.
 
 Yii provides the DI container feature through the [yiisoft/di](https://github.com/yiisoft/di) package and
 [yiisoft/injector](https://github.com/yiisoft/injector) package.
 
 ### Configuring container <span id="configuring-container"></span>
 
 Because dependencies are needed when new objects are being created, their registration should be done
 as early as possible. If you are application developer it could be done right in the application configuration,
 `config/web.php`. For the following service:
 
 ```php
@@ -199,10 +199,10 @@
 }
 ```
 
 Since action handler is instantiated and called using [yiisoft/injector](https://github.com/yiisoft/injector), it
 would check constructor and method argument types, get dependencies of these types from container and pass them as
 arguments. That is usually called auto-wiring. It happens for sub-dependencies as well i.e., if dependency is not provided
 explicitly, container would check if it has such a dependency first. As a developer it is enough to declare a dependency
 you need, and it would be got from container automatically.
 
 

guide/es/intro/what-is-yii.md

@@ -1,21 +1,21 @@
 What is Yii
 ===========
 
 Yii is a high performance, component-based PHP framework for rapidly developing modern Web applications.
 The name Yii (pronounced `Yee` or `[ji:]`) means "simple and evolutionary" in Chinese. It can also
 be thought of as an acronym for **Yes It Is**!
 
 
 What is Yii Best for?
 ---------------------
 
 Yii is a generic Web programming framework, meaning that it can be used for developing all kinds
 of Web applications using PHP. Because of its component-based architecture and sophisticated caching
 support, it is especially suitable for developing large-scale applications such as portals, forums, content
 management systems (CMS), e-commerce projects, RESTful Web services, and so on.
 
 
 How does Yii Compare with Other Frameworks?
 -------------------------------------------
 
 If you're already familiar with another framework, you may appreciate knowing how Yii compares:
@@ -28,41 +28,41 @@
   - Explicitness.
   - Consistency.
 
   Yii will never try to over-design things mainly for the purpose of strictly following
   some design pattern.
 - Yii extensively uses PSR interfaces with ability to reuse what PHP community created and even
   replace core implementations if needed.
 - Yii is both a set of libraries and a full-stack framework providing many proven and ready-to-use features:
   caching, logging, template engine, data abstraction, development tools, code generation; and more.
 - Yii is extremely extensible. You can customize or replace nearly every piece of the core's code. You can also
   take advantage of Yii's solid extension architecture to use or develop redistributable extensions.
 - High performance is always a primary goal of Yii.
 
-Yii is not a one-man show, it is backed up by a [strong core developer team](http://www.yiiframework.com/team/), as well as a large community
+Yii is not a one-man show, it is backed up by a [strong core developer team](https://www.yiiframework.com/team/), as well as a large community
 of professionals constantly contributing to Yii's development. The Yii developer team
 keeps a close eye on the latest Web development trends and on the best practices and features
 found in other frameworks and projects. The most relevant best practices and features found elsewhere are regularly incorporated into the core framework and exposed
 via simple and elegant interfaces.
 
 
 Yii Versions
 ------------
 
 Yii currently has three major versions available: 1.1, 2.0 and 3.0.
 
 Version 1.1 is the old generation and is now in security fixes only mode.
 
 Version 2.0 is current stable version that is in the feature freeze bugfix mode.
 
 Version 3.0 is the current version in development. This guide is mainly about version 3.
 
 
 Requirements and Prerequisites
 ------------------------------
 
 Yii 3.0 requires PHP 7.4 or above and runs best with the latest version of PHP 7.
 
 Using Yii requires basic knowledge of object-oriented programming (OOP), as Yii is a pure OOP-based framework.
 Yii 3.0 also makes use of the latest features of PHP, such as type declarations and generators. Understanding these
 concepts will help you more easily pick up Yii 3.0.
 

guide/es/security/authorization.md

@@ -41,47 +41,47 @@
 ```
 
 Behind the scenes, `Yiisoft\Yii\Web\User\User::can()` method calls `\Yiisoft\Access\AccessCheckerInterface::userHasPermission()`
 so an implementation should be provided in dependency container in order for it to work. 
 
 ## Role Based Access Control (RBAC) <span id="rbac"></span>
 
 Role-Based Access Control (RBAC) provides a simple yet powerful centralized access control. Please refer to
-the [Wikipedia](http://en.wikipedia.org/wiki/Role-based_access_control) for details about comparing RBAC
+the [Wikipedia](https://en.wikipedia.org/wiki/Role-based_access_control) for details about comparing RBAC
 with other more traditional access control schemes.
 
-Yii implements a General Hierarchical RBAC, following the [NIST RBAC model](http://csrc.nist.gov/rbac/sandhu-ferraiolo-kuhn-00.pdf).
+Yii implements a General Hierarchical RBAC, following the [NIST RBAC model](https://csrc.nist.gov/rbac/sandhu-ferraiolo-kuhn-00.pdf).
 
 Using RBAC involves two parts of work. The first part is to build up the RBAC authorization data, and the second
 part is to use the authorization data to perform access check in places where it is needed. Since RBAC implements
 `\Yiisoft\Access\AccessCheckerInterface`, using it is similar to using any other implementation of access checker.
 
 To facilitate our description next, we will first introduce some basic RBAC concepts.
 
 ### Basic Concepts <span id="basic-concepts"></span>
 
 A role represents a collection of *permissions* (e.g. creating posts, updating posts). A role may be assigned
 to one or multiple users. To check if a user has a specified permission, we may check if the user is assigned
 with a role that contains that permission.
 
 Associated with each role or permission, there may be a *rule*. A rule represents a piece of code that will be
 executed during access check to determine if the corresponding role or permission applies to the current user.
 For example, the "update post" permission may have a rule that checks if the current user is the post creator.
 During access checking, if the user is NOT the post creator, he/she will be considered not having the "update post" permission.
 
 Both roles and permissions can be organized in a hierarchy. In particular, a role may consist of other roles or permissions;
 and a permission may consist of other permissions. Yii implements a *partial order* hierarchy which includes the
 more special *tree* hierarchy. While a role can contain a permission, it is not `true` vice versa.
 
 
 ### Configuring RBAC <span id="configuring-rbac"></span>
 
 RBAC is available via `yiisoft/rbac` package so we need to require it:
 
 ```
 composer require yiisoft/rbac
 ```
 
 Before we set off to define authorization data and perform access checking, we need to configure the
 `\Yiisoft\Access\AccessCheckerInterface` in dependency container:
 
 ```php
@@ -97,11 +97,11 @@
 ];
 ```
 
 `\Yiisoft\Rbac\Manager\PhpManager` uses a PHP script files to store authorization data. The files are located under
 `@rbac` alias. Make sure the directory and all the files in it are writable by the Web server process if permissions
 hierarchy needs to be changed online.
 
 ### Building Authorization Data <span id="generating-rbac-data"></span>
 
 Building authorization data is all about the following tasks:
 
@@ -111,22 +111,22 @@
 - associating rules with roles and permissions;
 - assigning roles to users.
 
 Depending on authorization flexibility requirements the tasks above could be done in different ways.
 If your permissions hierarchy is meant to be changed by developers only, you can use either migrations
 or a console command. Migration pro is that it could be executed along with other migrations. Console
 command pro is that you have a good overview of the hierarchy in the code rather than it being scattered
 among multiple migrations.
 
 Either way in the end you'll get the following RBAC hierarchy:
 
 ![Simple RBAC hierarchy](img/rbac-hierarchy-1.svg "Simple RBAC hierarchy")
 
 In case you need permissions hierarchy to be formed dynamically you need a UI or a console command. API used to
 build the hierarchy itself won't be different.
 
 ### Using console command
 
 If your permissions hierarchy doesn't change at all and you have a fixed number of users you can create a
 -[console command](../tutorial/console-applications.md) that will initialize authorization data once via
 APIs offered by `\Yiisoft\Rbac\ManagerInterface`:
 
@@ -192,7 +192,7 @@
 }
 ```
 
 The command above could be executed from console the following way:
 
 ```
 ./vendor/bin/yii rbac/init
@@ -203,7 +203,7 @@
 
 #### Using migrations
 
 **TODO**: finish it when migrations are implemented.
 
 You can use [migrations](db-migrations.md)
 to initialize and modify hierarchy via APIs offered by `\Yiisoft\Rbac\ManagerInterface`.
@@ -262,15 +262,15 @@
 > If you don't want to hardcode which users have certain roles, don't put `->assign()` calls in migrations. Instead,
   create either UI or console command to manage assignments.
 
 Migration could be applied by using `./vendor/bin/yii migrate`.
 
 ## Assigning roles to users
 
 TODO: update when signup implemented in demo / template.
 
 Author can create post, admin can update post and do everything author can.
 
 If your application allows user signup you need to assign roles to these new users once. For example, in order for all
 signed up users to become authors in your advanced project template you need to modify `frontend\models\SignupForm::signup()`
 as follows:
 
@@ -298,14 +298,14 @@
 ```
 
 For applications that require complex access control with dynamically updated authorization data, special user interfaces
 (i.e. admin panel) may need to be developed using APIs offered by `authManager`.
 
 
 ### Using Rules <span id="using-rules"></span>
 
 As aforementioned, rules add additional constraint to roles and permissions. A rule is a class extending
 from `\Yiisoft\Rbac\Rule`. It must implement the `execute()` method. In the hierarchy we've
 created previously author cannot edit his own post. Let's fix it. First we need a rule to verify that the user is the post author:
 
 ```php
 namespace App\User\Rbac;
@@ -331,8 +331,8 @@
 }
 ```
 
 The rule above checks if the `post` is created by user rule is checked for. We'll create a special permission `updateOwnPost` in the
 command we've used previously:
 
 ```php
 /** @var \Yiisoft\Rbac\ManagerInterface $auth */
@@ -354,14 +354,14 @@
 $auth->addChild($author, $updateOwnPost);
 ```
 
 Now we have got the following hierarchy:
 
 ![RBAC hierarchy with a rule](img/rbac-hierarchy-2.svg "RBAC hierarchy with a rule")
 
 
 ### Access Check <span id="access-check"></span>
 
 The check is done similar to how it was done in the first section of this guide:
 
 ```php
 namespace App\Blog\Post;
@@ -399,11 +399,11 @@
 
 The difference is that now checking for user's own post is part of the RBAC.
 
 If the current user is Jane with `ID=1` we are starting at `createPost` and trying to get to `Jane`:
 
 ![Access check](img/rbac-access-check-1.svg "Access check")
 
 In order to check if a user can update a post, we need to pass an extra parameter that is required by `AuthorRule` described before:
 
 ```php
 if ($user->can('updatePost', ['post' => $post])) {
@@ -416,17 +416,17 @@
 
 ![Access check](img/rbac-access-check-2.svg "Access check")
 
 We are starting with the `updatePost` and going through `updateOwnPost`. In order to pass the access check, `AuthorRule`
 should return `true` from its `execute()` method. The method receives its `$params` from the `can()` method call, so the value is
 `['post' => $post]`. If everything is fine, we will get to `author` which is assigned to John.
 
 In case of Jane it is a bit simpler since she is an admin:
 
 ![Access check](img/rbac-access-check-3.svg "Access check")
 
 ## Implementing your own access checker
 
 In case RBAC does not suit your needs, you can implement your own access checker without changing application code:
 
 
 ```php

guide/es/security/best-practices.md

@@ -1,13 +1,13 @@
 # Security best practices
 
 Below we'll review common security principles and describe how to avoid threats when developing applications using Yii.
 Most of these principles are not unique to Yii alone but apply to website or software development in general,
 so you will also find links for further reading on the general ideas behind these.
 
 
 ## Basic principles
 
 There are two main principles when it comes to security no matter which application is being developed:
 
 1. Filter input.
 2. Escape output.
@@ -15,9 +15,9 @@
 
 ### Filter input
 
 Filter input means that input should never be considered safe, and you should always check if the value you've got is
 actually among allowed ones. For example, if we know that sorting could be done by three fields `title`, `created_at` and `status`
 and the field could be supplied via user input, it's better to check the value we've got right where we're receiving it.
 In terms of basic PHP that would look like the following:
 
 ```php
@@ -37,7 +37,7 @@
 
 ### Escape output
 
 Escape output means that depending on context where we're using data it should be escaped i.e. in context of HTML you
 should escape `<`, `>` and alike special characters. In context of JavaScript or SQL it will be different set of characters.
 Since it's error-prone to escape everything manually Yii provides various tools to perform escaping for different
 contexts.
@@ -49,9 +49,9 @@
 - <https://www.owasp.org/index.php/Cross-site_Scripting_%28XSS%29>
 
 
 ## Avoiding SQL injections
 
 SQL injection happens when query text is formed by concatenating unescaped strings such as the following:
 
 ```php
 $username = $_GET['username'];
@@ -65,13 +65,13 @@
 SELECT * FROM user WHERE username = ''; DROP TABLE user; --'
 ```
 
 This is a valid query that will search for users with empty username and then will drop `user` table most probably
 resulting in a broken website and data loss (you've set up regular backups, right?).
 
 Make sure to either use PDO prepared statements directly or ensure that library you prefer is doing it. 
 In case of prepared statements it's not possible to manipulate the query as was demonstrated above.
 
 If data is used to specify column names or table names the best thing to do is to allow only predefined set of values:
 
 ```php
 function actionList($orderBy = null)
@@ -89,18 +89,18 @@
 - <https://www.owasp.org/index.php/SQL_Injection>
 
 
 ## Avoiding XSS
 
 XSS or cross-site scripting happens when output isn't escaped properly when outputting HTML to the browser. For example,
 if user can enter his name and instead of `Alexander` he enters `<script>alert('Hello!');</script>`, every page that
 outputs user name without escaping it will execute JavaScript `alert('Hello!');` resulting in alert box popping up
 in a browser. Depending on website instead of innocent alert such script could send messages using your name or even
 perform bank transactions.
 
 Avoiding XSS is quite easy in Yii. There are generally two cases:
 
 1. You want data to be outputted as plain text.
 2. You want data to be outputted as HTML.
 
 If all you need is plain text then escaping is as easy as the following:
 
@@ -109,42 +109,42 @@
 <?= \Yiisoft\Html\Html::encode($username) ?>
 ```
 
-If it should be HTML we could get some help from [HtmlPurifier](http://htmlpurifier.org/).
+If it should be HTML we could get some help from [HtmlPurifier](https://htmlpurifier.org/).
 Note that HtmlPurifier processing is quite heavy so consider adding caching.
 
 Further reading on the topic:
 
 - <https://www.owasp.org/index.php/Cross-site_Scripting_%28XSS%29>
 
 
 ## Avoiding CSRF
 
 CSRF is an abbreviation for cross-site request forgery. The idea is that many applications assume that requests coming
 from a user browser are made by the user themselves. This assumption could be false.
 
 For example, the website `an.example.com` has a `/logout` URL that, when accessed using a simple GET request, logs the user out. As long
 as it's requested by the user themselves everything is OK, but one day bad guys are somehow posting
 `<img src="http://an.example.com/logout">` on a forum the user visits frequently. The browser doesn't make any difference between
 requesting an image or requesting a page so when the user opens a page with such a manipulated `<img>` tag,
 the browser will send the GET request to that URL and the user will be logged out from `an.example.com`.
 
 That's the basic idea of how a CSRF attack works. One can say that logging out a user is not a serious thing,
 however this was just an example, there are much more things one could do using this approach, for example triggering payments
 or changing data. Imagine that some website has an URL
 `http://an.example.com/purse/transfer?to=anotherUser&amount=2000`. Accessing it using GET request, causes transfer of $2000
 from authorized user account to user `anotherUser`. We know, that the browser will always send GET request to load an image,
 so we can modify code to accept only POST requests on that URL. Unfortunately, this will not save us, because an attacker
 can put some JavaScript code instead of `<img>` tag, which allows to send POST requests to that URL as well.
 
 For this reason, Yii applies additional mechanisms to protect against CSRF attacks.
 
 In order to avoid CSRF you should always:
 
 1. Follow HTTP specification i.e. GET should not change application state.
    See [RFC2616](https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html) for more details.
 2. Keep Yii CSRF protection enabled.
 
 In Yii CSRF protection is implemented as `Yiisoft\Yii\Web\Middleware\Csrf` middleware. Ensure it is in your application
 middleware stack.
 
 Further reading on the topic:
@@ -155,24 +155,24 @@
 
 ## Avoiding file exposure
 
 By default, server webroot is meant to be pointed to `public` directory where `index.php` is. In case of shared hosting
 environments it could be impossible to achieve, so we'll end up with all the code, configs and logs in server webroot.
 
 If it's the case don't forget to deny access to everything except `web`. If it can't be done consider hosting your
 application elsewhere.
 
 
 ## Avoiding debug info and tools in production
 
 In debug mode Yii shows quite verbose errors which are certainly helpful for development. The thing is that these
 verbose errors are handy for attacker as well since these could reveal database structure, configuration values and
 parts of your code.
 
 Never run production applications with debugger or Gii accessible to everyone. It could be used to get information
 about database structure, code and to simply rewrite code with what's generated by Gii.
 
 Debug toolbar should be avoided at production unless really necessary. It exposes all the application and config
 details possible. If you absolutely need it check twice that access is properly restricted to your IP only.
 
 Further reading on the topic:
 
@@ -180,27 +180,27 @@
 - <https://www.owasp.org/index.php/Top_10_2007-Information_Leakage>
 
 
 ## Using secure connection over TLS
 
 Yii provides features that rely on cookies and/or PHP sessions. These can be vulnerable in case your connection is
 compromised. The risk is reduced if the app uses secure connection via TLS (often referred to as [SSL](https://en.wikipedia.org/wiki/Transport_Layer_Security)).
 
 Nowadays, anyone could get a certificate for free and automatically update it thanks to [Let's Encrypt](https://letsencrypt.org/).
 
 ## Secure Server configuration
 
 The purpose of this section is to highlight risks that need to be considered when creating a
 server configuration for serving a Yii based website. Besides the points covered here there may
 be other security related configuration options to be considered, so do not consider this section to
 be complete.
 
 ### Avoiding `Host`-header attacks
 
 If the webserver is configured to serve the same site independent of the value of the `Host` header, this information may
 not be reliable and [may be faked by the user sending the HTTP request](https://www.acunetix.com/vulnerabilities/web/host-header-attack).
 In such situations you should fix your webserver configuration to serve the site only for specified host names.
 
 For more information about the server configuration, please refer to the documentation of your webserver:
 
-- Apache 2: <http://httpd.apache.org/docs/trunk/vhosts/examples.html#defaultallports>
+- Apache 2: <https://httpd.apache.org/docs/trunk/vhosts/examples.html#defaultallports>
 - Nginx: <https://www.nginx.com/resources/wiki/start/topics/examples/server_blocks/>

guide/es/start/hello.md

@@ -1,4 +1,4 @@
 # Saying Hello
 
 > Note: This document reflects current configuration. Yii team is going to make it significantly simpler before release.
 
@@ -16,11 +16,11 @@
 3. how an application dispatches requests to [handlers](../structure/handler.md).
 
 
 ## Creating a Handler <span id="creating-handler"></span>
 
 For the "Hello" task, you will create a `Hello` class with `say` method that reads
 a `message` parameter from the request and displays that message back to the user. If the request
 does not provide a `message` parameter, the action will display the default "Hello" message.
 
 Create `src/Controller/Hello.php`:
 
@@ -53,19 +53,19 @@
 }
 ```
 
 The `say` method in our example is given `$request` parameter that we can use to obtain
 message, whose value defaults to `"Hello"` (in 
 the same way you set a default value for any function or method argument in PHP). When the application
 receives a request and determines that the `say` action is responsible for handling said request, the application will
 populate this parameter with the same named parameter found in the request. In other words, if the request includes
 a `message` parameter with a value of `"Goodbye"`, the `$message` variable within the action will be assigned that value.
 
 The response returned goes through [middleware stack](../structure/middleware.md) and then is outputted to end user
 via emitter.
 
 ## Configuring router
 
 Now to map our handler to URL we need to configure router. We will use a factory
 to create the configured router. Create `src/Factory/AppRouterFactory`:
 
 ```php
@@ -97,10 +97,10 @@
 }
 ```
 
 In the above we are using FastRoute as routing engine and configuring two routes. For each route
 a "controller" `Hello` will be created and its "action" method `say` will be invoked. 
 
 The factory class should be used in the DI container to define router instance. To do that edit `config/web.php` by adding:
 
 ```php
 use Yiisoft\Router\FastRoute\UrlGenerator;
@@ -121,20 +121,20 @@
 
 ## Trying it out <span id="trying-it-out"></span>
 
 After creating the action and the view, start a web server with `./yii serve` and follow the following URL:
 
 ```
 http://localhost:8080/say/Hello+World
 ```
 
 This URL will result in a page displaying "The message is: Hello World".
 
 If you omit the `message` parameter in the URL, you would see the page display "The message is: Hello!".
 
 ## Creating a View Template <span id="creating-view-template"></span>
 
 Usually the task is more complicated than printing out hello world and involves rendering some complex
 HTML. For this task it is handy to use [views templates](structure/view.md). They are scripts you
 write to generate a response's body.
 
 For the "Hello" task, you will create a `/views/say/say.php` view that prints the `message` parameter received from the action method:
@@ -146,15 +146,15 @@
 <?= Html::encode($message) ?>
 ```
 
 Note that in the above code, the `message` parameter is HTML-encoded
 before being printed. This is necessary as the parameter comes from an end user, making it vulnerable to
-[cross-site scripting (XSS) attacks](http://en.wikipedia.org/wiki/Cross-site_scripting) by embedding
+[cross-site scripting (XSS) attacks](https://en.wikipedia.org/wiki/Cross-site_scripting) by embedding
 malicious JavaScript code in the parameter.
 
 Naturally, you may put more content in the `say` view. The content can consist of HTML tags, plain text, and even
 PHP statements. In fact, the `say` view is a PHP script that is executed by the view service.
 
 To use the view we need to modify `src/Controller/Hello.php`:
 
 ```php
 <?php
@@ -205,10 +205,10 @@
 }
 ```
 
 Here we're using `ViewContextInterface` tell a `view` service where to get templates. Producing response from a
 template and parameters is done with `render()` method.
 
 Sine we've used aliases, we have to configure them in DI container:
 
 ```php
 use Yiisoft\Aliases\Aliases;
@@ -230,7 +230,7 @@
 
 In this section, you have touched the handler and view parts of the typical web application.
 You created a handler as part of a class to handle a specific request. And you also created a view
 to compose the response's content. In this simple example, no data source was involved as the only data used was the `message` parameter.
 
 You have also learned about routing in Yii, which act as the bridge between user requests and handlers.
 

guide/es/start/installation.md

@@ -1,14 +1,14 @@
 # Installing Yii
 
 You can install Yii using the [Composer](https://getcomposer.org) package manager.
 
 Standard installations of Yii result in both the framework packages and a project template being downloaded and installed.
 A project template is a working Yii project implementing some basic features, such as login, contact form, etc.
 Its code is organized in a recommended way. Therefore, it can serve as a good starting point for your projects.
 
 ## Installing Composer
 
 If you do not already have Composer installed, you may do so by following the instructions at
 [getcomposer.org](https://getcomposer.org/download/). On Linux and Mac OS X, you'll run the following commands:
 
 ```bash
@@ -20,17 +20,17 @@
 
 Please refer to the [Troubleshooting section of the Composer Documentation](https://getcomposer.org/doc/articles/troubleshooting.md)
 if you encounter any problems.
 If you are new to Composer, we also recommend reading at least the [Basic usage section](https://getcomposer.org/doc/01-basic-usage.md)
 of the Composer documentation.
 
 In this guide, all composer commands assume you have installed composer [globally](https://getcomposer.org/doc/00-intro.md#globally)
 so that it is available as the `composer` command. If you are using the `composer.phar` in the local directory instead,
 you have to adjust the example commands accordingly.
 
 If you had Composer already installed before, make sure you use an up to date version. You can update Composer
 by running `composer self-update`.
 
 ## Installing Yii <span id="installing-from-composer"></span>
 
 With Composer installed, you can install Yii application template by running the following command
 under a Web-accessible folder:
@@ -49,21 +49,21 @@
 > composer create-project --stability=dev yiisoft/yii-demo app
 > ```
 >
 > Note that the development version of Yii should not be used for production as it may break your running code.
 
 ## Using individual packages
 
 Many Yii packages could be used separately from the framework via Composer. Framework-specific ones
 are prefixed with `yii-`.
 
 ## Installing Assets <span id="installing-assets"></span>
 
 ...
 
 
 ## Verifying the Installation <span id="verifying-installation"></span>
 
 After installation is done, either configure your web server (see next section) or use the
 [built-in PHP web server](https://secure.php.net/manual/en/features.commandline.webserver.php) by running the following
 console command while in the project `public` directory:
 
@@ -78,7 +78,7 @@
 ../vendor/bin/yii serve --port=8888
 ```
 
 You can use your browser to access the installed Yii application with the following URL:
 
 ```
 http://localhost:8080/
@@ -86,29 +86,29 @@
 
 ![Successful Installation of Yii](images/start-app-installed.png)
 
 You should see the above "Congratulations!" page in your browser.
 
 
 ## Configuring Web Servers <span id="configuring-web-servers"></span>
 
 > Info: You may skip this subsection for now if you are just test-driving Yii with no intention
   of deploying it to a production server.
 
 The application installed according to the above instructions should work out of the box with either
-an [Apache HTTP server](http://httpd.apache.org/) or an [Nginx HTTP server](http://nginx.org/), on
+an [Apache HTTP server](https://httpd.apache.org/) or an [Nginx HTTP server](https://nginx.org/), on
 Windows, Mac OS X, or Linux running PHP 7.2 or higher.
 
 On a production server, you may want to configure your Web server so that the application can be accessed
 via the URL `http://www.example.com/index.php` instead of `http://www.example.com/app/public/index.php`. Such configuration
 requires pointing the document root of your Web server to the `app/public` folder. You may also
 want to hide `index.php` from the URL, as described in the [Routing and URL Creation](runtime-routing.md) section.
 In this subsection, you'll learn how to configure your Apache or Nginx server to achieve these goals.
 
 > Info: By setting `app/public` as the document root, you also prevent end users from accessing
 your private application code and sensitive data files that are stored in the sibling directories
 of `app/public`. Denying access to those other folders is a security improvement.
 
 > Info: If your application will run in a shared hosting environment where you do not have permission
 to modify its Web server configuration, you may still adjust the structure of your application for better security. Please refer to
 the [Shared Hosting Environment](tutorial-shared-hosting.md) section for more details.
 
@@ -164,7 +164,7 @@
 
 ### Nginx <span id="nginx"></span>
 
-To use [Nginx](http://wiki.nginx.org/), you should install PHP as an [FPM SAPI](https://secure.php.net/install.fpm).
+To use [Nginx](https://wiki.nginx.org/), you should install PHP as an [FPM SAPI](https://secure.php.net/install.fpm).
 You may use the following Nginx configuration, replacing `path/to/app/public` with the actual path for 
 `app/public` and `mysite.test` with the actual hostname to serve.
 
@@ -217,11 +217,11 @@
 to avoid many unnecessary system `stat()` calls.
 
 Also note that when running an HTTPS server, you need to add `fastcgi_param HTTPS on;` so that Yii
 can properly detect if a connection is secure.
 
 ### IIS <span id="iss"></span>
 
 To use [IIS](https://www.iis.net/), put `Web.config` and `index.php` to public accessible directory. The following
 configuration goes to `Web.config`:
 
 ```xml
@@ -245,9 +245,9 @@
 ```
 
 
 ### lighttpd <span id="lighttpd"></span>
 
-To use [lighttpd](http://www.lighttpd.net/) >= 1.4.24 put `index.php` to webroot and add the following to configuration:
+To use [lighttpd](https://www.lighttpd.net/) >= 1.4.24 put `index.php` to webroot and add the following to configuration:
 
 ```
 url.rewrite-if-not-file = ("(.*)" => "/index.php/$0")

guide/es/structure/package.md

@@ -1,6 +1,6 @@
 # Packages
 
 Reusable code could be released as [Composer package](https://getcomposer.org/doc/05-repositories.md#package).
 It could be an infrastructure library, a module representing one of the application contexts or, basically, any
 reusable code.
 
@@ -11,18 +11,18 @@
 [create your own repository](https://getcomposer.org/doc/05-repositories.md#repository) and configure Composer
 to use it. This is useful if you are developing private packages that you want to share within your projects only.
 
 Packages installed by Composer are stored in the `vendor` directory of your project. 
 Because Composer is a dependency manager, when it installs a package, it will also install all its dependent packages.
 
 > Warning: `vendor` directory of your application should never be modified.
 
 A package could be installed with the following command:
 
 ```
 composer install vendor-name/package-name
 ```
 
 After it is done, Composer modifies `composer.json` and `composer.lock`. The former defines what packages to install,
 and their version constraints the later stores a snapshot of exact versions actually installed.
 
 Classes from the package will be available immediately via [autoloading](../concept/autoloading.md).
@@ -35,8 +35,8 @@
 
 Below are the basic steps you may follow.
 
 1. Create a project for your package and host it on a VCS repository, such as [github.com](https://github.com).
    The development and maintenance work for the package should be done on this repository.
 2. Under the root directory of the project, create a file named `composer.json` as required by Composer. Please
    refer to the next subsection for more details.
 3. Register your package with a Composer repository, such as [Packagist](https://packagist.org/), so that
@@ -107,27 +107,27 @@
 ```
 
 
 #### Package Name <span id="package-name"></span>
 
 Each Composer package should have a package name which uniquely identifies the package among all others.
 The format of package names is `vendorName/projectName`. For example, in the package name `yiisoft/queue`,
 the vendor name and the project name are `yiisoft` and `queue`, respectively.
 
 > Warning: Do NOT use `yiisoft` as your vendor name as it is reserved for use by the Yii itself.
 
 We recommend you prefix `yii-` to the project name for packages that are not able to work as general PHP
 packages and require Yii application. This will allow users to more easily tell whether a package is Yii specific.
 
 
 #### Dependencies <span id="dependencies"></span>
 
 If your extension depends on other packages, you should list them in `require` section of `composer.json`.
 Make sure you also list appropriate version constraints (e.g. `^1.0`, `@stable`) for each dependent package.
 Use stable dependencies when your extension released in a stable version.
 
 #### Class Autoloading <span id="class-autoloading"></span>
 
 In order for your classes to be autoloaded, you should specify the `autoload` entry in the `composer.json` file,
 like shown below:
 
 ```json
@@ -144,10 +144,10 @@
 
 You may list one or multiple root namespaces and their corresponding file paths.
 
 ### Recommended Practices <span id="recommended-practices"></span>
 
 Because packages are meant to be used by other people, you often need to make an extra effort during development.
 Below we introduce some common and recommended practices in creating high quality extensions.
 
 
 #### Testing <span id="testing"></span>
@@ -155,36 +155,36 @@
 You want your package to run flawlessly without bringing problems to other people. To reach this goal, you should
 test your extension before releasing it to public.
 
 It is recommended that you create various test cases to cover your extension code rather than relying on manual tests.
 Each time before you release a new version of your package, you may run these test cases to make sure
 everything is in good shape. For more details, please refer to the [Testing](../testing/overview.md) section.
 
 
 #### Versioning <span id="versioning"></span>
 
 You should give each release of your extension a version number (e.g. `1.0.1`). We recommend you follow the
-[semantic versioning](http://semver.org) practice when determining what version numbers should be used.
+[semantic versioning](https://semver.org) practice when determining what version numbers should be used.
 
 
 #### Releasing <span id="releasing"></span>
 
 To let other people know about your package, you need to release it to the public.
 
 If it is the first time you are releasing a package, you should register it on a Composer repository, such as
 [Packagist](https://packagist.org/). After that, all you need to do is simply create a release tag (e.g. `v1.0.1`)
 on the VCS repository of your extension and notify the Composer repository about the new release. People will
 then be able to find the new release, and install or update the package through the Composer repository.
 
 In the releases of your package, in addition to code files, you should also consider including the following to
 help other people learn about and use your extension:
 
 * A readme file in the package root directory: it describes what your extension does and how to install and use it.
-  We recommend you write it in [Markdown](http://daringfireball.net/projects/markdown/) format and name the file
+  We recommend you write it in [Markdown](https://daringfireball.net/projects/markdown/) format and name the file
   as `README.md`.
 * A changelog file in the package root directory: it lists what changes are made in each release. The file
   may be written in Markdown format and named as `CHANGELOG.md`.
 * An upgrade file in the package root directory: it gives the instructions on how to upgrade from older releases
   of the extension. The file may be written in Markdown format and named as `UPGRADE.md`.
 * Tutorials, demos, screenshots, etc.: these are needed if your extension provides many features that cannot be
   fully covered in the readme file.
 * API documentation: your code should be well documented to allow other people to more easily read and understand it.

guide/es/tutorial/performance-tuning.md

@@ -1,11 +1,11 @@
 # Performance Tuning
 
 There are many factors affecting the performance of your application. Some are environmental, some are related 
 with your code, while some others are related with Yii itself. In this section, we will enumerate most of these
 factors and explain how you can improve your application performance by adjusting these factors.
 
 
 ## Optimizing your PHP Environment <span id="optimizing-php"></span>
 
 A well configured PHP environment is important. To get maximum performance,
 
@@ -13,26 +13,26 @@
 - Enable bytecode caching with [Opcache](https://secure.php.net/opcache). 
   Bytecode caching avoids the time spent in parsing and including PHP scripts for every incoming request.
 - [Tune `realpath()` cache](https://github.com/samdark/realpath_cache_tuner).
 - Make sure [XDebug](https://xdebug.org/) is not installed in production environment.
 - Try [PHP 7 preloading](https://wiki.php.net/rfc/preload).
 
 ## Using Caching Techniques <span id="using-caching"></span>
 
 You can use various caching techniques to significantly improve the performance of your application. For example,
 if your application allows users to enter text in Markdown format, you may consider caching the parsed Markdown
 content to avoid parsing the same Markdown text repeatedly in every request. Please refer to 
 the [Caching](caching/overview.md) section to learn about the caching support provided by Yii.
 
 
 ## Optimizing Session Storage <span id="optimizing-session"></span>
 
 By default, session data are stored in files. The implementation is locking a file from opening a session to the point it's
 closed either by `$session->close()` or at the end of request.
 While session file is locked all other requests, which are trying to use the same session are blocked i.e. waiting for the
 initial request to release session file. This is fine for development and probably small projects. But when it comes 
 to handling massive concurrent requests, it is better to use more sophisticated storage, such as Redis.
 
 It could be done either by [configuring PHP via php.ini](https://www.digitalocean.com/community/tutorials/how-to-set-up-a-redis-server-as-a-session-handler-for-php-on-ubuntu-14-04)
 or [implementing SessionHandlerInterface](https://www.sitepoint.com/saving-php-sessions-in-redis/) and configuring
 session service as follows:
 
@@ -43,26 +43,26 @@
 ],
 ```
 
 ## Optimizing Databases <span id="optimizing-databases"></span>
 
 Executing DB queries and fetching data from databases are often the main performance bottleneck in
 a Web application. Although using [data caching](caching/data.md) techniques may alleviate the performance hit,
 it does not fully solve the problem. When the database contains enormous amounts of data and the cached data is invalid, 
 fetching the latest data could be prohibitively expensive without proper database and query design.
 
 A general technique to improve the performance of DB queries is to create indices for table columns that
 need to be filtered by. For example, if you need to look for a user record by `username`, you should create an index
 on `username`. Note that while indexing can make SELECT queries much faster, it will slow down INSERT, UPDATE and DELETE queries.
 
 For complex DB queries, it is recommended that you create database views to save the query parsing and preparation time.
 
 Last but not least, use `LIMIT` in your `SELECT` queries. This avoids fetching an overwhelming amount of data from the database
 and exhausting the memory allocated to PHP.
 
 
 ## Optimizing Composer Autoloader <span id="optimizing-autoloader"></span>
 
 Because Composer autoloader is used to include most third-party class files, you should consider optimizing it
 by executing the following command:
 
 ```
@@ -75,7 +75,7 @@
 Note that both optimizations may or may not be suitable for your particular case.
 
 
 ## Processing Data Offline <span id="processing-data-offline"></span>
 
 When a request involves some resource intensive operations, you should think of ways to perform those operations
 in offline mode without having users wait for them to finish.
@@ -85,14 +85,14 @@
 In the pull method, whenever a request involves some complex operation, you create a task and save it in a persistent 
 storage, such as database. You then use a separate process (such as a cron job) to pull the tasks and process them.
 This method is easy to implement, but it has some drawbacks. For example, the task process needs to periodically pull
 from the task storage. If the pull frequency is too low, the tasks may be processed with great delay, but if the frequency
 is too high, it will introduce high overhead.
 
 In the push method, you would use a message queue (e.g. RabbitMQ, ActiveMQ, Amazon SQS, etc.) to manage the tasks. 
 Whenever a new task is put on the queue, it will initiate or notify the task handling process to trigger the task processing.
 
 
 ## Performance Profiling <span id="performance-profiling"></span>
 
 You should profile your code to find out the performance bottlenecks and take appropriate measures accordingly.
 The following profiling tools may be useful:
@@ -100,4 +100,4 @@
 - [Yii debug toolbar and debugger](https://github.com/yiisoft/yii2-debug/blob/master/docs/guide/README.md)
 - [Blackfire](https://blackfire.io/)
 - [XHProf](https://secure.php.net/manual/en/book.xhprof.php)
-- [XDebug profiler](http://xdebug.org/docs/profiler)
+- [XDebug profiler](https://xdebug.org/docs/profiler)

guide/id/README.md

@@ -1,6 +1,6 @@
 # Panduan Definitif untuk Yii 3.0
 
-Panduan ini dirilis di bawah [Ketentuan Dokumentasi Yii](http://www.yiiframework.com/doc/terms/).
+Panduan ini dirilis di bawah [Ketentuan Dokumentasi Yii](https://www.yiiframework.com/doc/terms/).
 
 Pengenalan +
 ------------