huebot 0.4.0 → 1.0.0

data/lib/huebot/cli.rb

@@ -1,7 +1,3 @@
-require 'optparse'
-require 'ostruct'
-require 'yaml'
-
 module Huebot
   #
   # Helpers for running huebot in cli-mode.
@@ -14,108 +10,7 @@ module Huebot
     #
     Options = Struct.new(:inputs, :read_stdin)
 
-    #
-    # Returns the command given to huebot.
-    #
-    # @return [Symbol]
-    #
-    def self.get_cmd
-      ARGV[0].to_s.to_sym
-    end
-
-    #
-    # Parses and returns input from the CLI. Serious errors might result in the program exiting.
-    #
-    # @return [Huebot::CLI::Options] All given CLI options
-    # @return [Array<Huebot::ProgramSrc>] Array of given program sources
-    #
-    def self.get_input!
-      options, parser = option_parser
-      parser.parse!
-
-      files = ARGV[1..-1]
-      if files.empty? and !options.read_stdin
-        puts parser.help
-        exit 1
-      elsif (bad_paths = files.select { |p| !File.exists? p }).any?
-        $stderr.puts "Cannot find #{bad_paths.join ', '}"
-        exit 1
-      else
-        sources = files.map { |path|
-          ProgramSrc.new(YAML.load_file(path), path)
-        }
-        sources << ProgramSrc.new(YAML.load($stdin.read), "STDIN") if options.read_stdin
-        return options, sources
-      end
-    end
-
-    #
-    # Prints any program errors or warnings, and returns a boolean for each.
-    #
-    # @param programs [Array<Huebot::Program>]
-    # @param io [IO] Usually $stdout or $stderr
-    # @param quiet [Boolean] if true, don't print anything
-    #
-    def self.check!(programs, io, quiet: false)
-      if (invalid_progs = programs.select { |prog| prog.errors.any? }).any?
-        print_messages! io, "Errors", invalid_progs, :errors unless quiet
-      end
-
-      if (imperfect_progs = programs.select { |prog| prog.warnings.any? }).any?
-        puts "" if invalid_progs.any?
-        print_messages! io, "Warnings", imperfect_progs, :warnings unless quiet
-      end
-
-      return invalid_progs.any?, imperfect_progs.any?
-    end
-
-    # Print help and exit
-    def self.help!
-      _, parser = option_parser
-      puts parser.help
-      exit 1
-    end
-
-    private
-
-    #
-    # Print each message (of the given type) for each program.
-    #
-    # @param io [IO] Usually $stdout or $stderr
-    # @param label [String] Top-level for this group of messages
-    # @param progs [Array<Huebot::CLI::Program>]
-    # @param msg_type [Symbol] name of method that holds the messages (i.e. :errors or :warnings)
-    #
-    def self.print_messages!(io, label, progs, msg_type)
-      io.puts "#{label}:"
-      progs.each { |prog|
-        io.puts "  #{prog.name}:"
-        prog.send(msg_type).each_with_index { |msg, i| io.puts "    #{i+1}. #{msg}" }
-      }
-    end
-
-    def self.option_parser
-      options = Options.new([], false)
-      parser = OptionParser.new { |opts|
-        opts.banner = %(
-List all lights and groups:
-    huebot ls
-
-Run program(s):
-    huebot run file1.yml [file2.yml [file3.yml ...]] [options]
-
-Validate programs and inputs:
-    huebot check file1.yml [file2.yml [file3.yml ...]] [options]
-
-Options:
-        ).strip
-        opts.on("-lLIGHT", "--light=LIGHT", "Light ID or name") { |l| options.inputs << LightInput.new(l) }
-        opts.on("-gGROUP", "--group=GROUP", "Group ID or name") { |g| options.inputs << GroupInput.new(g) }
-        opts.on("--all", "All lights and groups TODO") { $stderr.puts "Not Implemented"; exit 1 }
-        opts.on("-i", "Read program from STDIN") { options.read_stdin = true }
-        opts.on("-h", "--help", "Prints this help") { puts opts; exit }
-      }
-      return options, parser
-    end
+    autoload :Helpers, 'huebot/cli/helpers'
+    autoload :Runner, 'huebot/cli/runner'
   end
 end

data/lib/huebot/client.rb

@@ -0,0 +1,132 @@
+require 'uri'
+require 'net/http'
+require 'json'
+
+module Huebot
+  class Client
+    DISCOVERY_URI = URI(ENV["HUE_DISCOVERY_API"] || "https://discovery.meethue.com/")
+    Bridge = Struct.new(:id, :ip)
+    Error = Class.new(Error)
+
+    attr_reader :config
+
+    def initialize(config = Huebot::Config.new)
+      @config = config
+      @ip = config["ip"] # NOTE will usually be null
+      @username = nil
+    end
+
+    def connect
+      if config["ip"]
+        @ip = config["ip"]
+      elsif config["id"]
+        @ip = bridges.detect { |b| b.id == id }&.ip
+        return "Unable to find Hue Bridge '#{config["id"]}' on your network" if @ip.nil?
+      else
+        bridge = bridges.first
+        return "Unable to find a Hue Bridge on your network" if bridge.nil?
+        config["id"] = bridge.id
+        @ip = bridge.ip
+      end
+
+      if config["username"]
+        if valid_username? config["username"]
+          @username = config["username"]
+        else
+          return "Invalid Hue Bridge username '#{config["username"]}'"
+        end
+      else
+        username, error = register
+        return error if error
+        config["username"] = @username = username
+      end
+      nil
+    end
+
+    def get!(path)
+      resp, error = get path
+      raise Error, error if error
+      resp
+    end
+
+    def get(path)
+      url = "http://#{@ip}/api"
+      url << "/#{@username}" if @username
+      url << path
+      req = Net::HTTP::Get.new(URI(url))
+      req_json req
+    end
+
+    def post!(path, body)
+      resp, error = post path, body
+      raise Error, error if error
+      resp
+    end
+
+    def post(path, body)
+      url = "http://#{@ip}/api"
+      url << "/#{@username}" if @username
+      url << path
+      req = Net::HTTP::Post.new(URI(url))
+      req["Content-Type"] = "application/json"
+      req.body = body.to_json
+      req_json req
+    end
+
+    def put!(path, body)
+      resp, error = put path, body
+      raise Error, error if error
+      resp
+    end
+
+    def put(path, body)
+      url = "http://#{@ip}/api"
+      url << "/#{@username}" if @username
+      url << path
+      req = Net::HTTP::Put.new(URI(url))
+      req["Content-Type"] = "application/json"
+      req.body = body.to_json
+      req_json req
+    end
+
+    def req_json(req)
+      resp = Net::HTTP.start req.uri.host, req.uri.port, {use_ssl: false} do |http|
+        http.request req
+      end
+      case resp.code.to_i
+      when 200..201
+        data = JSON.parse(resp.body)
+        if data[0] and (error = data[0]["error"])
+          return nil, error.fetch("description")
+        else
+          return data, nil
+        end
+      else
+        raise Error, "Unexpected response from Bridge (#{resp.code}): #{resp.body}"
+      end
+    end
+
+    def bridges
+      req = Net::HTTP::Get.new(DISCOVERY_URI)
+      resp = Net::HTTP.start req.uri.host, req.uri.port, {use_ssl: true} do |http|
+        http.request req
+      end
+      JSON.parse(resp.body).map { |x|
+        Bridge.new(x.fetch("id"), x.fetch("internalipaddress"))
+      }
+    end
+
+    private
+
+    def valid_username?(username)
+      _resp, error = get("/#{username}")
+      !error
+    end
+
+    def register
+      resp, error = post "/", {"devicetype": "huebot"}
+      return nil, error if error
+      resp[0].fetch("success").fetch("username")
+    end
+  end
+end

data/lib/huebot/compiler/api_v1.rb

@@ -0,0 +1,285 @@
+require 'date'
+require 'time'
+
+module Huebot
+  module Compiler
+    class ApiV1
+      DEVICE_REF = /\A\$([1-9][0-9]*)\Z/.freeze
+      TRANSITION_KEYS = ["transition"].freeze
+      SERIAL_KEYS = ["serial"].freeze
+      PARALLEL_KEYS = ["parallel"].freeze
+      INFINITE_KEYS = ["infinite"].freeze
+      COUNT_KEYS = ["count"].freeze
+      TIMER_KEYS = ["timer"].freeze
+      DEADLINE_KEYS = ["until"].freeze
+      HHMM = /\A[0-9]{2}:[0-9]{2}\Z/.freeze
+
+      def initialize(api_version)
+        @api_version = api_version
+      end
+
+      # @return [Huebot::Program]
+      def build(tokens, default_name = nil)
+        prog = Program.new
+        prog.name = tokens.delete("name") || default_name
+        prog.api_version = @api_version
+        prog.data = node tokens.dup
+        prog
+      end
+
+      private
+
+      def node(t, inherited_devices = nil)
+        errors, warnings = [], []
+        instruction, child_nodes =
+          case t.keys
+          when TRANSITION_KEYS
+            build_transition t.fetch("transition"), errors, warnings, inherited_devices
+          when SERIAL_KEYS
+            build_serial t.fetch("serial"), errors, warnings, inherited_devices
+          when PARALLEL_KEYS
+            build_parallel t.fetch("parallel"), errors, warnings, inherited_devices
+          else
+            errors << "Expected exactly one of: transition, serial, parallel. Found #{t.keys}"
+            [Program::AST::NoOp.new, []]
+          end
+        Program::AST::Node.new(instruction, child_nodes, errors, warnings)
+      end
+
+      def build_transition(t, errors, warnings, inherited_devices = nil)
+        state = build_state(t, errors, warnings)
+        devices = build_devices(t, errors, warnings, inherited_devices)
+        slp = build_sleep(t, errors, warnings)
+
+        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)
+        return instruction, []
+      end
+
+      def build_serial(t, errors, warnings, inherited_devices = nil)
+        lp = build_loop(t, errors, warnings)
+        slp = build_sleep(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)
+        return instruction, children
+      end
+
+      def build_parallel(t, errors, warnings, inherited_devices = nil)
+        lp = build_loop(t, errors, warnings)
+        slp = build_sleep(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)
+        return instruction, children
+      end
+
+      def map_state_keys(state, errors, warnings)
+        # bugfix to YAML
+        case state.delete true
+        when true
+          state["on"] = true
+        when false
+          state["on"] = false
+        end
+
+        time = state.delete "time"
+        case time
+        when Integer, Float
+          state["transitiontime"] = (time.to_f * 10).round(0)
+        when nil
+          # pass
+        else
+          errors << "'transition.state.time' must be a number"
+        end
+
+        ctk = state.delete "ctk"
+        case ctk
+        when 2000..6530
+          state["ct"] = (1_000_000 / ctk).round # https://en.wikipedia.org/wiki/Mired
+        when nil
+          # pass
+        else
+          errors << "'transition.state.ctk' must be an integer between 2700 and 6530"
+        end
+
+        state
+      end
+
+      def build_state(t, errors, warnings)
+        state = t.delete "state"
+        case state
+        when Hash
+          map_state_keys state, errors, warnings
+        when nil
+          errors << "'state' is required in a transition"
+          {}
+        else
+          errors << "Expected 'state' to be an object, got a #{state.class.name}"
+          {}
+        end
+      end
+
+      def build_steps(t, errors, warnings, inherited_devices = nil)
+        steps_val = t.delete "steps"
+        case steps_val
+        when Array
+          steps_val.map { |s| node s, inherited_devices }
+        when nil
+          errors << "Missing 'steps'"
+          []
+        else
+          errors << "'steps' should be an array but is a #{steps_val.class.name}"
+          []
+        end
+      end
+
+      def build_loop(t, errors, warnings)
+        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
+
+          lp =
+            case loop_val.keys
+            when INFINITE_KEYS
+              loop_val["infinite"] == true ? Program::AST::InfiniteLoop.new : Program::AST::CountedLoop.new(1)
+            when COUNT_KEYS
+              num = loop_val["count"]
+              errors << "'loop.count' must be an integer. Found '#{num.class.name}'" unless num.is_a? Integer
+              Program::AST::CountedLoop.new(num)
+            when TIMER_KEYS
+              build_timer_loop loop_val["timer"], errors, warnings
+            when DEADLINE_KEYS
+              build_deadline_loop loop_val["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)
+            end
+          lp.pause = pause
+          lp
+        when nil
+          Program::AST::CountedLoop.new(1)
+        else
+          errors << "'loop' must be an object. Found '#{loop_val.class.name}'"
+          Program::AST::CountedLoop.new(1)
+        end
+      end
+
+      def build_timer_loop(t, errors, warnings)
+        hours = t.delete "hours"
+        minutes = t.delete "minutes"
+
+        errors << "'loop.hours' must be an integer" if hours and !hours.is_a? Integer
+        errors << "'loop.minutes' must be an integer" if minutes and !minutes.is_a? Integer
+        errors << "Unknown keys in 'loop.timer': #{t.keys.join ", "}" if t.keys.any?
+
+        Program::AST::TimerLoop.new(hours || 0, minutes || 0)
+      end
+
+      def build_deadline_loop(t, errors, warnings)
+        date = t.delete "date"
+        time = t.delete "time"
+        errors << "Unknown keys in 'loop.until': #{t.keys.join ", "}" if t.keys.any?
+
+        stop_time = build_stop_time(date, time, errors, warnings)
+        Program::AST::DeadlineLoop.new(stop_time)
+      end
+
+      def build_sleep(t, errors, warnings)
+        sleep_val = t.delete "pause"
+        case sleep_val
+        when Integer, Float
+          sleep_val
+        when nil
+          nil
+        else
+          errors << "'pause' must be an integer or float"
+          nil
+        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
+
+        refs_val, lights_val, groups_val = devices_ref.delete("inputs"), devices_ref.delete("lights"), devices_ref.delete("groups")
+        lights = lights_val ? device_names(Program::AST::Light, "lights", lights_val, errors, warnings) : []
+        groups = groups_val ? device_names(Program::AST::Group, "groups", groups_val, errors, warnings) : []
+        refs =
+          case refs_val
+          when "$all"
+            [Program::AST::DeviceRef.new(:all)]
+          when nil
+            []
+          when Array
+            if refs_val.all? { |ref| ref.is_a?(String) && ref =~ DEVICE_REF }
+              refs_val.map { |ref|
+                n = ref.match(DEVICE_REF).captures[0].to_i
+                Program::AST::DeviceRef.new(n)
+              }
+            else
+              errors << "If 'inputs' is an array, it must be an array of input variables (e.g. [$1, $2, ...])"
+              []
+            end
+          else
+            errors << "'inputs' must be '$all' or an array of input variables (e.g. [$1, $2, ...])"
+            []
+          end
+
+        errors << "Unknown keys in 'devices': #{devices_ref.keys.join ", "}" if devices_ref.keys.any?
+        lights + groups + refs
+      end
+
+      def device_names(type, key, val, errors, warnings)
+        if val.is_a?(Array) and val.all? { |name| name.is_a? String }
+          val.map { |name| type.new(name) }
+        else
+          errors << "'#{key}' must be an array of names (found #{val.class.name})"
+          []
+        end
+      end
+
+      def build_stop_time(date_val, time_val, errors, warnings)
+        now = Time.now
+        d =
+          begin
+            date_val ? Date.iso8601(date_val) : now.to_date
+          rescue Date::Error
+            errors << "Invalid date '#{date_val}'. Use \"YYYY-MM-DD\" format."
+            Date.today
+          end
+
+        hrs, min =
+          if time_val.nil?
+            [now.hour, now.min]
+          elsif time_val.is_a?(String) and time_val =~ HHMM
+            time_val.split(":", 2).map(&:to_i)
+          else
+            errors << "Invalid time '#{time_val}'. Use \"HH:MM\" format."
+            [0, 0]
+          end
+
+        begin
+          t = Time.new(d.year, d.month, d.day, hrs, min, 0, now.utc_offset)
+          warnings << "Time (#{t.iso8601}) is already in the past" if t < now
+          t
+        rescue ArgumentError
+          errors << "Invalid datetime (year=#{d.year} month=#{d.month} day=#{d.day} hrs=#{hrs} min=#{min} sec=0 offset=#{now.utc_offset})"
+          now
+        end
+      end
+    end
+  end
+end

data/lib/huebot/compiler.rb

@@ -1,159 +1,23 @@
 module Huebot
-  class Compiler
-    def initialize(device_mapper)
-      @device_mapper = device_mapper
-    end
+  module Compiler
+    Error = Class.new(Error)
+
+    autoload :ApiV1, 'huebot/compiler/api_v1'
 
     #
     # Build a huebot program from an intermediate representation (a Hash).
     #
-    # @param ir [Hash]
-    # @param default_name [String] A name to use if one isn't specified
+    # @param src [Huebot::Program::Src]
     # @return [Huebot::Program]
     #
-    def build(ir, default_name = nil)
-      ir = ir.clone
-      prog = Huebot::Program.new
-      prog.name = ir.delete("name") || default_name
-
-      # loop/loops
-      val_loop = ir.delete("loop") || ir.delete(:loop)
-      prog.errors << "'loop' must be 'true' or 'false'." if !val_loop.nil? and ![true, false].include?(val_loop)
-      prog.loop = val_loop == true
-
-      val_loops = ir.delete("loops") || ir.delete(:loops)
-      prog.errors << "'loops' must be a positive integer." if !val_loops.nil? and val_loops.to_i < 0
-      prog.loops = val_loops.to_i
-
-      prog.errors << "'loop' and 'loops' are mutually exclusive." if prog.loop? and prog.loops > 0
-
-      # initial state
-      if (val_init = ir.delete("initial") || ir.delete(:initial))
-        errors, warnings, state = build_transition val_init
-        prog.initial_state = state
-        prog.errors += errors
-        prog.warnings += warnings
-      end
-
-      # transitions
-      if (val_trns = ir.delete("transitions") || ir.delete(:transitions))
-        val_trns.each do |val_trn|
-          errors, warnings, state = if val_trn["parallel"] || val_trn[:parallel]
-                                      build_parallel_transition val_trn
-                                    else
-                                      build_transition val_trn
-                                    end
-          prog.transitions << state
-          prog.errors += errors
-          prog.warnings += warnings
-        end
-      end
-
-      # final state
-      if (val_fnl = ir.delete("final") || ir.delete(:final))
-        errors, warnings, state = build_transition val_fnl
-        prog.final_state = state
-        prog.errors += errors
-        prog.warnings += warnings
-      end
-
-      # be strict about extra crap
-      if (unknown = ir.keys.map(&:to_s)).any?
-        prog.errors << "Unrecognized values: #{unknown.join ', '}."
-      end
-
-      # Add any warnings
-      prog.warnings << "'final' is defined but will never be reached because 'loop' is 'true'." if prog.final_state and prog.loop?
-
-      prog
-    end
-
-    private
-
-    def build_parallel_transition(t)
-      errors, warnings = [], []
-      transition = Huebot::Program::ParallelTransition.new(0, [])
-
-      transition.wait = t.delete("wait") || t.delete(:wait)
-      errors << "'wait' must be a positive integer." if transition.wait and transition.wait.to_i <= 0
-
-      parallel = t.delete("parallel") || t.delete(:parallel)
-      if !parallel.is_a? Array
-        errors << "'parallel' must be an array of transitions"
-      else
-        parallel.each do |sub_t|
-          sub_errors, sub_warnings, sub_transition = build_transition(sub_t)
-          errors += sub_errors
-          warnings += sub_warnings
-          transition.children << sub_transition
+    def self.build(src)
+      compiler_class =
+        case src.api_version
+        when 1.0 then ApiV1
+        else raise Error, "Unknown API version '#{src.api_version}'"
         end
-      end
-
-      return errors, warnings, transition
-    end
-
-    def build_transition(t)
-      errors, warnings = [], []
-      transition = Huebot::Program::Transition.new
-      transition.devices = []
-
-      map_devices(t, :light, :lights, :light!) { |map_errors, devices|
-        errors += map_errors
-        transition.devices += devices
-      }
-
-      map_devices(t, :group, :groups, :group!) { |map_errors, devices|
-        errors += map_errors
-        transition.devices += devices
-      }
-
-      map_devices(t, :device, :devices, :var!) { |map_errors, devices|
-        errors += map_errors
-        transition.devices += devices
-      }
-      errors << "Missing light/lights, group/groups, or device/devices" if transition.devices.empty?
-
-      transition.wait = t.delete("wait") || t.delete(:wait)
-      errors << "'wait' must be a positive integer." if transition.wait and transition.wait.to_i <= 0
-
-      state = {}
-      switch = t.delete("switch")
-      switch = t.delete(:switch) if switch.nil?
-      if !switch.nil?
-        state[:on] = case switch
-                     when true, :on then true
-                     when false, :off then false
-                     else
-                       errors << "Unrecognized 'switch' value '#{switch}'."
-                       nil
-                     end
-      end
-      state[:transitiontime] = t.delete("time") || t.delete(:time) || t.delete("transitiontime") || t.delete(:transitiontime) || 4
-
-      transition.state = t.merge(state).reduce({}) { |a, (key, val)|
-        a[key.to_sym] = val
-        a
-      }
-      return errors, warnings, transition
-    end
-
-    private
-
-    def map_devices(t, singular_key, plural_key, ref_type)
-      errors, devices = [], []
-
-      key = t[singular_key.to_s] || t[singular_key]
-      keys = t[plural_key.to_s] || t[plural_key]
-
-      (Array(key) + Array(keys)).each { |x|
-        begin
-          devices += Array(@device_mapper.send(ref_type, x))
-        rescue Huebot::DeviceMapper::Unmapped => e
-          errors << e.message
-        end
-      }
-
-      yield errors, devices
+      compiler = compiler_class.new(src.api_version)
+      compiler.build(src.tokens, src.default_name)
     end
   end
 end