O que é demais para passar dados via injeção de dependência?

O tópico de injeção de dependência já existe há algum tempo nos círculos de programação orientada a objetos. Às vezes vemos isso no WordPress; às vezes não.

Sou fã dele, mas, honestamente, nem sempre tenho certeza de quanta informação devo injetar em uma aula. Quero dizer, digamos que temos duas classes, e uma contém informações que a outra precisa.

• Não injetamos nenhuma classe em outra classe?
• Injetamos apenas uma informação (seja uma string, um inteiro, uma estrutura de dados ou qualquer outra coisa) na outra classe?

Não acho que haja uma regra rígida e rápida para isso, mas provavelmente é seguro dizer que é melhor injetar apenas os dados de que você precisa. Mas então isso levanta uma questão de como preparar os dados para injetar em uma determinada classe?

• Você cria um método em uma classe e passa para outra?
• Você passa um pedaço de informação privada ou protegida para ele?

Então, novamente, acho que depende se algo tem que acontecer com as informações antes de serem passadas para uma classe.

De qualquer forma, eu poderia ir e voltar sobre isso pelo resto do post e nunca chegar a uma conclusão, então por que não trabalhar com algum código-fonte até que haja algo razoável.

Vamos começar dizendo que temos um arquivo de classe de plugin principal e esta classe é responsável por manter informações como:

• o caminho para o plug-in,
• o URL do plug-in,
• se o plugin está ou não carregado,
• a tela que está sendo visualizada no momento,
• e as classes para as quais ele precisa transmitir (pense pub/sub) certas informações.

Talvez um esqueleto ou um stub da classe possa ser assim :

<?php

class Plugin
{
    protected $plugin_path;

    protected $plugin_url;

    private $loaded;

    public function __construct($file)
    {
        $this->loaded         = false;
        $this->plugin_path    = plugin_dir_path($file);
        $this->plugin_url     = plugin_dir_url($file);
    }

    public function isLoaded()
    {
        return $this->loaded;
    }

    public function load()
    {
      // ...
    }

    private function isCurrentAdminStatus()
    {
      // ...
    }

    public function getSubscribers()
    {
        return [
          new OtherPluginClass(...)
        ];
    }
}

Então vamos começar bem amplo. Digamos que queremos pegar a turma inteira e passá-la para uma das turmas para a qual está transmitindo informações.

Se fosse esse o caso, então poderia ficar assim :

<?php

class Plugin
{
    protected $plugin_path;

    protected $plugin_url;

    private $loaded;

    public function __construct($file)
    {
        $this->loaded         = false;
        $this->plugin_path    = plugin_dir_path($file);
        $this->plugin_url     = plugin_dir_url($file);
    }

    public function isLoaded()
    {
        return $this->loaded;
    }

    public function load()
    {
      // ...
    }

    private function isCurrentAdminStatus()
    {
      // ...
    }

    public function getSubscribers()
    {
        return [
          new OtherPluginClass($this)
        ];
    }
}

Mas um dos desafios com isso é que ele passa muito mais informações do que o necessário para outra classe. Além disso, ele passa informações que incluem informações sobre a classe para a qual suas informações estão passando.

Então, digamos que queremos dar um passo atrás e apenas passar uma das informações privadas. Isso é simples, certo? Acaba ficando mais ou menos assim :

<?php

class Plugin
{
    protected $plugin_path;

    protected $plugin_url;

    private $loaded;

    public function __construct($file)
    {
        $this->loaded         = false;
        $this->plugin_path    = plugin_dir_path($file);
        $this->plugin_url     = plugin_dir_url($file);
    }

    public function isLoaded()
    {
        return $this->loaded;
    }

    public function load()
    {
      // ...
    }

    private function isCurrentAdminStatus()
    {
      // ...
    }

    public function getSubscribers()
    {
        return [
          new OtherPluginClass($this->plugin_path)
        ];
    }
}

E isso pode ser completamente suficiente para alguns casos. Mas, como mencionado anteriormente, também há momentos em que queremos pegar as informações, processá-las e depois passá-las para uma classe.

Para fazer isso, basta definir um método, fazer com que ele processe as informações e, em seguida, passar o valor de retorno para a classe que precisa das informações :

<?php

class Plugin
{
    protected $plugin_path;

    protected $plugin_url;

    private $loaded;

    public function __construct($file)
    {
        $this->loaded         = false;
        $this->plugin_path    = plugin_dir_path($file);
        $this->plugin_url     = plugin_dir_url($file);
    }

    public function isLoaded()
    {
        return $this->loaded;
    }

    public function load()
    {
      // ...
    }

    private function isCurrentAdminStatus()
    {
      // ...
    }

    public function getSubscribers()
    {
        return [
          new OtherPluginClass($this->isCurrentAdminStatus())
        ];
    }
}

A ideia por trás dessa discussão surgiu ao trabalhar em uma revisão de código para um projeto recente e falar sobre as várias opções nas quais as informações podem ser passadas para uma classe.

Então eu comecei amplo (apesar do que é necessário, mesmo considerando o processo de pensamento acima) e depois reduzi ao que é apenas necessário.