twine-rails 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5e3dd60b497b3a0ceea4b930d21396ce2b589421
+  data.tar.gz: 98f97ae534740b9acf588183825169cec31fe172
+SHA512:
+  metadata.gz: 7e440905d00db7bdd0505d717ddd831579887ea4070dfce795fb77de64cec83a621875153a3c7ece28e4ff67aae011e049548d788dd3def4a63aa49da9ef569c
+  data.tar.gz: 6299d2b9385b20b9086b6f4d100d02bc030270e78f3d6c8eb7fc90265ee6432cae7e6ec66f45469867a011a3bd724658a5a0b6a0996bd1cc0fe30130563a2e6b

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Shopify Inc.
+
+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,111 @@
+twine
+-----
+
+[![Build Status](https://secure.travis-ci.org/Shopify/twine.png)](http://travis-ci.org/Shopify/twine)
+
+[Demonstration](http://shopify.github.io/twine/)
+
+Twine is a minimalistic two-way binding system.
+
+Features:
+ - It's just JS - no new syntax to learn for bindings
+ - Small and easy to understand codebase
+
+Non-features:
+ - No creation of new nodes (e.g. no iteration)
+ - No special declaration of bindable data (i.e. bind to any JS data)
+
+## Installation
+
+Twine is available on bower via `bower install twine` if that is your preference.
+
+Twine comes as `dist/twine.js` and `dist/twine.min.js` in this repo and in the bower package.
+
+Twine is also available as a gem.  In your Gemfile, add `gem 'twine-rails'` and include it in your `application.js` manifest via `//= require twine`
+
+## Usage
+
+Twine can be initialized simply with the following:
+
+```html
+<script type="text/javascript">
+  context = {}
+  $(function() {
+    Twine.reset(context).bind().refresh()
+  });
+</script>
+```
+
+Above, `context` will be considered the context root, and this will work until you navigate to a new page.  On a simple app, this may be all you need to do.
+
+### With [rails/turbolinks](https://github.com/rails/turbolinks)
+
+Turbolinks requires a bit more consideration, as the executing JS context will remain the same -- you have the same `window` object throughout operation.  When the page changes and new nodes come in, they need to be re-bound manually.  Twine leaves this to you, rather than attempting to guess.
+
+Here's a sample snippet that you might use:
+
+```coffee
+context = {}
+
+document.addEventListener 'page:change', ->
+  Twine.reset(context).bind().refresh()
+  return
+```
+
+If you're using the [jquery.turbolinks gem](https://github.com/kossnocorp/jquery.turbolinks), then you can use:
+
+```coffee
+context = {}
+
+$ ->
+  Twine.reset(context).bind().refresh()
+  return
+```
+
+### With [Shopify/turbograft](https://github.com/Shopify/turbograft)
+
+With TurboGraft, you may have cases where you want to keep parts of the page around, and thus, their bindings should continue to live.
+
+The following snippet may help:
+
+```coffee
+context = {}
+
+reset = (nodes) ->
+  if nodes
+    Twine.bind(node) for node in nodes
+  else
+    Twine.reset(context).bind()
+
+  Twine.refreshImmediately()
+  return
+
+document.addEventListener 'DOMContentLoaded', -> reset()
+
+document.addEventListener 'page:load', (event) ->
+  reset(event.data)
+  return
+
+document.addEventListener 'page:before-partial-replace', (event) ->
+  nodes = event.data
+  Twine.unbind(node) for node in nodes
+  return
+
+$(document).ajaxComplete ->
+  Twine.refresh()
+```
+
+## Contributing
+
+1. Clone the repo: `git clone git@github.com:Shopify/twine`
+2. `cd twine`
+3. `npm install`
+4. `npm install -g testem coffee-script`
+5. Run the tests using `testem`, or `testem ci`
+6. Submit a PR
+
+## Releasing
+
+1. Update version number in `package.json`, `bower.json`, and `lib/twine-rails/version.rb`
+2. Run `bundle install` to update `Gemfile.lock`
+3. Push the new tag to GitHub and the new version to rubygems with `bundle exec rake release`

data/lib/assets/javascripts/twine.js.coffee

@@ -0,0 +1,293 @@
+window.Twine = {}
+Twine.shouldDiscardEvent = {}
+
+# Map of node binding ids to objects that describe a node's bindings.
+elements = {}
+
+# The number of nodes bound since the last call to Twine.reset().
+# Used to determine the next binding id.
+nodeCount = 0
+
+# Storage for all bindable data, provided by the caller of Twine.reset().
+rootContext = null
+
+keypathRegex = /^[a-z]\w*(\.[a-z]\w*|\[\d+\])*$/i # Tests if a string is a pure keypath.
+refreshQueued = false
+rootNode = null
+
+# Cleans up all existing bindings and sets the root node and context.
+Twine.reset = (newContext, node = document.documentElement) ->
+  for bindingsArr in elements
+    obj.teardown() for obj in bindingsArr when obj.teardown
+  elements = {}
+
+  rootContext = newContext
+  rootNode = node
+  rootNode.bindingId = nodeCount = 1
+
+  this
+
+Twine.bind = (node = rootNode, context = Twine.context(node)) ->
+  bind(context, node, true)
+
+bind = (context, node, forceSaveContext) ->
+  if node.bindingId
+    Twine.unbind(node)
+
+  for type, binding of Twine.bindingTypes when definition = node.getAttribute(type)
+    element = {bindings: []} unless element  # Defer allocation to prevent GC pressure
+    fn = binding(node, context, definition, element)
+    element.bindings.push(fn) if fn
+
+  if newContextKey = node.getAttribute('context')
+    keypath = keypathForKey(newContextKey)
+    if keypath[0] == '$root'
+      context = rootContext
+      keypath = keypath.slice(1)
+    context = getValue(context, keypath) || setValue(context, keypath, {})
+
+  if element || newContextKey || forceSaveContext
+    (element ?= {}).childContext = context
+    elements[node.bindingId ?= ++nodeCount] = element
+
+  # IE and Safari don't support node.children for DocumentFragment and SVGElement nodes.
+  # If the element supports children we continue to traverse the children, otherwise
+  # we stop traversing that subtree.
+  # https://developer.mozilla.org/en-US/docs/Web/API/ParentNode.children
+  # As a result, Twine are unsupported within DocumentFragment and SVGElement nodes.
+  bind(context, childNode) for childNode in (node.children || [])
+  Twine.count = nodeCount
+  Twine
+
+# Queues a refresh of the DOM, batching up calls for the current synchronous block.
+Twine.refresh = ->
+  return if refreshQueued
+  refreshQueued = true
+  setTimeout(Twine.refreshImmediately, 0)
+
+refreshElement = (element) ->
+  (obj.refresh() if obj.refresh?) for obj in element.bindings if element.bindings
+  return
+
+Twine.refreshImmediately = ->
+  refreshQueued = false
+  refreshElement(element) for key, element of elements
+  return
+
+# Force the binding system to recognize programmatic changes to a node's value.
+Twine.change = (node, bubble = false) ->
+  event = document.createEvent("HTMLEvents")
+  event.initEvent('change', bubble, true) # for IE 9/10 compatibility.
+  node.dispatchEvent(event)
+
+# Cleans up everything related to a node and its subtree.
+Twine.unbind = (node) ->
+  if id = node.bindingId
+    if bindings = elements[id]?.bindings
+      obj.teardown() for obj in bindings when obj.teardown
+    delete elements[id]
+  # IE and Safari don't support node.children for DocumentFragment or SVGElement,
+  # See explaination in bind()
+  Twine.unbind(childNode) for childNode in (node.children || [])
+  this
+
+# Returns the binding context for a node by looking up the tree.
+Twine.context = (node) -> getContext(node, false)
+Twine.childContext = (node) -> getContext(node, true)
+
+getContext = (node, child) ->
+  while node
+    return rootContext if node == rootNode
+    node = node.parentNode if !child
+    if (id = node.bindingId) && (context = elements[id]?.childContext)
+      return context
+    node = node.parentNode if child
+
+# Returns the fully qualified key for a node's context
+Twine.contextKey = (node, lastContext) ->
+  keys = []
+  addKey = (context) ->
+    for key, val of context when lastContext == val
+      keys.unshift(key)
+      break
+    lastContext = context
+
+  while node && node != rootNode && node = node.parentNode
+    addKey(context) if (id = node.bindingId) && (context = elements[id]?.childContext)
+
+  addKey(rootContext) if node == rootNode
+  keys.join('.')
+
+valueAttributeForNode = (node) ->
+  name = node.nodeName.toLowerCase()
+  if name in ['input', 'textarea', 'select']
+    if node.getAttribute('type') in ['checkbox', 'radio'] then 'checked' else 'value'
+  else
+    'textContent'
+
+keypathForKey = (key) ->
+  keypath = []
+  for key in key.split('.')
+    if (start = key.indexOf('[')) != -1
+      keypath.push(key.substr(0, start))
+      key = key.substr(start)
+
+      while (end = key.indexOf(']')) != -1
+        keypath.push(parseInt(key.substr(1, end), 10))
+        key = key.substr(end + 1)
+    else
+      keypath.push(key)
+  keypath
+
+getValue = (object, keypath) ->
+  object = object[key] for key in keypath when object?
+  object
+
+setValue = (object, keypath, value) ->
+  [keypath..., lastKey] = keypath
+  for key in keypath
+    object = object[key] ?= {}
+  object[lastKey] = value
+
+stringifyNodeAttributes = (node) ->
+  nAttributes = node.attributes.length
+  i = 0
+  result = ""
+  while i < nAttributes
+    attr = node.attributes.item(i)
+    result += "#{attr.nodeName}='#{attr.textContent}'"
+    i+=1
+  result
+
+wrapFunctionString = (code, args, node) ->
+  if isKeypath(code) && keypath = keypathForKey(code)
+    if keypath[0] == '$root'
+      ($context, $root) -> getValue($root, keypath)
+    else
+      ($context, $root) -> getValue($context, keypath)
+  else
+    try
+      new Function(args, "with($context) { return #{code} }")
+    catch e
+      throw "Twine error: Unable to create function on #{node.nodeName} node with attributes #{stringifyNodeAttributes(node)}"
+
+isKeypath = (value) ->
+  value not in ['true', 'false', 'null', 'undefined'] and keypathRegex.test(value)
+
+fireCustomChangeEvent = (node) ->
+  event = document.createEvent('CustomEvent')
+  event.initCustomEvent('bindings:change', true, false, {})
+  node.dispatchEvent(event)
+
+Twine.bindingTypes =
+  bind: (node, context, definition) ->
+    valueAttribute = valueAttributeForNode(node)
+    value = node[valueAttribute]
+    lastValue = undefined
+    teardown = undefined
+
+    # Radio buttons only set the value to the node value if checked.
+    checkedValueType = node.getAttribute('type') == 'radio'
+    fn = wrapFunctionString(definition, '$context,$root', node)
+
+    refresh = ->
+      newValue = fn.call(node, context, rootContext)
+      return if newValue == lastValue
+
+      lastValue = newValue
+      return if newValue == node[valueAttribute]
+
+      node[valueAttribute] = if checkedValueType then newValue == node.value else newValue
+      fireCustomChangeEvent(node)
+
+    return {refresh} unless isKeypath(definition)
+
+    refreshContext = ->
+      if checkedValueType
+        return unless node.checked
+        setValue(context, keypath, node.value)
+      else
+        setValue(context, keypath, node[valueAttribute])
+
+    keypath = keypathForKey(definition)
+    twoWayBinding = valueAttribute != 'textContent' && node.type != 'hidden'
+
+    if keypath[0] == '$root'
+      context = rootContext
+      keypath = keypath.slice(1)
+
+    if value? && (twoWayBinding || value != '') && !(oldValue = getValue(context, keypath))?
+      refreshContext()
+
+    if twoWayBinding
+      changeHandler = ->
+        return if getValue(context, keypath) == this[valueAttribute]
+        refreshContext()
+        Twine.refreshImmediately()
+      node.addEventListener(eventKey, changeHandler) for eventKey in ['input', 'keyup', 'change']
+      teardown = ->
+        node.removeEventListener(eventKey, changeHandler) for eventKey in ['input', 'keyup', 'change']
+
+    {refresh, teardown}
+
+  'bind-show': (node, context, definition) ->
+    fn = wrapFunctionString(definition, '$context,$root', node)
+    lastValue = undefined
+    return refresh: ->
+      newValue = !fn.call(node, context, rootContext)
+      return if newValue == lastValue
+      $(node).toggleClass('hide', lastValue = newValue)
+
+  'bind-class': (node, context, definition) ->
+    fn = wrapFunctionString(definition, '$context,$root', node)
+    lastValue = {}
+    return refresh: ->
+      newValue = fn.call(node, context, rootContext)
+      for key, value of newValue when !lastValue[key] != !value
+        $(node).toggleClass(key, !!value)
+      lastValue = newValue
+
+  define: (node, context, definition) ->
+    fn = wrapFunctionString(definition, '$context,$root', node)
+    object = fn.call(node, context, rootContext)
+    context[key] = value for key, value of object
+    return
+
+setupAttributeBinding = (attributeName, bindingName) ->
+  booleanAttribute = attributeName in ['checked', 'disabled', 'readOnly']
+
+  Twine.bindingTypes["bind-#{bindingName}"] = (node, context, definition) ->
+    fn = wrapFunctionString(definition, '$context,$root', node)
+    lastValue = undefined
+    return refresh: ->
+      newValue = fn.call(node, context, rootContext)
+      newValue = !!newValue if booleanAttribute
+      return if newValue == lastValue
+      node[attributeName] = lastValue = newValue
+
+for attribute in ['placeholder', 'checked', 'disabled', 'href', 'title', 'readOnly']
+  setupAttributeBinding(attribute, attribute)
+
+setupAttributeBinding('innerHTML', 'unsafe-html')
+
+preventDefaultForEvent = (event) ->
+  (event.type == 'submit' || event.currentTarget.nodeName.toLowerCase() == 'a') && event.currentTarget.getAttribute('allow-default') != '1'
+
+setupEventBinding = (eventName) ->
+  Twine.bindingTypes["bind-event-#{eventName}"] = (node, context, definition) ->
+    onEventHandler = (event, data) ->
+      discardEvent = Twine.shouldDiscardEvent[eventName]?(event)
+      if discardEvent || preventDefaultForEvent(event)
+        event.preventDefault()
+
+      return if discardEvent
+
+      wrapFunctionString(definition, '$context,$root,event,data', node).call(node, context, rootContext, event, data)
+      Twine.refreshImmediately()
+    $(node).on eventName, onEventHandler
+
+    return teardown: ->
+      $(node).off eventName, onEventHandler
+
+for eventName in ['click', 'dblclick', 'mousedown', 'mouseup', 'submit', 'dragenter', 'dragleave', 'dragover', 'drop', 'drag', 'change', 'keypress', 'keydown', 'keyup', 'input', 'error', 'done', 'fail', 'blur', 'focus']
+  setupEventBinding(eventName)

data/lib/twine-rails/version.rb

@@ -0,0 +1,3 @@
+module TwineRails
+  VERSION = '0.0.5'
+end

data/lib/twine-rails.rb

@@ -0,0 +1,9 @@
+require "rails"
+require "active_support"
+
+require "twine-rails/version"
+
+module TwineRails
+  class Engine < ::Rails::Engine
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: twine-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Justin Li
+- Kristian Plettenberg-Dussault
+- Anthony Cameron
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: coffee-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !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: 
+email:
+- jli@shopify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/assets/javascripts/twine.js.coffee
+- lib/twine-rails.rb
+- lib/twine-rails/version.rb
+homepage: https://github.com/Shopify/twine
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Minimalistic two-way bindings
+test_files: []