Add Symfony specific rules

.github/workflows/ci.yaml

@@ -0,0 +1,52 @@
+name: CI
+
+on: [push, pull_request]
+
+env:
+  PHPUNIT_FLAGS: "-v"
+
+jobs:
+  test:
+    name: ProgressiveBundle (PHP ${{ matrix.php-versions }} on ${{ matrix.operating-system }})
+    runs-on: ${{ matrix.operating-system }}
+
+    strategy:
+      matrix:
+        operating-system: ['ubuntu-latest', 'windows-latest', 'macos-latest']
+        php-versions: ['7.3', '7.4', '8.0']
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: ${{ matrix.php-versions }}
+          tools: composer:v2
+
+      - name: Validate composer.json and composer.lock
+        run: composer validate
+
+      - name: "Set composer cache directory"
+        id: composer-cache
+        run: echo "::set-output name=dir::$(composer config cache-files-dir)"
+
+      - name: "Cache composer"
+        uses: actions/cache@v2
+        with:
+          path: ${{ steps.composer-cache.outputs.dir }}
+          key: ${{ runner.os }}-${{ matrix.php-version }}-composer-${{ hashFiles('**/composer.lock') }}
+          restore-keys: ${{ runner.os }}-${{ matrix.php-version }}-composer-
+
+      - name: Setup problem matchers for PHPUnit
+        run: echo "::add-matcher::${{ runner.tool_cache }}/phpunit.json"
+
+      - name: Install dependencies
+        run: composer install --prefer-dist --optimize-autoloader
+
+      - name: "Run tests"
+        run: vendor/bin/phpunit ${{ env.PHPUNIT_FLAGS }}
+
+
+

.github/workflows/lint.yaml

@@ -0,0 +1,17 @@
+name: Lint
+
+on: [push, pull_request]
+
+jobs:
+  php-cs-fixer:
+    name: PHP-CS-Fixer
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: "Checkout code"
+        uses: actions/checkout@v2
+
+      - name: PHP-CS-Fixer
+        uses: docker://oskarstark/php-cs-fixer-ga
+        with:
+          args: --diff --dry-run

.gitignore

@@ -1,2 +1,4 @@
 /vendor/
 .php_cs.cache
+.phpunit.xml
+.phpunit.result.cache

AfProgressiveBundle.php

@@ -2,8 +2,14 @@
 
 namespace Af\ProgressiveBundle;
 
+use Af\ProgressiveBundle\DependencyInjection\Compiler\RulePass;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\HttpKernel\Bundle\Bundle;
 
 class AfProgressiveBundle extends Bundle
 {
+    public function build(ContainerBuilder $container)
+    {
+        $container->addCompilerPass(new RulePass());
+    }
 }

DependencyInjection/AfProgressiveExtension.php

@@ -2,6 +2,8 @@
 
 namespace Af\ProgressiveBundle\DependencyInjection;
 
+use Progressive\Context;
+use Progressive\Progressive;
 use Symfony\Component\Config\FileLocator;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Extension\Extension;
@@ -21,12 +23,14 @@ public function load(array $configs, ContainerBuilder $container)
         $configuration = new Configuration();
         $config = $this->processConfiguration($configuration, $configs);
 
+        // Add parameters to the Context
         if (null !== $config['context']) {
-            $definition = $container->getDefinition('af.progressive.context');
+            $definition = $container->getDefinition(Context::class);
             $definition->addMethodCall('add', [$config['context']]);
         }
 
-        $definition = $container->getDefinition('af.progressive');
+        // Features' configuration
+        $definition = $container->getDefinition(Progressive::class);
         $featuresConfig = Yaml::parseFile($config['config']);
         $definition->replaceArgument(0, $featuresConfig);
     }

DependencyInjection/Compiler/RulePass.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Af\ProgressiveBundle\DependencyInjection\Compiler;
+
+use Progressive\Rule\Store;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+class RulePass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container): void
+    {
+        if (!$container->has(Store::class)) {
+            return;
+        }
+
+        $definition = $container->findDefinition(Store::class);
+
+        $taggedServices = $container->findTaggedServiceIds('af_progressive.rule');
+
+        foreach ($taggedServices as $id => $tags) {
+            $definition->addMethodCall('add', [new Reference($id)]);
+        }
+    }
+}

README.md

@@ -1,6 +1,8 @@
 # Progressive Bundle
 
-**Symfony integration for the feature-flag library [Progressive](https://github.com/antfroger/progressive)**
+Symfony integration for the feature-flag library [Progressive](https://github.com/antfroger/progressive)
+
+[![Build Status](https://github.com/antfroger/progressive-bundle/workflows/CI/badge.svg)](https://github.com/antfroger/progressive-bundle)
 
 ## Installation
 
@@ -55,3 +57,19 @@ features:
       env: ['dev', 'preprod']
       roles: ['ROLE_ADMIN', 'ROLE_DEV']
 ```
+
+Look at the [Progressive documentation](https://github.com/antfroger/progressive#usage) to know more about the feature's configuration.
+
+## Usage
+
+You can use Progressive in a controller:
+
+```php
+  public function info(Progressive $progressive): Response
+  {
+      if ($progressive->isEnabled('call-center')) {
+          // Do what you want when the feature `call-center` is enabled
+      }
+  }
+```
+

Resources/config/services.xml

@@ -5,12 +5,24 @@
         https://symfony.com/schema/dic/services/services-1.0.xsd">
 
     <services>
-        <service id="Progressive\Progressive" alias="af.progressive"/>
-        <service id="af.progressive" class="Progressive\Progressive">
+        <service id="Progressive\Progressive">
             <argument type="collection" /><!-- configuration will be dynamically filled in -->
-            <argument type="service" id="af.progressive.context"/>
+            <argument type="service" id="Progressive\Context"/>
+            <argument type="service" id="Progressive\Rule\Store"/>
         </service>
 
-        <service id="af.progressive.context" class="Progressive\Context" />
+        <service id="Progressive\Context"/>
+        <service id="Progressive\Rule\Store"/>
+
+        <service id="Af\ProgressiveBundle\Rule\Environments">
+            <argument>%kernel.environment%</argument>
+        </service>
+        <service id="Af\ProgressiveBundle\Rule\Roles">
+            <argument type="service" id="security.helper"/>
+        </service>
+
+        <instanceof id="Progressive\Rule\RuleInterface" autowire="true">
+            <tag name="af_progressive.rule"/>
+        </instanceof>
     </services>
 </container>

Rule/Environments.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Af\ProgressiveBundle\Rule;
+
+use Progressive\ParameterBagInterface;
+use Progressive\Rule\RuleInterface;
+
+class Environments implements RuleInterface
+{
+    /** @var string */
+    private $env;
+
+    public function __construct($env)
+    {
+        $this->env = $env;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function decide(ParameterBagInterface $bag, array $envs = []): bool
+    {
+        return in_array($this->env, $envs);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getName(): string
+    {
+        return 'env';
+    }
+}

Rule/Roles.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Af\ProgressiveBundle\Rule;
+
+use Progressive\ParameterBagInterface;
+use Progressive\Rule\RuleInterface;
+use Symfony\Component\Security\Core\Security;
+
+class Roles implements RuleInterface
+{
+    /** @var Security */
+    private $security;
+
+    public function __construct(Security $security)
+    {
+        $this->security = $security;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function decide(ParameterBagInterface $bag, array $roles = []): bool
+    {
+        if (null === $user = $this->security->getUser()) {
+            return false;
+        }
+
+        $userRoles = $user->getRoles();
+        foreach ($userRoles as $role) {
+            if (in_array($role, $roles, true)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getName(): string
+    {
+        return 'roles';
+    }
+}

Tests/Rule/EnvironmentsTest.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Af\ProgressiveBundle\Tests\Rule;
+
+use Af\ProgressiveBundle\Rule\Environments;
+use PHPUnit\Framework\TestCase;
+use Progressive\ParameterBagInterface;
+
+class EnvironmentsTest extends TestCase
+{
+    /**
+     * @dataProvider valueProvider
+     */
+    public function testDecide(string $env, array $envs, bool $expected)
+    {
+        $context = $this->createMock(ParameterBagInterface::class);
+
+        $rule = new Environments($env);
+        $response = $rule->decide($context, $envs);
+
+        $this->assertSame($response, $expected);
+    }
+
+    public function valueProvider(): array
+    {
+        return [
+            ['dev', ['dev', 'test', 'prod'], true],
+            ['dev', ['preprod', 'dev'], true],
+            ['test', ['test'], true],
+            ['test', [], false],
+            ['prod', ['dev', 'test'], false],
+        ];
+    }
+}

Tests/Rule/RolesTest.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace Af\ProgressiveBundle\Tests\Rule;
+
+use Af\ProgressiveBundle\Rule\Roles;
+use PHPUnit\Framework\TestCase;
+use Progressive\ParameterBagInterface;
+use Symfony\Component\Security\Core\Security;
+use Symfony\Component\Security\Core\User\UserInterface;
+
+class RolesTest extends TestCase
+{
+    public function testNotAuthenticated()
+    {
+        $security = $this->createMock(Security::class);
+        $context = $this->createMock(ParameterBagInterface::class);
+
+        $rule = new Roles($security);
+        $this->assertFalse($rule->decide($context, []));
+    }
+
+    /**
+     * @dataProvider rolesProvider
+     */
+    public function testAuthenticatedUser(array $roles, bool $expected)
+    {
+        $user = $this->createMock(UserInterface::class);
+        $user->expects($this->once())
+            ->method('getRoles')
+            ->willReturn(['ROLE_DEV', 'ROLE_ADMIN'])
+        ;
+
+        $security = $this->createMock(Security::class);
+        $security->expects($this->once())
+            ->method('getUser')
+            ->willReturn($user)
+        ;
+        $context = $this->createMock(ParameterBagInterface::class);
+
+        $rule = new Roles($security);
+        $response = $rule->decide($context, $roles);
+
+        $this->assertSame($response, $expected);
+    }
+
+    public function rolesProvider(): array
+    {
+        return [
+            [[], false],
+            [['ROLE_SUPERADMIN', 'ROLE_TRANSLATOR'], false],
+            [['ROLE_ADMIN', 'ROLE_DEV', 'ROLE_SUPERADMIN'], true],
+            [['ROLE_DEV', 'ROLE_ADMIN'], true],
+            [['ROLE_ADMIN'], true],
+            [['ROLE_DEV'], true],
+        ];
+    }
+}

composer.json

@@ -11,10 +11,16 @@
         }
     ],
     "require": {
-        "antfroger/progressive": "^1.0"
+        "antfroger/progressive": "^1.0",
+        "symfony/config": "^5.2",
+        "symfony/dependency-injection": "^5.2",
+        "symfony/http-kernel": "^5.2",
+        "symfony/security-core": "^5.2",
+        "symfony/yaml": "^5.2"
     },
     "require-dev": {
-        "friendsofphp/php-cs-fixer": "^2.17"
+        "friendsofphp/php-cs-fixer": "^2.17",
+        "phpunit/phpunit": "^9.5"
     },
     "autoload": {
         "psr-4": { "Af\\ProgressiveBundle\\": "" }