golang – 水色（仮）

2024年12月18日2024年12月18日

Tree-sitter による Go ソースのカラーリング試験 / Coloring test Go source by Tree-sitter

Tree-sitter による Go ソースのカラーリング試験
ワイド文字を処理していません
1文字が 1 バイトを超える文字は文字化けする

/*
Colorize test Go source by Tree-sitter
Not process wide character
Error on if letter larger than 1 byte
Support url at comment and interpreted_string_literal
2024-12-18
*/
package main

import (
	"bytes"
	"fmt"
	"regexp"
	"sort"

	sitter "github.com/smacker/go-tree-sitter"
	"github.com/smacker/go-tree-sitter/golang"
)

// ノードの種類に応じた色マッピング
var nodeColors = map[string]string{
	"interpreted_string_literal": "\033[1;33m", // 黄色
	"comment":                    "\033[1;34m", // 青
	"url":                        "\033[1;36m", // シアン
	"package":                    "\033[1;32m", // 緑
	"identifier":                 "\033[1;31m", // 赤
	"string":                     "\033[1;35m", // 紫
	"number":                     "\033[1;37m", // 白
	"int_literal":                "\033[0;33m", // 茶色
	"slice_type":                 "\033[0;34m", // 濃い青
	"default":                    "\033[0m",    // リセット
}

// URL 検出用の正規表現
var urlRegex = regexp.MustCompile(`https?://[^\s]+`)

// イベント構造体
type Event struct {
	Row       uint32 // 行番号 (0-based)
	Column    uint32 // 列番号 (0-based) byte column
	EventType string // イベントの種類 ("start" or "end")
	Color     string // 対応する色
	NodeType  string // ノードの種類
}

func main() {
	sourceCode := []byte(`
		package main

		/*
		コメント例
		https://example.com
		*/

		func main() {
			message := "Hello, Tree-sitter!" // コメント
			fmt.Println(message)
		}
	`)

	// Tree-sitter パーサーのセットアップ
	parser := sitter.NewParser()
	parser.SetLanguage(golang.GetLanguage()) // Go 言語用パーサー

	// 構文解析
	tree := parser.Parse(nil, sourceCode) // 非推奨コード
	rootNode := tree.RootNode()
	// fmt.Printf("rootNode: %v\n--------\n", rootNode)

	// パース結果を位置データに変換
	events := parseToPositionData(sourceCode, rootNode)
	// fmt.Printf("events: %v\n--------\n", events)

	// 行、列でソート
	// 行、列で比較し、"end" イベントを優先する
	sort.Slice(events, func(i, j int) bool {
		if events[i].Row == events[j].Row {
			if events[i].Column == events[j].Column {
				return events[i].EventType == "end" // "end" を優先
			}
			return events[i].Column < events[j].Column
		}
		return events[i].Row < events[j].Row
	})
	fmt.Printf("sorted events: %v\n--------\n", events)

	// スイープラインでソースコードに色付け
	colorizeSource(sourceCode, events)
}

func colorizeSource(source []byte, events []Event) {
	currentColor := "\033[0m" // 初期はリセット色
	eventIndex := 0           // 現在処理中のイベントインデックス

	for row, line := range splitLines(source) {
		coloredLine := ""

		for col := 0; col < len(line); col++ {
			// 現在の行と列に該当するイベントを処理
			for eventIndex < len(events) && events[eventIndex].Row == uint32(row) && events[eventIndex].Column == uint32(col) {
				if events[eventIndex].EventType == "start" {
					pushColor(currentColor)
					currentColor = events[eventIndex].Color
				} else if events[eventIndex].EventType == "end" {
					// currentColor = "\033[0m" // リセット色
					currentColor = popColor()
				}
				eventIndex++
			}

			// 現在の文字に色を付ける
			coloredLine += currentColor + string(line[col])
		}

		// 行の終了後にリセット
		fmt.Printf("%s\033[0m", coloredLine)
		// fmt.Printf("%s", coloredLine)
	}
}

// ソースコードを行ごとに分割
// セパレーターは "\n" は残す
func splitLines(source []byte) [][]byte {
	return bytes.SplitAfter(source, []byte("\n"))
}

// 構文木を走査してコールバックを実行
func walk(node *sitter.Node, source []byte, callback func(node *sitter.Node)) {
	if node == nil {
		return
	}

	// 現在のノードでコールバックを実行
	callback(node)

	// 子ノードを再帰的に処理
	for i := 0; i < int(node.ChildCount()); i++ {
		walk(node.Child(i), source, callback)
	}
}

// パース結果を位置データに変換
func parseToPositionData(source []byte, node *sitter.Node) []Event {
	var events []Event

	walk(node, source, func(currentNode *sitter.Node) {
		nodeType := currentNode.Type()
		color, err := getColor(nodeType)
		if err != nil {
			return
		}

		startPoint := currentNode.StartPoint()
		endPoint := currentNode.EndPoint()

		// コメントや文字列リテラル内にURLがある場合
		// Tree-sitterの構文木をさらに詳細に解析する方法もあるけれどやめ
		if nodeType == "comment" || nodeType == "interpreted_string_literal" {
			text := currentNode.Content(source)
			matches := urlRegex.FindAllStringIndex(text, -1)
			for _, match := range matches {
				urlStart := match[0]
				urlEnd := match[1]
				startRow, startCol := calculatePosition(text, currentNode, urlStart)
				endRow, endCol := calculatePosition(text, currentNode, urlEnd)

				events = append(events, Event{
					Row:       startRow,
					Column:    startCol,
					EventType: "start",
					Color:     nodeColors["url"],
					NodeType:  "url",
				}, Event{
					Row:       endRow,
					Column:    endCol,
					EventType: "end",
					Color:     nodeColors["url"],
					NodeType:  "url",
				})
			}
		}

		events = append(events, Event{
			Row:       startPoint.Row,
			Column:    startPoint.Column,
			EventType: "start",
			Color:     color,
			NodeType:  nodeType,
		})
		events = append(events, Event{
			Row:       endPoint.Row,
			Column:    endPoint.Column,
			EventType: "end",
			Color:     color,
			NodeType:  nodeType,
		})
	})

	return events
}

// ノード内の相対位置を計算して絶対位置に変換
func calculatePosition(text string, node *sitter.Node, byteIndex int) (uint32, uint32) {
	lines := bytes.Split([]byte(text[:byteIndex]), []byte("\n"))
	row := node.StartPoint().Row + uint32(len(lines)-1)
	col := uint32(len(lines[len(lines)-1]))
	if len(lines) == 1 {
		col += node.StartPoint().Column
	}
	return row, col
}

// ノードの種類に応じた色を取得
func getColor(nodeType string) (string, error) {
	if color, ok := nodeColors[nodeType]; ok {
		return color, nil
	}
	return nodeColors["default"], fmt.Errorf("color not found for node type: %s", nodeType)
}

// スイープラインの処理でネストした色付けを処理
var colorStack = []string{}

func pushColor(color string) {
	colorStack = append(colorStack, color)
}

func popColor() string {
	if len(colorStack) == 0 {
		return "\033[0m" // リセット色
	}
	color := colorStack[len(colorStack)-1]      // スタックの末尾を取得
	colorStack = colorStack[:len(colorStack)-1] // スタックから末尾を削除
	return color
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

Colorize test Go source by Tree-sitter

Not process wide character

Error on if letter larger than 1 byte

Support url at comment and interpreted_string_literal

2024-12-18

package main

import (

"bytes"

"fmt"

"regexp"

"sort"

sitter "github.com/smacker/go-tree-sitter"

"github.com/smacker/go-tree-sitter/golang"

)

// ノードの種類に応じた色マッピング

var nodeColors = map[string]string{

"interpreted_string_literal": "\033[1;33m", // 黄色

"comment": "\033[1;34m", // 青

"url": "\033[1;36m", // シアン

"package": "\033[1;32m", // 緑

"identifier": "\033[1;31m", // 赤

"string": "\033[1;35m", // 紫

"number": "\033[1;37m", // 白

"int_literal": "\033[0;33m", // 茶色

"slice_type": "\033[0;34m", // 濃い青

"default": "\033[0m", // リセット

}

// URL 検出用の正規表現

var urlRegex = regexp.MustCompile(`https?://[^\s]+`)

// イベント構造体

type Event struct {

Row uint32 // 行番号 (0-based)

Column uint32 // 列番号 (0-based) byte column

EventType string // イベントの種類 ("start" or "end")

Color string // 対応する色

NodeType string // ノードの種類

}

func main() {

sourceCode := []byte(`

package main

コメント例

https://example.com

func main() {

message := "Hello, Tree-sitter!" // コメント

fmt.Println(message)

}

// Tree-sitter パーサーのセットアップ

parser := sitter.NewParser()

parser.SetLanguage(golang.GetLanguage()) // Go 言語用パーサー

// 構文解析

tree := parser.Parse(nil, sourceCode) // 非推奨コード

rootNode := tree.RootNode()

// fmt.Printf("rootNode: %v\n--------\n", rootNode)

// パース結果を位置データに変換

events := parseToPositionData(sourceCode, rootNode)

// fmt.Printf("events: %v\n--------\n", events)

// 行、列でソート

// 行、列で比較し、"end" イベントを優先する

sort.Slice(events, func(i, j int) bool {

if events[i].Row == events[j].Row {

if events[i].Column == events[j].Column {

return events[i].EventType == "end" // "end" を優先

}

return events[i].Column < events[j].Column

}

return events[i].Row < events[j].Row

})

fmt.Printf("sorted events: %v\n--------\n", events)

// スイープラインでソースコードに色付け

colorizeSource(sourceCode, events)

}

func colorizeSource(source []byte, events []Event) {

currentColor := "\033[0m" // 初期はリセット色

eventIndex := 0 // 現在処理中のイベントインデックス

for row, line := range splitLines(source) {

coloredLine := ""

for col := 0; col < len(line); col++ {

// 現在の行と列に該当するイベントを処理

for eventIndex < len(events) && events[eventIndex].Row == uint32(row) && events[eventIndex].Column == uint32(col) {

if events[eventIndex].EventType == "start" {

pushColor(currentColor)

currentColor = events[eventIndex].Color

} else if events[eventIndex].EventType == "end" {

// currentColor = "\033[0m" // リセット色

currentColor = popColor()

}

eventIndex++

}

// 現在の文字に色を付ける

coloredLine += currentColor + string(line[col])

}

// 行の終了後にリセット

fmt.Printf("%s\033[0m", coloredLine)

// fmt.Printf("%s", coloredLine)

}

// ソースコードを行ごとに分割

// セパレーターは "\n" は残す

func splitLines(source []byte) [][]byte {

return bytes.SplitAfter(source, []byte("\n"))

}

// 構文木を走査してコールバックを実行

func walk(node *sitter.Node, source []byte, callback func(node *sitter.Node)) {

if node == nil {

return

}

// 現在のノードでコールバックを実行

callback(node)

// 子ノードを再帰的に処理

for i := 0; i < int(node.ChildCount()); i++ {

walk(node.Child(i), source, callback)

}

// パース結果を位置データに変換

func parseToPositionData(source []byte, node *sitter.Node) []Event {

var events []Event

walk(node, source, func(currentNode *sitter.Node) {

nodeType := currentNode.Type()

color, err := getColor(nodeType)

if err != nil {

return

}

startPoint := currentNode.StartPoint()

endPoint := currentNode.EndPoint()

// コメントや文字列リテラル内にURLがある場合

// Tree-sitterの構文木をさらに詳細に解析する方法もあるけれどやめ

if nodeType == "comment" || nodeType == "interpreted_string_literal" {

text := currentNode.Content(source)

matches := urlRegex.FindAllStringIndex(text, -1)

for _, match := range matches {

urlStart := match[0]

urlEnd := match[1]

startRow, startCol := calculatePosition(text, currentNode, urlStart)

endRow, endCol := calculatePosition(text, currentNode, urlEnd)

events = append(events, Event{

Row: startRow,

Column: startCol,

EventType: "start",

Color: nodeColors["url"],

NodeType: "url",

}, Event{

Row: endRow,

Column: endCol,

EventType: "end",

Color: nodeColors["url"],

NodeType: "url",

})

}

events = append(events, Event{

Row: startPoint.Row,

Column: startPoint.Column,

EventType: "start",

Color: color,

NodeType: nodeType,

})

events = append(events, Event{

Row: endPoint.Row,

Column: endPoint.Column,

EventType: "end",

Color: color,

NodeType: nodeType,

})

return events

}

// ノード内の相対位置を計算して絶対位置に変換

func calculatePosition(text string, node *sitter.Node, byteIndex int) (uint32, uint32) {

lines := bytes.Split([]byte(text[:byteIndex]), []byte("\n"))

row := node.StartPoint().Row + uint32(len(lines)-1)

col := uint32(len(lines[len(lines)-1]))

if len(lines) == 1 {

col += node.StartPoint().Column

}

return row, col

}

// ノードの種類に応じた色を取得

func getColor(nodeType string) (string, error) {

if color, ok := nodeColors[nodeType]; ok {

return color, nil

}

return nodeColors["default"], fmt.Errorf("color not found for node type: %s", nodeType)

}

// スイープラインの処理でネストした色付けを処理

var colorStack = []string{}

func pushColor(color string) {

colorStack = append(colorStack, color)

}

func popColor() string {

if len(colorStack) == 0 {

return "\033[0m" // リセット色

}

color := colorStack[len(colorStack)-1] // スタックの末尾を取得

colorStack = colorStack[:len(colorStack)-1] // スタックから末尾を削除

return color

}

2023年4月20日2023年4月20日

golang で UPnP をサポートするルーターを検出し、ルーターの外部ポートをローカル PC の転送ポートにマップする / Detects routers that support UPnP and maps the router’s external ports to forward ports on the local PC with golang

下記のパッケージで機能が提供されています：

https://github.com/huin/goupnp
https://gitlab.com/NebulousLabs/go-upnp
https://gitlab.com/NebulousLabs/fastrand

gitlab.com/NebulousLabs/go-upnp は、このままでは
現在の github.com/huin/goupnp とマッチしないので
ローカルの upnp/upnp.go に必要な箇所をコピーして修正して使用しました。

最低限のソースのみ

upnp/upnp.go:

// Package upnp provides a simple and opinionated interface to UPnP-enabled
// routers, allowing users to forward ports and discover their external IP
// address. Specific quirks:
//
// - When attempting to discover UPnP-enabled routers on the network, only the
// first such router is returned. If you have multiple routers, this may cause
// some trouble. But why would you do that?
//
// - Forwarded ports are always symmetric, e.g. the router's port 9980 will be
// mapped to the client's port 9980. This will be unacceptable for some
// purposes, but too bad. Symmetric mappings are the desired behavior 99% of
// the time, and they save a function argument.
//
// - TCP and UDP protocols are forwarded together.
//
// - Ports are forwarded permanently. Some other implementations lease a port
// mapping for a set duration, and then renew it periodically. This is nice,
// because it means mappings won't stick around after they've served their
// purpose. Unfortunately, some routers only support permanent mappings, so this
// package has chosen to support the lowest common denominator. To un-forward a
// port, you must use the Clear function (or do it manually).
//
// Once you've discovered your router, you can retrieve its address by calling
// its Location method. This address can be supplied to Load to connect to the
// router directly, which is much faster than calling Discover.
package upnp

import (
	"context"
	"errors"
	"net/url"
	"time"

	"gitlab.com/NebulousLabs/fastrand"

	"github.com/huin/goupnp"
	"github.com/huin/goupnp/dcps/internetgateway1"
)

// An IGD provides an interface to the most commonly used functions of an
// Internet Gateway Device: discovering the external IP, and forwarding ports.
type IGD struct {
	// This interface is satisfied by the internetgateway1.WANIPConnection1
	// and internetgateway1.WANPPPConnection1 types.
	client interface {
		GetExternalIPAddress() (string, error)
		AddPortMapping(string, uint16, string, uint16, string, bool, string, uint32) error
		GetSpecificPortMappingEntry(string, uint16, string) (uint16, string, bool, string, uint32, error)
		DeletePortMapping(string, uint16, string) error
		GetServiceClient() *goupnp.ServiceClient
	}
}

// ExternalIP returns the router's external IP.
func (d *IGD) ExternalIP() (string, error) {
	return d.client.GetExternalIPAddress()
}

// Forward forwards the specified protcol, port, and adds its description to the
// router's port mapping table.
func (d *IGD) Forward(routerPort uint16, protcol string, destIP string, destPort uint16, desc string) error {
	time.Sleep(time.Millisecond)
	return d.client.AddPortMapping("", routerPort, protcol, destPort, destIP, true, desc, 0)
}

// Clear un-forwards a port, removing it from the router's port mapping table.
func (d *IGD) Clear(port uint16, protcol string) error {
	time.Sleep(time.Millisecond)
	return d.client.DeletePortMapping("", port, protcol)
}

// Discover is deprecated; use DiscoverCtx instead.
func Discover() (*IGD, error) {
	return DiscoverCtx(context.Background())
}

// DiscoverCtx scans the local network for routers and returns the first
// UPnP-enabled router it encounters.  It will try up to 3 times to find a
// router, sleeping a random duration between each attempt.  This is to
// mitigate a race condition with many callers attempting to discover
// simultaneously.
func DiscoverCtx(ctx context.Context) (*IGD, error) {
	// TODO: if more than one client is found, only return those on the same
	// subnet as the user?
	maxTries := 3
	sleepTime := time.Millisecond * time.Duration(fastrand.Intn(5000))
	for try := 0; try < maxTries; try++ {
		pppclients, _, _ := internetgateway1.NewWANPPPConnection1Clients()
		if len(pppclients) > 0 {
			return &IGD{pppclients[0]}, nil
		}
		ipclients, _, _ := internetgateway1.NewWANIPConnection1Clients()
		if len(ipclients) > 0 {
			return &IGD{ipclients[0]}, nil
		}
		select {
		case <-ctx.Done():
			return nil, context.Canceled
		case <-time.After(sleepTime):
		}
		sleepTime *= 2
	}
	return nil, errors.New("no UPnP-enabled gateway found")
}

// Load connects to the router service specified by rawurl. This is much
// faster than Discover. Generally, Load should only be called with values
// returned by the IGD's Location method.
func Load(rawurl string) (*IGD, error) {
	loc, err := url.Parse(rawurl)
	if err != nil {
		return nil, err
	}
	pppclients, _ := internetgateway1.NewWANPPPConnection1ClientsByURL(loc)
	if len(pppclients) > 0 {
		return &IGD{pppclients[0]}, nil
	}
	ipclients, _ := internetgateway1.NewWANIPConnection1ClientsByURL(loc)
	if len(ipclients) > 0 {
		return &IGD{ipclients[0]}, nil
	}
	return nil, errors.New("no UPnP-enabled gateway found at URL " + rawurl)
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

// Package upnp provides a simple and opinionated interface to UPnP-enabled

// routers, allowing users to forward ports and discover their external IP

// address. Specific quirks:

// - When attempting to discover UPnP-enabled routers on the network, only the

// first such router is returned. If you have multiple routers, this may cause

// some trouble. But why would you do that?

// - Forwarded ports are always symmetric, e.g. the router's port 9980 will be

// mapped to the client's port 9980. This will be unacceptable for some

// purposes, but too bad. Symmetric mappings are the desired behavior 99% of

// the time, and they save a function argument.

// - TCP and UDP protocols are forwarded together.

// - Ports are forwarded permanently. Some other implementations lease a port

// mapping for a set duration, and then renew it periodically. This is nice,

// because it means mappings won't stick around after they've served their

// purpose. Unfortunately, some routers only support permanent mappings, so this

// package has chosen to support the lowest common denominator. To un-forward a

// port, you must use the Clear function (or do it manually).

// Once you've discovered your router, you can retrieve its address by calling

// its Location method. This address can be supplied to Load to connect to the

// router directly, which is much faster than calling Discover.

package upnp

import (

"context"

"errors"

"net/url"

"time"

"gitlab.com/NebulousLabs/fastrand"

"github.com/huin/goupnp"

"github.com/huin/goupnp/dcps/internetgateway1"

)

// An IGD provides an interface to the most commonly used functions of an

// Internet Gateway Device: discovering the external IP, and forwarding ports.

type IGD struct {

// This interface is satisfied by the internetgateway1.WANIPConnection1

// and internetgateway1.WANPPPConnection1 types.

client interface {

GetExternalIPAddress() (string, error)

AddPortMapping(string, uint16, string, uint16, string, bool, string, uint32) error

GetSpecificPortMappingEntry(string, uint16, string) (uint16, string, bool, string, uint32, error)

DeletePortMapping(string, uint16, string) error

GetServiceClient() *goupnp.ServiceClient

}

// ExternalIP returns the router's external IP.

func (d *IGD) ExternalIP() (string, error) {

return d.client.GetExternalIPAddress()

}

// Forward forwards the specified protcol, port, and adds its description to the

// router's port mapping table.

func (d *IGD) Forward(routerPort uint16, protcol string, destIP string, destPort uint16, desc string) error {

time.Sleep(time.Millisecond)

return d.client.AddPortMapping("", routerPort, protcol, destPort, destIP, true, desc, 0)

}

// Clear un-forwards a port, removing it from the router's port mapping table.

func (d *IGD) Clear(port uint16, protcol string) error {

time.Sleep(time.Millisecond)

return d.client.DeletePortMapping("", port, protcol)

}

// Discover is deprecated; use DiscoverCtx instead.

func Discover() (*IGD, error) {

return DiscoverCtx(context.Background())

}

// DiscoverCtx scans the local network for routers and returns the first

// UPnP-enabled router it encounters. It will try up to 3 times to find a

// router, sleeping a random duration between each attempt. This is to

// mitigate a race condition with many callers attempting to discover

// simultaneously.

func DiscoverCtx(ctx context.Context) (*IGD, error) {

// TODO: if more than one client is found, only return those on the same

// subnet as the user?

maxTries := 3

sleepTime := time.Millisecond * time.Duration(fastrand.Intn(5000))

for try := 0; try < maxTries; try++ {

pppclients, _, _ := internetgateway1.NewWANPPPConnection1Clients()

if len(pppclients) > 0 {

return &IGD{pppclients[0]}, nil

}

ipclients, _, _ := internetgateway1.NewWANIPConnection1Clients()

if len(ipclients) > 0 {

return &IGD{ipclients[0]}, nil

}

select {

case <-ctx.Done():

return nil, context.Canceled

case <-time.After(sleepTime):

}

sleepTime *= 2

}

return nil, errors.New("no UPnP-enabled gateway found")

}

// Load connects to the router service specified by rawurl. This is much

// faster than Discover. Generally, Load should only be called with values

// returned by the IGD's Location method.

func Load(rawurl string) (*IGD, error) {

loc, err := url.Parse(rawurl)

if err != nil {

return nil, err

}

pppclients, _ := internetgateway1.NewWANPPPConnection1ClientsByURL(loc)

if len(pppclients) > 0 {

return &IGD{pppclients[0]}, nil

}

ipclients, _ := internetgateway1.NewWANIPConnection1ClientsByURL(loc)

if len(ipclients) > 0 {

return &IGD{ipclients[0]}, nil

}

return nil, errors.New("no UPnP-enabled gateway found at URL " + rawurl)

}

main.go:

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"strings"

	"go-upnp-simple/upnp"
)

func main() {
	localIPv4 := "192.168.1.14"
	var internalPort uint16 = 80
	var externalPort uint16 = 8080
	desc := "go upnp test"

	// UPnPデバイスの検索
	igo, err := upnp.Discover()
	if err != nil {
		log.Println(err)
		return
	}

	// ルーターの外部IPアドレスを取得
	externalIP, err := igo.ExternalIP()
	if err != nil {
		log.Println(err)
		return
	}

	// ポートマッピングを追加 TCP
	err = igo.Forward(externalPort, "TCP", localIPv4, internalPort, desc)
	if err != nil {
		log.Println("error forwarding port", err)
		return
	}
	// ポートマッピングを追加 UDP
	err = igo.Forward(externalPort, "UDP", localIPv4, internalPort, desc)
	if err != nil {
		log.Println("error forwarding port", err)
		return
	}

	log.Printf("From external %s:%d forwarded to local %s:%d\n", externalIP, externalPort, localIPv4, internalPort)

	stringPrompt("Press enter key to exit...")

	// ポートマッピングを削除 TCP
	err = igo.Clear(externalPort, "TCP")
	if err != nil {
		log.Println(err)
	}
	// ポートマッピングを削除 UDP
	err = igo.Clear(externalPort, "UDP")
	if err != nil {
		log.Println(err)
	}
}

// stringPrompt asks for a string value using the label
// https://dev.to/tidalcloud/interactive-cli-prompts-in-go-3bj9
func stringPrompt(label string) string {
	var s string
	r := bufio.NewReader(os.Stdin)
	for {
		fmt.Fprint(os.Stderr, label+" ")
		s, _ = r.ReadString('\n')
		if s != "" {
			break
		}
	}
	return strings.TrimSpace(s)
}

package main

import (

"bufio"

"fmt"

"log"

"os"

"strings"

"go-upnp-simple/upnp"

)

func main() {

localIPv4 := "192.168.1.14"

var internalPort uint16 = 80

var externalPort uint16 = 8080

desc := "go upnp test"

// UPnPデバイスの検索

igo, err := upnp.Discover()

if err != nil {

log.Println(err)

return

}

// ルーターの外部IPアドレスを取得

externalIP, err := igo.ExternalIP()

if err != nil {

log.Println(err)

return

}

// ポートマッピングを追加 TCP

err = igo.Forward(externalPort, "TCP", localIPv4, internalPort, desc)

if err != nil {

log.Println("error forwarding port", err)

return

}

// ポートマッピングを追加 UDP

err = igo.Forward(externalPort, "UDP", localIPv4, internalPort, desc)

if err != nil {

log.Println("error forwarding port", err)

return

}

log.Printf("From external %s:%d forwarded to local %s:%d\n", externalIP, externalPort, localIPv4, internalPort)

stringPrompt("Press enter key to exit...")

// ポートマッピングを削除 TCP

err = igo.Clear(externalPort, "TCP")

if err != nil {

log.Println(err)

}

// ポートマッピングを削除 UDP

err = igo.Clear(externalPort, "UDP")

if err != nil {

log.Println(err)

}

// stringPrompt asks for a string value using the label

// https://dev.to/tidalcloud/interactive-cli-prompts-in-go-3bj9

func stringPrompt(label string) string {

var s string

r := bufio.NewReader(os.Stdin)

for {

fmt.Fprint(os.Stderr, label+" ")

s, _ = r.ReadString('\n')

if s != "" {

break

}

return strings.TrimSpace(s)

}

2022年12月6日2022年12月6日

golang でログ出力を止める / stop logging in golang

package main

import (
    "log"
)

func init() {
    log.SetOutput(io.Discard)
}

...

package main

import (

"log"

)

func init() {

log.SetOutput(io.Discard)

}

...

filepath and path packages

path の操作ではまった。
path の操作には2つのパッケージが使用できるですが
filepath と path
path の方知りませんでした

パスの区切り文字が違う
filepath パッケージは OS固有のものが使用され
path パッケージは “/” が使用されるとのことで

当たり前ですが、
embed パッケージで使用する path は区切りが常に “/”

—

2022年8月10日2022年8月11日

vscode に golang の build tag 指定方法 / How to specify golang build tag for vscode

“staticcheck” に替わってから？ vscode で golang開発する際に
下記のように build tag でソースコードの置き換えをしていると

//go:build foo_bar

1	//go:build foo_bar

この build tag を書いたファイルで vscode の機能が上手く働いてくれない場合がありました。チェックが厳密？正確？になったから？でしょうか。

環境変数指定で解決しました。複数指定はカンマ区切りでした…
と言うことで開発の際には環境変数をちゃんと指定しとけよってことでした。

$ export GOFLAGS="-tags=debug,foo_bar,ja_JP"

1	$ export GOFLAGS="-tags=debug,foo_bar,ja_JP"

vscode の設定で何とかするには、Goの公式拡張機能を入れて
プロジェクト内に “.vscode/settings.json” を作成してこんな感じです。

{
    "go.toolsEnvVars": {
        "GOFLAGS": "-tags=debug,foo_bar,ja_JP"
    }
}

{

"go.toolsEnvVars": {

"GOFLAGS": "-tags=debug,foo_bar,ja_JP"

}

Environment variables that will be passed to the tools that run the Go tools (e.g. CGO_CFLAGS) and debuggee process launched by Delve. Format as string key:value pairs. When debugging, merged with envFile and env values with precedence env > envFile > go.toolsEnvVars.

説明に書かれている「環境ファイル」はおそらく “~/.config/go/env”

vscode の EXPLORERバーの下の方の GOセクション？の env で編集できるようです。

2022年7月20日2022年7月20日

電子帳簿保存法なにやらで pdf ファイルが増えて何のファイルか分からなくなるので取り敢えず、自動でファイル名を変更してみるテスト / Rename the pdf receipt using pdftotext and golang

// 電子帳簿保存法なにやらで pdf ファイルが増えて
// 何のファイルか分からなくなるので
// 取り敢えず、自動でファイル名を変更してみる
//
// pdftotext を利用して pdf からテキストを取り出しそれを利用してファイル名を変更する
// 今回は以下のファイルを対象にしている
// 変更前: foo{数字}.pdf
// 変更後: foo_{受付時刻}_{受付時刻}_{振込指定日}_{受取人}_{信用金庫名}_{支店名}.pdf

package main

import (
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strconv"
	"strings"

	"github.com/dlclark/regexp2"
)

type Name struct {
	bank      string
	branch    string
	reception string
	specified string
	receiver  string
}

func main() {
	for i := 1; i < len(os.Args); i++ {
		arg := os.Args[i]
		dir := filepath.Dir(arg)
		basename := filepath.Base(arg)
		ext := filepath.Ext(arg)
		// fname := basename[0 : len(basename)-len(ext)]
		if strings.ToLower(ext) != ".pdf" {
			continue
		}

		if strings.Index(strings.ToLower(basename), "foo") != -1 {
			text, err := pdftotext(arg)
			if err != nil {
				fmt.Println(err)
				continue
			}
			// fmt.Println(i, dir, fname, ext, text)
			// fmt.Println("=====================")
			name := foo(text)
			newName := filepath.Join(dir, fmt.Sprintf("foo_%s_%s_%s_%s_%s%s", name.reception, name.specified, name.receiver, name.bank, name.branch, ext))
			if Exists(newName) {
				continue
			}
			fmt.Println(arg, "==>", newName)
			if err = os.Rename(arg, newName); err != nil {
				fmt.Println(err)
			}
		}
	}
}

func pdftotext(pdf string) (text string, err error) {
	var out []byte
	out, err = exec.Command("pdftotext", pdf, "-").Output()
	if err != nil {
		return
	}
	text = string(out)
	return
}

func foo(text string) (name Name) {

	// Bank
	// re := regexp2.MustCompile(`(?m)^.*信用金庫`, 0)
	re := regexp2.MustCompile(`.*信用金庫`, 0)
	m, _ := re.FindStringMatch(text)
	bank := strings.TrimSpace(m.String())

	// Branch
	re = regexp2.MustCompile(`お取引店[\s\n]+(.*)`, 0)
	m, _ = re.FindStringMatch(text)
	gps := m.Groups()
	branch := strings.TrimSpace(gps[1].Captures[0].String())

	// Reception datetime
	re = regexp2.MustCompile(`受付時刻[\s\n]+(\d+)年(\d+)月(\d+)日(\d+)時(\d+)分(\d+)秒`, 0)
	m, _ = re.FindStringMatch(text)
	gps = m.Groups()
	reception := fmt.Sprintf("%04d-%02d-%02d_%02d%02d%02d",
		atoi(gps[1].Captures[0].String()),
		atoi(gps[2].Captures[0].String()),
		atoi(gps[3].Captures[0].String()),
		atoi(gps[4].Captures[0].String()),
		atoi(gps[5].Captures[0].String()),
		atoi(gps[6].Captures[0].String()))

	// Specified transfer date
	re = regexp2.MustCompile(`振込指定日[\s\n]+(\d+)年(\d+)月(\d+)日`, 0)
	m, _ = re.FindStringMatch(text)
	gps = m.Groups()
	specified := fmt.Sprintf("%04d-%02d-%02d",
		atoi(gps[1].Captures[0].String()),
		atoi(gps[2].Captures[0].String()),
		atoi(gps[3].Captures[0].String()))

	// Receiver
	re = regexp2.MustCompile(`受取人[\s\n]+(.*)`, 0)
	m, _ = re.FindStringMatch(text)
	gps = m.Groups()
	receiver := strings.TrimSpace(gps[1].Captures[0].String())

	/*
		for i := 0; i < len(gps); i++ {
			for j := 0; j < len(gps[i].Captures); j++ {
				fmt.Println(i, j, gps[i].Captures[j].String())
			}
		}
	*/

	// fmt.Println("bank", bank, "branch", branch, "reception", reception, "specified", specified, "receiver", receiver)

	return Name{
		bank:      bank,
		branch:    branch,
		reception: reception,
		specified: specified,
		receiver:  receiver,
	}
}

func Exists(filename string) bool {
	_, err := os.Stat(filename)
	return err == nil
}

func atoi(a string) int {
	i, err := strconv.Atoi(a)
	if err != nil {
		panic(err)
	}
	return i
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

// 電子帳簿保存法なにやらで pdf ファイルが増えて

// 何のファイルか分からなくなるので

// 取り敢えず、自動でファイル名を変更してみる

// pdftotext を利用して pdf からテキストを取り出しそれを利用してファイル名を変更する

// 今回は以下のファイルを対象にしている

// 変更前: foo{数字}.pdf

// 変更後: foo_{受付時刻}_{受付時刻}_{振込指定日}_{受取人}_{信用金庫名}_{支店名}.pdf

package main

import (

"fmt"

"os"

"os/exec"

"path/filepath"

"strconv"

"strings"

"github.com/dlclark/regexp2"

)

type Name struct {

bank string

branch string

reception string

specified string

receiver string

}

func main() {

for i := 1; i < len(os.Args); i++ {

arg := os.Args[i]

dir := filepath.Dir(arg)

basename := filepath.Base(arg)

ext := filepath.Ext(arg)

// fname := basename[0 : len(basename)-len(ext)]

if strings.ToLower(ext) != ".pdf" {

continue

}

if strings.Index(strings.ToLower(basename), "foo") != -1 {

text, err := pdftotext(arg)

if err != nil {

fmt.Println(err)

continue

}

// fmt.Println(i, dir, fname, ext, text)

// fmt.Println("=====================")

name := foo(text)

newName := filepath.Join(dir, fmt.Sprintf("foo_%s_%s_%s_%s_%s%s", name.reception, name.specified, name.receiver, name.bank, name.branch, ext))

if Exists(newName) {

continue

}

fmt.Println(arg, "==>", newName)

if err = os.Rename(arg, newName); err != nil {

fmt.Println(err)

}

func pdftotext(pdf string) (text string, err error) {

var out []byte

out, err = exec.Command("pdftotext", pdf, "-").Output()

if err != nil {

return

}

text = string(out)

return

}

func foo(text string) (name Name) {

// Bank

// re := regexp2.MustCompile(`(?m)^.*信用金庫`, 0)

re := regexp2.MustCompile(`.*信用金庫`, 0)

m, _ := re.FindStringMatch(text)

bank := strings.TrimSpace(m.String())

// Branch

re = regexp2.MustCompile(`お取引店[\s\n]+(.*)`, 0)

m, _ = re.FindStringMatch(text)

gps := m.Groups()

branch := strings.TrimSpace(gps[1].Captures[0].String())

// Reception datetime

re = regexp2.MustCompile(`受付時刻[\s\n]+(\d+)年(\d+)月(\d+)日(\d+)時(\d+)分(\d+)秒`, 0)

m, _ = re.FindStringMatch(text)

gps = m.Groups()

reception := fmt.Sprintf("%04d-%02d-%02d_%02d%02d%02d",

atoi(gps[1].Captures[0].String()),

atoi(gps[2].Captures[0].String()),

atoi(gps[3].Captures[0].String()),

atoi(gps[4].Captures[0].String()),

atoi(gps[5].Captures[0].String()),

atoi(gps[6].Captures[0].String()))

// Specified transfer date

re = regexp2.MustCompile(`振込指定日[\s\n]+(\d+)年(\d+)月(\d+)日`, 0)

m, _ = re.FindStringMatch(text)

gps = m.Groups()

specified := fmt.Sprintf("%04d-%02d-%02d",

atoi(gps[1].Captures[0].String()),

atoi(gps[2].Captures[0].String()),

atoi(gps[3].Captures[0].String()))

// Receiver

re = regexp2.MustCompile(`受取人[\s\n]+(.*)`, 0)

m, _ = re.FindStringMatch(text)

gps = m.Groups()

receiver := strings.TrimSpace(gps[1].Captures[0].String())

for i := 0; i < len(gps); i++ {

for j := 0; j < len(gps[i].Captures); j++ {

fmt.Println(i, j, gps[i].Captures[j].String())

}

// fmt.Println("bank", bank, "branch", branch, "reception", reception, "specified", specified, "receiver", receiver)

return Name{

bank: bank,

branch: branch,

reception: reception,

specified: specified,

receiver: receiver,

}

func Exists(filename string) bool {

_, err := os.Stat(filename)

return err == nil

}

func atoi(a string) int {

i, err := strconv.Atoi(a)

if err != nil {

panic(err)

}

return i

}