Yang Utils - service refactor by Angular styleguide

[dlux.git] / modules / common-yangutils-resources / src / main / resources / yangutils / services / module-connector.services.js

diff --git a/modules/common-yangutils-resources/src/main/resources/yangutils/services/module-connector.services.js b/modules/common-yangutils-resources/src/main/resources/yangutils/services/module-connector.services.js
index 3004a23f0258745af693947f6f9cce97c96bd114..c353ee1971a2c8c78fcb17d3edc02caf237f7caa 100644 (file)
--- a/modules/common-yangutils-resources/src/main/resources/yangutils/services/module-connector.services.js
+++ b/modules/common-yangutils-resources/src/main/resources/yangutils/services/module-connector.services.js
@@ -2,16 +2,43 @@ define([], function () {
     'use strict';
 
     function ModuleConnectorService(){
-        var isBuildInType = function (type) {
-            return ['int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'uint64',
-                    'decimal64', 'string', 'boolean', 'enumeration', 'bits', 'binary',
-                    'leafref', 'identityref', 'empty', 'union', 'instance-identifier'].indexOf(type) > -1;
-        };
 
-        var moduleConnector = {},
-            linkFunctions = {};
+        var service = {
+                processModuleObjs: processModuleObjs,
+                __test: {
+                    isBuildInType: isBuildInType,
+                    linkFunctions: linkFunctions,
+                    findLinkedStatement: findLinkedStatement,
+                    appendChildren: appendChildren,
+                    searchModule: searchModule,
+                    applyLinks: applyLinks,
+                    interConnectModules: interConnectModules,
+                    applyModuleRevision: applyModuleRevision,
+                },
+            },
+            linkFunctions = {
+                uses: uses,
+                type: type,
+            };
+
+        return service;
+
+        // TODO: add service's description
+        function processModuleObjs(modules) {
+            var rootNodes = [],
+                augments = [],
+                connectedModules = interConnectModules(modules.slice());
+
+            connectedModules.forEach(function (module) {
+                rootNodes = rootNodes.concat(module.getRoots());
+                augments = augments.concat(module.getAugments());
+            });
+
+            return { rootNodes: rootNodes, augments: augments };
+        }
 
-        linkFunctions.uses = function (usesNode, currentModule) {
+        // TODO: add function's description
+        function uses(usesNode, currentModule) {
             var targetType = 'grouping';
             return function (modules) {
                 var data = findLinkedStatement(usesNode, targetType, currentModule, modules),
@@ -20,7 +47,7 @@ define([], function () {
                     changed = false;
 
                 if (node && module) {
-                    usesNode.parent.children.splice(usesNode.parent.children.indexOf(usesNode), 1); //delete uses node
+                    usesNode.parent.children.splice(usesNode.parent.children.indexOf(usesNode), 1); // delete uses node
                     for (var i = 0; i < node.children.length; i++) {
                         applyLinks(node.children[i], module, modules);
                     }
@@ -30,9 +57,10 @@ define([], function () {
 
                 return changed;
             };
-        };
+        }
 
-        linkFunctions.type = function (typeNode, currentModule) {
+        // TODO: add function's description
+        function type(typeNode, currentModule) {
             var targetType = 'typedef';
 
             if (isBuildInType(typeNode.label) === false) {
@@ -42,7 +70,8 @@ define([], function () {
                         changed = false;
 
                     if (node) {
-                        typeNode.parent.children.splice(typeNode.parent.children.indexOf(typeNode), 1); //delete referencing type node
+                        // delete referencing type node
+                        typeNode.parent.children.splice(typeNode.parent.children.indexOf(typeNode), 1);
                         typeNode.parent.addChild(node);
                         changed = true;
                     }
@@ -54,9 +83,17 @@ define([], function () {
                     return false;
                 };
             }
-        };
+        }
 
-        var findLinkedStatement = function (node, targetType, currentModule, modules) {
+        // TODO: add function's description
+        function isBuildInType(type) {
+            return ['int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'uint64',
+                    'decimal64', 'string', 'boolean', 'enumeration', 'bits', 'binary',
+                    'leafref', 'identityref', 'empty', 'union', 'instance-identifier'].indexOf(type) > -1;
+        }
+
+        // TODO: add function's description
+        function findLinkedStatement(node, targetType, currentModule, modules) {
             var sourceNode,
                 sourceModule,
                 link = node.label;
@@ -65,48 +102,54 @@ define([], function () {
                 var parts = link.split(':'),
                     targetImport = currentModule.getImportByPrefix(parts[0]);
 
-                sourceModule = targetImport ? searchModule(modules, targetImport.label, targetImport.revisionDate) : null;
+                sourceModule = targetImport ?
+                                    searchModule(modules, targetImport.label, targetImport.revisionDate) : null;
                 sourceNode = sourceModule ? sourceModule.searchNode(targetType, parts[1]) : null;
             } else {
                 sourceModule = searchModule(modules, node.module, node.moduleRevision);
                 sourceNode = sourceModule ? sourceModule.searchNode(targetType, link) : null;
             }
 
-            return {node: sourceNode, module: sourceModule};
-        };
+            return { node: sourceNode, module: sourceModule };
+        }
 
-        var appendChildren = function (targetNode, sourceNode) {
+        // TODO: add function's description
+        function appendChildren(targetNode, sourceNode) {
             sourceNode.children.forEach(function (child) {
                 targetNode.addChild(child);
             });
-        };
+        }
 
-        var searchModule = function (modules, moduleName, moduleRevision) {
+        // TODO: add function's description
+        function searchModule(modules, moduleName, moduleRevision) {
             var searchResults = modules.filter(function (item) {
                     return (moduleName === item._name && (moduleRevision ? moduleRevision === item._revision : true));
                 }),
                 targetModule = (searchResults && searchResults.length) ? searchResults[0] : null;
 
             return targetModule;
-        };
-        var applyLinks = function (node, module, modules) {
+        }
+
+        // TODO: add function's description
+        function applyLinks(node, module, modules) {
             var changed = false;
-            if (linkFunctions.hasOwnProperty(node.type)) { //applying link function to uses.node
+            if (linkFunctions.hasOwnProperty(node.type)) { // applying link function to uses.node
                 changed = linkFunctions[node.type](node, module)(modules);
             }
 
             for (var i = 0; i < node.children.length; i++) {
                 if (applyLinks(node.children[i], module, modules)) {
-                    i--; //need to repeat current index because we are deleting uses nodes, so in case there are more uses in row, it would skip second one
+                    i--;
+                    // need to repeat current index because we are deleting uses nodes,
+                    // so in case there are more uses in row, it would skip second one
                 }
             }
 
             return changed;
-        };
+        }
 
-        var interConnectModules = function (modules) {
-            var rootNodes = [],
-                augments = [];
+        // TODO: add function's description
+        function interConnectModules(modules) {
 
             modules.forEach(function (module) {
                 module.getRoots().concat(module.getRawAugments()).forEach(function (node) {
@@ -129,9 +172,10 @@ define([], function () {
             });
 
             return modules;
-        };
+        }
 
-        var applyModuleRevision = function (node, module, revision) {
+        // TODO: add function's description
+        function applyModuleRevision(node, module, revision) {
             node.module = module;
             node.moduleRevision = revision;
 
@@ -140,37 +184,11 @@ define([], function () {
             });
 
             return node;
-        };
-
-        moduleConnector.processModuleObjs = function (modules) {
-            var rootNodes = [],
-                augments = [],
-                connectedModules = interConnectModules(modules.slice());
-
-            connectedModules.forEach(function (module) {
-                rootNodes = rootNodes.concat(module.getRoots());
-                augments = augments.concat(module.getAugments());
-            });
-
-            return {rootNodes: rootNodes, augments: augments};
-        };
-
-        moduleConnector.__test = {
-            isBuildInType: isBuildInType,
-            linkFunctions: linkFunctions,
-            findLinkedStatement: findLinkedStatement,
-            appendChildren: appendChildren,
-            searchModule: searchModule,
-            applyLinks: applyLinks,
-            interConnectModules: interConnectModules,
-            applyModuleRevision: applyModuleRevision
-        };
-
-        return moduleConnector;
+        }
     }
 
-    ModuleConnectorService.$inject=[];
+    ModuleConnectorService.$inject = [];
 
     return ModuleConnectorService;
 
-});
\ No newline at end of file
+});