huebot 1.2.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7febcd2a42112b4c3636581d9419a58c490a1157637e143fd46e6e7d94aefba5
-  data.tar.gz: d4a9ab3178d381786595f14a14899e55af7789b4650cfa2da1928b83b5fe2135
+  metadata.gz: 2fd718fb625c5f417b31619579459bdfcaffac98276d9981882df7d9b1e192b9
+  data.tar.gz: 213fb99651e6826283d4c0be21c26e9442f146ea2df1734a2acb5c53f0e6eafa
 SHA512:
-  metadata.gz: 15150d4cd9652f7d5e2518bd714de8155f1b574054360f61c0ac383c30f6fe81e3421f0bf64f0da43f090dabd2677b71609ae0a1e4f3741524adcdd631bd1116
-  data.tar.gz: 548d5adc4af710d2b1c9719e54fad7aa5fe5ba18749845089d0cb66fb59b4fd5e8279acc4214e961757c9956bad0b79ed8dacf4e531e3f54097322ce44a6b4bb
+  metadata.gz: caa7f46fb1d7ac5954f7b1e8f8b48c81b69c3cea59c7ce0ad246eb6ecafda318bd161eec1aff2a41e7e8f6a84af4d2a18a555f56dab808e97b39ff3396b91d9c
+  data.tar.gz: 2221b64eb67ab257232358e52657446cb3b8c95d7f102220954ee71e9a85bc1447ec1566712b651bd1a0d5c4db8be2eff82097551302186cd092688ad0df5548

data/README.md

@@ -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:
@@ -78,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:
@@ -96,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/lib/huebot/bot.rb

@@ -18,47 +18,49 @@ module Huebot
     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
-          _res = device.set_state state
-          @logger.log :set_state, {device: device.name, state: state, result: nil}
-          wait time
+          _res = device.set_state i.state
+          @logger.log :set_state, {device: device.name, state: i.state, result: nil}
+          wait Program::AST::Num.new(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) { |loop_type|
+    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) { |loop_type|
+    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 {
@@ -67,33 +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 {
+          wait lp.pause.pre if lp.pause&.pre
           yield :infinite
-          wait lp.pause if lp.pause
+          wait lp.pause.post if lp.pause&.post
         }
       when Program::AST::CountedLoop
-        lp.n.times {
+        number(lp.n).round.times {
+          wait lp.pause.pre if lp.pause&.pre
           yield :counted
-          wait lp.pause if lp.pause
+          wait lp.pause.post if lp.pause&.post
         }
       when Program::AST::DeadlineLoop
         until Time.now >= lp.stop_time
+          wait lp.pause.pre if lp.pause&.pre
           yield :deadline
-          wait lp.pause if lp.pause
+          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
+          wait lp.pause.pre if lp.pause&.pre
           yield :timer
-          wait lp.pause if lp.pause
+          wait lp.pause.post if lp.pause&.post
           time += (Time.now - start).round
         end
       else
@@ -118,11 +124,23 @@ module Huebot
       }
     end
 
-    def wait(seconds)
+    def wait(n)
+      seconds = number n
       @logger.log :pause, {time: seconds}
       @waiter.call seconds
     end
 
+    def number(n)
+      case n
+      when Program::AST::Num
+        n.n
+      when Program::AST::RandomNum
+        rand(n.min..n.max)
+      else
+        raise Error, "Unknown numeric type. Expected Program::AST::Num, Program::AST::NRandomNum, found: #{n.class.name}"
+      end
+    end
+
     module Waiter
       def self.call(seconds)
         sleep seconds

data/lib/huebot/cli/helpers.rb

@@ -5,6 +5,8 @@ require 'json'
 module Huebot
   module CLI
     module Helpers
+      DEFAULT_API_VERSION = 1.2
+
       #
       # Returns the command given to huebot.
       #
@@ -70,7 +72,7 @@ module Huebot
               opts.stderr.puts "Unknown file extension '#{ext}'. Expected .yaml, .yml, or .json"
               return []
             end
-          version = (src.delete("version") || 1.0).to_f
+          version = (src.delete("version") || DEFAULT_API_VERSION).to_f
           Program::Src.new(src, path, version)
         }
 
@@ -80,7 +82,7 @@ module Huebot
           src = raw[0] == "{" ? JSON.load(raw) : YAML.safe_load(raw)
 
           opts.stdout.puts "Executing..." if opts.read_stdin
-          version = (src.delete("version") || 1.0).to_f
+          version = (src.delete("version") || DEFAULT_API_VERSION).to_f
           sources << Program::Src.new(src, "STDIN", version)
         end
         sources

data/lib/huebot/cli/runner.rb

@@ -8,6 +8,8 @@ module Huebot
       rescue ::Huebot::Error => e
         opts.stderr.puts "#{e.class.name}: #{e.message}"
         return 1
+      rescue Interrupt
+        return 130
       end
 
       def self.run(sources, lights, groups, opts)
@@ -25,6 +27,8 @@ module Huebot
       rescue ::Huebot::Error => e
         opts.stderr.puts "#{e.class.name}: #{e.message}"
         return 1
+      rescue Interrupt
+        return 130
       end
 
       def self.check(sources, lights, groups, opts)
@@ -47,6 +51,8 @@ module Huebot
       rescue ::Huebot::Error => e
         opts.stderr.puts "#{e.class.name}: #{e.message}"
         return 1
+      rescue Interrupt
+        return 130
       end
 
       def self.get_state(lights, groups, opts)
@@ -56,6 +62,8 @@ module Huebot
           opts.stdout.puts "  #{device.get_state}"
         end
         0
+      rescue Interrupt
+        return 130
       end
 
       def self.set_ip(config, ip, opts)
@@ -64,6 +72,8 @@ module Huebot
       rescue ::Huebot::Error => e
         opts.stderr.puts "#{e.class.name}: #{e.message}"
         return 1
+      rescue Interrupt
+        return 130
       end
 
       def self.clear_ip(config, opts)
@@ -72,6 +82,8 @@ module Huebot
       rescue ::Huebot::Error => e
         opts.stderr.puts "#{e.class.name}: #{e.message}"
         return 1
+      rescue Interrupt
+        return 130
       end
 
       def self.unregister(config, opts)
@@ -80,6 +92,8 @@ module Huebot
       rescue ::Huebot::Error => e
         opts.stderr.puts "#{e.class.name}: #{e.message}"
         return 1
+      rescue Interrupt
+        return 130
       end
     end
   end

data/lib/huebot/compiler/api_v1.rb

@@ -10,6 +10,8 @@ module Huebot
       PARALLEL_KEYS = ["parallel"].freeze
       INFINITE_KEYS = ["infinite"].freeze
       COUNT_KEYS = ["count"].freeze
+      RANDOM_KEYS = ["random"].freeze
+      MIN_MAX = ["min", "max"].freeze
       TIMER_KEYS = ["timer"].freeze
       DEADLINE_KEYS = ["until"].freeze
       HHMM = /\A[0-9]{2}:[0-9]{2}\Z/.freeze
@@ -51,40 +53,56 @@ 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
 
@@ -167,32 +185,58 @@ 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
-              loop_val["infinite"] == true ? Program::AST::InfiniteLoop.new : Program::AST::CountedLoop.new(1)
+              loop_val.fetch("infinite") == true ? Program::AST::InfiniteLoop.new : Program::AST::CountedLoop.new(Program::AST::Num.new(1))
             when COUNT_KEYS
-              num = loop_val["count"]
+              num = loop_val.fetch("count")
               errors << "'loop.count' must be an integer. Found '#{num.class.name}'" unless num.is_a? Integer
-              Program::AST::CountedLoop.new(num)
+              Program::AST::CountedLoop.new(Program::AST::Num.new(num))
+            when RANDOM_KEYS
+              n = build_random loop_val, errors, warnings
+              Program::AST::CountedLoop.new(n)
             when TIMER_KEYS
-              build_timer_loop loop_val["timer"], errors, warnings
+              build_timer_loop loop_val.fetch("timer"), errors, warnings
             when DEADLINE_KEYS
-              build_deadline_loop loop_val["until"], errors, warnings
+              build_deadline_loop loop_val.fetch("until"), errors, warnings
             else
               errors << "'loop' must contain exactly one of: 'infinite', 'count', 'timer', or 'until', and optionally 'pause'. Found: #{loop_val.keys.join ", "}"
-              Program::AST::CountedLoop.new(1)
+              Program::AST::CountedLoop.new(Program::AST::Num.new(1))
             end
           lp.pause = pause
           lp
         when nil
-          Program::AST::CountedLoop.new(1)
+          Program::AST::CountedLoop.new(Program::AST::Num.new(1))
         else
           errors << "'loop' must be an object. Found '#{loop_val.class.name}'"
-          Program::AST::CountedLoop.new(1)
+          Program::AST::CountedLoop.new(Program::AST::Num.new(1))
+        end
+      end
+
+      def build_random(t, errors, warnings)
+        random = t.delete("random") || {}
+        min = build_random_n(random, "min", errors, warnings)
+        max = build_random_n(random, "max", errors, warnings)
+        errors << "'random.max' must be greater than 'random.min'" unless max > min
+        errors << "Unknown keys in 'random': #{random.keys.join ", "}" if random.keys.any?
+        Program::AST::RandomNum.new(min, max)
+      end
+
+      def build_random_n(t, name, errors, warnings)
+        n = t.delete name
+        case n
+        when Integer, Float
+          if n >= 0
+            n
+          else
+            errors << "'random.#{name}' must be >= 0, found #{n}"
+            0
+          end
+        else
+          errors << "'random.#{name}' must be an integer or float > 0, found #{n.class.name}"
+          0
         end
       end
 
@@ -216,11 +260,20 @@ 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)
+        when 1.2 then build_pause_1_2(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, Program::AST::Num.new(pause_val))
         when nil
           nil
         else
@@ -229,6 +282,86 @@ 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, Program::AST::Num.new(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?
+          pre = Program::AST::Num.new(pre) if pre
+          post = Program::AST::Num.new(post) if post
+          Program::AST::Pause.new(pre, post)
+        when nil
+          nil
+        else
+          errors << "'pause' must be an integer or float, or an object with 'before' and/or 'after'"
+          nil
+        end
+      end
+
+      def build_pause_1_2(t, errors, warnings)
+        pause_val = t.delete "pause"
+        case pause_val
+        when Integer, Float
+          Program::AST::Pause.new(nil, Program::AST::Num.new(pause_val))
+        when Hash
+          pre = build_pause_part(pause_val, "before", errors, warnings)
+          post = build_pause_part(pause_val, "after", errors, warnings)
+          errors << "'pause' requires one or both of 'before' or 'after'" if pre.nil? and post.nil?
+          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, or an object with 'before' and/or 'after'"
+          nil
+        end
+      end
+
+      def build_pause_part(t, part, errors, warnings)
+        val = t.delete part
+        case val
+        when nil
+          nil
+        when Integer, Float
+          Program::AST::Num.new(val)
+        when Hash
+          if @api_version < 1.2
+            errors << "Unknown 'pause.#{part}' type (#{val.class.name})"
+            return Program::AST::Num.new(1)
+          end
+
+          case val.keys
+          when RANDOM_KEYS
+            build_random val, errors, warnings
+          else
+            errors << "Expected 'pause.#{part}' to contain 'random', found #{val.keys.join ", "}"
+            Program::AST::Num.new(1)
+          end
+        else
+          errors << "Unknown 'pause.#{part}' type (#{val.class.name})"
+          Program::AST::Num.new(1)
+        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/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, 1.2 then ApiV1
         else raise Error, "Unknown API version '#{src.api_version}'"
         end
       compiler = compiler_class.new(src.api_version)

data/lib/huebot/program.rb

@@ -16,15 +16,18 @@ 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)
+      Num = Struct.new(:n)
+      RandomNum = Struct.new(:min, :max)
       DeviceRef = Struct.new(:ref)
       Light = Struct.new(:name)
       Group = Struct.new(:name)
@@ -55,14 +58,14 @@ module Huebot
     end
 
     def errors(node = data)
-      node.children.reduce(node.errors) { |errors, child|
-        errors + child.errors
+      node.children.reduce(node.errors) { |acc, child|
+        acc + errors(child)
       }
     end
 
     def warnings(node = data)
-      node.children.reduce(node.warnings) { |warnings, child|
-        warnings + child.warnings
+      node.children.reduce(node.warnings) { |acc, child|
+        acc + warnings(child)
       }
     end
 

data/lib/huebot/version.rb

@@ -1,4 +1,4 @@
 module Huebot
   # Gem version
-  VERSION = '1.2.0'
+  VERSION = '1.4.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: huebot
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Jordan Hollinger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-21 00:00:00.000000000 Z
+date: 2023-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest