16967431324

Committed 14 Aug 2025 02:03PM UTC coverage: 73.223% (-0.5%) from 73.685%

Build # 16967431324

Build Type

Pull #221

github

Committed by

web-flow

Commit Message

Merge f03872e4f into 812fde906

Pull Request Pull Request #221: update deprecated github api

Run Details

1 of 183 new or added lines in 2 files covered. (0.55%)

24 existing lines in 1 file now uncovered.

18461 of 25212 relevant lines covered (73.22%)

0.73 hits per line

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

20.95

/src/GitHubHealth-Model-Importer/GithubModelImporter.class.st

Class {
        #name : #GithubModelImporter,
        #superclass : #GitModelImporter,
        #category : #'GitHubHealth-Model-Importer'
}

{ #category : #accessing }
GithubModelImporter >> api [

        self
                deprecated: 'Use #repoApi instead'
                on: '7 October 2024'
                in:
                'Pharo-11.0.0+build.726.sha.aece1b5473acf3830a0e082c1bc3a15d4ff3522b (64 Bit)'.

        ^ repoApi
]

{ #category : #accessing }
GithubModelImporter >> api: anObject [

        self
                deprecated: 'Use #repoApi: instead'
                on: '7 October 2024'
                in:
                'Pharo-11.0.0+build.726.sha.aece1b5473acf3830a0e082c1bc3a15d4ff3522b (64 Bit)'.

        repoApi := anObject
]

{ #category : #commit }
GithubModelImporter >> completeImportedCommit: aGLHCommit [

        | result |
        ('completing commit: ' , aGLHCommit short_id printString) recordInfo.
        "link commit to user"
        self importCreatorOfCommit: aGLHCommit.

        "import deletion and addition"
        result := self repoApi
                          commit: aGLHCommit id
                          ofOrganisation: aGLHCommit repository project group name
                          ofProject: aGLHCommit repository project name.
        aGLHCommit deletions:
                ((result at: #files) collect: [ :file | file at: #deletions ]) sum.
        aGLHCommit additions:
                ((result at: #files) collect: [ :file | file at: #additions ]) sum.


        "import diffs of this commits"
        self withCommitDiffs ifTrue: [
                | diffs |
                aGLHCommit diffs ifEmpty: [
                        diffs := self parseDiffresult: result.
                        diffs := aGLHCommit diffs
                                         addAll: diffs
                                         unless: self blockForDiffEquality.
                        self glhModel addAll: diffs unless: self blockForDiffEquality.
                        diffs do: [ :diff | self importDiffRangesForDiff: diff ] ] ].

        ^ aGLHCommit 
]

{ #category : #api }
GithubModelImporter >> completeImportedProject: aGLHProject [

        self importPipelinesOf: aGLHProject.
        self importBranchesOf: aGLHProject.
        self withCommitsSince ifNotNil: [ :withCommitSince | "If not nil, it means we have to import commit"
                | commits |
                commits := self importCommitsOfProject: aGLHProject.
                self chainsCommitsFrom: commits ]
]

{ #category : #private }
GithubModelImporter >> convertApiFileAsFile: aAPIFile [

        aAPIFile type = 'dir' ifTrue: [ 
                ^ GLHFileDirectory new
                          name: aAPIFile name;
                          yourself ].
        ^ GLHFileBlob new
                  name: aAPIFile name;
                  yourself
]

{ #category : #api }
GithubModelImporter >> ensureGroupNamed: aGroupName [

        ^ self glhModel
                  detect: [ :a |
                  (a isKindOf: GLHGroup) and: [ a name = aGroupName ] ]
                  ifNone: [ self glhModel newGroupNamed: aGroupName ]
]

{ #category : #api }
GithubModelImporter >> importBranchesOf: project [

        "add the pipeline (actions runs) in the project"

        | branchesResult branches repository |
        branchesResult := self repoApi
                                  branchesOfRepo: project name
                                  ofOrganization: project group name.
        branches := self parseBranchesResult: branchesResult.
        self glhModel addAll: branches.
        repository := GLHRepository new.
        self glhModel add: repository.
        project repository: repository.
        branches do: [ :branch | 
                repository addBranch: branch.
                self withFiles ifTrue: [ self importFilesOfBranch: branch ] ]
]

{ #category : #api }
GithubModelImporter >> importCommitsOfProject: aGLHProject [

        | itemByPage foundCommits tmp pageNumber |
        itemByPage := 100.
        pageNumber := 1.
        ('Extract all commits of ' , aGLHProject name) recordInfo.
        foundCommits := OrderedCollection new.
        ('Extract commits from ' , foundCommits size printString , ' to '
         , (foundCommits size + itemByPage) printString) recordInfo.
        "also check that there is at least one commit with the error handling"
        [
        tmp := self parseCommitsResult: (self repoApi
                                commitsOfProject: aGLHProject name
                                ofOrganization: aGLHProject group name
                                since: self withCommitsSince
                                perPage: itemByPage
                                page: pageNumber) ]
                on: GHRepositoryEmptyError
                do: [ ^ {  } ].

        foundCommits addAll: tmp.
        [ tmp size = itemByPage ] whileTrue: [
                pageNumber := pageNumber + 1.
                ('Extract issues from ' , foundCommits size printString , ' to '
                 , (foundCommits size + itemByPage) printString) recordInfo.
                tmp := self parseCommitsResult: (self repoApi
                                        commitsOfProject: aGLHProject name
                                        ofOrganization: aGLHProject group name
                                        since: self withCommitsSince
                                        perPage: itemByPage
                                        page: pageNumber).
                foundCommits addAll: tmp ].

        "add the imported commits (unless they are already added to this repository)"
        aGLHProject repository commits
                addAll: foundCommits
                unless: [ :existing :new | existing id = new id ].
        "add the imported commits to the model unles they are already added to the model"
        ^ self glhModel
                  addAll: foundCommits
                  unless: [ :existing :new | existing id = new id ]
]

{ #category : #'import - commits' }
GithubModelImporter >> importCreatorOfCommit: aGLHCommit [

        | creator |
        (self glhModel allWithType: GLHUser)
                detect: [ :user | user username = aGLHCommit author_name ]
                ifFound: [ :user |
                        aGLHCommit commitCreator: user.
                        ^ user ].

        aGLHCommit author_name ifNotNil: [ :author_name |
                creator := self importUserByUsername: author_name.
                aGLHCommit commitCreator: creator ].
        ^ creator
]

{ #category : #api }
GithubModelImporter >> importDiffOfCommit: aGLHCommit [

        | result diffsResult |
        aGLHCommit diffs ifNotEmpty: [
                'Diff already importer: '
                , aGLHCommit short_id printString recordInfo.
                ^ aGLHCommit diffs ].
        ('Import diff of commit: ' , aGLHCommit short_id printString)
                recordInfo.
        result := self repoApi
                          commit: aGLHCommit id
                          ofOrganisation: aGLHCommit repository project group name
                          ofProject: aGLHCommit repository project name.
        diffsResult := self parseDiffresult: result.

        ^ aGLHCommit diffs
                  addAll: diffsResult
                  unless: self blockForDiffEquality
]

{ #category : #api }
GithubModelImporter >> importDirectoryFiles: aDirectoryFile OfBranch: aBranch [

        | result files apiFiles |
        ('Explore ' , aDirectoryFile name) recordInfo.
        result := self api
                          contentsOfRepo: aBranch repository project name
                          ofOrganization: aBranch repository project group name
                          inBranch: aBranch name
                          withPath: aDirectoryFile path.
        apiFiles := self parseFileTreeResult: result.
        files := apiFiles collect: [ :apiFile | 
                         self convertApiFileAsFile: apiFile ].
        files do: [ :file | 
                self glhModel add: file.
                aDirectoryFile addFile: file ].
        files
                select: [ :file | file isKindOf: GLHFileDirectory ]
                thenCollect: [ :file | 
                self importDirectoryFiles: file OfBranch: aBranch ]
]

{ #category : #api }
GithubModelImporter >> importFilesOfBranch: aBranch [

        | result files apiFiles |
        result := self api
                          contentsOfRepo: aBranch repository project name
                          ofOrganization: aBranch repository project group name
                          inBranch: aBranch name
                          withPath: nil.
        apiFiles := self parseFileTreeResult: result.
        files := apiFiles collect: [ :apiFile | 
                         self convertApiFileAsFile: apiFile ].
        files do: [ :file | 
                self glhModel add: file.
                aBranch addFile: file ].
        files
                select: [ :file | file isKindOf: GLHFileDirectory ]
                thenCollect: [ :file | 
                self importDirectoryFiles: file OfBranch: aBranch ]
]

{ #category : #api }
GithubModelImporter >> importGroup: aGroupName [

        | result groupResult |
        result := self repoApi organization: aGroupName.
        groupResult := self parseGroupResult: result.
        self glhModel add: groupResult.
        self importRepositoriesOfGroup: groupResult.
        ^ groupResult
]

{ #category : #'import - merge request' }
GithubModelImporter >> importMergeRequests: aProject [ 
        |response mergeRequests|
        response := self repoApi 
                        mergeRequestsOfRepo: aProject group name 
                        ofProject: aProject name.
        mergeRequests := self parseMergeRequestsResult: response. 
        
        mergeRequests := aProject mergeRequests addAll:mergeRequests unless: self blockOnIdEquality.
        ^ mergeRequests
        
]

{ #category : #api }
GithubModelImporter >> importPipelinesOf: project [

        "add the pipeline (actions runs) in the project"

        | pipelinesResult ghApiPipelineOverview |
        pipelinesResult := self repoApi
                                   actionsRunOfRepo: project name
                                   ofOrganization: project group name.
        ghApiPipelineOverview := self parsePipelinesResult: pipelinesResult.
        ghApiPipelineOverview workflow_runs do: [ :pipeline | 
                project addPipeline: pipeline ]
]

{ #category : #api }
GithubModelImporter >> importProject: aProjectName ofGroup: aGroupName [

        | result projectResult group |
        group := self ensureGroupNamed: aGroupName.
        result := self repoApi organization: aGroupName repo: aProjectName.
        projectResult := self parseProjectResult: result.
        projectResult group: group.
        self glhModel add: projectResult.
        self completeImportedProject: projectResult.
        ^ projectResult
]

{ #category : #api }
GithubModelImporter >> importRepositoriesOfGroup: groupResult [

        | reposResult itemByPage pageNumber reposFound tmp |
        itemByPage := 100.
        pageNumber := 1.
        ('Extract all repository of ' , groupResult name) recordInfo.
        reposFound := OrderedCollection new.
        ('Extract commits from ' , reposFound size printString , ' to '
         , (reposFound size + itemByPage) printString) recordInfo.
        tmp := self parseArrayOfProject: (self repoApi
                                reposOfOrganization: groupResult name
                                perPage: itemByPage
                                page: pageNumber).

        reposFound addAll: tmp.
        [ tmp size = itemByPage ] whileTrue: [
                pageNumber := pageNumber + 1.
                ('Extract issues from ' , reposFound size printString , ' to '
                 , (reposFound size + itemByPage) printString) recordInfo.
                tmp := self parseArrayOfProject: (self repoApi
                                        reposOfOrganization: groupResult name
                                        perPage: itemByPage
                                        page: pageNumber).
                reposFound addAll: tmp ].

        reposResult := self repoApi reposOfOrganization: groupResult name.
        groupResult projects addAll: reposFound.
        self glhModel addAll: groupResult projects.
        groupResult projects do: [ :project |
                self completeImportedProject: project ].
        ^ groupResult
]

{ #category : #api }
GithubModelImporter >> importUser: userID [

        | result userResult |
        (glhModel allWithType: GLHUser)
                detect: [ :user | user id = userID ]
                ifFound: [ :user | ^ user ].
        ('Import user: ' , userID printString) recordInfo.
        result := self repoApi user: userID.
        userResult := self parseUserResult: result.
        ^ glhModel
                  add: userResult
                  unless: [ :current :new | current id = new id ]
]

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

        super initialize.
        self repoApi: GHApi new.
        self repoApi output: 'json'.
        self withCommitDiffs: false.
        withFiles := false
]

{ #category : #parsing }
GithubModelImporter >> parseArrayOfProject: arrayOfProjects [

        | reader |
        reader := NeoJSONReader on: arrayOfProjects readStream.
        reader
                for: #ArrayOfProjects
                customDo: [ :customMappting | 
                customMappting listOfElementSchema: GLHProject ].
        reader for: GLHProject do: [ :mapping | 
                mapping mapInstVar: #name to: #name.
                mapping mapInstVar: #description to: #description.
                mapping mapInstVar: #id to: #id.
                mapping mapInstVar: #archived to: #archived.
                mapping mapInstVar: #web_url to: #html_url.
                mapping mapInstVar: #topics to: #topics ].
        ^ reader nextAs: #ArrayOfProjects
]

{ #category : #parsing }
GithubModelImporter >> parseBranchesResult: arrayOfBranch [

        | reader |
        reader := NeoJSONReader on: arrayOfBranch readStream.
        reader mapInstVarsFor: GLHBranch.
        reader
                for: #ArrayOfBranch
                customDo: [ :customMappting | 
                customMappting listOfElementSchema: GLHBranch ].
        ^ reader nextAs: #ArrayOfBranch
]

{ #category : #parsing }
GithubModelImporter >> parseCommitsResult: result [

        | reader |
        (result includesSubstring: '"status":"409"') ifTrue: [
                GHRepositoryEmptyError signal: 'Git Repository is empty' ].

        reader := NeoJSONReader on: result readStream.

        reader for: GLHCommit do: [ :mapping |
                mapping mapInstVar: #id to: #sha.
                mapping mapInstVar: #web_url to: #html_url.

                mapping
                        mapProperty: #commit
                        getter: [ :object | #ignore ]
                        setter: [ :glhCommit :value |
                                glhCommit message: (value at: #message).
                                glhCommit authored_date:
                                        (DateAndTime fromString: (value at: #author at: #date)).
                                glhCommit committed_date:
                                        (DateAndTime fromString: (value at: #committer at: #date)) ].

                mapping
                        mapProperty: #author
                        getter: [ :object | #ignore ]
                        setter: [ :glhCommit :value |
                                value ifNotNil: [
                                        glhCommit author_name: (value at: #login).
                                        value
                                                at: #id
                                                ifPresent: [ :authorId |
                                                glhCommit commitCreator: (self importUser: authorId) ] ] ].

                mapping
                        mapProperty: #committer
                        getter: [ :object | #ignore ]
                        setter: [ :glhCommit :value |
                                value ifNotNil: [ glhCommit committer_name: (value at: #login) ] ].

                (mapping mapInstVar: #parent_ids to: #parents) valueSchema:
                        #ArrayOfIds ].

        reader for: DateAndTime customDo: [ :mapping |
                mapping decoder: [ :string | DateAndTime fromString: string ] ].

        reader for: #ArrayOfIds customDo: [ :mapping |
                mapping decoder: [ :parents |
                        parents collect: [ :parent | parent at: #sha ] ] ].

        reader
                for: #ArrayOfCommit
                customDo: [ :customMappting |
                customMappting listOfElementSchema: GLHCommit ].


        ^ reader nextAs: #ArrayOfCommit
]

{ #category : #parsing }
GithubModelImporter >> parseDiffresult: response [

        | result |
        result := (response at: #files) collect: [ :file |
                          GLHDiff new
                                  diffString: (file at: #patch);
                                  old_path: (file at: #filename);
                                  new_path: (file at: #filename) ].

        ^ result
]

{ #category : #parsing }
GithubModelImporter >> parseFileTreeResult: aResult [

        | reader |
        reader := NeoJSONReader on: aResult readStream.
        reader mapInstVarsFor: GHApiFile.
        reader
                for: #ArrayOfFile
                customDo: [ :customMappting | 
                customMappting listOfElementSchema: GHApiFile ].
        ^ reader nextAs: #ArrayOfFile
]

{ #category : #parsing }
GithubModelImporter >> parseGroupResult: aResult [

        | reader |
        reader := NeoJSONReader on: aResult readStream.
        reader for: GLHGroup do: [ :mapping | 
                mapping mapInstVar: #name to: #login.
                mapping mapInstVar: #description to: #description.
                mapping mapInstVar: #id to: #id.
                mapping mapInstVar: #web_url to: #html_url ].
        ^ reader nextAs: GLHGroup
]

{ #category : #parsing }
GithubModelImporter >> parseMergeRequestsResult: response [

        | result json|
        self flag: 'temp version, must remade using NeoJsonReader'.
        json := NeoJSONReader fromString: response.
        
        result := json collect: [ :aPull |
                          GLHMergeRequest new
                                  id: (aPull at: #id);
                                  title: (aPull at: #title);
                                  state: (aPull at: #state);
                                  closed_at:
                                          ((aPull at: #closed_at) ifNotNil: #asDateAndTime);
                                  merged_at:
                                          ((aPull at: #merged_at) ifNotNil: #asDateAndTime);
                                  updated_at:
                                          ((aPull at: #updated_at) ifNotNil: #asDateAndTime);
                                  created_at:
                                          ((aPull at: #created_at) ifNotNil: #asDateAndTime);
                                  sha: (aPull at: #head at: #sha);
                                  merge_commit_sha: (aPull at: #merge_commit_sha) ].
        result := self glhModel addAll: result unless: self blockOnIdEquality.
        ^ result
]

{ #category : #parsing }
GithubModelImporter >> parsePipelinesResult: pipelineOverview [

        | reader |
        reader := NeoJSONReader on: pipelineOverview readStream.
        
        reader for: GHAPIPipelineOverview do: [ :mapping |
                mapping mapInstVar: #total_count to: #total_count.
                (mapping mapInstVar: #workflow_runs) valueSchema: #ArrayOfPipelines ].
        
        reader
                for: #ArrayOfPipelines
                customDo: [ :customMappting |
                customMappting listOfElementSchema: GLHPipeline ].
        
        reader for: GLHPipeline do: [ :mapping |
                mapping
                        mapInstVar: #status to: #conclusion;
                        mapProperty: #run_started_at
                        getter: [ :object | #ignore ]
                        setter: [ :object :value |
                                object runDate: (DateAndTime fromString: value) ] ].
        
        ^ reader nextAs: GHAPIPipelineOverview
]

{ #category : #parsing }
GithubModelImporter >> parseProjectResult: aResult [

        | reader |
        reader := NeoJSONReader on: aResult readStream.
        reader for: GLHProject do: [ :mapping |
                mapping mapInstVar: #name to: #name.
                mapping mapInstVar: #description to: #description.
                mapping mapInstVar: #id to: #id.
                mapping mapInstVar: #archived to: #archived.
                mapping mapInstVar: #web_url to: #html_url.
                mapping mapInstVar: #topics to: #topics ].
        ^ reader nextAs: GLHProject
]

{ #category : #parsing }
GithubModelImporter >> parseUserResult: result [

        | reader |
        reader := NeoJSONReader on: result readStream.
        reader for: GLHUser do: [ :mapping |
                mapping mapInstVar: #id to: #id.
                mapping mapInstVar: #public_email to: #email.
                mapping mapInstVar: #username to: #login.
                mapping mapInstVar: #bio to: #bio.
                mapping mapInstVar: #organization to: #company.
                mapping mapInstVar: #followers to: #followers.
                mapping mapInstVar: #following to: #following.
                mapping mapInstVar: #web_url to: #html_url.
                mapping mapInstVar: #name to: #name.
                mapping mapInstVar: #avatar_url to: #avatar_url ].
        ^ reader nextAs: GLHUser
]

{ #category : #api }
GithubModelImporter >> privateToken [
        ^ self api privateToken
]

{ #category : #api }
GithubModelImporter >> privateToken: aTokenString [
        ^ self repoApi privateToken: aTokenString
]

1	Class {
2	#name : #GithubModelImporter,
3	#superclass : #GitModelImporter,
4	#category : #'GitHubHealth-Model-Importer'
5	}
6
7	{ #category : #accessing }
8	GithubModelImporter >> api [	×
9		×
10	self	×
11	deprecated: 'Use #repoApi instead'	×
12	on: '7 October 2024'	×
13	in:	×
14	'Pharo-11.0.0+build.726.sha.aece1b5473acf3830a0e082c1bc3a15d4ff3522b (64 Bit)'.	×
15		×
16	^ repoApi	×
17	]	×
18
19	{ #category : #accessing }
20	GithubModelImporter >> api: anObject [	×
21		×
22	self	×
23	deprecated: 'Use #repoApi: instead'	×
24	on: '7 October 2024'	×
25	in:	×
26	'Pharo-11.0.0+build.726.sha.aece1b5473acf3830a0e082c1bc3a15d4ff3522b (64 Bit)'.	×
27		×
28	repoApi := anObject	×
29	]	×
30
31	{ #category : #commit }
32	GithubModelImporter >> completeImportedCommit: aGLHCommit [	×
33		×
34	\| result \|	×
35	('completing commit: ' , aGLHCommit short_id printString) recordInfo.	×
36	"link commit to user"	×
37	self importCreatorOfCommit: aGLHCommit.	×
38		×
39	"import deletion and addition"	×
40	result := self repoApi	×
41	commit: aGLHCommit id	×
42	ofOrganisation: aGLHCommit repository project group name	×
43	ofProject: aGLHCommit repository project name.	×
44	aGLHCommit deletions:	×
45	((result at: #files) collect: [ :file \| file at: #deletions ]) sum.	×
46	aGLHCommit additions:	×
47	((result at: #files) collect: [ :file \| file at: #additions ]) sum.	×
48		×
49		×
50	"import diffs of this commits"	×
51	self withCommitDiffs ifTrue: [	×
52	\| diffs \|	×
53	aGLHCommit diffs ifEmpty: [	×
54	diffs := self parseDiffresult: result.	×
55	diffs := aGLHCommit diffs	×
56	addAll: diffs	×
57	unless: self blockForDiffEquality.	×
58	self glhModel addAll: diffs unless: self blockForDiffEquality.	×
59	diffs do: [ :diff \| self importDiffRangesForDiff: diff ] ] ].	×
60		×
61	^ aGLHCommit	×
62	]	×
63
64	{ #category : #api }
65	GithubModelImporter >> completeImportedProject: aGLHProject [	×
66		×
67	self importPipelinesOf: aGLHProject.	×
68	self importBranchesOf: aGLHProject.	×
69	self withCommitsSince ifNotNil: [ :withCommitSince \| "If not nil, it means we have to import commit"	×
70	\| commits \|	×
71	commits := self importCommitsOfProject: aGLHProject.	×
72	self chainsCommitsFrom: commits ]	×
73	]	×
74
75	{ #category : #private }
76	GithubModelImporter >> convertApiFileAsFile: aAPIFile [	×
77		×
78	aAPIFile type = 'dir' ifTrue: [	×
79	^ GLHFileDirectory new	×
80	name: aAPIFile name;	×
81	yourself ].	×
82	^ GLHFileBlob new	×
83	name: aAPIFile name;	×
84	yourself	×
85	]	×
86
87	{ #category : #api }
88	GithubModelImporter >> ensureGroupNamed: aGroupName [	×
89		×
90	^ self glhModel	×
91	detect: [ :a \|	×
92	(a isKindOf: GLHGroup) and: [ a name = aGroupName ] ]	×
93	ifNone: [ self glhModel newGroupNamed: aGroupName ]	×
94	]	×
95
96	{ #category : #api }
97	GithubModelImporter >> importBranchesOf: project [	×
98		×
99	"add the pipeline (actions runs) in the project"	×
100		×
101	\| branchesResult branches repository \|	×
102	branchesResult := self repoApi	×
103	branchesOfRepo: project name	×
104	ofOrganization: project group name.	×
105	branches := self parseBranchesResult: branchesResult.	×
106	self glhModel addAll: branches.	×
107	repository := GLHRepository new.	×
108	self glhModel add: repository.	×
109	project repository: repository.	×
110	branches do: [ :branch \|	×
111	repository addBranch: branch.	×
112	self withFiles ifTrue: [ self importFilesOfBranch: branch ] ]	×
113	]	×
114
115	{ #category : #api }
116	GithubModelImporter >> importCommitsOfProject: aGLHProject [	×
117		×
118	\| itemByPage foundCommits tmp pageNumber \|	×
119	itemByPage := 100.	×
120	pageNumber := 1.	×
121	('Extract all commits of ' , aGLHProject name) recordInfo.	×
122	foundCommits := OrderedCollection new.	×
123	('Extract commits from ' , foundCommits size printString , ' to '	×
124	, (foundCommits size + itemByPage) printString) recordInfo.	×
125	"also check that there is at least one commit with the error handling"	×
126	[	×
127	tmp := self parseCommitsResult: (self repoApi	×
128	commitsOfProject: aGLHProject name	×
129	ofOrganization: aGLHProject group name	×
130	since: self withCommitsSince	×
131	perPage: itemByPage	×
132	page: pageNumber) ]	×
133	on: GHRepositoryEmptyError	×
134	do: [ ^ { } ].	×
135		×
136	foundCommits addAll: tmp.	×
137	[ tmp size = itemByPage ] whileTrue: [	×
138	pageNumber := pageNumber + 1.	×
139	('Extract issues from ' , foundCommits size printString , ' to '	×
140	, (foundCommits size + itemByPage) printString) recordInfo.	×
141	tmp := self parseCommitsResult: (self repoApi	×
142	commitsOfProject: aGLHProject name	×
143	ofOrganization: aGLHProject group name	×
144	since: self withCommitsSince	×
145	perPage: itemByPage	×
146	page: pageNumber).	×
147	foundCommits addAll: tmp ].	×
148		×
149	"add the imported commits (unless they are already added to this repository)"	×
150	aGLHProject repository commits	×
151	addAll: foundCommits	×
152	unless: [ :existing :new \| existing id = new id ].	×
153	"add the imported commits to the model unles they are already added to the model"	×
154	^ self glhModel	×
155	addAll: foundCommits	×
156	unless: [ :existing :new \| existing id = new id ]	×
157	]	×
158
159	{ #category : #'import - commits' }
160	GithubModelImporter >> importCreatorOfCommit: aGLHCommit [	×
161		×
162	\| creator \|	×
163	(self glhModel allWithType: GLHUser)	×
164	detect: [ :user \| user username = aGLHCommit author_name ]	×
165	ifFound: [ :user \|	×
166	aGLHCommit commitCreator: user.	×
167	^ user ].	×
168		×
169	aGLHCommit author_name ifNotNil: [ :author_name \|	×
170	creator := self importUserByUsername: author_name.	×
171	aGLHCommit commitCreator: creator ].	×
172	^ creator	×
173	]	×
174
175	{ #category : #api }
176	GithubModelImporter >> importDiffOfCommit: aGLHCommit [	×
177		×
178	\| result diffsResult \|	×
179	aGLHCommit diffs ifNotEmpty: [	×
180	'Diff already importer: '	×
181	, aGLHCommit short_id printString recordInfo.	×
182	^ aGLHCommit diffs ].	×
183	('Import diff of commit: ' , aGLHCommit short_id printString)	×
184	recordInfo.	×
185	result := self repoApi	×
186	commit: aGLHCommit id	×
187	ofOrganisation: aGLHCommit repository project group name	×
188	ofProject: aGLHCommit repository project name.	×
189	diffsResult := self parseDiffresult: result.	×
190		×
191	^ aGLHCommit diffs	×
192	addAll: diffsResult	×
193	unless: self blockForDiffEquality	×
194	]	×
195
196	{ #category : #api }
197	GithubModelImporter >> importDirectoryFiles: aDirectoryFile OfBranch: aBranch [	×
198		×
199	\| result files apiFiles \|	×
200	('Explore ' , aDirectoryFile name) recordInfo.	×
201	result := self api	×
202	contentsOfRepo: aBranch repository project name	×
203	ofOrganization: aBranch repository project group name	×
204	inBranch: aBranch name	×
205	withPath: aDirectoryFile path.	×
206	apiFiles := self parseFileTreeResult: result.	×
207	files := apiFiles collect: [ :apiFile \|	×
208	self convertApiFileAsFile: apiFile ].	×
209	files do: [ :file \|	×
210	self glhModel add: file.	×
211	aDirectoryFile addFile: file ].	×
212	files	×
213	select: [ :file \| file isKindOf: GLHFileDirectory ]	×
214	thenCollect: [ :file \|	×
215	self importDirectoryFiles: file OfBranch: aBranch ]	×
216	]	×
217
218	{ #category : #api }
219	GithubModelImporter >> importFilesOfBranch: aBranch [	×
220		×
221	\| result files apiFiles \|	×
222	result := self api	×
223	contentsOfRepo: aBranch repository project name	×
224	ofOrganization: aBranch repository project group name	×
225	inBranch: aBranch name	×
226	withPath: nil.	×
227	apiFiles := self parseFileTreeResult: result.	×
228	files := apiFiles collect: [ :apiFile \|	×
229	self convertApiFileAsFile: apiFile ].	×
230	files do: [ :file \|	×
231	self glhModel add: file.	×
232	aBranch addFile: file ].	×
233	files	×
234	select: [ :file \| file isKindOf: GLHFileDirectory ]	×
235	thenCollect: [ :file \|	×
236	self importDirectoryFiles: file OfBranch: aBranch ]	×
237	]	×
238
239	{ #category : #api }
240	GithubModelImporter >> importGroup: aGroupName [	×
241		×
242	\| result groupResult \|	×
243	result := self repoApi organization: aGroupName.	×
244	groupResult := self parseGroupResult: result.	×
245	self glhModel add: groupResult.	×
246	self importRepositoriesOfGroup: groupResult.	×
247	^ groupResult	×
248	]	×
249
250	{ #category : #'import - merge request' }
251	GithubModelImporter >> importMergeRequests: aProject [	×
252	\|response mergeRequests\|	×
253	response := self repoApi	×
254	mergeRequestsOfRepo: aProject group name	×
255	ofProject: aProject name.	×
256	mergeRequests := self parseMergeRequestsResult: response.	×
257		×
258	mergeRequests := aProject mergeRequests addAll:mergeRequests unless: self blockOnIdEquality.	×
259	^ mergeRequests	×
260		×
261	]	×
262
263	{ #category : #api }
264	GithubModelImporter >> importPipelinesOf: project [	×
265		×
266	"add the pipeline (actions runs) in the project"	×
267		×
268	\| pipelinesResult ghApiPipelineOverview \|	×
269	pipelinesResult := self repoApi	×
270	actionsRunOfRepo: project name	×
271	ofOrganization: project group name.	×
272	ghApiPipelineOverview := self parsePipelinesResult: pipelinesResult.	×
273	ghApiPipelineOverview workflow_runs do: [ :pipeline \|	×
274	project addPipeline: pipeline ]	×
275	]	×
276
277	{ #category : #api }
278	GithubModelImporter >> importProject: aProjectName ofGroup: aGroupName [	×
279		×
280	\| result projectResult group \|	×
281	group := self ensureGroupNamed: aGroupName.	×
282	result := self repoApi organization: aGroupName repo: aProjectName.	×
283	projectResult := self parseProjectResult: result.	×
284	projectResult group: group.	×
285	self glhModel add: projectResult.	×
286	self completeImportedProject: projectResult.	×
287	^ projectResult	×
288	]	×
289
290	{ #category : #api }
291	GithubModelImporter >> importRepositoriesOfGroup: groupResult [	×
292		×
293	\| reposResult itemByPage pageNumber reposFound tmp \|	×
294	itemByPage := 100.	×
295	pageNumber := 1.	×
296	('Extract all repository of ' , groupResult name) recordInfo.	×
297	reposFound := OrderedCollection new.	×
298	('Extract commits from ' , reposFound size printString , ' to '	×
299	, (reposFound size + itemByPage) printString) recordInfo.	×
300	tmp := self parseArrayOfProject: (self repoApi	×
301	reposOfOrganization: groupResult name	×
302	perPage: itemByPage	×
303	page: pageNumber).	×
304		×
305	reposFound addAll: tmp.	×
306	[ tmp size = itemByPage ] whileTrue: [	×
307	pageNumber := pageNumber + 1.	×
308	('Extract issues from ' , reposFound size printString , ' to '	×
309	, (reposFound size + itemByPage) printString) recordInfo.	×
310	tmp := self parseArrayOfProject: (self repoApi	×
311	reposOfOrganization: groupResult name	×
312	perPage: itemByPage	×
313	page: pageNumber).	×
314	reposFound addAll: tmp ].	×
315		×
316	reposResult := self repoApi reposOfOrganization: groupResult name.	×
317	groupResult projects addAll: reposFound.	×
318	self glhModel addAll: groupResult projects.	×
319	groupResult projects do: [ :project \|	×
320	self completeImportedProject: project ].	×
321	^ groupResult	×
322	]	×
323
324	{ #category : #api }
325	GithubModelImporter >> importUser: userID [	×
326		×
327	\| result userResult \|	×
328	(glhModel allWithType: GLHUser)	×
329	detect: [ :user \| user id = userID ]	×
330	ifFound: [ :user \| ^ user ].	×
331	('Import user: ' , userID printString) recordInfo.	×
332	result := self repoApi user: userID.	×
333	userResult := self parseUserResult: result.	×
334	^ glhModel	×
335	add: userResult	×
336	unless: [ :current :new \| current id = new id ]	×
337	]	×
338
339	{ #category : #initialization }
340	GithubModelImporter >> initialize [	1✔
341		1✔
342	super initialize.	1✔
343	self repoApi: GHApi new.	1✔
344	self repoApi output: 'json'.	1✔
345	self withCommitDiffs: false.	1✔
346	withFiles := false	1✔
347	]	1✔
348
349	{ #category : #parsing }
350	GithubModelImporter >> parseArrayOfProject: arrayOfProjects [	×
351		×
352	\| reader \|	×
353	reader := NeoJSONReader on: arrayOfProjects readStream.	×
354	reader	×
355	for: #ArrayOfProjects	×
356	customDo: [ :customMappting \|	×
357	customMappting listOfElementSchema: GLHProject ].	×
358	reader for: GLHProject do: [ :mapping \|	×
359	mapping mapInstVar: #name to: #name.	×
360	mapping mapInstVar: #description to: #description.	×
361	mapping mapInstVar: #id to: #id.	×
362	mapping mapInstVar: #archived to: #archived.	×
363	mapping mapInstVar: #web_url to: #html_url.	×
364	mapping mapInstVar: #topics to: #topics ].	×
365	^ reader nextAs: #ArrayOfProjects	×
366	]	×
367
368	{ #category : #parsing }
369	GithubModelImporter >> parseBranchesResult: arrayOfBranch [	×
370		×
371	\| reader \|	×
372	reader := NeoJSONReader on: arrayOfBranch readStream.	×
373	reader mapInstVarsFor: GLHBranch.	×
374	reader	×
375	for: #ArrayOfBranch	×
376	customDo: [ :customMappting \|	×
377	customMappting listOfElementSchema: GLHBranch ].	×
378	^ reader nextAs: #ArrayOfBranch	×
379	]	×
380
381	{ #category : #parsing }
382	GithubModelImporter >> parseCommitsResult: result [	1✔
383		1✔
384	\| reader \|	1✔
385	(result includesSubstring: '"status":"409"') ifTrue: [	1✔
386	GHRepositoryEmptyError signal: 'Git Repository is empty' ].	1✔
387		1✔
388	reader := NeoJSONReader on: result readStream.	1✔
389		1✔
390	reader for: GLHCommit do: [ :mapping \|	1✔
391	mapping mapInstVar: #id to: #sha.	1✔
392	mapping mapInstVar: #web_url to: #html_url.	1✔
393		1✔
394	mapping	1✔
395	mapProperty: #commit	1✔
396	getter: [ :object \| #ignore ]	1✔
397	setter: [ :glhCommit :value \|	1✔
398	glhCommit message: (value at: #message).	1✔
399	glhCommit authored_date:	1✔
400	(DateAndTime fromString: (value at: #author at: #date)).	1✔
401	glhCommit committed_date:	1✔
402	(DateAndTime fromString: (value at: #committer at: #date)) ].	1✔
403		1✔
404	mapping	1✔
405	mapProperty: #author	1✔
406	getter: [ :object \| #ignore ]	1✔
407	setter: [ :glhCommit :value \|	1✔
408	value ifNotNil: [	1✔
409	glhCommit author_name: (value at: #login).	1✔
410	value	1✔
411	at: #id	1✔
412	ifPresent: [ :authorId \|	1✔
413	glhCommit commitCreator: (self importUser: authorId) ] ] ].	1✔
414		1✔
415	mapping	1✔
416	mapProperty: #committer	1✔
417	getter: [ :object \| #ignore ]	1✔
418	setter: [ :glhCommit :value \|	1✔
419	value ifNotNil: [ glhCommit committer_name: (value at: #login) ] ].	1✔
420		1✔
421	(mapping mapInstVar: #parent_ids to: #parents) valueSchema:	1✔
422	#ArrayOfIds ].	1✔
423		1✔
424	reader for: DateAndTime customDo: [ :mapping \|	1✔
425	mapping decoder: [ :string \| DateAndTime fromString: string ] ].	1✔
426		1✔
427	reader for: #ArrayOfIds customDo: [ :mapping \|	1✔
428	mapping decoder: [ :parents \|	1✔
429	parents collect: [ :parent \| parent at: #sha ] ] ].	1✔
430		1✔
431	reader	1✔
432	for: #ArrayOfCommit	1✔
433	customDo: [ :customMappting \|	1✔
434	customMappting listOfElementSchema: GLHCommit ].	1✔
435		1✔
436		1✔
437	^ reader nextAs: #ArrayOfCommit	1✔
438	]	1✔
439
440	{ #category : #parsing }
441	GithubModelImporter >> parseDiffresult: response [	×
442		×
443	\| result \|	×
444	result := (response at: #files) collect: [ :file \|	×
445	GLHDiff new	×
446	diffString: (file at: #patch);	×
447	old_path: (file at: #filename);	×
448	new_path: (file at: #filename) ].	×
449		×
450	^ result	×
451	]	×
452
453	{ #category : #parsing }
454	GithubModelImporter >> parseFileTreeResult: aResult [	×
455		×
456	\| reader \|	×
457	reader := NeoJSONReader on: aResult readStream.	×
458	reader mapInstVarsFor: GHApiFile.	×
459	reader	×
460	for: #ArrayOfFile	×
461	customDo: [ :customMappting \|	×
462	customMappting listOfElementSchema: GHApiFile ].	×
463	^ reader nextAs: #ArrayOfFile	×
464	]	×
465
466	{ #category : #parsing }
467	GithubModelImporter >> parseGroupResult: aResult [	×
468		×
469	\| reader \|	×
470	reader := NeoJSONReader on: aResult readStream.	×
471	reader for: GLHGroup do: [ :mapping \|	×
472	mapping mapInstVar: #name to: #login.	×
473	mapping mapInstVar: #description to: #description.	×
474	mapping mapInstVar: #id to: #id.	×
475	mapping mapInstVar: #web_url to: #html_url ].	×
476	^ reader nextAs: GLHGroup	×
477	]	×
478
479	{ #category : #parsing }
480	GithubModelImporter >> parseMergeRequestsResult: response [	×
481		×
NEW 482	\| result json\|	×
483	self flag: 'temp version, must remade using NeoJsonReader'.	×
NEW 484	json := NeoJSONReader fromString: response.	×
NEW 485		×
NEW 486	result := json collect: [ :aPull \|	×
487	GLHMergeRequest new	×
488	id: (aPull at: #id);	×
489	title: (aPull at: #title);	×
490	state: (aPull at: #state);	×
491	closed_at:	×
492	((aPull at: #closed_at) ifNotNil: #asDateAndTime);	×
493	merged_at:	×
494	((aPull at: #merged_at) ifNotNil: #asDateAndTime);	×
495	updated_at:	×
496	((aPull at: #updated_at) ifNotNil: #asDateAndTime);	×
497	created_at:	×
498	((aPull at: #created_at) ifNotNil: #asDateAndTime);	×
499	sha: (aPull at: #head at: #sha);	×
500	merge_commit_sha: (aPull at: #merge_commit_sha) ].	×
501	result := self glhModel addAll: result unless: self blockOnIdEquality.	×
502	^ result	×
503	]	×
504
505	{ #category : #parsing }
506	GithubModelImporter >> parsePipelinesResult: pipelineOverview [	1✔
507		1✔
508	\| reader \|	1✔
509	reader := NeoJSONReader on: pipelineOverview readStream.	1✔
510		1✔
511	reader for: GHAPIPipelineOverview do: [ :mapping \|	1✔
512	mapping mapInstVar: #total_count to: #total_count.	1✔
513	(mapping mapInstVar: #workflow_runs) valueSchema: #ArrayOfPipelines ].	1✔
514		1✔
515	reader	1✔
516	for: #ArrayOfPipelines	1✔
517	customDo: [ :customMappting \|	1✔
518	customMappting listOfElementSchema: GLHPipeline ].	1✔
519		1✔
520	reader for: GLHPipeline do: [ :mapping \|	1✔
521	mapping	1✔
522	mapInstVar: #status to: #conclusion;	1✔
523	mapProperty: #run_started_at	1✔
524	getter: [ :object \| #ignore ]	1✔
525	setter: [ :object :value \|	1✔
526	object runDate: (DateAndTime fromString: value) ] ].	1✔
527		1✔
528	^ reader nextAs: GHAPIPipelineOverview	1✔
529	]	1✔
530
531	{ #category : #parsing }
532	GithubModelImporter >> parseProjectResult: aResult [	×
533		×
534	\| reader \|	×
535	reader := NeoJSONReader on: aResult readStream.	×
536	reader for: GLHProject do: [ :mapping \|	×
537	mapping mapInstVar: #name to: #name.	×
538	mapping mapInstVar: #description to: #description.	×
539	mapping mapInstVar: #id to: #id.	×
540	mapping mapInstVar: #archived to: #archived.	×
541	mapping mapInstVar: #web_url to: #html_url.	×
542	mapping mapInstVar: #topics to: #topics ].	×
543	^ reader nextAs: GLHProject	×
544	]	×
545
546	{ #category : #parsing }
547	GithubModelImporter >> parseUserResult: result [	1✔
548		1✔
549	\| reader \|	1✔
550	reader := NeoJSONReader on: result readStream.	1✔
551	reader for: GLHUser do: [ :mapping \|	1✔
552	mapping mapInstVar: #id to: #id.	1✔
553	mapping mapInstVar: #public_email to: #email.	1✔
554	mapping mapInstVar: #username to: #login.	1✔
555	mapping mapInstVar: #bio to: #bio.	1✔
556	mapping mapInstVar: #organization to: #company.	1✔
557	mapping mapInstVar: #followers to: #followers.	1✔
558	mapping mapInstVar: #following to: #following.	1✔
559	mapping mapInstVar: #web_url to: #html_url.	1✔
560	mapping mapInstVar: #name to: #name.	1✔
561	mapping mapInstVar: #avatar_url to: #avatar_url ].	1✔
562	^ reader nextAs: GLHUser	1✔
563	]	1✔
564
565	{ #category : #api }
566	GithubModelImporter >> privateToken [	×
567	^ self api privateToken	×
568	]	×
569
570	{ #category : #api }
571	GithubModelImporter >> privateToken: aTokenString [	×
572	^ self repoApi privateToken: aTokenString	×
573	]	×

moosetechnology / GitProjectHealth / 16967431324

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