select adjacent should do a minus on adjacent end #17

Author: codingedgar

src/index.ts

@@ -93,12 +93,18 @@ export function multiselect(context: Context, command: Command): Context {
     const pivotIndex = context.list.indexOf(context.adjacentPivot);
     const selectionIndex = context.list.indexOf(command.id);
 
-    const adjacent = findAdjacentToPivotInSortedArray(
+    const adjacentToStart = findAdjacentToPivotInSortedArray(
       context.list,
       context.selected,
       context.adjacentPivot
     );
 
+    const adjacentToEnd = findAdjacentToPivotInSortedArray(
+      context.list,
+      context.selected,
+      command.id,
+    );
+    
     const nextSelection = context.list.slice(
       Math.min(pivotIndex, selectionIndex),
       Math.max(pivotIndex, selectionIndex) + 1
@@ -108,7 +114,7 @@ export function multiselect(context: Context, command: Command): Context {
       nextSelection.reverse()
     }
 
-    const toRemove = difference(adjacent, nextSelection);
+    const toRemove = union(adjacentToStart, adjacentToEnd);
 
     return {
       ...context,

src/spec/arbitraries.ts

@@ -1,4 +1,5 @@
 import fc from 'fast-check';
+import { sort } from 'ramda';
 
 export function subsequentSubarray(arr: string[]) {
   return fc.tuple(fc.nat(arr.length), fc.nat(arr.length))
@@ -15,3 +16,70 @@ export function nonEmptySubsequentSubarray(nonEmptyArray: string[]) {
 export function list() {
   return fc.set(fc.string())
 }
+
+export function ascending (a: number, b:number): number {
+  return a - b;
+}
+
+export function descending (a:number, b:number): number {
+  return b - a;
+}
+
+export function takeFromTo<T>(array: T[], start: T, end: T) {
+  const startIndex = array.indexOf(start);
+  const endIndex = array.indexOf(end) + 1;
+
+  return array.slice(startIndex, endIndex);
+}
+
+export function indexWithAdjacentConnections() {
+  return fc
+    .tuple(
+      fc.set(
+        fc.string(),
+        { minLength: 1 }
+      ),
+      fc.nat(),
+      fc.nat(),
+      fc.nat(),
+      fc.nat(),
+      fc.nat(),
+      fc.nat(),
+    )
+    .map(([list, startStart, startEnd, endStart, endEnd, start, end]) =>
+        [
+          list,
+          ...sort(ascending, [
+            startStart % list.length,
+            startEnd % list.length,
+            endStart % list.length,
+            endEnd % list.length,
+          ]),
+          start,
+          end,
+        ] as const
+    )
+    .map(([list, startStart, startEnd, endStart, endEnd, start, end]) =>
+        [
+          list,
+          startStart,
+          startEnd,
+          endStart,
+          endEnd,
+          (start % (startEnd - startStart + 1)) + startStart,
+          (end % (endEnd - endStart + 1)) + endStart,
+        ] as const
+    )
+    .map(([list, startStart, startEnd, endStart, endEnd, start, end]) => ({
+        list,
+        adjacentGroup1: list.slice(startStart, start),
+        adjacentGroup2: list.slice(start + 1, startEnd),
+        // if startEnd is the same as endStart
+        // end can be a member of group3
+        adjacentGroup3: list.slice(endStart + ((startEnd === endStart) ? 1 : 0), end),
+        adjacentGroup4: list.slice(end + 1, endEnd),
+        end: list[end],
+        start: list[start],
+      })
+  )
+}

src/spec/selectAdjacent.spec.ts

@@ -1,6 +1,7 @@
 import fc, { array } from 'fast-check';
-import { take, last, head, startsWith } from "ramda";
-import { multiselect } from '../index';
+import { take, last, head, reverse } from "ramda";
+import { Context, multiselect } from '../index';
+import { indexWithAdjacentConnections, takeFromTo } from './arbitraries';
 
 describe('Select Adjacent', () => {
   test('Should select from top to bottom in an empty list', () => {
@@ -188,4 +189,118 @@ describe('Select Adjacent', () => {
       ),
     )
   })
+
+  test('Should perform a minus between the old and new end selection group, when selection is ascendent', () => {
+    fc.assert(
+      fc.property(
+        indexWithAdjacentConnections()
+        ,
+        ({
+          list,
+          adjacentGroup1,
+          adjacentGroup2,
+          adjacentGroup3,
+          adjacentGroup4,
+          start,
+          end,
+        }) => {
+
+          const expectedSelection = takeFromTo(list, start, end);
+
+          let context: Context = {
+            adjacentPivot: undefined,
+            list,
+            selected: []
+          }
+
+          context = [
+            ...adjacentGroup1,
+            ...adjacentGroup2,
+            ...adjacentGroup3,
+            ...adjacentGroup4,
+            start
+          ].reduce(
+            (ctx, id) => multiselect(
+              ctx,
+              {
+                type: "TOGGLE SELECTION",
+                id
+              }
+            ),
+            context
+          );
+
+          const result = multiselect(
+            context,
+            {
+              type: 'SELECT ADJACENT',
+              id: end
+            }
+          )
+          expect(result).toEqual({
+            list,
+            adjacentPivot: start,
+            selected: expectedSelection,
+          })
+        }
+      ),
+    )
+  })
+
+  test('Should perform a minus between the old and new end selection group, when selection is descendent', () => {
+    fc.assert(
+      fc.property(
+        indexWithAdjacentConnections()
+        ,
+        ({
+          list,
+          adjacentGroup1,
+          adjacentGroup2,
+          adjacentGroup3,
+          adjacentGroup4,
+          start,
+          end,
+        }) => {
+
+          const expectedSelection = reverse(takeFromTo(list, start, end));
+
+          let context: Context = {
+            adjacentPivot: undefined,
+            list,
+            selected: []
+          }
+
+          context = [
+            ...adjacentGroup1,
+            ...adjacentGroup2,
+            ...adjacentGroup3,
+            ...adjacentGroup4,
+            end,
+          ].reduce(
+            (ctx, id) => multiselect(
+              ctx,
+              {
+                type: "TOGGLE SELECTION",
+                id
+              }
+            ),
+            context
+          );
+
+          const result = multiselect(
+            context,
+            {
+              type: 'SELECT ADJACENT',
+              id: start
+            }
+          )
+          expect(result).toEqual({
+            list,
+            adjacentPivot: end,
+            selected: expectedSelection,
+          })
+        }
+      ),
+    )
+  })
 })