@ambers/helios/src/Helios-Core.js

Helios IDE for Amber Smalltalk

define(["amber/boot", "require", "amber/core/Kernel-Objects", "amber/web/Web"], function($boot,requirejs){"use strict";
var $core=$boot.api,nil=$boot.nilAsValue,$nil=$boot.nilAsReceiver,$recv=$boot.asReceiver,$globals=$boot.globals;
var $pkg = $core.addPackage("Helios-Core");
$pkg.transport = {"type":"amd","amdNamespace":"helios"};

$core.addClass("HLModel", $globals.Object, "Helios-Core");
$core.setSlots($globals.HLModel, ["announcer", "environment"]);
//>>excludeStart("ide", pragmas.excludeIdeData);
$globals.HLModel.comment="I am the abstract superclass of all models of Helios.\x0aI am the \x22Model\x22 part of the MVC pattern implementation in Helios.\x0a\x0aI provide access to an `Environment` object and both a local (model-specific) and global (system-specific) announcer.\x0a\x0aThe `#withChangesDo:` method is handy for performing model changes ensuring that all widgets are aware of the change and can prevent it from happening.\x0a\x0aModifications of the system should be done via commands (see `HLCommand` and subclasses).";
//>>excludeEnd("ide");
$core.addMethod(
$core.method({
selector: "announcer",
protocol: "accessing",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "announcer\x0a\x09^ announcer ifNil: [ announcer := Announcer new ]",
referencedClasses: ["Announcer"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["ifNil:", "new"]
}, function ($methodClass){ return function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$self.announcer;
if($1 == null || $1.a$nil){
$self.announcer=$recv($globals.Announcer)._new();
return $self.announcer;
} else {
return $1;
}
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"announcer",{})});
//>>excludeEnd("ctx");
}; }),
$globals.HLModel);

$core.addMethod(
$core.method({
selector: "environment",
protocol: "accessing",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "environment\x0a\x09^ environment ifNil: [ self manager environment ]",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["ifNil:", "environment", "manager"]
}, function ($methodClass){ return function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$self.environment;
if($1 == null || $1.a$nil){
return $recv($self._manager())._environment();
} else {
return $1;
}
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"environment",{})});
//>>excludeEnd("ctx");
}; }),
$globals.HLModel);

$core.addMethod(
$core.method({
selector: "environment:",
protocol: "accessing",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anEnvironment"],
source: "environment: anEnvironment\x0a\x09environment := anEnvironment",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: []
}, function ($methodClass){ return function (anEnvironment){
var self=this,$self=this;
$self.environment=anEnvironment;
return self;

}; }),
$globals.HLModel);

$core.addMethod(
$core.method({
selector: "isBrowserModel",
protocol: "testing",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "isBrowserModel\x0a\x09^ false",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: []
}, function ($methodClass){ return function (){
var self=this,$self=this;
return false;

}; }),
$globals.HLModel);

$core.addMethod(
$core.method({
selector: "isReferencesModel",
protocol: "testing",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "isReferencesModel\x0a\x09^ false",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: []
}, function ($methodClass){ return function (){
var self=this,$self=this;
return false;

}; }),
$globals.HLModel);

$core.addMethod(
$core.method({
selector: "isToolModel",
protocol: "testing",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "isToolModel\x0a\x09^ false",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: []
}, function ($methodClass){ return function (){
var self=this,$self=this;
return false;

}; }),
$globals.HLModel);

$core.addMethod(
$core.method({
selector: "manager",
protocol: "accessing",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "manager\x0a\x09^ HLManager current",
referencedClasses: ["HLManager"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["current"]
}, function ($methodClass){ return function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($globals.HLManager)._current();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"manager",{})});
//>>excludeEnd("ctx");
}; }),
$globals.HLModel);

$core.addMethod(
$core.method({
selector: "systemAnnouncer",
protocol: "accessing",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "systemAnnouncer\x0a\x09^ self environment systemAnnouncer",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["systemAnnouncer", "environment"]
}, function ($methodClass){ return function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._environment())._systemAnnouncer();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"systemAnnouncer",{})});
//>>excludeEnd("ctx");
}; }),
$globals.HLModel);

$core.addMethod(
$core.method({
selector: "withChangesDo:",
protocol: "error handling",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "withChangesDo: aBlock\x0a\x09[ \x0a\x09\x09self announcer announce: (HLAboutToChange new\x0a\x09\x09\x09actionBlock: aBlock;\x0a\x09\x09\x09yourself).\x0a\x09\x09aBlock value.\x0a\x09]\x0a\x09\x09on: HLChangeForbidden \x0a\x09\x09do: [ :ex | ]",
referencedClasses: ["HLAboutToChange", "HLChangeForbidden"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["on:do:", "announce:", "announcer", "actionBlock:", "new", "yourself", "value"]
}, function ($methodClass){ return function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$2;
$recv((function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
$1=$self._announcer();
$2=$recv($globals.HLAboutToChange)._new();
$recv($2)._actionBlock_(aBlock);
$recv($1)._announce_($recv($2)._yourself());
return $recv(aBlock)._value();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
//>>excludeEnd("ctx");
}))._on_do_($globals.HLChangeForbidden,(function(ex){

}));
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"withChangesDo:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
}; }),
$globals.HLModel);



$core.addClass("HLFinder", $globals.HLModel, "Helios-Core");
//>>excludeStart("ide", pragmas.excludeIdeData);
$globals.HLFinder.comment="I am the `Finder` service handler of Helios.\x0a\x0aFinding a class will open a new class browser, while finding a method will open a references browser.";
//>>excludeEnd("ide");
$core.addMethod(
$core.method({
selector: "findClass:",
protocol: "finding",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aClass"],
source: "findClass: aClass\x0a\x09HLBrowser openAsTab openClassNamed: aClass name",
referencedClasses: ["HLBrowser"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["openClassNamed:", "openAsTab", "name"]
}, function ($methodClass){ return function (aClass){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($recv($globals.HLBrowser)._openAsTab())._openClassNamed_($recv(aClass)._name());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"findClass:",{aClass:aClass})});
//>>excludeEnd("ctx");
}; }),
$globals.HLFinder);

$core.addMethod(
$core.method({
selector: "findMethod:",
protocol: "finding",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aCompiledMethod"],
source: "findMethod: aCompiledMethod\x0a\x09HLBrowser openAsTab openMethod: aCompiledMethod",
referencedClasses: ["HLBrowser"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["openMethod:", "openAsTab"]
}, function ($methodClass){ return function (aCompiledMethod){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($recv($globals.HLBrowser)._openAsTab())._openMethod_(aCompiledMethod);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"findMethod:",{aCompiledMethod:aCompiledMethod})});
//>>excludeEnd("ctx");
}; }),
$globals.HLFinder);

$core.addMethod(
$core.method({
selector: "findString:",
protocol: "finding",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "findString: aString\x0a\x09| foundClass |\x0a\x09\x0a\x09foundClass := self environment classes \x0a\x09\x09detect: [ :each | each name = aString ]\x0a\x09\x09ifNone: [ nil ].\x0a\x09\x0a\x09foundClass \x0a\x09\x09ifNil: [ HLReferences openAsTab search: aString ]\x0a\x09\x09ifNotNil: [ self findClass: foundClass ]",
referencedClasses: ["HLReferences"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["detect:ifNone:", "classes", "environment", "=", "name", "ifNil:ifNotNil:", "search:", "openAsTab", "findClass:"]
}, function ($methodClass){ return function (aString){
var self=this,$self=this;
var foundClass;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
foundClass=$recv($recv($self._environment())._classes())._detect_ifNone_((function(each){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
return $recv($recv(each)._name()).__eq(aString);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)});
//>>excludeEnd("ctx");
}),(function(){
return nil;

}));
$1=foundClass;
if($1 == null || $1.a$nil){
$recv($recv($globals.HLReferences)._openAsTab())._search_(aString);
} else {
$self._findClass_(foundClass);
}
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"findString:",{aString:aString,foundClass:foundClass})});
//>>excludeEnd("ctx");
}; }),
$globals.HLFinder);



$core.addClass("HLToolModel", $globals.HLModel, "Helios-Core");
$core.setSlots($globals.HLToolModel, ["selectedClass", "selectedPackage", "selectedProtocol", "selectedSelector"]);
//>>excludeStart("ide", pragmas.excludeIdeData);
$globals.HLToolModel.comment="I am a model specific to package and class manipulation. All browsers should either use me or a subclass as their model.\x0a\x0aI provide methods for package, class, protocol and method manipulation and access, forwarding to my environment.\x0a\x0aI also handle compilation of classes and methods as well as compilation and parsing errors.";
//>>excludeEnd("ide");
$core.addMethod(
$core.method({
selector: "addInstVarNamed:",
protocol: "actions",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "addInstVarNamed: aString\x0a\x09self environment addInstVarNamed: aString to: self selectedClass.\x0a\x09self announcer announce: (HLInstVarAdded new\x0a\x09\x09theClass: self selectedClass;\x0a\x09\x09variableName: aString;\x0a\x09\x09yourself)",
referencedClasses: ["HLInstVarAdded"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["addInstVarNamed:to:", "environment", "selectedClass", "announce:", "announcer", "theClass:", "new", "variableName:", "yourself"]
}, function ($methodClass){ return function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$2;
$recv($self._environment())._addInstVarNamed_to_(aString,[$self._selectedClass()
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
,$ctx1.sendIdx["selectedClass"]=1
//>>excludeEnd("ctx");
][0]);
$1=$self._announcer();
$2=$recv($globals.HLInstVarAdded)._new();
$recv($2)._theClass_($self._selectedClass());
$recv($2)._variableName_(aString);
$recv($1)._announce_($recv($2)._yourself());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"addInstVarNamed:",{aString:aString})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "allProtocol",
protocol: "defaults",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "allProtocol\x0a\x09^ '-- all --'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: []
}, function ($methodClass){ return function (){
var self=this,$self=this;
return "-- all --";

}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "allSelectors",
protocol: "accessing",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "allSelectors\x0a\x09^ self environment allSelectors",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["allSelectors", "environment"]
}, function ($methodClass){ return function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._environment())._allSelectors();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"allSelectors",{})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "availableClassNames",
protocol: "accessing",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "availableClassNames\x0a\x09^ self environment availableClassNames",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["availableClassNames", "environment"]
}, function ($methodClass){ return function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._environment())._availableClassNames();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"availableClassNames",{})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "availablePackageNames",
protocol: "accessing",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "availablePackageNames\x0a\x09^ self environment availablePackageNames",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["availablePackageNames", "environment"]
}, function ($methodClass){ return function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._environment())._availablePackageNames();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"availablePackageNames",{})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "availablePackages",
protocol: "accessing",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "availablePackages\x0a\x09^ self environment availablePackageNames",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["availablePackageNames", "environment"]
}, function ($methodClass){ return function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._environment())._availablePackageNames();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"availablePackages",{})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "availableProtocols",
protocol: "accessing",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "availableProtocols\x0a\x09^ self environment availableProtocolsFor: self selectedClass",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["availableProtocolsFor:", "environment", "selectedClass"]
}, function ($methodClass){ return function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._environment())._availableProtocolsFor_($self._selectedClass());
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"availableProtocols",{})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "commitPackageOnSuccess:onError:",
protocol: "commands actions",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock", "anotherBlock"],
source: "commitPackageOnSuccess: aBlock onError: anotherBlock\x0a\x09self environment \x0a\x09\x09commitPackage: self packageToCommit\x0a\x09\x09onSuccess: aBlock\x0a\x09\x09onError: anotherBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["commitPackage:onSuccess:onError:", "environment", "packageToCommit"]
}, function ($methodClass){ return function (aBlock,anotherBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($self._environment())._commitPackage_onSuccess_onError_($self._packageToCommit(),aBlock,anotherBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"commitPackageOnSuccess:onError:",{aBlock:aBlock,anotherBlock:anotherBlock})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "compilationProtocol",
protocol: "private",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "compilationProtocol\x0a\x09| currentProtocol |\x0a\x09\x0a\x09currentProtocol := self selectedProtocol.\x0a\x09currentProtocol ifNil: [ currentProtocol := self unclassifiedProtocol ].\x0a\x09self selectedMethod ifNotNil: [ currentProtocol := self selectedMethod protocol ].\x0a\x0a\x09^ currentProtocol = self allProtocol\x0a\x09\x09ifTrue: [ self unclassifiedProtocol ]\x0a\x09\x09ifFalse: [ currentProtocol ]",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["selectedProtocol", "ifNil:", "unclassifiedProtocol", "ifNotNil:", "selectedMethod", "protocol", "ifTrue:ifFalse:", "=", "allProtocol"]
}, function ($methodClass){ return function (){
var self=this,$self=this;
var currentProtocol;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$2;
currentProtocol=$self._selectedProtocol();
$1=currentProtocol;
if($1 == null || $1.a$nil){
currentProtocol=[$self._unclassifiedProtocol()
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
,$ctx1.sendIdx["unclassifiedProtocol"]=1
//>>excludeEnd("ctx");
][0];
currentProtocol;
} else {
$1;
}
$2=[$self._selectedMethod()
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
,$ctx1.sendIdx["selectedMethod"]=1
//>>excludeEnd("ctx");
][0];
if($2 == null || $2.a$nil){
$2;
} else {
currentProtocol=$recv($self._selectedMethod())._protocol();
currentProtocol;
}
if($core.assert($recv(currentProtocol).__eq($self._allProtocol()))){
return $self._unclassifiedProtocol();
} else {
return currentProtocol;
}
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"compilationProtocol",{currentProtocol:currentProtocol})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "compileClassComment:",
protocol: "compiling",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "compileClassComment: aString\x0a\x09self environment \x0a\x09\x09compileClassComment: aString \x0a\x09\x09for: self selectedClass",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["compileClassComment:for:", "environment", "selectedClass"]
}, function ($methodClass){ return function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($self._environment())._compileClassComment_for_(aString,$self._selectedClass());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"compileClassComment:",{aString:aString})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "compileClassDefinition:",
protocol: "compiling",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "compileClassDefinition: aString\x0a\x09self environment compileClassDefinition: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["compileClassDefinition:", "environment"]
}, function ($methodClass){ return function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($self._environment())._compileClassDefinition_(aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"compileClassDefinition:",{aString:aString})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "compileMethod:",
protocol: "compiling",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "compileMethod: aString\x0a\x09| method |\x0a\x09\x0a\x09self withCompileErrorHandling: [ \x0a\x09\x09method := self environment \x0a\x09\x09\x09compileMethod: aString \x0a\x09\x09\x09for: self selectedClass\x0a\x09\x09\x09protocol: self compilationProtocol.\x0a\x0a\x09\x09self selectedMethod: method ]",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["withCompileErrorHandling:", "compileMethod:for:protocol:", "environment", "selectedClass", "compilationProtocol", "selectedMethod:"]
}, function ($methodClass){ return function (aString){
var self=this,$self=this;
var method;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._withCompileErrorHandling_((function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
method=$recv($self._environment())._compileMethod_for_protocol_(aString,$self._selectedClass(),$self._compilationProtocol());
return $self._selectedMethod_(method);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
//>>excludeEnd("ctx");
}));
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"compileMethod:",{aString:aString,method:method})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "copyClassTo:",
protocol: "commands actions",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aClassName"],
source: "copyClassTo: aClassName\x0a\x09self withChangesDo: [ \x0a\x09\x09self environment \x0a\x09\x09\x09copyClass: self selectedClass theNonMetaClass\x0a\x09\x09\x09to: aClassName.\x0a\x09\x09self selectedClass: (self environment classNamed: aClassName) ]",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["withChangesDo:", "copyClass:to:", "environment", "theNonMetaClass", "selectedClass", "selectedClass:", "classNamed:"]
}, function ($methodClass){ return function (aClassName){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._withChangesDo_((function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
$recv([$self._environment()
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
,$ctx2.sendIdx["environment"]=1
//>>excludeEnd("ctx");
][0])._copyClass_to_($recv($self._selectedClass())._theNonMetaClass(),aClassName);
return $self._selectedClass_($recv($self._environment())._classNamed_(aClassName));
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
//>>excludeEnd("ctx");
}));
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"copyClassTo:",{aClassName:aClassName})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "handleCompileError:",
protocol: "error handling",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anError"],
source: "handleCompileError: anError\x0a\x09self announcer announce: (HLCompileErrorRaised new\x0a\x09\x09error: anError;\x0a\x09\x09yourself)",
referencedClasses: ["HLCompileErrorRaised"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["announce:", "announcer", "error:", "new", "yourself"]
}, function ($methodClass){ return function (anError){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$2;
$1=$self._announcer();
$2=$recv($globals.HLCompileErrorRaised)._new();
$recv($2)._error_(anError);
$recv($1)._announce_($recv($2)._yourself());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"handleCompileError:",{anError:anError})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "handleParseError:",
protocol: "error handling",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anError"],
source: "handleParseError: anError\x0a\x09| split line column messageToInsert |\x0a\x09\x0a\x09split := anError messageText tokenize: ' : '.\x0a\x09messageToInsert := split second.\x0a\x0a\x09\x2221 = 'Parse error on line ' size + 1\x22\x0a\x09split := split first copyFrom: 21 to: split first size.\x0a\x09\x0a\x09split := split tokenize: ' column '.\x0a\x09line := split first.\x0a\x09column := split second.\x0a\x09\x0a\x09self announcer announce: (HLParseErrorRaised new\x0a\x09\x09line: line asNumber;\x0a\x09\x09column: column asNumber;\x0a\x09\x09message: messageToInsert;\x0a\x09\x09error: anError;\x0a\x09\x09yourself)",
referencedClasses: ["HLParseErrorRaised"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tokenize:", "messageText", "second", "copyFrom:to:", "first", "size", "announce:", "announcer", "line:", "new", "asNumber", "column:", "message:", "error:", "yourself"]
}, function ($methodClass){ return function (anError){
var self=this,$self=this;
var split,line,column,messageToInsert;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$2;
split=[$recv($recv(anError)._messageText())._tokenize_(" : ")
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
,$ctx1.sendIdx["tokenize:"]=1
//>>excludeEnd("ctx");
][0];
messageToInsert=[$recv(split)._second()
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
,$ctx1.sendIdx["second"]=1
//>>excludeEnd("ctx");
][0];
split=$recv([$recv(split)._first()
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
,$ctx1.sendIdx["first"]=1
//>>excludeEnd("ctx");
][0])._copyFrom_to_((21),$recv([$recv(split)._first()
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
,$ctx1.sendIdx["first"]=2
//>>excludeEnd("ctx");
][0])._size());
split=$recv(split)._tokenize_(" column ");
line=$recv(split)._first();
column=$recv(split)._second();
$1=$self._announcer();
$2=$recv($globals.HLParseErrorRaised)._new();
$recv($2)._line_([$recv(line)._asNumber()
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
,$ctx1.sendIdx["asNumber"]=1
//>>excludeEnd("ctx");
][0]);
$recv($2)._column_($recv(column)._asNumber());
$recv($2)._message_(messageToInsert);
$recv($2)._error_(anError);
$recv($1)._announce_($recv($2)._yourself());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"handleParseError:",{anError:anError,split:split,line:line,column:column,messageToInsert:messageToInsert})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "handleUnkownVariableError:",
protocol: "error handling",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anError"],
source: "handleUnkownVariableError: anError\x0a\x09self announcer announce: (HLUnknownVariableErrorRaised new\x0a\x09\x09error: anError;\x0a\x09\x09yourself)",
referencedClasses: ["HLUnknownVariableErrorRaised"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["announce:", "announcer", "error:", "new", "yourself"]
}, function ($methodClass){ return function (anError){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$2;
$1=$self._announcer();
$2=$recv($globals.HLUnknownVariableErrorRaised)._new();
$recv($2)._error_(anError);
$recv($1)._announce_($recv($2)._yourself());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"handleUnkownVariableError:",{anError:anError})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "isToolModel",
protocol: "testing",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "isToolModel\x0a\x09^ true",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: []
}, function ($methodClass){ return function (){
var self=this,$self=this;
return true;

}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "moveClassToPackage:",
protocol: "commands actions",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aPackageName"],
source: "moveClassToPackage: aPackageName\x0a\x09self withChangesDo: [\x0a\x09\x09self environment \x0a\x09\x09\x09moveClass: self selectedClass theNonMetaClass\x0a\x09\x09\x09toPackage: aPackageName ]",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["withChangesDo:", "moveClass:toPackage:", "environment", "theNonMetaClass", "selectedClass"]
}, function ($methodClass){ return function (aPackageName){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._withChangesDo_((function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
return $recv($self._environment())._moveClass_toPackage_($recv($self._selectedClass())._theNonMetaClass(),aPackageName);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
//>>excludeEnd("ctx");
}));
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"moveClassToPackage:",{aPackageName:aPackageName})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "moveMethodToClass:",
protocol: "commands actions",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aClassName"],
source: "moveMethodToClass: aClassName\x0a\x09self withChangesDo: [\x0a\x09\x09self environment \x0a\x09\x09\x09moveMethod: self selectedMethod \x0a\x09\x09\x09toClass: aClassName ]",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["withChangesDo:", "moveMethod:toClass:", "environment", "selectedMethod"]
}, function ($methodClass){ return function (aClassName){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._withChangesDo_((function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
return $recv($self._environment())._moveMethod_toClass_($self._selectedMethod(),aClassName);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
//>>excludeEnd("ctx");
}));
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"moveMethodToClass:",{aClassName:aClassName})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "moveMethodToProtocol:",
protocol: "commands actions",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aProtocol"],
source: "moveMethodToProtocol: aProtocol\x0a\x09self withChangesDo: [\x0a\x09\x09self environment \x0a\x09\x09\x09moveMethod: self selectedMethod \x0a\x09\x09\x09toProtocol: aProtocol ]",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["withChangesDo:", "moveMethod:toProtocol:", "environment", "selectedMethod"]
}, function ($methodClass){ return function (aProtocol){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._withChangesDo_((function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
return $recv($self._environment())._moveMethod_toProtocol_($self._selectedMethod(),aProtocol);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
//>>excludeEnd("ctx");
}));
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"moveMethodToProtocol:",{aProtocol:aProtocol})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "openClassNamed:",
protocol: "commands actions",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "openClassNamed: aString\x0a\x09| class |\x0a\x09\x0a\x09self withChangesDo: [\x0a\x09\x09class := self environment classNamed: aString.\x0a\x09\x09self selectedPackage: class package.\x0a\x09\x09self selectedClass: class ]",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["withChangesDo:", "classNamed:", "environment", "selectedPackage:", "package", "selectedClass:"]
}, function ($methodClass){ return function (aString){
var self=this,$self=this;
var class_;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._withChangesDo_((function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
class_=$recv($self._environment())._classNamed_(aString);
$self._selectedPackage_($recv(class_)._package());
return $self._selectedClass_(class_);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
//>>excludeEnd("ctx");
}));
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"openClassNamed:",{aString:aString,class_:class_})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "packageToCommit",
protocol: "accessing",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "packageToCommit\x0a\x09\x22Answer the package to commit depending on the context:\x0a\x09- if a Method is selected, answer its package\x0a\x09- else answer the `selectedPackage`\x22\x0a\x09\x0a\x09^ self selectedMethod \x0a\x09\x09ifNil: [ self selectedPackage ]\x0a\x09\x09ifNotNil: [ :method | method package ]",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["ifNil:ifNotNil:", "selectedMethod", "selectedPackage", "package"]
}, function ($methodClass){ return function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$self._selectedMethod();
if($1 == null || $1.a$nil){
return $self._selectedPackage();
} else {
var method;
method=$1;
return $recv(method)._package();
}
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"packageToCommit",{})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "packages",
protocol: "accessing",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "packages\x0a\x09^ self environment packages",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["packages", "environment"]
}, function ($methodClass){ return function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._environment())._packages();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"packages",{})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "removeClass",
protocol: "commands actions",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "removeClass\x0a\x09self withChangesDo: [\x0a\x09\x09self manager \x0a\x09\x09\x09confirm: 'Do you REALLY want to remove class ', self selectedClass theNonMetaClass name\x0a\x09\x09\x09ifTrue: [ self environment removeClass: self selectedClass theNonMetaClass ] ]",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["withChangesDo:", "confirm:ifTrue:", "manager", ",", "name", "theNonMetaClass", "selectedClass", "removeClass:", "environment"]
}, function ($methodClass){ return function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._withChangesDo_((function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
return $recv($self._manager())._confirm_ifTrue_("Do you REALLY want to remove class ".__comma($recv([$recv([$self._selectedClass()
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
,$ctx2.sendIdx["selectedClass"]=1
//>>excludeEnd("ctx");
][0])._theNonMetaClass()
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
,$ctx2.sendIdx["theNonMetaClass"]=1
//>>excludeEnd("ctx");
][0])._name()),(function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx3) {
//>>excludeEnd("ctx");
return $recv($self._environment())._removeClass_($recv($self._selectedClass())._theNonMetaClass());
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)});
//>>excludeEnd("ctx");
}));
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
//>>excludeEnd("ctx");
}));
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"removeClass",{})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "removeMethod",
protocol: "commands actions",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "removeMethod\x0a\x09self withChangesDo: [\x0a\x09\x09self manager \x0a\x09\x09\x09confirm: 'Do you REALLY want to remove method ', self selectedMethod origin name,' >> #', self selectedMethod selector\x0a\x09\x09\x09ifTrue: [ self environment removeMethod: self selectedMethod ] ]",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["withChangesDo:", "confirm:ifTrue:", "manager", ",", "name", "origin", "selectedMethod", "selector", "removeMethod:", "environment"]
}, function ($methodClass){ return function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._withChangesDo_((function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
return $recv($self._manager())._confirm_ifTrue_([$recv([$recv("Do you REALLY want to remove method ".__comma($recv($recv([$self._selectedMethod()
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
,$ctx2.sendIdx["selectedMethod"]=1
//>>excludeEnd("ctx");
][0])._origin())._name())).__comma(" >> #")
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
,$ctx2.sendIdx[","]=2
//>>excludeEnd("ctx");
][0]).__comma($recv([$self._selectedMethod()
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
,$ctx2.sendIdx["selectedMethod"]=2
//>>excludeEnd("ctx");
][0])._selector())
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
,$ctx2.sendIdx[","]=1
//>>excludeEnd("ctx");
][0],(function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx3) {
//>>excludeEnd("ctx");
return $recv($self._environment())._removeMethod_($self._selectedMethod());
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)});
//>>excludeEnd("ctx");
}));
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
//>>excludeEnd("ctx");
}));
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"removeMethod",{})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "removeProtocol",
protocol: "commands actions",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "removeProtocol\x0a\x09self withChangesDo: [\x0a\x09\x09self manager \x0a\x09\x09\x09confirm: 'Do you REALLY want to remove protocol ', self selectedProtocol\x0a\x09\x09\x09ifTrue: [ self environment \x0a\x09\x09\x09\x09removeProtocol: self selectedProtocol \x0a\x09\x09\x09\x09from: self selectedClass ] ]",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["withChangesDo:", "confirm:ifTrue:", "manager", ",", "selectedProtocol", "removeProtocol:from:", "environment", "selectedClass"]
}, function ($methodClass){ return function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._withChangesDo_((function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
return $recv($self._manager())._confirm_ifTrue_("Do you REALLY want to remove protocol ".__comma([$self._selectedProtocol()
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
,$ctx2.sendIdx["selectedProtocol"]=1
//>>excludeEnd("ctx");
][0]),(function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx3) {
//>>excludeEnd("ctx");
return $recv($self._environment())._removeProtocol_from_($self._selectedProtocol(),$self._selectedClass());
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)});
//>>excludeEnd("ctx");
}));
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
//>>excludeEnd("ctx");
}));
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"removeProtocol",{})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "renameClassTo:",
protocol: "commands actions",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aClassName"],
source: "renameClassTo: aClassName\x0a\x09self withChangesDo: [\x0a\x09\x09self environment \x0a\x09\x09\x09renameClass: self selectedClass theNonMetaClass\x0a\x09\x09\x09to: aClassName ]",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["withChangesDo:", "renameClass:to:", "environment", "theNonMetaClass", "selectedClass"]
}, function ($methodClass){ return function (aClassName){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._withChangesDo_((function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
return $recv($self._environment())._renameClass_to_($recv($self._selectedClass())._theNonMetaClass(),aClassName);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
//>>excludeEnd("ctx");
}));
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"renameClassTo:",{aClassName:aClassName})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "renamePackageTo:",
protocol: "commands actions",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aPackageName"],
source: "renamePackageTo: aPackageName\x0a\x09self withChangesDo: [\x0a\x09\x09self environment\x0a\x09\x09\x09renamePackage: self selectedPackage name\x0a\x09\x09\x09to: aPackageName ]",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["withChangesDo:", "renamePackage:to:", "environment", "name", "selectedPackage"]
}, function ($methodClass){ return function (aPackageName){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._withChangesDo_((function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
return $recv($self._environment())._renamePackage_to_($recv($self._selectedPackage())._name(),aPackageName);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
//>>excludeEnd("ctx");
}));
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"renamePackageTo:",{aPackageName:aPackageName})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "renameProtocolTo:",
protocol: "commands actions",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "renameProtocolTo: aString\x0a\x09self withChangesDo: [\x0a\x09\x09self environment \x0a\x09\x09\x09renameProtocol: self selectedProtocol\x0a\x09\x09\x09to: aString\x0a\x09\x09\x09in: self selectedClass ]",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["withChangesDo:", "renameProtocol:to:in:", "environment", "selectedProtocol", "selectedClass"]
}, function ($methodClass){ return function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._withChangesDo_((function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
return $recv($self._environment())._renameProtocol_to_in_($self._selectedProtocol(),aString,$self._selectedClass());
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
//>>excludeEnd("ctx");
}));
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"renameProtocolTo:",{aString:aString})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "save:",
protocol: "actions",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "save: aString\x0a\x09self announcer announce: HLSourceCodeSaved new.\x0a\x09\x0a\x09(self shouldCompileDefinition: aString)\x0a\x09\x09ifTrue: [ self compileClassDefinition: aString ]\x0a\x09\x09ifFalse: [ self compileMethod: aString ]",
referencedClasses: ["HLSourceCodeSaved"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["announce:", "announcer", "new", "ifTrue:ifFalse:", "shouldCompileDefinition:", "compileClassDefinition:", "compileMethod:"]
}, function ($methodClass){ return function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($self._announcer())._announce_($recv($globals.HLSourceCodeSaved)._new());
if($core.assert($self._shouldCompileDefinition_(aString))){
$self._compileClassDefinition_(aString);
} else {
$self._compileMethod_(aString);
}
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"save:",{aString:aString})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "saveSourceCode",
protocol: "actions",
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "saveSourceCode\x0a\x09self announcer announce: HLSaveSourceCode new",
referencedClasses: ["HLSaveSourceCode"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["announce:", "announcer", "new"]
}, function ($methodClass){ return function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($self._announcer())._announce_($recv($globals.HLSaveSourceCode)._new());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"saveSourceCode",{})});
//>>excludeEnd("ctx");
}; }),
$globals.HLToolModel);

$core.addMethod(
$core.method({
selector: "selectedClass",
protocol: "accessing",
//>>excludeStart("