tooltip_js 1.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml ADDED
@@ -0,0 +1,7 @@
1
+ ---
2
+ SHA1:
3
+ metadata.gz: 5d4745efa11a8280027930a14d534b5e1ae2fcb0
4
+ data.tar.gz: 9f2a2993b9c77afb011a6ba63ce1d03db3b9f44c
5
+ SHA512:
6
+ metadata.gz: cc4fc78dc4f654cc2026c4543cf54a00c0ae2044119fe3e454ea1fca0207eccf4e0082612215719db4f28c5aa2bcb3a901b9d6e4b0b306dc8e93ffc41777e408
7
+ data.tar.gz: 433e8da23e3955ebaab0673b9193adca9e2712b6682356fcdaf93dccfb988d827ddd95434ba0cbe79c38f68edf4bffea2a3cb3eb36c1f60ce3650b96a5a97706
@@ -0,0 +1,589 @@
1
+ /**!
2
+ * @fileOverview Kickass library to create and place poppers near their reference elements.
3
+ * @version 1.3.1
4
+ * @license
5
+ * Copyright (c) 2016 Federico Zivolo and contributors
6
+ *
7
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
8
+ * of this software and associated documentation files (the "Software"), to deal
9
+ * in the Software without restriction, including without limitation the rights
10
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11
+ * copies of the Software, and to permit persons to whom the Software is
12
+ * furnished to do so, subject to the following conditions:
13
+ *
14
+ * The above copyright notice and this permission notice shall be included in all
15
+ * copies or substantial portions of the Software.
16
+ *
17
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23
+ * SOFTWARE.
24
+ */
25
+ (function (global, factory) {
26
+ typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('popper.js')) :
27
+ typeof define === 'function' && define.amd ? define(['popper.js'], factory) :
28
+ (global.Tooltip = factory(global.Popper));
29
+ }(this, (function (Popper) { 'use strict';
30
+
31
+ Popper = Popper && Popper.hasOwnProperty('default') ? Popper['default'] : Popper;
32
+
33
+ /**
34
+ * Check if the given variable is a function
35
+ * @method
36
+ * @memberof Popper.Utils
37
+ * @argument {Any} functionToCheck - variable to check
38
+ * @returns {Boolean} answer to: is a function?
39
+ */
40
+ function isFunction(functionToCheck) {
41
+ var getType = {};
42
+ return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
43
+ }
44
+
45
+ var classCallCheck = function (instance, Constructor) {
46
+ if (!(instance instanceof Constructor)) {
47
+ throw new TypeError("Cannot call a class as a function");
48
+ }
49
+ };
50
+
51
+ var createClass = function () {
52
+ function defineProperties(target, props) {
53
+ for (var i = 0; i < props.length; i++) {
54
+ var descriptor = props[i];
55
+ descriptor.enumerable = descriptor.enumerable || false;
56
+ descriptor.configurable = true;
57
+ if ("value" in descriptor) descriptor.writable = true;
58
+ Object.defineProperty(target, descriptor.key, descriptor);
59
+ }
60
+ }
61
+
62
+ return function (Constructor, protoProps, staticProps) {
63
+ if (protoProps) defineProperties(Constructor.prototype, protoProps);
64
+ if (staticProps) defineProperties(Constructor, staticProps);
65
+ return Constructor;
66
+ };
67
+ }();
68
+
69
+
70
+
71
+
72
+
73
+
74
+
75
+ var _extends = Object.assign || function (target) {
76
+ for (var i = 1; i < arguments.length; i++) {
77
+ var source = arguments[i];
78
+
79
+ for (var key in source) {
80
+ if (Object.prototype.hasOwnProperty.call(source, key)) {
81
+ target[key] = source[key];
82
+ }
83
+ }
84
+ }
85
+
86
+ return target;
87
+ };
88
+
89
+ var DEFAULT_OPTIONS = {
90
+ container: false,
91
+ delay: 0,
92
+ html: false,
93
+ placement: 'top',
94
+ title: '',
95
+ template: '<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',
96
+ trigger: 'hover focus',
97
+ offset: 0,
98
+ arrowSelector: '.tooltip-arrow, .tooltip__arrow',
99
+ innerSelector: '.tooltip-inner, .tooltip__inner'
100
+ };
101
+
102
+ var Tooltip = function () {
103
+ /**
104
+ * Create a new Tooltip.js instance
105
+ * @class Tooltip
106
+ * @param {HTMLElement} reference - The DOM node used as reference of the tooltip (it can be a jQuery element).
107
+ * @param {Object} options
108
+ * @param {String} options.placement='top'
109
+ * Placement of the popper accepted values: `top(-start, -end), right(-start, -end), bottom(-start, -end),
110
+ * left(-start, -end)`
111
+ * @param {String} options.arrowSelector='.tooltip-arrow, .tooltip__arrow' - className used to locate the DOM arrow element in the tooltip.
112
+ * @param {String} options.innerSelector='.tooltip-inner, .tooltip__inner' - className used to locate the DOM inner element in the tooltip.
113
+ * @param {HTMLElement|String|false} options.container=false - Append the tooltip to a specific element.
114
+ * @param {Number|Object} options.delay=0
115
+ * Delay showing and hiding the tooltip (ms) - does not apply to manual trigger type.
116
+ * If a number is supplied, delay is applied to both hide/show.
117
+ * Object structure is: `{ show: 500, hide: 100 }`
118
+ * @param {Boolean} options.html=false - Insert HTML into the tooltip. If false, the content will inserted with `textContent`.
119
+ * @param {String} [options.template='<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>']
120
+ * Base HTML to used when creating the tooltip.
121
+ * The tooltip's `title` will be injected into the `.tooltip-inner` or `.tooltip__inner`.
122
+ * `.tooltip-arrow` or `.tooltip__arrow` will become the tooltip's arrow.
123
+ * The outermost wrapper element should have the `.tooltip` class.
124
+ * @param {String|HTMLElement|TitleFunction} options.title='' - Default title value if `title` attribute isn't present.
125
+ * @param {String} [options.trigger='hover focus']
126
+ * How tooltip is triggered - click, hover, focus, manual.
127
+ * You may pass multiple triggers; separate them with a space. `manual` cannot be combined with any other trigger.
128
+ * @param {Boolean} options.closeOnClickOutside=false - Close a popper on click outside of the popper and reference element. This has effect only when options.trigger is 'click'.
129
+ * @param {String|HTMLElement} options.boundariesElement
130
+ * The element used as boundaries for the tooltip. For more information refer to Popper.js'
131
+ * [boundariesElement docs](https://popper.js.org/popper-documentation.html)
132
+ * @param {Number|String} options.offset=0 - Offset of the tooltip relative to its reference. For more information refer to Popper.js'
133
+ * [offset docs](https://popper.js.org/popper-documentation.html)
134
+ * @param {Object} options.popperOptions={} - Popper options, will be passed directly to popper instance. For more information refer to Popper.js'
135
+ * [options docs](https://popper.js.org/popper-documentation.html)
136
+ * @return {Object} instance - The generated tooltip instance
137
+ */
138
+ function Tooltip(reference, options) {
139
+ classCallCheck(this, Tooltip);
140
+
141
+ _initialiseProps.call(this);
142
+
143
+ // apply user options over default ones
144
+ options = _extends({}, DEFAULT_OPTIONS, options);
145
+
146
+ reference.jquery && (reference = reference[0]);
147
+
148
+ // cache reference and options
149
+ this.reference = reference;
150
+ this.options = options;
151
+
152
+ // get events list
153
+ var events = typeof options.trigger === 'string' ? options.trigger.split(' ').filter(function (trigger) {
154
+ return ['click', 'hover', 'focus'].indexOf(trigger) !== -1;
155
+ }) : [];
156
+
157
+ // set initial state
158
+ this._isOpen = false;
159
+ this._popperOptions = {};
160
+
161
+ // set event listeners
162
+ this._setEventListeners(reference, events, options);
163
+ }
164
+
165
+ //
166
+ // Public methods
167
+ //
168
+
169
+ /**
170
+ * Reveals an element's tooltip. This is considered a "manual" triggering of the tooltip.
171
+ * Tooltips with zero-length titles are never displayed.
172
+ * @method Tooltip#show
173
+ * @memberof Tooltip
174
+ */
175
+
176
+
177
+ /**
178
+ * Hides an element’s tooltip. This is considered a “manual” triggering of the tooltip.
179
+ * @method Tooltip#hide
180
+ * @memberof Tooltip
181
+ */
182
+
183
+
184
+ /**
185
+ * Hides and destroys an element’s tooltip.
186
+ * @method Tooltip#dispose
187
+ * @memberof Tooltip
188
+ */
189
+
190
+
191
+ /**
192
+ * Toggles an element’s tooltip. This is considered a “manual” triggering of the tooltip.
193
+ * @method Tooltip#toggle
194
+ * @memberof Tooltip
195
+ */
196
+
197
+
198
+ /**
199
+ * Updates the tooltip's title content
200
+ * @method Tooltip#updateTitleContent
201
+ * @memberof Tooltip
202
+ * @param {String|HTMLElement} title - The new content to use for the title
203
+ */
204
+
205
+
206
+ //
207
+ // Private methods
208
+ //
209
+
210
+ createClass(Tooltip, [{
211
+ key: '_create',
212
+
213
+
214
+ /**
215
+ * Creates a new tooltip node
216
+ * @memberof Tooltip
217
+ * @private
218
+ * @param {HTMLElement} reference
219
+ * @param {String} template
220
+ * @param {String|HTMLElement|TitleFunction} title
221
+ * @param {Boolean} allowHtml
222
+ * @return {HTMLElement} tooltipNode
223
+ */
224
+ value: function _create(reference, template, title, allowHtml) {
225
+ // create tooltip element
226
+ var tooltipGenerator = window.document.createElement('div');
227
+ tooltipGenerator.innerHTML = template.trim();
228
+ var tooltipNode = tooltipGenerator.childNodes[0];
229
+
230
+ // add unique ID to our tooltip (needed for accessibility reasons)
231
+ tooltipNode.id = 'tooltip_' + Math.random().toString(36).substr(2, 10);
232
+
233
+ // set initial `aria-hidden` state to `false` (it's visible!)
234
+ tooltipNode.setAttribute('aria-hidden', 'false');
235
+
236
+ // add title to tooltip
237
+ var titleNode = tooltipGenerator.querySelector(this.options.innerSelector);
238
+ this._addTitleContent(reference, title, allowHtml, titleNode);
239
+
240
+ // return the generated tooltip node
241
+ return tooltipNode;
242
+ }
243
+ }, {
244
+ key: '_addTitleContent',
245
+ value: function _addTitleContent(reference, title, allowHtml, titleNode) {
246
+ if (title.nodeType === 1 || title.nodeType === 11) {
247
+ // if title is a element node or document fragment, append it only if allowHtml is true
248
+ allowHtml && titleNode.appendChild(title);
249
+ } else if (isFunction(title)) {
250
+ // if title is a function, call it and set textContent or innerHtml depending by `allowHtml` value
251
+ var titleText = title.call(reference);
252
+ allowHtml ? titleNode.innerHTML = titleText : titleNode.textContent = titleText;
253
+ } else {
254
+ // if it's just a simple text, set textContent or innerHtml depending by `allowHtml` value
255
+ allowHtml ? titleNode.innerHTML = title : titleNode.textContent = title;
256
+ }
257
+ }
258
+ }, {
259
+ key: '_show',
260
+ value: function _show(reference, options) {
261
+ // don't show if it's already visible
262
+ // or if it's not being showed
263
+ if (this._isOpen && !this._isOpening) {
264
+ return this;
265
+ }
266
+ this._isOpen = true;
267
+
268
+ // if the tooltipNode already exists, just show it
269
+ if (this._tooltipNode) {
270
+ this._tooltipNode.style.visibility = 'visible';
271
+ this._tooltipNode.setAttribute('aria-hidden', 'false');
272
+ this.popperInstance.update();
273
+ return this;
274
+ }
275
+
276
+ // get title
277
+ var title = reference.getAttribute('title') || options.title;
278
+
279
+ // don't show tooltip if no title is defined
280
+ if (!title) {
281
+ return this;
282
+ }
283
+
284
+ // create tooltip node
285
+ var tooltipNode = this._create(reference, options.template, title, options.html);
286
+
287
+ // Add `aria-describedby` to our reference element for accessibility reasons
288
+ reference.setAttribute('aria-describedby', tooltipNode.id);
289
+
290
+ // append tooltip to container
291
+ var container = this._findContainer(options.container, reference);
292
+
293
+ this._append(tooltipNode, container);
294
+
295
+ this._popperOptions = _extends({}, options.popperOptions, {
296
+ placement: options.placement
297
+ });
298
+
299
+ this._popperOptions.modifiers = _extends({}, this._popperOptions.modifiers, {
300
+ arrow: {
301
+ element: this.options.arrowSelector
302
+ },
303
+ offset: {
304
+ offset: options.offset
305
+ }
306
+ });
307
+
308
+ if (options.boundariesElement) {
309
+ this._popperOptions.modifiers.preventOverflow = {
310
+ boundariesElement: options.boundariesElement
311
+ };
312
+ }
313
+
314
+ this.popperInstance = new Popper(reference, tooltipNode, this._popperOptions);
315
+
316
+ this._tooltipNode = tooltipNode;
317
+
318
+ return this;
319
+ }
320
+ }, {
321
+ key: '_hide',
322
+ value: function _hide() /*reference, options*/{
323
+ // don't hide if it's already hidden
324
+ if (!this._isOpen) {
325
+ return this;
326
+ }
327
+
328
+ this._isOpen = false;
329
+
330
+ // hide tooltipNode
331
+ this._tooltipNode.style.visibility = 'hidden';
332
+ this._tooltipNode.setAttribute('aria-hidden', 'true');
333
+
334
+ return this;
335
+ }
336
+ }, {
337
+ key: '_dispose',
338
+ value: function _dispose() {
339
+ var _this = this;
340
+
341
+ // remove event listeners first to prevent any unexpected behaviour
342
+ this._events.forEach(function (_ref) {
343
+ var func = _ref.func,
344
+ event = _ref.event;
345
+
346
+ _this.reference.removeEventListener(event, func);
347
+ });
348
+ this._events = [];
349
+
350
+ if (this._tooltipNode) {
351
+ this._hide();
352
+
353
+ // destroy instance
354
+ this.popperInstance.destroy();
355
+
356
+ // destroy tooltipNode if removeOnDestroy is not set, as popperInstance.destroy() already removes the element
357
+ if (!this.popperInstance.options.removeOnDestroy) {
358
+ this._tooltipNode.parentNode.removeChild(this._tooltipNode);
359
+ this._tooltipNode = null;
360
+ }
361
+ }
362
+ return this;
363
+ }
364
+ }, {
365
+ key: '_findContainer',
366
+ value: function _findContainer(container, reference) {
367
+ // if container is a query, get the relative element
368
+ if (typeof container === 'string') {
369
+ container = window.document.querySelector(container);
370
+ } else if (container === false) {
371
+ // if container is `false`, set it to reference parent
372
+ container = reference.parentNode;
373
+ }
374
+ return container;
375
+ }
376
+
377
+ /**
378
+ * Append tooltip to container
379
+ * @memberof Tooltip
380
+ * @private
381
+ * @param {HTMLElement} tooltipNode
382
+ * @param {HTMLElement|String|false} container
383
+ */
384
+
385
+ }, {
386
+ key: '_append',
387
+ value: function _append(tooltipNode, container) {
388
+ container.appendChild(tooltipNode);
389
+ }
390
+ }, {
391
+ key: '_setEventListeners',
392
+ value: function _setEventListeners(reference, events, options) {
393
+ var _this2 = this;
394
+
395
+ var directEvents = [];
396
+ var oppositeEvents = [];
397
+
398
+ events.forEach(function (event) {
399
+ switch (event) {
400
+ case 'hover':
401
+ directEvents.push('mouseenter');
402
+ oppositeEvents.push('mouseleave');
403
+ break;
404
+ case 'focus':
405
+ directEvents.push('focus');
406
+ oppositeEvents.push('blur');
407
+ break;
408
+ case 'click':
409
+ directEvents.push('click');
410
+ oppositeEvents.push('click');
411
+ break;
412
+ }
413
+ });
414
+
415
+ // schedule show tooltip
416
+ directEvents.forEach(function (event) {
417
+ var func = function func(evt) {
418
+ if (_this2._isOpening === true) {
419
+ return;
420
+ }
421
+ evt.usedByTooltip = true;
422
+ _this2._scheduleShow(reference, options.delay, options, evt);
423
+ };
424
+ _this2._events.push({ event: event, func: func });
425
+ reference.addEventListener(event, func);
426
+ });
427
+
428
+ // schedule hide tooltip
429
+ oppositeEvents.forEach(function (event) {
430
+ var func = function func(evt) {
431
+ if (evt.usedByTooltip === true) {
432
+ return;
433
+ }
434
+ _this2._scheduleHide(reference, options.delay, options, evt);
435
+ };
436
+ _this2._events.push({ event: event, func: func });
437
+ reference.addEventListener(event, func);
438
+ if (event === 'click' && options.closeOnClickOutside) {
439
+ document.addEventListener('mousedown', function (e) {
440
+ if (!_this2._isOpening) {
441
+ return;
442
+ }
443
+ var popper = _this2.popperInstance.popper;
444
+ if (reference.contains(e.target) || popper.contains(e.target)) {
445
+ return;
446
+ }
447
+ func(e);
448
+ }, true);
449
+ }
450
+ });
451
+ }
452
+ }, {
453
+ key: '_scheduleShow',
454
+ value: function _scheduleShow(reference, delay, options /*, evt */) {
455
+ var _this3 = this;
456
+
457
+ this._isOpening = true;
458
+ // defaults to 0
459
+ var computedDelay = delay && delay.show || delay || 0;
460
+ this._showTimeout = window.setTimeout(function () {
461
+ return _this3._show(reference, options);
462
+ }, computedDelay);
463
+ }
464
+ }, {
465
+ key: '_scheduleHide',
466
+ value: function _scheduleHide(reference, delay, options, evt) {
467
+ var _this4 = this;
468
+
469
+ this._isOpening = false;
470
+ // defaults to 0
471
+ var computedDelay = delay && delay.hide || delay || 0;
472
+ window.setTimeout(function () {
473
+ window.clearTimeout(_this4._showTimeout);
474
+ if (_this4._isOpen === false) {
475
+ return;
476
+ }
477
+ if (!document.body.contains(_this4._tooltipNode)) {
478
+ return;
479
+ }
480
+
481
+ // if we are hiding because of a mouseleave, we must check that the new
482
+ // reference isn't the tooltip, because in this case we don't want to hide it
483
+ if (evt.type === 'mouseleave') {
484
+ var isSet = _this4._setTooltipNodeEvent(evt, reference, delay, options);
485
+
486
+ // if we set the new event, don't hide the tooltip yet
487
+ // the new event will take care to hide it if necessary
488
+ if (isSet) {
489
+ return;
490
+ }
491
+ }
492
+
493
+ _this4._hide(reference, options);
494
+ }, computedDelay);
495
+ }
496
+ }, {
497
+ key: '_updateTitleContent',
498
+ value: function _updateTitleContent(title) {
499
+ if (typeof this._tooltipNode === 'undefined') {
500
+ if (typeof this.options.title !== 'undefined') {
501
+ this.options.title = title;
502
+ }
503
+ return;
504
+ }
505
+ var titleNode = this._tooltipNode.parentNode.querySelector(this.options.innerSelector);
506
+ this._clearTitleContent(titleNode, this.options.html, this.reference.getAttribute('title') || this.options.title);
507
+ this._addTitleContent(this.reference, title, this.options.html, titleNode);
508
+ this.options.title = title;
509
+ this.popperInstance.update();
510
+ }
511
+ }, {
512
+ key: '_clearTitleContent',
513
+ value: function _clearTitleContent(titleNode, allowHtml, lastTitle) {
514
+ if (lastTitle.nodeType === 1 || lastTitle.nodeType === 11) {
515
+ allowHtml && titleNode.removeChild(lastTitle);
516
+ } else {
517
+ allowHtml ? titleNode.innerHTML = '' : titleNode.textContent = '';
518
+ }
519
+ }
520
+ }]);
521
+ return Tooltip;
522
+ }();
523
+
524
+ /**
525
+ * Title function, its context is the Tooltip instance.
526
+ * @memberof Tooltip
527
+ * @callback TitleFunction
528
+ * @return {String} placement - The desired title.
529
+ */
530
+
531
+
532
+ var _initialiseProps = function _initialiseProps() {
533
+ var _this5 = this;
534
+
535
+ this.show = function () {
536
+ return _this5._show(_this5.reference, _this5.options);
537
+ };
538
+
539
+ this.hide = function () {
540
+ return _this5._hide();
541
+ };
542
+
543
+ this.dispose = function () {
544
+ return _this5._dispose();
545
+ };
546
+
547
+ this.toggle = function () {
548
+ if (_this5._isOpen) {
549
+ return _this5.hide();
550
+ } else {
551
+ return _this5.show();
552
+ }
553
+ };
554
+
555
+ this.updateTitleContent = function (title) {
556
+ return _this5._updateTitleContent(title);
557
+ };
558
+
559
+ this._events = [];
560
+
561
+ this._setTooltipNodeEvent = function (evt, reference, delay, options) {
562
+ var relatedreference = evt.relatedreference || evt.toElement || evt.relatedTarget;
563
+
564
+ var callback = function callback(evt2) {
565
+ var relatedreference2 = evt2.relatedreference || evt2.toElement || evt2.relatedTarget;
566
+
567
+ // Remove event listener after call
568
+ _this5._tooltipNode.removeEventListener(evt.type, callback);
569
+
570
+ // If the new reference is not the reference element
571
+ if (!reference.contains(relatedreference2)) {
572
+ // Schedule to hide tooltip
573
+ _this5._scheduleHide(reference, options.delay, options, evt2);
574
+ }
575
+ };
576
+
577
+ if (_this5._tooltipNode.contains(relatedreference)) {
578
+ // listen to mouseleave on the tooltip element to be able to hide the tooltip
579
+ _this5._tooltipNode.addEventListener(evt.type, callback);
580
+ return true;
581
+ }
582
+
583
+ return false;
584
+ };
585
+ };
586
+
587
+ return Tooltip;
588
+
589
+ })));
data/lib/tooltip_js.rb ADDED
@@ -0,0 +1,15 @@
1
+ # frozen_string_literal: true
2
+
3
+ require 'tooltip_js/version'
4
+
5
+ if defined?(::Rails)
6
+ require 'tooltip_js/engine'
7
+ else
8
+ gem_path = File.expand_path('..', File.dirname(__FILE__))
9
+ assets_path = File.join(gem_path, 'assets')
10
+ if defined?(::Sprockets)
11
+ Sprockets.append_path(File.join(assets_path, 'javascripts'))
12
+ elsif defined?(::Hanami)
13
+ Hanami::Assets.sources << assets_path
14
+ end
15
+ end
@@ -0,0 +1,9 @@
1
+ # frozen_string_literal: true
2
+
3
+ module TooltipJs
4
+ class Engine < ::Rails::Engine
5
+ initializer 'tooltip_js.assets' do |app|
6
+ app.config.assets.paths << root.join('assets', 'javascripts').to_s
7
+ end
8
+ end
9
+ end
@@ -0,0 +1,5 @@
1
+ # frozen_string_literal: true
2
+
3
+ module TooltipJs
4
+ VERSION = '1.3.1'
5
+ end
metadata ADDED
@@ -0,0 +1,106 @@
1
+ --- !ruby/object:Gem::Specification
2
+ name: tooltip_js
3
+ version: !ruby/object:Gem::Version
4
+ version: 1.3.1
5
+ platform: ruby
6
+ authors:
7
+ - Gleb Mazovetskiy
8
+ - Christoph Illnar
9
+ autorequire:
10
+ bindir: exe
11
+ cert_chain: []
12
+ date: 2018-11-13 00:00:00.000000000 Z
13
+ dependencies:
14
+ - !ruby/object:Gem::Dependency
15
+ name: bundler
16
+ requirement: !ruby/object:Gem::Requirement
17
+ requirements:
18
+ - - "~>"
19
+ - !ruby/object:Gem::Version
20
+ version: '1.15'
21
+ type: :development
22
+ prerelease: false
23
+ version_requirements: !ruby/object:Gem::Requirement
24
+ requirements:
25
+ - - "~>"
26
+ - !ruby/object:Gem::Version
27
+ version: '1.15'
28
+ - !ruby/object:Gem::Dependency
29
+ name: rake
30
+ requirement: !ruby/object:Gem::Requirement
31
+ requirements:
32
+ - - "~>"
33
+ - !ruby/object:Gem::Version
34
+ version: '10.0'
35
+ type: :development
36
+ prerelease: false
37
+ version_requirements: !ruby/object:Gem::Requirement
38
+ requirements:
39
+ - - "~>"
40
+ - !ruby/object:Gem::Version
41
+ version: '10.0'
42
+ - !ruby/object:Gem::Dependency
43
+ name: rspec
44
+ requirement: !ruby/object:Gem::Requirement
45
+ requirements:
46
+ - - "~>"
47
+ - !ruby/object:Gem::Version
48
+ version: '3.0'
49
+ type: :development
50
+ prerelease: false
51
+ version_requirements: !ruby/object:Gem::Requirement
52
+ requirements:
53
+ - - "~>"
54
+ - !ruby/object:Gem::Version
55
+ version: '3.0'
56
+ - !ruby/object:Gem::Dependency
57
+ name: rubocop
58
+ requirement: !ruby/object:Gem::Requirement
59
+ requirements:
60
+ - - ">="
61
+ - !ruby/object:Gem::Version
62
+ version: '0'
63
+ type: :development
64
+ prerelease: false
65
+ version_requirements: !ruby/object:Gem::Requirement
66
+ requirements:
67
+ - - ">="
68
+ - !ruby/object:Gem::Version
69
+ version: '0'
70
+ description: Works with Rails out of the box.
71
+ email:
72
+ - glex.spb@gmail.com
73
+ - illnar@communitor.com
74
+ executables: []
75
+ extensions: []
76
+ extra_rdoc_files: []
77
+ files:
78
+ - assets/javascripts/tooltip.js
79
+ - lib/tooltip_js.rb
80
+ - lib/tooltip_js/engine.rb
81
+ - lib/tooltip_js/version.rb
82
+ homepage: https://github.com/mrillo/tooltip_js-rubygem
83
+ licenses:
84
+ - MIT
85
+ metadata: {}
86
+ post_install_message:
87
+ rdoc_options: []
88
+ require_paths:
89
+ - lib
90
+ required_ruby_version: !ruby/object:Gem::Requirement
91
+ requirements:
92
+ - - ">="
93
+ - !ruby/object:Gem::Version
94
+ version: '0'
95
+ required_rubygems_version: !ruby/object:Gem::Requirement
96
+ requirements:
97
+ - - ">="
98
+ - !ruby/object:Gem::Version
99
+ version: '0'
100
+ requirements: []
101
+ rubyforge_project:
102
+ rubygems_version: 2.5.2.3
103
+ signing_key:
104
+ specification_version: 4
105
+ summary: Tooltip.js assets from Popper.js as a Ruby gem. https://popper.js.org/
106
+ test_files: []