countable-rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 466203ca5ba87067c5ba7d0657f90f955f6a2408
+  data.tar.gz: 5bfa6acafd0afd2656d5723a471ef35b01b8e582
+SHA512:
+  metadata.gz: fccc6811184777f0c22a437a62b96d0ef9f5ffef3130d51cb7581816d67950c2121be5d3c1c8ab9eb261e40f14835134e36808940dc2a46ab364f0b143324faf
+  data.tar.gz: a86acde04a373572d1e7830b5b5499304a4102f27a8627ef045e2512a4a830b27b9b31b68fa6d76a20b12bed53ee91cc9c394a5d23e865d389066cf44591a6d1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,33 @@
+source 'https://rubygems.org'
+
+gem 'rails', '3.2.8'
+
+# Bundle edge Rails instead:
+# gem 'rails', :git => 'git://github.com/rails/rails.git'
+
+gem 'sqlite3'
+
+
+# Gems used only for assets and not required
+# in production environments by default.
+group :assets do
+  gem 'sass-rails',   '~> 3.2.3'
+  gem 'coffee-rails', '~> 3.2.1'
+
+  # See https://github.com/sstephenson/execjs#readme for more supported runtimes
+  # gem 'therubyracer', :platforms => :ruby
+
+  gem 'uglifier', '>= 1.0.3'
+
+  gem 'jquery-ui-rails'
+end
+
+gem 'jquery-rails'
+
+# Specify your gem's dependencies in jquery-modal-rails.gemspec
+gemspec
+
+# add rspec
+gem 'rspec'
+gem 'rspec-rails'
+gem 'shoulda', :require => false

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Kyle Szives
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,130 @@
+# Countable
+
+Countable Rails is a Rails wrapper for the javascript plugin Coutnable by [Sacha Schmid](http://sachaschmid.ch) ([**@sachaschmid**](https://twitter.com/sachaschmid))
+
+Countable is a JavaScript function to add **live paragraph-, word- and character-counting** to an HTML element. Countable is a *zero-dependency* library and comes in at **1KB** when minified and gzipped.
+
+[**View the Demo**](http://radlikewhoa.github.io/Countable#demo)
+
+[**View the Original**](https://github.com/RadLikeWhoa/Countable)
+
+## Installation
+
+```
+gem install 'countable-rails'
+```
+
+or 
+
+```
+gem 'countable-rails'
+```
+
+## Usage
+
+Countable is available as a Node / CommonJS module, an AMD module and as a global. All methods are accessed on the Countable object directly.
+
+### Callbacks
+
+The `live` and `once` method both accept a callback. The given callback is then called whenever needed with a single parameter that carries all the releavant data. `this` is bound to the current element. Take the following code for an example.
+
+```javascript
+var area = document.getElementById('text')
+
+Countable.once(area, function (counter) {
+  console.log(this, counter)
+})
+```
+
+```
+=> <textarea id="text"></textarea>, { all: 0, characters: 0, paragraphs: 0, words: 0 }
+```
+
+Property   | Meaning
+---------- | --------------------------------------------------------------------------------------------
+paragraphs | The number of paragraphs. Paragraphs can be separated by either a soft or a hard (two line breaks) return. To use hard returns, set the corresponding option (`hardReturns`).
+words      | The number of words. Words are split using spaces.
+characters | The number of characters (without spaces). This contains all non-whitespace characters.
+all        | The number of characters including whitespace. This is the total number of all characters in the element.
+
+### Countable#live(elements, callback, options)
+
+Bind the callback to all given elements. The callback gets called everytime the element's value or text is changed.
+
+```javascript
+Countable.live(area, function (counter) {
+  console.log(counter)
+})
+```
+
+### Countable#die(elements)
+
+Remove the bound callback from all given elements.
+
+```javascript
+Countable.die(area)
+```
+
+### Countable#once(elements, callback, options)
+
+Similar to `Countable.live()`, but the callback is only executed once, there are no events bound.
+
+```javascript
+Countable.once(area, function (counter) {
+  console.log(counter)
+})
+```
+
+### Countable#enabled(element)
+
+Checks the live-counting functionality is bound to the given.
+
+```javascript
+Countable.enabled(area)
+```
+
+### Options
+
+`Countable.live()` and `Countable.once()` both accept a third argument, an options object that allows you to change how Countable treats certain aspects of your element's text.
+
+```javascript
+{
+  hardReturns: false,
+  stripTags: false
+}
+```
+
+By default, paragraphs are split by a single return (a soft return). By setting `hardReturns` to true, Countable splits paragraphs after two returns.
+
+Depending on your application and audience, you might need to strip HTML tags from the text before counting it. You can do this by setting `stripTags` to true.
+
+## Browser Support
+
+Countable supports all modern browsers. Internet Explorer is supported down to version 7. Note that some browsers don't implement the `oninput` event consistently so there might be differences in the way Countable works in different browsers.
+
+## Upgrading from version 1.x.x
+
+Upgrading from version 1.x.x is easy. Most likely, you've used something like the following:
+
+```javascript
+var area = document.getElementById('area')
+
+new Countable(area, function (counter) {
+  console.log(counter)
+}, { stripTags: true })
+```
+
+The new syntax offers more functions as described above, but to keep the live-counting functionality, you just write this:
+
+```javascript
+var area = document.getElementById('area')
+
+Countable.live(area, function (counter) {
+  console.log(counter)
+}, { stripTags: true })
+```
+
+* The callback parameter is no longer optional
+* `options.once` has been replaced with `Countable.once()`
+* `Countable.live()` and `Countable.once()` both accept one or more elements, rather than just a single one
+* Inside the callback, `this` is now bound to the current element

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/countable-rails.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'countable/rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "countable-rails"
+  spec.version       = Countable::Rails::VERSION
+  spec.authors       = ["Kyle Szives"]
+  spec.email         = ["kjszives@gmail.com"]
+  spec.summary          = "Countable is a script to allow for live paragraph-, word- and character- counting on an HTML element."
+  spec.description      = "Countable is a script to allow for live paragraph-, word- and character- counting on an HTML element based on http://radlikewhoa.github.io/Countable."
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "railties", ">= 3.1"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/countable/rails/version.rb

@@ -0,0 +1,6 @@
+module Countable
+  module Rails
+    VERSION = "0.0.1"
+    COUNTABLE_VERSION = "2.0.1"
+  end
+end

data/lib/countable/rails.rb

@@ -0,0 +1,8 @@
+require "countable/rails/version"
+
+module Countable
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/vendor/assets/javascripts/countable.js

@@ -0,0 +1,377 @@
+/**
+ * Countable is a script to allow for live paragraph-, word- and character-
+ * counting on an HTML element.
+ *
+ * @author   Sacha Schmid (<https://github.com/RadLikeWhoa>)
+ * @version  2.0.1
+ * @license  MIT
+ * @see      <http://radlikewhoa.github.io/Countable/>
+ */
+
+/**
+ * Note: For the purpose of this internal documentation, arguments of the type
+ * {Nodes} are to be interpreted as either {NodeList} or {Element}.
+ */
+
+;(function (global) {
+  'use strict'
+
+  /**
+   * @private
+   *
+   * `_liveElements` holds all elements that have the live-counting
+   * functionality bound to them.
+   *
+   * `_event` holds the event to handle the live counting, based on the
+   * browser's capabilities.
+   */
+
+  var _liveElements = [],
+      _event = 'oninput' in document ? 'input' : 'keyup'
+
+  /**
+   * `String.trim()` polyfill for non-supporting browsers. This is the
+   * recommended polyfill on MDN.
+   *
+   * @see     <http://goo.gl/uYveB>
+   * @see     <http://goo.gl/xjIxJ>
+   *
+   * @return  {String}  The original string with leading and trailing whitespace
+   *                    removed.
+   */
+
+  if (!String.prototype.trim) {
+    String.prototype.trim = function () {
+      return this.replace(/^\s+|\s+$/g, '')
+    }
+  }
+
+  /**
+   * `ucs2decode` function from the punycode.js library.
+   *
+   * Creates an array containing the decimal code points of each Unicode
+   * character in the string. While JavaScript uses UCS-2 internally, this
+   * function will convert a pair of surrogate halves (each of which UCS-2
+   * exposes as separate characters) into a single code point, matching
+   * UTF-16.
+   *
+   * @see     <http://goo.gl/8M09r>
+   * @see     <http://goo.gl/u4UUC>
+   *
+   * @param   {String}  string   The Unicode input string (UCS-2).
+   *
+   * @return  {Array}   The new array of code points.
+   */
+
+  function _decode (string) {
+    var output = [],
+        counter = 0,
+        length = string.length,
+        value, extra
+
+    while (counter < length) {
+      value = string.charCodeAt(counter++)
+
+      if ((value & 0xF800) == 0xD800 && counter < length) {
+
+        // High surrogate, and there is a next character.
+
+        extra = string.charCodeAt(counter++)
+
+        if ((extra & 0xFC00) == 0xDC00) {
+
+          // Low surrogate.
+
+          output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000)
+        } else {
+          output.push(value, extra)
+        }
+      } else {
+        output.push(value)
+      }
+    }
+
+    return output
+  }
+
+  /**
+   * `_validateArguments` validates the arguments given to each function call.
+   * Errors are logged to the console as warnings, but Countable fails silently.
+   *
+   * @private
+   *
+   * @param   {Nodes}     elements  The (collection of) element(s) to
+   *                                validate.
+   *
+   * @param   {Function}  callback  The callback function to validate.
+   *
+   * @return  {Boolean}   Returns whether all arguments are vaild.
+   */
+
+  function _validateArguments (elements, callback) {
+    var elementsValid = elements && ((Object.prototype.toString.call(elements) === '[object NodeList]' && elements.length) || (elements.nodeType === 1)),
+        callbackValid = callback && typeof callback === 'function'
+
+    if ('console' in window && 'warn' in console) {
+      if (!elementsValid) console.warn('Countable: No valid elements were found')
+      if (!callbackValid) console.warn('Countable: "' + callback + '" is not a valid callback function')
+    }
+
+    return elementsValid && callbackValid
+  }
+
+  /**
+   * `_extendDefaults` is a function to extend a set of default options with the
+   * ones given in the function call. Available options are described below.
+   *
+   * {Boolean}  hardReturns  Use two returns to seperate a paragraph instead of
+   *                         one.
+   * {Boolean}  stripTags    Strip HTML tags before counting the values.
+   *
+   * @private
+   *
+   * @param   {Object}  options  Countable allows the options described above.
+   *                             They can be used in a function call to override
+   *                             the default behaviour.
+   *
+   * @return  {Object}  The new options object.
+   */
+
+  function _extendDefaults (options) {
+    var defaults = { hardReturns: false, stripTags: false }
+
+    for (var prop in options) {
+      if (defaults.hasOwnProperty(prop)) defaults[prop] = options[prop]
+    }
+
+    return defaults
+  }
+
+  /**
+   * `_count` trims an element's value, optionally strips HTML tags and counts
+   * paragraphs, words, characters and characters plus spaces.
+   *
+   * @private
+   *
+   * @param   {Element}  element  The element whose value is to be counted.
+   *
+   * @param   {Object}   options  The options to use for the counting.
+   *
+   * @return  {Object}   The object containing the number of paragraphs,
+   *                     words, characters and characters plus spaces.
+   */
+
+  function _count (element, options) {
+    var original = 'value' in element ? element.value : element.innerText || element.textContent,
+        trimmed
+
+    /**
+     * The initial implementation to allow for HTML tags stripping was created
+     * @craniumslows while the current one was created by @Rob--W.
+     *
+     * @see <http://goo.gl/Exmlr>
+     * @see <http://goo.gl/gFQQh>
+     */
+
+    if (options.stripTags) original = original.replace(/<\/?[a-z][^>]*>/gi, '')
+
+    trimmed = original.trim()
+
+    /**
+     * Most of the performance improvements are based on the works of @epmatsw.
+     *
+     * @see <http://goo.gl/SWOLB>
+     */
+
+    return {
+      paragraphs: trimmed ? (trimmed.match(options.hardReturns ? /\n{2,}/g : /\n+/g) || []).length + 1 : 0,
+      words: trimmed ? (trimmed.replace(/['";:,.?¿\-!¡]+/g, '').match(/\S+/g) || []).length : 0,
+      characters: trimmed ? _decode(trimmed.replace(/\s/g, '')).length : 0,
+      all: _decode(original.replace(/[\n\r]/g, '')).length
+    }
+  }
+
+  /**
+   * `_loop` is a helper function to iterate over a collection, e.g. a NodeList
+   * or an Array. The callback receives the current element as the single
+   * parameter.
+   *
+   * @private
+   *
+   * @param  {Array}     which     The collection to iterate over.
+   *
+   * @param  {Function}  callback  The callback function to call on each
+   *                               iteration.
+   */
+
+  function _loop (which, callback) {
+    var len = which.length
+
+    if (typeof len !== 'undefined') {
+      while (len--) {
+        callback(which[len])
+      }
+    } else {
+      callback(which)
+    }
+  }
+
+  /**
+   * This is the main object that will later be exposed to other scripts. It
+   * holds all the public methods that can be used to enable the Countable
+   * functionality.
+   */
+
+  var Countable = {
+
+    /**
+     * The `live` method binds the counting handler to all given elements. The
+     * event is either `oninput` or `onkeydown`, based on the capabilities of
+     * the browser.
+     *
+     * @param   {Nodes}     elements   All elements that should receive the
+     *                                 Countable functionality.
+     *
+     * @param   {Function}  callback   The callback to fire whenever the
+     *                                 element's value changes. The callback is
+     *                                 called with the relevant element bound to
+     *                                 `this` and the counted values as the
+     *                                 single parameter.
+     *
+     * @param   {Object}    [options]  An object to modify Countable's
+     *                                 behaviour. Refer to `_extendDefaults` for
+     *                                 a list of available options.
+     *
+     * @return  {Object}    Returns the Countable object to allow for chaining.
+     */
+
+    live: function (elements, callback, options) {
+      var ops = _extendDefaults(options),
+          bind = function (element) {
+            var handler = function () {
+                  callback.call(element, _count(element, ops))
+                }
+
+            _liveElements.push({ element: element, handler: handler })
+
+            handler()
+
+            if (element.addEventListener) {
+              element.addEventListener(_event, handler, false)
+            } else if (element.attachEvent) {
+              element.attachEvent('on' + _event, handler)
+            }
+          }
+
+      if (!_validateArguments(elements, callback)) return
+
+      if (elements.length) {
+        _loop(elements, bind)
+      } else {
+        bind(elements)
+      }
+
+      return this
+    },
+
+    /**
+     * The `die` method removes the Countable functionality from all given
+     * elements.
+     *
+     * @param   {Nodes}  elements  All elements whose Countable functionality
+     *                             should be unbound.
+     *
+     * @return  {Object}  Returns the Countable object to allow for chaining.
+     */
+
+    die: function (elements) {
+      if (!_validateArguments(elements, function () {})) return
+
+      _loop(elements, function (element) {
+        var liveElement
+
+        _loop(_liveElements, function (live) {
+          if (live.element === element) liveElement = live
+        })
+
+        if (!liveElement) return
+
+        if (element.removeEventListener) {
+          element.removeEventListener(_event, liveElement.handler, false)
+        } else if (element.detachEvent) {
+          element.detachEvent('on' + _event, liveElement.handler)
+        }
+
+        _liveElements.splice(_liveElements.indexOf(liveElement), 1)
+      })
+
+      return this
+    },
+
+    /**
+     * The `once` method works mostly like the `live` method, but no events are
+     * bound, the functionality is only executed once.
+     *
+     * @param   {Nodes}     elements   All elements that should receive the
+     *                                 Countable functionality.
+     *
+     * @param   {Function}  callback   The callback to fire whenever the
+     *                                 element's value changes. The callback is
+     *                                 called with the relevant element bound to
+     *                                 `this` and the counted values as the
+     *                                 single parameter.
+     *
+     * @param   {Object}    [options]  An object to modify Countable's
+     *                                 behaviour. Refer to `_extendDefaults`
+     *                                 for a list of available options.
+     *
+     * @return  {Object}    Returns the Countable object to allow for chaining.
+     */
+
+    once: function (elements, callback, options) {
+      if (!_validateArguments(elements, callback)) return
+
+      _loop(elements, function (element) {
+        callback.call(element, _count(element, _extendDefaults(options)))
+      })
+
+      return this
+    },
+
+    /**
+     * The `enabled` method checks if the live-counting functionality is bound
+     * to an element.
+     *
+     * @param   {Element}  element  A single Element.
+     *
+     * @return  {Boolean}  A boolean value representing whether Countable
+     *                     functionality is bound to the given element.
+     */
+
+    enabled: function (element) {
+      var isEnabled = false
+
+      if (element && element.nodeType === 1) {
+        _loop(_liveElements, function (live) {
+          if (live.element === element) isEnabled = true
+        })
+      }
+
+      return isEnabled
+    }
+
+  }
+
+  /**
+   * Expose Countable depending on the module system used across the
+   * application. (Node / CommonJS, AMD, global)
+   */
+
+  if (typeof exports === 'object') {
+    module.exports = Countable
+  } else if (typeof define === 'function' && define.amd) {
+    define(function () { return Countable })
+  } else {
+    global.Countable = Countable
+  }
+}(this))

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: countable-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kyle Szives
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Countable is a script to allow for live paragraph-, word- and character-
+  counting on an HTML element based on http://radlikewhoa.github.io/Countable.
+email:
+- kjszives@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- countable-rails.gemspec
+- lib/countable/rails.rb
+- lib/countable/rails/version.rb
+- vendor/assets/javascripts/countable.js
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: Countable is a script to allow for live paragraph-, word- and character-
+  counting on an HTML element.
+test_files: []