.github/workflows/golang-ci.yml

@@ -1,29 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [ "main" ]
-    paths:
-      - '**.go'
-  pull_request:
-    branches: [ "main" ]
-    paths:
-      - '**.go'
-jobs:
-  lint:
-    name: Lint
-    runs-on: ubuntu-latest
-    if: github.event_name == 'pull_request'
-    timeout-minutes: 3
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 1
-      - name: Setup Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: '1.24'
-      - name: Install golangci-lint
-        run: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
-      - name: Run golangci-lint
-        run: golangci-lint run ./...

.github/workflows/update-go-modules.yml

@@ -1,30 +0,0 @@
-name: Auto-Update Go Modules
-
-on:
-  schedule:
-    - cron: "0 0 * * 1" # Runs every Monday at midnight
-
-jobs:
-  update-go-modules:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v4
-
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: stable
-
-      - name: Update Dependencies
-        run: |
-          go get -u ./...
-          go mod tidy
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git add go.mod go.sum
-          git commit -m "chore: auto-update Go modules"
-          git push

.gitignore

@@ -9,7 +9,6 @@
 *.dll
 *.so
 *.dylib
-bin/
 
 # Test binary, built with `go test -c`
 *.test

.golangci.yml

@@ -1,54 +0,0 @@
-run:
-  # timeout for analysis, e.g. 30s, 3m, default is 1m
-  timeout: 3m
-  # exclude test files
-  tests: true
-
-linters:
-  # Set to true runs only fast linters.
-  # Good option for 'lint on save', pre-commit hook or CI.
-  fast: true
-
-  disable-all: true
-
-  enable:
-    - gosimple
-    - govet
-    - ineffassign
-    - staticcheck
-    - unused
-    - gofmt
-    - gofumpt
-    - misspell
-    - unparam
-    - gosec
-    - asciicheck
-    - errname
-    - gci
-    - godot
-    - goimports
-    - revive
-
-linters-settings:
-  gofmt:
-    rewrite-rules:
-      - pattern: 'interface{}'
-        replacement: 'any'
-      - pattern: 'a[b:len(a)]'
-        replacement: 'a[b:]'
-
-  misspell:
-    locale: UK
-
-  errcheck:
-    check-type-assertions: true
-
-issues:
-  max-same-issues: 0
-  max-issues-per-linter: 0
-  exclude-use-default: false
-  exclude:
-    # gosec: Duplicated errcheck checks
-    - G104
-    # gosec: integer overflow conversion int -> uint32
-    - G115

README.md

@@ -1,8 +1,3 @@
-![Windows](https://img.shields.io/badge/Windows-0078D6?style=for-the-badge&logo=windows&logoColor=white)
-![Linux](https://img.shields.io/badge/Linux-FCC624?style=for-the-badge&logo=linux&logoColor=black)
-![macOS](https://img.shields.io/badge/mac%20os-000000?style=for-the-badge&logo=macos&logoColor=F0F0F0)
-
-
 # Gignore - Generate .gitinore files
 
 ## Install

cmd/gen/gen.go

@@ -1,17 +1,16 @@
-// Package main generates gitignore.io templates using the gogi library.
 package main
 
 import (
 	"fmt"
+	"log"
 	"os"
 	"strings"
 
 	"github.com/cuonglm/gogi"
-	log "github.com/sirupsen/logrus"
 )
 
 func main() {
-	log.Info("Generating gitignore.io templates...")
+	fmt.Println("Generating gitignore.io templates...")
 
 	gogiClient, _ := gogi.NewHTTPClient()
 

cmd/gignore/main.go

@@ -1,5 +1,3 @@
-// Package main provides the entry point for the gignore command-line tool,
-// which generates .gitignore files based on specified templates.
 package main
 
 import (
@@ -52,9 +50,7 @@ func main() {
 	client := gignore.New(gignore.WithTemplateDirectory(templateDir))
 
 	if list {
-		if err := listTemplates(client); err != nil {
+		listTemplates(client)
-			log.Fatalf("failed to list templates: %v", err)
-		}
 		return
 	}
 
@@ -72,13 +68,12 @@ func main() {
 	fmt.Printf("√ created %s .gitignore file\n", args[0])
 }
 
-func listTemplates(client *gignore.Client) error {
+func listTemplates(client *gignore.GignoreClient) {
 	templates, err := client.List()
 	if err != nil {
-		return err
+		log.Fatalf("failed to list templates: %v", err)
 	}
 	for _, template := range templates {
 		fmt.Println(template)
 	}
-	return nil
 }

error.go

@@ -1,4 +1,3 @@
-// Package gignore provides functionality for handling template errors and registry operations.
 package gignore
 
 import (

gignore.go

@@ -3,54 +3,50 @@ package gignore
 import (
 	"io"
 
+	log "github.com/sirupsen/logrus"
+
 	"github.com/onyx-and-iris/gignore/internal/filewriter"
 	"github.com/onyx-and-iris/gignore/internal/registry"
-	log "github.com/sirupsen/logrus"
 )
 
 //go:generate go run cmd/gen/gen.go
 
-// Client is a client for managing .gitignore templates.
+type GignoreClient struct {
-type Client struct {
 	registry *registry.TemplateRegistry
 	writer   io.Writer
 }
 
-// New creates a new Client with the provided options.
+func New(options ...Option) *GignoreClient {
-func New(options ...Option) *Client {
+	gc := &GignoreClient{
-	c := &Client{
+		registry.NewTemplateRegistry(),
-		registry.New(),
+		filewriter.New()}
-		filewriter.New(),
-	}
 
 	for _, option := range options {
-		option(c)
+		option(gc)
 	}
 
-	return c
+	return gc
 }
 
-// List returns a list of available .gitignore templates.
+func (g *GignoreClient) List() ([]string, error) {
-func (c *Client) List() ([]string, error) {
+	return g.registry.ListTemplates()
-	return c.registry.ListTemplates()
 }
 
-// Create generates a .gitignore file from the specified template.
+func (g *GignoreClient) Create(template string) error {
-func (c *Client) Create(template string) error {
+	ok, err := g.registry.Contains(template)
-	ok, err := c.registry.Contains(template)
 	if err != nil {
 		return err
 	}
 	if !ok {
-		templateNotFoundErr := &templateNotFoundError{template, c.registry}
+		templateNotFoundErr := &templateNotFoundError{template, g.registry}
-		if c.registry.Directory == "gitignoreio" {
+		if g.registry.Directory == "gitignoreio" {
 			return templateNotFoundErr
 		}
 
 		log.Errorf("%s. Checking default registry...", templateNotFoundErr)
 
-		c.registry.Directory = "gitignoreio"
+		g.registry.Directory = "gitignoreio"
-		ok, err = c.registry.Contains(template)
+		ok, err = g.registry.Contains(template)
 		if err != nil {
 			return err
 		}
@@ -60,12 +56,12 @@ func (c *Client) Create(template string) error {
 		log.Infof("template '%s' found in default gitignoreio registry", template)
 	}
 
-	content, err := c.registry.GetTemplate(template)
+	content, err := g.registry.GetTemplate(template)
 	if err != nil {
 		return err
 	}
 
-	_, err = c.writer.Write(content)
+	_, err = g.writer.Write(content)
 	if err != nil {
 		return err
 	}

internal/filewriter/filewriter.go

@@ -1,4 +1,3 @@
-// Package filewriter provides functionality to write content to a .gitignore file.
 package filewriter
 
 import (
@@ -7,14 +6,11 @@ import (
 	"os"
 )
 
-// FileWriter provides functionality to write content to a .gitignore file.
 type FileWriter struct {
-	targetFileName string
 }
 
-// New creates a new FileWriter with the default target file name.
 func New() *FileWriter {
-	return &FileWriter{".gitignore"}
+	return &FileWriter{}
 }
 
 func (fw *FileWriter) writeContent(content []byte, dst io.Writer) (int64, error) {
@@ -29,7 +25,7 @@ func (fw *FileWriter) writeContent(content []byte, dst io.Writer) (int64, error)
 }
 
 func (fw *FileWriter) Write(content []byte) (int, error) {
-	f, err := os.Create(fw.targetFileName)
+	f, err := os.Create(".gitignore")
 	if err != nil {
 		return 0, err
 	}

internal/registry/registry.go

@@ -1,4 +1,3 @@
-// Package registry provides functionality to manage and retrieve gitignore templates.
 package registry
 
 import (
@@ -11,14 +10,12 @@ import (
 //go:embed templates
 var templates embed.FS
 
-// TemplateRegistry provides methods to manage and retrieve gitignore templates.
 type TemplateRegistry struct {
 	templates fs.FS
 	Directory string
 }
 
-// New creates a new instance of TemplateRegistry.
+func NewTemplateRegistry() *TemplateRegistry {
-func New() *TemplateRegistry {
 	return &TemplateRegistry{
 		templates: templates,
 	}
@@ -28,7 +25,6 @@ func (t *TemplateRegistry) filePath(name string) string {
 	return fmt.Sprintf("templates/%s/%s.gitignore", t.Directory, name)
 }
 
-// Contains checks if a template with the given name exists in the registry.
 func (t *TemplateRegistry) Contains(name string) (bool, error) {
 	_, err := fs.Stat(t.templates, t.filePath(name))
 	if err != nil {
@@ -41,7 +37,6 @@ func (t *TemplateRegistry) Contains(name string) (bool, error) {
 	return true, nil
 }
 
-// GetTemplate retrieves the content of the gitignore template with the given name.
 func (t *TemplateRegistry) GetTemplate(name string) ([]byte, error) {
 	data, err := fs.ReadFile(t.templates, t.filePath(name))
 	if err != nil {
@@ -50,7 +45,6 @@ func (t *TemplateRegistry) GetTemplate(name string) ([]byte, error) {
 	return data, nil
 }
 
-// ListTemplates lists all the gitignore templates in the registry.
 func (t *TemplateRegistry) ListTemplates() ([]string, error) {
 	var paths []string
 

option.go

@@ -1,11 +1,9 @@
 package gignore
 
-// Option is a function that configures a GignoreClient.
+type Option func(*GignoreClient)
-type Option func(*Client)
 
-// WithTemplateDirectory sets the template directory for the GignoreClient.
 func WithTemplateDirectory(directory string) Option {
-	return func(c *Client) {
+	return func(g *GignoreClient) {
-		c.registry.Directory = directory
+		g.registry.Directory = directory
 	}
 }