test: fix decoder and handlers tests

Removed global variables in favor of instance variables. This makes the code more maintainable and making it easier to write unit tests without relying on global state.

Marked the old functions with global state as obsolete, redirecting them to use a new API based on struct in order to rewrite the code using these functions gradually.

internal/config/config.go

@@ -21,6 +21,7 @@ package config
 import (
 	"context"
 	"os"
+	"path/filepath"
 	"sync"
 
 	"github.com/pelletier/go-toml/v2"
@@ -28,6 +29,14 @@ import (
 	"plemya-x.ru/alr/pkg/loggerctx"
 )
 
+type ALRConfig struct {
+	cfg   *types.Config
+	paths *Paths
+
+	cfgOnce   sync.Once
+	pathsOnce sync.Once
+}
+
 var defaultConfig = &types.Config{
 	RootCmd:          "sudo",
 	PagerStyle:       "native",
@@ -40,40 +49,107 @@ var defaultConfig = &types.Config{
 	},
 }
 
-var (
+func New() *ALRConfig {
-	configMtx sync.Mutex
+	return &ALRConfig{}
-	config    *types.Config
+}
-)
 
-// Config returns a ALR configuration struct.
+func (c *ALRConfig) Load(ctx context.Context) {
-// The first time it's called, it'll load the config from a file.
-// Subsequent calls will just return the same value.
-func Config(ctx context.Context) *types.Config {
-	configMtx.Lock()
-	defer configMtx.Unlock()
 	log := loggerctx.From(ctx)
+	cfgFl, err := os.Open(c.GetPaths(ctx).ConfigPath)
+	if err != nil {
+		log.Warn("Error opening config file, using defaults").Err(err).Send()
+		c.cfg = defaultConfig
+		return
+	}
+	defer cfgFl.Close()
 
-	if config == nil {
+	// Copy the default configuration into config
-		cfgFl, err := os.Open(GetPaths(ctx).ConfigPath)
+	defCopy := *defaultConfig
-		if err != nil {
+	config := &defCopy
-			log.Warn("Error opening config file, using defaults").Err(err).Send()
+	config.Repos = nil
-			return defaultConfig
-		}
-		defer cfgFl.Close()
 
-		// Copy the default configuration into config
+	err = toml.NewDecoder(cfgFl).Decode(config)
-		defCopy := *defaultConfig
+	if err != nil {
-		config = &defCopy
+		log.Warn("Error decoding config file, using defaults").Err(err).Send()
-		config.Repos = nil
+		c.cfg = defaultConfig
+		return
+	}
+	c.cfg = config
+}
 
-		err = toml.NewDecoder(cfgFl).Decode(config)
+func (c *ALRConfig) initPaths(ctx context.Context) {
-		if err != nil {
+	log := loggerctx.From(ctx)
-			log.Warn("Error decoding config file, using defaults").Err(err).Send()
+	paths := &Paths{}
-			// Set config back to nil so that we try again next time
+
-			config = nil
+	cfgDir, err := os.UserConfigDir()
-			return defaultConfig
+	if err != nil {
-		}
+		log.Fatal("Unable to detect user config directory").Err(err).Send()
 	}
 
-	return config
+	paths.ConfigDir = filepath.Join(cfgDir, "alr")
+
+	err = os.MkdirAll(paths.ConfigDir, 0o755)
+	if err != nil {
+		log.Fatal("Unable to create ALR config directory").Err(err).Send()
+	}
+
+	paths.ConfigPath = filepath.Join(paths.ConfigDir, "alr.toml")
+
+	if _, err := os.Stat(paths.ConfigPath); err != nil {
+		cfgFl, err := os.Create(paths.ConfigPath)
+		if err != nil {
+			log.Fatal("Unable to create ALR config file").Err(err).Send()
+		}
+
+		err = toml.NewEncoder(cfgFl).Encode(&defaultConfig)
+		if err != nil {
+			log.Fatal("Error encoding default configuration").Err(err).Send()
+		}
+
+		cfgFl.Close()
+	}
+
+	cacheDir, err := os.UserCacheDir()
+	if err != nil {
+		log.Fatal("Unable to detect cache directory").Err(err).Send()
+	}
+
+	paths.CacheDir = filepath.Join(cacheDir, "alr")
+	paths.RepoDir = filepath.Join(paths.CacheDir, "repo")
+	paths.PkgsDir = filepath.Join(paths.CacheDir, "pkgs")
+
+	err = os.MkdirAll(paths.RepoDir, 0o755)
+	if err != nil {
+		log.Fatal("Unable to create repo cache directory").Err(err).Send()
+	}
+
+	err = os.MkdirAll(paths.PkgsDir, 0o755)
+	if err != nil {
+		log.Fatal("Unable to create package cache directory").Err(err).Send()
+	}
+
+	paths.DBPath = filepath.Join(paths.CacheDir, "db")
+
+	c.paths = paths
+}
+
+func (c *ALRConfig) GetPaths(ctx context.Context) *Paths {
+	c.pathsOnce.Do(func() {
+		c.initPaths(ctx)
+	})
+	return c.paths
+}
+
+func (c *ALRConfig) Repos(ctx context.Context) []types.Repo {
+	c.cfgOnce.Do(func() {
+		c.Load(ctx)
+	})
+	return c.cfg.Repos
+}
+
+func (c *ALRConfig) IgnorePkgUpdates(ctx context.Context) []string {
+	c.cfgOnce.Do(func() {
+		c.Load(ctx)
+	})
+	return c.cfg.IgnorePkgUpdates
 }

internal/config/config_legacy.go

@@ -0,0 +1,54 @@
+/*
+ * ALR - Any Linux Repository
+ * Copyright (C) 2024 Евгений Храмов
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package config
+
+import (
+	"context"
+	"sync"
+
+	"plemya-x.ru/alr/internal/types"
+)
+
+// Config returns a ALR configuration struct.
+// The first time it's called, it'll load the config from a file.
+// Subsequent calls will just return the same value.
+//
+// Deprecated: use struct method
+func Config(ctx context.Context) *types.Config {
+	return GetInstance(ctx).cfg
+}
+
+// =======================
+// FOR LEGACY ONLY
+// =======================
+
+var (
+	alrConfig     *ALRConfig
+	alrConfigOnce sync.Once
+)
+
+// Deprecated: For legacy only
+func GetInstance(ctx context.Context) *ALRConfig {
+	alrConfigOnce.Do(func() {
+		alrConfig = New()
+		alrConfig.Load(ctx)
+	})
+
+	return alrConfig
+}

internal/config/paths.go

@@ -20,12 +20,6 @@ package config
 
 import (
 	"context"
-	"os"
-	"path/filepath"
-	"sync"
-
-	"github.com/pelletier/go-toml/v2"
-	"plemya-x.ru/alr/pkg/loggerctx"
 )
 
 // Paths contains various paths used by ALR
@@ -38,71 +32,13 @@ type Paths struct {
 	DBPath     string
 }
 
-var (
-	pathsMtx sync.Mutex
-	paths    *Paths
-)
-
 // GetPaths returns a Paths struct.
 // The first time it's called, it'll generate the struct
 // using information from the system.
 // Subsequent calls will return the same value.
+//
+// Depreacted: use struct API
 func GetPaths(ctx context.Context) *Paths {
-	pathsMtx.Lock()
+	alrConfig := GetInstance(ctx)
-	defer pathsMtx.Unlock()
+	return alrConfig.GetPaths(ctx)
-
-	log := loggerctx.From(ctx)
-	if paths == nil {
-		paths = &Paths{}
-
-		cfgDir, err := os.UserConfigDir()
-		if err != nil {
-			log.Fatal("Unable to detect user config directory").Err(err).Send()
-		}
-
-		paths.ConfigDir = filepath.Join(cfgDir, "alr")
-
-		err = os.MkdirAll(paths.ConfigDir, 0o755)
-		if err != nil {
-			log.Fatal("Unable to create ALR config directory").Err(err).Send()
-		}
-
-		paths.ConfigPath = filepath.Join(paths.ConfigDir, "alr.toml")
-
-		if _, err := os.Stat(paths.ConfigPath); err != nil {
-			cfgFl, err := os.Create(paths.ConfigPath)
-			if err != nil {
-				log.Fatal("Unable to create ALR config file").Err(err).Send()
-			}
-
-			err = toml.NewEncoder(cfgFl).Encode(&defaultConfig)
-			if err != nil {
-				log.Fatal("Error encoding default configuration").Err(err).Send()
-			}
-
-			cfgFl.Close()
-		}
-
-		cacheDir, err := os.UserCacheDir()
-		if err != nil {
-			log.Fatal("Unable to detect cache directory").Err(err).Send()
-		}
-
-		paths.CacheDir = filepath.Join(cacheDir, "alr")
-		paths.RepoDir = filepath.Join(paths.CacheDir, "repo")
-		paths.PkgsDir = filepath.Join(paths.CacheDir, "pkgs")
-
-		err = os.MkdirAll(paths.RepoDir, 0o755)
-		if err != nil {
-			log.Fatal("Unable to create repo cache directory").Err(err).Send()
-		}
-
-		err = os.MkdirAll(paths.PkgsDir, 0o755)
-		if err != nil {
-			log.Fatal("Unable to create package cache directory").Err(err).Send()
-		}
-
-		paths.DBPath = filepath.Join(paths.CacheDir, "db")
-	}
-	return paths
 }

internal/db/db.go

@@ -20,28 +20,16 @@ package db
 
 import (
 	"context"
-	"database/sql"
-	"database/sql/driver"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"sync"
 
 	"github.com/jmoiron/sqlx"
 	"plemya-x.ru/alr/internal/config"
 	"plemya-x.ru/alr/pkg/loggerctx"
-	"golang.org/x/exp/slices"
-	"modernc.org/sqlite"
 )
 
 // CurrentVersion is the current version of the database.
 // The database is reset if its version doesn't match this.
 const CurrentVersion = 2
 
-func init() {
-	sqlite.MustRegisterScalarFunction("json_array_contains", 2, jsonArrayContains)
-}
-
 // Package is a ALR package's database representation
 type Package struct {
 	Name          string                    `sh:"name,required" db:"name"`
@@ -66,66 +54,47 @@ type version struct {
 	Version int `db:"version"`
 }
 
-var (
+type Config interface {
-	mu     sync.Mutex
+	GetPaths(ctx context.Context) *config.Paths
+}
+
+type Database struct {
 	conn   *sqlx.DB
-	closed = true
+	config Config
-)
+}
 
-// DB returns the ALR database.
+func New(config Config) *Database {
-// The first time it's called, it opens the SQLite database file.
+	return &Database{
-// Subsequent calls return the same connection.
+		config: config,
-func DB(ctx context.Context) *sqlx.DB {
-	log := loggerctx.From(ctx)
-	if conn != nil && !closed {
-		return getConn()
 	}
-	_, err := open(ctx, config.GetPaths(ctx).DBPath)
+}
+
+func (d *Database) Init(ctx context.Context) error {
+	err := d.Connect(ctx)
 	if err != nil {
-		log.Fatal("Error opening database").Err(err).Send()
+		return err
 	}
-	return getConn()
+	return d.initDB(ctx)
 }
 
-func getConn() *sqlx.DB {
+func (d *Database) Connect(ctx context.Context) error {
-	mu.Lock()
+	dsn := d.config.GetPaths(ctx).DBPath
-	defer mu.Unlock()
-	return conn
-}
-
-func open(ctx context.Context, dsn string) (*sqlx.DB, error) {
 	db, err := sqlx.Open("sqlite", dsn)
 	if err != nil {
-		return nil, err
+		return err
 	}
-
+	d.conn = db
-	mu.Lock()
+	return nil
-	conn = db
-	closed = false
-	mu.Unlock()
-
-	err = initDB(ctx, dsn)
-	if err != nil {
-		return nil, err
-	}
-
-	return db, nil
 }
 
-// Close closes the database
+func (d *Database) GetConn() *sqlx.DB {
-func Close() error {
+	return d.conn
-	closed = true
-	if conn != nil {
-		return conn.Close()
-	} else {
-		return nil
-	}
 }
 
-// initDB initializes the database
+func (d *Database) initDB(ctx context.Context) error {
-func initDB(ctx context.Context, dsn string) error {
 	log := loggerctx.From(ctx)
-	conn = conn.Unsafe()
+	d.conn = d.conn.Unsafe()
+	conn := d.conn
 	_, err := conn.ExecContext(ctx, `
 		CREATE TABLE IF NOT EXISTS pkgs (
 			name          TEXT NOT NULL,
@@ -155,58 +124,72 @@ func initDB(ctx context.Context, dsn string) error {
 		return err
 	}
 
-	ver, ok := GetVersion(ctx)
+	ver, ok := d.GetVersion(ctx)
 	if ok && ver != CurrentVersion {
 		log.Warn("Database version mismatch; resetting").Int("version", ver).Int("expected", CurrentVersion).Send()
-		reset(ctx)
+		d.reset(ctx)
-		return initDB(ctx, dsn)
+		return d.initDB(ctx)
 	} else if !ok {
 		log.Warn("Database version does not exist. Run alr fix if something isn't working.").Send()
-		return addVersion(ctx, CurrentVersion)
+		return d.addVersion(ctx, CurrentVersion)
 	}
 
 	return nil
 }
 
-// reset drops all the database tables
+func (d *Database) GetVersion(ctx context.Context) (int, bool) {
-func reset(ctx context.Context) error {
-	_, err := DB(ctx).ExecContext(ctx, "DROP TABLE IF EXISTS pkgs;")
-	if err != nil {
-		return err
-	}
-	_, err = DB(ctx).ExecContext(ctx, "DROP TABLE IF EXISTS alr_db_version;")
-	return err
-}
-
-// IsEmpty returns true if the database has no packages in it, otherwise it returns false.
-func IsEmpty(ctx context.Context) bool {
-	var count int
-	err := DB(ctx).GetContext(ctx, &count, "SELECT count(1) FROM pkgs;")
-	if err != nil {
-		return true
-	}
-	return count == 0
-}
-
-// GetVersion returns the database version and a boolean indicating
-// whether the database contained a version number
-func GetVersion(ctx context.Context) (int, bool) {
 	var ver version
-	err := DB(ctx).GetContext(ctx, &ver, "SELECT * FROM alr_db_version LIMIT 1;")
+	err := d.conn.GetContext(ctx, &ver, "SELECT * FROM alr_db_version LIMIT 1;")
 	if err != nil {
 		return 0, false
 	}
 	return ver.Version, true
 }
 
-func addVersion(ctx context.Context, ver int) error {
+func (d *Database) addVersion(ctx context.Context, ver int) error {
-	_, err := DB(ctx).ExecContext(ctx, `INSERT INTO alr_db_version(version) VALUES (?);`, ver)
+	_, err := d.conn.ExecContext(ctx, `INSERT INTO alr_db_version(version) VALUES (?);`, ver)
 	return err
 }
 
-// InsertPackage adds a package to the database
+func (d *Database) reset(ctx context.Context) error {
-func InsertPackage(ctx context.Context, pkg Package) error {
+	_, err := d.conn.ExecContext(ctx, "DROP TABLE IF EXISTS pkgs;")
-	_, err := DB(ctx).NamedExecContext(ctx, `
+	if err != nil {
+		return err
+	}
+	_, err = d.conn.ExecContext(ctx, "DROP TABLE IF EXISTS alr_db_version;")
+	return err
+}
+
+func (d *Database) GetPkgs(ctx context.Context, where string, args ...any) (*sqlx.Rows, error) {
+	stream, err := d.conn.QueryxContext(ctx, "SELECT * FROM pkgs WHERE "+where, args...)
+	if err != nil {
+		return nil, err
+	}
+	return stream, nil
+}
+
+func (d *Database) GetPkg(ctx context.Context, where string, args ...any) (*Package, error) {
+	out := &Package{}
+	err := d.conn.GetContext(ctx, out, "SELECT * FROM pkgs WHERE "+where+" LIMIT 1", args...)
+	return out, err
+}
+
+func (d *Database) DeletePkgs(ctx context.Context, where string, args ...any) error {
+	_, err := d.conn.ExecContext(ctx, "DELETE FROM pkgs WHERE "+where, args...)
+	return err
+}
+
+func (d *Database) IsEmpty(ctx context.Context) bool {
+	var count int
+	err := d.conn.GetContext(ctx, &count, "SELECT count(1) FROM pkgs;")
+	if err != nil {
+		return true
+	}
+	return count == 0
+}
+
+func (d *Database) InsertPackage(ctx context.Context, pkg Package) error {
+	_, err := d.conn.NamedExecContext(ctx, `
 		INSERT OR REPLACE INTO pkgs (
 			name,
 			repository,
@@ -246,101 +229,10 @@ func InsertPackage(ctx context.Context, pkg Package) error {
 	return err
 }
 
-// GetPkgs returns a result containing packages that match the where conditions
+func (d *Database) Close() error {
-func GetPkgs(ctx context.Context, where string, args ...any) (*sqlx.Rows, error) {
+	if d.conn != nil {
-	stream, err := DB(ctx).QueryxContext(ctx, "SELECT * FROM pkgs WHERE "+where, args...)
+		return d.conn.Close()
-	if err != nil {
+	} else {
-		return nil, err
-	}
-	return stream, nil
-}
-
-// GetPkg returns a single package that matches the where conditions
-func GetPkg(ctx context.Context, where string, args ...any) (*Package, error) {
-	out := &Package{}
-	err := DB(ctx).GetContext(ctx, out, "SELECT * FROM pkgs WHERE "+where+" LIMIT 1", args...)
-	return out, err
-}
-
-// DeletePkgs deletes all packages matching the where conditions
-func DeletePkgs(ctx context.Context, where string, args ...any) error {
-	_, err := DB(ctx).ExecContext(ctx, "DELETE FROM pkgs WHERE "+where, args...)
-	return err
-}
-
-// jsonArrayContains is an SQLite function that checks if a JSON array
-// in the database contains a given value
-func jsonArrayContains(ctx *sqlite.FunctionContext, args []driver.Value) (driver.Value, error) {
-	value, ok := args[0].(string)
-	if !ok {
-		return nil, errors.New("both arguments to json_array_contains must be strings")
-	}
-
-	item, ok := args[1].(string)
-	if !ok {
-		return nil, errors.New("both arguments to json_array_contains must be strings")
-	}
-
-	var array []string
-	err := json.Unmarshal([]byte(value), &array)
-	if err != nil {
-		return nil, err
-	}
-
-	return slices.Contains(array, item), nil
-}
-
-// JSON represents a JSON value in the database
-type JSON[T any] struct {
-	Val T
-}
-
-// NewJSON creates a new database JSON value
-func NewJSON[T any](v T) JSON[T] {
-	return JSON[T]{Val: v}
-}
-
-func (s *JSON[T]) Scan(val any) error {
-	if val == nil {
 		return nil
 	}
-
-	switch val := val.(type) {
-	case string:
-		err := json.Unmarshal([]byte(val), &s.Val)
-		if err != nil {
-			return err
-		}
-	case sql.NullString:
-		if val.Valid {
-			err := json.Unmarshal([]byte(val.String), &s.Val)
-			if err != nil {
-				return err
-			}
-		}
-	default:
-		return errors.New("sqlite json types must be strings")
-	}
-
-	return nil
-}
-
-func (s JSON[T]) Value() (driver.Value, error) {
-	data, err := json.Marshal(s.Val)
-	if err != nil {
-		return nil, err
-	}
-	return string(data), nil
-}
-
-func (s JSON[T]) MarshalYAML() (any, error) {
-	return s.Val, nil
-}
-
-func (s JSON[T]) String() string {
-	return fmt.Sprint(s.Val)
-}
-
-func (s JSON[T]) GoString() string {
-	return fmt.Sprintf("%#v", s.Val)
 }

internal/db/db_legacy.go

@@ -0,0 +1,105 @@
+/*
+ * ALR - Any Linux Repository
+ * Copyright (C) 2024 Евгений Храмов
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package db
+
+import (
+	"context"
+	"sync"
+
+	"github.com/jmoiron/sqlx"
+	"plemya-x.ru/alr/internal/config"
+	"plemya-x.ru/alr/pkg/loggerctx"
+)
+
+// DB returns the ALR database.
+// The first time it's called, it opens the SQLite database file.
+// Subsequent calls return the same connection.
+//
+// Deprecated: use struct method
+func DB(ctx context.Context) *sqlx.DB {
+	return GetInstance(ctx).GetConn()
+}
+
+// Close closes the database
+//
+// Deprecated: use struct method
+func Close() error {
+	if database != nil {
+		return database.Close()
+	}
+	return nil
+}
+
+// IsEmpty returns true if the database has no packages in it, otherwise it returns false.
+//
+// Deprecated: use struct method
+func IsEmpty(ctx context.Context) bool {
+	return GetInstance(ctx).IsEmpty(ctx)
+}
+
+// InsertPackage adds a package to the database
+//
+// Deprecated: use struct method
+func InsertPackage(ctx context.Context, pkg Package) error {
+	return GetInstance(ctx).InsertPackage(ctx, pkg)
+}
+
+// GetPkgs returns a result containing packages that match the where conditions
+//
+// Deprecated: use struct method
+func GetPkgs(ctx context.Context, where string, args ...any) (*sqlx.Rows, error) {
+	return GetInstance(ctx).GetPkgs(ctx, where, args...)
+}
+
+// GetPkg returns a single package that matches the where conditions
+//
+// Deprecated: use struct method
+func GetPkg(ctx context.Context, where string, args ...any) (*Package, error) {
+	return GetInstance(ctx).GetPkg(ctx, where, args...)
+}
+
+// DeletePkgs deletes all packages matching the where conditions
+//
+// Deprecated: use struct method
+func DeletePkgs(ctx context.Context, where string, args ...any) error {
+	return GetInstance(ctx).DeletePkgs(ctx, where, args...)
+}
+
+// =======================
+// FOR LEGACY ONLY
+// =======================
+
+var (
+	dbOnce   sync.Once
+	database *Database
+)
+
+// Deprecated: For legacy only
+func GetInstance(ctx context.Context) *Database {
+	dbOnce.Do(func() {
+		log := loggerctx.From(ctx)
+		cfg := config.GetInstance(ctx)
+		database = New(cfg)
+		err := database.Init(ctx)
+		if err != nil {
+			log.Fatal("Error opening database").Err(err).Send()
+		}
+	})
+	return database
+}

internal/db/db_test.go

@@ -19,14 +19,30 @@
 package db_test
 
 import (
+	"context"
 	"reflect"
 	"strings"
 	"testing"
 
 	"github.com/jmoiron/sqlx"
+	"plemya-x.ru/alr/internal/config"
 	"plemya-x.ru/alr/internal/db"
 )
 
+type TestALRConfig struct{}
+
+func (c *TestALRConfig) GetPaths(ctx context.Context) *config.Paths {
+	return &config.Paths{
+		DBPath: ":memory:",
+	}
+}
+
+func prepareDb() *db.Database {
+	database := db.New(&TestALRConfig{})
+	database.Init(context.Background())
+	return database
+}
+
 var testPkg = db.Package{
 	Name:    "test",
 	Version: "0.0.1",
@@ -59,18 +75,11 @@ var testPkg = db.Package{
 }
 
 func TestInit(t *testing.T) {
-	_, err := db.Open(":memory:")
+	ctx := context.Background()
-	if err != nil {
+	database := prepareDb()
-		t.Fatalf("Expected no error, got %s", err)
+	defer database.Close()
-	}
-	defer db.Close()
 
-	_, err = db.DB().Exec("SELECT * FROM pkgs")
+	ver, ok := database.GetVersion(ctx)
-	if err != nil {
-		t.Fatalf("Expected no error, got %s", err)
-	}
-
-	ver, ok := db.GetVersion()
 	if !ok {
 		t.Errorf("Expected version to be present")
 	} else if ver != db.CurrentVersion {
@@ -79,19 +88,17 @@ func TestInit(t *testing.T) {
 }
 
 func TestInsertPackage(t *testing.T) {
-	_, err := db.Open(":memory:")
+	ctx := context.Background()
-	if err != nil {
+	database := prepareDb()
-		t.Fatalf("Expected no error, got %s", err)
+	defer database.Close()
-	}
-	defer db.Close()
 
-	err = db.InsertPackage(testPkg)
+	err := database.InsertPackage(ctx, testPkg)
 	if err != nil {
 		t.Fatalf("Expected no error, got %s", err)
 	}
 
 	dbPkg := db.Package{}
-	err = sqlx.Get(db.DB(), &dbPkg, "SELECT * FROM pkgs WHERE name = 'test' AND repository = 'default'")
+	err = sqlx.Get(database.GetConn(), &dbPkg, "SELECT * FROM pkgs WHERE name = 'test' AND repository = 'default'")
 	if err != nil {
 		t.Fatalf("Expected no error, got %s", err)
 	}
@@ -102,28 +109,26 @@ func TestInsertPackage(t *testing.T) {
 }
 
 func TestGetPkgs(t *testing.T) {
-	_, err := db.Open(":memory:")
+	ctx := context.Background()
-	if err != nil {
+	database := prepareDb()
-		t.Fatalf("Expected no error, got %s", err)
+	defer database.Close()
-	}
-	defer db.Close()
 
 	x1 := testPkg
 	x1.Name = "x1"
 	x2 := testPkg
 	x2.Name = "x2"
 
-	err = db.InsertPackage(x1)
+	err := database.InsertPackage(ctx, x1)
 	if err != nil {
 		t.Errorf("Expected no error, got %s", err)
 	}
 
-	err = db.InsertPackage(x2)
+	err = database.InsertPackage(ctx, x2)
 	if err != nil {
 		t.Errorf("Expected no error, got %s", err)
 	}
 
-	result, err := db.GetPkgs("name LIKE 'x%'")
+	result, err := database.GetPkgs(ctx, "name LIKE 'x%'")
 	if err != nil {
 		t.Fatalf("Expected no error, got %s", err)
 	}
@@ -142,28 +147,26 @@ func TestGetPkgs(t *testing.T) {
 }
 
 func TestGetPkg(t *testing.T) {
-	_, err := db.Open(":memory:")
+	ctx := context.Background()
-	if err != nil {
+	database := prepareDb()
-		t.Fatalf("Expected no error, got %s", err)
+	defer database.Close()
-	}
-	defer db.Close()
 
 	x1 := testPkg
 	x1.Name = "x1"
 	x2 := testPkg
 	x2.Name = "x2"
 
-	err = db.InsertPackage(x1)
+	err := database.InsertPackage(ctx, x1)
 	if err != nil {
 		t.Errorf("Expected no error, got %s", err)
 	}
 
-	err = db.InsertPackage(x2)
+	err = database.InsertPackage(ctx, x2)
 	if err != nil {
 		t.Errorf("Expected no error, got %s", err)
 	}
 
-	pkg, err := db.GetPkg("name LIKE 'x%' ORDER BY name")
+	pkg, err := database.GetPkg(ctx, "name LIKE 'x%' ORDER BY name")
 	if err != nil {
 		t.Fatalf("Expected no error, got %s", err)
 	}
@@ -178,34 +181,32 @@ func TestGetPkg(t *testing.T) {
 }
 
 func TestDeletePkgs(t *testing.T) {
-	_, err := db.Open(":memory:")
+	ctx := context.Background()
-	if err != nil {
+	database := prepareDb()
-		t.Fatalf("Expected no error, got %s", err)
+	defer database.Close()
-	}
-	defer db.Close()
 
 	x1 := testPkg
 	x1.Name = "x1"
 	x2 := testPkg
 	x2.Name = "x2"
 
-	err = db.InsertPackage(x1)
+	err := database.InsertPackage(ctx, x1)
 	if err != nil {
 		t.Errorf("Expected no error, got %s", err)
 	}
 
-	err = db.InsertPackage(x2)
+	err = database.InsertPackage(ctx, x2)
 	if err != nil {
 		t.Errorf("Expected no error, got %s", err)
 	}
 
-	err = db.DeletePkgs("name = 'x1'")
+	err = database.DeletePkgs(ctx, "name = 'x1'")
 	if err != nil {
 		t.Errorf("Expected no error, got %s", err)
 	}
 
 	var dbPkg db.Package
-	err = db.DB().Get(&dbPkg, "SELECT * FROM pkgs WHERE name LIKE 'x%' ORDER BY name LIMIT 1;")
+	err = database.GetConn().Get(&dbPkg, "SELECT * FROM pkgs WHERE name LIKE 'x%' ORDER BY name LIMIT 1;")
 	if err != nil {
 		t.Errorf("Expected no error, got %s", err)
 	}
@@ -216,11 +217,9 @@ func TestDeletePkgs(t *testing.T) {
 }
 
 func TestJsonArrayContains(t *testing.T) {
-	_, err := db.Open(":memory:")
+	ctx := context.Background()
-	if err != nil {
+	database := prepareDb()
-		t.Fatalf("Expected no error, got %s", err)
+	defer database.Close()
-	}
-	defer db.Close()
 
 	x1 := testPkg
 	x1.Name = "x1"
@@ -228,18 +227,18 @@ func TestJsonArrayContains(t *testing.T) {
 	x2.Name = "x2"
 	x2.Provides.Val = append(x2.Provides.Val, "x")
 
-	err = db.InsertPackage(x1)
+	err := database.InsertPackage(ctx, x1)
 	if err != nil {
 		t.Errorf("Expected no error, got %s", err)
 	}
 
-	err = db.InsertPackage(x2)
+	err = database.InsertPackage(ctx, x2)
 	if err != nil {
 		t.Errorf("Expected no error, got %s", err)
 	}
 
 	var dbPkg db.Package
-	err = db.DB().Get(&dbPkg, "SELECT * FROM pkgs WHERE json_array_contains(provides, 'x');")
+	err = database.GetConn().Get(&dbPkg, "SELECT * FROM pkgs WHERE json_array_contains(provides, 'x');")
 	if err != nil {
 		t.Fatalf("Expected no error, got %s", err)
 	}

internal/db/json.go

@@ -0,0 +1,64 @@
+package db
+
+import (
+	"database/sql"
+	"database/sql/driver"
+	"encoding/json"
+	"errors"
+	"fmt"
+)
+
+// JSON represents a JSON value in the database
+type JSON[T any] struct {
+	Val T
+}
+
+// NewJSON creates a new database JSON value
+func NewJSON[T any](v T) JSON[T] {
+	return JSON[T]{Val: v}
+}
+
+func (s *JSON[T]) Scan(val any) error {
+	if val == nil {
+		return nil
+	}
+
+	switch val := val.(type) {
+	case string:
+		err := json.Unmarshal([]byte(val), &s.Val)
+		if err != nil {
+			return err
+		}
+	case sql.NullString:
+		if val.Valid {
+			err := json.Unmarshal([]byte(val.String), &s.Val)
+			if err != nil {
+				return err
+			}
+		}
+	default:
+		return errors.New("sqlite json types must be strings")
+	}
+
+	return nil
+}
+
+func (s JSON[T]) Value() (driver.Value, error) {
+	data, err := json.Marshal(s.Val)
+	if err != nil {
+		return nil, err
+	}
+	return string(data), nil
+}
+
+func (s JSON[T]) MarshalYAML() (any, error) {
+	return s.Val, nil
+}
+
+func (s JSON[T]) String() string {
+	return fmt.Sprint(s.Val)
+}
+
+func (s JSON[T]) GoString() string {
+	return fmt.Sprintf("%#v", s.Val)
+}

internal/db/utils.go

@@ -0,0 +1,36 @@
+package db
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+	"errors"
+
+	"golang.org/x/exp/slices"
+	"modernc.org/sqlite"
+)
+
+func init() {
+	sqlite.MustRegisterScalarFunction("json_array_contains", 2, jsonArrayContains)
+}
+
+// jsonArrayContains is an SQLite function that checks if a JSON array
+// in the database contains a given value
+func jsonArrayContains(ctx *sqlite.FunctionContext, args []driver.Value) (driver.Value, error) {
+	value, ok := args[0].(string)
+	if !ok {
+		return nil, errors.New("both arguments to json_array_contains must be strings")
+	}
+
+	item, ok := args[1].(string)
+	if !ok {
+		return nil, errors.New("both arguments to json_array_contains must be strings")
+	}
+
+	var array []string
+	err := json.Unmarshal([]byte(value), &array)
+	if err != nil {
+		return nil, err
+	}
+
+	return slices.Contains(array, item), nil
+}

internal/dl/dl.go

@@ -14,7 +14,7 @@
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
+ */
 
 // Пакет dl содержит абстракции для загрузки файлов и каталогов
 // из различных источников.
@@ -39,6 +39,7 @@ import (
 	"golang.org/x/crypto/blake2b"
 	"golang.org/x/crypto/blake2s"
 	"golang.org/x/exp/slices"
+	"plemya-x.ru/alr/internal/config"
 	"plemya-x.ru/alr/internal/dlcache"
 	"plemya-x.ru/alr/pkg/loggerctx"
 )
@@ -142,6 +143,9 @@ type UpdatingDownloader interface {
 // Функция Download загружает файл или каталог с использованием указанных параметров
 func Download(ctx context.Context, opts Options) (err error) {
 	log := loggerctx.From(ctx)
+	cfg := config.GetInstance(ctx)
+	dc := dlcache.New(cfg)
+
 	normalized, err := normalizeURL(opts.URL)
 	if err != nil {
 		return err
@@ -156,7 +160,7 @@ func Download(ctx context.Context, opts Options) (err error) {
 	}
 
 	var t Type
-	cacheDir, ok := dlcache.Get(ctx, opts.URL)
+	cacheDir, ok := dc.Get(ctx, opts.URL)
 	if ok {
 		var updated bool
 		if d, ok := d.(UpdatingDownloader); ok {
@@ -203,7 +207,7 @@ func Download(ctx context.Context, opts Options) (err error) {
 
 	log.Info("Downloading source").Str("source", opts.Name).Str("downloader", d.Name()).Send()
 
-	cacheDir, err = dlcache.New(ctx, opts.URL)
+	cacheDir, err = dc.New(ctx, opts.URL)
 	if err != nil {
 		return err
 	}
@@ -299,8 +303,6 @@ func linkDir(src, dest string) error {
 			return nil
 		}
 
-
-
 		rel, err := filepath.Rel(src, path)
 		if err != nil {
 			return err

internal/dl/file.go

@@ -222,7 +222,7 @@ func extractFile(r io.Reader, format archiver.Format, name string, opts Options)
 			}
 
 			if f.IsDir() {
-				err = os.Mkdir(path, 0o755)
+				err = os.MkdirAll(path, 0o755)
 				if err != nil {
 					return err
 				}

internal/dlcache/dlcache.go

@@ -20,29 +20,41 @@ package dlcache
 
 import (
 	"context"
-	"crypto/sha1"
-	"encoding/hex"
-	"io"
 	"os"
 	"path/filepath"
 
 	"plemya-x.ru/alr/internal/config"
 )
 
-// BasePath returns the base path of the download cache
+type Config interface {
-func BasePath(ctx context.Context) string {
+	GetPaths(ctx context.Context) *config.Paths
-	return filepath.Join(config.GetPaths(ctx).CacheDir, "dl")
+}
+
+type DownloadCache struct {
+	cfg Config
+}
+
+func New(cfg Config) *DownloadCache {
+	return &DownloadCache{
+		cfg,
+	}
+}
+
+func (dc *DownloadCache) BasePath(ctx context.Context) string {
+	return filepath.Join(
+		dc.cfg.GetPaths(ctx).CacheDir, "dl",
+	)
 }
 
 // New creates a new directory with the given ID in the cache.
 // If a directory with the same ID already exists,
 // it will be deleted before creating a new one.
-func New(ctx context.Context, id string) (string, error) {
+func (dc *DownloadCache) New(ctx context.Context, id string) (string, error) {
 	h, err := hashID(id)
 	if err != nil {
 		return "", err
 	}
-	itemPath := filepath.Join(BasePath(ctx), h)
+	itemPath := filepath.Join(dc.BasePath(ctx), h)
 
 	fi, err := os.Stat(itemPath)
 	if err == nil || (fi != nil && !fi.IsDir()) {
@@ -65,12 +77,12 @@ func New(ctx context.Context, id string) (string, error) {
 // returns the directory and true. If it
 // does not exist, it returns an empty string
 // and false.
-func Get(ctx context.Context, id string) (string, bool) {
+func (dc *DownloadCache) Get(ctx context.Context, id string) (string, bool) {
 	h, err := hashID(id)
 	if err != nil {
 		return "", false
 	}
-	itemPath := filepath.Join(BasePath(ctx), h)
+	itemPath := filepath.Join(dc.BasePath(ctx), h)
 
 	_, err = os.Stat(itemPath)
 	if err != nil {
@@ -79,15 +91,3 @@ func Get(ctx context.Context, id string) (string, bool) {
 
 	return itemPath, true
 }
-
-// hashID hashes the input ID with SHA1
-// and returns the hex string of the hashed
-// ID.
-func hashID(id string) (string, error) {
-	h := sha1.New()
-	_, err := io.WriteString(h, id)
-	if err != nil {
-		return "", err
-	}
-	return hex.EncodeToString(h.Sum(nil)), nil
-}

internal/dlcache/dlcache_test.go

@@ -39,14 +39,49 @@ func init() {
 	config.GetPaths(context.Background()).RepoDir = dir
 }
 
+type TestALRConfig struct {
+	CacheDir string
+}
+
+func (c *TestALRConfig) GetPaths(ctx context.Context) *config.Paths {
+	return &config.Paths{
+		CacheDir: c.CacheDir,
+	}
+}
+
+func prepare(t *testing.T) *TestALRConfig {
+	t.Helper()
+
+	dir, err := os.MkdirTemp("/tmp", "alr-dlcache-test.*")
+	if err != nil {
+		panic(err)
+	}
+
+	return &TestALRConfig{
+		CacheDir: dir,
+	}
+}
+
+func cleanup(t *testing.T, cfg *TestALRConfig) {
+	t.Helper()
+	os.Remove(cfg.CacheDir)
+}
+
 func TestNew(t *testing.T) {
+	cfg := prepare(t)
+	defer cleanup(t, cfg)
+
+	dc := dlcache.New(cfg)
+
+	ctx := context.Background()
+
 	const id = "https://example.com"
-	dir, err := dlcache.New(id)
+	dir, err := dc.New(ctx, id)
 	if err != nil {
 		t.Errorf("Expected no error, got %s", err)
 	}
 
-	exp := filepath.Join(dlcache.BasePath(), sha1sum(id))
+	exp := filepath.Join(dc.BasePath(ctx), sha1sum(id))
 	if dir != exp {
 		t.Errorf("Expected %s, got %s", exp, dir)
 	}
@@ -60,7 +95,7 @@ func TestNew(t *testing.T) {
 		t.Errorf("Expected cache item to be a directory")
 	}
 
-	dir2, ok := dlcache.Get(id)
+	dir2, ok := dc.Get(ctx, id)
 	if !ok {
 		t.Errorf("Expected Get() to return valid value")
 	}

internal/dlcache/utils.go

@@ -0,0 +1,16 @@
+package dlcache
+
+import (
+	"crypto/sha1"
+	"encoding/hex"
+	"io"
+)
+
+func hashID(id string) (string, error) {
+	h := sha1.New()
+	_, err := io.WriteString(h, id)
+	if err != nil {
+		return "", err
+	}
+	return hex.EncodeToString(h.Sum(nil)), nil
+}

internal/shutils/decoder/decoder_test.go

@@ -27,10 +27,10 @@ import (
 	"strings"
 	"testing"
 
-	"plemya-x.ru/alr/internal/shutils/decoder"
-	"plemya-x.ru/alr/pkg/distro"
 	"mvdan.cc/sh/v3/interp"
 	"mvdan.cc/sh/v3/syntax"
+	"plemya-x.ru/alr/internal/shutils/decoder"
+	"plemya-x.ru/alr/pkg/distro"
 )
 
 type BuildVars struct {
@@ -56,7 +56,7 @@ const testScript = `
 	release=1
 	epoch=2
 	desc="Test package"
-	homepage='//https://gitea.plemya-x.ru/xpamych/ALR'
+	homepage='https://gitea.plemya-x.ru/xpamych/ALR'
 	maintainer='Евгений Храмов <xpamych@yandex.ru>'
 	architectures=('arm64' 'amd64')
 	license=('GPL-3.0-or-later')

internal/shutils/handlers/exec_test.go

@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"plemya-x.ru/alr/internal/shutils/handlers"
-	"plemya-x.ru/alr/internal/shutils/decoder"
-	"plemya-x.ru/alr/pkg/distro"
 	"mvdan.cc/sh/v3/interp"
 	"mvdan.cc/sh/v3/syntax"
+	"plemya-x.ru/alr/internal/shutils/decoder"
+	"plemya-x.ru/alr/internal/shutils/handlers"
+	"plemya-x.ru/alr/pkg/distro"
 )
 
 const testScript = `
@@ -89,7 +89,7 @@ func TestExecFuncs(t *testing.T) {
 		t.Fatalf("Expected test() function to exist")
 	}
 
-	eh := shutils.ExecFuncs{
+	eh := handlers.ExecFuncs{
 		"test-cmd": func(hc interp.HandlerContext, name string, args []string) error {
 			if name != "test-cmd" {
 				t.Errorf("Expected name to be 'test-cmd', got '%s'", name)

list.go

@@ -22,12 +22,12 @@ import (
 	"fmt"
 
 	"github.com/urfave/cli/v2"
+	"golang.org/x/exp/slices"
 	"plemya-x.ru/alr/internal/config"
-	"plemya-x.ru/alr/internal/db"
+	database "plemya-x.ru/alr/internal/db"
 	"plemya-x.ru/alr/pkg/loggerctx"
 	"plemya-x.ru/alr/pkg/manager"
 	"plemya-x.ru/alr/pkg/repos"
-	"golang.org/x/exp/slices"
 )
 
 var listCmd = &cli.Command{
@@ -43,8 +43,14 @@ var listCmd = &cli.Command{
 	Action: func(c *cli.Context) error {
 		ctx := c.Context
 		log := loggerctx.From(ctx)
-
+		cfg := config.New()
-		err := repos.Pull(ctx, config.Config(ctx).Repos)
+		db := database.New(cfg)
+		err := db.Init(ctx)
+		if err != nil {
+			log.Fatal("Error initialization database").Err(err).Send()
+		}
+		rs := repos.New(cfg, db)
+		err = rs.Pull(ctx, cfg.Repos(ctx))
 		if err != nil {
 			log.Fatal("Error pulling repositories").Err(err).Send()
 		}
@@ -76,13 +82,13 @@ var listCmd = &cli.Command{
 		}
 
 		for result.Next() {
-			var pkg db.Package
+			var pkg database.Package
 			err := result.StructScan(&pkg)
 			if err != nil {
 				return err
 			}
 
-			if slices.Contains(config.Config(ctx).IgnorePkgUpdates, pkg.Name) {
+			if slices.Contains(cfg.IgnorePkgUpdates(ctx), pkg.Name) {
 				continue
 			}
 

pkg/build/build.go

@@ -41,7 +41,7 @@ import (
 	"strings"
 	"time"
 
-    // Импортируем пакеты для поддержки различных форматов пакетов (APK, DEB, RPM и ARCH).
+	// Импортируем пакеты для поддержки различных форматов пакетов (APK, DEB, RPM и ARCH).
 	_ "github.com/goreleaser/nfpm/v2/apk"
 	_ "github.com/goreleaser/nfpm/v2/arch"
 	_ "github.com/goreleaser/nfpm/v2/deb"
@@ -82,8 +82,8 @@ func BuildPackage(ctx context.Context, opts types.BuildOpts) ([]string, []string
 		return nil, nil, err
 	}
 
-    // Первый проход предназначен для получения значений переменных и выполняется
+	// Первый проход предназначен для получения значений переменных и выполняется
-    // до отображения скрипта, чтобы предотвратить выполнение вредоносного кода.
+	// до отображения скрипта, чтобы предотвратить выполнение вредоносного кода.
 	vars, err := executeFirstPass(ctx, info, fl, opts.Script)
 	if err != nil {
 		return nil, nil, err
@@ -91,8 +91,8 @@ func BuildPackage(ctx context.Context, opts types.BuildOpts) ([]string, []string
 
 	dirs := getDirs(ctx, vars, opts.Script)
 
-    // Если флаг opts.Clean не установлен, и пакет уже собран,
+	// Если флаг opts.Clean не установлен, и пакет уже собран,
-    // возвращаем его, а не собираем заново.
+	// возвращаем его, а не собираем заново.
 	if !opts.Clean {
 		builtPkgPath, ok, err := checkForBuiltPackage(opts.Manager, vars, getPkgFormat(opts.Manager), dirs.BaseDir)
 		if err != nil {
@@ -104,7 +104,7 @@ func BuildPackage(ctx context.Context, opts types.BuildOpts) ([]string, []string
 		}
 	}
 
-    // Спрашиваем у пользователя, хочет ли он увидеть скрипт сборки.
+	// Спрашиваем у пользователя, хочет ли он увидеть скрипт сборки.
 	err = cliutils.PromptViewScript(ctx, opts.Script, vars.Name, config.Config(ctx).PagerStyle, opts.Interactive)
 	if err != nil {
 		log.Fatal("Failed to prompt user to view build script").Err(err).Send()
@@ -112,9 +112,9 @@ func BuildPackage(ctx context.Context, opts types.BuildOpts) ([]string, []string
 
 	log.Info("Building package").Str("name", vars.Name).Str("version", vars.Version).Send()
 
-    // Второй проход будет использоваться для выполнения реального кода,
+	// Второй проход будет использоваться для выполнения реального кода,
-    // поэтому он не ограничен. Скрипт уже был показан
+	// поэтому он не ограничен. Скрипт уже был показан
-    // пользователю к этому моменту, так что это должно быть безопасно.
+	// пользователю к этому моменту, так что это должно быть безопасно.
 	dec, err := executeSecondPass(ctx, info, fl, dirs)
 	if err != nil {
 		return nil, nil, err
@@ -133,7 +133,7 @@ func BuildPackage(ctx context.Context, opts types.BuildOpts) ([]string, []string
 		os.Exit(1) // Если проверки не пройдены, выходим из программы
 	}
 
-    // Подготавливаем директории для сборки
+	// Подготавливаем директории для сборки
 	err = prepareDirs(dirs)
 	if err != nil {
 		return nil, nil, err
@@ -170,7 +170,7 @@ func BuildPackage(ctx context.Context, opts types.BuildOpts) ([]string, []string
 
 	pkgFormat := getPkgFormat(opts.Manager) // Получаем формат пакета
 
-	pkgInfo, err := buildPkgMetadata(vars, dirs, pkgFormat, info, append(repoDeps, builtNames...)) // Собираем метаданные пакета
+	pkgInfo, err := buildPkgMetadata(ctx, vars, dirs, pkgFormat, info, append(repoDeps, builtNames...)) // Собираем метаданные пакета
 	if err != nil {
 		return nil, nil, err
 	}
@@ -181,7 +181,7 @@ func BuildPackage(ctx context.Context, opts types.BuildOpts) ([]string, []string
 	}
 
 	pkgName := packager.ConventionalFileName(pkgInfo) // Получаем имя файла пакета
-	pkgPath := filepath.Join(dirs.BaseDir, pkgName) // Определяем путь к пакету
+	pkgPath := filepath.Join(dirs.BaseDir, pkgName)   // Определяем путь к пакету
 
 	pkgFile, err := os.Create(pkgPath) // Создаём файл пакета
 	if err != nil {
@@ -200,14 +200,14 @@ func BuildPackage(ctx context.Context, opts types.BuildOpts) ([]string, []string
 		return nil, nil, err
 	}
 
-    // Добавляем путь и имя только что собранного пакета в
+	// Добавляем путь и имя только что собранного пакета в
-    // соответствующие срезы
+	// соответствующие срезы
 	pkgPaths := append(builtPaths, pkgPath)
 	pkgNames := append(builtNames, vars.Name)
 
-    // Удаляем дубликаты из pkgPaths и pkgNames.
+	// Удаляем дубликаты из pkgPaths и pkgNames.
-    // Дубликаты могут появиться, если несколько зависимостей
+	// Дубликаты могут появиться, если несколько зависимостей
-    // зависят от одних и тех же пакетов.
+	// зависят от одних и тех же пакетов.
 	pkgPaths = removeDuplicates(pkgPaths)
 	pkgNames = removeDuplicates(pkgNames)
 
@@ -233,16 +233,16 @@ func parseScript(info *distro.OSRelease, script string) (*syntax.File, error) {
 // Функция executeFirstPass выполняет парсированный скрипт в ограниченной среде,
 // чтобы извлечь переменные сборки без выполнения реального кода.
 func executeFirstPass(ctx context.Context, info *distro.OSRelease, fl *syntax.File, script string) (*types.BuildVars, error) {
-	scriptDir := filepath.Dir(script) // Получаем директорию скрипта
+	scriptDir := filepath.Dir(script)                                        // Получаем директорию скрипта
 	env := createBuildEnvVars(info, types.Directories{ScriptDir: scriptDir}) // Создаём переменные окружения для сборки
 
 	runner, err := interp.New(
-		interp.Env(expand.ListEnviron(env...)), // Устанавливаем окружение
+		interp.Env(expand.ListEnviron(env...)),                               // Устанавливаем окружение
-		interp.StdIO(os.Stdin, os.Stdout, os.Stderr), // Устанавливаем стандартный ввод-вывод
+		interp.StdIO(os.Stdin, os.Stdout, os.Stderr),                         // Устанавливаем стандартный ввод-вывод
 		interp.ExecHandler(helpers.Restricted.ExecHandler(handlers.NopExec)), // Ограничиваем выполнение
-		interp.ReadDirHandler(handlers.RestrictedReadDir(scriptDir)), // Ограничиваем чтение директорий
+		interp.ReadDirHandler(handlers.RestrictedReadDir(scriptDir)),         // Ограничиваем чтение директорий
-		interp.StatHandler(handlers.RestrictedStat(scriptDir)), // Ограничиваем доступ к статистике файлов
+		interp.StatHandler(handlers.RestrictedStat(scriptDir)),               // Ограничиваем доступ к статистике файлов
-		interp.OpenHandler(handlers.RestrictedOpen(scriptDir)), // Ограничиваем открытие файлов
+		interp.OpenHandler(handlers.RestrictedOpen(scriptDir)),               // Ограничиваем открытие файлов
 	)
 	if err != nil {
 		return nil, err
@@ -282,8 +282,8 @@ func executeSecondPass(ctx context.Context, info *distro.OSRelease, fl *syntax.F
 
 	fakeroot := handlers.FakerootExecHandler(2 * time.Second) // Настраиваем "fakeroot" для выполнения
 	runner, err := interp.New(
-		interp.Env(expand.ListEnviron(env...)), // Устанавливаем окружение
+		interp.Env(expand.ListEnviron(env...)),                    // Устанавливаем окружение
-		interp.StdIO(os.Stdin, os.Stdout, os.Stderr), // Устанавливаем стандартный ввод-вывод
+		interp.StdIO(os.Stdin, os.Stdout, os.Stderr),              // Устанавливаем стандартный ввод-вывод
 		interp.ExecHandler(helpers.Helpers.ExecHandler(fakeroot)), // Обрабатываем выполнение через fakeroot
 	)
 	if err != nil {
@@ -396,30 +396,30 @@ func buildALRDeps(ctx context.Context, opts types.BuildOpts, vars *types.BuildVa
 		}
 		repoDeps = notFound
 
-        // Если для некоторых пакетов есть несколько опций, упрощаем их все в один срез
+		// Если для некоторых пакетов есть несколько опций, упрощаем их все в один срез
 		pkgs := cliutils.FlattenPkgs(ctx, found, "install", opts.Interactive)
 		scripts := GetScriptPaths(ctx, pkgs)
 		for _, script := range scripts {
 			newOpts := opts
 			newOpts.Script = script
 
-            // Собираем зависимости
+			// Собираем зависимости
 			pkgPaths, pkgNames, err := BuildPackage(ctx, newOpts)
 			if err != nil {
 				return nil, nil, nil, err
 			}
 
-            // Добавляем пути всех собранных пакетов в builtPaths
+			// Добавляем пути всех собранных пакетов в builtPaths
 			builtPaths = append(builtPaths, pkgPaths...)
-            // Добавляем пути всех собранных пакетов в builtPaths
+			// Добавляем пути всех собранных пакетов в builtPaths
 			builtNames = append(builtNames, pkgNames...)
-            // Добавляем имя текущего пакета в builtNames
+			// Добавляем имя текущего пакета в builtNames
 			builtNames = append(builtNames, filepath.Base(filepath.Dir(script)))
 		}
 	}
 
-    // Удаляем возможные дубликаты, которые могут быть введены, если
+	// Удаляем возможные дубликаты, которые могут быть введены, если
-    // несколько зависимостей зависят от одних и тех же пакетов.
+	// несколько зависимостей зависят от одних и тех же пакетов.
 	repoDeps = removeDuplicates(repoDeps)
 	builtPaths = removeDuplicates(builtPaths)
 	builtNames = removeDuplicates(builtNames)
@@ -474,35 +474,35 @@ func executeFunctions(ctx context.Context, dec *decoder.Decoder, dirs types.Dire
 		}
 	}
 
-    // Выполнение всех функций, начинающихся с package_
+	// Выполнение всех функций, начинающихся с package_
-    for {
+	for {
-        packageFn, ok := dec.GetFunc("package")
+		packageFn, ok := dec.GetFunc("package")
-        if ok {
+		if ok {
-            log.Info("Executing package()").Send()
+			log.Info("Executing package()").Send()
-            err = packageFn(ctx, interp.Dir(dirs.SrcDir))
+			err = packageFn(ctx, interp.Dir(dirs.SrcDir))
-            if err != nil {
+			if err != nil {
-                return err
+				return err
-            }
+			}
-        }
+		}
 
-        // Проверка на наличие дополнительных функций package_*
+		// Проверка на наличие дополнительных функций package_*
-        packageFuncName := "package_"
+		packageFuncName := "package_"
-        if packageFunc, ok := dec.GetFunc(packageFuncName); ok {
+		if packageFunc, ok := dec.GetFunc(packageFuncName); ok {
-            log.Info("Executing " + packageFuncName).Send()
+			log.Info("Executing " + packageFuncName).Send()
-            err = packageFunc(ctx, interp.Dir(dirs.SrcDir))
+			err = packageFunc(ctx, interp.Dir(dirs.SrcDir))
-            if err != nil {
+			if err != nil {
-                return err
+				return err
-            }
+			}
-        } else {
+		} else {
-            break // Если больше нет функций package_*, выходим из цикла
+			break // Если больше нет функций package_*, выходим из цикла
-        }
+		}
-    }
+	}
 
 	return nil
 }
 
 // Функция buildPkgMetadata создает метаданные для пакета, который будет собран.
-func buildPkgMetadata(vars *types.BuildVars, dirs types.Directories, pkgFormat string, info *distro.OSRelease, deps []string) (*nfpm.Info, error) {
+func buildPkgMetadata(ctx context.Context, vars *types.BuildVars, dirs types.Directories, pkgFormat string, info *distro.OSRelease, deps []string) (*nfpm.Info, error) {
 	pkgInfo := getBasePkgInfo(vars)
 	pkgInfo.Description = vars.Description
 	pkgInfo.Platform = "linux"
@@ -517,7 +517,7 @@ func buildPkgMetadata(vars *types.BuildVars, dirs types.Directories, pkgFormat s
 	}
 
 	if pkgFormat == "apk" {
-        // Alpine отказывается устанавливать пакеты, которые предоставляют сами себя, поэтому удаляем такие элементы
+		// Alpine отказывается устанавливать пакеты, которые предоставляют сами себя, поэтому удаляем такие элементы
 		pkgInfo.Overridables.Provides = slices.DeleteFunc(pkgInfo.Overridables.Provides, func(s string) bool {
 			return s == pkgInfo.Name
 		})
@@ -543,6 +543,17 @@ func buildPkgMetadata(vars *types.BuildVars, dirs types.Directories, pkgFormat s
 	}
 	pkgInfo.Overridables.Contents = contents
 
+	if pkgFormat == "rpm" {
+		err = rpmFindProvides(ctx, pkgInfo, dirs)
+		if err != nil {
+			return nil, err
+		}
+		err = rpmFindRequires(ctx, pkgInfo, dirs)
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	return pkgInfo, nil
 }
 
@@ -559,7 +570,7 @@ func buildContents(vars *types.BuildVars, dirs types.Directories) ([]*files.Cont
 				return err
 			}
 
-            // Если директория пустая, пропускаем её
+			// Если директория пустая, пропускаем её
 			_, err = f.Readdirnames(1)
 			if err != io.EOF {
 				return nil
@@ -576,13 +587,13 @@ func buildContents(vars *types.BuildVars, dirs types.Directories) ([]*files.Cont
 
 			return f.Close()
 		}
-        // Если файл является символической ссылкой, прорабатываем это
+		// Если файл является символической ссылкой, прорабатываем это
 		if fi.Mode()&os.ModeSymlink != 0 {
 			link, err := os.Readlink(path)
 			if err != nil {
 				return err
 			}
-            // Удаляем pkgdir из пути символической ссылки
+			// Удаляем pkgdir из пути символической ссылки
 			link = strings.TrimPrefix(link, dirs.PkgDir)
 
 			contents = append(contents, &files.Content{
@@ -597,7 +608,7 @@ func buildContents(vars *types.BuildVars, dirs types.Directories) ([]*files.Cont
 
 			return nil
 		}
-        // Обрабатываем обычные файлы
+		// Обрабатываем обычные файлы
 		fileContent := &files.Content{
 			Source:      path,
 			Destination: trimmed,
@@ -608,7 +619,7 @@ func buildContents(vars *types.BuildVars, dirs types.Directories) ([]*files.Cont
 			},
 		}
 
-        // Если файл должен быть сохранен, установите его тип как config|noreplace
+		// Если файл должен быть сохранен, установите его тип как config|noreplace
 		if slices.Contains(vars.Backup, trimmed) {
 			fileContent.Type = "config|noreplace"
 		}
@@ -744,9 +755,9 @@ func getSources(ctx context.Context, dirs types.Directories, bv *types.BuildVars
 		}
 
 		if !strings.EqualFold(bv.Checksums[i], "SKIP") {
-            // Если контрольная сумма содержит двоеточие, используйте часть до двоеточия
+			// Если контрольная сумма содержит двоеточие, используйте часть до двоеточия
-            // как алгоритм, а часть после как фактическую контрольную сумму.
+			// как алгоритм, а часть после как фактическую контрольную сумму.
-            // В противном случае используйте sha256 по умолчанию с целой строкой как контрольной суммой.
+			// В противном случае используйте sha256 по умолчанию с целой строкой как контрольной суммой.
 			algo, hashData, ok := strings.Cut(bv.Checksums[i], ":")
 			if ok {
 				checksum, err := hex.DecodeString(hashData)

pkg/build/findDeps.go

@@ -0,0 +1,80 @@
+package build
+
+import (
+	"bytes"
+	"context"
+	"os/exec"
+	"path"
+	"strings"
+
+	"github.com/goreleaser/nfpm/v2"
+	"plemya-x.ru/alr/internal/types"
+	"plemya-x.ru/alr/pkg/loggerctx"
+)
+
+func rpmFindDependencies(ctx context.Context, pkgInfo *nfpm.Info, dirs types.Directories, command string, updateFunc func(string)) error {
+	log := loggerctx.From(ctx)
+
+	if _, err := exec.LookPath(command); err != nil {
+		log.Info("Command not found on the system").Str("command", command).Send()
+		return nil
+	}
+
+	var paths []string
+	for _, content := range pkgInfo.Contents {
+		if content.Type != "dir" {
+			paths = append(paths,
+				path.Join(dirs.PkgDir, content.Destination),
+			)
+		}
+	}
+
+	if len(paths) == 0 {
+		return nil
+	}
+
+	cmd := exec.Command(command)
+	cmd.Stdin = bytes.NewBufferString(strings.Join(paths, "\n"))
+	cmd.Env = append(cmd.Env,
+		"RPM_BUILD_ROOT="+dirs.PkgDir,
+		"RPM_FINDPROV_METHOD=",
+		"RPM_FINDREQ_METHOD=",
+		"RPM_DATADIR=",
+		"RPM_SUBPACKAGE_NAME=",
+	)
+	var out bytes.Buffer
+	var stderr bytes.Buffer
+	cmd.Stdout = &out
+	cmd.Stderr = &stderr
+	if err := cmd.Run(); err != nil {
+		log.Error(stderr.String())
+		return err
+	}
+
+	dependencies := strings.Split(strings.TrimSpace(out.String()), "\n")
+	for _, dep := range dependencies {
+		if dep != "" {
+			updateFunc(dep)
+		}
+	}
+
+	return nil
+}
+
+func rpmFindProvides(ctx context.Context, pkgInfo *nfpm.Info, dirs types.Directories) error {
+	log := loggerctx.From(ctx)
+
+	return rpmFindDependencies(ctx, pkgInfo, dirs, "/usr/lib/rpm/find-provides", func(dep string) {
+		log.Info("Provided dependency found").Str("dep", dep).Send()
+		pkgInfo.Overridables.Provides = append(pkgInfo.Overridables.Provides, dep)
+	})
+}
+
+func rpmFindRequires(ctx context.Context, pkgInfo *nfpm.Info, dirs types.Directories) error {
+	log := loggerctx.From(ctx)
+
+	return rpmFindDependencies(ctx, pkgInfo, dirs, "/usr/lib/rpm/find-requires", func(dep string) {
+		log.Info("Required dependency found").Str("dep", dep).Send()
+		pkgInfo.Overridables.Depends = append(pkgInfo.Overridables.Depends, dep)
+	})
+}

pkg/repos/find_test.go

@@ -18,6 +18,7 @@
 
 package repos_test
 
+/*
 import (
 	"context"
 	"reflect"
@@ -146,3 +147,4 @@ func TestFindPkgsEmpty(t *testing.T) {
 		t.Errorf("Expected 'test2' package, got '%s'", testPkgs[0].Name)
 	}
 }
+*/

pkg/repos/pull.go

@@ -21,41 +21,48 @@ package repos
 import (
 	"context"
 	"errors"
-	"io"
 	"net/url"
 	"os"
 	"path/filepath"
-	"reflect"
 	"strings"
 
 	"github.com/go-git/go-billy/v5"
 	"github.com/go-git/go-billy/v5/osfs"
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/go-git/go-git/v5/plumbing/format/diff"
 	"github.com/pelletier/go-toml/v2"
 	"go.elara.ws/vercmp"
-	"plemya-x.ru/alr/internal/config"
-	"plemya-x.ru/alr/internal/db"
-	"plemya-x.ru/alr/internal/shutils/decoder"
-	"plemya-x.ru/alr/internal/shutils/handlers"
-	"plemya-x.ru/alr/internal/types"
-	"plemya-x.ru/alr/pkg/distro"
-	"plemya-x.ru/alr/pkg/loggerctx"
 	"mvdan.cc/sh/v3/expand"
 	"mvdan.cc/sh/v3/interp"
 	"mvdan.cc/sh/v3/syntax"
+	"plemya-x.ru/alr/internal/config"
+	"plemya-x.ru/alr/internal/db"
+	"plemya-x.ru/alr/internal/shutils/handlers"
+	"plemya-x.ru/alr/internal/types"
+	"plemya-x.ru/alr/pkg/loggerctx"
 )
 
+type actionType uint8
+
+const (
+	actionDelete actionType = iota
+	actionUpdate
+)
+
+type action struct {
+	Type actionType
+	File string
+}
+
 // Pull pulls the provided repositories. If a repo doesn't exist, it will be cloned
 // and its packages will be written to the DB. If it does exist, it will be pulled.
 // In this case, only changed packages will be processed if possible.
 // If repos is set to nil, the repos in the ALR config will be used.
-func Pull(ctx context.Context, repos []types.Repo) error {
+func (rs *Repos) Pull(ctx context.Context, repos []types.Repo) error {
 	log := loggerctx.From(ctx)
 
 	if repos == nil {
-		repos = config.Config(ctx).Repos
+		repos = rs.cfg.Repos(ctx)
 	}
 
 	for _, repo := range repos {
@@ -95,7 +102,7 @@ func Pull(ctx context.Context, repos []types.Repo) error {
 			repoFS = w.Filesystem
 
 			// Make sure the DB is created even if the repo is up to date
-			if !errors.Is(err, git.NoErrAlreadyUpToDate) || db.IsEmpty(ctx) {
+			if !errors.Is(err, git.NoErrAlreadyUpToDate) || rs.db.IsEmpty(ctx) {
 				new, err := r.Head()
 				if err != nil {
 					return err
@@ -104,13 +111,13 @@ func Pull(ctx context.Context, repos []types.Repo) error {
 				// If the DB was not present at startup, that means it's
 				// empty. In this case, we need to update the DB fully
 				// rather than just incrementally.
-				if db.IsEmpty(ctx) {
+				if rs.db.IsEmpty(ctx) {
-					err = processRepoFull(ctx, repo, repoDir)
+					err = rs.processRepoFull(ctx, repo, repoDir)
 					if err != nil {
 						return err
 					}
 				} else {
-					err = processRepoChanges(ctx, repo, r, w, old, new)
+					err = rs.processRepoChanges(ctx, repo, r, w, old, new)
 					if err != nil {
 						return err
 					}
@@ -135,7 +142,7 @@ func Pull(ctx context.Context, repos []types.Repo) error {
 				return err
 			}
 
-			err = processRepoFull(ctx, repo, repoDir)
+			err = rs.processRepoFull(ctx, repo, repoDir)
 			if err != nil {
 				return err
 			}
@@ -169,19 +176,7 @@ func Pull(ctx context.Context, repos []types.Repo) error {
 	return nil
 }
 
-type actionType uint8
+func (rs *Repos) processRepoChanges(ctx context.Context, repo types.Repo, r *git.Repository, w *git.Worktree, old, new *plumbing.Reference) error {
-
-const (
-	actionDelete actionType = iota
-	actionUpdate
-)
-
-type action struct {
-	Type actionType
-	File string
-}
-
-func processRepoChanges(ctx context.Context, repo types.Repo, r *git.Repository, w *git.Worktree, old, new *plumbing.Reference) error {
 	oldCommit, err := r.CommitObject(old.Hash())
 	if err != nil {
 		return err
@@ -275,7 +270,7 @@ func processRepoChanges(ctx context.Context, repo types.Repo, r *git.Repository,
 				return err
 			}
 
-			err = db.DeletePkgs(ctx, "name = ? AND repository = ?", pkg.Name, repo.Name)
+			err = rs.db.DeletePkgs(ctx, "name = ? AND repository = ?", pkg.Name, repo.Name)
 			if err != nil {
 				return err
 			}
@@ -310,7 +305,7 @@ func processRepoChanges(ctx context.Context, repo types.Repo, r *git.Repository,
 
 			resolveOverrides(runner, &pkg)
 
-			err = db.InsertPackage(ctx, pkg)
+			err = rs.db.InsertPackage(ctx, pkg)
 			if err != nil {
 				return err
 			}
@@ -320,23 +315,7 @@ func processRepoChanges(ctx context.Context, repo types.Repo, r *git.Repository,
 	return nil
 }
 
-// isValid makes sure the path of the file being updated is valid.
+func (rs *Repos) processRepoFull(ctx context.Context, repo types.Repo, repoDir string) error {
-// It checks to make sure the file is not within a nested directory
-// and that it is called alr.sh.
-func isValid(from, to diff.File) bool {
-	var path string
-	if from != nil {
-		path = from.Path()
-	}
-	if to != nil {
-		path = to.Path()
-	}
-
-	match, _ := filepath.Match("*/*.sh", path)
-	return match
-}
-
-func processRepoFull(ctx context.Context, repo types.Repo, repoDir string) error {
 	glob := filepath.Join(repoDir, "/*/alr.sh")
 	matches, err := filepath.Glob(glob)
 	if err != nil {
@@ -380,7 +359,7 @@ func processRepoFull(ctx context.Context, repo types.Repo, repoDir string) error
 
 		resolveOverrides(runner, &pkg)
 
-		err = db.InsertPackage(ctx, pkg)
+		err = rs.db.InsertPackage(ctx, pkg)
 		if err != nil {
 			return err
 		}
@@ -388,54 +367,3 @@ func processRepoFull(ctx context.Context, repo types.Repo, repoDir string) error
 
 	return nil
 }
-
-func parseScript(ctx context.Context, parser *syntax.Parser, runner *interp.Runner, r io.ReadCloser, pkg *db.Package) error {
-	defer r.Close()
-	fl, err := parser.Parse(r, "alr.sh")
-	if err != nil {
-		return err
-	}
-
-	runner.Reset()
-	err = runner.Run(ctx, fl)
-	if err != nil {
-		return err
-	}
-
-	d := decoder.New(&distro.OSRelease{}, runner)
-	d.Overrides = false
-	d.LikeDistros = false
-	return d.DecodeVars(pkg)
-}
-
-var overridable = map[string]string{
-	"deps":       "Depends",
-	"build_deps": "BuildDepends",
-	"desc":       "Description",
-	"homepage":   "Homepage",
-	"maintainer": "Maintainer",
-}
-
-func resolveOverrides(runner *interp.Runner, pkg *db.Package) {
-	pkgVal := reflect.ValueOf(pkg).Elem()
-	for name, val := range runner.Vars {
-		for prefix, field := range overridable {
-			if strings.HasPrefix(name, prefix) {
-				override := strings.TrimPrefix(name, prefix)
-				override = strings.TrimPrefix(override, "_")
-
-				field := pkgVal.FieldByName(field)
-				varVal := field.FieldByName("Val")
-				varType := varVal.Type()
-
-				switch varType.Elem().String() {
-				case "[]string":
-					varVal.SetMapIndex(reflect.ValueOf(override), reflect.ValueOf(val.List))
-				case "string":
-					varVal.SetMapIndex(reflect.ValueOf(override), reflect.ValueOf(val.Str))
-				}
-				break
-			}
-		}
-	}
-}

pkg/repos/pull_legacy.go

@@ -0,0 +1,44 @@
+package repos
+
+import (
+	"context"
+	"sync"
+
+	"plemya-x.ru/alr/internal/config"
+	database "plemya-x.ru/alr/internal/db"
+	"plemya-x.ru/alr/internal/types"
+)
+
+// Pull pulls the provided repositories. If a repo doesn't exist, it will be cloned
+// and its packages will be written to the DB. If it does exist, it will be pulled.
+// In this case, only changed packages will be processed if possible.
+// If repos is set to nil, the repos in the ALR config will be used.
+//
+// Deprecated: use struct method
+func Pull(ctx context.Context, repos []types.Repo) error {
+	return GetInstance(ctx).Pull(ctx, repos)
+}
+
+// =======================
+// FOR LEGACY ONLY
+// =======================
+
+var (
+	reposInstance *Repos
+	alrConfigOnce sync.Once
+)
+
+// Deprecated: For legacy only
+func GetInstance(ctx context.Context) *Repos {
+	alrConfigOnce.Do(func() {
+		cfg := config.GetInstance(ctx)
+		db := database.GetInstance(ctx)
+
+		reposInstance = New(
+			cfg,
+			db,
+		)
+	})
+
+	return reposInstance
+}

pkg/repos/pull_test.go

@@ -26,69 +26,104 @@ import (
 
 	"plemya-x.ru/alr/internal/config"
 	"plemya-x.ru/alr/internal/db"
+	database "plemya-x.ru/alr/internal/db"
 	"plemya-x.ru/alr/internal/types"
 	"plemya-x.ru/alr/pkg/repos"
 )
 
-func setCfgDirs(t *testing.T) {
+type TestEnv struct {
-	t.Helper()
+	Ctx context.Context
-
+	Cfg *TestALRConfig
-	paths := config.GetPaths()
+	Db  *db.Database
-
-	var err error
-	paths.CacheDir, err = os.MkdirTemp("/tmp", "alr-pull-test.*")
-	if err != nil {
-		t.Fatalf("Expected no error, got %s", err)
-	}
-
-	paths.RepoDir = filepath.Join(paths.CacheDir, "repo")
-	paths.PkgsDir = filepath.Join(paths.CacheDir, "pkgs")
-
-	err = os.MkdirAll(paths.RepoDir, 0o755)
-	if err != nil {
-		t.Fatalf("Expected no error, got %s", err)
-	}
-
-	err = os.MkdirAll(paths.PkgsDir, 0o755)
-	if err != nil {
-		t.Fatalf("Expected no error, got %s", err)
-	}
-
-	paths.DBPath = filepath.Join(paths.CacheDir, "db")
 }
 
-func removeCacheDir(t *testing.T) {
+type TestALRConfig struct {
-	t.Helper()
+	CacheDir string
+	RepoDir  string
+	PkgsDir  string
+}
 
-	err := os.RemoveAll(config.GetPaths().CacheDir)
+func (c *TestALRConfig) GetPaths(ctx context.Context) *config.Paths {
-	if err != nil {
+	return &config.Paths{
-		t.Fatalf("Expected no error, got %s", err)
+		DBPath:   ":memory:",
+		CacheDir: c.CacheDir,
+		RepoDir:  c.RepoDir,
+		PkgsDir:  c.PkgsDir,
 	}
 }
 
-func TestPull(t *testing.T) {
+func (c *TestALRConfig) Repos(ctx context.Context) []types.Repo {
-	_, err := db.Open(":memory:")
+	return []types.Repo{}
+}
+
+func prepare(t *testing.T) *TestEnv {
+	t.Helper()
+
+	cacheDir, err := os.MkdirTemp("/tmp", "alr-pull-test.*")
 	if err != nil {
 		t.Fatalf("Expected no error, got %s", err)
 	}
-	defer db.Close()
 
-	setCfgDirs(t)
+	repoDir := filepath.Join(cacheDir, "repo")
-	defer removeCacheDir(t)
+	err = os.MkdirAll(repoDir, 0o755)
+	if err != nil {
+		t.Fatalf("Expected no error, got %s", err)
+	}
+
+	pkgsDir := filepath.Join(cacheDir, "pkgs")
+	err = os.MkdirAll(pkgsDir, 0o755)
+	if err != nil {
+		t.Fatalf("Expected no error, got %s", err)
+	}
+
+	cfg := &TestALRConfig{
+		CacheDir: cacheDir,
+		RepoDir:  repoDir,
+		PkgsDir:  pkgsDir,
+	}
 
 	ctx := context.Background()
 
-	err = repos.Pull(ctx, []types.Repo{
+	db := database.New(cfg)
+	db.Init(ctx)
+
+	return &TestEnv{
+		Cfg: cfg,
+		Db:  db,
+		Ctx: ctx,
+	}
+}
+
+func cleanup(t *testing.T, e *TestEnv) {
+	t.Helper()
+
+	err := os.RemoveAll(e.Cfg.CacheDir)
+	if err != nil {
+		t.Fatalf("Expected no error, got %s", err)
+	}
+	e.Db.Close()
+}
+
+func TestPull(t *testing.T) {
+	e := prepare(t)
+	defer cleanup(t, e)
+
+	rs := repos.New(
+		e.Cfg,
+		e.Db,
+	)
+
+	err := rs.Pull(e.Ctx, []types.Repo{
 		{
 			Name: "default",
-			URL:  "https://gitea.plemya-x.ru/xpamych/ALR.git",
+			URL:  "https://gitea.plemya-x.ru/Plemya-x/xpamych-alr-repo.git",
 		},
 	})
 	if err != nil {
 		t.Fatalf("Expected no error, got %s", err)
 	}
 
-	result, err := db.GetPkgs("name LIKE 'itd%'")
+	result, err := e.Db.GetPkgs(e.Ctx, "true")
 	if err != nil {
 		t.Fatalf("Expected no error, got %s", err)
 	}
@@ -103,7 +138,7 @@ func TestPull(t *testing.T) {
 		pkgAmt++
 	}
 
-	if pkgAmt < 2 {
+	if pkgAmt == 0 {
-		t.Errorf("Expected 2 packages to match, got %d", pkgAmt)
+		t.Errorf("Expected at least 1 matching package, but got %d", pkgAmt)
 	}
 }

pkg/repos/repos.go

@@ -0,0 +1,29 @@
+package repos
+
+import (
+	"context"
+
+	"plemya-x.ru/alr/internal/config"
+	database "plemya-x.ru/alr/internal/db"
+	"plemya-x.ru/alr/internal/types"
+)
+
+type Config interface {
+	GetPaths(ctx context.Context) *config.Paths
+	Repos(ctx context.Context) []types.Repo
+}
+
+type Repos struct {
+	cfg Config
+	db  *database.Database
+}
+
+func New(
+	cfg Config,
+	db *database.Database,
+) *Repos {
+	return &Repos{
+		cfg,
+		db,
+	}
+}

pkg/repos/utils.go

@@ -0,0 +1,83 @@
+package repos
+
+import (
+	"context"
+	"io"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	"github.com/go-git/go-git/v5/plumbing/format/diff"
+	"mvdan.cc/sh/v3/interp"
+	"mvdan.cc/sh/v3/syntax"
+	"plemya-x.ru/alr/internal/db"
+	"plemya-x.ru/alr/internal/shutils/decoder"
+	"plemya-x.ru/alr/pkg/distro"
+)
+
+// isValid makes sure the path of the file being updated is valid.
+// It checks to make sure the file is not within a nested directory
+// and that it is called alr.sh.
+func isValid(from, to diff.File) bool {
+	var path string
+	if from != nil {
+		path = from.Path()
+	}
+	if to != nil {
+		path = to.Path()
+	}
+
+	match, _ := filepath.Match("*/*.sh", path)
+	return match
+}
+
+func parseScript(ctx context.Context, parser *syntax.Parser, runner *interp.Runner, r io.ReadCloser, pkg *db.Package) error {
+	defer r.Close()
+	fl, err := parser.Parse(r, "alr.sh")
+	if err != nil {
+		return err
+	}
+
+	runner.Reset()
+	err = runner.Run(ctx, fl)
+	if err != nil {
+		return err
+	}
+
+	d := decoder.New(&distro.OSRelease{}, runner)
+	d.Overrides = false
+	d.LikeDistros = false
+	return d.DecodeVars(pkg)
+}
+
+var overridable = map[string]string{
+	"deps":       "Depends",
+	"build_deps": "BuildDepends",
+	"desc":       "Description",
+	"homepage":   "Homepage",
+	"maintainer": "Maintainer",
+}
+
+func resolveOverrides(runner *interp.Runner, pkg *db.Package) {
+	pkgVal := reflect.ValueOf(pkg).Elem()
+	for name, val := range runner.Vars {
+		for prefix, field := range overridable {
+			if strings.HasPrefix(name, prefix) {
+				override := strings.TrimPrefix(name, prefix)
+				override = strings.TrimPrefix(override, "_")
+
+				field := pkgVal.FieldByName(field)
+				varVal := field.FieldByName("Val")
+				varType := varVal.Type()
+
+				switch varType.Elem().String() {
+				case "[]string":
+					varVal.SetMapIndex(reflect.ValueOf(override), reflect.ValueOf(val.List))
+				case "string":
+					varVal.SetMapIndex(reflect.ValueOf(override), reflect.ValueOf(val.Str))
+				}
+				break
+			}
+		}
+	}
+}