151 lines
3.4 KiB
Markdown
151 lines
3.4 KiB
Markdown
# Contributing to go-rst
|
|
|
|
## Adding New Node Types
|
|
|
|
### 1. Define the Node Type
|
|
First, add your new node type in `pkg/nodes/types.go`:
|
|
|
|
```go
|
|
const (
|
|
NodeText NodeType = iota
|
|
NodeHeading
|
|
NodeParagraph
|
|
NodeMeta
|
|
NodeDirective
|
|
NodeCode
|
|
YourNewNodeType // Add your new node type here
|
|
)
|
|
```
|
|
|
|
### 2. Create Node Structure
|
|
In `pkg/nodes/nodes.go`, define your new node structure:
|
|
|
|
```go
|
|
type YourNewNode struct {
|
|
BaseNode
|
|
// Add specific fields for your node type
|
|
SpecificField string
|
|
}
|
|
|
|
func NewYourNewNode(specific string) Node {
|
|
return &YourNewNode{
|
|
BaseNode: BaseNode{
|
|
nodeType: YourNewNodeType,
|
|
},
|
|
SpecificField: specific,
|
|
}
|
|
}
|
|
```
|
|
|
|
### 3. Update Parser Components
|
|
|
|
#### a. Add Pattern (if needed)
|
|
In `pkg/parser/patterns.go`, add a new regex pattern:
|
|
|
|
```go
|
|
type Patterns struct {
|
|
// Existing patterns...
|
|
yourNewPattern *regexp.Regexp
|
|
}
|
|
|
|
func NewPatterns() *Patterns {
|
|
return &Patterns{
|
|
// Existing patterns...
|
|
yourNewPattern: regexp.MustCompile(`your-pattern-here`),
|
|
}
|
|
}
|
|
```
|
|
|
|
#### b. Add Token Type
|
|
In `pkg/parser/lexer.go`, add a new token type:
|
|
|
|
```go
|
|
const (
|
|
// Existing token types...
|
|
TokenYourNew TokenType = iota
|
|
)
|
|
```
|
|
|
|
#### c. Update Lexer
|
|
Modify the `Tokenize` method in `pkg/parser/lexer.go` to recognize your new pattern:
|
|
|
|
```go
|
|
func (l *Lexer) Tokenize(line string) Token {
|
|
// Existing checks...
|
|
|
|
if l.patterns.yourNewPattern.MatchString(line) {
|
|
return Token{
|
|
Type: TokenYourNew,
|
|
Content: // Extract relevant content
|
|
}
|
|
}
|
|
|
|
// Default case...
|
|
}
|
|
```
|
|
|
|
#### d. Update Parser
|
|
In `pkg/parser/parser.go`, add handling for your new token type:
|
|
|
|
```go
|
|
func (p *Parser) processToken(token, prevToken Token, currentNode nodes.Node) nodes.Node {
|
|
switch token.Type {
|
|
// Existing cases...
|
|
case TokenYourNew:
|
|
return nodes.NewYourNewNode(token.Content)
|
|
}
|
|
return currentNode
|
|
}
|
|
```
|
|
|
|
### 4. Add Renderer Support
|
|
In `pkg/renderer/html.go`, implement HTML rendering for your new node type:
|
|
|
|
```go
|
|
func (r *HTMLRenderer) renderNode(node nodes.Node) string {
|
|
switch node.Type() {
|
|
// Existing cases...
|
|
case nodes.YourNewNodeType:
|
|
return r.renderYourNewNode(node.(*nodes.YourNewNode))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (r *HTMLRenderer) renderYourNewNode(node *nodes.YourNewNode) string {
|
|
return fmt.Sprintf("<your-tag>%s</your-tag>", node.SpecificField)
|
|
}
|
|
```
|
|
|
|
### 5. Testing
|
|
|
|
1. Add test cases in appropriate test files
|
|
2. Create or modify example RST documents showcasing your new node type
|
|
3. Verify translation handling if applicable
|
|
|
|
### Best Practices
|
|
|
|
1. **Type Safety**: Use Go's type system effectively
|
|
2. **Error Handling**: Return meaningful errors
|
|
3. **Documentation**: Add godoc comments to all public types and functions
|
|
4. **Testing**: Write comprehensive tests for new functionality
|
|
5. **Performance**: Consider memory allocation and processing efficiency
|
|
|
|
### Translation Support
|
|
|
|
If your node type contains translatable content:
|
|
|
|
1. Ensure the content is passed through the translator in the parser
|
|
2. Update example PO files to demonstrate translation capabilities
|
|
3. Add translation tests
|
|
|
|
### Pull Request Process
|
|
|
|
1. Fork the repository
|
|
2. Create a feature branch
|
|
3. Implement your changes
|
|
4. Add tests and documentation
|
|
5. Submit a pull request with a clear description
|
|
|
|
### Questions?
|
|
|
|
Feel free to open an issue for discussion before implementing major changes. |