JQuery: Por que o gatilho não dispararia de um objeto JS?

Question

Eu tenho implementado uma forma de um padrão de design de editor/assinante no jQuery. Estou basicamente construindo aulas em JavaScript, utilizando o CoffeeScript que servem como componentes na minha página. ou seja, navegação, datalista, etc.

Em vez de ter o DOM Elements Fire Events, tenho instâncias dessas classes que usam o Trigger por si mesmos para enviar eventos personalizados. Essas instâncias podem então se ouvir e atualizar os elementos DOM que eles possuem de acordo com as mudanças no comportamento um do outro!

Sei que isso funciona, pois tenho um dos meus componentes que envia um evento personalizado corretamente. No entanto, eu encontrei um problema. Criei outro componente e, para a minha vida, não consigo descobrir por que o evento não está sendo demitido.

Esta é a implementação da minha classe:

window.List = (function() {
    List = function(element, settings) {
      var _a, _b, _c;
      this.list = $(element);
      this.settings = jQuery.extend(List.DEFAULTS, settings);
      this.links = this.list.find(this.settings.link_selector);
      this.links.selectable();
      _b = [SelectableEvent.COMPLETED, SelectableEvent.UNDONE, SelectableEvent.SELECTED, SelectableEvent.DESELECTED];
      for (_a = 0, _c = _b.length; _a < _c; _a++) {
        (function() {
          var event_type = _b[_a];
          return this.links.bind(event_type, __bind(function(event, selectable_event) {
            return this.dispatch(selectable_event);
          }, this));
        }).call(this);
      }
      return this;
    };
    List.DEFAULTS = {
      link_selector: "a",
      completed_selector: ".completed"
    };
    List.prototype.change = function(mode, previous_mode) {
      if (mode !== this.mode) {
        this.mode = mode;
        if (previous_mode) {
          this.list.removeClass(previous_mode);
        }
        return this.list.addClass(this.mode);
      }
    };
    List.prototype.length = function() {
      return this.links.length;
    };
    List.prototype.remaining = function() {
      return this.length() - this.list.find(this.settings.completed_selector).length;
    };
    List.prototype.dispatch = function(selectable_event) {
      $(this).trigger(selectable_event.type, selectable_event);
      return alert(selectable_event.type);
    };
    return List;
}).call(this);

Prestar atenção em:

List.prototype.dispatch = function(selectable_event) {
    $(this).trigger(selectable_event.type, selectable_event);
    return alert(selectable_event.type);
};

Este código é acionado corretamente e retorna o tipo de evento esperado por meio de um alerta. Mas antes do alerta, espera -se que ele desencadeie um evento personalizado. É aqui que estou encontrando meu problema.

$(document).ready(function() {
    var list_change_handler, todo_list;
    todo_list = new List("ul.tasks");
    list_change_handler = function(event, selectable_event) {
      return alert("Hurray!");
    };
    $(todo_list).bind(SelectableEvent.COMPLETED, list_change_handler);
    $(todo_list).bind(SelectableEvent.UNDONE, list_change_handler);
    $(todo_list).bind(SelectableEvent.SELECTED, list_change_handler);
    $(todo_list).bind(SelectableEvent.DESELECTED, list_change_handler);
}

Você vê aqui o alerta "Hurrah" é o que eu quero demitir, mas infelizmente não estou tendo sorte aqui. Ironicamente, fiz exatamente a mesma coisa com outra classe implementada da mesma maneira que a Despacho um evento personalizado e o ouvinte está recebendo muito bem. Alguma idéia sobre por que isso não funcionaria?

Atualizar:

Por discussão nos comentários, parece que o log "this" no console retorna o objeto JS que representa a classe. Mas o registro "$ (this)" retorna um objeto jQuery vazio, assim o gatilho nunca seria disparado. Alguma idéia de por que $ (isso) está vazio quando "isso" está retornando com precisão a instância da classe?

Answer 1

Descobri que o jQuery não poderia indexar meu objeto porque a classe implementou sua própria versão de um método jQuery. Nesse caso, comprimento (). A renomeação do método Length () para Total () resolveu o problema completamente e qualquer instância da classe pode desencadear eventos com sucesso.