☰

GM 2 port - Function Override Helper

Not yet.

当前为 2014-06-18 提交的版本，查看 最新版本。

此脚本不应直接安装。它是供其他脚本使用的外部库，要使用该库请加入元指令 // @require https://update.cn-greasyfork.org/scripts/2599/7130/GM%202%20port%20-%20Function%20Override%20Helper.js 

  1. // ==UserScript==
  2. // @name        GM 2 port - Function Override Helper
  3. // @Description Not yet.
  4. // @namespace   org.jixun.gm2.port
  5. // @version     1.0.1
  6.  
  7. // unsafeWindow required to use `exportFunction`.
  8. // @grant       unsafeWindow
  9.  
  10. // @run-at      document-start
  11. // ==/UserScript==
  12.  
  13. // Check if is GM 2.x
  14. if (typeof exportFunction == 'undefined') {
  15. 	// For GM 1.x backward compatibility, should work.
  16. 	var exportFunction = (function (foo, scope, defAs) {
  17. 		scope[defAs.defineAs] = foo;
  18. 	}).bind(unsafeWindow);
  19.  
  20. 	// Well.. It's not going to do anything.
  21. 	var cloneInto = (function (obj, scope, opt) {
  22. 		return obj;
  23. 	}).bind(unsafeWindow);
  24. }
  25.  
  26. /**
  27.  * unsafeObject:
  28.  * Basically cloneInto but could without scope (Default: unsafeWindow)
  29.  * 
  30.  * @param  {Object} obj   Object to pass through
  31.  * @param  {Object} scope Scope where object is going to be applied.
  32.  * @param  {Object} opt   Options
  33.  * @return {Object}       A reference to the cloned object.
  34.  */
  35. var unsafeObject = function (obj, scope, opt) {
  36. 	return cloneInto (obj, scope || unsafeWindow, opt || {});
  37. };
  38.  
  39. /**
  40.  * unsafeDefineFunction
  41.  * @param  {String} fooName Target name
  42.  * @param  {Function} foo   The function to override
  43.  * @param  {Object} scope   unsafeWindow
  44.  * @return {Function}       The placeholder function which has been created in the target context.
  45.  */
  46. var unsafeDefineFunction = function (fooName, foo, scope) {
  47. 	// @throw TypeError: can't redefine non-configurable property
  48. 	// @throw Error: First argument must be a function
  49. 	return exportFunction (foo, scope || unsafeWindow, {defineAs: fooName});
  50. };
  51.  
  52. /**
  53.  * unsafeOverwriteFunction
  54.  * @param  {Object} fooMapping {name: foo}
  55.  * @param  {Object} scope      unsafeWindow
  56.  * @param  {String} scopeName  Optional, required if target is not `window`.
  57.  *                             e.g. The target is window.api.xxx, '.api' would
  58.  *                             be the scopeName.
  59.  * @return {HTML Element}      Script Tag
  60.  */
  61. var unsafeOverwriteFunction = function (fooMapping, scope, scopeName) {
  62. 	var argMapping = {}, tmpName;
  63.  
  64. 	// Mapping new random names.
  65. 	for (var x in fooMapping) {
  66. 		if (fooMapping.hasOwnProperty(x)) {
  67. 			try {
  68. 				tmpName = 'u_w_f_' + Math.random().toString().slice(2) + +new Date();
  69. 				
  70. 				// Export function
  71. 				// unsafeDefineFunction will take care of null values.
  72. 				unsafeDefineFunction (tmpName, fooMapping[x], scope);
  73. 				argMapping[x] = tmpName;
  74. 			} catch (e) {
  75. 				console.error ('Error at `unsafeOverwrite`:', e);
  76. 			}
  77. 		}
  78. 	}
  79.  
  80. 	var tmpScript = document.createElement ('script');
  81. 	tmpScript.textContent = ';('+ (function (j, x) {
  82. 		for (x in j)
  83. 			if (j.hasOwnProperty(x))
  84. 				// Map everything.
  85. 				// If Object with custom function / Function 
  86. 				// passed in it will throw CloneNonReflectorsWrite.
  87. 				// Use unsafeOverwriteFunctionSafeProxy if you need to bypass that.
  88. 				// However, it's going to be slower.
  89. 				window/**/[x] = window/**/[j[x]];
  90. 		
  91. 		// TODO: Maybe remove this script tag after finish?
  92. 	}).toString().replace(/\/\*\*\//g, scopeName ? scopeName : '') +')(' + JSON.stringify(argMapping) + ');';
  93. 	document.head.appendChild (tmpScript);
  94.  
  95. 	return tmpScript;
  96. };
  97.  
  98. /**
  99.  * ErrorUnsafe:
  100.  * An error class for unsafeOverwriteFunctionSafeProxy.
  101.  * 
  102.  * @param {String} name    Error Name
  103.  * @param {String} message Error Message
  104.  */
  105. var ErrorUnsafe = function (name, message) {
  106. 	return cloneInto ({
  107. 		name: name || 'ErrorUnsafe',
  108. 		message: message || 'Unknown error.'
  109. 	}, scope || unsafeWindow);
  110. };
  111.  
  112. /**
  113.  * ErrorUnsafeSuccess:
  114.  * An Error Class for unsafeOverwriteFunctionSafeProxy.
  115.  * Inform proxy to execute origional function with its full arguments.
  116.  * 
  117.  * @param {[type]} message [description]
  118.  * @param {[type]} scope   [description]
  119.  */
  120. var ErrorUnsafeSuccess = function (message, scope) {
  121. 	return cloneInto ({
  122. 		name: 'ErrorUnsafeSuccess: ProxyFinish',
  123. 		success: true,
  124. 		message: message || ''
  125. 	}, scope || unsafeWindow);
  126. };
  127.  
  128. /**
  129.  * unsafeOverwriteFunctionSafeProxy
  130.  * Similar to unsafeOverwriteFunction, but its a proxy instead.
  131.  * It will strip all functions before pass in to sandboxed function.
  132.  * So, it can prevent CloneNonReflectorsWrite error.
  133.  * 
  134.  * @param  {[type]} fooMapping [description]
  135.  * @param  {[type]} scope      [description]
  136.  * @param  {[type]} scopeName  [description]
  137.  * @return {[type]}            [description]
  138.  */
  139. var unsafeOverwriteFunctionSafeProxy = function (fooMapping, scope, scopeName) {
  140. 	var argMapping = {}, tmpName;
  141.  
  142. 	// Mapping new random names.
  143. 	for (var x in fooMapping) {
  144. 		if (fooMapping.hasOwnProperty(x)) {
  145. 			try {
  146. 				tmpName = 'u_w_f_' + Math.random().toString().slice(2) + +new Date();
  147. 				
  148. 				// Export function
  149. 				// unsafeDefineFunction will take care of null values.
  150. 				unsafeDefineFunction (tmpName, fooMapping[x], scope);
  151. 				argMapping[x] = tmpName;
  152. 			} catch (e) {
  153. 				console.error ('Error at `unsafeOverwrite`:', e);
  154. 				alert (e);
  155. 			}
  156. 		}
  157. 	}
  158.  
  159. 	var tmpScript = document.createElement ('script');
  160. 	tmpScript.textContent = ';('+ (function (j, x) {
  161. 		for (x in j)
  162. 			if (j.hasOwnProperty(x)) {
  163. 				(function (x, bak, foo) {
  164. 					// Assign variable to our proxy function.
  165. 					window/**/[x] = function () {
  166. 						// console.info (arguments);
  167. 							for (var i = 0, y, args = []; i < arguments.length; i++) {
  168. 								// Array - Sure we can handle this right?
  169. 								if (arguments[i] instanceof Array) {
  170. 									args.push (arguments[i].slice());
  171. 								} else if (arguments[i] instanceof Object) {
  172. 									// Strip off all prototype functions, if possible.
  173. 									
  174. 									// TODO: maybe try-catch the following line?
  175. 									args.push (JSON.parse(JSON.stringify (arguments[i])));
  176. 								} else if ('function' == typeof arguments[i]) {
  177. 									// Function can't be sandboxied :<
  178. 									args.push (null);
  179. 								} else {
  180. 									// idk... should be safe to pass through?
  181. 									args.push (arguments[i]);
  182. 								}
  183. 							}
  184.  
  185. 						try {
  186. 							// Try to call our function!
  187. 							return foo.apply({}, args);
  188. 						} catch (err) {
  189. 							// We throw this error on purpose,
  190. 							// if we need to do the complete callback.
  191. 							
  192. 							// If the error don'e have success flag, we'll 
  193. 							// throw the error to console.
  194.  
  195. 							if (!err.success) console.error (err);
  196. 							return bak.apply ({}, arguments);
  197. 						}
  198. 					};
  199. 				}) (x, window/**/[x], window/**/[j[x]]);
  200. 			}
  201.  
  202. 		// TODO: Maybe remove this script tag after finish?
  203. 	}).toString().replace(/\/\*\*\//g, scopeName ? scopeName : '') +')(' + JSON.stringify(argMapping) + ');';
  204. 	document.head.appendChild (tmpScript);
  205.  
  206. 	return tmpScript;
  207. };