resin 0.0.1 → 0.0.2

data/amber/st/Kernel-Methods.st

@@ -1,74 +1,90 @@
 Smalltalk current createPackage: 'Kernel-Methods' properties: #{}!
-Object subclass: #CompiledMethod
-	instanceVariableNames: ''
+Object subclass: #Message
+	instanceVariableNames: 'selector arguments'
 	category: 'Kernel-Methods'!
-!CompiledMethod commentStamp!
-CompiledMethod hold the source and compiled code of a class method.
-
-You can get a CompiledMethod using `Behavior>>methodAt:`
+!Message commentStamp!
+Generally, the system does not use instances of Message for efficiency reasons.
+However, when a message is not understood by its receiver, the interpreter will make up an instance of it in order to capture the information involved in an actual message transmission. 
+This instance is sent it as an argument with the message `doesNotUnderstand:` to the receiver.
 
-	String methodAt: 'lines'
+See boot.js, `messageNotUnderstood`  and its counterpart `Object>>doesNotUnderstand:`!
 
-and read the source code
+!Message methodsFor: 'accessing'!
 
-	(String methodAt: 'lines') source
+selector
+	^selector
+!
 
-See referenced classes:
+selector: aString
+	selector := aString
+!
 
-	(String methodAt: 'lines') referencedClasses
+arguments: anArray
+	arguments := anArray
+!
 
-or messages sent from this method:
-	
-	(String methodAt: 'lines')  messageSends!
+arguments
+	^arguments
+! !
 
-!CompiledMethod methodsFor: 'accessing'!
+!Message methodsFor: 'printing'!
 
-source
-	^(self basicAt: 'source') ifNil: ['']
+printString
+	^ String streamContents: [:aStream|  
+                                  				aStream 
+                                  					nextPutAll: super printString;
+                                  					nextPutAll: '(';
+                                  					nextPutAll: selector;
+                                  					nextPutAll: ')' 				]
 !
 
-source: aString
-	self basicAt: 'source' put: aString
-!
+sendTo: anObject
+	Smalltalk current send: self selector to: anObject arguments: self arguments
+! !
 
-category
-	^(self basicAt: 'category') ifNil: ['']
-!
+!Message class methodsFor: 'instance creation'!
 
-category: aString
-	self basicAt: 'category' put: aString
-!
+selector: aString arguments: anArray
+	^self new
+		selector: aString;
+		arguments: anArray;
+		yourself
+! !
 
-selector
-	^self basicAt: 'selector'
-!
+Object subclass: #MethodContext
+	instanceVariableNames: ''
+	category: 'Kernel-Methods'!
+!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 
 
-selector: aString
-	self basicAt: 'selector' put: aString
-!
+Current limitation: MethodContext instances are not created on Block evaluation. That means it's actually impossible to debug inside a Block.!
 
-fn
-	^self basicAt: 'fn'
+!MethodContext methodsFor: 'accessing'!
+
+receiver
+	<return self.receiver>
 !
 
-fn: aBlock
-	self basicAt: 'fn' put: aBlock
+selector
+	<return smalltalk.convertSelector(self.selector)>
 !
 
-messageSends
-	^self basicAt: 'messageSends'
+home
+	<return self.homeContext>
 !
 
-methodClass
-	^self basicAt: 'methodClass'
+temps
+	<return self.temps>
 !
 
-referencedClasses
-	^self basicAt: 'referencedClasses'
+printString
+	^super printString, '(', self asString, ')'
 !
 
-arguments
-	<return self.args || []>
+asString
+	^self receiver class printString, ' >> ', self selector
 ! !
 
 Object subclass: #BlockClosure
@@ -201,87 +217,75 @@ valueWithInterval: aNumber
 	<return setInterval(self, aNumber)>
 ! !
 
-Object subclass: #MethodContext
+Object subclass: #CompiledMethod
 	instanceVariableNames: ''
 	category: 'Kernel-Methods'!
-!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 
+!CompiledMethod commentStamp!
+CompiledMethod hold the source and compiled code of a class method.
 
-Current limitation: MethodContext instances are not created on Block evaluation. That means it's actually impossible to debug inside a Block.!
+You can get a CompiledMethod using `Behavior>>methodAt:`
 
-!MethodContext methodsFor: 'accessing'!
+	String methodAt: 'lines'
 
-receiver
-	<return self.receiver>
-!
+and read the source code
 
-selector
-	<return smalltalk.convertSelector(self.selector)>
-!
+	(String methodAt: 'lines') source
 
-home
-	<return self.homeContext>
-!
+See referenced classes:
 
-temps
-	<return self.temps>
-!
+	(String methodAt: 'lines') referencedClasses
 
-printString
-	^super printString, '(', self asString, ')'
-!
+or messages sent from this method:
+	
+	(String methodAt: 'lines')  messageSends!
 
-asString
-	^self receiver class printString, ' >> ', self selector
-! !
+!CompiledMethod methodsFor: 'accessing'!
 
-Object subclass: #Message
-	instanceVariableNames: 'selector arguments'
-	category: 'Kernel-Methods'!
-!Message commentStamp!
-Generally, the system does not use instances of Message for efficiency reasons.
-However, when a message is not understood by its receiver, the interpreter will make up an instance of it in order to capture the information involved in an actual message transmission. 
-This instance is sent it as an argument with the message `doesNotUnderstand:` to the receiver.
+source
+	^(self basicAt: 'source') ifNil: ['']
+!
 
-See boot.js, `messageNotUnderstood`  and its counterpart `Object>>doesNotUnderstand:`!
+source: aString
+	self basicAt: 'source' put: aString
+!
 
-!Message methodsFor: 'accessing'!
+category
+	^(self basicAt: 'category') ifNil: ['']
+!
+
+category: aString
+	self basicAt: 'category' put: aString
+!
 
 selector
-	^selector
+	^self basicAt: 'selector'
 !
 
 selector: aString
-	selector := aString
+	self basicAt: 'selector' put: aString
 !
 
-arguments: anArray
-	arguments := anArray
+fn
+	^self basicAt: 'fn'
 !
 
-arguments
-	^arguments
-! !
+fn: aBlock
+	self basicAt: 'fn' put: aBlock
+!
 
-!Message methodsFor: 'printing'!
+messageSends
+	^self basicAt: 'messageSends'
+!
 
-printString
-	^ String streamContents: [:aStream|  
-                                  				aStream 
-                                  					nextPutAll: super printString;
-                                  					nextPutAll: '(';
-                                  					nextPutAll: selector;
-                                  					nextPutAll: ')' 				]
-! !
+methodClass
+	^self basicAt: 'methodClass'
+!
 
-!Message class methodsFor: 'instance creation'!
+referencedClasses
+	^self basicAt: 'referencedClasses'
+!
 
-selector: aString arguments: anArray
-	^self new
-		selector: aString;
-		arguments: anArray;
-		yourself
+arguments
+	<return self.args || []>
 ! !
 

data/amber/st/Kernel-Objects.st

@@ -384,6 +384,12 @@ reservedWords
 
 readJSObject: anObject
 	<return self.readJSObject(anObject)>
+!
+
+send: aSelector to: anObject arguments: aCollection
+	| selector |
+	selector := aSelector asString asSelector.
+	<self.send(anObject, selector, aCollection)>
 ! !
 
 !Smalltalk methodsFor: 'classes'!
@@ -545,6 +551,17 @@ commitPathSt: aString
 classes
 	"We need to do a reverse scan."
 	^Smalltalk current classes select: [:c | c package == self]
+!
+
+sortedClasses
+	"Answer all classes in the receiver, sorted by superclass/subclasses"
+	
+	^self classes inject: #() into: [:acc :each | 
+		acc isEmpty 
+			ifTrue: [acc add: each; yourself]
+			ifFalse: [(acc includes: each superclass)
+				ifTrue: [acc add: each; yourself]
+				ifFalse: [{each}, acc]]]
 ! !
 
 !Package methodsFor: 'printing'!
@@ -662,11 +679,6 @@ A Number can be used to evaluate a Block a fixed number of times:
 	
 	1 to: 10 by: 2 do: [:aNumber| Transcript show: aNumber asString; cr].!
 
-!Number methodsFor: ''!
-
-
-! !
-
 !Number methodsFor: 'accessing'!
 
 identityHash
@@ -1271,137 +1283,189 @@ new
 	    self error: 'You cannot create new instances of UndefinedObject. Use nil'
 ! !
 
-Object subclass: #Random
+Object subclass: #Date
 	instanceVariableNames: ''
 	category: 'Kernel-Objects'!
-!Random commentStamp!
-`Random` is a random number generator and is implemented as a trivial wrapper around javascript `Math.random()` and is used like this:
+!Date commentStamp!
+The Date class is used to work with dates and times. Therefore `Date today` and `Date now` are both valid in
+Amber and answer the same date object.
 
-	Random new next
+Date wraps the `Date()` JavaScript constructor, and Smalltalk date objects are JavaScript date objects.!
 
-This will return a float x where x < 1 and x > 0. If you want a random integer from 1 to 10 you can use `#atRandom`
+!Date methodsFor: 'accessing'!
 
-	10 atRandom
+year
+	<return self.getFullYear()>
+!
 
-...and if you want a random number in a specific interval this also works:
+month
+	<return self.getMonth() + 1>
+!
 
-	(3 to: 7) atRandom
+month: aNumber
+	<self.setMonth(aNumber - 1)>
+!
 
-...but be aware that `#to:` does not create an Interval as in other Smalltalk implementations but in fact an `Array` of numbers, so it's better to use:
+day
+	^self dayOfWeek
+!
 
-	5 atRandom + 2
+dayOfWeek
+	<return self.getDay() + 1>
+!
 
-Since `#atRandom` is implemented in `SequencableCollection` you can easy pick an element at random:
+dayOfWeek: aNumber
+	<return self.setDay(aNumber - 1)>
+!
 
-	#('a' 'b' 'c') atRandom
+day: aNumber
+	self day: aNumber
+!
 
-...or perhaps a letter from a `String`:
+year: aNumber
+	<self.setFullYear(aNumber)>
+!
 
-	'abc' atRandom
+dayOfMonth
+	<return self.getDate()>
+!
 
-Since Amber does not have Characters this will return a `String` of length 1 like for example `'b'`.!
+dayOfMonth: aNumber
+	<self.setDate(aNumber)>
+!
 
-!Random methodsFor: 'accessing'!
+time
+	<return self.getTime()>
+!
 
-next
-	<return Math.random()>
+time: aNumber
+	<self.setTime(aNumber)>
 !
 
-next: anInteger
-    ^(1 to: anInteger) collect: [:each | self next]
-! !
+hours: aNumber
+	<self.setHours(aNumber)>
+!
 
-Object subclass: #Point
-	instanceVariableNames: 'x y'
-	category: 'Kernel-Objects'!
-!Point commentStamp!
-A `Point` represents an x-y pair of numbers usually designating a geometric coordinate.
-Points are traditionally created using the binary `#@` message to a number:
+minutes: aNumber
+	<self.setMinutes(aNumber)>
+!
 
-	100@120
+seconds: aNumber
+	<self.setSeconds(aNumber)>
+!
 
-Points can then be arithmetically manipulated:
+milliseconds: aNumber
+	<self.setMilliseconds(aNumber)>
+!
 
-	100@100 + (10@10)
+hours
+	<return self.getHours()>
+!
 
-...or for example:
+minutes
+	<return self.getMinutes()>
+!
 
-	(100@100) * 2
+seconds
+	<return self.getSeconds()>
+!
 
-**NOTE:** Creating a Point with a negative y-value will need a space after `@` in order to avoid a parsing error:
+milliseconds
+	<return self.getMilliseconds()>
+! !
 
-	100@ -100 "but 100@-100 would not parse"
+!Date methodsFor: 'arithmetic'!
 
-Amber does not have much behavior in this class out-of-the-box.!
+- aDate
+	<return self - aDate>
+!
 
-!Point methodsFor: 'accessing'!
++ aDate
+	<return self + aDate>
+! !
 
-x
-	^x
+!Date methodsFor: 'comparing'!
+
+< aDate
+	<return self < aDate>
 !
 
-y
-	^y
+> aDate
+	<return self >> aDate>
 !
 
-y: aNumber
-	y := aNumber
+<= aDate
+	<return self <= aDate>
 !
 
-x: aNumber
-	x := aNumber
+>= aDate
+	<return self >>= aDate>
 ! !
 
-!Point methodsFor: 'arithmetic'!
+!Date methodsFor: 'converting'!
 
-* aPoint
-	^Point x: self x * aPoint asPoint x y: self y * aPoint asPoint y
+asString
+	<return self.toString()>
 !
 
-+ aPoint
-	^Point x: self x + aPoint asPoint x y: self y + aPoint asPoint y
+asMilliseconds
+	^self time
 !
 
-- aPoint
-	^Point x: self x - aPoint asPoint x y: self y - aPoint asPoint y
+asDateString
+	<return self.toDateString()>
 !
 
-/ aPoint
-	^Point x: self x / aPoint asPoint x y: self y / aPoint asPoint y
+asTimeString
+	<return self.toTimeString()>
 !
 
-= aPoint
-	^aPoint class = self class and: [
-		(aPoint x = self x) & (aPoint y = self y)]
+asLocaleString
+	<return self.toLocaleString()>
+!
+
+asNumber
+	^self asMilliseconds
 ! !
 
-!Point methodsFor: 'converting'!
+!Date methodsFor: 'printing'!
 
-asPoint
-	^self
+printString
+	^self asString
 ! !
 
-!Point methodsFor: 'printing'!
+!Date class methodsFor: 'instance creation'!
 
-printString
-	"Print receiver in classic x@y notation."
+new: anObject
+	<return new Date(anObject)>
+!
 
-	^String streamContents: [:stream |
-		stream nextPutAll: x printString, '@'.
-		(y notNil and: [y negative])
-			ifTrue: [
-				"Avoid ambiguous @- construct"
-				stream space].
-		stream nextPutAll: y printString]
-! !
+fromString: aString
+	"Example: Date fromString('2011/04/15 00:00:00')"
+	^self new: aString
+!
 
-!Point class methodsFor: 'instance creation'!
+fromSeconds: aNumber
+	^self fromMilliseconds: aNumber * 1000
+!
 
-x: aNumber y: anotherNumber
+fromMilliseconds: aNumber
+	^self new: aNumber
+!
+
+today
 	^self new
-		x: aNumber;
-		y: anotherNumber;
-		yourself
+!
+
+now
+	^self today
+!
+
+millisecondsToRun: aBlock
+	| t |
+	t := Date now.
+	aBlock value.
+	^Date now - t
 ! !
 
 Object subclass: #JSObjectProxy
@@ -1487,3 +1551,136 @@ on: aJSObject
 		yourself
 ! !
 
+Object subclass: #Point
+	instanceVariableNames: 'x y'
+	category: 'Kernel-Objects'!
+!Point commentStamp!
+A `Point` represents an x-y pair of numbers usually designating a geometric coordinate.
+Points are traditionally created using the binary `#@` message to a number:
+
+	100@120
+
+Points can then be arithmetically manipulated:
+
+	100@100 + (10@10)
+
+...or for example:
+
+	(100@100) * 2
+
+**NOTE:** Creating a Point with a negative y-value will need a space after `@` in order to avoid a parsing error:
+
+	100@ -100 "but 100@-100 would not parse"
+
+Amber does not have much behavior in this class out-of-the-box.!
+
+!Point methodsFor: 'accessing'!
+
+x
+	^x
+!
+
+y
+	^y
+!
+
+y: aNumber
+	y := aNumber
+!
+
+x: aNumber
+	x := aNumber
+! !
+
+!Point methodsFor: 'arithmetic'!
+
+* aPoint
+	^Point x: self x * aPoint asPoint x y: self y * aPoint asPoint y
+!
+
++ aPoint
+	^Point x: self x + aPoint asPoint x y: self y + aPoint asPoint y
+!
+
+- aPoint
+	^Point x: self x - aPoint asPoint x y: self y - aPoint asPoint y
+!
+
+/ aPoint
+	^Point x: self x / aPoint asPoint x y: self y / aPoint asPoint y
+!
+
+= aPoint
+	^aPoint class = self class and: [
+		(aPoint x = self x) & (aPoint y = self y)]
+! !
+
+!Point methodsFor: 'converting'!
+
+asPoint
+	^self
+! !
+
+!Point methodsFor: 'printing'!
+
+printString
+	"Print receiver in classic x@y notation."
+
+	^String streamContents: [:stream |
+		stream nextPutAll: x printString, '@'.
+		(y notNil and: [y negative])
+			ifTrue: [
+				"Avoid ambiguous @- construct"
+				stream space].
+		stream nextPutAll: y printString]
+! !
+
+!Point class methodsFor: 'instance creation'!
+
+x: aNumber y: anotherNumber
+	^self new
+		x: aNumber;
+		y: anotherNumber;
+		yourself
+! !
+
+Object subclass: #Random
+	instanceVariableNames: ''
+	category: 'Kernel-Objects'!
+!Random commentStamp!
+`Random` is a random number generator and is implemented as a trivial wrapper around javascript `Math.random()` and is used like this:
+
+	Random new next
+
+This will return a float x where x < 1 and x > 0. If you want a random integer from 1 to 10 you can use `#atRandom`
+
+	10 atRandom
+
+...and if you want a random number in a specific interval this also works:
+
+	(3 to: 7) atRandom
+
+...but be aware that `#to:` does not create an Interval as in other Smalltalk implementations but in fact an `Array` of numbers, so it's better to use:
+
+	5 atRandom + 2
+
+Since `#atRandom` is implemented in `SequencableCollection` you can easy pick an element at random:
+
+	#('a' 'b' 'c') atRandom
+
+...or perhaps a letter from a `String`:
+
+	'abc' atRandom
+
+Since Amber does not have Characters this will return a `String` of length 1 like for example `'b'`.!
+
+!Random methodsFor: 'accessing'!
+
+next
+	<return Math.random()>
+!
+
+next: anInteger
+    ^(1 to: anInteger) collect: [:each | self next]
+! !
+