Smalltalk current createPackage: 'Kernel-Objects' properties: #{}! nil subclass: #Object instanceVariableNames: '' package: 'Kernel-Objects'! !Object commentStamp! *Object is the root of the Smalltalk class system*. All classes in the system are subclasses of Object. Object provides default behavior common to all normal objects, such as: - access - copying - comparison - error handling - message sending - reflection Also utility messages that all objects should respond to are defined here. Object has no instance variable. ##Access Instance variables can be accessed with `#instVarAt:` and `#instVarAt:put:`. `Object >> instanceVariableNames` answers a collection of all instance variable names. Accessing JavaScript properties of an object is done through `#basicAt:`, `#basicAt:put:` and `basicDelete:`. ##Copying Copying an object is handled by `#copy` and `#deepCopy`. The first one performs a shallow copy of the receiver, while the second one performs a deep copy. The hook method `#postCopy` can be overriden in subclasses to copy fields as necessary to complete the full copy. It will be sent by the copy of the receiver. ##Comparison Objects understand equality `#=` and identity `#==` comparison. ##Error handling - `#halt` is the typical message to use for inserting breakpoints during debugging. - `#error:` throws a generic error exception - `#doesNotUnderstand:` handles the fact that there was an attempt to send the given message to the receiver but the receiver does not understand this message. Overriding this message can be useful to implement proxies for example.! !Object methodsFor: 'accessing'! basicAt: aString ! basicAt: aString put: anObject ! basicDelete: aString ! class ! identityHash < var hash=self.identityHash; if (hash) return hash; hash=smalltalk.nextId(); Object.defineProperty(self, 'identityHash', {value:hash}); return hash; > ! instVarAt: aSymbol | varname | varname := aSymbol asString. ! instVarAt: aSymbol put: anObject | varname | varname := aSymbol asString. ! size self error: 'Object not indexable' ! yourself ^self ! ! !Object methodsFor: 'comparing'! = anObject ^self == anObject ! == anObject ^self identityHash = anObject identityHash ! ~= anObject ^(self = anObject) = false ! ~~ anObject ^(self == anObject) = false ! ! !Object methodsFor: 'converting'! -> anObject ^Association key: self value: anObject ! asJSON | variables | variables := HashedCollection new. self class allInstanceVariableNames do: [:each | variables at: each put: (self instVarAt: each) asJSON]. ^variables ! asJSONString ^JSON stringify: self asJSON ! asJavascript ^self asString ! asString ^self printString ! ! !Object methodsFor: 'copying'! copy ^self shallowCopy postCopy ! deepCopy < var copy = self.klass._new(); for(var i in self) { if(/^@.+/.test(i)) { copy[i] = self[i]._deepCopy(); } } return copy; > ! postCopy ! shallowCopy < var copy = self.klass._new(); for(var i in self) { if(/^@.+/.test(i)) { copy[i] = self[i]; } } return copy; > ! ! !Object methodsFor: 'error handling'! deprecatedAPI "Just a simple way to deprecate methods. #deprecatedAPI is in the 'error handling' protocol even if it doesn't throw an error, but it could in the future." console warn: thisContext home asString, ' is deprecated!! (in ', thisContext home home asString, ')' ! doesNotUnderstand: aMessage MessageNotUnderstood new receiver: self; message: aMessage; signal ! error: aString Error signal: aString ! halt self error: 'Halt encountered' ! shouldNotImplement self error: 'This method should not be implemented in ', self class name ! subclassResponsibility self error: 'This method is a responsibility of a subclass' ! try: aBlock catch: anotherBlock ! ! !Object methodsFor: 'initialization'! initialize ! ! !Object methodsFor: 'message handling'! basicPerform: aSymbol ^self basicPerform: aSymbol withArguments: #() ! basicPerform: aSymbol withArguments: aCollection ! perform: aSymbol ^self perform: aSymbol withArguments: #() ! perform: aSymbol withArguments: aCollection | selector | selector := aSymbol asSelector. ! ! !Object methodsFor: 'printing'! log: aString block: aBlock | result | console log: aString, ' time: ', (Date millisecondsToRun: [result := aBlock value]) printString. ^result ! printNl ! printString ^'a ', self class name ! storeOn: aStream aStream nextPutAll: self printString ! storeString "Answer a String representation of the receiver from which the receiver can be reconstructed." ^ String streamContents: [:s | self storeOn: s] ! ! !Object methodsFor: 'testing'! ifNil: aBlock "inlined in the Compiler" ^self ! ifNil: aBlock ifNotNil: anotherBlock "inlined in the Compiler" ^anotherBlock value ! ifNotNil: aBlock "inlined in the Compiler" ^aBlock value ! ifNotNil: aBlock ifNil: anotherBlock "inlined in the Compiler" ^aBlock value ! isClass ^false ! isKindOf: aClass ^(self isMemberOf: aClass) ifTrue: [true] ifFalse: [self class inheritsFrom: aClass] ! isMemberOf: aClass ^self class = aClass ! isMetaclass ^false ! isNil ^false ! isNumber ^false ! isParseFailure ^false ! isString ^false ! isSymbol ^false ! notNil ^self isNil not ! respondsTo: aSelector ^self class canUnderstand: aSelector ! ! !Object class methodsFor: 'initialization'! initialize "no op" ! ! Object subclass: #Boolean instanceVariableNames: '' package: 'Kernel-Objects'! !Boolean commentStamp! Boolean wraps the JavaScript `Boolean()` constructor. The `true` and `false` objects are the JavaScript boolean objects. Boolean defines the protocol for logic testing operations and conditional control structures for the logical values. Boolean instances are weither `true` or `false`.! !Boolean methodsFor: 'comparing'! = aBoolean aBoolean class = self class ifFalse: [^false]. ! == aBoolean ^self = aBoolean ! ! !Boolean methodsFor: 'controlling'! & aBoolean < if(self == true) { return aBoolean; } else { return false; } > ! and: aBlock ^self = true ifTrue: aBlock ifFalse: [false] ! ifFalse: aBlock "inlined in the Compiler" ^self ifTrue: [] ifFalse: aBlock ! ifFalse: aBlock ifTrue: anotherBlock "inlined in the Compiler" ^self ifTrue: anotherBlock ifFalse: aBlock ! ifTrue: aBlock "inlined in the Compiler" ^self ifTrue: aBlock ifFalse: [] ! ifTrue: aBlock ifFalse: anotherBlock "inlined in the Compiler" < if(self == true) { return aBlock(); } else { return anotherBlock(); } > ! not ^self = false ! or: aBlock ^self = true ifTrue: [true] ifFalse: aBlock ! | aBoolean < if(self == true) { return true; } else { return aBoolean; } > ! ! !Boolean methodsFor: 'converting'! asJSON ^self ! ! !Boolean methodsFor: 'copying'! deepCopy ^self ! shallowCopy ^self ! ! !Boolean methodsFor: 'printing'! printString ! ! Object subclass: #Date instanceVariableNames: '' package: 'Kernel-Objects'! !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. Date wraps the `Date()` JavaScript constructor, and Smalltalk date objects are JavaScript date objects.! !Date methodsFor: 'accessing'! day ^self dayOfWeek ! day: aNumber self dayOfWeek: aNumber ! dayOfMonth ! dayOfMonth: aNumber ! dayOfWeek ! dayOfWeek: aNumber ! hours ! hours: aNumber ! milliseconds ! milliseconds: aNumber ! minutes ! minutes: aNumber ! month ! month: aNumber ! seconds ! seconds: aNumber ! time ! time: aNumber ! year ! year: aNumber ! ! !Date methodsFor: 'arithmetic'! + aDate ! - aDate ! ! !Date methodsFor: 'comparing'! < aDate ! <= aDate ! > aDate > aDate> ! >= aDate >= aDate> ! ! !Date methodsFor: 'converting'! asDateString ! asLocaleString ! asMilliseconds ^self time ! asNumber ^self asMilliseconds ! asString ! asTimeString ! ! !Date methodsFor: 'printing'! printString ^self asString ! ! !Date class methodsFor: 'instance creation'! fromMilliseconds: aNumber ^self new: aNumber ! fromSeconds: aNumber ^self fromMilliseconds: aNumber * 1000 ! fromString: aString "Example: Date fromString('2011/04/15 00:00:00')" ^self new: aString ! millisecondsToRun: aBlock | t | t := Date now. aBlock value. ^Date now - t ! new: anObject ! now ^self today ! today ^self new ! ! Object subclass: #JSObjectProxy instanceVariableNames: 'jsObject' package: 'Kernel-Objects'! !JSObjectProxy commentStamp! JSObjectProxy handles sending messages to JavaScript object, therefore accessing JavaScript objects from Amber is transparent. JSOjbectProxy makes intensive use of `#doesNotUnderstand:`. ## Examples JSObjectProxy objects are instanciated by Amber when a Smalltalk message is sent to a JavaScript object. window alert: 'hello world'. window inspect. (window jQuery: 'body') append: 'hello world' Smalltalk messages sends are converted to JavaScript function calls or object property access _(in this order)_. If n one of them match, a `MessageNotUnderstood` error will be thrown. ## Message conversion rules - `someUser name` becomes `someUser.name` - `someUser name: 'John'` becomes `someUser name = "John"` - `console log: 'hello world'` becomes `console.log('hello world')` - `(window jQuery: 'foo') css: 'background' color: 'red'` becomes `window.jQuery('foo').css('background', 'red')` __Note:__ For keyword-based messages, only the first keyword is kept: `window foo: 1 bar: 2` is equivalent to `window foo: 1 baz: 2`.! !JSObjectProxy methodsFor: 'accessing'! at: aSymbol | attr | attr := aSymbol asString. ! at: aSymbol put: anObject | attr | attr := aSymbol asString. ! jsObject ^jsObject ! jsObject: aJSObject jsObject := aJSObject ! ! !JSObjectProxy methodsFor: 'proxy'! doesNotUnderstand: aMessage | obj selector jsSelector arguments | obj := self jsObject. selector := aMessage selector. jsSelector := selector asJavaScriptSelector. arguments := aMessage arguments. . super doesNotUnderstand: aMessage ! inspectOn: anInspector | variables | variables := Dictionary new. variables at: '#self' put: self jsObject. anInspector setLabel: self printString. . anInspector setVariables: variables ! printString ^self jsObject toString ! ! !JSObjectProxy class methodsFor: 'instance creation'! on: aJSObject ^self new jsObject: aJSObject; yourself ! ! Object subclass: #Number instanceVariableNames: '' package: 'Kernel-Objects'! !Number commentStamp! Number holds the most general methods for dealing with numbers. Number is directly mapped to JavaScript Number. Most arithmetic methods like `#+` `#/` `#-` `#max:` are directly inlined into javascript. ##Enumerating A Number can be used to evaluate a Block a fixed number of times: 5 timesRepeat: [Transcript show: 'This will be printed 5 times'; cr]. 1 to: 5 do: [:aNumber| Transcript show: aNumber asString; cr]. 1 to: 10 by: 2 do: [:aNumber| Transcript show: aNumber asString; cr].! !Number methodsFor: 'accessing'! identityHash ^self asString, 'n' ! ! !Number methodsFor: 'arithmetic'! * aNumber "Inlined in the Compiler" ! + aNumber "Inlined in the Compiler" ! - aNumber "Inlined in the Compiler" ! / aNumber "Inlined in the Compiler" ! \\ aNumber ! max: aNumber ! min: aNumber ! negated ^0 - self ! sqrt ! squared ^self * self ! ! !Number methodsFor: 'comparing'! < aNumber "Inlined in the Compiler" ! <= aNumber "Inlined in the Compiler" ! = aNumber aNumber isNumber ifFalse: [^false]. ! > aNumber "Inlined in the Compiler" > aNumber> ! >= aNumber "Inlined in the Compiler" >= aNumber> ! ! !Number methodsFor: 'converting'! & aNumber ! @ aNumber ^Point x: self y: aNumber ! asJSON ^self ! asJavascript ^'(', self printString, ')' ! asPoint ^Point x: self y: self ! asString ^self printString ! atRandom ^(Random new next * self) truncated + 1 ! rounded ! to: aNumber | array first last count | first := self truncated. last := aNumber truncated + 1. count := 1. array := Array new. (last - first) timesRepeat: [ array at: count put: first. count := count + 1. first := first + 1]. ^array ! to: stop by: step | array value pos | value := self. array := Array new. pos := 1. step = 0 ifTrue: [self error: 'step must be non-zero']. step < 0 ifTrue: [[ value >= stop ] whileTrue: [ array at: pos put: value. pos := pos + 1. value := value + step]] ifFalse: [[ value <= stop ] whileTrue: [ array at: pos put: value. pos := pos + 1. value := value + step]]. ^array ! truncated |result| self >= 0 ifTrue: [] ifFalse: []. ^ result ! | aNumber ! ! !Number methodsFor: 'copying'! copy ^self ! deepCopy ^self copy ! ! !Number methodsFor: 'enumerating'! timesRepeat: aBlock | integer count | integer := self truncated. count := 1. [count > self] whileFalse: [ aBlock value. count := count + 1] ! to: stop by: step do: aBlock | value | value := self. step = 0 ifTrue: [self error: 'step must be non-zero']. step < 0 ifTrue: [[ value >= stop ] whileTrue: [ aBlock value: value. value := value + step]] ifFalse: [[ value <= stop ] whileTrue: [ aBlock value: value. value := value + step]] ! to: stop do: aBlock "Evaluate aBlock for each number from self to aNumber." | nextValue | nextValue := self. [nextValue <= stop] whileTrue: [aBlock value: nextValue. nextValue := nextValue + 1] ! ! !Number methodsFor: 'printing'! printShowingDecimalPlaces: placesDesired ! printString ! ! !Number methodsFor: 'testing'! even ^ 0 = (self \\ 2) ! isNumber ^true ! isZero ^self = 0 ! negative "Answer whether the receiver is mathematically negative." ^ self < 0 ! odd ^ self even not ! positive "Answer whether the receiver is positive or equal to 0. (ST-80 protocol)." ^ self >= 0 ! ! !Number methodsFor: 'timeouts/intervals'! clearInterval ! clearTimeout ! ! !Number class methodsFor: 'instance creation'! pi ! ! Object subclass: #Package instanceVariableNames: 'commitPathJs commitPathSt' package: 'Kernel-Objects'! !Package commentStamp! A Package is similar to a "class category" typically found in other Smalltalks like Pharo or Squeak. Amber does not have class categories anymore, it had in the beginning but now each class in the system knows which package it belongs to. A Package has a name, an Array of "requires", a comment and a Dictionary with other optional key value attributes. A Package can also be queried for its classes, but it will then resort to a reverse scan of all classes to find them. Packages are manipulated through "Smalltalk current", like for example finding one based on a name: Smalltalk current packageAt: 'Kernel' ...but you can also use: Package named: 'Kernel' A Package differs slightly from a Monticello package which can span multiple class categories using a naming convention based on hyphenation. But just as in Monticello a Package supports "class extensions" so a Package can define behaviors in foreign classes using a naming convention for method categories where the category starts with an asterisk and then the name of the owning package follows. This can easily be seen in for example class String where the method category "*IDE" defines #inspectOn: which thus is a method belonging to the IDE package. You can fetch a package from the server: Package fetch: 'Additional-Examples'! !Package methodsFor: 'accessing'! commitPathJs ^ commitPathJs ifNil: [self class defaultCommitPathJs] ! commitPathJs: aString commitPathJs := aString ! commitPathSt ^ commitPathSt ifNil: [self class defaultCommitPathSt] ! commitPathSt: aString commitPathSt := aString ! dependencies ^self propertyAt: 'dependencies' ifAbsent: [#()] ! dependencies: anArray ^self propertyAt: 'dependencies' put: anArray ! name ! name: aString ! properties ^Smalltalk current readJSObject: (self basicAt: 'properties') ! properties: aDict "We store it as a javascript object." | object |