Data structures (#18)

* data-structures complete

* review v2.0

* review v3.0

* Update README.md (#25)

* restructured instructions so that student makes any file operations when in a feature branch context to avoid commits to `master` before student reads instructions on pull request initialization
* added instructions on PR updates

* Port sniffer (#11)

* Add port-sniffer homework

* Add code after prettier and eslint check

* Fix eslint errors

* Add dependencies: commander, async

* Fixes respectively to PR 'Port sniffer' #11,

#11

* Delete dependencies from package.json

* Add all package-lock.jsons into .gitignore

* Add .gitignore in port-sniffer subdirectory

* Remove global package-lock.json

* Resolve integration with CI manager

* kissik/port-sniffer: integrate project into root package

* chores: make eslint ignoring nested node_modules

* change eslint+airbnb to semistandard (#24)

* change eslint+airbnb to semistandard

* fix linting errors

* submissions/kissik/port-sniffer: Fix linting errors

* data-structures complete

* review v2.0

* review v3.0

* Change eslint

Author: Siusarna

submissions/Siusarna/data-structures/data-structures/Element.js

@@ -0,0 +1,24 @@
+/* eslint-disable no-underscore-dangle */
+
+module.exports = class Node {
+  constructor (value, next = null) {
+    this._value = value;
+    this._next = next;
+  }
+
+  getValue () {
+    return this._value;
+  }
+
+  setValue (newValue) {
+    this._value = newValue;
+  }
+
+  getNext () {
+    return this._next;
+  }
+
+  setNext (newNext) {
+    this._next = newNext;
+  }
+};

submissions/Siusarna/data-structures/data-structures/linkedList.js

@@ -0,0 +1,75 @@
+/* eslint-disable no-underscore-dangle */
+
+const Node = require('./Element.js');
+
+function getSuccessorNode (prevNode, successor) {
+  let successorNode = prevNode;
+  if (!successor) {
+    return successorNode;
+  }
+  // successor value saved in prevNode or prevNode._next() so we check these node
+  if (prevNode.getValue() === successor) {
+    successorNode = prevNode;
+  } else if (prevNode.getNext()) {
+    successorNode = prevNode.getNext();
+  } else {
+    throw new Error('not found this successor');
+  }
+  return successorNode;
+}
+
+module.exports = class LinkedList {
+  constructor () {
+    this._head = null;
+    this._size = 0;
+  }
+
+  searchForPrevNode (inputValue) {
+    let iteratorNode = this._head;
+    while (
+      iteratorNode.getNext() &&
+      iteratorNode.getNext().getValue() !== inputValue
+    ) {
+      iteratorNode = iteratorNode.getNext();
+    }
+    return iteratorNode;
+  }
+
+  insert (inputValue, successor = null) {
+    if (this._head === null) {
+      this._head = new Node(inputValue);
+    } else {
+      const prevNode = this.searchForPrevNode(successor);
+      const successorNode = getSuccessorNode(prevNode, successor);
+      const currentNode = new Node(inputValue, successorNode.getNext());
+      successorNode.setNext(currentNode);
+    }
+    this._size += 1;
+  }
+
+  remove (inputValue) {
+    if (this._head.getValue() === inputValue) {
+      this._head = this._head.getNext();
+    } else {
+      const prevNodeForInputValue = this.searchForPrevNode(inputValue);
+      if (!prevNodeForInputValue.getNext()) {
+        throw new Error('not found this value');
+      }
+      const nextForRemovedNode = prevNodeForInputValue.getNext().getNext();
+      prevNodeForInputValue.setNext(nextForRemovedNode);
+    }
+    this._size -= 1;
+  }
+
+  show () {
+    let iteratorNode = this._head;
+    const allValueInList = [];
+    if (this._head) {
+      while (iteratorNode) {
+        allValueInList.push(iteratorNode.getValue());
+        iteratorNode = iteratorNode.getNext();
+      }
+    }
+    return allValueInList.reverse();
+  }
+};

submissions/Siusarna/data-structures/data-structures/stack.js

@@ -0,0 +1,29 @@
+/* eslint-disable no-underscore-dangle */
+
+const Node = require('./Element.js');
+
+module.exports = class Stack {
+  constructor () {
+    this._head = null;
+    this._size = 0;
+  }
+
+  push (inputValue) {
+    this._head = new Node(inputValue, this._head);
+    this._size += 1;
+  }
+
+  pop () {
+    let removedValue;
+    if (this._size) {
+      removedValue = this._head.getValue();
+      this._head = this._head.getNext() || null;
+      this._size -= 1;
+    }
+    return removedValue;
+  }
+
+  getSize () {
+    return this._size;
+  }
+};

submissions/Siusarna/data-structures/index.js

@@ -0,0 +1,5 @@
+const server = require('./server/server.js');
+const LinkedList = require('./data-structures/linkedList.js');
+const Stack = require('./data-structures/stack.js');
+
+server(new LinkedList(), new Stack());

submissions/Siusarna/data-structures/server/controllers.js

@@ -0,0 +1,163 @@
+function isJSON (req) {
+  return req.headers['content-type'] === 'application/json';
+}
+
+function showList (res, list) {
+  const allNodeFromList = list.show();
+  const jsonObjWithAllNode = JSON.stringify({ data: allNodeFromList });
+  const result = {
+    status: 'success',
+    data: jsonObjWithAllNode
+  };
+  return result;
+}
+
+function deleteElementsFromStack (res, stack) {
+  const removedValue = stack.pop();
+  const jsonObjWithRemovedValue = JSON.stringify({ data: removedValue });
+  const result = {
+    status: 'success',
+    data: jsonObjWithRemovedValue
+  };
+  return result;
+}
+
+function isValidData (inputData) {
+  return typeof inputData === 'number' || typeof inputData === 'string';
+}
+
+function sendWrongTypeOfContentResponse () {
+  const result = {
+    status: 'error',
+    data: 'wrong type of content'
+  };
+  return result;
+}
+
+function insertInList (res, list, inputData) {
+  const { data, successor } = inputData;
+  if (!isValidData(data)) {
+    throw new Error('wrong type of input value');
+  }
+  if (successor && isValidData(successor)) {
+    try {
+      list.insert(data, successor);
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  } else if (!successor) {
+    list.insert(data);
+  } else {
+    throw new Error('wrong type of input value');
+  }
+}
+
+function processOfInsertInList (res, list, inputData) {
+  const result = {};
+  try {
+    insertInList(res, list, inputData);
+    result.status = 'success';
+  } catch (err) {
+    result.status = 'error';
+    result.data = err.message;
+  }
+  return result;
+}
+
+function removeFromList (res, list, inputData) {
+  const result = {};
+  try {
+    list.remove(inputData.data);
+    result.status = 'success';
+  } catch (err) {
+    result.status = 'error';
+    result.data = err.message;
+  }
+  return result;
+}
+
+function pushOnStack (res, stack, inputData) {
+  stack.push(inputData.data);
+  const result = {
+    status: 'success'
+  };
+  return result;
+}
+
+function notFound () {
+  const result = {
+    status: 'error',
+    data: 'Url not found'
+  };
+  return result;
+}
+
+function makeStackResponse (method, stack, inputData, res) {
+  let result;
+  if (method === 'DELETE') {
+    result = deleteElementsFromStack(res, stack);
+  } else if (method === 'POST') {
+    result = pushOnStack(res, stack, inputData);
+  }
+  return result;
+}
+
+function makeListResponse (method, list, inputData, res) {
+  let result;
+  if (method === 'GET') {
+    result = showList(res, list);
+  } else if (method === 'POST') {
+    result = processOfInsertInList(res, list, inputData);
+  } else if (method === 'DELETE') {
+    result = removeFromList(res, list, inputData);
+  }
+  return result;
+}
+
+function responseMakers (typeOfStructures, method, inputData, res, list, stack) {
+  let result;
+  if (typeOfStructures === 'list') {
+    result = makeListResponse(method, list, inputData, res);
+  } else if (typeOfStructures === 'stack') {
+    result = makeStackResponse(method, stack, inputData, res);
+  } else {
+    result = notFound();
+  }
+  return result;
+}
+
+async function readBody (req) {
+  return new Promise(resolve => {
+    let body = '';
+    req.on('data', chunk => {
+      body += chunk.toString();
+    });
+    req.on('end', () => {
+      resolve(body);
+    });
+  });
+}
+
+module.exports = (list, stack) => {
+  return function controller (req, res) {
+    const typeOfStructeres = req.url.substr(1);
+    return new Promise(resolve => {
+      if (!isJSON(req)) {
+        resolve(sendWrongTypeOfContentResponse(res));
+      } else {
+        readBody(req).then(completeBody => {
+          const inputData = JSON.parse(completeBody);
+          const result = responseMakers(
+            typeOfStructeres,
+            req.method,
+            inputData,
+            res,
+            list,
+            stack
+          );
+          resolve(result);
+        });
+      }
+    });
+  };
+};

submissions/Siusarna/data-structures/server/httpResponce.js

@@ -0,0 +1,20 @@
+function success (res, data = null) {
+  if (data) {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+  } else {
+    res.writeHead(200);
+  }
+  res.end(data);
+}
+
+function error (res, message) {
+  res.writeHead(400, message);
+  res.end();
+}
+
+const responseSender = {
+  success,
+  error
+};
+
+module.exports = responseSender;

submissions/Siusarna/data-structures/server/server.js

@@ -0,0 +1,18 @@
+const http = require('http');
+const controllers = require('./controllers.js');
+const responseSender = require('./httpResponce.js');
+
+module.exports = (list, stack) => {
+  http
+    .createServer((req, res) => {
+      const promiseWithResult = controllers(list, stack)(req, res);
+      promiseWithResult.then(objWithStatusAndData => {
+        if (objWithStatusAndData.status === 'error') {
+          responseSender.error(res, objWithStatusAndData.data);
+        } else {
+          responseSender.success(res, objWithStatusAndData.data);
+        }
+      });
+    })
+    .listen(3000);
+};