RubyGems - iqvoc - Versions diffs - 4.8.1 → 4.8.2 - Mend

iqvoc 4.8.1 → 4.8.2

Files changed (606) hide show

data/vendor/assets/bower_components/typeahead.js/test/playground.html ADDED

@@ -0,0 +1,347 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <script src="../bower_components/jquery/jquery.js"></script>
+    <script src="../dist/typeahead.bundle.js"></script>
+    <style>
+      .container {
+        width: 800px;
+        margin: 50px auto;
+      }
+      .typeahead-wrapper {
+        display: block;
+        margin: 50px 0;
+      }
+      .tt-dropdown-menu {
+        background-color: #fff;
+        border: 1px solid #000;
+      }
+      .tt-suggestion.tt-cursor {
+        background-color: #ccc;
+      }
+      .triggered-events {
+        float: right;
+        width: 500px;
+        height: 300px;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <textarea class="triggered-events"></textarea>
+      <form action="/where" method="GET">
+        <div class="typeahead-wrapper">
+          <input class="states" name="states" type="text" placeholder="states" value="Michigan">
+          <input type="submit">
+        </div>
+      </form>
+      <div class="typeahead-wrapper">
+        <input class="bad-tokens" type="text" placeholder="bad tokens">
+      </div>
+      <div class="typeahead-wrapper">
+        <input class="regex-symbols" type="text" placeholder="regex symbols">
+      </div>
+      <div class="typeahead-wrapper">
+        <input class="header-footer" type="text" placeholder="header footer">
+      </div>
+      <div class="typeahead-wrapper">
+        <input class="ltr" type="text" placeholder="ltr">
+      </div>
+      <div class="typeahead-wrapper">
+        <input class="rtl" type="text" placeholder="rtl">
+      </div>
+      <div class="typeahead-wrapper">
+        <input class="mixed" type="text" placeholder="mixed">
+      </div>
+    </div>
+    </div>
+    <script>
+      var states = new Bloodhound({
+        datumTokenizer: function(d) {
+          return Bloodhound.tokenizers.whitespace(d.val);
+        },
+        queryTokenizer: Bloodhound.tokenizers.whitespace,
+        local: [
+          { val: 'Alabama' },
+          { val: 'Alaska' },
+          { val: 'Arizona' },
+          { val: 'Arkansas' },
+          { val: 'California' },
+          { val: 'Colorado' },
+          { val: 'Connecticut' },
+          { val: 'Delaware' },
+          { val: 'Florida' },
+          { val: 'Georgia' },
+          { val: 'Hawaii' },
+          { val: 'Idaho' },
+          { val: 'Illinois' },
+          { val: 'Indiana' },
+          { val: 'Iowa' },
+          { val: 'Kansas' },
+          { val: 'Kentucky' },
+          { val: 'Louisiana' },
+          { val: 'Maine' },
+          { val: 'Maryland' },
+          { val: 'Massachusetts' },
+          { val: 'Michigan' },
+          { val: 'Minnesota' },
+          { val: 'Mississippi' },
+          { val: 'Missouri' },
+          { val: 'Montana' },
+          { val: 'Nebraska' },
+          { val: 'Nevada' },
+          { val: 'New Hampshire' },
+          { val: 'New Jersey' },
+          { val: 'New Mexico' },
+          { val: 'New York' },
+          { val: 'North Carolina' },
+          { val: 'North Dakota' },
+          { val: 'Ohio' },
+          { val: 'Oklahoma' },
+          { val: 'Oregon' },
+          { val: 'Pennsylvania' },
+          { val: 'Rhode Island' },
+          { val: 'South Carolina' },
+          { val: 'South Dakota' },
+          { val: 'Tennessee' },
+          { val: 'Texas' },
+          { val: 'Utah' },
+          { val: 'Vermont' },
+          { val: 'Virginia' },
+          { val: 'Washington' },
+          { val: 'West Virginia' },
+          { val: 'Wisconsin' },
+          { val: 'Wyoming' }
+        ]
+      });
+      states.initialize();
+      $('.states').typeahead({
+        highlight: true
+      },
+      {
+        displayKey: 'val',
+        source: states.ttAdapter()
+      });
+      var badTokens = new Bloodhound({
+        datumTokenizer: function(d) { return d.tokens; },
+        queryTokenizer: Bloodhound.tokenizers.whitespace,
+        local: [
+          {
+            value1: 'all bad',
+            jake: '111',
+            tokens: ['  ', ' ', null, undefined, false, 'all', 'bad']
+          },
+          {
+            value1: 'whitespace',
+            jake: '112',
+            tokens: ['  ', ' ', '\t', '\n', 'whitespace']
+          },
+          {
+            value1: 'undefined',
+            jake: '113',
+            tokens: [undefined, 'undefined']
+          },
+          {
+            value1: 'null',
+            jake: '114',
+            tokens: [null, 'null']
+          },
+          {
+            value1: 'false',
+            jake: '115',
+            tokens: [false, 'false']
+          }
+        ]
+      });
+      badTokens.initialize();
+      $('.bad-tokens').typeahead(null, {
+        displayKey: 'value1',
+        source: badTokens.ttAdapter()
+      });
+      var regexSymbols = new Bloodhound({
+        datumTokenizer: function(d) {
+          return Bloodhound.tokenizers.whitespace(d.val);
+        },
+        queryTokenizer: Bloodhound.tokenizers.whitespace,
+        local: [
+          { val: '*.js' },
+          { val: '[Tt]ypeahead.js' },
+          { val: '^typeahead.js$' },
+          { val: 'typeahead.js(0.8.2)' },
+          { val: 'typeahead.js(@\\d.\\d.\\d)' },
+          { val: 'typeahead.js@0.8.2' }
+        ]
+      });
+      regexSymbols.initialize();
+      $('.regex-symbols').typeahead(null, {
+        displayKey: 'val',
+        source: regexSymbols.ttAdapter()
+      });
+      var abc = new Bloodhound({
+        datumTokenizer: function(d) {
+          return Bloodhound.tokenizers.whitespace(d.val);
+        },
+        queryTokenizer: Bloodhound.tokenizers.whitespace,
+        local: [
+          { val: 'a' },
+          { val: 'ab' },
+          { val: 'abc' },
+          { val: 'abcd' },
+          { val: 'abcde' }
+        ]
+      });
+      abc.initialize();
+      $('.header-footer').typeahead(null, {
+        displayKey: 'val',
+        source: abc.ttAdapter(),
+        templates: {
+          header: '<h3>Header</h3>',
+          footer: '<h3>Footer</h3>'
+        }
+      },
+      {
+        displayKey: 'val',
+        source: abc.ttAdapter(),
+        templates: {
+          header: '<h3>start</h3>',
+          footer: '<h3>end</h3>',
+          empty: '<h3>empty</h3>'
+        }
+      });
+      var ltr = new Bloodhound({
+        datumTokenizer: function(d) {
+          return Bloodhound.tokenizers.whitespace(d.val);
+        },
+        queryTokenizer: Bloodhound.tokenizers.whitespace,
+        local: [
+          { val: "one" },
+          { val: "two three" },
+          { val: "four" },
+          { val: "five six" },
+          { val: "seven" }
+        ]
+      });
+      ltr.initialize();
+      $('.ltr').typeahead({
+        highlight: true
+      },
+      {
+        displayKey: 'val',
+        source: ltr.ttAdapter()
+      });
+      var rtl = new Bloodhound({
+        datumTokenizer: function(d) {
+          return Bloodhound.tokenizers.whitespace(d.val);
+        },
+        queryTokenizer: Bloodhound.tokenizers.whitespace,
+        local: [
+          { val: "שלום" },
+          { val: "ערב טוב" },
+          { val: "מה שלומך" },
+          { val: "רב תודות" },
+          { val: "אין דבר" }
+        ]
+      });
+      rtl.initialize();
+      $('.rtl').typeahead({
+        highlight: true
+      },
+      {
+        displayKey: 'val',
+        source: rtl.ttAdapter()
+      });
+      var mixed = new Bloodhound({
+        datumTokenizer: function(d) {
+          return Bloodhound.tokenizers.whitespace(d.val);
+        },
+        queryTokenizer: Bloodhound.tokenizers.whitespace,
+        local: [
+          { val: "שלום" },
+          { val: "ערב טוב" },
+          { val: "מה שלומך" },
+          { val: "one" },
+          { val: "two three" }
+        ]
+      });
+      mixed.initialize();
+      $('.mixed').typeahead({
+        highlight: true
+      },
+      {
+        displayKey: 'val',
+        source: mixed.ttAdapter()
+      });
+      $('input').on([
+        'typeahead:initialized',
+        'typeahead:initialized:err',
+        'typeahead:selected',
+        'typeahead:autocompleted',
+        'typeahead:cursorchanged',
+        'typeahead:opened',
+        'typeahead:closed'
+      ].join(' '), logTypeaheadEvent);
+      $('form').on('submit', logSubmitEvent);
+      function logSubmitEvent($e) {
+        var text;
+        $e && $e.preventDefault();
+        text = JSON.stringify($(this).serializeArray());
+        writeToTextarea('submit', text);
+      }
+      function logTypeaheadEvent($e) {
+        var args, type, text;
+        args = [].slice.call(arguments, 1);
+        type = $e.type;
+        text = window.JSON ? JSON.stringify(args) : '';
+        writeToTextarea(type, text);
+      }
+      function writeToTextarea(/* lines */) {
+        var $textarea, val, text;
+        $textarea = $('.triggered-events');
+        val = $textarea.val();
+        text = [].join.call(arguments, '\n');
+        $textarea.val([val, text, '\n'].join('\n'));
+        $textarea[0].scrollTop = $textarea[0].scrollHeight;
+      }
+    </script>
+  </body>
+</html>

data/vendor/assets/bower_components/typeahead.js/test/search_index_spec.js ADDED

@@ -0,0 +1,60 @@
+describe('SearchIndex', function() {
+  beforeEach(function() {
+    this.searchIndex = new SearchIndex({
+      datumTokenizer: datumTokenizer,
+      queryTokenizer: queryTokenizer
+    });
+    this.searchIndex.add(fixtures.data.simple);
+  });
+  it('should support serialization/deserialization', function() {
+    var serialized = this.searchIndex.serialize();
+    this.searchIndex = new SearchIndex({
+      datumTokenizer: datumTokenizer,
+      queryTokenizer: queryTokenizer
+    });
+    this.searchIndex.bootstrap(serialized);
+    expect(this.searchIndex.get('smaller')).toEqual([{ value: 'smaller' }]);
+  });
+  it('should be able to add data on the fly', function() {
+    this.searchIndex.add({ value: 'new' });
+    expect(this.searchIndex.get('new')).toEqual([{ value: 'new' }]);
+  });
+  it('#get should return datums that match the given query', function() {
+    expect(this.searchIndex.get('big')).toEqual([
+      { value: 'big' },
+      { value: 'bigger' },
+      { value: 'biggest' }
+    ]);
+    expect(this.searchIndex.get('small')).toEqual([
+      { value: 'small' },
+      { value: 'smaller' },
+      { value: 'smallest' }
+    ]);
+  });
+  it('#get should return an empty array of there are no matches', function() {
+    expect(this.searchIndex.get('wtf')).toEqual([]);
+  });
+  it('#reset should empty the search index', function() {
+    this.searchIndex.reset();
+    expect(this.searchIndex.datums).toEqual([]);
+    expect(this.searchIndex.trie.ids).toEqual([]);
+    expect(this.searchIndex.trie.children).toEqual({});
+  });
+  // helper functions
+  // ----------------
+  function datumTokenizer(d) { return $.trim(d.value).split(/\s+/); }
+  function queryTokenizer(s) { return $.trim(s).split(/\s+/); }
+});

data/vendor/assets/bower_components/typeahead.js/test/tokenizers_spec.js ADDED

@@ -0,0 +1,60 @@
+describe('tokenizers', function() {
+  it('.whitespace should tokenize on whitespace', function() {
+    var tokens = tokenizers.whitespace('big-deal ok');
+    expect(tokens).toEqual(['big-deal', 'ok']);
+  });
+  it('.whitespace should treat null as empty string', function() {
+    var tokens = tokenizers.whitespace(null);
+    expect(tokens).toEqual([]);
+  });
+  it('.whitespace should treat undefined as empty string', function() {
+    var tokens = tokenizers.whitespace(undefined);
+    expect(tokens).toEqual([]);
+  });
+  it('.nonword should tokenize on non-word characters', function() {
+    var tokens = tokenizers.nonword('big-deal ok');
+    expect(tokens).toEqual(['big', 'deal', 'ok']);
+  });
+  it('.nonword should treat null as empty string', function() {
+    var tokens = tokenizers.nonword(null);
+    expect(tokens).toEqual([]);
+  });
+  it('.nonword should treat undefined as empty string', function() {
+    var tokens = tokenizers.nonword(undefined);
+    expect(tokens).toEqual([]);
+  });
+  it('.obj.whitespace should tokenize on whitespace', function() {
+    var t = tokenizers.obj.whitespace('val');
+    var tokens = t({ val: 'big-deal ok' });
+    expect(tokens).toEqual(['big-deal', 'ok']);
+  });
+  it('.obj.whitespace should accept multiple properties', function() {
+    var t = tokenizers.obj.whitespace('one', 'two');
+    var tokens = t({ one: 'big-deal ok', two: 'buzz' });
+    expect(tokens).toEqual(['big-deal', 'ok', 'buzz']);
+  });
+  it('.obj.nonword should tokenize on non-word characters', function() {
+    var t = tokenizers.obj.nonword('val');
+    var tokens = t({ val: 'big-deal ok' });
+    expect(tokens).toEqual(['big', 'deal', 'ok']);
+  });
+  it('.obj.nonword should accept multiple properties', function() {
+    var t = tokenizers.obj.nonword('one', 'two');
+    var tokens = t({ one: 'big-deal ok', two: 'buzz' });
+    expect(tokens).toEqual(['big', 'deal', 'ok', 'buzz']);
+  });
+});