lifx 0.0.1 → 0.4.0

data/lib/lifx.rb

@@ -1,5 +1,19 @@
 require "lifx/version"
+require "bindata"
+require "bindata_ext/bool"
+require "bindata_ext/record"
+require "lifx/utilities"
+require "lifx/logging"
+
+require "lifx/protocol/payload"
+%w(device light sensor wan wifi message).each { |f| require "lifx/protocol/#{f}" }
+require "lifx/protocol/type"
+require "lifx/message"
+require "lifx/transport"
+
+require "lifx/config"
+require "lifx/client"
 
 module LIFX
-  # Your code goes here...
+
 end

data/lifx.gemspec

@@ -8,18 +8,22 @@ Gem::Specification.new do |spec|
   spec.version       = LIFX::VERSION
   spec.authors       = ["Jack Chen (chendo)"]
   spec.email         = ["chendo@lifx.co"]
-  spec.description   = %q{Ruby client for LIFX}
-  spec.summary       = %q{Ruby client for LIFX}
-  spec.homepage      = ""
+  spec.description   = %q{A Ruby gem that allows easy interaction with LIFX devices.}
+  spec.summary       = %q{A Ruby gem that allows easy interaction with LIFX devices. Handles discovery, rate limiting, tags, gateway connections and provides an object-based API for interacting with LIFX devices. }
+  spec.homepage      = "https://github.com/LIFX/lifx-gem"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files`.split($/).reject { |f| f =~ /^script\// }
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 2.1"
 
-  spec.add_dependency 'bindata'
+  spec.add_dependency "bindata", "~> 2.0"
+  spec.add_dependency "yell", "~> 2.0"
+  spec.add_dependency "timers", "~> 2.0"
+  spec.add_dependency "configatron", "~> 3.0"
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rake", '~> 10.1'
+  spec.add_development_dependency "rspec", "~> 2.14"
 end

data/spec/color_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module LIFX
+  describe Color do
+    let(:default_kelvin) { 3500 }
+    describe '.rgb' do
+      context 'translating from RGB' do
+        it 'translates red correctly' do
+          c = Color.rgb(255, 0, 0)
+          c.to_a.should == [0, 1, 1, default_kelvin]
+        end
+
+        it 'translates yellow correctly' do
+          c = Color.rgb(255, 255, 0)
+          c.to_a.should == [60, 1, 1, default_kelvin]
+        end
+
+        it 'translates green correctly' do
+          c = Color.rgb(0, 255, 0)
+          c.to_a.should == [120, 1, 1, default_kelvin]
+        end
+
+        it 'translates cyan correctly' do
+          c = Color.rgb(0, 255, 255)
+          c.to_a.should == [180, 1, 1, default_kelvin]
+        end
+
+        it 'translates blue correctly' do
+          c = Color.rgb(0, 0, 255)
+          c.to_a.should == [240, 1, 1, default_kelvin]
+        end
+
+        it 'translates white correctly' do
+          c = Color.rgb(255, 255, 255)
+          c.to_a.should == [0, 0, 1, default_kelvin]
+        end
+
+        it 'translates black correctly' do
+          c = Color.rgb(0, 0, 0)
+          c.to_a.should == [0, 0, 0, default_kelvin]
+        end
+      end
+    end
+  end
+end

data/spec/gateway_connection_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module LIFX
+  describe GatewayConnection do
+    subject do
+      GatewayConnection.new
+    end
+
+    let(:message) { double(Message).tap { |m| m.stub(:is_a?).and_return(true); m.stub(:pack) } }
+    let(:ip) { '127.0.0.1' }
+    let(:port) { 35003 }
+
+    after do
+      subject.close
+    end
+
+    context 'write queue resiliency' do
+      it 'does not send if there is no available connection' do
+        expect(subject).to_not receive(:actually_write)
+        subject.write(message)
+        expect { subject.flush(timeout: 0.5) }.to raise_error(Timeout::Error)
+      end
+      
+      it 'pushes message back into queue if unable to write' do
+        subject.connect_udp(ip, port)
+        expect(subject).to receive(:actually_write).and_return(false, true)
+        subject.write(message)
+        subject.flush
+      end
+    end
+  end
+end

data/spec/integration/client_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module LIFX
+  describe Client, integration: true do
+    describe '#sync' do
+      it 'schedules sending all messages to be executed at the same time' do
+
+        lifx.discover! do
+          lights.count >= 3
+        end
+
+        if lights.count < 3
+          fail "This test requires 3 or more lights tagged under Test"
+        end
+
+        white = LIFX::Color.white(brightness: 0.5)
+        lights.set_color(white, duration: 0)
+        sleep 1
+
+        udp = Transport::UDP.new('0.0.0.0', 56750)
+        msgs = []
+        udp.add_observer(self) do |message:, ip:, transport:|
+          msgs << message if message.payload.is_a?(Protocol::Light::SetWaveform)
+        end
+        udp.listen
+
+        delay = lifx.sync do
+          lights.each do |light|
+            light.pulse(LIFX::Color.hsb(rand(360), 1, 1), period: 1)
+          end
+        end
+
+        msgs.count.should == lights.count
+        msgs.map(&:at_time).uniq.count.should == 1
+
+        flush
+      end
+    end
+  end
+end

data/spec/integration/light_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module LIFX
+  describe Light, integration: true do
+    describe '#set_power' do
+      it "sets the power of the light asynchronously" do
+        light.set_power(0)
+        wait { light.off?.should == true }
+        light.set_power(1)
+        wait { light.on?.should == true }
+      end
+    end
+
+    describe '#set_power!' do
+      it "sets the power of the light synchronously" do
+        light.set_power!(0)
+        light.off?.should == true
+        light.set_power!(1)
+        light.on?.should == true
+      end
+    end
+
+    describe '#set_color' do
+      it "sets the color of the light asynchronously" do
+        color = Color.hsb(rand(360), rand, rand)
+        light.set_color(color, duration: 0)
+        sleep 1
+        light.refresh
+        wait { light.color.should == color }
+      end
+    end
+
+    describe '#set_label' do
+      it "sets the label of the light synchronously" do
+        label = light.label.sub(/\d+|$/, rand(100).to_s)
+        light.set_label(label)
+        light.label.should == label
+      end
+    end
+
+
+  end
+end

data/spec/integration/tags_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module LIFX
+  describe "tags", integration: true do
+    it 'Clearing, setting and using tags' do
+      light.add_tag('Foo')
+      light.tags.should include('Foo')
+
+      test_tag = lights.with_tag('Foo')
+      test_tag.turn_on
+      color = Color.hsb(rand(360), 0.3, 0.3)
+      test_tag.set_color(color, duration: 0) 
+      flush
+      sleep 1 # Set messages are scheduled 250ms if no at_time is set
+              # It also returns the current light state rather than the final state
+      light.refresh
+      wait { light.color.should == color }
+
+      light.remove_tag('Foo')
+      wait { light.tags.should_not include('Foo') }
+    end
+
+    it 'deletes tags when no longer assigned to a light' do
+      light.add_tag('TempTag')
+      light.remove_tag('TempTag')
+      lifx.unused_tags.should include('TempTag')
+      lifx.purge_unused_tags!
+      lifx.unused_tags.should be_empty
+    end
+  end
+end

data/spec/message_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe LIFX::Message do
+  context 'unpacking' do
+    let(:data) { "\x39\x00\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x6c\x69\x66\x78\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x01\x00\x00\xff\xff\xff\xff\xac\x0d\xc8\x00\x00\x00\x00\x00\x80\x3f\x00\x00\x00".b }
+    let(:msg) { LIFX::Message.unpack(data) }
+
+    it 'unpacks without errors' do
+      msg.should_not be_nil
+    end
+
+    it 'returns the correct frame data' do
+      msg.msg_size.should == 57
+      msg.protocol.should == 1024
+      msg.addressable?.should == true
+    end
+
+    it 'returns the correct address data' do
+      msg.raw_site.should == '1lifx1'
+      msg.raw_target.should == "\x00" * 8
+    end
+
+    it 'has correct ProtocolPath data' do
+      msg.path.should be_instance_of(LIFX::ProtocolPath)
+      msg.path.site_id.should == '316c69667831'
+      msg.path.tag_ids.should == []
+      msg.path.device_id.should == nil
+    end
+
+    it 'returns the correct metadata' do
+      msg.at_time.should == 0
+      msg.type.should == 103
+    end
+
+    let(:payload) { msg.payload }
+    it 'returns the payload' do
+      payload.class.should == LIFX::Protocol::Light::SetWaveform
+      payload.stream.should == 0
+      payload.transient.should be_true
+      payload.color.hue.should == 0
+      payload.color.saturation.should == 65535
+      payload.color.brightness.should == 65535
+      payload.color.kelvin.should == 3500
+      payload.period.should == 200
+      payload.cycles.should == 1.0
+      payload.duty_cycle.should == 0
+      payload.waveform.should == 0
+    end
+
+    it 'repacks to the same data' do
+      msg.pack.should == data
+    end
+  end
+
+  context 'packing' do
+    context 'no attributes' do
+      let(:msg) { LIFX::Message.new }
+
+      it 'throws an exception' do
+        expect { msg.pack }.to raise_error(LIFX::Message::NoPayload)
+      end
+    end
+
+    context 'no path' do
+      let(:msg) { LIFX::Message.new(payload: LIFX::Protocol::Device::SetPower.new) }
+
+      it 'throws an exception' do
+        expect { msg.pack }.to raise_error(LIFX::Message::NoPath)
+      end
+    end
+
+    context 'passed in via hash' do
+      let(:msg) do
+        LIFX::Message.new({
+          path: LIFX::ProtocolPath.new(tagged: false, raw_target: "abcdefgh"),
+          at_time: 9001,
+          payload: LIFX::Protocol::Wifi::SetAccessPoint.new(
+            interface: 1,
+            ssid: "who let the dogs out",
+            pass: "woof, woof, woof woof!",
+            security: 1
+          )
+        })
+      end
+
+      it 'sets the size' do
+        msg.msg_size.should == 134
+      end
+
+      it 'packs correctly' do
+        msg.pack.should == "\x86\x00\x00\x14\x00\x00\x00\x00abcdefgh\x00\x00\x00\x00\x00\x00\x00\x00)#\x00\x00\x00\x00\x00\x001\x01\x00\x00\x01who let the dogs out\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00woof, woof, woof woof!\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01".b
+        unpacked = LIFX::Message.unpack(msg.pack)
+        msg.protocol.should == 1024
+        msg.path.tagged?.should == false
+        msg.addressable?.should == true
+        msg.path.raw_target.should == 'abcdefgh'
+        msg.at_time.should == 9001
+        msg.type.should == 305
+        msg.payload.class.should == LIFX::Protocol::Wifi::SetAccessPoint
+        msg.payload.interface.should == 1
+        msg.payload.ssid.should == "who let the dogs out"
+        msg.payload.pass.should == "woof, woof, woof woof!"
+        msg.payload.security.should == 1
+      end
+    end
+
+    context 'packing with tags' do
+      let(:msg) do
+        LIFX::Message.new({
+          path: LIFX::ProtocolPath.new(tag_ids: [0,1]),
+          at_time: 9001,
+          payload: LIFX::Protocol::Device::GetTime.new
+        })
+      end
+
+      let(:unpacked) { LIFX::Message.unpack(msg.pack) }
+
+      it 'packs the tag correctly' do
+        msg.pack.should == "$\x00\x004\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00)#\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00".b
+      end
+
+      it 'sets tagged' do
+        unpacked.path.tagged?.should == true
+      end
+
+      it 'sets tags' do
+        unpacked.path.tag_ids.should == [0, 1]
+      end
+
+      it 'device should be nil' do
+        unpacked.path.device_id.should == nil
+      end
+    end
+
+    context 'packing with device' do
+      let(:msg) do
+        LIFX::Message.new({
+          path: LIFX::ProtocolPath.new(device_id: '0123456789ab', site_id: '0' * 12),
+          at_time: 9001,
+          payload: LIFX::Protocol::Device::GetTime.new
+        })
+      end
+
+      let(:unpacked) { LIFX::Message.unpack(msg.pack) }
+
+      it 'packs the tag correctly' do
+        msg.pack.should == "$\x00\x00\x14\x00\x00\x00\x00\x01#Eg\x89\xAB\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00)#\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00".b
+      end
+
+      it 'sets tagged to false' do
+        unpacked.path.tagged?.should == false
+      end
+
+      it 'sets device' do
+        unpacked.path.device_id.should == '0123456789ab'
+      end
+
+      it 'tags should be nil' do
+        unpacked.path.tag_ids.should == nil
+      end
+    end
+  end
+end

data/spec/protocol_path_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+module LIFX
+  describe ProtocolPath do
+    describe 'initializing from raw data' do
+      context 'device target' do
+        subject do
+          ProtocolPath.new(raw_site: "1lifx1", raw_target: "\xAB\xCD\xEF\x12\x34\x56\x00\x00", tagged: false)
+        end
+
+        it 'returns site_id in hex' do
+          subject.site_id.should == "316c69667831"
+        end
+
+        it 'returns device_id in hex' do
+          subject.device_id.should == 'abcdef123456'
+        end
+
+        it 'returns tagged as false' do
+          subject.tagged?.should be_false
+        end
+
+        it 'returns nil for tag_ids' do
+          subject.tag_ids.should == nil
+        end
+      end
+
+      context 'tagged target' do
+        subject do
+          ProtocolPath.new(raw_site: "1lifx1", raw_target: "\x03\x00\x00\x00\x00\x00\x00\x00", tagged: true)
+        end
+
+        it 'returns site_id in hex' do
+          subject.site_id.should == "316c69667831"
+        end
+
+        it 'returns device_id as nil' do
+          subject.device_id.should == nil
+        end
+
+        it 'returns tagged as true' do
+          subject.tagged?.should be_true
+        end
+
+        it 'returns the tag_ids' do
+          subject.tag_ids.should == [0, 1]
+        end
+      end
+    end
+
+    describe 'initializing from strings' do
+      context 'device target' do
+        subject do
+          ProtocolPath.new(site_id: "316c69667831", device_id: 'abcdef123456')
+        end
+
+        it 'sets raw_site correctly' do
+          subject.raw_site.should == "1lifx1"
+        end
+
+        it 'sets raw_target correctly' do
+          subject.raw_target.should == "\xAB\xCD\xEF\x12\x34\x56\x00\x00".b
+        end
+
+        it 'sets tagged to false' do
+          subject.tagged?.should be_false
+        end
+      end
+
+      context 'tagged target' do
+        subject do
+          ProtocolPath.new(site_id: "316c69667831", tag_ids: [0, 1])
+        end
+
+        it 'sets raw_site properly' do
+          subject.raw_site.should == "1lifx1"
+        end
+
+        it 'sets raw_target correctly' do
+          subject.raw_target.should == "\x03\x00\x00\x00\x00\x00\x00\x00".b
+        end
+
+        it 'returns tagged as true' do
+          subject.tagged?.should be_true
+        end
+      end
+
+      context 'tagged target with no site' do
+        subject do
+          ProtocolPath.new(tagged: true)
+        end
+
+        it 'raw_site should be null string' do
+          subject.raw_site.should == "\x00\x00\x00\x00\x00\x00".b
+        end
+
+        it 'sets raw_target correctly' do
+          subject.raw_target.should == "\x00\x00\x00\x00\x00\x00\x00\x00".b
+        end
+
+        it 'returns tagged as true' do
+          subject.tagged?.should be_true
+        end
+      end
+
+    end
+
+  end
+end

data/spec/routing_manager_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module LIFX
+  describe RoutingManager do
+    describe '#tags_for_device_id' do
+      subject do
+        RoutingManager.new(context: double)
+      end
+
+      before do
+        subject.tag_table.update_table(site_id: 'site', tag_id: 0, label: 'Some label')
+        subject.tag_table.update_table(site_id: 'site', tag_id: 1, label: 'Another label')
+        subject.tag_table.update_table(site_id: 'site', tag_id: 2, label: 'Much label')
+        subject.routing_table.update_table(site_id: 'site', device_id: 'device', tag_ids: [0,2])
+      end
+
+      it 'resolves tags' do
+        subject.tags_for_device_id('device').should == ['Some label', 'Much label']
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,52 @@
+require 'bundler'
+Bundler.require
+require 'pry'
+
+require 'lifx'
+require 'lifx/utilities'
+
+shared_context 'integration', integration: true do
+  def lifx
+    $lifx ||= begin
+      c = LIFX::Client.lan
+      begin
+        c.discover! do
+          c.tags.include?('Test') && c.lights.with_tag('Test').count > 0
+        end
+      rescue Timeout::Error
+        raise "Could not find any lights with tag Test in #{c.lights.inspect}"
+      end
+      c
+    end
+  end
+
+  def flush
+    lifx.flush
+  end
+
+  def wait(timeout: 5, retry_wait: 0.1, &block)
+    Timeout.timeout(timeout) do
+      begin
+        block.call
+      rescue RSpec::Expectations::ExpectationNotMetError
+        sleep(retry_wait)
+        retry
+      end
+    end
+  rescue Timeout::Error
+    block.call
+  end
+
+  let(:lights) { lifx.lights.with_tag('Test') }
+  let(:light) { lights.first }
+end
+
+if ENV['DEBUG']
+  LIFX::Config.logger = Yell.new(STDERR)
+end
+
+RSpec.configure do |config|
+  config.formatter = 'documentation'
+  config.color = true
+end
+

data/spec/transport/udp_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe LIFX::Transport::UDP do
+  let(:port) { 45828 }
+  subject do
+    LIFX::Transport::UDP.new('localhost', port)
+  end
+
+  describe '#write' do
+    let(:message) { double }
+    let(:payload) { double }
+    it 'writes a Message to specified host' do
+      message.should_receive(:pack).and_return(payload)
+      UDPSocket.any_instance.should_receive(:send).with(payload, 0, 'localhost', port)
+      subject.write(message)
+    end
+  end
+
+  describe '#listen' do
+    let(:raw_message) { 'some binary data' }
+    let(:message) { double }
+    let(:socket) { UDPSocket.new }
+
+    it 'listens to the specified socket data, unpacks it and notifies observers' do
+      messages = []
+      subject.add_observer(self) do |message:, ip:, transport:|
+        messages << message
+      end
+      subject.listen
+
+      LIFX::Message.should_receive(:unpack).with(raw_message).and_return(message)
+      socket.send(raw_message, 0, 'localhost', port)
+      sleep 0.01
+      messages.should include(message)
+    end
+
+  end
+end

data/spec/transport_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe LIFX::Transport do
+  # Transport handles communicating to the bulbs
+  # UDP, TCP, Cloud
+
+  describe 'initialize' do
+    it 'takes an host and port' do
+      transport = LIFX::Transport.new('127.0.0.1', 31337)
+      transport.host.should == '127.0.0.1'
+      transport.port.should == 31337
+    end
+  end
+end