Lightweight alternative to Announcement with only strong references.

BaselineOfLightweightObserver/BaselineOfLightweightObserver.class.st

@@ -0,0 +1,17 @@
+Class {
+	#name : #BaselineOfLightweightObserver,
+	#superclass : #BaselineOf,
+	#category : #BaselineOfLightweightObserver
+}
+
+{ #category : #baselines }
+BaselineOfLightweightObserver >> baseline: spec [
+	<baseline>
+
+	spec for: #'common' do: [
+		spec 
+			blessing: #'baseline';
+			repository: 'github://bouraqadi/PharoMisc'; 
+			package: #LightweightObserver. ].
+
+]

BaselineOfLightweightObserver/package.st

@@ -0,0 +1 @@
+Package { #name : #BaselineOfLightweightObserver }

LightweightObserver/Array.extension.st

@@ -0,0 +1,11 @@
+Extension { #name : #Array }
+
+{ #category : #'*LightweightObserver' }
+Array >> asSubject [
+	| subject |
+	subject := LoSubjectArray new: self size.
+	self withIndexDo: [ : value : index | subject at: index put: value ].
+	self becomeForward: subject.
+
+
+]

LightweightObserver/Collection.extension.st

@@ -0,0 +1,8 @@
+Extension { #name : #Collection }
+
+{ #category : #'*LightweightObserver' }
+Collection class >> adoptInstance: aCollection [
+	[ super adoptInstance: aCollection ] 
+		on: Error 
+		do: [ (self withAll: aCollection) become: aCollection ]
+]

LightweightObserver/CompiledMethod.extension.st

@@ -0,0 +1,6 @@
+Extension { #name : #CompiledMethod }
+
+{ #category : #'*LightweightObserver' }
+CompiledMethod >> isBasicMethod [
+	^false
+]

LightweightObserver/Dictionary.extension.st

@@ -0,0 +1,6 @@
+Extension { #name : #Dictionary }
+
+{ #category : #'*LightweightObserver' }
+Dictionary >> asSubject [
+	LoSubjectDictionary adoptInstance: self
+]

LightweightObserver/LoArrayAutomaticEventGenerationTest.class.st

@@ -0,0 +1,48 @@
+Class {
+	#name : #LoArrayAutomaticEventGenerationTest,
+	#superclass : #LoAutomaticEventGenerationTest,
+	#category : #'LightweightObserver-Test'
+}
+
+{ #category : #testing }
+LoArrayAutomaticEventGenerationTest >> testAtPut [
+	| lastRemovedValue lastAddedValue lastIndex|
+	subject collection: { 11. 21. 31. }.
+	subject 
+		afterReplaceInCollection: #collection 
+		do: [ : index : addedValue : removedValue | 
+			lastIndex := index.
+			lastRemovedValue := removedValue.
+			lastAddedValue := addedValue].
+	subject collection at: 1 put: 10.
+	self assert: lastRemovedValue equals: 11.
+	self assert: lastAddedValue equals: 10.
+	self assert: lastIndex equals: 1.
+	subject collection at: 2 put: 20.
+	self assert: lastRemovedValue equals: 21.
+	self assert: lastAddedValue equals: 20.
+	self assert: lastIndex equals: 2.
+
+]
+
+{ #category : #testing }
+LoArrayAutomaticEventGenerationTest >> testReset [
+	| lastRemovedValue lastAddedValue lastIndex|
+	subject collection: #(a b c).
+	subject 
+		afterReplaceInCollection: #collection 
+		do: [ : index : addedValue : removedValue| 
+			lastIndex := index.
+			lastRemovedValue := removedValue.
+			lastAddedValue := addedValue].
+	subject collection: { 11. 21. 31. }.
+	subject collection at: 1 put: 10.
+	self assert: lastRemovedValue equals: 11.
+	self assert: lastAddedValue equals: 10.
+	self assert: lastIndex equals: 1.
+	subject collection at: 2 put: 20.
+	self assert: lastRemovedValue equals: 21.
+	self assert: lastAddedValue equals: 20.
+	self assert: lastIndex equals: 2.
+
+]

LightweightObserver/LoAutomaticEventGenerationTest.class.st

@@ -0,0 +1,119 @@
+Class {
+	#name : #LoAutomaticEventGenerationTest,
+	#superclass : #TestCase,
+	#instVars : [
+		'subject'
+	],
+	#category : #'LightweightObserver-Test'
+}
+
+{ #category : #running }
+LoAutomaticEventGenerationTest >> setUp [
+	super setUp.
+	subject := LoSubjectForTest new
+]
+
+{ #category : #testing }
+LoAutomaticEventGenerationTest >> testObservingAnyIvChange [
+	| changeCounter |
+	changeCounter := 0.
+	subject afterChangeDo: [changeCounter := changeCounter + 1 ].
+	subject a: #someValue.
+	self assert: changeCounter equals: 1.
+	subject b: #otherValue.
+	self assert: changeCounter equals: 2.
+
+]
+
+{ #category : #testing }
+LoAutomaticEventGenerationTest >> testObservingMultipleIvsNewValues [
+	| aLastValue bLastValue |
+	subject afterChangeDo: [: event | 
+		aLastValue := event newValueFor: #a.
+		bLastValue := event newValueFor: #b ].
+	subject a: #someValue b: #otherValue.
+	self assert: aLastValue equals: #someValue.
+	self assert: bLastValue equals: #otherValue.
+
+]
+
+{ #category : #testing }
+LoAutomaticEventGenerationTest >> testObservingSpecificIvChange [
+	| aChangeCounter bChangeCounter |
+	aChangeCounter := 0.
+	bChangeCounter := 0.
+	subject afterChangeOf: #a do: [aChangeCounter := aChangeCounter + 1 ].
+	subject afterChangeOf: #b do: [bChangeCounter := bChangeCounter + 1 ].
+	subject a: #someValue.
+	self assert: aChangeCounter equals: 1.
+	self assert: bChangeCounter equals: 0.
+	subject b: #otherValue.
+	self assert: aChangeCounter equals: 1.
+	self assert: bChangeCounter equals: 1.
+
+]
+
+{ #category : #testing }
+LoAutomaticEventGenerationTest >> testObservingSpecificIvNewValue [
+	| aLastValue bLastValue |
+	subject afterChangeOf: #a do: [: newValue | aLastValue := newValue ].
+	subject afterChangeOf: #b do: [: newValue | bLastValue := newValue].
+	subject a: #someValue.
+	self assert: aLastValue equals: #someValue.
+	subject b: #otherValue.
+	self assert: bLastValue equals: #otherValue.
+
+]
+
+{ #category : #testing }
+LoAutomaticEventGenerationTest >> testPerformingMessagesWithoutObserving [
+	subject a: #someValue.
+	self assert: subject a equals: #someValue.
+	subject b: #otherValue.
+	self assert: subject b equals: #otherValue.
+
+]
+
+{ #category : #testing }
+LoAutomaticEventGenerationTest >> testRestartObservingAnyIvChange [
+	| changeCounter observer |
+	changeCounter := 0.
+	observer := subject afterChangeDo: [changeCounter := changeCounter + 1 ].
+	observer stopObserving.
+	subject a: #someValue.
+	observer startObserving.
+	self assert: changeCounter equals: 0.
+	subject b: #otherValue.
+	self assert: changeCounter equals: 1.
+
+]
+
+{ #category : #testing }
+LoAutomaticEventGenerationTest >> testStopObservingAnyIvChange [
+	| changeCounter observer |
+	changeCounter := 0.
+	observer := subject afterChangeDo: [changeCounter := changeCounter + 1 ].
+	observer stopObserving.
+	subject a: #someValue.
+	self assert: changeCounter equals: 0.
+	subject b: #otherValue.
+	self assert: changeCounter equals: 0.
+
+]
+
+{ #category : #testing }
+LoAutomaticEventGenerationTest >> testStopObservingSpecificIvChange [
+	| aChangeCounter bChangeCounter observer |
+	aChangeCounter := 0.
+	bChangeCounter := 0.
+	observer := subject afterChangeOf: #a do: [aChangeCounter := aChangeCounter + 1 ].
+	subject afterChangeOf: #b do: [bChangeCounter := bChangeCounter + 1 ].
+	observer stopObserving.
+	subject a: #someValue.
+	self assert: aChangeCounter equals: 0.
+	self assert: bChangeCounter equals: 0.
+	subject b: #otherValue.
+	self assert: aChangeCounter equals: 0.
+	self assert: bChangeCounter equals: 1.
+
+]

LightweightObserver/LoCompositeObserver.class.st

@@ -0,0 +1,42 @@
+"
+Composite observer. I am actually a collection of observers that are my children.
+
+    Instance Variables
+	children:		<Collection of observers>
+
+"
+Class {
+	#name : #LoCompositeObserver,
+	#superclass : #Object,
+	#instVars : [
+		'children'
+	],
+	#category : #'LightweightObserver-Kernel'
+}
+
+{ #category : #'instance creation' }
+LoCompositeObserver class >> children: aCollection [ 
+	^self new
+		children: aCollection;
+		yourself
+]
+
+{ #category : #accessing }
+LoCompositeObserver >> children [
+	^ children
+]
+
+{ #category : #accessing }
+LoCompositeObserver >> children: anObject [
+	children := anObject
+]
+
+{ #category : #observing }
+LoCompositeObserver >> startObserving [
+	self children do: [ : each | each startObserving ]
+]
+
+{ #category : #observing }
+LoCompositeObserver >> stopObserving [
+	self children do: [ : each | each stopObserving ]
+]

LightweightObserver/LoCustomEventObserverTest.class.st

@@ -0,0 +1,84 @@
+Class {
+	#name : #LoCustomEventObserverTest,
+	#superclass : #TestCase,
+	#instVars : [
+		'subject',
+		'dispatcher'
+	],
+	#category : #'LightweightObserver-Test'
+}
+
+{ #category : #testing }
+LoCustomEventObserverTest >> setUp [
+	super setUp.
+	subject := LoSubjectForTest new.
+
+]
+
+{ #category : #testing }
+LoCustomEventObserverTest >> testEventData [
+	| eventData newEvent |
+	subject on: LoEvent1ForTest do: [: event | eventData := event data  ].
+	newEvent := LoEvent1ForTest new.
+	newEvent data: 123.
+	subject dispatch: newEvent.
+	self assert: eventData equals: newEvent data.
+]
+
+{ #category : #testing }
+LoCustomEventObserverTest >> testEventInheritanceObserver [
+	| eventCounter |
+	eventCounter := 0.
+	subject on: LoEvent2ForTest do: [eventCounter := eventCounter + 1  ].
+	3 timesRepeat: [subject dispatch: LoEvent3ForTest new].
+	self assert: eventCounter equals: 3.
+]
+
+{ #category : #testing }
+LoCustomEventObserverTest >> testSingleEventObserver [
+	| eventCounter |
+	eventCounter := 0.
+	subject on: LoEvent1ForTest do: [eventCounter := eventCounter + 1  ].
+	3 timesRepeat: [subject dispatch: LoEvent1ForTest new].
+	self assert: eventCounter equals: 3.
+]
+
+{ #category : #testing }
+LoCustomEventObserverTest >> testTwoObserversForDifferentEvents [
+	| counterA counterB |
+	counterA := 0.
+	subject on: LoEvent1ForTest do: [counterA := counterA + 1  ].
+	counterB := 0.
+	subject on: LoEvent2ForTest do: [counterB := counterB + 1  ].
+	subject dispatch: LoEvent1ForTest new.
+	self assert: counterA equals: 1.
+	self assert: counterB equals: 0.
+	2 timesRepeat: [subject dispatch: LoEvent2ForTest new].
+	self assert: counterA equals: 1.
+	self assert: counterB equals: 2.
+
+]
+
+{ #category : #testing }
+LoCustomEventObserverTest >> testTwoObserversForSameEvent [
+	| counterA counterB |
+	counterA := 0.
+	subject on: LoEvent1ForTest do: [counterA := counterA + 1  ].
+	subject dispatch: LoEvent1ForTest new.
+	counterB := 0.
+	subject on: LoEvent1ForTest do: [counterB := counterB + 1  ].
+	subject dispatch: LoEvent1ForTest new.
+	self assert: counterA equals: 2.
+	self assert: counterB equals: 1.
+
+]
+
+{ #category : #testing }
+LoCustomEventObserverTest >> testUnsbscribingAnEventObserver [
+	| eventCounter observer |
+	eventCounter := 0.
+	observer := subject on: LoEvent1ForTest do: [eventCounter := eventCounter + 1  ].
+	subject unsubscribe: observer.
+	3 timesRepeat: [subject dispatch: LoEvent1ForTest new].
+	self assert: eventCounter equals: 0.
+]