Merge branch 'release/v0.3.0'

Author: Kamil Kisiela

CHANGELOG.md

@@ -2,6 +2,19 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [0.3.0] - 2015-11-23
+### Added
+- Support autoformly.validation.messages in SimpleSchema
+- Add optional manual formly configuration for each field in autoFormly service
+- Implement more advanced filtering
+- `schema.autoformly.templateOptions.rows` to be displayed as textarea
+
+### Deprecated
+- Filtering using schema keys as array  
+
+### Fixed
+- Prevent templatesObject.label overwriting
+
 ## [0.2.1] - 2015-11-18
 ### Changed
 - Refactor all files to use Strict Dependency Injection
@@ -20,6 +33,7 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## 0.0.1 - 2015-11-14
 
+[0.3.0]: https://github.com/wieldo/meteor-autoformly/compare/v0.2.1...v0.3.0
 [0.2.1]: https://github.com/wieldo/meteor-autoformly/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/wieldo/meteor-autoformly/compare/v0.1.0...v0.2.0 
 [0.1.0]: https://github.com/wieldo/meteor-autoformly/compare/v0.0.1...v0.1.0

README.md

@@ -17,12 +17,52 @@ meteor add wieldo:autoformly
 
 ## How to use it
 
+
+### Convert all schema fields
+
 ```javascript
 const fields = autoFormly.collection(BooksCollection);
 // or
 const fields = autoFormly.schema(BooksSchema);
 ```
 
+### Convert all schema fields excluding one
+```javascript
+const fields = autoFormly.schema(BooksSchema, {
+    fields: {
+        published: false
+    }
+});
+```
+
+### Convert selected schema fields
+```javascript
+const fields = autoFormly.schema(BooksSchema, {
+    all: false,
+    fields: {
+        published: true,
+        author: true,
+        title: true
+    }
+});
+```
+
+### Extend formly configuration for selected field
+
+```javascript
+const fields = autoFormly.schema(BooksSchema, {
+    all: false,
+    fields: {
+        published: true,
+        author: {
+            templateOptions: {
+                label: "Written by"
+            }
+        }
+    }
+});
+```
+
 ## What is ready?
 Take a look at this docs:
 
@@ -59,20 +99,21 @@ We're currently working on three other packages that are very useful in autoForm
 ### Roadmap 1.0
 
 - [x] Extend SimpleSchema to use `autoformly` property
-- [ ] Support for **_array of objects_**
+- [x] Add optional manual formly configuration for each field
+- [x] More advanced field filtering (show all / hide all / add excluding)
 - [x] `schema.key` as `formly.key`
 - [x] `schema.label` as `formly.templateOptions.label`
 - [x] `schema.optional` and required validator
 - [x] `schema.max` for **_String_** and **_Number_** types as **maxlength** and **maxnumber** validator
 - [x] `schema.min` for **_String_** and **_Number_** types as **minlength** and **minnumber** validator
 - [x] `schema.regEx` as **pattern** validator
 - [x] `schema.defaultValue` as `formly.defaultValue`
-- [ ] `schema.autoformly.rows` to be displayed textarea
+- [x] `schema.autoformly.templateOptions.rows` to be displayed as textarea
 - [x] **_Boolean_** type as checkbox
 - [x] `schema.autoformly.type` to be `formly.type`
 - [x] `schema.allowedValues` as select element (schema type is a String) 
-- [ ] `schema.minCount` support
-- [ ] `schema.maxCount` support
+- [ ] `schema.minCount` and `schema.maxCount` support
+- [ ] Support for **_array of objects_**
 - [ ] Support for **_Object_** type fields
 - [ ] Support for server-side validation errors (like _unique_)
 - [ ] Interactive **demo**

docs/auto-formly-parsers.md

@@ -5,4 +5,28 @@ autoFormlyParsers
 AngularJS service.
 ```
 
-__File: [lib/client/auto-formly-parsers.js](../lib/client/auto-formly-parsers.js)__
+__File: [lib/client/auto-formly-parsers.js](../lib/client/auto-formly-parsers.js)__
+
+-
+
+### *autoFormlyParsers*.register(parser)
+
+```
+Register new parsing function
+```
+
+__Arguments__
+
+* __collection__ *{Function}*  
+
+ Parsing function with three arguments:
+ 
+ - *{string}* field's key
+ - *{object}* copy of field's schema from SimpleSchema object
+ - *{object}* object with formly configuration for field
+ 
+ 
+__Returns__  *{undefined}*
+ 
+ There is no need to return something. Use formly configuration object as reference.
+ 

docs/auto-formly.md

@@ -21,37 +21,25 @@ __Arguments__
 
  Mongo Collection
 
-* __fields__ *{array|undefined}*
+* __options__ *{array|object|undefined}*
 
- Optional filtering fields using collection's keys
+ Optional filtering fields using array with collection's keys 
+ or options object.
 
-__Returns__  *{Array}*
- 
- Array with fields to use in formly-form.
- 
--
-
-### *autoFormly*.schema(schema, fields)
-
-```
-Parse SimpleSchema object to get array with fields
-```
+* __options.all__ *{boolean}*
 
-__Arguments__
+ Show all fields when true. Otherwise only these defined (see below)
 
-* __collection__ *{SimpleSchema}*  
+* __options.fields__ *{object}*
 
- SimpleSchema instance
+ Object with the field's key as property and formly field configuration (extends the auto-generated configuration).
+ Instead of using formly configuration you can set field as visible or not using boolean value (true visible, false not used)
 
-* __fields__ *{array|undefined}*
-
- Optional filtering fields using collection's keys
 
 __Returns__  *{Array}*
 
  Array with fields to use in formly-form.
 
-  
 -
 
 ### *autoFormly*.schema(schema, fields)
@@ -66,10 +54,11 @@ __Arguments__
 
  SimpleSchema instance
 
-* __fields__ *{array|undefined}*
+* __options__ *{array|object|undefined}*
 
- Optional filtering fields using collection's keys
+ See collection()
 
 __Returns__  *{Array}*
 
- Array with fields to use in formly-form.
+ Array with fields to use in formly-form.
+ 

lib/client/auto-formly-helpers.js

@@ -2,4 +2,33 @@ autoFormlyHelpers = class autoFormlyHelpers {
     createError(msg) {
         return new Error(`[AutoFormly] ${msg}`);
     }
+
+    createNestedObject(obj, path) {
+        path = this.pathNestedObject(path);
+        for (let i = 0; i < path.length; i++) {
+            obj = obj[path[i]] = obj[path[i]] || {};
+        }
+    }
+
+    getNestedObject(obj, path) {
+        path = this.pathNestedObject(path);
+        let objCopy = angular.copy(obj);
+        for (let i = 0; i < path.length; i++) {
+            if (!objCopy.hasOwnProperty(path[i])) {
+                objCopy = undefined;
+                break;
+            } else {
+                objCopy = objCopy[path[i]];
+            }
+        }
+
+        return objCopy;
+    }
+
+    pathNestedObject(path) {
+        if ("string" === typeof path) {
+            path = path.split('.');
+        }
+        return path;
+    }
 };

lib/client/auto-formly-parsers.js

@@ -61,7 +61,7 @@ class autoFormlyParser extends autoFormlyHelpers {
             return;
         }
 
-        const formlyField = {};
+        const formlyField = fieldSchema.autoformly ? fieldSchema.autoformly : {};
 
         this.runParsers(fieldKey, fieldSchema, formlyField);
 

lib/client/auto-formly.js

@@ -26,15 +26,15 @@ class autoFormly extends autoFormlyHelpers {
      * @public
      * @method autoFormly.collection
      * @param {Collection} collection
-     * @param {array} fields - schema keys you want to use (optional)
+     * @param {array|object} options - schema keys you want to use or formly fields configuration (optional)
      * @returns {array}
      */
-    collection(collection, fields) {
+    collection(collection, options) {
         if (!collection.simpleSchema) {
             throw this.createError("Collection does not contain SimpleSchema");
         }
 
-        return this.schema(collection.simpleSchema(), fields);
+        return this.schema(collection.simpleSchema(), options);
     }
 
     /**
@@ -43,20 +43,63 @@ class autoFormly extends autoFormlyHelpers {
      * @public
      * @method autoFormly.schema
      * @param {SimpleSchema} schema
-     * @param {array} fields - schema keys you want to use (optional)
+     * @param {array|object} options - schema keys you want to use or formly fields configuration (optional)
      * @returns {array}
      */
-    schema(schema, fields) {
-        if (!schema || !angular.isFunction(schema.schema)) {
+    schema(schema, options) {
+        let sortedSchema;
+        const schemaCopy = angular.copy(schema);
+
+        /**
+         * @deprecated avoid filtering with fields keys as array, use object configuration instead
+         */
+        if (!schemaCopy || !angular.isFunction(schemaCopy.schema)) {
             throw this.createError("Schema has to be instance of SimpleSchema");
         }
 
-        let sortedSchema;
+        // filter and return
+        if (angular.isArray(options)) {
+            return this.fields(this.filterSchema(schemaCopy, options));
+        }
+
+        // no options
+        if (angular.isUndefined(options)) {
+            return this.fields(schemaCopy.schema());
+        }
 
-        if (fields) {
-            sortedSchema = this.filterSchema(schema, fields);
+        //
+        // handle options object
+        //
+
+        // pass only object
+        if (!angular.isObject(options)) {
+            throw this.createError("Options have to be an array or object");
+        }
+
+        // use filter?
+        if (options.all === false) {
+            // pass only with defined fields
+            if (!angular.isObject(options.fields)) {
+                throw this.createError("Missing or invalid property fields in options");
+            }
+            // skip fields marked as unused ("fieldKey": false)
+            sortedSchema = this.filterSchema(schemaCopy, Object.keys(_.omit(options.fields, (val) => val === false)));
         } else {
-            sortedSchema = schema.schema();
+            sortedSchema = schemaCopy.schema();
+        }
+
+        // check each field
+        if (options.fields) {
+            _.each(sortedSchema, (fSchema, fKey) => {
+                // and skip field if marked as unused
+                if (options.fields[fKey] === false) {
+                    delete sortedSchema[fKey];
+                }
+                // or extend autoformly in schema using defined field extension
+                if (angular.isObject(options.fields[fKey])) {
+                    sortedSchema[fKey].autoformly = angular.merge({}, fSchema.autoformly, options.fields[fKey]);
+                }
+            });
         }
 
         return this.fields(sortedSchema);
@@ -65,12 +108,12 @@ class autoFormly extends autoFormlyHelpers {
     /**
      *
      * @param {object} schema
-     * @param {array} fields
+     * @param {array} fields - schema keys you want to use (optional)
      * @returns {object}
      */
     filterSchema(schema, fields) {
         if (!angular.isArray(fields)) {
-            throw this.createError("Fields have to be an array");
+            throw this.createError("Fields to filter have to be an array");
         }
 
         const sorted = {};

lib/client/parsers/templateoptions-label.js

@@ -4,11 +4,12 @@ SetModule('autoFormly')
     .run(['autoFormlyParser', (autoFormlyParser) => {
 
         autoFormlyParser.register((fieldKey, fieldSchema, formlyField) => {
-            if (!formlyField.templateOptions) {
-                formlyField.templateOptions = {};
-            }
+            autoFormlyParser.createNestedObject(formlyField, 'templateOptions');
 
-            formlyField.templateOptions.label = fieldSchema.label ? fieldSchema.label : fieldKey;
+            // prevent overwriting
+            if (!autoFormlyParser.getNestedObject(formlyField, 'templateOptions.label')) {
+                formlyField.templateOptions.label = fieldSchema.label ? fieldSchema.label : fieldKey;
+            }
         });
 
     }]);

lib/client/parsers/type.js

@@ -5,15 +5,17 @@ SetModule('autoFormly')
 
         autoFormlyParser.register((fieldKey, fieldSchema, formlyField) => {
 
-            if (fieldSchema.autoformly && fieldSchema.autoformly.type) {
+            if (autoFormlyParser.getNestedObject(fieldSchema, 'autoformly.type')) {
                 formlyField.type = fieldSchema.autoformly.type;
                 return;
             }
 
             if (fieldSchema.type === String) {
-                
-                if(angular.isDefined(fieldSchema.allowedValues)) {
+
+                if (angular.isDefined(fieldSchema.allowedValues)) {
                     formlyField.type = 'select';
+                } else if (autoFormlyParser.getNestedObject(fieldSchema, 'autoformly.templateOptions.rows')) {
+                    formlyField.type = 'textarea';
                 } else {
                     formlyField.type = 'input';
                 }