RubyGems - iqvoc - Versions diffs - 4.12.0 → 4.13.2 - Mend

iqvoc 4.12.0 → 4.13.2

Files changed (855) hide show

data/vendor/assets/bower_components/typeahead.js/doc/jquery_typeahead.md DELETED Viewed

@@ -1,383 +0,0 @@
-jQuery#typeahead
-----------------
-The UI component of typeahead.js is a available as a jQuery plugin. It's
-responsible for rendering suggestions and handling DOM interactions.
-Table of Contents
------------------
-* [Features](#features)
-* [Specification](#specification)
-* [Usage](#usage)
-  * [API](#api)
-  * [Options](#options)
-  * [Datasets](#datasets)
-  * [Custom Events](#custom-events)
-  * [Look and Feel](#look-and-feel)
-* [Bloodhound Integration](#bloodhound-integration)
-Features
---------
-* Displays suggestions to end-users as they type
-* Shows top suggestion as a hint (i.e. background text)
-* Supports custom templates to allow for UI flexibility
-* Works well with RTL languages and input method editors
-* Highlights query matches within the suggestion
-* Triggers custom events
-Specification
--------------
-In an effort to take advantage of the pre-existing knowledge of typeahead.js
-users, the behavior of the typeahead.js UI is modeled after google.com's search
-box. Below is pseudocode that details how the UI reacts to pertinent events.
-**Input Control Gains Focus**
-```
-activate typeahead
-```
-**Input Control Loses Focus**
-```
-deactivate typeahead
-close dropdown menu
-remove hint
-clear suggestions from dropdown menu
-```
-**Value of the Input Control Changes**
-```
-IF query satisfies minLength requirement THEN
-  request suggestions for new query
-  IF suggestions are available THEN
-    render suggestions in dropdown menu
-    open dropdown menu
-    update hint
-  ELSE
-    close dropdown menu
-    clear suggestions from dropdown menu
-    remove hint
-  ENDIF
-ELSE
-  close dropdown menu
-  clear suggestions from dropdown menu
-  remove hint
-ENDIF
-```
-**Up Arrow is Keyed**
-```
-IF dropdown menu is open THEN
-  move dropdown menu cursor up 1 suggestion
-ELSE
-  request suggestions for current query
-  IF suggestions are available THEN
-    render suggestions in dropdown menu
-    open dropdown menu
-    update hint
-  ENDIF
-ENDIF
-```
-**Down Arrow is Keyed**
-```
-IF dropdown menu is open THEN
-  move dropdown menu cursor down 1 suggestion
-ELSE
-  request suggestions for current query
-  IF suggestions are available THEN
-    render suggestions in dropdown menu
-    open dropdown menu
-    update hint
-  ENDIF
-ENDIF
-```
-**Left Arrow is Keyed**
-```
-IF detected query language direction is right-to-left THEN
-  IF hint is being shown THEN
-    IF text cursor is at end of query THEN
-      autocomplete query to hint
-    ENDIF
-  ENDIF
-ENDIF
-```
-**Right Arrow is Keyed**
-```
-IF detected query language direction is left-to-right THEN
-  IF hint is being shown THEN
-    IF text cursor is at the end of the query THEN
-      autocomplete query to hint
-    ENDIF
-  ENDIF
-ENDIF
-```
-**Tab is Keyed**
-```
-IF dropdown menu cursor is on suggestion THEN
-  close dropdown menu
-  update query to display key of suggestion
-  remove hint
-ELSIF hint is being shown THEN
-  autocomplete query to hint
-ENDIF
-```
-**Enter is Keyed**
-```
-IF dropdown menu cursor is on suggestion THEN
-  close dropdown menu
-  update query to display key of suggestion
-  remove hint
-  prevent default browser action e.g. form submit
-ENDIF
-```
-**Esc is Keyed**
-```
-close dropdown menu
-remove hint
-```
-**Suggestion is Clicked**
-```
-update query to display key of suggestion
-close dropdown menu
-remove hint
-```
-Usage
------
-### API
-#### jQuery#typeahead(options, [\*datasets])
-Turns any `input[type="text"]` element into a typeahead. `options` is an
-options hash that's used to configure the typeahead to your liking. Refer to
-[Options](#options) for more info regarding the available configs. Subsequent
-arguments (`*datasets`), are individual option hashes for datasets. For more
-details regarding datasets, refer to [Datasets](#datasets).
-```javascript
-$('.typeahead').typeahead({
-  minLength: 3,
-  highlight: true,
-},
-{
-  name: 'my-dataset',
-  source: mySource
-});
-```
-#### jQuery#typeahead('destroy')
-Removes typeahead functionality and reverts the `input` element back to its
-original state.
-```javascript
-$('.typeahead').typeahead('destroy');
-```
-#### jQuery#typeahead('open')
-Opens the dropdown menu of typeahead. Note that being open does not mean that
-the menu is visible. The menu is only visible when it is open and has content.
-```javascript
-$('.typeahead').typeahead('open');
-```
-#### jQuery#typeahead('close')
-Closes the dropdown menu of typeahead.
-```javascript
-$('.typeahead').typeahead('close');
-```
-#### jQuery#typeahead('val')
-Returns the current value of the typeahead. The value is the text the user has
-entered into the `input` element.
-```javascript
-var myVal = $('.typeahead').typeahead('val');
-```
-#### jQuery#typeahead('val', val)
-Sets the value of the typeahead. This should be used in place of `jQuery#val`.
-```javascript
-$('.typeahead').typeahead('val', myVal);
-```
-#### jQuery.fn.typeahead.noConflict()
-Returns a reference to the typeahead plugin and reverts `jQuery.fn.typeahead`
-to its previous value. Can be used to avoid naming collisions.
-```javascript
-var typeahead = jQuery.fn.typeahead.noConflict();
-jQuery.fn._typeahead = typeahead;
-```
-### Options
-When initializing a typeahead, there are a number of options you can configure.
-* `highlight` – If `true`, when suggestions are rendered, pattern matches
-  for the current query in text nodes will be wrapped in a `strong` element with
-  `tt-highlight` class. Defaults to `false`.
-* `hint` – If `false`, the typeahead will not show a hint. Defaults to `true`.
-* `minLength` – The minimum character length needed before suggestions start
-  getting rendered. Defaults to `1`.
-### Datasets
-A typeahead is composed of one or more datasets. When an end-user modifies the
-value of a typeahead, each dataset will attempt to render suggestions for the
-new value.
-For most use cases, one dataset should suffice. It's only in the scenario where
-you want rendered suggestions to be grouped in the dropdown menu based on some
-sort of categorical relationship that you'd need to use multiple datasets. For
-example, on twitter.com, the search typeahead groups results into recent
-searches, trends, and accounts – that would be a great use case for using
-multiple datasets.
-Datasets can be configured using the following options.
-* `source` – The backing data source for suggestions. Expected to be a function
-  with the signature `(query, cb)`. It is expected that the function will
-  compute the suggestion set (i.e. an array of JavaScript objects) for `query`
-  and then invoke `cb` with said set. `cb` can be invoked synchronously or
-  asynchronously. A Bloodhound suggestion engine can be used here, to learn
-  how, see [Bloodhound Integration](#bloodhound-integration). **Required**.
-* `name` – The name of the dataset. This will be appended to `tt-dataset-` to
-  form the class name of the containing DOM element.  Must only consist of
-  underscores, dashes, letters (`a-z`), and numbers. Defaults to a random
-  number.
-* `displayKey` – For a given suggestion object, determines the string
-  representation of it. This will be used when setting the value of the input
-  control after a suggestion is selected. Can be either a key string or a
-  function that transforms a suggestion object into a string. Defaults to
-  `value`.
-* `templates` – A hash of templates to be used when rendering the dataset. Note
-  a precompiled template is a function that takes a JavaScript object as its
-  first argument and returns a HTML string.
-  * `empty` – Rendered when `0` suggestions are available for the given query.
-  Can be either a HTML string or a precompiled template. If it's a precompiled
-  template, the passed in context will contain `query`.
-  * `footer`– Rendered at the bottom of the dataset. Can be either a HTML
-  string or a precompiled template. If it's a precompiled template, the passed
-  in context will contain `query` and `isEmpty`.
-  * `header` – Rendered at the top of the dataset. Can be either a HTML string
-  or a precompiled template. If it's a precompiled template, the passed in
-  context will contain `query` and `isEmpty`.
-  * `suggestion` – Used to render a single suggestion. If set, this has to be a
-  precompiled template. The associated suggestion object will serve as the
-  context. Defaults to the value of `displayKey` wrapped in a `p` tag i.e.
-  `<p>{{value}}</p>`.
-### Custom Events
-The typeahead component triggers the following custom events.
-* `typeahead:opened` – Triggered when the dropdown menu of a typeahead is
-  opened.
-* `typeahead:closed` – Triggered when the dropdown menu of a typeahead is
-  closed.
-* `typeahead:cursorchanged` – Triggered when the dropdown menu cursor is moved
-  to a different suggestion. The event handler will be invoked with 3
-  arguments: the jQuery event object, the suggestion object, and the name of
-  the dataset the suggestion belongs to.
-* `typeahead:selected` – Triggered when a suggestion from the dropdown menu is
-  selected. The event handler will be invoked with 3 arguments: the jQuery
-  event object, the suggestion object, and the name of the dataset the
-  suggestion belongs to.
-* `typeahead:autocompleted` – Triggered when the query is autocompleted.
-  Autocompleted means the query was changed to the hint. The event handler will
-  be invoked with 3 arguments: the jQuery event object, the suggestion object,
-  and the name of the dataset the suggestion belongs to.
-All custom events are triggered on the element initialized as a typeahead.
-### Look and Feel
-Below is a faux mustache template describing the DOM structure of a typeahead
-dropdown menu. Keep in mind that `header`, `footer`, `suggestion`, and `empty`
-come from the provided templates detailed [here](#datasets).
-```html
-<span class="tt-dropdown-menu">
-  {{#datasets}}
-    <div class="tt-dataset-{{name}}">
-      {{{header}}}
-      <span class="tt-suggestions">
-        {{#suggestions}}
-          <div class="tt-suggestion">{{{suggestion}}}</div>
-        {{/suggestions}}
-        {{^suggestions}}
-          {{{empty}}}
-        {{/suggestions}}
-      </span>
-      {{{footer}}}
-    </div>
-  {{/datasets}}
-</span>
-```
-When an end-user mouses or keys over a `.tt-suggestion`, the class `tt-cursor`
-will be added to it. You can use this class as a hook for styling the "under
-cursor" state of suggestions.
-Bloodhound Integration
-----------------------
-Because datasets expect their `source` to be a function, you cannot directly
-pass a Bloodhound suggestion engine in as `source`. Rather, you'll need to
-pass the suggestion engine's typeahead adapter:
-```javascript
-var engine = new Bloodhound({ /* options */ });
-engine.initialize();
-$('.typeahead').typeahead(null, {
-  source: engine.ttAdapter()
-});
-```

data/vendor/assets/bower_components/typeahead.js/doc/migration/0.10.0.md DELETED Viewed

@@ -1,234 +0,0 @@
-Migrating to typeahead.js v0.10.0
-=================================
-Preamble
---------
-v0.10.0 of typeahead.js ended up being almost a complete rewrite. Many things
-stayed the same, but there were a handful of changes you need to be aware of
-if you plan on upgrading from an older version. This document aims to call out
-those changes and explain what you need to do in order to have an painless
-upgrade.
-Notable Changes
-----------------
-### First Argument to the jQuery Plugin
-In v0.10.0, the first argument to `jQuery#typeahead` is an options hash that
-can be used to configure the behavior of the typeahead. This is in contrast
-to previous versions where `jQuery#typeahead` expected just a series of datasets
-to be passed to it:
-```javascript
-// pre-v0.10.0
-$('.typeahead').typeahead(myDataset);
-// v0.10.0
-$('.typeahead').typeahead({
-  highlight: true,
-  hint: false
-}, myDataset);
-```
-If you're fine with the default configuration, you can just pass `null` as the
-first argument:
-```javascript
-$('.typeahead').typeahead(null, myDataset);
-```
-### Bloodhound Suggestion Engine
-The most notable change in v0.10.0 is that typeahead.js has been decomposed into
-a suggestion engine and a UI view. As part of this change, the way you configure
-datasets has changed. Previously, a dataset config would have looked like:
-```javascript
-{
-  valueKey: 'num',
-  local: [{ num: 'one' }, { num: 'two' }, { num: 'three' }],
-  prefetch: '/prefetch',
-  remote: '/remote?q=%QUERY'
-}
-```
-In v0.10.0, an equivalent dataset config would look like:
-```javascript
-{
- displayKey: 'num',
- source: mySource
-}
-```
-As you can see, `local`, `prefetch`, and `remote` are no longer defined at the
-dataset level. Instead, all you set in a dataset config is `source`. `source` is
-expected to be a function with the signature `function(query, callback)`. When a
-typeahead's query changes, suggestions will be requested from  `source`. It's
-expected `source` will compute the suggestion set and invoke `callback` with an array
-of suggestion objects. The typeahead will then go on to render those suggestions.
-If you're wondering if you can still configure `local`, `prefetch`, and
-`remote`, don't worry, that's where the Bloodhound suggestion engine comes in.
-Here's how you would define `mySource` which was referenced in the previous
-code snippet:
-```
-var mySource = new Bloodhound({
-  datumTokenizer: function(d) {
-    return Bloodhound.tokenizers.whitespace(d.num);
-  },
-  queryTokenizer: Bloodhound.tokenizers.whitespace,
-  local: [{ num: 'one' }, { num: 'two' }, { num: 'three' }],
-  prefetch: '/prefetch',
-  remote: '/remote?q=%QUERY'
-});
-// this kicks off the loading and processing of local and prefetch data
-// the suggestion engine will be useless until it is initialized
-mySource.initialize();
-```
-In the above snippet, a Bloodhound suggestion engine is initialized and that's
-what will be used as the source of your dataset. There's still one last thing
-that needs to be done before you can use a Bloodhound suggestion engine as the
-source of a dataset. Because datasets expect `source` to be function, the
-Bloodhound instance needs to be wrapped in an adapter so it can meet that
-expectation.
-```
-mySource = mySource.ttAdapter();
-```
-Put it all together:
-```javascript
-var mySource = new Bloodhound({
-  datumTokenizer: function(d) {
-    return Bloodhound.tokenizers.whitespace(d.num);
-  },
-  queryTokenizer: Bloodhound.tokenizers.whitespace,
-  local: [{ num: 'one' }, { num: 'two' }, { num: 'three' }],
-  prefetch: '/prefetch',
-  remote: '/remote?q=%QUERY'
-});
-mySource.initialize();
-$('.typeahead').typeahead(null, {
-  displayKey: 'num',
-  source: mySource.ttAdapter()
-});
-```
-### Tokenization Methods Must Be Provided
-The Bloodhound suggestion engine is token-based, so how datums and queries are
-tokenized plays a vital role in the quality of search results. Pre-v0.10.0,
-it was not possible to configure the tokenization method. Starting in v0.10.0,
-you **must** specify how you want datums and queries tokenized.
-The most common tokenization methods split a given string on whitespace or
-non-word characters. Bloodhound provides implementations for those methods
-out of the box:
-```javascript
-// returns ['one', 'two', 'twenty-five']
-Bloodhound.tokenizers.whitespace('  one two  twenty-five');
-// returns ['one', 'two', 'twenty', 'five']
-Bloodhound.tokenizers.nonword('  one two  twenty-five');
-```
-For query tokenization, you'll probably want to use one of the above methods.
-For datum tokenization, this is where you may want to do something a tad bit
-more advanced.
-For datums, sometimes you want tokens to be dervied from more than one property.
-For example, if you were building a search engine for GitHub repositories, it'd
-probably be wise to have tokens derived from the repo's name, owner, and
-primary language:
-```javascript
-var repos = [
-  { name: 'example', owner: 'John Doe', language: 'JavaScript' },
-  { name: 'another example', owner: 'Joe Doe', language: 'Scala' }
-];
-function customTokenizer(datum) {
-  var nameTokens = Bloodhound.tokenizers.whitespace(datum.name);
-  var ownerTokens = Bloodhound.tokenizers.whitespace(datum.owner);
-  var languageTokens = Bloodhound.tokenizers.whitespace(datum.language);
-  return nameTokens.concat(ownerTokens).concat(languageTokens);
-}
-```
-There may also be the scenario where you want datum tokenization to be performed
-on the backend. The best way to do that is to just add a property to your datums
-that contains those tokens. You can then provide a tokenizer that just returns
-the already existing tokens:
-```javascript
-var sports = [
-  { value: 'football', tokens: ['football', 'pigskin'] },
-  { value: 'basketball', tokens: ['basketball', 'bball'] }
-];
-function customTokenizer(datum) { return datum.tokens; }
-```
-There are plenty of other ways you could go about tokenizing datums, it really
-just depends on what you are trying to accomplish.
-### String Datums Are No Longer Supported
-Dropping support for string datums was a difficult choice, but in the end it
-made sense for a number of reasons. If you still want to hydrate the suggestion
-engine with string datums, you'll need to use the `filter` function:
-```javascript
-var engine = new Bloodhound({
-  prefetch: {
-    url: '/data',
-    filter: function(data) {
-      // assume data is an array of strings e.g. ['one', 'two', 'three']
-      return $.map(data, function(str) { return { value: str }; });
-    },
-    datumTokenizer: function(d) {
-      return Bloodhound.tokenizers.whitespace(d.value);
-    },
-    queryTokenizer: Bloodhound.tokenizers.whitespace
-  }
-});
-```
-### Precompiled Templates Are Now Required
-In previous versions of typeahead.js, you could specify a string template along
-with the templating engine that should be used to compile/render it. In
-v0.10.0, you can no longer specify templating engines; instead you must provide
-precompiled templates. Precompiled templates are functions that take one
-argument: the context the template should be rendered with.
-Most of the popular templating engines allow for the creation of precompiled
-templates. For example, you can generate one using Handlebars by doing the
-following:
-```javascript
-var precompiledTemplate = Handlebars.compile('<p>{{value}}</p>');
-```
-[Handlebars]: http://handlebarsjs.com/
-### CSS Class Changes
-`tt-is-under-cursor` is now `tt-cursor` - Applied to a hovered-on suggestion (either via cursor or arrow key).
-`tt-query` is now `tt-input` - Applied to the typeahead input field.
-Something Missing?
-------------------
-If something is missing from this migration guide, pull requests are accepted :)

data/vendor/assets/bower_components/typeahead.js/karma.conf.js DELETED Viewed

@@ -1,98 +0,0 @@
-// Karma configuration
-// Generated on Sun Jun 30 2013 00:14:30 GMT-0700 (PDT)
-// base path, that will be used to resolve files and exclude
-basePath = '';
-preprocessors = {
-'src/**/*.js': 'coverage'
-};
-// list of files / patterns to load in the browser
-files = [
-  'bower_components/jquery/jquery.js',
-  'src/common/utils.js',
-  'src/bloodhound/version.js',
-  'src/bloodhound/tokenizers.js',
-  'src/bloodhound/lru_cache.js',
-  'src/bloodhound/persistent_storage.js',
-  'src/bloodhound/transport.js',
-  'src/bloodhound/search_index.js',
-  'src/bloodhound/options_parser.js',
-  'src/bloodhound/bloodhound.js',
-  'src/typeahead/html.js',
-  'src/typeahead/css.js',
-  'src/typeahead/event_bus.js',
-  'src/typeahead/event_emitter.js',
-  'src/typeahead/highlight.js',
-  'src/typeahead/input.js',
-  'src/typeahead/dataset.js',
-  'src/typeahead/dropdown.js',
-  'src/typeahead/typeahead.js',
-  'src/typeahead/plugin.js',
-  JASMINE,
-  JASMINE_ADAPTER,
-  'test/fixtures/**/*',
-  'bower_components/jasmine-jquery/lib/jasmine-jquery.js',
-  'bower_components/jasmine-ajax/lib/mock-ajax.js',
-  'test/helpers/**/*',
-  'test/*_spec.js'
-];
-// list of files to exclude
-exclude = [
-];
-// test results reporter to use
-// possible values: 'dots', 'progress', 'junit'
-reporters = ['progress', 'coverage'];
-// web server port
-port = 9876;
-// cli runner port
-runnerPort = 9100;
-// code coverage configs
-coverageReporter = {
-  type : 'html',
-  dir : 'test/coverage/'
-}
-// enable / disable colors in the output (reporters and logs)
-colors = true;
-// level of logging
-// possible values: LOG_DISABLE || LOG_ERROR || LOG_WARN || LOG_INFO || LOG_DEBUG
-logLevel = LOG_INFO;
-// enable / disable watching file and executing tests whenever any file changes
-autoWatch = true;
-// Start these browsers, currently available:
-// - Chrome
-// - ChromeCanary
-// - Firefox
-// - Opera
-// - Safari (only Mac)
-// - PhantomJS
-// - IE (only Windows)
-browsers = ['Chrome'];
-// If browser does not capture in given timeout [ms], kill it
-captureTimeout = 60000;
-// Continuous Integration mode
-// if true, it capture browsers, run tests and exit
-singleRun = false;