Release v1.3.1

This commit adds tests to make sure that the browserify bundle will work in the dist file of clipboard.js

This commit adds the mocha and chai modules, since karma doesn't work well with node only tests.

Also splited tests tasks in package.json and updated .gitignore

.gitignore

@@ -1,2 +1,3 @@
+npm-debug.log
 bower_components
 node_modules

README.md

@@ -52,36 +52,36 @@ We're living a _declarative renaissance_, that's why we decided to take advantag
 
 ### Copy text from another element
 
-A pretty common use case is to copy content from another element. You can do that by adding a `data-target` attribute in your trigger element.
+A pretty common use case is to copy content from another element. You can do that by adding a `data-clipboard-target` attribute in your trigger element.
 
-The value you include on this attribute needs to match another's element `id` attribute.
+The value you include on this attribute needs to match another's element selector.
 
-<a href="http://zenorocha.github.io/clipboard.js/#demo-target"><img width="473" alt="example-2" src="https://cloud.githubusercontent.com/assets/398893/9983467/a4946aaa-5fb1-11e5-9780-f09fcd7ca6c8.png"></a>
+<a href="http://zenorocha.github.io/clipboard.js/#example-target"><img width="473" alt="example-2" src="https://cloud.githubusercontent.com/assets/398893/9983467/a4946aaa-5fb1-11e5-9780-f09fcd7ca6c8.png"></a>
 
 ```html
 <!-- Target -->
 <input id="foo" value="https://github.com/zenorocha/clipboard.js.git">
 
 <!-- Trigger -->
-<button class="btn" data-target="foo">
+<button class="btn" data-clipboard-target="#foo">
     <img src="assets/clippy.svg" alt="Copy to clipboard">
 </button>
 ```
 
 ### Cut text from another element
 
-Additionally, you can define a `data-action` attribute to specify if you want to either `copy` or `cut` content.
+Additionally, you can define a `data-clipboard-action` attribute to specify if you want to either `copy` or `cut` content.
 
 If you omit this attribute, `copy` will be used by default.
 
-<a href="http://zenorocha.github.io/clipboard.js/#demo-action"><img width="473" alt="example-3" src="https://cloud.githubusercontent.com/assets/398893/10000358/7df57b9c-6050-11e5-9cd1-fbc51d2fd0a7.png"></a>
+<a href="http://zenorocha.github.io/clipboard.js/#example-action"><img width="473" alt="example-3" src="https://cloud.githubusercontent.com/assets/398893/10000358/7df57b9c-6050-11e5-9cd1-fbc51d2fd0a7.png"></a>
 
 ```html
 <!-- Target -->
 <textarea id="bar">Mussum ipsum cacilds...</textarea>
 
 <!-- Trigger -->
-<button class="btn" data-action="cut" data-target="bar">
+<button class="btn" data-clipboard-action="cut" data-clipboard-target="#bar">
     Cut to clipboard
 </button>
 ```
@@ -90,17 +90,41 @@ As you may expect, the `cut` action only works on `<input>` or `<textarea>` elem
 
 ### Copy text from attribute
 
-Truth is, you don't even need another element to copy its content from. You can just include a `data-text` attribute in your trigger element.
+Truth is, you don't even need another element to copy its content from. You can just include a `data-clipboard-text` attribute in your trigger element.
 
-<a href="http://zenorocha.github.io/clipboard.js/#demo-text"><img width="147" alt="example-1" src="https://cloud.githubusercontent.com/assets/398893/10000347/6e16cf8c-6050-11e5-9883-1c5681f9ec45.png"></a>
+<a href="http://zenorocha.github.io/clipboard.js/#example-text"><img width="147" alt="example-1" src="https://cloud.githubusercontent.com/assets/398893/10000347/6e16cf8c-6050-11e5-9883-1c5681f9ec45.png"></a>
 
 ```html
 <!-- Trigger -->
-<button class="btn" data-text="Just because you can doesn't mean you should — clipboard.js">
+<button class="btn" data-clipboard-text="Just because you can doesn't mean you should — clipboard.js">
     Copy to clipboard
 </button>
 ```
 
+## Advanced Usage
+
+If you don't want to modify your HTML, there's a pretty handy imperative API for you to use. All you need to do is declare a function, do your thing, and return a value.
+
+For instance, if you want to dynamically set a `target`, you'll need to return a Node.
+
+```js
+new Clipboard('.btn', {
+    target: function(trigger) {
+        return trigger.nextElementSibling;
+    }
+});
+```
+
+If you want to dynamically set a `text`, you'll return a String.
+
+```js
+new Clipboard('.btn', {
+    text: function(trigger) {
+        return trigger.getAttribute('aria-label');
+    }
+});
+```
+
 ## Events
 
 There are cases where you'd like to show some user feedback or capture what has been selected after a copy/cut operation.

bower.json

@@ -1,6 +1,6 @@
 {
   "name": "clipboard",
-  "version": "1.0.0",
+  "version": "1.3.1",
   "description": "Modern copy to clipboard. No Flash. Just 2kb",
   "license": "MIT",
   "main": "src/clipboard.js",

dist/clipboard.js

@@ -0,0 +1,578 @@
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Clipboard = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+/**
+ * Module dependencies.
+ */
+
+var closest = require('closest')
+  , event = require('component-event');
+
+/**
+ * Delegate event `type` to `selector`
+ * and invoke `fn(e)`. A callback function
+ * is returned which may be passed to `.unbind()`.
+ *
+ * @param {Element} el
+ * @param {String} selector
+ * @param {String} type
+ * @param {Function} fn
+ * @param {Boolean} capture
+ * @return {Function}
+ * @api public
+ */
+
+// Some events don't bubble, so we want to bind to the capture phase instead
+// when delegating.
+var forceCaptureEvents = ['focus', 'blur'];
+
+exports.bind = function(el, selector, type, fn, capture){
+  if (forceCaptureEvents.indexOf(type) !== -1) capture = true;
+
+  return event.bind(el, type, function(e){
+    var target = e.target || e.srcElement;
+    e.delegateTarget = closest(target, selector, true, el);
+    if (e.delegateTarget) fn.call(el, e);
+  }, capture);
+};
+
+/**
+ * Unbind event `type`'s callback `fn`.
+ *
+ * @param {Element} el
+ * @param {String} type
+ * @param {Function} fn
+ * @param {Boolean} capture
+ * @api public
+ */
+
+exports.unbind = function(el, type, fn, capture){
+  if (forceCaptureEvents.indexOf(type) !== -1) capture = true;
+
+  event.unbind(el, type, fn, capture);
+};
+
+},{"closest":2,"component-event":4}],2:[function(require,module,exports){
+var matches = require('matches-selector')
+
+module.exports = function (element, selector, checkYoSelf) {
+  var parent = checkYoSelf ? element : element.parentNode
+
+  while (parent && parent !== document) {
+    if (matches(parent, selector)) return parent;
+    parent = parent.parentNode
+  }
+}
+
+},{"matches-selector":3}],3:[function(require,module,exports){
+
+/**
+ * Element prototype.
+ */
+
+var proto = Element.prototype;
+
+/**
+ * Vendor function.
+ */
+
+var vendor = proto.matchesSelector
+  || proto.webkitMatchesSelector
+  || proto.mozMatchesSelector
+  || proto.msMatchesSelector
+  || proto.oMatchesSelector;
+
+/**
+ * Expose `match()`.
+ */
+
+module.exports = match;
+
+/**
+ * Match `el` to `selector`.
+ *
+ * @param {Element} el
+ * @param {String} selector
+ * @return {Boolean}
+ * @api public
+ */
+
+function match(el, selector) {
+  if (vendor) return vendor.call(el, selector);
+  var nodes = el.parentNode.querySelectorAll(selector);
+  for (var i = 0; i < nodes.length; ++i) {
+    if (nodes[i] == el) return true;
+  }
+  return false;
+}
+},{}],4:[function(require,module,exports){
+var bind = window.addEventListener ? 'addEventListener' : 'attachEvent',
+    unbind = window.removeEventListener ? 'removeEventListener' : 'detachEvent',
+    prefix = bind !== 'addEventListener' ? 'on' : '';
+
+/**
+ * Bind `el` event `type` to `fn`.
+ *
+ * @param {Element} el
+ * @param {String} type
+ * @param {Function} fn
+ * @param {Boolean} capture
+ * @return {Function}
+ * @api public
+ */
+
+exports.bind = function(el, type, fn, capture){
+  el[bind](prefix + type, fn, capture || false);
+  return fn;
+};
+
+/**
+ * Unbind `el` event `type`'s callback `fn`.
+ *
+ * @param {Element} el
+ * @param {String} type
+ * @param {Function} fn
+ * @param {Boolean} capture
+ * @return {Function}
+ * @api public
+ */
+
+exports.unbind = function(el, type, fn, capture){
+  el[unbind](prefix + type, fn, capture || false);
+  return fn;
+};
+},{}],5:[function(require,module,exports){
+function E () {
+	// Keep this empty so it's easier to inherit from
+  // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
+}
+
+E.prototype = {
+	on: function (name, callback, ctx) {
+    var e = this.e || (this.e = {});
+    
+    (e[name] || (e[name] = [])).push({
+      fn: callback,
+      ctx: ctx
+    });
+    
+    return this;
+  },
+
+  once: function (name, callback, ctx) {
+    var self = this;
+    var fn = function () {
+      self.off(name, fn);
+      callback.apply(ctx, arguments);
+    };
+    
+    return this.on(name, fn, ctx);
+  },
+
+  emit: function (name) {
+    var data = [].slice.call(arguments, 1);
+    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+    var i = 0;
+    var len = evtArr.length;
+    
+    for (i; i < len; i++) {
+      evtArr[i].fn.apply(evtArr[i].ctx, data);
+    }
+    
+    return this;
+  },
+
+  off: function (name, callback) {
+    var e = this.e || (this.e = {});
+    var evts = e[name];
+    var liveEvents = [];
+    
+    if (evts && callback) {
+      for (var i = 0, len = evts.length; i < len; i++) {
+        if (evts[i].fn !== callback) liveEvents.push(evts[i]);
+      }
+    }
+    
+    // Remove event from queue to prevent memory leak
+    // Suggested by https://github.com/lazd
+    // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910
+
+    (liveEvents.length) 
+      ? e[name] = liveEvents
+      : delete e[name];
+    
+    return this;
+  }
+};
+
+module.exports = E;
+
+},{}],6:[function(require,module,exports){
+/**
+ * Inner class which performs selection from either `text` or `target`
+ * properties and then executes copy or cut operations.
+ */
+'use strict';
+
+exports.__esModule = true;
+
+var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+var ClipboardAction = (function () {
+    /**
+     * @param {Object} options
+     */
+
+    function ClipboardAction(options) {
+        _classCallCheck(this, ClipboardAction);
+
+        this.resolveOptions(options);
+        this.initSelection();
+    }
+
+    /**
+     * Defines base properties passed from constructor.
+     * @param {Object} options
+     */
+
+    ClipboardAction.prototype.resolveOptions = function resolveOptions() {
+        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+        this.action = options.action;
+        this.emitter = options.emitter;
+        this.target = options.target;
+        this.text = options.text;
+        this.trigger = options.trigger;
+
+        this.selectedText = '';
+    };
+
+    /**
+     * Decides which selection strategy is going to be applied based
+     * on the existence of `text` and `target` properties.
+     */
+
+    ClipboardAction.prototype.initSelection = function initSelection() {
+        if (this.text && this.target) {
+            throw new Error('Multiple attributes declared, use either "target" or "text"');
+        } else if (this.text) {
+            this.selectFake();
+        } else if (this.target) {
+            this.selectTarget();
+        } else {
+            throw new Error('Missing required attributes, use either "target" or "text"');
+        }
+    };
+
+    /**
+     * Creates a fake input element, sets its value from `text` property,
+     * and makes a selection on it.
+     */
+
+    ClipboardAction.prototype.selectFake = function selectFake() {
+        var _this = this;
+
+        this.removeFake();
+
+        this.fakeHandler = document.body.addEventListener('click', function () {
+            return _this.removeFake();
+        });
+
+        this.fakeElem = document.createElement('input');
+        this.fakeElem.style.position = 'absolute';
+        this.fakeElem.style.left = '-9999px';
+        this.fakeElem.setAttribute('readonly', '');
+        this.fakeElem.value = this.text;
+        this.selectedText = this.text;
+
+        document.body.appendChild(this.fakeElem);
+
+        this.fakeElem.select();
+        this.copyText();
+    };
+
+    /**
+     * Only removes the fake element after another click event, that way
+     * an user can hit `Ctrl+C` to copy because selection still exists.
+     */
+
+    ClipboardAction.prototype.removeFake = function removeFake() {
+        if (this.fakeHandler) {
+            document.body.removeEventListener('click');
+            this.fakeHandler = null;
+        }
+
+        if (this.fakeElem) {
+            document.body.removeChild(this.fakeElem);
+            this.fakeElem = null;
+        }
+    };
+
+    /**
+     * Selects the content from element passed on `target` property.
+     */
+
+    ClipboardAction.prototype.selectTarget = function selectTarget() {
+        if (this.target.nodeName === 'INPUT' || this.target.nodeName === 'TEXTAREA') {
+            this.target.select();
+            this.selectedText = this.target.value;
+        } else {
+            var range = document.createRange();
+            var selection = window.getSelection();
+
+            range.selectNodeContents(this.target);
+            selection.addRange(range);
+            this.selectedText = selection.toString();
+        }
+
+        this.copyText();
+    };
+
+    /**
+     * Executes the copy operation based on the current selection.
+     */
+
+    ClipboardAction.prototype.copyText = function copyText() {
+        var succeeded = undefined;
+
+        try {
+            succeeded = document.execCommand(this.action);
+        } catch (err) {
+            succeeded = false;
+        }
+
+        this.handleResult(succeeded);
+    };
+
+    /**
+     * Fires an event based on the copy operation result.
+     * @param {Boolean} succeeded
+     */
+
+    ClipboardAction.prototype.handleResult = function handleResult(succeeded) {
+        if (succeeded) {
+            this.emitter.emit('success', {
+                action: this.action,
+                text: this.selectedText,
+                trigger: this.trigger,
+                clearSelection: this.clearSelection.bind(this)
+            });
+        } else {
+            this.emitter.emit('error', {
+                action: this.action,
+                trigger: this.trigger,
+                clearSelection: this.clearSelection.bind(this)
+            });
+        }
+    };
+
+    /**
+     * Removes current selection and focus from `target` element.
+     */
+
+    ClipboardAction.prototype.clearSelection = function clearSelection() {
+        if (this.target) {
+            this.target.blur();
+        }
+
+        window.getSelection().removeAllRanges();
+    };
+
+    /**
+     * Sets the `action` to be performed which can be either 'copy' or 'cut'.
+     * @param {String} action
+     */
+
+    _createClass(ClipboardAction, [{
+        key: 'action',
+        set: function set() {
+            var action = arguments.length <= 0 || arguments[0] === undefined ? 'copy' : arguments[0];
+
+            this._action = action;
+
+            if (this._action !== 'copy' && this._action !== 'cut') {
+                throw new Error('Invalid "action" value, use either "copy" or "cut"');
+            }
+        },
+
+        /**
+         * Gets the `action` property.
+         * @return {String}
+         */
+        get: function get() {
+            return this._action;
+        }
+
+        /**
+         * Sets the `target` property using an element
+         * that will be have its content copied.
+         * @param {Element} target
+         */
+    }, {
+        key: 'target',
+        set: function set(target) {
+            if (target !== undefined) {
+                if (target && typeof target === 'object' && target.nodeType === 1) {
+                    this._target = target;
+                } else {
+                    throw new Error('Invalid "target" value, use a valid Element');
+                }
+            }
+        },
+
+        /**
+         * Gets the `target` property.
+         * @return {String|HTMLElement}
+         */
+        get: function get() {
+            return this._target;
+        }
+    }]);
+
+    return ClipboardAction;
+})();
+
+exports['default'] = ClipboardAction;
+module.exports = exports['default'];
+
+},{}],7:[function(require,module,exports){
+'use strict';
+
+exports.__esModule = true;
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var _clipboardAction = require('./clipboard-action');
+
+var _clipboardAction2 = _interopRequireDefault(_clipboardAction);
+
+var _delegateEvents = require('delegate-events');
+
+var _delegateEvents2 = _interopRequireDefault(_delegateEvents);
+
+var _tinyEmitter = require('tiny-emitter');
+
+var _tinyEmitter2 = _interopRequireDefault(_tinyEmitter);
+
+var prefix = 'data-clipboard-';
+
+/**
+ * Base class which takes a selector, delegates a click event to it,
+ * and instantiates a new `ClipboardAction` on each click.
+ */
+
+var Clipboard = (function (_Emitter) {
+    _inherits(Clipboard, _Emitter);
+
+    /**
+     * @param {String} selector
+     * @param {Object} options
+     */
+
+    function Clipboard(selector, options) {
+        _classCallCheck(this, Clipboard);
+
+        _Emitter.call(this);
+
+        this.resolveOptions(options);
+        this.delegateClick(selector);
+    }
+
+    /**
+     * Defines if attributes would be resolved using internal setter functions
+     * or custom functions that were passed in the constructor.
+     * @param {Object} options
+     */
+
+    Clipboard.prototype.resolveOptions = function resolveOptions() {
+        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+        this.action = typeof options.action === 'function' ? options.action : this.setAction;
+        this.target = typeof options.target === 'function' ? options.target : this.setTarget;
+        this.text = typeof options.text === 'function' ? options.text : this.setText;
+    };
+
+    /**
+     * Delegates a click event on the passed selector.
+     * @param {String} selector
+     */
+
+    Clipboard.prototype.delegateClick = function delegateClick(selector) {
+        var _this = this;
+
+        _delegateEvents2['default'].bind(document.body, selector, 'click', function (e) {
+            return _this.initialize(e);
+        });
+    };
+
+    /**
+     * Defines a new `ClipboardAction` on each click event.
+     * @param {Event} e
+     */
+
+    Clipboard.prototype.initialize = function initialize(e) {
+        if (this.clipboardAction) {
+            this.clipboardAction = null;
+        }
+
+        this.clipboardAction = new _clipboardAction2['default']({
+            action: this.action(e.delegateTarget),
+            target: this.target(e.delegateTarget),
+            text: this.text(e.delegateTarget),
+            trigger: e.delegateTarget,
+            emitter: this
+        });
+    };
+
+    /**
+     * Sets the `action` lookup function.
+     * @param {Element} trigger
+     */
+
+    Clipboard.prototype.setAction = function setAction(trigger) {
+        if (!trigger.hasAttribute(prefix + 'action')) {
+            return;
+        }
+
+        return trigger.getAttribute(prefix + 'action');
+    };
+
+    /**
+     * Sets the `target` lookup function.
+     * @param {Element} trigger
+     */
+
+    Clipboard.prototype.setTarget = function setTarget(trigger) {
+        if (!trigger.hasAttribute(prefix + 'target')) {
+            return;
+        }
+
+        var target = trigger.getAttribute(prefix + 'target');
+        return document.querySelector(target);
+    };
+
+    /**
+     * Sets the `text` lookup function.
+     * @param {Element} trigger
+     */
+
+    Clipboard.prototype.setText = function setText(trigger) {
+        if (!trigger.hasAttribute(prefix + 'text')) {
+            return;
+        }
+
+        return trigger.getAttribute(prefix + 'text');
+    };
+
+    return Clipboard;
+})(_tinyEmitter2['default']);
+
+exports['default'] = Clipboard;
+module.exports = exports['default'];
+
+},{"./clipboard-action":6,"delegate-events":1,"tiny-emitter":5}]},{},[7])(7)
+});

karma.conf.js

@@ -10,6 +10,8 @@ module.exports = function(karma) {
             './node_modules/phantomjs-polyfill/bind-polyfill.js'
         ],
 
+        exclude: ['test/module-systems.js'],
+
         preprocessors: {
             'src/**/*.js' : ['browserify'],
             'test/**/*.js': ['browserify']

package.json

@@ -1,9 +1,15 @@
 {
   "name": "clipboard",
-  "version": "1.0.0",
+  "version": "1.3.1",
   "description": "Modern copy to clipboard. No Flash. Just 2kb",
   "repository": "zenorocha/clipboard.js",
-  "main": "src/clipboard.js",
+  "main": "dist/clipboard.js",
+  "browser": "src/clipboard.js",
+  "browserify": {
+    "transform": [
+      ["babelify", { "loose": "all" }]
+    ]
+  },
   "license": "MIT",
   "keywords": [
     "clipboard",
@@ -23,13 +29,16 @@
     "karma-mocha": "^0.2.0",
     "karma-phantomjs-launcher": "^0.2.1",
     "karma-sinon": "^1.0.4",
+    "mocha": "^2.3.3",
     "phantomjs-polyfill": "0.0.1",
     "uglify": "^0.1.5"
   },
   "scripts": {
-    "publish": "npm run build && npm run minify",
-    "build": "browserify src/clipboard.js -t [babelify --loose all] -o dist/clipboard.min.js",
-    "minify": "uglify -s dist/clipboard.min.js -o dist/clipboard.min.js",
-    "test": "karma start --single-run"
+    "build": "npm run build-debug && npm run build-min",
+    "build-debug": "browserify src/clipboard.js -s Clipboard -o dist/clipboard.js",
+    "build-min": "uglify -s dist/clipboard.js -o dist/clipboard.min.js",
+    "test": "npm run test-browser && npm run test-server",
+    "test-browser": "karma start --single-run",
+    "test-server": "mocha test/module-systems.js"
   }
 }

src/clipboard-action.js

@@ -1,12 +1,21 @@
 /**
- * Inner class which performs selection and copy operations.
+ * Inner class which performs selection from either `text` or `target`
+ * properties and then executes copy or cut operations.
  */
 class ClipboardAction {
     /**
-     * Initializes selection from either `text` or `target` property.
      * @param {Object} options
      */
     constructor(options) {
+        this.resolveOptions(options);
+        this.initSelection();
+    }
+
+    /**
+     * Defines base properties passed from constructor.
+     * @param {Object} options
+     */
+    resolveOptions(options = {}) {
         this.action  = options.action;
         this.emitter = options.emitter;
         this.target  = options.target;
@@ -14,9 +23,15 @@ class ClipboardAction {
         this.trigger = options.trigger;
 
         this.selectedText = '';
+    }
 
+    /**
+     * Decides which selection strategy is going to be applied based
+     * on the existence of `text` and `target` properties.
+     */
+    initSelection() {
         if (this.text && this.target) {
-            throw new Error('Multiple attributes declared, use either "data-target" or "data-text"');
+            throw new Error('Multiple attributes declared, use either "target" or "text"');
         }
         else if (this.text) {
             this.selectFake();
@@ -25,7 +40,7 @@ class ClipboardAction {
             this.selectTarget();
         }
         else {
-            throw new Error('Missing required attributes, use either "data-target" or "data-text"');
+            throw new Error('Missing required attributes, use either "target" or "text"');
         }
     }
 
@@ -140,11 +155,11 @@ class ClipboardAction {
      * Sets the `action` to be performed which can be either 'copy' or 'cut'.
      * @param {String} action
      */
-    set action(action) {
-        this._action = action || 'copy';
+    set action(action = 'copy') {
+        this._action = action;
 
         if (this._action !== 'copy' && this._action !== 'cut') {
-            throw new Error('Invalid "data-action" value, use either "copy" or "cut"');
+            throw new Error('Invalid "action" value, use either "copy" or "cut"');
         }
     }
 
@@ -157,16 +172,17 @@ class ClipboardAction {
     }
 
     /**
-     * Sets the `target` property using the ID of an element
+     * Sets the `target` property using an element
      * that will be have its content copied.
-     * @param {String} target
+     * @param {Element} target
      */
     set target(target) {
-        if (target) {
-            this._target = document.getElementById(target);
-
-            if (!this._target) {
-                throw new Error('Invalid "data-target" selector, use a value that matches an ID');
+        if (target !== undefined) {
+            if (target && typeof target === 'object' && target.nodeType === 1) {
+                this._target = target;
+            }
+            else {
+                throw new Error('Invalid "target" value, use a valid Element');
             }
         }
     }

src/clipboard.js

@@ -2,22 +2,40 @@ import ClipboardAction from './clipboard-action';
 import Delegate from 'delegate-events';
 import Emitter from 'tiny-emitter';
 
+const prefix = 'data-clipboard-';
+
 /**
  * Base class which takes a selector, delegates a click event to it,
  * and instantiates a new `ClipboardAction` on each click.
  */
 class Clipboard extends Emitter {
+    /**
+     * @param {String} selector
+     * @param {Object} options
+     */
+    constructor(selector, options) {
+        super();
+
+        this.resolveOptions(options);
+        this.delegateClick(selector);
+    }
+
+    /**
+     * Defines if attributes would be resolved using internal setter functions
+     * or custom functions that were passed in the constructor.
+     * @param {Object} options
+     */
+    resolveOptions(options = {}) {
+        this.action = (typeof options.action === 'function') ? options.action : this.setAction;
+        this.target = (typeof options.target === 'function') ? options.target : this.setTarget;
+        this.text   = (typeof options.text   === 'function') ? options.text   : this.setText;
+    }
+
     /**
      * Delegates a click event on the passed selector.
      * @param {String} selector
      */
-    constructor(selector) {
-        super();
-
-        if (!document.querySelectorAll(selector).length) {
-            throw new Error('No matches were found for the provided selector');
-        }
-
+    delegateClick(selector) {
         Delegate.bind(document.body, selector, 'click', (e) => this.initialize(e));
     }
 
@@ -31,15 +49,50 @@ class Clipboard extends Emitter {
         }
 
         this.clipboardAction = new ClipboardAction({
-            action  : e.delegateTarget.getAttribute('data-action'),
-            target  : e.delegateTarget.getAttribute('data-target'),
-            text    : e.delegateTarget.getAttribute('data-text'),
+            action  : this.action(e.delegateTarget),
+            target  : this.target(e.delegateTarget),
+            text    : this.text(e.delegateTarget),
             trigger : e.delegateTarget,
             emitter : this
         });
     }
+
+    /**
+     * Sets the `action` lookup function.
+     * @param {Element} trigger
+     */
+    setAction(trigger) {
+        if (!trigger.hasAttribute(prefix + 'action')) {
+            return;
+        }
+
+        return trigger.getAttribute(prefix + 'action');
+    }
+
+    /**
+     * Sets the `target` lookup function.
+     * @param {Element} trigger
+     */
+    setTarget(trigger) {
+        if (!trigger.hasAttribute(prefix + 'target')) {
+            return;
+        }
+
+        let target = trigger.getAttribute(prefix + 'target');
+        return document.querySelector(target);
+    }
+
+    /**
+     * Sets the `text` lookup function.
+     * @param {Element} trigger
+     */
+    setText(trigger) {
+        if (!trigger.hasAttribute(prefix + 'text')) {
+            return;
+        }
+
+        return trigger.getAttribute(prefix + 'text');
+    }
 }
 
 export default Clipboard;
-
-global.Clipboard = Clipboard;

test/clipboard-action.js

@@ -19,35 +19,49 @@ describe('ClipboardAction', () => {
         document.body.innerHTML = '';
     });
 
-    describe('#constructor', () => {
-        it('should throw an error since both "data-text" and "data-target" were passed', done => {
+    describe('#resolveOptions', () => {
+        it('should set base properties', () => {
+            let clip = new ClipboardAction({
+                emitter: new Emitter(),
+                text: 'foo'
+            });
+
+            assert.property(clip, 'action');
+            assert.property(clip, 'emitter');
+            assert.property(clip, 'target');
+            assert.property(clip, 'text');
+            assert.property(clip, 'trigger');
+            assert.property(clip, 'selectedText');
+        });
+    });
+
+    describe('#initSelection', () => {
+        it('should throw an error since both "text" and "target" were passed', done => {
             try {
                 new ClipboardAction({
                     text: 'foo',
-                    target: 'input'
+                    target: document.querySelector('#input')
                 });
             }
             catch(e) {
-                assert.equal(e.message, 'Multiple attributes declared, use either "data-target" or "data-text"');
+                assert.equal(e.message, 'Multiple attributes declared, use either "target" or "text"');
                 done();
             }
         });
 
-        it('should throw an error since neither "data-text" nor "data-target" were passed', done => {
+        it('should throw an error since neither "text" nor "target" were passed', done => {
             try {
-                new ClipboardAction({
-                    action: ''
-                });
+                new ClipboardAction();
             }
             catch(e) {
-                assert.equal(e.message, 'Missing required attributes, use either "data-target" or "data-text"');
+                assert.equal(e.message, 'Missing required attributes, use either "target" or "text"');
                 done();
             }
         });
     });
 
     describe('#set action', () => {
-        it('should throw an error since "data-action" is invalid', done => {
+        it('should throw an error since "action" is invalid', done => {
             try {
                 new ClipboardAction({
                     text: 'foo',
@@ -55,21 +69,21 @@ describe('ClipboardAction', () => {
                 });
             }
             catch(e) {
-                assert.equal(e.message, 'Invalid "data-action" value, use either "copy" or "cut"');
+                assert.equal(e.message, 'Invalid "action" value, use either "copy" or "cut"');
                 done();
             }
         });
     });
 
     describe('#set target', () => {
-        it('should throw an error since "data-target" do not match any element', done => {
+        it('should throw an error since "target" do not match any element', done => {
             try {
                 new ClipboardAction({
-                    target: 'foo'
+                    target: document.querySelector('#foo')
                 });
             }
             catch(e) {
-                assert.equal(e.message, 'Invalid "data-target" selector, use a value that matches an ID');
+                assert.equal(e.message, 'Invalid "target" value, use a valid Element');
                 done();
             }
         });
@@ -103,7 +117,7 @@ describe('ClipboardAction', () => {
         it('should select text from editable element', () => {
             let clip = new ClipboardAction({
                 emitter: new Emitter(),
-                target: 'input'
+                target: document.querySelector('#input')
             });
 
             assert.equal(clip.selectedText, clip.target.value);
@@ -112,7 +126,7 @@ describe('ClipboardAction', () => {
         it('should select text from non-editable element', () => {
             let clip = new ClipboardAction({
                 emitter: new Emitter(),
-                target: 'paragraph'
+                target: document.querySelector('#paragraph')
             });
 
             assert.equal(clip.selectedText, clip.target.textContent);
@@ -139,7 +153,7 @@ describe('ClipboardAction', () => {
 
             let clip = new ClipboardAction({
                 emitter: emitter,
-                target: 'input'
+                target: document.querySelector('#input')
             });
         });
 
@@ -154,7 +168,7 @@ describe('ClipboardAction', () => {
 
             let clip = new ClipboardAction({
                 emitter: emitter,
-                target: 'input'
+                target: document.querySelector('#input')
             });
         });
     });
@@ -163,7 +177,7 @@ describe('ClipboardAction', () => {
         it('should fire a success event with certain properties', done => {
             let clip = new ClipboardAction({
                 emitter: new Emitter(),
-                target: 'input'
+                target: document.querySelector('#input')
             });
 
             clip.emitter.on('success', (e) => {
@@ -181,7 +195,7 @@ describe('ClipboardAction', () => {
         it('should fire a error event with certain properties', done => {
             let clip = new ClipboardAction({
                 emitter: new Emitter(),
-                target: 'input'
+                target: document.querySelector('#input')
             });
 
             clip.emitter.on('error', (e) => {
@@ -200,7 +214,7 @@ describe('ClipboardAction', () => {
         it('should remove focus from target and text selection', () => {
             let clip = new ClipboardAction({
                 emitter: new Emitter(),
-                target: 'input'
+                target: document.querySelector('#input')
             });
 
             clip.clearSelection();

test/clipboard.js

@@ -1,50 +1,95 @@
 import Clipboard from '../src/clipboard';
 import ClipboardAction from '../src/clipboard-action';
+import Delegate from 'delegate-events';
 
 describe('Clipboard', () => {
-    describe('#constructor', () => {
-        it('should throw an error since there was no arguments passed', done => {
-            try {
-                new Clipboard();
-            }
-            catch(e) {
-                assert.equal(e.message, 'No matches were found for the provided selector');
-                done();
-            }
+    before(() => {
+        global.button = document.createElement('button');
+        global.button.setAttribute('class', 'btn');
+        global.button.setAttribute('data-clipboard-text', 'foo');
+        document.body.appendChild(global.button);
+
+        global.event = {
+            delegateTarget: global.button
+        };
+    });
+
+    after(() => {
+        document.body.innerHTML = '';
+    });
+
+    describe('#resolveOptions', function() {
+        before(() => {
+            global.fn = function() {};
         });
 
-        it('should throw an error since an empty selector has been passed', done => {
-            try {
-                new Clipboard('#abc');
-            }
-            catch(e) {
-                assert.equal(e.message, 'No matches were found for the provided selector');
-                done();
-            }
+        it('should set action as a function', () => {
+            let clipboard = new Clipboard('.btn', {
+                action: global.fn
+            });
+
+            assert.equal(global.fn, clipboard.action);
+        });
+
+        it('should set target as a function', () => {
+            let clipboard = new Clipboard('.btn', {
+                target: global.fn
+            });
+
+            assert.equal(global.fn, clipboard.target);
+        });
+
+        it('should set text as a function', () => {
+            let clipboard = new Clipboard('.btn', {
+                text: global.fn
+            });
+
+            assert.equal(global.fn, clipboard.text);
+        });
+    });
+
+    describe('#delegateClick', function() {
+        before(() => {
+            global.spy = sinon.spy(Delegate, 'bind');
+        });
+
+        after(() => {
+            global.spy.restore();
+        });
+
+        it('should delegate a click event to the passed selector', () => {
+            let element = document.body;
+            let selector = '.btn'
+            let event = 'click';
+
+            let clipboard = new Clipboard(selector);
+
+            assert.ok(global.spy.calledOnce);
+            assert.ok(global.spy.calledWith(element, selector, event));
         });
     });
 
     describe('#initialize', () => {
-        before(() => {
-            global.button = document.createElement('button');
-            global.button.setAttribute('class', 'btn');
-            global.button.setAttribute('data-text', 'foo');
-            document.body.appendChild(global.button);
-
-            global.event = {
-                delegateTarget: global.button
-            };
-        });
-
-        after(() => {
-            document.body.innerHTML = '';
-        });
-
         it('should create a new instance of ClipboardAction', () => {
             let clipboard = new Clipboard('.btn');
 
             clipboard.initialize(global.event);
             assert.instanceOf(clipboard.clipboardAction, ClipboardAction);
         });
+
+        it('should throws exception target', done => {
+            try {
+                var clipboard = new Clipboard('.btn', {
+                    target: function() {
+                        return null;
+                    }
+                });
+                clipboard.initialize(global.event);
+            }
+            catch(e) {
+                assert.equal(e.message, 'Invalid "target" value, use a valid Element');
+                done();
+            }
+        });
     });
 });

test/module-systems.js

@@ -0,0 +1,15 @@
+var assert = require('chai').assert;
+var browserify = require('browserify');
+
+describe('CommonJS', function() {
+    it('should import the lib in a commonjs env without babel', function(done) {
+        browserify('./dist/clipboard.js').bundle(function(err) {
+            assert.equal(err, null);
+            done();
+        });
+    });
+});
+
+describe('AMD', function() {
+    // TODO: Write test case
+});