gobot: rename Master to Manager (#1070)

CHANGELOG.md

@@ -1183,7 +1183,7 @@
 
 ### core
 
-* Add Running() methods for Master and Robot and increase test coverage accordingly
+* Add Running() methods for Manager and Robot and increase test coverage accordingly
 
 ### sysfs
 
@@ -1647,17 +1647,17 @@
 ### core
 
 * Refactoring to allow 'Metal' development using Gobot packages
-* Able to run robots without being part of a Master.
+* Able to run robots without being part of a Manager.
 * Now running all work in separate goroutines
-* Rename internal name of Master type
+* Rename internal name of Manager type
 * Refactor events to use channels all the way down.
 * Eliminate potential race conditions from Events and Every functions
 * Add Unsubscribe() to Eventer, now Once() works as expected
 * DeleteEvent function added to Eventer interface
 * Ranges over event channels instead of using select
 * No longer return non-standard slices of errors, instead use hashicorp/go-multierror
 * Ensure that all drivers have default names
-* Now both Robot and Master operate using AutoRun as expected
+* Now both Robot and Manager operate using AutoRun as expected
 * Use canonical import domain of gobot.io for all code
 * Use time.Sleep unless waiting for a timeout in a select
 * Uses time.NewTimer() instead of time.After() to be more efficient
@@ -2456,7 +2456,7 @@
 * Replaced ginkgo/gomega with system testing package
 * Refactor gobot/robot/device commands
 * Added Event type
-* Replaced Master type with Gobot type
+* Replaced Manager type with Gobot type
 * Every` and `After` now accept `time.Duration`
 * Removed reflection helper methods
 
@@ -2580,7 +2580,7 @@
 * Finalize on SIGINT
 * Publish function for driver events
 * device test coverage
-* master and robot test coverage
+* manager and robot test coverage
 
 ### Clean
 
@@ -2600,7 +2600,7 @@
 
 ### Refactor
 
-* robot and master
+* robot and manager
 
 ### Remove
 
@@ -2636,8 +2636,8 @@
 * Travis banner to README
 * api commands
 * POST command
-* master example
-* robot master
+* manager example
+* robot manager
 * Sphero example
 * Digispark to list of supported platforms
 * helper functions
@@ -2737,11 +2737,11 @@
 
 ### Rename
 
-* Gobot struct to Master
+* Gobot struct to Manager
 
 ### Set
 
-* GOMAXPROCS property in GobotMaster
+* GOMAXPROCS property in GobotManager
 
 ### Skeleton
 

README.md

@@ -78,8 +78,8 @@ func main() {
  work := func() {
  gobot.Every(1*time.Second, func() {
  if err := led.Toggle(); err != nil {
- fmt.Println(err)
- }
+ fmt.Println(err)
+ }
  })
  }
 
@@ -90,8 +90,8 @@ func main() {
  )
 
  if err := robot.Start(); err != nil {
- panic(err)
- }
+ panic(err)
+ }
 }
 ```
 
@@ -148,26 +148,26 @@ import (
 func main() {
  e := edison.NewAdaptor()
  if err := e.Connect(); err != nil {
- fmt.Println(err)
- }
+ fmt.Println(err)
+ }
 
  led := gpio.NewLedDriver(e, "13")
  if err := led.Start(); err != nil {
- fmt.Println(err)
- }
+ fmt.Println(err)
+ }
 
  for {
  if err := led.Toggle(); err != nil {
- fmt.Println(err)
- }
+ fmt.Println(err)
+ }
  time.Sleep(1000 * time.Millisecond)
  }
 }
 ```
 
-### "Master" Gobot
+### "Manager" Gobot
 
-You can also use the full capabilities of the framework aka "Master Gobot" to control swarms of robots or other features
+You can also use the full capabilities of the framework aka "Manager Gobot" to control swarms of robots or other features
 such as the built-in API server. For example:
 
 ```go
@@ -216,8 +216,8 @@ func NewSwarmBot(port string) *gobot.Robot {
 }
 
 func main() {
- master := gobot.NewMaster()
- api.NewAPI(master).Start()
+ manager := gobot.NewManager()
+ api.NewAPI(manager).Start()
 
  spheros := []string{
  "/dev/rfcomm0",
@@ -227,12 +227,12 @@ func main() {
  }
 
  for _, port := range spheros {
- master.AddRobot(NewSwarmBot(port))
+ manager.AddRobot(NewSwarmBot(port))
  }
 
- if err := master.Start(); err != nil {
- panic(err)
- }
+ if err := manager.Start(); err != nil {
+ panic(err)
+ }
 }
 ```
 
@@ -416,15 +416,15 @@ device status, and execute device commands.
 To activate the API, import the `gobot.io/x/gobot/v2/api` package and instantiate the `API` like this:
 
 ```go
- master := gobot.NewMaster()
- api.NewAPI(master).Start()
+ manager := gobot.NewManager()
+ api.NewAPI(manager).Start()
 ```
 
 You can also specify the api host and port, and turn on authentication:
 
 ```go
- master := gobot.NewMaster()
- server := api.NewAPI(master)
+ manager := gobot.NewManager()
+ server := api.NewAPI(manager)
  server.Port = "4000"
  server.AddHandler(api.BasicAuth("gort", "klatuu"))
  server.Start()

api/api.go

@@ -17,7 +17,7 @@ import (
 
 // API represents an API server
 type API struct {
- master *gobot.Master
+ manager *gobot.Manager
  router *pat.PatternServeMux
  Host string
  Port string
@@ -28,11 +28,11 @@ type API struct {
 }
 
 // NewAPI returns a new api instance
-func NewAPI(m *gobot.Master) *API {
+func NewAPI(m *gobot.Manager) *API {
  return &API{
- master: m,
- router: pat.New(),
- Port: "3000",
+ manager: m,
+ router:  pat.New(),
+ Port:  "3000",
  start: func(a *API) {
  log.Println("Initializing API on " + a.Host + ":" + a.Port + "...")
  http.Handle("/", a)
@@ -196,20 +196,20 @@ func (a *API) robeaux(res http.ResponseWriter, req *http.Request) {
 // mcp returns MCP route handler.
 // Writes JSON with gobot representation
 func (a *API) mcp(res http.ResponseWriter, req *http.Request) {
- a.writeJSON(map[string]interface{}{"MCP": gobot.NewJSONMaster(a.master)}, res)
+ a.writeJSON(map[string]interface{}{"MCP": gobot.NewJSONManager(a.manager)}, res)
 }
 
 // mcpCommands returns commands route handler.
 // Writes JSON with global commands representation
 func (a *API) mcpCommands(res http.ResponseWriter, req *http.Request) {
- a.writeJSON(map[string]interface{}{"commands": gobot.NewJSONMaster(a.master).Commands}, res)
+ a.writeJSON(map[string]interface{}{"commands": gobot.NewJSONManager(a.manager).Commands}, res)
 }
 
 // robots returns route handler.
 // Writes JSON with robots representation
 func (a *API) robots(res http.ResponseWriter, req *http.Request) {
  jsonRobots := []*gobot.JSONRobot{}
- a.master.Robots().Each(func(r *gobot.Robot) {
+ a.manager.Robots().Each(func(r *gobot.Robot) {
  jsonRobots = append(jsonRobots, gobot.NewJSONRobot(r))
  })
  a.writeJSON(map[string]interface{}{"robots": jsonRobots}, res)
@@ -238,7 +238,7 @@ func (a *API) robotCommands(res http.ResponseWriter, req *http.Request) {
 // robotDevices returns devices route handler.
 // Writes JSON with robot devices representation
 func (a *API) robotDevices(res http.ResponseWriter, req *http.Request) {
- if robot := a.master.Robot(req.URL.Query().Get(":robot")); robot != nil {
+ if robot := a.manager.Robot(req.URL.Query().Get(":robot")); robot != nil {
  jsonDevices := []*gobot.JSONDevice{}
  robot.Devices().Each(func(d gobot.Device) {
  jsonDevices = append(jsonDevices, gobot.NewJSONDevice(d))
@@ -268,11 +268,11 @@ func (a *API) robotDeviceEvent(res http.ResponseWriter, req *http.Request) {
  res.Header().Set("Cache-Control", "no-cache")
  res.Header().Set("Connection", "keep-alive")
 
- device := a.master.Robot(req.URL.Query().Get(":robot")).
+ device := a.manager.Robot(req.URL.Query().Get(":robot")).
  Device(req.URL.Query().Get(":device"))
 
  //nolint:forcetypeassert // no error return value, so there is no better way
- if event := a.master.Robot(req.URL.Query().Get(":robot")).
+ if event := a.manager.Robot(req.URL.Query().Get(":robot")).
  Device(req.URL.Query().Get(":device")).(gobot.Eventer).
  Event(req.URL.Query().Get(":event")); len(event) > 0 {
  //nolint:forcetypeassert // no error return value, so there is no better way
@@ -314,7 +314,7 @@ func (a *API) robotDeviceCommands(res http.ResponseWriter, req *http.Request) {
 // writes JSON with robot connections representation
 func (a *API) robotConnections(res http.ResponseWriter, req *http.Request) {
  jsonConnections := []*gobot.JSONConnection{}
- if robot := a.master.Robot(req.URL.Query().Get(":robot")); robot != nil {
+ if robot := a.manager.Robot(req.URL.Query().Get(":robot")); robot != nil {
  robot.Connections().Each(func(c gobot.Connection) {
  jsonConnections = append(jsonConnections, gobot.NewJSONConnection(c))
  })
@@ -336,7 +336,7 @@ func (a *API) robotConnection(res http.ResponseWriter, req *http.Request) {
 
 // executeMcpCommand calls a global command associated to requested route
 func (a *API) executeMcpCommand(res http.ResponseWriter, req *http.Request) {
- a.executeCommand(a.master.Command(req.URL.Query().Get(":command")),
+ a.executeCommand(a.manager.Command(req.URL.Query().Get(":command")),
  res,
  req,
  )
@@ -350,7 +350,7 @@ func (a *API) executeRobotDeviceCommand(res http.ResponseWriter, req *http.Reque
  } else {
  a.executeCommand(
  //nolint:forcetypeassert // no error return value, so there is no better way
- a.master.Robot(req.URL.Query().Get(":robot")).
+ a.manager.Robot(req.URL.Query().Get(":robot")).
  Device(req.URL.Query().Get(":device")).(gobot.Commander).
  Command(req.URL.Query().Get(":command")),
  res,
@@ -365,7 +365,7 @@ func (a *API) executeRobotCommand(res http.ResponseWriter, req *http.Request) {
  a.writeJSON(map[string]interface{}{"error": err.Error()}, res)
  } else {
  a.executeCommand(
- a.master.Robot(req.URL.Query().Get(":robot")).
+ a.manager.Robot(req.URL.Query().Get(":robot")).
  Command(req.URL.Query().Get(":command")),
  res,
  req,
@@ -410,22 +410,22 @@ func (a *API) Debug() {
 }
 
 func (a *API) jsonRobotFor(name string) (*gobot.JSONRobot, error) {
- if robot := a.master.Robot(name); robot != nil {
+ if robot := a.manager.Robot(name); robot != nil {
  return gobot.NewJSONRobot(robot), nil
  }
  return nil, fmt.Errorf("No Robot found with the name %s", name)
 }
 
 func (a *API) jsonDeviceFor(robot string, name string) (*gobot.JSONDevice, error) {
- if device := a.master.Robot(robot).Device(name); device != nil {
+ if device := a.manager.Robot(robot).Device(name); device != nil {
  return gobot.NewJSONDevice(device), nil
  }
 
  return nil, fmt.Errorf("No Device found with the name %s", name)
 }
 
 func (a *API) jsonConnectionFor(robot string, name string) (*gobot.JSONConnection, error) {
- if connection := a.master.Robot(robot).Connection(name); connection != nil {
+ if connection := a.manager.Robot(robot).Connection(name); connection != nil {
  return gobot.NewJSONConnection(connection), nil
  }
 

api/api_test.go

@@ -19,7 +19,7 @@ import (
 
 func initTestAPI() *API {
  log.SetOutput(NullReadWriteCloser{})
- g := gobot.NewMaster()
+ g := gobot.NewManager()
  a := NewAPI(g)
  a.start = func(m *API) {}
  a.Start()
@@ -38,7 +38,7 @@ func initTestAPI() *API {
 
 func TestStartWithoutDefaults(t *testing.T) {
  log.SetOutput(NullReadWriteCloser{})
- g := gobot.NewMaster()
+ g := gobot.NewManager()
  a := NewAPI(g)
  a.start = func(m *API) {}
 
@@ -396,13 +396,13 @@ func TestRobotDeviceEvent(t *testing.T) {
  respc <- resp
  }()
 
- event := a.master.Robot("Robot1").
+ event := a.manager.Robot("Robot1").
  Device("Device1").(gobot.Eventer).
  Event("TestEvent")
 
  go func() {
  time.Sleep(time.Millisecond * 5)
- a.master.Robot("Robot1").
+ a.manager.Robot("Robot1").
  Device("Device1").(gobot.Eventer).Publish(event, "event-data")
  }()
 

api/doc.go

@@ -13,14 +13,14 @@ Example:
  )
 
  func main() {
- gbot := gobot.NewMaster()
+ gbot := gobot.NewManager()
 
  // Starts the API server on default port 3000
  api.NewAPI(gbot).Start()
 
  // Accessible via http://localhost:3000/api/commands/say_hello
  gbot.AddCommand("say_hello", func(params map[string]interface{}) interface{} {
- return "Master says hello!"
+ return "Manager says hello!"
  })
 
  hello := gbot.AddRobot(gobot.NewRobot("Eve"))