trackler 2.2.1.44 → 2.2.1.45

data/tracks/typescript/exercises/triangle/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "xtypescript",
+  "version": "1.0.0",
+  "description": "Exercism exercises in Typescript.",
+  "author": "",
+  "private": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/exercism/xtypescript"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "tsc --noEmit -p . && jest --no-cache",
+    "lint": "tsc --noEmit -p . && tslint \"*.ts?(x)\"",
+    "lintci": "tslint \"*.ts?(x)\" --force"
+  },
+  "dependencies": {
+    "@types/jest": "^20.0.0",
+    "@types/node": "^7.0.5",
+    "jest": "^20.0.4",
+    "ts-jest": "^20.0.6",
+    "tslint": "^5.4.3",
+    "typescript": "^2.2.1"
+  },
+  "jest": {
+    "transform": {
+      ".(ts|tsx)": "<rootDir>/node_modules/ts-jest/preprocessor.js"
+    },
+    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(ts|tsx|js)$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js"
+    ]
+  }
+}

data/tracks/typescript/exercises/triangle/triangle.example.ts

@@ -0,0 +1,56 @@
+enum Type {
+    Equilateral = "equilateral",
+    Isosceles = "isosceles",
+    Scalene = "scalene"
+}
+
+export default class Triangle {
+    sides: number[]
+
+    constructor(...sides: number[]) {
+        this.sides = sides
+    }
+
+    kind() {
+        if (this.isIllegal()) {
+            throw new TypeError('illegal')
+        }
+
+        if (this.isEquilateral()) {
+            return Type.Equilateral
+        }
+
+        if (this.isIsosceles()) {
+            return Type.Isosceles
+        }
+
+        return Type.Scalene
+    }
+
+    isIllegal() {
+        return this.violatesInequality() || this.hasImpossibleSides()
+    }
+
+    violatesInequality() {
+        const [a, b, c] = this.sides
+        return a + b < c || a + c < b || b + c < a
+    }
+
+    hasImpossibleSides() {
+        const [a, b, c] = this.sides
+        return a <= 0 || b <= 0 || c <= 0
+    }
+
+    isEquilateral() {
+        return this.uniqueSidesLength() === 1
+    }
+
+    isIsosceles() {
+        return this.uniqueSidesLength() === 2
+    }
+
+    uniqueSidesLength() {
+        return new Set(this.sides).size
+    }
+
+}

data/tracks/typescript/exercises/triangle/triangle.test.ts

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

data/tracks/typescript/exercises/triangle/triangle.ts

@@ -0,0 +1,12 @@
+export default class Triangle {
+
+    sides: number[]
+
+    constructor(...sides: number[]) {
+        this.sides = sides
+    }
+
+    kind() {
+        return ""
+    }
+}

data/tracks/typescript/exercises/triangle/tsconfig.json

@@ -0,0 +1,22 @@
+{
+    "compilerOptions": { 
+        "target": "es2017",
+        "module": "commonjs",
+        "alwaysStrict": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "preserveConstEnums": true,
+        "noFallthroughCasesInSwitch":true,
+        "noImplicitThis":true,
+        "noImplicitReturns":true,
+        "sourceMap": true,
+        "noEmitOnError": true,
+        "outDir": "./build"
+    },
+    "compileOnSave": true, 
+    "exclude": [
+        "node_modules"
+    ]
+}

data/tracks/typescript/exercises/triangle/tslint.json

@@ -0,0 +1,127 @@
+{
+    "jsRules": {
+        "class-name": true,
+        "comment-format": [
+            true,
+            "check-space"
+        ],
+        "indent": [
+            true,
+            "spaces"
+        ],
+        "no-duplicate-variable": true,
+        "no-eval": true,
+        "no-trailing-whitespace": true,
+        "no-unsafe-finally": true,
+        "one-line": [
+            true,
+            "check-open-brace",
+            "check-whitespace"
+        ],
+        "quotemark": [
+            false,
+            "double"
+        ],
+        "semicolon": [
+            true,
+            "never"
+        ],
+        "triple-equals": [
+            true,
+            "allow-null-check"
+        ],
+        "variable-name": [
+            true,
+            "ban-keywords"
+        ],
+        "whitespace": [
+            true,
+            "check-branch",
+            "check-decl",
+            "check-operator",
+            "check-separator",
+            "check-type"
+        ]
+    },
+    "rules": {
+        "class-name": true,
+        "comment-format": [
+            true,
+            "check-space"
+        ],
+        "indent": [
+            true,
+            "spaces"
+        ],
+        "no-eval": true,
+        "no-internal-module": true,
+        "no-trailing-whitespace": true,
+        "no-unsafe-finally": true,
+        "no-var-keyword": true,
+        "one-line": [
+            true,
+            "check-open-brace",
+            "check-whitespace"
+        ],
+        "semicolon": [
+            true,
+            "never"
+        ],
+        "triple-equals": [
+            true,
+            "allow-null-check"
+        ],
+        "typedef-whitespace": [
+            true,
+            {
+                "call-signature": "nospace",
+                "index-signature": "nospace",
+                "parameter": "nospace",
+                "property-declaration": "nospace",
+                "variable-declaration": "nospace"
+            }
+        ],
+        "variable-name": [
+            true,
+            "ban-keywords"
+        ],
+        "whitespace": [
+            true,
+            "check-branch",
+            "check-decl",
+            "check-operator",
+            "check-separator",
+            "check-type"
+        ],
+        "no-namespace": true, 
+        "prefer-for-of": true,
+        "only-arrow-functions": [true, "allow-declarations"],
+        "no-var-requires": true,
+        "no-any": true,
+        "curly": true,
+        "forin": true,
+        "no-arg": true,
+        "label-position": true,
+        "no-conditional-assignment": true,
+        "no-console": [true, "log", "error"],
+        "no-construct": true,
+        "no-duplicate-variable": true,
+        "no-empty": true,
+        "no-invalid-this": [true, "check-function-in-method"],
+        "no-misused-new": true,
+        "no-null-keyword": true,
+        "no-string-literal": true,
+        "radix": true,
+        "typeof-compare": true,
+        "use-isnan": true,
+        "prefer-const": true,
+        "array-type": [true, "array-simple"],
+        "arrow-parens": true,
+        "new-parens": true,
+        "no-consecutive-blank-lines": [true,1],
+        "no-parameter-properties": true,
+        "no-unnecessary-initializer": true,
+        "object-literal-shorthand": true,
+        "object-literal-key-quotes": [true, "as-needed"]
+    }
+}