lifx 0.4.3 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 328ec4e4baf7ab42dc06ee0b0c7b7ae751eb58cb
-  data.tar.gz: adbb24f3dbf7e2c3bfd02d28d19d1f7272c1ae68
+  metadata.gz: f5454b2eb54cd767b3967cf5a6846ec306522599
+  data.tar.gz: 43f84ba663f3beece220825ca095d59417f6ab78
 SHA512:
-  metadata.gz: 1db446d2f25add2a0d822c727f3ed0ef9a4c273b937bf09e8b3018728396535892e0ac4b756740b44db1b8de2e2592b41846e875f500323069e05878483961ce
-  data.tar.gz: 377409d24f13ff4600d7505b11e58ba6afde843c7df135b3c3bebe3d95a8d8b17606f7fe41dc4a80fd6a90d71cbec318574a4a450a7fabde896da3cf712fecf2
+  metadata.gz: 918213bcae91fd85b24f90b5db998b46e9064dbcecf8ac6929bfcd9a697c5511c8ca0efac5e87570274db43491a0b499584fa45fdf15e8b712b0b5a2272622ef
+  data.tar.gz: a198a724a716d6444cdca5ba117d633ddc94c030dff4b3d31f49166740ec5009e6dda07dcda9760dcd5a5083426c48fee60515daaf582d90e9b6188aee112e71

data/CHANGES.md

@@ -0,0 +1,7 @@
+# 0.4.4
+
+- Fix SO_REUSEPORT issue on older Linux kernels.
+
+# 0.4.3
+
+- Initial public release

data/README.md

@@ -13,6 +13,7 @@ This gem is in an early beta state. Expect breaking API changes.
 
 * Ruby 2.1.1
 * Bundler
+* Tested on OS X Mavericks, but should work other *nix platforms. Please file an issue if you have any problems.
 
 ## Installation
 

data/lib/lifx/transport/udp.rb

@@ -33,7 +33,7 @@ module LIFX
         @listener = Thread.new do
           reader = UDPSocket.new
           reader.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
-          reader.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, true)
+          reader.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, true) if Socket.const_defined?('SO_REUSEPORT')
           reader.bind(ip, port)
           loop do
             begin

data/lib/lifx/version.rb

@@ -1,3 +1,3 @@
 module LIFX
-  VERSION = "0.4.3"
+  VERSION = "0.4.4"
 end

data/spec/color_spec.rb

@@ -3,42 +3,23 @@ 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]
+        shared_examples 'translating color' do |name, rgb, expected|
+          it "translates #{name} correctly" do
+            translation = Color.rgb(*rgb).to_a
+            expect(translation).to eq [*expected, default_kelvin]
+          end
         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
+        it_behaves_like 'translating color', 'red',    [255, 0, 0],     [0, 1, 1]
+        it_behaves_like 'translating color', 'yellow', [255, 255, 0],   [60, 1, 1]
+        it_behaves_like 'translating color', 'green',  [0, 255, 0],     [120, 1, 1]
+        it_behaves_like 'translating color', 'cyan',   [0, 255, 255],   [180, 1, 1]
+        it_behaves_like 'translating color', 'blue',   [0, 0, 255],     [240, 1, 1]
+        it_behaves_like 'translating color', 'white',  [255, 255, 255], [0, 0, 1]
+        it_behaves_like 'translating color', 'black',  [0, 0, 0],       [0, 0, 0]
       end
     end
   end

data/spec/gateway_connection_spec.rb

@@ -2,30 +2,26 @@ require 'spec_helper'
 
 module LIFX
   describe GatewayConnection do
-    subject do
-      GatewayConnection.new
-    end
+    subject(:gateway) { GatewayConnection.new }
 
-    let(:message) { double(Message).tap { |m| m.stub(:is_a?).and_return(true); m.stub(:pack) } }
+    let(:message) { double(Message, is_a?: true, pack: '') }
     let(:ip) { '127.0.0.1' }
-    let(:port) { 35003 }
+    let(:port) { 35_003 }
 
-    after do
-      subject.close
-    end
+    after { gateway.close }
 
     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)
+        expect(gateway).to_not receive(:actually_write)
+        gateway.write(message)
+        expect { gateway.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
+        gateway.connect_udp(ip, port)
+        expect(gateway).to receive(:actually_write).and_return(false, true)
+        gateway.write(message)
+        gateway.flush
       end
     end
   end

data/spec/integration/client_spec.rb

@@ -3,35 +3,35 @@ require 'spec_helper'
 module LIFX
   describe Client, integration: true do
     describe '#sync' do
+      let(:minimum_lights) { 3 }
+      let(:udp) { Transport::UDP.new('0.0.0.0', 56_750) }
+      let(:white) { Color.white(brightness: 0.5) }
+
       it 'schedules sending all messages to be executed at the same time' do
-        if lights.count < 3
-          pending "This test requires 3 or more lights tagged under Test"
+        if lights.count < minimum_lights
+          pending 'This test requires 3 or more lights tagged under Test'
           return
         end
 
-        lifx.discover! do
-          lights.count >= 3
-        end
+        lifx.discover! { lights.count >= minimum_lights }
 
-        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
+        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
+        expect(msgs.count).to eq lights.count
+        expect(msgs.map(&:at_time).uniq.count).to eq 1
 
         flush
       end

data/spec/integration/light_spec.rb

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

data/spec/integration/tags_spec.rb

@@ -1,31 +1,33 @@
 require 'spec_helper'
 
 module LIFX
-  describe "tags", integration: true do
-    it 'Clearing, setting and using tags' do
+  describe 'tags', integration: true do
+    let(:color) { Color.hsb(rand(360), 0.3, 0.3) }
+
+    specify 'Clearing, setting and using tags' do
       light.add_tag('Foo')
-      light.tags.should include('Foo')
+      expect(light.tags).to 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) 
+      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
+              # It also returns the current light state rather than the
+              # final state
       light.refresh
-      wait { light.color.should == color }
+      wait { expect(light.color).to eq color }
 
       light.remove_tag('Foo')
-      wait { light.tags.should_not include('Foo') }
+      wait { expect(light.tags).not_to 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')
+      expect(lifx.unused_tags).to include('TempTag')
       lifx.purge_unused_tags!
-      lifx.unused_tags.should be_empty
+      expect(lifx.unused_tags).to be_empty
     end
   end
 end

data/spec/light_collection_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module LIFX
+  describe LightCollection do
+    subject(:collection) { LightCollection.new(context: double) }
+
+    describe '#with_id' do
+      it 'returns a Light with matching id' do
+        light = double(Light, id: 'id')
+        collection.stub(lights: [light])
+        expect(collection.with_id('id')).to eq light
+      end
+
+      it 'returns nil when none matches' do
+        light = double(Light, id: 'id')
+        collection.stub(lights: [light])
+        ret = collection.with_id('wrong id')
+        expect(ret).to eq nil
+      end
+    end
+
+    describe '#with_label' do
+      it 'returns a Light with matching label' do
+        light = double(Light, label: 'label')
+        collection.stub(lights: [light])
+        expect(collection.with_label('label')).to eq light
+      end
+
+      it 'returns nil' do
+        light = double(Light, label: 'label')
+        collection.stub(lights: [light])
+        ret = collection.with_label('wrong label')
+        expect(ret).to eq nil
+      end
+    end
+  end
+end

data/spec/message_spec.rb

@@ -2,53 +2,58 @@ 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(:data) do
+      "\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
+    end
     let(:msg) { LIFX::Message.unpack(data) }
 
     it 'unpacks without errors' do
-      msg.should_not be_nil
+      expect(msg).not_to be_nil
     end
 
     it 'returns the correct frame data' do
-      msg.msg_size.should == 57
-      msg.protocol.should == 1024
-      msg.addressable?.should == true
+      expect(msg.msg_size).to eq 57
+      expect(msg.protocol).to eq 1024
+      expect(msg).to be_addressable
     end
 
     it 'returns the correct address data' do
-      msg.raw_site.should == '1lifx1'
-      msg.raw_target.should == "\x00" * 8
+      expect(msg.raw_site).to eq '1lifx1'
+      expect(msg.raw_target).to eq "\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
+      expect(msg.path).to be_a(LIFX::ProtocolPath)
+      expect(msg.path.site_id).to eq '316c69667831'
+      expect(msg.path.tag_ids).to eq []
+      expect(msg.path.device_id).to be_nil
     end
 
     it 'returns the correct metadata' do
-      msg.at_time.should == 0
-      msg.type.should == 103
+      expect(msg.at_time).to eq 0
+      expect(msg.type).to eq 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
+      expect(payload.class).to eq LIFX::Protocol::Light::SetWaveform
+      expect(payload.stream).to eq 0
+      expect(payload.transient).to be_true
+      expect(payload.color.hue).to eq 0
+      expect(payload.color.saturation).to eq 65_535
+      expect(payload.color.brightness).to eq 65_535
+      expect(payload.color.kelvin).to eq 3_500
+      expect(payload.period).to eq 200
+      expect(payload.cycles).to eq 1.0
+      expect(payload.duty_cycle).to eq 0
+      expect(payload.waveform).to eq 0
     end
 
     it 'repacks to the same data' do
-      msg.pack.should == data
+      expect(msg.pack).to eq data
     end
   end
 
@@ -72,42 +77,50 @@ describe LIFX::Message do
     context 'passed in via hash' do
       let(:msg) do
         LIFX::Message.new({
-          path: LIFX::ProtocolPath.new(tagged: false, raw_target: "abcdefgh"),
+          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!",
+            ssid: 'who let the dogs out',
+            pass: 'woof, woof, woof woof!',
             security: 1
           )
         })
       end
+      # let(:unpacked) { LIFX::Message.unpack(msg.pack) }
 
       it 'sets the size' do
-        msg.msg_size.should == 134
+        expect(msg.msg_size).to eq 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
+        expect(msg.pack).to eq "\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
+        expect(msg.protocol).to eq 1024
+        expect(msg.path).not_to be_tagged
+        expect(msg).to be_addressable
+        expect(msg.path.raw_target).to eq 'abcdefgh'
+        expect(msg.at_time).to eq 9001
+        expect(msg.type).to eq 305
+        expect(msg.payload.class).to eq LIFX::Protocol::Wifi::SetAccessPoint
+        expect(msg.payload.interface).to eq 1
+        expect(msg.payload.ssid).to eq 'who let the dogs out'
+        expect(msg.payload.pass).to eq 'woof, woof, woof woof!'
+        expect(msg.payload.security).to eq 1
       end
     end
 
     context 'packing with tags' do
       let(:msg) do
         LIFX::Message.new({
-          path: LIFX::ProtocolPath.new(tag_ids: [0,1]),
+          path: LIFX::ProtocolPath.new(tag_ids: [0, 1]),
           at_time: 9001,
           payload: LIFX::Protocol::Device::GetTime.new
         })
@@ -116,19 +129,22 @@ describe LIFX::Message do
       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
+        expect(msg.pack).to eq "$\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
+        expect(unpacked.path).to be_tagged
       end
 
       it 'sets tags' do
-        unpacked.path.tag_ids.should == [0, 1]
+        expect(unpacked.path.tag_ids).to eq [0, 1]
       end
 
       it 'device should be nil' do
-        unpacked.path.device_id.should == nil
+        expect(unpacked.path.device_id).to be_nil
       end
     end
 
@@ -144,19 +160,21 @@ describe LIFX::Message do
       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
+        expect(msg.pack).to eq "$\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
+        expect(unpacked.path).not_to be_tagged
       end
 
       it 'sets device' do
-        unpacked.path.device_id.should == '0123456789ab'
+        expect(unpacked.path.device_id).to eq '0123456789ab'
       end
 
       it 'tags should be nil' do
-        unpacked.path.tag_ids.should == nil
+        expect(unpacked.path.tag_ids).to be_nil
       end
     end
   end

data/spec/protocol_path_spec.rb

@@ -3,47 +3,49 @@ require 'spec_helper'
 module LIFX
   describe ProtocolPath do
     describe 'initializing from raw data' do
+      subject do
+        ProtocolPath.new(raw_site: '1lifx1', raw_target: target, tagged: tagged)
+      end
+
       context 'device target' do
-        subject do
-          ProtocolPath.new(raw_site: "1lifx1", raw_target: "\xAB\xCD\xEF\x12\x34\x56\x00\x00", tagged: false)
-        end
+        let(:target) { "\xAB\xCD\xEF\x12\x34\x56\x00\x00" }
+        let(:tagged) { false }
 
         it 'returns site_id in hex' do
-          subject.site_id.should == "316c69667831"
+          expect(subject.site_id).to eq '316c69667831'
         end
 
         it 'returns device_id in hex' do
-          subject.device_id.should == 'abcdef123456'
+          expect(subject.device_id).to eq 'abcdef123456'
         end
 
         it 'returns tagged as false' do
-          subject.tagged?.should be_false
+          expect(subject).not_to be_tagged
         end
 
         it 'returns nil for tag_ids' do
-          subject.tag_ids.should == nil
+          expect(subject.tag_ids).to be_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
+        let(:target) { "\x03\x00\x00\x00\x00\x00\x00\x00" }
+        let(:tagged) { true }
 
         it 'returns site_id in hex' do
-          subject.site_id.should == "316c69667831"
+          expect(subject.site_id).to eq '316c69667831'
         end
 
         it 'returns device_id as nil' do
-          subject.device_id.should == nil
+          expect(subject.device_id).to be_nil
         end
 
         it 'returns tagged as true' do
-          subject.tagged?.should be_true
+          expect(subject).to be_tagged
         end
 
         it 'returns the tag_ids' do
-          subject.tag_ids.should == [0, 1]
+          expect(subject.tag_ids).to eq [0, 1]
         end
       end
     end
@@ -51,11 +53,11 @@ module LIFX
     describe 'initializing from strings' do
       context 'device target' do
         subject do
-          ProtocolPath.new(site_id: "316c69667831", device_id: 'abcdef123456')
+          ProtocolPath.new(site_id: '316c69667831', device_id: 'abcdef123456')
         end
 
         it 'sets raw_site correctly' do
-          subject.raw_site.should == "1lifx1"
+          expect(subject.raw_site).to eq '1lifx1'
         end
 
         it 'sets raw_target correctly' do
@@ -69,41 +71,37 @@ module LIFX
 
       context 'tagged target' do
         subject do
-          ProtocolPath.new(site_id: "316c69667831", tag_ids: [0, 1])
+          ProtocolPath.new(site_id: '316c69667831', tag_ids: [0, 1])
         end
 
         it 'sets raw_site properly' do
-          subject.raw_site.should == "1lifx1"
+          expect(subject.raw_site).to eq '1lifx1'
         end
 
         it 'sets raw_target correctly' do
-          subject.raw_target.should == "\x03\x00\x00\x00\x00\x00\x00\x00".b
+          expect(subject.raw_target).to eq "\x03\x00\x00\x00\x00\x00\x00\x00".b
         end
 
         it 'returns tagged as true' do
-          subject.tagged?.should be_true
+          expect(subject).to be_tagged
         end
       end
 
       context 'tagged target with no site' do
-        subject do
-          ProtocolPath.new(tagged: true)
-        end
+        subject { ProtocolPath.new(tagged: true) }
 
         it 'raw_site should be null string' do
-          subject.raw_site.should == "\x00\x00\x00\x00\x00\x00".b
+          expect(subject.raw_site).to eq "\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
+          expect(subject.raw_target).to eq "\x00\x00\x00\x00\x00\x00\x00\x00".b
         end
 
         it 'returns tagged as true' do
-          subject.tagged?.should be_true
+          expect(subject).to be_tagged
         end
       end
-
     end
-
   end
-end
+end

data/spec/routing_manager_spec.rb

@@ -3,19 +3,20 @@ require 'spec_helper'
 module LIFX
   describe RoutingManager do
     describe '#tags_for_device_id' do
-      subject do
-        RoutingManager.new(context: double)
-      end
+      subject(:manager) { RoutingManager.new(context: double) }
 
       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])
+        ['Some label', 'Another label', 'Much label'].each_with_index do |lbl, i|
+          manager.tag_table.update_table(site_id: 'site', tag_id: i, label: lbl)
+        end
+
+        manager.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']
+        tags = manager.tags_for_device_id('device')
+        expect(tags).to eq ['Some label', 'Much label']
       end
     end
   end

data/spec/spec_helper.rb

@@ -41,12 +41,9 @@ shared_context 'integration', integration: true do
   let(:light) { lights.first }
 end
 
-if ENV['DEBUG']
-  LIFX::Config.logger = Yell.new(STDERR)
-end
+LIFX::Config.logger = Yell.new(STDERR) if ENV['DEBUG']
 
 RSpec.configure do |config|
   config.formatter = 'documentation'
   config.color = true
 end
-

data/spec/transport/udp_spec.rb

@@ -1,38 +1,40 @@
 require 'spec_helper'
 
 describe LIFX::Transport::UDP do
-  let(:port) { 45828 }
-  subject do
-    LIFX::Transport::UDP.new('localhost', port)
-  end
+  subject(:udp) { LIFX::Transport::UDP.new(host, port) }
+
+  let(:host) { 'localhost' }
+  let(:message) { double }
+  let(:port) { 45_828 }
 
   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)
+      expect(message).to receive(:pack).and_return(payload)
+      expect_any_instance_of(UDPSocket).to receive(:send)
+                                           .with(payload, 0, host, port)
+      udp.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:|
+      udp.add_observer(self) do |message:, ip:, transport:|
         messages << message
       end
-      subject.listen
+      udp.listen
 
-      LIFX::Message.should_receive(:unpack).with(raw_message).and_return(message)
-      socket.send(raw_message, 0, 'localhost', port)
+      expect(LIFX::Message).to receive(:unpack)
+                               .with(raw_message)
+                               .and_return(message)
+      socket.send(raw_message, 0, host, port)
       sleep 0.01
-      messages.should include(message)
+      expect(messages).to include(message)
     end
-
   end
 end

data/spec/transport_spec.rb

@@ -6,9 +6,9 @@ describe LIFX::Transport do
 
   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
+      transport = LIFX::Transport.new('127.0.0.1', 31_337)
+      expect(transport.host).to eq '127.0.0.1'
+      expect(transport.port).to eq 31_337
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lifx
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.4
 platform: ruby
 authors:
 - Jack Chen (chendo)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-24 00:00:00.000000000 Z
+date: 2014-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bindata
@@ -118,6 +118,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".yardopts"
+- CHANGES.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -177,6 +178,7 @@ files:
 - spec/integration/client_spec.rb
 - spec/integration/light_spec.rb
 - spec/integration/tags_spec.rb
+- spec/light_collection_spec.rb
 - spec/message_spec.rb
 - spec/protocol_path_spec.rb
 - spec/routing_manager_spec.rb
@@ -215,6 +217,7 @@ test_files:
 - spec/integration/client_spec.rb
 - spec/integration/light_spec.rb
 - spec/integration/tags_spec.rb
+- spec/light_collection_spec.rb
 - spec/message_spec.rb
 - spec/protocol_path_spec.rb
 - spec/routing_manager_spec.rb