helios 0.0.5 → 0.1.1

data/lib/helios/frontend/javascripts/helios/collections.coffee

@@ -1,4 +1,17 @@
-class Helios.Collection extends Backbone.Collection
+class Helios.Collection extends Backbone.Paginator.requestPager
+  paginator_ui:
+    firstPage: 1,
+    currentPage: 1,
+    perPage: 20
+
+  server_api:
+    'q': ->
+      @query || ""
+    'limit': ->
+      @perPage
+    'offset': ->
+      (@currentPage - 1) * @perPage
+
   parse: (response, options) ->
     if _.isArray(response)
       response
@@ -6,25 +19,73 @@ class Helios.Collection extends Backbone.Collection
       if response.page?
         @total = response.total
         @page = response.page
-      
+        @totalPages = Math.ceil(@total / @perPage)
+
       _.detect response, (value, key) ->
         _.isArray(value)
 
-class Helios.Collections.Entities extends Helios.Collection
+class Helios.Collections.Entities extends Backbone.Collection
   model: Helios.Models.Entity
   url: '/'
 
-class Helios.Collections.Resources extends Helios.Collection
+  parse: (response, options) ->
+    if _.isArray(response)
+      response
+    else
+      if response.page?
+        @total = response.total
+        @page = response.page
+        @totalPages = Math.ceil(@total / @perPage)
+
+      _.detect response, (value, key) ->
+        _.isArray(value)
+
+class Helios.Collections.Resources extends Backbone.Collection
   model: Helios.Models.Resource
 
+  parse: (response, options) ->
+    if _.isArray(response)
+      response
+    else
+      if response.page?
+        @total = response.total
+        @page = response.page
+        @totalPages = Math.ceil(@total / @perPage)
+
+      _.detect response, (value, key) ->
+        _.isArray(value)
+
 class Helios.Collections.Devices extends Helios.Collection
   model: Helios.Models.Device
-  url: '/devices'
+  fields: ['token', 'alias', 'badge', 'locale', 'language', 'timezone', 'ip_address', 'lat', 'lng']
+
+  paginator_core:
+    type: 'GET'
+    dataType: 'json'
+    url: '/devices?'
+
+  comparator: (device) ->
+    device.get('token')
+
 
 class Helios.Collections.Receipts extends Helios.Collection
   model: Helios.Models.Receipt
   url: '/receipts'
+  fields: ['transaction_id', 'product_id', 'purchase_date', 'original_transaction_id', 'original_purchase_date', 'app_item_id', 'version_external_identifier', 'bid', 'bvrs', 'ip_address']
+
+  paginator_core:
+    type: 'GET'
+    dataType: 'json'
+    url: '/receipts?'
+
 
 class Helios.Collections.Passes extends Helios.Collection
   model: Helios.Models.Pass
-  url: '/passes'
+  url: '/passes'
+  fields: ['pass_type_identifier', 'serial_number', 'authentication_token']
+
+  paginator_core:
+    type: 'GET'
+    dataType: 'json'
+    url: '/passes?'
+

data/lib/helios/frontend/javascripts/helios/models.coffee

@@ -13,11 +13,8 @@ class Helios.Models.Resource extends Backbone.Model
 
 class Helios.Models.Device extends Backbone.Model
   idAttribute: "token"
-  fields: ['token', 'alias', 'badge', 'locale', 'language', 'timezone', 'ip_address', 'lat', 'lng']
-
+  
 class Helios.Models.Receipt extends Backbone.Model
   idAttribute: "transaction_id"
-  fields: ['transaction_id', 'product_id', 'purchase_date', 'original_transaction_id', 'original_purchase_date', 'app_item_id', 'version_external_identifier', 'bid', 'bvrs', 'ip_address']
 
 class Helios.Models.Pass extends Backbone.Model
-  fields: ['pass_type_identifier', 'serial_number', 'authentication_token']

data/lib/helios/frontend/javascripts/helios/router.coffee

@@ -14,37 +14,23 @@ class Helios.Routers.Root extends Backbone.Router
     'passbook':           'passbook'
 
   index: ->
-    console.log("index")
-    # @_activateNavbarLink("devices")
-
     Helios.entities.fetch(type: 'OPTIONS')
-    # @views.devices ?= new RPN.Views.Devices(collection: RPN.devices)
-    # @views.devices.render()
-
-  # _activateNavbarLink: (className) ->
-  #   $li = $("header nav li")
-  #   $li.removeClass("active")
-  #   $li.filter("." + className).addClass("active")
 
   data: ->
-    console.log("data")
     Helios.entities.fetch(type: 'OPTIONS')
     @views.entities.render()
 
   push_notification: ->
-    console.log("push")
     @devices ?= new Helios.Collections.Devices
     @views.devices ?= new Helios.Views.Devices(collection: @devices)
     @views.devices.render()
 
   in_app_purchase: ->
-    console.log("IAP")
     @receipts ?= new Helios.Collections.Receipts
     @views.receipts ?= new Helios.Views.Receipts(collection: @receipts)
     @views.receipts.render()
 
   passbook: ->
-    console.log("passbook")
     @passes ?= new Helios.Collections.Passes
     @views.passes ?= new Helios.Views.Passes(collection: @passes)
     @views.passes.render()

data/lib/helios/frontend/javascripts/helios/views.coffee

@@ -25,7 +25,7 @@ class Helios.Views.Entity extends Backbone.View
 
   render: =>
     if @collection
-      @datagrid = new Backbone.Datagrid({
+      @datagrid ?= new Backbone.Datagrid({
         collection: @collection,
         columns: @collection.first().attributes.keys,
         paginated: true,
@@ -39,54 +39,195 @@ class Helios.Views.Devices extends Backbone.View
   template: JST['devices']
   el: "[role='main']"
 
+  events:
+    'keyup form.filter input': 'filter'
+
+  initialize: ->
+    @datagrid = new Backbone.Datagrid({
+      collection: @collection,
+      columns: @collection.fields,
+      paginated: true,
+      perPage: 20
+    })
+
   render: =>
     @$el.html(@template())
 
-    if @collection
-      @datagrid = new Backbone.Datagrid({
-        collection: @collection,
-        columns: Helios.Models.Device.fields,
-        paginated: true,
-        perPage: 20
-      })
-      @$el.find("#datagrid").html(@datagrid.el)
+    @composeView ?= new Helios.Views.Compose()
+    @composeView.render()
+    @$el.find("#datagrid").html(@datagrid.el)
+
+    @
+
+  filter: (e) ->
+    e.preventDefault()
+    @collection.query = $(e.target).val()
+    @collection.fetch()
+
+class Helios.Views.Compose extends Backbone.View
+  template: JST['compose']
+  el: "#compose-modal"
+
+  events:
+    'submit form': 'submit'
+    'click button#send': 'submit'
+    'keyup textarea': 'updatePreview'
+    'focus textarea': ->
+      @$el.find("input[type=radio][value=selected]").prop('checked',true)
+
+  initialize: ->
+    window.setInterval(@updateTime, 10000)
+
+  render: ->
+    @$el.html(@template())
+
+    @editor = CodeMirror.fromTextArea(document.getElementById("payload"), {
+      mode: "application/json",
+      theme: "solarized-dark",
+      tabMode: "indent",
+      lineNumbers : true,
+      matchBrackets: true
+    })
+
+    @updatePreview()
+    @updateTime()
 
+    # $.ajax("/message"
+    #   type: "HEAD"
+
+    #   error: (data, status) =>
+    #     @disable()
+    # )
     @
 
+  submit: ->
+    $form = @$el.find("form#compose")
+    payload = @editor.getValue()
+
+    tokens = undefined
+    if $("input[name='recipients']:checked").val() == "specified"
+      tokens = [$form.find("#tokens").val()]
+
+    $.ajax("/message"
+      type: "POST"
+      dataType: "json"
+      data: {
+        tokens: tokens,
+        payload: payload
+      }
+    )
+
+      beforeSend: =>
+        @$el.find(".alert-error, .alert-success").remove()
+
+      success: (data, status) =>
+        alert = """
+          <div class="alert alert-block alert-success">
+            <button type="button" class="close" data-dismiss="alert">×</button>
+            <h4>Push Notification Succeeded</h4>
+          </div>
+        """
+        @$el.prepend(alert)
+
+      error: (data, status) =>
+        alert = """
+          <div class="alert alert-block alert-error">
+            <button type="button" class="close" data-dismiss="alert">×</button>
+            <h4>Push Notification Failed</h4>
+            <p>#{$.parseJSON(data.responseText).error}</p>
+          </div>
+        """
+        @$el.prepend(alert)
+
+
+  disable: ->
+    alert = """
+      <div class="alert alert-block">
+        <button type="button" class="close" data-dismiss="alert">×</button>
+        <h4>Push Notification Sending Unavailable</h4>
+        <p>Check that Rack::PushNotification initializes with a <tt>:certificate</tt> parameter, and that the certificate exists and is readable in the location specified.</p>
+      </div>
+    """
+
+    @$el.prepend(alert)
+
+    $(".iphone").css(opacity: 0.5)
+
+    $form = @$el.find("form#compose")
+    $form.css(opacity: 0.5)
+    $form.find("input").disable()
+
+  updatePreview: ->
+    try
+      json = $.parseJSON(@editor.getValue())
+      if alert = json.aps.alert
+        $(".preview p").text(alert)
+
+    catch error
+      $(".alert strong").text(error.name)
+      $(".alert span").text(error.message)
+    finally
+      if alert? and alert.length > 0
+        $(".notification").show()
+        $(".alert").hide()
+      else
+        $(".notification").hide()
+        $(".alert").show()
+
+  updateTime: ->
+    $time = $("time")
+    $time.attr("datetime", Date.now().toISOString())
+    $time.find(".time").text(Date.now().toString("HH:mm"))
+    $time.find(".date").text(Date.now().toString("dddd, MMMM d"))
+
 class Helios.Views.Receipts extends Backbone.View
   template: JST['receipts']
   el: "[role='main']"
 
-  render: =>
-    @$el.html(@template())
+  events:
+    'keyup form.filter input': 'filter'
 
-    if @collection
-      console.log("receipts")
-      @datagrid = new Backbone.Datagrid({
+  initialize: ->
+    @datagrid = new Backbone.Datagrid({
         collection: @collection,
-        columns: Helios.Models.Receipt.fields,
+        columns: @collection.fields,
         paginated: true,
         perPage: 20
       })
-      @$el.find("#datagrid").html(@datagrid.el)
+
+  render: =>
+    @$el.html(@template())
+    @$el.find("#datagrid").html(@datagrid.el)
 
     @
 
+  filter: (e) ->
+    e.preventDefault()
+    @collection.query = $(e.target).val()
+    @collection.fetch()
+
 class Helios.Views.Passes extends Backbone.View
   template: JST['passes']
   el: "[role='main']"
 
-  render: =>
-    @$el.html(@template())
+  events:
+    'keyup form.filter input': 'filter'
 
-    if @collection
-      console.log("passes")
-      @datagrid = new Backbone.Datagrid({
+  initialize: ->
+    @datagrid = new Backbone.Datagrid({
         collection: @collection,
-        columns: Helios.Models.Pass.fields,
+        columns: @collection.fields,
         paginated: true,
         perPage: 20
       })
-      @$el.find("#datagrid").html(@datagrid.el)
+
+  render: =>
+    @$el.html(@template())
+    @$el.find("#datagrid").html(@datagrid.el)
 
     @
+
+  filter: (e) ->
+    e.preventDefault()
+    @collection.query = $(e.target).val()
+    @collection.fetch()

data/lib/helios/frontend/javascripts/vendor/backbone.paginator.js

@@ -0,0 +1,1046 @@
+/*! backbone.paginator - v0.5.1-dev - 3/19/2013
+* http://github.com/addyosmani/backbone.paginator
+* Copyright (c) 2013 Addy Osmani; Licensed MIT */
+
+Backbone.Paginator = (function ( Backbone, _, $ ) {
+  "use strict";
+
+  var Paginator = {};
+  Paginator.version = "0.6.0";
+
+  // @name: clientPager
+  //
+  // @tagline: Paginator for client-side data
+  //
+  // @description:
+  // This paginator is responsible for providing pagination
+  // and sort capabilities for a single payload of data
+  // we wish to paginate by the UI for easier browsering.
+  //
+  Paginator.clientPager = Backbone.Collection.extend({
+
+    // DEFAULTS FOR SORTING & FILTERING
+    useDiacriticsPlugin: true, // use diacritics plugin if available
+    useLevenshteinPlugin: true, // use levenshtein plugin if available
+    sortColumn: "",
+    sortDirection: "desc",
+    lastSortColumn: "",
+    fieldFilterRules: [],
+    lastFieldFilterRules: [],
+    filterFields: "",
+    filterExpression: "",
+    lastFilterExpression: "",
+
+    //DEFAULT PAGINATOR UI VALUES
+    defaults_ui: {
+      firstPage: 0,
+      currentPage: 1,
+      perPage: 5,
+      totalPages: 10,
+      pagesInRange: 4
+    },
+
+    // Default values used when sorting and/or filtering.
+    initialize: function(){
+      //LISTEN FOR ADD & REMOVE EVENTS THEN REMOVE MODELS FROM ORGINAL MODELS
+      this.on('add', this.addModel, this);
+      this.on('remove', this.removeModel, this);
+
+      // SET DEFAULT VALUES (ALLOWS YOU TO POPULATE PAGINATOR MAUNALLY)
+      this.setDefaults();
+    },
+
+
+    setDefaults: function() {
+      // SET DEFAULT UI SETTINGS
+      var options = _.defaults(this.paginator_ui, this.defaults_ui);
+
+      //UPDATE GLOBAL UI SETTINGS
+      _.defaults(this, options);
+    },
+
+    addModel: function(model) {
+      this.origModels.push(model);
+    },
+
+    removeModel: function(model) {
+      var index = _.indexOf(this.origModels, model);
+
+      this.origModels.splice(index, 1);
+    },
+
+    sync: function ( method, model, options ) {
+      var self = this;
+
+      // SET DEFAULT VALUES
+      this.setDefaults();
+
+      // Some values could be functions, let's make sure
+      // to change their scope too and run them
+      var queryAttributes = {};
+      _.each(_.result(self, "server_api"), function(value, key){
+        if( _.isFunction(value) ) {
+          value = _.bind(value, self);
+          value = value();
+        }
+        queryAttributes[key] = value;
+      });
+
+      var queryOptions = _.clone(self.paginator_core);
+      _.each(queryOptions, function(value, key){
+        if( _.isFunction(value) ) {
+          value = _.bind(value, self);
+          value = value();
+        }
+        queryOptions[key] = value;
+      });
+
+      // Create default values if no others are specified
+      queryOptions = _.defaults(queryOptions, {
+        timeout: 25000,
+        cache: false,
+        type: 'GET',
+        dataType: 'jsonp'
+      });
+
+      queryOptions = _.extend(queryOptions, {
+        data: decodeURIComponent($.param(queryAttributes)),
+        processData: false,
+        url: _.result(queryOptions, 'url')
+      }, options);
+
+      var bbVer = Backbone.VERSION.split('.');
+      var oldSuccessFormat = (parseInt(bbVer[0], 10) === 0 &&
+                              parseInt(bbVer[1], 10) === 9 &&
+                              parseInt(bbVer[2], 10) <= 9);
+
+      var success = queryOptions.success;
+      queryOptions.success = function ( resp, status, xhr ) {
+        if ( success ) {
+          // This is to keep compatibility with Backbone older than 0.9.10
+          if (oldSuccessFormat) {
+            success( resp, status, xhr );
+          } else {
+            success( model, resp, queryOptions );
+          }
+        }
+        if ( model && model.trigger ) {
+          model.trigger( 'sync', model, resp, queryOptions );
+        }
+      };
+
+      var error = queryOptions.error;
+      queryOptions.error = function ( xhr ) {
+        if ( error ) {
+          error( model, xhr, queryOptions );
+        }
+        if ( model && model.trigger ) {
+          model.trigger( 'error', model, xhr, queryOptions );
+        }
+      };
+
+      var xhr = queryOptions.xhr = $.ajax( queryOptions );
+      if ( model && model.trigger ) {
+        model.trigger('request', model, xhr, queryOptions);
+      }
+      return xhr;
+    },
+
+    nextPage: function (options) {
+      if(this.currentPage < this.information.totalPages) {
+        this.currentPage = ++this.currentPage;
+        this.pager(options);
+      }
+    },
+
+    previousPage: function (options) {
+      if(this.currentPage > 1) {
+        this.currentPage = --this.currentPage;
+        this.pager(options);
+      }
+    },
+
+    goTo: function ( page, options ) {
+      if(page !== undefined){
+        this.currentPage = parseInt(page, 10);
+        this.pager(options);
+      }
+    },
+
+    howManyPer: function ( perPage ) {
+      if(perPage !== undefined){
+        var lastPerPage = this.perPage;
+        this.perPage = parseInt(perPage, 10);
+        this.currentPage = Math.ceil( ( lastPerPage * ( this.currentPage - 1 ) + 1 ) / perPage);
+        this.pager();
+      }
+    },
+
+
+    // setSort is used to sort the current model. After
+    // passing 'column', which is the model's field you want
+    // to filter and 'direction', which is the direction
+    // desired for the ordering ('asc' or 'desc'), pager()
+    // and info() will be called automatically.
+    setSort: function ( column, direction ) {
+      if(column !== undefined && direction !== undefined){
+        this.lastSortColumn = this.sortColumn;
+        this.sortColumn = column;
+        this.sortDirection = direction;
+        this.pager();
+        this.info();
+      }
+    },
+
+    // setFieldFilter is used to filter each value of each model
+    // according to `rules` that you pass as argument.
+    // Example: You have a collection of books with 'release year' and 'author'.
+    // You can filter only the books that were released between 1999 and 2003
+    // And then you can add another `rule` that will filter those books only to
+    // authors who's name start with 'A'.
+    setFieldFilter: function ( fieldFilterRules ) {
+      if( !_.isEmpty( fieldFilterRules ) ) {
+        this.lastFieldFilterRules = this.fieldFilterRules;
+        this.fieldFilterRules = fieldFilterRules;
+        this.pager();
+        this.info();
+        // if all the filters are removed, we should save the last filter
+        // and then let the list reset to it's original state.
+      } else {
+        this.lastFieldFilterRules = this.fieldFilterRules;
+        this.fieldFilterRules = '';
+        this.pager();
+        this.info();
+      }
+    },
+
+    // doFakeFieldFilter can be used to get the number of models that will remain
+    // after calling setFieldFilter with a filter rule(s)
+    doFakeFieldFilter: function ( rules ) {
+      if( !_.isEmpty( rules ) ) {
+        var testModels = this.origModels;
+        if (testModels === undefined) {
+          testModels = this.models;
+        }
+
+        testModels = this._fieldFilter(testModels, rules);
+
+        // To comply with current behavior, also filter by any previously defined setFilter rules.
+        if ( this.filterExpression !== "" ) {
+          testModels = this._filter(testModels, this.filterFields, this.filterExpression);
+        }
+
+        // Return size
+        return testModels.length;
+      }
+
+    },
+
+    // setFilter is used to filter the current model. After
+    // passing 'fields', which can be a string referring to
+    // the model's field, an array of strings representing
+    // each of the model's fields or an object with the name
+    // of the model's field(s) and comparing options (see docs)
+    // you wish to filter by and
+    // 'filter', which is the word or words you wish to
+    // filter by, pager() and info() will be called automatically.
+    setFilter: function ( fields, filter ) {
+      if( fields !== undefined && filter !== undefined ){
+        this.filterFields = fields;
+        this.lastFilterExpression = this.filterExpression;
+        this.filterExpression = filter;
+        this.pager();
+        this.info();
+      }
+    },
+
+    // doFakeFilter can be used to get the number of models that will
+    // remain after calling setFilter with a `fields` and `filter` args.
+    doFakeFilter: function ( fields, filter ) {
+      if( fields !== undefined && filter !== undefined ){
+        var testModels = this.origModels;
+        if (testModels === undefined) {
+          testModels = this.models;
+        }
+
+        // To comply with current behavior, first filter by any previously defined setFieldFilter rules.
+        if ( !_.isEmpty( this.fieldFilterRules ) ) {
+          testModels = this._fieldFilter(testModels, this.fieldFilterRules);
+        }
+
+        testModels = this._filter(testModels, fields, filter);
+
+        // Return size
+        return testModels.length;
+      }
+    },
+
+
+    // pager is used to sort, filter and show the data
+    // you expect the library to display.
+    pager: function (options) {
+      var self = this,
+      disp = this.perPage,
+      start = (self.currentPage - 1) * disp,
+      stop = start + disp;
+      // Saving the original models collection is important
+      // as we could need to sort or filter, and we don't want
+      // to loose the data we fetched from the server.
+      if (self.origModels === undefined) {
+        self.origModels = self.models;
+      }
+
+      self.models = self.origModels.slice();
+
+      // Check if sorting was set using setSort.
+      if ( this.sortColumn !== "" ) {
+        self.models = self._sort(self.models, this.sortColumn, this.sortDirection);
+      }
+
+      // Check if field-filtering was set using setFieldFilter
+      if ( !_.isEmpty( this.fieldFilterRules ) ) {
+        self.models = self._fieldFilter(self.models, this.fieldFilterRules);
+      }
+
+      // Check if filtering was set using setFilter.
+      if ( this.filterExpression !== "" ) {
+        self.models = self._filter(self.models, this.filterFields, this.filterExpression);
+      }
+
+      // If the sorting or the filtering was changed go to the first page
+      if ( this.lastSortColumn !== this.sortColumn || this.lastFilterExpression !== this.filterExpression || !_.isEqual(this.fieldFilterRules, this.lastFieldFilterRules) ) {
+        start = 0;
+        stop = start + disp;
+        self.currentPage = 1;
+
+        this.lastSortColumn = this.sortColumn;
+        this.lastFieldFilterRules = this.fieldFilterRules;
+        this.lastFilterExpression = this.filterExpression;
+      }
+
+      // We need to save the sorted and filtered models collection
+      // because we'll use that sorted and filtered collection in info().
+      self.sortedAndFilteredModels = self.models.slice();
+      self.info();
+      self.reset(self.models.slice(start, stop));
+
+      // This is somewhat of a hack to get all the nextPage, prevPage, and goTo methods
+      // to work with a success callback (as in the requestPager). Realistically there is no failure case here,
+      // but maybe we could catch exception and trigger a failure callback?
+      _.result(options, 'success');
+    },
+
+    // The actual place where the collection is sorted.
+    // Check setSort for arguments explicacion.
+    _sort: function ( models, sort, direction ) {
+      models = models.sort(function (a, b) {
+        var ac = a.get(sort),
+        bc = b.get(sort);
+
+        if ( _.isUndefined(ac) || _.isUndefined(bc) || ac === null || bc === null ) {
+          return 0;
+        } else {
+          /* Make sure that both ac and bc are lowercase strings.
+           * .toString() first so we don't have to worry if ac or bc
+           * have other String-only methods.
+           */
+          ac = ac.toString().toLowerCase();
+          bc = bc.toString().toLowerCase();
+        }
+
+        if (direction === 'desc') {
+
+          // We need to know if there aren't any non-number characters
+          // and that there are numbers-only characters and maybe a dot
+          // if we have a float.
+          // Oh, also a '-' for negative numbers!
+          if((!ac.match(/[^\-\d\.]/) && ac.match(/-?[\d\.]+/)) &&
+          (!bc.match(/[^\-\d\.]/) && bc.match(/-?[\d\.]+/))
+            ){
+
+              if( (ac - 0) < (bc - 0) ) {
+                return 1;
+              }
+              if( (ac - 0) > (bc - 0) ) {
+                return -1;
+              }
+            } else {
+              if (ac < bc) {
+                return 1;
+              }
+              if (ac > bc) {
+                return -1;
+              }
+            }
+
+        } else {
+
+          //Same as the regexp check in the 'if' part.
+          if((!ac.match(/[^\-\d\.]/) && ac.match(/-?[\d\.]+/)) &&
+          (!bc.match(/[^\-\d\.]/) && bc.match(/-?[\d\.]+/))
+            ){
+              if( (ac - 0) < (bc - 0) ) {
+                return -1;
+              }
+              if( (ac - 0) > (bc - 0) ) {
+                return 1;
+              }
+            } else {
+              if (ac < bc) {
+                return -1;
+              }
+              if (ac > bc) {
+                return 1;
+              }
+            }
+
+        }
+
+        if (a.cid && b.cid){
+          var aId = a.cid,
+          bId = b.cid;
+
+          if (aId < bId) {
+            return -1;
+          }
+          if (aId > bId) {
+            return 1;
+          }
+        }
+
+        return 0;
+      });
+
+      return models;
+    },
+
+    // The actual place where the collection is field-filtered.
+    // Check setFieldFilter for arguments explicacion.
+    _fieldFilter: function( models, rules ) {
+
+      // Check if there are any rules
+      if ( _.isEmpty(rules) ) {
+        return models;
+      }
+
+      var filteredModels = [];
+
+      // Iterate over each rule
+      _.each(models, function(model){
+
+        var should_push = true;
+
+        // Apply each rule to each model in the collection
+        _.each(rules, function(rule){
+
+          // Don't go inside the switch if we're already sure that the model won't be included in the results
+          if( !should_push ){
+            return false;
+          }
+
+          should_push = false;
+
+          // The field's value will be passed to a custom function, which should
+          // return true (if model should be included) or false (model should be ignored)
+          if(rule.type === "function"){
+            var f = _.wrap(rule.value, function(func){
+              return func( model.get(rule.field) );
+            });
+            if( f() ){
+              should_push = true;
+            }
+
+            // The field's value is required to be non-empty
+          }else if(rule.type === "required"){
+            if( !_.isEmpty( model.get(rule.field).toString() ) ) {
+              should_push = true;
+            }
+
+            // The field's value is required to be greater tan N (numbers only)
+          }else if(rule.type === "min"){
+            if( !_.isNaN( Number( model.get(rule.field) ) ) &&
+               !_.isNaN( Number( rule.value ) ) &&
+                 Number( model.get(rule.field) ) >= Number( rule.value ) ) {
+              should_push = true;
+            }
+
+            // The field's value is required to be smaller tan N (numbers only)
+          }else if(rule.type === "max"){
+            if( !_.isNaN( Number( model.get(rule.field) ) ) &&
+               !_.isNaN( Number( rule.value ) ) &&
+                 Number( model.get(rule.field) ) <= Number( rule.value ) ) {
+              should_push = true;
+            }
+
+            // The field's value is required to be between N and M (numbers only)
+          }else if(rule.type === "range"){
+            if( !_.isNaN( Number( model.get(rule.field) ) ) &&
+               _.isObject( rule.value ) &&
+                 !_.isNaN( Number( rule.value.min ) ) &&
+                   !_.isNaN( Number( rule.value.max ) ) &&
+                     Number( model.get(rule.field) ) >= Number( rule.value.min ) &&
+                       Number( model.get(rule.field) ) <= Number( rule.value.max ) ) {
+              should_push = true;
+            }
+
+            // The field's value is required to be more than N chars long
+          }else if(rule.type === "minLength"){
+            if( model.get(rule.field).toString().length >= rule.value ) {
+              should_push = true;
+            }
+
+            // The field's value is required to be no more than N chars long
+          }else if(rule.type === "maxLength"){
+            if( model.get(rule.field).toString().length <= rule.value ) {
+              should_push = true;
+            }
+
+            // The field's value is required to be more than N chars long and no more than M chars long
+          }else if(rule.type === "rangeLength"){
+            if( _.isObject( rule.value ) &&
+               !_.isNaN( Number( rule.value.min ) ) &&
+                 !_.isNaN( Number( rule.value.max ) ) &&
+                   model.get(rule.field).toString().length >= rule.value.min &&
+                     model.get(rule.field).toString().length <= rule.value.max ) {
+              should_push = true;
+            }
+
+            // The field's value is required to be equal to one of the values in rules.value
+          }else if(rule.type === "oneOf"){
+            if( _.isArray( rule.value ) &&
+               _.include( rule.value, model.get(rule.field) ) ) {
+              should_push = true;
+            }
+
+            // The field's value is required to be equal to the value in rules.value
+          }else if(rule.type === "equalTo"){
+            if( rule.value === model.get(rule.field) ) {
+              should_push = true;
+            }
+
+          }else if(rule.type === "containsAllOf"){
+            if( _.isArray( rule.value ) &&
+               _.isArray(model.get(rule.field)) &&
+                 _.intersection( rule.value, model.get(rule.field)).length === rule.value.length
+              ) {
+                should_push = true;
+              }
+
+              // The field's value is required to match the regular expression
+          }else if(rule.type === "pattern"){
+            if( model.get(rule.field).toString().match(rule.value) ) {
+              should_push = true;
+            }
+
+            //Unknown type
+          }else{
+            should_push = false;
+          }
+
+        });
+
+        if( should_push ){
+          filteredModels.push(model);
+        }
+
+      });
+
+      return filteredModels;
+    },
+
+    // The actual place where the collection is filtered.
+    // Check setFilter for arguments explicacion.
+    _filter: function ( models, fields, filter ) {
+
+      //  For example, if you had a data model containing cars like { color: '', description: '', hp: '' },
+      //  your fields was set to ['color', 'description', 'hp'] and your filter was set
+      //  to "Black Mustang 300", the word "Black" will match all the cars that have black color, then
+      //  "Mustang" in the description and then the HP in the 'hp' field.
+      //  NOTE: "Black Musta 300" will return the same as "Black Mustang 300"
+
+      // We accept fields to be a string, an array or an object
+      // but if string or array is passed we need to convert it
+      // to an object.
+
+      var self = this;
+
+      var obj_fields = {};
+
+      if( _.isString( fields ) ) {
+        obj_fields[fields] = {cmp_method: 'regexp'};
+      }else if( _.isArray( fields ) ) {
+        _.each(fields, function(field){
+          obj_fields[field] = {cmp_method: 'regexp'};
+        });
+      }else{
+        _.each(fields, function( cmp_opts, field ) {
+          obj_fields[field] = _.defaults(cmp_opts, { cmp_method: 'regexp' });
+        });
+      }
+
+      fields = obj_fields;
+
+      //Remove diacritic characters if diacritic plugin is loaded
+      if( _.has(Backbone.Paginator, 'removeDiacritics') && self.useDiacriticsPlugin ){
+        filter = Backbone.Paginator.removeDiacritics(filter);
+      }
+
+      // 'filter' can be only a string.
+      // If 'filter' is string we need to convert it to
+      // a regular expression.
+      // For example, if 'filter' is 'black dog' we need
+      // to find every single word, remove duplicated ones (if any)
+      // and transform the result to '(black|dog)'
+      if( filter === '' || !_.isString(filter) ) {
+        return models;
+      } else {
+        var words = _.map(filter.match(/\w+/ig), function(element) { return element.toLowerCase(); });
+        var pattern = "(" + _.uniq(words).join("|") + ")";
+        var regexp = new RegExp(pattern, "igm");
+      }
+
+      var filteredModels = [];
+
+      // We need to iterate over each model
+      _.each( models, function( model ) {
+
+        var matchesPerModel = [];
+
+        // and over each field of each model
+        _.each( fields, function( cmp_opts, field ) {
+
+          var value = model.get( field );
+
+          if( value ) {
+
+            // The regular expression we created earlier let's us detect if a
+            // given string contains each and all of the words in the regular expression
+            // or not, but in both cases match() will return an array containing all
+            // the words it matched.
+            var matchesPerField = [];
+
+            if( _.has(Backbone.Paginator, 'removeDiacritics') && self.useDiacriticsPlugin ){
+              value = Backbone.Paginator.removeDiacritics(value.toString());
+            }else{
+              value = value.toString();
+            }
+
+            // Levenshtein cmp
+            if( cmp_opts.cmp_method === 'levenshtein' && _.has(Backbone.Paginator, 'levenshtein') && self.useLevenshteinPlugin ) {
+              var distance = Backbone.Paginator.levenshtein(value, filter);
+
+              _.defaults(cmp_opts, { max_distance: 0 });
+
+              if( distance <= cmp_opts.max_distance ) {
+                matchesPerField = _.uniq(words);
+              }
+
+              // Default (RegExp) cmp
+            }else{
+              matchesPerField = value.match( regexp );
+            }
+
+            matchesPerField = _.map(matchesPerField, function(match) {
+              return match.toString().toLowerCase();
+            });
+
+            _.each(matchesPerField, function(match){
+              matchesPerModel.push(match);
+            });
+
+          }
+
+        });
+
+        // We just need to check if the returned array contains all the words in our
+        // regex, and if it does, it means that we have a match, so we should save it.
+        matchesPerModel = _.uniq( _.without(matchesPerModel, "") );
+
+        if(  _.isEmpty( _.difference(words, matchesPerModel) ) ) {
+          filteredModels.push(model);
+        }
+
+      });
+
+      return filteredModels;
+    },
+
+    // You shouldn't need to call info() as this method is used to
+    // calculate internal data as first/prev/next/last page...
+    info: function () {
+      var self = this,
+      info = {},
+      totalRecords = (self.sortedAndFilteredModels) ? self.sortedAndFilteredModels.length : self.length,
+      totalPages = Math.ceil(totalRecords / self.perPage);
+
+      info = {
+        totalUnfilteredRecords: self.origModels.length,
+        totalRecords: totalRecords,
+        currentPage: self.currentPage,
+        perPage: this.perPage,
+        totalPages: totalPages,
+        lastPage: totalPages,
+        previous: false,
+        next: false,
+        startRecord: totalRecords === 0 ? 0 : (self.currentPage - 1) * this.perPage + 1,
+        endRecord: Math.min(totalRecords, self.currentPage * this.perPage)
+      };
+
+      if (self.currentPage > 1) {
+        info.previous = self.currentPage - 1;
+      }
+
+      if (self.currentPage < info.totalPages) {
+        info.next = self.currentPage + 1;
+      }
+
+      info.pageSet = self.setPagination(info);
+
+      self.information = info;
+      return info;
+    },
+
+
+    // setPagination also is an internal function that shouldn't be called directly.
+    // It will create an array containing the pages right before and right after the
+    // actual page.
+    setPagination: function ( info ) {
+
+      var pages = [], i = 0, l = 0;
+
+      // How many adjacent pages should be shown on each side?
+      var ADJACENTx2 = this.pagesInRange * 2,
+      LASTPAGE = Math.ceil(info.totalRecords / info.perPage);
+
+      if (LASTPAGE > 1) {
+
+        // not enough pages to bother breaking it up
+        if (LASTPAGE <= (1 + ADJACENTx2)) {
+          for (i = 1, l = LASTPAGE; i <= l; i++) {
+            pages.push(i);
+          }
+        }
+
+        // enough pages to hide some
+        else {
+
+          //close to beginning; only hide later pages
+          if (info.currentPage <=  (this.pagesInRange + 1)) {
+            for (i = 1, l = 2 + ADJACENTx2; i < l; i++) {
+              pages.push(i);
+            }
+          }
+
+          // in middle; hide some front and some back
+          else if (LASTPAGE - this.pagesInRange > info.currentPage && info.currentPage > this.pagesInRange) {
+            for (i = info.currentPage - this.pagesInRange; i <= info.currentPage + this.pagesInRange; i++) {
+              pages.push(i);
+            }
+          }
+
+          // close to end; only hide early pages
+          else {
+            for (i = LASTPAGE - ADJACENTx2; i <= LASTPAGE; i++) {
+              pages.push(i);
+            }
+          }
+        }
+
+      }
+
+      return pages;
+
+    },
+
+    bootstrap: function(options) {
+      _.extend(this, options);
+      this.goTo(1);
+      this.info();
+      return this;
+    }
+
+  });
+
+  // function aliasing
+  Paginator.clientPager.prototype.prevPage = Paginator.clientPager.prototype.previousPage;
+
+  // @name: requestPager
+  //
+  // Paginator for server-side data being requested from a backend/API
+  //
+  // @description:
+  // This paginator is responsible for providing pagination
+  // and sort capabilities for requests to a server-side
+  // data service (e.g an API)
+  //
+  Paginator.requestPager = Backbone.Collection.extend({
+
+    sync: function ( method, model, options ) {
+
+      var self = this;
+
+      self.setDefaults();
+
+      // Some values could be functions, let's make sure
+      // to change their scope too and run them
+      var queryAttributes = {};
+      _.each(_.result(self, "server_api"), function(value, key){
+        if( _.isFunction(value) ) {
+          value = _.bind(value, self);
+          value = value();
+        }
+        queryAttributes[key] = value;
+      });
+
+      var queryOptions = _.clone(self.paginator_core);
+      _.each(queryOptions, function(value, key){
+        if( _.isFunction(value) ) {
+          value = _.bind(value, self);
+          value = value();
+        }
+        queryOptions[key] = value;
+      });
+
+      // Create default values if no others are specified
+      queryOptions = _.defaults(queryOptions, {
+        timeout: 25000,
+        cache: false,
+        type: 'GET',
+        dataType: 'jsonp'
+      });
+
+      // Allows the passing in of {data: {foo: 'bar'}} at request time to overwrite server_api defaults
+      if( options.data ){
+        options.data = decodeURIComponent($.param(_.extend(queryAttributes,options.data)));
+      }else{
+        options.data = decodeURIComponent($.param(queryAttributes));
+      }
+
+      queryOptions = _.extend(queryOptions, {
+        data: decodeURIComponent($.param(queryAttributes)),
+        processData: false,
+        url: _.result(queryOptions, 'url')
+      }, options);
+
+      var bbVer = Backbone.VERSION.split('.');
+      var oldSuccessFormat = (parseInt(bbVer[0], 10) === 0 &&
+                              parseInt(bbVer[1], 10) === 9 &&
+                              parseInt(bbVer[2], 10) <= 9);
+
+      var success = queryOptions.success;
+      queryOptions.success = function ( resp, status, xhr ) {
+
+        if ( success ) {
+          // This is to keep compatibility with Backbone older than 0.9.10
+          if (oldSuccessFormat) {
+            success( resp, status, xhr );
+          } else {
+            success( model, resp, queryOptions );
+          }
+        }
+        if ( model && model.trigger ) {
+          model.trigger( 'sync', model, resp, queryOptions );
+        }
+      };
+
+      var error = queryOptions.error;
+      queryOptions.error = function ( xhr ) {
+        if ( error ) {
+          error( model, xhr, queryOptions );
+        }
+        if ( model && model.trigger ) {
+          model.trigger( 'error', model, xhr, queryOptions );
+        }
+      };
+
+      var xhr = queryOptions.xhr = $.ajax( queryOptions );
+      if ( model && model.trigger ) {
+        model.trigger('request', model, xhr, queryOptions);
+      }
+      return xhr;
+    },
+
+    setDefaults: function() {
+      var self = this;
+
+      // Create default values if no others are specified
+      _.defaults(self.paginator_ui, {
+        firstPage: 0,
+        currentPage: 1,
+        perPage: 5,
+        totalPages: 10,
+        pagesInRange: 4
+      });
+
+      // Change scope of 'paginator_ui' object values
+      _.each(self.paginator_ui, function(value, key) {
+        if (_.isUndefined(self[key])) {
+          self[key] = self.paginator_ui[key];
+        }
+      });
+    },
+
+    requestNextPage: function ( options ) {
+      if ( this.currentPage !== undefined ) {
+        this.currentPage += 1;
+        return this.pager( options );
+      } else {
+        var response = new $.Deferred();
+        response.reject();
+        return response.promise();
+      }
+    },
+
+    requestPreviousPage: function ( options ) {
+      if ( this.currentPage !== undefined ) {
+        this.currentPage -= 1;
+        return this.pager( options );
+      } else {
+        var response = new $.Deferred();
+        response.reject();
+        return response.promise();
+      }
+    },
+
+    updateOrder: function ( column ) {
+      if (column !== undefined) {
+        this.sortField = column;
+        this.pager();
+      }
+
+    },
+
+    goTo: function ( page, options ) {
+      if ( page !== undefined ) {
+        this.currentPage = parseInt(page, 10);
+        return this.pager( options );
+      } else {
+        var response = new $.Deferred();
+        response.reject();
+        return response.promise();
+      }
+    },
+
+    howManyPer: function ( count ) {
+      if( count !== undefined ){
+        this.currentPage = this.firstPage;
+        this.perPage = count;
+        this.pager();
+      }
+    },
+
+    info: function () {
+
+      var info = {
+        // If parse() method is implemented and totalRecords is set to the length
+        // of the records returned, make it available. Else, default it to 0
+        totalRecords: this.totalRecords || 0,
+
+        currentPage: this.currentPage,
+        firstPage: this.firstPage,
+        totalPages: Math.ceil(this.totalRecords / this.perPage),
+        lastPage: this.totalPages, // should use totalPages in template
+        perPage: this.perPage,
+        previous:false,
+        next:false
+      };
+
+      if (this.currentPage > 1) {
+        info.previous = this.currentPage - 1;
+      }
+
+      if (this.currentPage < info.totalPages) {
+        info.next = this.currentPage + 1;
+      }
+
+      // left around for backwards compatibility
+      info.hasNext = info.next;
+      info.hasPrevious = info.next;
+
+      info.pageSet = this.setPagination(info);
+
+      this.information = info;
+      return info;
+    },
+
+    setPagination: function ( info ) {
+
+      var pages = [], i = 0, l = 0;
+
+      // How many adjacent pages should be shown on each side?
+      var ADJACENTx2 = this.pagesInRange * 2,
+      LASTPAGE = Math.ceil(info.totalRecords / info.perPage);
+
+      if (LASTPAGE > 1) {
+
+        // not enough pages to bother breaking it up
+        if (LASTPAGE <= (1 + ADJACENTx2)) {
+          for (i = 1, l = LASTPAGE; i <= l; i++) {
+            pages.push(i);
+          }
+        }
+
+        // enough pages to hide some
+        else {
+
+          //close to beginning; only hide later pages
+          if (info.currentPage <=  (this.pagesInRange + 1)) {
+            for (i = 1, l = 2 + ADJACENTx2; i < l; i++) {
+              pages.push(i);
+            }
+          }
+
+          // in middle; hide some front and some back
+          else if (LASTPAGE - this.pagesInRange > info.currentPage && info.currentPage > this.pagesInRange) {
+            for (i = info.currentPage - this.pagesInRange; i <= info.currentPage + this.pagesInRange; i++) {
+              pages.push(i);
+            }
+          }
+
+          // close to end; only hide early pages
+          else {
+            for (i = LASTPAGE - ADJACENTx2; i <= LASTPAGE; i++) {
+              pages.push(i);
+            }
+          }
+        }
+
+      }
+
+      return pages;
+
+    },
+
+    // fetches the latest results from the server
+    pager: function ( options ) {
+      if ( !_.isObject(options) ) {
+        options = {};
+      }
+      return this.fetch( options );
+    },
+
+    url: function(){
+      // Expose url parameter enclosed in this.paginator_core.url to properly
+      // extend Collection and allow Collection CRUD
+      if(this.paginator_core !== undefined && this.paginator_core.url !== undefined){
+        return this.paginator_core.url;
+      } else {
+        return null;
+      }
+    },
+
+    bootstrap: function(options) {
+      _.extend(this, options);
+      this.setDefaults();
+      this.info();
+      return this;
+    }
+  });
+
+  // function aliasing
+  Paginator.requestPager.prototype.nextPage = Paginator.requestPager.prototype.requestNextPage;
+  Paginator.requestPager.prototype.prevPage = Paginator.requestPager.prototype.requestPreviousPage;
+
+  return Paginator;
+
+}( Backbone, _, jQuery ));