some long overdue Rackety: renaming the 'scheme:' exports of the framework to 'racket:'

original commit: 458e2c2282adca43aabe3d1e62957389d2fbe798

collects/embedded-gui/private/tests/test-case-box.rkt

@@ -161,7 +161,7 @@
   ;; a locked text hightlighted to show that it is inactive
   (define actual-text%
     (class (grey-editor-mixin
-            (text:hide-caret/selection-mixin scheme:text%))
+            (text:hide-caret/selection-mixin racket:text%))
       (inherit hide-caret lock)
       (super-new)
       (hide-caret true)

collects/framework/framework-unit.rkt

@@ -1,4 +1,4 @@
-#lang scheme/base
+#lang racket/base
 
 (require racket/unit
          mred/mred-sig)
@@ -27,7 +27,7 @@
          "private/canvas.rkt"
          "private/panel.rkt"
          "private/frame.rkt"
-         "private/scheme.rkt"
+         "private/racket.rkt"
          "private/main.rkt"
          "private/mode.rkt"
          "private/early-init.rkt")
@@ -60,14 +60,14 @@
           framework:panel^
           framework:frame^ 
           framework:handler^
-          framework:scheme^ 
+          framework:racket^ 
           framework:main^)
   (link
    preferences@ early-init@
    application@ version@ color-model@ mode@ exit@ menu@
    number-snip@ autosave@ path-utils@ icon@ keymap@
    editor@ pasteboard@ text@ color@ color-prefs@ comment-box@ 
-   finder@ group@ canvas@ panel@ frame@ handler@ scheme@ main@))
+   finder@ group@ canvas@ panel@ frame@ handler@ racket@ main@))
 
 (define-unit/new-import-export framework@ (import mred^) (export framework^)
   (((prefix application: framework:application^)
@@ -94,6 +94,6 @@
     (prefix panel: framework:panel^)
     (prefix frame: framework:frame^)
     (prefix handler: framework:handler^)
-    (prefix scheme: framework:scheme^)
+    (prefix racket: framework:racket^)
     (prefix main: framework:main^))
    framework-separate@ mred^))

collects/framework/main.rkt

@@ -8,7 +8,8 @@
          framework/framework-unit
          framework/private/sig
          (for-syntax scheme/base)
-         scribble/srcdoc) 
+         scribble/srcdoc
+         (for-syntax "private/scheme.rkt")) 
 
 ;; these next two lines do a little dance to make the
 ;; require/doc setup work out properly
@@ -54,7 +55,7 @@
  (prefix panel: framework:panel-class^)
  (prefix frame: framework:frame-class^)
  (prefix handler: framework:handler-class^)
- (prefix scheme: framework:scheme-class^)
+ (prefix racket: framework:racket-class^)
  (prefix main: framework:main-class^))
 
 (define-values/invoke-unit/infer
@@ -1376,7 +1377,7 @@
                    cover the eol ambiguity)}]})
  
  (proc-doc/names
-  scheme:text-balanced?
+  racket:text-balanced?
   (->* ((is-a?/c text%))
        (number? (or/c false/c number?))
        boolean?)
@@ -1395,78 +1396,78 @@
     range of the buffer.})
 
  (proc-doc/names
-  scheme:add-preferences-panel
+  racket:add-preferences-panel
   (-> void?)
   ()
   @{Adds a tabbing preferences panel to the preferences dialog.})
 
  (proc-doc/names
-  scheme:get-keymap
+  racket:get-keymap
   (-> (is-a?/c keymap%))
   ()
   @{Returns a keymap with binding suitable for Racket.})
 
  (proc-doc/names
-  scheme:add-coloring-preferences-panel
+  racket:add-coloring-preferences-panel
   (-> any)
   ()
   @{Installs the ``Racket'' preferences panel in the ``Syntax Coloring''
     section.})
 
  (proc-doc/names
-  scheme:get-color-prefs-table
+  racket:get-color-prefs-table
   (-> (listof (list/c symbol? (is-a?/c color%))))
   ()
   @{Returns a table mapping from symbols (naming the categories that the online
     colorer uses for Racket mode coloring) to their colors.
     
     These symbols are suitable for input to
-    @racket[scheme:short-sym->pref-name] and
+    @racket[racket:short-sym->pref-name] and
-    @racket[scheme:short-sym->style-name].
+    @racket[racket:short-sym->style-name].
     
-    See also @racket[scheme:get-white-on-black-color-prefs-table].})
+    See also @racket[racket:get-white-on-black-color-prefs-table].})
 
  (proc-doc/names
-  scheme:get-white-on-black-color-prefs-table
+  racket:get-white-on-black-color-prefs-table
   (-> (listof (list/c symbol? (is-a?/c color%))))
   ()
   @{Returns a table mapping from symbols (naming the categories that the online
     colorer uses for Racket mode coloring) to their colors when the user
     chooses the white-on-black mode in the preferences dialog.
     
-    See also @racket[scheme:get-color-prefs-table].})
+    See also @racket[racket:get-color-prefs-table].})
 
  (proc-doc/names
-  scheme:short-sym->pref-name
+  racket:short-sym->pref-name
   (symbol? . -> . symbol?)
   (short-sym)
   @{Builds the symbol naming the preference from one of the symbols in the
-    table returned by @racket[scheme:get-color-prefs-table].})
+    table returned by @racket[racket:get-color-prefs-table].})
 
  (proc-doc/names
-  scheme:short-sym->style-name
+  racket:short-sym->style-name
   (symbol? . -> . string?)
   (short-sym)
   @{Builds the symbol naming the editor style from one of the symbols in the
-    table returned by @racket[scheme:get-color-prefs-table].  This style is a
+    table returned by @racket[racket:get-color-prefs-table].  This style is a
     named style in the style list returned by
     @racket[editor:get-standard-style-list].})
 
  (proc-doc/names
-  scheme:get-wordbreak-map
+  racket:get-wordbreak-map
   (-> (is-a?/c editor-wordbreak-map%))
   ()
   @{This method returns a @racket[editor-wordbreak-map%] that is suitable for
     Racket.})
 
  (proc-doc/names
-  scheme:init-wordbreak-map
+  racket:init-wordbreak-map
   ((is-a?/c keymap%) . -> . void?)
   (key)
   @{Initializes the workdbreak map for @racket[keymap].})
 
  (proc-doc/names
-  scheme:setup-keymap
+  racket:setup-keymap
   ((is-a?/c keymap%) . -> . void?)
   (keymap)
   @{Initializes @racket[keymap] with Racket-mode keybindings.})
@@ -1716,3 +1717,11 @@
   ()
   @{Sets the colors registered by @racket[color-prefs:register-color-preference]
     to their black-on-white variety.}))
+
+(define-syntax (racket:-reprovides stx)
+  #`(provide
+     (rename-out #,@(for/list ([suffix (in-list racket:ids)])
+                      (define rkt (string->symbol (format "racket:~a" suffix)))
+                      (define scm (string->symbol (format "scheme:~a" suffix)))
+                      #`[#,rkt #,scm]))))
+(racket:-reprovides)

collects/framework/private/autosave.rkt

@@ -11,7 +11,7 @@
   (import mred^
           [prefix exit: framework:exit^]
           [prefix frame: framework:frame^]
-          [prefix scheme: framework:scheme^]
+          [prefix racket: framework:racket^]
           [prefix editor: framework:editor^]
           [prefix text: framework:text^]
           [prefix finder: framework:finder^]

collects/framework/private/color-prefs.rkt

@@ -9,7 +9,7 @@
           [prefix editor: framework:editor^]
           [prefix panel: framework:panel^]
           [prefix canvas: framework:canvas^]
-          [prefix scheme: framework:scheme^]
+          [prefix racket: framework:racket^]
           [prefix color: framework:color^])
   (export framework:color-prefs^)
   (init-depend framework:editor^)

collects/framework/private/color.rkt

@@ -20,7 +20,7 @@ added get-regions
         [prefix mode: framework:mode^]
         [prefix text: framework:text^]
         [prefix color-prefs: framework:color-prefs^]
-        [prefix scheme: framework:scheme^])
+        [prefix racket: framework:racket^])
 
 (export (rename framework:color^
                 (-text<%> text<%>)

collects/framework/private/comment-box.rkt

@@ -15,7 +15,7 @@
 (define-unit comment-box@
   
   (import [prefix text: framework:text^]
-          [prefix scheme: framework:scheme^]
+          [prefix racket: framework:racket^]
           [prefix keymap: framework:keymap^])
   (export (rename framework:comment-box^
                   (-snip% snip%)))
@@ -36,7 +36,7 @@
   (define (get-scheme+copy-self%)
     (unless scheme+copy-self%
       (set! scheme+copy-self%
-            (class scheme:text%
+            (class racket:text%
               (inherit copy-self-to)
               (define/override (copy-self)
                 (let ([ed (new scheme+copy-self%)])

collects/framework/private/frame.rkt

@@ -28,7 +28,7 @@
         [prefix editor: framework:editor^]
         [prefix canvas: framework:canvas^]
         [prefix menu: framework:menu^]
-        [prefix scheme: framework:scheme^]
+        [prefix racket: framework:racket^]
         [prefix exit: framework:exit^]
         [prefix comment-box: framework:comment-box^])
 

collects/framework/private/main.rkt

@@ -11,11 +11,11 @@
         [prefix handler: framework:handler^]
         [prefix editor: framework:editor^]
         [prefix color-prefs: framework:color-prefs^]
-        [prefix scheme: framework:scheme^]
+        [prefix racket: framework:racket^]
         [prefix early-init: framework:early-init^])
 (export framework:main^)
 (init-depend framework:preferences^ framework:exit^ framework:editor^
-             framework:color-prefs^ framework:scheme^ framework:early-init^)
+             framework:color-prefs^ framework:racket^ framework:early-init^)
 
 (preferences:low-level-get-preference preferences:get-preference/gui)
 (preferences:low-level-put-preferences preferences:put-preferences/gui)
@@ -344,12 +344,12 @@
                   [color (cadr line)]
                   [white-on-black-color (cadr white-on-black-line)])
               (color-prefs:register-color-preference
-               (scheme:short-sym->pref-name sym)
+               (racket:short-sym->pref-name sym)
-               (scheme:short-sym->style-name sym)
+               (racket:short-sym->style-name sym)
                color
                white-on-black-color)))
-          (scheme:get-color-prefs-table)
+          (racket:get-color-prefs-table)
-          (scheme:get-white-on-black-color-prefs-table))
+          (racket:get-white-on-black-color-prefs-table))
 (preferences:set-default 'framework:coloring-active #t boolean?)
 
 (color-prefs:set-default/color-scheme 'framework:default-text-color "black" "white")

collects/framework/private/sig.rkt

@@ -411,7 +411,7 @@
      white-on-black
      black-on-white))
   
-  (define-signature scheme-class^
+  (define-signature racket-class^
     (text<%>
      text-mixin
      text%
@@ -424,7 +424,7 @@
      
      sexp-snip%
      sexp-snip<%>))
-  (define-signature scheme^ extends scheme-class^
+  (define-signature racket^ extends racket-class^
     (get-wordbreak-map
      init-wordbreak-map
      get-keymap
@@ -487,5 +487,5 @@
      (open (prefix panel: panel^))
      (open (prefix frame: frame^))
      (open (prefix handler: handler^))
-     (open (prefix scheme: scheme^))
+     (open (prefix racket: racket^))
      (open (prefix main: main^))))

collects/framework/private/text.rkt

@@ -20,7 +20,7 @@
         [prefix keymap: framework:keymap^]
         [prefix color-model: framework:color-model^]
         [prefix frame: framework:frame^]
-        [prefix scheme: framework:scheme^]
+        [prefix racket: framework:racket^]
         [prefix number-snip: framework:number-snip^]
         [prefix finder: framework:finder^])
 (export (rename framework:text^
@@ -1564,7 +1564,7 @@
     (define/private (refresh-delegate/do-work)
       (send delegate begin-edit-sequence)
       (send delegate lock #f)
-      (when (is-a? this scheme:text<%>)
+      (when (is-a? this racket:text<%>)
         (send delegate set-tabs null (send this get-tab-size) #f))
       (send delegate hide-caret #t)
       (send delegate erase)

collects/scribblings/framework/comment-box.scrbl

@@ -10,7 +10,7 @@
 
   @defmethod*[#:mode override (((make-editor) (is-a?/c text%)))]{
     Makes an instance of
-    @racketblock[(scheme:text-mixin text:keymap%)]}
+    @racketblock[(racket:text-mixin text:keymap%)]}
 
   @defmethod*[#:mode override (((make-snip) (is-a?/c comment-snip%)))]{
     Returns an instance of the @racket[comment-snip%] class.}

collects/scribblings/framework/framework.scrbl

@@ -1,7 +1,8 @@
 #lang scribble/doc
 
-@(require (for-label framework framework/framework-unit framework/framework-sig racket/gui))
+@(require (for-label framework framework/framework-unit framework/framework-sig racket/gui)
-@(require scribble/manual)
+          (for-syntax framework/private/scheme racket/base)
+          scribble/manual)
 
 @title{Framework: Racket GUI Application Framework}
 @(defmodule framework)
@@ -103,12 +104,22 @@ the @secref["editor-snip"] section.
 @include-section["path-utils.scrbl"]
 @include-section["preferences.scrbl"]
 @include-section["preferences-text.scrbl"]
-@include-section["scheme.scrbl"]
+@include-section["racket.scrbl"]
 @include-section["text.scrbl"]
 @include-section["splash.scrbl"]
 @include-section["test.scrbl"]
 @include-section["version.scrbl"]
 
+@section{Backwards Compatibility}
+
+@(define-syntax (scheme:-docs stx)
+   #`(begin
+       #,@(for/list ([suffix (in-list racket:ids)])
+            (define scheme:id (string->symbol (format "scheme:~a" suffix)))
+            (define racket:id (string->symbol (format "racket:~a" suffix)))
+            #`@defidform[#,scheme:id]{An alias for @racket[#,racket:id].})))
+@(scheme:-docs)
+
 @section{Signatures}
 
 @defmodule[framework/framework-sig]

collects/scribblings/framework/racket.scrbl

@@ -4,19 +4,19 @@
 @(require (for-label scheme/gui))
 @title{Racket}
 
-@definterface[scheme:sexp-snip<%> ()]{
+@definterface[racket:sexp-snip<%> ()]{
   @defmethod*[(((get-saved-snips) (listof (is-a?/c snip%))))]{
     This returns the list of snips hidden by the sexp snip.
   }
 }
-@defclass[scheme:sexp-snip% snip% (scheme:sexp-snip<%> readable-snip<%>)]{
+@defclass[racket:sexp-snip% snip% (racket:sexp-snip<%> readable-snip<%>)]{
   @defmethod*[#:mode override
               (((get-text (offset number?) (num number?)
                           (flattened? boolean? #f))
                 string?))]{
     Returns the concatenation of the text for all of the hidden snips.
   }
-  @defmethod*[#:mode override (((copy) (is-a?/c scheme:sexp-snip%)))]{
+  @defmethod*[#:mode override (((copy) (is-a?/c racket:sexp-snip%)))]{
     Returns a copy of this snip that includes the hidden snips.
   }
   @defmethod*[#:mode override (((write (stream-out (is-a?/c editor-stream-out%))) void?))]{
@@ -41,7 +41,7 @@
     Returns a size corresponding to what this snip draws.
   }
 }
-@definterface[scheme:text<%> (text:basic<%> mode:host-text<%> color:text<%>)]{
+@definterface[racket:text<%> (text:basic<%> mode:host-text<%> color:text<%>)]{
   Texts matching this interface support Racket mode operations.
 
   @defmethod*[(((get-limit (start exact-integer?)) exact-integer?))]{
@@ -84,7 +84,7 @@
   }
 
   @defmethod*[(((insert-return) void?))]{
-    Inserts a newline into the buffer.  If @method[scheme:text<%>
+    Inserts a newline into the buffer.  If @method[racket:text<%>
     tabify-on-return?] returns @racket[#t], this will tabify the new line.
   }
 
@@ -209,7 +209,7 @@
 
   @defmethod*[(((get-tab-size) exact-integer?))]{
     This method returns the current size of the tabs for scheme mode.
-    See also @method[scheme:text<%> set-tab-size].
+    See also @method[racket:text<%> set-tab-size].
   }
 
   @defmethod*[(((set-tab-size (new-size exact-integer?)) void?))]{
@@ -226,9 +226,9 @@
     sexpression following the insertion point.
   }
 }
-@defmixin[scheme:text-mixin
+@defmixin[racket:text-mixin
           (text:basic<%> mode:host-text<%> color:text<%> text:autocomplete<%>)
-          (scheme:text<%>)]{
+          (racket:text<%>)]{
   This mixin adds functionality for editing Racket files.
 
   The result of this mixin uses the same initialization arguments as the
@@ -248,41 +248,41 @@
   }
 }
 
-@definterface[scheme:text-mode<%> ()]{
+@definterface[racket:text-mode<%> ()]{
-  The result of @racket[scheme:text-mode-mixin] implements this
+  The result of @racket[racket:text-mode-mixin] implements this
   interface.
 }
 
-@defmixin[scheme:text-mode-mixin
+@defmixin[racket:text-mode-mixin
           (color:text-mode<%> mode:surrogate-text<%>)
-          (scheme:text-mode<%>)]{
+          (racket:text-mode<%>)]{
   This mixin adds Racket mode functionality to the mode that it is mixed into.
   The resulting mode assumes that it is only set to an editor that is the
-  result of @racket[scheme:text-mixin].
+  result of @racket[racket:text-mixin].
 
   @defmethod*[#:mode override (((on-disable-surrogate) void?))]{
-    Removes the scheme keymap (see also @racket[scheme:get-keymap]) and
+    Removes the scheme keymap (see also @racket[racket:get-keymap]) and
     disables any parenthesis highlighting in the host editor.
   }
 
   @defmethod*[#:mode override (((on-enable-surrogate) void?))]{
-    Adds the scheme keymap (see also @racket[scheme:get-keymap]) and enables a
+    Adds the scheme keymap (see also @racket[racket:get-keymap]) and enables a
     parenthesis highlighting in the host editor.
   }
 }
 
-@defmixin[scheme:set-mode-mixin (scheme:text<%> mode:host-text<%>) ()]{
+@defmixin[racket:set-mode-mixin (racket:text<%> mode:host-text<%>) ()]{
-  This mixin creates a new instance of @racket[scheme:text-mode%] and installs
+  This mixin creates a new instance of @racket[racket:text-mode%] and installs
   it, by calling its own @method[mode:host-text<%> set-surrogate] method with
   the object.
 }
 
-@defclass[scheme:text%
+@defclass[racket:text%
-          (scheme:set-mode-mixin
+          (racket:set-mode-mixin
-           (scheme:text-mixin
+           (racket:text-mixin
             (text:autocomplete-mixin (mode:host-text-mixin color:text%))))
           ()]{}
 
-@defclass[scheme:text-mode% (scheme:text-mode-mixin color:text-mode%) ()]{}
+@defclass[racket:text-mode% (racket:text-mode-mixin color:text-mode%) ()]{}
 
-@(include-previously-extracted "main-extracts.rkt" #rx"^scheme:")
+@(include-previously-extracted "main-extracts.rkt" #rx"^racket:")

collects/scribblings/framework/text.scrbl

@@ -471,7 +471,7 @@
 
     When it is set, all of the snips are copied from this object to
     @racket[delegate]. Additionally, if this object implements
-    @racket[scheme:text<%>] the tab settings of @racket[delegate] are updated
+    @racket[racket:text<%>] the tab settings of @racket[delegate] are updated
     to match this objects.
   }
 }

collects/tests/framework/README

@@ -74,7 +74,7 @@ signal failures when there aren't any.
 
   | Tests the scheme: section
 
-  |# scheme.rkt #|
+  |# racket.rkt #|
 
 - panel tests:
 

collects/tests/framework/keys.rkt

@@ -137,7 +137,7 @@
                    (list (list (list #\[)))
                    (list (list (list #\[)))))
   
-  ;; the keybindings test cases applied to scheme:text% editors
+  ;; the keybindings test cases applied to racket:text% editors
   (define scheme-specs
     (list 
      (make-key-spec (make-buff-spec "(abc (def))" 4 4)
@@ -327,13 +327,13 @@
   (test-specs "global keybindings test" 'frame:text% global-specs)
   (test-specs "scheme mode keybindings test" 
               '(class frame:editor%
-                 (define/override (get-editor%) scheme:text%)
+                 (define/override (get-editor%) racket:text%)
                  (super-new))
               scheme-specs)
   (queue-sexp-to-mred `(preferences:set 'framework:automatic-parens #t))
   (queue-sexp-to-mred `(preferences:set 'framework:fixup-open-parens #f))
   (test-specs "scheme mode automatic-parens on keybindings test" 
               '(class frame:editor%
-                 (define/override (get-editor%) scheme:text%)
+                 (define/override (get-editor%) racket:text%)
                  (super-new))
               automatic-scheme-specs)

collects/tests/framework/mem.rkt

@@ -152,7 +152,7 @@
 (test-editor-allocate 'pasteboard:backup-autosave%)
 (test-editor-allocate 'pasteboard:info%)
 
-(test-editor-allocate 'scheme:text%)
+(test-editor-allocate 'racket:text%)
 
 (test-allocate "text:return%"
                '(lambda () (make-object text:return% void))

collects/tests/framework/racket.rkt

@@ -10,14 +10,14 @@
 
 (define (test-text-balanced? number str start end expected)
   (test
-   (string->symbol (format "scheme:text-balanced?-~a" number))
+   (string->symbol (format "racket:text-balanced?-~a" number))
    (lambda (x) 
      (equal? x expected))
    (λ ()
      (queue-sexp-to-mred
-      `(let ([t (new scheme:text%)])
+      `(let ([t (new racket:text%)])
          (send t insert ,str)
-         (scheme:text-balanced? t ,start ,end))))))
+         (racket:text-balanced? t ,start ,end))))))
 
 (test-text-balanced? 0 "" 0 #f #f)
 (test-text-balanced? 1 "  \n " 0 #f #f)
@@ -32,11 +32,11 @@
 
 (define (test-indentation which before after)
   (test
-   (string->symbol (format "scheme:test-indentation-~a" which))
+   (string->symbol (format "racket:test-indentation-~a" which))
    (λ (x) (equal? x after))
    (λ ()
      (queue-sexp-to-mred
-      `(let* ([t (new scheme:text%)]
+      `(let* ([t (new racket:text%)]
               [f (new frame% [label ""] [width 600] [height 600])]
               [ec (new editor-canvas% [parent f] [editor t])])
          (send f reflow-container)
@@ -57,16 +57,16 @@
 
 (define (test-magic-square-bracket which before after)
   (test
-   (string->symbol (format "scheme:test-magic-square-bracket-~a" which))
+   (string->symbol (format "racket:test-magic-square-bracket-~a" which))
    (λ (x) (equal? x after))
    (λ ()
      (queue-sexp-to-mred
-      `(let* ([t (new scheme:text%)]
+      `(let* ([t (new racket:text%)]
               [f (new frame% [label ""] [width 600] [height 600])]
               [ec (new editor-canvas% [parent f] [editor t])])
          (send f reflow-container)
          (send t insert ,before)
-         (send (scheme:get-keymap) call-function "maybe-insert-[]-pair-maybe-fixup-[]" t (new event%))
+         (send (racket:get-keymap) call-function "maybe-insert-[]-pair-maybe-fixup-[]" t (new event%))
          (send t get-text))))))
 
 (queue-sexp-to-mred `(preferences:set 'framework:automatic-parens #f))