mui_app_rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a878628587b89fdd9513fde1d79af4204308c421
+  data.tar.gz: 166ef6dd5788da1499ffda6dc0c64826370f2a44
+SHA512:
+  metadata.gz: 7ebec06eca54e807b0bf08eb299b0119897bbc5d810c053d146c4e43a86c4c4ae759c06bc24440d93e74b03740efce1761bea00336da214303f481b491f201cd
+  data.tar.gz: 11430bf459db6c08d5ae94b373e5a008ed89e9e3b8ad52e3b6424e313d424ea349e62141e03841bd2e052b56baefbe290c5520f3a2c2346bc6178da5893e7a80

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    = 'MuiAppRails'
+  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/mui_app_rails/actions.js

@@ -0,0 +1,26 @@
+/**
+ * actions
+ * @param {type} $
+ * @param {type} name
+ * @returns {undefined}
+ */
+(function($, name) {
+	var CLASS_ACTION = $.className('action');
+
+	var handle = function(event, target) {
+		if (target.className && ~target.className.indexOf(CLASS_ACTION)) {
+			event.preventDefault();
+			return target;
+		}
+		return false;
+	};
+
+	$.registerTarget({
+		name: name,
+		index: 50,
+		handle: handle,
+		target: false,
+		isContinue: true
+	});
+
+})(mui, 'action');

data/app/assets/javascripts/mui_app_rails/ajax.plugin.js

@@ -0,0 +1,3 @@
+(function($) {
+    //TODO
+})(mui);

data/app/assets/javascripts/mui_app_rails/input.plugin.js

@@ -0,0 +1,232 @@
+/**
+ * Input(TODO resize)
+ * @param {type} $
+ * @param {type} window
+ * @param {type} document
+ * @returns {undefined}
+ */
+(function($, window, document) {
+	var CLASS_ICON = $.className('icon');
+	var CLASS_ICON_CLEAR = $.className('icon-clear');
+	var CLASS_ICON_SPEECH = $.className('icon-speech');
+	var CLASS_ICON_SEARCH = $.className('icon-search');
+	var CLASS_INPUT_ROW = $.className('input-row');
+	var CLASS_PLACEHOLDER = $.className('placeholder');
+	var CLASS_TOOLTIP = $.className('tooltip');
+	var CLASS_HIDDEN = $.className('hidden');
+	var CLASS_FOCUSIN = $.className('focusin');
+	var SELECTOR_ICON_CLOSE = '.' + CLASS_ICON_CLEAR;
+	var SELECTOR_ICON_SPEECH = '.' + CLASS_ICON_SPEECH;
+	var SELECTOR_PLACEHOLDER = '.' + CLASS_PLACEHOLDER;
+	var SELECTOR_TOOLTIP = '.' + CLASS_TOOLTIP;
+
+	var findRow = function(target) {
+		for (; target && target !== document; target = target.parentNode) {
+			if (target.classList && target.classList.contains(CLASS_INPUT_ROW)) {
+				return target;
+			}
+		}
+		return null;
+	};
+	var Input = function(element, options) {
+		this.element = element;
+		this.options = options || {
+			actions: 'clear'
+		};
+		if (~this.options.actions.indexOf('slider')) { //slider
+			this.sliderActionClass = CLASS_TOOLTIP + ' ' + CLASS_HIDDEN;
+			this.sliderActionSelector = SELECTOR_TOOLTIP;
+		} else { //clear,speech,search
+			if (~this.options.actions.indexOf('clear')) {
+				this.clearActionClass = CLASS_ICON + ' ' + CLASS_ICON_CLEAR + (element.value ? '' : (' ' + CLASS_HIDDEN));
+				this.clearActionSelector = SELECTOR_ICON_CLOSE;
+			}
+			if (~this.options.actions.indexOf('speech')) { //only for 5+
+				this.speechActionClass = CLASS_ICON + ' ' + CLASS_ICON_SPEECH;
+				this.speechActionSelector = SELECTOR_ICON_SPEECH;
+			}
+			if (~this.options.actions.indexOf('search')) {
+				this.searchActionClass = CLASS_PLACEHOLDER;
+				this.searchActionSelector = SELECTOR_PLACEHOLDER;
+			}
+		}
+		this.init();
+	};
+	Input.prototype.init = function() {
+		this.initAction();
+		this.initElementEvent();
+	};
+	Input.prototype.initAction = function() {
+		var self = this;
+
+		var row = self.element.parentNode;
+		if (row) {
+			if (self.sliderActionClass) {
+				self.sliderAction = self.createAction(row, self.sliderActionClass, self.sliderActionSelector);
+			} else {
+				if (self.searchActionClass) {
+					self.searchAction = self.createAction(row, self.searchActionClass, self.searchActionSelector);
+					self.searchAction.addEventListener('tap', function(e) {
+						$.focus(self.element);
+						e.stopPropagation();
+					});
+				}
+				if (self.speechActionClass) {
+					self.speechAction = self.createAction(row, self.speechActionClass, self.speechActionSelector);
+					self.speechAction.addEventListener('click', $.stopPropagation);
+					self.speechAction.addEventListener('tap', function(event) {
+						self.speechActionClick(event);
+					});
+				}
+				if (self.clearActionClass) {
+					self.clearAction = self.createAction(row, self.clearActionClass, self.clearActionSelector);
+					self.clearAction.addEventListener('tap', function(event) {
+						self.clearActionClick(event);
+					});
+
+				}
+			}
+		}
+	};
+	Input.prototype.createAction = function(row, actionClass, actionSelector) {
+		var action = row.querySelector(actionSelector);
+		if (!action) {
+			var action = document.createElement('span');
+			action.className = actionClass;
+			if (actionClass === this.searchActionClass) {
+				action.innerHTML = '<span class="' + CLASS_ICON + ' ' + CLASS_ICON_SEARCH + '"></span>' + this.element.getAttribute('placeholder');
+				this.element.setAttribute('placeholder', '');
+				if (this.element.value.trim()) {
+					row.classList.add($.className('active'));
+				}
+			}
+			row.insertBefore(action, this.element.nextSibling);
+		}
+		return action;
+	};
+	Input.prototype.initElementEvent = function() {
+		var element = this.element;
+
+		if (this.sliderActionClass) {
+			var tooltip = this.sliderAction;
+			//TODO resize
+			var offsetLeft = element.offsetLeft;
+			var width = element.offsetWidth - 28;
+			var tooltipWidth = tooltip.offsetWidth;
+			var distince = Math.abs(element.max - element.min);
+
+			var timer = null;
+			var showTip = function() {
+				tooltip.classList.remove(CLASS_HIDDEN);
+				tooltipWidth = tooltipWidth || tooltip.offsetWidth;
+				var scaleWidth = Math.abs(element.value) / distince * width;
+				tooltip.style.left = (14 + offsetLeft + scaleWidth - tooltipWidth / 2) + 'px';
+				tooltip.innerText = element.value;
+				if (timer) {
+					clearTimeout(timer);
+				}
+				timer = setTimeout(function() {
+					tooltip.classList.add(CLASS_HIDDEN);
+				}, 1000);
+			};
+			element.addEventListener('input', showTip);
+			element.addEventListener('tap', showTip);
+			element.addEventListener('touchmove', function(e) {
+				e.stopPropagation();
+			});
+		} else {
+			if (this.clearActionClass) {
+				var action = this.clearAction;
+				if (!action) {
+					return;
+				}
+				$.each(['keyup', 'change', 'input', 'focus', 'blur', 'cut', 'paste'], function(index, type) {
+					(function(type) {
+						element.addEventListener(type, function() {
+							action.classList[element.value.trim() ? 'remove' : 'add'](CLASS_HIDDEN);
+						});
+					})(type);
+				});
+			}
+			if (this.searchActionClass) {
+				element.addEventListener('focus', function() {
+					element.parentNode.classList.add($.className('active'));
+				});
+				element.addEventListener('blur', function() {
+					if (!element.value.trim()) {
+						element.parentNode.classList.remove($.className('active'));
+					}
+				});
+			}
+		}
+	};
+	Input.prototype.clearActionClick = function(event) {
+		var self = this;
+		self.element.value = '';
+		$.focus(self.element);
+		self.clearAction.classList.add(CLASS_HIDDEN);
+		event.preventDefault();
+	};
+	Input.prototype.speechActionClick = function(event) {
+		if (window.plus) {
+			var self = this;
+			var oldValue = self.element.value;
+			self.element.value = '';
+			document.body.classList.add(CLASS_FOCUSIN);
+			plus.speech.startRecognize({
+				engine: 'iFly'
+			}, function(s) {
+				self.element.value += s;
+				$.focus(self.element);
+				plus.speech.stopRecognize();
+				$.trigger(self.element, 'recognized', {
+					value: self.element.value
+				});
+				if (oldValue !== self.element.value) {
+					$.trigger(self.element, 'change');
+					$.trigger(self.element, 'input');
+				}
+				// document.body.classList.remove(CLASS_FOCUSIN);
+			}, function(e) {
+				document.body.classList.remove(CLASS_FOCUSIN);
+			});
+		} else {
+			alert('only for 5+');
+		}
+		event.preventDefault();
+	};
+	$.fn.input = function(options) {
+		this.each(function() {
+			var actions = [];
+			var row = findRow(this.parentNode);
+			if (this.type === 'range' && row.classList.contains($.className('input-range'))) {
+				actions.push('slider');
+			} else {
+				var classList = this.classList;
+				if (classList.contains($.className('input-clear'))) {
+					actions.push('clear');
+				}
+				if (classList.contains($.className('input-speech'))) {
+					actions.push('speech');
+				}
+				if (this.type === 'search' && row.classList.contains($.className('search'))) {
+					actions.push('search');
+				}
+			}
+			var id = this.getAttribute('data-input-' + actions[0]);
+			if (!id) {
+				id = ++$.uuid;
+				$.data[id] = new Input(this, {
+					actions: actions.join(',')
+				});
+				for (var i = 0, len = actions.length; i < len; i++) {
+					this.setAttribute('data-input-' + actions[i], id);
+				}
+			}
+
+		});
+	};
+	$.ready(function() {
+		$($.classSelector('.input-row input')).input();
+	});
+})(mui, window, document);

data/app/assets/javascripts/mui_app_rails/modals.js

@@ -0,0 +1,37 @@
+/**
+ * Modals
+ * @param {type} $
+ * @param {type} window
+ * @param {type} document
+ * @param {type} name
+ * @returns {undefined}
+ */
+(function($, window, document, name) {
+	var CLASS_MODAL = $.className('modal');
+
+	var handle = function(event, target) {
+		if (target.tagName === 'A' && target.hash) {
+			var modal = document.getElementById(target.hash.replace('#', ''));
+			if (modal && modal.classList.contains(CLASS_MODAL)) {
+				return modal;
+			}
+		}
+		return false;
+	};
+
+	$.registerTarget({
+		name: name,
+		index: 50,
+		handle: handle,
+		target: false,
+		isReset: false,
+		isContinue: true
+	});
+
+	window.addEventListener('tap', function(event) {
+		if ($.targets.modal) {
+			event.detail.gesture.preventDefault(); //fixed hashchange
+			$.targets.modal.classList.toggle($.className('active'));
+		}
+	});
+})(mui, window, document, 'modal');

data/app/assets/javascripts/mui_app_rails/mui.active.js

@@ -0,0 +1,30 @@
+/**
+ * TODO mui active
+ */
+(function(window) {
+	var active;
+	window.addEventListener('touchstart', function(event) {
+		var target = event.target;
+		var isCellDisabled = false;
+		for (; target && target !== document; target = target.parentNode) {
+			if (target.classList) {
+				var classList = target.classList;
+				if (classList.contains(CLASS_DISABLED)) { //normal
+					isCellDisabled = true;
+				} else if (target.tagName === 'INPUT' || target.tagName === 'BUTTON' || classList.contains(CLASS_TOGGLE) || classList.contains(CLASS_BTN)) {
+					isCellDisabled = true;
+				}
+				if (classList.contains(CLASS_TABLE_VIEW_CELL)) {
+					if (!isCellDisabled) {
+						active = target;
+						var link = cell.querySelector('a');
+						if (link && link.parentNode === cell) { //li>a
+							active = link;
+						}
+					}
+					break;
+				}
+			}
+		}
+	});
+})(window);

data/app/assets/javascripts/mui_app_rails/mui.ajax.5+.js

@@ -0,0 +1,27 @@
+/**
+ * 5+ ajax
+ */
+(function($) {
+	var originAnchor = document.createElement('a');
+	originAnchor.href = window.location.href;
+	$.plusReady(function() {
+		$.ajaxSettings = $.extend($.ajaxSettings, {
+			xhr: function(settings) {
+				if (settings.crossDomain) { //强制使用plus跨域
+					return new plus.net.XMLHttpRequest();
+				}
+				//仅在webview的url为远程文件，且ajax请求的资源不同源下使用plus.net.XMLHttpRequest
+				if (originAnchor.protocol !== 'file:') {
+					var urlAnchor = document.createElement('a');
+					urlAnchor.href = settings.url;
+					urlAnchor.href = urlAnchor.href;
+					settings.crossDomain = (originAnchor.protocol + '//' + originAnchor.host) !== (urlAnchor.protocol + '//' + urlAnchor.host);
+					if (settings.crossDomain) {
+						return new plus.net.XMLHttpRequest();
+					}
+				}
+				return new window.XMLHttpRequest();
+			}
+		});
+	});
+})(mui);

data/app/assets/javascripts/mui_app_rails/mui.ajax.js

@@ -0,0 +1,277 @@
+/**
+ * mui ajax
+ * @param {type} $
+ * @returns {undefined}
+ */
+(function($, window, undefined) {
+
+	var jsonType = 'application/json';
+	var htmlType = 'text/html';
+	var rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi;
+	var scriptTypeRE = /^(?:text|application)\/javascript/i;
+	var xmlTypeRE = /^(?:text|application)\/xml/i;
+	var blankRE = /^\s*$/;
+
+	$.ajaxSettings = {
+		type: 'GET',
+		beforeSend: $.noop,
+		success: $.noop,
+		error: $.noop,
+		complete: $.noop,
+		context: null,
+		xhr: function(protocol) {
+			return new window.XMLHttpRequest();
+		},
+		accepts: {
+			script: 'text/javascript, application/javascript, application/x-javascript',
+			json: jsonType,
+			xml: 'application/xml, text/xml',
+			html: htmlType,
+			text: 'text/plain'
+		},
+		timeout: 0,
+		processData: true,
+		cache: true
+	};
+	var ajaxBeforeSend = function(xhr, settings) {
+		var context = settings.context
+		if (settings.beforeSend.call(context, xhr, settings) === false) {
+			return false;
+		}
+	};
+	var ajaxSuccess = function(data, xhr, settings) {
+		settings.success.call(settings.context, data, 'success', xhr);
+		ajaxComplete('success', xhr, settings);
+	};
+	// type: "timeout", "error", "abort", "parsererror"
+	var ajaxError = function(error, type, xhr, settings) {
+		settings.error.call(settings.context, xhr, type, error);
+		ajaxComplete(type, xhr, settings);
+	};
+	// status: "success", "notmodified", "error", "timeout", "abort", "parsererror"
+	var ajaxComplete = function(status, xhr, settings) {
+		settings.complete.call(settings.context, xhr, status);
+	};
+
+	var serialize = function(params, obj, traditional, scope) {
+		var type, array = $.isArray(obj),
+			hash = $.isPlainObject(obj);
+		$.each(obj, function(key, value) {
+			type = $.type(value);
+			if (scope) {
+				key = traditional ? scope :
+					scope + '[' + (hash || type === 'object' || type === 'array' ? key : '') + ']';
+			}
+			// handle data in serializeArray() format
+			if (!scope && array) {
+				params.add(value.name, value.value);
+			}
+			// recurse into nested objects
+			else if (type === "array" || (!traditional && type === "object")) {
+				serialize(params, value, traditional, key);
+			} else {
+				params.add(key, value);
+			}
+		});
+	};
+	var serializeData = function(options) {
+		if (options.processData && options.data && typeof options.data !== "string") {
+			options.data = $.param(options.data, options.traditional);
+		}
+		if (options.data && (!options.type || options.type.toUpperCase() === 'GET')) {
+			options.url = appendQuery(options.url, options.data);
+			options.data = undefined;
+		}
+	};
+	var appendQuery = function(url, query) {
+		if (query === '') {
+			return url;
+		}
+		return (url + '&' + query).replace(/[&?]{1,2}/, '?');
+	};
+	var mimeToDataType = function(mime) {
+		if (mime) {
+			mime = mime.split(';', 2)[0];
+		}
+		return mime && (mime === htmlType ? 'html' :
+			mime === jsonType ? 'json' :
+			scriptTypeRE.test(mime) ? 'script' :
+			xmlTypeRE.test(mime) && 'xml') || 'text';
+	};
+	var parseArguments = function(url, data, success, dataType) {
+		if ($.isFunction(data)) {
+			dataType = success, success = data, data = undefined;
+		}
+		if (!$.isFunction(success)) {
+			dataType = success, success = undefined;
+		}
+		return {
+			url: url,
+			data: data,
+			success: success,
+			dataType: dataType
+		};
+	};
+	$.ajax = function(url, options) {
+		if (typeof url === "object") {
+			options = url;
+			url = undefined;
+		}
+		var settings = options || {};
+		settings.url = url || settings.url;
+		for (var key in $.ajaxSettings) {
+			if (settings[key] === undefined) {
+				settings[key] = $.ajaxSettings[key];
+			}
+		}
+		serializeData(settings);
+		var dataType = settings.dataType;
+
+		if (settings.cache === false || ((!options || options.cache !== true) && ('script' === dataType))) {
+			settings.url = appendQuery(settings.url, '_=' + $.now());
+		}
+		var mime = settings.accepts[dataType];
+		var headers = {};
+		var setHeader = function(name, value) {
+			headers[name.toLowerCase()] = [name, value];
+		};
+		var protocol = /^([\w-]+:)\/\//.test(settings.url) ? RegExp.$1 : window.location.protocol;
+		var xhr = settings.xhr(settings);
+		var nativeSetHeader = xhr.setRequestHeader;
+		var abortTimeout;
+
+		setHeader('X-Requested-With', 'XMLHttpRequest');
+		setHeader('Accept', mime || '*/*');
+		if (!!(mime = settings.mimeType || mime)) {
+			if (mime.indexOf(',') > -1) {
+				mime = mime.split(',', 2)[0];
+			}
+			xhr.overrideMimeType && xhr.overrideMimeType(mime);
+		}
+		if (settings.contentType || (settings.contentType !== false && settings.data && settings.type.toUpperCase() !== 'GET')) {
+			setHeader('Content-Type', settings.contentType || 'application/x-www-form-urlencoded');
+		}
+		if (settings.headers) {
+			for (var name in settings.headers)
+				setHeader(name, settings.headers[name]);
+		}
+		xhr.setRequestHeader = setHeader;
+
+		xhr.onreadystatechange = function() {
+			if (xhr.readyState === 4) {
+				xhr.onreadystatechange = $.noop;
+				clearTimeout(abortTimeout);
+				var result, error = false;
+				if ((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304 || (xhr.status === 0 && protocol === 'file:')) {
+					dataType = dataType || mimeToDataType(settings.mimeType || xhr.getResponseHeader('content-type'));
+					result = xhr.responseText;
+					try {
+						// http://perfectionkills.com/global-eval-what-are-the-options/
+						if (dataType === 'script') {
+							(1, eval)(result);
+						} else if (dataType === 'xml') {
+							result = xhr.responseXML;
+						} else if (dataType === 'json') {
+							result = blankRE.test(result) ? null : $.parseJSON(result);
+						}
+					} catch (e) {
+						error = e;
+					}
+
+					if (error) {
+						ajaxError(error, 'parsererror', xhr, settings);
+					} else {
+						ajaxSuccess(result, xhr, settings);
+					}
+				} else {
+					ajaxError(xhr.statusText || null, xhr.status ? 'error' : 'abort', xhr, settings);
+				}
+			}
+		};
+		if (ajaxBeforeSend(xhr, settings) === false) {
+			xhr.abort();
+			ajaxError(null, 'abort', xhr, settings);
+			return xhr;
+		}
+
+		if (settings.xhrFields) {
+			for (var name in settings.xhrFields) {
+				xhr[name] = settings.xhrFields[name];
+			}
+		}
+
+		var async = 'async' in settings ? settings.async : true;
+
+		xhr.open(settings.type.toUpperCase(), settings.url, async, settings.username, settings.password);
+
+		for (var name in headers) {
+			nativeSetHeader.apply(xhr, headers[name]);
+		}
+		if (settings.timeout > 0) {
+			abortTimeout = setTimeout(function() {
+				xhr.onreadystatechange = $.noop;
+				xhr.abort();
+				ajaxError(null, 'timeout', xhr, settings);
+			}, settings.timeout);
+		}
+		xhr.send(settings.data ? settings.data : null);
+		return xhr;
+	};
+
+
+	$.param = function(obj, traditional) {
+		var params = [];
+		params.add = function(k, v) {
+			this.push(encodeURIComponent(k) + '=' + encodeURIComponent(v));
+		};
+		serialize(params, obj, traditional);
+		return params.join('&').replace(/%20/g, '+');
+	};
+	$.get = function( /* url, data, success, dataType */ ) {
+		return $.ajax(parseArguments.apply(null, arguments));
+	};
+
+	$.post = function( /* url, data, success, dataType */ ) {
+		var options = parseArguments.apply(null, arguments);
+		options.type = 'POST';
+		return $.ajax(options);
+	};
+
+	$.getJSON = function( /* url, data, success */ ) {
+		var options = parseArguments.apply(null, arguments);
+		options.dataType = 'json';
+		return $.ajax(options);
+	};
+
+	$.fn.load = function(url, data, success) {
+		if (!this.length)
+			return this;
+		var self = this,
+			parts = url.split(/\s/),
+			selector,
+			options = parseArguments(url, data, success),
+			callback = options.success;
+		if (parts.length > 1)
+			options.url = parts[0], selector = parts[1];
+		options.success = function(response) {
+			if (selector) {
+				var div = document.createElement('div');
+				div.innerHTML = response.replace(rscript, "");
+				var selectorDiv = document.createElement('div');
+				var childs = div.querySelectorAll(selector);
+				if (childs && childs.length > 0) {
+					for (var i = 0, len = childs.length; i < len; i++) {
+						selectorDiv.appendChild(childs[i]);
+					}
+				}
+				self[0].innerHTML = selectorDiv.innerHTML;
+			} else {
+				self[0].innerHTML = response;
+			}
+			callback && callback.apply(self, arguments);
+		};
+		$.ajax(options);
+		return this;
+	};
+
+})(mui, window);