Add MPL-2 license file

.gitignore

@@ -6,8 +6,6 @@
 *.so
 *.dylib
 
-/bin
-
 # Test binary, built with `go test -c`
 *.test
 
@@ -18,9 +16,3 @@
 # vendor/
 
 .lumerc
-.vscode/configurationCache.log
-.vscode/dryrun.log
-.vscode/targets.log
-
-# packaging
-/build

LICENSE

@@ -1,312 +0,0 @@
-Mozilla Public License Version 2.0
-
-   1. Definitions
-
-1.1. "Contributor" means each individual or legal entity that creates, contributes
-to the creation of, or owns Covered Software.
-
-1.2. "Contributor Version" means the combination of the Contributions of others
-(if any) used by a Contributor and that particular Contributor's Contribution.
-
-      1.3. "Contribution" means Covered Software of a particular Contributor.
-
-1.4. "Covered Software" means Source Code Form to which the initial Contributor
-has attached the notice in Exhibit A, the Executable Form of such Source Code
-Form, and Modifications of such Source Code Form, in each case including portions
-thereof.
-
-      1.5. "Incompatible With Secondary Licenses" means
-
-(a) that the initial Contributor has attached the notice described in Exhibit
-B to the Covered Software; or
-
-(b) that the Covered Software was made available under the terms of version
-1.1 or earlier of the License, but not also under the terms of a Secondary
-License.
-
-1.6. "Executable Form" means any form of the work other than Source Code Form.
-
-1.7. "Larger Work" means a work that combines Covered Software with other
-material, in a separate file or files, that is not Covered Software.
-
-      1.8. "License" means this document.
-
-1.9. "Licensable" means having the right to grant, to the maximum extent possible,
-whether at the time of the initial grant or subsequently, any and all of the
-rights conveyed by this License.
-
-      1.10. "Modifications" means any of the following:
-
-(a) any file in Source Code Form that results from an addition to, deletion
-from, or modification of the contents of Covered Software; or
-
-(b) any new file in Source Code Form that contains any Covered Software.
-
-1.11. "Patent Claims" of a Contributor means any patent claim(s), including
-without limitation, method, process, and apparatus claims, in any patent Licensable
-by such Contributor that would be infringed, but for the grant of the License,
-by the making, using, selling, offering for sale, having made, import, or
-transfer of either its Contributions or its Contributor Version.
-
-1.12. "Secondary License" means either the GNU General Public License, Version
-2.0, the GNU Lesser General Public License, Version 2.1, the GNU Affero General
-Public License, Version 3.0, or any later versions of those licenses.
-
-1.13. "Source Code Form" means the form of the work preferred for making modifications.
-
-1.14. "You" (or "Your") means an individual or a legal entity exercising rights
-under this License. For legal entities, "You" includes any entity that controls,
-is controlled by, or is under common control with You. For purposes of this
-definition, "control" means (a) the power, direct or indirect, to cause the
-direction or management of such entity, whether by contract or otherwise,
-or (b) ownership of more than fifty percent (50%) of the outstanding shares
-or beneficial ownership of such entity.
-
-   2. License Grants and Conditions
-
-      2.1. Grants
-
-Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive
-license:
-
-(a) under intellectual property rights (other than patent or trademark) Licensable
-by such Contributor to use, reproduce, make available, modify, display, perform,
-distribute, and otherwise exploit its Contributions, either on an unmodified
-basis, with Modifications, or as part of a Larger Work; and
-
-(b) under Patent Claims of such Contributor to make, use, sell, offer for
-sale, have made, import, and otherwise transfer either its Contributions or
-its Contributor Version.
-
-      2.2. Effective Date
-
-The licenses granted in Section 2.1 with respect to any Contribution become
-effective for each Contribution on the date the Contributor first distributes
-such Contribution.
-
-      2.3. Limitations on Grant Scope
-
-The licenses granted in this Section 2 are the only rights granted under this
-License. No additional rights or licenses will be implied from the distribution
-or licensing of Covered Software under this License. Notwithstanding Section
-2.1(b) above, no patent license is granted by a Contributor:
-
-(a) for any code that a Contributor has removed from Covered Software; or
-
-(b) for infringements caused by: (i) Your and any other third party's modifications
-of Covered Software, or (ii) the combination of its Contributions with other
-software (except as part of its Contributor Version); or
-
-(c) under Patent Claims infringed by Covered Software in the absence of its
-Contributions.
-
-This License does not grant any rights in the trademarks, service marks, or
-logos of any Contributor (except as may be necessary to comply with the notice
-requirements in Section 3.4).
-
-      2.4. Subsequent Licenses
-
-No Contributor makes additional grants as a result of Your choice to distribute
-the Covered Software under a subsequent version of this License (see Section
-10.2) or under the terms of a Secondary License (if permitted under the terms
-of Section 3.3).
-
-      2.5. Representation
-
-Each Contributor represents that the Contributor believes its Contributions
-are its original creation(s) or it has sufficient rights to grant the rights
-to its Contributions conveyed by this License.
-
-      2.6. Fair Use
-
-This License is not intended to limit any rights You have under applicable
-copyright doctrines of fair use, fair dealing, or other equivalents.
-
-      2.7. Conditions
-
-Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
-Section 2.1.
-
-   3. Responsibilities
-
-      3.1. Distribution of Source Form
-
-All distribution of Covered Software in Source Code Form, including any Modifications
-that You create or to which You contribute, must be under the terms of this
-License. You must inform recipients that the Source Code Form of the Covered
-Software is governed by the terms of this License, and how they can obtain
-a copy of this License. You may not attempt to alter or restrict the recipients'
-rights in the Source Code Form.
-
-      3.2. Distribution of Executable Form
-
-      If You distribute Covered Software in Executable Form then:
-
-(a) such Covered Software must also be made available in Source Code Form,
-as described in Section 3.1, and You must inform recipients of the Executable
-Form how they can obtain a copy of such Source Code Form by reasonable means
-in a timely manner, at a charge no more than the cost of distribution to the
-recipient; and
-
-(b) You may distribute such Executable Form under the terms of this License,
-or sublicense it under different terms, provided that the license for the
-Executable Form does not attempt to limit or alter the recipients' rights
-in the Source Code Form under this License.
-
-      3.3. Distribution of a Larger Work
-
-You may create and distribute a Larger Work under terms of Your choice, provided
-that You also comply with the requirements of this License for the Covered
-Software. If the Larger Work is a combination of Covered Software with a work
-governed by one or more Secondary Licenses, and the Covered Software is not
-Incompatible With Secondary Licenses, this License permits You to additionally
-distribute such Covered Software under the terms of such Secondary License(s),
-so that the recipient of the Larger Work may, at their option, further distribute
-the Covered Software under the terms of either this License or such Secondary
-License(s).
-
-      3.4. Notices
-
-You may not remove or alter the substance of any license notices (including
-copyright notices, patent notices, disclaimers of warranty, or limitations
-of liability) contained within the Source Code Form of the Covered Software,
-except that You may alter any license notices to the extent required to remedy
-known factual inaccuracies.
-
-      3.5. Application of Additional Terms
-
-You may choose to offer, and to charge a fee for, warranty, support, indemnity
-or liability obligations to one or more recipients of Covered Software. However,
-You may do so only on Your own behalf, and not on behalf of any Contributor.
-You must make it absolutely clear that any such warranty, support, indemnity,
-or liability obligation is offered by You alone, and You hereby agree to indemnify
-every Contributor for any liability incurred by such Contributor as a result
-of warranty, support, indemnity or liability terms You offer. You may include
-additional disclaimers of warranty and limitations of liability specific to
-any jurisdiction.
-
-   4. Inability to Comply Due to Statute or Regulation
-
-If it is impossible for You to comply with any of the terms of this License
-with respect to some or all of the Covered Software due to statute, judicial
-order, or regulation then You must: (a) comply with the terms of this License
-to the maximum extent possible; and (b) describe the limitations and the code
-they affect. Such description must be placed in a text file included with
-all distributions of the Covered Software under this License. Except to the
-extent prohibited by statute or regulation, such description must be sufficiently
-detailed for a recipient of ordinary skill to be able to understand it.
-
-   5. Termination
-
-5.1. The rights granted under this License will terminate automatically if
-You fail to comply with any of its terms. However, if You become compliant,
-then the rights granted under this License from a particular Contributor are
-reinstated (a) provisionally, unless and until such Contributor explicitly
-and finally terminates Your grants, and (b) on an ongoing basis, if such Contributor
-fails to notify You of the non-compliance by some reasonable means prior to
-60 days after You have come back into compliance. Moreover, Your grants from
-a particular Contributor are reinstated on an ongoing basis if such Contributor
-notifies You of the non-compliance by some reasonable means, this is the first
-time You have received notice of non-compliance with this License from such
-Contributor, and You become compliant prior to 30 days after Your receipt
-of the notice.
-
-5.2. If You initiate litigation against any entity by asserting a patent infringement
-claim (excluding declaratory judgment actions, counter-claims, and cross-claims)
-alleging that a Contributor Version directly or indirectly infringes any patent,
-then the rights granted to You by any and all Contributors for the Covered
-Software under Section 2.1 of this License shall terminate.
-
-5.3. In the event of termination under Sections 5.1 or 5.2 above, all end
-user license agreements (excluding distributors and resellers) which have
-been validly granted by You or Your distributors under this License prior
-to termination shall survive termination.
-
-   6. Disclaimer of Warranty
-
-Covered Software is provided under this License on an "as is" basis, without
-warranty of any kind, either expressed, implied, or statutory, including,
-without limitation, warranties that the Covered Software is free of defects,
-merchantable, fit for a particular purpose or non-infringing. The entire risk
-as to the quality and performance of the Covered Software is with You. Should
-any Covered Software prove defective in any respect, You (not any Contributor)
-assume the cost of any necessary servicing, repair, or correction. This disclaimer
-of warranty constitutes an essential part of this License. No use of any Covered
-Software is authorized under this License except under this disclaimer.
-
-   7. Limitation of Liability
-
-Under no circumstances and under no legal theory, whether tort (including
-negligence), contract, or otherwise, shall any Contributor, or anyone who
-distributes Covered Software as permitted above, be liable to You for any
-direct, indirect, special, incidental, or consequential damages of any character
-including, without limitation, damages for lost profits, loss of goodwill,
-work stoppage, computer failure or malfunction, or any and all other commercial
-damages or losses, even if such party shall have been informed of the possibility
-of such damages. This limitation of liability shall not apply to liability
-for death or personal injury resulting from such party's negligence to the
-extent applicable law prohibits such limitation. Some jurisdictions do not
-allow the exclusion or limitation of incidental or consequential damages,
-so this exclusion and limitation may not apply to You.
-
-   8. Litigation
-
-Any litigation relating to this License may be brought only in the courts
-of a jurisdiction where the defendant maintains its principal place of business
-and such litigation shall be governed by laws of that jurisdiction, without
-reference to its conflict-of-law provisions. Nothing in this Section shall
-prevent a party's ability to bring cross-claims or counter-claims.
-
-   9. Miscellaneous
-
-This License represents the complete agreement concerning the subject matter
-hereof. If any provision of this License is held to be unenforceable, such
-provision shall be reformed only to the extent necessary to make it enforceable.
-Any law or regulation which provides that the language of a contract shall
-be construed against the drafter shall not be used to construe this License
-against a Contributor.
-
-   10. Versions of the License
-
-      10.1. New Versions
-
-Mozilla Foundation is the license steward. Except as provided in Section 10.3,
-no one other than the license steward has the right to modify or publish new
-versions of this License. Each version will be given a distinguishing version
-number.
-
-      10.2. Effect of New Versions
-
-You may distribute the Covered Software under the terms of the version of
-the License under which You originally received the Covered Software, or under
-the terms of any subsequent version published by the license steward.
-
-      10.3. Modified Versions
-
-If you create software not governed by this License, and you want to create
-a new license for such software, you may create and use a modified version
-of this License if you rename the license and remove any references to the
-name of the license steward (except to note that such modified license differs
-from this License).
-
-10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses
-
-If You choose to distribute Source Code Form that is Incompatible With Secondary
-Licenses under the terms of this version of the License, the notice described
-in Exhibit B of this License must be attached. Exhibit A - Source Code Form
-License Notice
-
-This Source Code Form is subject to the terms of the Mozilla Public License,
-v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain
-one at http://mozilla.org/MPL/2.0/.
-
-If it is not possible or desirable to put the notice in a particular file,
-then You may include the notice in a location (such as a LICENSE file in a
-relevant directory) where a recipient would be likely to look for such a notice.
-
-You may add additional accurate notices of copyright ownership.
-
-Exhibit B - "Incompatible With Secondary Licenses" Notice
-
-This Source Code Form is "Incompatible With Secondary Licenses", as defined
-by the Mozilla Public License, v. 2.0.

Makefile

@@ -1,108 +1,7 @@
-V ?= 0
-Q = $(if $(filter 1, $V),, @)
-BINDIR=$(CURDIR)/bin
-PREFIX=/usr
-DESTDIR=bin
-BUILDDIR=$(CURDIR)/build
-MANDIR=$(PREFIX)/share/man/man1
-
-PKGREVISION=1
-
-DEBBUILDDIR=$(BUILDDIR)/deb
-DEBTMPLDIR=$(CURDIR)/packaging/debian
-DEBDATE=$(shell date -R)
-DEBORIGSRC=lume_$(DEBVERSION).orig.tar.xz
-DEBORIGSRCDIR=lume-$(DEBVERSION)
-DEBREVISION=$(PKGREVISION)
-
-RPMVERSION=$(subst -,_,$(LUME_VERSION))
-RPMBUILDDIR=$(BUILDDIR)/rpm
-RPMTMPLDIR=$(CURDIR)/packaging/rpm
-RPMDATE=$(shell date "+%a %b %d %Y")
-RPMORIGSRC=lume-$(RPMVERSION).tar.xz
-RPMORIGSRCDIR=lume-$(RPMVERSION)
-RPMREVISION=$(PKGREVISION)
-
-ifeq ($(OS), Windows_NT)
-    EXE=$(BINDIR)/lume.exe
-	RM=del /f /q
-	BUILD_DATE=$(shell powershell Get-Date -Format "yyyy-MM-ddThh:mm:sszzz")
-else
-    EXE=$(BINDIR)/lume
-    RM=rm -f
-	BUILD_DATE=$(shell date --iso-8601=seconds)
-endif
-
-LUME_VERSION ?= $(shell git describe --tags --always)
-GIT_COMMIT := $(shell git rev-parse --short HEAD)
-GIT_TAG=$(shell git describe --tags --abbrev=0)
-LDFLAGS = \
-	-X git.kill0.net/chill9/lume/cmd.Version=$(LUME_VERSION) \
-	-X git.kill0.net/chill9/lume/cmd.BuildDate=$(BUILD_DATE) \
-	-X git.kill0.net/chill9/lume/cmd.GitCommit=$(GIT_COMMIT)
-
-ifneq (,$(findstring -,$(LUME_VERSION)))
-	DEBVERSION=$(GIT_TAG)+git$(shell date +%Y%m%d)+$(GIT_COMMIT)
-else
-	DEBVERSION=$(LUME_VERSION)
-endif
-
 .PHONY: build
 build:
-	$(Q) go build -o $(EXE) -ldflags="$(LDFLAGS)" ./cmd/lume
+	go build -o lume ./cmd/lume
 
 .PHONY: clean
-clean: deb-clean rpm-clean
+clean:
-	$(Q) $(RM) $(EXE)
+	rm -f ./lifx
-
-install-man:
-	install -p -D -m 0644 lume.1 $(DESTDIR)$(MANDIR)/lume.1
-
-.PHONY: install
-install: install-man
-	$(Q) install -p -D -m 0755 $(EXE) $(DESTDIR)${PREFIX}/bin/lume
-	$(Q) install -p -D -m 0644 .lumerc.sample $(DESTDIR)${PREFIX}/share/lume/lumerc
-
-.PHONY: deb
-deb: deb-clean
-	$(Q) mkdir -p $(DEBBUILDDIR)
-	$(Q) git archive --format tar --prefix lume-$(DEBVERSION)/ $(LUME_VERSION) | xz > $(DEBBUILDDIR)/$(DEBORIGSRC)
-	$(Q) tar xf $(DEBBUILDDIR)/$(DEBORIGSRC) -C $(DEBBUILDDIR)
-	$(Q) mkdir $(DEBBUILDDIR)/$(DEBORIGSRCDIR)/debian
-	$(Q) mkdir $(DEBBUILDDIR)/$(DEBORIGSRCDIR)/debian/source
-	$(Q) sed -e 's/__VERSION__/$(DEBVERSION)/g' -e 's/__REVISION__/$(DEBREVISION)/g' $(DEBTMPLDIR)/rules > $(DEBBUILDDIR)/$(DEBORIGSRCDIR)/debian/rules
-	$(Q) chmod 0755 $(DEBBUILDDIR)/$(DEBORIGSRCDIR)/debian/rules
-	$(Q) sed -e 's/__VERSION__/$(DEBVERSION)/g' -e 's/__DATE__/$(DEBDATE)/g' -e 's/__REVISION__/$(DEBREVISION)/g' $(DEBTMPLDIR)/changelog > $(DEBBUILDDIR)/$(DEBORIGSRCDIR)/debian/changelog
-	$(Q) echo 10 > $(DEBBUILDDIR)/$(DEBORIGSRCDIR)/debian/compat
-	$(Q) echo "3.0 (quilt)" > $(DEBBUILDDIR)/$(DEBORIGSRCDIR)/debian/source/format
-	$(Q) cp $(DEBTMPLDIR)/control $(DEBBUILDDIR)/$(DEBORIGSRCDIR)/debian/control
-	$(Q) cp $(DEBTMPLDIR)/copyright $(DEBBUILDDIR)/$(DEBORIGSRCDIR)/debian/copyright
-	$(Q) cp $(DEBTMPLDIR)/lume.manpages $(DEBBUILDDIR)/$(DEBORIGSRCDIR)/debian/lume.manpages
-	$(Q) cd $(DEBBUILDDIR)/$(DEBORIGSRCDIR) && dpkg-buildpackage -us -uc
-	$(Q) mv $(DEBBUILDDIR)/*.dsc $(BUILDDIR)
-	$(Q) mv $(DEBBUILDDIR)/*.changes $(BUILDDIR)
-	$(Q) mv $(DEBBUILDDIR)/*.buildinfo $(BUILDDIR)
-	$(Q) mv $(DEBBUILDDIR)/*.deb $(BUILDDIR)
-	$(Q) mv $(DEBBUILDDIR)/*.tar.* $(BUILDDIR)
-
-.PHONY: rpm
-rpm: rpm-clean
-	$(Q) mkdir -p $(RPMBUILDDIR)/SPECS
-	$(Q) mkdir -p $(RPMBUILDDIR)/SOURCES
-	$(Q) sed -e 's/__VERSION__/$(RPMVERSION)/g' -e 's/__DATE__/$(RPMDATE)/g' -e 's/__REVISION__/$(RPMREVISION)/g' $(RPMTMPLDIR)/lume.spec > $(RPMBUILDDIR)/SPECS/lume.spec
-	$(Q) git archive --format tar --prefix $(RPMORIGSRCDIR)/ $(LUME_VERSION) | xz > $(RPMBUILDDIR)/SOURCES/$(RPMORIGSRC)
-	$(Q) rpmbuild --define "_topdir $(RPMBUILDDIR)"  -ba $(RPMBUILDDIR)/SPECS/lume.spec
-	$(Q) mv $(RPMBUILDDIR)/RPMS/*/*.rpm $(BUILDDIR)
-	$(Q) mv $(RPMBUILDDIR)/SRPMS/*.rpm $(BUILDDIR)
-
-deb-clean:
-	$(Q) rm -rf $(DEBBUILDDIR)
-	$(Q) rm -f $(BUILDDIR)/*.dsc
-	$(Q) rm -f $(BUILDDIR)/*.changes
-	$(Q) rm -f $(BUILDDIR)/*.buildinfo
-	$(Q) rm -f $(BUILDDIR)/*.deb
-	$(Q) rm -f $(BUILDDIR)/*.tar.*
-
-rpm-clean:
-	$(Q) rm -rf $(RPMBUILDDIR)
-	$(Q) rm -f $(BUILDDIR)/*.rpm

cmd/breathe.go

@@ -1,109 +0,0 @@
-package lumecmd
-
-import (
-	"flag"
-	"fmt"
-
-	"git.kill0.net/chill9/lifx-go"
-)
-
-func NewCmdBreathe() Command {
-	return Command{
-		Name: "breathe",
-		Func: BreatheCmd,
-		Flags: func() *flag.FlagSet {
-			fs := flag.NewFlagSet("breathe", flag.ExitOnError)
-
-			selector := fs.String("selector", defaultSelector, "Set the selector")
-			fs.StringVar(selector, "s", defaultSelector, "Set the selector")
-
-			color := fs.String("color", defaultColor, "The color to use for the breathe effect")
-			fs.StringVar(color, "c", defaultColor, "The color to use for the breathe effect")
-
-			fs.String("from-color", defaultColor, "The color to start the effect from")
-
-			fs.Float64("period", lifx.DefaultBreathePeriod, "The time in seconds for one cycle of the effect")
-
-			fs.Float64("cycles", lifx.DefaultBreatheCycles, "The number of times to repeat the effect")
-
-			fs.Bool("persist", lifx.DefaultBreathePersist, "If false set the light back to its previous value when effect ends, if true leave the last effect color")
-
-			fs.Bool("power-on", lifx.DefaultBreathePowerOn, "If true, turn the bulb on if it is not already on")
-
-			fs.Float64("peak", lifx.DefaultBreathePeak, "Defines where in a period the target color is at its maximum (min: 0.0, max: 1.0)")
-
-			return fs
-		}(),
-		Use:   "[--selector <selector>] --color <color> [--from-color <color>] [--period <period>] [--cycles <cycles>] [--persist <persist>] [--power-on] [--peak <peak>]",
-		Short: "The breathe effect",
-	}
-}
-
-func BreatheCmd(ctx Context) (int, error) {
-	var p Printer
-
-	c := ctx.Client
-	breathe := lifx.NewBreathe()
-	selector := ctx.Flags.String("selector")
-	format, err := getOutputFormatFromFlags(ctx.Flags)
-	if err != nil {
-		return ExitFailure, err
-	}
-
-	if format == "" && ctx.Config.OutputFormat != "" {
-		format = ctx.Config.OutputFormat
-	}
-
-	color := ctx.Flags.String("color")
-	if color != "" {
-		breathe.Color = lifx.NamedColor(color)
-	}
-
-	from_color := ctx.Flags.String("from-color")
-	if from_color != "" {
-		breathe.FromColor = lifx.NamedColor(from_color)
-	}
-
-	periodFlag := ctx.Flags.String("period")
-	if periodFlag != "" {
-		period := ctx.Flags.Float64("period")
-		breathe.Period = period
-	}
-
-	cyclesFlag := ctx.Flags.String("cycles")
-	if cyclesFlag != "" {
-		cycles := ctx.Flags.Float64("cycles")
-		breathe.Cycles = cycles
-	}
-
-	persist := ctx.Flags.Bool("persist")
-	breathe.Persist = persist
-
-	power_on := ctx.Flags.Bool("power-on")
-	breathe.PowerOn = power_on
-
-	peakFlag := ctx.Flags.String("peak")
-	if peakFlag != "" {
-		peak := ctx.Flags.Float64("peak")
-		breathe.Peak = peak
-	}
-
-	if color == "" {
-		printCmdHelp(ctx.Name)
-		return ExitFailure, nil
-	}
-
-	if err := breathe.Valid(); err != nil {
-		return ExitFailure, err
-	}
-
-	r, err := c.Breathe(selector, breathe)
-	if err != nil {
-		return ExitFailure, err
-	}
-
-	p = NewPrinter(format)
-	fmt.Print(p.Results(r.Results))
-
-	return ExitSuccess, nil
-}

cmd/command.go

@@ -14,9 +14,13 @@ const (
 	ExitFailure
 )
 
-type Context struct {
+type Config struct {
+	AccessToken string               `toml:"access_token"`
+	Colors      map[string][]float32 `toml:"colors"`
+}
+
+type CmdArgs struct {
 	Flags  Flags
-	Args   []string
 	Client *lifx.Client
 	Config Config
 	Name   string
@@ -28,7 +32,7 @@ type Flags struct {
 
 type Command struct {
 	Name  string
-	Func  func(Context) (int, error)
+	Func  func(CmdArgs) (int, error)
 	Flags *flag.FlagSet
 	Use   string
 	Short string
@@ -38,20 +42,19 @@ type Command struct {
 var commandRegistry = make(map[string]Command)
 
 var (
-	defaultSelector     string  = "all"
+	defaultSelector    string  = "all"
-	defaultDuration     float64 = 1.0
+	defaultDuration    float64 = 1.0
-	defaultPower        string  = ""
+	defaultPower       string  = ""
-	defaultColor        string  = ""
+	defaultColor       string  = ""
-	defaultBrightness   string  = ""
+	defaultBrightness  string  = ""
-	defaultInfrared     string  = ""
+	defaultInfrared    string  = ""
-	defaultFast         bool    = false
+	defaultFast        bool    = false
-	defaultWhiteKelvin  string  = ""
+	defaultWhiteKelvin string  = ""
-	defaultWhiteName    string  = ""
+	defaultWhiteName   string  = ""
-	defaultHue          string  = ""
+	defaultHue         string  = ""
-	defaultSaturation   string  = ""
+	defaultSaturation  string  = ""
-	defaultRGB          string  = ""
+	defaultRGB         string  = ""
-	defaultName         string  = ""
+	defaultName        string  = ""
-	defaultOutputFormat string  = ""
 )
 
 func (f Flags) String(name string) string {
@@ -78,18 +81,12 @@ func (f Flags) Bool(name string) bool {
 	return val
 }
 
-func RegisterCommand(cmd Command) error {
+func RegisterCommand(name string, cmd Command) error {
-	if _, ok := commandRegistry[cmd.Name]; ok {
+	if _, ok := commandRegistry[name]; ok {
 		return fmt.Errorf("%s command is already registered")
 	}
-
+	cmd.Name = name
-	if cmd.Flags == nil {
+	commandRegistry[name] = cmd
-		cmd.Flags = flag.NewFlagSet(cmd.Name, flag.ExitOnError)
-	}
-
-	mergeGlobalFlags(cmd.Flags)
-
-	commandRegistry[cmd.Name] = cmd
 	return nil
 }
 
@@ -98,25 +95,37 @@ func GetCommand(name string) (Command, bool) {
 	return cmd, ok
 }
 
-func mergeGlobalFlags(fs *flag.FlagSet) {
+// Validate configuration struct
-	fs.Bool("debug", false, "Enable debug mode")
+func (c *Config) Validate() error {
-
+	var err error
-	formatTable := fs.Bool("table", false, "Format output as an ASCII table")
+	if c.AccessToken == "" {
-	fs.BoolVar(formatTable, "t", false, "Format output as an ASCII table")
+		err = errors.New("access_token is not set")
-
-	fs.Bool("simple", false, "Format output simply")
-}
-
-func getOutputFormatFromFlags(fs Flags) (string, error) {
-	formatSimple := fs.Bool("simple")
-	formatTable := fs.Bool("table")
-
-	switch {
-	case formatSimple && formatTable:
-		return "", errors.New("only one output format permitted")
-	case formatTable:
-		return "table", nil
-	default:
-		return "simple", nil
 	}
+
+	if err = c.validateColors(); err != nil {
+		return err
+	}
+
+	return err
+}
+
+func (c *Config) validateColors() (err error) {
+	if len(c.Colors) > 0 {
+		for name, hsb := range c.Colors {
+			if len(hsb) != 3 {
+				return fmt.Errorf("color '%s' needs three values", name)
+			}
+			h, s, b := hsb[0], hsb[1], hsb[2]
+			if h < 0 || h > 360 {
+				return fmt.Errorf("color '%s' hue value must be between 0.0-360.0", name)
+			}
+			if s < 0 || b > 1 {
+				return fmt.Errorf("color '%s' saturation value must be between 0.0-1.0", name)
+			}
+			if b < 0 || b > 1 {
+				return fmt.Errorf("color '%s' brightness value must be between 0.0-1.0", name)
+			}
+		}
+	}
+	return err
 }

cmd/config.go

@@ -1,157 +0,0 @@
-package lumecmd
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path"
-	"strings"
-
-	"github.com/BurntSushi/toml"
-)
-
-const lumercFile string = ".lumerc"
-const lumeConfigFile string = "lume.conf"
-const defaultPowerIndicator rune = '●'
-
-type Config struct {
-	AccessToken  string               `toml:"access_token"`
-	OutputFormat string               `toml:"output_format"`
-	Colors       map[string][]float32 `toml:"colors"`
-	userAgent    string
-	Debug        bool   `toml:"debug"`
-	Indicator    string `toml:"indicator"`
-}
-
-var (
-	DefaultConfig = Config{
-		userAgent: initUserAgent(),
-	}
-	globalConfig *Config = NewConfig()
-)
-
-func NewConfig() *Config {
-	c := new(Config)
-	c.userAgent = initUserAgent()
-	c.Debug = false
-	c.OutputFormat = "simple"
-	c.Indicator = string(defaultPowerIndicator)
-	return c
-}
-
-func GetConfig() *Config {
-	return globalConfig
-}
-
-// Validate configuration struct
-func (c *Config) Validate() error {
-	var err error
-
-	if c.AccessToken == "" {
-		return errors.New("access_token is not set")
-	}
-
-	if len([]rune(c.Indicator)) != 1 {
-		return errors.New("indicator must be a single rune")
-	}
-
-	if err = c.validateColors(); err != nil {
-		return err
-	}
-
-	return err
-}
-
-func (c *Config) validateColors() (err error) {
-	if len(c.Colors) > 0 {
-		for name, hsb := range c.Colors {
-			if len(hsb) != 3 {
-				return fmt.Errorf("color '%s' needs three values", name)
-			}
-			h, s, b := hsb[0], hsb[1], hsb[2]
-			if h < 0 || h > 360 {
-				return fmt.Errorf("color '%s' hue value must be between 0.0-360.0", name)
-			}
-			if s < 0 || b > 1 {
-				return fmt.Errorf("color '%s' saturation value must be between 0.0-1.0", name)
-			}
-			if b < 0 || b > 1 {
-				return fmt.Errorf("color '%s' brightness value must be between 0.0-1.0", name)
-			}
-		}
-	}
-	return err
-}
-
-func (c *Config) MergeWithEnv() {
-	envAccessToken := os.Getenv("LIFX_ACCESS_TOKEN")
-	if envAccessToken != "" {
-		c.AccessToken = envAccessToken
-	}
-}
-
-func LoadConfig(s string) (*Config, error) {
-	var err error
-	var c *Config = GetConfig()
-
-	if _, err := toml.Decode(s, &c); err != nil {
-		err = fmt.Errorf("fatal: failed to parse; %w", err)
-	}
-
-	return c, err
-}
-
-func LoadConfigFile(configPath string) (*Config, error) {
-	var err error
-
-	var c *Config = GetConfig()
-
-	if _, err := toml.DecodeFile(configPath, &c); err != nil {
-		err = fmt.Errorf("fatal: failed to parse %s; %w", configPath, err)
-	}
-
-	return c, err
-}
-
-func getConfigPath() string {
-	var tryPath, configPath, homeDir, cwd string
-	var err error
-
-	// ~/.lumerc
-	homeDir, err = os.UserHomeDir()
-	if err == nil {
-		tryPath = path.Join(homeDir, lumercFile)
-		if _, err := os.Stat(tryPath); !os.IsNotExist(err) {
-			configPath = tryPath
-		}
-	}
-
-	// ~/.config/lume/lume.conf
-	homeDir, err = os.UserHomeDir()
-	if err == nil {
-		tryPath = path.Join(homeDir, ".config/lume", lumeConfigFile)
-		if _, err := os.Stat(tryPath); !os.IsNotExist(err) {
-			configPath = tryPath
-		}
-	}
-
-	// ./.lumerc
-	cwd, err = os.Getwd()
-	if err == nil {
-		tryPath = path.Join(cwd, lumercFile)
-		if _, err := os.Stat(tryPath); !os.IsNotExist(err) {
-			configPath = tryPath
-		}
-	}
-
-	return configPath
-}
-
-func initUserAgent() string {
-	var b strings.Builder
-
-	b.WriteString("lume")
-	b.WriteRune('/')
-	b.WriteString(Version)
-	return b.String()
-}

cmd/help.go

@@ -3,35 +3,21 @@ package lumecmd
 import (
 	"fmt"
 	"sort"
-	"strings"
 )
 
-func NewCmdHelp() Command {
+func HelpCmd(args CmdArgs) (int, error) {
-	return Command{
+	argv := args.Flags.Args()
-		Name:  "help",
-		Func:  HelpCmd,
-		Use:   "<command>",
-		Short: "Show help for a command",
-	}
-}
 
-func HelpCmd(ctx Context) (int, error) {
+	if len(argv) == 0 {
-	if len(ctx.Args) == 0 {
+		printHelp(commandRegistry)
-		fmt.Print(printHelp(commandRegistry))
+	} else if len(argv) >= 1 {
-	} else if len(ctx.Args) >= 1 {
+		printCmdHelp(argv[0])
-		if cmdHelp, err := printCmdHelp(ctx.Args[0]); err == nil {
-			fmt.Print(cmdHelp)
-		} else {
-			fmt.Print(err)
-		}
 	}
 
 	return ExitSuccess, nil
 }
 
-func printHelp(commands map[string]Command) string {
+func printHelp(commands map[string]Command) {
-	var b strings.Builder
-
 	var maxLen, cmdLen int
 	var keys []string
 
@@ -43,45 +29,30 @@ func printHelp(commands map[string]Command) string {
 		}
 	}
 
-	fmt.Fprintf(&b, "usage:\n  lume <command> [<args...>]")
+	fmt.Printf("usage:\n  lume <command> [<args...>]")
-	fmt.Fprintln(&b)
+	fmt.Println()
-	fmt.Fprintln(&b, "\ncommands:")
+	fmt.Println("\ncommands:")
 
 	sort.Strings(keys)
-
 	for _, k := range keys {
 		c := commands[k]
-		fmt.Fprintf(&b, "  %-*s    %s\n", maxLen, c.Name, c.Short)
+		fmt.Printf("  %-*s    %s\n", maxLen, c.Name, c.Short)
 	}
-
-	return b.String()
 }
 
-func printCmdHelp(name string) (string, error) {
+func printCmdHelp(name string) error {
-	var b strings.Builder
-
 	subCmd, ok := commandRegistry[name]
-
 	if !ok {
-		return "", fmt.Errorf("unknown commnnd: %s\n", name)
+		return fmt.Errorf("unknown commnnd: %s\n", name)
 	}
 
 	if subCmd.Use != "" {
-		fmt.Fprintf(&b, "usage:\n  lume %s %s\n", subCmd.Name, subCmd.Use)
+		fmt.Printf("usage:\n  lume %s %s\n", subCmd.Name, subCmd.Use)
-	} else {
+		fmt.Println()
-		fmt.Fprintf(&b, "usage:\n  lume %s\n", subCmd.Name)
 	}
 
-	if subCmd.Flags != nil {
+	fmt.Print("flags:\n")
-		out := subCmd.Flags.Output()
+	subCmd.Flags.PrintDefaults()
-		defer subCmd.Flags.SetOutput(out)
 
-		fmt.Fprintln(&b)
+	return nil
-		fmt.Fprint(&b, "flags:\n")
-
-		subCmd.Flags.SetOutput(&b)
-		subCmd.Flags.PrintDefaults()
-	}
-
-	return b.String(), nil
 }

cmd/ls.go

@@ -1,49 +1,12 @@
 package lumecmd
 
-import (
+func LsCmd(args CmdArgs) (int, error) {
-	"flag"
+	c := args.Client
-	"fmt"
+	selector := args.Flags.String("selector")
-)
-
-func NewCmdLs() Command {
-	return Command{
-		Name: "ls",
-		Func: LsCmd,
-		Flags: func() *flag.FlagSet {
-			fs := flag.NewFlagSet("ls", flag.ExitOnError)
-
-			selector := fs.String("selector", defaultSelector, "Set the selector")
-			fs.StringVar(selector, "s", defaultSelector, "Set the selector")
-
-			return fs
-		}(),
-		Use:   "[--selector=<selector>]",
-		Short: "List the lights",
-	}
-}
-
-func LsCmd(ctx Context) (int, error) {
-	var p Printer
-
-	c := ctx.Client
-	selector := ctx.Flags.String("selector")
-	format, err := getOutputFormatFromFlags(ctx.Flags)
-	if err != nil {
-		return ExitFailure, err
-	}
-
-	if format == "" && ctx.Config.OutputFormat != "" {
-		format = ctx.Config.OutputFormat
-	}
-
 	lights, err := c.ListLights(selector)
-
 	if err != nil {
 		return ExitFailure, err
 	}
-
+	PrintLights(lights)
-	p = NewPrinter(format)
-	fmt.Print(p.Lights(lights))
-
 	return ExitSuccess, nil
 }

cmd/main.go

@@ -4,35 +4,213 @@ import (
 	"errors"
 	"flag"
 	"fmt"
+	"os"
+	"path"
+	"strings"
 
 	"git.kill0.net/chill9/lifx-go"
+	"github.com/BurntSushi/toml"
 )
 
+var userAgent string
+
 func init() {
-	RegisterCommand(NewCmdHelp())
+	userAgent = initUserAgent()
-	RegisterCommand(NewCmdLs())
+
-	RegisterCommand(NewCmdPoweroff())
+	RegisterCommand("help", Command{
-	RegisterCommand(NewCmdPoweron())
+		Func: HelpCmd,
-	RegisterCommand(NewCmdSetColor())
+		Flags: func() *flag.FlagSet {
-	RegisterCommand(NewCmdSetState())
+			fs := flag.NewFlagSet("help", flag.ExitOnError)
-	RegisterCommand(NewCmdSetWhite())
+
-	RegisterCommand(NewCmdShow())
+			return fs
-	RegisterCommand(NewCmdToggle())
+		}(),
-	RegisterCommand(NewCmdVersion())
+		Use:   "<command>",
-	RegisterCommand(NewCmdBreathe())
+		Short: "Show help for a command",
-	RegisterCommand(NewCmdValidate())
+	})
+	RegisterCommand("ls", Command{
+		Func: LsCmd,
+		Flags: func() *flag.FlagSet {
+			fs := flag.NewFlagSet("ls", flag.ExitOnError)
+
+			selector := fs.String("selector", defaultSelector, "Set the selector")
+			fs.StringVar(selector, "s", defaultSelector, "Set the selector")
+
+			return fs
+		}(),
+		Use:   "[--selector=<selector>]",
+		Short: "List the lights",
+	})
+	RegisterCommand("poweroff", Command{
+		Func: PoweroffCmd,
+		Flags: func() *flag.FlagSet {
+			fs := flag.NewFlagSet("poweroff", flag.ExitOnError)
+
+			duration := fs.Float64("duration", defaultDuration, "Set the duration")
+			fs.Float64Var(duration, "d", defaultDuration, "Set the duration")
+
+			selector := fs.String("selector", defaultSelector, "Set the selector")
+			fs.StringVar(selector, "s", defaultSelector, "Set the selector")
+
+			return fs
+		}(),
+		Use:   "[--selector <selector>] [--duration <sec>]",
+		Short: "Power on",
+	})
+	RegisterCommand("poweron", Command{
+		Func: PoweronCmd,
+		Flags: func() *flag.FlagSet {
+			fs := flag.NewFlagSet("poweron", flag.ExitOnError)
+
+			duration := fs.Float64("duration", defaultDuration, "Set the duration")
+			fs.Float64Var(duration, "d", defaultDuration, "Set the duration")
+
+			selector := fs.String("selector", defaultSelector, "Set the selector")
+			fs.StringVar(selector, "s", defaultSelector, "Set the selector")
+
+			return fs
+		}(),
+		Use:   "[--selector <selector>] [--duration <sec>]",
+		Short: "Power on",
+	})
+	RegisterCommand("set-color", Command{
+		Func: SetColorCmd,
+		Flags: func() *flag.FlagSet {
+			fs := flag.NewFlagSet("set-color", flag.ExitOnError)
+
+			selector := fs.String("selector", "all", "the selector")
+			fs.StringVar(selector, "s", "all", "the selector")
+
+			power := fs.String("power", defaultPower, "power state")
+			fs.StringVar(power, "p", defaultPower, "power state")
+
+			hue := fs.String("hue", defaultHue, "hue level")
+			fs.StringVar(hue, "H", defaultHue, "hue level")
+
+			saturation := fs.String("saturation", defaultSaturation, "saturation level")
+			fs.StringVar(saturation, "S", defaultSaturation, "saturation level")
+
+			rgb := fs.String("rgb", defaultRGB, "RGB value")
+			fs.StringVar(rgb, "r", defaultRGB, "RGB value")
+
+			name := fs.String("name", defaultName, "named color")
+			fs.StringVar(name, "n", defaultName, "named color")
+
+			brightness := fs.String("brightness", defaultBrightness, "brightness state")
+			fs.StringVar(brightness, "b", defaultBrightness, "brightness state")
+
+			duration := fs.Float64("duration", defaultDuration, "duration state")
+			fs.Float64Var(duration, "d", defaultDuration, "duration state")
+
+			fast := fs.Bool("fast", defaultFast, "fast state")
+			fs.BoolVar(fast, "f", defaultFast, "fast state")
+
+			return fs
+		}(),
+		Use:   "[--selector <selector>] [--power (on|off)] [--hue <hue>] [--saturation <saturation>] [--rgb <rbg>] [--name <color>] [--brightness <brightness>] [--duration <sec>] [--fast]",
+		Short: "Set the color",
+	})
+	RegisterCommand("set-state", Command{
+		Func: SetStateCmd,
+		Flags: func() *flag.FlagSet {
+			fs := flag.NewFlagSet("set-state", flag.ExitOnError)
+
+			selector := fs.String("selector", defaultSelector, "Set the selector")
+			fs.StringVar(selector, "s", defaultSelector, "Set the selector")
+
+			power := fs.String("power", defaultPower, "power state")
+			fs.StringVar(power, "p", defaultPower, "power state")
+
+			color := fs.String("color", defaultColor, "color state")
+			fs.StringVar(color, "c", defaultColor, "color state")
+
+			brightness := fs.String("brightness", defaultBrightness, "brightness state")
+			fs.StringVar(brightness, "b", defaultBrightness, "brightness state")
+
+			duration := fs.Float64("duration", defaultDuration, "duration state")
+			fs.Float64Var(duration, "d", defaultDuration, "duration state")
+
+			infrared := fs.String("infrared", defaultInfrared, "infrared state")
+			fs.StringVar(infrared, "i", defaultInfrared, "infrared state")
+
+			fast := fs.Bool("fast", defaultFast, "fast state")
+			fs.BoolVar(fast, "f", defaultFast, "fast state")
+
+			return fs
+		}(),
+		Use:   "[--selector <selector>] [--power (on|off)] [--color <color>] [--brightness <brightness>] [--duration <sec>] [--infrared <infrared>] [--fast]",
+		Short: "Set various state attributes",
+	})
+	RegisterCommand("set-white", Command{
+		Func: SetWhiteCmd,
+		Flags: func() *flag.FlagSet {
+			fs := flag.NewFlagSet("set-white", flag.ExitOnError)
+
+			selector := fs.String("selector", "all", "the selector")
+			fs.StringVar(selector, "s", "all", "the selector")
+
+			power := fs.String("power", defaultPower, "power state")
+			fs.StringVar(power, "p", defaultPower, "power state")
+
+			kelvin := fs.String("kelvin", defaultWhiteKelvin, "kelvin level")
+			fs.StringVar(kelvin, "k", defaultWhiteKelvin, "kelvin level")
+
+			name := fs.String("name", defaultWhiteName, "named white level")
+			fs.StringVar(name, "n", defaultWhiteName, "named white level")
+
+			brightness := fs.String("brightness", defaultBrightness, "brightness state")
+			fs.StringVar(brightness, "b", defaultBrightness, "brightness state")
+
+			duration := fs.Float64("duration", defaultDuration, "duration state")
+			fs.Float64Var(duration, "d", defaultDuration, "duration state")
+
+			infrared := fs.String("infrared", defaultInfrared, "infrared state")
+			fs.StringVar(infrared, "i", defaultInfrared, "infrared state")
+
+			fast := fs.Bool("fast", defaultFast, "fast state")
+			fs.BoolVar(fast, "f", defaultFast, "fast state")
+
+			return fs
+		}(),
+		Use:   "[--selector <selector>] [--power (on|off)] [--kelvin <kelvin>] [--name <color>] [--brightness <brightness>] [--duration <sec>] [--infrared] [--fast]",
+		Short: "Set the white level",
+	})
+	RegisterCommand("show", Command{
+		Func: ShowCmd,
+		Flags: func() *flag.FlagSet {
+			fs := flag.NewFlagSet("show", flag.ExitOnError)
+
+			selector := fs.String("selector", defaultSelector, "Set the selector")
+			fs.StringVar(selector, "s", defaultSelector, "Set the selector")
+
+			return fs
+		}(),
+		Use:   "[--selector=<selector>]",
+		Short: "Show details about the lights",
+	})
+	RegisterCommand("toggle", Command{
+		Func: ToggleCmd,
+		Flags: func() *flag.FlagSet {
+			fs := flag.NewFlagSet("toggle", flag.ExitOnError)
+
+			duration := fs.Float64("duration", defaultDuration, "Set the duration")
+			fs.Float64Var(duration, "d", defaultDuration, "Set the duration")
+
+			selector := fs.String("selector", defaultSelector, "Set the selector")
+			fs.StringVar(selector, "s", defaultSelector, "Set the selector")
+
+			return fs
+		}(),
+		Use:   "[--selector <selector>] [--duration <sec>]",
+		Short: "Toggle the power on/off",
+	})
 }
 
-var Version string
+const lumercFile string = ".lumerc"
-var BuildDate string
-var GitCommit string
 
 func Main(args []string) (int, error) {
-	var config *Config = GetConfig()
+	var config Config
 	var err error
 
-	flag.Parse()
-
 	if len(args) == 1 {
 		args = append(args, "help")
 	}
@@ -43,27 +221,32 @@ func Main(args []string) (int, error) {
 		return ExitFailure, err
 	}
 
-	if config, err = LoadConfigFile(configPath); err != nil {
+	if _, err := toml.DecodeFile(configPath, &config); err != nil {
+		err = fmt.Errorf("fatal: failed to parse %s; %w", configPath, err)
 		return ExitFailure, err
 	}
-	config.MergeWithEnv()
+
+	envAccessToken := os.Getenv("LIFX_ACCESS_TOKEN")
+	if envAccessToken != "" {
+		config.AccessToken = envAccessToken
+	}
 
 	if err = config.Validate(); err != nil {
 		return ExitFailure, fmt.Errorf("fatal: %s", err)
 	}
 
+	flag.Parse()
+
 	command := args[1]
 
 	c := lifx.NewClient(
 		config.AccessToken,
-		lifx.WithUserAgent(config.userAgent),
+		lifx.WithUserAgent(userAgent),
-		lifx.WithDebug(config.Debug),
 	)
 
-	ctx := Context{
+	cmdArgs := CmdArgs{
 		Client: c,
-		Config: *config,
+		Config: config,
-		Args:   args[2:],
 	}
 
 	cmd, ok := GetCommand(command)
@@ -71,18 +254,48 @@ func Main(args []string) (int, error) {
 		err = fmt.Errorf("lume: '%s' is not lume command. See 'lume help'", command)
 		return ExitFailure, err
 	}
-
 	fs := cmd.Flags
-	if fs != nil {
+	fs.Parse(args[2:])
-		fs.Parse(args[2:])
-		ctx.Flags = Flags{FlagSet: fs}
-	}
-	ctx.Name = command
 
-	exitCode, err := cmd.Func(ctx)
+	cmdArgs.Flags = Flags{FlagSet: fs}
+	cmdArgs.Name = command
+	exitCode, err := cmd.Func(cmdArgs)
 	if err != nil {
 		err = fmt.Errorf("fatal: %s", err)
 	}
 
 	return exitCode, err
 }
+
+func getConfigPath() string {
+	var tryPath, configPath string
+
+	// ~/.lumerc
+	homeDir, err := os.UserHomeDir()
+	if err == nil {
+		tryPath = path.Join(homeDir, lumercFile)
+		if _, err := os.Stat(tryPath); !os.IsNotExist(err) {
+			configPath = tryPath
+		}
+	}
+
+	// ./.lumerc
+	cwd, err := os.Getwd()
+	if err == nil {
+		tryPath = path.Join(cwd, lumercFile)
+		if _, err := os.Stat(tryPath); !os.IsNotExist(err) {
+			configPath = tryPath
+		}
+	}
+
+	return configPath
+}
+
+func initUserAgent() string {
+	var b strings.Builder
+
+	b.WriteString("lume")
+	b.WriteRune('/')
+	b.WriteString(Version)
+	return b.String()
+}

cmd/poweroff.go

@@ -1,55 +1,19 @@
 package lumecmd
 
 import (
-	"flag"
-	"fmt"
-
 	"git.kill0.net/chill9/lifx-go"
 )
 
-func NewCmdPoweroff() Command {
+func PoweroffCmd(args CmdArgs) (int, error) {
-	return Command{
+	c := args.Client
-		Name: "poweroff",
+	duration := args.Flags.Float64("duration")
-		Func: PoweroffCmd,
+	selector := args.Flags.String("selector")
-		Flags: func() *flag.FlagSet {
-			fs := flag.NewFlagSet("poweroff", flag.ExitOnError)
-
-			duration := fs.Float64("duration", defaultDuration, "Set the duration")
-			fs.Float64Var(duration, "d", defaultDuration, "Set the duration")
-
-			selector := fs.String("selector", defaultSelector, "Set the selector")
-			fs.StringVar(selector, "s", defaultSelector, "Set the selector")
-
-			return fs
-		}(),
-		Use:   "[--selector <selector>] [--duration <sec>]",
-		Short: "Power on",
-	}
-}
-
-func PoweroffCmd(ctx Context) (int, error) {
-	var p Printer
-
-	c := ctx.Client
-	duration := ctx.Flags.Float64("duration")
-	selector := ctx.Flags.String("selector")
 	state := lifx.State{Power: "off", Duration: duration}
-	format, err := getOutputFormatFromFlags(ctx.Flags)
-	if err != nil {
-		return ExitFailure, err
-	}
-
-	if format == "" && ctx.Config.OutputFormat != "" {
-		format = ctx.Config.OutputFormat
-	}
 
 	r, err := c.SetState(selector, state)
 	if err != nil {
 		return ExitFailure, err
 	}
-
+	PrintResults(r.Results)
-	p = NewPrinter(format)
-	fmt.Print(p.Results(r.Results))
-
 	return ExitSuccess, nil
 }

cmd/poweron.go

@@ -1,55 +1,19 @@
 package lumecmd
 
 import (
-	"flag"
-	"fmt"
-
 	"git.kill0.net/chill9/lifx-go"
 )
 
-func NewCmdPoweron() Command {
+func PoweronCmd(args CmdArgs) (int, error) {
-	return Command{
+	c := args.Client
-		Name: "poweron",
+	duration := args.Flags.Float64("duration")
-		Func: PoweronCmd,
+	selector := args.Flags.String("selector")
-		Flags: func() *flag.FlagSet {
-			fs := flag.NewFlagSet("poweron", flag.ExitOnError)
-
-			duration := fs.Float64("duration", defaultDuration, "Set the duration")
-			fs.Float64Var(duration, "d", defaultDuration, "Set the duration")
-
-			selector := fs.String("selector", defaultSelector, "Set the selector")
-			fs.StringVar(selector, "s", defaultSelector, "Set the selector")
-
-			return fs
-		}(),
-		Use:   "[--selector <selector>] [--duration <sec>]",
-		Short: "Power on",
-	}
-}
-
-func PoweronCmd(ctx Context) (int, error) {
-	var p Printer
-
-	c := ctx.Client
-	duration := ctx.Flags.Float64("duration")
-	selector := ctx.Flags.String("selector")
 	state := lifx.State{Power: "on", Duration: duration}
-	format, err := getOutputFormatFromFlags(ctx.Flags)
-	if err != nil {
-		return ExitFailure, err
-	}
-
-	if format == "" && ctx.Config.OutputFormat != "" {
-		format = ctx.Config.OutputFormat
-	}
 
 	r, err := c.SetState(selector, state)
 	if err != nil {
 		return ExitFailure, err
 	}
-
+	PrintResults(r.Results)
-	p = NewPrinter(format)
-	fmt.Print(p.Results(r.Results))
-
 	return ExitSuccess, nil
 }

cmd/print.go

@@ -1,195 +0,0 @@
-package lumecmd
-
-import (
-	"fmt"
-	"io"
-	"strings"
-	"time"
-
-	"git.kill0.net/chill9/lifx-go"
-	"github.com/fatih/color"
-	"github.com/olekukonko/tablewriter"
-)
-
-type Printer interface {
-	Results(results []lifx.Result) string
-	Lights(lights []lifx.Light) string
-}
-
-type defaultPrinter struct{}
-
-type tablePrinter struct{}
-
-func NewPrinter(format string) Printer {
-	switch format {
-	case "table":
-		return &tablePrinter{}
-	default:
-		return &defaultPrinter{}
-	}
-}
-
-func (dp *defaultPrinter) Results(results []lifx.Result) string {
-	var b strings.Builder
-
-	sortResults(results)
-
-	table := tablewriter.NewWriter(&b)
-	_, rows := makeResultsTable(results)
-
-	for _, v := range rows {
-		table.Append(v)
-	}
-
-	fmt.Fprintf(&b, "total %d\n", len(results))
-	table.SetAlignment(tablewriter.ALIGN_LEFT)
-	table.SetAutoWrapText(false)
-	table.SetBorder(false)
-	table.SetCenterSeparator("")
-	table.SetColumnSeparator("")
-	table.SetHeaderLine(false)
-	table.SetNoWhiteSpace(true)
-	table.SetRowSeparator("")
-	table.SetTablePadding(" ")
-	table.Render()
-
-	return b.String()
-}
-
-func (tp *tablePrinter) Results(results []lifx.Result) string {
-	var b strings.Builder
-
-	sortResults(results)
-
-	table := tablewriter.NewWriter(&b)
-	hdr, rows := makeResultsTable(results)
-
-	for _, v := range rows {
-		table.Append(v)
-	}
-
-	table.SetHeader(hdr)
-	table.Render()
-
-	return b.String()
-}
-
-func (dp *defaultPrinter) Lights(lights []lifx.Light) string {
-	var b strings.Builder
-
-	sortLights(lights)
-
-	table := tablewriter.NewWriter(&b)
-	_, rows := makeLightsTable(lights)
-
-	for _, v := range rows {
-		table.Append(v)
-	}
-
-	fmt.Fprintf(&b, "total %d\n", len(lights))
-	table.SetAlignment(tablewriter.ALIGN_LEFT)
-	table.SetAutoWrapText(false)
-	table.SetBorder(false)
-	table.SetCenterSeparator("")
-	table.SetColumnSeparator("")
-	table.SetHeaderLine(false)
-	table.SetNoWhiteSpace(true)
-	table.SetRowSeparator("")
-	table.SetTablePadding(" ")
-	table.Render()
-
-	return b.String()
-}
-
-func (tp *tablePrinter) Lights(lights []lifx.Light) string {
-	var b strings.Builder
-
-	sortLights(lights)
-
-	table := tablewriter.NewWriter(&b)
-	hdr, rows := makeLightsTable(lights)
-
-	for _, v := range rows {
-		table.Append(v)
-	}
-
-	table.SetHeader(hdr)
-	table.Render()
-
-	return b.String()
-}
-
-func ColorizeIndicator(s string) string {
-	c := color.New(color.FgRed)
-	if s == "on" {
-		c = color.New(color.FgGreen)
-	}
-
-	return c.Sprint(GetConfig().Indicator)
-}
-
-func ColorizePower(s string) string {
-	c := color.New(color.FgRed)
-	if s == "on" {
-		c = color.New(color.FgGreen)
-	}
-
-	return c.Sprint(s)
-}
-
-func ColorizeStatus(s lifx.Status) string {
-	c := color.New(color.FgRed)
-	if s == "ok" {
-		c = color.New(color.FgGreen)
-	}
-
-	return c.Sprint(s)
-}
-
-func PrintWithIndent(indent int, s string) {
-	fmt.Printf("%*s%s", indent, "", s)
-}
-
-func PrintfWithIndent(indent int, format string, a ...interface{}) (n int, err error) {
-	format = fmt.Sprintf("%*s%s", indent, "", format)
-	return fmt.Printf(format, a...)
-}
-
-func FprintfWithIndent(w io.Writer, indent int, format string, a ...interface{}) (n int, err error) {
-	format = fmt.Sprintf("%*s%s", indent, "", format)
-	return fmt.Fprintf(w, format, a...)
-}
-
-func makeLightsTable(lights []lifx.Light) (hdr []string, rows [][]string) {
-	hdr = []string{"", "ID", "Location", "Group", "Label", "Last Seen", "Power"}
-
-	for _, l := range lights {
-		rows = append(rows, []string{
-			fmt.Sprint(ColorizeIndicator(l.Power)),
-			fmt.Sprint(l.Id),
-			fmt.Sprint(l.Location.Name),
-			fmt.Sprint(l.Group.Name),
-			fmt.Sprint(l.Label),
-			fmt.Sprint(l.LastSeen.Local().Format(time.RFC3339)),
-			fmt.Sprint(ColorizePower(l.Power)),
-		})
-
-	}
-
-	return
-}
-
-func makeResultsTable(results []lifx.Result) (hdr []string, rows [][]string) {
-	hdr = []string{"ID", "Label", "Status"}
-
-	for _, r := range results {
-		rows = append(rows, []string{
-			fmt.Sprint(r.Id),
-			fmt.Sprint(r.Label),
-			fmt.Sprint(ColorizeStatus(r.Status)),
-		})
-
-	}
-
-	return
-}

cmd/setcolor.go

@@ -1,80 +1,28 @@
 package lumecmd
 
 import (
-	"flag"
 	"fmt"
 
 	"git.kill0.net/chill9/lifx-go"
 )
 
-func NewCmdSetColor() Command {
+func SetColorCmd(args CmdArgs) (int, error) {
-	return Command{
+	c := args.Client
-		Name: "set-color",
-		Func: SetColorCmd,
-		Flags: func() *flag.FlagSet {
-			fs := flag.NewFlagSet("set-color", flag.ExitOnError)
-
-			selector := fs.String("selector", "all", "the selector")
-			fs.StringVar(selector, "s", "all", "the selector")
-
-			power := fs.String("power", defaultPower, "power state")
-			fs.StringVar(power, "p", defaultPower, "power state")
-
-			hue := fs.String("hue", defaultHue, "hue level")
-			fs.StringVar(hue, "H", defaultHue, "hue level")
-
-			saturation := fs.String("saturation", defaultSaturation, "saturation level")
-			fs.StringVar(saturation, "S", defaultSaturation, "saturation level")
-
-			rgb := fs.String("rgb", defaultRGB, "RGB value")
-			fs.StringVar(rgb, "r", defaultRGB, "RGB value")
-
-			name := fs.String("name", defaultName, "named color")
-			fs.StringVar(name, "n", defaultName, "named color")
-
-			brightness := fs.String("brightness", defaultBrightness, "brightness state")
-			fs.StringVar(brightness, "b", defaultBrightness, "brightness state")
-
-			duration := fs.Float64("duration", defaultDuration, "duration state")
-			fs.Float64Var(duration, "d", defaultDuration, "duration state")
-
-			fast := fs.Bool("fast", defaultFast, "fast state")
-			fs.BoolVar(fast, "f", defaultFast, "fast state")
-
-			return fs
-		}(),
-		Use:   "[--selector <selector>] [--power (on|off)] [--hue <hue>] [--saturation <saturation>] [--rgb <rbg>] [--name <color>] [--brightness <brightness>] [--duration <sec>] [--fast]",
-		Short: "Set the color",
-	}
-}
-
-func SetColorCmd(ctx Context) (int, error) {
-	var p Printer
-
-	c := ctx.Client
 	state := lifx.State{}
-	selector := ctx.Flags.String("selector")
+	selector := args.Flags.String("selector")
-	format, err := getOutputFormatFromFlags(ctx.Flags)
-	if err != nil {
-		return ExitFailure, err
-	}
 
-	if format == "" && ctx.Config.OutputFormat != "" {
+	power := args.Flags.String("power")
-		format = ctx.Config.OutputFormat
-	}
-
-	power := ctx.Flags.String("power")
 	if power != "" {
 		state.Power = power
 	}
 
-	hueFlag := ctx.Flags.String("hue")
+	hueFlag := args.Flags.String("hue")
-	saturationFlag := ctx.Flags.String("saturation")
+	saturationFlag := args.Flags.String("saturation")
-	rgbFlag := ctx.Flags.String("rgb")
+	rgbFlag := args.Flags.String("rgb")
-	name := ctx.Flags.String("name")
+	name := args.Flags.String("name")
 
 	if (hueFlag == "" || saturationFlag == "") && rgbFlag == "" && name == "" {
-		printCmdHelp(ctx.Name)
+		printCmdHelp(args.Name)
 		return ExitFailure, nil
 	}
 
@@ -82,12 +30,12 @@ func SetColorCmd(ctx Context) (int, error) {
 		color := lifx.HSBKColor{}
 
 		if hueFlag != "" {
-			hue := ctx.Flags.Float32("hue")
+			hue := args.Flags.Float32("hue")
 			color.H = lifx.Float32Ptr(hue)
 		}
 
 		if saturationFlag != "" {
-			saturation := ctx.Flags.Float32("saturation")
+			saturation := args.Flags.Float32("saturation")
 			color.S = lifx.Float32Ptr(saturation)
 		}
 		state.Color = color
@@ -99,7 +47,7 @@ func SetColorCmd(ctx Context) (int, error) {
 		}
 		state.Color = color
 	} else if name != "" {
-		hsb, ok := ctx.Config.Colors[name]
+		hsb, ok := args.Config.Colors[name]
 		if !ok {
 			return ExitFailure, fmt.Errorf("%s is not a defined color", name)
 		}
@@ -110,16 +58,16 @@ func SetColorCmd(ctx Context) (int, error) {
 		state.Color = color
 	}
 
-	brightnessFlag := ctx.Flags.String("brightness")
+	brightnessFlag := args.Flags.String("brightness")
 	if brightnessFlag != "" {
-		brightness := ctx.Flags.Float64("brightness")
+		brightness := args.Flags.Float64("brightness")
 		state.Brightness = brightness
 	}
 
-	duration := ctx.Flags.Float64("duration")
+	duration := args.Flags.Float64("duration")
 	state.Duration = duration
 
-	fast := ctx.Flags.Bool("fast")
+	fast := args.Flags.Bool("fast")
 	state.Fast = fast
 
 	r, err := c.SetState(selector, state)
@@ -129,8 +77,7 @@ func SetColorCmd(ctx Context) (int, error) {
 	}
 
 	if !fast {
-		p = NewPrinter(format)
+		PrintResults(r.Results)
-		fmt.Print(p.Results(r.Results))
 	}
 
 	return ExitSuccess, nil

cmd/setstate.go

@@ -1,92 +1,44 @@
 package lumecmd
 
 import (
-	"flag"
-	"fmt"
-
 	"git.kill0.net/chill9/lifx-go"
 )
 
-func NewCmdSetState() Command {
+func SetStateCmd(args CmdArgs) (int, error) {
-	return Command{
+	c := args.Client
-		Name: "set-state",
-		Func: SetStateCmd,
-		Flags: func() *flag.FlagSet {
-			fs := flag.NewFlagSet("set-state", flag.ExitOnError)
-
-			selector := fs.String("selector", defaultSelector, "Set the selector")
-			fs.StringVar(selector, "s", defaultSelector, "Set the selector")
-
-			power := fs.String("power", defaultPower, "power state")
-			fs.StringVar(power, "p", defaultPower, "power state")
-
-			color := fs.String("color", defaultColor, "color state")
-			fs.StringVar(color, "c", defaultColor, "color state")
-
-			brightness := fs.String("brightness", defaultBrightness, "brightness state")
-			fs.StringVar(brightness, "b", defaultBrightness, "brightness state")
-
-			duration := fs.Float64("duration", defaultDuration, "duration state")
-			fs.Float64Var(duration, "d", defaultDuration, "duration state")
-
-			infrared := fs.String("infrared", defaultInfrared, "infrared state")
-			fs.StringVar(infrared, "i", defaultInfrared, "infrared state")
-
-			fast := fs.Bool("fast", defaultFast, "fast state")
-			fs.BoolVar(fast, "f", defaultFast, "fast state")
-
-			return fs
-		}(),
-		Use:   "[--selector <selector>] [--power (on|off)] [--color <color>] [--brightness <brightness>] [--duration <sec>] [--infrared <infrared>] [--fast]",
-		Short: "Set various state attributes",
-	}
-}
-
-func SetStateCmd(ctx Context) (int, error) {
-	var p Printer
-
-	c := ctx.Client
 	state := lifx.State{}
-	selector := ctx.Flags.String("selector")
+	selector := args.Flags.String("selector")
-	format, err := getOutputFormatFromFlags(ctx.Flags)
-	if err != nil {
-		return ExitFailure, err
-	}
 
-	if format == "" && ctx.Config.OutputFormat != "" {
+	power := args.Flags.String("power")
-		format = ctx.Config.OutputFormat
-	}
-
-	power := ctx.Flags.String("power")
 	if power != "" {
 		state.Power = power
 	}
 
-	color := ctx.Flags.String("color")
+	color := args.Flags.String("color")
 	if color != "" {
 		state.Color = lifx.NamedColor(color)
 	}
 
-	brightnessFlag := ctx.Flags.String("brightness")
+	brightnessFlag := args.Flags.String("brightness")
 	if brightnessFlag != "" {
-		brightness := ctx.Flags.Float64("brightness")
+		brightness := args.Flags.Float64("brightness")
 		state.Brightness = brightness
 	}
 
-	duration := ctx.Flags.Float64("duration")
+	duration := args.Flags.Float64("duration")
 	state.Duration = duration
 
-	infraredFlag := ctx.Flags.String("infrared")
+	infraredFlag := args.Flags.String("infrared")
 	if infraredFlag != "" {
-		infrared := ctx.Flags.Float64("infrared")
+		infrared := args.Flags.Float64("infrared")
 		state.Infrared = infrared
 	}
 
-	fast := ctx.Flags.Bool("fast")
+	fast := args.Flags.Bool("fast")
 	state.Fast = fast
 
 	if power == "" && color == "" && brightnessFlag == "" && infraredFlag == "" {
-		printCmdHelp(ctx.Name)
+		printCmdHelp(args.Name)
 		return ExitFailure, nil
 	}
 
@@ -96,8 +48,7 @@ func SetStateCmd(ctx Context) (int, error) {
 	}
 
 	if !fast {
-		p = NewPrinter(format)
+		PrintResults(r.Results)
-		fmt.Print(p.Results(r.Results))
 	}
 
 	return ExitSuccess, nil

cmd/setwhite.go

@@ -1,73 +1,22 @@
 package lumecmd
 
 import (
-	"flag"
-	"fmt"
-
 	"git.kill0.net/chill9/lifx-go"
 )
 
-func NewCmdSetWhite() Command {
+func SetWhiteCmd(args CmdArgs) (int, error) {
-	return Command{
+	c := args.Client
-		Name: "set-white",
-		Func: SetWhiteCmd,
-		Flags: func() *flag.FlagSet {
-			fs := flag.NewFlagSet("set-white", flag.ExitOnError)
-
-			selector := fs.String("selector", "all", "the selector")
-			fs.StringVar(selector, "s", "all", "the selector")
-
-			power := fs.String("power", defaultPower, "power state")
-			fs.StringVar(power, "p", defaultPower, "power state")
-
-			kelvin := fs.String("kelvin", defaultWhiteKelvin, "kelvin level")
-			fs.StringVar(kelvin, "k", defaultWhiteKelvin, "kelvin level")
-
-			name := fs.String("name", defaultWhiteName, "named white level")
-			fs.StringVar(name, "n", defaultWhiteName, "named white level")
-
-			brightness := fs.String("brightness", defaultBrightness, "brightness state")
-			fs.StringVar(brightness, "b", defaultBrightness, "brightness state")
-
-			duration := fs.Float64("duration", defaultDuration, "duration state")
-			fs.Float64Var(duration, "d", defaultDuration, "duration state")
-
-			infrared := fs.String("infrared", defaultInfrared, "infrared state")
-			fs.StringVar(infrared, "i", defaultInfrared, "infrared state")
-
-			fast := fs.Bool("fast", defaultFast, "fast state")
-			fs.BoolVar(fast, "f", defaultFast, "fast state")
-
-			return fs
-		}(),
-		Use:   "[--selector <selector>] [--power (on|off)] [--kelvin <kelvin>] [--name <color>] [--brightness <brightness>] [--duration <sec>] [--infrared] [--fast]",
-		Short: "Set the white level",
-	}
-}
-
-func SetWhiteCmd(ctx Context) (int, error) {
-	var p Printer
-
-	c := ctx.Client
 	state := lifx.State{}
-	selector := ctx.Flags.String("selector")
+	selector := args.Flags.String("selector")
-	format, err := getOutputFormatFromFlags(ctx.Flags)
-	if err != nil {
-		return ExitFailure, err
-	}
 
-	if format == "" && ctx.Config.OutputFormat != "" {
+	power := args.Flags.String("power")
-		format = ctx.Config.OutputFormat
-	}
-
-	power := ctx.Flags.String("power")
 	if power != "" {
 		state.Power = power
 	}
 
-	kelvinFlag := ctx.Flags.String("kelvin")
+	kelvinFlag := args.Flags.String("kelvin")
 	if kelvinFlag != "" {
-		kelvin := ctx.Flags.Int16("kelvin")
+		kelvin := args.Flags.Int16("kelvin")
 		color, err := lifx.NewWhite(kelvin)
 		if err != nil {
 			return ExitFailure, err
@@ -75,9 +24,9 @@ func SetWhiteCmd(ctx Context) (int, error) {
 		state.Color = color
 	}
 
-	name := ctx.Flags.String("name")
+	name := args.Flags.String("name")
 	if name != "" {
-		name := ctx.Flags.String("name")
+		name := args.Flags.String("name")
 		color, err := lifx.NewWhiteString(name)
 		if err != nil {
 			return ExitFailure, err
@@ -85,26 +34,26 @@ func SetWhiteCmd(ctx Context) (int, error) {
 		state.Color = color
 	}
 
-	brightnessFlag := ctx.Flags.String("brightness")
+	brightnessFlag := args.Flags.String("brightness")
 	if brightnessFlag != "" {
-		brightness := ctx.Flags.Float64("brightness")
+		brightness := args.Flags.Float64("brightness")
 		state.Brightness = brightness
 	}
 
-	duration := ctx.Flags.Float64("duration")
+	duration := args.Flags.Float64("duration")
 	state.Duration = duration
 
-	infraredFlag := ctx.Flags.String("infrared")
+	infraredFlag := args.Flags.String("infrared")
 	if infraredFlag != "" {
-		infrared := ctx.Flags.Float64("infrared")
+		infrared := args.Flags.Float64("infrared")
 		state.Infrared = infrared
 	}
 
-	fast := ctx.Flags.Bool("fast")
+	fast := args.Flags.Bool("fast")
 	state.Fast = fast
 
 	if power == "" && kelvinFlag == "" && name == "" && brightnessFlag == "" && infraredFlag == "" {
-		printCmdHelp(ctx.Name)
+		printCmdHelp(args.Name)
 		return ExitFailure, nil
 	}
 
@@ -114,8 +63,7 @@ func SetWhiteCmd(ctx Context) (int, error) {
 	}
 
 	if !fast {
-		p = NewPrinter(format)
+		PrintResults(r.Results)
-		fmt.Print(p.Results(r.Results))
 	}
 
 	return ExitSuccess, nil

cmd/show.go

@@ -1,36 +1,10 @@
 package lumecmd
 
-import (
+import "fmt"
-	"flag"
-	"fmt"
-	"strings"
-)
 
-const Tabstop int = 2
+func ShowCmd(args CmdArgs) (int, error) {
-
+	c := args.Client
-func NewCmdShow() Command {
+	selector := args.Flags.String("selector")
-	return Command{
-		Name: "show",
-		Func: ShowCmd,
-		Flags: func() *flag.FlagSet {
-			fs := flag.NewFlagSet("show", flag.ExitOnError)
-
-			selector := fs.String("selector", defaultSelector, "Set the selector")
-			fs.StringVar(selector, "s", defaultSelector, "Set the selector")
-
-			return fs
-		}(),
-		Use:   "[--selector=<selector>]",
-		Short: "Show details about the lights",
-	}
-}
-
-func ShowCmd(ctx Context) (int, error) {
-	var indent int
-	var b strings.Builder
-
-	c := ctx.Client
-	selector := ctx.Flags.String("selector")
 	lights, err := c.ListLights(selector)
 
 	if err != nil {
@@ -39,54 +13,44 @@ func ShowCmd(ctx Context) (int, error) {
 
 	sortLights(lights)
 
-	for i, l := range lights {
+	for _, l := range lights {
-		indent = 0
+		fmt.Printf(
-		fmt.Fprintf(
+			"Light Id: %s, Label: %s, %s, Power: %s\n",
-			&b,
-			"%s Light ID: %s, %s, Power: %s\n",
-			ColorizeIndicator(l.Power),
 			l.Id,
+			l.Label,
 			connected(l.Connected),
-			ColorizePower(l.Power),
+			powerColor(l.Power),
 		)
-		indent += Tabstop + 2
+		fmt.Printf("  Label: %s\n", l.Label)
-		FprintfWithIndent(&b, indent, "Label: %s, ID: %s\n", l.Label, l.Id)
+		fmt.Printf("  UUID: %s\n", l.UUID)
-		FprintfWithIndent(&b, indent, "UUID: %s\n", l.UUID)
+		fmt.Printf("  Location: %s, ID: %s\n", l.Location.Name, l.Location.Id)
-		FprintfWithIndent(&b, indent, "Location: %s, ID: %s\n", l.Location.Name, l.Location.Id)
+		fmt.Printf("  Group: %s, ID: %s\n", l.Group.Name, l.Group.Id)
-		FprintfWithIndent(&b, indent, "Group: %s, ID: %s\n", l.Group.Name, l.Group.Id)
+		fmt.Printf("  Color: Hue: %.1f, Saturation: %.1f%%, Kelvin: %d\n",
-		FprintfWithIndent(&b, indent, "Color: Hue: %.1f, Saturation: %.1f%%, Kelvin: %d\n",
 			*l.Color.H, *l.Color.S, *l.Color.K)
-		FprintfWithIndent(&b, indent, "Brightness: %.1f%%\n", l.Brightness*100)
+		fmt.Printf("  Brightness: %.1f%%\n", l.Brightness*100)
 		if l.Effect != "" {
-			FprintfWithIndent(&b, indent, "Effect: %s\n", l.Effect)
+			fmt.Printf("  Effect: %s\n", l.Effect)
 		}
-		FprintfWithIndent(&b, indent, "Product: %s\n", l.Product.Name)
+		fmt.Printf("  Product: %s\n", l.Product.Name)
-		FprintfWithIndent(&b, indent, "Capabilities: ")
+		fmt.Printf("  Capabilities: ")
-		fmt.Fprintf(&b, "Color: %s, ", YesNo(l.Product.Capabilities.HasColor))
+		fmt.Printf("Color: %s, ", YesNo(l.Product.Capabilities.HasColor))
-		fmt.Fprintf(&b, "Variable Color Temp: %s, ", YesNo(l.Product.Capabilities.HasVariableColorTemp))
+		fmt.Printf("Variable Color Temp: %s, ", YesNo(l.Product.Capabilities.HasVariableColorTemp))
-		fmt.Fprintf(&b, "IR: %s, ", YesNo(l.Product.Capabilities.HasIR))
+		fmt.Printf("IR: %s, ", YesNo(l.Product.Capabilities.HasIR))
-		fmt.Fprintf(&b, "Chain: %s, ", YesNo(l.Product.Capabilities.HasChain))
+		fmt.Printf("Chain: %s, ", YesNo(l.Product.Capabilities.HasChain))
-		fmt.Fprintf(&b, "Multizone: %s, ", YesNo(l.Product.Capabilities.HasMultizone))
+		fmt.Printf("Multizone: %s, ", YesNo(l.Product.Capabilities.HasMultizone))
-		fmt.Fprintf(&b, "Min Kelvin: %.1f, ", l.Product.Capabilities.MinKelvin)
+		fmt.Printf("Min Kelvin: %.1f, ", l.Product.Capabilities.MinKelvin)
-		fmt.Fprintf(&b, "Max Kelvin: %.1f ", l.Product.Capabilities.MaxKelvin)
+		fmt.Printf("Max Kelvin: %.1f ", l.Product.Capabilities.MaxKelvin)
-		fmt.Fprintln(&b)
+		fmt.Println()
 		// List applicable selectors (most to least specific)
-		FprintfWithIndent(&b, indent, "Selectors:\n")
+		fmt.Printf("  Selectors:\n")
-		indent += Tabstop
+		fmt.Printf("    id:%s\n", l.Id)
-		FprintfWithIndent(&b, indent, "id:%s\n", l.Id)
+		fmt.Printf("    label:%s\n", l.Label)
-		FprintfWithIndent(&b, indent, "label:%s\n", l.Label)
+		fmt.Printf("    group_id:%s\n", l.Group.Id)
-		FprintfWithIndent(&b, indent, "group_id:%s\n", l.Group.Id)
+		fmt.Printf("    group:%s\n", l.Group.Name)
-		FprintfWithIndent(&b, indent, "group:%s\n", l.Group.Name)
+		fmt.Printf("    location_id:%s\n", l.Location.Id)
-		FprintfWithIndent(&b, indent, "location_id:%s\n", l.Location.Id)
+		fmt.Printf("    location:%s\n", l.Location.Name)
-		FprintfWithIndent(&b, indent, "location:%s\n", l.Location.Name)
+		fmt.Printf("  Last Seen: %s (%.1fs ago)\n", l.LastSeen, l.SecondsLastSeen)
-		indent -= Tabstop
+		fmt.Println()
-		FprintfWithIndent(&b, indent, "Last Seen: %s (%.1fs ago)\n", l.LastSeen, l.SecondsLastSeen)
-
-		if i < len(lights)-1 {
-			fmt.Fprintln(&b)
-		}
-
-		fmt.Print(b.String())
 	}
 	return ExitSuccess, nil
 }

cmd/toggle.go

@@ -1,52 +1,13 @@
 package lumecmd
 
-import (
+func ToggleCmd(args CmdArgs) (int, error) {
-	"flag"
+	c := args.Client
-	"fmt"
+	duration := args.Flags.Float64("duration")
-)
+	selector := args.Flags.String("selector")
-
-func NewCmdToggle() Command {
-	return Command{
-		Name: "toggle",
-		Func: ToggleCmd,
-		Flags: func() *flag.FlagSet {
-			fs := flag.NewFlagSet("toggle", flag.ExitOnError)
-
-			duration := fs.Float64("duration", defaultDuration, "Set the duration")
-			fs.Float64Var(duration, "d", defaultDuration, "Set the duration")
-
-			selector := fs.String("selector", defaultSelector, "Set the selector")
-			fs.StringVar(selector, "s", defaultSelector, "Set the selector")
-
-			return fs
-		}(),
-		Use:   "[--selector <selector>] [--duration <sec>]",
-		Short: "Toggle the power on/off",
-	}
-}
-
-func ToggleCmd(ctx Context) (int, error) {
-	var p Printer
-
-	c := ctx.Client
-	duration := ctx.Flags.Float64("duration")
-	selector := ctx.Flags.String("selector")
-	format, err := getOutputFormatFromFlags(ctx.Flags)
-	if err != nil {
-		return ExitFailure, err
-	}
-
-	if format == "" && ctx.Config.OutputFormat != "" {
-		format = ctx.Config.OutputFormat
-	}
-
 	r, err := c.Toggle(selector, duration)
 	if err != nil {
 		return ExitFailure, err
 	}
-
+	PrintResults(r.Results)
-	p = NewPrinter(format)
-	fmt.Print(p.Results(r.Results))
-
 	return ExitSuccess, nil
 }

cmd/util.go

@@ -6,10 +6,116 @@ import (
 	"sort"
 	"strconv"
 	"strings"
+	"time"
 
 	"git.kill0.net/chill9/lifx-go"
 )
 
+func powerColor(s string) string {
+	fs := "\033[1;31m%s\033[0m"
+	if s == "on" {
+		fs = "\033[1;32m%s\033[0m"
+	}
+
+	return fmt.Sprintf(fs, s)
+}
+
+func statusColor(s lifx.Status) string {
+	fs := "\033[1;31m%s\033[0m"
+	if s == "ok" {
+		fs = "\033[1;32m%s\033[0m"
+	}
+
+	return fmt.Sprintf(fs, s)
+}
+
+func PrintResults(res []lifx.Result) {
+	var length int
+	var widths map[string]int
+
+	widths = make(map[string]int)
+
+	for _, r := range res {
+		length = len(r.Id)
+		if widths["id"] < length {
+			widths["id"] = length
+		}
+
+		length = len(r.Label)
+		if widths["label"] < length {
+			widths["label"] = length
+		}
+
+		length = len(r.Status)
+		if widths["status"] < length {
+			widths["status"] = length
+		}
+	}
+
+	sortResults(res)
+
+	for _, r := range res {
+		fmt.Printf("%*s %*s %*s\n",
+			widths["id"], r.Id,
+			widths["label"], r.Label,
+			widths["status"], statusColor(r.Status))
+	}
+}
+
+func PrintLights(lights []lifx.Light) {
+	var length int
+	var widths map[string]int
+
+	widths = make(map[string]int)
+
+	for _, l := range lights {
+		length = len(l.Id)
+		if widths["id"] < length {
+			widths["id"] = length
+		}
+
+		length = len(l.Location.Name)
+		if widths["location"] < length {
+			widths["location"] = length
+		}
+
+		length = len(l.Group.Name)
+		if widths["group"] < length {
+			widths["group"] = length
+		}
+
+		length = len(l.Label)
+		if widths["label"] < length {
+			widths["label"] = length
+		}
+
+		length = len(l.LastSeen.Local().Format(time.RFC3339))
+		if widths["last_seen"] < length {
+			widths["last_seen"] = length
+		}
+
+		length = len(l.Power)
+		if widths["power"] < length {
+			widths["power"] = length
+		}
+	}
+
+	sortLights(lights)
+
+	fmt.Printf("total %d\n", len(lights))
+	for _, l := range lights {
+		fmt.Printf(
+			"%*s %*s %*s %*s %*s %-*s\n",
+			widths["id"], l.Id,
+			widths["loction"], l.Location.Name,
+			widths["group"], l.Group.Name,
+			widths["label"], l.Label,
+			widths["last_seen"], l.LastSeen.Local().Format(time.RFC3339),
+			widths["power"], powerColor(l.Power),
+		)
+	}
+}
+
 func parseRGB(s string) (lifx.RGBColor, error) {
 	var c lifx.RGBColor
 	rgb := strings.SplitN(s, ",", 3)
@@ -61,8 +167,6 @@ func YesNo(v bool) string {
 	return "no"
 }
 
-func Debugf(format string, a ...interface{}) {
+func PrintWithIndent(indent int, s string) {
-	if GetConfig().Debug {
+	fmt.Printf("%*s%s", indent, "", s)
-		fmt.Printf(format, a...)
+}
-	}
-}

cmd/validate.go

@@ -1,51 +0,0 @@
-package lumecmd
-
-import (
-	"errors"
-	"flag"
-	"fmt"
-	"strings"
-
-	"git.kill0.net/chill9/lifx-go"
-)
-
-func NewCmdValidate() Command {
-	return Command{
-		Name: "validate",
-		Func: ValidateCmd,
-		Flags: func() *flag.FlagSet {
-			fs := flag.NewFlagSet("validate", flag.ExitOnError)
-
-			return fs
-		}(),
-		Use:   "<command>",
-		Short: "Validate a color string",
-	}
-}
-
-func ValidateCmd(ctx Context) (int, error) {
-	var b strings.Builder
-	c := ctx.Client
-
-	if len(ctx.Args) != 1 {
-		fmt.Print(printCmdHelp(ctx.Name))
-		return ExitFailure, nil
-	}
-
-	color := lifx.NamedColor(ctx.Args[0])
-
-	i, err := c.ValidateColor(color)
-	if err != nil {
-		return ExitFailure, err
-	}
-
-	if validColor, ok := i.(*lifx.HSBKColor); ok {
-		fmt.Fprintln(&b, validColor)
-	} else {
-		return ExitFailure, errors.New("go type %T but wanted *HSBKColor")
-	}
-
-	fmt.Print(b.String())
-
-	return ExitSuccess, nil
-}

cmd/version.go

@@ -1,38 +1,3 @@
 package lumecmd
 
-import (
+const Version = "0.1.0"
-	"fmt"
-	"runtime"
-	"strings"
-)
-
-func NewCmdVersion() Command {
-	return Command{
-		Name:  "version",
-		Func:  VersionCmd,
-		Flags: nil,
-		Use:   "",
-		Short: "Show version",
-	}
-}
-
-func VersionCmd(ctx Context) (int, error) {
-	var b strings.Builder
-
-	fmt.Fprintf(&b, "lume, version %s\n", Version)
-
-	if GitCommit != "" {
-		fmt.Fprintf(&b, "  revision:   %s\n", GitCommit)
-	}
-
-	if BuildDate != "" {
-		fmt.Fprintf(&b, "  build date: %s\n", BuildDate)
-	}
-
-	fmt.Fprintf(&b, "  go version: %s\n", runtime.Version())
-	fmt.Fprintf(&b, "  platform:   %s/%s\n", runtime.GOOS, runtime.GOARCH)
-
-	fmt.Print(b.String())
-
-	return ExitSuccess, nil
-}

go.mod

@@ -3,11 +3,7 @@ module git.kill0.net/chill9/lume
 go 1.15
 
 require (
-	git.kill0.net/chill9/lifx-go v0.0.0-20210418161634-4c1678b62c73
+	git.kill0.net/chill9/lifx-go v0.0.0-20210215004437-f86c28b0a5ef
 	github.com/BurntSushi/toml v0.3.1
-	github.com/fatih/color v1.10.0
+	golang.org/x/sys v0.0.0-20210110051926-789bb1bd4061
-	github.com/mattn/go-runewidth v0.0.10 // indirect
-	github.com/olekukonko/tablewriter v0.0.5
-	github.com/rivo/uniseg v0.2.0 // indirect
-	golang.org/x/sys v0.0.0-20210326220804-49726bf1d181
 )

go.sum

@@ -1,33 +1,6 @@
 git.kill0.net/chill9/lifx-go v0.0.0-20210215004437-f86c28b0a5ef h1:8yyXAk+qiRvrowTeHHAOBZqGXXCr8SxWFydez61ZGp8=
 git.kill0.net/chill9/lifx-go v0.0.0-20210215004437-f86c28b0a5ef/go.mod h1:ZFKIcwdJ4Nqlrkn/eUHbeLt0NVhFsfxBREkVoA+jzUc=
-git.kill0.net/chill9/lifx-go v0.0.0-20210323044657-dbe1c40e1621 h1:koWq2W08HjmvsNm4D8kD0OjMZKCJ/3681P9XFMTj77I=
-git.kill0.net/chill9/lifx-go v0.0.0-20210323044657-dbe1c40e1621/go.mod h1:jInpjEqTBhrFpQKk7zPIWISvgjjfS2djXeKB3yB/8dY=
-git.kill0.net/chill9/lifx-go v0.0.0-20210329222320-2107a0586447 h1:tN+zR5aszesrZRrhS3uOqAIWLcADCIH7GFJ6SOQS9r0=
-git.kill0.net/chill9/lifx-go v0.0.0-20210329222320-2107a0586447/go.mod h1:jInpjEqTBhrFpQKk7zPIWISvgjjfS2djXeKB3yB/8dY=
-git.kill0.net/chill9/lifx-go v0.0.0-20210418161634-4c1678b62c73 h1:fteCAelwAcfam2Q8eeJFyK4+sXGOpR6Me5YMKBi+MYY=
-git.kill0.net/chill9/lifx-go v0.0.0-20210418161634-4c1678b62c73/go.mod h1:jInpjEqTBhrFpQKk7zPIWISvgjjfS2djXeKB3yB/8dY=
 github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/fatih/color v1.10.0 h1:s36xzo75JdqLaaWoiEHk767eHiwo0598uUxyfiPkDsg=
-github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
-github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
-github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
-github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
-github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
-github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
-github.com/mattn/go-runewidth v0.0.10 h1:CoZ3S2P7pvtP45xOtBw+/mDL2z0RKI576gSkzRRpdGg=
-github.com/mattn/go-runewidth v0.0.10/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
-github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
-github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
-github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210110051926-789bb1bd4061 h1:DQmQoKxQWtyybCtX/3dIuDBcAhFszqq8YiNeS6sNu1c=
 golang.org/x/sys v0.0.0-20210110051926-789bb1bd4061/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4 h1:EZ2mChiOa8udjfp6rRmswTbtZN/QzUQp4ptM4rnjHvc=
-golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210326220804-49726bf1d181 h1:64ChN/hjER/taL4YJuA+gpLfIMT+/NFherRZixbxOhg=
-golang.org/x/sys v0.0.0-20210326220804-49726bf1d181/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

lume.1

@@ -1,186 +0,0 @@
-.Dd $Mdocdate$
-
-.Dt lume \&1 "User Commands"
-
-.Sh NAME
-.Nm lume
-.Nd CLI tool for the LIFX HTTP API
-
-.Sh SYNOPSIS
-.Nm lume
-.Ar COMMAND
-.Op Ar OPTIONS ...
-
-.Sh COMMANDS
-.Bl -tag -width Ds
-.It Xo Ic breathe
-.Op Fl s Ar selector | Fl Fl selector Ns = Ns Ar selector
-.Fl c | Fl Fl color
-.Op Fl Fl from-color Ns = Ns Ar color
-.Op Fl Fl cycles Ns = Ns Ar cycles
-.Op Fl Fl peak Ns = Ns Ar peak
-.Op Fl Fl period Ns = Ns Ar period
-.Op Fl Fl persist
-.Op Fl Fl power-on
-.Xc
-.It Xo Ic help
-.Op Ar COMMAND
-.Xc
-Print the help message. If a command is specified, then show the subcommand's help message.
-.It Xo Ic ls
-.Op Fl s Ar selector | Fl Fl selector Ns = Ns Ar selector
-.Op Fl Fl simple | Fl Fl table
-.Xc
-List the lights and their basic state
-.It Xo Ic poweroff
-.Op Fl s Ar selector | Fl Fl selector Ns = Ns Ar selector
-.Op Fl Fl simple | Fl Fl table
-.Op Fl d | Fl Fl duration
-.Xc
-Power off lights
-.It Xo Ic poweron
-.Op Fl s Ar selector | Fl Fl selector Ns = Ns Ar selector
-.Op Fl Fl simple | Fl Fl table
-.Op Fl d | Fl Fl duration
-.Xc
-Power off lights
-.It Xo Ic set-color
-.Op Fl b Ar brightness | Fl Fl brightness Ns = Ns Ar brightness
-.Op Fl d | Fl Fl duration
-.Op Fl f Ar fast | Fl Fl fast Ns = Ns Ar fast
-.Op Fl H Ar hue | Fl Fl hue Ns = Ns Ar hue
-.Op Fl n Ar name | Fl Fl name Ns = Ns Ar name
-.Op Fl p Ar power | Fl Fl power Ns = Ns Ar power
-.Op Fl r Ar rgb | Fl Fl rgb Ns = Ns Ar rgb
-.Op Fl S Ar saturation | Fl Fl saturation Ns = Ns Ar saturation
-.Op Fl s Ar selector | Fl Fl selector Ns = Ns Ar selector
-.Op Fl Fl simple | Fl Fl table
-.Xc
-Set light color
-.It Xo Ic set-state
-.Op Fl b Ar brightness | Fl Fl brightness Ns = Ns Ar brightness
-.Op Fl c | Fl Fl color
-.Op Fl d | Fl Fl duration
-.Op Fl f Ar fast | Fl Fl fast Ns = Ns Ar fast
-.Op Fl i Ar infrared | Fl Fl infrared Ns = Ns Ar infrared
-.Op Fl p Ar power | Fl Fl power Ns = Ns Ar power
-.Op Fl s Ar selector | Fl Fl selector Ns = Ns Ar selector
-.Op Fl Fl simple | Fl Fl table
-.Xc
-Set light properties
-.It Xo Ic set-white
-.Op Fl b Ar brightness | Fl Fl brightness Ns = Ns Ar brightness
-.Op Fl d | Fl Fl duration
-.Op Fl f Ar fast | Fl Fl fast Ns = Ns Ar fast
-.Op Fl i Ar infrared | Fl Fl infrared Ns = Ns Ar infrared
-.Op Fl k Ar kelvin | Fl Fl kelvin Ns = Ns Ar kelvin
-.Op Fl n Ar name | Fl Fl name Ns = Ns Ar name
-.Op Fl p Ar power | Fl Fl power Ns = Ns Ar power
-.Op Fl s Ar selector | Fl Fl selector Ns = Ns Ar selector
-.Op Fl Fl simple | Fl Fl table
-.Xc
-Set light white levels
-.It Xo Ic show
-.Op Fl s Ar selector | Fl Fl selector Ns = Ns Ar selector
-.Xc
-Show extended details about the lights
-.It Xo Ic toggle
-.Op Fl d | Fl Fl duration
-.Op Fl s Ar selector | Fl Fl selector Ns = Ns Ar selector
-.Op Fl Fl simple | Fl Fl table
-.Xc
-Toggle the power
-.It Xo Ic validate
-.Ar color_string
-.Xc
-Validate a color string
-.It Xo Ic version
-.Xc
-Print the version
-.El
-
-.Sh OPTIONS 
-.Bl -tag -width Ds
-.It Fl b , Fl Fl brightness Ns = Ns Ar brightness
-The brightness level from 0.0 to 1.0. Overrides any brightness set in color (if any)
-.It Fl c , Fl Fl color Ns = Ns Ar color
-This color to use for the action.
-.Pp
-When used with the
-.Nm breathe
-effect, this
-is the "to" color.
-.It Fl Fl cycles Ns = Ns Ar cycles
-The number of times to repeat the effect. Defaults to 1.0 cycle.
-.It Fl d , Fl Fl duration Ns = Ns Ar duration
-The time in seconds to spend performing the action. Range: 0.0 – 3155760000.0 (100 years).
-.It Fl f , Fl Fl fast
-Execute the action fast without any state checks or waiting for the result from the HTTP API
-.It Fl Fl from-color Ns = Ns Ar color
-The color to start the
-.Nm breathe
-effect from. If this parameter is omitted
-then the color the bulb is currently set to is used instead.
-.It Fl H , Fl Fl hue Ns = Ns Ar hue
-Sets the hue. Range 0 - 360.
-.It Fl i , Fl Fl infrared Ns = Ns Ar infrared
-Sets the maximum  brightness of the infrared channel from 0.0 to 1.0.
-.It Fl k , Fl Fl kelvin Ns = Ns Ar kelvin
-Set the kelvin value. The saturation is automatically set to 0.
-.It Fl n , Fl Fl name Ns = Ns Ar name
-Set the color using a named color from
-.Pa lumerc
-.It Fl Fl peak Ns = Ns Ar peak
-Defines where in a period the target color is at its maximum. Minimum 0.0,
-maximum 1.0. Defaults to 0.5.
-.It Fl Fl period Ns = Ns Ar period
-The time in seconds for one cycle of the
-.Nm breathe
-effect. Defaults to 1.0
-second.
-.It Fl Fl persist
-If false set the light back to its previous value when effect ends, if true
-leave the last effect color.
-.It Fl p , Fl Fl power Ns = Ns Ar [ on | off ]
-Set the power state
-.It Fl Fl power-on
-If true, turn the bulb on if it is not already on.
-.It Fl r , Fl Fl rgb Ns = Ns Ar R,G,B
-Set the color via a comma delimited R,G,B string. Values range from 0 - 255.
-.It Fl S , Fl Fl saturation Ns = Ns Ar saturation
-Set the saturation. Range 0.0 - 1.0.
-.It Fl s , Fl Fl selector Ns = Ns Ar selector
-The selector is used to group lights together belonging in the same account
-.Pp
-Selectors can be in the following format: all, label:[value], id:[value], group_id:[value], group:[value], location_id:[value], location:[value], scene_id:[value]
-.Pp
-The default selector is "all"
-.Sh FILES
-.Bl -tag -width "~/.config/lume/lume.conf" -compact
-.It Pa ~/.lumerc
-Default
-.Nm
-configuration file
-.It Pa ~/.config/lume/lume.conf
-XDG config home
-.Nm
-configuration file
-.Sh EXAMPLES
-Sample
-.Pa lumerc
-file:
-.Bd -literal -offset indent
-access_token = "token"
-# indicator = "●"
-# output_format = "table"
-
-[colors]
-purple_candy = [ 280.0, 0.29, 0.71 ]
-wasabi = [ 120.0, 1.0, 0.7 ]
-honeydew = [ 120.0, 1.0, 0.97 ]
-green_mist = [ 92.0, 0.72, 0.75 ]
-pea = [ 90.0, 0.42, 0.47 ]
-cat_eye = [ 76.0, 0.74, 0.61 ]
-seagreen = [ 160.0, 1.0, 0.50 ]
-blue_mist = [ 202.0, 0.97, 0.75 ]
-.Ed

lume.code-workspace

@@ -1,12 +0,0 @@
-{
-	"folders": [
-		{
-			"path": "."
-		},
-		{
-			"name": "lifx-go",
-			"path": "..\\lifx-go"
-		}
-	],
-	"settings": {}
-}

packaging/debian/changelog

@@ -1,5 +0,0 @@
-lume (__VERSION__-__REVISION__) unstable; urgency=medium
-
-  * Package generated with make deb
-
- -- Ryan Cavicchioni <ryan@cavi.cc>  __DATE__

packaging/debian/control

@@ -1,14 +0,0 @@
-Source: lume
-Section: unknown
-Priority: optional
-Maintainer: Ryan Cavicchioni <ryan@cavi.cc>
-Build-Depends: debhelper (>= 10)
-Standards-Version: 4.1.2
-Homepage: https://git.kill0.net/chill9/lume
-Vcs-Git: https://git.kill0.net/chill9/lume.git
-Vcs-Browser: https://git.kill0.net/chill9/lume.git
-
-Package: lume
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}
-Description: A CLI tool for the LIFX HTTP API

packaging/debian/copyright

@@ -1,28 +0,0 @@
-Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-Upstream-Name: lume
-Source: https://git.kill0.net/chill9/lume
-
-Files: *
-Copyright: 2021 Ryan Cavicchioni <ryan@cavi.cc>
-License: MPL-2.0
-
-License: MPL-2.0
- Licensed under the Mozilla Public License License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.  You may
- obtain a copy of the License at
- .
- https://www.mozilla.org/en-US/MPL/2.0/
- .
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
- .
- On Debian systems, the complete text of the Mozilla Public License version 2.0
- license can be found in "/usr/share/common-licenses/MPL-2.0".
-
-# Please also look if there are files or directories which have a
-# different copyright/license attached and list them here.
-# Please avoid picking licenses with terms that are more restrictive than the
-# packaged work, as it may make Debian's contributions unacceptable upstream.

packaging/debian/lume.manpages

@@ -1 +0,0 @@
-lume.1

packaging/debian/rules

@@ -1,19 +0,0 @@
-#!/usr/bin/make -f
-
-DISTRIBUTION = $(shell lsb_release -sr)
-VERSION = __VERSION__
-REVISION = __REVISION__
-PACKAGEVERSION = $(VERSION)-$(REVISION)
-
-%:
-	dh $@
-
-override_dh_auto_clean:
-override_dh_auto_test:
-override_dh_auto_build:
-	make
-override_dh_auto_install:
-	make install DESTDIR=debian/lume
-
-override_dh_gencontrol:
-	dh_gencontrol -- -v$(PACKAGEVERSION)

packaging/rpm/lume.spec

@@ -1,33 +0,0 @@
-Name:           lume
-Version:        __VERSION__
-Release:        __REVISION__%{?dist}
-Summary:        A CLI tool for the LIFX HTTP API
-
-License:        MPL
-URL:            https://git.kill0.net/chill9/lume
-Source:         %{name}-%{version}.tar.xz
-
-%global debug_package %{nil}
-
-%description
-
-%prep
-%setup
-
-%build
-%make_build
-
-%install
-%make_install DESTDIR=%{buildroot}
-
-
-%files
-%{_bindir}/lume
-%license LICENSE
-/usr/share/lume/lumerc
-%doc %{_mandir}/man1/lume.1.*
-
-
-%changelog
-* __DATE__ Ryan Cavicchioni <ryan@cavi.cc>
-- lume __VERSION__