init

.gitignore

@@ -0,0 +1,5 @@
+*.iml
+*.ipr
+*.iws
+.idea/
+*target*

haxelib.json

@@ -0,0 +1,11 @@
+{
+  "name": "haxework",
+  "url" : "git@bitbucket.org/shmyga/haxework.git",
+  "license": "",
+  "tags": [],
+  "description": "",
+  "version": "0.0.0",
+  "releasenote": "Updated from git.",
+  "contributors": [],
+  "dependencies": {}
+}

project.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<project>
+
+  <meta title="Haxework" package="com.abit.haxework" version="1.0.0" company="Abit"/>
+  <app main="com.abit.haxework.Test" path="target" file="haxework-test"/>
+
+  <source path="src/main/haxe"/>
+
+  <haxelib name="openfl"/>
+</project>

src/main/haxe/com/abit/haxework/Test.hx

@@ -0,0 +1,21 @@
+package com.abit.haxework;
+
+import com.abit.haxework.net.JsonLoader;
+import flash.display.Sprite;
+
+class Test extends Sprite {
+
+  public function new() {
+    super();
+    trace("Ok");
+
+    new JsonLoader()
+      .GET("http://umix.tv/channel/data/maxim.json")
+      .success(function(data:String):Void {
+        trace("OK: " + data);
+      })
+      .fail(function(error:Dynamic):Void {
+        trace("FAIL: " + error);
+      });
+  }
+}

src/main/haxe/com/abit/haxework/net/BaseLoader.hx

@@ -0,0 +1,73 @@
+package com.abit.haxework.net;
+
+import flash.events.SecurityErrorEvent;
+import com.abit.haxework.net.callback.Callback;
+import com.abit.haxework.net.callback.ICallback;
+import flash.events.IOErrorEvent;
+import flash.net.URLRequest;
+import flash.events.Event;
+import flash.net.URLLoader;
+import com.abit.haxework.net.ILoader.Method;
+
+class BaseLoader<T> implements ILoader<T> {
+
+  private var busy:Bool;
+  private var url:String;
+  private var loader:URLLoader;
+  private var callback:ICallback<T>;
+
+  public function new() {
+    busy = false;
+  }
+
+  public function request(url:String, method:Method):ICallback<T> {
+    if (busy) throw "Busy";
+    busy = true;
+    this.url = url;
+    callback = new Callback<T>();
+    loader = buildLoader();
+    loader.load(new URLRequest(url));
+    return callback;
+  }
+
+  public function GET(url:String):ICallback<T> {
+    return request(url, Method.GET);
+  }
+
+  private function buildLoader():URLLoader {
+    var loader:URLLoader = new URLLoader();
+    loader.addEventListener(Event.COMPLETE, onComplete);
+    loader.addEventListener(IOErrorEvent.IO_ERROR, onError);
+    loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onError);
+    return loader;
+  }
+
+  private function onComplete(e:Event):Void {
+    var data:T = extrudeResult(loader.data);
+    var c:ICallback<T> = callback;
+    dispose();
+    c.callSuccess(data);
+  }
+
+  private function onError(e:Event):Void {
+    var c:ICallback<T> = callback;
+    dispose();
+    c.callFail(e);
+  }
+
+  private function dispose():Void {
+    loader.removeEventListener(Event.COMPLETE, onComplete);
+    loader.removeEventListener(IOErrorEvent.IO_ERROR, onError);
+    loader.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, onError);
+    loader = null;
+    url = null;
+    callback = null;
+    busy = false;
+  }
+
+  private function extrudeResult(data:Dynamic):T {
+    throw "Abstract";
+    return null;
+  }
+}
+

src/main/haxe/com/abit/haxework/net/ILoader.hx

@@ -0,0 +1,13 @@
+package com.abit.haxework.net;
+
+import com.abit.haxework.net.callback.ICallback;
+
+enum Method {
+  GET;
+  POST;
+}
+
+interface ILoader<T> {
+  public function request(url:String, method:Method):ICallback<T>;
+  public function GET(url:String):ICallback<T>;
+}

src/main/haxe/com/abit/haxework/net/JsonLoader.hx

@@ -0,0 +1,10 @@
+package com.abit.haxework.net;
+
+import haxe.Json;
+
+class JsonLoader extends BaseLoader<Dynamic> {
+
+  override private function extrudeResult(data:Dynamic):Dynamic {
+    return Json.parse(Std.string(data));
+  }
+}

src/main/haxe/com/abit/haxework/net/TextLoader.hx

@@ -0,0 +1,8 @@
+package com.abit.haxework.net;
+
+class TextLoader extends BaseLoader<String> {
+
+  override private function extrudeResult(data:Dynamic):String {
+    return Std.string(data);
+  }
+}

src/main/haxe/com/abit/haxework/net/callback/Callback.hx

@@ -0,0 +1,35 @@
+package com.abit.haxework.net.callback;
+
+class Callback<T> implements ICallback<T> {
+
+  private var _success:Null<T -> Void>;
+  private var _fail:Null<Dynamic -> Void>;
+
+  public function new() {}
+
+  public function success(f:T -> Void):ICallback<T> {
+    _success = f;
+    return this;
+  }
+
+  public function fail(f:Dynamic -> Void):ICallback<T> {
+    _fail = f;
+    return this;
+  }
+
+  public function callSuccess(data:T):Void {
+    try {
+      _success(data);
+    } catch (error:Dynamic) {
+      callFail(error);
+    }
+  }
+
+  public function callFail(error:Dynamic):Void {
+    try {
+      _fail(error);
+    } catch (error:Dynamic) {
+      trace(error);
+    }
+  }
+}

src/main/haxe/com/abit/haxework/net/callback/ICallback.hx

@@ -0,0 +1,9 @@
+package com.abit.haxework.net.callback;
+
+interface ICallback<T> {
+  public function success(f:T -> Void):ICallback<T>;
+  public function fail(f:Dynamic -> Void):ICallback<T>;
+  public function callSuccess(data:T):Void;
+  public function callFail(error:Dynamic):Void;
+}
+