Unicode.pod - Working with unicode

       In this tutorial, we're assuming that all encodings are UTF-8. It's relatively simple to combine
       different encodings from different sources, but that's beyond the scope of this tutorial.

       For simplicity, we're also going to assume that you're using Catalyst for your web-framework, DBIx::Class
       for your database ORM, TT for your templating system, and YAML format "HTML::FormFu" configuration files,
       with YAML::XS installed. However, the principles we'll cover should translate to whatever technologies
       you chose to work with.

       Carl Franks <cpan@fireartist.com>

       Carl Franks "cfranks@cpan.org" Michele Beltrame "arthas@cpan.org" (contributions)

       To make it short and sweet: you must decode all data going into your program, and encode all data coming
       from your program.

       Skip to "CHANGES REQUIRED" if you want to see what you need to do without any other explanation.

CatalystConfiguration
       Add Catalyst::Plugin::Unicode to the list of Catalyst plugins:

           use Catalyst qw( ConfigLoader Static::Simple Unicode );

   DBIx::ClassConfiguration
       Add DBIx::Class::UTF8Columns to the list of components loaded, for each table that has columns storing
       unicode:

           __PACKAGE__->load_components( qw( UTF8Columns HTML::FormFu PK::Auto Core ) );

       Pass each column name that will store unicode to utf8_columns():

           __PACKAGE__->utf8_columns( qw( lastname firstname ) );

   TTConfiguration
       Tell TT to decode all template files, by adding the following to your application config in MyApp.pm

           package MyApp;
               use parent 'Catalyst';
           use Catalyst qw( ConfigLoader );

           MyApp->config({
               'View::TT' => {
                   ENCODING => 'UTF-8',
               },
           });

           1;

   HTML::FormFuTemplateConfiguration
       Make "HTML::FormFu" tell TT to decode all template files, by adding the following to your "myapp.yml"
       Catalyst configuration file:

           package MyApp;
               use parent 'Catalyst';
           use Catalyst qw( ConfigLoader );

           MyApp->config({
               'Controller::HTML::FormFu' => {
                   constructor => {
                       tt_args => {
                           ENCODING => 'UTF-8',
                       },
                   },
               },
           });

           1;

       These above 2 examples should be combined, like so:

           package MyApp;
               use parent 'Catalyst';
           use Catalyst qw( ConfigLoader );

           MyApp->config({
               'Controller::HTML::FormFu' => {
                   constructor => {
                       tt_args => {
                           ENCODING => 'UTF-8',
                       },
                   },
               },
               'View::TT' => {
                   ENCODING => 'UTF-8',
               },
           });

           1;

       This document is free, you can redistribute it and/or modify it under the same terms as Perl itself.

       This software is copyright (c) 2018 by Carl Franks.

       This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5
       programming language system itself.

perl v5.38.2                                       2024-04-10                 HTML::FormFu::Manual::Unicode(3pm)

       Working with unicode.

       For a practical example, see the Catalyst application in the "examples/unicode" directory in this
       distribution.

Inputparametersfromthebrowser
       If you're using "Catalyst", Catalyst::Plugin::Unicode will decode all input parameters sent from the
       browser to your application - see "Catalyst Configuration".

       If you're using some other framework or, in any case, you need to decode the input parameters yourself,
       please take a look at HTML::FormFu::Filter::Encode.

   Datafromthedatabase
       If you're using DBIx::Class, DBIx::Class::UTF8Columns is likely the best options, as it will decode all
       input retrieved from the database - see "DBIx::Class Configuration".

       In other cases (i.e. plain DBI), you still need to decode the string data coming from the database. This
       varies depending on the database server.  For MySQL, for instance, you can use the "mysql_enable_utf8"
       attribute: see DBD::mysql documentation for details.

   Yourtemplatefiles
       Set TT to decode all template files - see "TT Configuration".

   HTML::FormFu'sowntemplatefiles
       Set "HTML::FormFu" to decode all template files - see "HTML::FormFu Template Configuration".

   HTML::FormFuformconfigurationfiles
       If you're using "YAML" config files, your files will automatically be decoded by
       "load_config_file|HTML::FormFu/load_config_file" and
       "load_config_filestem|HTML::FormFu/load_config_filestem".

       If you have Config::General config files, your files will automatically be decoded by
       "load_config_file|HTML::FormFu/load_config_file" and
       "load_config_filestem|HTML::FormFu/load_config_filestem", which automatically sets Config::General's
       "-UTF8" setting.

   Yourperlsourcecode
       Any perl source files which contain Unicode characters must use the utf8 module.

       Unicode.pod - Working with unicode

Datasavedtothedatabase
       With "DBIx::Class", DBIx::Class::UTF8Columns will encode all data sent to the database - see "DBIx::Class
       Configuration".

   HTMLsenttothebrowser
       With "Catalyst", Catalyst::Plugin::Unicode will encode all output sent from your application to the
       browser - see "Catalyst Configuration".

       In other circumstances you need to be sure to output your Unicode (decoded) strings in UTF-8. To do this
       you can encode your output before it's sent to the browser with something like:

           use utf8;
           if ( $output && utf8::is_utf8($output) ){
               utf8::encode( $output ); # Encodes in-place
           }

       Another option is to set the "binmode" for "STDOUT":

           bindmode STDOUT, ':utf8';

       However, be sure to do this only when sending UTF-8 data: if you're serving images, PFD files, etc,
       "binmode" should remain set to ":raw".

       version 2.07