gumby_on_rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 68e25b9c9c26c4b193c3ba6da34e9cd2decac523
+  data.tar.gz: 9696bb0ce23170abb83822b0307e5f0e9be91fad
+SHA512:
+  metadata.gz: f1e23ae40c7c9c316ad1b59581ec6eeec6c6e1418b6c034dc1f5cbd9b108d3e22fe6e7d7aa3648f07188cbcd1cf7c1ac1d814b95abe364fa5879ec3d296544a2
+  data.tar.gz: 26544b4b037dce4446cc6f5ae6337bd187744596f14c5c6fd67bd498dc99a6f4ad8fef567e8f3e7398e52ca1695c6b8ceb8bfc4777c56702c3665bb14c0b6e0a

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 YOURNAME
+
+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/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Gumby'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/javascripts/gumby/libs/extensions/gumby.comments.js

@@ -0,0 +1,152 @@
+/**
+* Gumby Comments
+* http://github.com/GumbyFramework/ResponsiveComments v1.0.0
+*/
+!function($) {
+
+	'use strict';
+
+	// data attributes
+	var attrs = {
+		'media' : 'gumby-comment-media',
+		'supports' : 'gumby-comment-supports',
+		'insert' : 'gumby-comment-insert'
+	};
+
+	// cache responsive comments nodes and data
+	function prepNodes(nodes) {
+		var i = 0, l = nodes.length, mqs = [], el, ins, obj;
+		for(; i < l; i++) {
+			el = nodes[i];
+			// beforeend default insert type
+			ins = el.getAttribute(attrs.insert) || 'beforeend';
+			// store element, insert type, media query / support test
+			obj = {
+				'element' : el,
+				'insert' : ins,
+				'media' :  el.getAttribute(attrs.media) || false,
+				'supports' :  el.getAttribute(attrs.supports) || false
+			};
+
+			mqs.push(obj);
+		}
+		return mqs;
+	}
+
+	// call required function (media/supports) on each array element
+	function testNodes(type) {
+		// if type present first argument is event object
+		type = typeof type === 'string' ? type : false;
+		this.forEach(function(x) {
+			if((type === 'supports' || !type) && x.supports) {
+				testSupportNodes.apply(x);
+			} else if((type === 'media' || !type) && x.media) {
+				testMediaNodes.apply(x);
+			}
+		});
+	}
+
+	// test media query nodes, requires matchMedia
+	function testMediaNodes() {
+		// matchMedia and media query itself required
+		if(!this.media || !window.matchMedia) {
+			return;
+		}
+
+		// media query passes and attribute not already set to complete
+		if(window.matchMedia(this.media).matches &&
+			this.element.getAttribute(attrs.media) !== 'complete') {
+			childNodes.apply(this);
+			return;
+		}
+
+		return;
+	}
+
+	// test media query nodes, requires matchMedia
+	function testSupportNodes() {
+		// Modernizr and tests required
+		if(!this.supports || !Modernizr ||
+			// test already been carried out
+			this.element.getAttribute(attrs.support) === 'complete') {
+			return;
+		}
+
+		if(featureDetection(this.supports.split(','))) {
+			childNodes.apply(this);
+			return;
+		}
+
+		return;
+	}
+
+	// handle Modernir feature detection
+	// if multiple features hand off to multiFeatureDetection
+	function featureDetection(features) {
+		// multiple feature detections
+		if(features.length > 1) {
+			return multiFeatureDetection(features);
+		}
+
+		// single feature detection
+		return Modernizr[features];
+	}
+
+	// handle multiple modernizr feature detections
+	function multiFeatureDetection(features) {
+		var passed = true;
+		features.forEach(function(feature) {
+			if(!Modernizr[feature]) {
+				passed = false;
+			}
+		});
+		return passed;
+	}
+
+	// loop round child nodes, find commented content
+	function childNodes() {
+		var l = this.element.childNodes.length,
+			i = 0;
+
+		for(; i < l; i++) {
+			// node type 8 is comment
+			if(this.element.childNodes[i].nodeType === 8) {
+				insertComment.apply(this, [i]);
+			}
+		}
+	}
+
+	// insert commented content into DOM, mark as complete and trigger event
+	function insertComment(index) {
+		this.element.insertAdjacentHTML(this.insert, this.element.childNodes[index].textContent);
+		this.element.setAttribute(attrs.media, 'complete');
+		dispatchEvent.apply(this);
+	}
+
+	// dispatch CustomEvent if supported with media query and insert type detail
+	function dispatchEvent() {
+		$(this.element).trigger('gumby.onInsert');
+	}
+
+	// add initialisation
+	Gumby.addInitalisation('comments', function() {
+		// find and cache responsive comments nodes
+		var els = prepNodes(
+			document.querySelectorAll('['+attrs.media+'],['+attrs.supports+']')
+		);
+
+		// test media nodes only on resize
+		window.addEventListener('resize', testNodes.bind(els, 'media'));
+		// test media and support nodes on load
+		window.addEventListener('load', testNodes.bind(els));
+	});
+
+	// register UI module
+	Gumby.UIModule({
+		module: 'comments',
+		events: ['onInsert'],
+		init: function() {
+			Gumby.initialize('comments');
+		}
+	});
+}(jQuery);

data/app/assets/javascripts/gumby/libs/extensions/gumby.fittext.js

@@ -0,0 +1,126 @@
+/**
+* Gumby FitText
+*
+* Adapted from the awesome FitText jQuery plugin
+* brought to you by Paravel - http://paravelinc.com/
+*
+* http://github.com/GumbyFramework/FitText v1.0.1
+*/
+!function() {
+
+	'use strict';
+
+	function FitText($el) {
+
+		Gumby.debug('Initializing FitText', $el);
+
+		this.$el = $el;
+
+		this.rate = 0;
+		this.fontSizes = {};
+		this.debugDelay = 0;
+
+		// set up module based on attributes
+		this.setup();
+
+		var scope = this;
+
+		// re-initialize module
+		this.$el.on('gumby.initialize', function() {
+			Gumby.debug('Re-initializing FitText', scope.$el);
+			scope.setup();
+			scope.resize();
+		});
+
+		// lets go
+		$(window).on('load resize orientationchange', function() {
+			scope.resize();
+		});
+
+		this.resize();
+	}
+
+	// set up module based on attributes
+	FitText.prototype.setup = function() {
+		// optional compressor rate
+		this.rate = Number(Gumby.selectAttr.apply(this.$el, ['rate'])) || 1;
+		// optional font sizes (min|max)
+		this.fontSizes = this.parseSizes(Gumby.selectAttr.apply(this.$el, ['sizes']));
+	};
+
+	// apply the resizing
+	FitText.prototype.resize = function() {
+		var size = this.calculateSize(),
+			scope = this;
+
+		this.$el.css('font-size', size);
+
+		// wrap debug in timeout so not printing on every resize event
+		clearTimeout(this.debugDelay);
+		this.debugDelay = setTimeout(function() {
+			Gumby.debug('Updated font size to '+size+'px', scope.$el);
+		}, 200);
+	};
+
+	// calculate the font size
+	FitText.prototype.calculateSize = function() {
+		return Math.max(Math.min(this.$el.width() / (this.rate*10), parseFloat(this.fontSizes.max)), parseFloat(this.fontSizes.min));
+	};
+
+	// parse size attributes with min|max syntax
+	FitText.prototype.parseSizes = function(attrStr) {
+		var sizes = {
+			min: Number.NEGATIVE_INFINITY,
+			max: Number.POSITIVE_INFINITY
+		};
+
+		// attribute is optional
+		if(!attrStr) { return sizes; }
+
+		// min and/or max specified
+		if(attrStr.indexOf('|') > -1) {
+			attrStr = attrStr.split('|');
+
+			// both are optional
+			sizes.min = Number(attrStr[0]) || sizes.min;
+			sizes.max = Number(attrStr[1]) || sizes.max;
+		}
+
+		// only one value specific without | so use as min
+		sizes.min = Number(attrStr) || sizes.min;
+
+		return sizes;
+	};
+
+	// add initialisation
+	Gumby.addInitalisation('fittext', function(all) {
+		$('.fittext').each(function() {
+			var $this = $(this);
+
+			// this element has already been initialized
+			// and we're only initializing new modules
+			if($this.data('isFittext') && !all) {
+				return true;
+
+			// this element has already been initialized
+			// and we need to reinitialize it
+			} else if($this.data('isFittext') && all) {
+				$this.trigger('gumby.initialize');
+				return true;
+			}
+
+			// mark element as initialized
+			$this.data('isFittext', true);
+			new FitText($this);
+		});
+	});
+
+	// register UI module
+	Gumby.UIModule({
+		module: 'fittext',
+		events: ['initialize'],
+		init: function() {
+			Gumby.initialize('fittext');
+		}
+	});
+}();

data/app/assets/javascripts/gumby/libs/extensions/gumby.images.js

@@ -0,0 +1,202 @@
+/**
+* Gumby Images
+* http://github.com/GumbyFramework/ResponsiveImages v1.1.0
+*/
+!function() {
+
+	'use strict';
+
+	function Images($el) {
+
+		Gumby.debug('Initializing Responsive Images module', $el);
+
+		this.$el = $el;
+
+		this.type = '';
+		this.supports = '';
+		this.media = '';
+		this.def = '';
+		this.current = '';
+
+		// set up module based on attributes
+		this.setup();
+
+		var scope = this;
+		$(window).on('load gumby.trigger '+(!this.media || 'resize'), function(e) {
+			scope.fire();
+		});
+
+		this.$el.on('gumby.initialize', function() {
+			Gumby.debug('Re-initializing Responsive Images module', scope.$el);
+			scope.setup();
+			scope.fire();
+		});
+
+		scope.fire();
+	}
+
+	// set up module based on attributes
+	Images.prototype.setup = function() {
+		// is this an <img> or background-image?
+		this.type = this.$el.is('img') ? 'img' : 'bg';
+		// supports attribute in format test:image
+		this.supports = Gumby.selectAttr.apply(this.$el, ['supports']) || false;
+		// media attribute in format mediaQuery:image
+		this.media = Gumby.selectAttr.apply(this.$el, ['media']) || false;
+		// default image to load
+		this.def = Gumby.selectAttr.apply(this.$el, ['default']) || false;
+
+		// parse support/media objects
+		if(this.supports) { this.supports = this.parseAttr(this.supports); }
+		if(this.media) { this.media = this.parseAttr(this.media); }
+
+		// check functions
+		this.checks = {
+			supports : function(val) {
+				return Modernizr[val];
+			},
+			media: function(val) {
+				return window.matchMedia(val).matches;
+			}
+		};
+	};
+
+	// fire required checks and load resulting image
+	Images.prototype.fire = function() {
+		// feature supported or media query matched
+		var success = false;
+
+		// if support attribute supplied and Modernizr is present
+		if(this.supports && Modernizr) {
+			success = this.handleTests('supports', this.supports);
+		}
+
+		// if media attribute supplied and matchMedia is supported
+		// and success is still false, meaning no supporting feature was found
+		if(this.media && window.matchMedia && !success) {
+			success = this.handleTests('media', this.media);
+		}
+
+		// no feature supported or media query matched so load default if supplied
+		if(!success && this.def) {
+			success = this.def;
+		}
+
+		// no image to load
+		if(!success) {
+			return false;
+		}
+
+		// preload image and insert or set background-image property if not already set
+		if(this.current !== success) {
+			this.current = success;
+			this.insertImage(this.type, success);
+		}
+	};
+
+	// handle media object checking each prop for matching media query
+	Images.prototype.handleTests = function(type, array) {
+		var scope = this,
+			supported = false;
+
+		$(array).each(function(key, val) {
+			// media query matched
+			// supplied in order of preference so halt each loop
+			if(scope.check(type, val.test)) {
+				supported = val.img;
+				return false;
+			}
+		});
+
+		return supported;
+	};
+
+	// return the result of test function
+	Images.prototype.check = function(type, val) {
+		return this.checks[type](val);
+	};
+
+	// preload image and insert or set background-image property
+	Images.prototype.insertImage = function(type, img) {
+		var scope = this,
+			image = $(new Image());
+
+		image.load(function() {
+			type === 'img' ? scope.$el.attr('src', img) : scope.$el.css('background-image', 'url('+img+')');
+
+			// trigger custom loaded event
+			Gumby.debug('Triggering onChange event', img, scope.$el);
+			scope.$el.trigger('gumby.onChange', [img]);
+		}).attr('src', img);
+	};
+
+	// parse attribute strings, media/support
+	Images.prototype.parseAttr = function(support) {
+		var scope = this,
+			supp = support.split(','),
+			res = [], splt = [];
+
+		// multiple can be supplied so loop round and create object
+		$(supp).each(function(key, val) {
+			splt = val.split('|');
+			if(splt.length !== 2) {
+				return true;
+			}
+
+			// object containing Modernizr test or media query and image url
+			res.push({
+				'test' : scope.shorthand(splt[0]),
+				'img' : splt[1]
+			});
+		});
+
+		return res;
+	};
+
+	// replace < and > with min/max width media queries
+	Images.prototype.shorthand = function(str) {
+		// replace < and >
+		if(str.indexOf('>') > -1 || str.indexOf('<') > -1) {
+			str = str.replace('>', 'min-width: ').replace('<', 'max-width: ');
+		}
+
+		// check if media query wrapped in ()
+		if(str.charAt(0) !== '(' && str.charAt(str.length - 1) !== ')') {
+			str = '('+str+')';
+		}
+
+		return str;
+	};
+
+	// add initialisation
+	Gumby.addInitalisation('images', function(all) {
+		$('[gumby-supports],[data-supports],[supports],[gumby-media],[data-media],[media]').each(function() {
+			var $this = $(this);
+
+			// this element has already been initialized
+			// and we're only initializing new modules
+			if($this.data('isImage') && !all) {
+				return true;
+
+			// this element has already been initialized
+			// and we need to reinitialize it
+			} else if($this.data('isImage') && all) {
+				$this.trigger('gumby.initialize');
+				return true;
+			}
+
+			// mark element as initialized
+			$this.data('isImage', true);
+			new Images($this);
+		});
+	});
+
+	// register UI module
+	Gumby.UIModule({
+		module: 'images',
+		events: ['onChange', 'trigger'],
+		init: function() {
+			Gumby.initialize('images');
+		}
+	});
+}();