hacky_hal 0.2.4 → 0.2.5

data/hacky_hal.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |gem|
   gem.name    = "hacky_hal"
-  gem.version = "0.2.4"
+  gem.version = "0.2.5"
 
   gem.authors     = ["Nick Ewing"]
   gem.email       = ["nick@nickewing.net"]
@@ -18,5 +18,5 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(/^spec/)
   gem.require_paths = ["lib"]
 
-  gem.license = 'MIT'
+  gem.license = "MIT"
 end

data/lib/hacky_hal/device_controllers/epson_projector.rb

@@ -78,11 +78,11 @@ module HackyHAL
         @model = options[:model]
       end
 
-      def on
+      def power
         power_status == :on
       end
 
-      def on=(value)
+      def set_power(value)
         value = value ? "ON" : "OFF"
         write_command("PWR #{value}")
         read_command(1)
@@ -109,7 +109,7 @@ module HackyHAL
         {id: source_id, name: source_name}
       end
 
-      def source=(source_id)
+      def set_source(source_id)
         write_command("SOURCE #{source_id}")
         read_command(SOURCE_COMMAND_TIMEOUT)
       end
@@ -124,7 +124,7 @@ module HackyHAL
         {id: color_mode_id, name: color_mode_name}
       end
 
-      def color_mode=(color_mode_id)
+      def set_color_mode(color_mode_id)
         write_command("CMODE #{color_mode_id}")
         read_command
       end
@@ -139,7 +139,7 @@ module HackyHAL
         {id: aspect_ratio_id, name: aspect_ratio_name}
       end
 
-      def aspect_ratio=(aspect_ratio_id)
+      def set_aspect_ratio(aspect_ratio_id)
         write_command("ASPECT #{aspect_ratio_id}")
         read_command
       end

data/lib/hacky_hal/device_controllers/generic_ssh.rb

@@ -1,4 +1,4 @@
-require 'net/ssh'
+require "net/ssh"
 require_relative "base"
 
 module HackyHAL
@@ -50,7 +50,7 @@ module HackyHAL
       end
 
       def connected?
-        @ssh && !@ssh.closed?
+        !!(@ssh && !@ssh.closed?)
       end
 
       def disconnect

data/lib/hacky_hal/device_controllers/io_gear_avior_hdmi_switch.rb

@@ -17,7 +17,7 @@ module HackyHAL
         super(options)
       end
 
-      def input=(value)
+      def set_input(value)
         unless value.is_a?(Fixnum)
           raise ArgumentError, "Input value must be an integer."
         end
@@ -41,7 +41,7 @@ module HackyHAL
         read_command
       end
 
-      def power_on_detection=(value)
+      def set_power_on_detection(value)
         value = value ? "on" : "off"
         write_command("pod #{value}")
         read_command

data/lib/hacky_hal/device_controllers/yamaha_av_receiver.rb

@@ -104,7 +104,7 @@ module HackyHAL
         response.elements["YAMAHA_AV/Main_Zone/Input/Input_Sel"].text
       end
 
-      def input=(input_name)
+      def set_input(input_name)
         put_request(%|<Main_Zone><Input><Input_Sel>#{input_name}</Input_Sel></Input></Main_Zone>|)
       end
 
@@ -118,12 +118,12 @@ module HackyHAL
         put_request(%|<System><Sound_Video><HDMI><Output><#{output_name}>#{value}</#{output_name}></Output></HDMI></Sound_Video></System>|)
       end
 
-      def on
+      def power
         response = get_request("<Main_Zone><Power_Control><Power>GetParam</Power></Power_Control></Main_Zone>")
         response.elements["YAMAHA_AV/Main_Zone/Power_Control/Power"].text == "On"
       end
 
-      def on=(value)
+      def set_power(value)
         value = value ? "On" : "Standby"
         put_request("<Main_Zone><Power_Control><Power>#{value}</Power></Power_Control></Main_Zone>")
       end
@@ -133,7 +133,7 @@ module HackyHAL
         element_volume_value(response.elements["YAMAHA_AV/Main_Zone/Volume/Lvl/Val"])
       end
 
-      def volume=(value)
+      def set_volume(value)
         value = (value * 10.0).to_i.to_s
         response = put_request("<Main_Zone><Volume><Lvl><Val>#{value}</Val><Exp>1</Exp><Unit>dB</Unit></Lvl></Volume></Main_Zone>")
       end
@@ -143,7 +143,7 @@ module HackyHAL
         element_on?(response.elements["YAMAHA_AV/Main_Zone/Volume/Mute"])
       end
       
-      def mute=(value)
+      def set_mute(value)
         value = case value
                 when true then "On"
                 when false then "Off"
@@ -158,7 +158,7 @@ module HackyHAL
         response.elements["YAMAHA_AV/Main_Zone/Surround/Program_Sel/Current/Sound_Program"].text
       end
 
-      def sound_program=(program_name)
+      def set_sound_program(program_name)
         response = put_request("<Main_Zone><Surround><Program_Sel><Current><Sound_Program>#{program_name}</Sound_Program></Current></Program_Sel></Surround></Main_Zone>")
         puts response
         # response.elements["YAMAHA_AV/Main_Zone/Surround/Program_Sel/Current/Sound_Program"].text

data/lib/hacky_hal/registry.rb

@@ -1,4 +1,5 @@
 require "singleton"
+require "yaml"
 require_relative "util"
 
 module HackyHAL

data/spec/hacky_hal/device_controllers/base_spec.rb

@@ -3,13 +3,13 @@ require "hacky_hal/device_controllers/base"
 
 describe HackyHAL::DeviceControllers::Base do
   it "should include Options" do
-    described_class.ancestors.should include(HackyHAL::Options)
+    expect(described_class.ancestors).to include(HackyHAL::Options)
   end
 
   describe "#log" do
     it "should log to HackyHAL::Log with device name" do
       controller = described_class.new(name: "dummy device")
-      HackyHAL::Log.instance.should_receive(:info).with("dummy device: dummy message")
+      expect(HackyHAL::Log.instance).to receive(:info).with("dummy device: dummy message")
       controller.log("dummy message", :info)
     end
   end

data/spec/hacky_hal/device_controllers/generic_serial_port_spec.rb

@@ -4,51 +4,51 @@ require "hacky_hal/device_controllers/generic_serial_port"
 describe HackyHAL::DeviceControllers::GenericSerialPort do
   before(:each) do
     @serial_port = double("serial port")
-    @serial_port.stub(:read_timeout=)
-    @serial_port.stub(:baud=)
-    @serial_port.stub(:data_bits=)
-    @serial_port.stub(:stop_bits=)
-    @serial_port.stub(:parity=)
-    @serial_port.stub(:flow_control=)
+    allow(@serial_port).to receive(:read_timeout=)
+    allow(@serial_port).to receive(:baud=)
+    allow(@serial_port).to receive(:data_bits=)
+    allow(@serial_port).to receive(:stop_bits=)
+    allow(@serial_port).to receive(:parity=)
+    allow(@serial_port).to receive(:flow_control=)
 
     @serial_device_path = "/dev/foo0"
     @generic_serial_port = described_class.new(serial_device_path: @serial_device_path)
 
-    SerialPort.stub(:new).and_return(@serial_port)
+    allow(SerialPort).to receive(:new).and_return(@serial_port)
   end
 
   describe "#write_command" do
     before(:each) do
-      @serial_port.stub(:flush)
+      allow(@serial_port).to receive(:flush)
     end
 
     it "should write to the serial port" do
-      @serial_port.should_receive(:write).with("foobar\r\n")
+      expect(@serial_port).to receive(:write).with("foobar\r\n")
       @generic_serial_port.write_command("foobar")
     end
 
     it "should return true on successful run" do
-      @serial_port.should_receive(:write)
-      @generic_serial_port.write_command("foobar").should be_true
+      expect(@serial_port).to receive(:write)
+      expect(@generic_serial_port.write_command("foobar")).to be true
     end
 
     it "should retry after rescuing from an Errno::EIO" do
-      @generic_serial_port.should_receive(:disconnect)
+      expect(@generic_serial_port).to receive(:disconnect)
 
       retries = 0
-      @serial_port.stub(:write) do
+      allow(@serial_port).to receive(:write) do
         if retries < HackyHAL::DeviceControllers::GenericSerialPort::MAX_READ_WRITE_RETRIES
           retries += 1
           raise Errno::EIO
         end
       end
 
-      @generic_serial_port.write_command("foobar").should be_true
+      expect(@generic_serial_port.write_command("foobar")).to be true
     end
 
     it "should raise Errno::EIO if retry failed" do
-      @serial_port.stub(:write) { raise Errno::EIO }
-      @serial_port.stub(:close)
+      allow(@serial_port).to receive(:write) { raise Errno::EIO }
+      allow(@serial_port).to receive(:close)
 
       expect {
         @generic_serial_port.write_command("foobar")
@@ -56,47 +56,47 @@ describe HackyHAL::DeviceControllers::GenericSerialPort do
     end
 
     it "should log debug message" do
-      @serial_port.stub(:write)
-      @generic_serial_port.should_receive(:log).with("Wrote: \"foobar\\r\\n\"", :debug)
+      allow(@serial_port).to receive(:write)
+      expect(@generic_serial_port).to receive(:log).with("Wrote: \"foobar\\r\\n\"", :debug)
       @generic_serial_port.write_command("foobar")
     end
   end
 
   describe "#read_command" do
     it "should return read string on successful run" do
-      @serial_port.stub(:readline).and_return("a return string")
-      @generic_serial_port.read_command.should == "a return string"
+      allow(@serial_port).to receive(:readline).and_return("a return string")
+      expect(@generic_serial_port.read_command).to eq "a return string"
     end
 
     it "should set the serial port read timeout to given value" do
-      @serial_port.stub(:readline)
-      @serial_port.should_receive(:read_timeout=).with(12000)
+      allow(@serial_port).to receive(:readline)
+      expect(@serial_port).to receive(:read_timeout=).with(12000)
       @generic_serial_port.read_command(12)
     end
 
     it "should call handle_error if error_response?(response) is true" do
-      @serial_port.stub(:readline)
-      @generic_serial_port.stub(:error_response?).and_return(true)
-      @generic_serial_port.should_receive(:handle_error)
+      allow(@serial_port).to receive(:readline)
+      allow(@generic_serial_port).to receive(:error_response?).and_return(true)
+      expect(@generic_serial_port).to receive(:handle_error)
       @generic_serial_port.read_command
     end
 
     it "should rescue EOFError and return nil" do
-      @serial_port.stub(:readline) { raise EOFError }
-      @generic_serial_port.read_command.should be_nil
+      allow(@serial_port).to receive(:readline) { raise EOFError }
+      expect(@generic_serial_port.read_command).to be nil
     end
 
     it "should rescue EOFError and log warn message" do
-      @serial_port.stub(:readline) { raise EOFError }
-      @generic_serial_port.should_receive(:log).with("Read EOFError", :warn)
+      allow(@serial_port).to receive(:readline) { raise EOFError }
+      expect(@generic_serial_port).to receive(:log).with("Read EOFError", :warn)
       @generic_serial_port.read_command
     end
 
     it "should retry after rescuing from an Errno::EIO" do
-      @generic_serial_port.should_receive(:disconnect)
+      expect(@generic_serial_port).to receive(:disconnect)
 
       retries = 0
-      @serial_port.stub(:readline) do
+      allow(@serial_port).to receive(:readline) do
         if retries < HackyHAL::DeviceControllers::GenericSerialPort::MAX_READ_WRITE_RETRIES
           retries += 1
           raise Errno::EIO
@@ -105,12 +105,12 @@ describe HackyHAL::DeviceControllers::GenericSerialPort do
         end
       end
 
-      @generic_serial_port.read_command.should == "a return string"
+      expect(@generic_serial_port.read_command).to eq "a return string"
     end
 
     it "should raise Errno::EIO if retry failed" do
-      @serial_port.stub(:readline) { raise Errno::EIO }
-      @serial_port.stub(:close)
+      allow(@serial_port).to receive(:readline) { raise Errno::EIO }
+      allow(@serial_port).to receive(:close)
 
       expect {
         @generic_serial_port.read_command
@@ -118,8 +118,8 @@ describe HackyHAL::DeviceControllers::GenericSerialPort do
     end
 
     it "should log debug message" do
-      @serial_port.stub(:readline).and_return("response")
-      @generic_serial_port.should_receive(:log).with("Read: \"response\"", :debug)
+      allow(@serial_port).to receive(:readline).and_return("response")
+      expect(@generic_serial_port).to receive(:log).with("Read: \"response\"", :debug)
       @generic_serial_port.read_command
     end
   end
@@ -127,41 +127,41 @@ describe HackyHAL::DeviceControllers::GenericSerialPort do
   describe "#disconnect" do
     it "should close serial port if serial port is set" do
       @generic_serial_port.serial_port # make sure serial port is set
-      @serial_port.should_receive(:close)
+      expect(@serial_port).to receive(:close)
       @generic_serial_port.disconnect
     end
 
     it "should not attempt to close serial port if serial port is not set" do
-      @generic_serial_port.stub(:serial_port).and_return(nil)
+      allow(@generic_serial_port).to receive(:serial_port).and_return(nil)
       @generic_serial_port.disconnect
     end
 
     it "should set serial_port to nil" do
       @generic_serial_port.serial_port # make sure serial port is set
-      @serial_port.should_receive(:close)
+      expect(@serial_port).to receive(:close)
       @generic_serial_port.disconnect
-      SerialPort.should_receive(:new)
+      expect(SerialPort).to receive(:new)
       @generic_serial_port.serial_port
     end
   end
 
   describe "#serial_port" do
     it "should create new SerialPort" do
-      SerialPort.should_receive(:new).with(@serial_device_path).and_return(@serial_port)
-      @generic_serial_port.stub(:serial_options).and_return(
+      expect(SerialPort).to receive(:new).with(@serial_device_path).and_return(@serial_port)
+      allow(@generic_serial_port).to receive(:serial_options).and_return(
         baud_rate: 50,
         data_bits: 5,
         stop_bits: 2,
         parity: SerialPort::EVEN,
         flow_control: SerialPort::HARD
       )
-      @serial_port.should_receive(:baud=).with(50)
-      @serial_port.should_receive(:data_bits=).with(5)
-      @serial_port.should_receive(:stop_bits=).with(2)
-      @serial_port.should_receive(:parity=).with(SerialPort::EVEN)
-      @serial_port.should_receive(:flow_control=).with(SerialPort::HARD)
+      expect(@serial_port).to receive(:baud=).with(50)
+      expect(@serial_port).to receive(:data_bits=).with(5)
+      expect(@serial_port).to receive(:stop_bits=).with(2)
+      expect(@serial_port).to receive(:parity=).with(SerialPort::EVEN)
+      expect(@serial_port).to receive(:flow_control=).with(SerialPort::HARD)
 
-      @generic_serial_port.serial_port.should == @serial_port
+      expect(@generic_serial_port.serial_port).to eq @serial_port
     end
   end
 end

data/spec/hacky_hal/device_controllers/generic_ssh_spec.rb

@@ -22,60 +22,60 @@ describe HackyHAL::DeviceControllers::GenericSsh do
       )
 
       @ssh = double("ssh connection")
-      @ssh.stub(:exec!).and_yield(nil, nil, "dummy output")
-      @ssh.stub(:close)
-      @ssh.stub(:closed?).and_return(false)
-      Net::SSH.stub(:start).and_return(@ssh)
+      allow(@ssh).to receive(:exec!).and_yield(nil, nil, "dummy output")
+      allow(@ssh).to receive(:close)
+      allow(@ssh).to receive(:closed?).and_return(false)
+      allow(Net::SSH).to receive(:start).and_return(@ssh)
     end
 
     describe "#exec" do
       it "should pass command to ssh.exec!" do
-        @ssh.should_receive(:exec!).with("dummy_command")
+        expect(@ssh).to receive(:exec!).with("dummy_command")
         @generic_ssh.exec("dummy_command")
       end
 
       it "should connect if not connected" do
-        @generic_ssh.should_receive(:connected?).and_return(false)
-        @generic_ssh.should_receive(:connect)
-        @generic_ssh.stub(:ssh_exec)
-        @generic_ssh.stub(:disconnect)
+        expect(@generic_ssh).to receive(:connected?).and_return(false)
+        expect(@generic_ssh).to receive(:connect)
+        allow(@generic_ssh).to receive(:ssh_exec)
+        allow(@generic_ssh).to receive(:disconnect)
         @generic_ssh.exec("dummy_command")
       end
 
       it "should not connect if already connected" do
-        @generic_ssh.should_receive(:connected?).and_return(true)
-        @generic_ssh.should_not_receive(:connect)
-        @generic_ssh.stub(:ssh_exec)
-        @generic_ssh.stub(:disconnect)
+        expect(@generic_ssh).to receive(:connected?).and_return(true)
+        expect(@generic_ssh).not_to receive(:connect)
+        allow(@generic_ssh).to receive(:ssh_exec)
+        allow(@generic_ssh).to receive(:disconnect)
         @generic_ssh.exec("dummy_command")
       end
 
       it "should join output from ssh.exec!" do
-        @ssh.stub(:exec!).and_yield(nil, nil, "foo").and_yield(nil, nil, "bar")
-        @generic_ssh.exec("dummy_command").should == "foobar"
+        allow(@ssh).to receive(:exec!).and_yield(nil, nil, "foo").and_yield(nil, nil, "bar")
+        expect(@generic_ssh.exec("dummy_command")).to eq "foobar"
       end
 
       it "should log debug message" do
-        @generic_ssh.should_receive(:log).with("Command: \"dummy_command\"", :debug)
-        @generic_ssh.should_receive(:log).with("Output: \"dummy output\"", :debug)
+        expect(@generic_ssh).to receive(:log).with("Command: \"dummy_command\"", :debug)
+        expect(@generic_ssh).to receive(:log).with("Output: \"dummy output\"", :debug)
         @generic_ssh.exec("dummy_command")
       end
 
       describe "on command failure" do
         before(:each) do
-          @generic_ssh.stub(:ssh_exec).and_raise(EOFError.new("foo"))
+          allow(@generic_ssh).to receive(:ssh_exec).and_raise(EOFError.new("foo"))
         end
 
         it "should log warn message" do
-          @generic_ssh.should_receive(:log).with("Command: \"dummy_command\"", :debug).twice
-          @generic_ssh.should_receive(:log).with("Command failed: EOFError - foo", :warn).twice
-          @generic_ssh.should_receive(:log).with("Retrying last command", :warn).once
+          expect(@generic_ssh).to receive(:log).with("Command: \"dummy_command\"", :debug).twice
+          expect(@generic_ssh).to receive(:log).with("Command failed: EOFError - foo", :warn).twice
+          expect(@generic_ssh).to receive(:log).with("Retrying last command", :warn).once
           @generic_ssh.exec("dummy_command")
         end
 
         it "should retry once after reconnecting" do
-          @generic_ssh.should_receive(:disconnect).twice
-          @generic_ssh.should_receive(:connect).twice
+          expect(@generic_ssh).to receive(:disconnect).twice
+          expect(@generic_ssh).to receive(:connect).twice
           @generic_ssh.exec("dummy_command")
         end
       end
@@ -84,18 +84,18 @@ describe HackyHAL::DeviceControllers::GenericSsh do
     describe "#connect" do
       it "should disconnect if already connected" do
         @generic_ssh.connect
-        @generic_ssh.should_receive(:disconnect)
+        expect(@generic_ssh).to receive(:disconnect)
         @generic_ssh.connect
       end
 
       it "should open a new Net:SSH connection" do
-        Net::SSH.should_receive(:start)
+        expect(Net::SSH).to receive(:start)
         @generic_ssh.connect
       end
 
       it "should log warn message on error" do
-        Net::SSH.should_receive(:start).and_raise(SocketError.new("dummy message"))
-        @generic_ssh.should_receive(:log).with("Failed to connect: SocketError - dummy message", :warn)
+        expect(Net::SSH).to receive(:start).and_raise(SocketError.new("dummy message"))
+        expect(@generic_ssh).to receive(:log).with("Failed to connect: SocketError - dummy message", :warn)
         @generic_ssh.connect
       end
     end
@@ -103,38 +103,38 @@ describe HackyHAL::DeviceControllers::GenericSsh do
     describe "disconnect" do
       it "should close the ssh connection if connected" do
         @generic_ssh.connect
-        @ssh.should_receive(:close)
-        @generic_ssh.disconnect.should be_nil
+        expect(@ssh).to receive(:close)
+        expect(@generic_ssh.disconnect).to be nil
       end
 
       it "should not close the ssh connection if not connected" do
-        @generic_ssh.should_receive(:connected?).and_return(false)
-        @ssh.should_not_receive(:close)
-        @generic_ssh.disconnect.should be_nil
+        expect(@generic_ssh).to receive(:connected?).and_return(false)
+        expect(@ssh).not_to receive(:close)
+        expect(@generic_ssh.disconnect).to be nil
       end
 
       it "should return nil on Net::SSH::Disconnect" do
         @generic_ssh.connect
-        @ssh.should_receive(:close).and_raise(Net::SSH::Disconnect)
-        @generic_ssh.disconnect.should be_nil
+        expect(@ssh).to receive(:close).and_raise(Net::SSH::Disconnect)
+        expect(@generic_ssh.disconnect).to be nil
       end
 
       it "should still disconnect on Net::SSH::Disconnect" do
         @generic_ssh.connect
-        @ssh.should_receive(:close).and_raise(Net::SSH::Disconnect)
+        expect(@ssh).to receive(:close).and_raise(Net::SSH::Disconnect)
         @generic_ssh.disconnect
-        @generic_ssh.connected?.should be_false
+        expect(@generic_ssh.connected?).to be false
       end
     end
 
     describe "connect?" do
       it "should return true if connected" do
         @generic_ssh.connect
-        @generic_ssh.connected?.should be_true
+        expect(@generic_ssh.connected?).to be true
       end
 
       it "should return false if not connected" do
-        @generic_ssh.connected?.should be_false
+        expect(@generic_ssh.connected?).to be false
       end
     end
   end

data/spec/hacky_hal/device_controllers/roku_spec.rb

@@ -19,12 +19,12 @@ describe HackyHAL::DeviceControllers::Roku do
   # FIXME: identical in YamahaAvReceiver spec
   it "should resolve host through device resolver" do
     resolved_uri = double("resolved URI")
-    resolved_uri.stub(:path=)
-    resolved_uri.stub(:port=)
+    allow(resolved_uri).to receive(:path=)
+    allow(resolved_uri).to receive(:port=)
     device_resolver = double("device resolver")
-    device_resolver.should_receive(:uri).and_return(resolved_uri)
-    HackyHAL::DeviceResolvers::Dummy.should_receive(:new).with(foo: 1).and_return(device_resolver)
-    controller = described_class.new(device_resolver: {type: 'Dummy', foo: 1})
-    controller.host_uri.should == resolved_uri
+    expect(device_resolver).to receive(:uri).and_return(resolved_uri)
+    expect(HackyHAL::DeviceResolvers::Dummy).to receive(:new).with(foo: 1).and_return(device_resolver)
+    controller = described_class.new(device_resolver: {type: "Dummy", foo: 1})
+    expect(controller.host_uri).to eq resolved_uri
   end
 end

data/spec/hacky_hal/device_controllers/yamaha_av_receiver_spec.rb

@@ -18,12 +18,12 @@ describe HackyHAL::DeviceControllers::YamahaAvReceiver do
   
   it "should resolve host through device resolver" do
     resolved_uri = double("resolved URI")
-    resolved_uri.stub(:path=)
-    resolved_uri.stub(:port=)
+    allow(resolved_uri).to receive(:path=)
+    allow(resolved_uri).to receive(:port=)
     device_resolver = double("device resolver")
-    device_resolver.should_receive(:uri).and_return(resolved_uri)
-    HackyHAL::DeviceResolvers::Dummy.should_receive(:new).with(foo: 1).and_return(device_resolver)
-    controller = described_class.new(device_resolver: {type: 'Dummy', foo: 1})
-    controller.host_uri.should == resolved_uri
+    expect(device_resolver).to receive(:uri).and_return(resolved_uri)
+    expect(HackyHAL::DeviceResolvers::Dummy).to receive(:new).with(foo: 1).and_return(device_resolver)
+    controller = described_class.new(device_resolver: {type: "Dummy", foo: 1})
+    expect(controller.host_uri).to eq resolved_uri
   end
 end

data/spec/hacky_hal/device_resolvers/base_spec.rb

@@ -3,6 +3,6 @@ require "hacky_hal/device_resolvers/base"
 
 describe HackyHAL::DeviceResolvers::Base do
   it "should include Options" do
-    described_class.ancestors.should include(HackyHAL::Options)
+    expect(described_class.ancestors).to include(HackyHAL::Options)
   end
 end

data/spec/hacky_hal/device_resolvers/ssdp_spec.rb

@@ -11,7 +11,7 @@ describe HackyHAL::DeviceResolvers::SSDP do
 
   it "should default to search for root devices" do
     resolver = described_class.new(usn: "dummy-usn")
-    resolver.options[:search].should == "upnp:rootdevice"
+    expect(resolver.options[:search]).to eq "upnp:rootdevice"
   end
 
   describe "instance" do
@@ -20,27 +20,27 @@ describe HackyHAL::DeviceResolvers::SSDP do
     end
 
     it "should return uri resolved via SSDP" do
-      UPnP::SSDP.stub(:search).and_return([
+      allow(UPnP::SSDP).to receive(:search).and_return([
         {location: "http://resolved-host/path", usn: "dummy-usn"}
       ])
-      @resolver.uri.host.should == "resolved-host"
+      expect(@resolver.uri.host).to eq "resolved-host"
     end
 
     it "should raise SsdpUnresolvedDevice if no device found" do
-      UPnP::SSDP.stub(:search).and_return([])
+      allow(UPnP::SSDP).to receive(:search).and_return([])
       expect { @resolver.uri }.to raise_error(HackyHAL::DeviceResolvers::SsdpUnresolvedDevice)
     end
 
     it "should return the host of device with given USN" do
-      UPnP::SSDP.stub(:search).and_return([
+      allow(UPnP::SSDP).to receive(:search).and_return([
         {location: "http://other-resolved-host/path", usn: "other-usn"},
         {location: "http://resolved-host/path", usn: "dummy-usn"}
       ])
-      @resolver.uri.host.should == "resolved-host"
+      expect(@resolver.uri.host).to eq "resolved-host"
     end
 
     it "should raise SsdpUnresolvedDevice if device with request USN not found" do
-      UPnP::SSDP.stub(:search).and_return([
+      allow(UPnP::SSDP).to receive(:search).and_return([
         {location: "http://other-resolved-host/path", usn: "other-usn"}
       ])
       expect { @resolver.uri }.to raise_error(HackyHAL::DeviceResolvers::SsdpUnresolvedDevice)

data/spec/hacky_hal/device_resolvers/static_uri_spec.rb

@@ -11,6 +11,6 @@ describe HackyHAL::DeviceResolvers::StaticURI do
 
   it "should return static host" do
     resolver = described_class.new(uri: "http://device-host.local")
-    resolver.uri.host.should == "device-host.local"
+    expect(resolver.uri.host).to eq "device-host.local"
   end
 end

data/spec/hacky_hal/log_spec.rb

@@ -12,14 +12,14 @@ describe HackyHAL::Log do
   end
 
   it "should use custom formatter" do
-    described_class.instance.formatter.should be_a(described_class::Formatter)
-    described_class.instance.formatter.should_receive(:call)
+    expect(described_class.instance.formatter).to be_a(described_class::Formatter)
+    expect(described_class.instance.formatter).to receive(:call)
     described_class.instance.info("foo")
   end
 
   describe "#write" do
     it "should alias to self.<<" do
-      described_class.instance.should_receive(:<<).with("foo")
+      expect(described_class.instance).to receive(:<<).with("foo")
       described_class.instance.write("foo")
     end
   end

data/spec/hacky_hal/options_spec.rb

@@ -9,14 +9,14 @@ describe HackyHAL::Options do
   describe "#initialize" do
     it "should set options" do
       object = DummyClass.new(dummy_argument: "dummy value")
-      object.options.should == {dummy_argument: "dummy value"}
+      expect(object.options).to eq({dummy_argument: "dummy value"})
     end
   end
 
   describe "#[]" do
     it "should return option values" do
       object = DummyClass.new(dummy_argument: "dummy value")
-      object[:dummy_argument].should == "dummy value"
+      expect(object[:dummy_argument]).to eq "dummy value"
     end
   end
 end

data/spec/hacky_hal/registry_spec.rb

@@ -10,21 +10,22 @@ describe HackyHAL::Registry do
           "foo" => "bar"
         }
       }
-      File.stub(:read)
-      YAML.stub(:load).and_return(@device_config)
+
+      allow(File).to receive(:read)
+      allow(YAML).to receive(:load).and_return(@device_config)
     end
 
     it "should load and initialize device controllers into registry" do
       described_class.instance.load_yaml_file("foo.yml")
       devices = described_class.instance.devices
-      devices.length.should == 1
-      devices[:foo_device].should be_instance_of(HackyHAL::DeviceControllers::Base)
+      expect(devices.length).to eq 1
+      expect(devices[:foo_device]).to be_instance_of(HackyHAL::DeviceControllers::Base)
     end
 
     it "should convert keys to symbols" do
       described_class.instance.load_yaml_file("foo.yml")
       devices = described_class.instance.devices
-      devices[:foo_device][:foo].should == "bar"
+      expect(devices[:foo_device][:foo]).to eq "bar"
     end
   end
 end

data/spec/hacky_hal/util_spec.rb

@@ -14,14 +14,14 @@ describe HackyHAL::Util do
 
     it "should return instance of built class" do
       dummy_instance = double("dummy instance")
-      DummyModule::DummyClass.should_receive(:new).with(foo: 1).and_return(dummy_instance)
-      described_class.object_from_hash({type: 'DummyClass', foo: 1}, DummyModule).should == dummy_instance
+      expect(DummyModule::DummyClass).to receive(:new).with(foo: 1).and_return(dummy_instance)
+      expect(described_class.object_from_hash({type: "DummyClass", foo: 1}, DummyModule)).to eq dummy_instance
     end
   end
 
   describe ".symbolize_keys_deep" do
     it "should symbolize hash keys" do
-      described_class.symbolize_keys_deep("a" => 1, :b => {"c" => 2}).should == {a: 1, b: {c: 2}}
+      expect(described_class.symbolize_keys_deep("a" => 1, :b => {"c" => 2})).to eq({a: 1, b: {c: 2}})
     end
   end
 end

metadata

@@ -2,14 +2,14 @@
 name: hacky_hal
 version: !ruby/object:Gem::Version
   prerelease: 
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Nick Ewing
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-08 00:00:00.000000000 Z
+date: 2014-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: upnp-nickewing