resin 0.3.0 → 0.3.1

data/amber/js/amber.js

@@ -56,7 +56,8 @@ amber = (function() {
 		}
 
 		loadDependencies();
-		addJSToLoad('compat.js');
+		addJSToLoad('lib/es5-shim-2.0.2/es5-shim.min.js');
+		addJSToLoad('lib/es5-shim-2.0.2/es5-sham.min.js');
 		addJSToLoad('boot.js');
 
 		if (deploy) {

data/amber/js/boot.js

@@ -33,7 +33,7 @@
    |
    ==================================================================== */
 
-/* Make that console is defined */
+/* Make sure that console is defined */
 
 if (typeof console === "undefined") {
 	this.console = {
@@ -47,19 +47,42 @@ if (typeof console === "undefined") {
 
 /* Smalltalk constructors definition */
 
-function SmalltalkObject(){}
-function SmalltalkBehavior(){}
-function SmalltalkClass(){}
-function SmalltalkPackage(){}
+function SmalltalkObject(){};
+function SmalltalkBehavior(){};
+function SmalltalkClass(){};
+function SmalltalkPackage(){};
 function SmalltalkMetaclass(){
 	this.meta = true;
-}
-function SmalltalkMethod(){}
-function SmalltalkNil(){}
+};
+function SmalltalkMethod(){};
+function SmalltalkNil(){};
 
 function SmalltalkSymbol(string){
 	this.value = string;
-}
+};
+
+function SmalltalkOrganizer() {
+    this.elements = [];
+};
+
+SmalltalkOrganizer.prototype.addElement = function(el) {
+    if(typeof el === 'undefined' || el === nil) {
+        return false;
+    }
+    if(this.elements.indexOf(el) == -1) {
+        this.elements.push(el);
+    }
+};
+
+SmalltalkOrganizer.prototype.removeElement = function(el) {
+    for(var i=0; i<this.elements.length; i++) {
+        if(this.elements[i] == el) {
+            this.elements.splice(i, 1);
+            break;
+        }
+    }
+};
+
 
 function Smalltalk(){
 
@@ -108,6 +131,7 @@ function Smalltalk(){
 	function pkg(spec) {
 		var that = new SmalltalkPackage();
 		that.pkgName = spec.pkgName;
+        that.organization = new SmalltalkOrganizer();
 		that.properties = spec.properties || {};
 		return that;
 	};
@@ -131,7 +155,7 @@ function Smalltalk(){
 	}
 	
 	function metaclass() {
-		var meta = setupClass(new SmalltalkMetaclass(), {});
+		var meta = setupClass(new SmalltalkMetaclass(), {})
 		meta.instanceClass = new meta.fn;
 		return meta;
 	}
@@ -143,6 +167,7 @@ function Smalltalk(){
 			value: function() { return 'Smalltalk ' + this.className; }, 
             configurable: true // no writable - in par with ES6 methods
 		});
+        that.organization = new SmalltalkOrganizer();
 		that.pkg = spec.pkg;
 		Object.defineProperties(that.fn.prototype, {
 			methods: { value: {}, enumerable: false, configurable: true, writable: true },
@@ -320,9 +345,16 @@ function Smalltalk(){
 				iVarNames: iVarNames
 			});
 		}
+
+        pkg.organization.addElement(st[className]);
 	};
 
-	/* Add a method to a class */
+    st.removeClass = function(klass) {
+        klass.pkg.organization.removeElement(klass);
+        delete st[klass.className];
+    };
+
+	/* Add/remove a method to/from a class */
 
 	st.addMethod = function(jsSelector, method, klass) {
 		Object.defineProperty(klass.fn.prototype, jsSelector, {
@@ -331,8 +363,31 @@ function Smalltalk(){
 		klass.fn.prototype.methods[method.selector] = method;
 		method.methodClass = klass;
 		method.jsSelector = jsSelector;
+
+        klass.organization.addElement(method.category);
 	};
 
+    st.removeMethod = function(method) {
+        var protocol = method.category;
+        var klass = method.methodClass;
+		var methods = klass.fn.prototype.methods;
+
+		delete klass.fn.prototype[method.selector._asSelector()];
+		delete methods[method.selector];
+
+		var selectors = Object.keys(methods);
+		var shouldDeleteProtocol = true;
+		for(var i= 0, l = selectors.length; i<l; i++) {
+            if(methods[selectors[i]].category === protocol) {
+                shouldDeleteProtocol = false;
+				break;
+            };
+        };
+        if(shouldDeleteProtocol) {
+            klass.organization.removeElement(protocol)
+        };
+    };
+
 	/* Handles unhandled errors during message sends */
 
 	st.send = function(receiver, selector, args, klass) {
@@ -514,7 +569,7 @@ function Smalltalk(){
 
     /* Boolean assertion */
     st.assert = function(boolean) {
-        if(boolean.klass === smalltalk.Boolean) {
+        if ((undefined !== boolean) && (boolean.klass === smalltalk.Boolean)) {
             return boolean;
         } else {
             smalltalk.NonBooleanReceiver._new()._object_(boolean)._signal();
@@ -528,12 +583,6 @@ function SmalltalkMethodContext(receiver, selector, method, temps, home) {
 	this.method      = method;
 	this.temps       = temps || {};
 	this.homeContext = home;
-
-    this.resume = function() {
-        //Brutally set the receiver as thisContext, then re-enter the function
-        smalltalk.thisContext = this;
-        return this.method.apply(receiver, temps);
-    };
 };
 
 SmalltalkMethodContext.prototype.copy = function() {
@@ -548,6 +597,12 @@ SmalltalkMethodContext.prototype.copy = function() {
 	);
 };
 
+SmalltalkMethodContext.prototype.resume = function() {
+    //Brutally set the receiver as thisContext, then re-enter the function
+    smalltalk.thisContext = this;
+    return this.method.apply(receiver, temps);
+};
+
 /* Global Smalltalk objects. */
 
 var nil = new SmalltalkNil();
@@ -570,6 +625,7 @@ smalltalk.wrapClassName("Behavior", "Kernel", SmalltalkBehavior, smalltalk.Objec
 smalltalk.wrapClassName("Class", "Kernel", SmalltalkClass, smalltalk.Behavior);
 smalltalk.wrapClassName("Metaclass", "Kernel", SmalltalkMetaclass, smalltalk.Behavior);
 smalltalk.wrapClassName("CompiledMethod", "Kernel", SmalltalkMethod, smalltalk.Object);
+smalltalk.wrapClassName("Organizer", "Kernel-Objects", SmalltalkOrganizer, smalltalk.Object);
 
 smalltalk.Object.klass.superclass = smalltalk.Class;
 

data/amber/js/lib/es5-shim-2.0.2/CHANGES

@@ -0,0 +1,93 @@
+
+2.0.0
+ - Separate reliable shims from dubious shims (shams).
+
+1.2.10
+ - Group-effort Style Cleanup
+ - Took a stab at fixing Object.defineProperty on IE8 without
+   bad side-effects. (@hax)
+ - Object.isExtensible no longer fakes it. (@xavierm)
+ - Date.prototype.toISOString no longer deals with partial
+   ISO dates, per spec (@kitcambridge)
+ - More (mostly from @bryanforbes)
+
+1.2.9
+ - Corrections to toISOString by @kitcambridge
+ - Fixed three bugs in array methods revealed by Jasmine tests.
+ - Cleaned up Function.prototype.bind with more fixes and tests from
+   @bryanforbes.
+
+1.2.8
+ - Actually fixed problems with Function.prototype.bind, and regressions
+   from 1.2.7 (@bryanforbes, @jdalton #36)
+
+1.2.7 - REGRESSED
+ - Fixed problems with Function.prototype.bind when called as a constructor.
+   (@jdalton #36)
+
+1.2.6
+ - Revised Date.parse to match ES 5.1 (kitcambridge)
+
+1.2.5
+ - Fixed a bug for padding it Date..toISOString (tadfisher issue #33)
+
+1.2.4
+ - Fixed a descriptor bug in Object.defineProperty (raynos)
+
+1.2.3
+ - Cleaned up RequireJS and <script> boilerplate
+
+1.2.2
+ - Changed reduce to follow the letter of the spec with regard to having and
+   owning properties.
+ - Fixed a bug where RegExps pass as Functions in some engines in reduce.
+
+1.2.1
+ - Adding few fixes to make jshint happy.
+ - Fix for issue #12, function expressions can cause scoping issues in IE.
+ - NPM will minify on install or when `npm run-script install` is executed.
+ - Adding .gitignore to avoid publishing dev dependencies.
+
+1.2.0
+ - Making script loadable as AMD module.
+ - Adding `indexOf` to the list of safe shims.
+
+1.1.0
+ - Added support for accessor properties where possible (which is all browsers
+   except IE).
+ - Stop exposing bound function's (that are returned by
+   `Function.prototype.bind`) internal properties (`bound, boundTo, boundArgs`)
+   as in some cases (when using facade objects for example) capabilities of the
+   enclosed functions will be leaked.
+ - `Object.create` now explicitly sets `__proto__` property to guarantee
+   correct behavior of `Object.getPrototypeOf`'s on all objects created using
+   `Object.create`.
+ - Switched to `===` from `==` where possible as it's slightly faster on older
+   browsers that are target of this lib.
+ - Added names to all anonymous functions to have a better stack traces.
+
+1.0.0
+ - fixed Date.toISODate, using UTC accessors, as in
+   http://code.google.com/p/v8/source/browse/trunk/src/date.js?r=6120#986
+   (arian)
+
+0.0.4
+ - Revised Object.getPrototypeOf to work in more cases
+   in response to http://ejohn.org/blog/objectgetprototypeof/
+   [issue #2] (fschaefer)
+
+0.0.3
+ - Fixed typos in Object.keys (samsonjs)
+
+0.0.2
+   Per kangax's recommendations:
+ - faster Object.create(null)
+ - fixed a function-scope function declaration statement in Object.create
+
+0.0.1
+ - fixed Object.create(null), in so far as that's possible
+ - reworked Rhino Object.freeze(Function) bug detector and patcher
+
+0.0.0
+ - forked from narwhal-lib
+

data/amber/js/lib/es5-shim-2.0.2/CONTRIBUTORS.md

@@ -0,0 +1,25 @@
+
+-   kriskowal Kris Kowal Copyright (C) 2009-2011 MIT License
+-   tlrobinson Tom Robinson Copyright (C) 2009-2010 MIT License (Narwhal
+    Project)
+-   dantman Daniel Friesen Copyright (C) 2010 XXX TODO License or CLA
+-   fschaefer Florian Schäfer Copyright (C) 2010 MIT License
+-   Gozala Irakli Gozalishvili Copyright (C) 2010 MIT License
+-   kitcambridge Kit Cambridge Copyright (C) 2011 MIT License
+-   kossnocorp Sasha Koss XXX TODO License or CLA
+-   bryanforbes Bryan Forbes XXX TODO License or CLA
+-   killdream Quildreen Motta Copyright (C) 2011 MIT Licence
+-   michaelficarra Michael Ficarra Copyright (C) 2011 3-clause BSD
+    License
+-   sharkbrainguy Gerard Paapu Copyright (C) 2011 MIT License
+-   bbqsrc Brendan Molloy (C) 2011 Creative Commons Zero (public domain)
+-   iwyg XXX TODO License or CLA
+-   DomenicDenicola Domenic Denicola Copyright (C) 2011 MIT License
+-   xavierm02 Montillet Xavier Copyright (C) 2011 MIT License
+-   Raynos Jake Verbaten Copyright (C) 2011 MIT Licence
+-   samsonjs Sami Samhuri Copyright (C) 2010 MIT License
+-   rwldrn Rick Waldron Copyright (C) 2011 MIT License
+-   lexer Alexey Zakharov XXX TODO License or CLA
+-   280 North Inc. (Now Motorola LLC, a subsidiary of Google Inc.)
+    Copyright (C) 2009 MIT License
+

data/amber/js/lib/es5-shim-2.0.2/LICENSE

@@ -0,0 +1,19 @@
+
+Copyright 2009, 2010 Kristopher Michael Kowal. All rights reserved.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

data/amber/js/lib/es5-shim-2.0.2/README.md

@@ -0,0 +1,161 @@
+
+`es5-shim.js` and `es5-shim.min.js` monkey-patch a JavaScript context to
+contain all EcmaScript 5 methods that can be faithfully emulated with a
+legacy JavaScript engine.
+
+`es5-sham.js` and `es5-sham.min.js` monkey-patch other ES5 methods as
+closely as possible.  For these methods, as closely as possible to ES5
+is not very close.  Many of these shams are intended only to allow code
+to be written to ES5 without causing run-time errors in older engines.
+In many cases, this means that these shams cause many ES5 methods to
+silently fail.  Decide carefully whether this is what you want.
+
+
+## Tests
+
+The tests are written with the Jasmine BDD test framework.
+To run the tests, navigate to <root-folder>/tests/. 
+
+In order to run against the shim-code, the tests attempt to kill the current 
+implementation of the missing methods. This happens in <root-folder>/tests/helpers/h-kill.js.
+So in order to run the tests against the build-in methods, invalidate that file somehow
+(comment-out, delete the file, delete the script-tag, etc.).
+
+## Shims
+
+### Complete tests ###
+
+* Array.prototype.every
+* Array.prototype.filter
+* Array.prototype.forEach
+* Array.prototype.indexOf
+* Array.prototype.lastIndexOf
+* Array.prototype.map
+* Array.prototype.some
+* Array.prototype.reduce
+* Array.prototype.reduceRight
+* Array.isArray
+* Date.now
+* Date.prototype.toJSON
+* Function.prototype.bind
+    * /!\ Caveat: the bound function's length is always 0.
+    * /!\ Caveat: the bound function has a prototype property.
+    * /!\ Caveat: bound functions do not try too hard to keep you
+      from manipulating their ``arguments`` and ``caller`` properties.
+    * /!\ Caveat: bound functions don't have checks in ``call`` and
+      ``apply`` to avoid executing as a constructor.
+* Object.keys
+* String.prototype.trim
+
+### Untested ###
+
+* Date.parse (for ISO parsing)
+* Date.prototype.toISOString
+
+## Shams
+
+* /?\ Object.create
+
+    For the case of simply "begetting" an object that
+    inherits prototypically from another, this should work
+    fine across legacy engines.
+
+    /!\ Object.create(null) will work only in browsers that
+    support prototype assignment.  This creates an object
+    that does not have any properties inherited from
+    Object.prototype.  It will silently fail otherwise.
+
+    /!\ The second argument is passed to
+    Object.defineProperties which will probably fail
+    silently.
+
+* /?\ Object.getPrototypeOf
+
+    This will return "undefined" in some cases.  It uses
+    __proto__ if it's available.  Failing that, it uses
+    constructor.prototype, which depends on the constructor
+    property of the object's prototype having not been
+    replaced.  If your object was created like this, it
+    won't work:
+
+        function Foo() {
+        }
+        Foo.prototype = {};
+
+    Because the prototype reassignment destroys the
+    constructor property.
+
+    This will work for all objects that were created using
+    `Object.create` implemented with this library.
+
+* /!\ Object.getOwnPropertyNames
+
+    This method uses Object.keys, so it will not be accurate
+    on legacy engines.
+
+* Object.isSealed
+
+    Returns "false" in all legacy engines for all objects,
+    which is conveniently guaranteed to be accurate.
+
+* Object.isFrozen
+
+    Returns "false" in all legacy engines for all objects,
+    which is conveniently guaranteed to be accurate.
+
+* Object.isExtensible
+
+    Works like a charm, by trying very hard to extend the
+    object then redacting the extension.
+
+### Fail silently
+
+* /!\ Object.getOwnPropertyDescriptor
+    
+    The behavior of this shim does not conform to ES5.  It
+    should probably not be used at this time, until its
+    behavior has been reviewed and been confirmed to be
+    useful in legacy engines.
+
+* /!\ Object.defineProperty
+
+    This method will silently fail to set "writable",
+    "enumerable", and "configurable" properties.
+    
+    Providing a getter or setter with "get" or "set" on a
+    descriptor will silently fail on engines that lack
+    "__defineGetter__" and "__defineSetter__", which include
+    all versions of IE up to version 8 so far.
+
+    IE 8 provides a version of this method but it only works
+    on DOM objects.  Thus, the shim will not get installed
+    and attempts to set "value" properties will fail
+    silently on non-DOM objects.
+
+    https://github.com/kriskowal/es5-shim/issues#issue/5
+
+* /!\ Object.defineProperties
+
+    This uses the Object.defineProperty shim
+
+* Object.seal
+
+    Silently fails on all legacy engines.  This should be
+    fine unless you are depending on the safety and security
+    provisions of this method, which you cannot possibly
+    obtain in legacy engines.
+
+* Object.freeze
+
+    Silently fails on all legacy engines.  This should be
+    fine unless you are depending on the safety and security
+    provisions of this method, which you cannot possibly
+    obtain in legacy engines.
+
+* Object.preventExtensions
+
+    Silently fails on all legacy engines.  This should be
+    fine unless you are depending on the safety and security
+    provisions of this method, which you cannot possibly
+    obtain in legacy engines.
+