Merge pull request #44 from arandilopez/strict-validation

New rule for strict validation against profane words

.phpunit.result.cache

@@ -1 +0,0 @@
-C:37:"PHPUnit\Runner\DefaultTestResultCache":1921:{a:2:{s:7:"defects";a:0:{}s:5:"times";a:22:{s:67:"LaravelProfaneTests\DictionaryTest::test_words_from_only_one_locale";d:0.006;s:65:"LaravelProfaneTests\DictionaryTest::test_words_from_only_one_file";d:0;s:64:"LaravelProfaneTests\DictionaryTest::test_words_from_locale_array";d:0;s:62:"LaravelProfaneTests\DictionaryTest::test_words_from_file_array";d:0;s:79:"LaravelProfaneTests\ProfaneValidatorTest::test_can_validate_a_word_with_numbers";d:0.001;s:66:"LaravelProfaneTests\ProfaneValidatorTest::test_can_validate_a_text";d:0.001;s:79:"LaravelProfaneTests\ProfaneValidatorTest::test_can_evaluate_profanity_of_a_word";d:0;s:83:"LaravelProfaneTests\ProfaneValidatorTest::test_can_evaluate_profanity_of_a_sentence";d:0;s:86:"LaravelProfaneTests\ProfaneValidatorTest::test_can_evaluate_profanity_of_a_html_string";d:0;s:76:"LaravelProfaneTests\ProfaneValidatorTest::test_can_evaluate_as_caseless_mode";d:0;s:63:"LaravelProfaneTests\ProfaneValidatorTest::test_match_exact_word";d:0;s:82:"LaravelProfaneTests\ProfaneValidatorTest::test_can_validate_a_bad_word_with_accent";d:0;s:75:"LaravelProfaneTests\ProfaneValidatorTest::test_enie_in_spanish_is_evaluated";d:0;s:75:"LaravelProfaneTests\ProfaneValidatorTest::test_can_validate_a_word_in_greek";d:0.001;s:75:"LaravelProfaneTests\ProfaneValidatorTest::test_can_validate_a_text_in_greek";d:0;s:85:"LaravelProfaneTests\StrTest::test_string_contains_a_piece_insensitive_match_from_text";d:0;s:76:"LaravelProfaneTests\StrTest::test_text_contains_insensitive_match_from_array";d:0;s:77:"LaravelProfaneTests\StrTest::test_text_contains_insensitive_match_from_string";d:0;s:86:"LaravelProfaneTests\StrTest::test_text_contains_the_same_insensitive_match_from_string";d:0;s:64:"LaravelProfaneTests\StrTest::test_remove_accents_in_spanish_text";d:0;s:54:"LaravelProfaneTests\StrTest::test_enie_char_is_allowed";d:0;s:57:"LaravelProfaneTests\StrTest::test_remove_accents_in_greek";d:0;}}}

README.md

@@ -13,11 +13,13 @@ I made this package to perform a validation for swearwords using Laravel validat
 ## Installation
 
 Install via composer
+
 ```shell
 composer require arandilopez/laravel-profane
 ```
 
 ## Configuration
+
 Add the `ProfaneServiceProvider` class in your `config/app.php` file.
 
 ```php
@@ -98,10 +100,34 @@ class MyController extends Controller
 }
 ```
 
+#### Strict validation
+
+Now you can strictly validate the exact profane word in the content.
+
+```php
+<?php
+// ...
+class MyController extends Controller
+{
+    public function store(Request $request)
+    {
+        $this->validate($request, [
+            'username' => 'required|strictly_profane:es,en'
+        ]);
+
+        // ...
+    }
+}
+```
+
+This fixes known issues when you get a error in validation for words like `class` or `analysis`, as they include `ass` and `anal` respectively, but fails the validation for content like `sucker69`.
+
 ## Getting Help
+
 If you're stuck getting something to work, or need to report a bug, please [post an issue in the Github Issues for this project](https://github.com/arandilopez/laravel-profane/issues).
 
 ## Contributing
+
 If you're interesting in contributing code to this project, clone it by running:
 
 ```shell
@@ -112,9 +138,10 @@ Please read the [CONTRIBUTING](CONTRIBUTING.md) file.
 
 Pull requests are welcome, but please make sure you provide unit tests to cover your changes. **You can help to add and support more locales!**
 
-*Thanks to [@dorianneto](https://github.com/dorianneto) for his contributions.*
+_Thanks to [@dorianneto](https://github.com/dorianneto) for his contributions._
 
 ### Supported Locales
+
 - English ( provided by [@arandilopez](https://github.com/arandilopez) )
 - Spanish ( provided by [@arandilopez](https://github.com/arandilopez) and [@xDidier901](https://github.com/xDidier901))
 - Italian ( provided by [@aletundo](https://github.com/aletundo) )
@@ -131,4 +158,5 @@ Pull requests are welcome, but please make sure you provide unit tests to cover
 - Indonesian ( provided by [@rizasaputra](https://github.com/rizasaputra) )
 
 ## License
+
 This project is open-sourced software licensed under the [MIT license](http://opensource.org/licenses/MIT).

src/ProfaneServiceProvider.php

@@ -16,15 +16,18 @@ class ProfaneServiceProvider extends ServiceProvider
             __DIR__.'/lang' => resource_path('lang/vendor/laravel-profane'),
         ]);
 
+        // Rule for caseless content matching
         Validator::extend('profane', 'LaravelProfane\ProfaneValidator@validate', Lang::get('laravel-profane::validation.profane'));
 
-        Validator::replacer('profane', function ($message, $attribute, $rule, $parameters) {
+        Validator::replacer('profane', function ($message, $attribute) {
+            return str_replace(':attribute', $attribute, $message);
+        });
+
+        // Rule for caseless but strict word matching
+        Validator::extend('strictly_profane', 'LaravelProfane\ProfaneValidator@validateStrict', Lang::get('laravel-profane::validation.profane'));
+
+        Validator::replacer('strictly_profane', function ($message, $attribute) {
             return str_replace(':attribute', $attribute, $message);
         });
     }
-
-    public function register()
-    {
-        // code...
-    }
 }

src/ProfaneValidator.php

@@ -2,27 +2,19 @@
 
 namespace LaravelProfane;
 
-use Illuminate\Contracts\Validation\Validator;
-
 class ProfaneValidator
 {
     /**
-     * [$dictionary description].
+     * @var Dictionary
-     *
-     * @var [type]
      */
     protected $dictionary;
 
     /**
-     * [$badwords description].
-     *
      * @var array
      */
     protected $badwords = [];
 
     /**
-     * [__construct description].
-     *
      * @param Dictionary $dictionary [description]
      */
     public function __construct(Dictionary $dictionary)
@@ -32,25 +24,41 @@ class ProfaneValidator
     }
 
     /**
-     * Method to extends to Validator.
+     * Method to extends to Validation Service.
      *
      * @param string $attribute
-     * @param midex                                      $value
+     * @param mixed  $value
      * @param array  $parameters
-     * @param \Illuminate\Contracts\Validation\Validator $validator  [description]
      *
      * @return bool
      */
     public function validate($attribute, $value, $parameters)
     {
         if ($parameters) {
-            $this->dictionary->setDictionary($parameters);
+            $this->setDictionary($parameters);
-            $this->badwords = $this->dictionary->getDictionary();
         }
 
         return !$this->isProfane($value);
     }
 
+    /**
+     * Method to extends to Validation Service for strict word matching.
+     *
+     * @param string $attribute
+     * @param mixed  $value
+     * @param array  $parameters
+     *
+     * @return bool
+     */
+    public function validateStrict($attribute, $value, $parameters)
+    {
+        if ($parameters) {
+            $this->setDictionary($parameters);
+        }
+
+        return !$this->isProfane($value, true);
+    }
+
     /**
      * Check profanity of text.
      *
@@ -58,11 +66,23 @@ class ProfaneValidator
      *
      * @return bool
      */
-    public function isProfane($text)
+    public function isProfane($text, $strict = false)
     {
         return Str::containsCaseless(
-            Str::removeAccent($text),
+            $this->sanitizeText($text),
-            $this->badwords
+            $this->badwords,
+            $strict
         );
     }
+
+    private function setDictionary($dictionaries)
+    {
+        $this->dictionary->setDictionary($dictionaries);
+        $this->badwords = $this->dictionary->getDictionary();
+    }
+
+    private function sanitizeText($text)
+    {
+        return Str::removeAccent(strip_tags($text));
+    }
 }

src/Str.php

@@ -13,11 +13,12 @@ class Str
      *
      * @return bool
      */
-    public static function containsCaseless($haystack, $needles)
+    public static function containsCaseless($haystack, $needles, $strict = false)
     {
         foreach ((array) $needles as $needle) {
             $needle = preg_quote($needle);
-            if ($needle != '' && preg_match("/$needle/iu", $haystack)) {
+            $regex = $strict ? "/\b$needle\b/iu" : "/$needle/iu";
+            if ($needle != '' && preg_match($regex, $haystack)) {
                 return true;
             }
         }

tests/ProfaneValidatorTest.php

@@ -13,6 +13,13 @@ class ProfaneValidatorTest extends TestCase
         $this->assertFalse($builder->validate(['username', 'culero23', ['es']]));
     }
 
+    public function test_can_not_validate_a_word_with_numbers_in_strict_mode()
+    {
+        $builder = new ProfaneValidatorBuilder();
+
+        $this->assertTrue($builder->validate(['username', 'culero23', ['es']], true));
+    }
+
     public function test_can_validate_a_text()
     {
         $builder = new ProfaneValidatorBuilder();
@@ -38,6 +45,15 @@ class ProfaneValidatorTest extends TestCase
         $this->assertTrue($builder->build()->isProfane($word));
     }
 
+    public function test_can_evaluate_profanity_of_a_sentence_in_strict_mode()
+    {
+        $builder = new ProfaneValidatorBuilder();
+
+        $word = 'fuck you if you read this';
+
+        $this->assertTrue($builder->build()->isProfane($word), true);
+    }
+
     public function test_can_evaluate_profanity_of_a_html_string()
     {
         $builder = new ProfaneValidatorBuilder();
@@ -56,7 +72,7 @@ class ProfaneValidatorTest extends TestCase
         $this->assertTrue($builder->build()->isProfane($word));
     }
 
-    public function test_match_exact_word()
+    public function test_match_content()
     {
         $builder = new ProfaneValidatorBuilder();
 
@@ -67,6 +83,17 @@ class ProfaneValidatorTest extends TestCase
         $this->assertTrue($builder->build()->isProfane('sucker96'));
     }
 
+    public function test_match_exact_word_in_strict_mode()
+    {
+        $builder = new ProfaneValidatorBuilder();
+
+        // class is a safe word
+        $this->assertFalse($builder->build()->isProfane('class', true));
+
+        // in strict mode this will pass a safe word
+        $this->assertFalse($builder->build()->isProfane('sucker96', true));
+    }
+
     public function test_can_validate_a_bad_word_with_accent()
     {
         $builder = new ProfaneValidatorBuilder('sk');

tests/StrTest.php

@@ -21,6 +21,25 @@ class StrTest extends TestCase
         $this->assertTrue(Str::containsCaseless('Fuck! This class is so bad!', 'fUcK'));
     }
 
+    public function test_text_does_not_contain_match_in_strict_mode()
+    {
+        $this->assertFalse(Str::containsCaseless('This class is so bad!', 'ass', true));
+        $this->assertFalse(Str::containsCaseless('Theorem Analisys', 'anal', true));
+    }
+
+    public function test_text_contains_match_in_strict_mode()
+    {
+        $this->assertTrue(Str::containsCaseless('This class is a crap!', 'crap', true));
+        $this->assertFalse(Str::containsCaseless('Theorem Analisys', 'anal', true));
+        $this->assertFalse(Str::containsCaseless('Sucker69', 'sucker', true));
+    }
+
+    public function test_text_contains_match_in_not_strict_mode()
+    {
+        $this->assertTrue(Str::containsCaseless('This class is so bad!', 'ass', false));
+        $this->assertTrue(Str::containsCaseless('Theorem Analisys', 'anal', false));
+    }
+
     public function test_text_contains_the_same_insensitive_match_from_string()
     {
         $this->assertTrue(Str::containsCaseless('Fuck! This class is so bad!', 'Fuck'));

tests/Support/ProfaneValidatorBuilder.php

@@ -31,10 +31,14 @@ class ProfaneValidatorBuilder
      *
      * @return [type] [description]
      */
-    public function validate(array $parameters)
+    public function validate(array $parameters, $strict = false)
     {
         list($attribute, $text, $dictionaries) = $parameters;
 
+        if ($strict) {
+            return $this->build()->validateStrict($attribute, $text, $dictionaries);
+        }
+
         return $this->build()->validate($attribute, $text, $dictionaries);
     }