The Trunk: ToolBuilder-Kernel-mt.125.mcz

Marcel Taeumel uploaded a new version of ToolBuilder-Kernel to project The Trunk:
http://source.squeak.org/trunk/ToolBuilder-Kernel-mt.125.mcz

==================== Summary ====================

Name: ToolBuilder-Kernel-mt.125
Author: mt
Time: 11 July 2019, 8:50:30.487838 am
UUID: 3f3a21f8-a141-734f-8aed-f0c21aff22b9
Ancestors: ToolBuilder-Kernel-mt.124

Updates the search for class names using the new find-features feature on strings. Find WeakIdentityKeyDictionary (in a small list of results) with any of the following patterns:

WKD
Weak*Dict*
WeakDict
WeakIdentityKeyDictionary

=============== Diff against ToolBuilder-Kernel-mt.124 ===============

Item was changed:
  ----- Method: UIManager>>classOrTraitFrom:pattern:label: (in category 'system introspecting') -----
  classOrTraitFrom: environment pattern: pattern label: label
+       "Given a pattern and an environment, try to find a class or trait using several strategies:
+               - EXACT: If there is a class or trait whose name exactly given by pattern, return it.
+               - UPPER: If the pattern is upper-case only, find camel-case letters with that sequence.
+               - WILD: Try the pattern as-is for regular wild-card search.
+               - FEATURE: Split patterns at feature boundaries and insert wild cards between.
+               - FUZZY: Split patterns at feature boundaries BUT treat each feature as a full class name.
+       If there is only one class or trait in the given environment whose name matches pattern, return it. Otherwise, put up a menu offering the names of all classes that match pattern, and return the class chosen, else nil if nothing chosen.
-       "If there is a class or trait whose name exactly given by pattern, return it.
-       If there is only one class or trait in the given environment whose name matches pattern, return it.
-       Otherwise, put up a menu offering the names of all classes that match pattern, and return the class chosen, else nil if nothing chosen.
-       This method ignores separator characters in the pattern"

+       !!!! In any case, separator characters in the pattern are ignored."
+       
+       | toMatch potentialNames names selectedIndex |
+       
+       "If there's a class or trait named as pattern, then return it."
+       (environment classOrTraitNamed: pattern) ifNotNil: [:classOrTrait | ^ classOrTrait].
+
+       "Validate pattern."     
-       | toMatch potentialNames names exactMatch lines reducedIdentifiers selectedIndex |
        toMatch := pattern copyWithoutAll: Character separators.
+       toMatch := toMatch asLowercase copyWithout: $..
        toMatch ifEmpty: [ ^nil ].
+
+       "Fetch search space."
+       names := OrderedCollection new.
+       potentialNames := environment classAndTraitNames asOrderedCollection.
+
+       "Try uppercase-only patterns for patterns such as 'WKD' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               (pattern allSatisfy: [:char | char isUppercase]) ifTrue: [
+                       potentialNames do: [:each |
+                               | patternStream |
+                               patternStream := pattern readStream.<—-[ [_]— you don’t

+                               each detect: [:char |
+                                       (patternStream atEnd not and: [patternStream peek = char])
+                                               ifTrue: [
+                                                       patternStream next.
+                                                       patternStream atEnd
+                                                               ifTrue: [names add: each. true "Match!!"]
+                                                               ifFalse: [false "Not yet..."]]
+                                               ifFalse: [false "No match..."] ] ifNone: [] ] ]].

+
+       "Try wildcard search for patterns such as 'Weak*Dict*' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               names := potentialNames select: [ :each | toMatch match: each ]].
-       "If there's a class or trait named as pattern, then return it."
-       Symbol hasInterned: pattern ifTrue: [ :symbol |
-               environment at: symbol ifPresent: [ :maybeClassOrTrait |
-                       ((maybeClassOrTrait isKindOf: Class) or: [
-                               maybeClassOrTrait isTrait ])
-                                       ifTrue: [ ^maybeClassOrTrait ] ] ].
-       "No exact match, look for potential matches."
-       toMatch := pattern asLowercase copyWithout: $..
-       potentialNames := (environment classAndTraitNames) asOrderedCollection.
-       names := pattern last = $. "This is some old hack, using String>>#match: may be better."
-               ifTrue: [ potentialNames select: [ :each | each asLowercase = toMatch ] ]
-               ifFalse: [
-                       potentialNames select: [ :each |
-                               each includesSubstring: toMatch caseSensitive: false ] ].
-       exactMatch := names detect: [ :each | each asLowercase = toMatch ] ifNone: [ nil ].
-       lines := OrderedCollection new.
-       exactMatch ifNotNil: [ lines add: 1 ].
-       "Also try some fuzzy matching."
-       reducedIdentifiers := pattern suggestedTypeNames select: [ :each |
-               potentialNames includes: each ].
-       reducedIdentifiers ifNotEmpty: [
-               names addAll: reducedIdentifiers.
-               lines add: 1 + names size + reducedIdentifiers size ].
-       "Let the user select if there's more than one possible match. This may give surprising results."
-       names size = 0 ifTrue: [^ nil "nothing matches"].

+       "Try feature-based search for patterns such as 'WeakDict' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               toMatch := pattern copyWithoutAll: '.*#'.
+               toMatch findFeatures in: [:features |
+                       "1) Insert wildcards between features and at the end."
+                       toMatch := (features joinSeparatedBy: '*'), '*'.
+                       names := potentialNames select: [ :each | toMatch match: each ].
+                       names ifEmpty: [       
+                               "2) Insert wildcards before, between, and after features."
+                               toMatch := '*', (features joinSeparatedBy: '*'), '*'.
+                               names := potentialNames select: [ :each | toMatch match: each ] ]] ].
+       
+       "Try some fuzzy matching."
+       names addAll: (pattern suggestedTypeNames select: [ :each | potentialNames includes: each ]).
+       
+       "Still no match?"
+       names ifEmpty: [ ^ nil ].
+
+       "Let the user select if there's more than one possible match. This may give surprising results."       
        selectedIndex := names size = 1
                ifTrue: [ 1 ]
+               ifFalse: [ self chooseFrom: names title: label ].
-               ifFalse: [
-                       exactMatch ifNotNil: [ names addFirst: exactMatch ].
-                       self chooseFrom: names lines: lines title: label ].
        selectedIndex = 0 ifTrue: [ ^nil ].
        ^environment at: (names at: selectedIndex) asSymbol!

On Mon, Jul 15, 2019 at 00:18 <[hidden email]> wrote:

Marcel Taeumel uploaded a new version of ToolBuilder-Kernel to project The Trunk:
http://source.squeak.org/trunk/ToolBuilder-Kernel-mt.125.mcz

==================== Summary ====================

Name: ToolBuilder-Kernel-mt.125
Author: mt
Time: 11 July 2019, 8:50:30.487838 am
UUID: 3f3a21f8-a141-734f-8aed-f0c21aff22b9
Ancestors: ToolBuilder-Kernel-mt.124

Updates the search for class names using the new find-features feature on strings. Find WeakIdentityKeyDictionary (in a small list of results) with any of the following patterns:

WKD
Weak*Dict*
WeakDict
WeakIdentityKeyDictionary

=============== Diff against ToolBuilder-Kernel-mt.124 ===============

Item was changed:
  ----- Method: UIManager>>classOrTraitFrom:pattern:label: (in category 'system introspecting') -----
  classOrTraitFrom: environment pattern: pattern label: label
+       "Given a pattern and an environment, try to find a class or trait using several strategies:
+               - EXACT: If there is a class or trait whose name exactly given by pattern, return it.
+               - UPPER: If the pattern is upper-case only, find camel-case letters with that sequence.
+               - WILD: Try the pattern as-is for regular wild-card search.
+               - FEATURE: Split patterns at feature boundaries and insert wild cards between.
+               - FUZZY: Split patterns at feature boundaries BUT treat each feature as a full class name.
+       If there is only one class or trait in the given environment whose name matches pattern, return it. Otherwise, put up a menu offering the names of all classes that match pattern, and return the class chosen, else nil if nothing chosen.
-       "If there is a class or trait whose name exactly given by pattern, return it.
-       If there is only one class or trait in the given environment whose name matches pattern, return it.
-       Otherwise, put up a menu offering the names of all classes that match pattern, and return the class chosen, else nil if nothing chosen.
-       This method ignores separator characters in the pattern"

+       !!!! In any case, separator characters in the pattern are ignored."
+       
+       | toMatch potentialNames names selectedIndex |
+       
+       "If there's a class or trait named as pattern, then return it."
+       (environment classOrTraitNamed: pattern) ifNotNil: [:classOrTrait | ^ classOrTrait].
+
+       "Validate pattern."     
-       | toMatch potentialNames names exactMatch lines reducedIdentifiers selectedIndex |
        toMatch := pattern copyWithoutAll: Character separators.
+       toMatch := toMatch asLowercase copyWithout: $..
        toMatch ifEmpty: [ ^nil ].
+
+       "Fetch search space."
+       names := OrderedCollection new.
+       potentialNames := environment classAndTraitNames asOrderedCollection.
+
+       "Try uppercase-only patterns for patterns such as 'WKD' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               (pattern allSatisfy: [:char | char isUppercase]) ifTrue: [
+                       potentialNames do: [:each |
+                               | patternStream |

+                               patternStream := pattern readStream.<—-[ [_]— you don’t

really need to recreate this same patternStream for each [ :each ... ] do you ? ]

+                               each detect: [:char |
+                                       (patternStream atEnd not and: [patternStream peek = char])
+                                               ifTrue: [
+                                                       patternStream next.
+                                                       patternStream atEnd
+                                                               ifTrue: [names add: each. true "Match!!"]
+                                                               ifFalse: [false "Not yet..."]]
+                                               ifFalse: [false "No match..."] ] ifNone: [] ] ]].

<——————-—-[ [_]— using KEGGenerators maybe it could be done like

 [ | last eNGen | 

 ( pattern asCharacters lastDo:[ :p | last := true . p ] )ifNotNil:[ :patternGen |

      potentialNames select:[ :eachName | last := false .

            ( patternGen shuffle:[ :p :c | (p=c)yourselfDo:[ :b | b ifTrue:[ eNGen next ] . last := b&&last ] ]

                                   with:( eNGen := eachName asGenerator )

               ) iterate . last

            ]

      ]”<——-[ [x]— >>lastDo: evaluates its input on last element p of pattern 

                      [x]— >>shuffle:with: does (p=c)<=>( patternGen next ) i think

                      [x]— >>yourselfDo: returns its receiver r after doing( aBlock value:r )

                      [_]— String>>asCharacters = String>>asCharacter<—-[ is part

                               of the singular is plural idea of you don’t have to separate 

                               singular from plural with KEGGenerators just do( obj asGen ) ] ]”

] value .”<—-[ [_]— move local vars last & eNGen up and delete this >>value ]”

or 

 [ | last eNGen | 

 ( 

 ( pattern asCharacters lastDo:[ :p | last := true . p ] 

 ) shuffle:[ :p :c | (p=c)yourselfDo:[ :b | b ifTrue:[ eNGen next ]. last:=b&&last ] ] ]

    with:( eNGen := KEGGenerator streamGenerator ) 

 )ifNotNil:[ :shuffleGen |

      potentialNames select:[ :eachName | last := false . eNGen genOn:eacName . 

            shuffleGen iterate . last

            ]

      ]”<——-[ [_]— this actually does not reAllocate any ..Generator in the loop ]”

] value .”<—-[ untested . not looked up . unpublished >>genOn: = >>on: i think ]”

+
+       "Try wildcard search for patterns such as 'Weak*Dict*' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               names := potentialNames select: [ :each | toMatch match: each ]].
-       "If there's a class or trait named as pattern, then return it."
-       Symbol hasInterned: pattern ifTrue: [ :symbol |
-               environment at: symbol ifPresent: [ :maybeClassOrTrait |
-                       ((maybeClassOrTrait isKindOf: Class) or: [
-                               maybeClassOrTrait isTrait ])
-                                       ifTrue: [ ^maybeClassOrTrait ] ] ].
-       "No exact match, look for potential matches."
-       toMatch := pattern asLowercase copyWithout: $..
-       potentialNames := (environment classAndTraitNames) asOrderedCollection.
-       names := pattern last = $. "This is some old hack, using String>>#match: may be better."
-               ifTrue: [ potentialNames select: [ :each | each asLowercase = toMatch ] ]
-               ifFalse: [
-                       potentialNames select: [ :each |
-                               each includesSubstring: toMatch caseSensitive: false ] ].
-       exactMatch := names detect: [ :each | each asLowercase = toMatch ] ifNone: [ nil ].
-       lines := OrderedCollection new.
-       exactMatch ifNotNil: [ lines add: 1 ].
-       "Also try some fuzzy matching."
-       reducedIdentifiers := pattern suggestedTypeNames select: [ :each |
-               potentialNames includes: each ].
-       reducedIdentifiers ifNotEmpty: [
-               names addAll: reducedIdentifiers.
-               lines add: 1 + names size + reducedIdentifiers size ].
-       "Let the user select if there's more than one possible match. This may give surprising results."
-       names size = 0 ifTrue: [^ nil "nothing matches"].

+       "Try feature-based search for patterns such as 'WeakDict' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               toMatch := pattern copyWithoutAll: '.*#'.
+               toMatch findFeatures in: [:features |
+                       "1) Insert wildcards between features and at the end."
+                       toMatch := (features joinSeparatedBy: '*'), '*'.
+                       names := potentialNames select: [ :each | toMatch match: each ].
+                       names ifEmpty: [       
+                               "2) Insert wildcards before, between, and after features."
+                               toMatch := '*', (features joinSeparatedBy: '*'), '*'.
+                               names := potentialNames select: [ :each | toMatch match: each ] ]] ].
+       
+       "Try some fuzzy matching."
+       names addAll: (pattern suggestedTypeNames select: [ :each | potentialNames includes: each ]).
+       
+       "Still no match?"
+       names ifEmpty: [ ^ nil ].
+
+       "Let the user select if there's more than one possible match. This may give surprising results."       
        selectedIndex := names size = 1
                ifTrue: [ 1 ]
+               ifFalse: [ self chooseFrom: names title: label ].
-               ifFalse: [
-                       exactMatch ifNotNil: [ names addFirst: exactMatch ].
-                       self chooseFrom: names lines: lines title: label ].
        selectedIndex = 0 ifTrue: [ ^nil ].
        ^environment at: (names at: selectedIndex) asSymbol!

[_]— or how about 

 

potentialNames select:[ :eachName | | first stillAMatch | first := stillAMatch := true .

  ( ( pattern inject:( 1 )into:[ :i :p | 

     stillAMatch ifTrue:[

       ( eachName indexOfSubCollection:( p asString )startingAt: i 

        )yourselfAfter:[ :i1 | stillAMatch := first ifTrue:[i = i1]ifFalse:[i<i1] . first := false ] 

       ifFalse:[ 0 ] ] 

    ) ~= 0 

    ) && stillAMatch

   ]

On Mon, Jul 15, 2019 at 06:55 Kjell Godo <[hidden email]> wrote:

On Mon, Jul 15, 2019 at 00:18 <[hidden email]> wrote:

Marcel Taeumel uploaded a new version of ToolBuilder-Kernel to project The Trunk:
http://source.squeak.org/trunk/ToolBuilder-Kernel-mt.125.mcz

==================== Summary ====================

Name: ToolBuilder-Kernel-mt.125
Author: mt
Time: 11 July 2019, 8:50:30.487838 am
UUID: 3f3a21f8-a141-734f-8aed-f0c21aff22b9
Ancestors: ToolBuilder-Kernel-mt.124

Updates the search for class names using the new find-features feature on strings. Find WeakIdentityKeyDictionary (in a small list of results) with any of the following patterns:

WKD
Weak*Dict*
WeakDict
WeakIdentityKeyDictionary

=============== Diff against ToolBuilder-Kernel-mt.124 ===============

Item was changed:
  ----- Method: UIManager>>classOrTraitFrom:pattern:label: (in category 'system introspecting') -----
  classOrTraitFrom: environment pattern: pattern label: label
+       "Given a pattern and an environment, try to find a class or trait using several strategies:
+               - EXACT: If there is a class or trait whose name exactly given by pattern, return it.
+               - UPPER: If the pattern is upper-case only, find camel-case letters with that sequence.
+               - WILD: Try the pattern as-is for regular wild-card search.
+               - FEATURE: Split patterns at feature boundaries and insert wild cards between.
+               - FUZZY: Split patterns at feature boundaries BUT treat each feature as a full class name.
+       If there is only one class or trait in the given environment whose name matches pattern, return it. Otherwise, put up a menu offering the names of all classes that match pattern, and return the class chosen, else nil if nothing chosen.
-       "If there is a class or trait whose name exactly given by pattern, return it.
-       If there is only one class or trait in the given environment whose name matches pattern, return it.
-       Otherwise, put up a menu offering the names of all classes that match pattern, and return the class chosen, else nil if nothing chosen.
-       This method ignores separator characters in the pattern"

+       !!!! In any case, separator characters in the pattern are ignored."
+       
+       | toMatch potentialNames names selectedIndex |
+       
+       "If there's a class or trait named as pattern, then return it."
+       (environment classOrTraitNamed: pattern) ifNotNil: [:classOrTrait | ^ classOrTrait].
+
+       "Validate pattern."     
-       | toMatch potentialNames names exactMatch lines reducedIdentifiers selectedIndex |
        toMatch := pattern copyWithoutAll: Character separators.
+       toMatch := toMatch asLowercase copyWithout: $..
        toMatch ifEmpty: [ ^nil ].
+
+       "Fetch search space."
+       names := OrderedCollection new.
+       potentialNames := environment classAndTraitNames asOrderedCollection.
+
+       "Try uppercase-only patterns for patterns such as 'WKD' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               (pattern allSatisfy: [:char | char isUppercase]) ifTrue: [
+                       potentialNames do: [:each |
+                               | patternStream |

+                               patternStream := pattern readStream.<—-[ [_]— you don’t

really need to recreate this same patternStream for each [ :each ... ] do you ? ]

+                               each detect: [:char |
+                                       (patternStream atEnd not and: [patternStream peek = char])
+                                               ifTrue: [
+                                                       patternStream next.
+                                                       patternStream atEnd
+                                                               ifTrue: [names add: each. true "Match!!"]
+                                                               ifFalse: [false "Not yet..."]]
+                                               ifFalse: [false "No match..."] ] ifNone: [] ] ]].

<——————-—-[ [_]— using KEGGenerators maybe it could be done like

 [ | last eNGen | 

 ( pattern asCharacters lastDo:[ :p | last := true . p ] )ifNotNil:[ :patternGen |

      potentialNames select:[ :eachName | last := false .

            ( patternGen shuffle:[ :p :c | (p=c)yourselfDo:[ :b | b ifTrue:[ eNGen next ] . last := b&&last ] ]

                                   with:( eNGen := eachName asGenerator )

               ) iterate . last

            ]

      ]”<——-[ [x]— >>lastDo: evaluates its input on last element p of pattern 

                      [x]— >>shuffle:with: does (p=c)<=>( patternGen next ) i think

                      [x]— >>yourselfDo: returns its receiver r after doing( aBlock value:r )

                      [_]— String>>asCharacters = String>>asCharacter<—-[ is part

                               of the singular is plural idea of you don’t have to separate 

                               singular from plural with KEGGenerators just do( obj asGen ) ] ]”

] value .”<—-[ [_]— move local vars last & eNGen up and delete this >>value ]”

or 

 [ | last eNGen | 

 ( 

 ( pattern asCharacters lastDo:[ :p | last := true . p ] 

 ) shuffle:[ :p :c | (p=c)yourselfDo:[ :b | b ifTrue:[ eNGen next ]. last:=b&&last ] ] ]

    with:( eNGen := KEGGenerator streamGenerator ) 

 )ifNotNil:[ :shuffleGen |

      potentialNames select:[ :eachName | last := false . eNGen genOn:eacName . 

            shuffleGen iterate . last

            ]

      ]”<——-[ [_]— this actually does not reAllocate any ..Generator in the loop ]”

] value .”<—-[ untested . not looked up . unpublished >>genOn: = >>on: i think ]”

+
+       "Try wildcard search for patterns such as 'Weak*Dict*' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               names := potentialNames select: [ :each | toMatch match: each ]].
-       "If there's a class or trait named as pattern, then return it."
-       Symbol hasInterned: pattern ifTrue: [ :symbol |
-               environment at: symbol ifPresent: [ :maybeClassOrTrait |
-                       ((maybeClassOrTrait isKindOf: Class) or: [
-                               maybeClassOrTrait isTrait ])
-                                       ifTrue: [ ^maybeClassOrTrait ] ] ].
-       "No exact match, look for potential matches."
-       toMatch := pattern asLowercase copyWithout: $..
-       potentialNames := (environment classAndTraitNames) asOrderedCollection.
-       names := pattern last = $. "This is some old hack, using String>>#match: may be better."
-               ifTrue: [ potentialNames select: [ :each | each asLowercase = toMatch ] ]
-               ifFalse: [
-                       potentialNames select: [ :each |
-                               each includesSubstring: toMatch caseSensitive: false ] ].
-       exactMatch := names detect: [ :each | each asLowercase = toMatch ] ifNone: [ nil ].
-       lines := OrderedCollection new.
-       exactMatch ifNotNil: [ lines add: 1 ].
-       "Also try some fuzzy matching."
-       reducedIdentifiers := pattern suggestedTypeNames select: [ :each |
-               potentialNames includes: each ].
-       reducedIdentifiers ifNotEmpty: [
-               names addAll: reducedIdentifiers.
-               lines add: 1 + names size + reducedIdentifiers size ].
-       "Let the user select if there's more than one possible match. This may give surprising results."
-       names size = 0 ifTrue: [^ nil "nothing matches"].

+       "Try feature-based search for patterns such as 'WeakDict' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               toMatch := pattern copyWithoutAll: '.*#'.
+               toMatch findFeatures in: [:features |
+                       "1) Insert wildcards between features and at the end."
+                       toMatch := (features joinSeparatedBy: '*'), '*'.
+                       names := potentialNames select: [ :each | toMatch match: each ].
+                       names ifEmpty: [       
+                               "2) Insert wildcards before, between, and after features."
+                               toMatch := '*', (features joinSeparatedBy: '*'), '*'.
+                               names := potentialNames select: [ :each | toMatch match: each ] ]] ].
+       
+       "Try some fuzzy matching."
+       names addAll: (pattern suggestedTypeNames select: [ :each | potentialNames includes: each ]).
+       
+       "Still no match?"
+       names ifEmpty: [ ^ nil ].
+
+       "Let the user select if there's more than one possible match. This may give surprising results."       
        selectedIndex := names size = 1
                ifTrue: [ 1 ]
+               ifFalse: [ self chooseFrom: names title: label ].
-               ifFalse: [
-                       exactMatch ifNotNil: [ names addFirst: exactMatch ].
-                       self chooseFrom: names lines: lines title: label ].
        selectedIndex = 0 ifTrue: [ ^nil ].
        ^environment at: (names at: selectedIndex) asSymbol!

WHOOPS

[_]— or how about 

 

potentialNames select:[ :eachName | | first stillAMatch | first := stillAMatch := true .

  ( ( pattern inject:( 1 )into:[ :i :p | 

     stillAMatch ifTrue:[

       ( eachName indexOfSubCollection:( p asString )startingAt: i 

        )yourselfAfter:[ :i1 | stillAMatch := first ifTrue:[i = i1]ifFalse:[i<i1] . first := false ] 

       ifFalse:[ 0 ] ] 

    ) ~= 0 

    ) && stillAMatch

   ]

On Mon, Jul 15, 2019 at 07:59 Kjell Godo <[hidden email]> wrote:

[_]— or how about 

 

potentialNames select:[ :eachName | | first stillAMatch | first := stillAMatch := true .

  ( ( pattern inject:( 1 )into:[ :i :p | 

     stillAMatch ifTrue:[

       ( eachName indexOfSubCollection:( p asString )startingAt: i 

        )yourselfAfter:[ :i1 | stillAMatch := first ifTrue:[i = i1]ifFalse:[i<i1] . first := false ] 

       ifFalse:[ 0 ] ] 

    ) ~= 0 

    ) && stillAMatch

   ]

On Mon, Jul 15, 2019 at 06:55 Kjell Godo <[hidden email]> wrote:

On Mon, Jul 15, 2019 at 00:18 <[hidden email]> wrote:

Marcel Taeumel uploaded a new version of ToolBuilder-Kernel to project The Trunk:
http://source.squeak.org/trunk/ToolBuilder-Kernel-mt.125.mcz

==================== Summary ====================

Name: ToolBuilder-Kernel-mt.125
Author: mt
Time: 11 July 2019, 8:50:30.487838 am
UUID: 3f3a21f8-a141-734f-8aed-f0c21aff22b9
Ancestors: ToolBuilder-Kernel-mt.124

Updates the search for class names using the new find-features feature on strings. Find WeakIdentityKeyDictionary (in a small list of results) with any of the following patterns:

WKD
Weak*Dict*
WeakDict
WeakIdentityKeyDictionary

=============== Diff against ToolBuilder-Kernel-mt.124 ===============

Item was changed:
  ----- Method: UIManager>>classOrTraitFrom:pattern:label: (in category 'system introspecting') -----
  classOrTraitFrom: environment pattern: pattern label: label
+       "Given a pattern and an environment, try to find a class or trait using several strategies:
+               - EXACT: If there is a class or trait whose name exactly given by pattern, return it.
+               - UPPER: If the pattern is upper-case only, find camel-case letters with that sequence.
+               - WILD: Try the pattern as-is for regular wild-card search.
+               - FEATURE: Split patterns at feature boundaries and insert wild cards between.
+               - FUZZY: Split patterns at feature boundaries BUT treat each feature as a full class name.
+       If there is only one class or trait in the given environment whose name matches pattern, return it. Otherwise, put up a menu offering the names of all classes that match pattern, and return the class chosen, else nil if nothing chosen.
-       "If there is a class or trait whose name exactly given by pattern, return it.
-       If there is only one class or trait in the given environment whose name matches pattern, return it.
-       Otherwise, put up a menu offering the names of all classes that match pattern, and return the class chosen, else nil if nothing chosen.
-       This method ignores separator characters in the pattern"

+       !!!! In any case, separator characters in the pattern are ignored."
+       
+       | toMatch potentialNames names selectedIndex |
+       
+       "If there's a class or trait named as pattern, then return it."
+       (environment classOrTraitNamed: pattern) ifNotNil: [:classOrTrait | ^ classOrTrait].
+
+       "Validate pattern."     
-       | toMatch potentialNames names exactMatch lines reducedIdentifiers selectedIndex |
        toMatch := pattern copyWithoutAll: Character separators.
+       toMatch := toMatch asLowercase copyWithout: $..
        toMatch ifEmpty: [ ^nil ].
+
+       "Fetch search space."
+       names := OrderedCollection new.
+       potentialNames := environment classAndTraitNames asOrderedCollection.
+
+       "Try uppercase-only patterns for patterns such as 'WKD' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               (pattern allSatisfy: [:char | char isUppercase]) ifTrue: [
+                       potentialNames do: [:each |
+                               | patternStream |

+                               patternStream := pattern readStream.<—-[ [_]— you don’t

really need to recreate this same patternStream for each [ :each ... ] do you ? ]

+                               each detect: [:char |
+                                       (patternStream atEnd not and: [patternStream peek = char])
+                                               ifTrue: [
+                                                       patternStream next.
+                                                       patternStream atEnd
+                                                               ifTrue: [names add: each. true "Match!!"]
+                                                               ifFalse: [false "Not yet..."]]
+                                               ifFalse: [false "No match..."] ] ifNone: [] ] ]].

<——————-—-[ [_]— using KEGGenerators maybe it could be done like

 [ | last eNGen | 

 ( pattern asCharacters lastDo:[ :p | last := true . p ] )ifNotNil:[ :patternGen |

      potentialNames select:[ :eachName | last := false .

            ( patternGen shuffle:[ :p :c | (p=c)yourselfDo:[ :b | b ifTrue:[ eNGen next ] . last := b&&last ] ]

                                   with:( eNGen := eachName asGenerator )

               ) iterate . last

            ]

      ]”<——-[ [x]— >>lastDo: evaluates its input on last element p of pattern 

                      [x]— >>shuffle:with: does (p=c)<=>( patternGen next ) i think

                      [x]— >>yourselfDo: returns its receiver r after doing( aBlock value:r )

                      [_]— String>>asCharacters = String>>asCharacter<—-[ is part

                               of the singular is plural idea of you don’t have to separate 

                               singular from plural with KEGGenerators just do( obj asGen ) ] ]”

] value .”<—-[ [_]— move local vars last & eNGen up and delete this >>value ]”

or 

 [ | last eNGen | 

 ( 

 ( pattern asCharacters lastDo:[ :p | last := true . p ] 

 ) shuffle:[ :p :c | (p=c)yourselfDo:[ :b | b ifTrue:[ eNGen next ]. last:=b&&last ] ] ]

    with:( eNGen := KEGGenerator streamGenerator ) 

 )ifNotNil:[ :shuffleGen |

      potentialNames select:[ :eachName | last := false . eNGen genOn:eacName . 

            shuffleGen iterate . last

            ]

      ]”<——-[ [_]— this actually does not reAllocate any ..Generator in the loop ]”

] value .”<—-[ untested . not looked up . unpublished >>genOn: = >>on: i think ]”

+
+       "Try wildcard search for patterns such as 'Weak*Dict*' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               names := potentialNames select: [ :each | toMatch match: each ]].
-       "If there's a class or trait named as pattern, then return it."
-       Symbol hasInterned: pattern ifTrue: [ :symbol |
-               environment at: symbol ifPresent: [ :maybeClassOrTrait |
-                       ((maybeClassOrTrait isKindOf: Class) or: [
-                               maybeClassOrTrait isTrait ])
-                                       ifTrue: [ ^maybeClassOrTrait ] ] ].
-       "No exact match, look for potential matches."
-       toMatch := pattern asLowercase copyWithout: $..
-       potentialNames := (environment classAndTraitNames) asOrderedCollection.
-       names := pattern last = $. "This is some old hack, using String>>#match: may be better."
-               ifTrue: [ potentialNames select: [ :each | each asLowercase = toMatch ] ]
-               ifFalse: [
-                       potentialNames select: [ :each |
-                               each includesSubstring: toMatch caseSensitive: false ] ].
-       exactMatch := names detect: [ :each | each asLowercase = toMatch ] ifNone: [ nil ].
-       lines := OrderedCollection new.
-       exactMatch ifNotNil: [ lines add: 1 ].
-       "Also try some fuzzy matching."
-       reducedIdentifiers := pattern suggestedTypeNames select: [ :each |
-               potentialNames includes: each ].
-       reducedIdentifiers ifNotEmpty: [
-               names addAll: reducedIdentifiers.
-               lines add: 1 + names size + reducedIdentifiers size ].
-       "Let the user select if there's more than one possible match. This may give surprising results."
-       names size = 0 ifTrue: [^ nil "nothing matches"].

+       "Try feature-based search for patterns such as 'WeakDict' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               toMatch := pattern copyWithoutAll: '.*#'.
+               toMatch findFeatures in: [:features |
+                       "1) Insert wildcards between features and at the end."
+                       toMatch := (features joinSeparatedBy: '*'), '*'.
+                       names := potentialNames select: [ :each | toMatch match: each ].
+                       names ifEmpty: [       
+                               "2) Insert wildcards before, between, and after features."
+                               toMatch := '*', (features joinSeparatedBy: '*'), '*'.
+                               names := potentialNames select: [ :each | toMatch match: each ] ]] ].
+       
+       "Try some fuzzy matching."
+       names addAll: (pattern suggestedTypeNames select: [ :each | potentialNames includes: each ]).
+       
+       "Still no match?"
+       names ifEmpty: [ ^ nil ].
+
+       "Let the user select if there's more than one possible match. This may give surprising results."       
        selectedIndex := names size = 1
                ifTrue: [ 1 ]
+               ifFalse: [ self chooseFrom: names title: label ].
-               ifFalse: [
-                       exactMatch ifNotNil: [ names addFirst: exactMatch ].
-                       self chooseFrom: names lines: lines title: label ].
        selectedIndex = 0 ifTrue: [ ^nil ].
        ^environment at: (names at: selectedIndex) asSymbol!

Hi Kjell,

thanks for your suggestions. This algorithm is bound to what support is there in the Trunk image. So KEGGenerators is no option here.

Your alternative looks like this for Squeak:

potentialNames select: [:eachName | | first stillAMatch |

first := true.

stillAMatch := true.

((pattern inject: 1 into: [:i :char | 

stillAMatch

ifTrue: [

(eachName findString: char asString startingAt: i)

in: [:i1 |

stillAMatch := (first ifTrue: [i = i1] ifFalse: [i < i1]).

first := false];

yourself] 

ifFalse: [0]] ) > 0) & stillAMatch ] 

For 'WKD' as input, it takes 695 microseconds to find the results. The current version (after the re-used stream), takes 1670 microseconds to find the results.

Maybe we can also get rid of that "char asString" ? Or is that optimized?

Best,

Marcel

Am 15.07.2019 17:08:54 schrieb Kjell Godo <[hidden email]>:

WHOOPS

[_]— or how about 

 

potentialNames select:[ :eachName | | first stillAMatch | first := stillAMatch := true  . [

  ( ( pattern inject:( 1 )into:[ :i :p | 

     stillAMatch ifTrue:[

       ( eachName indexOfSubCollection:( p asString )startingAt: i 

        )yourselfAfter:[ :i1 | stillAMatch := first ifTrue:[i = i1]ifFalse:[i<i1] . first := false ] 

       ifFalse:[ 0 ] ] 

    ) ~= 0 

    ) && stillAMatch

  ]on:Error do:[ :e | false ]

  ]

On Mon, Jul 15, 2019 at 08:03 Kjell Godo <[hidden email]> wrote:

WHOOPS

[_]— or how about 

 

potentialNames select:[ :eachName | | first stillAMatch | first := stillAMatch := true .

  ( ( pattern inject:( 1 )into:[ :i :p | 

     stillAMatch ifTrue:[

       ( eachName indexOfSubCollection:( p asString )startingAt: i 

        )yourselfAfter:[ :i1 | stillAMatch := first ifTrue:[i = i1]ifFalse:[i<i1] . first := false ] 

       ifFalse:[ 0 ] ] 

    ) ~= 0 

    ) && stillAMatch

   ]

On Mon, Jul 15, 2019 at 07:59 Kjell Godo <[hidden email]> wrote:

[_]— or how about 

 

potentialNames select:[ :eachName | | first stillAMatch | first := stillAMatch := true .

  ( ( pattern inject:( 1 )into:[ :i :p | 

     stillAMatch ifTrue:[

       ( eachName indexOfSubCollection:( p asString )startingAt: i 

        )yourselfAfter:[ :i1 | stillAMatch := first ifTrue:[i = i1]ifFalse:[i<i1] . first := false ] 

       ifFalse:[ 0 ] ] 

    ) ~= 0 

    ) && stillAMatch

   ]

On Mon, Jul 15, 2019 at 06:55 Kjell Godo <[hidden email]> wrote:

On Mon, Jul 15, 2019 at 00:18 <[hidden email]> wrote:

Marcel Taeumel uploaded a new version of ToolBuilder-Kernel to project The Trunk:
http://source.squeak.org/trunk/ToolBuilder-Kernel-mt.125.mcz

==================== Summary ====================

Name: ToolBuilder-Kernel-mt.125
Author: mt
Time: 11 July 2019, 8:50:30.487838 am
UUID: 3f3a21f8-a141-734f-8aed-f0c21aff22b9
Ancestors: ToolBuilder-Kernel-mt.124

Updates the search for class names using the new find-features feature on strings. Find WeakIdentityKeyDictionary (in a small list of results) with any of the following patterns:

WKD
Weak*Dict*
WeakDict
WeakIdentityKeyDictionary

=============== Diff against ToolBuilder-Kernel-mt.124 ===============

Item was changed:
  ----- Method: UIManager>>classOrTraitFrom:pattern:label: (in category 'system introspecting') -----
  classOrTraitFrom: environment pattern: pattern label: label
+       "Given a pattern and an environment, try to find a class or trait using several strategies:
+               - EXACT: If there is a class or trait whose name exactly given by pattern, return it.
+               - UPPER: If the pattern is upper-case only, find camel-case letters with that sequence.
+               - WILD: Try the pattern as-is for regular wild-card search.
+               - FEATURE: Split patterns at feature boundaries and insert wild cards between.
+               - FUZZY: Split patterns at feature boundaries BUT treat each feature as a full class name.
+       If there is only one class or trait in the given environment whose name matches pattern, return it. Otherwise, put up a menu offering the names of all classes that match pattern, and return the class chosen, else nil if nothing chosen.
-       "If there is a class or trait whose name exactly given by pattern, return it.
-       If there is only one class or trait in the given environment whose name matches pattern, return it.
-       Otherwise, put up a menu offering the names of all classes that match pattern, and return the class chosen, else nil if nothing chosen.
-       This method ignores separator characters in the pattern"

+       !!!! In any case, separator characters in the pattern are ignored."
+       
+       | toMatch potentialNames names selectedIndex |
+       
+       "If there's a class or trait named as pattern, then return it."
+       (environment classOrTraitNamed: pattern) ifNotNil: [:classOrTrait | ^ classOrTrait].
+
+       "Validate pattern."     
-       | toMatch potentialNames names exactMatch lines reducedIdentifiers selectedIndex |
        toMatch := pattern copyWithoutAll: Character separators.
+       toMatch := toMatch asLowercase copyWithout: $..
        toMatch ifEmpty: [ ^nil ].
+
+       "Fetch search space."
+       names := OrderedCollection new.
+       potentialNames := environment classAndTraitNames asOrderedCollection.
+
+       "Try uppercase-only patterns for patterns such as 'WKD' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               (pattern allSatisfy: [:char | char isUppercase]) ifTrue: [
+                       potentialNames do: [:each |
+                               | patternStream |

+                               patternStream := pattern readStream.<—-[ [_]— you don’t

really need to recreate this same patternStream for each [ :each ... ] do you ? ]

+                               each detect: [:char |
+                                       (patternStream atEnd not and: [patternStream peek = char])
+                                               ifTrue: [
+                                                       patternStream next.
+                                                       patternStream atEnd
+                                                               ifTrue: [names add: each. true "Match!!"]
+                                                               ifFalse: [false "Not yet..."]]
+                                               ifFalse: [false "No match..."] ] ifNone: [] ] ]].

<——————-—-[ [_]— using KEGGenerators maybe it could be done like

 [ | last eNGen | 

 ( pattern asCharacters lastDo:[ :p | last := true . p ] )ifNotNil:[ :patternGen |

      potentialNames select:[ :eachName | last := false .

            ( patternGen shuffle:[ :p :c | (p=c)yourselfDo:[ :b | b ifTrue:[ eNGen next ] . last := b&&last ] ]

                                   with:( eNGen := eachName asGenerator )

               ) iterate . last

            ]

      ]”<——-[ [x]— >>lastDo: evaluates its input on last element p of pattern 

                      [x]— >>shuffle:with: does (p=c)<=>( patternGen next ) i think

                      [x]— >>yourselfDo: returns its receiver r after doing( aBlock value:r )

                      [_]— String>>asCharacters = String>>asCharacter<—-[ is part

                               of the singular is plural idea of you don’t have to separate 

                               singular from plural with KEGGenerators just do( obj asGen ) ] ]”

] value .”<—-[ [_]— move local vars last & eNGen up and delete this >>value ]”

or 

 [ | last eNGen | 

 ( 

 ( pattern asCharacters lastDo:[ :p | last := true . p ] 

 ) shuffle:[ :p :c | (p=c)yourselfDo:[ :b | b ifTrue:[ eNGen next ]. last:=b&&last ] ] ]

    with:( eNGen := KEGGenerator streamGenerator ) 

 )ifNotNil:[ :shuffleGen |

      potentialNames select:[ :eachName | last := false . eNGen genOn:eacName . 

            shuffleGen iterate . last

            ]

      ]”<——-[ [_]— this actually does not reAllocate any ..Generator in the loop ]”

] value .”<—-[ untested . not looked up . unpublished >>genOn: = >>on: i think ]”

+
+       "Try wildcard search for patterns such as 'Weak*Dict*' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               names := potentialNames select: [ :each | toMatch match: each ]].
-       "If there's a class or trait named as pattern, then return it."
-       Symbol hasInterned: pattern ifTrue: [ :symbol |
-               environment at: symbol ifPresent: [ :maybeClassOrTrait |
-                       ((maybeClassOrTrait isKindOf: Class) or: [
-                               maybeClassOrTrait isTrait ])
-                                       ifTrue: [ ^maybeClassOrTrait ] ] ].
-       "No exact match, look for potential matches."
-       toMatch := pattern asLowercase copyWithout: $..
-       potentialNames := (environment classAndTraitNames) asOrderedCollection.
-       names := pattern last = $. "This is some old hack, using String>>#match: may be better."
-               ifTrue: [ potentialNames select: [ :each | each asLowercase = toMatch ] ]
-               ifFalse: [
-                       potentialNames select: [ :each |
-                               each includesSubstring: toMatch caseSensitive: false ] ].
-       exactMatch := names detect: [ :each | each asLowercase = toMatch ] ifNone: [ nil ].
-       lines := OrderedCollection new.
-       exactMatch ifNotNil: [ lines add: 1 ].
-       "Also try some fuzzy matching."
-       reducedIdentifiers := pattern suggestedTypeNames select: [ :each |
-               potentialNames includes: each ].
-       reducedIdentifiers ifNotEmpty: [
-               names addAll: reducedIdentifiers.
-               lines add: 1 + names size + reducedIdentifiers size ].
-       "Let the user select if there's more than one possible match. This may give surprising results."
-       names size = 0 ifTrue: [^ nil "nothing matches"].

+       "Try feature-based search for patterns such as 'WeakDict' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               toMatch := pattern copyWithoutAll: '.*#'.
+               toMatch findFeatures in: [:features |
+                       "1) Insert wildcards between features and at the end."
+                       toMatch := (features joinSeparatedBy: '*'), '*'.
+                       names := potentialNames select: [ :each | toMatch match: each ].
+                       names ifEmpty: [       
+                               "2) Insert wildcards before, between, and after features."
+                               toMatch := '*', (features joinSeparatedBy: '*'), '*'.
+                               names := potentialNames select: [ :each | toMatch match: each ] ]] ].
+       
+       "Try some fuzzy matching."
+       names addAll: (pattern suggestedTypeNames select: [ :each | potentialNames includes: each ]).
+       
+       "Still no match?"
+       names ifEmpty: [ ^ nil ].
+
+       "Let the user select if there's more than one possible match. This may give surprising results."       
        selectedIndex := names size = 1
                ifTrue: [ 1 ]
+               ifFalse: [ self chooseFrom: names title: label ].
-               ifFalse: [
-                       exactMatch ifNotNil: [ names addFirst: exactMatch ].
-                       self chooseFrom: names lines: lines title: label ].
        selectedIndex = 0 ifTrue: [ ^nil ].
        ^environment at: (names at: selectedIndex) asSymbol!

[_]— how about 

No that won’t work won’t fulfill the specification

0 < ( ( eachName select:[ :c | c isUpperCase ] ) 

               indexOfSubCollection: pattern )

almost

On Mon, Jul 15, 2019 at 09:24 Marcel Taeumel <[hidden email]> wrote:

Hi Kjell,

thanks for your suggestions. This algorithm is bound to what support is there in the Trunk image. So KEGGenerators is no option here.

Your alternative looks like this for Squeak:

potentialNames select: [:eachName | | first stillAMatch |

first := true.

stillAMatch := true.

((pattern inject: 1 into: [:i :char | 

stillAMatch

ifTrue: [

(eachName findString: char asString startingAt: i)

in: [:i1 |

stillAMatch := (first ifTrue: [i = i1] ifFalse: [i < i1]).

first := false];

yourself] 

ifFalse: [0]] ) > 0) & stillAMatch ] 

For 'WKD' as input, it takes 695 microseconds to find the results. The current version (after the re-used stream), takes 1670 microseconds to find the results.

Maybe we can also get rid of that "char asString" ? Or is that optimized?

Best,

Marcel

Am 15.07.2019 17:08:54 schrieb Kjell Godo <[hidden email]>:

WHOOPS

[_]— or how about 

 

potentialNames select:[ :eachName | | first stillAMatch | first := stillAMatch := true  . [

  ( ( pattern inject:( 1 )into:[ :i :p | 

     stillAMatch ifTrue:[

       ( eachName indexOfSubCollection:( p asString )startingAt: i 

        )yourselfAfter:[ :i1 | stillAMatch := first ifTrue:[i = i1]ifFalse:[i<i1] . first := false ] 

       ifFalse:[ 0 ] ] 

    ) ~= 0 

    ) && stillAMatch

  ]on:Error do:[ :e | false ]

  ]

On Mon, Jul 15, 2019 at 08:03 Kjell Godo <[hidden email]> wrote:

WHOOPS

[_]— or how about 

 

potentialNames select:[ :eachName | | first stillAMatch | first := stillAMatch := true .

  ( ( pattern inject:( 1 )into:[ :i :p | 

     stillAMatch ifTrue:[

       ( eachName indexOfSubCollection:( p asString )startingAt: i 

        )yourselfAfter:[ :i1 | stillAMatch := first ifTrue:[i = i1]ifFalse:[i<i1] . first := false ] 

       ifFalse:[ 0 ] ] 

    ) ~= 0 

    ) && stillAMatch

   ]

On Mon, Jul 15, 2019 at 07:59 Kjell Godo <[hidden email]> wrote:

[_]— or how about 

 

potentialNames select:[ :eachName | | first stillAMatch | first := stillAMatch := true .

  ( ( pattern inject:( 1 )into:[ :i :p | 

     stillAMatch ifTrue:[

       ( eachName indexOfSubCollection:( p asString )startingAt: i 

        )yourselfAfter:[ :i1 | stillAMatch := first ifTrue:[i = i1]ifFalse:[i<i1] . first := false ] 

       ifFalse:[ 0 ] ] 

    ) ~= 0 

    ) && stillAMatch

   ]

On Mon, Jul 15, 2019 at 06:55 Kjell Godo <[hidden email]> wrote:

On Mon, Jul 15, 2019 at 00:18 <[hidden email]> wrote:

Marcel Taeumel uploaded a new version of ToolBuilder-Kernel to project The Trunk:
http://source.squeak.org/trunk/ToolBuilder-Kernel-mt.125.mcz

==================== Summary ====================

Name: ToolBuilder-Kernel-mt.125
Author: mt
Time: 11 July 2019, 8:50:30.487838 am
UUID: 3f3a21f8-a141-734f-8aed-f0c21aff22b9
Ancestors: ToolBuilder-Kernel-mt.124

Updates the search for class names using the new find-features feature on strings. Find WeakIdentityKeyDictionary (in a small list of results) with any of the following patterns:

WKD
Weak*Dict*
WeakDict
WeakIdentityKeyDictionary

=============== Diff against ToolBuilder-Kernel-mt.124 ===============

Item was changed:
  ----- Method: UIManager>>classOrTraitFrom:pattern:label: (in category 'system introspecting') -----
  classOrTraitFrom: environment pattern: pattern label: label
+       "Given a pattern and an environment, try to find a class or trait using several strategies:
+               - EXACT: If there is a class or trait whose name exactly given by pattern, return it.
+               - UPPER: If the pattern is upper-case only, find camel-case letters with that sequence.
+               - WILD: Try the pattern as-is for regular wild-card search.
+               - FEATURE: Split patterns at feature boundaries and insert wild cards between.
+               - FUZZY: Split patterns at feature boundaries BUT treat each feature as a full class name.
+       If there is only one class or trait in the given environment whose name matches pattern, return it. Otherwise, put up a menu offering the names of all classes that match pattern, and return the class chosen, else nil if nothing chosen.
-       "If there is a class or trait whose name exactly given by pattern, return it.
-       If there is only one class or trait in the given environment whose name matches pattern, return it.
-       Otherwise, put up a menu offering the names of all classes that match pattern, and return the class chosen, else nil if nothing chosen.
-       This method ignores separator characters in the pattern"

+       !!!! In any case, separator characters in the pattern are ignored."
+       
+       | toMatch potentialNames names selectedIndex |
+       
+       "If there's a class or trait named as pattern, then return it."
+       (environment classOrTraitNamed: pattern) ifNotNil: [:classOrTrait | ^ classOrTrait].
+
+       "Validate pattern."     
-       | toMatch potentialNames names exactMatch lines reducedIdentifiers selectedIndex |
        toMatch := pattern copyWithoutAll: Character separators.
+       toMatch := toMatch asLowercase copyWithout: $..
        toMatch ifEmpty: [ ^nil ].
+
+       "Fetch search space."
+       names := OrderedCollection new.
+       potentialNames := environment classAndTraitNames asOrderedCollection.
+
+       "Try uppercase-only patterns for patterns such as 'WKD' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               (pattern allSatisfy: [:char | char isUppercase]) ifTrue: [
+                       potentialNames do: [:each |
+                               | patternStream |

+                               patternStream := pattern readStream.<—-[ [_]— you don’t

really need to recreate this same patternStream for each [ :each ... ] do you ? ]

+                               each detect: [:char |
+                                       (patternStream atEnd not and: [patternStream peek = char])
+                                               ifTrue: [
+                                                       patternStream next.
+                                                       patternStream atEnd
+                                                               ifTrue: [names add: each. true "Match!!"]
+                                                               ifFalse: [false "Not yet..."]]
+                                               ifFalse: [false "No match..."] ] ifNone: [] ] ]].

<——————-—-[ [_]— using KEGGenerators maybe it could be done like

 [ | last eNGen | 

 ( pattern asCharacters lastDo:[ :p | last := true . p ] )ifNotNil:[ :patternGen |

      potentialNames select:[ :eachName | last := false .

            ( patternGen shuffle:[ :p :c | (p=c)yourselfDo:[ :b | b ifTrue:[ eNGen next ] . last := b&&last ] ]

                                   with:( eNGen := eachName asGenerator )

               ) iterate . last

            ]

      ]”<——-[ [x]— >>lastDo: evaluates its input on last element p of pattern 

                      [x]— >>shuffle:with: does (p=c)<=>( patternGen next ) i think

                      [x]— >>yourselfDo: returns its receiver r after doing( aBlock value:r )

                      [_]— String>>asCharacters = String>>asCharacter<—-[ is part

                               of the singular is plural idea of you don’t have to separate 

                               singular from plural with KEGGenerators just do( obj asGen ) ] ]”

] value .”<—-[ [_]— move local vars last & eNGen up and delete this >>value ]”

or 

 [ | last eNGen | 

 ( 

 ( pattern asCharacters lastDo:[ :p | last := true . p ] 

 ) shuffle:[ :p :c | (p=c)yourselfDo:[ :b | b ifTrue:[ eNGen next ]. last:=b&&last ] ] ]

    with:( eNGen := KEGGenerator streamGenerator ) 

 )ifNotNil:[ :shuffleGen |

      potentialNames select:[ :eachName | last := false . eNGen genOn:eacName . 

            shuffleGen iterate . last

            ]

      ]”<——-[ [_]— this actually does not reAllocate any ..Generator in the loop ]”

] value .”<—-[ untested . not looked up . unpublished >>genOn: = >>on: i think ]”

+
+       "Try wildcard search for patterns such as 'Weak*Dict*' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               names := potentialNames select: [ :each | toMatch match: each ]].
-       "If there's a class or trait named as pattern, then return it."
-       Symbol hasInterned: pattern ifTrue: [ :symbol |
-               environment at: symbol ifPresent: [ :maybeClassOrTrait |
-                       ((maybeClassOrTrait isKindOf: Class) or: [
-                               maybeClassOrTrait isTrait ])
-                                       ifTrue: [ ^maybeClassOrTrait ] ] ].
-       "No exact match, look for potential matches."
-       toMatch := pattern asLowercase copyWithout: $..
-       potentialNames := (environment classAndTraitNames) asOrderedCollection.
-       names := pattern last = $. "This is some old hack, using String>>#match: may be better."
-               ifTrue: [ potentialNames select: [ :each | each asLowercase = toMatch ] ]
-               ifFalse: [
-                       potentialNames select: [ :each |
-                               each includesSubstring: toMatch caseSensitive: false ] ].
-       exactMatch := names detect: [ :each | each asLowercase = toMatch ] ifNone: [ nil ].
-       lines := OrderedCollection new.
-       exactMatch ifNotNil: [ lines add: 1 ].
-       "Also try some fuzzy matching."
-       reducedIdentifiers := pattern suggestedTypeNames select: [ :each |
-               potentialNames includes: each ].
-       reducedIdentifiers ifNotEmpty: [
-               names addAll: reducedIdentifiers.
-               lines add: 1 + names size + reducedIdentifiers size ].
-       "Let the user select if there's more than one possible match. This may give surprising results."
-       names size = 0 ifTrue: [^ nil "nothing matches"].

+       "Try feature-based search for patterns such as 'WeakDict' to find 'WeakIdentityKeyDictionary' etc."
+       names ifEmpty: [
+               toMatch := pattern copyWithoutAll: '.*#'.
+               toMatch findFeatures in: [:features |
+                       "1) Insert wildcards between features and at the end."
+                       toMatch := (features joinSeparatedBy: '*'), '*'.
+                       names := potentialNames select: [ :each | toMatch match: each ].
+                       names ifEmpty: [       
+                               "2) Insert wildcards before, between, and after features."
+                               toMatch := '*', (features joinSeparatedBy: '*'), '*'.
+                               names := potentialNames select: [ :each | toMatch match: each ] ]] ].
+       
+       "Try some fuzzy matching."
+       names addAll: (pattern suggestedTypeNames select: [ :each | potentialNames includes: each ]).
+       
+       "Still no match?"
+       names ifEmpty: [ ^ nil ].
+
+       "Let the user select if there's more than one possible match. This may give surprising results."       
        selectedIndex := names size = 1
                ifTrue: [ 1 ]
+               ifFalse: [ self chooseFrom: names title: label ].
-               ifFalse: [
-                       exactMatch ifNotNil: [ names addFirst: exactMatch ].
-                       self chooseFrom: names lines: lines title: label ].
        selectedIndex = 0 ifTrue: [ ^nil ].
        ^environment at: (names at: selectedIndex) asSymbol!

I really like making the search tool more helpful; thnak you.

It reminds me that many (many...) years ago a colleague at ParcPlace did a quick 'soundex' search implementation. It was fairly simple and seemed to work quite well for those times when you don't know the exact speliiiing ov yur thngg. It might be an interesting avenue to wander down.

tim
--
tim Rowledge; [hidden email]; http://www.rowledge.org/tim
Strange OpCodes: CLOUT: Call Long-distance On Unused Telephone