blacksmith-organization-system 0.4.2

package/system/core/basic-subject-model.js

@@ -0,0 +1,200 @@
+/*
+  blacksmith-organization-system
+  part of Anubis System
+  Sett Sarverott 2019
+*/
+module.exports=function(BOS){
+  return class BlacksmithSubject extends BOS{
+    //static counter=0;
+    //initializationOfObject(initOpts){
+
+    //}
+    //loadConfiguration(){
+
+    //}
+    //eventListenersSetup(){
+
+    //}
+  };
+}
+
+/*
+const {BOS, SE}=require("./main.js");
+const fs=require("fs");
+const path=require("path");
+class BlacksmithSubject extends BOS{
+  setup(dirpath, name=path.basename(dirpath)){
+    SE.SAFE_CREATE_DIR(dirpath);
+    //this.parrent=parrent;
+    this.status="forged";
+    this.name=name;
+    this.dirpath=dirpath;
+    //this.extensions=[];
+    //this.history=[];
+    this.mainWatchHook=null;
+    this.content=this.refreshContent();
+    //GITIGNORE READING NEEDED
+    //this.files=[];
+    this.watcher=function(){};
+    //GITIGNORE READING NEEDED
+  }
+  refreshContent(){
+    var content={};
+    content.files=fs.readdirSync(
+      this.dirpath,
+      {withFileTypes:true}
+    ).map(function(file){
+      return {
+        name:file.name,
+        type:
+          (file.isFile())
+          ?
+          "flie"
+          :
+          (
+            (file.isDirectory())?"dir":"else"
+          )
+      }
+    });
+    content.status=fs.statSync(this.dirpath);
+    return content;
+  }
+  mainWatch(command){
+    switch(command){
+      case "start":
+        var tmpThis=this;
+        this.mainWatchHook=fs.watch(this.dirpath,function(...args){
+          args.push(tmpThis.refreshContent);
+          tmpThis.watcher(...args);
+        });
+      break;
+      case "stop":
+        if(this.mainWatchHook)this.mainWatchHook.close();
+      break;
+    }
+  }
+
+  //GITIGNORE READING NEEDED
+  /*
+  readContent(dirpath=this.dirpath){
+    var filelistTmp=fs.readdirSync(dirpath, {withFileTypes:true});
+    var output=[];
+    for(var i in filelistTmp){
+      var tmpFile={
+        "name":filelistTmp[i].name,
+        "path":path.join(dirpath,filelistTmp[i].name)
+      };
+      fs.stat(tmpFile.path,function(err, data){
+        tmpFile.status=data;
+      });
+      if(filelistTmp[i].isDirectory()){
+        tmpFile.type="dir";
+        tmpFile.content=this.readContent(tmpFile.path);
+      }else if(filelistTmp[i].isFile()){
+        tmpFile.type="file";
+        var tmpThis=this;
+        tmpFile.listener=fs.watchFile(tmpFile.path, function(...args){
+          tmpThis.watcher(...args);
+        });
+      }else{
+        tmpFile.type="else";
+      }
+      output.push(tmpFile);
+    }
+    if(dirpath===this.dirpath)this.files=output;
+    return output;
+    //fs.watch(path, action);
+  }
+  */
+  //GITIGNORE READING NEEDED
+/*
+  open(){
+    this.emitter.emit('open');
+  }
+  create(){
+    this.emitter.emit('create');
+  }
+  save(){
+    this.emitter.emit('save');
+  }
+  close(){
+    this.emitter.emit('close');
+  }
+  delete(){
+    this.emitter.emit('delete');
+  }
+  move(){
+    this.emitter.emit('move');
+  }
+  list(){
+    this.emitter.emit('list');
+  }
+  upload(){
+    this.emitter.emit('upload');
+  }
+  change(){
+    this.emitter.emit('change');
+  }
+  /*loadStorybook(data){
+    var tmp=[];
+    for(var i in data){
+      var tmptmp=new Fileitem(data[i].path);
+      tmptmp.checksum=data[i].checksum;
+      tmp.push(tmptmp);
+    }
+    return tmp;
+  }
+  checkAgreement(data){
+    var tmp1=this.loadStorybook(data);
+    var tmp2=this.scanFiles();
+    for(var i in tmp1){
+      for(var i in tmp1){
+
+      }
+    }
+  }
+  scanFiles(){
+    var tmp=getFilelist(this.getPath());
+    var tmpFiles=[]
+    for(var i in tmp){
+      var tmptmp=new Fileitem(tmp[i]);
+      tmptmp.getChecksum();
+      tmpFiles.push(tmptmp);
+    }
+    return tmpFiles;
+  }*/
+  //open(){
+    //if(this.isOpened()){
+
+    //  return false;
+    //}else{
+
+    //}
+    //if(this.watcher==null){
+    //  var tmpThis=this;
+    //  this.watcher=addChangeListener(this.getPath(), function(eventType, filename){
+    //    tmpThis.onChange(eventType, filename);
+    //  });
+    //}
+    //this.onOpen();
+  //}
+  /*
+  getWorkshop(){
+    if(this.parrent instanceof BOS.Workshop){
+      return this.parrent;
+    }else{
+      return this.parrent.parrent;
+    }
+  }
+  getSuperproject(){
+    if(this.parrent instanceof BOS.Workshop){
+      return this;
+    }else{
+      return this.parrent;
+    }
+  }
+  */
+  /*
+}
+module.exports=BlacksmithSubject;
+*/

package/system/core/config-controll.js

@@ -0,0 +1,51 @@
+//module.exports=
+//  (BOS) => class ConfigControll extends BOS.form.Controller
+//  {
+//
+//  }
+
+const os = require('os');
+const path = require('path');
+
+const DEFAULT_CONFIG={
+  workshopPath:path.join(
+    os.homedir(),
+    ".__WORKSHOP"
+  ),
+  workshopName:"the-thought-forest",
+  host:os.hostname(),//setternet
+  user:os.userInfo().username,
+  basicShell:os.userInfo().shell,
+  instanceRole:["cli","server","desktop","webapp","command"][0],
+  encryptArchive:false,
+  autobackups:false,
+  autocommit:false,
+  monitPushingSuggestions:false,
+  autoversioning:false,
+  branchPerHost:false,
+  publishAuth:{
+    //gitConfigs:[],
+    //npmConfigs:[],
+    //ftpCreds...
+  },
+  logger:{
+
+  },
+  workTree:{
+
+  },
+  setternet:{
+
+  }
+}
+
+const CONFIG_CONTROLL={
+  SETUP:{
+  }
+}
+
+module.exports=CONFIG_CONTROLL;
+//  (BOS) => class RaportControll extends BOS.form.Controller
+//  {
+
+//  }

package/system/core/contain-controll.js

@@ -0,0 +1,28 @@
+//module.exports=
+//  (BOS) => class ContainControll extends BOS.form.Controller
+//  {
+//
+//  }
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const {loadJSON, changeCase, capitalFirst} = require('carnival-toolbox');
+
+const CONTAIN_CONTROLL={
+
+  IsWorkshopDeployed(){
+    return fs.existsSync(
+      path.join(
+        os.homedir(),
+        ".__WORKSHOP"
+      )
+    );
+  }
+}
+
+module.exports=CONTAIN_CONTROLL;
+//  (BOS) => class RaportControll extends BOS.form.Controller
+//  {
+
+//  }

package/system/core/event-controll.js

@@ -0,0 +1,12 @@
+//const {BOS}=require("./main.js");
+//const events=require("events");
+
+//class BOSlistener extends events.EventEmitter{};
+
+//module.exports=function(){return new BOSlistener();}
+
+//module.exports=
+//  (BOS) => class EventControll extends BOS.form.Controller
+//  {
+//
+//  }

package/system/core/extending-mod.js

@@ -0,0 +1,145 @@
+
+//const transform=require('carnival-toolbox').caseX.transform;
+const fs = require('fs');
+const path = require('path');
+const {changeCase, capitalFirst, debug} = require('carnival-toolbox');
+
+const EXTENDER={
+  Update(updatePack, whoAmI=this){
+    Object.assign(
+      whoAmI,
+      updatePack
+    );
+    return whoAmI;
+  },
+  HookRef(contextRef, hookName, whoAmI=this){
+    Object.defineProperty(
+      whoAmI,
+      hookName,
+      {
+        get(){
+          return contextRef;
+        }
+      }
+    );
+    return whoAmI;
+  },
+  LoadExt(...pathChain){
+    pathChain.push(`${pathChain.pop()}.js`);
+    //console.log(this);
+    const EXT=require(
+      this.PathTo(...pathChain)
+    );
+    this.Update(
+      EXT
+    );
+    return Object.keys(EXT);
+  },
+  LoadController(name){
+    debug.log("CONTROLER-LOAD:", [name]);
+    this.CONTROLLERS[name]=this.LoadExt("system", "core", name);
+  },
+  LoadInterface(name){
+    debug.log("INTERFACE-LOAD:", [name]);
+    //this.loadExt("system", "interfaces", name)
+    return require(
+      this.PathTo(
+        "system",
+        "interfaces",
+        `${name}`,
+        `index.js`
+      )
+    )
+  },
+  LoadBridge(name){
+    debug.log("BRIDGE-LOAD:", [name]);
+    //this.LoadExt("system", "bridge", name)
+  },
+  LoadAllControllers(){
+    const autolistControllers=fs.readdirSync(__dirname).filter(
+      (filename)=>filename.endsWith("-controll.js")
+    ).map(
+      (name)=>path.basename(name, ".js")
+    );
+    for(var item of autolistControllers){
+      this.LoadController(item);
+      //console.log(item)
+    }
+  },
+  LoadAllFactors(){
+    const factoryScripts=fs.readdirSync(
+      this.PathTo("system","factors"),
+      {withFileTypes:true}
+    ).filter(
+      (item)=>item.isFile()
+    ).filter(
+      (item)=>item.name.endsWith("-factory.js")
+    ).map(
+      (item)=>item.name
+    );
+    //this.FACTORS={};
+    //console.log(factoryScripts);
+    for(var script of factoryScripts){
+      debug.log("FACTOR-LOAD:", [script.split("-")[0]]);
+      this.FACTORS[
+        capitalFirst(script.split("-")[0])
+      ]=require(this.PathTo("system","factors",script));
+    }
+  },
+  LoadCommand(name, script){
+    debug.log("COMMAND-LOAD:", [name,script]);
+    this.COMMANDS[name]=require(
+      this.PathTo( "system", "commands", script)
+    );
+  },
+  LoadAllCommands(){
+    const commandsScripts=fs.readdirSync(
+      this.PathTo("system", "commands"),
+      {withFileTypes:true}
+    ).filter(
+      (script)=>script.isFile()
+    ).filter(
+      (script)=>path.extname(script.name)==".js"
+    ).map(
+      (script)=>script.name
+    );
+    for(var script of commandsScripts){
+      this.LoadCommand(
+        changeCase(
+          path.basename(script, ".js")
+        ).from("kebabcase").to("camelcase").GO,
+        script
+      );
+    }
+  },
+  LoadAllModels(){
+    const models=this.ListModelsDir();
+    for(var model of models){
+      this.LoadModel(model);
+    }
+  },
+  LoadModel(name){
+    debug.log("MODEL-LOAD:", [name]);
+    //console.log(name);
+    this.MODELS[name]=require(
+      this.PathTo( "system", "models", name, "class.js")
+    );
+    var modelname = changeCase(name).from("camelcase").to("pascalcase").GO;
+    this.HookRef(this.MODELS[name], modelname);
+  },
+  ListModelsDir(){
+    return fs.readdirSync(
+      this.PathTo("system", "models"),
+      {withFileTypes:true}
+    ).filter(
+      (model)=>model.isDirectory()
+    ).map(
+      (model)=>model.name
+    );
+  }
+}
+
+module.exports=function(BOS){
+  EXTENDER.Update(EXTENDER, BOS);
+  return BOS;
+}

package/system/core/main.js

@@ -0,0 +1,184 @@
+/*
+  blacksmith-organization-system
+  part of Anubis System
+  Sett Sarverott 2019
+*/
+
+//const SE=require("./static-extender.js");
+
+const {caseX}=require('carnival-toolbox');
+const child_process = require('child_process');
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const EventEmitter = require('events');
+
+const CONTROLLERS = {}
+const MODELS = {}
+const ID_REJESTR = {}
+const FACTORS = {}
+const INTERFACES = {}
+const COMMANDS = {}
+
+
+
+class BlacksmithOrganizationSystem extends EventEmitter{
+  constructor(classname, modelDir){
+    this.type=classname.replace("Blacksmith","");
+
+    //this.readIndex();
+    //this.openManuals();
+    //this.eventEmitter=new eventEmitter();
+
+    this.loadMethods(modelDir);
+    this.loadExtenders(modelDir);
+    this.loadEvents(modelDir);
+    this.loadActions(modelDir);
+    this.loadListeners(modelDir);
+  }
+  //readIndex(){
+
+  //}
+  //openManuals(){
+
+  //}
+  static GetModelScripts(section, modelDir){
+    return fs.readdirSync(
+      path.join(
+        modelDir,
+        section
+      ),
+      {withFileTypes:true}
+    ).filter(
+      (script)=>script.isFile()&&script.name.endsWith(".js")
+    ).map(
+      (direntItem)=>direntItem.name
+    );
+  }
+  loadEvents(modelDir){ // direct listeners and emitters of model
+    const modelScripts=BOS.GetModelScripts(
+      "events",
+      modelDir
+    );
+
+  }
+  loadActions(modelDir){// acts like deamons or child precesses
+    const modelScripts=BOS.GetModelScripts(
+      "actions",
+      modelDir
+    );
+  }
+  loadListeners(modelDir){// everything what that model listens
+    const modelScripts=BOS.GetModelScripts(
+      "listeners",
+      modelDir
+    );
+  }
+  loadMethods(modelDir){// synchronous, returns data
+    const modelScripts=BOS.GetModelScripts(
+      "methods",
+      modelDir
+    );
+  }
+  loadExtenders(modelDir){// extensionpacks for model
+    const modelScripts=BOS.GetModelScripts(
+      "extenders",
+      modelDir
+    );
+    for(var scriptName of modelScripts){
+      Object.assign(
+        this,
+        require(
+          path.join(
+            modelDir,
+            "extenders",
+            scriptName
+          )
+        )
+      );
+    }
+  }
+  static get Subject(){
+    return require("./basic-subject-model.js")(BOS);
+  }
+  static PathTo(...locationChain){
+    return path.join(__dirname, "..", "..", ...locationChain);
+  }
+  static get BOS(){
+    return this;
+  }
+  get BOS(){
+    return BOS;
+  }
+  static get INITIALIZE(){
+    return BOS.LOAD();
+  }
+  static BOX_EMPTY(boxHook){
+    return Object.keys(boxHook).length==0;
+  }
+  static LOAD(...limiter){
+    if(this.BOX_EMPTY(CONTROLLERS))this.LoadAllControllers();
+    if(this.BOX_EMPTY(MODELS))this.LoadAllModels();
+    if(this.BOX_EMPTY(FACTORS))this.LoadAllFactors();
+    if(this.BOX_EMPTY(COMMANDS))this.LoadAllCommands();
+    /*}
+    for(var i in loadList){
+      if(
+        (
+          limiter.length==0
+          ||
+          limiter.includes(i)
+        )
+        &&
+        loadList[i][0])
+      ){
+        this[
+          loadList[i][1]
+        ]();
+      }
+    }*/
+    return this;
+  }
+  //static debugLog(...args){
+  //  if(BOS.DEBUGGING)console.log(...args);
+  //}
+};
+
+//BOS.DEBUGGING=false;
+
+BOS=BlacksmithOrganizationSystem;
+//BOS.INIT_BASE();
+//BOS.TypeList=TYPES_LIST;
+//BOS.IdRegistList=ID_REJESTR
+
+const FORM=require('./extending-mod.js')(BOS);
+BOS.Update({
+  CONTROLLERS,
+  MODELS,
+  ID_REJESTR,
+  FACTORS,
+  INTERFACES,
+  COMMANDS
+});
+//BOS.LOAD();
+//BOS.loadInterface()
+
+//
+
+module.exports={
+  BOS,
+  get INITIALIZE(){
+    return BOS.INITIALIZE;
+  }
+  //CONTROLLERS,
+  //MODELS,
+  //ID_REJESTR,
+  //FACTORS,
+  //INTERFACES,
+  //COMMANDS
+  //ID_REJESTR
+  //FORM
+
+  //SE
+  //HOSTNAME
+};

package/system/core/raport-controll.js

@@ -0,0 +1,10 @@
+
+const RAPORT_CONTROLL={
+  
+}
+
+module.exports=RAPORT_CONTROLL;
+//  (BOS) => class RaportControll extends BOS.form.Controller
+//  {
+
+//  }

package/system/core/static-extender.js

@@ -0,0 +1,19 @@
+const fs=require("fs");
+module.exports={
+  SAFE_CREATE_DIR(path){
+    fs.mkdirSync(path,{recursive:true})
+  },
+  WRITE_OUTPUT_FILE(filepath, output, readable=false){
+    fs.writeFileSync(
+      filepath,
+      JSON.stringify(
+        ...((readable)?[output, null, '\t']:[output])
+      )
+    );
+  },
+  READ_INPUT_FILE(filepath){
+    return JSON.parse(fs.readFileSync(
+      filepath
+    ));
+  }
+}

package/system/factors/bridge-factory.js

@@ -0,0 +1,5 @@
+
+
+module.exports=class BOS_Bridge{
+  
+};

package/system/factors/command-factory.js

@@ -0,0 +1,45 @@
+const {debug} = require('carnival-toolbox');
+
+module.exports=class BOS_Command{
+  constructor(name){
+    this.name=name;
+    this.interfaces={};
+    this.CONTEXT={};
+  }
+  USAGE(interfaceName){
+    return {
+      interfaceName:interfaceName,
+      interfaces:this.interfaces,
+      get DEFINE(){
+        if(
+          !this.interfaces.hasOwnProperty(this.interfaceName)
+        )this.interfaces[this.interfaceName]={get:()=>null,set:(x)=>null};
+        return {
+          interfaceName:this.interfaceName,
+          interfaces:this.interfaces,
+          set METHOD(funct){
+            this.GET=()=>funct;
+          },
+          set SET(funct){
+            this.interfaces[this.interfaceName].set=funct;
+          },
+          set GET(funct){
+            this.interfaces[this.interfaceName].get=funct;
+          }
+        }
+      },
+      get LOAD(){
+        return this.interfaces[this.interfaceName];
+      }
+    }
+  }
+  INCLUDE_TO(context, interfaceName){
+    this.CONTEXT[interfaceName]=context;
+    debug.log(`---including command ${this.name} as usage by ${interfaceName} in context`)
+    Object.defineProperty(
+      context,
+      this.name,
+      this.USAGE(interfaceName).LOAD
+    );
+  }
+}

package/system/factors/config-factory.js

@@ -0,0 +1,6 @@
+
+//os.userInfo().username,
+
+module.exports=class BOS_config{
+
+}