merge master branch

Author: Mihail Slavchev

binding-generator/Generator/src/com/tns/bindings/Dump.java

@@ -389,65 +389,110 @@ private Method[] groupMethodsByName(Method[] methods)
 
 		return result.values().toArray(new Method[result.size()]);
 	}
+	
+	private String getMethodSignature(Method m)
+	{
+		String sig = m.toGenericString();
+		
+		int nameIdx = sig.indexOf("(");
+		int endSigIdx = sig.indexOf(")") + 1;
+		
+		return m.getName() + sig.substring(nameIdx, endSigIdx);
+	}
 
 	private Method[] getSupportedMethods(Class<?> clazz, HashSet<String> methodOverrides)
 	{
 		ArrayList<Method> result = new ArrayList<Method>();
-		HashMap<String, Method> finalMethods = new HashMap<String, Method>();
-		ArrayList<Class<?>> implementedInterfaces = new ArrayList<Class<?>>();
-		while (clazz != null)
+
+		if (clazz.isInterface())
 		{
-			Method[] methods = clazz.getDeclaredMethods();
-			
-			ArrayList<Method> methodz = new ArrayList<Method>();
-			
-			for (int i = 0; i < methods.length; i++)
+			Set<String> objectMethods = new HashSet<String>();
+			for (Method objMethod: java.lang.Object.class.getDeclaredMethods())
 			{
-				Method candidateMethod = methods[i];
-				if (methodOverrides != null && !methodOverrides.contains(candidateMethod.getName()))
+				if (!Modifier.isStatic(objMethod.getModifiers()))
 				{
-					continue;
+					String sig = getMethodSignature(objMethod);
+					objectMethods.add(sig);
 				}
-				
-				methodz.add(methods[i]);
 			}
-			
-			
-			Class<?>[] interfaces = clazz.getInterfaces();
-			for (int i = 0; i < interfaces.length; i++)
+			Set<Method> notImplementedObjectMethods = new HashSet<Method>();
+			Method[] ifaceMethods = clazz.getDeclaredMethods();
+			for (Method ifaceMethod: ifaceMethods)
 			{
-				implementedInterfaces.add(interfaces[i]);
+				if (!Modifier.isStatic(ifaceMethod.getModifiers()))
+				{
+					String sig = getMethodSignature(ifaceMethod);
+					if (objectMethods.contains(sig) && !methodOverrides.contains(ifaceMethod.getName()))
+					{
+						notImplementedObjectMethods.add(ifaceMethod);
+					}
+				}
 			}
-			
-			for (int i = 0; i < methodz.size(); i++)
+			for (Method ifaceMethod: ifaceMethods)
 			{
-				Method method = methodz.get(i);
-				
-				if (isMethodSupported(method, finalMethods))
+				if (!notImplementedObjectMethods.contains(ifaceMethod))
 				{
-					result.add(method);
+					result.add(ifaceMethod);
 				}
 			}
-			
-			clazz = clazz.getSuperclass();
 		}
-		
-		for (int i = 0; i < implementedInterfaces.size(); i++)
+		else
 		{
-			Class<?> implementedInterface = implementedInterfaces.get(i);
-			Method[] interfaceMethods = implementedInterface.getMethods();
-			for (int j = 0; j < interfaceMethods.length; j++)
+			HashMap<String, Method> finalMethods = new HashMap<String, Method>();
+			ArrayList<Class<?>> implementedInterfaces = new ArrayList<Class<?>>();
+			while (clazz != null)
 			{
-				Method method = interfaceMethods[j];
+				Method[] methods = clazz.getDeclaredMethods();
+				
+				ArrayList<Method> methodz = new ArrayList<Method>();
+				
+				for (int i = 0; i < methods.length; i++)
+				{
+					Method candidateMethod = methods[i];
+					if (methodOverrides != null && !methodOverrides.contains(candidateMethod.getName()))
+					{
+						continue;
+					}
+					
+					methodz.add(methods[i]);
+				}
+				
+				Class<?>[] interfaces = clazz.getInterfaces();
+				for (int i = 0; i < interfaces.length; i++)
+				{
+					implementedInterfaces.add(interfaces[i]);
+				}
 
-				if (methodOverrides != null && !methodOverrides.contains(method.getName()))
+				for (int i = 0; i < methodz.size(); i++)
 				{
-					continue;
+					Method method = methodz.get(i);
+					
+					if (isMethodSupported(method, finalMethods))
+					{
+						result.add(method);
+					}
 				}
 
-				if (!isMethodMarkedAsFinalInClassHierarchy(method, finalMethods))
+				clazz = clazz.getSuperclass();
+			}
+			
+			for (int i = 0; i < implementedInterfaces.size(); i++)
+			{
+				Class<?> implementedInterface = implementedInterfaces.get(i);
+				Method[] interfaceMethods = implementedInterface.getMethods();
+				for (int j = 0; j < interfaceMethods.length; j++)
 				{
-					result.add(method);	
+					Method method = interfaceMethods[j];
+					
+					if (methodOverrides != null && !methodOverrides.contains(method.getName()))
+					{
+						continue;
+					}
+					
+					if (!isMethodMarkedAsFinalInClassHierarchy(method, finalMethods))
+					{
+						result.add(method);	
+					}
 				}
 			}
 		}
@@ -1158,4 +1203,4 @@ private int getDexModifiers(int modifiers)
 
 		return org.ow2.asmdex.Opcodes.ACC_PROTECTED;
 	}
-}
+}

build/project-template-gradle/build-tools/android-static-binding-generator/.gitignore

@@ -0,0 +1,38 @@
+var fs = require("fs"),
+	path = require("path");
+module.exports = function Helpers(config) {
+
+	function cleanOutFile(filePath) {
+		fs.truncateSync(filePath, 0);
+		if(config && config.logger) {
+			config.logger.info("+cleared out file: " + filePath);
+		}
+	}
+
+	function createFile(filePath) {
+		if(ensureDirectories(filePath)) {
+			fs.writeFileSync(filePath, "");
+			if(config && config.logger) {
+				config.logger.info("+created ast output file: ");
+			}
+		}
+		cleanOutFile(filePath)
+	}
+
+	function ensureDirectories(filePath) {
+		var parentDir = path.dirname(filePath);
+		if(fs.existsSync(parentDir)) {
+			return true;
+		}
+
+		ensureDirectories(parentDir);
+		fs.mkdirSync(parentDir);
+		return true;
+	}
+
+	return {
+		cleanOutFile: cleanOutFile,
+		createFile: createFile,
+		ensureDirectories: ensureDirectories
+	}
+};

build/project-template-gradle/build-tools/android-static-binding-generator/README.md

@@ -0,0 +1,47 @@
+var stringifyOnce = function(obj, replacer, indent){
+    var printedObjects = [];
+    var printedObjectKeys = [];
+    var passingIndent = 4;
+    if(indent) {
+        passingIndent = indent;
+    }
+
+    function printOnceReplacer(key, value){
+        if ( printedObjects.length > 2000){ // browsers will not print more than 20K, I don't see the point to allow 2K.. algorithm will not be fast anyway if we have too many objects
+        return 'object too long';
+        }
+        var printedObjIndex = false;
+        printedObjects.forEach(function(obj, index){
+            if(obj===value){
+                printedObjIndex = index;
+            }
+        });
+
+        if ( key == ''){ //root element
+             printedObjects.push(obj);
+            printedObjectKeys.push("root");
+             return value;
+        }
+
+        else if(printedObjIndex+"" != "false" && typeof(value)=="object"){
+            if ( printedObjectKeys[printedObjIndex] == "root"){
+                return "(pointer to root)";
+            }else{
+                return "(see " + ((!!value && !!value.constructor) ? value.constructor.name.toLowerCase()  : typeof(value)) + " with key " + printedObjectKeys[printedObjIndex] + ")";
+            }
+        }else{
+
+            var qualifiedKey = key || "(empty key)";
+            printedObjects.push(value);
+            printedObjectKeys.push(qualifiedKey);
+            if(replacer){
+                return replacer(key, value);
+            }else{
+                return value;
+            }
+        }
+    }
+    return JSON.stringify(obj, printOnceReplacer, passingIndent);
+};
+
+module.exports = stringifyOnce;

build/project-template-gradle/build-tools/android-static-binding-generator/ast-parser/.gitignore

@@ -0,0 +1,93 @@
+var fs = require('fs'),
+	path = require('path'),
+	os = require('os'),
+    fileHelpers = require("./file_helpers")();
+
+module.exports = function(setting){
+	
+    var logDirectory = path.dirname(setting.logPath);
+    if (!fs.existsSync(logDirectory)){
+        console.error("couldn't find logDirectory so it will be created in place:" + setting.logPath);
+        fileHelpers.ensureDirectories(setting.logPath);
+    }
+    if (os.type().indexOf('Windows') === -1) {
+        var appLogStat = fs.statSync(logDirectory);
+        if (canWrite(process.uid === appLogStat.uid, process.gid === appLogStat.gid, appLogStat.mode)){
+            console.error("ERROR WRITING TO LOG FILE DIRECTORY : " + logDirectory);
+            process.exit(-1);
+        }
+    }
+
+    var appLog = createLog(setting.APP_NAME, logDirectory, setting);
+	
+	if(setting.disable) {
+		for(var prop in appLog) {
+			appLog[prop] = function() {};
+		}
+	}
+	return appLog;
+};
+
+function canWrite(owner, inGroup, mode){
+    return owner && (mode & 00200) || // User is owner and owner can write.
+        inGroup && (mode & 00020) || // User is in group and group can write.
+        (mode & 00002); // Anyone can write.
+}
+
+function createLog(appName, logDirectory, setting){
+	
+	var appLog = {};
+	
+    function getRequestId() {
+        return (process.domain && process.domain.id) || "";
+    }
+
+    function getLogDate(){
+        var today = new Date();
+
+        var fullYear = today.getFullYear();
+        var month = today.getMonth();
+        var day = today.getDate();
+        var hours = today.getHours();
+        var minutes = today.getMinutes();
+        var seconds = today.getSeconds();
+
+        var logDate = fullYear + "-" + month + "-" + day + "/" + hours + ":" + minutes + ":" + seconds;
+        return logDate;
+    }
+
+    function setMessageWithFormat(message) {
+        var res = getLogDate() + "\t" + message;
+        return res;
+    }
+
+    function appendToLogFile(line) {
+        var logFile = logDirectory + path.sep + appName + ".log";
+        var augmentedLine = getLogDate() + "\t" + line + os.EOL
+        fs.appendFile(logFile, augmentedLine, function (err) {
+            if(err) {
+                throw "couldn't write to " + logFile; 
+            }
+        });
+    }
+    
+    appLog.log = function (input) {
+		console.log(setMessageWithFormat(input));
+        appendToLogFile(input);
+	}
+
+    appLog.info = appLog.log;
+    	
+    appLog.warn = function (input) {
+		console.warn(setMessageWithFormat(input));
+        appendToLogFile(input);
+	}
+	
+    appLog.error = function (input) {
+		console.error(setMessageWithFormat(input));
+        appendToLogFile(input);
+	}
+
+    return appLog;
+}
+

build/project-template-gradle/build-tools/android-static-binding-generator/ast-parser/example_command.txt

@@ -0,0 +1,2 @@
+*
+!.gitignore