Merge pull request Larcheveque#1 from mahugnon/master

update

.properties

@@ -0,0 +1,3 @@
+{
+	#format : #tonel
+}

.smalltalk.ston

@@ -0,0 +1,7 @@
+SmalltalkCISpec {
+  #loading : [
+    SCIMetacelloLoadSpec {
+      #baseline : 'SymbolResolver'
+    }
+  ]
+}

.travis.yml

@@ -0,0 +1,23 @@
+
+language: smalltalk
+sudo: false
+
+os:
+  - linux
+
+smalltalk:
+  - Pharo64-7.0
+  - Pharo64-8.0
+
+matrix:
+  fast_finish: true
+  allow_failures:
+    - smalltalk: Pharo64-7.0
+
+after_success:
+  - wget -c https://github.com/probonopd/uploadtool/raw/master/upload.sh
+  - bash upload.sh Pharo.image Pharo.changes
+
+branches:
+  except:
+    - /^(?i:continuous)$/

README.md

@@ -0,0 +1,12 @@
+# SymbolResolver
+
+
+You can download the project in your image by doing:
+
+```st
+Metacello new
+  baseline: 'SymbolResolver';
+  repository: 'github://moosetechnology/SymbolResolver';
+  onWarningLog;
+  load.
+```

src/BaselineOfSymbolResolver/BaselineOfSymbolResolver.class.st

@@ -7,5 +7,31 @@ Class {
 { #category : #baselines }
 BaselineOfSymbolResolver >> baseline: spec [
 	<baseline>
-	spec for: #common do: [ spec package: 'SymbolResolver' ]
+	spec
+		for: #common
+		do: [ spec
+				package: 'SymbolResolver';
+				package: 'SRResolvableTest'
+					with: [ spec requires: #('SymbolResolver') ] ].
+	spec
+		for: #WithoutMoose
+		do: [ self baselineOfFamix: spec.
+			spec
+				package: 'SymbolResolver'
+				with: [ spec requires: #('Famix') ] ]
+]
+
+{ #category : #baselines }
+BaselineOfSymbolResolver >> baselineOfFamix: spec [
+	spec
+    	baseline: 'Famix'
+    	with: [ spec repository: 'github://moosetechnology/Moose:development/src' ]
+]
+
+{ #category : #accessing }
+BaselineOfSymbolResolver >> customProjectAttributes [
+	self class environment
+		at: #MooseEntity
+		ifAbsent: [ ^ #(#WithoutMoose) ].
+	^ #()
 ]

src/SymbolResolver-Tests/SRReferencesSolverTest.class.st

@@ -44,11 +44,6 @@ SRReferencesSolverTest >> testCurrentEntity [
 	self assert: referencesSolver currentEntity equals: currentEntity.
 ]
 
-{ #category : #tests }
-SRReferencesSolverTest >> testDefineAliasInCurrentScopeFor [
-	self fail
-]
-
 { #category : #tests }
 SRReferencesSolverTest >> testEnsureScopesAreCopied [
 	| firstScope scopesFirstState secondScope scopesSecondState |
@@ -133,18 +128,3 @@ SRReferencesSolverTest >> testRemoveScope [
 	self assert: referencesSolver scopes first equals: scope3.
 	self assert: referencesSolver scopes allButFirst first equals: scope1
 ]
-
-{ #category : #tests }
-SRReferencesSolverTest >> testResolve [
-	self fail
-]
-
-{ #category : #tests }
-SRReferencesSolverTest >> testResolveInScope [
-	self fail
-]
-
-{ #category : #tests }
-SRReferencesSolverTest >> testTopScopeReachableEntities [
-	self fail
-]

src/SymbolResolver-Tests/SRResolvableTest.class.st

@@ -0,0 +1,65 @@
+Class {
+	#name : #SRResolvableTest,
+	#superclass : #TestCase,
+	#instVars : [
+		'scope',
+		'variable1',
+		'variable2',
+		'variable3'
+	],
+	#category : #'SymbolResolver-Tests'
+}
+
+{ #category : #running }
+SRResolvableTest >> setUp [
+	variable1 := FamixTest2Class  new
+		name: 'aVariable1';
+		yourself.
+	variable2 := FamixTest2Class new
+		name: 'aVariable2';
+		yourself.
+	variable3 := FamixTest2Class new
+		name: 'aVariable3';
+		yourself.
+	scope := SRCollectionScope new.
+	scope
+		reachableEntitiesOwned:
+			{variable1.
+			variable2.
+			variable3}
+]
+
+{ #category : #tests }
+SRResolvableTest >> testResolveConsiderCase [
+	| resolver |
+	resolver := (SRIdentifierWithNode identifier: 'AVariable1' node: nil)
+		isCaseSensitive: true;
+		foundAction: [ :identifier :currentEntity |  ];
+		yourself.
+	self
+		should: [ resolver resolveInScope: scope currentEntity: nil ]
+		raise: NotFound
+]
+
+{ #category : #tests }
+SRResolvableTest >> testResolveIgnoreCase [
+	| resolver |
+	resolver := (SRIdentifierWithNode identifier: 'AVariable1' node: nil)
+		isCaseSensitive: false ;
+		foundAction: [ :identifier :currentEntity |  ];
+		yourself.
+	resolver resolveInScope: scope currentEntity: nil.
+	self assert: resolver entity equals: variable1
+]
+
+{ #category : #tests }
+SRResolvableTest >> testResolveSameCase [
+	| resolver |
+	resolver := (SRIdentifierWithNode identifier: 'aVariable1' node: nil)
+		isCaseSensitive: false ;
+		foundAction: [ :identifier :currentEntity | ];
+		yourself.
+
+	resolver resolveInScope: scope currentEntity: nil.
+	self assert: resolver entity equals: variable1
+]

src/SymbolResolver/SRCollectionScope.class.st

@@ -23,6 +23,6 @@ SRCollectionScope >> reachableEntitiesOwned [
 ]
 
 { #category : #accessing }
-SRCollectionScope >> reachableEntitiesOwned: anObject [
-	reachableEntitiesOwned := anObject
+SRCollectionScope >> reachableEntitiesOwned: aCollection [
+	reachableEntitiesOwned := aCollection 
 ]

src/SymbolResolver/SRFutureReferencesSolver.class.st

@@ -1,5 +1,5 @@
 "
-I am a reference solver that does not directly resolve stuff but store all the resolution it will have to do and then resolve everything when #resolveStoredCases is called
+I am a reference solver that does not directly resolve stuff but store all the resolution it will have to do and then resolve everything when #resolveUnresolvedReferences is called
 "
 Class {
 	#name : #SRFutureReferencesSolver,

src/SymbolResolver/SRIdentifierWithNode.class.st

@@ -34,7 +34,7 @@ SRIdentifierWithNode >> resolveInScope: aScope currentEntity: currentEntity [
 		entity:
 			(aScope
 				detect: [ :anEntity | 
-					anEntity name = self identifier
+					(self name: anEntity name isSameAs: self identifier)
 						and: [ self checkKindOfEntity: anEntity ] ]).
 	self triggerFoundActionWithCurrentEntity: currentEntity.
 	self isLast

src/SymbolResolver/SRInvocationWithNode.class.st

@@ -12,7 +12,7 @@ Class {
 }
 
 { #category : #'instance creation' }
-SRInvocationWithNode class >> identifier: anIdentifier node: aNode expectedKind: aKind arguments: aCollectionOfArguments [
+SRInvocationWithNode class >> identifier: anIdentifier expectedKind: aKind node: aNode arguments: aCollectionOfArguments [
 	^ (self identifier: anIdentifier node: aNode)
 		expectedKind: aKind;
 		arguments: aCollectionOfArguments;
@@ -64,7 +64,7 @@ SRInvocationWithNode >> resolveInScope: aScope currentEntity: currentEntity [
 		ifFalse: [ NotFound signal ].
 	^ (aScope
 		select: [ :anEntity | 
-			anEntity name = self identifier
+			(self name: anEntity name isSameAs: self identifier)
 				and: [ self checkKindOfEntity: anEntity ] ])
 		ifEmpty: [ NotFound signal ]
 		ifNotEmpty: [ :entities | 

src/SymbolResolver/SRReferencesSolver.class.st

@@ -5,7 +5,8 @@ Class {
 	#name : #SRReferencesSolver,
 	#superclass : #Object,
 	#instVars : [
-		'scopes'
+		'scopes',
+		'isCaseSensitive'
 	],
 	#category : #'SymbolResolver-Solver'
 }
@@ -41,7 +42,18 @@ SRReferencesSolver >> detect: aBlock [
 { #category : #initialization }
 SRReferencesSolver >> initialize [
 	super initialize.
-	self scopes: Stack new
+	self scopes: Stack new.
+	isCaseSensitive := true
+]
+
+{ #category : #accessing }
+SRReferencesSolver >> isCaseSensitive [
+	^ isCaseSensitive
+]
+
+{ #category : #accessing }
+SRReferencesSolver >> isCaseSensitive: anObject [
+	isCaseSensitive := anObject
 ]
 
 { #category : #accessing }
@@ -100,6 +112,13 @@ SRReferencesSolver >> removeScope: aPSQLScope [
 	self copyScopes remove: aPSQLScope
 ]
 
+{ #category : #factory }
+SRReferencesSolver >> resolvable: aResolvable [
+	^aResolvable
+		isCaseSensitive: self isCaseSensitive  ;
+		yourself
+]
+
 { #category : #resolution }
 SRReferencesSolver >> resolve: aChainOfIdentifiers [
 	"a collection of identifier will be for example {'myTable' . 'columnA'}"

src/SymbolResolver/SRResolvable.class.st

@@ -10,7 +10,8 @@ Class {
 		'next',
 		'expectedKind',
 		'foundAction',
-		'notFoundReplacementEntity'
+		'notFoundReplacementEntity',
+		'isCaseSensitive'
 	],
 	#category : #'SymbolResolver-Core'
 }
@@ -31,11 +32,11 @@ SRResolvable class >> identifier: aStringIdentifier node: aPSQLASTIdentifier [
 ]
 
 { #category : #'instance creation' }
-SRResolvable class >> identifier: aStringIdentifier node: aPSQLASTIdentifier next: aNextPSQIdentifierWithNode [
+SRResolvable class >> identifier: aString node: anIdentifier next: aNextIdentifierWithNode [
 	^ self new
-		identifier: aStringIdentifier;
-		node: aPSQLASTIdentifier;
-		next: aNextPSQIdentifierWithNode;
+		identifier: aString;
+		node: anIdentifier;
+		next: aNextIdentifierWithNode;
 		yourself
 ]
 
@@ -93,11 +94,34 @@ SRResolvable >> identifier: anObject [
 	identifier := anObject
 ]
 
+{ #category : #resolution }
+SRResolvable >> initialize [
+	super initialize.
+	isCaseSensitive := true
+]
+
+{ #category : #accessing }
+SRResolvable >> isCaseSensitive [
+	^ isCaseSensitive
+]
+
+{ #category : #accessing }
+SRResolvable >> isCaseSensitive: aBoolean [
+	isCaseSensitive := aBoolean
+]
+
 { #category : #testing }
 SRResolvable >> isLast [
 	^ self next isNil
 ]
 
+{ #category : #resolution }
+SRResolvable >> name: aString isSameAs: anotherString [
+	^ self isCaseSensitive
+		ifTrue: [ aString = anotherString ]
+		ifFalse: [ aString asLowercase = anotherString asLowercase ]
+]
+
 { #category : #accessing }
 SRResolvable >> next [
 	^ next

src/SymbolResolver/SRSolverUserVisitor.trait.st

@@ -81,7 +81,8 @@ SRSolverUserVisitor >> errorReport: anObject [
 
 { #category : #initialization }
 SRSolverUserVisitor >> initialiseFutureSolver [
-	solver := SRFutureReferencesSolver new
+	solver := SRFutureReferencesSolver new.
+	solver isCaseSensitive: false
 ]
 
 { #category : #initialization }
@@ -109,6 +110,11 @@ SRSolverUserVisitor >> pushEntityAsScope: anEntity [
 	self solver pushEntityAsScope: anEntity
 ]
 
+{ #category : #factory }
+SRSolverUserVisitor >> resolvable: aResolvable [
+	^ self solver resolvable: aResolvable
+]
+
 { #category : #resolution }
 SRSolverUserVisitor >> resolve: identifiers [
 	self solver resolve: identifiers