10452237749

Committed 19 Aug 2024 11:10AM UTC coverage: 18.86% (-14.8%) from 33.667%

Build # 10452237749

Build Type

Pull #31

github

Committed by

web-flow

Commit Message

Merge 2cf167214 into 48c9c9c78

Pull Request Pull Request #31: fix: error if there are no commits in averageTimeBetweenCommits method

Run Details

163 of 1071 new or added lines in 15 files covered. (15.22%)

856 existing lines in 12 files now uncovered.

1585 of 8404 relevant lines covered (18.86%)

0.19 hits per line

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

33.42

/src/GitLabProjectHealth-Model-Importer/GLPHModelImporter.class.st

Class {
        #name : #GLPHModelImporter,
        #superclass : #GLHModelImporter,
        #category : #'GitLabProjectHealth-Model-Importer'
}

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

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

{ #category : #commit }
GLPHModelImporter >> commitsOfProject: aGLHProject forRefName: refName until: toDate [

        | newlyFoundCommit page |
        page := 0.
        newlyFoundCommit := { true }.
        [ newlyFoundCommit isNotEmpty ] whileTrue: [
                | results parsedResults existingCommits |
                page := page + 1.
                ('import commit page ' , page printString) recordInfo.
                results := self glhApi
                                   commitsOfProject: aGLHProject id
                                   forRefName: refName
                                   since: nil
                                   until: nil
                                   path: nil
                                   author: nil
                                   all: nil
                                   with_stats: nil
                                   firstParent: nil
                                   order: nil
                                   trailers: nil
                                   perPage: 100
                                   page: page.
                parsedResults := self parseCommitsResult: results.
                existingCommits := aGLHProject mooseModel allWithType: GLHCommit.

                newlyFoundCommit := parsedResults reject: [ :commitParsed |
                                            (toDate isNil or: [
                                                     commitParsed committed_date
                                                     < toDate asDateAndTime ]) or: [
                                                    existingCommits anySatisfy: [ :existingCommit |
                                                            existingCommit id = commitParsed id ] ] ].
                self glhModel addAll: newlyFoundCommit unless: self blockOnIdEquality.
                aGLHProject repository commits addAll: newlyFoundCommit unless: self blockOnIdEquality  ].
        self withCommitDiffs ifTrue: [
                aGLHProject repository commits do: [ :commit |
                        self importDiffOfCommit: commit ] ]
]

{ #category : #'private - api' }
GLPHModelImporter >> completeImportProject: aGLHProject [
        |completedProject|
        completedProject := super completeImportProject: aGLHProject.

        "for this initial import, with only look at some but not all MR"
        withInitialMergeRequest ifTrue: [ self
                importMergeRequests: completedProject
                since: DateAndTime today
                until: DateAndTime now. ].

        ^ completedProject
]

{ #category : #'private - configure reader' }
GLPHModelImporter >> configureReaderForMergeRequest: reader [
        "declare quil y a un array a mapper"

        reader for: #ArrayOfMergeRequest customDo: [ :customMappting |
                customMappting listOfElementSchema: GLPHEMergeRequest ].

        "declare la liste des properties"
        reader for: GLPHEMergeRequest do: [ :mapping |
                mapping mapInstVars:
                        #( blocking_discussions_resolved changes_count description
                           detailed_merge_status discussion_locked downvotes draft first_deployed_to_production_at
                           force_remove_source_branch has_conflicts id iid labels latest_build_finished_at
                           latest_build_started_at merge_commit_sha merge_status
                           merge_when_pipeline_succeeds merged_at milestone project_id
                           reference references_full references_relative
                           references_short sha should_remove_source_branch
                           source_branch source_project_id squash squash_commit_sha
                           squash_on_merge state subscribed target_branch target_project_id
                           task_completion_status_completed_count
                           task_completion_status_count time_stats_human_time_estimate
                           time_stats_human_total_time_spent
                           time_stats_time_estimate time_stats_total_time_spent
                           title updated_at upvotes user_notes_count web_url work_in_progress ).
                (mapping mapInstVar: #created_at) valueSchema: DateAndTime.
                (mapping mapInstVar: #updated_at) valueSchema: DateAndTime.
                (mapping mapInstVar: #merged_at) valueSchema: DateAndTime.
                (mapping mapInstVar: #closed_at) valueSchema: DateAndTime.
                "(mapping mapInstVar: #assignee) valueSchema: GLHUser."
                mapping
                        mapProperty: #author
                        getter: [  ]
                        setter: [ :object :value |
                        object cacheAt: #authorID put: (value at: #id) ].
                mapping
                        mapProperty: #merge_user
                        getter: [  ]
                        setter: [ :object :value | 
                                value ifNotNil: [
                                        object cacheAt: #mergeUserID put: (value at: #id) ] ] ].

        "(mapping mapInstVar: #closed_by) valueSchema: GLHUser.
        (mapping mapInstVar: #mergeCommit) valueSchema: GLHCommit."
        "indique ce que doit faire le reader lorsqu'il parse une DateAndTime object"
        reader for: DateAndTime customDo: [ :mapping |
                mapping decoder: [ :string |
                        string ifNil: [ nil ] ifNotNil: [ DateAndTime fromString: string ] ] ]
]

{ #category : #import }
GLPHModelImporter >> importCommitsOfBranch: aGLHBranch [

        | commits |
        "        result := self glhApi
                          commitsOfProject: aGLHBranch repository project id
                          forRefName: aGLHBranch name."
        commits := self
                           importCommitsOfBranch: aGLHBranch
                           forRefName: aGLHBranch name
                           since: withCommitsSince.

        self chainsCommitsFrom: commits.

        commits do: [ :aCommit |
                aCommit repository: aGLHBranch repository.
                self completeImportedCommit: aCommit. 
                 ]
]

{ #category : #import }
GLPHModelImporter >> importCommitsOfMergeResquest: aGLPHEMergeRequest [

        | foundCommits |
        foundCommits := OrderedCollection new.

        ('Import commit sha of MR:  ' , aGLPHEMergeRequest iid printString)
                recordInfo.
        "the founds commits are added to the model during their respective import"
        aGLPHEMergeRequest mergeRequestCommit: ((self
                          importCommitOfProject: aGLPHEMergeRequest project
                          withId: aGLPHEMergeRequest sha) ifNotNil: [ :commit |
                         foundCommits add: commit ]).

        ('Import commit merge_commit_sha of MR:  '
         , aGLPHEMergeRequest iid printString) recordInfo.
        aGLPHEMergeRequest mergedCommit: ((self
                          importCommitOfProject: aGLPHEMergeRequest project
                          withId: aGLPHEMergeRequest merge_commit_sha) ifNotNil: [ :commit |
                         foundCommits add: commit ]).

        ('Import commit squash_commit_sha of MR:  '
         , aGLPHEMergeRequest iid printString) recordInfo.
        aGLPHEMergeRequest squashCommit: ((self
                          importCommitOfProject: aGLPHEMergeRequest project
                          withId: aGLPHEMergeRequest squash_commit_sha) ifNotNil: [ :commit |
                         foundCommits add: commit ]).


        self chainsCommitsFrom: foundCommits.
        ^ foundCommits
]

{ #category : #api }
GLPHModelImporter >> importDiffOfCommit: aCommit [

        super importDiffOfCommit: aCommit.
        
        "changes are added into the model during the import"
        aCommit diffs do: [ :diff | self importDiffRangesForDiff: diff ].

        ^ aCommit diffs
]

{ #category : #'as yet unclassified' }
GLPHModelImporter >> importDiffOfMergeRequest: aMergeRequest [

        | result diffsResult |
        aMergeRequest diffs ifNotEmpty: [
                'Diff of already importer: '
                , aMergeRequest iid printString recordInfo.
                ^ aMergeRequest diffs ].
        ('Import diff commits of MR ' , aMergeRequest iid printString)
                recordInfo.
        result := self glhApi
                          diffsMergeRequestOfProject: aMergeRequest project_id
                          withId: aMergeRequest iid.

        diffsResult := self newParseDiffResult: result.


        aMergeRequest diffs
                addAll: diffsResult
                unless: self blockForDiffEquality.
        self glhModel
                addAll: aMergeRequest diffs
                unless: self blockForDiffEquality.

        aMergeRequest diffs do: [ :diff | self importDiffRangesForDiff: diff ].

        ^ aMergeRequest diffs
]

{ #category : #import }
GLPHModelImporter >> 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 : #'import - merge request' }
GLPHModelImporter >> importMergeRequests: aGLHProject [

        | results parsedResults |
        ('Import merge request of Project: ' , aGLHProject id printString)
                recordInfo.

        results := self glhApi mergeRequestOfProject: aGLHProject id.
        parsedResults := self parseMergeRequestResult: results.

        aGLHProject mergeRequests
                addAll: parsedResults
                unless: self blockOnIdEquality.

        self glhModel
                addAll: aGLHProject mergeRequests
                unless: self blockOnIdEquality.


        "gets it related commits"
        aGLHProject mergeRequests do: [ :mr |
                self importCommitsOfMergeResquest: mr ].


        self withCommitDiffs ifTrue: [
                aGLHProject mergeRequests do: [ :mr |
                        self importDiffOfMergeRequest: mr ] ]
]

{ #category : #'import - merge request' }
GLPHModelImporter >> importMergeRequests: aGLHProject since: fromDate until: toDate [

        | newlyFoundMR page foundMR |
        ('import MR of Project ' , aGLHProject name) recordInfo.

        page := 0.
        foundMR := OrderedCollection new.
        newlyFoundMR := { true }.
        [ newlyFoundMR isNotEmpty ] whileTrue: [
                | results |
                page := page + 1.
                ('import MR page ' , page printString) recordInfo.
                results := self glhApi
                                   mergeRequestsOfProject: aGLHProject id
                                   createdAfter:
                                   (fromDate ifNotNil: [ fromDate asDateAndTime asString ])
                                   createdBefore:
                                   (toDate ifNotNil: [ toDate asDateAndTime asString ])
                                   authorId: nil
                                   authorUsername: nil
                                   scope: 'all'
                                   orderBy: 'created_at'
                                   page: page.


                newlyFoundMR := aGLHProject mergeRequests
                                        addAll: (self parseMergeRequestResult: results)
                                        unless: self blockOnIdEquality.
                foundMR addAll: newlyFoundMR ].


        "gets it related commits"
        aGLHProject mergeRequests do: [ :mr |
                self importCommitsOfMergeResquest: mr ].

        self withCommitDiffs ifTrue: [
                aGLHProject mergeRequests do: [ :mr |
                        self importDiffOfMergeRequest: mr ] ].
        
        self glhModel addAll: foundMR unless: (self blockEqualityOn: #iid).

        ^ foundMR
]

{ #category : #'import - merge request' }
GLPHModelImporter >> importMergeResquestApprovals: aGLPHEMergeRequest [

        | results parsedResult |
        (String streamContents: [ :str |
                 str << 'Check approvals of '.
                 aGLPHEMergeRequest printOn: str ]) recordInfo.
        results := self glhApi
                           approvalsOfMergeQuest: aGLPHEMergeRequest iid
                           ofProject: aGLPHEMergeRequest project id.

        parsedResult := generalReader
                                on: results readStream;
                                next.

        (parsedResult at: #approved_by) do: [ :approvedUser |
                aGLPHEMergeRequest addApproved_by:
                        (self importUser: ((approvedUser at: #user) at: #id)) ].
        aGLPHEMergeRequest approved: (parsedResult at: #approved).
        ^ aGLPHEMergeRequest
]

{ #category : #'import - merge request' }
GLPHModelImporter >> importMergeResquestAuthor: aGLPHEMergeRequest [

        | authorID |
        aGLPHEMergeRequest author ifNotNil: [ ^ aGLPHEMergeRequest author ].
        authorID := aGLPHEMergeRequest cacheAt: #authorID ifAbsent: [
                            (generalReader
                                     on: (self glhApi
                                                      mergeRequestOfProject:
                                                              aGLPHEMergeRequest project_id
                                                      withId: aGLPHEMergeRequest iid) readStream;
                                     next) at: #author at: #id ].
        aGLPHEMergeRequest author: (self importUser: authorID)
]

{ #category : #'import - merge request' }
GLPHModelImporter >> importMergeResquestMerger: aGLPHEMergeRequest [

        | authorID |
        aGLPHEMergeRequest merge_user ifNotNil: [
                ^ aGLPHEMergeRequest merge_user ].
        authorID := aGLPHEMergeRequest cacheAt: #mergeUserID ifAbsent: [
                            (generalReader
                                     on: (self glhApi
                                                      mergeRequestOfProject:
                                                              aGLPHEMergeRequest project_id
                                                      withId: aGLPHEMergeRequest iid) readStream;
                                     next)
                                    at: #merge_user
                                    ifPresent: [ :mergeUser |
                                    mergeUser ifNotNil: [ :mruser | mruser at: #id ] ] ].
        aGLPHEMergeRequest merge_user: (self importUser: authorID)
]

{ #category : #'private - api' }
GLPHModelImporter >> importRepository: aGLHRepository [

        super importRepository: aGLHRepository.

        withInitialCommits ifTrue: [
                aGLHRepository branches do: [ :branch |
                        self importCommitsOfBranch: branch ] ]
]

{ #category : #initialization }
GLPHModelImporter >> initReader [

        super initReader.
        self configureReaderForMergeRequest: generalReader
]

{ #category : #initialization }
GLPHModelImporter >> initialize [

        super initialize.
        withCommitDiffs := true
]

{ #category : #parsing }
GLPHModelImporter >> 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 := GLPHEDiffRange 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 := GLPHEChange 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 : #parsing }
GLPHModelImporter >> parseMergeRequestResult: result [

        generalReader on: result readStream.
        ^ generalReader nextAs: #ArrayOfMergeRequest
]

{ #category : #accessing }
GLPHModelImporter >> withCommitsSince: someDays [
        "substract the current date with a given number of days. Use to retrieve the commits submit in the last giving days"
        "(GLPHModelImporter new withCommitsSince: 1 week ) >>> (Date today - 1 week) asDateAndTime"
        "(GLPHModelImporter new withCommitsSince: 30 day ) >>> (Date today - 30 day) asDateAndTime"
        withCommitsSince := (Date today - someDays) asDateAndTime
]

1	Class {
2	#name : #GLPHModelImporter,
3	#superclass : #GLHModelImporter,
4	#category : #'GitLabProjectHealth-Model-Importer'
5	}
6
7	{ #category : #'as yet unclassified' }
UNCOV 8	GLPHModelImporter >> blockForDiffRangeEquality [	×
UNCOV 9		×
UNCOV 10	^ [ :existing :new \|	×
UNCOV 11	existing diff mooseID = new diff mooseID and: [	×
UNCOV 12	existing originalLineRange = new originalLineRange and: [	×
UNCOV 13	existing newLineRange = new newLineRange ] ] ]	×
UNCOV 14	]	×
15
16	{ #category : #commit }
UNCOV 17	GLPHModelImporter >> commitsOfProject: aGLHProject forRefName: refName until: toDate [	×
18		×
19	\| newlyFoundCommit page \|	×
20	page := 0.	×
21	newlyFoundCommit := { true }.	×
22	[ newlyFoundCommit isNotEmpty ] whileTrue: [	×
23	\| results parsedResults existingCommits \|	×
24	page := page + 1.	×
25	('import commit page ' , page printString) recordInfo.	×
26	results := self glhApi	×
27	commitsOfProject: aGLHProject id	×
28	forRefName: refName	×
29	since: nil	×
30	until: nil	×
31	path: nil	×
32	author: nil	×
33	all: nil	×
34	with_stats: nil	×
35	firstParent: nil	×
36	order: nil	×
37	trailers: nil	×
38	perPage: 100	×
39	page: page.	×
40	parsedResults := self parseCommitsResult: results.	×
41	existingCommits := aGLHProject mooseModel allWithType: GLHCommit.	×
42		×
43	newlyFoundCommit := parsedResults reject: [ :commitParsed \|	×
44	(toDate isNil or: [	×
45	commitParsed committed_date	×
46	< toDate asDateAndTime ]) or: [	×
47	existingCommits anySatisfy: [ :existingCommit \|	×
48	existingCommit id = commitParsed id ] ] ].	×
49	self glhModel addAll: newlyFoundCommit unless: self blockOnIdEquality.	×
50	aGLHProject repository commits addAll: newlyFoundCommit unless: self blockOnIdEquality ].	×
51	self withCommitDiffs ifTrue: [	×
52	aGLHProject repository commits do: [ :commit \|	×
53	self importDiffOfCommit: commit ] ]	×
54	]	×
55
56	{ #category : #'private - api' }
UNCOV 57	GLPHModelImporter >> completeImportProject: aGLHProject [	×
UNCOV 58	\|completedProject\|	×
UNCOV 59	completedProject := super completeImportProject: aGLHProject.	×
UNCOV 60		×
UNCOV 61	"for this initial import, with only look at some but not all MR"	×
UNCOV 62	withInitialMergeRequest ifTrue: [ self	×
UNCOV 63	importMergeRequests: completedProject	×
UNCOV 64	since: DateAndTime today	×
UNCOV 65	until: DateAndTime now. ].	×
UNCOV 66		×
UNCOV 67	^ completedProject	×
UNCOV 68	]	×
69
70	{ #category : #'private - configure reader' }
71	GLPHModelImporter >> configureReaderForMergeRequest: reader [	1✔
72	"declare quil y a un array a mapper"	1✔
73		1✔
74	reader for: #ArrayOfMergeRequest customDo: [ :customMappting \|	1✔
75	customMappting listOfElementSchema: GLPHEMergeRequest ].	1✔
76		1✔
77	"declare la liste des properties"	1✔
78	reader for: GLPHEMergeRequest do: [ :mapping \|	1✔
79	mapping mapInstVars:	1✔
80	#( blocking_discussions_resolved changes_count description	1✔
81	detailed_merge_status discussion_locked downvotes draft first_deployed_to_production_at	1✔
82	force_remove_source_branch has_conflicts id iid labels latest_build_finished_at	1✔
83	latest_build_started_at merge_commit_sha merge_status	1✔
84	merge_when_pipeline_succeeds merged_at milestone project_id	1✔
85	reference references_full references_relative	1✔
86	references_short sha should_remove_source_branch	1✔
87	source_branch source_project_id squash squash_commit_sha	1✔
88	squash_on_merge state subscribed target_branch target_project_id	1✔
89	task_completion_status_completed_count	1✔
90	task_completion_status_count time_stats_human_time_estimate	1✔
91	time_stats_human_total_time_spent	1✔
92	time_stats_time_estimate time_stats_total_time_spent	1✔
93	title updated_at upvotes user_notes_count web_url work_in_progress ).	1✔
94	(mapping mapInstVar: #created_at) valueSchema: DateAndTime.	1✔
95	(mapping mapInstVar: #updated_at) valueSchema: DateAndTime.	1✔
96	(mapping mapInstVar: #merged_at) valueSchema: DateAndTime.	1✔
97	(mapping mapInstVar: #closed_at) valueSchema: DateAndTime.	1✔
98	"(mapping mapInstVar: #assignee) valueSchema: GLHUser."	1✔
99	mapping	1✔
100	mapProperty: #author	1✔
101	getter: [ ]	1✔
102	setter: [ :object :value \|	1✔
103	object cacheAt: #authorID put: (value at: #id) ].	1✔
104	mapping	1✔
105	mapProperty: #merge_user	1✔
106	getter: [ ]	1✔
107	setter: [ :object :value \|	1✔
108	value ifNotNil: [	1✔
109	object cacheAt: #mergeUserID put: (value at: #id) ] ] ].	1✔
110		1✔
111	"(mapping mapInstVar: #closed_by) valueSchema: GLHUser.	1✔
112	(mapping mapInstVar: #mergeCommit) valueSchema: GLHCommit."	1✔
113	"indique ce que doit faire le reader lorsqu'il parse une DateAndTime object"	1✔
114	reader for: DateAndTime customDo: [ :mapping \|	1✔
115	mapping decoder: [ :string \|	1✔
116	string ifNil: [ nil ] ifNotNil: [ DateAndTime fromString: string ] ] ]	1✔
117	]	1✔
118
119	{ #category : #import }
120	GLPHModelImporter >> importCommitsOfBranch: aGLHBranch [	×
121		×
122	\| commits \|	×
123	" result := self glhApi	×
124	commitsOfProject: aGLHBranch repository project id	×
125	forRefName: aGLHBranch name."	×
126	commits := self	×
127	importCommitsOfBranch: aGLHBranch	×
128	forRefName: aGLHBranch name	×
129	since: withCommitsSince.	×
130		×
131	self chainsCommitsFrom: commits.	×
132		×
133	commits do: [ :aCommit \|	×
134	aCommit repository: aGLHBranch repository.	×
135	self completeImportedCommit: aCommit.	×
136	]	×
137	]	×
138
139	{ #category : #import }
UNCOV 140	GLPHModelImporter >> importCommitsOfMergeResquest: aGLPHEMergeRequest [	×
UNCOV 141		×
UNCOV 142	\| foundCommits \|	×
UNCOV 143	foundCommits := OrderedCollection new.	×
UNCOV 144		×
UNCOV 145	('Import commit sha of MR: ' , aGLPHEMergeRequest iid printString)	×
UNCOV 146	recordInfo.	×
UNCOV 147	"the founds commits are added to the model during their respective import"	×
UNCOV 148	aGLPHEMergeRequest mergeRequestCommit: ((self	×
UNCOV 149	importCommitOfProject: aGLPHEMergeRequest project	×
UNCOV 150	withId: aGLPHEMergeRequest sha) ifNotNil: [ :commit \|	×
UNCOV 151	foundCommits add: commit ]).	×
UNCOV 152		×
UNCOV 153	('Import commit merge_commit_sha of MR: '	×
UNCOV 154	, aGLPHEMergeRequest iid printString) recordInfo.	×
UNCOV 155	aGLPHEMergeRequest mergedCommit: ((self	×
UNCOV 156	importCommitOfProject: aGLPHEMergeRequest project	×
UNCOV 157	withId: aGLPHEMergeRequest merge_commit_sha) ifNotNil: [ :commit \|	×
UNCOV 158	foundCommits add: commit ]).	×
UNCOV 159		×
UNCOV 160	('Import commit squash_commit_sha of MR: '	×
UNCOV 161	, aGLPHEMergeRequest iid printString) recordInfo.	×
UNCOV 162	aGLPHEMergeRequest squashCommit: ((self	×
UNCOV 163	importCommitOfProject: aGLPHEMergeRequest project	×
UNCOV 164	withId: aGLPHEMergeRequest squash_commit_sha) ifNotNil: [ :commit \|	×
UNCOV 165	foundCommits add: commit ]).	×
UNCOV 166		×
UNCOV 167		×
UNCOV 168	self chainsCommitsFrom: foundCommits.	×
UNCOV 169	^ foundCommits	×
UNCOV 170	]	×
171
172	{ #category : #api }
UNCOV 173	GLPHModelImporter >> importDiffOfCommit: aCommit [	×
UNCOV 174		×
UNCOV 175	super importDiffOfCommit: aCommit.	×
UNCOV 176		×
UNCOV 177	"changes are added into the model during the import"	×
UNCOV 178	aCommit diffs do: [ :diff \| self importDiffRangesForDiff: diff ].	×
UNCOV 179		×
UNCOV 180	^ aCommit diffs	×
UNCOV 181	]	×
182
183	{ #category : #'as yet unclassified' }
UNCOV 184	GLPHModelImporter >> importDiffOfMergeRequest: aMergeRequest [	×
UNCOV 185		×
UNCOV 186	\| result diffsResult \|	×
UNCOV 187	aMergeRequest diffs ifNotEmpty: [	×
UNCOV 188	'Diff of already importer: '	×
UNCOV 189	, aMergeRequest iid printString recordInfo.	×
UNCOV 190	^ aMergeRequest diffs ].	×
UNCOV 191	('Import diff commits of MR ' , aMergeRequest iid printString)	×
UNCOV 192	recordInfo.	×
UNCOV 193	result := self glhApi	×
UNCOV 194	diffsMergeRequestOfProject: aMergeRequest project_id	×
UNCOV 195	withId: aMergeRequest iid.	×
UNCOV 196		×
NEW 197	diffsResult := self newParseDiffResult: result.	×
UNCOV 198		×
UNCOV 199		×
UNCOV 200	aMergeRequest diffs	×
UNCOV 201	addAll: diffsResult	×
UNCOV 202	unless: self blockForDiffEquality.	×
UNCOV 203	self glhModel	×
UNCOV 204	addAll: aMergeRequest diffs	×
UNCOV 205	unless: self blockForDiffEquality.	×
UNCOV 206		×
UNCOV 207	aMergeRequest diffs do: [ :diff \| self importDiffRangesForDiff: diff ].	×
UNCOV 208		×
UNCOV 209	^ aMergeRequest diffs	×
UNCOV 210	]	×
211
212	{ #category : #import }
UNCOV 213	GLPHModelImporter >> importDiffRangesForDiff: aGLHDiff [	×
UNCOV 214		×
UNCOV 215	\| diffRanges \|	×
UNCOV 216	aGLHDiff diffRanges ifNotEmpty: [	×
UNCOV 217	('Diffs already imported for ' , aGLHDiff printString) recordInfo.	×
UNCOV 218	^ aGLHDiff diffRanges ].	×
UNCOV 219		×
UNCOV 220	('Import changes of diff ' , aGLHDiff printString) recordInfo.	×
UNCOV 221	"the import of 'diffRanges' entites is technically done inside the parseDiffString"	×
UNCOV 222		×
UNCOV 223	diffRanges := self glhModel	×
UNCOV 224	addAll: (self parseDiffString: aGLHDiff)	×
UNCOV 225	unless: self blockForDiffRangeEquality.	×
UNCOV 226	^ aGLHDiff diffRanges	×
UNCOV 227	addAll: diffRanges	×
UNCOV 228	unless: self blockForDiffRangeEquality	×
UNCOV 229	]	×
230
231	{ #category : #'import - merge request' }
UNCOV 232	GLPHModelImporter >> importMergeRequests: aGLHProject [	×
UNCOV 233		×
UNCOV 234	\| results parsedResults \|	×
UNCOV 235	('Import merge request of Project: ' , aGLHProject id printString)	×
UNCOV 236	recordInfo.	×
UNCOV 237		×
UNCOV 238	results := self glhApi mergeRequestOfProject: aGLHProject id.	×
UNCOV 239	parsedResults := self parseMergeRequestResult: results.	×
UNCOV 240		×
UNCOV 241	aGLHProject mergeRequests	×
UNCOV 242	addAll: parsedResults	×
UNCOV 243	unless: self blockOnIdEquality.	×
UNCOV 244		×
UNCOV 245	self glhModel	×
UNCOV 246	addAll: aGLHProject mergeRequests	×
UNCOV 247	unless: self blockOnIdEquality.	×
UNCOV 248		×
UNCOV 249		×
UNCOV 250	"gets it related commits"	×
UNCOV 251	aGLHProject mergeRequests do: [ :mr \|	×
UNCOV 252	self importCommitsOfMergeResquest: mr ].	×
UNCOV 253		×
UNCOV 254		×
UNCOV 255	self withCommitDiffs ifTrue: [	×
UNCOV 256	aGLHProject mergeRequests do: [ :mr \|	×
UNCOV 257	self importDiffOfMergeRequest: mr ] ]	×
UNCOV 258	]	×
259
260	{ #category : #'import - merge request' }
261	GLPHModelImporter >> importMergeRequests: aGLHProject since: fromDate until: toDate [	×
262		×
263	\| newlyFoundMR page foundMR \|	×
264	('import MR of Project ' , aGLHProject name) recordInfo.	×
265		×
266	page := 0.	×
267	foundMR := OrderedCollection new.	×
268	newlyFoundMR := { true }.	×
269	[ newlyFoundMR isNotEmpty ] whileTrue: [	×
270	\| results \|	×
271	page := page + 1.	×
272	('import MR page ' , page printString) recordInfo.	×
273	results := self glhApi	×
274	mergeRequestsOfProject: aGLHProject id	×
275	createdAfter:	×
276	(fromDate ifNotNil: [ fromDate asDateAndTime asString ])	×
277	createdBefore:	×
278	(toDate ifNotNil: [ toDate asDateAndTime asString ])	×
279	authorId: nil	×
280	authorUsername: nil	×
281	scope: 'all'	×
282	orderBy: 'created_at'	×
283	page: page.	×
284		×
285		×
286	newlyFoundMR := aGLHProject mergeRequests	×
287	addAll: (self parseMergeRequestResult: results)	×
288	unless: self blockOnIdEquality.	×
289	foundMR addAll: newlyFoundMR ].	×
290		×
291		×
292	"gets it related commits"	×
293	aGLHProject mergeRequests do: [ :mr \|	×
294	self importCommitsOfMergeResquest: mr ].	×
295		×
296	self withCommitDiffs ifTrue: [	×
297	aGLHProject mergeRequests do: [ :mr \|	×
298	self importDiffOfMergeRequest: mr ] ].	×
299		×
300	self glhModel addAll: foundMR unless: (self blockEqualityOn: #iid).	×
301		×
302	^ foundMR	×
303	]	×
304
305	{ #category : #'import - merge request' }
306	GLPHModelImporter >> importMergeResquestApprovals: aGLPHEMergeRequest [	×
307		×
308	\| results parsedResult \|	×
309	(String streamContents: [ :str \|	×
310	str << 'Check approvals of '.	×
311	aGLPHEMergeRequest printOn: str ]) recordInfo.	×
312	results := self glhApi	×
313	approvalsOfMergeQuest: aGLPHEMergeRequest iid	×
314	ofProject: aGLPHEMergeRequest project id.	×
315		×
316	parsedResult := generalReader	×
317	on: results readStream;	×
318	next.	×
319		×
320	(parsedResult at: #approved_by) do: [ :approvedUser \|	×
321	aGLPHEMergeRequest addApproved_by:	×
322	(self importUser: ((approvedUser at: #user) at: #id)) ].	×
323	aGLPHEMergeRequest approved: (parsedResult at: #approved).	×
324	^ aGLPHEMergeRequest	×
325	]	×
326
327	{ #category : #'import - merge request' }
328	GLPHModelImporter >> importMergeResquestAuthor: aGLPHEMergeRequest [	1✔
329		1✔
330	\| authorID \|	1✔
331	aGLPHEMergeRequest author ifNotNil: [ ^ aGLPHEMergeRequest author ].	1✔
332	authorID := aGLPHEMergeRequest cacheAt: #authorID ifAbsent: [	1✔
333	(generalReader	1✔
334	on: (self glhApi	1✔
335	mergeRequestOfProject:	1✔
336	aGLPHEMergeRequest project_id	1✔
337	withId: aGLPHEMergeRequest iid) readStream;	1✔
338	next) at: #author at: #id ].	1✔
339	aGLPHEMergeRequest author: (self importUser: authorID)	1✔
340	]	1✔
341
342	{ #category : #'import - merge request' }
343	GLPHModelImporter >> importMergeResquestMerger: aGLPHEMergeRequest [	1✔
344		1✔
345	\| authorID \|	1✔
346	aGLPHEMergeRequest merge_user ifNotNil: [	1✔
347	^ aGLPHEMergeRequest merge_user ].	1✔
348	authorID := aGLPHEMergeRequest cacheAt: #mergeUserID ifAbsent: [	1✔
349	(generalReader	1✔
350	on: (self glhApi	1✔
351	mergeRequestOfProject:	1✔
352	aGLPHEMergeRequest project_id	1✔
353	withId: aGLPHEMergeRequest iid) readStream;	1✔
354	next)	1✔
355	at: #merge_user	1✔
356	ifPresent: [ :mergeUser \|	1✔
357	mergeUser ifNotNil: [ :mruser \| mruser at: #id ] ] ].	1✔
358	aGLPHEMergeRequest merge_user: (self importUser: authorID)	1✔
359	]	1✔
360
361	{ #category : #'private - api' }
UNCOV 362	GLPHModelImporter >> importRepository: aGLHRepository [	×
UNCOV 363		×
UNCOV 364	super importRepository: aGLHRepository.	×
UNCOV 365		×
UNCOV 366	withInitialCommits ifTrue: [	×
UNCOV 367	aGLHRepository branches do: [ :branch \|	×
UNCOV 368	self importCommitsOfBranch: branch ] ]	×
UNCOV 369	]	×
370
371	{ #category : #initialization }
372	GLPHModelImporter >> initReader [	1✔
373		1✔
374	super initReader.	1✔
375	self configureReaderForMergeRequest: generalReader	1✔
376	]	1✔
377
378	{ #category : #initialization }
379	GLPHModelImporter >> initialize [	1✔
380		1✔
381	super initialize.	1✔
382	withCommitDiffs := true	1✔
383	]	1✔
384
385	{ #category : #parsing }
386	GLPHModelImporter >> parseDiffString: aDiff [	1✔
387	"parse diff string to create entities for each lines"	1✔
388		1✔
389	\| lines range index firstChangeRange \|	1✔
390	lines := aDiff diffString lines.	1✔
391	index := 0.	1✔
392	range := nil.	1✔
393		1✔
394	lines ifEmpty: [ ^ aDiff diffRanges ].	1✔
395	lines := self filterCommitChanges: lines.	1✔
396	(lines first beginsWith: '@@') ifFalse: [ ^ aDiff diffRanges ].	1✔
397		1✔
398	lines do: [ :line \|	1✔
399	\| aChange \|	1✔
400	firstChangeRange := false.	1✔
401	(line trim beginsWith: #'@@') ifTrue: [	1✔
402	range := GLPHEDiffRange newFrom: line.	1✔
403	firstChangeRange := true.	1✔
404	range := aDiff diffRanges add: range unless: [ :existing :new \|	1✔
405	existing originalLineRange = new originalLineRange and: [	1✔
406	existing newLineRange = new newLineRange ] ] ].	1✔
407		1✔
408	self withCommitDiffs ifTrue: [	1✔
409	firstChangeRange ifFalse: [	1✔
410	aChange := GLPHEChange newFrom: line.	1✔
411	aChange relativeIndex: index.	1✔
412	aChange := range changes add: aChange unless: [ :existing :new \|	1✔
413	existing sourceCode = new sourceCode and: [	1✔
414	existing index = new index ] ].	1✔
415	index := index + 1 ] ] ].	1✔
416		1✔
417	"add changes to the diff range"	1✔
418	aDiff diffRanges do: [ :diffRange \|	1✔
419	self glhModel addAll: diffRange changes unless: [ :existing :new \|	1✔
420	existing diffRange mooseID = new diffRange mooseID and: [	1✔
421	existing sourceCode = new sourceCode and: [	1✔
422	existing index = new index ] ] ] ].	1✔
423		1✔
424	^ aDiff diffRanges	1✔
425	]	1✔
426
427	{ #category : #parsing }
428	GLPHModelImporter >> parseMergeRequestResult: result [	1✔
429		1✔
430	generalReader on: result readStream.	1✔
431	^ generalReader nextAs: #ArrayOfMergeRequest	1✔
432	]	1✔
433
434	{ #category : #accessing }
UNCOV 435	GLPHModelImporter >> withCommitsSince: someDays [	×
UNCOV 436	"substract the current date with a given number of days. Use to retrieve the commits submit in the last giving days"	×
UNCOV 437	"(GLPHModelImporter new withCommitsSince: 1 week ) >>> (Date today - 1 week) asDateAndTime"	×
UNCOV 438	"(GLPHModelImporter new withCommitsSince: 30 day ) >>> (Date today - 30 day) asDateAndTime"	×
UNCOV 439	withCommitsSince := (Date today - someDays) asDateAndTime	×
UNCOV 440	]	×

moosetechnology / GitProjectHealth / 10452237749

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