export const sampleForletter = (letter: string) => (
  collection: string[],
  count: number,
  replacement = false
): string[] => {
  const suitableWords = R.filter(startsWith(letter), collection);

  let words = sample<string>(suitableWords, count, replacement);
  words = [
    ...words,
    ...sample<string>(
      R.filter(
        word => !startsWith(letter)(word) && includes(letter)(word),
        collection
      ),
      count - words.length
    )
  ];
  words = [
    ...words,
    ...sample<string>(
      R.filter(
        word => !startsWith(letter)(word) && !includes(letter)(word),
        collection
      ),
      count - words.length
    )
  ];

  return words;
};

		.map(([claims, title]) => {
			switch (title) {
				case PENDING_CLAIM:
					return R.filter((n: any) => n.status == STATUS_SUBMITTED || n.status == STATUS_DRAFT || n.status == STATUS_REJECTED)(claims);

				case CLOSED_CLAIM:
					return R.filter((n: any) => n.status == STATUS_APPROVED)(claims);

				default:
				  return claims;
			}
		});

  /**
   * Return a filtered array of records
   *
   * Example
   *
   * ```
   * this.list = Array.filter(this.searchText, ['invoiceCode', 'customer', 'description'], this._data);
   * ```
   */
  static filter(query, fields, array) {
    if (query) { query = query.toLowerCase() }

    if(array == null || query === '') { return array }
    let arr = array;
    const filterByFields = obj => {
      let toFilter = false;

      fields.forEach(field => {
        if (!toFilter) {
          if (R.is(Object, field)) {
            const key = R.head(R.keys(field));
            const value = R.values(field);
            if (key === 'eq') {
              toFilter = (obj[value] === query);
            }
          } else {
            if (!R.isNil(obj[field])) {
              toFilter = obj[field].toString()
                .toLowerCase().indexOf(query) > -1
            }
          }
        }
      });
      return toFilter;
    };

    return R.filter(filterByFields, array);
  }

    exec('git branch --no-color -a', options, (error, stdout, stderr) => {
      if (stderr || error) return reject(stderr || error);

      const getCurrentBranch = R.compose(
        R.trim,
        R.replace('*', ''),
        R.find(line => line.startsWith('*')),
        R.split('\n')
      );

      const processBranches = R.compose(
        R.filter(br => stdout.match(new RegExp(`remotes\/.*\/${br}`))),
        R.uniq
      );

      const currentBranch = getCurrentBranch(stdout);
      const branches = processBranches([currentBranch, defaultBranch]);

      return excludeCurrentRevision
        ? resolve(branches)
        : getCurrentRevision(exec, projectPath)
            .then((currentRevision) => {
              return resolve(branches.concat(currentRevision));
            });
    });

    /**
     * Sends all subscribed values to the Reactotron app.
     *
     * @param node The tree to grab the state data from
     */
    function sendSubscriptions(state: any) {
      // this is unreadable
      const changes = pipe(
        map(when(isNil, always(""))) as any,
        filter(endsWith(".*")),
        map((key: string) => {
          const keyMinusWildcard = slice(0, -2, key)
          const value = dotPath(keyMinusWildcard, state)
          if (is(Object, value) && !isNilOrEmpty(value)) {
            return pipe(keys, map(key => `${keyMinusWildcard}.${key}`))(value)
          }
          return []
        }) as any,
        concat(map(when(isNil, always("")), subscriptions)),
        flatten,
        reject(endsWith(".*")) as any,
        uniq as any,
        sortBy(identity) as any,
        map((key: string) => ({
          path: key,
          value: isNilOrEmpty(key) ? state : dotPath(key, state),
        })),
      )(subscriptions)

      reactotron.stateValuesChange(changes)
    }

export function findChildImages(parentName: string, imagesConfigMap: ImagesConfigMap): string[] {
  const confPairs = toPairs(imagesConfigMap) as [string, ImageConfig][];
  return pipe(
    filter<[string, ImageConfig]>(pathEq(['1', 'baseimage'], parentName)),
    map((arr: [string, ImageConfig]) => arr[0])
  )(confPairs);
}

  public getNextChild(id: string): Optional<ICourseStructure> {
    const entity = this.course.findEntity(id);

    if (!entity) {
      return undefined;
    }

    if ((entity as InternalNode).getChildren()) {
      const children = (entity as InternalNode).getChildren();

      const cmps = [
        ascend(
          (child: AbstractNode) => this.getProgress(child.getId()).progress
        ),
        ascend(
          (child: AbstractNode) => this.getProgress(child.getId()).counter || 0
        )
      ];

      const sortedChildren = stableSortWith(cmps, children);

      const relevantChildren = filter(
        (child: AbstractNode) =>
          this.getProgress(child.getId()).progress < Progress.Correct,
        sortedChildren
      );

      if (relevantChildren.length !== 0) {
        return relevantChildren[0].getInfo() as ICourseStructure;
      }
    }

    return undefined;
  }

export const hiddenComponentDecorator = ({
  modelName,
  fields,
}: {
  modelName: string;
  fields: Fields;
}): { modelName; fields: Fields & WithHidden } => {
  const TAG = '[hiddenComponentDecorator]';
  logger.log(TAG, { fields });

  let wrappedFields = R.omit([castModelKey('createdAt'), castModelKey('updatedAt')])(fields);
  if (R.has('id', wrappedFields)) {
    const hidden = R.isNil(wrappedFields.id.value);
    wrappedFields = R.mergeDeepRight(wrappedFields, { id: { options: { hidden } } });
  }

  const positions = R.filter(R.pathEq(['options', 'type'], 'SortPosition'))(wrappedFields);
  if (!R.isEmpty(positions)) {
    const hiddenPositions = R.map(position => ({
      ...position,
      options: { hidden: true },
    }))(positions);

    wrappedFields = R.mergeDeepRight(wrappedFields, { ...hiddenPositions });
  }
  logger.log(TAG, 'wrappedFields', { wrappedFields }, diff(fields, wrappedFields));
  return { modelName, fields: wrappedFields };
};

export const associationDecorator = ({ modelName, fields }: { modelName: string; fields }) => {
  const TAG = '[associationDecorator]';
  logger.log(TAG, { fields });

  // prettier-ignore
  const associationFields = R.filter(R.compose(R.not, R.isNil, R.prop('associations')))(fields);
  logger.log(TAG, { associationFields }, R.not(R.isEmpty(associationFields)));
  if (R.not(R.isEmpty(associationFields))) {
    const wrapForeignOpt = R.map(opt => ({
      ...opt,
      association: AppContext.adapters.models.getAssociationConfigs(opt.modelName),
    }));
    const withAssociations = R.mapObjIndexed(field => ({
      ...field,
      foreignOpts: wrapForeignOpt(field.foreignOpts),
    }))(associationFields);
    logger.debug(TAG, { withAssociations, wrapForeignOpt });

    const wrappedFields = R.mergeDeepRight(fields, withAssociations);
    logger.debug(TAG, { wrappedFields });

    return { modelName, fields: wrappedFields };
  }

  return { modelName, fields };
};

    describe('ramda', function () {

        function filterUserData(username) {
            return R.filter(R.propEq('username', username));
        }

        const isUnComplete = (task) => !task.complete;
        const filterOutstandingTasks = R.pipe(
            R.filter(isUnComplete),
            R.map(R.pick(['id', 'title', 'dueDate', 'priority'])));

        function descSort(property) {
            return (a, b) => a[property].localeCompare(b[property]);
        }

        function getIncompleteTaskSummaries(username) {
            return R.pipeP(fetchTaskData, R.prop('tasks'), filterUserData(username), filterOutstandingTasks, R.sort(descSort('dueDate')));
        }

        it('returns unfinished tasks sorted by due dates in ascending order', function (done) {
            getIncompleteTaskSummaries('Scott')()
                .then((answer) => done(assert.deepEqual(answer, expectedAnswer)))
                .catch((error) => done(error));
        });
    });