score.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stdlib.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "score.h"
#include "index/lib.h"
#include "parse/lib.h"
#include "pattern/lib.h"
#include "email.h"
#include "globals.h"
#include "module_data.h"
#include "sort.h"

void score_list_free(struct Score **sp)
{
  if (!sp)
    return;
 
  struct Score *sc = *sp;
  while (sc)
  {
    struct Score *next = sc->next;
    mutt_pattern_free(&sc->pat);
    FREE(&sc->str);
    FREE(&sc);
    sc = next;
  }
  *sp = NULL;
}

enum CommandResult parse_score(const struct Command *cmd, struct Buffer *line,
                               const struct ParseContext *pc, struct ParseError *pe)
{
  struct Buffer *err = pe->message;
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Score *ptr = NULL;
  struct Score *last = NULL;
  char *pattern = NULL;
  char *patchar = NULL;
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  parse_extract_token(token, line, TOKEN_NONE);
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    goto done;
  }
  pattern = buf_strdup(token);
  parse_extract_token(token, line, TOKEN_NONE);
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    goto done;
  }
 
  /* look for an existing entry and update the value, else add it to the end
   * of the list */
  for (ptr = mod_data->score_list, last = NULL; ptr; last = ptr, ptr = ptr->next)
    if (mutt_str_equal(pattern, ptr->str))
      break;
 
  if (ptr)
  {
    /* 'token' arg was cleared and 'pattern' holds the only reference;
     * as here 'ptr' != NULL -> update the value only in which case
     * ptr->str already has the string, so pattern should be freed.  */
    FREE(&pattern);
  }
  else
  {
    struct MailboxView *mv_cur = get_current_mailbox_view();
    struct PatternList *pat = mutt_pattern_comp(mv_cur, pattern, MUTT_PC_NONE, err);
    if (!pat)
    {
      goto done;
    }
    ptr = MUTT_MEM_CALLOC(1, struct Score);
    if (last)
      last->next = ptr;
    else
      mod_data->score_list = ptr;
    ptr->pat = pat;
    ptr->str = pattern;
    pattern = NULL;
  }
 
  patchar = token->data;
  if (*patchar == '=')
  {
    ptr->exact = true;
    patchar++;
  }
 
  if (!mutt_str_atoi_full(patchar, &ptr->val))
  {
    buf_strcpy(err, _("Error: score: invalid number"));
    goto done;
  }
  OptNeedRescore = true;
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  FREE(&pattern);
  return rc;
}

enum CommandResult parse_unscore(const struct Command *cmd, struct Buffer *line,
                                 const struct ParseContext *pc, struct ParseError *pe)
{
  struct Buffer *err = pe->message;
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Score *tmp = NULL;
  struct Score *last = NULL;
  struct Buffer *token = buf_pool_get();
 
  while (MoreArgs(line))
  {
    parse_extract_token(token, line, TOKEN_NONE);
    if (mutt_str_equal("*", buf_string(token)))
    {
      score_list_free(&mod_data->score_list);
    }
    else
    {
      for (tmp = mod_data->score_list; tmp; last = tmp, tmp = tmp->next)
      {
        if (mutt_str_equal(buf_string(token), tmp->str))
        {
          if (last)
            last->next = tmp->next;
          else
            mod_data->score_list = tmp->next;
          mutt_pattern_free(&tmp->pat);
          FREE(&tmp);
          /* there should only be one score per pattern, so we can stop here */
          break;
        }
      }
    }
  }
 
  OptNeedRescore = true;
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

void mutt_check_rescore(struct Mailbox *m)
{
  const bool c_score = cs_subset_bool(NeoMutt->sub, "score");
  if (OptNeedRescore && c_score)
  {
    const enum EmailSortType c_sort = cs_subset_sort(NeoMutt->sub, "sort");
    const enum EmailSortType c_sort_aux = cs_subset_sort(NeoMutt->sub, "sort_aux");
    if (((c_sort & SORT_MASK) == EMAIL_SORT_SCORE) ||
        ((c_sort_aux & SORT_MASK) == EMAIL_SORT_SCORE))
    {
      OptNeedResort = true;
      if (mutt_using_threads())
        OptSortSubthreads = true;
    }
 
    mutt_debug(LL_NOTIFY, "NT_SCORE: %p\n", (void *) m);
    notify_send(m->notify, NT_SCORE, 0, NULL);
  }
  OptNeedRescore = false;
}

void mutt_score_message(struct Mailbox *m, struct Email *e, bool upd_mbox)
{
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
  struct Score *tmp = NULL;
  struct PatternCache cache = { 0 };
 
  e->score = 0; /* in case of re-scoring */
  for (tmp = mod_data->score_list; tmp; tmp = tmp->next)
  {
    if (mutt_pattern_exec(SLIST_FIRST(tmp->pat), MUTT_MATCH_FULL_ADDRESS, NULL, e, &cache) > 0)
    {
      if (tmp->exact || (tmp->val == 9999) || (tmp->val == -9999))
      {
        e->score = tmp->val;
        break;
      }
      e->score += tmp->val;
    }
  }
  if (e->score < 0)
    e->score = 0;
 
  const short c_score_threshold_delete = cs_subset_number(NeoMutt->sub, "score_threshold_delete");
  const short c_score_threshold_flag = cs_subset_number(NeoMutt->sub, "score_threshold_flag");
  const short c_score_threshold_read = cs_subset_number(NeoMutt->sub, "score_threshold_read");
 
  if (e->score <= c_score_threshold_delete)
    mutt_set_flag(m, e, MUTT_DELETE, true, upd_mbox);
  if (e->score <= c_score_threshold_read)
    mutt_set_flag(m, e, MUTT_READ, true, upd_mbox);
  if (e->score >= c_score_threshold_flag)
    mutt_set_flag(m, e, MUTT_FLAG, true, upd_mbox);
}