commit ffaadd3d7304fe70ef83aeebdb1cb5daf6826828 · kot.pink/core

+1

appview/db/db.go

···

       428
       428
        
       			-- repo identifiers

     

       429
       429
        
       			repo_at text not null,

     

       430
       430
        
       			ref text not null,

     

       431
       431
       +
       			is_default_ref integer not null default 0,

     

       431
       432
        
       

     

       432
       433
        
       			-- language breakdown

     

       433
       434
        
       			language text not null,

+20 -8

appview/db/language.go

···

       8
       8
        
       )

     

       9
       9
        
       

     

       10
       10
        
       type RepoLanguage struct {

     

       11
       11
       -
       	Id       int64

     

       12
       12
       -
       	RepoAt   syntax.ATURI

     

       13
       13
       -
       	Ref      string

     

       14
       14
       -
       	Language string

     

       15
       15
       -
       	Bytes    int64

     

       11
       11
       +
       	Id           int64

     

       12
       12
       +
       	RepoAt       syntax.ATURI

     

       13
       13
       +
       	Ref          string

     

       14
       14
       +
       	IsDefaultRef bool

     

       15
       15
       +
       	Language     string

     

       16
       16
       +
       	Bytes        int64

     

       16
       17
        
       }

     

       17
       18
        
       

     

       18
       19
        
       func GetRepoLanguages(e Execer, filters ...filter) ([]RepoLanguage, error) {

     
···

       29
       30
        
       	}

     

       30
       31
        
       

     

       31
       32
        
       	query := fmt.Sprintf(

     

       32
       32
       -
       		`select id, repo_at, ref, language, bytes from repo_languages %s`,

     

       33
       33
       +
       		`select id, repo_at, ref, is_default_ref, language, bytes from repo_languages %s`,

     

       33
       34
        
       		whereClause,

     

       34
       35
        
       	)

     

       35
       36
        
       	rows, err := e.Query(query, args...)

     
···

       41
       42
        
       	var langs []RepoLanguage

     

       42
       43
        
       	for rows.Next() {

     

       43
       44
        
       		var rl RepoLanguage

     

       45
       45
       +
       		var isDefaultRef int

     

       44
       46
        
       

     

       45
       47
        
       		err := rows.Scan(

     

       46
       48
        
       			&rl.Id,

     

       47
       49
        
       			&rl.RepoAt,

     

       48
       50
        
       			&rl.Ref,

     

       51
       51
       +
       			&isDefaultRef,

     

       49
       52
        
       			&rl.Language,

     

       50
       53
        
       			&rl.Bytes,

     

       51
       54
        
       		)

     

       52
       55
        
       		if err != nil {

     

       53
       56
        
       			return nil, fmt.Errorf("failed to scan: %w ", err)

     

       57
       57
       +
       		}

     

       58
       58
       +
       

     

       59
       59
       +
       		if isDefaultRef != 0 {

     

       60
       60
       +
       			rl.IsDefaultRef = true

     

       54
       61
        
       		}

     

       55
       62
        
       

     

       56
       63
        
       		langs = append(langs, rl)

     
···

       64
       71
        
       

     

       65
       72
        
       func InsertRepoLanguages(e Execer, langs []RepoLanguage) error {

     

       66
       73
        
       	stmt, err := e.Prepare(

     

       67
       67
       -
       		"insert or replace into repo_languages (repo_at, ref, language, bytes) values (?, ?, ?, ?)",

     

       74
       74
       +
       		"insert or replace into repo_languages (repo_at, ref, is_default_ref, language, bytes) values (?, ?, ?, ?, ?)",

     

       68
       75
        
       	)

     

       69
       76
        
       	if err != nil {

     

       70
       77
        
       		return err

     

       71
       78
        
       	}

     

       72
       79
        
       

     

       73
       80
        
       	for _, l := range langs {

     

       74
       74
       -
       		_, err := stmt.Exec(l.RepoAt, l.Ref, l.Language, l.Bytes)

     

       81
       81
       +
       		isDefaultRef := 0

     

       82
       82
       +
       		if l.IsDefaultRef {

     

       83
       83
       +
       			isDefaultRef = 1

     

       84
       84
       +
       		}

     

       85
       85
       +
       

     

       86
       86
       +
       		_, err := stmt.Exec(l.RepoAt, l.Ref, isDefaultRef, l.Language, l.Bytes)

     

       75
       87
        
       		if err != nil {

     

       76
       88
        
       			return err

     

       77
       89
        
       		}

+9 -5

appview/repo/index.go

···

       123
       123
        
       		}

     

       124
       124
        
       	}

     

       125
       125
        
       

     

       126
       126
       -
       	languageInfo, err := rp.getLanguageInfo(f, signedClient)

     

       126
       126
       +
       	// TODO: a bit dirty

     

       127
       127
       +
       	languageInfo, err := rp.getLanguageInfo(f, signedClient, chi.URLParam(r, "ref") == "")

     

       127
       128
        
       	if err != nil {

     

       128
       129
        
       		log.Printf("failed to compute language percentages: %s", err)

     

       129
       130
        
       		// non-fatal

     
···

       158
       159
        
       func (rp *Repo) getLanguageInfo(

     

       159
       160
        
       	f *reporesolver.ResolvedRepo,

     

       160
       161
        
       	signedClient *knotclient.SignedClient,

     

       162
       162
       +
       	isDefaultRef bool,

     

       161
       163
        
       ) ([]types.RepoLanguageDetails, error) {

     

       162
       164
        
       	// first attempt to fetch from db

     

       163
       165
        
       	langs, err := db.GetRepoLanguages(

     
···

       175
       177
        
       		if ls == nil {

     

       176
       178
        
       			return nil, nil

     

       177
       179
        
       		}

     

       180
       180
       +
       

     

       178
       181
        
       		for l, s := range ls.Languages {

     

       179
       182
        
       			langs = append(langs, db.RepoLanguage{

     

       180
       180
       -
       				RepoAt:   f.RepoAt,

     

       181
       181
       -
       				Ref:      f.Ref,

     

       182
       182
       -
       				Language: l,

     

       183
       183
       -
       				Bytes:    s,

     

       183
       183
       +
       				RepoAt:       f.RepoAt,

     

       184
       184
       +
       				Ref:          f.Ref,

     

       185
       185
       +
       				IsDefaultRef: isDefaultRef,

     

       186
       186
       +
       				Language:     l,

     

       187
       187
       +
       				Bytes:        s,

     

       184
       188
        
       			})

     

       185
       189
        
       		}

     

       186
       190

+5 -4

appview/state/knotstream.go

···

       159
       159
        
       		}

     

       160
       160
        
       

     

       161
       161
        
       		langs = append(langs, db.RepoLanguage{

     

       162
       162
       -
       			RepoAt:   repo.RepoAt(),

     

       163
       163
       -
       			Ref:      ref.Short(),

     

       164
       164
       -
       			Language: l.Lang,

     

       165
       165
       -
       			Bytes:    l.Size,

     

       162
       162
       +
       			RepoAt:       repo.RepoAt(),

     

       163
       163
       +
       			Ref:          ref.Short(),

     

       164
       164
       +
       			IsDefaultRef: record.Meta.IsDefaultRef,

     

       165
       165
       +
       			Language:     l.Lang,

     

       166
       166
       +
       			Bytes:        l.Size,

     

       166
       167
        
       		})

     

       167
       168
        
       	}

     

       168
       169