Add triangle

Author: SLIB53

Diff for: triangle/.eslintrc

@@ -0,0 +1,26 @@
+{
+  "root": true,
+  "parser": "babel-eslint",
+  "parserOptions": {
+    "ecmaVersion": 7,
+    "sourceType": "module"
+  },
+  "env": {
+    "es6": true,
+    "node": true,
+    "jest": true
+  },
+  "extends": [
+    "eslint:recommended",
+    "plugin:import/errors",
+    "plugin:import/warnings"
+  ],
+  "rules": {
+    "linebreak-style": "off",
+
+    "import/extensions": "off",
+    "import/no-default-export": "off",
+    "import/no-unresolved": "off",
+    "import/prefer-default-export": "off"
+  }
+}

Diff for: triangle/README.md

@@ -0,0 +1,43 @@
+# Triangle
+
+Determine if a triangle is equilateral, isosceles, or scalene.
+
+An _equilateral_ triangle has all three sides the same length.
+
+An _isosceles_ triangle has at least two sides the same length. (It is sometimes
+specified as having exactly two sides the same length, but for the purposes of
+this exercise we'll say at least two.)
+
+A _scalene_ triangle has all sides of different lengths.
+
+## Note
+
+For a shape to be a triangle at all, all sides have to be of length > 0, and
+the sum of the lengths of any two sides must be greater than or equal to the
+length of the third side. See [Triangle Inequality](https://en.wikipedia.org/wiki/Triangle_inequality).
+
+## Dig Deeper
+
+The case where the sum of the lengths of two sides _equals_ that of the
+third is known as a _degenerate_ triangle - it has zero area and looks like
+a single line. Feel free to add your own code/tests to check for degenerate triangles.
+
+## Requirements
+
+Install assignment dependencies:
+
+```bash
+$ yarn
+```
+
+## Making the test suite pass
+
+Execute the tests with:
+
+```bash
+$ yarn test
+```
+
+## Source
+
+The Ruby Koans triangle project, parts 1 & 2 [http://rubykoans.com](http://rubykoans.com)

Diff for: triangle/babel.config.js

@@ -0,0 +1,14 @@
+module.exports = {
+  presets: [
+    [
+      '@babel/env',
+      {
+        targets: {
+          node: 'current',
+        },
+        useBuiltIns: false,
+      },
+
+    ],
+  ],
+};

Diff for: triangle/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "exercism-javascript",
+  "description": "Exercism exercises in Javascript.",
+  "author": "Katrina Owen",
+  "private": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/exercism/javascript"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.5.5",
+    "@babel/core": "^7.5.5",
+    "@babel/preset-env": "^7.5.5",
+    "@types/jest": "^24.0.16",
+    "@types/node": "^12.6.8",
+    "babel-eslint": "^10.0.2",
+    "babel-jest": "^24.8.0",
+    "eslint": "^6.1.0",
+    "eslint-plugin-import": "^2.18.2",
+    "jest": "^24.8.0"
+  },
+  "jest": {
+    "modulePathIgnorePatterns": [
+      "package.json"
+    ]
+  },
+  "scripts": {
+    "test": "jest --no-cache ./*",
+    "watch": "jest --no-cache --watch ./*",
+    "lint": "eslint .",
+    "lint-test": "eslint . && jest --no-cache ./* "
+  },
+  "license": "MIT",
+  "dependencies": {}
+}

Diff for: triangle/triangle.js

@@ -0,0 +1,38 @@
+function isValidTriangle(s1, s2, s3) {
+  const sidesSorted = [s1, s2, s3].sort((a, b) => a - b);
+
+  return (
+    sidesSorted[0] > 0 && sidesSorted[0] + sidesSorted[1] >= sidesSorted[2]
+  );
+}
+
+function classifyTriangle(s1, s2, s3) {
+  const sidesSorted = [s1, s2, s3].sort((a, b) => a - b);
+
+  if (sidesSorted[0] === sidesSorted[2]) {
+    return "equilateral";
+  } else if (
+    sidesSorted[0] === sidesSorted[1] ||
+    sidesSorted[1] === sidesSorted[2]
+  ) {
+    return "isosceles";
+  } else {
+    return "scalene";
+  }
+}
+
+export class Triangle {
+  constructor(s1, s2, s3) {
+    this.s1 = s1;
+    this.s2 = s2;
+    this.s3 = s3;
+  }
+
+  kind() {
+    if (!isValidTriangle(this.s1, this.s2, this.s3)) {
+      throw "invalid triangle";
+    }
+
+    return classifyTriangle(this.s1, this.s2, this.s3);
+  }
+}

Diff for: triangle/triangle.spec.js

@@ -0,0 +1,78 @@
+import { Triangle } from './triangle';
+
+describe('Triangle', () => {
+  test('equilateral triangles have equal sides', () => {
+    const triangle = new Triangle(2, 2, 2);
+    expect(triangle.kind()).toEqual('equilateral');
+  });
+
+  test('larger equilateral triangles also have equal sides', () => {
+    const triangle = new Triangle(10, 10, 10);
+    expect(triangle.kind()).toEqual('equilateral');
+  });
+
+  test('isosceles triangles have last two sides equal', () => {
+    const triangle = new Triangle(3, 4, 4);
+    expect(triangle.kind()).toEqual('isosceles');
+  });
+
+  test('isosceles trianges have first and last sides equal', () => {
+    const triangle = new Triangle(4, 3, 4);
+    expect(triangle.kind()).toEqual('isosceles');
+  });
+
+  test('isosceles triangles have two first sides equal', () => {
+    const triangle = new Triangle(4, 4, 3);
+    expect(triangle.kind()).toEqual('isosceles');
+  });
+
+  test('isosceles triangles have in fact exactly two sides equal', () => {
+    const triangle = new Triangle(10, 10, 2);
+    expect(triangle.kind()).toEqual('isosceles');
+  });
+
+  test('scalene triangles have no equal sides', () => {
+    const triangle = new Triangle(3, 4, 5);
+    expect(triangle.kind()).toEqual('scalene');
+  });
+
+  test('scalene triangles have no equal sides at a larger scale too', () => {
+    const triangle = new Triangle(10, 11, 12);
+    expect(triangle.kind()).toEqual('scalene');
+  });
+
+  test('scalene triangles have no equal sides in descending order either', () => {
+    const triangle = new Triangle(5, 4, 2);
+    expect(triangle.kind()).toEqual('scalene');
+  });
+
+  test('very small triangles are legal', () => {
+    const triangle = new Triangle(0.4, 0.6, 0.3);
+    expect(triangle.kind()).toEqual('scalene');
+  });
+
+  test('test triangles with no size are illegal', () => {
+    const triangle = new Triangle(0, 0, 0);
+    expect(triangle.kind.bind(triangle)).toThrow();
+  });
+
+  test('triangles with negative sides are illegal', () => {
+    const triangle = new Triangle(3, 4, -5);
+    expect(triangle.kind.bind(triangle)).toThrow();
+  });
+
+  test('triangles violating triangle inequality are illegal', () => {
+    const triangle = new Triangle(1, 1, 3);
+    expect(triangle.kind.bind(triangle)).toThrow();
+  });
+
+  test('triangles violating triangle inequality are illegal 2', () => {
+    const triangle = new Triangle(7, 3, 2);
+    expect(triangle.kind.bind(triangle)).toThrow();
+  });
+
+  test('triangles violating triangle inequality are illegal 3', () => {
+    const triangle = new Triangle(10, 1, 3);
+    expect(triangle.kind.bind(triangle)).toThrow();
+  });
+});