[log] update

haxelib.json

@@ -4,7 +4,7 @@
   "license": "BSD",
   "tags": ["flash", "openfl"],
   "description": "Framework.",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "releasenote": "Update.",
   "contributors": ["shmyga"],
   "classPath": "src/main",

src/main/haxework/log/BaseLogger.hx

@@ -1,40 +1,44 @@
 package haxework.log;
 
-#if flash
-import flash.events.ErrorEvent;
-import flash.errors.Error;
-#end
 import haxework.log.ILogger.LogLevel;
+import haxe.CallStack;
+
+
+class LoggerUtil {
+
+    public static function printPos(pos:haxe.PosInfos):String {
+        return '${pos.fileName}:${pos.lineNumber}:';
+    }
+
+    public static function printStackItem(item:StackItem):String {
+        return switch item {
+            case StackItem.CFunction: 'CFunction';
+            case StackItem.Module(m): m;
+            case StackItem.FilePos(s, file, line): '${file}:${line}';
+            case StackItem.Method(classname, method): '${classname}::${method}}';
+            case StackItem.LocalFunction(v): 'LocalFunction(${v})';
+        }
+    }
+
+    public static function printError(error:Dynamic):String {
+        return error == null ? '' : Std.string('${error}\n\t${CallStack.exceptionStack().map(printStackItem).join('\n\t')}');
+    }
+}
+
 
 class BaseLogger implements ILogger {
 
     public function new() {}
 
     public function log(level:LogLevel, tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
-    write(buildString(level, tag, message, error), p);
+        write(buildString(level, tag, message, error, p));
     }
 
-  private function buildString(level:LogLevel, tag:String, message:String, ?error:Dynamic):String {
+    private function buildString(level:LogLevel, tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):String {
-    return  "[" + level + "] " + tag + " - " + message + (error == null ? "" : " {" + error2strign(error) + "}");
+        return '${Date.now()} | ${LoggerUtil.printPos(p)} [${level}] ${tag} - ${message}${LoggerUtil.printError(error)}';
     }
 
-  public static function error2strign(error:Dynamic):String {
+    private function write(text:String):Void {}
-    #if flash
-    return if (Std.is(error, Error)) {
-      var stack:String = error.getStackTrace();
-      stack == null ? Std.string(error) : stack;
-    } else if (Std.is(error, ErrorEvent)) {
-      var event:ErrorEvent = cast(error, ErrorEvent);
-      event.type + " - " + event.text;
-    } else {
-      Std.string(error);
-    }
-    #else
-    return Std.string(error);
-    #end
-  }
-
-  private function write(text:String, ?p:haxe.PosInfos):Void {}
 
     public function d(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
         log(LogLevel.DEBUG, tag, message, error, p);

src/main/haxework/log/JSLogger.hx

@@ -4,6 +4,7 @@ import haxework.log.ILogger.LogLevel;
 import flash.external.ExternalInterface;
 import haxework.log.BaseLogger;
 
+
 class JSLogger extends BaseLogger {
 
     private var available:Bool;
@@ -13,18 +14,16 @@ class JSLogger extends BaseLogger {
         available = ExternalInterface.available;
     }
 
-  override public function e(tag:String, message:String, error:Dynamic = null, p:haxe.PosInfos = null):Void {
+    override public function e(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
         if (available) {
             var text:String = buildString(LogLevel.ERROR, tag, message, error);
-      var s:String = p.fileName + ":" + p.lineNumber + ": " + text + "\n";
+            try {ExternalInterface.call("console.error", text);} catch (error:Dynamic) {available = false;}
-      try {ExternalInterface.call("console.error", s);} catch (error:Dynamic) {available = false;}
         }
     }
 
-  override private function write(text:String, ?p:haxe.PosInfos):Void {
+    override private function write(text:String):Void {
         if (available) {
-      var s:String = p.fileName + ":" + p.lineNumber + ": " + text + "\n";
+            try {ExternalInterface.call("console.log", text);} catch (error:Dynamic) {available = false;}
-      try {ExternalInterface.call("console.log", s);} catch (error:Dynamic) {available = false;}
         }
     }
 }

src/main/haxework/log/SocketLogger.hx

@@ -15,6 +15,7 @@ import sys.net.Host;
 import sys.net.Socket;
 #end
 
+
 class SocketLogger extends BaseLogger {
 
     private var socket:Socket;
@@ -43,14 +44,15 @@ class SocketLogger extends BaseLogger {
         //trace("SocketLogger", "", error);
     }
 
-  override private function write(text:String, ?p:haxe.PosInfos):Void {
+    override private function write(text:String):Void {
         try {
-    var s:String = p.fileName + ":" + p.lineNumber + ": " + text + "\n";
             #if flash
-    socket.writeUTFBytes(s);
+            socket.writeUTFBytes(text);
+            socket.writeUTFBytes('\n');
             socket.flush();
             #else
-    socket.write(s);
+            socket.write(text);
+            socket.write('\n');
             #end
         } catch (error:Dynamic) {}
     }

src/main/haxework/log/TextFieldLogger.hx

@@ -2,6 +2,7 @@ package haxework.log;
 
 import flash.text.TextField;
 
+
 class TextFieldLogger extends BaseLogger {
 
     private var textField:TextField;
@@ -11,7 +12,7 @@ class TextFieldLogger extends BaseLogger {
         this.textField = textField;
     }
 
-  override private function write(text:String, ?p:haxe.PosInfos):Void {
+    override private function write(text:String):Void {
         this.textField.text += ("\n" + text);
     }
 }

src/main/haxework/log/TraceLogger.hx

@@ -1,6 +1,5 @@
 package haxework.log;
 
-import haxework.log.ILogger.LogLevel;
 
 class TraceLogger extends BaseLogger {
 
@@ -8,7 +7,7 @@ class TraceLogger extends BaseLogger {
         super();
     }
 
-  override private function write(text:String, ?p:haxe.PosInfos):Void {
+    override private function write(text:String):Void {
-    haxe.Log.trace(text, p);
+        haxe.Log.trace(text);
     }
 }

src/main/haxework/provider/Provider.hx

@@ -1,20 +1,15 @@
 package haxework.provider;
 
+
 class Provider {
 
     private static function key<T>(i:Class<T>, ?type:Dynamic):String {
         var result = Type.getClassName(i);
-    if (type != null) result += ':${type}';
+        if (type != null) result += ':${Std.string(type)}';
         return result;
     }
 
-  //private static var factories:Map<String, Class<Dynamic>> = new Map();
+    private static var factories:Map<String, Class<Dynamic>> = new Map();
-  private static var factories:Map<String, Class<Dynamic>> = cast [
-    #if (!neko)
-    key(haxework.net.manage.LoaderManager) => haxework.net.manage.ILoaderManager
-    #end
-  ];
-
     private static var args:Map<String, Array<Dynamic>> = new Map();
     private static var instances:Map<String, Dynamic> = new Map();