chiropractor 1.0.0

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in chiropractor.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Andrew Eberbach
+
+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,46 @@
+# Chiropractor
+
+I miss ActiveSupport. I really do. The javascript standard library is lacking. So this is a collection of some useful Backbone and Underscore components. Saves me from having to keep downloading them into every project. This seems like a reasonable stack that gives you pretty powerful framework for building backbone apps.
+
+Included:
+
+* Underscore.Inflector: https://github.com/jeremyruppel/underscore.inflection
+* Underscore.String: https://github.com/epeli/underscore.string
+* Backbone.Marionette: https://github.com/marionettejs/backbone.marionette
+* Backbone.Relational: https://github.com/PaulUithol/Backbone-relational
+* Backbone.ModelBinder: https://github.com/theironcook/Backbone.ModelBinder
+* AccountingJS: http://josscrowcroft.github.com/accounting.js/
+* MomentJS: https://github.com/timrwood/moment/
+
+Also have a couple extensions:
+
+* Backbone.LayoutRegion: Combines Layouts and Regions from Marionette
+* Backbone.JST: Adds JST support to Marionette
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'chiropractor'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install chiropractor
+
+## Usage
+
+```javascript
+//= require chiropractor
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+
+scripts = {
+  "https://github.com/jeremyruppel/underscore.inflection" => "https://raw.github.com/jeremyruppel/underscore.inflection/master/src/underscore.inflection.js",
+  "https://github.com/epeli/underscore.string" => "https://raw.github.com/epeli/underscore.string/master/lib/underscore.string.js",
+  "https://github.com/timrwood/moment/" => "https://raw.github.com/timrwood/moment/master/moment.js",
+  "http://josscrowcroft.github.com/accounting.js/" => "https://raw.github.com/josscrowcroft/accounting.js/master/accounting.js",
+  "https://github.com/PaulUithol/Backbone-relational" => "https://raw.github.com/PaulUithol/Backbone-relational/master/backbone-relational.js",
+  "https://github.com/theironcook/Backbone.ModelBinder" => "https://raw.github.com/theironcook/Backbone.ModelBinder/master/Backbone.ModelBinder.js"
+}
+
+require 'open-uri'
+desc "Update scripts"
+task :update_scripts do
+  dir = File.expand_path("../vendor/assets/javascripts/chiropractor", __FILE__)
+  FileUtils.mkdir_p(dir)
+  scripts.each do |repo_url, file_url|
+    file = File.basename(URI.parse(file_url).path)
+    output = File.join(dir,file)
+    File.open(output, "w+"){|f| f.write(open(file_url).read)}
+  end  
+end

data/chiropractor.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'chiropractor/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "chiropractor"
+  gem.version       = Chiropractor::VERSION
+  gem.authors       = ["Andrew Eberbach"]
+  gem.email         = ["andrew@ebertech.ca"]
+  gem.description   = %q{A helpful collection of tools to help your Backbone}
+  gem.summary       = %q{A helpful collection of tools to help your Backbone}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  
+  gem.add_runtime_dependency "backbone-on-rails"
+  gem.add_runtime_dependency "marionette-rails"
+  gem.add_runtime_dependency "coffee-rails"
+  gem.add_runtime_dependency "jquery-rails"
+end

data/lib/chiropractor.rb

@@ -0,0 +1,11 @@
+require "backbone-on-rails"
+require "marionette-rails"
+require "coffee-rails"
+require "jquery-rails"
+
+module Chiropractor
+  autoload :Engine, 'chiropractor/engine'
+  autoload :VERSION, 'chiropractor/version'
+end
+
+Chiropractor::Engine

data/lib/chiropractor/engine.rb

@@ -0,0 +1,6 @@
+module Chiropractor
+  class Engine < Rails::Engine
+    
+  end
+end
+  

data/lib/chiropractor/version.rb

@@ -0,0 +1,3 @@
+module Chiropractor
+  VERSION = "1.0.0"
+end

data/vendor/assets/javascripts/chiropractor/Backbone.ModelBinder.js

@@ -0,0 +1,482 @@
+// Backbone.ModelBinder v0.1.6
+// (c) 2012 Bart Wood
+// Distributed Under MIT License
+
+(function (factory) {
+    if (typeof define === 'function' && define.amd) {
+        // AMD. Register as an anonymous module.
+        define(['underscore', 'jquery', 'backbone'], factory);
+    } else {
+        // Browser globals
+        factory(_, $, Backbone);
+    }
+}(function(_, $, Backbone){
+
+    if(!Backbone){
+        throw 'Please include Backbone.js before Backbone.ModelBinder.js';
+    }
+
+    Backbone.ModelBinder = function(modelSetOptions){
+        _.bindAll(this);
+	this._modelSetOptions = modelSetOptions || {};
+    };
+
+    // Current version of the library.
+    Backbone.ModelBinder.VERSION = '0.1.6';
+    Backbone.ModelBinder.Constants = {};
+    Backbone.ModelBinder.Constants.ModelToView = 'ModelToView';
+    Backbone.ModelBinder.Constants.ViewToModel = 'ViewToModel';
+
+    _.extend(Backbone.ModelBinder.prototype, {
+
+        bind:function (model, rootEl, attributeBindings, modelSetOptions) {
+            this.unbind();
+
+            this._model = model;
+            this._rootEl = rootEl;
+	        this._modelSetOptions = _.extend({}, this._modelSetOptions, modelSetOptions);
+
+            if (!this._model) throw 'model must be specified';
+            if (!this._rootEl) throw 'rootEl must be specified';
+
+            if(attributeBindings){
+                // Create a deep clone of the attribute bindings
+                this._attributeBindings = $.extend(true, {}, attributeBindings);
+
+                this._initializeAttributeBindings();
+                this._initializeElBindings();
+            }
+            else {
+                this._initializeDefaultBindings();
+            }
+
+            this._bindModelToView();
+            this._bindViewToModel();
+        },
+
+	    bindCustomTriggers: function (model, rootEl, triggers, attributeBindings, modelSetOptions) {
+           this._triggers = triggers;
+           this.bind(model, rootEl, attributeBindings, modelSetOptions)
+    	},
+
+        unbind:function () {
+            this._unbindModelToView();
+            this._unbindViewToModel();
+
+            if(this._attributeBindings){
+                delete this._attributeBindings;
+                this._attributeBindings = undefined;
+            }
+        },
+
+        // Converts the input bindings, which might just be empty or strings, to binding objects
+        _initializeAttributeBindings:function () {
+            var attributeBindingKey, inputBinding, attributeBinding, elementBindingCount, elementBinding;
+
+            for (attributeBindingKey in this._attributeBindings) {
+                inputBinding = this._attributeBindings[attributeBindingKey];
+
+                if (_.isString(inputBinding)) {
+                    attributeBinding = {elementBindings: [{selector: inputBinding}]};
+                }
+                else if (_.isArray(inputBinding)) {
+                    attributeBinding = {elementBindings: inputBinding};
+                }
+                else if(_.isObject(inputBinding)){
+                    attributeBinding = {elementBindings: [inputBinding]};
+                }
+                else {
+                    throw 'Unsupported type passed to Model Binder ' + attributeBinding;
+                }
+
+                // Add a linkage from the element binding back to the attribute binding
+                for(elementBindingCount = 0; elementBindingCount < attributeBinding.elementBindings.length; elementBindingCount++){
+                    elementBinding = attributeBinding.elementBindings[elementBindingCount];
+                    elementBinding.attributeBinding = attributeBinding;
+                }
+
+                attributeBinding.attributeName = attributeBindingKey;
+                this._attributeBindings[attributeBindingKey] = attributeBinding;
+            }
+        },
+
+        // If the bindings are not specified, the default binding is performed on the name attribute
+        _initializeDefaultBindings: function(){
+            var elCount, namedEls, namedEl, name, attributeBinding;
+            this._attributeBindings = {};
+            namedEls = $('[name]', this._rootEl);
+
+            for(elCount = 0; elCount < namedEls.length; elCount++){
+                namedEl = namedEls[elCount];
+                name = $(namedEl).attr('name');
+
+                // For elements like radio buttons we only want a single attribute binding with possibly multiple element bindings
+                if(!this._attributeBindings[name]){
+                    attributeBinding =  {attributeName: name};
+                    attributeBinding.elementBindings = [{attributeBinding: attributeBinding, boundEls: [namedEl]}];
+                    this._attributeBindings[name] = attributeBinding;
+                }
+                else{
+                    this._attributeBindings[name].elementBindings.push({attributeBinding: this._attributeBindings[name], boundEls: [namedEl]});
+                }
+            }
+        },
+
+        _initializeElBindings:function () {
+            var bindingKey, attributeBinding, bindingCount, elementBinding, foundEls, elCount, el;
+            for (bindingKey in this._attributeBindings) {
+                attributeBinding = this._attributeBindings[bindingKey];
+
+                for (bindingCount = 0; bindingCount < attributeBinding.elementBindings.length; bindingCount++) {
+                    elementBinding = attributeBinding.elementBindings[bindingCount];
+                    if (elementBinding.selector === '') {
+                        foundEls = $(this._rootEl);
+                    }
+                    else {
+                        foundEls = $(elementBinding.selector, this._rootEl);
+                    }
+
+                    if (foundEls.length === 0) {
+                        throw 'Bad binding found. No elements returned for binding selector ' + elementBinding.selector;
+                    }
+                    else {
+                        elementBinding.boundEls = [];
+                        for (elCount = 0; elCount < foundEls.length; elCount++) {
+                            el = foundEls[elCount];
+                            elementBinding.boundEls.push(el);
+                        }
+                    }
+                }
+            }
+        },
+
+        _bindModelToView: function () {
+            this._model.on('change', this._onModelChange, this);
+
+            this.copyModelAttributesToView();
+        },
+
+        // attributesToCopy is an optional parameter - if empty, all attributes
+        // that are bound will be copied.  Otherwise, only attributeBindings specified
+        // in the attributesToCopy are copied.
+        copyModelAttributesToView: function(attributesToCopy){
+            var attributeName, attributeBinding;
+
+            for (attributeName in this._attributeBindings) {
+                if(attributesToCopy === undefined || _.indexOf(attributesToCopy, attributeName) !== -1){
+                    attributeBinding = this._attributeBindings[attributeName];
+                    this._copyModelToView(attributeBinding);
+                }
+            }
+        },
+
+        _unbindModelToView: function(){
+            if(this._model){
+                this._model.off('change', this._onModelChange);
+                this._model = undefined;
+            }
+        },
+
+        _bindViewToModel: function () {
+            if (this._triggers) {
+                _.each(this._triggers, function (event, selector) {
+                    $(this._rootEl).delegate(selector, event, this._onElChanged);
+                }, this);
+            }
+            else {
+                $(this._rootEl).delegate('', 'change', this._onElChanged);
+                // The change event doesn't work properly for contenteditable elements - but blur does
+                $(this._rootEl).delegate('[contenteditable]', 'blur', this._onElChanged);
+            }
+        },
+
+        _unbindViewToModel: function () {
+            if (this._rootEl) {
+                if (this._triggers) {
+                    _.each(this._triggers, function (event, selector) {
+                        $(this._rootEl).undelegate(selector, event, this._onElChanged);
+                    }, this);
+                }
+                else {
+                    $(this._rootEl).undelegate('', 'change', this._onElChanged);
+                    $(this._rootEl).undelegate('[contenteditable]', 'blur', this._onElChanged);
+                }
+            }
+        },
+
+        _onElChanged:function (event) {
+            var el, elBindings, elBindingCount, elBinding;
+
+            el = $(event.target)[0];
+            elBindings = this._getElBindings(el);
+
+            for(elBindingCount = 0; elBindingCount < elBindings.length; elBindingCount++){
+                elBinding = elBindings[elBindingCount];
+                if (this._isBindingUserEditable(elBinding)) {
+                    this._copyViewToModel(elBinding, el);
+                }
+            }
+        },
+
+        _isBindingUserEditable: function(elBinding){
+            return elBinding.elAttribute === undefined ||
+                elBinding.elAttribute === 'text' ||
+                elBinding.elAttribute === 'html';
+        },
+
+        _getElBindings:function (findEl) {
+            var attributeName, attributeBinding, elementBindingCount, elementBinding, boundElCount, boundEl;
+            var elBindings = [];
+
+            for (attributeName in this._attributeBindings) {
+                attributeBinding = this._attributeBindings[attributeName];
+
+                for (elementBindingCount = 0; elementBindingCount < attributeBinding.elementBindings.length; elementBindingCount++) {
+                    elementBinding = attributeBinding.elementBindings[elementBindingCount];
+
+                    for (boundElCount = 0; boundElCount < elementBinding.boundEls.length; boundElCount++) {
+                        boundEl = elementBinding.boundEls[boundElCount];
+
+                        if (boundEl === findEl) {
+                            elBindings.push(elementBinding);
+                        }
+                    }
+                }
+            }
+
+            return elBindings;
+        },
+
+        _onModelChange:function () {
+            var changedAttribute, attributeBinding;
+
+            for (changedAttribute in this._model.changedAttributes()) {
+                attributeBinding = this._attributeBindings[changedAttribute];
+
+                if (attributeBinding) {
+                    this._copyModelToView(attributeBinding);
+                }
+            }
+        },
+
+        _copyModelToView:function (attributeBinding) {
+            var elementBindingCount, elementBinding, boundElCount, boundEl, value, convertedValue;
+
+            value = this._model.get(attributeBinding.attributeName);
+
+            for (elementBindingCount = 0; elementBindingCount < attributeBinding.elementBindings.length; elementBindingCount++) {
+                elementBinding = attributeBinding.elementBindings[elementBindingCount];
+
+                for (boundElCount = 0; boundElCount < elementBinding.boundEls.length; boundElCount++) {
+                    boundEl = elementBinding.boundEls[boundElCount];
+
+                    if(!boundEl._isSetting){
+                        convertedValue = this._getConvertedValue(Backbone.ModelBinder.Constants.ModelToView, elementBinding, value);
+                        this._setEl($(boundEl), elementBinding, convertedValue);
+                    }
+                }
+            }
+        },
+
+        _setEl: function (el, elementBinding, convertedValue) {
+            if (elementBinding.elAttribute) {
+                this._setElAttribute(el, elementBinding, convertedValue);
+            }
+            else {
+                this._setElValue(el, convertedValue);
+            }
+        },
+
+        _setElAttribute:function (el, elementBinding, convertedValue) {
+            switch (elementBinding.elAttribute) {
+                case 'html':
+                    el.html(convertedValue);
+                    break;
+                case 'text':
+                    el.text(convertedValue);
+                    break;
+                case 'enabled':
+                    el.attr('disabled', !convertedValue);
+                    break;
+                case 'displayed':
+                    el[convertedValue ? 'show' : 'hide']();
+                    break;
+                case 'hidden':
+                    el[convertedValue ? 'hide' : 'show']();
+                    break;
+                case 'css':
+                    el.css(elementBinding.cssAttribute, convertedValue);
+                    break;
+                case 'class':
+                    var previousValue = this._model.previous(elementBinding.attributeBinding.attributeName);
+                    if(!_.isUndefined(previousValue)){
+                        previousValue = this._getConvertedValue(Backbone.ModelBinder.Constants.ModelToView, elementBinding, previousValue);
+                        el.removeClass(previousValue);
+                    }
+
+                    if(convertedValue){
+                        el.addClass(convertedValue);
+                    }
+                    break;
+                default:
+                    el.attr(elementBinding.elAttribute, convertedValue);
+            }
+        },
+
+        _setElValue:function (el, convertedValue) {
+            if(el.attr('type')){
+                switch (el.attr('type')) {
+                    case 'radio':
+                        if (el.val() === convertedValue) {
+                            el.attr('checked', 'checked');
+                        }
+                        break;
+                    case 'checkbox':
+                        if (convertedValue) {
+                            el.attr('checked', 'checked');
+                        }
+                        else {
+                            el.removeAttr('checked');
+                        }
+                        break;
+                    default:
+                        el.val(convertedValue);
+                }
+            }
+            else if(el.is('input') || el.is('select') || el.is('textarea')){
+                el.val(convertedValue);
+            }
+            else {
+                el.text(convertedValue);
+            }
+        },
+
+        _copyViewToModel: function (elementBinding, el) {
+            var value, convertedValue;
+
+            if (!el._isSetting) {
+
+                el._isSetting = true;
+                this._setModel(elementBinding, $(el));
+                el._isSetting = false;
+
+                if(elementBinding.converter){
+                    value = this._model.get(elementBinding.attributeBinding.attributeName);
+                    convertedValue = this._getConvertedValue(Backbone.ModelBinder.Constants.ModelToView, elementBinding, value);
+                    this._setEl($(el), elementBinding, convertedValue);
+                }
+            }
+        },
+
+        _getElValue: function(elementBinding, el){
+            switch (el.attr('type')) {
+                case 'checkbox':
+                    return el.prop('checked') ? true : false;
+                default:
+                    if(el.attr('contenteditable') !== undefined){
+                        return el.html();
+                    }
+                    else {
+                        return el.val();
+                    }
+            }
+        },
+
+        _setModel: function (elementBinding, el) {
+            var data = {};
+            var elVal = this._getElValue(elementBinding, el);
+            elVal = this._getConvertedValue(Backbone.ModelBinder.Constants.ViewToModel, elementBinding, elVal);
+            data[elementBinding.attributeBinding.attributeName] = elVal;
+	        var opts = _.extend({}, this._modelSetOptions, {changeSource: 'ModelBinder'});
+            this._model.set(data, opts);
+        },
+
+        _getConvertedValue: function (direction, elementBinding, value) {
+            if (elementBinding.converter) {
+                value = elementBinding.converter(direction, value, elementBinding.attributeBinding.attributeName, this._model);
+            }
+
+            return value;
+        }
+    });
+
+    Backbone.ModelBinder.CollectionConverter = function(collection){
+        this._collection = collection;
+
+        if(!this._collection){
+            throw 'Collection must be defined';
+        }
+        _.bindAll(this, 'convert');
+    };
+
+    _.extend(Backbone.ModelBinder.CollectionConverter.prototype, {
+        convert: function(direction, value){
+            if (direction === Backbone.ModelBinder.Constants.ModelToView) {
+                return value ? value.id : undefined;
+            }
+            else {
+                return this._collection.get(value);
+            }
+        }
+    });
+
+    // A static helper function to create a default set of bindings that you can customize before calling the bind() function
+    // rootEl - where to find all of the bound elements
+    // attributeType - probably 'name' or 'id' in most cases
+    // converter(optional) - the default converter you want applied to all your bindings
+    // elAttribute(optional) - the default elAttribute you want applied to all your bindings
+    Backbone.ModelBinder.createDefaultBindings = function(rootEl, attributeType, converter, elAttribute){
+        var foundEls, elCount, foundEl, attributeName;
+        var bindings = {};
+
+        foundEls = $('[' + attributeType + ']', rootEl);
+
+        for(elCount = 0; elCount < foundEls.length; elCount++){
+            foundEl = foundEls[elCount];
+            attributeName = $(foundEl).attr(attributeType);
+
+            if(!bindings[attributeName]){
+                var attributeBinding =  {selector: '[' + attributeType + '="' + attributeName + '"]'};
+                bindings[attributeName] = attributeBinding;
+
+                if(converter){
+                    bindings[attributeName].converter = converter;
+                }
+
+                if(elAttribute){
+                    bindings[attributeName].elAttribute = elAttribute;
+                }
+            }
+        }
+
+        return bindings;
+    };
+
+    // Helps you to combine 2 sets of bindings
+    Backbone.ModelBinder.combineBindings = function(destination, source){
+        _.each(source, function(value, key){
+            var elementBinding = {selector: value.selector};
+
+            if(value.converter){
+                elementBinding.converter = value.converter;
+            }
+
+            if(value.elAttribute){
+                elementBinding.elAttribute = value.elAttribute;
+            }
+
+            if(!destination[key]){
+                destination[key] = elementBinding;
+            }
+            else {
+                destination[key] = [destination[key], elementBinding];
+            }
+        });
+
+        return destination;
+    };
+
+
+    return Backbone.ModelBinder;
+
+}));