DNEnvironment::getPipelineFilename() - Code Metrics - Inspection of "Converted to PSR-2" - silverstripe/deploynaut - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#489)

by Helpful
created 2015-12-25 21:53 UTC
DNEnvironment::getPipelineFilename() A

↳ Parent: DNEnvironment
Complexity

Conditions	3
Paths	3
Size

Total Lines	11
Code Lines	7
Duplication

Lines	0
Ratio	0 %
Metric	Value
dl	0
loc	11
rs	9.4286
cc	3
eloc	7
nc	3
nop	0
<?php

/**
 * DNEnvironment
 *
 * This dataobject represents a target environment that source code can be deployed to.
 * Permissions are controlled by environment, see the various many-many relationships.
 *
 * @property string $Filename
 * @property string $Name
 * @property string $URL
 * @property string $BackendIdentifier
 * @property bool $DryRunEnabled
 * @property bool $Usage
 *
 * @method DNProject Project()
 * @property int $ProjectID
 *
 * @method HasManyList Deployments()
 * @method HasManyList DataArchives()
 * @method HasManyList Pipelines()
 *
 * @method ManyManyList Viewers()
 * @method ManyManyList ViewerGroups()
 * @method ManyManyList Deployers()
 * @method ManyManyList DeployerGroups()
 * @method ManyManyList CanRestoreMembers()
 * @method ManyManyList CanRestoreGroups()
 * @method ManyManyList CanBackupMembers()
 * @method ManyManyList CanBackupGroups()
 * @method ManyManyList ArchiveUploaders()
 * @method ManyManyList ArchiveUploaderGroups()
 * @method ManyManyList ArchiveDownloaders()
 * @method ManyManyList ArchiveDownloaderGroups()
 * @method ManyManyList ArchiveDeleters()
 * @method ManyManyList ArchiveDeleterGroups()
 * @method ManyManyList PipelineApprovers()
 * @method ManyManyList PipelineApproverGroups()
 * @method ManyManyList PipelineCancellers()
 * @method ManyManyList PipelineCancellerGroups()
 */
class DNEnvironment extends DataObject
{

    /**
     * If this is set to a full pathfile, it will be used as template
     * file when creating a new capistrano environment config file.
     *
     * If not set, the default 'environment.template' from the module
     * root is used
     *
     * @config
     * @var string
     */
    private static $template_file = '';

    /**
     * Set this to true to allow editing of the environment files via the web admin
     *
     * @var bool
     */
    private static $allow_web_editing = false;

    /**
     * @var array
     */
    private static $casting = array(
        'DeployHistory' => 'Text'
    );

    /**
     * Allowed backends. A map of Injector identifier to human-readable label.
     *
     * @config
     * @var array
     */
    private static $allowed_backends = array();

    /**
     * @var array
     */
    public static $db = array(
        "Filename" => "Varchar(255)",
        "Name" => "Varchar(255)",
        "URL" => "Varchar(255)",
        "BackendIdentifier" => "Varchar(255)", // Injector identifier of the DeploymentBackend
        "DryRunEnabled" => "Boolean", // True if the dry run button should be enabled on the frontend
        "Usage" => "Enum('Production, UAT, Test, Unspecified', 'Unspecified')"
    );

    /**
     * @var array
     */
    public static $has_one = array(
        "Project" => "DNProject",
        "CreateEnvironment" => "DNCreateEnvironment"
    );

    /**
     * @var array
     */
    public static $has_many = array(
        "Deployments" => "DNDeployment",
        "DataArchives" => "DNDataArchive",
        "Pipelines" => "Pipeline" // Only one Pipeline can be 'Running' at any one time. @see self::CurrentPipeline().
    );

    /**
     * @var array
     */
    public static $many_many = array(
        "Viewers"            => "Member", // Who can view this environment
        "ViewerGroups"       => "Group",
        "Deployers"          => "Member", // Who can deploy to this environment
        "DeployerGroups" => "Group",
        "CanRestoreMembers"  => "Member", // Who can restore archive files to this environment
        "CanRestoreGroups"  => "Group",
        "CanBackupMembers"   => "Member", // Who can backup archive files from this environment
        "CanBackupGroups"   => "Group",
        "ArchiveUploaders"   => "Member", // Who can upload archive files linked to this environment
        "ArchiveUploaderGroups" => "Group",
        "ArchiveDownloaders" => "Member", // Who can download archive files from this environment
        "ArchiveDownloaderGroups" => "Group",
        "ArchiveDeleters"    => "Member", // Who can delete archive files from this environment,
        "ArchiveDeleterGroups" => "Group",
        "PipelineApprovers"  => "Member", // Who can approve / reject pipelines from this environment
        "PipelineApproverGroups" => "Group",
        "PipelineCancellers"   => "Member", // Who can abort pipelines
        "PipelineCancellerGroups" => "Group"
    );

    /**
     * @var array
     */
    public static $summary_fields = array(
        "Name" => "Environment Name",
        "Usage" => "Usage",
        "URL" => "URL",
        "DeployersList" => "Can Deploy List",
        "CanRestoreMembersList" => "Can Restore List",
        "CanBackupMembersList" => "Can Backup List",
        "ArchiveUploadersList" => "Can Upload List",
        "ArchiveDownloadersList" => "Can Download List",
        "ArchiveDeletersList"  => "Can Delete List",
        "PipelineApproversList" => "Can Approve List",
        "PipelineCancellersList" => "Can Cancel List"
    );

    private static $singular_name = 'Capistrano Environment';

    private static $plural_name = 'Capistrano Environments';

    /**
     * @var array
     */
    public static $searchable_fields = array(
        "Name",
    );

    /**
     * @var string
     */
    private static $default_sort = 'Name';

    /**
     * Used by the sync task
     *
     * @param string $path
     * @return \DNEnvironment
     */
    public static function create_from_path($path)
    {
        $e = DNEnvironment::create();
        $e->Filename = $path;
        $e->Name = basename($e->Filename, '.rb');

        // add each administrator member as a deployer of the new environment
        $adminGroup = Group::get()->filter('Code', 'administrators')->first();
        $e->DeployerGroups()->add($adminGroup);
        return $e;
    }

    /**
     * Get the deployment backend used for this environment.
     *
     * Enforces compliance with the allowed_backends setting; if the DNEnvironment.BackendIdentifier value is
     * illegal then that value is ignored.
     *
     * @return DeploymentBackend
     */
    public function Backend()
    {
        $backends = array_keys($this->config()->get('allowed_backends', Config::FIRST_SET));
        switch (sizeof($backends)) {
        // Nothing allowed, use the default value "DeploymentBackend"
            case 0:
                $backend = "DeploymentBackend";
                break;

            // Only 1 thing allowed, use that
            case 1:
                $backend = $backends[0];
                break;

            // Multiple choices, use our choice if it's legal, otherwise default to the first item on the list
            default:
                $backend = $this->BackendIdentifier;
                if (!in_array($backend, $backends)) {
                    $backend = $backends[0];
                }
        }

        return Injector::inst()->get($backend);
    }

    public function Menu()
    {
        $list = new ArrayList();

        $controller = Controller::curr();
        $actionType = $controller->getField('CurrentActionType');

        $list->push(new ArrayData(array(
            'Link' => sprintf('naut/project/%s/environment/%s', $this->Project()->Name, $this->Name),
            'Title' => 'Deployments',
            'IsCurrent' => $this->isCurrent(),
            'IsSection' => $this->isSection() && $actionType == DNRoot::ACTION_DEPLOY
        )));

        $this->extend('updateMenu', $list);

        return $list;
    }

    /**
     * Return the current object from $this->Menu()
     * Good for making titles and things
     */
    public function CurrentMenu()
    {
        return $this->Menu()->filter('IsSection', true)->First();
    }

    /**
     * Return a name for this environment.
     *
     * @param string $separator The string used when concatenating project with env name
     * @return string
     */
    public function getFullName($separator = ':')
    {
        return sprintf('%s%s%s', $this->Project()->Name, $separator, $this->Name);
    }

    public function getBareURL()
    {
        $url = parse_url($this->URL);
        if (isset($url['host'])) {
            return strtolower($url['host']);
        }
    }

    /**
     * @return boolean true if there is a pipeline for the current environment.
     */
    public function HasPipelineSupport()
    {
        $config = $this->GenericPipelineConfig();
        return $config instanceof ArrayData && isset($config->Steps);
    }

    /**
     * Returns a {@link Pipeline} object that is linked to this environment, but isn't saved into the database. This
     * shouldn't be saved into the database unless you plan on starting an actual pipeline.
     *
     * @return Pipeline
     */
    public function GenericPipeline()
    {
        $pipeline = Pipeline::create();
        $pipeline->EnvironmentID = $this->ID;
        return $pipeline;
    }

    /**
     * Returns the parsed config, based on a {@link Pipeline} being created for this {@link DNEnvironment}.
     *
     * @return ArrayData
     */
    public function GenericPipelineConfig()
    {
        $config = $this->loadPipelineConfig();
        if ($config) {
            return self::array_to_viewabledata($config);
        }
    }

    /**
     * Extract pipeline configuration data from the source yml file
     *
     * @return array
     */
    public function loadPipelineConfig()
    {
        require_once 'thirdparty/spyc/spyc.php';

        $path = $this->getPipelineFilename();
        if (file_exists($path)) {
            return Spyc::YAMLLoad($path);
        }
    }

    /**
     * Returns the {@link DNEnvironment} object relating to the pipeline config for this environment. The environment
     * YAML file (e.g. project1-uat.yml; see docs/en/pipelines.md) contains two variable called `DependsOnProject` and
     * `DependsOnEnvironment` - these are used together to find the {@link DNEnvironment} that this environment should
     * rely on.
     */
    public function DependsOnEnvironment()
    {
        if ($this->HasPipelineSupport()) {
            $pipeline = $this->GenericPipeline();
            return $pipeline->getDependentEnvironment();
        }

        return null;
    }

    /**
     * @return bool true if there is a currently running Pipeline, and false if there isn't
     */
    public function HasCurrentPipeline()
    {
        return $this->CurrentPipeline() && $this->CurrentPipeline()->isInDB();
    }

    /**
     * This can be used to determine if there is a currently running pipeline (there can only be one running per
     * {@link DNEnvironment} at once), as well as getting the current pipeline to be shown in templates.
     *
     * @return DataObject|null The currently running pipeline, or null if there isn't any.
     */
    public function CurrentPipeline()
    {
        return $this->Pipelines()->filter('Status', array('Running', 'Rollback'))->first();
    }

    /**
     * @return bool true if the current user can cancel a running pipeline
     */
    public function CanCancelPipeline()
    {
        // do we have a current pipeline
        if ($this->HasCurrentPipeline()) {
            return $this->CurrentPipeline()->canAbort();
        }
        return false;
    }

    /**
     * Environments are only viewable by people that can view the environment.
     *
     * @param Member|null $member
     * @return boolean
     */
    public function canView($member = null)
    {
        if (!$member) {
            $member = Member::currentUser();
        }
        if (!$member) {
            return false;
        }
        // Must be logged in to check permissions

        if (Permission::checkMember($member, 'ADMIN')) {
            return true;
        }

        // if no Viewers or ViewerGroups defined, fallback to DNProject::canView permissions
        if ($this->Viewers()->exists() || $this->ViewerGroups()->exists()) {
            return $this->Viewers()->byID($member->ID)
                || $member->inGroups($this->ViewerGroups());
        }

        return $this->Project()->canView($member);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Allow deploy only to some people.
     *
     * @param Member|null $member
     * @return boolean
     */
    public function canDeploy($member = null)

    {
        if (!$member) {
            $member = Member::currentUser();
        }
        if (!$member) {
            return false;
        }
        // Must be logged in to check permissions

        if ($this->Usage==='Production' || $this->Usage==='Unspecified') {
            if ($this->Project()->allowed(DNRoot::ALLOW_PROD_DEPLOYMENT, $member)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                return true;
            }
        } else {
            if ($this->Project()->allowed(DNRoot::ALLOW_NON_PROD_DEPLOYMENT, $member)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                return true;
            }
        }

        return $this->Deployers()->byID($member->ID)
            || $member->inGroups($this->DeployerGroups());
    }

    /**
     * Allows only selected {@link Member} objects to restore {@link DNDataArchive} objects into this
     * {@link DNEnvironment}.
     *
     * @param Member|null $member The {@link Member} object to test against. If null, uses Member::currentMember();
     * @return boolean true if $member can restore, and false if they can't.
     */
    public function canRestore($member = null)

    {
        if (!$member) {
            $member = Member::currentUser();
        }
        if (!$member) {
            return false;
        }
        // Must be logged in to check permissions

        if ($this->Usage==='Production' || $this->Usage==='Unspecified') {
            if ($this->Project()->allowed(DNRoot::ALLOW_PROD_SNAPSHOT, $member)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                return true;
            }
        } else {
            if ($this->Project()->allowed(DNRoot::ALLOW_NON_PROD_SNAPSHOT, $member)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                return true;
            }
        }

        return $this->CanRestoreMembers()->byID($member->ID)
            || $member->inGroups($this->CanRestoreGroups());
    }

    /**
     * Allows only selected {@link Member} objects to backup this {@link DNEnvironment} to a {@link DNDataArchive}
     * file.
     *
     * @param Member|null $member The {@link Member} object to test against. If null, uses Member::currentMember();
     * @return boolean true if $member can backup, and false if they can't.
     */
    public function canBackup($member = null)

    {
        $project = $this->Project();
        if ($project->HasDiskQuota() && $project->HasExceededDiskQuota()) {
            return false;
        }

        if (!$member) {
            $member = Member::currentUser();
        }
        // Must be logged in to check permissions
        if (!$member) {
            return false;
        }

        if ($this->Usage==='Production' || $this->Usage==='Unspecified') {
            if ($this->Project()->allowed(DNRoot::ALLOW_PROD_SNAPSHOT, $member)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                return true;
            }
        } else {
            if ($this->Project()->allowed(DNRoot::ALLOW_NON_PROD_SNAPSHOT, $member)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                return true;
            }
        }

        return $this->CanBackupMembers()->byID($member->ID)
            || $member->inGroups($this->CanBackupGroups());
    }

    /**
     * Allows only selected {@link Member} objects to upload {@link DNDataArchive} objects linked to this
     * {@link DNEnvironment}.
     *
     * Note: This is not uploading them to the actual environment itself (e.g. uploading to the live site) - it is the
     * process of uploading a *.sspak file into Deploynaut for later 'restoring' to an environment. See
     * {@link self::canRestore()}.
     *
     * @param Member|null $member The {@link Member} object to test against. If null, uses Member::currentMember();
     * @return boolean true if $member can upload archives linked to this environment, false if they can't.
     */
    public function canUploadArchive($member = null)

    {
        $project = $this->Project();
        if ($project->HasDiskQuota() && $project->HasExceededDiskQuota()) {
            return false;
        }

        if (!$member) {
            $member = Member::currentUser();
        }
        if (!$member) {
            return false;
        }
        // Must be logged in to check permissions

        if ($this->Usage==='Production' || $this->Usage==='Unspecified') {
            if ($this->Project()->allowed(DNRoot::ALLOW_PROD_SNAPSHOT, $member)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                return true;
            }
        } else {
            if ($this->Project()->allowed(DNRoot::ALLOW_NON_PROD_SNAPSHOT, $member)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                return true;
            }
        }

        return $this->ArchiveUploaders()->byID($member->ID)
            || $member->inGroups($this->ArchiveUploaderGroups());
    }

    /**
     * Allows only selected {@link Member} objects to download {@link DNDataArchive} objects from this
     * {@link DNEnvironment}.
     *
     * @param Member|null $member The {@link Member} object to test against. If null, uses Member::currentMember();
     * @return boolean true if $member can download archives from this environment, false if they can't.
     */
    public function canDownloadArchive($member = null)

    {
        if (!$member) {
            $member = Member::currentUser();
        }
        if (!$member) {
            return false;
        }
        // Must be logged in to check permissions

        if ($this->Usage==='Production' || $this->Usage==='Unspecified') {
            if ($this->Project()->allowed(DNRoot::ALLOW_PROD_SNAPSHOT, $member)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                return true;
            }
        } else {
            if ($this->Project()->allowed(DNRoot::ALLOW_NON_PROD_SNAPSHOT, $member)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                return true;
            }
        }

        return $this->ArchiveDownloaders()->byID($member->ID)
            || $member->inGroups($this->ArchiveDownloaderGroups());
    }

    /**
     * Determine if the specified user can abort any pipelines
     *
     * @param Member|null $member
     * @return boolean
     */
    public function canAbort($member = null)

    {
        if (!$member) {
            $member = Member::currentUser();
        }
        if (!$member) {
            return false;
        }

        if (Permission::checkMember($member, 'ADMIN')) {
            return true;
        }

        return $this->PipelineCancellers()->byID($member->ID)
            || $member->inGroups($this->PipelineCancellerGroups());
    }

    /**
     * Determine if the specified user can approve any pipelines
     *
     * @param Member|null $member
     * @return boolean
     */
    public function canApprove($member = null)

    {
        if (!$member) {
            $member = Member::currentUser();
        }
        if (!$member) {
            return false;
        }

        if (Permission::checkMember($member, 'ADMIN')) {
            return true;
        }
        return $this->PipelineApprovers()->byID($member->ID)
            || $member->inGroups($this->PipelineApproverGroups());
    }

    /**
     * Allows only selected {@link Member} objects to delete {@link DNDataArchive} objects from this
     * {@link DNEnvironment}.
     *
     * @param Member|null $member The {@link Member} object to test against. If null, uses Member::currentMember();
     * @return boolean true if $member can delete archives from this environment, false if they can't.
     */
    public function canDeleteArchive($member = null)

    {
        if (!$member) {
            $member = Member::currentUser();
        }
        if (!$member) {
            return false;
        }
        // Must be logged in to check permissions

        if ($this->Usage==='Production' || $this->Usage==='Unspecified') {
            if ($this->Project()->allowed(DNRoot::ALLOW_PROD_SNAPSHOT, $member)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                return true;
            }
        } else {
            if ($this->Project()->allowed(DNRoot::ALLOW_NON_PROD_SNAPSHOT, $member)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                return true;
            }
        }

        return $this->ArchiveDeleters()->byID($member->ID)
            || $member->inGroups($this->ArchiveDeleterGroups());
    }
    /**
     * Get a string of groups/people that are allowed to deploy to this environment.
     * Used in DNRoot_project.ss to list {@link Member}s who have permission to perform this action.
     *
     * @return string
     */
    public function getDeployersList()
    {
        return implode(
            ", ",
            array_merge(
                $this->DeployerGroups()->column("Title"),
                $this->Deployers()->column("FirstName")
            )
        );
    }

    /**
     * Get a string of groups/people that are allowed to restore {@link DNDataArchive} objects into this environment.
     *
     * @return string
     */
    public function getCanRestoreMembersList()
    {
        return implode(
            ", ",
            array_merge(
                $this->CanRestoreGroups()->column("Title"),
                $this->CanRestoreMembers()->column("FirstName")
            )
        );
    }

    /**
     * Get a string of groups/people that are allowed to backup {@link DNDataArchive} objects from this environment.
     *
     * @return string
     */
    public function getCanBackupMembersList()
    {
        return implode(
            ", ",
            array_merge(
                $this->CanBackupGroups()->column("Title"),
                $this->CanBackupMembers()->column("FirstName")
            )
        );
    }

    /**
     * Get a string of groups/people that are allowed to upload {@link DNDataArchive}
     *  objects linked to this environment.
     *
     * @return string
     */
    public function getArchiveUploadersList()
    {
        return implode(
            ", ",
            array_merge(
                $this->ArchiveUploaderGroups()->column("Title"),
                $this->ArchiveUploaders()->column("FirstName")
            )
        );
    }

    /**
     * Get a string of groups/people that are allowed to download {@link DNDataArchive} objects from this environment.
     *
     * @return string
     */
    public function getArchiveDownloadersList()
    {
        return implode(
            ", ",
            array_merge(
                $this->ArchiveDownloaderGroups()->column("Title"),
                $this->ArchiveDownloaders()->column("FirstName")
            )
        );
    }

    /**
     * Get a string of groups/people that are allowed to delete {@link DNDataArchive} objects from this environment.
     *
     * @return string
     */
    public function getArchiveDeletersList()
    {
        return implode(
            ", ",
            array_merge(
                $this->ArchiveDeleterGroups()->column("Title"),
                $this->ArchiveDeleters()->column("FirstName")
            )
        );
    }

    /**
     * Get a string of groups/people that are allowed to approve pipelines
     *
     * @return string
     */
    public function getPipelineApproversList()
    {
        return implode(
            ", ",
            array_merge(
                $this->PipelineApproverGroups()->column("Title"),
                $this->PipelineApprovers()->column("FirstName")
            )
        );
    }

    /**
     * Get a string of groups/people that are allowed to cancel pipelines
     *
     * @return string
     */
    public function getPipelineCancellersList()
    {
        return implode(
            ", ",
            array_merge(
                $this->PipelineCancellerGroups()->column("Title"),
                $this->PipelineCancellers()->column("FirstName")
            )
        );
    }

    /**
     * @return DNData
     */
    public function DNData()
    {
        return DNData::inst();
    }

    /**
     * Get the current deployed build for this environment
     *
     * Dear people of the future: If you are looking to optimize this, simply create a CurrentBuildSHA(), which can be
     * a lot faster. I presume you came here because of the Project display template, which only needs a SHA.
     *
     * @return false|DNDeployment
     */
    public function CurrentBuild()
    {
        // The DeployHistory function is far too slow to use for this

        /** @var DNDeployment $deploy */
        $deploy = DNDeployment::get()->filter(array(
            'EnvironmentID' => $this->ID,
            'Status' => 'Finished'
        ))->sort('LastEdited DESC')->first();

        if (!$deploy || (!$deploy->SHA)) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            return false;
        }

        $repo = $this->Project()->getRepository();
        if (!$repo) {
            return $deploy;
        }

        try {
            $commit = $repo->getCommit($deploy->SHA);
            if ($commit) {
                $deploy->Message = Convert::raw2xml($commit->getMessage());
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                $deploy->Committer = Convert::raw2xml($commit->getCommitterName());
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                $deploy->CommitDate = $commit->getCommitterDate()->Format('d/m/Y g:ia');
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                $deploy->Author = Convert::raw2xml($commit->getAuthorName());
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                $deploy->AuthorDate = $commit->getAuthorDate()->Format('d/m/Y g:ia');
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            }
            // We can't find this SHA, so we ignore adding a commit message to the deployment
        } catch (Exception $ex) {
        }

        return $deploy;
    }

    /**
     * A history of all builds deployed to this environment
     *
     * @return ArrayList
     */
    public function DeployHistory()
    {
        return $this->Deployments()
            ->where('SHA IS NOT NULL')
            ->sort('LastEdited DESC');
    }

    /**
     * @param string $sha
     * @return array
     */
    protected function getCommitData($sha)
    {
        try {
            $repo = $this->Project()->getRepository();
            if ($repo !== false) {
                $commit = new \Gitonomy\Git\Commit($repo, $sha);
                return [
                    'AuthorName' => (string)Convert::raw2xml($commit->getAuthorName()),
                    'AuthorEmail' => (string)Convert::raw2xml($commit->getAuthorEmail()),
                    'Message' => (string)Convert::raw2xml($commit->getMessage()),
                    'ShortHash' => Convert::raw2xml($commit->getFixedShortHash(8)),
                    'Hash' => Convert::raw2xml($commit->getHash())
                ];
            }
        } catch (\Gitonomy\Git\Exception\ReferenceNotFoundException $exc) {
            SS_Log::log($exc, SS_Log::WARN);
        }
        return array(
            'AuthorName' => '(unknown)',
            'AuthorEmail' => '(unknown)',
            'Message' => '(unknown)',
            'ShortHash' => $sha,
            'Hash' => '(unknown)',
        );
    }

    /**
     * @return string
     */
    public function Link()
    {
        return $this->Project()->Link() . "/environment/" . $this->Name;
    }

    /**
     * Is this environment currently at the root level of the controller that handles it?
     * @return bool
     */
    public function isCurrent()
    {
        return $this->isSection() && Controller::curr()->getAction() == 'environment';
    }

    /**
     * Is this environment currently in a controller that is handling it or performing a sub-task?
     * @return bool
     */
    public function isSection()
    {
        $controller = Controller::curr();
        $environment = $controller->getField('CurrentEnvironment');
        return $environment && $environment->ID == $this->ID;
    }


    /**
     * Build a set of multi-select fields for assigning permissions to a pair of group and member many_many relations
     *
     * @param string $groupField Group field name
     * @param string $memberField Member field name
     * @param array $groups List of groups
     * @param array $members List of members
     * @return FieldGroup
     */
    protected function buildPermissionField($groupField, $memberField, $groups, $members)
    {
        return FieldGroup::create(
            ListboxField::create($groupField, false, $groups)
                ->setMultiple(true)
                ->setAttribute('data-placeholder', 'Groups')
                ->setAttribute('placeholder', 'Groups')
                ->setAttribute('style', 'width: 400px;'),

            ListboxField::create($memberField, false, $members)
                ->setMultiple(true)
                ->setAttribute('data-placeholder', 'Members')
                ->setAttribute('placeholder', 'Members')
                ->setAttribute('style', 'width: 400px;')
        );
    }

    /**
     * @return FieldList
     */
    public function getCMSFields()
    {
        $fields = new FieldList(new TabSet('Root'));

        $project = $this->Project();
        if ($project && $project->exists()) {
            $viewerGroups = $project->Viewers();
            $groups = $viewerGroups->sort('Title')->map()->toArray();
            $members = array();
            foreach ($viewerGroups as $group) {
                foreach ($group->Members()->map() as $k => $v) {
                    $members[$k] = $v;
                }
            }
            asort($members);
        } else {
            $groups = array();
            $members = array();
        }

        // Main tab
        $fields->addFieldsToTab('Root.Main', array(
            // The Main.ProjectID
            TextField::create('ProjectName', 'Project')
                ->setValue(($project = $this->Project()) ? $project->Name : null)
                ->performReadonlyTransformation(),

            // The Main.Name
            TextField::create('Name', 'Environment name')
                ->setDescription('A descriptive name for this environment, e.g. staging, uat, production'),


            $this->obj('Usage')->scaffoldFormField('Environment usage'),

            // The Main.URL field
            TextField::create('URL', 'Server URL')
                ->setDescription('This url will be used to provide the front-end with a link to this environment'),

            // The Main.Filename
            TextField::create('Filename')
                ->setDescription('The capistrano environment file name')
                ->performReadonlyTransformation(),
        ));

        // Backend identifier - pick from a named list of configurations specified in YML config
        $backends = $this->config()->get('allowed_backends', Config::FIRST_SET);
        // If there's only 1 backend, then user selection isn't needed
        if (sizeof($backends) > 1) {
            $fields->addFieldToTab('Root.Main', DropdownField::create('BackendIdentifier', 'Deployment backend')
                ->setSource($backends)
                ->setDescription('What kind of deployment system should be used to deploy to this environment'));
        }

        $fields->addFieldsToTab('Root.UserPermissions', array(
            // The viewers of the environment
            $this
                ->buildPermissionField('ViewerGroups', 'Viewers', $groups, $members)
                ->setTitle('Who can view this environment?')
                ->setDescription('Groups or Users who can view this environment'),

            // The Main.Deployers
            $this
                ->buildPermissionField('DeployerGroups', 'Deployers', $groups, $members)
                ->setTitle('Who can deploy?')
                ->setDescription('Groups or Users who can deploy to this environment'),

            // A box to select all snapshot options.
            $this
                ->buildPermissionField('TickAllSnapshotGroups', 'TickAllSnapshot', $groups, $members)
                ->setTitle("<em>All snapshot permissions</em>")
                ->addExtraClass('tickall')
                ->setDescription('UI shortcut to select all snapshot-related options - not written to the database.'),

            // The Main.CanRestoreMembers
            $this
                ->buildPermissionField('CanRestoreGroups', 'CanRestoreMembers', $groups, $members)
                ->setTitle('Who can restore?')
                ->setDescription('Groups or Users who can restore archives from Deploynaut into this environment'),

            // The Main.CanBackupMembers
            $this
                ->buildPermissionField('CanBackupGroups', 'CanBackupMembers', $groups, $members)
                ->setTitle('Who can backup?')
                ->setDescription('Groups or Users who can backup archives from this environment into Deploynaut'),

            // The Main.ArchiveDeleters
            $this
                ->buildPermissionField('ArchiveDeleterGroups', 'ArchiveDeleters', $groups, $members)
                ->setTitle('Who can delete?')
                ->setDescription("Groups or Users who can delete archives from this environment's staging area."),

            // The Main.ArchiveUploaders
            $this
                ->buildPermissionField('ArchiveUploaderGroups', 'ArchiveUploaders', $groups, $members)
                ->setTitle('Who can upload?')
                ->setDescription(
                    'Users who can upload archives linked to this environment into Deploynaut.<br />' .
                    'Linking them to an environment allows limiting download permissions (see below).'
                ),

            // The Main.ArchiveDownloaders
            $this
                ->buildPermissionField('ArchiveDownloaderGroups', 'ArchiveDownloaders', $groups, $members)
                ->setTitle('Who can download?')
                ->setDescription(<<<PHP
Users who can download archives from this environment to their computer.<br />
Since this implies access to the snapshot, it is also a prerequisite for restores
to other environments, alongside the "Who can restore" permission.<br>
Should include all users with upload permissions, otherwise they can't download
their own uploads.
PHP
                ),

            // The Main.PipelineApprovers
            $this
                ->buildPermissionField('PipelineApproverGroups', 'PipelineApprovers', $groups, $members)
                ->setTitle('Who can approve pipelines?')
                ->setDescription('Users who can approve waiting deployment pipelines.'),

            // The Main.PipelineCancellers
            $this
                ->buildPermissionField('PipelineCancellerGroups', 'PipelineCancellers', $groups, $members)
                ->setTitle('Who can cancel pipelines?')
                ->setDescription('Users who can cancel in-progess deployment pipelines.')
        ));

        // The Main.DeployConfig
        if ($this->Project()->exists()) {
            $this->setDeployConfigurationFields($fields);
        }

        // The DataArchives
        $dataArchiveConfig = GridFieldConfig_RecordViewer::create();
        $dataArchiveConfig->removeComponentsByType('GridFieldAddNewButton');
        if (class_exists('GridFieldBulkManager')) {
            $dataArchiveConfig->addComponent(new GridFieldBulkManager());
        }
        $dataArchive = GridField::create('DataArchives', 'Data Archives', $this->DataArchives(), $dataArchiveConfig);
        $fields->addFieldToTab('Root.DataArchive', $dataArchive);

        // Pipeline templates
        $this->setPipelineConfigurationFields($fields);

        // Pipelines
        if ($this->Pipelines()->Count()) {
            $pipelinesConfig = GridFieldConfig_RecordEditor::create();
            $pipelinesConfig->removeComponentsByType('GridFieldAddNewButton');
            if (class_exists('GridFieldBulkManager')) {
                $pipelinesConfig->addComponent(new GridFieldBulkManager());
            }
            $pipelines = GridField::create('Pipelines', 'Pipelines', $this->Pipelines(), $pipelinesConfig);
            $fields->addFieldToTab('Root.Pipelines', $pipelines);
        }

        // Deployments
        $deploymentsConfig = GridFieldConfig_RecordEditor::create();
        $deploymentsConfig->removeComponentsByType('GridFieldAddNewButton');
        if (class_exists('GridFieldBulkManager')) {
            $deploymentsConfig->addComponent(new GridFieldBulkManager());
        }
        $deployments = GridField::create('Deployments', 'Deployments', $this->Deployments(), $deploymentsConfig);
        $fields->addFieldToTab('Root.Deployments', $deployments);

        Requirements::javascript('deploynaut/javascript/environment.js');

        // Add actions
        $action = new FormAction('check', 'Check Connection');
        $action->setUseButtonTag(true);
        $dataURL = Director::absoluteBaseURL() . 'naut/api/' . $this->Project()->Name . '/' . $this->Name . '/ping';
        $action->setAttribute('data-url', $dataURL);
        $fields->insertBefore($action, 'Name');
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        // Allow extensions
        $this->extend('updateCMSFields', $fields);
        return $fields;
    }

    /**
     * @param FieldList $fields
     */
    protected function setDeployConfigurationFields(&$fields)
    {
        if (!$this->config()->get('allow_web_editing')) {
            return;
        }

        if ($this->envFileExists()) {
            $deployConfig = new TextareaField('DeployConfig', 'Deploy config', $this->getEnvironmentConfig());
            $deployConfig->setRows(40);
            $fields->insertAfter($deployConfig, 'Filename');
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            return;
        }

        $warning = 'Warning: This environment doesn\'t have deployment configuration.';
        $noDeployConfig = new LabelField('noDeployConfig', $warning);
        $noDeployConfig->addExtraClass('message warning');
        $fields->insertAfter($noDeployConfig, 'Filename');
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $createConfigField = new CheckboxField('CreateEnvConfig', 'Create Config');
        $createConfigField->setDescription('Would you like to create the capistrano deploy configuration?');
        $fields->insertAfter($createConfigField, 'noDeployConfig');
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @param FieldList $fields
     */
    protected function setPipelineConfigurationFields($fields)
    {
        if (!$this->config()->get('allow_web_editing')) {
            return;
        }
        $config = $this->pipelineFileExists()
            ? file_get_contents($this->getPipelineFilename())
            : '';
        $deployConfig = new TextareaField('PipelineConfig', 'Pipeline config', $config);
        $deployConfig->setRows(40);
        if (!$this->pipelineFileExists()) {
            $deployConfig->setDescription(
                "No pipeline is configured for this environment. Saving content here will generate a new template."
            );
        }
        $fields->addFieldsToTab('Root.PipelineSettings', array(
            FieldGroup::create(
                CheckboxField::create('DryRunEnabled', 'Enable dry-run?')
            )
                ->setTitle('Pipeline Options')
                ->setDescription(
                    "Allows admins to run simulated pipelines without triggering deployments or notifications."
                ),
            $deployConfig
        ));
    }

    /**
     */
    public function onBeforeWrite()
    {
        parent::onBeforeWrite();
        if ($this->Name && $this->Name . '.rb' != $this->Filename) {
            $this->Filename = $this->Name . '.rb';
        }
        $this->checkEnvironmentPath();
        $this->writeConfigFile();
        $this->writePipelineFile();
    }

    public function onAfterWrite()
    {
        parent::onAfterWrite();

        if ($this->Usage == 'Production' || $this->Usage == 'UAT') {
            $conflicting = DNEnvironment::get()
                ->filter('ProjectID', $this->ProjectID)
                ->filter('Usage', $this->Usage)
                ->exclude('ID', $this->ID);

            foreach ($conflicting as $otherEnvironment) {
                $otherEnvironment->Usage = 'Unspecified';
                $otherEnvironment->write();
            }
        }
    }


    /**
     * Ensure that environment paths are setup on the local filesystem
     */
    protected function checkEnvironmentPath()
    {
        // Create folder if it doesn't exist
        $configDir = dirname($this->getConfigFilename());
        if (!file_exists($configDir) && $configDir) {
            mkdir($configDir, 0777, true);
        }
    }

    /**
     * Write the deployment config file to filesystem
     */
    protected function writeConfigFile()
    {
        if (!$this->config()->get('allow_web_editing')) {
            return;
        }

        // Create a basic new environment config from a template
        if (!$this->envFileExists()
            && $this->Filename
            && $this->CreateEnvConfig
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        ) {
            $templateFile = $this->config()->template_file ?: BASE_PATH . '/deploynaut/environment.template';
            file_put_contents($this->getConfigFilename(), file_get_contents($templateFile));
        } elseif ($this->envFileExists() && $this->DeployConfig) {
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            file_put_contents($this->getConfigFilename(), $this->DeployConfig);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        }
    }

    /**
     * Write the pipeline config file to filesystem
     */
    protected function writePipelineFile()
    {
        if (!$this->config()->get('allow_web_editing')) {
            return;
        }
        $path = $this->getPipelineFilename();
        if ($this->PipelineConfig) {
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            // Update file
            file_put_contents($path, $this->PipelineConfig);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        } elseif ($this->isChanged('PipelineConfig') && file_exists($path)) {
            // Remove file if deleted
            unlink($path);
        }
    }

    /**
     * Delete any related config files
     */
    public function onAfterDelete()
    {
        parent::onAfterDelete();
        // Create a basic new environment config from a template
        if ($this->config()->get('allow_web_editing') && $this->envFileExists()) {
            unlink($this->getConfigFilename());
        }

        $create = $this->CreateEnvironment();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        if ($create && $create->exists()) {
            $create->delete();
        }
    }

    /**
     * @return string
     */
    protected function getEnvironmentConfig()
    {
        if (!$this->envFileExists()) {
            return '';
        }
        return file_get_contents($this->getConfigFilename());
    }

    /**
     * @return boolean
     */
    protected function envFileExists()
    {
        if (!$this->getConfigFilename()) {
            return false;
        }
        return file_exists($this->getConfigFilename());
    }

    /**
     * Returns the path to the ruby config file
     *
     * @return string
     */
    public function getConfigFilename()
    {
        if (!$this->Project()->exists()) {
            return '';
        }
        if (!$this->Filename) {
            return '';
        }
        return $this->DNData()->getEnvironmentDir() . '/' . $this->Project()->Name . '/' . $this->Filename;
    }

    /**
     * Returns the path to the {@link Pipeline} configuration for this environment.
     * Uses the same path and filename as the capistrano config, but with .yml extension.
     *
     * @return string
     */
    public function getPipelineFilename()
    {
        $name = $this->getConfigFilename();
        if (!$name) {
            return null;
        }
        $path = pathinfo($name);
        if ($path) {
            return $path['dirname'] . '/' . $path['filename'] . '.yml';
        }
    }

    /**
     * Does this environment have a pipeline config file
     *
     * @return boolean
     */
    protected function pipelineFileExists()
    {
        $filename = $this->getPipelineFilename();
        if (empty($filename)) {
            return false;
        }
        return file_exists($filename);
    }

    /**
     * Helper function to convert a multi-dimensional array (associative or indexed) to an {@link ArrayList} or
     * {@link ArrayData} object structure, so that values can be used in templates.
     *
     * @param array $array The (single- or multi-dimensional) array to convert
     * @return object Either an {@link ArrayList} or {@link ArrayData} object, or the original item ($array) if $array
     * isn't an array.
     */
    public static function array_to_viewabledata($array)
    {
        // Don't transform non-arrays
        if (!is_array($array)) {
            return $array;
        }

        // Figure out whether this is indexed or associative
        $keys = array_keys($array);
        $assoc = ($keys != array_keys($keys));
        if ($assoc) {
            // Treat as viewable data
            $data = new ArrayData(array());
            foreach ($array as $key => $value) {
                $data->setField($key, self::array_to_viewabledata($value));
            }
            return $data;
        } else {
            // Treat this as basic non-associative list
            $list = new ArrayList();
            foreach ($array as $value) {
                $list->push(self::array_to_viewabledata($value));
            }
            return $list;
        }
    }



    /**
     * Helper function to retrieve filtered commits from an environment
     * this environment depends on
     *
     * @return DataList
     */
    public function getDependentFilteredCommits()
    {
        // check if this environment depends on another environemnt
        $dependsOnEnv = $this->DependsOnEnvironment();
        if (empty($dependsOnEnv)) {
            return null;
        }

        // Check if there is a filter
        $config = $this->GenericPipelineConfig();
        $filter = isset($config->PipelineConfig->FilteredCommits)
            ? $config->PipelineConfig->FilteredCommits
            : null;
        if (empty($filter)) {
            return null;
        }

        // Create and execute filter
        if (!class_exists($filter)) {
            throw new Exception(sprintf("Class %s does not exist", $filter));
        }
        $commitClass = $filter::create();
        // setup the environment to check for commits
        $commitClass->env = $dependsOnEnv;
        return $commitClass->getCommits();
    }

    /**
     * Enable the maintenance page
     *
     * @param DeploynautLogFile $log
     */
    public function enableMaintenace($log)
    {
        $this->Backend()
            ->enableMaintenance($this, $log, $this->Project());
    }

    /**
     * Disable maintenance page
     *
     * @param DeploynautLogFile $log
     */
    public function disableMaintenance($log)
    {
        $this->Backend()
            ->disableMaintenance($this, $log, $this->Project());
    }

    protected function validate()
    {
        $result = parent::validate();
        $backend = $this->Backend();

        if (strcasecmp('test', $this->Name) === 0 && get_class($backend) == 'CapistranoDeploymentBackend') {
            $result->error('"test" is not a valid environment name when using Capistrano backend.');
        }

        return $result;
    }
}

silverstripe / deploynaut

Pull Request — master (#489)

DNEnvironment::getPipelineFilename() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like
