hue-lib 0.5.0 → 0.6.0

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+*.gem

data/README.md

@@ -1,7 +1,8 @@
-RubyHue
+hue-lib
 ================
 
-This is a very early attempt to create a Ruby library for controlling the [Philips Hue](http://www.meethue.com) lighting system. The API has not yet been released, but there are [several](http://www.nerdblog.com/2012/10/a-day-with-philips-hue.html) [people](http://rsmck.co.uk/hue) working to figure it out.
+This is a Ruby library for controlling the [Philips Hue](http://www.meethue.com) lighting system. 
+The API has not yet been released, but there are [several](http://www.nerdblog.com/2012/10/a-day-with-philips-hue.html) [people](http://rsmck.co.uk/hue) working to figure it out.
 
 # WARNING
 All of this is very experimental and could permanently damage your awesome (but ridiculously expensive) lightbulbs. As such, exercise extreme caution.
@@ -9,30 +10,49 @@ All of this is very experimental and could permanently damage your awesome (but
 ## Getting Started
 You can get a [great overview](http://rsmck.co.uk/hue) of the options and limitations of the lights from Ross McKillop.
 
-You will need to find the IP address of your bridge unit and also generate a unique ID (UUID works great) for your controlling application and add them to the top of the `hue.rb` file.
-
-You will need to use this information to register your app with the controller. This library does not do that at this time, so you will need to manually do that. I suggest following the *Registering Your Application* section of [Ross's overview](http://rsmck.co.uk/hue).
-
 ## Usage
-To begin using, fire up the irb console and load the `hue.rb` file.
+To begin using, fire up the irb console from the project root thus:
+
+```
+irb -I lib
+```
 
 ```ruby
->> load 'hue.rb'
+>> require 'hue'
 => true
 ```
 
+Start by registering your application. Press the button on the bridge and execute
+
+```ruby
+>> Hue.register_default
+=> #<Hue::Bridge:0x8b9d950 @application_id="4aa41fe737808af3559f3d22ca67a0ca", @base_uri="http://198.168.1.1/api">
+```
+
+This will create two config files in your ~/.hue-lib directory.
+One for the bridges discovered on your network and one for the registered application.
+
+You can fetch the default application thus:
+
+```ruby
+>> bridge = Hue.application
+=> #<Hue::Bridge:0x8b9d950 @application_id="4aa41fe737808af3559f3d22ca67a0ca", @base_uri="http://198.168.1.1/api">
+```
+
 You can see all of the lights attached to your controller by querying the bridge.
 
 ```ruby
->> Hue::Bridge.identities
-=> {"1"=>"Master Bedroom Dresser", "2"=>"Wife Bedside", "3"=>"Bedside (front)", "4"=>"Bedside (back)", "5"=>"Family Room Desk", "6"=>"Family Room", "7"=>"Living Room Square"}
+>> bridge.lights
+=> {"1"=>{"name"=>"Bedroom Overhead"}, "2"=>{"name"=>"Living Overhead"}, "3"=>{"name"=>"Standing Lamp"}, "4"=>{"name"=>"Living Cabinet"}}
+>> bridge.light_names
+=> "1. Bedroom Overhead\n2. Living Overhead\n3. Standing Lamp\n4. Living Cabinet"
 ```
 
 If you know the ID number of a particular lamp, you can access it directly.
 
 ```ruby
->> b = Hue::Bulb.new(5)
-=> #<Hue::Bulb:0x007fe35a3586b8 @id=5, @hub=#<Hue::Bridge:0x007fe35a358690 @light_id="5">>
+>> b = Hue::Bulb.new(bridge, 1)
+=> #<Hue::Bulb:0x007fe35a3586b8 @bridge=#<Hue::Bridge:0x007fe35a358690 @id="1">>
 
 # on/off
 >> b.on?
@@ -62,27 +82,12 @@ If you know the ID number of a particular lamp, you can access it directly.
 => false
 
 >> b.blink
-=> nil
 
 >> b.blinking?
 => true
 
->> b.blink false
-=> nil
+>> b.solid
 
 >> b.blinking?
 => false
 ```
-
-## Experimental
-There is an experimental mode that attempts to simulate a candle flicker. This defaults to only flickering 15 times as it's really not the way the bridge or bulbs were designed to work. Additionally, this operates on the main thread so you really can't do anything else while it's running.
-
-```ruby
->> b.candle
-=> nil
-```
-
-The candle makes use of temporarily stashing the lamp's current settings before it starts and then restoring them upon completion. You can use this yourself with the `stash` and `restore` commands.
-
-## Going Forward
-There is still a lot of work to be done figuring out the various timer options of the hub, etc. Hopefully, the official API will be released in the near future and expose even more goodies that we're unaware of.

data/hue-lib.gemspec

@@ -3,8 +3,8 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "hue-lib"
-  s.version     = '0.5.0'
-  s.authors     = ["Birkir A. Barkarson", ""]
+  s.version     = '0.6.0'
+  s.authors     = ["Birkir A. Barkarson", "Aaron Hurley"]
   s.email       = ["birkirb@stoicviking.net"]
   s.homepage    = "https://github.com/birkirb/hue-lib"
   s.summary     = %q{Ruby library for controlling Phillips Hue light bridge.}

data/lib/hue/bridge.rb

@@ -1,52 +1,16 @@
-require 'digest/md5'
-require 'uuid'
-# require 'singleton'
+require 'socket'
+require 'timeout'
 
 module Hue
   class Bridge
-    # include Singleton
-
-    # # Remove
-    # def self.method_missing(method, *args, &block)
-    #   if args.empty?
-    #     self.instance.send method
-    #   else
-    #     self.instance.send method, *args
-    #   end
-    # end
-
-    # Move to APP class
-    def self.register(host = BASE)
-      # TODO: Look for default config.
-      puts "Please press the button on bridge before continuing."
-      puts "Once done, press Enter to continue."
-      gets
-      secret = Digest::MD5.hexdigest(UUID.generate) # one time UUID
-      puts "Registering app...(#{secret})"
-      config = Hue::Config.new(host, secret)
-      instance.create(
-        URI.parse(config.base_uri),
-        {"username" => config.base_uri, "devicetype" => Hue.device_type}
-      )
-      config.write
-    end
-
-    # Move to APP class
-    def self.remove
-      config = Config.default
-      instance.delete(
-        URI.parse(config.base_uri),
-        {"username" => config.identifier}
-      )
-      config.delete
-    end
 
     public
 
-    attr_reader :hue_config
+    attr_reader :application_id, :bridge_uri
 
-    def initialize(hue_config = Hue.config)
-      @hue_config = hue_config
+    def initialize(application_id, bridge_uri)
+      @application_id = application_id
+      @bridge_uri = bridge_uri
     end
 
     def status
@@ -93,42 +57,55 @@ module Hue
       update(uri('lights', id, 'state'), state)
     end
 
+    def register
+      create(URI.parse(bridge_uri),
+             {"username" => application_id, "devicetype" => Hue.device_type})
+    end
+
+    def unregister
+      delete(uri('config', 'whitelist', application_id))
+    end
+
     private
 
     def uri(*args)
-      URI [hue_config.base_uri, hue_config.identifier, args].flatten.reject{|x| x.to_s.strip == ''}.join('/')
+      URI.parse([bridge_uri, application_id, args].flatten.reject { |x| x.to_s.strip == '' }.join('/'))
     end
 
     def index(url)
-      # json = Net::HTTP.get(url)
-      # JSON.parse(json)
       request = Net::HTTP::Get.new(url.request_uri, initheader = {'Content-Type' =>'application/json'})
-      response = Net::HTTP.new(url.host, url.port).start {|http| http.request(request) }
-      display(response)
-      json = JSON.parse(response.body)
-      if json.is_a?(Array) && error = json.first['error']
-        raise Hue::API::Error.new(error)
-      else
-        json
-      end
+      parse_and_check_response(Net::HTTP.new(url.host, url.port).start { |http| http.request(request) })
     end
 
     def update(url, settings = {})
       request = Net::HTTP::Put.new(url.request_uri, initheader = {'Content-Type' =>'application/json'})
       request.body = settings.to_json
-      display Net::HTTP.new(url.host, url.port).start {|http| http.request(request) }
+      parse_and_check_response(Net::HTTP.new(url.host, url.port).start { |http| http.request(request) })
     end
 
     def delete(url, settings = {})
       request = Net::HTTP::Delete.new(url.request_uri, initheader = {'Content-Type' =>'application/json'})
       request.body = settings.to_json
-      display Net::HTTP.new(url.host, url.port).start{|http| http.request(request)}
+      parse_and_check_response(Net::HTTP.new(url.host, url.port).start{ |http| http.request(request) })
     end
 
     def create(url, settings = {})
       request = Net::HTTP::Post.new(url.request_uri, initheader = {'Content-Type' =>'application/json'})
       request.body = settings.to_json
-      display Net::HTTP.new(url.host, url.port).start {|http| http.request(request) }
+      parse_and_check_response(Net::HTTP.new(url.host, url.port).start { |http| http.request(request) })
+    end
+
+    def parse_and_check_response(response)
+      if display(response)
+        json = JSON.parse(response.body)
+        if json.is_a?(Array) && error = json.first['error']
+          raise Hue::API::Error.new(error)
+        else
+          json
+        end
+      else
+        raise Hue::Error.new("Unexpected response: #{response.code}, #{response.message}")
+      end
     end
 
     def display(response = nil)

data/lib/hue/config/abstract.rb

@@ -0,0 +1,73 @@
+require 'yaml'
+require 'fileutils'
+
+module Hue
+  module Config
+    class NotFound < Hue::Error; end;
+
+    class Abstract
+
+      public
+
+      attr_reader :path, :name
+
+      def initialize(name, path)
+        @path = path
+        @name = name
+        self.class.setup_file_path(self.path)
+      end
+
+      def write(overwrite_existing_key = false)
+        yaml = YAML.load_file(self.path) rescue Hash.new
+        if yaml.key?(name) && !overwrite_existing_key
+          raise "Key named '#{name}' already exists in config file '#{self.path}'.\nPlease remove it before creating a new one with the same name."
+        else
+          add_self_to_yaml(yaml)
+          dump_yaml(yaml)
+        end
+      end
+
+      def delete
+        yaml = YAML.load_file(self.path) rescue Hash::New
+
+        if yaml.key?(name)
+          yaml.delete(name)
+        end
+
+        dump_yaml(yaml)
+      end
+
+      def ==(rhs)
+        lhs = self
+
+        lhs.class == rhs.class && lhs.name == rhs.name
+      end
+
+      private
+
+      def add_self_to_yaml(yaml)
+        yaml[name] = {}
+      end
+
+      def dump_yaml(yaml)
+        File.open(self.path, 'w+' ) do |out|
+          YAML.dump(yaml, out)
+        end
+      end
+
+      def self.setup_file_path(path)
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir) unless Dir.exists?(dir)
+      end
+
+      def self.read_file(config_file)
+        begin
+          yaml = YAML.load_file(config_file)
+        rescue => err
+          raise Error.new("Failed to read configuration file", err)
+        end
+      end
+
+    end
+  end
+end

data/lib/hue/config/application.rb

@@ -0,0 +1,55 @@
+module Hue
+  module Config
+    class Application < Abstract
+
+      STRING_BRIDGE_ID = 'bridge_id'
+      STRING_DEFAULT = 'default'
+      STRING_ID = 'id'
+
+      def self.file_path
+        File.join(ENV['HOME'], ".#{Hue.device_type}", 'applications.yml')
+      end
+
+      def self.default
+        named(STRING_DEFAULT)
+      end
+
+      def self.named(name)
+        yaml = read_file(file_path)
+        if named_yaml = yaml[name]
+          new(named_yaml[STRING_BRIDGE_ID], named_yaml[STRING_ID], name)
+        else
+          raise NotFound.new("Config named '#{name}' not found.")
+        end
+      end
+
+      public
+
+      attr_reader :bridge_id, :id, :name
+
+      def initialize(bridge_id, id, name = STRING_DEFAULT, path = self.class.file_path)
+        super(name, path)
+        @bridge_id = bridge_id
+        @id = id
+      end
+
+      def ==(rhs)
+        super(rhs) &&
+          self.bridge_id == rhs.bridge_id &&
+          self.id == rhs.id
+      end
+
+      private
+
+      def add_self_to_yaml(yaml)
+        key = self.name.dup.force_encoding('ASCII') # Avoid binary encoded YAML
+        bridge = bridge_id.dup.force_encoding('ASCII')
+        yaml[key] = {
+          STRING_ID => id.force_encoding('ASCII'),
+          STRING_BRIDGE_ID => bridge,
+        }
+      end
+
+    end
+  end
+end

data/lib/hue/config/bridge.rb

@@ -0,0 +1,45 @@
+module Hue
+  module Config
+    class Bridge < Abstract
+
+      def self.file_path
+        File.join(ENV['HOME'], ".#{Hue.device_type}", 'bridges.yml')
+      end
+
+      def self.find(id)
+        yaml = read_file(file_path)
+        entry = yaml.select { |k,v| k.to_s == id.to_s }
+        if entry.empty?
+          nil
+        else
+          new(id, entry[id]['uri'])
+        end
+      end
+
+      public
+
+      attr_accessor :uri
+
+      def initialize(id, uri, path = self.class.file_path)
+        super(id, path)
+        @uri = uri
+      end
+
+      def id
+        self.name
+      end
+
+      def write(overwrite_existing_key = true)
+        super(overwrite_existing_key)
+      end
+
+      private
+
+      def add_self_to_yaml(yaml)
+        key = id.dup.force_encoding('ASCII')
+        yaml[key] = {'uri' => self.uri.force_encoding('ASCII')}
+      end
+
+    end
+  end
+end

data/lib/hue.rb

@@ -1,11 +1,8 @@
-APP_NAME = 'ruby_hue'
-BASE    = 'http://10.10.10.20/api'
-# UUID    = 'd79713a3433df3d972ba7c22cb1cc23e'
-# Digest::MD5.hexdigest('aa4f6bc0-2045-0130-8cf0-0018de9ecdd0')
-
 require 'net/http'
 require 'json'
 require 'matrix'
+require 'digest/md5'
+require 'uuid'
 
 RGB_MATRIX = Matrix[
   [3.233358361244897, -1.5262682428425947, 0.27916711262124544],
@@ -13,20 +10,98 @@ RGB_MATRIX = Matrix[
   [0.12942207487871885, 0.19839858329512317, 2.0280912276039635]
 ]
 
-require 'hue/bridge.rb'
-require 'hue/bulb.rb'
-require 'hue/config.rb'
-
 module Hue
 
-  DEVICE_TYPE = "RubyHue"
+  DEVICE_TYPE = 'hue-lib'
+  DEFAULT_UDP_TIMEOUT = 2
+  ERROR_DEFAULT_EXISTS = 'Default application already registered.'
+  ERROR_NO_BRIDGE_FOUND = 'No bridge found.'
 
   def self.device_type
     DEVICE_TYPE
   end
 
-  def self.config
-    Hue::Config.default
+  def self.one_time_uuid
+    Digest::MD5.hexdigest(UUID.generate)
+  end
+
+  def self.register_default
+    if default = (Hue::Config::Application.default rescue nil)
+      raise Hue::Error.new(ERROR_DEFAULT_EXISTS)
+    else
+      bridge_config = register_bridges.values.first # Assuming one bridge for now
+      secret = Hue.one_time_uuid
+      app_config = Hue::Config::Application.new(bridge_config.id, secret)
+      puts "Registering app...(#{secret})"
+      instance = Hue::Bridge.new(app_config.id, bridge_config.uri)
+      instance.register
+      app_config.write
+      instance
+    end
+  end
+
+  def self.application
+    application_config = Hue::Config::Application.default
+    bridge_config = Hue::Config::Bridge.find(application_config.bridge_id)
+    bridge_config ||= register_bridges[application_config.bridge_id]
+
+    if bridge_config.nil?
+      raise Error.new("Unable to find bridge: #{application_config.bridge_id}")
+    end
+
+    Hue::Bridge.new(application_config.id, bridge_config.uri)
+  end
+
+  def self.remove_default
+    instance = application
+    instance.unregister
+    Hue::Config::Application.default.delete
+    true
+  end
+
+  def self.discover(timeout = DEFAULT_UDP_TIMEOUT)
+    bridges = Hash.new
+    payload = <<-PAYLOAD
+M-SEARCH * HTTP/1.1
+HOST: 239.255.255.250:1900
+MAN: ssdp:discover
+MX: 10
+ST: ssdp:all
+    PAYLOAD
+    broadcast_address = '239.255.255.250'
+    port_number = 1900
+
+    socket = UDPSocket.new(Socket::AF_INET)
+    socket.send(payload, 0, broadcast_address, port_number)
+
+    Timeout.timeout(timeout, Hue::Error) do
+      loop do
+        message, (address_family, port, hostname, ip_add) = socket.recvfrom(1024)
+        if message =~ /IpBridge/ && location = /LOCATION: (.*)$/.match(message)
+          if uuid = /uuid:(.{36})/.match(message)
+            # Assume this is Philips Hue for now.
+            bridges[uuid.captures.first] = "http://#{ip_add}/api"
+          end
+        end
+      end
+    end
+
+  rescue Hue::Error
+    bridges
+  end
+
+  def self.register_bridges
+    bridges = self.discover
+    if bridges.empty?
+      raise Error.new(ERROR_NO_BRIDGE_FOUND)
+    else
+      bridges.inject(Hash.new) do |hash, (id, ip)|
+        config = Hue::Config::Bridge.new(id, ip)
+        config.write
+        hash[id] = config
+        hash
+      end
+    end
   end
 
   class Error < StandardError
@@ -57,3 +132,9 @@ module Hue
   end
 
 end
+
+require 'hue/config/abstract'
+require 'hue/config/application'
+require 'hue/config/bridge'
+require 'hue/bridge'
+require 'hue/bulb'

data/spec/config/applications.yml

@@ -0,0 +1,4 @@
+---
+default:
+  bridge_id: bc6be180-4c57-0130-8d8f-0018de9ecdd0
+  id: application_uuid

data/spec/config/bridges.yml

@@ -1,4 +1,3 @@
 ---
-default:
-  base_uri: http://localhost/api
-  identifier: test_identifier
+bc6be180-4c57-0130-8d8f-0018de9ecdd0:
+  uri: http://localhost/api

data/spec/hue/bridge_spec.rb

@@ -2,36 +2,12 @@ require 'spec_helper.rb'
 
 describe Hue::Bridge do
 
-  def self.klass
-    Hue::Bridge
-  end
-
-  def klass
-    self.class.klass
-  end
-
-  # it 'should acts as a singleton and give access to the instance' do
-  #   klass.instance.should be_a_kind_of(Hue::Bridge)
-  # end
-
-  it 'should allow registering a new bridge' do
-    pending
-  end
-
-  it 'should allow un-registering a bridge' do
-    pending
-  end
+  context 'when instantiated' do
+    bridge = test_bridge
 
-  context 'when instantiated with a given config' do
-    bridge = klass.new
-
-    # before(:each) do
-    #   with_fake_index_request
-    # end
-
-    it 'should report the bridge status' do
-      with_fake_request_base
-      bridge.status.should == api_reply(:base)
+    it 'should report the status' do
+      with_fake_request
+      bridge.status.should == api_reply(:get_success)
     end
 
     it 'should report errors' do
@@ -41,7 +17,7 @@ describe Hue::Bridge do
       end.should raise_error(Hue::API::Error, 'unauthorized user')
     end
 
-    it 'should report the bridge lights' do
+    it 'should report the available lights' do
       with_fake_request(:lights)
       bridge.lights.should == api_reply(:lights)
     end
@@ -70,6 +46,20 @@ describe Hue::Bridge do
       end
     end
 
+    it 'should allow unregistering an existing config' do
+      with_fake_delete("config/whitelist/#{TEST_APPLICATION_UUID}")
+      bridge.unregister
+    end
+  end
+
+  context 'when instantiated with a new config' do
+    new_id = 'new_test_id'
+    bridge = described_class.new(new_id, TEST_BRIDGE_URI)
+
+    it 'should allow registering the new config' do
+      with_fake_post(nil, {:username => new_id, :devicetype => Hue.device_type})
+      bridge.register
+    end
   end
 
 end

data/spec/hue/bulb_spec.rb

@@ -2,16 +2,8 @@ require 'spec_helper.rb'
 
 describe Hue::Bulb do
 
-  def self.klass
-    Hue::Bulb
-  end
-
-  def klass
-    self.class.klass
-  end
-
   context 'when instantiated with a given bridge and id' do
-    bulb = klass.new(Hue::Bridge.new, 1)
+    bulb = described_class.new(test_bridge, 1)
 
     before(:all) do
       with_fake_request('lights/1')
@@ -104,4 +96,5 @@ describe Hue::Bulb do
     end
 
   end
+
 end

data/spec/hue/config/abstract_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper.rb'
+
+class Hue::Config::AbstractTest < Hue::Config::Abstract
+  private
+  def add_self_to_yaml(yaml)
+    yaml[name] = { 1 => :test}
+  end
+end
+
+describe Hue::Config::Abstract do
+
+  before(:all) do
+    create_test_application_config
+  end
+
+  context 'given an new config' do
+    config = described_class.new('test', TEST_CONFIG_APPLICATION_PATH)
+
+    it 'should report the values' do
+      config.name == 'test'
+      config.path == TEST_CONFIG_APPLICATION_PATH
+    end
+
+    it 'should allow writing the new config to file' do
+      config.write
+      YAML.load_file(config.path)['test'].should be_a(Hash)
+    end
+
+    it 'should allow deleting that named config from the file' do
+      config.delete
+      YAML.load_file(config.path)['test'].should be_nil
+    end
+  end
+
+end

data/spec/hue/config/application_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Hue::Config::Application do
+
+  mock_application_config_path
+
+  after(:all) do
+    create_test_application_config
+  end
+
+  it 'should report the config file location' do
+    described_class.file_path.should == TEST_CONFIG_APPLICATION_PATH
+  end
+
+  it "should throw and error if a named config doesn't exist" do
+    lambda do
+      described_class.named('not_default')
+    end.should raise_error(Hue::Config::NotFound, /Config named (.*) not found/)
+  end
+
+  context 'with a config file, containing a default' do
+    config = described_class.default
+
+    it "should give the default config and report it's values" do
+      config.name == described_class::STRING_DEFAULT
+      config.bridge_id == TEST_CONFIG_APPLICATION[config.name][described_class::STRING_BRIDGE_ID]
+      config.id == TEST_CONFIG_APPLICATION[config.name][described_class::STRING_ID]
+    end
+
+    it 'should allow deleting the default config from the file' do
+      config.delete
+      YAML.load_file(described_class.file_path)[described_class::STRING_DEFAULT].should be_nil
+    end
+  end
+
+  context 'given an new config' do
+    config = described_class.new('http://someip/api', 'some_id', 'not_default')
+
+    it 'should report the values' do
+      config.name == 'not_default'
+      config.bridge_id == 'http://someip/api'
+      config.id == 'not_default'
+    end
+
+    it 'should allow writing the new config to file' do
+      config.write
+      YAML.load_file(described_class.file_path)['not_default'].should be_a(Hash)
+    end
+
+    it 'should allow fetching that name config' do
+      named_config = described_class.named('not_default')
+      named_config.should == config
+    end
+
+    it 'should allow deleting that named config from the file' do
+      config.delete
+      YAML.load_file(described_class.file_path)['not_default'].should be_nil
+    end
+  end
+
+end

data/spec/hue/config/bridge_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper.rb'
+
+describe Hue::Config::Bridge do
+
+  mock_bridge_config_path
+
+  after(:all) do
+    create_test_bridge_config
+  end
+
+  it 'should report the config file location' do
+    described_class.file_path.should == TEST_CONFIG_BRIDGE_PATH
+  end
+
+  it 'should find existing bridges given an id' do
+    found = described_class.find(TEST_BRIDGE_UUID)
+    found.id.should == TEST_BRIDGE_UUID
+    found.uri.should == TEST_BRIDGE_URI
+
+    described_class.find('something').should be_nil
+  end
+
+  context 'given an new config' do
+    uuid = UUID.generate
+    uri = 'http://someip/api'
+    config = described_class.new(uuid, uri)
+
+    it 'should report the values' do
+      config.name == uuid
+      config.id == uuid
+      config.uri == uri
+    end
+  end
+
+end

data/spec/hue_spec.rb

@@ -2,12 +2,79 @@ require 'spec_helper.rb'
 
 describe Hue do
 
+  mock_application_config_path
+  mock_bridge_config_path
+
+  after(:each) do
+    create_test_bridge_config
+  end
+
+  before(:each) do
+    mock_udp_replies
+  end
+
   it 'should report the device type as itself' do
-    Hue.device_type.should == Hue::DEVICE_TYPE
+    described_class.device_type.should == described_class::DEVICE_TYPE
   end
 
-  it 'should return the default config' do
-    Hue.config.should be_a(Hue::Config)
+  it 'should return the default application' do
+    described_class.application.should be_a(described_class::Bridge)
+  end
+
+  context 'when discovering new bridges' do
+    it 'should return a list discovered bridges' do
+      bridges = Hue.discover
+      bridges.should == {TEST_UDP_BRIDGE_UUID => TEST_UDP_BRIDGE_URI}
+    end
+
+    it 'should allow registering of discovered bridges' do
+      Hue::Config::Bridge.find(TEST_UDP_BRIDGE_UUID).should be_nil
+      registered = Hue.register_bridges
+      new_bridge = registered[TEST_UDP_BRIDGE_UUID]
+      new_bridge.id.should == TEST_UDP_BRIDGE_UUID
+      new_bridge.uri.should == TEST_UDP_BRIDGE_URI
+    end
+  end
+
+  context 'after discovering bridges' do
+    before(:each) do
+      mock_udp_replies(TEST_BRIDGE_UUID, 'new_host')
+    end
+
+    it 'should update already registered bridges' do
+      bridge = Hue::Config::Bridge.find(TEST_BRIDGE_UUID)
+      bridge.should_not be_nil
+
+      registered = Hue.register_bridges
+
+      updated_bridge = registered[TEST_BRIDGE_UUID]
+      updated_bridge.id.should == TEST_BRIDGE_UUID
+      updated_bridge.uri.should_not == bridge.uri
+    end
+  end
+
+  context 'when registering or un-registering the application' do
+    it 'should throw and error if the default already exists' do
+      lambda do
+        described_class.register_default
+      end.should raise_error(described_class::Error, described_class::ERROR_DEFAULT_EXISTS)
+    end
+
+    it 'should allow a new default if one doesn\'t exist' do
+      with_temp_config_path do
+        with_fake_post(nil, {}, 'post_success', TEST_UDP_BRIDGE_URI)
+        with_stdout(/Registering app...(.*)$/) do
+          instance = described_class.register_default
+        end
+      end
+    end
+
+    it 'should allow un-registering the default' do
+      with_temp_config_path(true) do
+        with_fake_delete("config/whitelist/#{TEST_APPLICATION_UUID}")
+        instance = described_class.remove_default
+      end
+    end
   end
 
 end

data/spec/json/config/whitelist/application_uuid/delete_success.json

@@ -0,0 +1 @@
+[{}]

data/spec/json/post_error.json

@@ -0,0 +1 @@
+{"error"=>{"type"=>101, "address"=>"", "description"=>"link button not pressed"}}

data/spec/json/post_success.json

@@ -0,0 +1,8 @@
+[
+  {
+    "success":
+    {
+      "username":"new_test_id"
+    }
+  }
+]

data/spec/json/put_success.json

@@ -0,0 +1 @@
+[{}]

data/spec/spec_helper.rb

@@ -5,21 +5,113 @@ require 'mocha'
 
 WebMock.disable_net_connect!
 
+# GENERAL
+
+def join_paths(*paths)
+  File.join(paths.delete_if { |entry| entry.nil? || entry.empty? })
+end
+
+def with_stdout(expected_output, &block)
+  original_stdout = $stdout
+  new_stdout = StringIO.new
+  begin
+    $stdout = new_stdout
+    yield
+    new_stdout.seek(0)
+    output = new_stdout.read
+    output.should match(expected_output)
+  ensure
+    new_stdout.close
+    $stdout = original_stdout
+  end
+end
+
+def silence_warnings
+  begin
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+end
+
 SPEC_DIR = File.dirname(__FILE__)
-TEST_BRIDGE_CONFIG_PATH = File.join(SPEC_DIR, 'config', 'bridges.yml')
-TEST_BRIDGE_CONFIG = YAML.load_file(TEST_BRIDGE_CONFIG_PATH)
+
+silence_warnings do
+  Hue.const_set(:DEFAULT_UDP_TIMEOUT, 0.01)
+end
+
+# APPLICATION CONFIG
+
+TEST_CONFIG_APPLICATION_PATH = File.join(SPEC_DIR, 'config', 'applications.yml')
+TEST_CONFIG_APPLICATION = YAML.load_file(TEST_CONFIG_APPLICATION_PATH)
 TEST_JSON_DATA_PATH = File.join(SPEC_DIR, 'json')
 
-Hue::Config.expects(:bridges_config_path).at_least_once.returns(TEST_BRIDGE_CONFIG_PATH)
+def create_test_application_config(path = TEST_CONFIG_APPLICATION_PATH)
+  File.open(path, 'w' ) do |out|
+    YAML.dump(TEST_CONFIG_APPLICATION, out)
+  end
+end
 
-def with_fake_request_base
-  stub_request(:get, "http://localhost/api/test_identifier").
-    to_return(:status => 200, :body => api_reply_json(:base), :headers => {})
+def mock_application_config_path
+  Hue::Config::Application.stubs(:file_path).returns(TEST_CONFIG_APPLICATION_PATH)
 end
 
-def with_fake_request(named, body_name = named)
-  stub_request(:get, "http://localhost/api/test_identifier/#{named.to_s}").
-    to_return(:status => 200, :body => api_reply_json(body_name), :headers => {})
+def with_temp_config_path(write_config = false)
+  temp_config_path = File.join(SPEC_DIR, 'config', 'temp')
+  FileUtils.mkdir_p(temp_config_path)
+  temp_config = File.join(temp_config_path, 'applications.yml')
+  if write_config
+    create_test_application_config(temp_config)
+  end
+  Hue::Config::Application.expects(:file_path).at_least_once.returns(temp_config)
+
+  begin
+    yield
+  ensure
+    FileUtils.rm_f(temp_config)
+    mock_bridge_config_path
+  end
+end
+
+# BRIDGE CONFIG
+
+TEST_CONFIG_BRIDGE_PATH = File.join(SPEC_DIR, 'config', 'bridges.yml')
+TEST_BRIDGE_UUID = 'bc6be180-4c57-0130-8d8f-0018de9ecdd0'
+TEST_CONFIG_BRIDGE = YAML.load_file(TEST_CONFIG_BRIDGE_PATH)
+
+def create_test_bridge_config
+  File.open(TEST_CONFIG_BRIDGE_PATH, 'w' ) do |out|
+    YAML.dump(TEST_CONFIG_BRIDGE, out)
+  end
+end
+
+def mock_bridge_config_path
+  Hue::Config::Bridge.stubs(:file_path).returns(TEST_CONFIG_BRIDGE_PATH)
+end
+
+# HUE - UDP
+
+TEST_UDP_BRIDGE_UUID = '09230030-4c1e-0130-8d83-0018de9ecdd0'
+TEST_UDP_BRIDGE_HOSTNAME = 'upd-host'
+TEST_UDP_BRIDGE_URI = "http://#{TEST_UDP_BRIDGE_HOSTNAME}/api"
+
+def mock_udp_replies(uuid = TEST_UDP_BRIDGE_UUID, hostname = TEST_UDP_BRIDGE_HOSTNAME)
+  reply = ["HTTP/1.1 200 OK\r\nCACHE-CONTROL: max-age=100\r\nEXT:\r\nLOCATION: http://127.0.0.1:80/description.xml\r\nSERVER: FreeRTOS/6.0.5, UPnP/1.0, IpBridge/0.1\r\nST: upnp:rootdevice\r\nUSN: uuid:#{uuid}::upnp:rootdevice\r\n\r\n", ["AF_INET", 1900, "127.0.0.1", hostname]]
+
+  socket = Object.new
+  socket.stubs(:send).returns(nil)
+  socket.stubs(:recvfrom).returns(reply)
+  UDPSocket.stubs(:new).returns(socket)
+end
+
+# BRIDGE - API CALLS
+
+TEST_BRIDGE_URI = 'http://localhost/api'
+TEST_APPLICATION_UUID = 'application_uuid'
+
+def test_bridge
+  Hue::Bridge.new(TEST_APPLICATION_UUID, TEST_BRIDGE_URI)
 end
 
 def api_reply_json(named)
@@ -32,10 +124,37 @@ def api_reply(named)
   JSON.parse(api_reply_json(named))
 end
 
-def with_fake_update(named, update = {})
-  stub = stub_request(:put, "http://localhost/api/test_identifier/#{named.to_s}").
-    with(:body => update.to_json).
-    to_return(:status => 200, :body => update.to_json, :headers => {})
+def with_fake_request(named = nil, body_name = nil)
+  body_name ||= (named.nil? ? 'get_success' : named)
+  stub_request(:get, join_paths(TEST_BRIDGE_URI, TEST_APPLICATION_UUID, named.to_s)).
+    to_return(:status => 200, :body => api_reply_json(body_name), :headers => {})
+end
+
+def with_fake_update(named, put_body = {})
+  stub = stub_request(:put, "#{TEST_BRIDGE_URI}/#{TEST_APPLICATION_UUID}/#{named.to_s}").
+    with(:body => put_body.to_json).
+    to_return(:status => 200, :body => api_reply_json(:put_success), :headers => {})
+
+  if block_given?
+    yield
+    stub.should have_been_requested
+  end
+end
+
+def with_fake_post(named, post_body = {}, post_reply_name = 'post_success', uri = TEST_BRIDGE_URI)
+  stub = stub_request(:post, join_paths(uri, named))
+  stub.with(:body => post_body.to_json) unless post_body.empty?
+  stub.to_return(:status => 200, :body => api_reply_json(join_paths(named, post_reply_name)), :headers => {})
+
+  if block_given?
+    yield
+    stub.should have_been_requested
+  end
+end
+
+def with_fake_delete(named, delete_reply = 'delete_success')
+  stub = stub_request(:delete, "#{TEST_BRIDGE_URI}/#{TEST_APPLICATION_UUID}/#{named.to_s}").
+    to_return(:status => 200, :body => api_reply_json(join_paths(named, delete_reply)), :headers => {})
 
   if block_given?
     yield

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: hue-lib
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
 - Birkir A. Barkarson
-- ''
+- Aaron Hurley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-10 00:00:00.000000000 Z
+date: 2013-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -83,6 +83,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .gitignore
 - Gemfile
 - README.md
 - Rakefile
@@ -90,16 +91,25 @@ files:
 - lib/hue.rb
 - lib/hue/bridge.rb
 - lib/hue/bulb.rb
-- lib/hue/config.rb
+- lib/hue/config/abstract.rb
+- lib/hue/config/application.rb
+- lib/hue/config/bridge.rb
+- spec/config/applications.yml
 - spec/config/bridges.yml
 - spec/hue/bridge_spec.rb
 - spec/hue/bulb_spec.rb
-- spec/hue/config_spec.rb
+- spec/hue/config/abstract_spec.rb
+- spec/hue/config/application_spec.rb
+- spec/hue/config/bridge_spec.rb
 - spec/hue_spec.rb
-- spec/json/base.json
 - spec/json/config.json
+- spec/json/config/whitelist/application_uuid/delete_success.json
+- spec/json/get_success.json
 - spec/json/lights.json
 - spec/json/lights/1.json
+- spec/json/post_error.json
+- spec/json/post_success.json
+- spec/json/put_success.json
 - spec/json/schedules.json
 - spec/json/unauthorized.json
 - spec/spec_helper.rb

data/lib/hue/config.rb

@@ -1,94 +0,0 @@
-module Hue
-  class Config
-    STRING_DEFAULT = 'default'
-    STRING_BASE_URI = 'base_uri'
-    STRING_IDENTIFIER = 'identifier'
-
-    require 'yaml'
-    require 'fileutils'
-
-    def self.bridges_config_path
-      File.join(ENV['HOME'], ".#{APP_NAME}", 'bridges.yml')
-    end
-
-    def self.default
-      named(STRING_DEFAULT)
-    end
-
-    def self.named(name)
-      yaml = read_file
-      if named_yaml = yaml[name]
-        Config.new(named_yaml[STRING_BASE_URI], named_yaml[STRING_IDENTIFIER], name)
-      else
-        raise Error.new("Config named '#{name}' not found.")
-      end
-    end
-
-    public
-
-    attr_reader :base_uri, :identifier, :name
-
-    def initialize(base_uri, identifier, name = STRING_DEFAULT)
-      @base_uri = base_uri
-      @identifier = identifier
-      @name = name
-    end
-
-    def write(config_file = self.class.bridges_config_path)
-      yaml = YAML.load_file(self.class.bridges_config_path) rescue Hash::New
-      if yaml.key?(name)
-        raise "Configuration named '#{name}' already exists in #{config_file}\nPlease de-register before creating a new one with the same name."
-      else
-        yaml[name] = {
-          STRING_BASE_URI => self.base_uri,
-          STRING_IDENTIFIER => identifier.force_encoding('ASCII') # Avoid binary encoded YAML
-        }
-        self.class.setup_config_path(config_file)
-        File.open(config_file, 'w+' ) do |out|
-          YAML.dump(yaml, out)
-        end
-      end
-    end
-
-    def delete
-      config_file = self.class.bridges_config_path
-      yaml = YAML.load_file(config_file) rescue Hash::New
-
-      if yaml.key?(name)
-        yaml.delete(name)
-      end
-
-      if yaml.size > 0
-        self.class.setup_config_path(config_file)
-        File.open(config_file, 'w+' ) do |out|
-          YAML.dump(yaml, out)
-        end
-      end
-    end
-
-    def ==(rhs)
-      lhs = self
-
-      lhs.class == rhs.class &&
-        lhs.name == rhs.name &&
-        lhs.base_uri == rhs.base_uri &&
-        lhs.identifier == rhs.identifier
-    end
-
-    private
-
-    def self.setup_config_path(path)
-      dir = File.dirname(path)
-      FileUtils.mkdir_p(dir) unless Dir.exists?(dir)
-    end
-
-    def self.read_file(config_file = bridges_config_path)
-      begin
-        yaml = YAML.load_file(config_file)
-      rescue => err
-        raise Error.new("Failed to read configuration file", err)
-      end
-    end
-
-  end
-end

data/spec/hue/config_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper.rb'
-
-describe Hue::Config do
-
-  TEST_IDENTIFIER = 'test_identifier'
-
-  def self.klass
-    Hue::Config
-  end
-
-  def klass
-    self.class.klass
-  end
-
-  after(:all) do
-    File.open(TEST_BRIDGE_CONFIG_PATH, 'w' ) do |out|
-      YAML.dump(TEST_BRIDGE_CONFIG, out)
-    end
-  end
-
-  it 'should report the bridge config file location' do
-    klass.bridges_config_path.should == TEST_BRIDGE_CONFIG_PATH
-  end
-
-  it "should throw and error if a named config doesn't exist" do
-    lambda do
-      klass.named('not_default')
-    end.should raise_error(Hue::Error, /Config named (.*) not found/)
-  end
-
-  context 'with a bridge config file, containing the default bridge' do
-    it "should give the default config and report it's values" do
-      config = klass.default
-      config.name == klass::STRING_DEFAULT
-      config.base_uri == TEST_BRIDGE_CONFIG[config.name][klass::STRING_BASE_URI]
-      config.identifier == TEST_BRIDGE_CONFIG[config.name][klass::STRING_IDENTIFIER]
-    end
-  end
-
-  context 'given an new config' do
-    config = klass.new('http://someip/api', 'some_id', 'not_default')
-
-    it 'should report the values' do
-      config.name == 'not_default'
-      config.base_uri == 'http://someip/api'
-      config.identifier == 'not_default'
-    end
-
-    it 'should allow writing the new config to file' do
-      config.write
-      YAML.load_file(klass.bridges_config_path)['not_default'].should be_a(Hash)
-    end
-
-    it 'should allow fetching that name config' do
-      named_config = klass.named('not_default')
-      named_config.should == config
-    end
-
-    it 'should allow deleting that named config from the file' do
-      config.delete
-      YAML.load_file(klass.bridges_config_path)['not_default'].should be_nil
-    end
-  end
-
-end