Merge pull request #7 from underbek/feature/parse_broken_sources

Fixed parsing broken sources

README.md

@@ -3,7 +3,7 @@
 ### Install
 
 ```shell
-go install github.com/underbek/datamapper@v0.0.6
+go install github.com/underbek/datamapper@v0.0.7
 ```
 
 ### Usage
@@ -137,10 +137,9 @@ func ConvertStringToDecimal(from string) (decimal.Decimal, error) {
 * [x] Generate convertor with from/to pointer
 * [x] Fix error by parsing function as member
 * [x] Wrap errors
-* [ ] Parse packages with broken sources
+* [x] Parse packages with broken sources
 * [ ] Update readme
 * [ ] Map field without tag
-* [ ] Use in my projects
 * [ ] Generate convertors with map fields
 * [ ] Generate convertors with array fields
 * [ ] Recursive convert by option if not found conversions

_test_data/mapper/broken/models.go

@@ -0,0 +1,21 @@
+package transport
+
+import "github.com/google/uuid"
+
+type User struct {
+	UUID       uuid.UUID `json:"uuid" map:"id"`
+	Name       string    `json:"name" map:"name"`
+	Age        string    `map:"age"`
+	ChildCount *string   `map:"children"`
+}
+
+type BrokenUser [T]struct {
+	UUID       uuid.UUID `json:"uuid" map:"id"`
+	Name       string    `json:"name" map:"name"`
+	Age        string    `map:"age"`
+	ChildCount *string   `map:"children"`
+}
+
+type BrokenUser2 struct {
+	UUID `json:"uuid"`
+}

_test_data/mapper/convertors_with_broken/user_conversion_functions.go

@@ -0,0 +1,19 @@
+package convertors
+
+import (
+	"github.com/google/uuid"
+	"github.com/shopspring/decimal"
+	"golang.org/x/exp/constraints"
+)
+
+func CustomUUIDToInteger[T constraints.Integer](from uuid.UUID) T {
+	return T(from.ID())
+}
+
+func CustomIntegerToUUID[T constraints.Integer](from T) uuid.UUID {
+	return uuid.New()
+}
+
+func BrokenConvertor(from decimal.Decimal) int {
+	return ""
+}

generator/generator_test.go

@@ -6,6 +6,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/underbek/datamapper/_test_data"
+	"github.com/underbek/datamapper/logger"
 	"github.com/underbek/datamapper/models"
 	"github.com/underbek/datamapper/parser"
 )
@@ -20,7 +21,7 @@ const (
 )
 
 func parseFunctions(t *testing.T, source string) models.Functions {
-	funcs, err := parser.ParseConversionFunctions(source)
+	funcs, err := parser.ParseConversionFunctions(logger.New(), source)
 	require.NoError(t, err)
 	return funcs
 }
@@ -250,17 +251,19 @@ func Test_GenerateConvertor(t *testing.T) {
 		},
 	}
 
+	lg := logger.New()
+
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			modelsFrom, err := parser.ParseModels(testGeneratorPath + tt.pathFrom + "/models.go")
+			modelsFrom, err := parser.ParseModels(lg, testGeneratorPath+tt.pathFrom+"/models.go")
 			require.NoError(t, err)
 
-			modelsTo, err := parser.ParseModels(testGeneratorPath + tt.pathTo + "/models.go")
+			modelsTo, err := parser.ParseModels(lg, testGeneratorPath+tt.pathTo+"/models.go")
 			require.NoError(t, err)
 
 			funcs := parseFunctions(t, tt.cfPath)
 
-			pkg, err := parser.ParseDestinationPackage(testGeneratorPath + tt.generatePath)
+			pkg, err := parser.ParseDestinationPackage(lg, testGeneratorPath+tt.generatePath)
 			require.NoError(t, err)
 
 			from := modelsFrom["From"]
@@ -282,10 +285,12 @@ func Test_GenerateConvertor(t *testing.T) {
 }
 
 func Test_GenerateConvertorWithAliases(t *testing.T) {
-	modelsFrom, err := parser.ParseModels(testGeneratorPath + "with_aliases/from")
+	lg := logger.New()
+
+	modelsFrom, err := parser.ParseModels(lg, testGeneratorPath+"with_aliases/from")
 	require.NoError(t, err)
 
-	modelsTo, err := parser.ParseModels(testGeneratorPath + "with_aliases/to")
+	modelsTo, err := parser.ParseModels(lg, testGeneratorPath+"with_aliases/to")
 	require.NoError(t, err)
 
 	funcs := parseFunctions(t, testGeneratorPath+"with_aliases/cf")
@@ -300,7 +305,7 @@ func Test_GenerateConvertorWithAliases(t *testing.T) {
 	to := modelsTo["To"]
 	to.Type.Package.Alias = "toalias"
 
-	pkg, err := parser.ParseDestinationPackage(testGeneratorPath + "with_aliases")
+	pkg, err := parser.ParseDestinationPackage(lg, testGeneratorPath+"with_aliases")
 	require.NoError(t, err)
 
 	pkgs, convertor, err := GenerateConvertor(from, to, pkg, funcs)

logger/logger.go

@@ -0,0 +1,47 @@
+package logger
+
+import (
+	"fmt"
+	"log"
+	"os"
+)
+
+const depth = 2
+
+type Logger interface {
+	Info(v ...any)
+	Warn(v ...any)
+	Error(v ...any)
+	Fatal(v ...any)
+}
+
+type logger struct {
+	info  *log.Logger
+	warn  *log.Logger
+	error *log.Logger
+}
+
+func New() Logger {
+	return &logger{
+		info:  log.New(os.Stderr, "INFO: ", log.Ldate|log.Ltime),
+		warn:  log.New(os.Stderr, "WARNING: ", log.Ldate|log.Ltime),
+		error: log.New(os.Stderr, "ERROR: ", log.Ldate|log.Ltime),
+	}
+}
+
+func (l *logger) Info(v ...any) {
+	_ = l.info.Output(depth, fmt.Sprint(v...))
+}
+
+func (l *logger) Warn(v ...any) {
+	_ = l.warn.Output(depth, fmt.Sprint(v...))
+}
+
+func (l *logger) Error(v ...any) {
+	_ = l.error.Output(depth, fmt.Sprint(v...))
+}
+
+func (l *logger) Fatal(v ...any) {
+	_ = l.error.Output(depth, fmt.Sprint(v...))
+	os.Exit(1)
+}

main.go

@@ -1,21 +1,20 @@
 package main
 
 import (
-	"log"
-	"os"
-
+	"github.com/underbek/datamapper/logger"
 	"github.com/underbek/datamapper/mapper"
 	"github.com/underbek/datamapper/options"
 )
 
 func main() {
+	lg := logger.New()
 	opts, err := options.ParseOptions()
 	if err != nil {
-		os.Exit(1)
+		lg.Fatal(err)
 	}
 
-	err = mapper.MapModels(opts)
+	err = mapper.MapModels(lg, opts)
 	if err != nil {
-		log.Fatal(err)
+		lg.Fatal(err)
 	}
 }

mapper/mapper.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	"github.com/underbek/datamapper/generator"
+	"github.com/underbek/datamapper/logger"
 	"github.com/underbek/datamapper/models"
 	"github.com/underbek/datamapper/options"
 	"github.com/underbek/datamapper/parser"
@@ -21,10 +22,10 @@ var (
 	ErrNotFoundTag    = errors.New("not found tag error")
 )
 
-func MapModels(opts options.Options) error {
+func MapModels(lg logger.Logger, opts options.Options) error {
 	fromSource, fromAlias := parseSourceOption(opts.FromSource)
 
-	structs, err := parser.ParseModelsByPackage(fromSource)
+	structs, err := parser.ParseModelsByPackage(lg, fromSource)
 	if err != nil {
 		return fmt.Errorf("parse models error: %w", err)
 	}
@@ -37,7 +38,7 @@ func MapModels(opts options.Options) error {
 	from.Type.Pointer = isFromPointer
 
 	toSource, toAlias := parseSourceOption(opts.ToSource)
-	structs, err = parser.ParseModelsByPackage(toSource)
+	structs, err = parser.ParseModelsByPackage(lg, toSource)
 	if err != nil {
 		return fmt.Errorf("parse models error: %w", err)
 	}
@@ -70,7 +71,7 @@ func MapModels(opts options.Options) error {
 	}
 
 	//TODO: parse or copy embed sources
-	funcs, err := parser.ParseConversionFunctionsByPackage(internalConvertsPackagePath)
+	funcs, err := parser.ParseConversionFunctionsByPackage(lg, internalConvertsPackagePath)
 	if err != nil {
 		return fmt.Errorf("parse internal conversion functions error: %w", err)
 	}
@@ -80,7 +81,7 @@ func MapModels(opts options.Options) error {
 	if len(opts.UserCFSources) != 0 {
 		for _, optSource := range opts.UserCFSources {
 			source, cfAlias := parseSourceOption(optSource)
-			res, err := parser.ParseConversionFunctionsByPackage(source)
+			res, err := parser.ParseConversionFunctionsByPackage(lg, source)
 			if err != nil {
 				return fmt.Errorf("parse user conversion functions error: %w", err)
 			}
@@ -105,7 +106,7 @@ func MapModels(opts options.Options) error {
 		return fmt.Errorf("create destination dir %s error: %w", path.Dir(opts.Destination), err)
 	}
 
-	pkg, err := parser.ParseDestinationPackage(opts.Destination)
+	pkg, err := parser.ParseDestinationPackage(lg, opts.Destination)
 	if err != nil {
 		return fmt.Errorf("parse destination package %s error: %w", opts.Destination, err)
 	}

mapper/mapper_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/underbek/datamapper/_test_data"
+	"github.com/underbek/datamapper/logger"
 	"github.com/underbek/datamapper/options"
 )
 
@@ -106,9 +107,11 @@ func Test_IncorrectOptions(t *testing.T) {
 		},
 	}
 
+	lg := logger.New()
+
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err := MapModels(tt.opts)
+			err := MapModels(lg, tt.opts)
 			require.Error(t, err)
 		})
 	}
@@ -196,9 +199,11 @@ func Test_MapModels(t *testing.T) {
 		},
 	}
 
+	lg := logger.New()
+
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err := MapModels(tt.opts)
+			err := MapModels(lg, tt.opts)
 			require.NoError(t, err)
 
 			actual := readActual(t)

parser/conversion_functions.go

@@ -9,6 +9,7 @@ import (
 	"path/filepath"
 	"strings"
 
+	"github.com/underbek/datamapper/logger"
 	"github.com/underbek/datamapper/models"
 	"github.com/underbek/datamapper/utils"
 	"golang.org/x/tools/go/packages"
@@ -20,10 +21,10 @@ var (
 	ErrUndefinedType = errors.New("undefined type error")
 )
 
-func ParseConversionFunctionsByPackage(source string) (models.Functions, error) {
+func ParseConversionFunctionsByPackage(lg logger.Logger, source string) (models.Functions, error) {
 	_, err := os.Stat(source)
 	if err == nil {
-		return ParseConversionFunctions(source)
+		return ParseConversionFunctions(lg, source)
 	}
 
 	if !os.IsNotExist(err) {
@@ -40,16 +41,16 @@ func ParseConversionFunctionsByPackage(source string) (models.Functions, error)
 		return nil, err
 	}
 
-	return ParseConversionFunctions(p.Dir)
+	return ParseConversionFunctions(lg, p.Dir)
 }
-func ParseConversionFunctions(source string) (models.Functions, error) {
+func ParseConversionFunctions(lg logger.Logger, source string) (models.Functions, error) {
 
 	absSourcePath, err := filepath.Abs(source)
 	if err != nil {
 		return nil, err
 	}
 
-	pkg, err := utils.LoadPackage(source)
+	pkg, err := utils.LoadPackage(lg, source)
 	if err != nil {
 		return nil, err
 	}