diff --git a/cli/cmd/config.go b/cli/cmd/config.go index 88e9587..138294d 100644 --- a/cli/cmd/config.go +++ b/cli/cmd/config.go @@ -4,16 +4,17 @@ import ( "context" "database/sql" "fmt" - mssql "github.com/denisenkom/go-mssqldb" - "github.com/denisenkom/go-mssqldb/azuread" - "golang.org/x/net/proxy" "io/ioutil" "os" "path" "strings" - _ "github.com/denisenkom/go-mssqldb/azuread" - "github.com/denisenkom/go-mssqldb/msdsn" + mssql "github.com/microsoft/go-mssqldb" + "github.com/microsoft/go-mssqldb/azuread" + "golang.org/x/net/proxy" + + _ "github.com/microsoft/go-mssqldb/azuread" + "github.com/microsoft/go-mssqldb/msdsn" "github.com/pkg/errors" "github.com/sirupsen/logrus" "gopkg.in/yaml.v3" diff --git a/cli/cmd/find.go b/cli/cmd/find.go new file mode 100644 index 0000000..3afb49c --- /dev/null +++ b/cli/cmd/find.go @@ -0,0 +1,80 @@ +package cmd + +import ( + "errors" + "io/fs" + "os" + "path/filepath" + "strings" + + "github.com/spf13/cobra" +) + +type node struct { + symbol string + fileName string + lineToString map[int]string + declaration bool + parent *node + children []*node +} + +func parseSql(content string, nodes []*node) error { + return nil +} + +var ( + findCmd = &cobra.Command{ + Use: "find", + Short: "TODO", + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) != 0 && len(args) != 1 { + _ = cmd.Help() + return errors.New("Too many arguments") + } + + dir, err := os.Getwd() + if err != nil { + return err + } + + if len(args) != 0 { + dir = args[1] + } + + nodes := []*node{} + + // Walk the directory recursively + err = filepath.Walk(dir, func(path string, info fs.FileInfo, err error) error { + if err != nil { + return err + } + // Check if it's a regular file and ends with .sql + if !info.IsDir() && strings.HasSuffix(info.Name(), ".sql") { + contentBytes, err := os.ReadFile(path) + if err != nil { + return err + } + content := string(contentBytes) + if strings.Contains(content, "[code]") { + err := parseSql(content, nodes) + if err != nil { + return err // TODO: multiple errors + } + } + } + return nil + }) + + if err != nil { + return err + } + + return nil + }, + } +) + +func init() { + rootCmd.AddCommand(findCmd) +} diff --git a/cli/cmd/sqlfs.go b/cli/cmd/sqlfs.go new file mode 100644 index 0000000..bab8812 --- /dev/null +++ b/cli/cmd/sqlfs.go @@ -0,0 +1,114 @@ +package cmd + +import ( + "errors" + "fmt" + "go/ast" + "io/fs" + "os" + + "github.com/spf13/cobra" + "github.com/vippsas/sqlcode" + "github.com/vippsas/sqlcode/go/mapfs" + "github.com/vippsas/sqlcode/go/parser" + "golang.org/x/tools/go/packages" +) + +// TODO: Handle include tags + +var ( + sqlFsCmd = &cobra.Command{ + Use: "sqlfs", + Short: "TODO", + RunE: func(cmd *cobra.Command, args []string) error { + if len(args) != 0 && len(args) != 1 { + _ = cmd.Help() + return errors.New("Too many arguments") + } + + dir, err := os.Getwd() + if err != nil { + return err + } + + if len(args) != 0 { + dir = args[1] + } + + deployables := func( + dir string, + finder func([]*packages.Package) map[ast.Node][]parser.EmbeddedFsInfo, + ) map[ast.Node][]parser.EmbeddedFsInfo { + pkgs, err := parser.GetPackages(dir) + if err != nil { + fmt.Printf("Error loading package: %v\n", err) + return nil + } + return finder(pkgs) + }(dir, parser.NewWalker().FindDeployablesAndFileSystems) + + for deployable, fss := range deployables { + embeddedFiles := mapfs.MapFS{} + + fmt.Printf("deployable %d %v\n", deployable) + for j, fs := range fss { + fmt.Printf("fileSystem %d\n", j) + fmt.Printf("%s\n", fs.Package) + fmt.Printf("%s\n", fs.Object) + efs, err := parser.GetEmbbededFiles(fs.Object.Pkg().Path()) + if err != nil { + continue + } + fmt.Printf("%v\n", efs) + fmt.Printf("\n") + for _, ef := range efs { + embeddedFiles.Add(ef) + } + } + VerifyEmbeddedFiles(embeddedFiles) + } + + return nil + }, + } +) + +func VerifyEmbeddedFiles(files fs.FS) { + // TODO(dsf): tags + d, err := sqlcode.Include( + sqlcode.Options{ + IncludeTags: tags, + PartialParseResults: true, + }, + files, + ) + if err != nil { + fmt.Println("Error during parsing: " + err.Error()) + fmt.Println("Treat results below with caution.") + fmt.Println() + err = nil + } + if len(d.CodeBase.Creates) == 0 && len(d.CodeBase.Declares) == 0 { + fmt.Println("No SQL code found in given paths") + } + if len(d.CodeBase.Errors) > 0 { + fmt.Println("Errors:") + for _, e := range d.CodeBase.Errors { + fmt.Printf("%s:%d:%d: %s\n", e.Pos.File, e.Pos.Line, e.Pos.Line, e.Message) + } + } + for _, c := range d.CodeBase.Creates { + fmt.Println(c.QuotedName.String() + ":") + if len(c.DependsOn) > 0 { + fmt.Println(" Uses:") + for _, u := range c.DependsOn { + fmt.Println(" " + u.String()) + } + } + fmt.Println() + } +} + +func init() { + rootCmd.AddCommand(sqlFsCmd) +} diff --git a/deployable.go b/deployable.go index 0969568..e2bbea2 100644 --- a/deployable.go +++ b/deployable.go @@ -4,12 +4,13 @@ import ( "context" "database/sql" "fmt" - mssql "github.com/denisenkom/go-mssqldb" - "github.com/pkg/errors" - "github.com/vippsas/sqlcode/sqlparser" "io/fs" "strconv" "strings" + + mssql "github.com/microsoft/go-mssqldb" + "github.com/pkg/errors" + "github.com/vippsas/sqlcode/sqlparser" ) type Deployable struct { diff --git a/error.go b/error.go index 6131fbf..0eff39c 100644 --- a/error.go +++ b/error.go @@ -3,9 +3,10 @@ package sqlcode import ( "bytes" "fmt" - mssql "github.com/denisenkom/go-mssqldb" - "github.com/vippsas/sqlcode/sqlparser" "strings" + + mssql "github.com/microsoft/go-mssqldb" + "github.com/vippsas/sqlcode/sqlparser" ) type SQLUserError struct { diff --git a/go.mod b/go.mod index fbaa135..642ab13 100644 --- a/go.mod +++ b/go.mod @@ -4,29 +4,36 @@ go 1.18 require ( github.com/alecthomas/repr v0.4.0 - github.com/denisenkom/go-mssqldb v0.12.3 github.com/gofrs/uuid v4.4.0+incompatible + github.com/microsoft/go-mssqldb v1.8.0 github.com/pkg/errors v0.9.1 github.com/sirupsen/logrus v1.9.3 github.com/smasher164/xid v0.1.2 github.com/spf13/cobra v1.8.1 github.com/stretchr/testify v1.10.0 golang.org/x/net v0.34.0 + golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d gopkg.in/yaml.v3 v3.0.1 ) require ( - github.com/Azure/azure-sdk-for-go/sdk/azcore v0.19.0 // indirect - github.com/Azure/azure-sdk-for-go/sdk/azidentity v0.11.0 // indirect - github.com/Azure/azure-sdk-for-go/sdk/internal v0.7.0 // indirect + github.com/Azure/azure-sdk-for-go/sdk/azcore v1.11.1 // indirect + github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.6.0 // indirect + github.com/Azure/azure-sdk-for-go/sdk/internal v1.8.0 // indirect + github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2 // indirect github.com/davecgh/go-spew v1.1.1 // indirect - github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe // indirect + github.com/golang-jwt/jwt/v5 v5.2.1 // indirect + github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 // indirect github.com/golang-sql/sqlexp v0.1.0 // indirect + github.com/google/uuid v1.6.0 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect + github.com/kylelemons/godebug v1.1.0 // indirect github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect github.com/pmezard/go-difflib v1.0.0 // indirect github.com/spf13/pflag v1.0.5 // indirect golang.org/x/crypto v0.32.0 // indirect + golang.org/x/mod v0.17.0 // indirect + golang.org/x/sync v0.10.0 // indirect golang.org/x/sys v0.29.0 // indirect golang.org/x/text v0.21.0 // indirect ) diff --git a/go.sum b/go.sum index 5ab0652..5ec2150 100644 --- a/go.sum +++ b/go.sum @@ -1,34 +1,44 @@ -github.com/Azure/azure-sdk-for-go/sdk/azcore v0.19.0 h1:lhSJz9RMbJcTgxifR1hUNJnn6CNYtbgEDtQV22/9RBA= -github.com/Azure/azure-sdk-for-go/sdk/azcore v0.19.0/go.mod h1:h6H6c8enJmmocHUbLiiGY6sx7f9i+X3m1CHdd5c6Rdw= -github.com/Azure/azure-sdk-for-go/sdk/azidentity v0.11.0 h1:OYa9vmRX2XC5GXRAzeggG12sF/z5D9Ahtdm9EJ00WN4= -github.com/Azure/azure-sdk-for-go/sdk/azidentity v0.11.0/go.mod h1:HcM1YX14R7CJcghJGOYCgdezslRSVzqwLf/q+4Y2r/0= -github.com/Azure/azure-sdk-for-go/sdk/internal v0.7.0 h1:v9p9TfTbf7AwNb5NYQt7hI41IfPoLFiFkLtb+bmGjT0= -github.com/Azure/azure-sdk-for-go/sdk/internal v0.7.0/go.mod h1:yqy467j36fJxcRV2TzfVZ1pCb5vxm4BtZPUdYWe/Xo8= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.11.1 h1:E+OJmp2tPvt1W+amx48v1eqbjDYsgN+RzP4q16yV5eM= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.11.1/go.mod h1:a6xsAQUZg+VsS3TJ05SRp524Hs4pZ/AeFSr5ENf0Yjo= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.6.0 h1:U2rTu3Ef+7w9FHKIAXM6ZyqF3UOWJZ12zIm8zECAFfg= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.6.0/go.mod h1:9kIvujWAA58nmPmWB1m23fyWic1kYZMxD9CxaWn4Qpg= +github.com/Azure/azure-sdk-for-go/sdk/internal v1.8.0 h1:jBQA3cKT4L2rWMpgE7Yt3Hwh2aUj8KXjIGLxjHeYNNo= +github.com/Azure/azure-sdk-for-go/sdk/internal v1.8.0/go.mod h1:4OG6tQ9EOP/MT0NMjDlRzWoVFxfu9rN9B2X+tlSVktg= +github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azkeys v1.0.1 h1:MyVTgWR8qd/Jw1Le0NZebGBUCLbtak3bJ3z1OlqZBpw= +github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/internal v1.0.0 h1:D3occbWoio4EBLkbkevetNMAVX197GkzbUMtqjGWn80= +github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2 h1:XHOnouVk1mxXfQidrMEnLlPk9UMeRtyBTnEFtxkV0kU= +github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI= github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc= github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4= github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/denisenkom/go-mssqldb v0.12.3 h1:pBSGx9Tq67pBOTLmxNuirNTeB8Vjmf886Kx+8Y+8shw= -github.com/denisenkom/go-mssqldb v0.12.3/go.mod h1:k0mtMFOnU+AihqFxPMiF05rtiDrorD1Vrm1KEz5hxDo= -github.com/dnaeon/go-vcr v1.2.0/go.mod h1:R4UdLID7HZT3taECzJs4YgbbH6PIGXB6W/sc5OLb6RQ= github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA= github.com/gofrs/uuid v4.4.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= -github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe h1:lXe2qZdvpiX5WZkZR4hgp4KJVfY3nMkvmwbVkpv1rVY= -github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0= +github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk= +github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk= +github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 h1:au07oEsX2xN0ktxqI+Sida1w446QrXBRJ0nee3SNZlA= +github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0= github.com/golang-sql/sqlexp v0.1.0 h1:ZCD6MBpcuOVfGVqsEmY5/4FtYiKz6tSyUv9LPEDei6A= github.com/golang-sql/sqlexp v0.1.0/go.mod h1:J4ad9Vo8ZCWQ2GMrC4UCQy1JpCbwU9m3EOqtpKwwwHI= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= -github.com/modocache/gover v0.0.0-20171022184752-b58185e213c5/go.mod h1:caMODM3PzxT8aQXRPkAt8xlV/e7d7w8GM5g0fa5F0D8= -github.com/pkg/browser v0.0.0-20180916011732-0a3d74bf9ce4/go.mod h1:4OwLy04Bl9Ef3GJJCoec+30X3LQs/0/m4HFRt/2LUSA= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/microsoft/go-mssqldb v1.8.0 h1:7cyZ/AT7ycDsEoWPIXibd+aVKFtteUNhDGf3aobP+tw= +github.com/microsoft/go-mssqldb v1.8.0/go.mod h1:6znkekS3T2vp0waiMhen4GPU1BiAsrP+iXHcE7a7rFo= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= @@ -42,37 +52,26 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc= golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc= -golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20210610132358-84b48f89b13b/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA= +golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0= golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ= +golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU= golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d h1:vU5i/LfpvrRCpgM/VPfJLg5KjxD3E+hfT1SH+d9zLwg= +golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/go/mapfs/mapfs.go b/go/mapfs/mapfs.go new file mode 100644 index 0000000..4b66f76 --- /dev/null +++ b/go/mapfs/mapfs.go @@ -0,0 +1,95 @@ +package mapfs + +import ( + "fmt" + "io" + "io/fs" + "os" + "path/filepath" + "time" +) + +type MapFS map[string]string + +var _ fs.FS = (*MapFS)(nil) + +func (m MapFS) Open(filename string) (fs.File, error) { + if filename == "." { + var entries []fs.DirEntry + for base, fullpath := range m { + info, err := os.Stat(fullpath) + if err != nil { + continue + } + entries = append(entries, fileDirEntry{name: base, info: info}) + } + return &virtualDir{ + entries: entries, + pos: 0, + }, nil + } + + if _, ok := m[filename]; !ok { + return nil, fmt.Errorf("%w: %s", fs.ErrNotExist, filename) + } + return os.Open(m[filename]) +} + +func (m MapFS) Add(path string) { + filename := filepath.Base(path) + m[filename] = path +} + +// virtualDir implements fs.File + ReadDirFile +type virtualDir struct { + entries []fs.DirEntry + pos int +} + +func (d *virtualDir) Stat() (fs.FileInfo, error) { + return dirInfo{name: ".", mode: fs.ModeDir}, nil +} + +func (d *virtualDir) Read([]byte) (int, error) { + return 0, io.EOF // directories have no data +} + +func (d *virtualDir) Close() error { + return nil +} + +func (d *virtualDir) ReadDir(n int) ([]fs.DirEntry, error) { + if d.pos >= len(d.entries) { + return nil, io.EOF + } + if n <= 0 || d.pos+n > len(d.entries) { + n = len(d.entries) - d.pos + } + entries := d.entries[d.pos : d.pos+n] + d.pos += n + return entries, nil +} + +// fileDirEntry implements fs.DirEntry +type fileDirEntry struct { + name string + info os.FileInfo +} + +func (e fileDirEntry) Name() string { return e.name } +func (e fileDirEntry) IsDir() bool { return e.info.IsDir() } +func (e fileDirEntry) Type() fs.FileMode { return e.info.Mode().Type() } +func (e fileDirEntry) Info() (fs.FileInfo, error) { return e.info, nil } + +// dirInfo is a simple FileInfo for the root dir +type dirInfo struct { + name string + mode fs.FileMode +} + +func (d dirInfo) Name() string { return d.name } +func (d dirInfo) Size() int64 { return 0 } +func (d dirInfo) Mode() fs.FileMode { return d.mode } +func (d dirInfo) ModTime() time.Time { return time.Time{} } +func (d dirInfo) IsDir() bool { return d.mode.IsDir() } +func (d dirInfo) Sys() interface{} { return nil } diff --git a/go/parser/utils.go b/go/parser/utils.go new file mode 100644 index 0000000..922b9fa --- /dev/null +++ b/go/parser/utils.go @@ -0,0 +1,146 @@ +package parser + +import ( + "errors" + "fmt" + "go/ast" + "go/types" + "strings" + + "golang.org/x/tools/go/packages" +) + +type EmbeddedFsInfo struct { + Package *packages.Package + Object types.Object +} + +// type FinderFunc func([]*packages.Package) [][]EmbeddedFsInfo +type FinderFunc func([]*packages.Package) map[ast.Node][]EmbeddedFsInfo + +func GetEmbbededFiles(pkgPath string) ([]string, error) { + cfg := &packages.Config{ + Mode: packages.LoadAllSyntax | packages.NeedEmbedFiles, + } + + pkgs, err := packages.Load(cfg, pkgPath) + if err != nil { + return nil, err + } + + println("here") + if len(pkgs) != 1 { + return nil, fmt.Errorf("expected one package, %d found", len(pkgs)) + } + pkg := pkgs[0] + fmt.Printf("%#v\n", pkg.Name) + + return pkg.EmbedFiles, nil +} + +/* +func GetPositionInPackage(obj types.Object) error { + fset := pkg.Fset + declPos := fset.Position(obj.Pos()) + fmt.Println("Declared at", declPos) + + // Now, to find the AST node at that position: + found := false + for _, file := range pkg.Syntax { + if fset.Position(file.Pos()).Filename != declPos.Filename { + continue + } + + ast.Inspect(file, func(n ast.Node) bool { + if n == nil { + return false + } + if n.Pos() == obj.Pos() { + fmt.Printf("Found declaration AST node: %T\n", n) + found = true + return false + } + return true + }) + } + + if !found { + fmt.Println("Declaration AST node not found — maybe external package?") + } + return nil +} +*/ + +func GetPackages(dir string) ([]*packages.Package, error) { + cfg := &packages.Config{ + Mode: packages.LoadAllSyntax | packages.NeedEmbedFiles, + Dir: dir, + } + pkgs, err := packages.Load(cfg, "./...") + if err != nil { + return nil, err + } + return pkgs, nil +} + +var UnhandledCallType = errors.New("unhandled call type") + +func IsIncludeFunc(call *ast.CallExpr) (bool, error) { + var funcName string + switch fun := call.Fun.(type) { + case *ast.Ident: + funcName = fun.Name + case *ast.SelectorExpr: + funcName = fmt.Sprintf("%s.%s", exprToString(fun.X), fun.Sel.Name) + default: + return false, UnhandledCallType + } + if !strings.Contains(funcName, "MustInclude") && !strings.Contains(funcName, "Include") { + return false, nil + } + return true, nil +} + +func GetEmbeddedFS(pkg *packages.Package, call *ast.CallExpr) []EmbeddedFsInfo { + embeddedFS := []EmbeddedFsInfo{} + for _, arg := range call.Args { + // Get type and object info + tv := pkg.TypesInfo.Types[arg] + obj := pkg.TypesInfo.Uses[identOf(arg)] + if tv.Type.String() != "embed.FS" { + continue + } + + if obj != nil { + embeddedFS = append(embeddedFS, EmbeddedFsInfo{ + Package: pkg, + Object: obj, + }) + } + } + return embeddedFS +} + +func exprToString(expr ast.Expr) string { + switch e := expr.(type) { + case *ast.Ident: + return e.Name + case *ast.BasicLit: + return e.Value + case *ast.SelectorExpr: + return fmt.Sprintf("%s.%s", exprToString(e.X), e.Sel.Name) + default: + return fmt.Sprintf("%T", expr) + } +} + +func identOf(expr ast.Expr) *ast.Ident { + switch e := expr.(type) { + case *ast.Ident: + return e + case *ast.SelectorExpr: + return e.Sel + default: + return nil + } +} diff --git a/go/parser/walk.go b/go/parser/walk.go new file mode 100644 index 0000000..34bf3dd --- /dev/null +++ b/go/parser/walk.go @@ -0,0 +1,95 @@ +package parser + +import ( + "fmt" + "go/ast" + + "golang.org/x/tools/go/packages" +) + +type walker struct{} + +func NewWalker() *walker { + return &walker{} +} + +func (v *walker) FindDeployablesAndFileSystems(pkgs []*packages.Package) map[ast.Node][]EmbeddedFsInfo { + deployables := make(map[ast.Node][]EmbeddedFsInfo) + for _, pkg := range pkgs { + for _, file := range pkg.Syntax { + visitor := &CallVisitor{ + pkg: pkg, + parentMap: make(map[ast.Node]ast.Node), + embeddedFSs: deployables, + } + ast.Walk(visitor, file) + } + } + return deployables +} + +type CallVisitor struct { + pkg *packages.Package + parentMap map[ast.Node]ast.Node + parent ast.Node + embeddedFSs map[ast.Node][]EmbeddedFsInfo +} + +func (v *CallVisitor) Visit(n ast.Node) ast.Visitor { + verbose := false + if n == nil { + return nil // End of this branch + } + + if v.parent != nil { + v.parentMap[n] = v.parent + } + + if verbose { + fmt.Printf("Visiting node %v at %v\n", n, v.pkg.Fset.Position(n.Pos())) + } + + if call, ok := n.(*ast.CallExpr); ok { + if verbose { + fmt.Printf("Visiting call %v\n", call) + } + if isIncludeFunc, err := IsIncludeFunc(call); err == nil && isIncludeFunc { + if verbose { + fmt.Printf("Is Include\n") + } + parent := v.parentMap[call] + v.embeddedFSs[parent] = GetEmbeddedFS(v.pkg, call) + } + } + + next := &CallVisitor{ + pkg: v.pkg, + parentMap: v.parentMap, + parent: n, + embeddedFSs: v.embeddedFSs, + } + + return next +} + +func (v *CallVisitor) GetParentOfCall(call *ast.CallExpr) { + fmt.Printf("Call to: %s at %v\n", exprToString(call.Fun), call.Pos()) + + parent := v.parentMap[call] + switch p := parent.(type) { + case *ast.AssignStmt: + fmt.Printf(" Assigned in assignment to: ") + for _, lhs := range p.Lhs { + fmt.Printf("%s ", exprToString(lhs)) + } + fmt.Println() + case *ast.ValueSpec: + fmt.Printf(" Assigned in var declaration to: ") + for _, name := range p.Names { + fmt.Printf("%s ", name.Name) + } + fmt.Println() + default: + fmt.Println(" Return value not assigned (used directly or discarded)") + } +} diff --git a/go/parser/walk_test.go b/go/parser/walk_test.go new file mode 100644 index 0000000..638b7f8 --- /dev/null +++ b/go/parser/walk_test.go @@ -0,0 +1,41 @@ +package parser + +import ( + "fmt" + "go/ast" + "go/parser" + "go/token" + "log" + "testing" +) + +func TestWalker(t *testing.T) { + src := ` +package main +func main() { + x := foo() + bar(foo()) +} +func foo() int { return 42 } +func bar(int) {} +` + fset := token.NewFileSet() + file, err := parser.ParseFile(fset, "example.go", src, 0) + if err != nil { + log.Fatal(err) + } + + visitor := &CallVisitor{ + parentMap: make(map[ast.Node]ast.Node), + } + ast.Walk(visitor, file) + + ast.Inspect(file, func(n ast.Node) bool { + if call, ok := n.(*ast.CallExpr); ok { + fmt.Printf("Call: %T at %v\n", call.Fun, fset.Position(call.Pos())) + parent := visitor.parentMap[call] + fmt.Printf(" Parent: %T\n", parent) + } + return true + }) +} diff --git a/sqltest/fixture.go b/sqltest/fixture.go index 0059908..b73ce7a 100644 --- a/sqltest/fixture.go +++ b/sqltest/fixture.go @@ -4,13 +4,14 @@ import ( "context" "database/sql" "fmt" - mssql "github.com/denisenkom/go-mssqldb" - "github.com/denisenkom/go-mssqldb/msdsn" - "github.com/gofrs/uuid" "io/ioutil" "os" "strings" "time" + + "github.com/gofrs/uuid" + mssql "github.com/microsoft/go-mssqldb" + "github.com/microsoft/go-mssqldb/msdsn" ) type StdoutLogger struct { @@ -68,7 +69,7 @@ func NewFixture() *Fixture { panic(err) } - pdsn, _, err := msdsn.Parse(dsn) + pdsn, err := msdsn.Parse(dsn) if err != nil { panic(err) }