feat: add base structure

Author: ldmi3i

internal/load/contentLoader.go

@@ -0,0 +1,24 @@
+package load
+
+import (
+	"context"
+	"errors"
+	"github.com/rog-golang-buddies/internal/model"
+)
+
+//ContentLoader loads content by url
+type ContentLoader interface {
+	Load(ctx context.Context, url string) (*model.FileResource, error)
+}
+
+type ContentLoaderImpl struct {
+}
+
+func (cl *ContentLoaderImpl) Load(ctx context.Context, url string) (*model.FileResource, error) {
+	//load content by url
+	return nil, errors.New("not implemented")
+}
+
+func NewContentLoader() ContentLoader {
+	return &ContentLoaderImpl{}
+}

internal/model/apiSpecDoc.go

@@ -0,0 +1,4 @@
+package model
+
+type ApiSpecDoc struct {
+}

internal/model/fileResource.go

@@ -0,0 +1,13 @@
+package model
+
+//FileResource representation of file resource
+type FileResource struct {
+	//File name if exists, else empty
+	Name string
+
+	//Original link to file
+	Link string
+
+	//File content
+	Content []byte
+}

internal/model/fileType.go

@@ -0,0 +1,9 @@
+package model
+
+type AsdFileType int
+
+const (
+	Undefined AsdFileType = iota
+	YamlOpenApi
+	JsonOpenAPI
+)

internal/parse/converter.go

@@ -0,0 +1,40 @@
+package parse
+
+import (
+	"errors"
+	"github.com/rog-golang-buddies/internal/model"
+)
+
+//Converter converts file data to API specification document using specific file type
+type Converter interface {
+	Convert(content []byte, fileType model.AsdFileType) (*model.ApiSpecDoc, error)
+}
+
+type ConverterImpl struct {
+	//For instance, we may have a map to hold parsers for different types. And populate it in NewConverter
+	parsers map[model.AsdFileType]Parser
+}
+
+func (c *ConverterImpl) Convert(content []byte, fileType model.AsdFileType) (*model.ApiSpecDoc, error) {
+	//Just example
+	parser, ok := c.parsers[fileType]
+	if !ok {
+		return nil, errors.New("file type not supported")
+	}
+	apiSpec, err := parser.parse(content)
+	if err != nil {
+		return nil, err
+	}
+
+	return apiSpec, nil
+}
+
+func NewConverter(parsers []Parser) Converter {
+	parsersMap := make(map[model.AsdFileType]Parser)
+	for _, parser := range parsers {
+		parsers[parser.getType()] = parser
+	}
+	return &ConverterImpl{
+		parsers: parsersMap,
+	}
+}

internal/parse/jsonOpenApiParser.go

@@ -0,0 +1,22 @@
+package parse
+
+import (
+	"errors"
+	"github.com/rog-golang-buddies/internal/model"
+)
+
+//JsonOpenApiParser implementation for parsing json open API files
+type JsonOpenApiParser struct {
+}
+
+func (joap *JsonOpenApiParser) parse(content []byte) (*model.ApiSpecDoc, error) {
+	return nil, errors.New("not implemented")
+}
+
+func (joap *JsonOpenApiParser) getType() model.AsdFileType {
+	return model.JsonOpenAPI
+}
+
+func NewJsonOpenApiParser() Parser {
+	return &JsonOpenApiParser{}
+}

internal/parse/parser.go

@@ -0,0 +1,12 @@
+package parse
+
+import "github.com/rog-golang-buddies/internal/model"
+
+//Parser is common interface with functionality
+//to parse content of the specific API specification document
+//and to construct ApiSpecDoc object from it
+type Parser interface {
+	parse(content []byte) (*model.ApiSpecDoc, error)
+
+	getType() model.AsdFileType
+}

internal/parse/yamlOpenApiParser.go

@@ -0,0 +1,22 @@
+package parse
+
+import (
+	"errors"
+	"github.com/rog-golang-buddies/internal/model"
+)
+
+//YamlOpenApiParser implementation for parsing yml open API files
+type YamlOpenApiParser struct {
+}
+
+func (yoap *YamlOpenApiParser) parse(content []byte) (*model.ApiSpecDoc, error) {
+	return nil, errors.New("not implemented")
+}
+
+func (yoap *YamlOpenApiParser) getType() model.AsdFileType {
+	return model.JsonOpenAPI
+}
+
+func NewYamlOpenApiParser() Parser {
+	return &YamlOpenApiParser{}
+}

internal/process/processor.go

@@ -0,0 +1,55 @@
+package process
+
+import (
+	"context"
+	"github.com/rog-golang-buddies/internal/load"
+	"github.com/rog-golang-buddies/internal/model"
+	"github.com/rog-golang-buddies/internal/parse"
+	"github.com/rog-golang-buddies/internal/recognize"
+)
+
+//UrlProcessor represents provide entrypoint for the url processing
+//full processing of the incoming
+type UrlProcessor interface {
+	process(ctx context.Context, url string) (*model.ApiSpecDoc, error)
+}
+
+type ProcessorImpl struct {
+	recognizer    recognize.Recognizer
+	converter     parse.Converter
+	contentLoader load.ContentLoader
+}
+
+func (p *ProcessorImpl) process(ctx context.Context, url string) (*model.ApiSpecDoc, error) {
+	//Check availability of url
+	//...
+
+	//Load content by url
+	file, err := p.contentLoader.Load(ctx, url)
+	if err != nil {
+		return nil, err
+	}
+
+	//If no errs recognize file type by content
+	fileType, err := p.recognizer.RecognizeFileType(file)
+	if err != nil {
+		return nil, err
+	}
+
+	//Parse API spec of defined type
+	apiSpec, err := p.converter.Convert(file.Content, fileType)
+	if err != nil {
+		return nil, err
+	}
+
+	return apiSpec, nil
+}
+
+func NewProcessor() (UrlProcessor, error) {
+	//Need to pass dependencies through constructor
+	return &ProcessorImpl{
+		recognizer:    recognize.NewRecognizer(),
+		converter:     parse.NewConverter([]parse.Parser{parse.NewYamlOpenApiParser(), parse.NewJsonOpenApiParser()}),
+		contentLoader: load.NewContentLoader(),
+	}, nil
+}

internal/recognize/recognizer.go

@@ -0,0 +1,25 @@
+package recognize
+
+import (
+	"errors"
+	"github.com/rog-golang-buddies/internal/model"
+)
+
+//Recognizer provide functionality to recognize file type by content
+type Recognizer interface {
+	//RecognizeFileType recognizes type of the file by content. Probably we may combine it with validation
+	//Also not sure name is needed here. Better to recognize by content (check is file yaml, if yaml - check version;
+	//if json - check openApi version) But it is easier to use file extension as starting point to check content.
+	RecognizeFileType(resource *model.FileResource) (model.AsdFileType, error)
+}
+
+type RecognizerImpl struct {
+}
+
+func (r *RecognizerImpl) RecognizeFileType(resource *model.FileResource) (model.AsdFileType, error) {
+	return model.Undefined, errors.New("not implemented")
+}
+
+func NewRecognizer() Recognizer {
+	return &RecognizerImpl{}
+}