11368607478

Committed 16 Oct 2024 03:13PM UTC coverage: 57.994% (-0.6%) from 58.623%

Build # 11368607478

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #83 from moosetechnology/feature/commitdiff-githubImporter

WIP Feature/commitdiff GitHub importer

Run Details

16 of 216 new or added lines in 6 files covered. (7.41%)

10 existing lines in 1 file now uncovered.

8963 of 15455 relevant lines covered (57.99%)

0.58 hits per line

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

74.85

/src/BitBucketHealth-Model-Importer/BitBucketModelImporter.class.st

Class {
        #name : #BitBucketModelImporter,
        #superclass : #GPModelImporter,
        #instVars : [
                'withInitialCommits'
        ],
        #category : #'BitBucketHealth-Model-Importer'
}

{ #category : #accessing }
BitBucketModelImporter >> bitBucketApi [

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

        ^ repoApi
]

{ #category : #accessing }
BitBucketModelImporter >> bitBucketApi: anObject [

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

        repoApi := anObject
]

{ #category : #'private - api' }
BitBucketModelImporter >> completeImportProject: aGLHProject [

        aGLHProject repository: GLHRepository new.
        self glhModel add: aGLHProject repository.
        "TODO: import repository"
        ^ aGLHProject
]

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

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

        ^ aCommit
]

{ #category : #convert }
BitBucketModelImporter >> convertBitBucketDiffToGitDiff: response [

        | bitbucketDiff filePath fromHash toHash sourceLine sourceSpan destinationLine destinationSpan result filePathSource filePathDestination |
        fromHash := (response at: 'fromHash') ifNil: ''.
        toHash := (response at: 'toHash') ifNil: ''.

        
        "Iterate over each diff in 'diffs'"
        result := (response at: #diffs) collect: [ :diff | "Extract file path, hashes"
                |gitDiff|
                gitDiff := ''.
                          filePathSource := (diff at: 'source')
                                                    ifNil: ''
                                                    ifNotNil: [ :source |
                                                    source at: 'toString' ].
                          filePathDestination := (diff at: 'destination')
                                                         ifNil: ''
                                                         ifNotNil: [ :destination |
                                                         destination at: 'toString' ].

                          "Build the diff header"
                          " gitDiff := gitDiff , 'diff --git a/', filePath, ' b/', filePath, String cr."
                          " gitDiff := gitDiff , 'index ', fromHash, '..', toHash, ' 100644', String cr."
                          gitDiff := gitDiff , '--- a/' , filePathSource , String cr.
                          gitDiff := gitDiff , '+++ b/' , filePathDestination
                                     , String cr.

                          "Iterate over hunks"
                          (diff at: 'hunks') do: [ :hunk |
                                  sourceLine := hunk at: 'sourceLine'.
                                  sourceSpan := hunk at: 'sourceSpan'.
                                  destinationLine := hunk at: 'destinationLine'.
                                  destinationSpan := hunk at: 'destinationSpan'.

                                  "Hunk header"
                                  gitDiff := gitDiff
                                             , ('@@ -{1},{2} +{3},{4} @@' format: {
                                                                      sourceLine.
                                                                      sourceSpan.
                                                                      destinationLine.
                                                                      destinationSpan }) , String cr.

                                  "Iterate over segments"
                                  (hunk at: 'segments') do: [ :segment |
                                          (segment at: 'lines') do: [ :line |
                                                                (segment at: 'type') = 'CONTEXT' ifTrue: [
                                                          gitDiff := gitDiff , (line at: 'line')
                                                                     , String cr ].
                                                                (segment at: 'type') = 'REMOVED' ifTrue: [
                                                          gitDiff := gitDiff , '-' , (line at: 'line')
                                                                     , String cr ].
                                                  (segment at: 'type') = 'ADDED' ifTrue: [
                                                          gitDiff := gitDiff , '+' , (line at: 'line')
                                                                     , String cr ] ] ] ].
                          GLHDiff new
                                  diffString: gitDiff;
                                  old_path: filePathSource;
                                  new_path: filePathDestination ].

        ^ result
]

{ #category : #'private - api' }
BitBucketModelImporter >> getContributionFromDiffs: diffs [

        | contribution |
        contribution := {
                                ('additions' -> 0).
                                ('deletions' -> 0) } asDictionary.

        diffs do: [ :diff |
                | hunks segments |
                hunks := diff at: #hunks ifAbsent: Array new.

                hunks do: [ :hunk |
                        | addedSegment removedSegment |
                        segments := hunk at: #segments.

                        addedSegment := segments
                                                detect: [ :segment |
                                                (segment at: #type) = 'ADDED' ]
                                                ifNone: [ nil ].
                        removedSegment := segments
                                                  detect: [ :segment |
                                                  (segment at: #type) = 'REMOVED' ]
                                                  ifNone: [ nil ].

                        addedSegment ifNotNil: [
                                contribution
                                        at: #additions
                                        put:
                                        (contribution at: #additions) + (addedSegment at: #lines) size ].
                        removedSegment ifNotNil: [
                                contribution
                                        at: #deletions
                                        put:
                                        (contribution at: #deletions) + (removedSegment at: #lines) size ] ] ].

        ^ contribution
]

{ #category : #'comment import' }
BitBucketModelImporter >> importAndLoadLatestsCommitsOfProject: aGLHProject [ 
        
        ^ self importCommitsOfProject: aGLHProject since: (Date today - 3 week) asDateAndTime  until: Date today asDateAndTime 
]

{ #category : #'import - commits' }
BitBucketModelImporter >> importCommitsOfProject: aGLHProject since: since until: until [

        | commits |
        commits := self repoApi
                           commitsOfRepoProjectId: aGLHProject id
                           inProjectGroupId: aGLHProject group id
                           since: since
                           until: until.

        commits := commits collect: [ :commit |
                           | glhCommit commitDiffs contribution |
                           glhCommit := self parseCommitIntoGLHCommit: commit.
                           commitDiffs := self repoApi
                                                  diffsOfCommit: glhCommit id
                                                  inRepoProjectId: aGLHProject id
                                                  inProjectGroupId: aGLHProject group id.

                           contribution := self getContributionFromDiffs:
                                                   (commitDiffs at: #diffs).
                           glhCommit additions: (contribution at: #additions).
                           glhCommit deletions: (contribution at: #deletions).
                           glhCommit ].

        
        commits := self glhModel addAll: commits unless: self blockOnIdEquality.
        ^ aGLHProject repository commits addAll: commits unless: self blockOnIdEquality.
]

{ #category : #'import - projects' }
BitBucketModelImporter >> importContributedProjectsOfUser: aGLHUser [

        | projects repositories repositoriesCommits userRepositories userProjects |
        "get all projects"
        projects := self repoApi projects.

        "get all repos of projects"
        repositories := projects flatCollect: [ :project |
                                self repoApi repositoryProjectsOfProjectGroupId:
                                        (project at: #key) ].


        "get all commits of repo"
        repositoriesCommits := repositories collect: [ :repository |
                                       repository -> (self repoApi
                                                commitsOfRepoProjectId: (repository at: #slug)
                                                inProjectGroupId:
                                                ((repository at: #project) at: #key)
                                                since: DateAndTime now - 10 days
                                                until: DateAndTime now) ].


        "look if user is author of min one commit"
        userRepositories := repositoriesCommits select: [ :repository |
                                    | repos |
                                    repos := repository value
                                                     ifEmpty: [ false ]
                                                     ifNotEmpty: [
                                                             repository value
                                                                     detect: [ :commit |
                                                                     ((commit at: #author) at: #name)
                                                                     = aGLHUser username ]
                                                                     ifFound: [ true ]
                                                                     ifNone: [ false ] ] ].


        "Transform user repositories in GLHProject"
        userProjects := userRepositories collect: [ :repoCommits |
                                | repo project |
                                repo := repoCommits key.
                                project := repo at: #project.

                                (self glhModel allWithType: GLHProject)
                                        detect: [ :glhProject |
                                        glhProject id = (project at: #key) ]
                                        ifFound: [ :glhProject | glhProject ]
                                        ifNone: [
                                                | glhProject |
                                                glhProject := self parseRepoIntoGLHProject: repo.
                                                glhModel add: glhProject.
                                                glhProject ] ].

        aGLHUser contributedProjects: userProjects.

        ^ userProjects
]

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

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

        creator := self importUserByUsername: aGLHCommit author_name.
        aGLHCommit commitCreator: creator.
        ^ creator
]

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

        | result diffsResult |
        aCommit diffs ifNotEmpty: [
                'Diff already importer: ' , aCommit short_id printString recordInfo.
                ^ aCommit diffs ].
        ('Import diff of commit: ' , aCommit short_id printString) recordInfo.
        result := self repoApi
                          diffsOfCommit: aCommit id
                          inRepoProjectId: aCommit repository project id
                          inProjectGroupId: aCommit repository project group id.

        diffsResult := self convertBitBucketDiffToGitDiff: result.


        diffsResult := aCommit diffs
                               addAll: diffsResult
                               unless: self blockForDiffEquality.

        "changes are added into the model during the import"
        diffsResult do: [ :diff | self importDiffRangesForDiff: diff ].

        ^ diffsResult
]

{ #category : #'import - merge-requests' }
BitBucketModelImporter >> importMergeRequestCommits: mergeRequest [

        | commits |
        commits := self repoApi
                           commitsOfPullRequest: mergeRequest id
                           ofRepoProjectId: mergeRequest project id
                           inProjectGroupId: mergeRequest project group id.

        commits := commits collect: [ :commit |
                           self parseCommitIntoGLHCommit: commit ].

        mergeRequest commits: commits.

        ^ commits
]

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

        | pullRequests |
        pullRequests := self repoApi
                                pullRequestsOfRepoProjectId: aGLHProject id
                                inProjectGroupId: aGLHProject group id
                                since: fromDate
                                until: toDate.

        pullRequests := pullRequests collect: [ :pullRequest |
                                self parsePullRequestIntoGLPHEMergeRequest:
                                        pullRequest ].

        pullRequests := self glhModel addAll: pullRequests unless: self blockOnIdEquality.

        ^ pullRequests
]

{ #category : #'import - merge-requests' }
BitBucketModelImporter >> importMergeResquestAuthor: mergeRequest [
        mergeRequest author ifNotNil: [ ^mergeRequest ]
]

{ #category : #'import - merge-requests' }
BitBucketModelImporter >> importMergeResquestMerger: mergeRequest [

        | activities mergeActivity mergeUser |
        mergeRequest merge_user ifNotNil: [ ^ mergeRequest merge_user ].
        mergeRequest state = 'merged' ifFalse: [ ^ nil ].

        activities := self repoApi
                              activitiesOfPullRequest: mergeRequest id
                              inRepoProjectId: mergeRequest project id
                              ofProjectGroupId: mergeRequest project group id.

        mergeActivity := activities detect: [ :activity |
                                 (activity at: #action) = 'MERGED' ].

        mergeUser := mergeActivity at: #user.

        mergeUser := (glhModel allWithType: GLHUser)
                             detect: [ :user | user id = (mergeUser at: #id) ]
                             ifFound: [ :user | user ]
                             ifNone: [
                                     | glhUser |
                                     glhUser := self parseUserIntoGLHUser: mergeUser.
                                     glhModel add: glhUser.
                                     glhUser ].

        mergeRequest merge_user: mergeUser.
        ^ mergeUser
]

{ #category : #'import - users' }
BitBucketModelImporter >> importUserByUsername: username [

         

        ^ self userCatalogue collectUsernames at: username ifAbsent: [
                |users glhUser user|
                
                users := self repoApi usersByUsername: username.
                users ifEmpty: [ ^ nil ].
                user := users first.

                glhUser := self parseUserIntoGLHUser: user.
                self glhModel add: glhUser unless: self blockOnIdEquality.
                self userCatalogue addUser: glhUser withName: username. 
                glhUser
                 ].
        
        
]

{ #category : #parsing }
BitBucketModelImporter >> parseCommitIntoGLHCommit: commitDictionary [

        | author committer parentIds |
        author := commitDictionary at: #author.
        committer := commitDictionary at: #committer.

        parentIds := (commitDictionary at: #parents) collect: [ :parent |
                             parent at: #id ].

        ^ GLHCommit new
                  id: (commitDictionary at: #id);
                  message: (commitDictionary at: #message);
                  author_email: (author at: #emailAddress);
                  author_name: (author at: #name);
                  authored_date: (DateAndTime fromUnixTime:
                                           (commitDictionary at: #authorTimestamp) / 1000);
                  created_at: (DateAndTime fromUnixTime:
                                           (commitDictionary at: #authorTimestamp) / 1000);
                  committed_date: (DateAndTime fromUnixTime:
                                           (commitDictionary at: #committerTimestamp) / 1000);
                  committer_email: (committer at: #emailAddress);
                  committer_name: (committer at: #name);
                  parent_ids: parentIds
]

{ #category : #parsing }
BitBucketModelImporter >> parseProjectIntoGLHGroup: projectRepository [

        ^GLHGroup new
                                                     name: (projectRepository at: #name);
                                                     id: (projectRepository at: #key);
                                                     description: (projectRepository at: #description).
]

{ #category : #parsing }
BitBucketModelImporter >> parsePullRequestIntoGLPHEMergeRequest: pullRequestDictionary [

        | repository project toRef fromRef glpheMergeRequest author state reviewers |
        toRef := pullRequestDictionary at: #toRef.
        fromRef := pullRequestDictionary at: #fromRef.
        
        reviewers := pullRequestDictionary at: #reviewers.
        reviewers := reviewers collect: [ :reviewer | 
                |reviewerUser|
                reviewerUser := reviewer at: #user.
                (self glhModel allWithType: GLHUser) detect: [ :user | user id = (reviewerUser at: #id) ]         ifFound: [ :user | user ] ifNone: [ 
                        |glhUser|
                        glhUser := self parseUserIntoGLHUser: reviewerUser.
                        glhModel  add: glhUser.
                        glhUser.                
                ]
                
        ].

        repository := toRef at: #repository.
        project := (self glhModel allWithType: GLHProject)
                           detect: [ :glhProject |
                           glhProject id = (repository at: #id) ]
                           ifFound: [ :glhProject | glhProject ]
                           ifNone: [
                                   project := self parseRepoIntoGLHProject: repository.
                                   self glhModel add: project.
                                   project ].


        author := pullRequestDictionary at: #author.
        author := (self glhModel allWithType: GLHUser)
                          detect: [ :user | user id = ((author at: #user) at: #id) ]
                          ifFound: [ :user | user ]
                          ifNone: [
                          self importUserByUsername:
                                  ((author at: #user) at: #displayName) ].


        glpheMergeRequest := GLPHEMergeRequest new
                                     name: (pullRequestDictionary at: #title);
                                     title: (pullRequestDictionary at: #title);
                                     id: (pullRequestDictionary at: #id);
                                     project: project;
                                     project_id: project id;
                                     target_branch: (toRef at: #id);
                                     target_project_id:
                                             ((toRef at: #repository) at: #id);
                                     source_branch: (fromRef at: #id);
                                     target_project_id:
                                             ((fromRef at: #repository) at: #id);
                                     updated_at: (DateAndTime fromUnixTime:
                                                              (pullRequestDictionary at: #updatedDate)
                                                              / 1000);
                                     created_at: (DateAndTime fromUnixTime:
                                                              (pullRequestDictionary at: #createdDate)
                                                              / 1000);
                                     author: author.

        "STATE"
        state := pullRequestDictionary at: #state.
        state = 'OPEN' ifTrue: [ glpheMergeRequest state: 'opened' ].
        state = 'MERGED' ifTrue: [
                glpheMergeRequest state: 'merged'.
                glpheMergeRequest merged_at: (DateAndTime fromUnixTime:
                                 (pullRequestDictionary at: #closedDate) / 1000) ].

        state = 'DECLINED' ifTrue: [
                glpheMergeRequest state: 'closed'.
                glpheMergeRequest closed_at: (DateAndTime fromUnixTime:
                                 (pullRequestDictionary at: #closedDate) / 1000) ].

        ^ glpheMergeRequest
]

{ #category : #parsing }
BitBucketModelImporter >> parseRepoIntoGLHProject: repositoryDictionary [

        | project group glhProject |
        project := repositoryDictionary at: #project.

        group := (self glhModel allWithType: GLHGroup)
                         detect: [ :glhGroup | glhGroup id = (project at: #key) ]
                         ifFound: [ :glhGroup | glhGroup ]
                         ifNone: [
                                 | newGroup |
                                 newGroup := self parseProjectIntoGLHGroup: project.
                                 glhModel add: newGroup.
                                 newGroup ].


        glhProject := GLHProject new
                              name: (repositoryDictionary at: #name);
                              id: (repositoryDictionary at: #slug);
                                                  repository: GLHRepository new;
                              group: group.

        group addProject: glhProject.

        ^ glhProject
]

{ #category : #parsing }
BitBucketModelImporter >> parseUserIntoGLHUser: userDictionnary [

        ^ GLHUser new name: (userDictionnary at: #displayName);
                public_email: (userDictionnary at: #emailAddress);
                id: (userDictionnary at: #id);
                username: (userDictionnary at: #name).
]

{ #category : #accessing }
BitBucketModelImporter >> withInitialCommits [

        ^ withInitialCommits
]

{ #category : #accessing }
BitBucketModelImporter >> withInitialCommits: anObject [

        withInitialCommits := anObject
]

1	Class {
2	#name : #BitBucketModelImporter,
3	#superclass : #GPModelImporter,
4	#instVars : [
5	'withInitialCommits'
6	],
7	#category : #'BitBucketHealth-Model-Importer'
8	}
9
10	{ #category : #accessing }
11	BitBucketModelImporter >> bitBucketApi [	×
12		×
13	self	×
14	deprecated: 'Use #repoApi instead'	×
15	on: '7 October 2024'	×
16	in:	×
17	'Pharo-11.0.0+build.726.sha.aece1b5473acf3830a0e082c1bc3a15d4ff3522b (64 Bit)'.	×
18		×
19	^ repoApi	×
20	]	×
21
22	{ #category : #accessing }
23	BitBucketModelImporter >> bitBucketApi: anObject [	1✔
24		1✔
25	self	1✔
26	deprecated: 'Use #repoApi: instead'	1✔
27	on: '7 October 2024'	1✔
28	in:	1✔
29	'Pharo-11.0.0+build.726.sha.aece1b5473acf3830a0e082c1bc3a15d4ff3522b (64 Bit)'.	1✔
30		1✔
31	repoApi := anObject	1✔
32	]	1✔
33
34	{ #category : #'private - api' }
35	BitBucketModelImporter >> completeImportProject: aGLHProject [	1✔
36		1✔
37	aGLHProject repository: GLHRepository new.	1✔
38	self glhModel add: aGLHProject repository.	1✔
39	"TODO: import repository"	1✔
40	^ aGLHProject	1✔
41	]	1✔
42
43	{ #category : #commit }
44	BitBucketModelImporter >> completeImportedCommit: aCommit [	×
45		×
46	('completing commit: ' , aCommit short_id printString) recordInfo.	×
47	self importCreatorOfCommit: aCommit.	×
48		×
49	self withCommitDiffs ifTrue: [	×
50	\| diffs \|	×
51	aCommit diffs ifEmpty: [	×
52	diffs := self importDiffOfCommit: aCommit.	×
53	self glhModel addAll: diffs unless: self blockForDiffEquality ] ].	×
54		×
55	^ aCommit	×
56	]	×
57
58	{ #category : #convert }
59	BitBucketModelImporter >> convertBitBucketDiffToGitDiff: response [	×
60		×
61	\| bitbucketDiff filePath fromHash toHash sourceLine sourceSpan destinationLine destinationSpan result filePathSource filePathDestination \|	×
62	fromHash := (response at: 'fromHash') ifNil: ''.	×
63	toHash := (response at: 'toHash') ifNil: ''.	×
64		×
65		×
66	"Iterate over each diff in 'diffs'"	×
67	result := (response at: #diffs) collect: [ :diff \| "Extract file path, hashes"	×
68	\|gitDiff\|	×
69	gitDiff := ''.	×
70	filePathSource := (diff at: 'source')	×
71	ifNil: ''	×
72	ifNotNil: [ :source \|	×
73	source at: 'toString' ].	×
74	filePathDestination := (diff at: 'destination')	×
75	ifNil: ''	×
76	ifNotNil: [ :destination \|	×
77	destination at: 'toString' ].	×
78		×
79	"Build the diff header"	×
80	" gitDiff := gitDiff , 'diff --git a/', filePath, ' b/', filePath, String cr."	×
81	" gitDiff := gitDiff , 'index ', fromHash, '..', toHash, ' 100644', String cr."	×
82	gitDiff := gitDiff , '--- a/' , filePathSource , String cr.	×
83	gitDiff := gitDiff , '+++ b/' , filePathDestination	×
84	, String cr.	×
85		×
86	"Iterate over hunks"	×
87	(diff at: 'hunks') do: [ :hunk \|	×
88	sourceLine := hunk at: 'sourceLine'.	×
89	sourceSpan := hunk at: 'sourceSpan'.	×
90	destinationLine := hunk at: 'destinationLine'.	×
91	destinationSpan := hunk at: 'destinationSpan'.	×
92		×
93	"Hunk header"	×
94	gitDiff := gitDiff	×
95	, ('@@ -{1},{2} +{3},{4} @@' format: {	×
96	sourceLine.	×
97	sourceSpan.	×
98	destinationLine.	×
99	destinationSpan }) , String cr.	×
100		×
101	"Iterate over segments"	×
102	(hunk at: 'segments') do: [ :segment \|	×
103	(segment at: 'lines') do: [ :line \|	×
104	(segment at: 'type') = 'CONTEXT' ifTrue: [	×
105	gitDiff := gitDiff , (line at: 'line')	×
106	, String cr ].	×
107	(segment at: 'type') = 'REMOVED' ifTrue: [	×
108	gitDiff := gitDiff , '-' , (line at: 'line')	×
109	, String cr ].	×
110	(segment at: 'type') = 'ADDED' ifTrue: [	×
111	gitDiff := gitDiff , '+' , (line at: 'line')	×
112	, String cr ] ] ] ].	×
113	GLHDiff new	×
114	diffString: gitDiff;	×
115	old_path: filePathSource;	×
116	new_path: filePathDestination ].	×
117		×
118	^ result	×
119	]	×
120
121	{ #category : #'private - api' }
122	BitBucketModelImporter >> getContributionFromDiffs: diffs [	1✔
123		1✔
124	\| contribution \|	1✔
125	contribution := {	1✔
126	('additions' -> 0).	1✔
127	('deletions' -> 0) } asDictionary.	1✔
128		1✔
129	diffs do: [ :diff \|	1✔
130	\| hunks segments \|	1✔
131	hunks := diff at: #hunks ifAbsent: Array new.	1✔
132		1✔
133	hunks do: [ :hunk \|	1✔
134	\| addedSegment removedSegment \|	1✔
135	segments := hunk at: #segments.	1✔
136		1✔
137	addedSegment := segments	1✔
138	detect: [ :segment \|	1✔
139	(segment at: #type) = 'ADDED' ]	1✔
140	ifNone: [ nil ].	1✔
141	removedSegment := segments	1✔
142	detect: [ :segment \|	1✔
143	(segment at: #type) = 'REMOVED' ]	1✔
144	ifNone: [ nil ].	1✔
145		1✔
146	addedSegment ifNotNil: [	1✔
147	contribution	1✔
148	at: #additions	1✔
149	put:	1✔
150	(contribution at: #additions) + (addedSegment at: #lines) size ].	1✔
151	removedSegment ifNotNil: [	1✔
152	contribution	1✔
153	at: #deletions	1✔
154	put:	1✔
155	(contribution at: #deletions) + (removedSegment at: #lines) size ] ] ].	1✔
156		1✔
157	^ contribution	1✔
158	]	1✔
159
160	{ #category : #'comment import' }
161	BitBucketModelImporter >> importAndLoadLatestsCommitsOfProject: aGLHProject [	×
162		×
163	^ self importCommitsOfProject: aGLHProject since: (Date today - 3 week) asDateAndTime until: Date today asDateAndTime	×
164	]	×
165
166	{ #category : #'import - commits' }
167	BitBucketModelImporter >> importCommitsOfProject: aGLHProject since: since until: until [	1✔
168		1✔
169	\| commits \|	1✔
170	commits := self repoApi	1✔
171	commitsOfRepoProjectId: aGLHProject id	1✔
172	inProjectGroupId: aGLHProject group id	1✔
173	since: since	1✔
174	until: until.	1✔
175		1✔
176	commits := commits collect: [ :commit \|	1✔
177	\| glhCommit commitDiffs contribution \|	1✔
178	glhCommit := self parseCommitIntoGLHCommit: commit.	1✔
179	commitDiffs := self repoApi	1✔
180	diffsOfCommit: glhCommit id	1✔
181	inRepoProjectId: aGLHProject id	1✔
182	inProjectGroupId: aGLHProject group id.	1✔
183		1✔
184	contribution := self getContributionFromDiffs:	1✔
185	(commitDiffs at: #diffs).	1✔
186	glhCommit additions: (contribution at: #additions).	1✔
187	glhCommit deletions: (contribution at: #deletions).	1✔
188	glhCommit ].	1✔
189		1✔
190		1✔
191	commits := self glhModel addAll: commits unless: self blockOnIdEquality.	1✔
192	^ aGLHProject repository commits addAll: commits unless: self blockOnIdEquality.	1✔
193	]	1✔
194
195	{ #category : #'import - projects' }
196	BitBucketModelImporter >> importContributedProjectsOfUser: aGLHUser [	1✔
197		1✔
198	\| projects repositories repositoriesCommits userRepositories userProjects \|	1✔
199	"get all projects"	1✔
200	projects := self repoApi projects.	1✔
201		1✔
202	"get all repos of projects"	1✔
203	repositories := projects flatCollect: [ :project \|	1✔
204	self repoApi repositoryProjectsOfProjectGroupId:	1✔
205	(project at: #key) ].	1✔
206		1✔
207		1✔
208	"get all commits of repo"	1✔
209	repositoriesCommits := repositories collect: [ :repository \|	1✔
210	repository -> (self repoApi	1✔
211	commitsOfRepoProjectId: (repository at: #slug)	1✔
212	inProjectGroupId:	1✔
213	((repository at: #project) at: #key)	1✔
214	since: DateAndTime now - 10 days	1✔
215	until: DateAndTime now) ].	1✔
216		1✔
217		1✔
218	"look if user is author of min one commit"	1✔
219	userRepositories := repositoriesCommits select: [ :repository \|	1✔
220	\| repos \|	1✔
221	repos := repository value	1✔
222	ifEmpty: [ false ]	1✔
223	ifNotEmpty: [	1✔
224	repository value	1✔
225	detect: [ :commit \|	1✔
226	((commit at: #author) at: #name)	1✔
227	= aGLHUser username ]	1✔
228	ifFound: [ true ]	1✔
229	ifNone: [ false ] ] ].	1✔
230		1✔
231		1✔
232	"Transform user repositories in GLHProject"	1✔
233	userProjects := userRepositories collect: [ :repoCommits \|	1✔
234	\| repo project \|	1✔
235	repo := repoCommits key.	1✔
236	project := repo at: #project.	1✔
237		1✔
238	(self glhModel allWithType: GLHProject)	1✔
239	detect: [ :glhProject \|	1✔
240	glhProject id = (project at: #key) ]	1✔
241	ifFound: [ :glhProject \| glhProject ]	1✔
242	ifNone: [	1✔
243	\| glhProject \|	1✔
244	glhProject := self parseRepoIntoGLHProject: repo.	1✔
245	glhModel add: glhProject.	1✔
246	glhProject ] ].	1✔
247		1✔
248	aGLHUser contributedProjects: userProjects.	1✔
249		1✔
250	^ userProjects	1✔
251	]	1✔
252
253	{ #category : #'import - commits' }
254	BitBucketModelImporter >> importCreatorOfCommit: aGLHCommit [	1✔
255		1✔
256	\| creator \|	1✔
257	(self glhModel allWithType: GLHUser)	1✔
258	detect: [ :user \| user username = aGLHCommit author_name ]	1✔
259	ifFound: [ :user \|	1✔
260	aGLHCommit commitCreator: user.	1✔
261	^ user ].	1✔
262		1✔
263	creator := self importUserByUsername: aGLHCommit author_name.	1✔
264	aGLHCommit commitCreator: creator.	1✔
265	^ creator	1✔
266	]	1✔
267
268	{ #category : #api }
269	BitBucketModelImporter >> importDiffOfCommit: aCommit [	×
270		×
271	\| result diffsResult \|	×
272	aCommit diffs ifNotEmpty: [	×
273	'Diff already importer: ' , aCommit short_id printString recordInfo.	×
274	^ aCommit diffs ].	×
275	('Import diff of commit: ' , aCommit short_id printString) recordInfo.	×
276	result := self repoApi	×
277	diffsOfCommit: aCommit id	×
278	inRepoProjectId: aCommit repository project id	×
279	inProjectGroupId: aCommit repository project group id.	×
280		×
281	diffsResult := self convertBitBucketDiffToGitDiff: result.	×
282		×
283		×
NEW 284	diffsResult := aCommit diffs	×
NEW 285	addAll: diffsResult	×
NEW 286	unless: self blockForDiffEquality.	×
287		×
288	"changes are added into the model during the import"	×
NEW 289	diffsResult do: [ :diff \| self importDiffRangesForDiff: diff ].	×
290		×
NEW 291	^ diffsResult	×
292	]	×
293
294	{ #category : #'import - merge-requests' }
295	BitBucketModelImporter >> importMergeRequestCommits: mergeRequest [	1✔
296		1✔
297	\| commits \|	1✔
298	commits := self repoApi	1✔
299	commitsOfPullRequest: mergeRequest id	1✔
300	ofRepoProjectId: mergeRequest project id	1✔
301	inProjectGroupId: mergeRequest project group id.	1✔
302		1✔
303	commits := commits collect: [ :commit \|	1✔
304	self parseCommitIntoGLHCommit: commit ].	1✔
305		1✔
306	mergeRequest commits: commits.	1✔
307		1✔
308	^ commits	1✔
309	]	1✔
310
311	{ #category : #'import - merge-requests' }
312	BitBucketModelImporter >> importMergeRequests: aGLHProject since: fromDate until: toDate [	1✔
313		1✔
314	\| pullRequests \|	1✔
315	pullRequests := self repoApi	1✔
316	pullRequestsOfRepoProjectId: aGLHProject id	1✔
317	inProjectGroupId: aGLHProject group id	1✔
318	since: fromDate	1✔
319	until: toDate.	1✔
320		1✔
321	pullRequests := pullRequests collect: [ :pullRequest \|	1✔
322	self parsePullRequestIntoGLPHEMergeRequest:	1✔
323	pullRequest ].	1✔
324		1✔
325	pullRequests := self glhModel addAll: pullRequests unless: self blockOnIdEquality.	1✔
326		1✔
327	^ pullRequests	1✔
328	]	1✔
329
330	{ #category : #'import - merge-requests' }
331	BitBucketModelImporter >> importMergeResquestAuthor: mergeRequest [	×
332	mergeRequest author ifNotNil: [ ^mergeRequest ]	×
333	]	×
334
335	{ #category : #'import - merge-requests' }
336	BitBucketModelImporter >> importMergeResquestMerger: mergeRequest [	1✔
337		1✔
338	\| activities mergeActivity mergeUser \|	1✔
339	mergeRequest merge_user ifNotNil: [ ^ mergeRequest merge_user ].	1✔
340	mergeRequest state = 'merged' ifFalse: [ ^ nil ].	1✔
341		1✔
342	activities := self repoApi	1✔
343	activitiesOfPullRequest: mergeRequest id	1✔
344	inRepoProjectId: mergeRequest project id	1✔
345	ofProjectGroupId: mergeRequest project group id.	1✔
346		1✔
347	mergeActivity := activities detect: [ :activity \|	1✔
348	(activity at: #action) = 'MERGED' ].	1✔
349		1✔
350	mergeUser := mergeActivity at: #user.	1✔
351		1✔
352	mergeUser := (glhModel allWithType: GLHUser)	1✔
353	detect: [ :user \| user id = (mergeUser at: #id) ]	1✔
354	ifFound: [ :user \| user ]	1✔
355	ifNone: [	1✔
356	\| glhUser \|	1✔
357	glhUser := self parseUserIntoGLHUser: mergeUser.	1✔
358	glhModel add: glhUser.	1✔
359	glhUser ].	1✔
360		1✔
361	mergeRequest merge_user: mergeUser.	1✔
362	^ mergeUser	1✔
363	]	1✔
364
365	{ #category : #'import - users' }
366	BitBucketModelImporter >> importUserByUsername: username [	1✔
367		1✔
368		1✔
369		1✔
370	^ self userCatalogue collectUsernames at: username ifAbsent: [	1✔
371	\|users glhUser user\|	1✔
372		1✔
373	users := self repoApi usersByUsername: username.	1✔
374	users ifEmpty: [ ^ nil ].	1✔
375	user := users first.	1✔
376		1✔
377	glhUser := self parseUserIntoGLHUser: user.	1✔
378	self glhModel add: glhUser unless: self blockOnIdEquality.	1✔
379	self userCatalogue addUser: glhUser withName: username.	1✔
380	glhUser	1✔
381	].	1✔
382		1✔
383		1✔
384	]	1✔
385
386	{ #category : #parsing }
387	BitBucketModelImporter >> parseCommitIntoGLHCommit: commitDictionary [	1✔
388		1✔
389	\| author committer parentIds \|	1✔
390	author := commitDictionary at: #author.	1✔
391	committer := commitDictionary at: #committer.	1✔
392		1✔
393	parentIds := (commitDictionary at: #parents) collect: [ :parent \|	1✔
394	parent at: #id ].	1✔
395		1✔
396	^ GLHCommit new	1✔
397	id: (commitDictionary at: #id);	1✔
398	message: (commitDictionary at: #message);	1✔
399	author_email: (author at: #emailAddress);	1✔
400	author_name: (author at: #name);	1✔
401	authored_date: (DateAndTime fromUnixTime:	1✔
402	(commitDictionary at: #authorTimestamp) / 1000);	1✔
403	created_at: (DateAndTime fromUnixTime:	1✔
404	(commitDictionary at: #authorTimestamp) / 1000);	1✔
405	committed_date: (DateAndTime fromUnixTime:	1✔
406	(commitDictionary at: #committerTimestamp) / 1000);	1✔
407	committer_email: (committer at: #emailAddress);	1✔
408	committer_name: (committer at: #name);	1✔
409	parent_ids: parentIds	1✔
410	]	1✔
411
412	{ #category : #parsing }
413	BitBucketModelImporter >> parseProjectIntoGLHGroup: projectRepository [	1✔
414		1✔
415	^GLHGroup new	1✔
416	name: (projectRepository at: #name);	1✔
417	id: (projectRepository at: #key);	1✔
418	description: (projectRepository at: #description).	1✔
419	]	1✔
420
421	{ #category : #parsing }
422	BitBucketModelImporter >> parsePullRequestIntoGLPHEMergeRequest: pullRequestDictionary [	1✔
423		1✔
424	\| repository project toRef fromRef glpheMergeRequest author state reviewers \|	1✔
425	toRef := pullRequestDictionary at: #toRef.	1✔
426	fromRef := pullRequestDictionary at: #fromRef.	1✔
427		1✔
428	reviewers := pullRequestDictionary at: #reviewers.	1✔
429	reviewers := reviewers collect: [ :reviewer \|	1✔
430	\|reviewerUser\|	1✔
431	reviewerUser := reviewer at: #user.	1✔
432	(self glhModel allWithType: GLHUser) detect: [ :user \| user id = (reviewerUser at: #id) ] ifFound: [ :user \| user ] ifNone: [	1✔
433	\|glhUser\|	1✔
434	glhUser := self parseUserIntoGLHUser: reviewerUser.	1✔
435	glhModel add: glhUser.	1✔
436	glhUser.	1✔
437	]	1✔
438		1✔
439	].	1✔
440		1✔
441	repository := toRef at: #repository.	1✔
442	project := (self glhModel allWithType: GLHProject)	1✔
443	detect: [ :glhProject \|	1✔
444	glhProject id = (repository at: #id) ]	1✔
445	ifFound: [ :glhProject \| glhProject ]	1✔
446	ifNone: [	1✔
447	project := self parseRepoIntoGLHProject: repository.	1✔
448	self glhModel add: project.	1✔
449	project ].	1✔
450		1✔
451		1✔
452	author := pullRequestDictionary at: #author.	1✔
453	author := (self glhModel allWithType: GLHUser)	1✔
454	detect: [ :user \| user id = ((author at: #user) at: #id) ]	1✔
455	ifFound: [ :user \| user ]	1✔
456	ifNone: [	1✔
457	self importUserByUsername:	1✔
458	((author at: #user) at: #displayName) ].	1✔
459		1✔
460		1✔
461	glpheMergeRequest := GLPHEMergeRequest new	1✔
462	name: (pullRequestDictionary at: #title);	1✔
463	title: (pullRequestDictionary at: #title);	1✔
464	id: (pullRequestDictionary at: #id);	1✔
465	project: project;	1✔
466	project_id: project id;	1✔
467	target_branch: (toRef at: #id);	1✔
468	target_project_id:	1✔
469	((toRef at: #repository) at: #id);	1✔
470	source_branch: (fromRef at: #id);	1✔
471	target_project_id:	1✔
472	((fromRef at: #repository) at: #id);	1✔
473	updated_at: (DateAndTime fromUnixTime:	1✔
474	(pullRequestDictionary at: #updatedDate)	1✔
475	/ 1000);	1✔
476	created_at: (DateAndTime fromUnixTime:	1✔
477	(pullRequestDictionary at: #createdDate)	1✔
478	/ 1000);	1✔
479	author: author.	1✔
480		1✔
481	"STATE"	1✔
482	state := pullRequestDictionary at: #state.	1✔
483	state = 'OPEN' ifTrue: [ glpheMergeRequest state: 'opened' ].	1✔
484	state = 'MERGED' ifTrue: [	1✔
485	glpheMergeRequest state: 'merged'.	1✔
486	glpheMergeRequest merged_at: (DateAndTime fromUnixTime:	1✔
487	(pullRequestDictionary at: #closedDate) / 1000) ].	1✔
488		1✔
489	state = 'DECLINED' ifTrue: [	1✔
490	glpheMergeRequest state: 'closed'.	1✔
491	glpheMergeRequest closed_at: (DateAndTime fromUnixTime:	1✔
492	(pullRequestDictionary at: #closedDate) / 1000) ].	1✔
493		1✔
494	^ glpheMergeRequest	1✔
495	]	1✔
496
497	{ #category : #parsing }
498	BitBucketModelImporter >> parseRepoIntoGLHProject: repositoryDictionary [	1✔
499		1✔
500	\| project group glhProject \|	1✔
501	project := repositoryDictionary at: #project.	1✔
502		1✔
503	group := (self glhModel allWithType: GLHGroup)	1✔
504	detect: [ :glhGroup \| glhGroup id = (project at: #key) ]	1✔
505	ifFound: [ :glhGroup \| glhGroup ]	1✔
506	ifNone: [	1✔
507	\| newGroup \|	1✔
508	newGroup := self parseProjectIntoGLHGroup: project.	1✔
509	glhModel add: newGroup.	1✔
510	newGroup ].	1✔
511		1✔
512		1✔
513	glhProject := GLHProject new	1✔
514	name: (repositoryDictionary at: #name);	1✔
515	id: (repositoryDictionary at: #slug);	1✔
516	repository: GLHRepository new;	1✔
517	group: group.	1✔
518		1✔
519	group addProject: glhProject.	1✔
520		1✔
521	^ glhProject	1✔
522	]	1✔
523
524	{ #category : #parsing }
525	BitBucketModelImporter >> parseUserIntoGLHUser: userDictionnary [	1✔
526		1✔
527	^ GLHUser new name: (userDictionnary at: #displayName);	1✔
528	public_email: (userDictionnary at: #emailAddress);	1✔
529	id: (userDictionnary at: #id);	1✔
530	username: (userDictionnary at: #name).	1✔
531	]	1✔
532
533	{ #category : #accessing }
534	BitBucketModelImporter >> withInitialCommits [	×
535		×
536	^ withInitialCommits	×
537	]	×
538
539	{ #category : #accessing }
540	BitBucketModelImporter >> withInitialCommits: anObject [	×
541		×
542	withInitialCommits := anObject	×
543	]	×

moosetechnology / GitProjectHealth / 11368607478

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