Sorry, but after evaluating

Gofer new
smalltalkhubUser: 'Pharo' project: 'Brick';
configuration;
loadDevelopment

in Pharo5.0#50270, i got an Error: Unrecognized class definition

The screenshots look really cool.

thanks


On Tue, Aug 25, 2015 at 5:13 PM, Tudor Girba <tu...@tudorgirba.com> wrote:

> Hi,
>
> We are happy to announce the first preview version of Brick, a new widget
> set created from scratch on top of Bloc.
>
> Brick is being developed primarily by Alex Syrel (together with Alain
> Plantec, Andrei Chis and myself), and the work is sponsored by ESUG. Brick
> is part of the Glamorous Toolkit effort and will provide the basis for the
> new versions of the development tools.
>
> Brick's goal is to provide a beautiful looking widget set, and the default
> look is based on material design. The widgets are theme-able.
>
> Right now, there exists:
> - Label
> - Simple button
> - Toggle button
> - Checkbox
> - Radio button
> - Window with or without an active title bar that can include various
> visual actions and info
> - Menu
> - Beautiful scrollbars that are thin by default and enlarge when the mouse
> hovers over it
> - Scalable list for huge amounts of items with various heights
> (The list also allows one for embedding text widgets with in place editing)
>
> The next immediate target is the creation of a new Pager widget (the
> widget that is behind the current GTInspector).
>
> You can see some screenshots on the official site:
> http://gt.moosetechnology.org/brick
>
> To play with it, you can download a ready-made image:
>
> https://ci.inria.fr/moose/job/gtoolkit5/lastSuccessfulBuild/artifact/gtoolkit5.zip
>
> and, in a Bloc space, you can browse the examples:
> BrExampleBrowser exampleOpen
>
> We would be happy to hear your feedback.
>
> Cheers,
> Doru
>
> --
> www.tudorgirba.com
>
> "Every thing has its own flow"
>



-- 
Bernardo E.C.

Sent from a cheap desktop computer in South America.
THERE_BE_DRAGONS_HERE
Error: Unrecognized class definition
25 August 2015 5:50:57.559625 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-HolgerHansPeterFreyther.21 uuid: e0df6e2d-5694-40e2-8035-dc217200b424 May  7 2015
NBCogit NativeBoost-CogPlugin-HolgerHansPeterFreyther.21 uuid: e0df6e2d-5694-40e2-8035-dc217200b424 May  7 2015
https://github.com/pharo-project/pharo-vm.git Commit: 81b5d19917dcb78f22482a780deec48c53738396 Date: 2014-09-20 14:36:18 +0200 By: Esteban Lorenzano <esteba...@gmail.com> Jenkins build #14858

Image: Pharo5.0 [Latest update: #50270]

MCStReader(Object)>>error:
	Receiver: a MCStReader
	Arguments and temporary variables: 
		aString: 	'Unrecognized class definition'
	Receiver's instance variables: 
		stream: 	a ReadStream
		definitions: 	an OrderedCollection(a MCClassDefinition(BlMainLoopManager) a MCMe...etc...


MCStReader>>typeOfSubclass:
	Receiver: a MCStReader
	Arguments and temporary variables: 
		aSymbol: 	#named:
	Receiver's instance variables: 
		stream: 	a ReadStream
		definitions: 	an OrderedCollection(a MCClassDefinition(BlMainLoopManager) a MCMe...etc...


MCStReader>>classDefinitionFrom:
	Receiver: a MCStReader
	Arguments and temporary variables: 
		aRingClass: 	TBlAnnouncerOwner
		tokens: 	#(#Trait #named: #TBlAnnouncerOwner #uses: #'{' #'}' #category: 'Bloc-C...etc...
		traitCompositionString: 	'{}
	category: ''Bloc-Core-Traits'''
		lastIndex: 	8
		classTraitCompositionString: 	'{}'
	Receiver's instance variables: 
		stream: 	a ReadStream
		definitions: 	an OrderedCollection(a MCClassDefinition(BlMainLoopManager) a MCMe...etc...


[ :ringClass | 
ringClass hasDefinitionSource
	ifTrue:
		[ definitions add: (self classDefinitionFrom: ringClass) ].
definitions addAll: (self methodDefinitionsFor: ringClass).
definitions
	addAll: (self methodDefinitionsFor: ringClass theMetaClass) ] in MCStReader>>loadDefinitions
	Receiver: a MCStReader
	Arguments and temporary variables: 
		filePackage: 	a RingChunkImporter
		ringClass: 	TBlAnnouncerOwner
	Receiver's instance variables: 
		stream: 	a ReadStream
		definitions: 	an OrderedCollection(a MCClassDefinition(BlMainLoopManager) a MCMe...etc...


Array(SequenceableCollection)>>do:
	Receiver: an Array(BlMainLoopManager AthensCompositeTransform BlMorphicSpace BlPopupOnMouseDownEvent...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :ringClass | 
ringClass hasDefinitionSource
	ifTrue:
		[ definitions ...etc...
		index: 	67
	Receiver's instance variables: 
an Array(BlMainLoopManager AthensCompositeTransform BlMorphicSpace BlPopupOnMouseDownEvent...etc...

MCStReader>>loadDefinitions
	Receiver: a MCStReader
	Arguments and temporary variables: 
		filePackage: 	a RingChunkImporter
	Receiver's instance variables: 
		stream: 	a ReadStream
		definitions: 	an OrderedCollection(a MCClassDefinition(BlMainLoopManager) a MCMe...etc...


MCStReader(MCSnapshotReader)>>definitions
	Receiver: a MCStReader
	Arguments and temporary variables: 

	Receiver's instance variables: 
		stream: 	a ReadStream
		definitions: 	an OrderedCollection(a MCClassDefinition(BlMainLoopManager) a MCMe...etc...


MCMczReader>>extractDefinitionsFrom:
	Receiver: a MCMczReader
	Arguments and temporary variables: 
		member: 	a ZipFileMember(snapshot/source.st)
		reader: 	a MCStReader
		rc: 	MCStReader
	Receiver's instance variables: 
		stream: 	a ReadStream
		package: 	a MCPackage(Bloc-Core)
		info: 	a MCVersionInfo(Bloc-Core-AliakseiSyrel.636)
		definitions: 	an OrderedCollection()
		dependencies: 	#()
		zip: 	a ZipArchive
		infoCache: 	a Dictionary(size 124)


[ :m | self extractDefinitionsFrom: m ] in MCMczReader>>loadDefinitions
	Receiver: a MCMczReader
	Arguments and temporary variables: 
		m: 	a ZipFileMember(snapshot/source.st)
	Receiver's instance variables: 
		stream: 	a ReadStream
		package: 	a MCPackage(Bloc-Core)
		info: 	a MCVersionInfo(Bloc-Core-AliakseiSyrel.636)
		definitions: 	an OrderedCollection()
		dependencies: 	#()
		zip: 	a ZipArchive
		infoCache: 	a Dictionary(size 124)


OrderedCollection>>do:
	Receiver: an OrderedCollection(a ZipFileMember(snapshot/source.st))
	Arguments and temporary variables: 
		aBlock: 	[ :m | self extractDefinitionsFrom: m ]
		index: 	1
	Receiver's instance variables: 
		array: 	an Array(a ZipFileMember(snapshot/source.st) nil nil nil nil nil nil nil...etc...
		firstIndex: 	1
		lastIndex: 	1


MCMczReader>>loadDefinitions
	Receiver: a MCMczReader
	Arguments and temporary variables: 

	Receiver's instance variables: 
		stream: 	a ReadStream
		package: 	a MCPackage(Bloc-Core)
		info: 	a MCVersionInfo(Bloc-Core-AliakseiSyrel.636)
		definitions: 	an OrderedCollection()
		dependencies: 	#()
		zip: 	a ZipArchive
		infoCache: 	a Dictionary(size 124)


MCMczReader(MCVersionReader)>>definitions
	Receiver: a MCMczReader
	Arguments and temporary variables: 

	Receiver's instance variables: 
		stream: 	a ReadStream
		package: 	a MCPackage(Bloc-Core)
		info: 	a MCVersionInfo(Bloc-Core-AliakseiSyrel.636)
		definitions: 	an OrderedCollection()
		dependencies: 	#()
		zip: 	a ZipArchive
		infoCache: 	a Dictionary(size 124)


MCMczReader(MCVersionReader)>>snapshot
	Receiver: a MCMczReader
	Arguments and temporary variables: 

	Receiver's instance variables: 
		stream: 	a ReadStream
		package: 	a MCPackage(Bloc-Core)
		info: 	a MCVersionInfo(Bloc-Core-AliakseiSyrel.636)
		definitions: 	an OrderedCollection()
		dependencies: 	#()
		zip: 	a ZipArchive
		infoCache: 	a Dictionary(size 124)


[ self snapshot ] in MCMczReader(MCVersionReader)>>basicVersion
	Receiver: a MCMczReader
	Arguments and temporary variables: 

	Receiver's instance variables: 
		stream: 	a ReadStream
		package: 	a MCPackage(Bloc-Core)
		info: 	a MCVersionInfo(Bloc-Core-AliakseiSyrel.636)
		definitions: 	an OrderedCollection()
		dependencies: 	#()
		zip: 	a ZipArchive
		infoCache: 	a Dictionary(size 124)


MCVersion>>snapshot
	Receiver: a MCVersion(Bloc-Core-AliakseiSyrel.636)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		package: 	a MCPackage(Bloc-Core)
		info: 	a MCVersionInfo(Bloc-Core-AliakseiSyrel.636)
		snapshot: 	[ self snapshot ]
		dependencies: 	#()
		completeSnapshot: 	nil


[ :ea | 
ea canOptimizeLoading
	ifTrue: [ ea patch applyTo: loader ]
	ifFalse:
		[ loader updatePackage: ea package withSnapshot: ea snapshot ] ] in MCVersionLoader>>loadWithNameLike:
	Receiver: a MCVersionLoader
	Arguments and temporary variables: 
		aString: 	'Bloc-Core-AliakseiSyrel.636'
		loader: 	a MCPackageLoader
		ea: 	a MCVersion(Bloc-Core-AliakseiSyrel.636)
	Receiver's instance variables: 
		versions: 	an OrderedCollection(a MCVersion(Bloc-Core-AliakseiSyrel.636))


OrderedCollection>>do:
	Receiver: an OrderedCollection(a MCVersion(Bloc-Core-AliakseiSyrel.636))
	Arguments and temporary variables: 
		aBlock: 	[ :ea | 
ea canOptimizeLoading
	ifTrue: [ ea patch applyTo: loader ]
	i...etc...
		index: 	1
	Receiver's instance variables: 
		array: 	an Array(a MCVersion(Bloc-Core-AliakseiSyrel.636) nil nil nil nil nil ni...etc...
		firstIndex: 	1
		lastIndex: 	1


MCVersionLoader>>loadWithNameLike:
	Receiver: a MCVersionLoader
	Arguments and temporary variables: 
		aString: 	'Bloc-Core-AliakseiSyrel.636'
		loader: 	a MCPackageLoader
	Receiver's instance variables: 
		versions: 	an OrderedCollection(a MCVersion(Bloc-Core-AliakseiSyrel.636))


[ 
self ensurePackage: version package.
self loadWithNameLike: version info name ] in [ 
| version |
version := versions first.
[ 
self ensurePackage: version package.
self loadWithNameLike: version info name ] asJob
	title: 'Loading ' , version info name asString;
	run ] in MCVersionLoader>>load
	Receiver: a MCVersionLoader
	Arguments and temporary variables: 
		version: 	a MCVersion(Bloc-Core-AliakseiSyrel.636)
	Receiver's instance variables: 
		versions: 	an OrderedCollection(a MCVersion(Bloc-Core-AliakseiSyrel.636))


BlockClosure>>cull:
	Receiver: [ 
self ensurePackage: version package.
self loadWithNameLike: version info name ]
	Arguments and temporary variables: 
		anArg: 	a Job
	Receiver's instance variables: 
		outerContext: 	[ 
| version |
version := versions first.
[ 
self ensurePackage: ...etc...
		startpc: 	83
		numArgs: 	0


[ ^ block cull: self ] in [ 
self prepareForRunning.
CurrentJob value: self during: [ ^ block cull: self ] ] in Job>>run
	Receiver: a Job
	Arguments and temporary variables: 

	Receiver's instance variables: 
		block: 	[ 
self ensurePackage: version package.
self loadWithNameLike: version i...etc...
		currentValue: 	0
		min: 	0
		max: 	100
		title: 	'Loading Bloc-Core-AliakseiSyrel.636'
		children: 	an OrderedCollection()
		isRunning: 	true
		parent: 	nil
		process: 	a Process in nil


[ 
p psValueAt: index put: anObject.
aBlock value ] in CurrentJob(DynamicVariable)>>value:during:
	Receiver: a CurrentJob
	Arguments and temporary variables: 
		anObject: 	a Job
		aBlock: 	[ ^ block cull: self ]
		p: 	a Process in nil
		oldValue: 	nil
	Receiver's instance variables: 
		index: 	8


BlockClosure>>ensure:
	Receiver: [ 
p psValueAt: index put: anObject.
aBlock value ]
	Arguments and temporary variables: 
		aBlock: 	[ p psValueAt: index put: oldValue ]
		complete: 	nil
		returnValue: 	nil
	Receiver's instance variables: 
		outerContext: 	CurrentJob(DynamicVariable)>>value:during:
		startpc: 	62
		numArgs: 	0


CurrentJob(DynamicVariable)>>value:during:
	Receiver: a CurrentJob
	Arguments and temporary variables: 
		anObject: 	a Job
		aBlock: 	[ ^ block cull: self ]
		p: 	a Process in nil
		oldValue: 	nil
	Receiver's instance variables: 
		index: 	8


CurrentJob class(DynamicVariable class)>>value:during:
	Receiver: CurrentJob
	Arguments and temporary variables: 
		anObject: 	a Job
		aBlock: 	[ ^ block cull: self ]
	Receiver's instance variables: 
		superclass: 	DynamicVariable
		methodDict: 	a MethodDictionary()
		format: 	132
		layout: 	a FixedLayout
		instanceVariables: 	#()
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#CurrentJob
		classPool: 	a Dictionary()
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Jobs-Base'
		traitComposition: 	{}
		localSelectors: 	nil
		hash: 	nil
		soleInstance: 	a CurrentJob


[ 
self prepareForRunning.
CurrentJob value: self during: [ ^ block cull: self ] ] in Job>>run
	Receiver: a Job
	Arguments and temporary variables: 

	Receiver's instance variables: 
		block: 	[ 
self ensurePackage: version package.
self loadWithNameLike: version i...etc...
		currentValue: 	0
		min: 	0
		max: 	100
		title: 	'Loading Bloc-Core-AliakseiSyrel.636'
		children: 	an OrderedCollection()
		isRunning: 	true
		parent: 	nil
		process: 	a Process in nil


BlockClosure>>ensure:
	Receiver: [ 
self prepareForRunning.
CurrentJob value: self during: [ ^ block cull: self ] ]
	Arguments and temporary variables: 
		aBlock: 	[ self cleanupAfterRunning ]
		complete: 	nil
		returnValue: 	nil
	Receiver's instance variables: 
		outerContext: 	Job>>run
		startpc: 	41
		numArgs: 	0


Job>>run
	Receiver: a Job
	Arguments and temporary variables: 

	Receiver's instance variables: 
		block: 	[ 
self ensurePackage: version package.
self loadWithNameLike: version i...etc...
		currentValue: 	0
		min: 	0
		max: 	100
		title: 	'Loading Bloc-Core-AliakseiSyrel.636'
		children: 	an OrderedCollection()
		isRunning: 	true
		parent: 	nil
		process: 	a Process in nil


[ 
| version |
version := versions first.
[ 
self ensurePackage: version package.
self loadWithNameLike: version info name ] asJob
	title: 'Loading ' , version info name asString;
	run ] in MCVersionLoader>>load
	Receiver: a MCVersionLoader
	Arguments and temporary variables: 
		version: 	a MCVersion(Bloc-Core-AliakseiSyrel.636)
	Receiver's instance variables: 
		versions: 	an OrderedCollection(a MCVersion(Bloc-Core-AliakseiSyrel.636))


BlockClosure>>ensure:
	Receiver: [ 
| version |
version := versions first.
[ 
self ensurePackage: version package.
self loa...etc...
	Arguments and temporary variables: 
		aBlock: 	[ 
self cacheActive: oldActive.
self isCacheActive
	ifFalse: [ self res...etc...
		complete: 	nil
		returnValue: 	nil
	Receiver's instance variables: 
		outerContext: 	MCVersionLoader>>load
		startpc: 	74
		numArgs: 	0


RPackageSet class>>withCacheDo:
	Receiver: RPackageSet
	Arguments and temporary variables: 
		aBlock: 	[ 
| version |
version := versions first.
[ 
self ensurePackage: versio...etc...
		oldActive: 	false
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(#asRPackageSet->RPackageSet>>#asRPackageSet #cat...etc...
		format: 	150
		layout: 	a FixedLayout
		instanceVariables: 	#('packageName' 'packages' 'classes' 'definedClasses' 'exten...etc...
		organization: 	a ClassOrganization
		subclasses: 	{MetacelloTestsPackageSet}
		name: 	#RPackageSet
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'RPackage-Core'
		traitComposition: 	{}
		localSelectors: 	nil
		cacheActive: 	true
		cachePackages: 	nil


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

	Receiver's instance variables: 
		versions: 	an OrderedCollection(a MCVersion(Bloc-Core-AliakseiSyrel.636))


MetacelloGoferLoad(GoferLoad)>>execute
	Receiver: a MetacelloGoferLoad
	Arguments and temporary variables: 

	Receiver's instance variables: 
		gofer: 	a MetacelloGofer
		model: 	a MCVersionLoader


[ 
goferLoad := MetacelloGoferLoad on: aGofer.
goferLoad addResolved: resolvedReference.
goferLoad execute.
MetacelloPlatform current clearCurrentVersionCache	"mcLoader postLoad: packageSpec" ] in loadPackageDirective: aPackageLoadDirective gofer: aGofer
	| packageSpec |
	packageSpec := aPackageLoadDirective spec.
	MetacelloPlatform current
		do:
			[ 
			| loadBlock goferLoad answers resolvedReference |
			aGofer disablePackageCache.	"for good luck:)"
			resolvedReference := self
				resolvePackageSpec: packageSpec
				gofer: aGofer.
			resolvedReference isNil
				ifTrue: [ ^ self ].
			"Package version already loaded into image"
			loadBlock := [ 
			goferLoad := MetacelloGoferLoad on: aGofer.
			goferLoad addResolved: resolvedReference.
			goferLoad execute.
			MetacelloPlatform current clearCurrentVersionCache	"mcLoader postLoad: packageSpec" ].
			"mcLoader preLoad: packageSpec."
			(answers := packageSpec answers) notEmpty
				ifTrue: [ loadBlock valueSupplyingMetacelloAnswers: answers ]
				ifFalse: [ loadBlock value ].
			resolvedReference workingCopy repositoryGroup
				addRepository: aPackageLoadDirective repository.
			Transcript
				cr;
				show:
					'Loaded -> ' , resolvedReference name , ' --- '
						, aPackageLoadDirective repository description , ' --- '
						, resolvedReference repository description ]
		displaying: 'Loading ' , packageSpec file in MetacelloLoadingMCSpecLoader(MetacelloCommonMCSpecLoader)>>loadPackageDirective:gofer:
	Receiver: a MetacelloLoadingMCSpecLoader
	Arguments and temporary variables: 
		aPackageLoadDirective: 	load : Bloc-Core-AliakseiSyrel.636
		aGofer: 	a MetacelloGofer
		packageSpec: 	spec 
	name: 'Bloc-Core';
	requires: #('TxText' 'Athens-SVG' ).
		loadBlock: 	[ 
goferLoad := MetacelloGoferLoad on: aGofer.
goferLoad addResolved...etc...
		answers: 	#()
		resolvedReference: 	a MetacelloCachingGoferResolvedReference name: 'Bloc-Core-Al...etc...
		goferLoad: 	a MetacelloGoferLoad
	Receiver's instance variables: 
		spec: 	a MetacelloMCVersionSpecLoader
		operator: 	nil
		loaderPolicy: 	a MetacelloLoaderPolicy
		disablePackageCache: 	false


loadPackageDirective: aPackageLoadDirective gofer: aGofer
	| packageSpec |
	packageSpec := aPackageLoadDirective spec.
	MetacelloPlatform current
		do:
			[ 
			| loadBlock goferLoad answers resolvedReference |
			aGofer disablePackageCache.	"for good luck:)"
			resolvedReference := self
				resolvePackageSpec: packageSpec
				gofer: aGofer.
			resolvedReference isNil
				ifTrue: [ ^ self ].
			"Package version already loaded into image"
			loadBlock := [ 
			goferLoad := MetacelloGoferLoad on: aGofer.
			goferLoad addResolved: resolvedReference.
			goferLoad execute.
			MetacelloPlatform current clearCurrentVersionCache	"mcLoader postLoad: packageSpec" ].
			"mcLoader preLoad: packageSpec."
			(answers := packageSpec answers) notEmpty
				ifTrue: [ loadBlock valueSupplyingMetacelloAnswers: answers ]
				ifFalse: [ loadBlock value ].
			resolvedReference workingCopy repositoryGroup
				addRepository: aPackageLoadDirective repository.
			Transcript
				cr;
				show:
					'Loaded -> ' , resolvedReference name , ' --- '
						, aPackageLoadDirective repository description , ' --- '
						, resolvedReference repository description ]
		displaying: 'Loading ' , packageSpec file in MetacelloLoadingMCSpecLoader(MetacelloCommonMCSpecLoader)>>loadPackageDirective:gofer:
	Receiver: a MetacelloLoadingMCSpecLoader
	Arguments and temporary variables: 
<<error during printing>
	Receiver's instance variables: 
		spec: 	a MetacelloMCVersionSpecLoader
		operator: 	nil
		loaderPolicy: 	a MetacelloLoaderPolicy
		disablePackageCache: 	false


MetacelloPharo30Platform(MetacelloPlatform)>>do:displaying:
	Receiver: a MetacelloPharo30Platform
	Arguments and temporary variables: 
		aBlock: 	loadPackageDirective: aPackageLoadDirective gofer: aGofer
	| packageSpe...etc...
		aString: 	'Loading Bloc-Core'
	Receiver's instance variables: 
		bypassProgressBars: 	false
		bypassGoferLoadUpdateCategories: 	false


MetacelloLoadingMCSpecLoader(MetacelloCommonMCSpecLoader)>>loadPackageDirective:gofer:
	Receiver: a MetacelloLoadingMCSpecLoader
	Arguments and temporary variables: 
		aPackageLoadDirective: 	load : Bloc-Core-AliakseiSyrel.636
		aGofer: 	a MetacelloGofer
		packageSpec: 	spec 
	name: 'Bloc-Core';
	requires: #('TxText' 'Athens-SVG' ).
	Receiver's instance variables: 
		spec: 	a MetacelloMCVersionSpecLoader
		operator: 	nil
		loaderPolicy: 	a MetacelloLoaderPolicy
		disablePackageCache: 	false


MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadPackageDirective:gofer:
	Receiver: linear load : 0.5-baseline [ConfigurationOfBloc]
	explicit load : 1.0 [ConfigurationOfAthe...etc...
	Arguments and temporary variables: 
		aPackageLoadDirective: 	load : Bloc-Core-AliakseiSyrel.636
		aGofer: 	a MetacelloGofer
	Receiver's instance variables: 
		spec: 	nil
		loader: 	a MetacelloFetchingMCSpecLoader(linear load : 
	explicit load : 0.1-bas...etc...
		loadDirectives: 	an OrderedCollection(explicit load : 1.0 [ConfigurationOfAthens...etc...


MetacelloPackageLoadDirective>>loadUsing:gofer:
	Receiver: load : Bloc-Core-AliakseiSyrel.636
	Arguments and temporary variables: 
		aLoaderDirective: 	linear load : 0.5-baseline [ConfigurationOfBloc]
	explicit lo...etc...
		aGofer: 	a MetacelloGofer
	Receiver's instance variables: 
		spec: 	spec 
	name: 'Bloc-Core';
	requires: #('TxText' 'Athens-SVG' ).
		loader: 	a MetacelloFetchingMCSpecLoader(linear load : 
	explicit load : 0.1-bas...etc...
		resolvedReference: 	nil
		externalReference: 	a MetacelloCachingGoferResolvedReference name: 'Bloc-Core-Al...etc...



--- The full stack ---
MCStReader(Object)>>error:
MCStReader>>typeOfSubclass:
MCStReader>>classDefinitionFrom:
[ :ringClass | 
ringClass hasDefinitionSource
	ifTrue:
		[ definitions add: (self classDefinitionFrom: ringClass) ].
definitions addAll: (self methodDefinitionsFor: ringClass).
definitions
	addAll: (self methodDefinitionsFor: ringClass theMetaClass) ] in MCStReader>>loadDefinitions
Array(SequenceableCollection)>>do:
MCStReader>>loadDefinitions
MCStReader(MCSnapshotReader)>>definitions
MCMczReader>>extractDefinitionsFrom:
[ :m | self extractDefinitionsFrom: m ] in MCMczReader>>loadDefinitions
OrderedCollection>>do:
MCMczReader>>loadDefinitions
MCMczReader(MCVersionReader)>>definitions
MCMczReader(MCVersionReader)>>snapshot
[ self snapshot ] in MCMczReader(MCVersionReader)>>basicVersion
MCVersion>>snapshot
[ :ea | 
ea canOptimizeLoading
	ifTrue: [ ea patch applyTo: loader ]
	ifFalse:
		[ loader updatePackage: ea package withSnapshot: ea snapshot ] ] in MCVersionLoader>>loadWithNameLike:
OrderedCollection>>do:
MCVersionLoader>>loadWithNameLike:
[ 
self ensurePackage: version package.
self loadWithNameLike: version info name ] in [ 
| version |
version := versions first.
[ 
self ensurePackage: version package.
self loadWithNameLike: version info name ] asJob
	title: 'Loading ' , version info name asString;
	run ] in MCVersionLoader>>load
BlockClosure>>cull:
[ ^ block cull: self ] in [ 
self prepareForRunning.
CurrentJob value: self during: [ ^ block cull: self ] ] in Job>>run
[ 
p psValueAt: index put: anObject.
aBlock value ] in CurrentJob(DynamicVariable)>>value:during:
BlockClosure>>ensure:
CurrentJob(DynamicVariable)>>value:during:
CurrentJob class(DynamicVariable class)>>value:during:
[ 
self prepareForRunning.
CurrentJob value: self during: [ ^ block cull: self ] ] in Job>>run
BlockClosure>>ensure:
Job>>run
[ 
| version |
version := versions first.
[ 
self ensurePackage: version package.
self loadWithNameLike: version info name ] asJob
	title: 'Loading ' , version info name asString;
	run ] in MCVersionLoader>>load
BlockClosure>>ensure:
RPackageSet class>>withCacheDo:
MCVersionLoader>>load
MetacelloGoferLoad(GoferLoad)>>execute
[ 
goferLoad := MetacelloGoferLoad on: aGofer.
goferLoad addResolved: resolvedReference.
goferLoad execute.
MetacelloPlatform current clearCurrentVersionCache	"mcLoader postLoad: packageSpec" ] in loadPackageDirective: aPackageLoadDirective gofer: aGofer
	| packageSpec |
	packageSpec := aPackageLoadDirective spec.
	MetacelloPlatform current
		do:
			[ 
			| loadBlock goferLoad answers resolvedReference |
			aGofer disablePackageCache.	"for good luck:)"
			resolvedReference := self
				resolvePackageSpec: packageSpec
				gofer: aGofer.
			resolvedReference isNil
				ifTrue: [ ^ self ].
			"Package version already loaded into image"
			loadBlock := [ 
			goferLoad := MetacelloGoferLoad on: aGofer.
			goferLoad addResolved: resolvedReference.
			goferLoad execute.
			MetacelloPlatform current clearCurrentVersionCache	"mcLoader postLoad: packageSpec" ].
			"mcLoader preLoad: packageSpec."
			(answers := packageSpec answers) notEmpty
				ifTrue: [ loadBlock valueSupplyingMetacelloAnswers: answers ]
				ifFalse: [ loadBlock value ].
			resolvedReference workingCopy repositoryGroup
				addRepository: aPackageLoadDirective repository.
			Transcript
				cr;
				show:
					'Loaded -> ' , resolvedReference name , ' --- '
						, aPackageLoadDirective repository description , ' --- '
						, resolvedReference repository description ]
		displaying: 'Loading ' , packageSpec file in MetacelloLoadingMCSpecLoader(MetacelloCommonMCSpecLoader)>>loadPackageDirective:gofer:
loadPackageDirective: aPackageLoadDirective gofer: aGofer
	| packageSpec |
	packageSpec := aPackageLoadDirective spec.
	MetacelloPlatform current
		do:
			[ 
			| loadBlock goferLoad answers resolvedReference |
			aGofer disablePackageCache.	"for good luck:)"
			resolvedReference := self
				resolvePackageSpec: packageSpec
				gofer: aGofer.
			resolvedReference isNil
				ifTrue: [ ^ self ].
			"Package version already loaded into image"
			loadBlock := [ 
			goferLoad := MetacelloGoferLoad on: aGofer.
			goferLoad addResolved: resolvedReference.
			goferLoad execute.
			MetacelloPlatform current clearCurrentVersionCache	"mcLoader postLoad: packageSpec" ].
			"mcLoader preLoad: packageSpec."
			(answers := packageSpec answers) notEmpty
				ifTrue: [ loadBlock valueSupplyingMetacelloAnswers: answers ]
				ifFalse: [ loadBlock value ].
			resolvedReference workingCopy repositoryGroup
				addRepository: aPackageLoadDirective repository.
			Transcript
				cr;
				show:
					'Loaded -> ' , resolvedReference name , ' --- '
						, aPackageLoadDirective repository description , ' --- '
						, resolvedReference repository description ]
		displaying: 'Loading ' , packageSpec file in MetacelloLoadingMCSpecLoader(MetacelloCommonMCSpecLoader)>>loadPackageDirective:gofer:
MetacelloPharo30Platform(MetacelloPlatform)>>do:displaying:
MetacelloLoadingMCSpecLoader(MetacelloCommonMCSpecLoader)>>loadPackageDirective:gofer:
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadPackageDirective:gofer:
MetacelloPackageLoadDirective>>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:
[ :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:
MetacelloPharo30Platform(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:
MetacelloMCVersion>>load
GoferMetacelloLoad>>loadConfiguration
GoferMetacelloLoad>>execute
Gofer>>execute:do:
Gofer>>loadVersion:
Gofer>>loadDevelopment
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 GLMMorphicPharoPlaygroundRenderer(GLMMorphicPharoCodeRenderer)>>actOnHighlightAndEvaluate:
RubEditingArea(RubAbstractTextArea)>>handleEdit:
[ 
textMorph textArea
	handleEdit:
		[ 
		textMorph textArea editor highlightEvaluateAndDo: ann action.
		textMorph shoutStyler style: textMorph text ] ] in GLMMorphicPharoPlaygroundRenderer(GLMMorphicPharoCodeRenderer)>>actOnHighlightAndEvaluate:
WorldState>>runStepMethodsIn:
WorldMorph>>runStepMethods
WorldState>>doOneCycleNowFor:
WorldState>>doOneCycleFor:
WorldMorph>>doOneCycle
[ 
[ 
World doOneCycle.
Processor yield.
false ] whileFalse: [  ] ] in MorphicUIManager>>spawnNewProcess
[ 
self value.
Processor terminateActive ] in BlockClosure>>newProcess
-------------------------------------------------------------------------------

Reply via email to