Erupe/CONTRIBUTING.md

Contributing to Erupe

Thank you for your interest in contributing to Erupe! This guide will help you get started.

Getting Started

Prerequisites

• Go 1.25+
• PostgreSQL
• Git

Setting Up Your Development Environment

1. Fork the repository on GitHub

2. Clone your fork:

   git clone https://github.com/YOUR_USERNAME/Erupe.git
   cd Erupe
   

3. Set up the database following the Installation guide

4. Copy config.example.json to config.json and configure it

5. Install dependencies:

   go mod download
   

6. Build and run:

   go build
   ./erupe-ce
   

Code Contribution Workflow

1. Create a branch for your changes:

   git checkout -b feature/your-feature-name
   

   Use descriptive branch names:

   • feature/ for new features
   • fix/ for bug fixes
   • refactor/ for code refactoring
   • docs/ for documentation changes

2. Make your changes and commit them with clear, descriptive messages:

   git commit -m "feat: add new quest loading system"
   git commit -m "fix: resolve database connection timeout"
   git commit -m "docs: update configuration examples"
   

3. Test your changes (see Testing Requirements)

4. Push to your fork:

   git push origin feature/your-feature-name
   

5. Create a Pull Request on GitHub with:

   • Clear description of what changes you made
   • Why the changes are needed
   • Any related issue numbers

6. Respond to code review feedback promptly

Coding Standards

Go Style

• Run gofmt before committing:

  gofmt -w .
  

• Use golangci-lint for linting:

  golangci-lint run ./...
  

• Follow standard Go naming conventions

• Keep functions focused and reasonably sized

• Add comments for exported functions and complex logic

• Handle errors explicitly (don't ignore them)

Code Organization

• Place new handlers in appropriate files under server/channelserver/
• Keep database queries in structured locations
• Use the existing pattern for message handlers

Testing Requirements

Before submitting a pull request:

1. Run all tests:

   go test -v ./...
   

2. Check for race conditions:

   go test -v -race ./...
   

3. Ensure your code has adequate test coverage:

   go test -v -cover ./...
   

Writing Tests

• Add tests for new features in *_test.go files
• Test edge cases and error conditions
• Use table-driven tests for multiple scenarios
• Mock external dependencies where appropriate

Example:

func TestYourFunction(t *testing.T) {
    tests := []struct {
        name string
        input int
        want int
    }{
        {"basic case", 1, 2},
        {"edge case", 0, 0},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := YourFunction(tt.input)
            if got != tt.want {
                t.Errorf("got %v, want %v", got, tt.want)
            }
        })
    }
}

Database Schema Changes

Patch Schemas (Development)

When actively developing new features that require schema changes:

1. Create a new file in patch-schema/ with format: NN_description.sql
2. Increment the number from the last patch
3. Test the migration on a clean database
4. Document what the patch does in comments

Important: Patch schemas are temporary and may change during development.

Update Schemas (Production)

For release-ready schema changes:

1. Consolidate patch schemas into update schemas
2. Create a new file in appropriate schema directory
3. Update schema version tracking
4. Test migration paths from previous versions

Documentation Requirements

Always Update

• CHANGELOG.md: Document your changes under "Unreleased" section
  • Use categories: Added, Changed, Fixed, Removed, Security
  • Be specific about what changed and why

When Applicable

• README.md: Update if you change:

  • Installation steps
  • Configuration options
  • Requirements
  • Usage instructions

• Code Comments: Add or update comments for:

  • Exported functions and types
  • Complex algorithms
  • Non-obvious business logic
  • Packet structures and handling

Getting Help

Questions and Discussion

• Mogapedia's Discord: Active development discussions
• Mezeporta Square Discord: Community support
• GitHub Issues: For bug reports and feature requests

Reporting Bugs

When filing a bug report, include:

1. Erupe version (git commit hash or release version)
2. Client version (ClientMode setting)
3. Go version: go version
4. PostgreSQL version: psql --version
5. Steps to reproduce the issue
6. Expected behavior vs actual behavior
7. Relevant logs (enable debug logging if needed)
8. Configuration (sanitize passwords!)

Requesting Features

For feature requests:

1. Check existing issues first
2. Describe the feature and its use case
3. Explain why it would benefit the project
4. Be open to discussion about implementation

Code of Conduct

• Be respectful and constructive
• Welcome newcomers and help them learn
• Focus on the code, not the person
• Assume good intentions

License

By contributing to Erupe, you agree that your contributions will be licensed under the same license as the project.

---

Thank you for contributing to Erupe!