11496852352

Committed 24 Oct 2024 09:49AM UTC coverage: 58.319% (-0.6%) from 58.906%

Build # 11496852352

Build Type

Pull #92

github

Committed by

web-flow

Commit Message

Merge pull request #91 from moosetechnology/feature-merge-metamodel

Merge Extended and default metamodel

Pull Request Pull Request #92: Develop

Run Details

1334 of 2585 new or added lines in 64 files covered. (51.61%)

21 existing lines in 6 files now uncovered.

9446 of 16197 relevant lines covered (58.32%)

0.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.45

/src/GitProjectHealth-Model-Importer/GPModelImporter.class.st

"
I am a superclass for Model importer.
I am a try of normalization for the different importer.

I also define some contract so it is easier to switch from one importer to another
"
Class {
        #name : 'GPModelImporter',
        #superclass : 'Object',
        #instVars : [
                'withCommitsSince',
                'withFiles',
                'glhModel',
                'userCatalogue',
                'repoApi',
                'withCommitDiffs'
        ],
        #classVars : [
                'currentImporter'
        ],
        #category : 'GitProjectHealth-Model-Importer',
        #package : 'GitProjectHealth-Model-Importer'
}

{ #category : 'accessing - global variables' }
GPModelImporter class >> importers [
        ^ currentImporter 
]

{ #category : 'initialization' }
GPModelImporter class >> reset [
        currentImporter := OrderedDictionary new.
]

{ #category : 'accessing' }
GPModelImporter >> beWithFiles [

        withFiles := true
]

{ #category : 'accessing' }
GPModelImporter >> beWithoutFiles [

        withFiles := false
]

{ #category : 'as yet unclassified' }
GPModelImporter >> blockEqualityOn: aSymbol [
        ^ [ :existing :new |
          (existing perform: aSymbol) = (new perform: aSymbol) ]
]

{ #category : 'equality' }
GPModelImporter >> blockForDiffEquality [
        ^ [ :existing :new |
                        existing diffString size = new diffString size and: [
                                existing diffString = new diffString ] ]
]

{ #category : 'as yet unclassified' }
GPModelImporter >> blockForDiffRangeEquality [

        ^ [ :existing :new |
          existing diff mooseID = new diff mooseID and: [
                  existing originalLineRange = new originalLineRange and: [
                          existing newLineRange = new newLineRange ] ] ]
]

{ #category : 'equality' }
GPModelImporter >> blockOnIdEquality [

        ^ [ :existing :new |
          existing id = new id ]
]

{ #category : 'equality' }
GPModelImporter >> blockOnNameEquality [

        ^ self blockEqualityOn: #name
]

{ #category : 'commit' }
GPModelImporter >> chainsCommitsFrom: commitsCollection [

        | dic |
        ('Chains ' , commitsCollection size printString , ' commits')
                recordInfo.

        dic := ((self glhModel allWithType: GLHCommit) collect: [ :commit |
                        commit id -> commit ]) asSet asDictionary.

        commitsCollection do: [ :commit |
                commit parent_ids do: [ :parentId |
                        dic
                                at: parentId
                                ifPresent: [ :parentCommit |
                                        parentCommit childCommits
                                                add: commit
                                                unless: [ :existing :new | existing id = new id ] ]
                                ifAbsent: [  ] ] ].
        ^ commitsCollection
]

{ #category : 'commit' }
GPModelImporter >> completeImportedCommit: aGLHCommit [ 
        
        
        ('completing commit: ' , aGLHCommit short_id printString) recordInfo.
        self importCreatorOfCommit: aGLHCommit.

        self withCommitDiffs ifTrue: [
                | diffs |
                aGLHCommit diffs ifEmpty: [
                        diffs := self importDiffOfCommit: aGLHCommit.
                        self glhModel addAll: diffs unless: self blockForDiffEquality ] ].

        ^ aGLHCommit
]

{ #category : 'as yet unclassified' }
GPModelImporter >> filterCommitChanges: aCollection [

        ^ aCollection reject: [ :line |
                  | trimmedLine |
                  trimmedLine := line trimLeft.
                  (trimmedLine beginsWith: '---') or: [
                          (trimmedLine beginsWith: '+++') or: [
                                  trimmedLine beginsWith: '\ No newline at end of file' ] ] ]
]

{ #category : 'accessing' }
GPModelImporter >> glhModel [

        ^ glhModel
]

{ #category : 'accessing' }
GPModelImporter >> glhModel: anObject [

        glhModel := anObject
]

{ #category : 'import' }
GPModelImporter >> importDiffRangesForDiff: aGLHDiff [

        | diffRanges |
        aGLHDiff diffRanges ifNotEmpty: [
                ('Diffs already imported for ' , aGLHDiff printString) recordInfo.
                ^ aGLHDiff diffRanges ].

        ('Import changes of diff ' , aGLHDiff printString) recordInfo.
        "the import of 'diffRanges' entites is technically done inside the parseDiffString"

        diffRanges := self glhModel
                              addAll: (self parseDiffString: aGLHDiff)
                              unless: self blockForDiffRangeEquality.
        ^ aGLHDiff diffRanges
                  addAll: diffRanges
                  unless: self blockForDiffRangeEquality
]

{ #category : 'initialization' }
GPModelImporter >> initialize [

        super initialize.
        self withCommitsSince: (Date today - 1 week) asDateAndTime.
                userCatalogue := GLHUserCatalogueV2 new
                                 anImporter: self;
                                 yourself.
]

{ #category : 'as yet unclassified' }
GPModelImporter >> makeGlobal [
        ^ self makeGlobal: DateAndTime now printString.
]

{ #category : 'as yet unclassified' }
GPModelImporter >> makeGlobal: aLabel [ 

        currentImporter := GHModelImporter importers ifNil: [ OrderedDictionary new ].
        currentImporter at: aLabel put: self. 
        ^ currentImporter 
]

{ #category : 'parsing' }
GPModelImporter >> parseDiffString: aDiff [
        "parse diff string to create entities for each lines"

        | lines range index firstChangeRange |
        lines := aDiff diffString lines.
        index := 0.
        range := nil.

        lines ifEmpty: [ ^ aDiff diffRanges ].
        lines := self filterCommitChanges: lines.
        (lines first beginsWith: '@@') ifFalse: [ ^ aDiff diffRanges ].

        lines do: [ :line |
                | aChange |
                firstChangeRange := false.
                (line trim beginsWith: #'@@') ifTrue: [
                        range := GLHDiffRange newFrom: line.
                        firstChangeRange := true.
                        range := aDiff diffRanges add: range unless: [ :existing :new |
                                         existing originalLineRange = new originalLineRange and: [
                                                 existing newLineRange = new newLineRange ] ] ].

                self withCommitDiffs ifTrue: [
                        firstChangeRange ifFalse: [
                                aChange := GLHChange newFrom: line.
                                aChange relativeIndex: index.
                                aChange := range changes add: aChange unless: [ :existing :new |
                                                   existing sourceCode = new sourceCode and: [
                                                           existing index = new index ] ].
                                index := index + 1 ] ] ].

        "add changes to the diff range"
        aDiff diffRanges do: [ :diffRange |
                self glhModel addAll: diffRange changes unless: [ :existing :new |
                        existing diffRange mooseID = new diffRange mooseID and: [
                                existing sourceCode = new sourceCode and: [
                                        existing index = new index ] ] ] ].

        ^ aDiff diffRanges
]

{ #category : 'accessing' }
GPModelImporter >> repoApi [

        ^ repoApi
]

{ #category : 'accessing' }
GPModelImporter >> repoApi: anObject [

        repoApi := anObject
]

{ #category : 'accessing' }
GPModelImporter >> userCatalogue [
        ^ userCatalogue 
]

{ #category : 'accessing' }
GPModelImporter >> userCatalogue: aGLHUserCatalogue [

        userCatalogue := aGLHUserCatalogue.
        aGLHUserCatalogue anImporter: self. 
]

{ #category : 'accessing' }
GPModelImporter >> withCommitDiffs [

        ^ withCommitDiffs
]

{ #category : 'accessing' }
GPModelImporter >> withCommitDiffs: anObject [

        withCommitDiffs := anObject
]

{ #category : 'accessing' }
GPModelImporter >> withCommitsSince [

        ^ withCommitsSince
]

{ #category : 'accessing' }
GPModelImporter >> withCommitsSince: anObject [

        withCommitsSince := anObject
]

{ #category : 'accessing' }
GPModelImporter >> withFiles [

        ^ withFiles
]

{ #category : 'accessing' }
GPModelImporter >> withFiles: anObject [

        withFiles := anObject
]

1	"
2	I am a superclass for Model importer.
3	I am a try of normalization for the different importer.
4
5	I also define some contract so it is easier to switch from one importer to another
6	"
7	Class {
8	#name : 'GPModelImporter',
9	#superclass : 'Object',
10	#instVars : [
11	'withCommitsSince',
12	'withFiles',
13	'glhModel',
14	'userCatalogue',
15	'repoApi',
16	'withCommitDiffs'
17	],
18	#classVars : [
19	'currentImporter'
20	],
21	#category : 'GitProjectHealth-Model-Importer',
22	#package : 'GitProjectHealth-Model-Importer'
23	}
24
25	{ #category : 'accessing - global variables' }
26	GPModelImporter class >> importers [	×
27	^ currentImporter	×
28	]	×
29
30	{ #category : 'initialization' }
31	GPModelImporter class >> reset [	×
NEW 32	currentImporter := OrderedDictionary new.	×
33	]	×
34
35	{ #category : 'accessing' }
36	GPModelImporter >> beWithFiles [	×
37		×
38	withFiles := true	×
39	]	×
40
41	{ #category : 'accessing' }
42	GPModelImporter >> beWithoutFiles [	×
43		×
44	withFiles := false	×
45	]	×
46
47	{ #category : 'as yet unclassified' }
48	GPModelImporter >> blockEqualityOn: aSymbol [	1✔
49	^ [ :existing :new \|	1✔
50	(existing perform: aSymbol) = (new perform: aSymbol) ]	1✔
51	]	1✔
52
53	{ #category : 'equality' }
54	GPModelImporter >> blockForDiffEquality [	1✔
55	^ [ :existing :new \|	1✔
56	existing diffString size = new diffString size and: [	1✔
57	existing diffString = new diffString ] ]	1✔
58	]	1✔
59
60	{ #category : 'as yet unclassified' }
61	GPModelImporter >> blockForDiffRangeEquality [	1✔
62		1✔
63	^ [ :existing :new \|	1✔
64	existing diff mooseID = new diff mooseID and: [	1✔
65	existing originalLineRange = new originalLineRange and: [	1✔
66	existing newLineRange = new newLineRange ] ] ]	1✔
67	]	1✔
68
69	{ #category : 'equality' }
70	GPModelImporter >> blockOnIdEquality [	1✔
71		1✔
72	^ [ :existing :new \|	1✔
73	existing id = new id ]	1✔
74	]	1✔
75
76	{ #category : 'equality' }
77	GPModelImporter >> blockOnNameEquality [	1✔
78		1✔
79	^ self blockEqualityOn: #name	1✔
80	]	1✔
81
82	{ #category : 'commit' }
83	GPModelImporter >> chainsCommitsFrom: commitsCollection [	1✔
84		1✔
85	\| dic \|	1✔
86	('Chains ' , commitsCollection size printString , ' commits')	1✔
87	recordInfo.	1✔
88		1✔
89	dic := ((self glhModel allWithType: GLHCommit) collect: [ :commit \|	1✔
90	commit id -> commit ]) asSet asDictionary.	1✔
91		1✔
92	commitsCollection do: [ :commit \|	1✔
93	commit parent_ids do: [ :parentId \|	1✔
94	dic	1✔
95	at: parentId	1✔
96	ifPresent: [ :parentCommit \|	1✔
97	parentCommit childCommits	1✔
98	add: commit	1✔
99	unless: [ :existing :new \| existing id = new id ] ]	1✔
100	ifAbsent: [ ] ] ].	1✔
101	^ commitsCollection	1✔
102	]	1✔
103
104	{ #category : 'commit' }
NEW 105	GPModelImporter >> completeImportedCommit: aGLHCommit [	×
NEW 106		×
NEW 107		×
NEW 108	('completing commit: ' , aGLHCommit short_id printString) recordInfo.	×
NEW 109	self importCreatorOfCommit: aGLHCommit.	×
NEW 110		×
NEW 111	self withCommitDiffs ifTrue: [	×
NEW 112	\| diffs \|	×
NEW 113	aGLHCommit diffs ifEmpty: [	×
NEW 114	diffs := self importDiffOfCommit: aGLHCommit.	×
NEW 115	self glhModel addAll: diffs unless: self blockForDiffEquality ] ].	×
NEW 116		×
NEW 117	^ aGLHCommit	×
NEW 118	]	×
119
120	{ #category : 'as yet unclassified' }
121	GPModelImporter >> filterCommitChanges: aCollection [	1✔
122		1✔
123	^ aCollection reject: [ :line \|	1✔
124	\| trimmedLine \|	1✔
125	trimmedLine := line trimLeft.	1✔
126	(trimmedLine beginsWith: '---') or: [	1✔
127	(trimmedLine beginsWith: '+++') or: [	1✔
128	trimmedLine beginsWith: '\ No newline at end of file' ] ] ]	1✔
129	]	1✔
130
131	{ #category : 'accessing' }
132	GPModelImporter >> glhModel [	1✔
133		1✔
134	^ glhModel	1✔
135	]	1✔
136
137	{ #category : 'accessing' }
138	GPModelImporter >> glhModel: anObject [	1✔
139		1✔
140	glhModel := anObject	1✔
141	]	1✔
142
143	{ #category : 'import' }
144	GPModelImporter >> importDiffRangesForDiff: aGLHDiff [	1✔
145		1✔
146	\| diffRanges \|	1✔
147	aGLHDiff diffRanges ifNotEmpty: [	1✔
148	('Diffs already imported for ' , aGLHDiff printString) recordInfo.	1✔
149	^ aGLHDiff diffRanges ].	1✔
150		1✔
151	('Import changes of diff ' , aGLHDiff printString) recordInfo.	1✔
152	"the import of 'diffRanges' entites is technically done inside the parseDiffString"	1✔
153		1✔
154	diffRanges := self glhModel	1✔
155	addAll: (self parseDiffString: aGLHDiff)	1✔
156	unless: self blockForDiffRangeEquality.	1✔
157	^ aGLHDiff diffRanges	1✔
158	addAll: diffRanges	1✔
159	unless: self blockForDiffRangeEquality	1✔
160	]	1✔
161
162	{ #category : 'initialization' }
163	GPModelImporter >> initialize [	1✔
164		1✔
165	super initialize.	1✔
166	self withCommitsSince: (Date today - 1 week) asDateAndTime.	1✔
167	userCatalogue := GLHUserCatalogueV2 new	1✔
168	anImporter: self;	1✔
169	yourself.	1✔
170	]	1✔
171
172	{ #category : 'as yet unclassified' }
NEW 173	GPModelImporter >> makeGlobal [	×
NEW 174	^ self makeGlobal: DateAndTime now printString.	×
NEW 175	]	×
176
177	{ #category : 'as yet unclassified' }
NEW 178	GPModelImporter >> makeGlobal: aLabel [	×
NEW 179		×
NEW 180	currentImporter := GHModelImporter importers ifNil: [ OrderedDictionary new ].	×
NEW 181	currentImporter at: aLabel put: self.	×
NEW 182	^ currentImporter	×
NEW 183	]	×
184
185	{ #category : 'parsing' }
186	GPModelImporter >> parseDiffString: aDiff [	1✔
187	"parse diff string to create entities for each lines"	1✔
188		1✔
189	\| lines range index firstChangeRange \|	1✔
190	lines := aDiff diffString lines.	1✔
191	index := 0.	1✔
192	range := nil.	1✔
193		1✔
194	lines ifEmpty: [ ^ aDiff diffRanges ].	1✔
195	lines := self filterCommitChanges: lines.	1✔
196	(lines first beginsWith: '@@') ifFalse: [ ^ aDiff diffRanges ].	1✔
197		1✔
198	lines do: [ :line \|	1✔
199	\| aChange \|	1✔
200	firstChangeRange := false.	1✔
201	(line trim beginsWith: #'@@') ifTrue: [	1✔
202	range := GLHDiffRange newFrom: line.	1✔
203	firstChangeRange := true.	1✔
204	range := aDiff diffRanges add: range unless: [ :existing :new \|	1✔
205	existing originalLineRange = new originalLineRange and: [	1✔
206	existing newLineRange = new newLineRange ] ] ].	1✔
207		1✔
208	self withCommitDiffs ifTrue: [	1✔
209	firstChangeRange ifFalse: [	1✔
210	aChange := GLHChange newFrom: line.	1✔
211	aChange relativeIndex: index.	1✔
212	aChange := range changes add: aChange unless: [ :existing :new \|	1✔
213	existing sourceCode = new sourceCode and: [	1✔
214	existing index = new index ] ].	1✔
215	index := index + 1 ] ] ].	1✔
216		1✔
217	"add changes to the diff range"	1✔
218	aDiff diffRanges do: [ :diffRange \|	1✔
219	self glhModel addAll: diffRange changes unless: [ :existing :new \|	1✔
220	existing diffRange mooseID = new diffRange mooseID and: [	1✔
221	existing sourceCode = new sourceCode and: [	1✔
222	existing index = new index ] ] ] ].	1✔
223		1✔
224	^ aDiff diffRanges	1✔
225	]	1✔
226
227	{ #category : 'accessing' }
228	GPModelImporter >> repoApi [	1✔
229		1✔
230	^ repoApi	1✔
231	]	1✔
232
233	{ #category : 'accessing' }
234	GPModelImporter >> repoApi: anObject [	1✔
235		1✔
236	repoApi := anObject	1✔
237	]	1✔
238
239	{ #category : 'accessing' }
240	GPModelImporter >> userCatalogue [	1✔
241	^ userCatalogue	1✔
242	]	1✔
243
244	{ #category : 'accessing' }
NEW 245	GPModelImporter >> userCatalogue: aGLHUserCatalogue [	×
NEW 246		×
NEW 247	userCatalogue := aGLHUserCatalogue.	×
NEW 248	aGLHUserCatalogue anImporter: self.	×
NEW 249	]	×
250
251	{ #category : 'accessing' }
252	GPModelImporter >> withCommitDiffs [	1✔
253		1✔
254	^ withCommitDiffs	1✔
255	]	1✔
256
257	{ #category : 'accessing' }
258	GPModelImporter >> withCommitDiffs: anObject [	1✔
259		1✔
260	withCommitDiffs := anObject	1✔
261	]	1✔
262
263	{ #category : 'accessing' }
264	GPModelImporter >> withCommitsSince [	×
265		×
266	^ withCommitsSince	×
267	]	×
268
269	{ #category : 'accessing' }
270	GPModelImporter >> withCommitsSince: anObject [	1✔
271		1✔
272	withCommitsSince := anObject	1✔
273	]	1✔
274
275	{ #category : 'accessing' }
276	GPModelImporter >> withFiles [	1✔
277		1✔
278	^ withFiles	1✔
279	]	1✔
280
281	{ #category : 'accessing' }
282	GPModelImporter >> withFiles: anObject [	1✔
283		1✔
284	withFiles := anObject	1✔
285	]	1✔

moosetechnology / GitProjectHealth / 11496852352

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous