resin 0.3.1 → 0.4.0

data/amber/st/Kernel-Collections.st

@@ -257,13 +257,9 @@ ifNotEmpty: aBlock
 !
 
 includes: anObject
-	<
-		var i = self.length;
-		while (i--) {
-			if (smalltalk.send(self[i], "__eq", [anObject])) {return true;}	
-		}
-		return false
-	>
+	| sentinel |
+    sentinel := Object new.
+    ^(self detect: [ :each | each = anObject] ifNone: [ sentinel ]) ~= sentinel
 !
 
 isEmpty
@@ -683,7 +679,7 @@ indexOf: anObject
 indexOf: anObject ifAbsent: aBlock
 	<
 		for(var i=0;i<self.length;i++) {
-			if(smalltalk.send(self[i], '__eq', [anObject])) {return i+1}
+			if(self[i].__eq(anObject)) {return i+1}
 		};
 		return aBlock();
 	>
@@ -776,6 +772,12 @@ withIndexDo: aBlock
 	<for(var i=0;i<self.length;i++){aBlock(self[i], i+1);}>
 ! !
 
+!SequenceableCollection methodsFor: 'testing'!
+
+includes: anObject
+	^(self indexOf: anObject ifAbsent: [nil]) notNil
+! !
+
 SequenceableCollection subclass: #Array
 	instanceVariableNames: ''
 	package: 'Kernel-Collections'!
@@ -810,9 +812,9 @@ remove: anObject ifAbsent: aBlock
 				self.splice(i,1);
 				return self;
 			}
-		}
-	>.
-	aBlock value
+		};
+        aBlock._value();
+	>
 !
 
 removeFrom: aNumber to: anotherNumber
@@ -995,8 +997,12 @@ unescaped
 !
 
 = aString
-	aString class = self class ifFalse: [^false].
-	<return String(self) === String(aString)>
+	<
+    	if(!! aString._isString || !! aString._isString()) {
+        	return false;
+        }
+    	return String(self) === String(aString)
+    >
 !
 
 == aString
@@ -1038,22 +1044,12 @@ asNumber
 	<return Number(self)>
 !
 
+asRegexp
+	^ RegularExpression fromString: self
+!
+
 asSelector
-	"If you change this method, change smalltalk.convertSelector too (see js/boot.js file)"
-
-	| selector |
-	selector := '_', self.
-	selector := selector replace: ':' with: '_'.
-	selector := selector replace: '[+]' with: '_plus'.
-	selector := selector replace: '-' with: '_minus'.
-	selector := selector replace: '[*]' with: '_star'.
-	selector := selector replace: '[/]' with: '_slash'.
-	selector := selector replace: '>' with: '_gt'.
-	selector := selector replace: '<' with: '_lt'.
-	selector := selector replace: '=' with: '_eq'.
-	selector := selector replace: ',' with: '_comma'.
-	selector := selector replace: '[@]' with: '_at'.
-	^selector
+	<return smalltalk.selector(self)>
 !
 
 asString
@@ -1343,6 +1339,10 @@ asString
 	<return self.value>
 !
 
+asSuperSelector
+	^self asString asSuperSelector
+!
+
 asSymbol
 	^self
 ! !
@@ -1490,6 +1490,16 @@ includes: anObject
 Object subclass: #Queue
 	instanceVariableNames: 'read readIndex write'
 	package: 'Kernel-Collections'!
+!Queue commentStamp!
+A Queue am a one-sided queue.
+
+A Queue uses two OrderedCollections inside,
+`read` is at the front, is not modified and only read using `readIndex`.
+`write` is at the back and is appended new items.
+When `read` is exhausted, `write` is promoted to `read` and new `write` is created.
+
+As a consequence, no data moving is done by the Queue; write appending may do data moving
+when growing `write`, but this is left to engine to implement as good as it chooses to.!
 
 !Queue methodsFor: 'accessing'!
 
@@ -1498,7 +1508,7 @@ back: anObject
 !
 
 front
-    ^self frontIfAbsent: [ self error: 'Cannot read from empty Queue.']
+    ^self frontIfAbsent: [ self error: 'Cannot read from empty Queue.' ]
 !
 
 frontIfAbsent: aBlock
@@ -1519,9 +1529,10 @@ frontIfAbsent: aBlock
 !Queue methodsFor: 'initialization'!
 
 initialize
-	read := #().
-    readIndex := 1.
-    write := OrderedCollection new
+	super initialize.
+	read := OrderedCollection new.
+    write := OrderedCollection new.
+    readIndex := 1
 ! !
 
 Object subclass: #RegularExpression

data/amber/st/Kernel-Exceptions.st

@@ -2,6 +2,13 @@ Smalltalk current createPackage: 'Kernel-Exceptions' properties: #{}!
 Object subclass: #Error
 	instanceVariableNames: 'messageText'
 	package: 'Kernel-Exceptions'!
+!Error commentStamp!
+From the ANSI standard:
+
+This protocol describes the behavior of instances of class `Error`. 
+These are used to represent error conditions that prevent the normal continuation of processing. 
+Actual error exceptions used by an application may be subclasses of this class.
+As `Error` is explicitly specified  to be subclassable, conforming implementations must implement its behavior in a non-fragile manner.!
 
 !Error methodsFor: 'accessing'!
 
@@ -21,6 +28,12 @@ messageText: aString
 	messageText := aString
 ! !
 
+!Error methodsFor: 'initialization'!
+
+initialize
+	self messageText: 'Errorclass: ', (self class name).
+! !
+
 !Error methodsFor: 'signaling'!
 
 signal
@@ -49,9 +62,54 @@ signal: aString
 		signal: aString
 ! !
 
+Error subclass: #JavaScriptException
+	instanceVariableNames: 'exception'
+	package: 'Kernel-Exceptions'!
+!JavaScriptException commentStamp!
+A JavaScriptException is thrown when a non-Smalltalk exception occurs while in the Smalltalk stack.
+See `boot.js` `inContext()` and `BlockClosure >> on:do:`!
+
+!JavaScriptException methodsFor: 'accessing'!
+
+context: aMethodContext
+	"Set the context from the outside.
+    See boot.js `inContext()` exception handling"
+    
+    <self.context = aMethodContext>
+!
+
+exception
+	^ exception
+!
+
+exception: anException
+	exception := anException
+!
+
+messageText
+	<return 'JavaScript exception: ' + self["@exception"].toString()>
+! !
+
+!JavaScriptException class methodsFor: 'instance creation'!
+
+on: anException
+	^ self new
+    	exception: anException;
+        yourself
+!
+
+on: anException context: aMethodContext
+	^ self new
+    	exception: anException;
+        context: aMethodContext;
+        yourself
+! !
+
 Error subclass: #MessageNotUnderstood
 	instanceVariableNames: 'message receiver'
 	package: 'Kernel-Exceptions'!
+!MessageNotUnderstood commentStamp!
+This exception is provided to support `Object>>doesNotUnderstand:`.!
 
 !MessageNotUnderstood methodsFor: 'accessing'!
 
@@ -78,6 +136,8 @@ receiver: anObject
 Error subclass: #NonBooleanReceiver
 	instanceVariableNames: 'object'
 	package: 'Kernel-Exceptions'!
+!NonBooleanReceiver commentStamp!
+NonBooleanReceiver exceptions may be thrown when executing inlined methods such as `#ifTrue:` with a non boolean receiver.!
 
 !NonBooleanReceiver methodsFor: 'accessing'!
 
@@ -92,6 +152,15 @@ object: anObject
 Object subclass: #ErrorHandler
 	instanceVariableNames: ''
 	package: 'Kernel-Exceptions'!
+!ErrorHandler commentStamp!
+ErrorHandler is used to manage Smalltalk errors. 
+See `boot.js` `handleError()` function.
+
+Subclasses of `ErrorHandler` can register themselves as the current handler with
+`ErrorHandler class >> register`.
+
+Subclasses may override `#handleError:` to perform an action on the thrown exception.
+The default behavior is to log the error and the context stack to the JavaScript console.!
 
 !ErrorHandler methodsFor: 'error handling'!
 
@@ -109,7 +178,7 @@ log: aString
 logContext: aContext
 	aContext home ifNotNil: [
 		self logContext: aContext home].
-	self log: aContext receiver asString, '>>', aContext selector
+	self log: aContext receiver asString, '>>', aContext selector asString
 !
 
 logError: anError

data/amber/st/Kernel-Methods.st

@@ -40,13 +40,23 @@ whileTrue: aBlock
 	<while(self()) {aBlock()}>
 ! !
 
+!BlockClosure methodsFor: 'converting'!
+
+asCompiledMethod: aString
+	<return smalltalk.method({selector:aString, fn:self});>
+! !
+
 !BlockClosure methodsFor: 'error handling'!
 
 on: anErrorClass do: aBlock
-	^self try: self catch: [:error |
-	    (error isKindOf: anErrorClass) 
-	     ifTrue: [aBlock value: error]
-	     ifFalse: [error signal]]
+	"All exceptions thrown in the Smalltalk stack are cought.
+    Convert all JS exceptions to JavaScriptException instances."
+    
+	^self try: self catch: [ :error | | smalltalkError |
+    	smalltalkError := Smalltalk current asSmalltalkException: error.
+	    (smalltalkError isKindOf: anErrorClass) 
+	     ifTrue: [ aBlock value: smalltalkError ]
+	     ifFalse: [ smalltalkError signal ] ]
 ! !
 
 !BlockClosure methodsFor: 'evaluating'!
@@ -56,7 +66,7 @@ applyTo: anObject arguments: aCollection
 !
 
 ensure: aBlock
-	<try{self()}finally{return aBlock._value()}>
+	<try{return self()}finally{aBlock._value()}>
 !
 
 new
@@ -80,7 +90,7 @@ newValue:  anObject value: anObject2
 newValue:  anObject value: anObject2 value: anObject3
 	"Use the receiver as a JS constructor. 
 	*Do not* use this method to instanciate Smalltalk objects!!"
-	<return new self(anObject, anObject2)>
+	<return new self(anObject, anObject2,anObject3)>
 !
 
 timeToRun
@@ -120,11 +130,17 @@ fork
 !
 
 valueWithInterval: aNumber
-	<return setInterval(self, aNumber)>
+	<
+    	var interval = setInterval(self, aNumber);
+    	return smalltalk.Timeout._on_(interval);
+    >
 !
 
 valueWithTimeout: aNumber
-	<return setTimeout(self, aNumber)>
+	<
+    	var timeout = setTimeout(self, aNumber);
+    	return smalltalk.Timeout._on_(timeout);
+    >
 ! !
 
 Object subclass: #CompiledMethod
@@ -215,33 +231,60 @@ source: aString
 Object subclass: #ForkPool
 	instanceVariableNames: 'poolSize maxPoolSize queue worker'
 	package: 'Kernel-Methods'!
+!ForkPool commentStamp!
+A ForkPool is responsible for handling forked blocks.
+The pool size sets the maximum concurrent forked blocks.
 
-!ForkPool methodsFor: 'action'!
+The default instance is accessed with `ForkPool default`!
 
-addWorker
-	worker valueWithTimeout: 0.
-    poolSize := poolSize + 1
+!ForkPool methodsFor: 'accessing'!
+
+maxPoolSize
+	^ maxPoolSize ifNil: [ self defaultMaxPoolSize ]
 !
 
+maxPoolSize: anInteger
+	maxPoolSize := anInteger
+! !
+
+!ForkPool methodsFor: 'actions'!
+
 fork: aBlock
-	poolSize < maxPoolSize ifTrue: [ self addWorker ].
+	poolSize < self maxPoolSize ifTrue: [ self addWorker ].
 	queue back: aBlock
 ! !
 
+!ForkPool methodsFor: 'defaults'!
+
+defaultMaxPoolSize
+	^ self class defaultMaxPoolSize
+! !
+
 !ForkPool methodsFor: 'initialization'!
 
 initialize
-	| sentinel |
+    super initialize.
+    
 	poolSize := 0.
-    maxPoolSize := self class defaultMaxPoolSize.
     queue := Queue new.
+    worker := self makeWorker
+!
+
+makeWorker
+	| sentinel |
     sentinel := Object new.
-    worker := [
-		| block |
+    ^[ | block |
         poolSize := poolSize - 1.
 		block := queue frontIfAbsent: [ sentinel ].
         block == sentinel ifFalse: [
-        	[ block value ] ensure: [ self addWorker ]]].
+        	[ block value ] ensure: [ self addWorker ]]]
+! !
+
+!ForkPool methodsFor: 'private'!
+
+addWorker
+	worker valueWithTimeout: 0.
+    poolSize := poolSize + 1
 ! !
 
 ForkPool class instanceVariableNames: 'default'!
@@ -300,7 +343,7 @@ printString
 !
 
 sendTo: anObject
-	^ Smalltalk current send: self selector to: anObject arguments: self arguments
+	^ anObject perform: self selector withArguments: self arguments
 ! !
 
 !Message class methodsFor: 'instance creation'!
@@ -318,17 +361,29 @@ Object subclass: #MethodContext
 !MethodContext commentStamp!
 MethodContext holds all the dynamic state associated with the execution of either a method activation resulting from a message send. That is used to build the call stack while debugging.
   
-MethodContext instances are JavaScript `SmalltalkMethodContext` objects defined in boot.js 
-
-Current limitation: MethodContext instances are not created on Block evaluation. That means it's actually impossible to debug inside a Block.!
+MethodContext instances are JavaScript `SmalltalkMethodContext` objects defined in boot.js!
 
 !MethodContext methodsFor: 'accessing'!
 
-asString
-	^self receiver class printString, ' >> ', self selector
+home
+	<return self.methodContext || self.homeContext>
 !
 
-home
+locals
+	<return self.locals>
+!
+
+method
+	^self methodContext receiver class lookupSelector: self methodContext selector
+!
+
+methodContext
+	self isBlockContext ifFalse: [ ^ self ].
+    
+    ^ self home
+!
+
+outerContext
 	<return self.homeContext>
 !
 
@@ -345,10 +400,93 @@ receiver
 !
 
 selector
-	<return smalltalk.convertSelector(self.selector)>
+	<
+    	if(self.selector) {
+        	return smalltalk.convertSelector(self.selector);
+        } else {
+        	return nil;
+        }
+    >
 !
 
 temps
-	<return self.temps>
+	self deprecatedAPI.
+    
+	^ self locals
+! !
+
+!MethodContext methodsFor: 'converting'!
+
+asString
+	^self isBlockContext 
+    	ifTrue: [ 'a block (in ', self methodContext receiver class printString, ')' ]
+      	ifFalse: [ self receiver class printString, ' >> ', self selector ]
+! !
+
+!MethodContext methodsFor: 'testing'!
+
+isBlockContext
+	"Block context do not have selectors."
+    
+	^ self selector isNil
+! !
+
+Object subclass: #NativeFunction
+	instanceVariableNames: ''
+	package: 'Kernel-Methods'!
+!NativeFunction commentStamp!
+NativeFunction is a wrapper around native functions, such as `WebSocket`.
+For 'normal' functions (whose constructor is the JavaScript `Function` object), use `BlockClosure`.
+
+See the class-side `instance creation` methods.
+
+Created instances will most probably be instance of `JSObjectProxy`.
+
+Usage example:
+
+    | ws |
+    ws := NativeFunction constructor: 'WebSocket' value: 'ws://localhost'.
+    ws at: 'onopen' put: [ ws send: 'hey there from Amber' ]!
+
+!NativeFunction class methodsFor: 'instance creation'!
+
+constructor: aString
+	<
+    	var native=eval(aString); 
+        return new native();
+	>
+!
+
+constructor: aString value:anObject
+	<
+    	var native=eval(aString); 
+        return new native(anObject);
+	>
+!
+
+constructor: aString value:anObject value: anObject2
+	<
+    	var native=eval(aString); 
+        return new native(anObject,anObject2);
+	>
+!
+
+constructor: aString value:anObject value: anObject2 value:anObject3
+	<
+    	var native=eval(aString); 
+        return new native(anObject,anObject2, anObject3);
+	>
+! !
+
+!NativeFunction class methodsFor: 'testing'!
+
+exists: aString
+	<
+    	if(aString in window) {
+        	return true
+        } else {
+        	return false
+        }
+    >
 ! !