Go言語でのpkgディレクトリ活用法：ロギングとユーティリティ関数の設計と配置

myproject/
├── cmd/
├── pkg/
│   ├── logging/
│   │   ├── logging.go
│   │   └── config.go

package logging

import (
    "os"

    "github.com/sirupsen/logrus"
)

var logger *logrus.Logger

// InitLogger initializes the logger with default settings
func InitLogger(logLevel string) {
    logger = logrus.New()

    // Set output to stdout
    logger.Out = os.Stdout

    // Parse log level
    level, err := logrus.ParseLevel(logLevel)
    if err != nil {
        level = logrus.InfoLevel
    }
    logger.SetLevel(level)

    // Set log format
    logger.SetFormatter(&logrus.JSONFormatter{})
}

// GetLogger provides the global logger instance
func GetLogger() *logrus.Logger {
    return logger
}

package logging

import (
    "log"
    "os"
)

// GetLogLevel retrieves the log level from environment variables
func GetLogLevel() string {
    level := os.Getenv("LOG_LEVEL")
    if level == "" {
        log.Println("LOG_LEVEL not set, defaulting to INFO")
        return "info"
    }
    return level
}

package main

import (
    "myproject/pkg/logging"
)

func main() {
    // Initialize the logger
    logging.InitLogger(logging.GetLogLevel())

    // Use the logger
    logger := logging.GetLogger()
    logger.Info("Application started")
    logger.Warn("This is a warning")
    logger.Error("An error occurred")
}

myproject/
├── pkg/
│   ├── utils/
│   │   ├── string_utils.go
│   │   ├── math_utils.go
│   │   └── file_utils.go

package utils

import "strings"

// ToCamelCase converts a string to camel case
func ToCamelCase(input string) string {
    words := strings.Fields(input)
    for i, word := range words {
        words[i] = strings.Title(word)
    }
    return strings.Join(words, "")
}

// ReverseString reverses a given string
func ReverseString(input string) string {
    runes := []rune(input)
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }
    return string(runes)
}

package utils

// Max returns the maximum of two integers
func Max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

// Factorial calculates the factorial of a given number
func Factorial(n int) int {
    if n == 0 {
        return 1
    }
    return n * Factorial(n-1)
}

package utils

import (
    "io/ioutil"
    "os"
)

// ReadFile reads the contents of a file
func ReadFile(filepath string) (string, error) {
    data, err := ioutil.ReadFile(filepath)
    if err != nil {
        return "", err
    }
    return string(data), nil
}

// FileExists checks if a file exists
func FileExists(filepath string) bool {
    _, err := os.Stat(filepath)
    return !os.IsNotExist(err)
}

package main

import (
    "fmt"
    "myproject/pkg/utils"
)

func main() {
    // String utilities
    fmt.Println(utils.ToCamelCase("hello world"))
    fmt.Println(utils.ReverseString("golang"))

    // Math utilities
    fmt.Println(utils.Max(10, 20))
    fmt.Println(utils.Factorial(5))

    // File utilities
    if utils.FileExists("example.txt") {
        content, _ := utils.ReadFile("example.txt")
        fmt.Println(content)
    }
}

package logging_test

import (
    "bytes"
    "myproject/pkg/logging"
    "testing"

    "github.com/sirupsen/logrus"
    "github.com/stretchr/testify/assert"
)

func TestLoggingOutput(t *testing.T) {
    var buf bytes.Buffer

    // カスタムログ出力先を設定
    logging.InitLogger("info")
    logger := logging.GetLogger()
    logger.Out = &buf

    // ログを出力
    logger.Info("Test log message")

    // 出力確認
    output := buf.String()
    assert.Contains(t, output, "Test log message")
    assert.Contains(t, output, "info")
}

package logging_test

import (
    "os"
    "myproject/pkg/logging"
    "testing"

    "github.com/stretchr/testify/assert"
)

func TestGetLogLevel(t *testing.T) {
    os.Setenv("LOG_LEVEL", "debug")
    defer os.Unsetenv("LOG_LEVEL")

    level := logging.GetLogLevel()
    assert.Equal(t, "debug", level)
}

package utils_test

import (
    "myproject/pkg/utils"
    "testing"

    "github.com/stretchr/testify/assert"
)

func TestToCamelCase(t *testing.T) {
    result := utils.ToCamelCase("hello world")
    assert.Equal(t, "HelloWorld", result)
}

func TestReverseString(t *testing.T) {
    result := utils.ReverseString("golang")
    assert.Equal(t, "gnalog", result)
}

package utils_test

import (
    "myproject/pkg/utils"
    "testing"

    "github.com/stretchr/testify/assert"
)

func TestMax(t *testing.T) {
    assert.Equal(t, 10, utils.Max(5, 10))
    assert.Equal(t, -1, utils.Max(-1, -10))
}

func TestFactorial(t *testing.T) {
    assert.Equal(t, 120, utils.Factorial(5))
    assert.Equal(t, 1, utils.Factorial(0))
}

package utils_test

import (
    "io/ioutil"
    "myproject/pkg/utils"
    "os"
    "testing"

    "github.com/stretchr/testify/assert"
)

func TestFileExists(t *testing.T) {
    tempFile, _ := ioutil.TempFile("", "testfile")
    defer os.Remove(tempFile.Name())

    assert.True(t, utils.FileExists(tempFile.Name()))
    assert.False(t, utils.FileExists("nonexistent.txt"))
}

task-manager/
├── cmd/
│   └── main.go
├── pkg/
│   ├── logging/
│   │   ├── logging.go
│   │   └── config.go
│   ├── utils/
│   │   ├── string_utils.go
│   │   └── time_utils.go

package main

import (
    "myproject/pkg/logging"
)

func main() {
    // Loggerの初期化
    logging.InitLogger(logging.GetLogLevel())
    logger := logging.GetLogger()

    // タスクの作成
    taskName := "Learn Go"
    logger.Info("Task created: ", taskName)

    // タスクの処理
    logger.Info("Processing task: ", taskName)
}

package main

import (
    "fmt"
    "myproject/pkg/utils"
)

func main() {
    taskName := "learn go programming"
    standardizedName := utils.ToCamelCase(taskName)
    fmt.Println("Standardized Task Name:", standardizedName)
}

package utils

import (
    "time"
)

// FormatDeadline formats a deadline as a human-readable string
func FormatDeadline(deadline time.Time) string {
    return deadline.Format("2006-01-02 15:04:05")
}

package main

import (
    "fmt"
    "myproject/pkg/utils"
    "time"
)

func main() {
    deadline := time.Now().Add(24 * time.Hour)
    fmt.Println("Task Deadline:", utils.FormatDeadline(deadline))
}

package main

import (
    "fmt"
    "myproject/pkg/logging"
    "myproject/pkg/utils"
    "time"
)

func main() {
    // ログの初期化
    logging.InitLogger("info")
    logger := logging.GetLogger()

    // タスクの作成
    taskName := "Complete documentation"
    logger.Info("Task created: ", taskName)

    // タスク名をCamelCaseに変換
    formattedName := utils.ToCamelCase(taskName)
    logger.Info("Formatted Task Name: ", formattedName)

    // 締め切りの計算
    deadline := time.Now().Add(48 * time.Hour)
    formattedDeadline := utils.FormatDeadline(deadline)
    logger.Info("Task Deadline: ", formattedDeadline)

    // タスク情報の表示
    fmt.Printf("Task: %s, Deadline: %s\n", formattedName, formattedDeadline)
}

// CalculateDiscount applies a discount to the given price
// based on the provided discount percentage.
func CalculateDiscount(price, discountPercent float64) float64 {
    return price * (1 - discountPercent/100)
}

gofmt -w your_file.go

file, err := os.Open("example.txt")
if err != nil {
    logger.Error("Failed to open file: ", err)
    return
}
defer file.Close()

package task

import (
    "fmt"
    "myproject/pkg/logging"
    "time"
)

// Task represents a task with a name and deadline
type Task struct {
    Name     string
    Deadline time.Time
}

// NewTask creates a new task with a given name and deadline
func NewTask(name string, deadline time.Time) *Task {
    return &Task{Name: name, Deadline: deadline}
}

// PrintDetails prints the task details to the logger
func (t *Task) PrintDetails() {
    logger := logging.GetLogger()
    logger.Info("Task Name: ", t.Name)
    logger.Info("Task Deadline: ", t.Deadline.Format("2006-01-02 15:04:05"))
    fmt.Printf("Task '%s' is due by %s\n", t.Name, t.Deadline.Format("2006-01-02 15:04:05"))
}