feat(rules): Added Writable rule

Author: ricardogobbosouza

README.md

@@ -177,5 +177,6 @@ The library can be loaded either as a standalone script, or through an [AMD](htt
 - [VideoUrl](docs/video-url.md)
 - [Vowel](docs/vowel.md)
 - [When](docs/when.md)
+- [Writable](docs/writable.md)
 - [Xdigit](docs/xdigit.md)
 - [Yes](docs/yes.md)

awesome-validator.min.js

@@ -0,0 +1,15 @@
+# Writable
+
+Validates if the given input is writable file.
+
+Valid values:
+
+```js
+validator.writable().validate(__filename);
+```
+
+Invalid values:
+
+```js
+validator.writable().validate(__dirname);
+```

docs/writable.md

@@ -44,5 +44,5 @@ export abstract class AbstractFileSystem extends AbstractRule {
     /**
      * Validate File System.
      */
-    protected abstract validateFileSystem(stas: Stats): boolean;
+    protected abstract validateFileSystem(stats: Stats): boolean;
 }

src/rules/abstract-file-system.ts

@@ -98,5 +98,6 @@ export * from './version';
 export * from './video-url';
 export * from './vowel';
 export * from './when';
+export * from './writable';
 export * from './xdigit';
 export * from './yes';

src/rules/index.ts

@@ -0,0 +1,19 @@
+import * as fs from 'fs';
+
+import { AbstractRule } from './abstract-rule';
+
+export class Writable extends AbstractRule {
+
+    /**
+     * Validate.
+     */
+    public validate(input: any): boolean {
+        try {
+            fs.accessSync(input, fs.constants.W_OK);
+
+            return true;
+        } catch (e) {}
+
+        return false;
+    }
+}

src/rules/writable.ts

@@ -108,6 +108,7 @@ export class Validator extends AllOf {
     public static videoUrl = (service?: VideoService): Validator => new Validator(new rules.VideoUrl(service));
     public static vowel = (additionalChars?: string): Validator => new Validator(new rules.Vowel(additionalChars));
     public static when = (whenRule: Validatable, thenRule: Validatable, elseRule?: Validatable): Validator => new Validator(new rules.When(whenRule, thenRule, elseRule));
+    public static writable = (): Validator => new Validator(new rules.Writable());
     public static xdigit = (additionalChars?: string): Validator => new Validator(new rules.Xdigit(additionalChars));
     public static yes = (additionalChars?: string): Validator => new Validator(new rules.Yes(additionalChars));
 
@@ -211,6 +212,7 @@ export class Validator extends AllOf {
     public videoUrl = (service?: VideoService): this => this.addRule(new rules.VideoUrl(service));
     public vowel = (additionalChars?: string): this => this.addRule(new rules.Vowel(additionalChars));
     public when = (whenRule: Validatable, thenRule: Validatable, elseRule?: Validatable): this => this.addRule(new rules.When(whenRule, thenRule, elseRule));
+    public writable = (): this => this.addRule(new rules.Writable());
     public xdigit = (additionalChars?: string): this => this.addRule(new rules.Xdigit(additionalChars));
     public yes = (additionalChars?: string): this => this.addRule(new rules.Yes(additionalChars));
     /* tslint:enable completed-docs max-line-length */

src/validator.ts

@@ -0,0 +1,38 @@
+import * as mock from 'mock-fs';
+
+import { assert } from 'chai';
+
+import { AbstractRule } from '../../src/rules/abstract-rule';
+import { Writable } from '../../src/rules/writable';
+
+describe('Writable', () => {
+
+    let writable: Writable;
+
+    beforeEach(() => {
+        writable = new Writable();
+
+        mock({
+            'file.txt': 'foo'
+        });
+    });
+
+    afterEach(() => {
+        mock.restore();
+    });
+
+    it('is rule', () => {
+        assert.instanceOf(writable, AbstractRule);
+    });
+
+    it('values is valid', () => {
+        assert.isTrue(writable.validate(''));
+        assert.isTrue(writable.validate('file.txt'));
+    });
+
+    it('values is not valid', () => {
+        assert.isFalse(writable.validate('foo'));
+        assert.isFalse(writable.validate('file-not-found.txt'));
+    });
+
+});

test/rules/writable.ts

@@ -164,6 +164,7 @@ describe('Validator', () => {
         assert.instanceOf(V.vowel('foo'), V);
         assert.instanceOf(V.when(V.alwaysValid(), V.alwaysValid()), V);
         assert.instanceOf(V.when(V.alwaysInvalid(), V.alwaysValid(), V.alwaysValid()), V);
+        assert.instanceOf(V.writable(), V);
         assert.instanceOf(V.xdigit(), V);
         assert.instanceOf(V.xdigit('foo'), V);
         assert.instanceOf(V.yes(), V);
@@ -317,6 +318,7 @@ describe('Validator', () => {
         assert.instanceOf(v.vowel('foo'), V);
         assert.instanceOf(v.when(V.alwaysValid(), V.alwaysValid()), V);
         assert.instanceOf(v.when(V.alwaysInvalid(), V.alwaysValid(), V.alwaysValid()), V);
+        assert.instanceOf(v.writable(), V);
         assert.instanceOf(v.xdigit(), V);
         assert.instanceOf(v.xdigit('foo'), V);
         assert.instanceOf(v.yes(), V);