install.xml

<?xml version="1.0"?>

<!--
  @file install.xml
  Targets for installing the-build templates into a project.

  Copyright 2016, 2017, 2018 Palantir.net, Inc.
  -->

<project name="install" default="install">

    <!-- This is required to set ${composer.composer} for installing for Platform.sh -->
    <import file="the-build.xml" />

    <property name="build.dir" value="${application.startdir}" />
    <property name="build.env" value="default" />
    <basename property="projectname" file="${build.dir}" suffix="local" />
    <resolvepath file="${phing.dir.install}/../" propertyName="build.thebuild.dir" />

    <!-- Provide the <copyproperties /> task. -->
    <taskdef name="copyproperties" classname="TheBuild\CopyPropertiesTask" />

    <!-- Target: install -->
    <target name="install" description="Install the Phing build template into your project.">

        <!-- Configuration prompts.
             This creates the initial project properties file.
             -->
        <echo message="Configure the default environment..." />

        <!-- Use existing configuration first (e.g. reinstalling the-build) -->
        <if>
            <available file="${application.startdir}/.the-build/build.yml" />
            <then>
                <property file="${application.startdir}/.the-build/build.yml" prefix="default" />
            </then>
        </if>
        <!-- ... then load the defaults. -->
        <property file="${build.thebuild.dir}/defaults.yml" prefix="default" />
        <mkdir dir="${application.startdir}/.the-build" />

        <!-- Generate a hash salt for Drupal. -->
        <php expression="hash('sha256', print_r($_SERVER, TRUE))" returnProperty="hash_salt" />
        <mkdir dir="${application.startdir}/config" />
        <echo message="${hash_salt}" file="${application.startdir}/config/salt.txt" />

        <!-- Prompt for the site name. -->
        <propertyprompt propertyName="projectname.new" defaultValue="${projectname}" promptText="Machine name for this project" promptCharacter=":" />
        <property name="projectname" value="${projectname.new}" override="true" />

        <!-- Prompt for the Drupal URI. -->
        <property name="default.drupal.sites.default.uri" value="https://${projectname}.ddev.site" />
        <propertyprompt propertyName="drupal.sites.default.uri" defaultValue="${default.drupal.sites.default.uri}" promptText="Drupal URI" promptCharacter=":" />

        <!-- Prompt for the web host. -->
        <input propertyName="build.host" validArgs="acquia,pantheon,platformsh,other" message="Hosting platform" promptChar=":" />

        <!-- Set and prompt for additional properties based on the host. We're not going
             very deep here at the moment because there are several elements of the setup
             that can vary, especially around the host-specific settings.php files. -->
        <switch value="${build.host}">
            <case value="acquia">
                <property name="drupal.root" value="docroot" override="true" />
            </case>
            <case value="pantheon">
              <property name="drupal.root" value="web" override="true" />
            </case>
            <case value="platformsh">
              <property name="drupal.root" value="web" override="true" />
            </case>
            <default>
              <property name="drupal.root" value="web" override="true" />
            </default>
        </switch>

        <!-- Load the defaults into the global namespace, which won't overwrite the properties the user just set. -->
        <property file="${build.thebuild.dir}/defaults.yml" />
        <!-- Copy defaults to fill in the sites array. -->
        <copyproperties fromPrefix="drupal.sites._defaults" toPrefix="drupal.sites.default" override="false" />

        <!-- Write the default properties file. -->
        <copy file="${phing.dir.install}/../defaults/install/the-build/build.yml" tofile="${application.startdir}/.the-build/build.yml" overwrite="true">
            <filterchain>
                <expandproperties />
            </filterchain>
        </copy>

        <phingcall target="setup-web-root" />
        <phingcall target="setup-templates" />
        <phingcall target="setup-host" />

        <!-- Run the first build. -->
        <phing dir="${application.startdir}" target="build" inheritAll="false" />

        <!-- If Drupal has a database connection available, offer to install Drupal. -->
        <trycatch>
            <try>
                <!-- The 'haltonfailure' attribute seems to have the opposite behavior
                     from what is described in the Phing documentation. -->
                <phing dir="${application.startdir}" target="drupal-has-database-connection" inheritAll="false" haltonfailure="true" />

                <!-- This code will run only when a database connection is available. -->
                <input propertyName="install_now" validArgs="y,n" message="Install Drupal now " promptChar="?" />
                <if>
                    <equals arg1="${install_now}" arg2="y" />
                    <then>
                        <phing dir="${application.startdir}" target="drupal-first-install" inheritAll="false" />
                    </then>
                </if>
            </try>
            <catch>
                <!-- Drupal will be installed later, if not manually then by the 'install'
                     target in the default build.xml. -->
                <echo>Skipping Drupal installation, since the database is not available.

            From within a development environment, you can run `phing install` to install Drupal.
                </echo>
            </catch>
        </trycatch>

        <!-- Whitespace is intentional. -->
        <echo>

            Successfully installed the-build. Next, you may want to run:

              $> phing list
              $> phing install
              $> phing test</echo>
    </target>


    <!-- Target: setup-web-root

         If the drupal.root directory doesn't exist, then we need to move it from the other location (web /
         docroot).-->
    <target name="setup-web-root" depends="set-site">
        <available file="${build.dir}/${drupal.root}/core" type="dir" property="drupal.root.exists" value="true" />

        <if>
            <not><equals arg1="${drupal.root.exists}" arg2="1" /></not>
            <then>
                <!-- The one that's available is the location we're moving from. -->
                <available file="${build.dir}/web/core" type="dir" property="drupal.root.old" value="web" />
                <available file="${build.dir}/docroot/core" type="dir" property="drupal.root.old" value="docroot" />
                <available file="${build.dir}/${drupal.root}/sites/default/settings.ddev.php" type="file" property="ddev_settings_exists" value="true" />
                <available file="${build.dir}/${drupal.root.old}/sites/default/settings.ddev.php" type="file" property="old_ddev_settings_exists" value="true" />

                <!-- Copy settings.ddev.php if it doesn't exist in the old drupal root. -->
                <if>
                    <and>
                      <equals arg1="${ddev_settings_exists}" arg2="1" />
                      <not><equals arg1="${old_ddev_settings_exists}" arg2="1" /></not>
                    </and>
                    <then>
                        <echo msg="Copying settings.ddev.php to old drupal root." />
                        <exec command="cp ${drupal.root}/sites/default/settings.ddev.php ${drupal.root.old}/sites/default" dir="${build.dir}" checkreturn="true" logoutput="true" />
                    </then>
                </if>

                <echo msg="Moving the ${drupal.root.old}/ directory to ${drupal.root}/" />
                <exec command="rm -rf ${drupal.root}" dir="${build.dir}" />
                <exec command="mv ${drupal.root.old} ${drupal.root}" dir="${build.dir}" checkreturn="true" logoutput="true" />

                <echo msg="Editing your composer.json to install Drupal in ${drupal.root}/" />
                <reflexive>
                    <fileset dir="${build.dir}" includes="composer.json" />
                    <filterchain>
                        <replaceregexp>
                            <regexp pattern='"${drupal.root.old}/(core|libraries|modules|profiles|themes)' replace='"${drupal.root}/\1' />
                            <regexp pattern='"web-root": "${drupal.root.old}/"' replace='"web-root": "${drupal.root}/"' />
                        </replaceregexp>
                    </filterchain>
                </reflexive>

                <echo msg="Updating your composer.lock hash" />
                <exec command="composer update --lock" dir="${application.startdir}" />

            </then>
        </if>
    </target>


    <!-- Target: setup-templates -->
    <target name="setup-templates" depends="set-site">
        <!-- Set the project name in the ddev config. -->
        <replaceregexp match="name: .*" replace="name: ${projectname}" file="${application.startdir}/.ddev/config.yaml" />

        <!-- Copy the build file template.

             This doesn't do any property substitution except for the "projectname",
             which is the name of the install directory, and the "host", set by prompt
             above.

             We can't do general property substitution here because this is a phing
             project file that uses phing variables.
             -->
        <copy file="${phing.dir.install}/../defaults/install/build.xml" tofile="${application.startdir}/build.xml" overwrite="true">
            <filterchain>
                <replacetokens>
                    <token key="projectname" value="${projectname}" />
                    <token key="host" value="${build.host}" />
                </replacetokens>
            </filterchain>
        </copy>

        <!-- Copy the phpcs.xml file template.
             -->
        <echo>Updating pcpcs.xml file for project root.</echo>
        <if>
            <equals arg1="${build.host}" arg2="acquia"/>
            <then>
                <property name="phpcs_dir" value="docroot"/>
            </then>
            <else>
                <property name="phpcs_dir" value="web"/>
            </else>
        </if>
        <copy file="${phing.dir.install}/../defaults/install/phpcs.xml" tofile="${application.startdir}/phpcs.xml" overwrite="true">
            <filterchain>
                <replacetokens>
                    <token key="projectname" value="${projectname}" />
                    <token key="webroot" value="${phpcs_dir}" />
                </replacetokens>
            </filterchain>
        </copy>

        <!-- Copy the phpmd.xml file template.
             -->
        <echo>Updating phpmd.xml file for project root.</echo>
        <if>
            <equals arg1="${build.host}" arg2="acquia"/>
            <then>
                <property name="phpmd_dir" value="docroot"/>
            </then>
            <else>
                <property name="phpmd_dir" value="web"/>
            </else>
        </if>
        <copy file="${phing.dir.install}/../defaults/install/phpmd.xml" tofile="${application.startdir}/phpmd.xml" overwrite="true">
            <filterchain>
                <replacetokens>
                    <token key="projectname" value="${projectname}" />
                    <token key="webroot" value="${phpmd_dir}" />
                </replacetokens>
            </filterchain>
        </copy>

         <!-- Copy other templates into place.
             These copy commands use <expandproperties /> for property substitution.
             -->
        <!-- Copy the behat template. -->
        <copy file="${phing.dir.install}/../defaults/install/behat.yml" tofile="${application.startdir}/behat.yml" overwrite="true">
            <filterchain>
                <expandproperties />
                <!-- Sometimes behat has issues with HTTPS, especially when
                     using the php built-in webserver on CI. -->
                <replaceregexp>
                    <regexp pattern="https:" replace="http:" />
                </replaceregexp>
            </filterchain>
        </copy>

        <!-- Copy the CircleCI configuration -->
        <copy todir="${application.startdir}/" overwrite="true">
            <fileset dir="${phing.dir.install}/../defaults/install" includes=".circleci/" />
            <filterchain>
                <expandproperties />
            </filterchain>
        </copy>

        <!-- Copy the CircleCI properties. -->
        <copy file="${phing.dir.install}/../defaults/install/the-build/build.circleci.yml" tofile="${application.startdir}/.the-build/build.circleci.yml" overwrite="true" />

        <!-- Copy Drush configuration and aliases file templates. -->
        <copy file="${phing.dir.install}/../defaults/install/drush/drush.yml" tofile="${application.startdir}/drush/drush.yml" overwrite="true">
            <filterchain>
                <expandproperties />
            </filterchain>
        </copy>
        <copy file="${phing.dir.install}/../defaults/install/drush/sites/projectname.site.yml" tofile="${application.startdir}/drush/sites/${projectname}.site.yml" overwrite="true">
            <filterchain>
                <replacetokens>
                    <token key="uri" value="${drupal.sites.default.uri}" />
                </replacetokens>
            </filterchain>
        </copy>

        <!-- Set up the Drupal sites directory. -->
        <property name="drupal.site.dir" value="default" />
        <mkdir dir="${build.dir}/${drupal.root}/sites/${drupal.site.dir}" />
        <chmod mode="750" file="${build.dir}/${drupal.root}/sites/default/" />
        <mkdir dir="${build.dir}/${drupal.root}/sites/${drupal.site.dir}/files" />
    </target>


    <!-- Target: setup-host -->
    <target name="setup-host" depends="set-site" description="Add host-specific configuration files.">
        <fail unless="build.host"/>

        <switch value="${build.host}">
            <case value="acquia">
                <!-- Site-level setup -->
                <!-- @see https://docs.acquia.com/cloud-platform/performance/memcached/enable/ -->
                <composer command="require" composer="${composer.composer}">
                    <arg line="--working-dir ${application.startdir}"/>
                    <arg value="drupal/memcache"/>
                </composer>
            </case>
            
            <case value="pantheon">
                <!-- Project-level setup -->
                <copy file="${build.thebuild.dir}/defaults/install/pantheon.yml" todir="${application.startdir}" overwrite="true"/>
                <!-- Site-level setup -->
                <httpget url="https://raw.githubusercontent.com/pantheon-systems/drops-8/default/sites/default/settings.pantheon.php" dir="${build.dir}/${drupal.root}/sites/${drupal.site.dir}"/>
            </case>

            <case value="platformsh">
                <!-- Project-level setup -->
                <copy file="${build.thebuild.dir}/defaults/install/.platform.app.yaml" todir="${application.startdir}" overwrite="true"/>
                <copy todir="${application.startdir}/.platform" overwrite="true">
                    <fileset dir="${build.thebuild.dir}/defaults/install/.platform"/>
                </copy>
                <httpget url="https://raw.githubusercontent.com/platformsh/template-drupal8/master/.environment" dir="${build.dir}/"/>

                <!-- Site-level setup -->
                <!-- Removing this due new packages for specific host will be added via ${host.host.host_packages}. See host-install-packages target. -->
                <httpget url="https://raw.githubusercontent.com/platformsh/template-drupal8/master/web/sites/default/settings.platformsh.php" dir="${build.dir}/${drupal.root}/sites/${drupal.site.dir}"/>
            </case>

            <default/>
        </switch>

        <!-- Installing Specific Host Packages. -->
        <phingcall target="host-install-packages" />
    </target>

    <!-- Target: host-install-packages -->
    <target name="host-install-packages" description="Install composer specific packages for host.">
        <if>
          <isset property="build.host_packages.${build.host}"/>
        <then>
            <foreach list="${build.host_packages.${build.host}}" param="package" target="install-package" />
        </then>
        </if>
    </target>

    <!-- Target: install-package -->
    <target name="install-package" description="Install a package using Composer in the application start directory">
      <fail unless="package" />

      <composer command="require" composer="${composer.composer}">
        <arg line="--working-dir ${application.startdir}"/>
        <arg value="${package}" />
      </composer>
    </target>

</project>