GD\Helpers\WriteFileBase

Complexity

Total Complexity

25

Size/Duplication

Total Lines	175
Duplicated Lines	2.29 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

83.13%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	getWriteClassName()	0	4	1
A	setWriteClassName()	0	4	1
A	getFilesystem()	0	7	2
A	setFilesystem()	0	9	2
A	convertDuskClassAndMethodsArrayToText()	0	16	2
A	getDuskClassAndMethodsString()	0	4	1
A	getAndSetHeaderArea()	0	5	1
	getAndSetFooterArea()	0	1	?
A	addSteps()	0	12	2
A	notLastLine()	0	8	2
A	addParentContent()	0	6	1
A	addNewStepToTest()	4	10	2
A	checkDestinationTestFolder()	0	12	3
A	saveToFile()	0	9	1
A	getExistingTestContent()	0	9	2
A	setExistingTestContent()	0	11	2

<?php


namespace GD\Helpers;

use GD\Exceptions\TestFileExists;
use Illuminate\Filesystem\Filesystem;

abstract class WriteFileBase
{

    protected $write_destination_folder_path = "";
    protected $dusk_class_and_methods_string = "";
    protected $write_class_name = "";
    protected $spacing = "";
    protected $existing_test_content;

    /**
     * @var Filesystem
     */
    protected $filesystem;
    protected $base;
    protected $step_template;
    protected $content;

    /**
     * @return string
     */
    public function getWriteClassName()
    {
        return $this->write_class_name;
    }

    public function setWriteClassName($name)
    {
        $this->write_class_name = $name;
    }


    /**
     * @return Filesystem
     */
    public function getFilesystem()
    {
        if (!$this->filesystem) {
            $this->setFilesystem();
        }
        return $this->filesystem;
    }

    /**
     * @param null $filesystem
     * @return $this
     */
    public function setFilesystem($filesystem = null)
    {
        if (!$filesystem) {
            $filesystem = new Filesystem();
        }

        $this->filesystem = $filesystem;
        return $this;
    }

    protected function convertDuskClassAndMethodsArrayToText($dusk_class_and_methods)
    {

        $this->getAndSetHeaderArea();

        foreach ($dusk_class_and_methods as $dusk_class_and_method_index => $dusk_class_and_method) {
            /**
             * Check if set
             */
            $this->addParentContent($dusk_class_and_method['parent']);

            $this->addSteps($dusk_class_and_method['steps']);
        }

        $this->getAndSetFooterArea();
    }

    public function getDuskClassAndMethodsString()
    {
        return $this->dusk_class_and_methods_string;
    }

    protected function getAndSetHeaderArea()
    {
        $content = str_replace("[TEST_NAME]", $this->write_class_name, $this->content);
        $this->dusk_class_and_methods_string = $content;
    }

    abstract protected function getAndSetFooterArea();

    protected function addSteps(array $steps)
    {
        $references = "";

        foreach ($steps as $index => $step) {
            $references = $references . $this->spacing . $step['reference'] . $this->notLastLine($steps, $index);
            $this->addNewStepToTest($step, $this->step_template);
        }

        $this->dusk_class_and_methods_string =
            str_replace("[STEPS_AREA]", $references, $this->dusk_class_and_methods_string);
    }

    protected function notLastLine(array $steps, $index)
    {
        if (($index + 1) < count($steps)) {
            return ";\n        ";
        }

        return ";";
    }


    protected function addParentContent($parent_function)
    {
        $base = str_replace("[PARENT_METHOD]", $parent_function, $this->base);

        $this->dusk_class_and_methods_string = $this->dusk_class_and_methods_string . $base;
    }

    protected function addNewStepToTest($step, $step_template)
    {
        $method = sprintf("protected function %s()", $step['method_name']);
        $found = substr_count($this->dusk_class_and_methods_string, $method);

        if ($found < 1) {

This code seems to be duplicated across your project.

            $content = str_replace(["[STEP]", "[METHOD]"], $step['method_name'], $step_template);
            $this->dusk_class_and_methods_string = $this->dusk_class_and_methods_string . $content;
        }
    }

    protected function checkDestinationTestFolder()
    {

        if (!$this->getFilesystem()->exists($this->write_destination_folder_path)) {
            $this->getFilesystem()->makeDirectory($this->write_destination_folder_path, 0777, true);
        } else {
            if ($this->getFilesystem()->exists($this->write_destination_folder_path .
                $this->write_class_name . '.php')) {
                throw new TestFileExists(sprintf("The file %s already exists", $this->write_class_name . '.php'));
            }
        }
    }

    protected function saveToFile()
    {
        $path = sprintf("%s/%s.php", $this->write_destination_folder_path, $this->write_class_name);

        $this->getFilesystem()->put(
            $path,
            $this->dusk_class_and_methods_string
        );
    }

    public function getExistingTestContent()
    {

        if (!$this->existing_test_content) {
            $this->setExistingTestContent();
        }
        
        return $this->existing_test_content;
    }

    /**
     * @param mixed $existing_test_content
     */
    public function setExistingTestContent($existing_test_content = null)
    {
        if (!$existing_test_content) {
            $file_to_append = $this->write_destination_folder_path . '/' . $this->getWriteClassName() . '.php';

            $content = $this->getFilesystem()->get($file_to_append);
            $this->existing_test_content = $content;
        }
        
        $this->existing_test_content = $existing_test_content;
    }
}