Merge branch 'release/1.1.0'

Author: Bubblesphere

.gitignore

@@ -1,5 +1,6 @@
 node_modules/
 dev/
+coverage/
 npm-debug.log
 yarn-error.log
 yarn.lock

README.md

@@ -66,7 +66,8 @@ Method | Description
 **`pushAll(values: Array<bit>)`** | Pushes a an array of bits onto the array
 **`push(value: bit)`** | Pushes a single bit onto the array
 **`atIndex(index: number)`** | Gets the bit at a given index.
-**`atIndexRange(index: number, count: number)`** | Gets count bits at a given index
+**`atIndexRange(index: number, count?: number)`** | Gets count bits at a given index. If count is null, the range goes to the end of the array
+**`set(index: number, value: bit)`** | Sets a specified bit at an index of the array
 
 #### Properties
 Property | Description
@@ -82,3 +83,7 @@ Initial release
 - `atIndexRange(index: number, count: number)`
 - `size`
 
+### 1.1.0
+Added method set and made count parameter optional for atIndexRange
+- `set(index: number, value: bit)`
+- `atIndexRange(index: number, count?: number)` 

jest.config.js

@@ -0,0 +1,17 @@
+module.exports = {
+  roots: [
+    "<rootDir>/src"
+  ],
+  transform: {
+    "^.+\\.tsx?$": "ts-jest"
+  },
+  testRegex: "(/__tests__/.*|(\\.|/)(test|spec))\\.tsx?$",
+  moduleFileExtensions: [
+    "ts",
+    "tsx",
+    "js",
+    "jsx",
+    "json",
+    "node"
+  ],
+}

package.json

@@ -19,9 +19,12 @@
   },
   "homepage": "https://github.com/Bubblesphere/bit-array",
   "devDependencies": {
+    "@types/jest": "^23.3.0",
     "babel-preset-es2015": "^6.24.1",
     "clean-webpack-plugin": "^0.1.19",
     "copy-webpack-plugin": "^4.5.1",
+    "jest": "^23.4.1",
+    "ts-jest": "^23.0.1",
     "ts-loader": "^4.1.0",
     "typescript": "^2.7.2",
     "webpack": "^4.1.1",
@@ -32,6 +35,7 @@
   },
   "scripts": {
     "start": "webpack-dev-server --open-page dev/index.html --config webpack.dev.js --mode development ",
-    "build": "webpack --config webpack.prod.js --mode production"
+    "build": "webpack --config webpack.prod.js --mode production",
+    "test": "jest --coverage"
   }
 }

src/demo/index.html

@@ -17,8 +17,11 @@ <h1>Hello world!</h1>
       arr.push(0);
       // 0, 1, 0, 1, 1, 1, 0
 
+      arr.set(0, 1);
+      // 1, 1, 0, 1, 1, 1, 0
+
       arr.atIndex(0);
-      // 0
+      // 1
 
       arr.atIndexRange(0, 3);
       // 0, 1, 0

src/demo/index.ts

@@ -3,20 +3,24 @@ import BitArray from "../lib/bit-array";
 const arr = new BitArray([0, 1, 0]);
 
 arr.pushAll([1, 1, 1]);
-console.log(arr.atIndexRange(0, arr.size));
+console.log(arr.atIndexRange(0));
 // 0, 1, 0, 1, 1, 1
 
 arr.push(0);
-console.log(arr.atIndexRange(0, arr.size));
+console.log(arr.atIndexRange(0));
 // 0, 1, 0, 1, 1, 1, 0
 
+arr.set(0, 1);
+console.log(arr.atIndexRange(0));
+// 1, 1, 0, 1, 1, 1, 0
+
 arr.atIndex(0);
 console.log(arr.atIndex(0));
-// 0
+// 1
 
 arr.atIndexRange(0, 3);
 console.log(arr.atIndexRange(0, 3));
-// 0, 1, 0
+// 1, 1, 0
 
 console.log(arr.size)
-// 7
+// 7

src/lib/bit-array.test.ts

@@ -0,0 +1,132 @@
+import BitArray, { bit } from "./bit-array";
+
+test('Passing less than 8 bit to the constructor', () => {
+  const arr1 = [1];
+  const arr2 = [1, 0];
+  const arr3 = [1, 0, 1];
+  const arr4 = [1, 0, 1, 0];
+  const arr5 = [1, 0, 1, 0, 1];
+  const arr6 = [1, 0, 1, 0, 1, 0];
+  const arr7 = [1, 0, 1, 0, 1, 0, 1];
+
+  const bArr1 = new BitArray(arr1 as Array<bit>);
+  const bArr2 = new BitArray(arr2 as Array<bit>);
+  const bArr3 = new BitArray(arr3 as Array<bit>);
+  const bArr4 = new BitArray(arr4 as Array<bit>);
+  const bArr5 = new BitArray(arr5 as Array<bit>);
+  const bArr6 = new BitArray(arr6 as Array<bit>);
+  const bArr7 = new BitArray(arr7 as Array<bit>);
+
+  expect(bArr1.atIndexRange(0)).toEqual(arr1);
+  expect(bArr2.atIndexRange(0)).toEqual(arr2);
+  expect(bArr3.atIndexRange(0)).toEqual(arr3);
+  expect(bArr4.atIndexRange(0)).toEqual(arr4);
+  expect(bArr5.atIndexRange(0)).toEqual(arr5);
+  expect(bArr6.atIndexRange(0)).toEqual(arr6);
+  expect(bArr7.atIndexRange(0)).toEqual(arr7);
+});
+
+test('Passing more than 8 bit to the constructor', () => {
+  const arr8 = [1, 0, 1, 0, 1, 0, 1, 0];
+  const arr9 = [1, 0, 1, 0, 1, 0, 1, 0, 1];
+
+  const bArr8 = new BitArray(arr8 as Array<bit>);
+  const bArr9 = new BitArray(arr9 as Array<bit>);
+
+  expect(bArr8.atIndexRange(0)).toEqual(arr8);
+  expect(bArr9.atIndexRange(0)).toEqual(arr9);
+});
+
+test('Can get a specific index correctly', () => {
+  const bArr1 = new BitArray([0, 0, 0, 0, 0, 0, 0, 0, 0]);
+  const bArr2 = new BitArray([1, 1, 1, 1, 1, 1, 1, 1, 1]);
+
+  for (let i = 0; i < bArr1.size; i++) {
+    expect(bArr1.atIndex(i)).toBe(0);
+    expect(bArr2.atIndex(i)).toBe(1);
+  }
+});
+
+test('Can\'t get an invalid index', () => {
+  const bArr1 = new BitArray([0, 0, 0, 0, 0, 0, 0, 0, 0]);
+
+  expect(() => bArr1.atIndex(-1)).toThrowError();
+  expect(() => bArr1.atIndex(bArr1.size + 1)).toThrowError();
+});
+
+test('Can\'t get an invalid index range', () => {
+  const bArr1 = new BitArray([0, 0, 0, 0, 0, 0, 0, 0, 0]);
+
+  expect(() => bArr1.atIndexRange(-1)).toThrowError();
+  expect(() => bArr1.atIndexRange(0, bArr1.size + 1)).toThrowError();
+});
+
+test('Can get a specific index range correctly', () => {
+  const arr1 = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+  const arr2 = [1, 1, 1, 1, 1, 1, 1, 1, 1];
+
+  const bArr1 = new BitArray(arr1 as Array<bit>);
+  const bArr2 = new BitArray(arr2 as Array<bit>);
+
+  expect(bArr1.atIndexRange(0)).toEqual(arr1);
+  expect(bArr2.atIndexRange(0)).toEqual(arr2);
+
+  expect(bArr1.atIndexRange(1)).toEqual(arr1.slice(1));
+  expect(bArr2.atIndexRange(1)).toEqual(arr2.slice(1));
+
+  expect(bArr1.atIndexRange(0, 2)).toEqual(arr1.slice(0, 2));
+  expect(bArr2.atIndexRange(0, 2)).toEqual(arr2.slice(0, 2));
+
+  expect(bArr1.atIndexRange(1, 5)).toEqual(arr1.slice(1, 6));
+  expect(bArr2.atIndexRange(1, 5)).toEqual(arr2.slice(1, 6));
+});
+
+test('Can push 0 values onto BitArray', () => {
+  const bArr1 = new BitArray([]);
+
+  for (let i = 0; i < 100; i++) {
+    bArr1.push(1);
+    expect(bArr1.atIndex(i)).toBe(1);
+  }
+});
+
+test('Can push 1 values onto BitArray', () => {
+  const bArr1 = new BitArray([]);
+
+  for (let i = 0; i < 100; i++) {
+    bArr1.push(0);
+    expect(bArr1.atIndex(i)).toBe(0);
+  }
+  bArr1[0] = 1;
+});
+
+test('Can set values', () => {
+  const bArr1 = new BitArray([1, 0]);
+
+  bArr1.set(0, 1);
+  expect(bArr1.atIndexRange(0)).toEqual([1, 0]);
+  bArr1.set(0, 0);
+  expect(bArr1.atIndexRange(0)).toEqual([0, 0]);
+  bArr1.set(1, 0);
+  expect(bArr1.atIndexRange(0)).toEqual([0, 0]);
+  bArr1.set(1, 1);
+  expect(bArr1.atIndexRange(0)).toEqual([0, 1]);
+});
+
+test('Can\'t set values for invalid index', () => {
+  const bArr1 = new BitArray([1, 0]);
+
+  expect(() => bArr1.set(-1, 0)).toThrowError();
+  expect(() => bArr1.set(bArr1.size + 1, 0)).toThrowError();
+});
+
+test('Size is valid', () => {
+  const bArr1 = new BitArray([1, 0]);
+  expect(bArr1.size).toBe(2);
+
+  bArr1.pushAll([1, 1]);
+  expect(bArr1.size).toBe(4);
+
+  bArr1.push(1);
+  expect(bArr1.size).toBe(5);
+});

src/lib/bit-array.ts

@@ -15,8 +15,8 @@ export default class BitArray {
    */
   constructor(values: Array<bit>) {
     this._pushedSize = 0;
-    this._size = values.length;
-    this._array = new Uint8Array(Math.ceil(this._size/this._bitPerIndex));
+    this._size = Math.ceil(values.length === 0 ? 1 : values.length /this._bitPerIndex);
+    this._array = new Uint8Array(this._size);
     this._pointer = 0;
     this.pushAll(values);
   }
@@ -28,12 +28,32 @@ export default class BitArray {
     return this._pushedSize;
   }
 
+  public set(index: number, value: bit) {
+    if (index < 0) {
+      throw `The specified index (${index}) has to be greater or equal to 0`;
+    }
+
+    if (index > this._pushedSize - 1) {
+      throw `The specified index (${index}) has to be between 0 and ${this._pushedSize - 1}`;
+    }
+
+    const persist = {
+      pointer: this._pointer,
+      pushedSize: this._pushedSize
+    }
+
+    this._pointer = index;
+    this.push(value);
+    this._pointer = persist.pointer;
+    this._pushedSize = persist.pushedSize;
+  }
+
   /**
    * Pushes a single bit onto the array
    * @param value The bit to push onto the array
    */
   public push(value: bit) {
-    if (this._pointer == this._size) {
+    if (this._pointer == this._size * this._bitPerIndex) {
       this._increaseArraySize();
     }
     // create a mask for current index.
@@ -71,6 +91,10 @@ export default class BitArray {
    * @param index The index of the bit to return
    */
   public atIndex(index: number): bit {
+    if (index < 0) {
+      throw `The specified index (${index}) has to be greater or equal to 0`;
+    }
+
     if (index > this._pushedSize) {
       throw `Index (${index}) exceeds the size of the bit array (${this._pushedSize})`;
     }
@@ -84,9 +108,17 @@ export default class BitArray {
    * @param index The index of the first bit to return
    * @param count The amount of bits to fetch starting at the index
    */
-  public atIndexRange(index: number, count: number): bit[] {
-    if (index + count - 1 > this._pushedSize) {
-      throw `Index (${index}) exceeds the size of the bit array (${this._pushedSize})`;
+  public atIndexRange(index: number, count?: number): bit[] {
+    if (index < 0) {
+      throw `The specified index (${index}) has to be greater or equal to 0`;
+    }
+
+    if (count == null) {
+      count = this._pushedSize - index;
+    }
+
+    if (index + count > this._pushedSize) {
+      throw `Index (${index + count}) exceeds the size of the bit array (${this._pushedSize})`;
     }
 
     const values: bit[] = [];
@@ -123,7 +155,7 @@ export default class BitArray {
   private _increaseArraySize() {
     this._size = this._size * 2;
     const tempArr = this._array.slice();
-    this._array = new Uint8Array(Math.ceil(this._size/this._bitPerIndex));
-    this._array = tempArr.slice();
+    this._array = new Uint8Array(this._size);
+    tempArr.forEach((value, index) => this._array[index] = value);
   }
 };