repo_zf1/documentation/manual/pt-br/tutorials/quickstart-create-project.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 24249 -->
<!-- Reviewed: no -->
<sect1 id="learning.quickstart.create-project">
    <title>Crie Seu Projeto</title>

    <para>
        Para criar seu projeto, você primeiro deve baixar e extrair o Zend Framework.
    </para>

    <sect2 id="learning.quickstart.create-project.install-zf">
        <title>Instale o Zend Framework</title>

        <para>
            A maneira mais fácil de obter o Zend Framework junto com uma pilha
            <acronym>PHP</acronym> completa é através da instalação do <ulink
                url="http://www.zend.com/en/products/server-ce/downloads">Zend Server</ulink>. O
            Zend Server tem instaladores nativos para Mac OSX, Windows, Fedora Core e Ubuntu, bem
            como um pacote de instalação universal compatível com a maioria das distribuições Linux.
        </para>

        <para>
            Depois que você tiver instalado o Zend Server, os arquivos Framework podem ser
            encontrados em <filename>/usr/local/zend/share/ZendFramework</filename> no Mac OSX e
            Linux, e em <filename>C:\Program Files\Zend\ZendServer\share\ZendFramework</filename> no
            Windows. O <constant>include_path</constant> já estará configurado para incluir o Zend
            Framework.
        </para>

        <para>
            Alternadamente, você pode fazer o <ulink
                url="http://framework.zend.com/download/latest">Download da última versão do Zend
                Framework</ulink> e extrair os conteúdos; faça nota de onde você fez isso.
        </para>

        <para>
            Opcionalmente, você pode adicionar o caminho do arquivo para o subdiretório
            <filename>library/</filename> para a configuração <constant>include_path</constant> do
            seu <filename>php.ini</filename>.
        </para>

        <para>
            É isso! O Zend Framework agora está instalado e pronto para uso.
        </para>
    </sect2>

    <sect2 id="learning.quickstart.create-project.create-project">
        <title>Crie seu Projeto</title>

        <note>
            <title>Ferramenta de Linha de Comando zf</title>

            <para>
                Na instalação do Zend Framework tem um subdiretório <filename>bin/</filename>,
                contendo os scripts <filename>zf.sh</filename> e <filename>zf.bat</filename> para
                usuários baseados em Unix e Windows, respectivamente. Faça nota do caminho absoluto
                para este script.
            </para>

            <para>
                Onde quer que você veja referências para o comando <command>zf</command>, por favor
                substitua o caminho absoluto ao script. Nos sistemas baseados em Unix, você pode
                querer usar a funcionalidade de apelido do shell: <command>alias
                    zf.sh=path/to/ZendFramework/bin/zf.sh</command>.
            </para>

            <para>
                Se você tiver problemas em configurar a ferramenta de linha de comando
                <command>zf</command>, por favor dirija-se
                <link linkend="zend.tool.framework.clitool"> ao manual</link>.
            </para>
        </note>

        <para>
            Abra o terminal (no Windows, <command>Iniciar -> Executar</command>, e então use
            <command>cmd</command>). Vá até o diretório onde você gostaria de iniciar um projeto.
            Depois, use o caminho para o script apropriado, e execute um dos seguintes:
        </para>

        <programlisting language="shell"><![CDATA[
% zf create project quickstart
]]></programlisting>

        <para>
            Executando este comando, será criada a estrutura básica do seu site, incluindo seus
            controladores e visualizações iniciais. A árvore parece com o seguinte:
        </para>

        <programlisting language="text"><![CDATA[
quickstart
|-- application
|   |-- Bootstrap.php
|   |-- configs
|   |   `-- application.ini
|   |-- controllers
|   |   |-- ErrorController.php
|   |   `-- IndexController.php
|   |-- models
|   `-- views
|       |-- helpers
|       `-- scripts
|           |-- error
|           |   `-- error.phtml
|           `-- index
|               `-- index.phtml
|-- library
|-- public
|   |-- .htaccess
|   `-- index.php
`-- tests
    |-- application
    |   `-- bootstrap.php
    |-- library
    |   `-- bootstrap.php
    `-- phpunit.xml
]]></programlisting>

        <para>
            Até este ponto, se você não adicionou o Zend Framework para o seu
            <constant>include_path</constant>, nós recomendamos também copiar ou criar um link
            simbólico em seu diretório <filename>library/</filename>. Em qualquer caso, você vai
            querer copiar recursivamente ou simbolizar o diretório
            <filename>library/Zend/</filename> da sua instalação Zend Framework no diretório
            <filename>library/</filename> do seu projeto. Nos sistemas baseados em Unix, que
            pareceriam como um dos seguintes:
        </para>

        <programlisting language="shell"><![CDATA[
# Symlink:
% cd library; ln -s path/to/ZendFramework/library/Zend .

# Copy:
% cd library; cp -r path/to/ZendFramework/library/Zend .
]]></programlisting>

        <para>
            Nos sistemas Windows, pode ser mais fácil fazer isso do Explorer.
        </para>

        <para>
            Agora que o projeto está criado, os artefatos principais para iniciar o entendimento
            são a inicialização da aplicação, configuração, controladores de ação e vizualizações.
        </para>
    </sect2>

    <sect2 id="learning.quickstart.create-project.bootstrap">
        <title>A Inicialização da Aplicação</title>

        <para>
            A classe <classname>Inicialização da Aplicação</classname> define quais recursos e
            componentes inicializar. Por padrão, o <link linkend="zend.controller.front">Controlador
                Frontal</link> do Zend Framework é inicializado, e ele usa o
            <filename>application/controllers/</filename> como diretório padrão o qual procura por
            controladores de ação (mais sobre isso mais tarde). A classe parece com o seguinte:
        </para>

        <programlisting language="php"><![CDATA[
// application/Bootstrap.php

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
}
]]></programlisting>

        <para>
            As you can see, not much is necessary to begin with.

            Como você pode ver, não é necessário muito para iniciar.
        </para>
    </sect2>

    <sect2 id="learning.quickstart.create-project.configuration">
        <title>Configuração</title>

        <para>
            Enquanto o Zend Framework é em si configuração, muitas vezes você precisa configurar
            sua aplicação. A configuração padrão está localizada em
            <filename>application/configs/application.ini</filename>, e contém algumas diretrizes
            básicas para configurar seu ambiente <acronym>PHP</acronym> (por exemplo, transformar
            relatório de erros dentro e fora), indicando o caminho para sua classe inicialização da
            aplicação (tão bem como sua classe nome), e o caminho para seus controladores de ação.
            Isso parece com o seguinte:
        </para>

        <programlisting language="ini"><![CDATA[
; application/configs/application.ini

[production]
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0
includePaths.library = APPLICATION_PATH "/../library"
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
appnamespace = "Application"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
resources.frontController.params.displayExceptions = 0

[staging : production]

[testing : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1
]]></programlisting>

        <para>
            Diversas coisas sobre este arquivo devem ser notadas. Primeiro, quando usar configuração
            de estilo <acronym>INI</acronym>, você pode referenciar constantes diretamente e
            expandi-las; <constant>APPLICATION_PATH</constant> é na verdade uma constante.
            Adicionalmente note que há várias seções definidas: produção, encenação, teste, e
            desenvolvimento. As últimas três herdam configurações do ambiente "produção". Este é um
            modo eficiente de organizar configurações para assegurar que as configurações
            apropriadas são válidas em cada estágio do desenvolvimento da aplicação.
        </para>
    </sect2>

    <sect2 id="learning.quickstart.create-project.action-controllers">
        <title>Action Controllers</title>

        <para>
            Your application's <emphasis>action controllers</emphasis> contain your application
            workflow, and do the work of mapping your requests to the appropriate models and views.
        </para>

        <para>
            An action controller should have one or more methods ending in "Action"; these methods
            may then be requested via the web. By default, Zend Framework URLs follow the schema
            <constant>/controller/action</constant>, where "controller" maps to the action
            controller name (minus the "Controller" suffix) and "action" maps to an action method
            (minus the "Action" suffix).
        </para>

        <para>
            Typically, you always need an <classname>IndexController</classname>, which is a
            fallback controller and which also serves the home page of the site, and an
            <classname>ErrorController</classname>, which is used to indicate things such as
            <acronym>HTTP</acronym> 404 errors (controller or action not found) and
            <acronym>HTTP</acronym> 500 errors (application errors).
        </para>

        <para>
            The default <classname>IndexController</classname> is as follows:
        </para>

        <programlisting language="php"><![CDATA[
// application/controllers/IndexController.php

class IndexController extends Zend_Controller_Action
{

    public function init()
    {
        /* Initialize action controller here */
    }

    public function indexAction()
    {
        // action body
    }
}
]]></programlisting>

        <para>
            And the default <classname>ErrorController</classname> is as follows:
        </para>

        <programlisting language="php"><![CDATA[
// application/controllers/ErrorController.php

class ErrorController extends Zend_Controller_Action
{

    public function errorAction()
    {
        $errors = $this->_getParam('error_handler');

        switch ($errors->type) {
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ROUTE:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:

                // 404 error -- controller or action not found
                $this->getResponse()->setHttpResponseCode(404);
                $this->view->message = 'Page not found';
                break;
            default:
                // application error
                $this->getResponse()->setHttpResponseCode(500);
                $this->view->message = 'Application error';
                break;
        }

        $this->view->exception = $errors->exception;
        $this->view->request   = $errors->request;
    }
}
]]></programlisting>

        <para>
            You'll note that (1) the <classname>IndexController</classname> contains no real code,
            and (2) the <classname>ErrorController</classname> makes reference to a "view" property.
            That leads nicely into our next subject.
        </para>
    </sect2>

    <sect2 id="learning.quickstart.create-project.views">
        <title>Views</title>

        <para>
            Views in Zend Framework are written in plain old <acronym>PHP</acronym>. View scripts
            are placed in <filename>application/views/scripts/</filename>, where they are further
            categorized using the controller names. In our case, we have an
            <classname>IndexController</classname> and an <classname>ErrorController</classname>,
            and thus we have corresponding <filename>index/</filename> and
            <filename>error/</filename> subdirectories within our view scripts directory. Within
            these subdirectories, you will then find and create view scripts that correspond to each
            controller action exposed; in the default case, we thus have the view scripts
            <filename>index/index.phtml</filename> and <filename>error/error.phtml</filename>.
        </para>

        <para>
            View scripts may contain any markup you want, and use the <emphasis>&lt;?php</emphasis>
            opening tag and <emphasis>?&gt;</emphasis> closing tag to insert <acronym>PHP</acronym>
            directives.
        </para>

        <para>
            The following is what we install by default for the
            <filename>index/index.phtml</filename> view script:
        </para>

        <programlisting language="php"><![CDATA[
<!-- application/views/scripts/index/index.phtml -->
<style>

    a:link,
    a:visited
    {
        color: #0398CA;
    }

    span#zf-name
    {
        color: #91BE3F;
    }

    div#welcome
    {
        color: #FFFFFF;
        background-image: url(http://framework.zend.com/images/bkg_header.jpg);
        width:  600px;
        height: 400px;
        border: 2px solid #444444;
        overflow: hidden;
        text-align: center;
    }

    div#more-information
    {
        background-image: url(http://framework.zend.com/images/bkg_body-bottom.gif);
        height: 100%;
    }

</style>
<div id="welcome">
    <h1>Welcome to the <span id="zf-name">Zend Framework!</span><h1 />
    <h3>This is your project's main page<h3 />
    <div id="more-information">
        <p>
            <img src="http://framework.zend.com/images/PoweredBy_ZF_4LightBG.png" />
        </p>

        <p>
            Helpful Links: <br />
            <a href="http://framework.zend.com/">Zend Framework Website</a> |
            <a href="http://framework.zend.com/manual/en/">Zend Framework
                Manual</a>
        </p>
    </div>
</div>
]]></programlisting>

        <para>
            The <filename>error/error.phtml</filename> view script is slightly more interesting as
            it uses some <acronym>PHP</acronym> conditionals:
        </para>

        <programlisting language="php"><![CDATA[
<!-- application/views/scripts/error/error.phtml -->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN";
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <title>Zend Framework Default Application</title>
</head>
<body>
  <h1>An error occurred</h1>
  <h2><?php echo $this->message ?></h2>

  <?php if ('development' == $this->env): ?>

  <h3>Exception information:</h3>
  <p>
      <b>Message:</b> <?php echo $this->exception->getMessage() ?>
  </p>

  <h3>Stack trace:</h3>
  <pre><?php echo $this->exception->getTraceAsString() ?>
  </pre>

  <h3>Request Parameters:</h3>
  <pre><?php echo var_export($this->request->getParams(), 1) ?>
  </pre>
  <?php endif ?>

</body>
</html>
]]></programlisting>
    </sect2>

    <sect2 id="learning.quickstart.create-project.vhost">
        <title>Create a virtual host</title>

        <para>
            For purposes of this quick start, we will assume you are using the <ulink
                url="http://httpd.apache.org/">Apache web server</ulink>. Zend Framework works
            perfectly well with other web servers -- including Microsoft Internet Information
            Server, lighttpd, nginx, and more -- but most developers should be famililar with Apache
            at the minimum, and it provides an easy introduction to Zend Framework's directory
            structure and rewrite capabilities.
        </para>

        <para>
            To create your vhost, you need to know the location of your
            <filename>httpd.conf</filename> file, and potentially where other configuration files
            are located. Some common locations:
        </para>

        <itemizedlist>
            <listitem>
                <para>
                    <filename>/etc/httpd/httpd.conf</filename> (Fedora, RHEL, and others)
                </para>
            </listitem>

            <listitem>
                <para>
                    <filename>/etc/apache2/httpd.conf</filename> (Debian, Ubuntu, and others)
                </para>
            </listitem>

            <listitem>
                <para>
                    <filename>/usr/local/zend/etc/httpd.conf</filename> (Zend Server on *nix
                    machines)
                </para>
            </listitem>

            <listitem>
                <para>
                    <filename>C:\Program Files\Zend\Apache2\conf</filename> (Zend Server on Windows
                    machines)
                </para>
            </listitem>
        </itemizedlist>

        <para>
            Within your <filename>httpd.conf</filename> (or <filename>httpd-vhosts.conf</filename>
            on some systems), you will need to do two things. First, ensure that the
            <varname>NameVirtualHost</varname> is defined; typically, you will set it to a value of
            "*:80". Second, define a virtual host:
        </para>

        <programlisting language="apache"><![CDATA[
<VirtualHost *:80>
    ServerName quickstart.local
    DocumentRoot /path/to/quickstart/public

    SetEnv APPLICATION_ENV "development"

    <Directory /path/to/quickstart/public>
        DirectoryIndex index.php
        AllowOverride All
        Order allow,deny
        Allow from all
    </Directory>
</VirtualHost>
]]></programlisting>

        <para>
            There are several things to note. First, note that the <varname>DocumentRoot</varname>
            setting specifies the <filename>public</filename> subdirectory of our project; this
            means that only files under that directory can ever be served directly by the server.
            Second, note the <varname>AllowOverride</varname>, <varname>Order</varname>, and
            <varname>Allow</varname> directives; these are to allow us to use
            <filename>htacess</filename> files within our project. During development, this is a
            good practice, as it prevents the need to constantly restart the web server as you make
            changes to your site directives; however, in production, you should likely push the
            content of your <filename>htaccess</filename> file into your server configuration and
            disable this. Third, note the <varname>SetEnv</varname> directive. What we are doing
            here is setting an environment variable for your virtual host; this variable will be
            picked up in the <filename>index.php</filename> and used to set the
            <constant>APPLICATION_ENV</constant> constant for our Zend Framework application. In
            production, you can omit this directive (in which case it will default to the value
            "production") or set it explicitly to "production".
        </para>

        <para>
            Finally, you will need to add an entry in your <filename>hosts</filename> file
            corresponding to the value you place in your <varname>ServerName</varname> directive. On
            *nix-like systems, this is usually <filename>/etc/hosts</filename>; on Windows, you'll
            typically find it in <filename>C:\WINDOWS\system32\drivers\etc</filename>. Regardless of
            the system, the entry will look like the following:
        </para>

        <programlisting language="text"><![CDATA[
127.0.0.1 quickstart.local
]]></programlisting>

        <para>
            Start your webserver (or restart it), and you should be ready to go.
        </para>
    </sect2>

    <sect2 id="learning.quickstart.create-project.checkpoint">
        <title>Checkpoint</title>

        <para>
            At this point, you should be able to fire up your initial Zend Framework application.
            Point your browser to the server name you configured in the previous section; you should
            be able to see a welcome page at this point.
        </para>
    </sect2>
</sect1>