On 12-08-17 10:47, Tudor Girba wrote:
Is this still an issue?

Yep. I tried with a clean 6.1 install.
The Moz2D library is downloaded, but does not seem to be installed correctly

> Could you also try on another OS (just to make sure)?

next step

Stephan

THERE_BE_DRAGONS_HERE
Warning
18 August 2017 4:56:07.371972 pm

VM: unix - i686 - linux-gnu - CoInterpreter VMMaker.oscog-eem.2254 uuid: 4f2c2cce-f4a2-469a-93f1-97ed941df0ad Jul 20 2017
StackToRegisterMappingCogit VMMaker.oscog-eem.2252 uuid: 2f3e9b0e-ecd3-4adf-b092-cce2e2587a5c Jul 20 2017
VM: 201707201942 https://github.com/OpenSmalltalk/opensmalltalk-vm.git $ Date: Thu Jul 20 12:42:21 2017 -0700 $ Plugins: 201707201942 https://github.com/OpenSmalltalk/opensmalltalk-vm.git $

Image: Pharo6.0 [Latest update: #60510]

MozServices class>>start
	Receiver: MozServices
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(#ffiLibraryName->MozServices>>#ffiLibraryName )
		format: 	0
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#MozServices
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Sparta-Moz2D'
		traitComposition: 	TMozLibrary
		localSelectors: 	a Set()
		isRunning: 	false


MozLibraryLinuxInstaller(MozLibraryInstaller)>>install
	Receiver: a MozLibraryLinuxInstaller
	Arguments and temporary variables: 
		pluginPath: 	File @ /home/stephan/Desktop/pharo6.1/bin/lib/pharo/5.0-20170720194...etc...
	Receiver's instance variables: 
a MozLibraryLinuxInstaller

MozLibraryInstaller class>>install
	Receiver: MozLibraryInstaller
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(#download->MozLibraryInstaller>>#download #downl...etc...
		format: 	0
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	{MozLibraryLinuxInstaller. MozLibraryMacInstaller. MozLibraryWindow...etc...
		name: 	#MozLibraryInstaller
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Sparta-Moz2D-Library'
		traitComposition: 	{}
		localSelectors: 	nil


[ :each | each method methodClass baseClass perform: each method selector ] in BaselineOfSparta>>postLoadSparta:
	Receiver: a BaselineOfSparta
	Arguments and temporary variables: 
		aSpecLoader: 	a MetacelloFetchingMCSpecLoader(linear load : 
	linear load : base...etc...
		pragmas: 	an OrderedCollection(<spartaPostLoad>)
		each: 	<spartaPostLoad>
	Receiver's instance variables: 
		project: 	BaselineOfSparta(baseline [BaselineOfSparta], )


OrderedCollection>>do:
	Receiver: an OrderedCollection(<spartaPostLoad>)
	Arguments and temporary variables: 
		aBlock: 	[ :each | each method methodClass baseClass perform: each method select...etc...
		index: 	1
	Receiver's instance variables: 
		array: 	an Array(<spartaPostLoad> nil nil nil nil nil nil nil nil nil)
		firstIndex: 	1
		lastIndex: 	1


BaselineOfSparta>>postLoadSparta:
	Receiver: a BaselineOfSparta
	Arguments and temporary variables: 
		aSpecLoader: 	a MetacelloFetchingMCSpecLoader(linear load : 
	linear load : base...etc...
		pragmas: 	an OrderedCollection(<spartaPostLoad>)
	Receiver's instance variables: 
		project: 	BaselineOfSparta(baseline [BaselineOfSparta], )


[ :aLoader | self project configuration perform: selector with: aLoader ] in MetacelloMCVersionSpec(MetacelloSpec)>>doItBlock:
	Receiver: spec postLoadDoIt: #'postLoadSparta:'.
spec repository: 'github://syrel/sparta/src'.
spec ...etc...
	Arguments and temporary variables: 
		selector: 	#postLoadSparta:
		aLoader: 	a MetacelloFetchingMCSpecLoader(linear load : 
	linear load : baseline...etc...
	Receiver's instance variables: 
		project: 	BaselineOfSparta(baseline [BaselineOfSparta], )
		loader: 	a MetacelloLoadingMCSpecLoader
		mutable: 	nil
		versionString: 	'baseline'
		blessing: 	nil
		description: 	nil
		author: 	nil
		timestamp: 	nil
		preLoadDoIt: 	nil
		postLoadDoIt: 	spec value: #postLoadSparta:
		packageList: 	spec	add: [
		spec 
			name: 'core';
			includes: #('Sparta-Core' ...etc...
		importName: 	nil
		importArray: 	nil
		repositories: 	spec
repository: 'github://syrel/sparta/src'
		packages: 	nil


BlockClosure>>valueWithPossibleArgs:
	Receiver: [ :aLoader | self project configuration perform: selector with: aLoader ]
	Arguments and temporary variables: 
		anArray: 	an Array(a MetacelloFetchingMCSpecLoader(linear load : 
	linear load :...etc...
	Receiver's instance variables: 
		outerContext: 	MetacelloMCVersionSpec(MetacelloSpec)>>doItBlock:
		startpc: 	75
		numArgs: 	1


[ block
	valueWithPossibleArgs:
		(Array with: aPostloadDirective loader with: aPostloadDirective spec) ] in MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadPostloadDirective:
	Receiver: linear load : 
	linear load : baseline [BaselineOfSparta]
		load : Sparta-Core-AliakseiSyr...etc...
	Arguments and temporary variables: 
		aPostloadDirective: 	postload : baseline [BaselineOfSparta] >> postLoadSparta:
		block: 	[ :aLoader | self project configuration perform: selector with: aLoader ...etc...
	Receiver's instance variables: 
		spec: 	nil
		loader: 	nil
		loadDirectives: 	an OrderedCollection(linear load : baseline [BaselineOfSparta]
...etc...


MetacelloPostLoadDirective(MetacelloPrePostLoadDirective)>>evaluateSupplyingAnswers:
	Receiver: postload : baseline [BaselineOfSparta] >> postLoadSparta:
	Arguments and temporary variables: 
		loadBlock: 	[ block
	valueWithPossibleArgs:
		(Array with: aPostloadDirective lo...etc...
		answers: 	#()
	Receiver's instance variables: 
		spec: 	spec postLoadDoIt: #'postLoadSparta:'.
spec repository: 'github://syrel/s...etc...
		loader: 	a MetacelloFetchingMCSpecLoader(linear load : 
	linear load : baseline ...etc...


MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadPostloadDirective:
	Receiver: linear load : 
	linear load : baseline [BaselineOfSparta]
		load : Sparta-Core-AliakseiSyr...etc...
	Arguments and temporary variables: 
		aPostloadDirective: 	postload : baseline [BaselineOfSparta] >> postLoadSparta:
		block: 	[ :aLoader | self project configuration perform: selector with: aLoader ...etc...
	Receiver's instance variables: 
		spec: 	nil
		loader: 	nil
		loadDirectives: 	an OrderedCollection(linear load : baseline [BaselineOfSparta]
...etc...


MetacelloPostLoadDirective>>loadUsing:gofer:
	Receiver: postload : baseline [BaselineOfSparta] >> postLoadSparta:
	Arguments and temporary variables: 
		aLoaderDirective: 	linear load : 
	linear load : baseline [BaselineOfSparta]
		l...etc...
		aGofer: 	a MetacelloGofer
	Receiver's instance variables: 
		spec: 	spec postLoadDoIt: #'postLoadSparta:'.
spec repository: 'github://syrel/s...etc...
		loader: 	a MetacelloFetchingMCSpecLoader(linear load : 
	linear load : baseline ...etc...


[ :directive | directive loadUsing: aLoaderDirective gofer: aGofer ] in MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadLinearLoadDirective:gofer:
	Receiver: linear load : 
	linear load : baseline [BaselineOfSparta]
		load : Sparta-Core-AliakseiSyr...etc...
	Arguments and temporary variables: 
		aLoaderDirective: 	linear load : 
	linear load : baseline [BaselineOfSparta]
		l...etc...
		aGofer: 	a MetacelloGofer
		directive: 	postload : baseline [BaselineOfSparta] >> postLoadSparta:
	Receiver's instance variables: 
		spec: 	nil
		loader: 	nil
		loadDirectives: 	an OrderedCollection(linear load : baseline [BaselineOfSparta]
...etc...


OrderedCollection>>do:
	Receiver: an OrderedCollection(linear load : baseline [BaselineOfSparta]
	load : Sparta-Core-Aliakse...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :directive | directive loadUsing: aLoaderDirective gofer: aGofer ]
		index: 	2
	Receiver's instance variables: 
		array: 	an Array(linear load : baseline [BaselineOfSparta]
	load : Sparta-Core-A...etc...
		firstIndex: 	1
		lastIndex: 	2


MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadLinearLoadDirective:gofer:
	Receiver: linear load : 
	linear load : baseline [BaselineOfSparta]
		load : Sparta-Core-AliakseiSyr...etc...
	Arguments and temporary variables: 
		aLoaderDirective: 	linear load : 
	linear load : baseline [BaselineOfSparta]
		l...etc...
		aGofer: 	a MetacelloGofer
	Receiver's instance variables: 
		spec: 	nil
		loader: 	nil
		loadDirectives: 	an OrderedCollection(linear load : baseline [BaselineOfSparta]
...etc...


MetacelloLinearLoadDirective>>loadUsing:gofer:
	Receiver: linear load : 
	linear load : baseline [BaselineOfSparta]
		load : Sparta-Core-AliakseiSyr...etc...
	Arguments and temporary variables: 
		aLoaderDirective: 	linear load : 
	linear load : baseline [BaselineOfSparta]
		l...etc...
		aGofer: 	a MetacelloGofer
	Receiver's instance variables: 
		spec: 	nil
		loader: 	nil
		loadDirectives: 	an OrderedCollection(linear load : baseline [BaselineOfSparta]
...etc...


MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadWithPolicy:
	Receiver: linear load : 
	linear load : baseline [BaselineOfSparta]
		load : Sparta-Core-AliakseiSyr...etc...
	Arguments and temporary variables: 
		aLoadPolicy: 	a MetacelloLoaderPolicy
		gofer: 	a MetacelloGofer
	Receiver's instance variables: 
		spec: 	nil
		loader: 	nil
		loadDirectives: 	an OrderedCollection(linear load : baseline [BaselineOfSparta]
...etc...


MetacelloLoaderPolicy>>load
	Receiver: a MetacelloLoaderPolicy
	Arguments and temporary variables: 

	Receiver's instance variables: 
		overrideRepositories: 	an Array(a MCDictionaryRepository(cache))
		repositoryMap: 	a Dictionary('Sparta-Cairo-AliakseiSyrel.1502129793'->an IceMeta...etc...
		ensuredMap: 	nil
		cacheRepository: 	a MCDictionaryRepository(cache)
		cacheGofer: 	nil
		ignoreImage: 	false
		loadData: 	a MetacelloLoadData
		loadDirective: 	linear load : 
	linear load : baseline [BaselineOfSparta]
		load...etc...
		silently: 	false


MetacelloFetchingMCSpecLoader>>doLoad
	Receiver: a MetacelloFetchingMCSpecLoader(linear load : 
	linear load : baseline [BaselineOfSparta]
...etc...
	Arguments and temporary variables: 

	Receiver's instance variables: 
		spec: 	a MetacelloMCVersionSpecLoader
		operator: 	nil
		loaderPolicy: 	a MetacelloLoaderPolicy
		disablePackageCache: 	false


[ fetchLoader doLoad ] in [ | fetchLoader |
fetchLoader := self
	fetchRequiredFromArray: (self defaultPackageNamesToLoad: anArray).
MetacelloPlatform current
	do: [ fetchLoader doLoad ]
	displaying: 'Loading ' , displayString.
Transcript
	cr;
	show: '...finished ' , self versionNumber printString.
^ fetchLoader ] in MetacelloMCVersion>>doLoadRequiredFromArray:
	Receiver: <>baseline [BaselineOfSparta]
	Arguments and temporary variables: 
		anArray: 	#(#development)
		displayString: 	'baseline of BaselineOfSparta'
		oldPolicy: 	a MetacelloLoaderPolicy
		oldBypassProgress: 	false
		fetchLoader: 	a MetacelloFetchingMCSpecLoader(linear load : 
	linear load : base...etc...
	Receiver's instance variables: 
		spec: 	spec postLoadDoIt: #'postLoadSparta:'.
spec repository: 'github://syrel/s...etc...
		versionNumber: 	baseline
		importedVersions: 	nil
		versionStatus: 	#somethingLoaded
		loaderPolicy: 	a MetacelloLoaderPolicy


IceMetacelloPharoPlatform(MetacelloPlatform)>>do:displaying:
	Receiver: an IceMetacelloPharoPlatform
	Arguments and temporary variables: 
		aBlock: 	[ fetchLoader doLoad ]
		aString: 	'Loading baseline of BaselineOfSparta'
	Receiver's instance variables: 
		bypassProgressBars: 	false
		bypassGoferLoadUpdateCategories: 	false


[ | fetchLoader |
fetchLoader := self
	fetchRequiredFromArray: (self defaultPackageNamesToLoad: anArray).
MetacelloPlatform current
	do: [ fetchLoader doLoad ]
	displaying: 'Loading ' , displayString.
Transcript
	cr;
	show: '...finished ' , self versionNumber printString.
^ fetchLoader ] in MetacelloMCVersion>>doLoadRequiredFromArray:
	Receiver: <>baseline [BaselineOfSparta]
	Arguments and temporary variables: 
		anArray: 	#(#development)
		displayString: 	'baseline of BaselineOfSparta'
		oldPolicy: 	a MetacelloLoaderPolicy
		oldBypassProgress: 	false
		fetchLoader: 	a MetacelloFetchingMCSpecLoader(linear load : 
	linear load : base...etc...
	Receiver's instance variables: 
		spec: 	spec postLoadDoIt: #'postLoadSparta:'.
spec repository: 'github://syrel/s...etc...
		versionNumber: 	baseline
		importedVersions: 	nil
		versionStatus: 	#somethingLoaded
		loaderPolicy: 	a MetacelloLoaderPolicy


BlockClosure>>ensure:
	Receiver: [ | fetchLoader |
fetchLoader := self
	fetchRequiredFromArray: (self defaultPackageNamesTo...etc...
	Arguments and temporary variables: 
		aBlock: 	[ MetacelloPlatform current bypassProgressBars: oldBypassProgress.
load...etc...
		complete: 	nil
		returnValue: 	nil
	Receiver's instance variables: 
		outerContext: 	MetacelloMCVersion>>doLoadRequiredFromArray:
		startpc: 	152
		numArgs: 	0


MetacelloMCVersion>>doLoadRequiredFromArray:
	Receiver: <>baseline [BaselineOfSparta]
	Arguments and temporary variables: 
		anArray: 	#(#development)
		displayString: 	'baseline of BaselineOfSparta'
		oldPolicy: 	a MetacelloLoaderPolicy
		oldBypassProgress: 	false
	Receiver's instance variables: 
		spec: 	spec postLoadDoIt: #'postLoadSparta:'.
spec repository: 'github://syrel/s...etc...
		versionNumber: 	baseline
		importedVersions: 	nil
		versionStatus: 	#somethingLoaded
		loaderPolicy: 	a MetacelloLoaderPolicy


ByteSymbol(String)>>loadRequiredForMetacelloMCVersion:
	Receiver: #development
	Arguments and temporary variables: 
		aMetacelloMCVersion: 	<>baseline [BaselineOfSparta]
	Receiver's instance variables: 
#development

MetacelloMCVersion>>load:
	Receiver: <>baseline [BaselineOfSparta]
	Arguments and temporary variables: 
		required: 	#development
	Receiver's instance variables: 
		spec: 	spec postLoadDoIt: #'postLoadSparta:'.
spec repository: 'github://syrel/s...etc...
		versionNumber: 	baseline
		importedVersions: 	nil
		versionStatus: 	#somethingLoaded
		loaderPolicy: 	a MetacelloLoaderPolicy


[ | version loadedSpec |
self setDefaultsAndValidateProjectSpec.
[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
	on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
	do:
		[ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade: onUpgradeBlock ].
version := loadedSpec versionForScriptEngine: self.
self
	root:
		(required isEmpty
			ifTrue: [ version load ]
			ifFalse: [ version load: required ]) loadDirective.
loadedSpec loads: required.
MetacelloProjectRegistration
	registrationForProjectSpec: loadedSpec
	ifAbsent: [ :new | 
		new
			loadedInImage: true;
			registerProject ]
	ifPresent: [ :existing :new | 
		existing
			copyOnWrite: [ :existingCopy | 
				existingCopy
					loadedInImage: true;
					merge: new ] ] ] in [ self
	handleNotificationsForAction: [ | version loadedSpec |
		self setDefaultsAndValidateProjectSpec.
		[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
			on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			do:
				[ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade: onUpgradeBlock ].
		version := loadedSpec versionForScriptEngine: self.
		self
			root:
				(required isEmpty
					ifTrue: [ version load ]
					ifFalse: [ version load: required ]) loadDirective.
		loadedSpec loads: required.
		MetacelloProjectRegistration
			registrationForProjectSpec: loadedSpec
			ifAbsent: [ :new | 
				new
					loadedInImage: true;
					registerProject ]
			ifPresent: [ :existing :new | 
				existing
					copyOnWrite: [ :existingCopy | 
						existingCopy
							loadedInImage: true;
							merge: new ] ] ] ] in MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
	Receiver: a MetacelloScriptEngine
	Arguments and temporary variables: 
<<error during printing>
	Receiver's instance variables: 
		root: 	nil
		projectSpec: 	spec 
	name: 'Sparta';
	repository: 'github://syrel/sparta/src'.
		options: 	a Dictionary()


BlockClosure>>on:do:
	Receiver: [ | version loadedSpec |
self setDefaultsAndValidateProjectSpec.
[ loadedSpec := (self loo...etc...
	Arguments and temporary variables: 
		exception: 	an ExceptionSet
		handlerAction: 	[ :ex | "lookup and registration handlers need to be innermost s...etc...
	Receiver's instance variables: 
		outerContext: 	[ self
	handleNotificationsForAction: [ | version loadedSpec |
		...etc...
		startpc: 	129
		numArgs: 	0


[ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ] in [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ] in [ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ]
	on: MetacelloAllowLockedProjectChange
	do:
		[ :ex | "MetacelloAllowLockedProjectChange need to be outermost handler ... since it is signaled from second line of handlers" ex handleResolutionFor: self ] ] in MetacelloScriptEngine>>handleNotificationsForAction:
	Receiver: a MetacelloScriptEngine
	Arguments and temporary variables: 
		actionBlock: 	[ | version loadedSpec |
self setDefaultsAndValidateProjectSpec.
[...etc...
	Receiver's instance variables: 
		root: 	nil
		projectSpec: 	spec 
	name: 'Sparta';
	repository: 'github://syrel/sparta/src'.
		options: 	a Dictionary()


BlockClosure>>on:do:
	Receiver: [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, M...etc...
	Arguments and temporary variables: 
		exception: 	an ExceptionSet
		handlerAction: 	[ :ex | "option handlers need to be outermost set of handlers .....etc...
	Receiver's instance variables: 
		outerContext: 	[ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLook...etc...
		startpc: 	84
		numArgs: 	0


[ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ] in [ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ]
	on: MetacelloAllowLockedProjectChange
	do:
		[ :ex | "MetacelloAllowLockedProjectChange need to be outermost handler ... since it is signaled from second line of handlers" ex handleResolutionFor: self ] ] in MetacelloScriptEngine>>handleNotificationsForAction:
	Receiver: a MetacelloScriptEngine
	Arguments and temporary variables: 
		actionBlock: 	[ | version loadedSpec |
self setDefaultsAndValidateProjectSpec.
[...etc...
	Receiver's instance variables: 
		root: 	nil
		projectSpec: 	spec 
	name: 'Sparta';
	repository: 'github://syrel/sparta/src'.
		options: 	a Dictionary()


BlockClosure>>on:do:
	Receiver: [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			,...etc...
	Arguments and temporary variables: 
		exception: 	MetacelloAllowLockedProjectChange
		handlerAction: 	[ :ex | "MetacelloAllowLockedProjectChange need to be outermost ...etc...
	Receiver's instance variables: 
		outerContext: 	[ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLo...etc...
		startpc: 	79
		numArgs: 	0


[ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ]
	on: MetacelloAllowLockedProjectChange
	do:
		[ :ex | "MetacelloAllowLockedProjectChange need to be outermost handler ... since it is signaled from second line of handlers" ex handleResolutionFor: self ] ] in MetacelloScriptEngine>>handleNotificationsForAction:
	Receiver: a MetacelloScriptEngine
	Arguments and temporary variables: 
		actionBlock: 	[ | version loadedSpec |
self setDefaultsAndValidateProjectSpec.
[...etc...
	Receiver's instance variables: 
		root: 	nil
		projectSpec: 	spec 
	name: 'Sparta';
	repository: 'github://syrel/sparta/src'.
		options: 	a Dictionary()


BlockClosure>>on:do:
	Receiver: [ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
		...etc...
	Arguments and temporary variables: 
		exception: 	Warning
		handlerAction: 	[ :ex | "Warning is absolute outermost handler" self handleWarni...etc...
	Receiver's instance variables: 
		outerContext: 	MetacelloScriptEngine>>handleNotificationsForAction:
		startpc: 	74
		numArgs: 	0


MetacelloScriptEngine>>handleNotificationsForAction:
	Receiver: a MetacelloScriptEngine
	Arguments and temporary variables: 
		actionBlock: 	[ | version loadedSpec |
self setDefaultsAndValidateProjectSpec.
[...etc...
	Receiver's instance variables: 
		root: 	nil
		projectSpec: 	spec 
	name: 'Sparta';
	repository: 'github://syrel/sparta/src'.
		options: 	a Dictionary()


[ self
	handleNotificationsForAction: [ | version loadedSpec |
		self setDefaultsAndValidateProjectSpec.
		[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
			on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			do:
				[ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade: onUpgradeBlock ].
		version := loadedSpec versionForScriptEngine: self.
		self
			root:
				(required isEmpty
					ifTrue: [ version load ]
					ifFalse: [ version load: required ]) loadDirective.
		loadedSpec loads: required.
		MetacelloProjectRegistration
			registrationForProjectSpec: loadedSpec
			ifAbsent: [ :new | 
				new
					loadedInImage: true;
					registerProject ]
			ifPresent: [ :existing :new | 
				existing
					copyOnWrite: [ :existingCopy | 
						existingCopy
							loadedInImage: true;
							merge: new ] ] ] ] in MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
	Receiver: a MetacelloScriptEngine
	Arguments and temporary variables: 
		required: 	#development
		onDownGradeBlock: 	[ :ex :existing :new | ex allowEvenIfLocked ]
		onUpgradeBlock: 	[ :ex :existing :new | ex allowEvenIfLocked ]
	Receiver's instance variables: 
		root: 	nil
		projectSpec: 	spec 
	name: 'Sparta';
	repository: 'github://syrel/sparta/src'.
		options: 	a Dictionary()


BlockClosure>>ensure:
	Receiver: [ self
	handleNotificationsForAction: [ | version loadedSpec |
		self setDefaultsAndValida...etc...
	Arguments and temporary variables: 
		aBlock: 	[ "install old version of registry"
newRegistry := self registry.	"see ...etc...
		complete: 	nil
		returnValue: 	nil
	Receiver's instance variables: 
		outerContext: 	MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
		startpc: 	121
		numArgs: 	0


MetacelloProjectRegistration class>>copyRegistryRestoreOnErrorWhile:
	Receiver: MetacelloProjectRegistration
	Arguments and temporary variables: 
		newRegistry: 	a MetacelloProjectRegistry
		aBlock: 	[ self
	handleNotificationsForAction: [ | version loadedSpec |
		self s...etc...
		oldRegistry: 	a MetacelloProjectRegistry
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(#=->MetacelloProjectRegistration>>#= #baseName->...etc...
		format: 	65543
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#MetacelloProjectRegistration
		classPool: 	a Dictionary(#Registry->a MetacelloProjectRegistry )
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Metacello-Core-Scripts'
		traitComposition: 	{}
		localSelectors: 	nil


MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
	Receiver: a MetacelloScriptEngine
	Arguments and temporary variables: 
		required: 	#development
		onDownGradeBlock: 	[ :ex :existing :new | ex allowEvenIfLocked ]
		onUpgradeBlock: 	[ :ex :existing :new | ex allowEvenIfLocked ]
	Receiver's instance variables: 
		root: 	nil
		projectSpec: 	spec 
	name: 'Sparta';
	repository: 'github://syrel/sparta/src'.
		options: 	a Dictionary()



--- The full stack ---
MozServices class>>start
MozLibraryLinuxInstaller(MozLibraryInstaller)>>install
MozLibraryInstaller class>>install
[ :each | each method methodClass baseClass perform: each method selector ] in BaselineOfSparta>>postLoadSparta:
OrderedCollection>>do:
BaselineOfSparta>>postLoadSparta:
[ :aLoader | self project configuration perform: selector with: aLoader ] in MetacelloMCVersionSpec(MetacelloSpec)>>doItBlock:
BlockClosure>>valueWithPossibleArgs:
[ block
	valueWithPossibleArgs:
		(Array with: aPostloadDirective loader with: aPostloadDirective spec) ] in MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadPostloadDirective:
MetacelloPostLoadDirective(MetacelloPrePostLoadDirective)>>evaluateSupplyingAnswers:
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadPostloadDirective:
MetacelloPostLoadDirective>>loadUsing:gofer:
[ :directive | directive loadUsing: aLoaderDirective gofer: aGofer ] in MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadLinearLoadDirective:gofer:
OrderedCollection>>do:
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadLinearLoadDirective:gofer:
MetacelloLinearLoadDirective>>loadUsing:gofer:
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadWithPolicy:
MetacelloLoaderPolicy>>load
MetacelloFetchingMCSpecLoader>>doLoad
[ fetchLoader doLoad ] in [ | fetchLoader |
fetchLoader := self
	fetchRequiredFromArray: (self defaultPackageNamesToLoad: anArray).
MetacelloPlatform current
	do: [ fetchLoader doLoad ]
	displaying: 'Loading ' , displayString.
Transcript
	cr;
	show: '...finished ' , self versionNumber printString.
^ fetchLoader ] in MetacelloMCVersion>>doLoadRequiredFromArray:
IceMetacelloPharoPlatform(MetacelloPlatform)>>do:displaying:
[ | fetchLoader |
fetchLoader := self
	fetchRequiredFromArray: (self defaultPackageNamesToLoad: anArray).
MetacelloPlatform current
	do: [ fetchLoader doLoad ]
	displaying: 'Loading ' , displayString.
Transcript
	cr;
	show: '...finished ' , self versionNumber printString.
^ fetchLoader ] in MetacelloMCVersion>>doLoadRequiredFromArray:
BlockClosure>>ensure:
MetacelloMCVersion>>doLoadRequiredFromArray:
ByteSymbol(String)>>loadRequiredForMetacelloMCVersion:
MetacelloMCVersion>>load:
[ | version loadedSpec |
self setDefaultsAndValidateProjectSpec.
[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
	on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
	do:
		[ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade: onUpgradeBlock ].
version := loadedSpec versionForScriptEngine: self.
self
	root:
		(required isEmpty
			ifTrue: [ version load ]
			ifFalse: [ version load: required ]) loadDirective.
loadedSpec loads: required.
MetacelloProjectRegistration
	registrationForProjectSpec: loadedSpec
	ifAbsent: [ :new | 
		new
			loadedInImage: true;
			registerProject ]
	ifPresent: [ :existing :new | 
		existing
			copyOnWrite: [ :existingCopy | 
				existingCopy
					loadedInImage: true;
					merge: new ] ] ] in [ self
	handleNotificationsForAction: [ | version loadedSpec |
		self setDefaultsAndValidateProjectSpec.
		[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
			on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			do:
				[ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade: onUpgradeBlock ].
		version := loadedSpec versionForScriptEngine: self.
		self
			root:
				(required isEmpty
					ifTrue: [ version load ]
					ifFalse: [ version load: required ]) loadDirective.
		loadedSpec loads: required.
		MetacelloProjectRegistration
			registrationForProjectSpec: loadedSpec
			ifAbsent: [ :new | 
				new
					loadedInImage: true;
					registerProject ]
			ifPresent: [ :existing :new | 
				existing
					copyOnWrite: [ :existingCopy | 
						existingCopy
							loadedInImage: true;
							merge: new ] ] ] ] in MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
BlockClosure>>on:do:
[ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ] in [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ] in [ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ]
	on: MetacelloAllowLockedProjectChange
	do:
		[ :ex | "MetacelloAllowLockedProjectChange need to be outermost handler ... since it is signaled from second line of handlers" ex handleResolutionFor: self ] ] in MetacelloScriptEngine>>handleNotificationsForAction:
BlockClosure>>on:do:
[ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ] in [ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ]
	on: MetacelloAllowLockedProjectChange
	do:
		[ :ex | "MetacelloAllowLockedProjectChange need to be outermost handler ... since it is signaled from second line of handlers" ex handleResolutionFor: self ] ] in MetacelloScriptEngine>>handleNotificationsForAction:
BlockClosure>>on:do:
[ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ]
	on: MetacelloAllowLockedProjectChange
	do:
		[ :ex | "MetacelloAllowLockedProjectChange need to be outermost handler ... since it is signaled from second line of handlers" ex handleResolutionFor: self ] ] in MetacelloScriptEngine>>handleNotificationsForAction:
BlockClosure>>on:do:
MetacelloScriptEngine>>handleNotificationsForAction:
[ self
	handleNotificationsForAction: [ | version loadedSpec |
		self setDefaultsAndValidateProjectSpec.
		[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
			on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			do:
				[ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade: onUpgradeBlock ].
		version := loadedSpec versionForScriptEngine: self.
		self
			root:
				(required isEmpty
					ifTrue: [ version load ]
					ifFalse: [ version load: required ]) loadDirective.
		loadedSpec loads: required.
		MetacelloProjectRegistration
			registrationForProjectSpec: loadedSpec
			ifAbsent: [ :new | 
				new
					loadedInImage: true;
					registerProject ]
			ifPresent: [ :existing :new | 
				existing
					copyOnWrite: [ :existingCopy | 
						existingCopy
							loadedInImage: true;
							merge: new ] ] ] ] in MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
BlockClosure>>ensure:
MetacelloProjectRegistration class>>copyRegistryRestoreOnErrorWhile:
MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
 - - - - - - - - - - - - - - -  
			- - - - - - - - - - - - - - - - - -
MetacelloScriptEngine>>load:
[ :projectSpec | 
| engine |
engine := MetacelloScriptEngine new
	options: self options copy;
	projectSpec: projectSpec;
	yourself.
engine perform: actionArg key withArguments: actionArg value.
engine root ifNotNil: [ :root | self roots add: root ] ] in MetacelloScriptApiExecutor(MetacelloScriptExecutor)>>execute:
[ :projectSpec | 
projectSpec
	ifNotNil: [ projectSpecBlock
			value: (self applyArgsToProjectSpec: projectSpec copy) ] ] in MetacelloScriptApiExecutor>>executeString:do:
Array(SequenceableCollection)>>do:
MetacelloScriptApiExecutor>>executeString:do:
ByteString(String)>>execute:against:
MetacelloScriptApiExecutor(MetacelloScriptExecutor)>>execute:
Metacello>>execute:args:
Metacello>>load:
BaselineOfBloc>>postLoadSparta:
[ :aLoader | self project configuration perform: selector with: aLoader ] in MetacelloMCBaselineOfProjectSpec(MetacelloSpec)>>doItBlock:
BlockClosure>>valueWithPossibleArgs:
[ block
	valueWithPossibleArgs:
		(Array with: aPostloadDirective loader with: aPostloadDirective spec) ] in MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadPostloadDirective:
MetacelloPostLoadDirective(MetacelloPrePostLoadDirective)>>evaluateSupplyingAnswers:
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadPostloadDirective:
MetacelloPostLoadDirective>>loadUsing:gofer:
[ :directive | directive loadUsing: aLoaderDirective gofer: aGofer ] in MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadLinearLoadDirective:gofer:
OrderedCollection>>do:
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadLinearLoadDirective:gofer:
MetacelloLinearLoadDirective>>loadUsing:gofer:
[ :directive | directive loadUsing: aLoaderDirective gofer: aGofer ] in MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadLinearLoadDirective:gofer:
OrderedCollection>>do:
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadLinearLoadDirective:gofer:
MetacelloLinearLoadDirective>>loadUsing:gofer:
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadWithPolicy:
MetacelloLoaderPolicy>>load
MetacelloFetchingMCSpecLoader>>doLoad
[ fetchLoader doLoad ] in [ | fetchLoader |
fetchLoader := self
	fetchRequiredFromArray: (self defaultPackageNamesToLoad: anArray).
MetacelloPlatform current
	do: [ fetchLoader doLoad ]
	displaying: 'Loading ' , displayString.
Transcript
	cr;
	show: '...finished ' , self versionNumber printString.
^ fetchLoader ] in MetacelloMCVersion>>doLoadRequiredFromArray:
IceMetacelloPharoPlatform(MetacelloPlatform)>>do:displaying:
[ | fetchLoader |
fetchLoader := self
	fetchRequiredFromArray: (self defaultPackageNamesToLoad: anArray).
MetacelloPlatform current
	do: [ fetchLoader doLoad ]
	displaying: 'Loading ' , displayString.
Transcript
	cr;
	show: '...finished ' , self versionNumber printString.
^ fetchLoader ] in MetacelloMCVersion>>doLoadRequiredFromArray:
BlockClosure>>ensure:
MetacelloMCVersion>>doLoadRequiredFromArray:
ByteSymbol(String)>>loadRequiredForMetacelloMCVersion:
MetacelloMCVersion>>load:
[ | version loadedSpec |
self setDefaultsAndValidateProjectSpec.
[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
	on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
	do:
		[ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade: onUpgradeBlock ].
version := loadedSpec versionForScriptEngine: self.
self
	root:
		(required isEmpty
			ifTrue: [ version load ]
			ifFalse: [ version load: required ]) loadDirective.
loadedSpec loads: required.
MetacelloProjectRegistration
	registrationForProjectSpec: loadedSpec
	ifAbsent: [ :new | 
		new
			loadedInImage: true;
			registerProject ]
	ifPresent: [ :existing :new | 
		existing
			copyOnWrite: [ :existingCopy | 
				existingCopy
					loadedInImage: true;
					merge: new ] ] ] in [ self
	handleNotificationsForAction: [ | version loadedSpec |
		self setDefaultsAndValidateProjectSpec.
		[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
			on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			do:
				[ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade: onUpgradeBlock ].
		version := loadedSpec versionForScriptEngine: self.
		self
			root:
				(required isEmpty
					ifTrue: [ version load ]
					ifFalse: [ version load: required ]) loadDirective.
		loadedSpec loads: required.
		MetacelloProjectRegistration
			registrationForProjectSpec: loadedSpec
			ifAbsent: [ :new | 
				new
					loadedInImage: true;
					registerProject ]
			ifPresent: [ :existing :new | 
				existing
					copyOnWrite: [ :existingCopy | 
						existingCopy
							loadedInImage: true;
							merge: new ] ] ] ] in MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
BlockClosure>>on:do:
[ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ] in [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ] in [ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ]
	on: MetacelloAllowLockedProjectChange
	do:
		[ :ex | "MetacelloAllowLockedProjectChange need to be outermost handler ... since it is signaled from second line of handlers" ex handleResolutionFor: self ] ] in MetacelloScriptEngine>>handleNotificationsForAction:
BlockClosure>>on:do:
[ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ] in [ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ]
	on: MetacelloAllowLockedProjectChange
	do:
		[ :ex | "MetacelloAllowLockedProjectChange need to be outermost handler ... since it is signaled from second line of handlers" ex handleResolutionFor: self ] ] in MetacelloScriptEngine>>handleNotificationsForAction:
BlockClosure>>on:do:
[ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ]
	on: MetacelloAllowLockedProjectChange
	do:
		[ :ex | "MetacelloAllowLockedProjectChange need to be outermost handler ... since it is signaled from second line of handlers" ex handleResolutionFor: self ] ] in MetacelloScriptEngine>>handleNotificationsForAction:
BlockClosure>>on:do:
MetacelloScriptEngine>>handleNotificationsForAction:
[ self
	handleNotificationsForAction: [ | version loadedSpec |
		self setDefaultsAndValidateProjectSpec.
		[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
			on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			do:
				[ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade: onUpgradeBlock ].
		version := loadedSpec versionForScriptEngine: self.
		self
			root:
				(required isEmpty
					ifTrue: [ version load ]
					ifFalse: [ version load: required ]) loadDirective.
		loadedSpec loads: required.
		MetacelloProjectRegistration
			registrationForProjectSpec: loadedSpec
			ifAbsent: [ :new | 
				new
					loadedInImage: true;
					registerProject ]
			ifPresent: [ :existing :new | 
				existing
					copyOnWrite: [ :existingCopy | 
						existingCopy
							loadedInImage: true;
							merge: new ] ] ] ] in MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
BlockClosure>>ensure:
MetacelloProjectRegistration class>>copyRegistryRestoreOnErrorWhile:
MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
MetacelloScriptEngine>>load:
[ :projectSpec | 
| engine |
engine := MetacelloScriptEngine new
	options: self options copy;
	projectSpec: projectSpec;
	yourself.
engine perform: actionArg key withArguments: actionArg value.
engine root ifNotNil: [ :root | self roots add: root ] ] in MetacelloScriptApiExecutor(MetacelloScriptExecutor)>>execute:
[ :projectSpec | 
projectSpec
	ifNotNil: [ projectSpecBlock
			value: (self applyArgsToProjectSpec: projectSpec copy) ] ] in MetacelloScriptApiExecutor>>executeString:do:
Array(SequenceableCollection)>>do:
MetacelloScriptApiExecutor>>executeString:do:
ByteString(String)>>execute:against:
MetacelloScriptApiExecutor(MetacelloScriptExecutor)>>execute:
Metacello>>execute:args:
Metacello>>load:
BaselineOfBrick>>postLoadBloc:
[ :aLoader | self project configuration perform: selector with: aLoader ] in MetacelloMCBaselineOfProjectSpec(MetacelloSpec)>>doItBlock:
BlockClosure>>valueWithPossibleArgs:
[ block
	valueWithPossibleArgs:
		(Array with: aPostloadDirective loader with: aPostloadDirective spec) ] in MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadPostloadDirective:
MetacelloPostLoadDirective(MetacelloPrePostLoadDirective)>>evaluateSupplyingAnswers:
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadPostloadDirective:
MetacelloPostLoadDirective>>loadUsing:gofer:
[ :directive | directive loadUsing: aLoaderDirective gofer: aGofer ] in MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadLinearLoadDirective:gofer:
OrderedCollection>>do:
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadLinearLoadDirective:gofer:
MetacelloLinearLoadDirective>>loadUsing:gofer:
[ :directive | directive loadUsing: aLoaderDirective gofer: aGofer ] in MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadLinearLoadDirective:gofer:
OrderedCollection>>do:
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadLinearLoadDirective:gofer:
MetacelloLinearLoadDirective>>loadUsing:gofer:
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadWithPolicy:
MetacelloLoaderPolicy>>load
MetacelloFetchingMCSpecLoader>>doLoad
[ fetchLoader doLoad ] in [ | fetchLoader |
fetchLoader := self
	fetchRequiredFromArray: (self defaultPackageNamesToLoad: anArray).
MetacelloPlatform current
	do: [ fetchLoader doLoad ]
	displaying: 'Loading ' , displayString.
Transcript
	cr;
	show: '...finished ' , self versionNumber printString.
^ fetchLoader ] in MetacelloMCVersion>>doLoadRequiredFromArray:
IceMetacelloPharoPlatform(MetacelloPlatform)>>do:displaying:
[ | fetchLoader |
fetchLoader := self
	fetchRequiredFromArray: (self defaultPackageNamesToLoad: anArray).
MetacelloPlatform current
	do: [ fetchLoader doLoad ]
	displaying: 'Loading ' , displayString.
Transcript
	cr;
	show: '...finished ' , self versionNumber printString.
^ fetchLoader ] in MetacelloMCVersion>>doLoadRequiredFromArray:
BlockClosure>>ensure:
MetacelloMCVersion>>doLoadRequiredFromArray:
ByteSymbol(String)>>loadRequiredForMetacelloMCVersion:
MetacelloMCVersion>>load:
[ | version loadedSpec |
self setDefaultsAndValidateProjectSpec.
[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
	on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
	do:
		[ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade: onUpgradeBlock ].
version := loadedSpec versionForScriptEngine: self.
self
	root:
		(required isEmpty
			ifTrue: [ version load ]
			ifFalse: [ version load: required ]) loadDirective.
loadedSpec loads: required.
MetacelloProjectRegistration
	registrationForProjectSpec: loadedSpec
	ifAbsent: [ :new | 
		new
			loadedInImage: true;
			registerProject ]
	ifPresent: [ :existing :new | 
		existing
			copyOnWrite: [ :existingCopy | 
				existingCopy
					loadedInImage: true;
					merge: new ] ] ] in [ self
	handleNotificationsForAction: [ | version loadedSpec |
		self setDefaultsAndValidateProjectSpec.
		[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
			on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			do:
				[ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade: onUpgradeBlock ].
		version := loadedSpec versionForScriptEngine: self.
		self
			root:
				(required isEmpty
					ifTrue: [ version load ]
					ifFalse: [ version load: required ]) loadDirective.
		loadedSpec loads: required.
		MetacelloProjectRegistration
			registrationForProjectSpec: loadedSpec
			ifAbsent: [ :new | 
				new
					loadedInImage: true;
					registerProject ]
			ifPresent: [ :existing :new | 
				existing
					copyOnWrite: [ :existingCopy | 
						existingCopy
							loadedInImage: true;
							merge: new ] ] ] ] in MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
BlockClosure>>on:do:
[ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ] in [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ] in [ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ]
	on: MetacelloAllowLockedProjectChange
	do:
		[ :ex | "MetacelloAllowLockedProjectChange need to be outermost handler ... since it is signaled from second line of handlers" ex handleResolutionFor: self ] ] in MetacelloScriptEngine>>handleNotificationsForAction:
BlockClosure>>on:do:
[ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ] in [ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ]
	on: MetacelloAllowLockedProjectChange
	do:
		[ :ex | "MetacelloAllowLockedProjectChange need to be outermost handler ... since it is signaled from second line of handlers" ex handleResolutionFor: self ] ] in MetacelloScriptEngine>>handleNotificationsForAction:
BlockClosure>>on:do:
[ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ]
	on: MetacelloAllowLockedProjectChange
	do:
		[ :ex | "MetacelloAllowLockedProjectChange need to be outermost handler ... since it is signaled from second line of handlers" ex handleResolutionFor: self ] ] in MetacelloScriptEngine>>handleNotificationsForAction:
BlockClosure>>on:do:
MetacelloScriptEngine>>handleNotificationsForAction:
[ self
	handleNotificationsForAction: [ | version loadedSpec |
		self setDefaultsAndValidateProjectSpec.
		[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
			on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			do:
				[ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade: onUpgradeBlock ].
		version := loadedSpec versionForScriptEngine: self.
		self
			root:
				(required isEmpty
					ifTrue: [ version load ]
					ifFalse: [ version load: required ]) loadDirective.
		loadedSpec loads: required.
		MetacelloProjectRegistration
			registrationForProjectSpec: loadedSpec
			ifAbsent: [ :new | 
				new
					loadedInImage: true;
					registerProject ]
			ifPresent: [ :existing :new | 
				existing
					copyOnWrite: [ :existingCopy | 
						existingCopy
							loadedInImage: true;
							merge: new ] ] ] ] in MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
BlockClosure>>ensure:
MetacelloProjectRegistration class>>copyRegistryRestoreOnErrorWhile:
MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
MetacelloScriptEngine>>load:
[ :projectSpec | 
| engine |
engine := MetacelloScriptEngine new
	options: self options copy;
	projectSpec: projectSpec;
	yourself.
engine perform: actionArg key withArguments: actionArg value.
engine root ifNotNil: [ :root | self roots add: root ] ] in MetacelloScriptApiExecutor(MetacelloScriptExecutor)>>execute:
[ :projectSpec | 
projectSpec
	ifNotNil: [ projectSpecBlock
			value: (self applyArgsToProjectSpec: projectSpec copy) ] ] in MetacelloScriptApiExecutor>>executeString:do:
Array(SequenceableCollection)>>do:
MetacelloScriptApiExecutor>>executeString:do:
ByteString(String)>>execute:against:
MetacelloScriptApiExecutor(MetacelloScriptExecutor)>>execute:
Metacello>>execute:args:
Metacello>>load:
UndefinedObject>>DoIt
OpalCompiler>>evaluate
RubSmalltalkEditor>>evaluate:andDo:
RubSmalltalkEditor>>highlightEvaluateAndDo:
[ textMorph textArea editor highlightEvaluateAndDo: ann action.
textMorph shoutStyler style: textMorph text ] in [ textMorph textArea
	handleEdit: [ textMorph textArea editor highlightEvaluateAndDo: ann action.
		textMorph shoutStyler style: textMorph text ] ] in GLMMorphicPharoScriptRenderer(GLMMorphicPharoCodeRenderer)>>actOnHighlightAndEvaluate:
RubEditingArea(RubAbstractTextArea)>>handleEdit:
[ textMorph textArea
	handleEdit: [ textMorph textArea editor highlightEvaluateAndDo: ann action.
		textMorph shoutStyler style: textMorph text ] ] in GLMMorphicPharoScriptRenderer(GLMMorphicPharoCodeRenderer)>>actOnHighlightAndEvaluate:
WorldState>>runStepMethodsIn:
WorldMorph>>runStepMethods
WorldState>>doOneCycleNowFor:
WorldState>>doOneCycleFor:
WorldMorph>>doOneCycle
WorldMorph class>>doOneCycle
[ [ WorldMorph doOneCycle.
Processor yield.
false ] whileFalse: [  ] ] in MorphicUIManager>>spawnNewProcess
[ self value.
Processor terminateActive ] in BlockClosure>>newProcess
-------------------------------------------------------------------------------

Reply via email to