silverstripe / multi-domain

tests/MultiDomainDomainTest.php

Indentation +164 added lines, -164 removed lines

@@ -8,168 +8,168 @@
 
 class MultiDomainDomainTest extends SapphireTest
 {
-    /**
-     * Set up some test domain data for testing
-     *
-     * {@inheritDoc}
-     */
-    public function setUp()
-    {
-        parent::setUp();
-        Config::nest();
-
-        Config::inst()->remove(MultiDomain::class, 'domains');
-        Config::inst()->update(MultiDomain::class, 'domains', array(
-            'primary' => array(
-                'hostname' => 'example.com'
-            ),
-            'store' => array(
-                'hostname' => 'example-store.com',
-                'resolves_to' => 'shop/store',
-                'allow' => array(
-                    'admin/*',
-                    'Security/*',
-                    'my-custom-webhook/'
-                )
-            ),
-            'configurable' => array(
-                'hostname' => 'MY_CONSTANT_HOSTNAME'
-            ),
-            'forceful' => array(
-                'hostname' => 'forced.com',
-                'force' => array(
-                    'buy-now/*'
-                )
-            )
-        ));
-    }
-
-    /**
-     * Test that a hostname defined in a constant will override the default configuration, otherwise the default
-     * configuration for the domain is returned
-     */
-    public function testGetHostname()
-    {
-        $configurableDomain = MultiDomain::get_domain('configurable');
-        define('MY_CONSTANT_HOSTNAME', 'I am a constant');
-        $this->assertSame('I am a constant', $configurableDomain->getHostname());
-
-        $storeDomain = MultiDomain::get_domain('store');
-        $this->assertSame('example-store.com', $storeDomain->getHostname());
-    }
-
-    /**
-     * Test that the domain's "resolves to" property is returned for the URL if it is defined, otherwise null
-     */
-    public function testGetUrl()
-    {
-        $primaryDomain = MultiDomain::get_domain('primary');
-        $this->assertNull($primaryDomain->getURL());
-
-        $storeDomain = MultiDomain::get_domain('store');
-        $this->assertSame('shop/store', $storeDomain->getURL());
-    }
-
-    /**
-     * Test that a domain can be identified as the primary domain or otherwise
-     */
-    public function testIsPrimary()
-    {
-        $this->assertTrue(MultiDomain::get_primary_domain()->isPrimary());
-        $this->assertFalse(MultiDomain::get_domain('store')->isPrimary());
-    }
-
-    /**
-     * When the request URI matches one of the allowed rules for a domain, the isActive method should return false
-     */
-    public function testIsActiveReturnsFalseWhenRequestUriIsAllowedPath()
-    {
-        $domain = MultiDomain::get_domain('store');
-        $domain->setRequestUri('/Security/login');
-        $this->assertFalse($domain->isActive());
-    }
-
-    /**
-     * When a subdomain is "allowed" and is requested, subdomains should be allowed through "isActive" as well
-     * as the primary domain
-     */
-    public function testSubdomainsAllowedInIsActiveWhenConfigured()
-    {
-        Config::inst()->update(MultiDomain::class, 'allow_subdomains', true);
-
-        $domain = MultiDomain::get_domain('store')
-            ->setRequestUri('/some/page')
-            ->setHttpHost('api.example-store.com');
-
-        $this->assertTrue($domain->isActive());
-    }
-
-    /**
-     * The default behaviour would be that if the current host from the request matchese that of the domain model
-     * then isActive should be true
-     */
-    public function testReturnActiveIfCurrentHostMatchesDomainsHostname()
-    {
-        $domain = MultiDomain::get_domain('primary')
-            ->setRequestUri('/another/page')
-            ->setHttpHost('example.com');
-
-        $this->assertTrue($domain->isActive());
-    }
-
-    /**
-     * getNativeUrl should not be used on the primary domain
-     *
-     * @expectedException Exception
-     * @expectedExceptionMessage Cannot convert a native URL on the primary domain
-     */
-    public function testGetNativeUrlThrowsExceptionOnPrimaryDomain()
-    {
-        MultiDomain::get_primary_domain()->getNativeUrl('foo');
-    }
-
-    /**
-     * Test that a URL segment can be added to the domain's URL and returned as a "native URL"
-     */
-    public function testGetNativeUrl()
-    {
-        $domain = MultiDomain::get_domain('store');
-        $this->assertSame('shop/store/foo/bar', $domain->getNativeUrl('foo/bar'));
-    }
-
-    /**
-     * "Allowed" and "forced" URLs should just be returned from getNativeUrl as is
-     */
-    public function testGetNativeUrlReturnsInputWhenUrlIsAllowedOrForced()
-    {
-        $domain = MultiDomain::get_domain('store');
-        $this->assertSame('my-custom-webhook/', $domain->getNativeUrl('my-custom-webhook/'));
-
-        $domain = MultiDomain::get_domain('forceful');
-        $this->assertSame('buy-now/whatever', $domain->getNativeUrl('buy-now/whatever'));
-    }
-
-    /**
-     * The primary domain and "allowed" route matches should be returned as it
-     */
-    public function testGetVanityUrlReturnsInputWhenUrlIsAllowedOrIsPrimaryDomain()
-    {
-        $this->assertSame('/pages/info', MultiDomain::get_primary_domain()->getVanityUrl('/pages/info'));
-        $this->assertSame('/Security/login', MultiDomain::get_domain('store')->getVanityUrl('/Security/login'));
-    }
-
-    /**
-     * Non-primary domains and un-allowed route matches should be returned without their URL for vanity
-     */
-    public function testGetVanityUrl()
-    {
-        $this->assertSame('partners/', MultiDomain::get_domain('store')->getVanityUrl('shop/store/partners/'));
-        $this->assertSame('foo/bar', MultiDomain::get_domain('store')->getVanityUrl('shop/store/foo/bar'));
-    }
-
-    public function tearDown()
-    {
-        Config::unnest();
-        parent::tearDown();
-    }
+	/**
+	 * Set up some test domain data for testing
+	 *
+	 * {@inheritDoc}
+	 */
+	public function setUp()
+	{
+		parent::setUp();
+		Config::nest();
+
+		Config::inst()->remove(MultiDomain::class, 'domains');
+		Config::inst()->update(MultiDomain::class, 'domains', array(
+			'primary' => array(
+				'hostname' => 'example.com'
+			),
+			'store' => array(
+				'hostname' => 'example-store.com',
+				'resolves_to' => 'shop/store',
+				'allow' => array(
+					'admin/*',
+					'Security/*',
+					'my-custom-webhook/'
+				)
+			),
+			'configurable' => array(
+				'hostname' => 'MY_CONSTANT_HOSTNAME'
+			),
+			'forceful' => array(
+				'hostname' => 'forced.com',
+				'force' => array(
+					'buy-now/*'
+				)
+			)
+		));
+	}
+
+	/**
+	 * Test that a hostname defined in a constant will override the default configuration, otherwise the default
+	 * configuration for the domain is returned
+	 */
+	public function testGetHostname()
+	{
+		$configurableDomain = MultiDomain::get_domain('configurable');
+		define('MY_CONSTANT_HOSTNAME', 'I am a constant');
+		$this->assertSame('I am a constant', $configurableDomain->getHostname());
+
+		$storeDomain = MultiDomain::get_domain('store');
+		$this->assertSame('example-store.com', $storeDomain->getHostname());
+	}
+
+	/**
+	 * Test that the domain's "resolves to" property is returned for the URL if it is defined, otherwise null
+	 */
+	public function testGetUrl()
+	{
+		$primaryDomain = MultiDomain::get_domain('primary');
+		$this->assertNull($primaryDomain->getURL());
+
+		$storeDomain = MultiDomain::get_domain('store');
+		$this->assertSame('shop/store', $storeDomain->getURL());
+	}
+
+	/**
+	 * Test that a domain can be identified as the primary domain or otherwise
+	 */
+	public function testIsPrimary()
+	{
+		$this->assertTrue(MultiDomain::get_primary_domain()->isPrimary());
+		$this->assertFalse(MultiDomain::get_domain('store')->isPrimary());
+	}
+
+	/**
+	 * When the request URI matches one of the allowed rules for a domain, the isActive method should return false
+	 */
+	public function testIsActiveReturnsFalseWhenRequestUriIsAllowedPath()
+	{
+		$domain = MultiDomain::get_domain('store');
+		$domain->setRequestUri('/Security/login');
+		$this->assertFalse($domain->isActive());
+	}
+
+	/**
+	 * When a subdomain is "allowed" and is requested, subdomains should be allowed through "isActive" as well
+	 * as the primary domain
+	 */
+	public function testSubdomainsAllowedInIsActiveWhenConfigured()
+	{
+		Config::inst()->update(MultiDomain::class, 'allow_subdomains', true);
+
+		$domain = MultiDomain::get_domain('store')
+			->setRequestUri('/some/page')
+			->setHttpHost('api.example-store.com');
+
+		$this->assertTrue($domain->isActive());
+	}
+
+	/**
+	 * The default behaviour would be that if the current host from the request matchese that of the domain model
+	 * then isActive should be true
+	 */
+	public function testReturnActiveIfCurrentHostMatchesDomainsHostname()
+	{
+		$domain = MultiDomain::get_domain('primary')
+			->setRequestUri('/another/page')
+			->setHttpHost('example.com');
+
+		$this->assertTrue($domain->isActive());
+	}
+
+	/**
+	 * getNativeUrl should not be used on the primary domain
+	 *
+	 * @expectedException Exception
+	 * @expectedExceptionMessage Cannot convert a native URL on the primary domain
+	 */
+	public function testGetNativeUrlThrowsExceptionOnPrimaryDomain()
+	{
+		MultiDomain::get_primary_domain()->getNativeUrl('foo');
+	}
+
+	/**
+	 * Test that a URL segment can be added to the domain's URL and returned as a "native URL"
+	 */
+	public function testGetNativeUrl()
+	{
+		$domain = MultiDomain::get_domain('store');
+		$this->assertSame('shop/store/foo/bar', $domain->getNativeUrl('foo/bar'));
+	}
+
+	/**
+	 * "Allowed" and "forced" URLs should just be returned from getNativeUrl as is
+	 */
+	public function testGetNativeUrlReturnsInputWhenUrlIsAllowedOrForced()
+	{
+		$domain = MultiDomain::get_domain('store');
+		$this->assertSame('my-custom-webhook/', $domain->getNativeUrl('my-custom-webhook/'));
+
+		$domain = MultiDomain::get_domain('forceful');
+		$this->assertSame('buy-now/whatever', $domain->getNativeUrl('buy-now/whatever'));
+	}
+
+	/**
+	 * The primary domain and "allowed" route matches should be returned as it
+	 */
+	public function testGetVanityUrlReturnsInputWhenUrlIsAllowedOrIsPrimaryDomain()
+	{
+		$this->assertSame('/pages/info', MultiDomain::get_primary_domain()->getVanityUrl('/pages/info'));
+		$this->assertSame('/Security/login', MultiDomain::get_domain('store')->getVanityUrl('/Security/login'));
+	}
+
+	/**
+	 * Non-primary domains and un-allowed route matches should be returned without their URL for vanity
+	 */
+	public function testGetVanityUrl()
+	{
+		$this->assertSame('partners/', MultiDomain::get_domain('store')->getVanityUrl('shop/store/partners/'));
+		$this->assertSame('foo/bar', MultiDomain::get_domain('store')->getVanityUrl('shop/store/foo/bar'));
+	}
+
+	public function tearDown()
+	{
+		Config::unnest();
+		parent::tearDown();
+	}
 }

tests/MultiDomainTest.php

Indentation +83 added lines, -83 removed lines

@@ -9,96 +9,96 @@
 
 class MultiDomainTest extends SapphireTest
 {
-    /**
-     * Set up some test domain configuration
-     *
-     * {@inheritDoc}
-     */
-    public function setUp()
-    {
-        parent::setUp();
-        Config::nest();
+	/**
+	 * Set up some test domain configuration
+	 *
+	 * {@inheritDoc}
+	 */
+	public function setUp()
+	{
+		parent::setUp();
+		Config::nest();
 
-        Config::inst()->remove(MultiDomain::class, 'domains');
-        Config::inst()->update(MultiDomain::class, 'domains', array(
-            'primary' => array(
-                'hostname' => 'foo.bar',
-                'resolves_to' => 'bar.baz'
-            ),
-            'secondary' => array(
-                'hostname' => 'localhost',
-                'resolves_to' => 'local.dev'
-            )
-        ));
-    }
+		Config::inst()->remove(MultiDomain::class, 'domains');
+		Config::inst()->update(MultiDomain::class, 'domains', array(
+			'primary' => array(
+				'hostname' => 'foo.bar',
+				'resolves_to' => 'bar.baz'
+			),
+			'secondary' => array(
+				'hostname' => 'localhost',
+				'resolves_to' => 'local.dev'
+			)
+		));
+	}
 
-    /**
-     * Test that a MultiDomainDomain can be returned from the configured domains
-     */
-    public function testGetDomain()
-    {
-        $this->assertNull(MultiDomain::get_domain('does-not-exist'));
-        $this->assertInstanceOf(MultiDomainDomain::class, MultiDomain::get_domain('primary'));
-    }
+	/**
+	 * Test that a MultiDomainDomain can be returned from the configured domains
+	 */
+	public function testGetDomain()
+	{
+		$this->assertNull(MultiDomain::get_domain('does-not-exist'));
+		$this->assertInstanceOf(MultiDomainDomain::class, MultiDomain::get_domain('primary'));
+	}
 
-    /**
-     * Test that all domains can be returned, with or without the primary domain
-     *
-     * @dataProvider getAllDomainsProvider
-     * @param bool $withPrimary
-     */
-    public function testGetAllDomains($withPrimary)
-    {
-        $result = MultiDomain::get_all_domains($withPrimary);
-        $this->assertInternalType('array', $result);
-        $this->assertNotEmpty($result);
+	/**
+	 * Test that all domains can be returned, with or without the primary domain
+	 *
+	 * @dataProvider getAllDomainsProvider
+	 * @param bool $withPrimary
+	 */
+	public function testGetAllDomains($withPrimary)
+	{
+		$result = MultiDomain::get_all_domains($withPrimary);
+		$this->assertInternalType('array', $result);
+		$this->assertNotEmpty($result);
 
-        $expectedCount = $withPrimary ? 2 : 1;
-        $this->assertCount($expectedCount, $result);
-    }
+		$expectedCount = $withPrimary ? 2 : 1;
+		$this->assertCount($expectedCount, $result);
+	}
 
-    /**
-     * @return array[]
-     */
-    public function getAllDomainsProvider()
-    {
-        return array(
-            array(true),
-            array(false)
-        );
-    }
+	/**
+	 * @return array[]
+	 */
+	public function getAllDomainsProvider()
+	{
+		return array(
+			array(true),
+			array(false)
+		);
+	}
 
-    /**
-     * Test that the primary domain can be returned
-     */
-    public function testGetPrimaryDomain()
-    {
-        $result = MultiDomain::get_primary_domain();
-        $this->assertInstanceOf(MultiDomainDomain::class, $result);
-        $this->assertTrue($result->isPrimary());
-    }
+	/**
+	 * Test that the primary domain can be returned
+	 */
+	public function testGetPrimaryDomain()
+	{
+		$result = MultiDomain::get_primary_domain();
+		$this->assertInstanceOf(MultiDomainDomain::class, $result);
+		$this->assertTrue($result->isPrimary());
+	}
 
-    /**
-     * Test that the correct domain can be returned by a provided URL
-     */
-    public function testDomainForUrl()
-    {
-        $result = MultiDomain::domain_for_url('foo.bar/my-page');
-        $this->assertInstanceOf(MultiDomainDomain::class, $result);
-        $this->assertSame('primary', $result->getKey());
-    }
+	/**
+	 * Test that the correct domain can be returned by a provided URL
+	 */
+	public function testDomainForUrl()
+	{
+		$result = MultiDomain::domain_for_url('foo.bar/my-page');
+		$this->assertInstanceOf(MultiDomainDomain::class, $result);
+		$this->assertSame('primary', $result->getKey());
+	}
 
-    /**
-     * Test that if a URL doesn't match any domain then the primary domain is returned
-     */
-    public function testDomainForUrlDefaultsToPrimaryDomain()
-    {
-        $this->assertTrue(MultiDomain::domain_for_url('does-not-exist.com')->isPrimary());
-    }
+	/**
+	 * Test that if a URL doesn't match any domain then the primary domain is returned
+	 */
+	public function testDomainForUrlDefaultsToPrimaryDomain()
+	{
+		$this->assertTrue(MultiDomain::domain_for_url('does-not-exist.com')->isPrimary());
+	}
 
-    public function tearDown()
-    {
-        Config::unnest();
-        parent::tearDown();
-    }
+	public function tearDown()
+	{
+		Config::unnest();
+		parent::tearDown();
+	}
 }

src/MultiDomainRequestFilter.php

Indentation +52 added lines, -52 removed lines

@@ -20,62 +20,62 @@
 class MultiDomainRequestFilter implements RequestFilter
 {
 
-    /**
-     * Gets the active domain, and sets its URL to the native one, with a vanity
-     * URL in the request
-     *
-     * @param  HTTPRequest $request
-     * @param  Session     $session
-     * @param  DataModel   $model
-     */
-    public function preRequest(HTTPRequest $request, Session $session, DataModel $model)
-    {
+	/**
+	 * Gets the active domain, and sets its URL to the native one, with a vanity
+	 * URL in the request
+	 *
+	 * @param  HTTPRequest $request
+	 * @param  Session     $session
+	 * @param  DataModel   $model
+	 */
+	public function preRequest(HTTPRequest $request, Session $session, DataModel $model)
+	{
 
-        if (Director::is_cli()) {
-            return;
-        }
+		if (Director::is_cli()) {
+			return;
+		}
 
-        // Not the best place for validation, but _config.php is too early.
-        if (!MultiDomain::get_primary_domain()) {
-            throw new Exception(
-                'MultiDomain must define a "' . MultiDomain::KEY_PRIMARY . '" domain in the config, under "domains"'
-            );
-        }
+		// Not the best place for validation, but _config.php is too early.
+		if (!MultiDomain::get_primary_domain()) {
+			throw new Exception(
+				'MultiDomain must define a "' . MultiDomain::KEY_PRIMARY . '" domain in the config, under "domains"'
+			);
+		}
 
-        foreach (MultiDomain::get_all_domains() as $domain) {
-            if (!$domain->isActive()) {
-                continue;
-            }
+		foreach (MultiDomain::get_all_domains() as $domain) {
+			if (!$domain->isActive()) {
+				continue;
+			}
 
-            $url = $this->createNativeURLForDomain($domain);
-            $parts = explode('?', $url);
-            $request->setURL($parts[0]);
-        }
-    }
+			$url = $this->createNativeURLForDomain($domain);
+			$parts = explode('?', $url);
+			$request->setURL($parts[0]);
+		}
+	}
 
-    /**
-     * Post request noop
-     * @param  HTTPRequest  $request
-     * @param  HTTPResponse $response
-     * @param  DataModel    $model
-     */
-    public function postRequest(HTTPRequest $request, HTTPResponse $response, DataModel $model)
-    {
-    }
+	/**
+	 * Post request noop
+	 * @param  HTTPRequest  $request
+	 * @param  HTTPResponse $response
+	 * @param  DataModel    $model
+	 */
+	public function postRequest(HTTPRequest $request, HTTPResponse $response, DataModel $model)
+	{
+	}
 
-    /**
-     * Creates a native URL for a domain. This functionality is abstracted so
-     * that other modules can overload it, e.g. translatable modules that
-     * have their own custom URLs.
-     *
-     * @param  MultiDomainDomain $domain
-     * @return string
-     */
-    protected function createNativeURLForDomain(MultiDomainDomain $domain)
-    {
-        return Controller::join_links(
-            Director::baseURL(),
-            $domain->getNativeURL($domain->getRequestUri())
-        );
-    }
+	/**
+	 * Creates a native URL for a domain. This functionality is abstracted so
+	 * that other modules can overload it, e.g. translatable modules that
+	 * have their own custom URLs.
+	 *
+	 * @param  MultiDomainDomain $domain
+	 * @return string
+	 */
+	protected function createNativeURLForDomain(MultiDomainDomain $domain)
+	{
+		return Controller::join_links(
+			Director::baseURL(),
+			$domain->getNativeURL($domain->getRequestUri())
+		);
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -38,7 +38,7 @@
         // Not the best place for validation, but _config.php is too early.
         if (!MultiDomain::get_primary_domain()) {
             throw new Exception(
-                'MultiDomain must define a "' . MultiDomain::KEY_PRIMARY . '" domain in the config, under "domains"'
+                'MultiDomain must define a "'.MultiDomain::KEY_PRIMARY.'" domain in the config, under "domains"'
             );
         }
 

src/MultiDomain.php

Indentation +65 added lines, -65 removed lines

@@ -14,77 +14,77 @@
  */
 class MultiDomain extends Object
 {
-    /**
-     * The key for the "primary" domain
-     *
-     * @var string
-     */
-    const KEY_PRIMARY = 'primary';
+	/**
+	 * The key for the "primary" domain
+	 *
+	 * @var string
+	 */
+	const KEY_PRIMARY = 'primary';
 
-    /**
-     * Given a url, get the domain that maps to it, e.g.
-     *
-     * /company/ -> silverstripe.com
-     * /company/partners -> silverstripe.com
-     * /community/forum -> silverstripe.org
-     *
-     * @param  string $url
-     * @return MultiDomainDomain
-     */
-    public static function domain_for_url($url)
-    {
-        $url = trim($url, '/');
+	/**
+	 * Given a url, get the domain that maps to it, e.g.
+	 *
+	 * /company/ -> silverstripe.com
+	 * /company/partners -> silverstripe.com
+	 * /community/forum -> silverstripe.org
+	 *
+	 * @param  string $url
+	 * @return MultiDomainDomain
+	 */
+	public static function domain_for_url($url)
+	{
+		$url = trim($url, '/');
 
-        foreach (self::get_all_domains() as $domain) {
-            if ($domain->hasURL($url)) {
-                return $domain;
-            }
-        }
+		foreach (self::get_all_domains() as $domain) {
+			if ($domain->hasURL($url)) {
+				return $domain;
+			}
+		}
 
-        return self::get_primary_domain();
-    }
+		return self::get_primary_domain();
+	}
 
-    /**
-     * Gets all the domains that have been configured
-     *
-     * @param  boolean $includePrimary If true, include the primary domain
-     * @return array
-     */
-    public static function get_all_domains($includePrimary = false)
-    {
-        $domains = array ();
+	/**
+	 * Gets all the domains that have been configured
+	 *
+	 * @param  boolean $includePrimary If true, include the primary domain
+	 * @return array
+	 */
+	public static function get_all_domains($includePrimary = false)
+	{
+		$domains = array ();
 
-        foreach (self::config()->domains as $key => $config) {
-            if (!$includePrimary && $key === self::KEY_PRIMARY) {
-                continue;
-            }
-            $domains[] = MultiDomainDomain::create($key, $config);
-        }
+		foreach (self::config()->domains as $key => $config) {
+			if (!$includePrimary && $key === self::KEY_PRIMARY) {
+				continue;
+			}
+			$domains[] = MultiDomainDomain::create($key, $config);
+		}
 
-        return $domains;
-    }
+		return $domains;
+	}
 
-    /**
-     * Gets the domain marked as "primary"
-     * @return MultiDomainDomain
-     */
-    public static function get_primary_domain()
-    {
-        return self::get_domain(self::KEY_PRIMARY);
-    }
+	/**
+	 * Gets the domain marked as "primary"
+	 * @return MultiDomainDomain
+	 */
+	public static function get_primary_domain()
+	{
+		return self::get_domain(self::KEY_PRIMARY);
+	}
 
-    /**
-     * Gets a domain by its key, e.g. 'org','com'
-     * @param  string $domain
-     * @return MultiDomainDomain
-     */
-    public static function get_domain($domain)
-    {
-        if (isset(self::config()->domains[$domain])) {
-            return MultiDomainDomain::create(
-                $domain,
-                self::config()->domains[$domain]
-            );
-        }
-    }
+	/**
+	 * Gets a domain by its key, e.g. 'org','com'
+	 * @param  string $domain
+	 * @return MultiDomainDomain
+	 */
+	public static function get_domain($domain)
+	{
+		if (isset(self::config()->domains[$domain])) {
+			return MultiDomainDomain::create(
+				$domain,
+				self::config()->domains[$domain]
+			);
+		}
+	}
 }

src/MultiDomainDomain.php

Indentation +271 added lines, -271 removed lines

@@ -16,275 +16,275 @@
  */
 class MultiDomainDomain extends Object
 {
-    /**
-     * The hostname of the domain, e.g. silverstripe.org
-     * @var string
-     */
-    protected $hostname;
-
-    /**
-     * The path that the hostname resolves to
-     * @var string
-     */
-    protected $url;
-
-    /**
-     * The identifier of the domain, e.g. 'org','com'
-     * @var string
-     */
-    protected $key;
-
-    /**
-     * Paths that are allowed to be accessed on the primary domain
-     * @var array
-     */
-    protected $allowedPaths;
-
-    /**
-     * Paths that are forced from the primary domain into a vanity one,
-     * outside the resolves_to path
-     *
-     * @var array
-     */
-    protected $forcedPaths;
-
-    /**
-     * The request URI
-     *
-     * @var string
-     */
-    protected $requestUri;
-
-    /**
-     * The request HTTP HOST
-     *
-     * @var string
-     */
-    protected $httpHost;
-
-    /**
-     * Constructor. Takes a key for the domain and its array of settings from the config
-     * @param string $key
-     * @param array $config
-     */
-    public function __construct($key, $config)
-    {
-        $this->key = $key;
-        $this->hostname = $config['hostname'];
-        $this->url = isset($config['resolves_to']) ? $config['resolves_to'] : null;
-
-        $globalAllowed = (array) Config::inst()->get(MultiDomain::class, 'allow');
-        $globalForced = (array) Config::inst()->get(MultiDomain::class, 'force');
-        $myAllowed = isset($config['allow']) ? $config['allow'] : array ();
-        $myForced = isset($config['force']) ? $config['force'] : array ();
-        $this->allowedPaths = array_merge($globalAllowed, $myAllowed);
-        $this->forcedPaths = array_merge($globalForced, $myForced);
-
-        parent::__construct();
-    }
-
-    /**
-     * Gets the hostname for the domain
-     * @return string
-     */
-    public function getHostname()
-    {
-        return defined($this->hostname) ? constant($this->hostname) : $this->hostname;
-    }
-
-    /**
-     * Gets the path that the hostname resolves to
-     * @return string
-     */
-    public function getURL()
-    {
-        return $this->url;
-    }
-
-    /**
-     * Returns true if the domain is currently in the HTTP_HOST
-     * @return boolean
-     */
-    public function isActive()
-    {
-        if ($this->isAllowedPath($this->getRequestUri())) {
-            return false;
-        }
-
-        $currentHost = $this->getHttpHost();
-        if (strpos(':', $currentHost) !== false) {
-            list($currentHost, $currentPort) = explode(':', $currentHost, 2);
-        }
-
-        $allow_subdomains = MultiDomain::config()->allow_subdomains;
-        $hostname = $this->getHostname();
-
-        return $allow_subdomains
-            ? (bool) preg_match('/(\.|^)'.$hostname.'$/', $currentHost)
-            : ($currentHost == $hostname);
-    }
-
-    /**
-     * Returns true if this domain is the primary domain
-     * @return boolean
-     */
-    public function isPrimary()
-    {
-        return $this->key === MultiDomain::KEY_PRIMARY;
-    }
-
-    /**
-     * Gets the native URL for a vanity domain, e.g. /partners/ for .com
-     * returns /company/partners when .com is mapped to /company/.
-     *
-     * @param  string $url
-     * @return string
-     */
-    public function getNativeURL($url)
-    {
-        if ($this->isPrimary()) {
-            throw new Exception("Cannot convert a native URL on the primary domain");
-        }
-
-        if ($this->isAllowedPath($url) || $this->isForcedPath($url)) {
-            return $url;
-        }
-
-        return Controller::join_links($this->getURL(), $url);
-    }
-
-    /**
-     * Gets the vanity URL given a native URL. /company/partners returns /partners/
-     * when .com is mapped to /company/.
-     *
-     * @param  string $url
-     * @return string
-     */
-    public function getVanityURL($url)
-    {
-        if ($this->isPrimary() || $this->isAllowedPath($url)) {
-            return $url;
-        }
-
-        $domainUrl = str_replace('/', '\/', $this->getURL());
-        return preg_replace('/^\/?' . $domainUrl . '\//', '', $url);
-    }
-
-    /**
-     * Return true if this domain contains the given URL
-     * @param  string  $url
-     * @return boolean
-     */
-    public function hasURL($url)
-    {
-        if ($this->isForcedPath($url)) {
-            return true;
-        }
-        $domainBaseURL = trim($this->getURL(), '/');
-        if (preg_match('/^'.$domainBaseURL.'/', $url)) {
-            return true;
-        }
-
-        return false;
-    }
-
-    /**
-     * Returns the key/identifier for this domain
-     *
-     * @return string
-     */
-    public function getKey()
-    {
-        return $this->key;
-    }
-
-    /**
-     * Set the request URI
-     *
-     * @param  string $requestUri
-     * @return $this
-     */
-    public function setRequestUri($requestUri)
-    {
-        $this->requestUri = (string) $requestUri;
-        return $this;
-    }
-
-    /**
-     * Return the current request URI, defaulting to retrieving it from the $_SERVER superglobal
-     *
-     * @return string
-     */
-    public function getRequestUri()
-    {
-        return $this->requestUri ?: $_SERVER['REQUEST_URI'];
-    }
-
-    /**
-     * Set the HTTP host in the request
-     *
-     * @param  string $httpHost
-     * @return $this
-     */
-    public function setHttpHost($httpHost)
-    {
-        $this->httpHost = (string) $httpHost;
-        return $this;
-    }
-
-    /**
-     * Return the current HTTP host, defaulting to retrieving it from the $_SERVER superglobal
-     *
-     * @return string
-     */
-    public function getHttpHost()
-    {
-        return $this->httpHost ?: $_SERVER['HTTP_HOST'];
-    }
-
-    /**
-     * Checks a given list of wildcard patterns to see if a path is allowed
-     * @param  string  $url
-     * @return boolean
-     */
-    protected function isAllowedPath($url)
-    {
-        return self::match_url($url, $this->allowedPaths);
-    }
-
-    /**
-     * Checks a given list of wildcard patterns to see if a path is allowed
-     * @param  string  $url
-     * @return boolean
-     */
-    protected function isForcedPath($url)
-    {
-        return self::match_url($url, $this->forcedPaths);
-    }
-
-    /**
-     * Matches a URL against a list of wildcard patterns
-     * @param  string $url
-     * @param  array $patterns
-     * @return boolean
-     */
-    protected static function match_url($url, $patterns)
-    {
-        if (!is_array($patterns)) {
-            return false;
-        }
-
-        $url = ltrim($url, '/');
-        if (substr($url, -1) !== '/') {
-            $url .= '/';
-        }
-
-        foreach ($patterns as $pattern) {
-            if (fnmatch($pattern, $url)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
+	/**
+	 * The hostname of the domain, e.g. silverstripe.org
+	 * @var string
+	 */
+	protected $hostname;
+
+	/**
+	 * The path that the hostname resolves to
+	 * @var string
+	 */
+	protected $url;
+
+	/**
+	 * The identifier of the domain, e.g. 'org','com'
+	 * @var string
+	 */
+	protected $key;
+
+	/**
+	 * Paths that are allowed to be accessed on the primary domain
+	 * @var array
+	 */
+	protected $allowedPaths;
+
+	/**
+	 * Paths that are forced from the primary domain into a vanity one,
+	 * outside the resolves_to path
+	 *
+	 * @var array
+	 */
+	protected $forcedPaths;
+
+	/**
+	 * The request URI
+	 *
+	 * @var string
+	 */
+	protected $requestUri;
+
+	/**
+	 * The request HTTP HOST
+	 *
+	 * @var string
+	 */
+	protected $httpHost;
+
+	/**
+	 * Constructor. Takes a key for the domain and its array of settings from the config
+	 * @param string $key
+	 * @param array $config
+	 */
+	public function __construct($key, $config)
+	{
+		$this->key = $key;
+		$this->hostname = $config['hostname'];
+		$this->url = isset($config['resolves_to']) ? $config['resolves_to'] : null;
+
+		$globalAllowed = (array) Config::inst()->get(MultiDomain::class, 'allow');
+		$globalForced = (array) Config::inst()->get(MultiDomain::class, 'force');
+		$myAllowed = isset($config['allow']) ? $config['allow'] : array ();
+		$myForced = isset($config['force']) ? $config['force'] : array ();
+		$this->allowedPaths = array_merge($globalAllowed, $myAllowed);
+		$this->forcedPaths = array_merge($globalForced, $myForced);
+
+		parent::__construct();
+	}
+
+	/**
+	 * Gets the hostname for the domain
+	 * @return string
+	 */
+	public function getHostname()
+	{
+		return defined($this->hostname) ? constant($this->hostname) : $this->hostname;
+	}
+
+	/**
+	 * Gets the path that the hostname resolves to
+	 * @return string
+	 */
+	public function getURL()
+	{
+		return $this->url;
+	}
+
+	/**
+	 * Returns true if the domain is currently in the HTTP_HOST
+	 * @return boolean
+	 */
+	public function isActive()
+	{
+		if ($this->isAllowedPath($this->getRequestUri())) {
+			return false;
+		}
+
+		$currentHost = $this->getHttpHost();
+		if (strpos(':', $currentHost) !== false) {
+			list($currentHost, $currentPort) = explode(':', $currentHost, 2);
+		}
+
+		$allow_subdomains = MultiDomain::config()->allow_subdomains;
+		$hostname = $this->getHostname();
+
+		return $allow_subdomains
+			? (bool) preg_match('/(\.|^)'.$hostname.'$/', $currentHost)
+			: ($currentHost == $hostname);
+	}
+
+	/**
+	 * Returns true if this domain is the primary domain
+	 * @return boolean
+	 */
+	public function isPrimary()
+	{
+		return $this->key === MultiDomain::KEY_PRIMARY;
+	}
+
+	/**
+	 * Gets the native URL for a vanity domain, e.g. /partners/ for .com
+	 * returns /company/partners when .com is mapped to /company/.
+	 *
+	 * @param  string $url
+	 * @return string
+	 */
+	public function getNativeURL($url)
+	{
+		if ($this->isPrimary()) {
+			throw new Exception("Cannot convert a native URL on the primary domain");
+		}
+
+		if ($this->isAllowedPath($url) || $this->isForcedPath($url)) {
+			return $url;
+		}
+
+		return Controller::join_links($this->getURL(), $url);
+	}
+
+	/**
+	 * Gets the vanity URL given a native URL. /company/partners returns /partners/
+	 * when .com is mapped to /company/.
+	 *
+	 * @param  string $url
+	 * @return string
+	 */
+	public function getVanityURL($url)
+	{
+		if ($this->isPrimary() || $this->isAllowedPath($url)) {
+			return $url;
+		}
+
+		$domainUrl = str_replace('/', '\/', $this->getURL());
+		return preg_replace('/^\/?' . $domainUrl . '\//', '', $url);
+	}
+
+	/**
+	 * Return true if this domain contains the given URL
+	 * @param  string  $url
+	 * @return boolean
+	 */
+	public function hasURL($url)
+	{
+		if ($this->isForcedPath($url)) {
+			return true;
+		}
+		$domainBaseURL = trim($this->getURL(), '/');
+		if (preg_match('/^'.$domainBaseURL.'/', $url)) {
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Returns the key/identifier for this domain
+	 *
+	 * @return string
+	 */
+	public function getKey()
+	{
+		return $this->key;
+	}
+
+	/**
+	 * Set the request URI
+	 *
+	 * @param  string $requestUri
+	 * @return $this
+	 */
+	public function setRequestUri($requestUri)
+	{
+		$this->requestUri = (string) $requestUri;
+		return $this;
+	}
+
+	/**
+	 * Return the current request URI, defaulting to retrieving it from the $_SERVER superglobal
+	 *
+	 * @return string
+	 */
+	public function getRequestUri()
+	{
+		return $this->requestUri ?: $_SERVER['REQUEST_URI'];
+	}
+
+	/**
+	 * Set the HTTP host in the request
+	 *
+	 * @param  string $httpHost
+	 * @return $this
+	 */
+	public function setHttpHost($httpHost)
+	{
+		$this->httpHost = (string) $httpHost;
+		return $this;
+	}
+
+	/**
+	 * Return the current HTTP host, defaulting to retrieving it from the $_SERVER superglobal
+	 *
+	 * @return string
+	 */
+	public function getHttpHost()
+	{
+		return $this->httpHost ?: $_SERVER['HTTP_HOST'];
+	}
+
+	/**
+	 * Checks a given list of wildcard patterns to see if a path is allowed
+	 * @param  string  $url
+	 * @return boolean
+	 */
+	protected function isAllowedPath($url)
+	{
+		return self::match_url($url, $this->allowedPaths);
+	}
+
+	/**
+	 * Checks a given list of wildcard patterns to see if a path is allowed
+	 * @param  string  $url
+	 * @return boolean
+	 */
+	protected function isForcedPath($url)
+	{
+		return self::match_url($url, $this->forcedPaths);
+	}
+
+	/**
+	 * Matches a URL against a list of wildcard patterns
+	 * @param  string $url
+	 * @param  array $patterns
+	 * @return boolean
+	 */
+	protected static function match_url($url, $patterns)
+	{
+		if (!is_array($patterns)) {
+			return false;
+		}
+
+		$url = ltrim($url, '/');
+		if (substr($url, -1) !== '/') {
+			$url .= '/';
+		}
+
+		foreach ($patterns as $pattern) {
+			if (fnmatch($pattern, $url)) {
+				return true;
+			}
+		}
+
+		return false;
+	}
 }

Spacing +3 added lines, -3 removed lines

@@ -75,8 +75,8 @@ 
 
         $globalAllowed = (array) Config::inst()->get(MultiDomain::class, 'allow');
         $globalForced = (array) Config::inst()->get(MultiDomain::class, 'force');
-        $myAllowed = isset($config['allow']) ? $config['allow'] : array ();
-        $myForced = isset($config['force']) ? $config['force'] : array ();
+        $myAllowed = isset($config['allow']) ? $config['allow'] : array();
+        $myForced = isset($config['force']) ? $config['force'] : array();
         $this->allowedPaths = array_merge($globalAllowed, $myAllowed);
         $this->forcedPaths = array_merge($globalForced, $myForced);
 
@@ -167,7 +167,7 @@ 
         }
 
         $domainUrl = str_replace('/', '\/', $this->getURL());
-        return preg_replace('/^\/?' . $domainUrl . '\//', '', $url);
+        return preg_replace('/^\/?'.$domainUrl.'\//', '', $url);
     }
 
     /**