huebot 1.1.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 587a390d34c338db6aa2cd4d94944b051cf25f6c77b2db25f86ae996cb76b44a
-  data.tar.gz: 1a0d4d34b73caa8123cf1336e61ebed393b104c9aad82b8245f65d3356bab890
+  metadata.gz: 643b636258939c0eb021d13d9369d845be85a5854ca1f6c38fa66c6556551c68
+  data.tar.gz: e5e1e74fded7ed9d456f8a7ce0c65f8f787a08187eb019413bddaff7bddaca74
 SHA512:
-  metadata.gz: 40d24c93bd23b68ccc914d0bd7834deee41d90faa96be78ce68d10f53ebcf55978b47f06beb569d5ef48d3d7cfb10501672df99a1312931e052a67fea9fb235b
-  data.tar.gz: 3c0e33394c515e02212192229df35bde7d79a36bd20590edb40d89f5f751bccaa3432921413c7ff0762638d3804a1e06aaca3a13c835d006d8aaa3f78c62dd6e
+  metadata.gz: '084232072462be01ec7867aadb43df7b476e4c0b6fe0fcc33b1d10cd23f568b8474d83ed450f0487123ce874c33a729d84bfa9e4cc683a59958e3b5fe7bd64e0'
+  data.tar.gz: 99c1ba63f4ff21161017fe42180ae76c5ee27721e32e7663eb5d09906953ef88886dd7e003f40e783e0ede9e3e5e123fab5635b5e0413085bf5882ebcb386bb8

data/README.md

@@ -1,8 +1,8 @@
 # Huebot
 
-Program your Hue lights!
+Program your Hue lights using YAML or JSON!
 
-    $ huebot run dimmer.yml --light="Office Desk"
+    $ huebot run dimmer.yaml --light="Office Desk"
 
 A few examples are below. [See the Wiki](https://github.com/jhollinger/huebot/wiki) for full documentation.
 
@@ -34,13 +34,15 @@ serial:
               state:
                 bri: 150
                 time: 10 # 10 second transition
-              pause: 2   # 2 second pause before the next step
+              pause:
+                after: 2   # 2 second pause before the next step
 
           - transition:
               state:
                 bri: 254
                 time: 10 # 10 second transition
-              pause: 2   # 2 second pause before the next step
+              pause:
+                after: 2   # 2 second pause before the next step
 
     - transition:
         state:
@@ -64,7 +66,8 @@ serial:
 
     # Run these steps in parallel in an infinite loop
     - parallel:
-        loop: true
+        loop:
+          infinite: true
         steps:
           # Parallel branch 1: Fade inputs #1 and #3 up and down
           - serial:
@@ -77,12 +80,14 @@ serial:
                     state:
                       bri: 254
                       time: 10 # transition over 10 seconds
-                    pause: 5   # pause an extra 5 sec after the transition
+                    pause:
+                      after: 5   # pause an extra 5 sec after the transition
                 - transition:
                     state:
                       bri: 25
                       time: 10
-                    pause: 5
+                    pause:
+                      after: 5
 
           # Parallel branch 2: Fade inputs #2 and #4 down and up
           - serial:
@@ -95,12 +100,14 @@ serial:
                     state:
                       bri: 25
                       time: 10
-                    pause: 5
+                    pause:
+                      after: 5
                 - transition:
                     state:
                       bri: 254
                       time: 10
-                    pause: 5
+                    pause:
+                      after: 5
 ```
 
 [See the Wiki](https://github.com/jhollinger/huebot/wiki) for more documentation and examples.

data/bin/huebot

@@ -1,23 +1,27 @@
 #!/usr/bin/env ruby
 
 # Used for local testing
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib') if ENV["HUEBOT_DEV"] == "1"
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib') if ENV["DEV"] == "1"
 
 require 'huebot'
 
 Huebot::CLI::Helpers.tap { |cli|
   case cli.get_cmd
   when :ls
+    cli.get_args!(num: 0)
+    opts = cli.get_opts!
     bridge, error = Huebot::Bridge.connect
     if error
       $stderr.puts error
       exit 1
     end
-    retval = Huebot::CLI::Runner.ls bridge
+
+    retval = Huebot::CLI::Runner.ls(bridge.lights, bridge.groups, opts)
     exit retval
 
   when :run
-    opts, sources = cli.get_input!
+    opts = cli.get_opts!
+    sources = cli.get_input! opts
     if sources.empty?
       cli.help!
       exit 1
@@ -28,26 +32,35 @@ Huebot::CLI::Helpers.tap { |cli|
       $stderr.puts error
       exit 1
     end
-    retval = Huebot::CLI::Runner.run(bridge, sources, opts)
+
+    retval = Huebot::CLI::Runner.run(sources, bridge.lights, bridge.groups, opts)
     exit retval
 
   when :check
-    opts, sources = cli.get_input!
+    opts = cli.get_opts!
+    sources = cli.get_input! opts
     if sources.empty?
       cli.help!
       exit 1
     end
 
-    bridge, error = Huebot::Bridge.connect
-    if error
-      $stderr.puts error
-      exit 1
-    end
-    retval = Huebot::CLI::Runner.check(bridge, sources, opts)
+    lights, groups =
+      if opts.no_device_check
+        [[], []]
+      else
+        bridge, error = Huebot::Bridge.connect
+        if error
+          $stderr.puts error
+          exit 1
+        end
+        [bridge.lights, bridge.groups]
+      end
+
+    retval = Huebot::CLI::Runner.check(sources, lights, groups, opts)
     exit retval
 
   when :"get-state"
-    opts, _sources = cli.get_input!
+    opts = cli.get_opts!
     if opts.inputs.empty?
       cli.help!
       exit 1
@@ -58,22 +71,29 @@ Huebot::CLI::Helpers.tap { |cli|
       $stderr.puts error
       exit 1
     end
-    retval = Huebot::CLI::Runner.get_state(bridge, opts.inputs)
+
+    retval = Huebot::CLI::Runner.get_state(bridge.lights, bridge.groups, opts)
     exit retval
 
   when :"set-ip"
-    ip = cli.get_args(num: 1).first
-    retval = Huebot::CLI::Runner.set_ip ip
+    opts = cli.get_opts!
+    ip = cli.get_args!(num: 1).first
+    config = Huebot::CLI::Config.new
+    retval = Huebot::CLI::Runner.set_ip config, ip, opts
     exit retval
 
   when :"clear-ip"
-    cli.get_args(num: 0)
-    retval = Huebot::CLI::Runner.unregister
+    opts = cli.get_opts!
+    cli.get_args!(num: 0)
+    config = Huebot::CLI::Config.new
+    retval = Huebot::CLI::Runner.clear_ip config, opts
     exit retval
 
   when :unregister
-    cli.get_args(num: 0)
-    retval = Huebot::CLI::Runner.unregister
+    opts = cli.get_opts!
+    cli.get_args!(num: 0)
+    config = Huebot::CLI::Config.new
+    retval = Huebot::CLI::Runner.unregister config, opts
     exit retval
 
   else cli.help!

data/lib/huebot/bot.rb

@@ -1,56 +1,67 @@
 module Huebot
+  # The Huebot runtime
   class Bot
     Error = Class.new(StandardError)
 
-    def initialize(device_mapper)
+    def initialize(device_mapper, waiter: nil, logger: nil)
       @device_mapper = device_mapper
-      #@client = device_mapper.bridge.client
+      @logger = logger || Logging::NullLogger.new
+      @waiter = waiter || Waiter
     end
 
     def execute(program)
+      @logger.log :start, {program: program.name}
       exec program.data
+      @logger.log :stop, {program: program.name}
     end
 
     private
 
     def exec(node)
-      i = node.instruction
-      case i
+      case node.instruction
       when Program::AST::Transition
-        transition i.state, i.devices, i.sleep
+        transition node.instruction
       when Program::AST::SerialControl
-        serial node.children, i.loop, i.sleep
+        serial node.children, node.instruction
       when Program::AST::ParallelControl
-        parallel node.children, i.loop, i.sleep
+        parallel node.children, node.instruction
       else
-        raise Error, "Unexpected instruction '#{i.class.name}'"
+        raise Error, "Unexpected instruction '#{node.instruction.class.name}'"
       end
     end
 
-    def transition(state, device_refs, sleep_time = nil)
-      time = (state["transitiontime"] || 4).to_f / 10
-      devices = map_devices device_refs
+    def transition(i)
+      time = (i.state["transitiontime"] || 4).to_f / 10
+      devices = map_devices i.devices
+      @logger.log :transition, {devices: devices.map(&:name)}
+
+      wait i.pause.pre if i.pause&.pre
       devices.map { |device|
         Thread.new {
           # TODO error handling
-          device.set_state state
-          wait time
+          _res = device.set_state i.state
+          @logger.log :set_state, {device: device.name, state: i.state, result: nil}
+          wait time if i.wait
         }
       }.map(&:join)
-      wait sleep_time if sleep_time
+      wait i.pause.post if i.pause&.post
     end
 
-    def serial(nodes, lp, sleep_time = nil)
-      control_loop(lp) {
-        nodes.map { |node|
+    def serial(nodes, i)
+      wait i.pause.pre if i.pause&.pre
+      control_loop(i.loop) { |loop_type|
+        @logger.log :serial, {loop: loop_type}
+        nodes.each { |node|
           exec node
         }
       }
-      wait sleep_time if sleep_time
+      wait i.pause.post if i.pause&.post
     end
 
-    def parallel(nodes, lp, sleep_time = nil)
-      control_loop(lp) {
+    def parallel(nodes, i)
+      wait i.pause.pre if i.pause&.pre
+      control_loop(i.loop) { |loop_type|
+        @logger.log :parallel, {loop: loop_type}
         nodes.map { |node|
           Thread.new {
             # TODO error handling
@@ -58,25 +69,37 @@ module Huebot
           }
         }.map(&:join)
       }
-      wait sleep_time if sleep_time
+      wait i.pause.post if i.pause&.post
     end
 
     def control_loop(lp)
       case lp
       when Program::AST::InfiniteLoop
-        loop { yield }
+        loop {
+          wait lp.pause.pre if lp.pause&.pre
+          yield :infinite
+          wait lp.pause.post if lp.pause&.post
+        }
       when Program::AST::CountedLoop
-        lp.n.times { yield }
+        lp.n.times {
+          wait lp.pause.pre if lp.pause&.pre
+          yield :counted
+          wait lp.pause.post if lp.pause&.post
+        }
       when Program::AST::DeadlineLoop
         until Time.now >= lp.stop_time
-          yield
+          wait lp.pause.pre if lp.pause&.pre
+          yield :deadline
+          wait lp.pause.post if lp.pause&.post
         end
       when Program::AST::TimerLoop
         sec = ((lp.hours * 60) + lp.minutes) * 60
         time = 0
         until time >= sec
           start = Time.now
-          yield
+          wait lp.pause.pre if lp.pause&.pre
+          yield :timer
+          wait lp.pause.post if lp.pause&.post
           time += (Time.now - start).round
         end
       else
@@ -102,8 +125,14 @@ module Huebot
     end
 
     def wait(seconds)
-      # TODO sleep in small bursts in a loop so can detect if an Interrupt was caught
-      sleep seconds
+      @logger.log :pause, {time: seconds}
+      @waiter.call seconds
+    end
+
+    module Waiter
+      def self.call(seconds)
+        sleep seconds
+      end
     end
   end
 end

data/lib/huebot/bridge.rb

@@ -1,24 +1,21 @@
 module Huebot
   class Bridge
-    def self.connect(config = Huebot::Config.new)
-      client = Client.new(config)
+    def self.connect(client = Client.new)
       error = client.connect
       return nil, error if error
       return new(client)
     end
 
-    attr_reader :client
-
     def initialize(client)
       @client = client
     end
 
     def lights
-      client.get!("/lights").map { |(id, attrs)| Light.new(client, id, attrs) }
+      @client.get!("/lights").map { |(id, attrs)| Light.new(@client, id, attrs) }
     end
 
     def groups
-      client.get!("/groups").map { |(id, attrs)| Group.new(client, id, attrs) }
+      @client.get!("/groups").map { |(id, attrs)| Group.new(@client, id, attrs) }
     end
   end
 end

data/lib/huebot/{cli.rb → cli/cli.rb}

@@ -8,8 +8,9 @@ module Huebot
     #
     # @attr inputs [Array<String>]
     #
-    Options = Struct.new(:inputs, :read_stdin)
+    Options = Struct.new(:inputs, :read_stdin, :debug, :no_device_check, :stdin, :stdout, :stderr, :bot_waiter)
 
+    autoload :Config, 'huebot/cli/config'
     autoload :Helpers, 'huebot/cli/helpers'
     autoload :Runner, 'huebot/cli/runner'
   end

data/lib/huebot/cli/config.rb

@@ -0,0 +1,47 @@
+require 'fileutils'
+require 'yaml'
+
+module Huebot
+  module CLI
+    class Config
+      def initialize(path = "~/.config/huebot")
+        @path = File.expand_path(path)
+        @dir = File.dirname(@path)
+        @dir_exists = File.exist? @dir
+        reload
+      end
+
+      def [](attr)
+        @config[attr.to_s]
+      end
+
+      def []=(attr, val)
+        if val.nil?
+          @config.delete(attr.to_s)
+        else
+          @config[attr.to_s] = val
+        end
+        write
+      end
+
+      def clear
+        @config.clear
+        write
+      end
+
+      def reload
+        @config = File.exist?(@path) ? YAML.load_file(@path) : {}
+      end
+
+      private
+
+      def write
+        unless @dir_exists
+          FileUtils.mkdir_p @dir
+          @dir_exists = true
+        end
+        File.write(@path, YAML.dump(@config))
+      end
+    end
+  end
+end

data/lib/huebot/cli/helpers.rb

@@ -1,73 +1,91 @@
 require 'optparse'
 require 'yaml'
+require 'json'
 
 module Huebot
   module CLI
     module Helpers
+      DEFAULT_API_VERSION = 1.1
+
       #
       # Returns the command given to huebot.
       #
       # @return [Symbol]
       #
-      def self.get_cmd
-        ARGV[0].to_s.to_sym
+      def self.get_cmd(argv = ARGV)
+        argv[0].to_s.to_sym
       end
 
-      def self.get_args(min: nil, max: nil, num: nil)
-        args = ARGV[1..]
+      def self.get_args!(argv = ARGV, min: nil, max: nil, num: nil)
+        args, error = get_args(argv, min: min, max: max, num: num)
+        if error
+          $stderr.puts error
+          exit 1
+        end
+        args
+      end
+
+      def self.get_args(argv = ARGV, min: nil, max: nil, num: nil)
+        args = argv[1..]
         if num
           if num != args.size
-            $stderr.puts "Expected #{num} args, found #{args.size}"
-            exit 1
+            return nil, "Expected #{num} args, found #{args.size}"
           end
         elsif min and max
           if args.size < min or args.size > max
-            $stderr.puts "Expected #{min}-#{max} args, found #{args.size}"
+            return nil, "Expected #{min}-#{max} args, found #{args.size}"
           end
         elsif min
           if args.size < min
-            $stderr.puts "Expected at least #{num} args, found #{args.size}"
-            exit 1
+            return nil, "Expected at least #{min} args, found #{args.size}"
           end
         elsif max
           if args.size > max
-            $stderr.puts "Expected no more than #{num} args, found #{args.size}"
-            exit 1
+            return nil, "Expected no more than #{max} args, found #{args.size}"
           end
         end
-        args
+        return args, nil
       end
 
       #
       # Parses and returns input from the CLI. Serious errors might result in the program exiting.
       #
-      # @return [Huebot::CLI::Options] All given CLI options
+      # @param opts [Huebot::CLI::Options] All given CLI options
       # @return [Array<Huebot::Program::Src>] Array of given program sources
       #
-      def self.get_input!
-        options, parser = option_parser
-        parser.parse!
-
-        files = ARGV[1..-1]
+      def self.get_input!(opts, argv = ARGV)
+        files = argv[1..-1]
         if (bad_paths = files.select { |p| !File.exist? p }).any?
-          $stderr.puts "Cannot find #{bad_paths.join ', '}"
-          exit 1
+          opts.stderr.puts "Cannot find #{bad_paths.join ', '}"
+          return []
         end
 
         sources = files.map { |path|
-          src = YAML.load_file(path)
-          version = (src.delete("version") || 1.0).to_f
+          ext = File.extname path
+          src =
+            case ext
+            when ".yaml", ".yml"
+              YAML.safe_load(File.read path) || {}
+            when ".json"
+              JSON.load(File.read path) || {}
+            else
+              opts.stderr.puts "Unknown file extension '#{ext}'. Expected .yaml, .yml, or .json"
+              return []
+            end
+          version = (src.delete("version") || DEFAULT_API_VERSION).to_f
           Program::Src.new(src, path, version)
         }
 
-        if !$stdin.isatty or options.read_stdin
-          puts "Please enter your YAML Huebot program below, followed by Ctrl+d:" if options.read_stdin
-          src = YAML.load($stdin.read)
-          puts "Executing..." if options.read_stdin
-          version = (src.delete("version") || 1.0).to_f
+        if !opts.stdin.isatty or opts.read_stdin
+          opts.stdout.puts "Please enter your YAML or JSON Huebot program below, followed by Ctrl+d:" if opts.read_stdin
+          raw = opts.stdin.read.lstrip
+          src = raw[0] == "{" ? JSON.load(raw) : YAML.safe_load(raw)
+
+          opts.stdout.puts "Executing..." if opts.read_stdin
+          version = (src.delete("version") || DEFAULT_API_VERSION).to_f
           sources << Program::Src.new(src, "STDIN", version)
         end
-        return options, sources
+        sources
       end
 
       #
@@ -95,27 +113,35 @@ module Huebot
 
         all_lights = programs.reduce([]) { |acc, p| acc + p.light_names }
         if (missing_lights = device_mapper.missing_lights all_lights).any?
-          print_messages! io, "Unknown lights", missing_lights
+          print_messages! io, "Unknown lights", missing_lights unless quiet
         end
 
         all_groups = programs.reduce([]) { |acc, p| acc + p.group_names }
         if (missing_groups = device_mapper.missing_groups all_groups).any?
-          print_messages! io, "Unknown groups", missing_groups
+          print_messages! io, "Unknown groups", missing_groups unless quiet
         end
 
         all_vars = programs.reduce([]) { |acc, p| acc + p.device_refs }
         if (missing_vars = device_mapper.missing_vars all_vars).any?
-          print_messages! io, "Unknown device inputs", missing_vars.map { |d| "$#{d}" }
+          print_messages! io, "Unknown device inputs", missing_vars.map { |d| "$#{d}" } unless quiet
         end
 
         invalid_devices = missing_lights.size + missing_groups.size + missing_vars.size
         return invalid_progs.any?, imperfect_progs.any?, invalid_devices > 0
       end
 
+      def self.get_opts!
+        opts = default_options
+        parser = option_parser opts
+        parser.parse!
+        opts
+      end
+
       # Print help and exit
       def self.help!
-        _, parser = option_parser
-        puts parser.help
+        opts = default_options
+        parser = option_parser opts
+        opts.stdout.puts parser.help
         exit 1
       end
 
@@ -135,15 +161,14 @@ module Huebot
         }
       end
 
-      def self.option_parser
-        options = Options.new([], false)
-        parser = OptionParser.new { |opts|
+      def self.option_parser(options)
+        OptionParser.new { |opts|
           opts.banner = %(
   List all lights and groups:
       huebot ls
 
   Run program(s):
-      huebot run prog1.yaml [prog2.yaml [prog3.yaml ...]] [options]
+      huebot run prog1.yaml [prog2.yml [prog3.json ...]] [options]
 
   Run program from STDIN:
       cat prog1.yaml | huebot run [options]
@@ -168,9 +193,18 @@ module Huebot
           opts.on("-lLIGHT", "--light=LIGHT", "Light ID or name") { |l| options.inputs << Light::Input.new(l) }
           opts.on("-gGROUP", "--group=GROUP", "Group ID or name") { |g| options.inputs << Group::Input.new(g) }
           opts.on("-i", "Read program from STDIN") { options.read_stdin = true }
-          opts.on("-h", "--help", "Prints this help") { puts opts; exit }
+          opts.on("--debug", "Print debug info during run") { options.debug = true }
+          opts.on("--no-device-check", "Don't validate devices against the Bridge ('check' cmd only)") { options.no_device_check = true }
+          opts.on("-h", "--help", "Prints this help") { options.stdout.puts opts; exit }
         }
-        return options, parser
+      end
+
+      def self.default_options
+        options = Options.new([], false)
+        options.stdin = $stdin
+        options.stdout = $stdout
+        options.stderr = $stderr
+        options
       end
     end
   end

data/lib/huebot/cli/runner.rb

@@ -1,76 +1,84 @@
 module Huebot
   module CLI
     module Runner
-      def self.ls(bridge)
-        puts "Lights\n" + bridge.lights.map { |l| "  #{l.id}: #{l.name}" }.join("\n") + \
-          "\nGroups\n" + bridge.groups.map { |g| "  #{g.id}: #{g.name}" }.join("\n")
+      def self.ls(lights, groups, opts)
+        opts.stdout.puts "Lights\n" + lights.map { |l| "  #{l.id}: #{l.name}" }.join("\n") + \
+          "\nGroups\n" + groups.map { |g| "  #{g.id}: #{g.name}" }.join("\n")
         return 0
       rescue ::Huebot::Error => e
-        $stderr.puts "#{e.class.name}: #{e.message}"
+        opts.stderr.puts "#{e.class.name}: #{e.message}"
         return 1
       end
 
-      def self.run(bridge, sources, opts)
-        device_mapper = Huebot::DeviceMapper.new(bridge, opts.inputs)
+      def self.run(sources, lights, groups, opts)
         programs = sources.map { |src|
           Huebot::Compiler.build src
         }
-        found_errors, _found_warnings, missing_devices = Helpers.check! programs, device_mapper, $stderr
+        device_mapper = Huebot::DeviceMapper.new(lights: lights, groups: groups, inputs: opts.inputs)
+        found_errors, _found_warnings, missing_devices = Helpers.check! programs, device_mapper, opts.stderr
         return 1 if found_errors || missing_devices
 
-        bot = Huebot::Bot.new(device_mapper)
+        logger = opts.debug ? Logging::IOLogger.new(opts.stdout) : nil
+        bot = Huebot::Bot.new(device_mapper, logger: logger, waiter: opts.bot_waiter)
         programs.each { |prog| bot.execute prog }
         return 0
       rescue ::Huebot::Error => e
-        $stderr.puts "#{e.class.name}: #{e.message}"
+        opts.stderr.puts "#{e.class.name}: #{e.message}"
         return 1
       end
 
-      def self.check(bridge, sources, opts)
-        device_mapper = Huebot::DeviceMapper.new(bridge, opts.inputs)
+      def self.check(sources, lights, groups, opts)
         programs = sources.map { |src|
           Huebot::Compiler.build src
         }
-        found_errors, found_warnings, missing_devices = Helpers.check! programs, device_mapper, $stdout
+
+        # Assume all devices and inputs are correct
+        if opts.no_device_check
+          light_input_names = opts.inputs.select { |i| i.is_a? Light::Input }.map(&:val)
+          lights = programs.reduce(light_input_names) { |acc, p| acc + p.light_names }.uniq.each_with_index.map { |name, i| Light.new(nil, i+1, {"name" => name}) }
+
+          group_input_names = opts.inputs.select { |i| i.is_a? Group::Input }.map(&:val)
+          groups = programs.reduce(group_input_names) { |acc, p| acc + p.group_names }.uniq.each_with_index.map { |name, i| Group.new(nil, i+1, {"name" => name}) }
+        end
+
+        device_mapper = Huebot::DeviceMapper.new(lights: lights, groups: groups, inputs: opts.inputs)
+        found_errors, found_warnings, missing_devices = Helpers.check! programs, device_mapper, opts.stderr
         return (found_errors || found_warnings || missing_devices) ? 1 : 0
       rescue ::Huebot::Error => e
-        $stderr.puts "#{e.class.name}: #{e.message}"
+        opts.stderr.puts "#{e.class.name}: #{e.message}"
         return 1
       end
 
-      def self.get_state(bridge, inputs)
-        device_mapper = Huebot::DeviceMapper.new(bridge, inputs)
+      def self.get_state(lights, groups, opts)
+        device_mapper = Huebot::DeviceMapper.new(lights: lights, groups: groups, inputs: opts.inputs)
         device_mapper.each do |device|
-          puts device.name
-          puts "  #{device.get_state}"
+          opts.stdout.puts device.name
+          opts.stdout.puts "  #{device.get_state}"
         end
         0
       end
 
-      def self.set_ip
-        config = Huebot::Config.new
+      def self.set_ip(config, ip, opts)
         config["ip"] = ip
         0
       rescue ::Huebot::Error => e
-        $stderr.puts "#{e.class.name}: #{e.message}"
+        opts.stderr.puts "#{e.class.name}: #{e.message}"
         return 1
       end
 
-      def self.clear_ip
-        config = Huebot::Config.new
+      def self.clear_ip(config, opts)
         config["ip"] = nil
         0
       rescue ::Huebot::Error => e
-        $stderr.puts "#{e.class.name}: #{e.message}"
+        opts.stderr.puts "#{e.class.name}: #{e.message}"
         return 1
       end
 
-      def self.unregister
-        config = Huebot::Config.new
+      def self.unregister(config, opts)
         config.clear
         0
       rescue ::Huebot::Error => e
-        $stderr.puts "#{e.class.name}: #{e.message}"
+        opts.stderr.puts "#{e.class.name}: #{e.message}"
         return 1
       end
     end

data/lib/huebot/client.rb

@@ -10,7 +10,7 @@ module Huebot
 
     attr_reader :config
 
-    def initialize(config = Huebot::Config.new)
+    def initialize(config = Huebot::CLI::Config.new)
       @config = config
       @ip = config["ip"] # NOTE will usually be null
       @username = nil

data/lib/huebot/compiler/api_v1.rb

@@ -51,45 +51,61 @@ module Huebot
       end
 
       def build_transition(t, errors, warnings, inherited_devices = nil)
+        if t.nil?
+          errors << "'transition' may not be blank"
+          t = {}
+        end
+
         state = build_state(t, errors, warnings)
         devices = build_devices(t, errors, warnings, inherited_devices)
-        slp = build_sleep(t, errors, warnings)
+        pause = build_pause(t, errors, warnings)
+        wait = @api_version >= 1.1 ? build_wait(t, errors, warnings) : true
 
         errors << "'transition' requires devices" if devices.empty?
         errors << "Unknown keys in 'transition': #{t.keys.join ", "}" if t.keys.any?
 
-        instruction = Program::AST::Transition.new(state, devices, slp)
+        instruction = Program::AST::Transition.new(state, devices, wait, pause)
         return instruction, []
       end
 
       def build_serial(t, errors, warnings, inherited_devices = nil)
+        if t.nil?
+          errors << "'serial' may not be blank"
+          t = {}
+        end
+
         lp = build_loop(t, errors, warnings)
-        slp = build_sleep(t, errors, warnings)
+        pause = build_pause(t, errors, warnings)
         devices = build_devices(t, errors, warnings, inherited_devices)
         children = build_steps(t, errors, warnings, devices)
 
         errors << "'serial' requires steps" if children.empty?
         errors << "Unknown keys in 'serial': #{t.keys.join ", "}" if t.keys.any?
 
-        instruction = Program::AST::SerialControl.new(lp, slp)
+        instruction = Program::AST::SerialControl.new(lp, pause)
         return instruction, children
       end
 
       def build_parallel(t, errors, warnings, inherited_devices = nil)
+        if t.nil?
+          errors << "'parallel' may not be blank"
+          t = {}
+        end
+
         lp = build_loop(t, errors, warnings)
-        slp = build_sleep(t, errors, warnings)
+        pause = build_pause(t, errors, warnings)
         devices = build_devices(t, errors, warnings, inherited_devices)
         children = build_steps(t, errors, warnings, devices)
 
         errors << "'parallel' requires steps" if children.empty?
         errors << "Unknown keys in 'parallel': #{t.keys.join ", "}" if t.keys.any?
 
-        instruction = Program::AST::ParallelControl.new(lp, slp)
+        instruction = Program::AST::ParallelControl.new(lp, pause)
         return instruction, children
       end
 
       def map_state_keys(state, errors, warnings)
-        # bugfix to YAML
+        # bugfix to YAML - it parses the "on" key as a Boolean
         case state.delete true
         when true
           state["on"] = true
@@ -167,9 +183,7 @@ module Huebot
         loop_val = t.delete "loop"
         case loop_val
         when Hash
-          pause = loop_val.delete "pause"
-          errors << "'loop.pause' must be an integer. Found '#{pause.class.name}'" if pause and !pause.is_a? Integer
-
+          pause = build_pause(loop_val, errors, warnings)
           lp =
             case loop_val.keys
             when INFINITE_KEYS
@@ -216,11 +230,19 @@ module Huebot
         Program::AST::DeadlineLoop.new(stop_time)
       end
 
-      def build_sleep(t, errors, warnings)
-        sleep_val = t.delete "pause"
-        case sleep_val
+      def build_pause(t, errors, warnings)
+        case @api_version
+        when 1.0 then build_pause_1_0(t, errors, warnings)
+        when 1.1 then build_pause_1_1(t, errors, warnings)
+        else raise Error, "Unknown api version '#{@api_version}'"
+        end
+      end
+
+      def build_pause_1_0(t, errors, warnings)
+        pause_val = t.delete "pause"
+        case pause_val
         when Integer, Float
-          sleep_val
+          Program::AST::Pause.new(nil, pause_val)
         when nil
           nil
         else
@@ -229,6 +251,39 @@ module Huebot
         end
       end
 
+      def build_pause_1_1(t, errors, warnings)
+        pause_val = t.delete "pause"
+        case pause_val
+        when Integer, Float
+          Program::AST::Pause.new(nil, pause_val)
+        when Hash
+          pre = pause_val.delete "before"
+          post = pause_val.delete "after"
+          errors << "'pause.before' must be an integer or float" unless pre.nil? or pre.is_a? Integer or pre.is_a? Float
+          errors << "'pause.after' must be an integer or float" unless post.nil? or post.is_a? Integer or post.is_a? Float
+          errors << "Unknown keys in 'pause': #{pause_val.keys.join ", "}" if pause_val.keys.any?
+          Program::AST::Pause.new(pre, post)
+        when nil
+          nil
+        else
+          errors << "'pause' must be an integer or float"
+          nil
+        end
+      end
+
+      def build_wait(t, errors, warnings)
+        wait = t.delete "wait"
+        case wait
+        when true, false
+          wait
+        when nil
+          true
+        else
+          errors << "'transition.wait' must be true or false"
+          true
+        end
+      end
+
       def build_devices(t, errors, warnings, inherited_devices = nil)
         devices_ref = t.delete("devices") || {}
         return inherited_devices if devices_ref.empty? and inherited_devices

data/lib/huebot/{compiler.rb → compiler/compiler.rb}

@@ -13,7 +13,7 @@ module Huebot
     def self.build(src)
       compiler_class =
         case src.api_version
-        when 1.0 then ApiV1
+        when 1.0, 1.1 then ApiV1
         else raise Error, "Unknown API version '#{src.api_version}'"
         end
       compiler = compiler_class.new(src.api_version)

data/lib/huebot/device_mapper.rb

@@ -2,20 +2,18 @@ module Huebot
   class DeviceMapper
     Unmapped = Class.new(Error)
 
-    def initialize(bridge, inputs = [])
-      all_lights, all_groups = bridge.lights, bridge.groups
-
-      @lights_by_id = all_lights.reduce({}) { |a, l| a[l.id] = l; a }
-      @lights_by_name = all_lights.reduce({}) { |a, l| a[l.name] = l; a }
-      @groups_by_id = all_groups.reduce({}) { |a, g| a[g.id] = g; a }
-      @groups_by_name = all_groups.reduce({}) { |a, g| a[g.name] = g; a }
+    def initialize(lights: [], groups:[], inputs: [])
+      @lights_by_id = lights.each_with_object({}) { |l, a| a[l.id] = l }
+      @lights_by_name = lights.each_with_object({}) { |l, a| a[l.name] = l }
+      @groups_by_id = groups.each_with_object({}) { |g, a| a[g.id] = g }
+      @groups_by_name = groups.each_with_object({}) { |g, a| a[g.name] = g }
       @devices_by_var = inputs.each_with_index.each_with_object({}) { |(x, idx), obj|
         obj[idx + 1] =
           case x
           when Light::Input then @lights_by_id[x.val.to_i] || @lights_by_name[x.val]
           when Group::Input then @groups_by_id[x.val.to_i] || @groups_by_name[x.val]
           else raise Error, "Invalid input: #{x}"
-          end || raise(Unmapped, "Could not find #{x.class.name[8..-6].downcase} with id or name '#{x.val}'")
+          end || raise(Unmapped, "Could not find #{x.class.name[8..-8].downcase} with id or name '#{x.val}'")
       }
       @all = @devices_by_var.values
     end

data/lib/huebot/group.rb

@@ -14,7 +14,6 @@ module Huebot
       @client = client
       @id = id.to_i
       @name = attrs.fetch("name")
-      @attrs = attrs
     end
 
     private

data/lib/huebot/light.rb

@@ -14,7 +14,6 @@ module Huebot
       @client = client
       @id = id.to_i
       @name = attrs.fetch("name")
-      @attrs = attrs
     end
 
     private

data/lib/huebot/logging/collecting_logger.rb

@@ -0,0 +1,20 @@
+module Huebot
+  module Logging
+    class CollectingLogger
+      attr_reader :events
+
+      def initialize
+        @events = []
+        @mut = Mutex.new
+      end
+
+      def log(event_type, data = {})
+        now = Time.now
+        @mut.synchronize {
+          @events << [now, event_type, data]
+        }
+        self
+      end
+    end
+  end
+end

data/lib/huebot/logging/io_logger.rb

@@ -0,0 +1,19 @@
+require 'json'
+
+module Huebot
+  module Logging
+    class IOLogger
+      def initialize(io)
+        @io = io
+        @mut = Mutex.new
+      end
+
+      def log(event_type, data = {})
+        ts = Time.now.iso8601
+        @mut.synchronize {
+          @io.puts "#{ts} #{event_type} #{data.to_json}"
+        }
+      end
+    end
+  end
+end

data/lib/huebot/logging/logging.rb

@@ -0,0 +1,7 @@
+module Huebot
+  module Logging
+    autoload :NullLogger, 'huebot/logging/null_logger'
+    autoload :CollectingLogger, 'huebot/logging/collecting_logger'
+    autoload :IOLogger, 'huebot/logging/io_logger'
+  end
+end

data/lib/huebot/logging/null_logger.rb

@@ -0,0 +1,9 @@
+module Huebot
+  module Logging
+    class NullLogger
+      def log(_event_type, _data = {})
+        self
+      end
+    end
+  end
+end

data/lib/huebot/program.rb

@@ -16,15 +16,16 @@ module Huebot
     module AST
       Node = Struct.new(:instruction, :children, :errors, :warnings)
 
-      Transition = Struct.new(:state, :devices, :sleep)
-      SerialControl = Struct.new(:loop, :sleep)
-      ParallelControl = Struct.new(:loop, :sleep)
+      Transition = Struct.new(:state, :devices, :wait, :pause)
+      SerialControl = Struct.new(:loop, :pause)
+      ParallelControl = Struct.new(:loop, :pause)
 
       InfiniteLoop = Struct.new(:pause)
       CountedLoop = Struct.new(:n, :pause)
       TimerLoop = Struct.new(:hours, :minutes, :pause)
       DeadlineLoop = Struct.new(:stop_time, :pause)
 
+      Pause = Struct.new(:pre, :post)
       DeviceRef = Struct.new(:ref)
       Light = Struct.new(:name)
       Group = Struct.new(:name)

data/lib/huebot/version.rb

@@ -1,4 +1,4 @@
 module Huebot
   # Gem version
-  VERSION = '1.1.0'
+  VERSION = '1.3.0'
 end

data/lib/huebot.rb

@@ -1,16 +1,16 @@
 module Huebot
   Error = Class.new(StandardError)
 
-  autoload :Config, 'huebot/config'
   autoload :Client, 'huebot/client'
-  autoload :CLI, 'huebot/cli'
+  autoload :CLI, 'huebot/cli/cli'
   autoload :Bridge, 'huebot/bridge'
   autoload :DeviceState, 'huebot/device_state'
   autoload :Light, 'huebot/light'
   autoload :Group, 'huebot/group'
   autoload :DeviceMapper, 'huebot/device_mapper'
   autoload :Program, 'huebot/program'
-  autoload :Compiler, 'huebot/compiler'
+  autoload :Compiler, 'huebot/compiler/compiler'
   autoload :Bot, 'huebot/bot'
+  autoload :Logging, 'huebot/logging/logging'
   autoload :VERSION, 'huebot/version'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: huebot
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Jordan Hollinger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-19 00:00:00.000000000 Z
+date: 2023-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -50,17 +50,21 @@ files:
 - lib/huebot.rb
 - lib/huebot/bot.rb
 - lib/huebot/bridge.rb
-- lib/huebot/cli.rb
+- lib/huebot/cli/cli.rb
+- lib/huebot/cli/config.rb
 - lib/huebot/cli/helpers.rb
 - lib/huebot/cli/runner.rb
 - lib/huebot/client.rb
-- lib/huebot/compiler.rb
 - lib/huebot/compiler/api_v1.rb
-- lib/huebot/config.rb
+- lib/huebot/compiler/compiler.rb
 - lib/huebot/device_mapper.rb
 - lib/huebot/device_state.rb
 - lib/huebot/group.rb
 - lib/huebot/light.rb
+- lib/huebot/logging/collecting_logger.rb
+- lib/huebot/logging/io_logger.rb
+- lib/huebot/logging/logging.rb
+- lib/huebot/logging/null_logger.rb
 - lib/huebot/program.rb
 - lib/huebot/version.rb
 homepage: https://github.com/jhollinger/huebot

data/lib/huebot/config.rb

@@ -1,41 +0,0 @@
-require 'fileutils'
-require 'yaml'
-
-module Huebot
-  class Config
-    def initialize(path = "~/.config/huebot")
-      @path = File.expand_path(path)
-      @dir = File.dirname(@path)
-      @dir_exists = File.exist? @dir
-      @config = File.exist?(@path) ? YAML.load_file(@path) : {}
-    end
-
-    def [](attr)
-      @config[attr.to_s]
-    end
-
-    def []=(attr, val)
-      if val.nil?
-        @config.delete(attr.to_s)
-      else
-        @config[attr.to_s] = val
-      end
-      write
-    end
-
-    def clear
-      @config.clear
-      write
-    end
-
-    private
-
-    def write
-      unless @dir_exists
-        FileUtils.mkdir_p @dir
-        @dir_exists = true
-      end
-      File.write(@path, YAML.dump(@config))
-    end
-  end
-end