refactor: interface

cmd/rimo/main.go

@@ -22,9 +22,9 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/cgi-fr/rimo/pkg/analyse"
-	"github.com/cgi-fr/rimo/pkg/io"
+	"github.com/cgi-fr/rimo/internal/infra"
 	"github.com/cgi-fr/rimo/pkg/model"
+	"github.com/cgi-fr/rimo/pkg/rimo"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
@@ -67,6 +67,7 @@ func main() { //nolint:funlen
 		},
 	}
 
+	// Make use of interface instead of analyse/pkg
 	rimoAnalyseCmd := &cobra.Command{ //nolint:exhaustruct
 		Use:   "analyse [inputDir] [outputDir]",
 		Short: "Generate a rimo.yaml from a directory of .jsonl files",
@@ -75,21 +76,33 @@ func main() { //nolint:funlen
 			inputDir := args[0]
 			outputDir := args[1]
 
-			// List .jsonl files in input directory
-			if err := io.ValidateDirPath(inputDir); err != nil {
-				log.Fatal().Msgf("error validating input directory: %v", err)
-			}
+			// Reader
 
-			inputList, err := FilesList(inputDir, ".jsonl")
+			inputList, err := BuildFilepathList(inputDir, ".jsonl")
 			if err != nil {
 				log.Fatal().Msgf("error listing files: %v", err)
 			}
 
-			if len(inputList) == 0 {
-				log.Fatal().Msgf("no .jsonl files found in %s", inputDir)
+			reader, err := infra.FilesReaderFactory(inputList)
+			if err != nil {
+				log.Fatal().Msgf("error creating reader: %v", err)
+			}
+
+			// Writer
+			// (could be relocated to infra.FilesReader)
+			baseName, _, err := infra.ExtractName(inputList[0])
+			if err != nil {
+				log.Fatal().Msgf("error extracting base name: %v", err)
+			}
+
+			outputPath := filepath.Join(outputDir, fmt.Sprintf("%s.yaml", baseName))
+
+			writer, err := infra.YAMLWriterFactory(outputPath)
+			if err != nil {
+				log.Fatal().Msgf("error creating writer: %v", err)
 			}
 
-			err = analyse.Orchestrator(inputList, outputDir)
+			err = rimo.AnalyseBase(reader, writer)
 			if err != nil {
 				log.Fatal().Msgf("error generating rimo.yaml: %v", err)
 			}
@@ -117,3 +130,44 @@ func FilesList(path string, extension string) ([]string, error) {
 
 	return files, nil
 }
+
+var ErrNoFile = fmt.Errorf("no file found")
+
+func BuildFilepathList(path string, extension string) ([]string, error) {
+	err := ValidateDirPath(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to validate input directory: %w", err)
+	}
+
+	pattern := filepath.Join(path, "*"+extension)
+
+	files, err := filepath.Glob(pattern)
+	if err != nil {
+		return nil, fmt.Errorf("error listing files: %w", err)
+	}
+
+	if len(files) == 0 {
+		return nil, fmt.Errorf("%w : no %s files found in %s", ErrNoFile, extension, path)
+	}
+
+	return files, nil
+}
+
+func ValidateDirPath(path string) error {
+	fileInfo, err := os.Stat(path)
+	if os.IsNotExist(err) {
+		return fmt.Errorf("%w: %s", infra.ErrDirDoesNotExist, path)
+	} else if err != nil {
+		return fmt.Errorf("failed to get directory info: %w", err)
+	}
+
+	if !fileInfo.IsDir() {
+		return fmt.Errorf("%w: %s", infra.ErrPathIsNotDir, path)
+	}
+
+	if fileInfo.Mode().Perm()&infra.WriteDirPerm != infra.WriteDirPerm {
+		return fmt.Errorf("%w: %s", infra.ErrWriteDirPermission, path)
+	}
+
+	return nil
+}

internal/infra/fileWriter.go

@@ -0,0 +1,81 @@
+// Copyright (C) 2023 CGI France
+//
+// This file is part of RIMO.
+//
+// RIMO 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.
+//
+// RIMO 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 RIMO.  If not, see <http://www.gnu.org/licenses/>.
+
+package infra
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/cgi-fr/rimo/pkg/model"
+	"gopkg.in/yaml.v3"
+)
+
+// Terminal writter interface
+
+type StdoutWriter struct{}
+
+func StdoutWriterFactory() *StdoutWriter {
+	writer := StdoutWriter{}
+
+	return &writer
+}
+
+func (w *StdoutWriter) Export(base *model.Base) error {
+	fmt.Printf("%v\n", base)
+
+	return nil
+}
+
+// YAML Writter interface
+
+type YAMLWriter struct {
+	outputPath string
+}
+
+func YAMLWriterFactory(filepath string) (*YAMLWriter, error) {
+	err := ValidateOutputPath(filepath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to validate file path: %w", err)
+	}
+
+	writer := YAMLWriter{
+		outputPath: filepath,
+	}
+
+	return &writer, nil
+}
+
+// Write a YAML file from RIMO base at outputPath.
+func (w *YAMLWriter) Export(base *model.Base) error {
+	outputFile, err := os.Create(w.outputPath)
+	if err != nil {
+		return fmt.Errorf("failed to create output file: %w", err)
+	}
+	defer outputFile.Close()
+
+	// Encode Base to YAML.
+	encoder := yaml.NewEncoder(outputFile)
+	defer encoder.Close()
+
+	err = encoder.Encode(base)
+	if err != nil {
+		return fmt.Errorf("failed to encode Base to YAML: %w", err)
+	}
+
+	return nil
+}

pkg/io/export_test.go → internal/infra/fileWriter_test.go

@@ -15,14 +15,14 @@
 // You should have received a copy of the GNU General Public License
 // along with RIMO.  If not, see <http://www.gnu.org/licenses/>.
 
-package io_test
+package infra_test
 
 import (
 	"os"
 	"path/filepath"
 	"testing"
 
-	"github.com/cgi-fr/rimo/pkg/io"
+	"github.com/cgi-fr/rimo/internal/infra"
 	"github.com/cgi-fr/rimo/pkg/model"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -32,7 +32,7 @@ const (
 	dataDir = "../../testdata/"
 )
 
-func TestExport(t *testing.T) {
+func TestWriterYAML(t *testing.T) {
 	t.Parallel()
 
 	base := model.Base{
@@ -54,8 +54,11 @@ func TestExport(t *testing.T) {
 	// Create a temporary file for the output
 	outputFile := filepath.Join(tempDir, "output.yaml")
 
-	// Export the base to the output file
-	err = io.Export(base, outputFile)
+	// Create the writer
+	writer, err := infra.YAMLWriterFactory(outputFile)
+	require.NoError(t, err)
+
+	err = writer.Export(&base)
 	require.NoError(t, err)
 
 	// Read the output file and check its contents