x.json

{
  "name": "utils",
  "description": "Utility components for Chiχ",
  "version": "0.0.3",
  "repository": {
    "type": "git",
    "url": "https://github.com/nodule/utils.git"
  },
  "dependencies": {
    "JSONPath": "0.x.x",
    "csv": "0.x.x",
    "glob": "3.x.x",
    "iffi": "0.x.x",
    "inquiry": "0.x.x",
    "json-path": "0.x.x",
    "xml2js": "0.x.x",
    "xml2json": "0.x.x"
  },
  "nodes": [
    {
      "name": "converter",
      "ns": "utils",
      "description": "Convert ascii, utf8, ucs2, base64, binary or hex",
      "async": true,
      "phrases": {
        "active": "Converting from {{input.from}} to {{input.to}}"
      },
      "ports": {
        "input": {
          "in": {
            "type": "any",
            "title": "Input",
            "async": true
          },
          "from": {
            "enum": [
              "ascii",
              "utf8",
              "ucs2",
              "base64",
              "binary",
              "hex"
            ],
            "type": "string",
            "title": "From",
            "default": "utf8"
          },
          "to": {
            "enum": [
              "ascii",
              "utf8",
              "ucs2",
              "base64",
              "binary",
              "hex"
            ],
            "type": "string",
            "title": "To",
            "default": "utf8"
          }
        },
        "output": {
          "out": {
            "type": "any",
            "title": "Output"
          }
        }
      },
      "dependencies": {
        "npm": {
          "buffer": "internal"
        }
      },
      "fn": "on.input.in = function() {\n  // \\n replace shouldn't be necessary.\n  if(typeof $.in === 'string' && $.from === 'base64') {\n    $.in = $.in.replace('\\n', '');\n  }\n  var d = new buffer.Buffer($.in, $.from);\n  output( { out: $.write('in', d.toString($.to)) });\n};\n"
    },
    {
      "name": "csv",
      "ns": "utils",
      "title": "CSV",
      "async": true,
      "description": "NodeCSV Parser",
      "phrases": {
        "active": "Parsing CSV"
      },
      "ports": {
        "input": {
          "in": {
            "type": "string",
            "title": "CSV",
            "async": true,
            "description": "A Comma Seperated Values document",
            "required": true
          }
        },
        "output": {
          "out": {
            "type": "array",
            "title": "Output",
            "description": "An array of records"
          }
        }
      },
      "dependencies": {
        "npm": {
          "csv": "0.x.x"
        }
      },
      "fn": "on.input.in = function() {\n  csv().\n    from.\n    string($.in, {}).\n    to.\n    array(function(val) {\n        output({ out: $.write('in', val) });\n        });\n};\n"
    },
    {
      "name": "dummy",
      "ns": "utils",
      "title": "Dummy",
      "description": "Takes an input and passes it to output.",
      "phrases": {
        "active": "Dummy"
      },
      "ports": {
        "input": {
          "in": {
            "type": "any",
            "title": "Input"
          }
        },
        "output": {
          "out": {
            "type": "any",
            "title": "Output"
          }
        }
      },
      "fn": "output.out = $.get('in')\n"
    },
    {
      "name": "exec",
      "ns": "utils",
      "description": "Execute a program",
      "phrases": {
        "active": "Executing {{input.in}}"
      },
      "ports": {
        "input": {
          "in": {
            "type": "string",
            "title": "Program String",
            "description": "e.g. `cat *.js bad_file | wc -l`"
          },
          "data": {
            "type": "string",
            "title": "Data For StdIn",
            "description": "Optional data to be send to stdin, the process executed must be set to expect stdin",
            "default": null
          },
          "encoding": {
            "type": "string",
            "title": "Encoding",
            "default": "utf-8"
          },
          "timeout": {
            "type": "number",
            "title": "Encoding",
            "default": 0
          },
          "maxBuffer": {
            "type": "number",
            "title": "Buffer Maximum",
            "default": 204800
          },
          "killSignal": {
            "type": "string",
            "title": "Kill Signal",
            "default": "SIGTERM"
          },
          "cwd": {
            "type": "string",
            "title": "Current working dir",
            "default": null
          },
          "env": {
            "type": "string",
            "title": "Env",
            "default": null
          }
        },
        "output": {
          "out": {
            "title": "Std Out",
            "type": "string"
          },
          "flushed": {
            "title": "Flushed",
            "type": "boolean"
          },
          "error": {
            "title": "Error",
            "type": "object"
          }
        }
      },
      "dependencies": {
        "npm": {
          "child_process": "builtin"
        }
      },
      "fn": "output = function (cb) {\n  var child = child_process.exec($.in,\n    function (error, stdout, stderr) {\n\n      if(stderr) {\n        cb({error: $.create(stderr)});\n      } else if (error) {\n        cb({error: $.create(error)});\n      } else {\n        cb({out: $.create(stdout)});\n      }\n\n      done();\n    }, {\n      encoding: $.encoding,\n      maxBuffer: $.maxBuffer,\n      killSignal: $.killSignal,\n      cwd: $.cwd,\n      env: $.env\n    });\n\n  child.on('error', function(err) {\n    cb({ error: $.create(err) });\n  });\n\n  if ($.data) {\n    child.stdin.end($.data, $.encoding, function () {\n      cb({flushed: $.create(true)});\n    });\n  }\n};\n"
    },
    {
      "name": "function",
      "ns": "utils",
      "async": true,
      "description": "Execute a function",
      "phrases": {
        "active": "Executing Function "
      },
      "ports": {
        "input": {
          "in": {
            "type": "any",
            "async": true,
            "title": "Function Input"
          },
          "fn": {
            "type": "function",
            "args": [
              "data",
              "output",
              "$"
            ],
            "title": "Function Body"
          }
        },
        "output": {
          "out": {
            "title": "Std Out",
            "type": "string"
          },
          "error": {
            "title": "Error",
            "type": "object"
          }
        }
      },
      "fn": "on.input.in = function() {\n  $.fn($.in, output, $);\n}\n"
    },
    {
      "name": "if",
      "ns": "utils",
      "title": "IF",
      "description": "Accepts a value on one port and checks it against an if statement.",
      "phrases": {
        "active": "Deciding IF"
      },
      "ports": {
        "input": {
          "value": {
            "type": "any",
            "title": "Value"
          },
          "in": {
            "type": "string",
            "title": "IF statement",
            "description": "Any if statement, the input is available as `in`. e.g. in.required === true, providing the input object has a property `required`, compilation failures will go to the error port. The input value will be passed either to the Yes or No port."
          }
        },
        "output": {
          "error": {
            "type": "object",
            "title": "Error",
            "description": "Error"
          },
          "yes": {
            "type": "any",
            "title": "Yes"
          },
          "no": {
            "type": "any",
            "title": "No"
          }
        }
      },
      "dependencies": {
        "npm": {
          "iffi": "0.x.x"
        }
      },
      "fn": "try {\n  if (iffi($.in, {\n    value: $.value\n  })) {\n    output = {yes: $.create($.value)};\n  } else {\n    output = {no: $.create($.value)};\n  }\n} catch (e) {\n  output = {error: $.create(e)};\n}\n"
    },
    {
      "name": "if2",
      "ns": "utils",
      "title": "IF2",
      "description": "Accepts values on two ports and checks it against an if statement.",
      "phrases": {
        "active": "Deciding IF"
      },
      "ports": {
        "input": {
          "value": {
            "type": "any",
            "title": "Input Value",
            "description": "The value to be checked"
          },
          "compare": {
            "type": "any",
            "title": "Comparant Value"
          },
          "in": {
            "type": "string",
            "title": "IF statement",
            "description": "Any if statement, the input is available as `in`. e.g. in.required === true, providing the input object has a property `required`, compilation failures will go to the output port."
          }
        },
        "output": {
          "error": {
            "type": "object",
            "title": "Error",
            "description": "Error"
          },
          "yes": {
            "type": "boolean",
            "title": "Yes"
          },
          "no": {
            "type": "boolean",
            "title": "No"
          }
        }
      },
      "dependencies": {
        "npm": {
          "iffi": "0.x.x"
        }
      },
      "fn": "try {\n  if (iffi($.in, {\n    'value': $.value,\n    'compare': $.compare\n  })) {\n    output = {yes: $.create($.value)};\n  } else {\n    output = {no: $.create($.value)};\n  }\n} catch (e) {\n  output = {error: $.create(e)};\n}\n"
    },
    {
      "name": "interval",
      "ns": "utils",
      "async": true,
      "description": "Repeats the input",
      "phrases": {
        "active": "Repeating input every {{input.interval}} milliseconds."
      },
      "expose": [
        "setInterval"
      ],
      "ports": {
        "input": {
          "in": {
            "type": "any",
            "title": "Input",
            "async": true,
            "description": "Input to be repeated (if any)",
            "default": null
          },
          "interval": {
            "type": "number",
            "title": "Interval",
            "description": "Interval in milliseconds",
            "format": "time",
            "required": true
          },
          "stop": {
            "type": "any",
            "title": "Stop",
            "async": true
          },
          "start": {
            "type": "any",
            "title": "Start",
            "async": true
          }
        },
        "output": {
          "out": {
            "type": "any",
            "title": "Output",
            "description": "Outputs the repeated input"
          }
        }
      },
      "fn": "state.doInterval = function() {\n  state.timer = setInterval(function () {\n    output({out: state.data});\n  }, state.interval);\n};\n\non.input.in = function() {\n  // automatically picked up by interval\n  state.data = $.get('in');\n};\n\non.input.interval = function() {\n  state.interval = $.interval;\n\n  if(state.timer) {\n    // already running reset\n    clearInterval(state.timer);\n  }\n\n  state.doInterval();\n};\n\non.input.start = function() {\n  // reject start if no data yet\n  if(undefined === state.data) {\n    return false;\n  }\n\n  // reject start if no interval value yet\n  if(undefined === state.interval) {\n    return false;\n  }\n\n  if(!state.timer) {\n    state.doInterval();\n  }\n};\n\non.input.stop = function() {\n  if(state.timer) {\n    clearInterval(state.timer);\n  }\n};\n"
    },
    {
      "name": "method",
      "ns": "utils",
      "description": "Execute a method",
      "phrases": {
        "active": "Executing method {{input.method}}"
      },
      "ports": {
        "input": {
          "in": {
            "type": "array",
            "title": "Arguments",
            "description": "arguments to be applied to this method",
            "default": []
          },
          "instance": {
            "type": "function",
            "title": "Instance",
            "description": "instance to invoke this method on"
          },
          "method": {
            "type": "string",
            "title": "Method name"
          }
        },
        "output": {
          "out": {
            "title": "Out",
            "type": "any"
          },
          "error": {
            "title": "Error",
            "type": "object"
          }
        }
      },
      "fn": "output.out = $.write('in', $.instance[$.method].apply($.instance, $.in))\n"
    },
    {
      "name": "true",
      "title": "true?",
      "ns": "utils",
      "description": "Whether the input is true or false",
      "phrases": {
        "active": "Determining truth"
      },
      "ports": {
        "input": {
          "in": {
            "type": "boolean",
            "title": "A boolean"
          }
        },
        "output": {
          "yes": {
            "type": "boolean",
            "title": "Yes"
          },
          "no": {
            "type": "boolean",
            "title": "No"
          }
        }
      },
      "fn": "if (!!$.in) {\n  output.yes = $.get('in')\n} else {\n  output.no = $.get('in')\n}\n"
    },
    {
      "name": "wait",
      "ns": "utils",
      "async": true,
      "description": "Holds the input for a while",
      "phrases": {
        "active": "Holding input for {{input.timeout}} milliseconds."
      },
      "expose": [
        "setTimeout"
      ],
      "ports": {
        "input": {
          "in": {
            "type": "any",
            "title": "Input",
            "description": "Input to be delayed",
            "async": true
          },
          "timeout": {
            "type": "number",
            "title": "Timeout",
            "description": "Timeout in milliseconds",
            "format": "time"
          }
        },
        "output": {
          "out": {
            "type": "any",
            "title": "Output",
            "description": "Outputs the delayed input"
          }
        }
      },
      "fn": "on.input.in = function() {\n  setTimeout(function () {\n    output({out: $.get('in')});\n  }, $.timeout);\n};\n"
    },
    {
      "name": "xml2js",
      "ns": "utils",
      "description": "Simple XML to JavaScript object converter",
      "phrases": {
        "active": "Converting XML to Object"
      },
      "ports": {
        "input": {
          "xml": {
            "type": "string",
            "format": "xml",
            "title": "XML"
          }
        },
        "output": {
          "error": {
            "type": "object",
            "title": "Error Object"
          },
          "result": {
            "type": "object"
          }
        }
      },
      "dependencies": {
        "npm": {
          "xml2js": "0.x.x"
        }
      },
      "fn": "output = [xml2js, 'parseString', $.xml]\n"
    }
  ]
}