smalrubot 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ce651f57013d0e5338ab3e30e112f500741fc04
-  data.tar.gz: e285691b27ab53bac6b01ebe2b8747aaeb3029fb
+  metadata.gz: cdb763c4d819bb8d2297f51690ae9e41c7cdeb2a
+  data.tar.gz: 33645921dc4d5795b923f001542dfad6f733a0c2
 SHA512:
-  metadata.gz: b0b3b177c7f63a7969c5d7492d1ea35e5b381812276446715c903d43d3cc26b1e59d09c1792116dafe5b8b7de939200b67af98deedb24b0bd17cda18f3076d96
-  data.tar.gz: 0f1808e56cebd435cc0d67b02c86928153985c8e0309e334c598f06448f81dd7e554c42c619af0ab69c3c3a9e19c90ff5cfc134e4dc842383b36cc3d3fffc3ee
+  metadata.gz: dd4d9ed9afd631bdf07b4ef43f89dfa7efc2160465002e52972ce1b9c4639df40a4993337f46f145e72cda9f725753f4344e1d3473a128af36bae418c83bf8e0
+  data.tar.gz: 24d8d1339cb310987f715a981016025042b0c9b8913a65f50f7a0344f53d6a5fd771928c0391e125fdef278a62652b1f644f103dfb98405bb6727efe3ee782dd

data/.travis.yml

@@ -1,4 +1,4 @@
 language: ruby
+
 rvm:
-  - 2.1.5
-script: bundle exec rspec spec
+  - 2.3.3

data/README.md

@@ -1,5 +1,8 @@
 # smalrubot
 
+[![Gem Version](https://badge.fury.io/rb/smalrubot.png)](https://badge.fury.io/rb/smalrubot)
+[![Build Status](https://travis-ci.org/smalruby/smalrubot.svg?branch=master)](https://travis-ci.org/smalruby/smalrubot)
+
 The smalrubot is a library and an Arduino sketch for Smalruby.
 
 This is a part of the Smalruby ([http://smalruby.jp](http://smalruby.jp)) Project.

data/Rakefile

@@ -21,7 +21,7 @@ task :release do
   File.open('lib/smalrubot/version.rb', 'r+') do |f|
     lines = []
     while line = f.gets
-      line = "#{$1} '#{next_version}'\n" if /(\s*VERSION = )/.match(line)
+      line = "#{$1}'#{next_version}'\n" if /(\s*VERSION =\s*)/.match(line)
       lines << line
     end
     f.rewind

data/lib/smalrubot/version.rb

@@ -1,3 +1,3 @@
 module Smalrubot
-  VERSION =  '0.0.6'
+  VERSION =  '0.0.7'
 end

data/spec/lib/board_spec.rb

@@ -16,7 +16,7 @@ module Smalrubot
       end
 
       it 'should initiate the handshake' do
-        io_mock.should_receive(:handshake)
+        expect(io_mock).to receive(:handshake)
         subject
       end
     end
@@ -25,77 +25,77 @@ module Smalrubot
       it 'should return true if the write succeeds' do
         @io = nil
         board = Board.new(io_mock(write: true))
-        board.write('message').should == true
+        expect(board.write('message')).to eq(true)
       end
 
       it 'should wrap the message in a ! and a . by default' do
-        io_mock.should_receive(:write).with('!hello.')
+        expect(io_mock).to receive(:write).with('!hello.')
         subject.write('hello')
       end
 
       it 'should not wrap the message if no_wrap is set to true' do
         board = Board.new(io_mock)
-        io_mock.should_receive(:write).with('hello')
+        expect(io_mock).to receive(:write).with('hello')
         board.write('hello', no_wrap: true)
       end
     end
 
     describe '#digital_write' do
       it 'should append a append a write to the pin and value' do
-        io_mock.should_receive(:write).with('!0101003.')
+        expect(io_mock).to receive(:write).with('!0101003.')
         subject.digital_write(01, 003)
       end
     end
 
     describe '#digital_read' do
       it 'should tell the board to read once from the given pin' do
-        io_mock.should_receive(:write).with('!0213000.')
-        io_mock.should_receive(:read).with(1).and_return(['13', Smalrubot::Board::HIGH.to_s])
+        expect(io_mock).to receive(:write).with('!0213000.')
+        expect(io_mock).to receive(:read).with(1).and_return(['13', Smalrubot::Board::HIGH.to_s])
         expect(subject.digital_read(13)).to eq(Smalrubot::Board::HIGH)
       end
     end
 
     describe '#analog_write' do
       it 'should append a append a write to the pin and value' do
-        io_mock.should_receive(:write).with('!0301003.')
+        expect(io_mock).to receive(:write).with('!0301003.')
         subject.analog_write(01, 003)
       end
     end
 
     describe '#analog_read' do
       it 'should tell the board to read once from the given pin' do
-        io_mock.should_receive(:write).with('!0413000.')
-        io_mock.should_receive(:read).with(1).once.and_return(['13', '256'])
+        expect(io_mock).to receive(:write).with('!0413000.')
+        expect(io_mock).to receive(:read).with(1).once.and_return(['13', '256'])
         expect(subject.analog_read(13)).to eq(256)
       end
     end
 
     describe '#set_pin_mode' do
       it 'should send a value of 0 if the pin mode is set to out' do
-        io_mock.should_receive(:write).with('!0013000.')
+        expect(io_mock).to receive(:write).with('!0013000.')
         subject.set_pin_mode(13, :out)
       end
 
       it 'should send a value of 1 if the pin mode is set to in' do
-        io_mock.should_receive(:write).with('!0013001.')
+        expect(io_mock).to receive(:write).with('!0013001.')
         subject.set_pin_mode(13, :in)
       end
     end
 
     describe '#handshake' do
       it 'should tell the board to reset to defaults' do
-        io_mock.should_receive(:handshake)
+        expect(io_mock).to receive(:handshake)
         subject.handshake
       end
     end
 
     describe '#normalize_pin' do
       it 'should normalize numbers so they are two digits' do
-        subject.normalize_pin(1).should == '01'
+        expect(subject.normalize_pin(1)).to eq('01')
       end
 
       it 'should not normalize numbers that are already two digits' do
-        subject.normalize_pin(10).should == '10'
+        expect(subject.normalize_pin(10)).to eq('10')
       end
 
       it 'should raise if a number larger than two digits are given' do
@@ -105,11 +105,11 @@ module Smalrubot
 
     describe '#normalize_value' do
       it 'should normalize numbers so they are three digits' do
-        subject.normalize_value(1).should == '001'
+        expect(subject.normalize_value(1)).to eq('001')
       end
 
       it 'should not normalize numbers that are already three digits' do
-        subject.normalize_value(10).should == '010'
+        expect(subject.normalize_value(10)).to eq('010')
       end
 
       it 'should raise if a number larger than three digits are given' do

data/spec/lib/components/base_component_spec.rb

@@ -10,8 +10,8 @@ module Smalrubot
         board = "a board"
         component = BaseComponent.new(pin: pin, board: board)
 
-        component.pin.should == pin
-        component.board.should == board
+        expect(component.pin).to eq(pin)
+        expect(component.board).to eq(board)
       end
 
       it 'should assign pins' do
@@ -19,19 +19,19 @@ module Smalrubot
         board = "a board"
         component = BaseComponent.new(pins: pins, board: board)
 
-        component.pins.should == pins
+        expect(component.pins).to eq(pins)
       end
 
       it 'should require a pin or pins' do
         expect {
           BaseComponent.new(board: 'some board')
-        }.to raise_exception
+        }.to raise_exception(RuntimeError)
       end
 
       it 'should require a board' do
         expect {
           BaseComponent.new(pin: 'some pin')
-        }.to raise_exception
+        }.to raise_exception(RuntimeError)
       end
 
       context "when subclassed #after_initialize should be executed" do
@@ -54,8 +54,8 @@ module Smalrubot
 
         it "should call #after_initialize with options" do
           component = SpecComponent.new(options)
-          component.should be_sucessfully_initialized
-          component.options.should eq options
+          expect(component).to be_sucessfully_initialized
+          expect(component.options).to eq(options)
         end
 
       end

data/spec/lib/components/led_spec.rb

@@ -9,22 +9,22 @@ module Smalrubot
         it 'should raise if it does not receive a pin' do
           expect {
             Led.new(board: board)
-          }.to raise_exception
+          }.to raise_exception(RuntimeError)
         end
 
         it 'should raise if it does not receive a board' do
           expect {
             Led.new(pins: {})
-          }.to raise_exception
+          }.to raise_exception(RuntimeError)
         end
 
         it 'should set the pin to out' do
-          board.should_receive(:set_pin_mode).with(13, :out, nil)
+          expect(board).to receive(:set_pin_mode).with(13, :out, nil)
           Led.new(pin: 13, board: board)
         end
 
         it 'should set the pin to low' do
-          board.should_receive(:digital_write).with(13, Board::LOW)
+          expect(board).to receive(:digital_write).with(13, Board::LOW)
           Led.new(pin: 13, board: board)
         end
       end
@@ -32,7 +32,7 @@ module Smalrubot
       describe '#on' do
         it 'should send a high to the board with the pin' do
           @led = Led.new(pin: 13, board: board)
-          board.should_receive(:digital_write).with(13, Board::HIGH)
+          expect(board).to receive(:digital_write).with(13, Board::HIGH)
           @led.on
         end
       end
@@ -40,7 +40,7 @@ module Smalrubot
       describe '#off' do
         it 'should send a high to the board with the pin' do
           @led = Led.new(pin: 13, board: board)
-          board.should_receive(:digital_write).with(13, Board::LOW)
+          expect(board).to receive(:digital_write).with(13, Board::LOW)
           @led.off
         end
       end

data/spec/lib/components/servo_spec.rb

@@ -9,23 +9,23 @@ module Smalrubot
         it 'should raise if it does not receive a pin' do
           expect {
             Servo.new(board: board)
-          }.to raise_exception
+          }.to raise_exception(RuntimeError)
         end
 
         it 'should raise if it does not receive a board' do
           expect {
             Servo.new(pin: 13)
-          }.to raise_exception
+          }.to raise_exception(RuntimeError)
         end
 
         it 'should set the pins to out' do
-          board.should_receive(:set_pin_mode).with(13, :out, nil)
+          expect(board).to receive(:set_pin_mode).with(13, :out, nil)
           Servo.new(pin: 13, board: board)
         end
 
         it 'should set the inital position to 0' do
           servo =  Servo.new(pin: 13, board: board)
-          servo.instance_variable_get(:@position).should == 0
+          expect(servo.instance_variable_get(:@position)).to eq(0)
         end
       end
 
@@ -34,21 +34,21 @@ module Smalrubot
 
         it 'should set the position of the Servo' do
           servo.position = 90
-          servo.instance_variable_get(:@position).should == 90
+          expect(servo.instance_variable_get(:@position)).to eq(90)
         end
 
         it 'should let you write up to 180' do
           servo.position = 180
-          servo.instance_variable_get(:@position).should == 180
+          expect(servo.instance_variable_get(:@position)).to eq(180)
         end
 
         it 'should modulate when position > 180' do
           servo.position = 190
-          servo.instance_variable_get(:@position).should == 10
+          expect(servo.instance_variable_get(:@position)).to eq(10)
         end
 
         it 'should write the new position to the board' do
-          board.should_receive(:servo_write).with(13, 10)
+          expect(board).to receive(:servo_write).with(13, 10)
           servo.position = 190
         end
       end

data/spec/lib/tx_rx/serial_spec.rb

@@ -6,13 +6,13 @@ module Smalrubot
 
     describe '#initialize' do
       it 'should set first_write to true' do
-        TxRx::Serial.new.instance_variable_get(:@first_write).should == true
+        expect(TxRx::Serial.new.instance_variable_get(:@first_write)).to eq(true)
       end
 
       it 'should set the device and buad if specified' do
         txrx = TxRx::Serial.new({device: "/dev/ttyACM0", baud: 9600})
-        txrx.instance_variable_get(:@baud).should == 9600
-        txrx.instance_variable_get(:@device).should == "/dev/ttyACM0"
+        expect(txrx.instance_variable_get(:@baud)).to eq(9600)
+        expect(txrx.instance_variable_get(:@device)).to eq("/dev/ttyACM0")
       end
     end
 
@@ -24,56 +24,56 @@ module Smalrubot
           subject.instance_variable_set('@tty_devices', ["COM1", "COM2", "COM3"])
 
           # COM2 is chosen as available for this test.
-          ::Serial.should_receive(:new).with("COM1", TxRx::Serial::BAUD).and_raise
-          ::Serial.should_receive(:new).with("COM2", TxRx::Serial::BAUD).and_return(mock_serial = double)
-          ::Serial.should_not_receive(:new).with("COM3", TxRx::Serial::BAUD)
+          expect(::Serial).to receive(:new).with("COM1", TxRx::Serial::BAUD).and_raise
+          expect(::Serial).to receive(:new).with("COM2", TxRx::Serial::BAUD).and_return(mock_serial = double)
+          expect(::Serial).not_to receive(:new).with("COM3", TxRx::Serial::BAUD)
 
-          subject.io.should == mock_serial
+          expect(subject.io).to eq(mock_serial)
           Constants.redefine(:RUBY_PLATFORM, original_platform, :on => Object)
         end
       end
 
       context "on unix" do
         it 'should instantiate a new ::Serial for the first available tty device' do
-          subject.should_receive(:tty_devices).and_return(['/dev/ttyACM0', '/dev/tty.usbmodem1'])
+          expect(subject).to receive(:tty_devices).and_return(['/dev/ttyACM0', '/dev/tty.usbmodem1'])
 
           # /dev/ttyACM0 is chosen as available for this test.
-          ::Serial.should_receive(:new).with('/dev/ttyACM0', TxRx::Serial::BAUD).and_return(mock_serial = double)
-          ::Serial.should_not_receive(:new).with('/dev/tty.usbmodem1', TxRx::Serial::BAUD)
+          expect(::Serial).to receive(:new).with('/dev/ttyACM0', TxRx::Serial::BAUD).and_return(mock_serial = double)
+          expect(::Serial).not_to receive(:new).with('/dev/tty.usbmodem1', TxRx::Serial::BAUD)
 
-          subject.io.should == mock_serial
+          expect(subject.io).to eq(mock_serial)
         end
       end
 
       it 'should connect to the specified device at the specified baud rate' do
-        subject.should_receive(:tty_devices).and_return(["/dev/ttyACM0"])
-        ::Serial.should_receive(:new).with('/dev/ttyACM0', 9600).and_return(mock_serial = double)
+        expect(subject).to receive(:tty_devices).and_return(["/dev/ttyACM0"])
+        expect(::Serial).to receive(:new).with('/dev/ttyACM0', 9600).and_return(mock_serial = double)
 
         subject.instance_variable_set(:@device, "/dev/ttyACM0")
         subject.instance_variable_set(:@baud, 9600)
 
-        subject.io.should == mock_serial
+        expect(subject.io).to eq(mock_serial)
       end
 
       it 'should use the existing io instance if set' do
-        subject.should_receive(:tty_devices).once.and_return(['/dev/tty.ACM0', '/dev/tty.usbmodem1'])
-        ::Serial.stub(:new).and_return(mock_serial = double)
+        expect(subject).to receive(:tty_devices).once.and_return(['/dev/tty.ACM0', '/dev/tty.usbmodem1'])
+        allow(::Serial).to receive(:new).and_return(mock_serial = double)
 
         3.times { subject.io }
-        subject.io.should == mock_serial
+        expect(subject.io).to eq(mock_serial)
       end
 
       it 'should raise a BoardNotFound exception if there is no board connected' do
-        ::Serial.stub(:new).and_raise
+        allow(::Serial).to receive(:new).and_raise
         expect { subject.io }.to raise_exception BoardNotFound
       end
     end
 
     describe '#write' do
       it 'should write to the device' do
-        subject.stub(:io).and_return(mock_serial = double)
+        allow(subject).to receive(:io).and_return(mock_serial = double)
         msg = 'a message'
-        mock_serial.should_receive(:write).with(msg).and_return(msg.length)
+        expect(mock_serial).to receive(:write).with(msg).and_return(msg.length)
         subject.write('a message')
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smalrubot
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Kouji Takao
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-22 00:00:00.000000000 Z
+date: 2017-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyserial
@@ -131,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: A library and an Arduino sketch for Smalruby.