resin 0.2.1 → 0.2.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/README.markdown +2 -0
- data/amber/bin/nodecompile.js +3 -3
- data/amber/css/amber.css +47 -23
- data/amber/images/off.amber.png +0 -0
- data/amber/images/offHover.amber.png +0 -0
- data/amber/images/sprite.amber.png +0 -0
- data/amber/images/tinylogo.amber.png +0 -0
- data/amber/js/Benchfib.deploy.js +34 -34
- data/amber/js/Benchfib.js +49 -49
- data/amber/js/Canvas.deploy.js +937 -937
- data/amber/js/Canvas.js +1622 -1622
- data/amber/js/Compiler-Tests.deploy.js +97 -0
- data/amber/js/Compiler-Tests.js +137 -0
- data/amber/js/Compiler.deploy.js +1030 -924
- data/amber/js/Compiler.js +1613 -1467
- data/amber/js/Documentation.deploy.js +417 -417
- data/amber/js/Documentation.js +728 -728
- data/amber/js/Examples.deploy.js +24 -13
- data/amber/js/Examples.js +36 -19
- data/amber/js/IDE.deploy.js +1583 -1527
- data/amber/js/IDE.js +2586 -2510
- data/amber/js/Kernel-Announcements.deploy.js +19 -19
- data/amber/js/Kernel-Announcements.js +28 -28
- data/amber/js/Kernel-Classes.deploy.js +332 -229
- data/amber/js/Kernel-Classes.js +532 -384
- data/amber/js/Kernel-Collections.deploy.js +1516 -1712
- data/amber/js/Kernel-Collections.js +2436 -2712
- data/amber/js/Kernel-Exceptions.deploy.js +85 -62
- data/amber/js/Kernel-Exceptions.js +131 -98
- data/amber/js/Kernel-Methods.deploy.js +326 -378
- data/amber/js/Kernel-Methods.js +473 -525
- data/amber/js/Kernel-Objects.deploy.js +1777 -2428
- data/amber/js/Kernel-Objects.js +2599 -3426
- data/amber/js/Kernel-Tests.deploy.js +871 -772
- data/amber/js/Kernel-Tests.js +1207 -1083
- data/amber/js/Kernel-Transcript.deploy.js +57 -57
- data/amber/js/Kernel-Transcript.js +94 -94
- data/amber/js/SUnit.deploy.js +116 -116
- data/amber/js/SUnit.js +211 -211
- data/amber/js/amber.js +10 -11
- data/amber/js/boot.js +132 -156
- data/amber/js/init.js +2 -2
- data/amber/js/parser.js +2095 -3014
- data/amber/js/parser.pegjs +1 -1
- data/amber/st/Benchfib.st +22 -22
- data/amber/st/Canvas.st +471 -471
- data/amber/st/Compiler-Tests.st +471 -0
- data/amber/st/Compiler.st +858 -794
- data/amber/st/Examples.st +22 -5
- data/amber/st/IDE.st +1326 -1291
- data/amber/st/Kernel-Announcements.st +2 -2
- data/amber/st/Kernel-Classes.st +148 -90
- data/amber/st/Kernel-Collections.st +950 -1061
- data/amber/st/Kernel-Exceptions.st +33 -25
- data/amber/st/Kernel-Methods.st +151 -151
- data/amber/st/Kernel-Objects.st +891 -1036
- data/amber/st/Kernel-Tests.st +622 -544
- data/amber/st/Kernel-Transcript.st +38 -38
- data/amber/st/SUnit.st +53 -53
- metadata +27 -20
| @@ -1,66 +1,71 @@ | |
| 1 1 | 
             
            smalltalk.addPackage('Kernel-Transcript', {});
         | 
| 2 | 
            -
            smalltalk.addClass(' | 
| 3 | 
            -
             | 
| 4 | 
            -
            smalltalk.Transcript.klass.iVarNames = ['current'];
         | 
| 2 | 
            +
            smalltalk.addClass('ConsoleTranscript', smalltalk.Object, ['textarea'], 'Kernel-Transcript');
         | 
| 5 3 | 
             
            smalltalk.addMethod(
         | 
| 6 | 
            -
             | 
| 4 | 
            +
            "_clear",
         | 
| 7 5 | 
             
            smalltalk.method({
         | 
| 8 | 
            -
            selector:  | 
| 6 | 
            +
            selector: "clear",
         | 
| 9 7 | 
             
            fn: function (){
         | 
| 10 8 | 
             
            var self=this;
         | 
| 11 | 
            -
             | 
| 9 | 
            +
             | 
| 12 10 | 
             
            return self;}
         | 
| 13 11 | 
             
            }),
         | 
| 14 | 
            -
            smalltalk. | 
| 12 | 
            +
            smalltalk.ConsoleTranscript);
         | 
| 15 13 |  | 
| 16 14 | 
             
            smalltalk.addMethod(
         | 
| 17 | 
            -
             | 
| 15 | 
            +
            "_cr",
         | 
| 18 16 | 
             
            smalltalk.method({
         | 
| 19 | 
            -
            selector:  | 
| 17 | 
            +
            selector: "cr",
         | 
| 20 18 | 
             
            fn: function (){
         | 
| 21 19 | 
             
            var self=this;
         | 
| 22 | 
            -
             | 
| 20 | 
            +
             | 
| 23 21 | 
             
            return self;}
         | 
| 24 22 | 
             
            }),
         | 
| 25 | 
            -
            smalltalk. | 
| 23 | 
            +
            smalltalk.ConsoleTranscript);
         | 
| 26 24 |  | 
| 27 25 | 
             
            smalltalk.addMethod(
         | 
| 28 | 
            -
             | 
| 26 | 
            +
            "_open",
         | 
| 29 27 | 
             
            smalltalk.method({
         | 
| 30 | 
            -
            selector:  | 
| 28 | 
            +
            selector: "open",
         | 
| 31 29 | 
             
            fn: function (){
         | 
| 32 30 | 
             
            var self=this;
         | 
| 33 | 
            -
             | 
| 31 | 
            +
             | 
| 34 32 | 
             
            return self;}
         | 
| 35 33 | 
             
            }),
         | 
| 36 | 
            -
            smalltalk. | 
| 34 | 
            +
            smalltalk.ConsoleTranscript);
         | 
| 37 35 |  | 
| 38 36 | 
             
            smalltalk.addMethod(
         | 
| 39 | 
            -
             | 
| 37 | 
            +
            "_show_",
         | 
| 40 38 | 
             
            smalltalk.method({
         | 
| 41 | 
            -
            selector:  | 
| 39 | 
            +
            selector: "show:",
         | 
| 42 40 | 
             
            fn: function (anObject){
         | 
| 43 41 | 
             
            var self=this;
         | 
| 44 | 
            -
             | 
| 42 | 
            +
            var string=nil;
         | 
| 43 | 
            +
            (string=smalltalk.send(anObject, "_asString", []));
         | 
| 44 | 
            +
            console.log(String(string));
         | 
| 45 45 | 
             
            return self;}
         | 
| 46 46 | 
             
            }),
         | 
| 47 | 
            -
            smalltalk. | 
| 47 | 
            +
            smalltalk.ConsoleTranscript);
         | 
| 48 | 
            +
             | 
| 48 49 |  | 
| 49 50 | 
             
            smalltalk.addMethod(
         | 
| 50 | 
            -
             | 
| 51 | 
            +
            "_initialize",
         | 
| 51 52 | 
             
            smalltalk.method({
         | 
| 52 | 
            -
            selector:  | 
| 53 | 
            +
            selector: "initialize",
         | 
| 53 54 | 
             
            fn: function (){
         | 
| 54 55 | 
             
            var self=this;
         | 
| 55 | 
            -
            smalltalk.send(smalltalk. | 
| 56 | 
            +
            smalltalk.send((smalltalk.Transcript || Transcript), "_register_", [smalltalk.send(self, "_new", [])]);
         | 
| 56 57 | 
             
            return self;}
         | 
| 57 58 | 
             
            }),
         | 
| 58 | 
            -
            smalltalk. | 
| 59 | 
            +
            smalltalk.ConsoleTranscript.klass);
         | 
| 60 | 
            +
             | 
| 61 | 
            +
             | 
| 62 | 
            +
            smalltalk.addClass('Transcript', smalltalk.Object, ['textarea'], 'Kernel-Transcript');
         | 
| 59 63 |  | 
| 64 | 
            +
            smalltalk.Transcript.klass.iVarNames = ['current'];
         | 
| 60 65 | 
             
            smalltalk.addMethod(
         | 
| 61 | 
            -
             | 
| 66 | 
            +
            "_clear",
         | 
| 62 67 | 
             
            smalltalk.method({
         | 
| 63 | 
            -
            selector:  | 
| 68 | 
            +
            selector: "clear",
         | 
| 64 69 | 
             
            fn: function (){
         | 
| 65 70 | 
             
            var self=this;
         | 
| 66 71 | 
             
            smalltalk.send(smalltalk.send(self, "_current", []), "_clear", []);
         | 
| @@ -69,74 +74,69 @@ return self;} | |
| 69 74 | 
             
            smalltalk.Transcript.klass);
         | 
| 70 75 |  | 
| 71 76 | 
             
            smalltalk.addMethod(
         | 
| 72 | 
            -
             | 
| 77 | 
            +
            "_cr",
         | 
| 73 78 | 
             
            smalltalk.method({
         | 
| 74 | 
            -
            selector:  | 
| 75 | 
            -
            fn: function ( | 
| 79 | 
            +
            selector: "cr",
         | 
| 80 | 
            +
            fn: function (){
         | 
| 76 81 | 
             
            var self=this;
         | 
| 77 | 
            -
            (self[ | 
| 82 | 
            +
            smalltalk.send(smalltalk.send(self, "_current", []), "_show_", [smalltalk.send((smalltalk.String || String), "_cr", [])]);
         | 
| 78 83 | 
             
            return self;}
         | 
| 79 84 | 
             
            }),
         | 
| 80 85 | 
             
            smalltalk.Transcript.klass);
         | 
| 81 86 |  | 
| 82 | 
            -
             | 
| 83 | 
            -
            smalltalk.addClass('ConsoleTranscript', smalltalk.Object, ['textarea'], 'Kernel-Transcript');
         | 
| 84 87 | 
             
            smalltalk.addMethod(
         | 
| 85 | 
            -
             | 
| 88 | 
            +
            "_current",
         | 
| 86 89 | 
             
            smalltalk.method({
         | 
| 87 | 
            -
            selector:  | 
| 90 | 
            +
            selector: "current",
         | 
| 88 91 | 
             
            fn: function (){
         | 
| 89 92 | 
             
            var self=this;
         | 
| 90 | 
            -
             | 
| 93 | 
            +
            return self['@current'];
         | 
| 91 94 | 
             
            return self;}
         | 
| 92 95 | 
             
            }),
         | 
| 93 | 
            -
            smalltalk. | 
| 96 | 
            +
            smalltalk.Transcript.klass);
         | 
| 94 97 |  | 
| 95 98 | 
             
            smalltalk.addMethod(
         | 
| 96 | 
            -
             | 
| 99 | 
            +
            "_new",
         | 
| 97 100 | 
             
            smalltalk.method({
         | 
| 98 | 
            -
            selector:  | 
| 101 | 
            +
            selector: "new",
         | 
| 99 102 | 
             
            fn: function (){
         | 
| 100 103 | 
             
            var self=this;
         | 
| 101 | 
            -
             | 
| 104 | 
            +
            smalltalk.send(self, "_shouldNotImplement", []);
         | 
| 102 105 | 
             
            return self;}
         | 
| 103 106 | 
             
            }),
         | 
| 104 | 
            -
            smalltalk. | 
| 107 | 
            +
            smalltalk.Transcript.klass);
         | 
| 105 108 |  | 
| 106 109 | 
             
            smalltalk.addMethod(
         | 
| 107 | 
            -
             | 
| 110 | 
            +
            "_open",
         | 
| 108 111 | 
             
            smalltalk.method({
         | 
| 109 | 
            -
            selector:  | 
| 110 | 
            -
            fn: function ( | 
| 112 | 
            +
            selector: "open",
         | 
| 113 | 
            +
            fn: function (){
         | 
| 111 114 | 
             
            var self=this;
         | 
| 112 | 
            -
             | 
| 113 | 
            -
            (string=smalltalk.send(anObject, "_asString", []));
         | 
| 114 | 
            -
            console.log(String(string));
         | 
| 115 | 
            +
            smalltalk.send(smalltalk.send(self, "_current", []), "_open", []);
         | 
| 115 116 | 
             
            return self;}
         | 
| 116 117 | 
             
            }),
         | 
| 117 | 
            -
            smalltalk. | 
| 118 | 
            +
            smalltalk.Transcript.klass);
         | 
| 118 119 |  | 
| 119 120 | 
             
            smalltalk.addMethod(
         | 
| 120 | 
            -
             | 
| 121 | 
            +
            "_register_",
         | 
| 121 122 | 
             
            smalltalk.method({
         | 
| 122 | 
            -
            selector:  | 
| 123 | 
            -
            fn: function (){
         | 
| 123 | 
            +
            selector: "register:",
         | 
| 124 | 
            +
            fn: function (aTranscript){
         | 
| 124 125 | 
             
            var self=this;
         | 
| 125 | 
            -
             | 
| 126 | 
            +
            (self['@current']=aTranscript);
         | 
| 126 127 | 
             
            return self;}
         | 
| 127 128 | 
             
            }),
         | 
| 128 | 
            -
            smalltalk. | 
| 129 | 
            -
             | 
| 129 | 
            +
            smalltalk.Transcript.klass);
         | 
| 130 130 |  | 
| 131 131 | 
             
            smalltalk.addMethod(
         | 
| 132 | 
            -
             | 
| 132 | 
            +
            "_show_",
         | 
| 133 133 | 
             
            smalltalk.method({
         | 
| 134 | 
            -
            selector:  | 
| 135 | 
            -
            fn: function (){
         | 
| 134 | 
            +
            selector: "show:",
         | 
| 135 | 
            +
            fn: function (anObject){
         | 
| 136 136 | 
             
            var self=this;
         | 
| 137 | 
            -
            smalltalk.send( | 
| 137 | 
            +
            smalltalk.send(smalltalk.send(self, "_current", []), "_show_", [anObject]);
         | 
| 138 138 | 
             
            return self;}
         | 
| 139 139 | 
             
            }),
         | 
| 140 | 
            -
            smalltalk. | 
| 140 | 
            +
            smalltalk.Transcript.klass);
         | 
| 141 141 |  | 
| 142 142 |  | 
| @@ -1,202 +1,202 @@ | |
| 1 1 | 
             
            smalltalk.addPackage('Kernel-Transcript', {});
         | 
| 2 | 
            -
            smalltalk.addClass(' | 
| 3 | 
            -
             | 
| 4 | 
            -
            smalltalk.Transcript.klass.iVarNames = ['current'];
         | 
| 2 | 
            +
            smalltalk.addClass('ConsoleTranscript', smalltalk.Object, ['textarea'], 'Kernel-Transcript');
         | 
| 5 3 | 
             
            smalltalk.addMethod(
         | 
| 6 | 
            -
             | 
| 4 | 
            +
            "_clear",
         | 
| 7 5 | 
             
            smalltalk.method({
         | 
| 8 | 
            -
            selector:  | 
| 9 | 
            -
            category: ' | 
| 6 | 
            +
            selector: "clear",
         | 
| 7 | 
            +
            category: 'printing',
         | 
| 10 8 | 
             
            fn: function (){
         | 
| 11 9 | 
             
            var self=this;
         | 
| 12 | 
            -
             | 
| 10 | 
            +
             | 
| 13 11 | 
             
            return self;},
         | 
| 14 12 | 
             
            args: [],
         | 
| 15 | 
            -
            source:  | 
| 16 | 
            -
            messageSends: [ | 
| 13 | 
            +
            source: "clear\x0a\x09\x22no op\x22",
         | 
| 14 | 
            +
            messageSends: [],
         | 
| 17 15 | 
             
            referencedClasses: []
         | 
| 18 16 | 
             
            }),
         | 
| 19 | 
            -
            smalltalk. | 
| 17 | 
            +
            smalltalk.ConsoleTranscript);
         | 
| 20 18 |  | 
| 21 19 | 
             
            smalltalk.addMethod(
         | 
| 22 | 
            -
             | 
| 20 | 
            +
            "_cr",
         | 
| 23 21 | 
             
            smalltalk.method({
         | 
| 24 | 
            -
            selector:  | 
| 25 | 
            -
            category: ' | 
| 22 | 
            +
            selector: "cr",
         | 
| 23 | 
            +
            category: 'printing',
         | 
| 26 24 | 
             
            fn: function (){
         | 
| 27 25 | 
             
            var self=this;
         | 
| 28 | 
            -
             | 
| 26 | 
            +
             | 
| 29 27 | 
             
            return self;},
         | 
| 30 28 | 
             
            args: [],
         | 
| 31 | 
            -
            source:  | 
| 32 | 
            -
            messageSends: [ | 
| 29 | 
            +
            source: "cr\x0a\x09\x22no op\x22",
         | 
| 30 | 
            +
            messageSends: [],
         | 
| 33 31 | 
             
            referencedClasses: []
         | 
| 34 32 | 
             
            }),
         | 
| 35 | 
            -
            smalltalk. | 
| 33 | 
            +
            smalltalk.ConsoleTranscript);
         | 
| 36 34 |  | 
| 37 35 | 
             
            smalltalk.addMethod(
         | 
| 38 | 
            -
             | 
| 36 | 
            +
            "_open",
         | 
| 39 37 | 
             
            smalltalk.method({
         | 
| 40 | 
            -
            selector:  | 
| 41 | 
            -
            category: ' | 
| 38 | 
            +
            selector: "open",
         | 
| 39 | 
            +
            category: 'actions',
         | 
| 42 40 | 
             
            fn: function (){
         | 
| 43 41 | 
             
            var self=this;
         | 
| 44 | 
            -
             | 
| 42 | 
            +
             | 
| 45 43 | 
             
            return self;},
         | 
| 46 44 | 
             
            args: [],
         | 
| 47 | 
            -
            source:  | 
| 45 | 
            +
            source: "open",
         | 
| 48 46 | 
             
            messageSends: [],
         | 
| 49 47 | 
             
            referencedClasses: []
         | 
| 50 48 | 
             
            }),
         | 
| 51 | 
            -
            smalltalk. | 
| 49 | 
            +
            smalltalk.ConsoleTranscript);
         | 
| 52 50 |  | 
| 53 51 | 
             
            smalltalk.addMethod(
         | 
| 54 | 
            -
             | 
| 52 | 
            +
            "_show_",
         | 
| 55 53 | 
             
            smalltalk.method({
         | 
| 56 | 
            -
            selector:  | 
| 54 | 
            +
            selector: "show:",
         | 
| 57 55 | 
             
            category: 'printing',
         | 
| 58 56 | 
             
            fn: function (anObject){
         | 
| 59 57 | 
             
            var self=this;
         | 
| 60 | 
            -
             | 
| 58 | 
            +
            var string=nil;
         | 
| 59 | 
            +
            (string=smalltalk.send(anObject, "_asString", []));
         | 
| 60 | 
            +
            console.log(String(string));
         | 
| 61 61 | 
             
            return self;},
         | 
| 62 62 | 
             
            args: ["anObject"],
         | 
| 63 | 
            -
            source:  | 
| 64 | 
            -
            messageSends: [" | 
| 63 | 
            +
            source: "show: anObject\x0a\x09| string |\x0a\x09string := anObject asString.\x0a\x09<console.log(String(string))>",
         | 
| 64 | 
            +
            messageSends: ["asString"],
         | 
| 65 65 | 
             
            referencedClasses: []
         | 
| 66 66 | 
             
            }),
         | 
| 67 | 
            -
            smalltalk. | 
| 67 | 
            +
            smalltalk.ConsoleTranscript);
         | 
| 68 | 
            +
             | 
| 68 69 |  | 
| 69 70 | 
             
            smalltalk.addMethod(
         | 
| 70 | 
            -
             | 
| 71 | 
            +
            "_initialize",
         | 
| 71 72 | 
             
            smalltalk.method({
         | 
| 72 | 
            -
            selector:  | 
| 73 | 
            -
            category: ' | 
| 73 | 
            +
            selector: "initialize",
         | 
| 74 | 
            +
            category: 'initialization',
         | 
| 74 75 | 
             
            fn: function (){
         | 
| 75 76 | 
             
            var self=this;
         | 
| 76 | 
            -
            smalltalk.send(smalltalk. | 
| 77 | 
            +
            smalltalk.send((smalltalk.Transcript || Transcript), "_register_", [smalltalk.send(self, "_new", [])]);
         | 
| 77 78 | 
             
            return self;},
         | 
| 78 79 | 
             
            args: [],
         | 
| 79 | 
            -
            source:  | 
| 80 | 
            -
            messageSends: [" | 
| 81 | 
            -
            referencedClasses: [" | 
| 80 | 
            +
            source: "initialize\x0a\x09Transcript register: self new",
         | 
| 81 | 
            +
            messageSends: ["register:", "new"],
         | 
| 82 | 
            +
            referencedClasses: ["Transcript"]
         | 
| 82 83 | 
             
            }),
         | 
| 83 | 
            -
            smalltalk. | 
| 84 | 
            +
            smalltalk.ConsoleTranscript.klass);
         | 
| 85 | 
            +
             | 
| 86 | 
            +
             | 
| 87 | 
            +
            smalltalk.addClass('Transcript', smalltalk.Object, ['textarea'], 'Kernel-Transcript');
         | 
| 84 88 |  | 
| 89 | 
            +
            smalltalk.Transcript.klass.iVarNames = ['current'];
         | 
| 85 90 | 
             
            smalltalk.addMethod(
         | 
| 86 | 
            -
             | 
| 91 | 
            +
            "_clear",
         | 
| 87 92 | 
             
            smalltalk.method({
         | 
| 88 | 
            -
            selector:  | 
| 93 | 
            +
            selector: "clear",
         | 
| 89 94 | 
             
            category: 'printing',
         | 
| 90 95 | 
             
            fn: function (){
         | 
| 91 96 | 
             
            var self=this;
         | 
| 92 97 | 
             
            smalltalk.send(smalltalk.send(self, "_current", []), "_clear", []);
         | 
| 93 98 | 
             
            return self;},
         | 
| 94 99 | 
             
            args: [],
         | 
| 95 | 
            -
            source:  | 
| 100 | 
            +
            source: "clear\x0a    self current clear",
         | 
| 96 101 | 
             
            messageSends: ["clear", "current"],
         | 
| 97 102 | 
             
            referencedClasses: []
         | 
| 98 103 | 
             
            }),
         | 
| 99 104 | 
             
            smalltalk.Transcript.klass);
         | 
| 100 105 |  | 
| 101 106 | 
             
            smalltalk.addMethod(
         | 
| 102 | 
            -
             | 
| 107 | 
            +
            "_cr",
         | 
| 103 108 | 
             
            smalltalk.method({
         | 
| 104 | 
            -
            selector:  | 
| 105 | 
            -
            category: ' | 
| 106 | 
            -
            fn: function ( | 
| 109 | 
            +
            selector: "cr",
         | 
| 110 | 
            +
            category: 'printing',
         | 
| 111 | 
            +
            fn: function (){
         | 
| 107 112 | 
             
            var self=this;
         | 
| 108 | 
            -
            (self[ | 
| 113 | 
            +
            smalltalk.send(smalltalk.send(self, "_current", []), "_show_", [smalltalk.send((smalltalk.String || String), "_cr", [])]);
         | 
| 109 114 | 
             
            return self;},
         | 
| 110 | 
            -
            args: [ | 
| 111 | 
            -
            source:  | 
| 112 | 
            -
            messageSends: [],
         | 
| 113 | 
            -
            referencedClasses: []
         | 
| 115 | 
            +
            args: [],
         | 
| 116 | 
            +
            source: "cr\x0a    self current show: String cr",
         | 
| 117 | 
            +
            messageSends: ["show:", "current", "cr"],
         | 
| 118 | 
            +
            referencedClasses: ["String"]
         | 
| 114 119 | 
             
            }),
         | 
| 115 120 | 
             
            smalltalk.Transcript.klass);
         | 
| 116 121 |  | 
| 117 | 
            -
             | 
| 118 | 
            -
            smalltalk.addClass('ConsoleTranscript', smalltalk.Object, ['textarea'], 'Kernel-Transcript');
         | 
| 119 122 | 
             
            smalltalk.addMethod(
         | 
| 120 | 
            -
             | 
| 123 | 
            +
            "_current",
         | 
| 121 124 | 
             
            smalltalk.method({
         | 
| 122 | 
            -
            selector:  | 
| 123 | 
            -
            category: ' | 
| 125 | 
            +
            selector: "current",
         | 
| 126 | 
            +
            category: 'instance creation',
         | 
| 124 127 | 
             
            fn: function (){
         | 
| 125 128 | 
             
            var self=this;
         | 
| 126 | 
            -
             | 
| 129 | 
            +
            return self['@current'];
         | 
| 127 130 | 
             
            return self;},
         | 
| 128 131 | 
             
            args: [],
         | 
| 129 | 
            -
            source:  | 
| 132 | 
            +
            source: "current\x0a    ^current",
         | 
| 130 133 | 
             
            messageSends: [],
         | 
| 131 134 | 
             
            referencedClasses: []
         | 
| 132 135 | 
             
            }),
         | 
| 133 | 
            -
            smalltalk. | 
| 136 | 
            +
            smalltalk.Transcript.klass);
         | 
| 134 137 |  | 
| 135 138 | 
             
            smalltalk.addMethod(
         | 
| 136 | 
            -
             | 
| 139 | 
            +
            "_new",
         | 
| 137 140 | 
             
            smalltalk.method({
         | 
| 138 | 
            -
            selector:  | 
| 139 | 
            -
            category: ' | 
| 141 | 
            +
            selector: "new",
         | 
| 142 | 
            +
            category: 'instance creation',
         | 
| 140 143 | 
             
            fn: function (){
         | 
| 141 144 | 
             
            var self=this;
         | 
| 142 | 
            -
             | 
| 145 | 
            +
            smalltalk.send(self, "_shouldNotImplement", []);
         | 
| 143 146 | 
             
            return self;},
         | 
| 144 147 | 
             
            args: [],
         | 
| 145 | 
            -
            source:  | 
| 146 | 
            -
            messageSends: [],
         | 
| 148 | 
            +
            source: "new\x0a    self shouldNotImplement",
         | 
| 149 | 
            +
            messageSends: ["shouldNotImplement"],
         | 
| 147 150 | 
             
            referencedClasses: []
         | 
| 148 151 | 
             
            }),
         | 
| 149 | 
            -
            smalltalk. | 
| 152 | 
            +
            smalltalk.Transcript.klass);
         | 
| 150 153 |  | 
| 151 154 | 
             
            smalltalk.addMethod(
         | 
| 152 | 
            -
             | 
| 155 | 
            +
            "_open",
         | 
| 153 156 | 
             
            smalltalk.method({
         | 
| 154 | 
            -
            selector:  | 
| 155 | 
            -
            category: ' | 
| 156 | 
            -
            fn: function ( | 
| 157 | 
            +
            selector: "open",
         | 
| 158 | 
            +
            category: 'instance creation',
         | 
| 159 | 
            +
            fn: function (){
         | 
| 157 160 | 
             
            var self=this;
         | 
| 158 | 
            -
             | 
| 159 | 
            -
            (string=smalltalk.send(anObject, "_asString", []));
         | 
| 160 | 
            -
            console.log(String(string));
         | 
| 161 | 
            +
            smalltalk.send(smalltalk.send(self, "_current", []), "_open", []);
         | 
| 161 162 | 
             
            return self;},
         | 
| 162 | 
            -
            args: [ | 
| 163 | 
            -
            source:  | 
| 164 | 
            -
            messageSends: [" | 
| 163 | 
            +
            args: [],
         | 
| 164 | 
            +
            source: "open\x0a    self current open",
         | 
| 165 | 
            +
            messageSends: ["open", "current"],
         | 
| 165 166 | 
             
            referencedClasses: []
         | 
| 166 167 | 
             
            }),
         | 
| 167 | 
            -
            smalltalk. | 
| 168 | 
            +
            smalltalk.Transcript.klass);
         | 
| 168 169 |  | 
| 169 170 | 
             
            smalltalk.addMethod(
         | 
| 170 | 
            -
             | 
| 171 | 
            +
            "_register_",
         | 
| 171 172 | 
             
            smalltalk.method({
         | 
| 172 | 
            -
            selector:  | 
| 173 | 
            -
            category: ' | 
| 174 | 
            -
            fn: function (){
         | 
| 173 | 
            +
            selector: "register:",
         | 
| 174 | 
            +
            category: 'instance creation',
         | 
| 175 | 
            +
            fn: function (aTranscript){
         | 
| 175 176 | 
             
            var self=this;
         | 
| 176 | 
            -
             | 
| 177 | 
            +
            (self['@current']=aTranscript);
         | 
| 177 178 | 
             
            return self;},
         | 
| 178 | 
            -
            args: [],
         | 
| 179 | 
            -
            source:  | 
| 179 | 
            +
            args: ["aTranscript"],
         | 
| 180 | 
            +
            source: "register: aTranscript\x0a\x09current := aTranscript",
         | 
| 180 181 | 
             
            messageSends: [],
         | 
| 181 182 | 
             
            referencedClasses: []
         | 
| 182 183 | 
             
            }),
         | 
| 183 | 
            -
            smalltalk. | 
| 184 | 
            -
             | 
| 184 | 
            +
            smalltalk.Transcript.klass);
         | 
| 185 185 |  | 
| 186 186 | 
             
            smalltalk.addMethod(
         | 
| 187 | 
            -
             | 
| 187 | 
            +
            "_show_",
         | 
| 188 188 | 
             
            smalltalk.method({
         | 
| 189 | 
            -
            selector:  | 
| 190 | 
            -
            category: ' | 
| 191 | 
            -
            fn: function (){
         | 
| 189 | 
            +
            selector: "show:",
         | 
| 190 | 
            +
            category: 'printing',
         | 
| 191 | 
            +
            fn: function (anObject){
         | 
| 192 192 | 
             
            var self=this;
         | 
| 193 | 
            -
            smalltalk.send( | 
| 193 | 
            +
            smalltalk.send(smalltalk.send(self, "_current", []), "_show_", [anObject]);
         | 
| 194 194 | 
             
            return self;},
         | 
| 195 | 
            -
            args: [],
         | 
| 196 | 
            -
            source:  | 
| 197 | 
            -
            messageSends: [" | 
| 198 | 
            -
            referencedClasses: [ | 
| 195 | 
            +
            args: ["anObject"],
         | 
| 196 | 
            +
            source: "show: anObject\x0a    self current show: anObject",
         | 
| 197 | 
            +
            messageSends: ["show:", "current"],
         | 
| 198 | 
            +
            referencedClasses: []
         | 
| 199 199 | 
             
            }),
         | 
| 200 | 
            -
            smalltalk. | 
| 200 | 
            +
            smalltalk.Transcript.klass);
         | 
| 201 201 |  | 
| 202 202 |  |