liquidscript 0.11.0.rc1 → 0.11.0

data/vendor/assets/javascripts/liquidscript.js

@@ -0,0 +1,103 @@
+(function() {
+  "use strict";
+  var Liquidscript, Promise;
+  Liquidscript = function(opt) {
+    if(! (this instanceof Liquidscript)) {
+      return new Liquidscript(opt);
+    }else if(this.initialize) {
+      this.initialize.apply(this, arguments);
+    };
+  };
+  Liquidscript.prototype = Liquidscript;
+    Liquidscript.prototype.singleton = function(fn) {
+    var ran, memo;
+    ran = false;
+    memo = undefined();
+    return function() {
+      var ran, memo;
+      if(ran) {
+        return memo;
+      };
+      ran = true;
+      return memo = fn.apply(null, arguments);
+    };
+  };
+;
+      Promise = Promise || function Promise() {
+    if(this.initialize) {
+      this.initialize.apply(this, arguments);
+    }
+  };
+  Promise.prototype.onFulfilled = [];
+  Promise.prototype.onRejected = [];
+  Promise.prototype.func = undefined;
+  Promise.prototype.state = undefined;
+  Promise.prototype.initialize = function(fn) {
+    this.onFulfilled = [];
+    this.onRejected = [];
+    this.func = fn;
+    return this.state = "pending";
+  };
+  Promise.prototype.then = function(fulfilled, rejected) {
+    if(fulfilled instanceof Function) {
+      this.onFulfilled.push(fulfilled);
+    };
+    if(rejected instanceof Function) {
+      this.onRejected.push(rejected);
+    };
+  };
+  Promise.prototype.reject = function() {
+    return null;
+  };
+  Promise.prototype.fulfill = function() {
+    return null;
+  };
+  Promise.prototype.resolve = function(value) {
+    var self, thenProperty, resolved;
+    self = this;
+    this.value = value;
+    if(this === value) {
+      return this.reject(TypeError);
+    }else if(value instanceof Promise) {
+      value.then(function(v) {
+        return self.fulfill(v);
+      }, function(e) {
+        return self.reject(e);
+      });
+    };
+    try {
+      thenProperty = value.then;
+    }catch(e) {
+      return this.reject(e);
+    };
+    if(thenProperty) {
+      resolved = false;
+      try {
+        thenProperty(function(v) {
+          var resolved;
+          if(resolved) {
+            return null;
+          };
+          resolved = true;
+          return self.resolve(v);
+        }, function(e) {
+          var resolved;
+          if(resolved) {
+            return null;
+          };
+          resolved = true;
+          return self.reject(e);
+        });
+      }catch(e) {
+        if(! resolved) {
+          this.reject(e);
+        };
+      };
+    } else {
+      this.fulfill(value);
+    };
+  };
+  Liquidscript.Promise = Promise;
+;
+;
+})();

data/vendor/assets/javascripts/liquidscript.liq

@@ -0,0 +1,29 @@
+(-> {
+
+  :[ strict ]
+
+  Liquidscript = (opt)-> {
+    if(!(this instanceof Liquidscript))
+      return new Liquidscript(opt)
+    elsif(this.initialize)
+      this.initialize.apply(this, arguments)
+  }
+
+  Liquidscript.prototype = Liquidscript
+
+  class Liquidscript {
+    singleton: (fn)-> {
+      ran = false
+      memo = undefined
+
+      ()-> {
+        if(ran) return memo
+        ran = true
+        memo = fn.apply(null, arguments)
+      }
+    }
+  }
+
+  :[ include "promise.liq" ]
+
+})()

data/vendor/assets/javascripts/promise.liq

@@ -0,0 +1,67 @@
+class Liquidscript {
+  class Promise {
+    on-fulfilled: []
+    on-rejected:  []
+    func:         undefined
+    state:        undefined
+
+    initialize: (fn)-> {
+      this.on-fulfilled = []
+      this.on-rejected  = []
+      this.func         = fn
+      this.state        = "pending"
+    }
+
+    then: (fulfilled, rejected)-> {
+      if(fulfilled instanceof Function) {
+        this.on-fulfilled.push(fulfilled)
+      }
+
+      if(rejected instanceof Function) {
+        this.on-rejected.push(rejected)
+      }
+    }
+
+    reject: -> nil
+    fulfill: -> nil
+
+    resolve: (value)-> {
+      self = this
+      this.value = value
+      if(this == value)
+        return reject(TypeError)
+      elsif(value instanceof Promise) {
+        value.then((v)-> self.fulfill(v), (e)-> self.reject(e))
+      }
+
+      try {
+        then-property = value.then
+      } catch(e) {
+        return reject(e)
+      }
+
+      if(then-property) {
+        resolved = false
+
+        try {
+          then-property((v)-> {
+            if(resolved) return null
+            resolved = true
+            self.resolve(v)
+          }, (e)-> {
+            if(resolved) return null
+            resolved = true
+            self.reject(e)
+          })
+        } catch(e) {
+          if(!resolved) {
+            reject(e)
+          }
+        }
+      } else {
+        fulfill(value)
+      }
+    }
+
+  }
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: liquidscript
 version: !ruby/object:Gem::Version
-  version: 0.11.0.rc1
+  version: 0.11.0
 platform: ruby
 authors:
 - Jeremy Rodi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-25 00:00:00.000000000 Z
+date: 2014-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -214,6 +214,9 @@ files:
 - spec/support/matchers/compile.rb
 - spec/support/matchers/generate.rb
 - spec/support/matchers/run.rb
+- vendor/assets/javascripts/liquidscript.js
+- vendor/assets/javascripts/liquidscript.liq
+- vendor/assets/javascripts/promise.liq
 homepage: https://github.com/medcat/liquidscript
 licenses:
 - MIT
@@ -229,9 +232,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2