lego-nxt 0.2.0 → 0.3.0

data/lib/nxt/patches/string.rb

@@ -1,29 +1,18 @@
+# frozen_string_literal: true
+
+# Some patches that extend the default Ruby String class with some useful
+# methods.
 class String
   # Convert the given string to a hexadecimal representation of the same data.
   # This method is non-destructive, it will return a new copy of the string
   # convered to hex.
   def to_hex_str
     str = ''
-    self.each_byte {|b| str << '0x%02x ' % b}
-    str
-  end
-
-  #
-  def from_hex_str_two
-    data = self.split(' ')
-    str = ''
-    data.each {|h| eval "str += '%c' % #{h}"}
+    each_byte { |b| str << format('0x%02x ', b) }
     str
   end
 
   def from_hex_str
-    data = self.split(' ')
-    str = ''
-
-    data.each do |h|
-      str += '%c' % h
-    end
-
-    str
+    unpack('C*')
   end
 end

data/lib/nxt/protocols/i2c.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module NXT
+  module Protocols
+    # Communication to the NXT brick for digital sensors is done using the I2C
+    # protocol. This module implements communication in that fashion,
+    # abstracing the messages
+    # we wish to send from the underlying protocol for ease-of-use.
+    module I2C
+      COMMAND_IDENTIFIER = {
+        ls_get_status: 0x0E,
+        ls_write: 0x0F,
+        ls_read: 0x10
+      }.freeze
+
+      I2C_HEADER = 0x02
+
+      # Format is I2C address, followed by the number of bytes expected in the response.
+      I2C_CONSTANT_OPS = {
+        read_version: [0x00, 8],
+        read_product_id: [0x08, 8],
+        read_sensor_type: [0x10, 8],
+        read_factory_zero: [0x11, 1],
+        read_factory_scale_factor: [0x12, 1],
+        read_factory_scale_divisor: [0x13, 1],
+        read_measurement_units: [0x14, 7]
+      }.freeze
+
+      # Format is the I2C address (all variable operations expect a 1 byte reponse).
+      I2C_VARIABLE_OPS = {
+        read_continuous_measurements_interval: 0x40,
+        read_command_state: 0x41,
+        read_measurement_byte_zero: 0x42,
+        read_measurement_byte_one: 0x43,
+        read_measurement_byte_two: 0x44,
+        read_measurement_byte_three: 0x45,
+        read_measurement_byte_four: 0x46,
+        read_measurement_byte_five: 0x47,
+        read_measurement_byte_six: 0x48,
+        read_measurement_byte_seven: 0x49,
+        read_actual_zero: 0x50,
+        read_actual_scale_factor: 0x51,
+        read_actual_scale_divisor: 0x52
+      }.freeze
+
+      # Format is I2C address, followed by the command. If the array is only
+      # one member large, then the second byte is instead a value passed at
+      # run-time, eg. the length of the interval to run the continuous
+      # measuring on the ultrasonic sensor for.
+      I2C_COMMANDS = {
+        off_command: [0x41, 0x00],
+        single_shot_command: [0x41, 0x01],
+        continuous_measurement_command: [0x41, 0x02],
+        event_capture_command: [0x41, 0x03],
+        request_warm_reset: [0x41, 0x04],
+        set_continuous_measurement_interval: [0x40],
+        set_actual_zero: [0x50],
+        set_actual_scale_factor: [0x51],
+        set_actual_scale_divisor: [0x52]
+      }.freeze
+
+      def self.method_missing(name, *args)
+        if I2C_CONSTANT_OPS.key?(name)
+          run_constant_op(name)
+        elsif I2C_VARIABLE_OPS.key?(name)
+          run_variable_op(name)
+        elsif I2C_COMMANDS.key?(name)
+          run_command(name, *args)
+        else
+          super
+        end
+      end
+
+      def self.respond_to_missing?(name, include_private = false)
+        I2C_CONSTANT_OPS.key?(name) ||
+          I2C_VARIABLE_OPS.key?(name) ||
+          I2C_COMMANDS.key?(name) ||
+          super
+      end
+
+      class << self
+        private
+
+        def run_constant_op(name)
+          op = I2C_CONSTANT_OPS[name]
+          addr = op[0]
+          rx_len = op[1]
+
+          [0, rx_len, I2C_HEADER, addr]
+        end
+
+        def run_variable_op(name)
+          op = I2C_VARIABLE_OPS[name]
+          addr = op
+          rx_len = 1
+
+          [0, rx_len, I2C_HEADER, addr]
+        end
+
+        def run_command(name, *args)
+          op = I2C_COMMANDS[name]
+          addr = op[0]
+          rx_len = 0
+
+          if op[1]
+            data = [op[1]]
+          elsif args[0]
+            data = [args[0]]
+          else
+            raise "Missing argument for command #{name}"
+          end
+
+          [data.size, rx_len, I2C_HEADER, addr] + data
+        end
+      end
+    end
+  end
+end

data/lib/nxt/utils/accessors.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 module NXT
   module Utils
+    # Utilities related to creating accessors that have some conditonal guards
+    # when setting values.
     module Accessors
+      include NXT::Utils::Assertions
+
       def attr_setter(name, options)
         define_method("#{name}=") do |value|
-          if options.include?(:is)
-            raise TypeError.new('Expected value to be a number') unless duration.is_a?(options[:is])
-          end
-
-          if options.include?(:is_key_in) && !options[:is_key_in].include?(value)
-            raise TypeError.new("Expected value to be one of: :#{options[:is_key_in].keys.join(', :')}")
-          end
+          assert_type(name, value, options[:is]) if options.include?(:is)
+          assert_in(name, value, options[:is_key_in]) if options.include?(:is_key_in)
 
           instance_variable_set("@#{name}", value)
           self

data/lib/nxt/utils/assertions.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module NXT
+  module Utils
+    # Utilities related to asserting values are what is expected.
+    module Assertions
+      def assert_in(name, value, values)
+        raise(TypeError, "Expected #{name} to be one of: :#{values.join(', :')}") unless values.include?(value)
+      end
+
+      def assert_type(name, value, type)
+        raise(TypeError, "Expected #{name} to be of type #{type}") unless value.is_a?(type)
+      end
+
+      def assert_responds_to(name, value, *methods)
+        valid = methods.all? do |method|
+          value.respond_to?(method)
+        end
+
+        raise(TypeError, "Expected #{name} to respond to: #{methods.join(', ')}") unless valid
+      end
+    end
+  end
+end

data/spec/matchers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rspec/expectations'
 
 RSpec::Matchers.define :have_constant do |expected|

data/spec/nxt/connector/output/motor_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe NXT::Connector::Output::Motor do
+  subject(:motor) { described_class.new(port, interface) }
+
+  let(:port) { :a }
+  let(:interface) { nil }
+
+  describe 'constants' do
+    it 'has a DURATION_TYPE constant' do
+      expect(motor).to have_constant(:DURATION_TYPE)
+    end
+
+    it 'has a DURATION_AFTER constant' do
+      expect(motor).to have_constant(:DURATION_AFTER)
+    end
+
+    it 'has a DIRECTION constant' do
+      expect(motor).to have_constant(:DIRECTION)
+    end
+  end
+
+  describe 'accessors' do
+    it 'has read accessor for @port' do
+      expect(motor).to respond_to(:port)
+    end
+
+    it 'has write accessor for @port' do
+      expect(motor).to respond_to(:port=)
+    end
+
+    it 'has read accessor for @interface' do
+      expect(motor).to respond_to(:interface)
+    end
+
+    it 'has write accessor for @interface' do
+      expect(motor).to respond_to(:interface=)
+    end
+  end
+
+  describe '#initialize' do
+    it 'sets the port to the incomming argument' do
+      expect(motor.port).to equal(port)
+    end
+
+    it 'sets the interface to the incomming argument' do
+      expect(motor.interface).to equal(interface)
+    end
+  end
+end

data/spec/nxt/interface/serial_port_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe NXT::Interface::SerialPort do
+  subject(:serial_port) { described_class.new(device) }
+
+  let(:device) { '/dev/zero' }
+
+  describe 'constants' do
+    it 'has a BAUD_RATE constant' do
+      expect(serial_port).to have_constant(:BAUD_RATE)
+    end
+
+    it 'has a DATA_BITS constant' do
+      expect(serial_port).to have_constant(:DATA_BITS)
+    end
+
+    it 'has a STOP_BITS constant' do
+      expect(serial_port).to have_constant(:STOP_BITS)
+    end
+
+    it 'has a PARITY constant' do
+      expect(serial_port).to have_constant(:PARITY)
+    end
+
+    it 'has a READ_TIMEOUT constant' do
+      expect(serial_port).to have_constant(:READ_TIMEOUT)
+    end
+  end
+
+  describe 'accessors' do
+    it 'has read accessor for @dev' do
+      expect(serial_port).to respond_to(:dev)
+    end
+
+    it 'has write accessor for @dev' do
+      expect(serial_port).to respond_to(:dev=)
+    end
+  end
+
+  describe '#initialize' do
+    it 'sets the device to the incomming argument' do
+      expect(serial_port.dev).to equal(device)
+    end
+
+    it 'raises an exception when trying to connect to invalid dev files' do
+      expect do
+        serial_port.class.new('/dev/foobar')
+      end.to raise_exception(InvalidDeviceError)
+    end
+  end
+
+  describe '#connect' do
+    it 'raises an exception when the SerialPort connection failed' do
+      expect do
+        serial_port.connect
+      end.to raise_exception(SerialPortConnectionError, "The #{device} device is not a valid SerialPort")
+    end
+
+    it 'raises an exception when the SerialPort connection is nil' do
+      allow(::SerialPort).to receive(:new).and_return(nil)
+      expect do
+        serial_port.connect
+      end.to raise_exception(SerialPortConnectionError, "Could not establish a SerialPort connection to #{device}")
+    end
+
+    it 'sets the flow control and read timeout when the connection is established' do
+      serial_port_stub = double
+      allow(serial_port_stub).to receive(:flow_control=).with(::SerialPort::HARD).once
+      allow(serial_port_stub).to receive(:read_timeout=).with(serial_port.class::READ_TIMEOUT).once
+      allow(::SerialPort).to receive(:new).and_return(serial_port_stub)
+
+      serial_port.connect
+    end
+  end
+
+  describe '#disconnect' do
+    let(:connection_klass) do
+      Class.new do
+        def initialize(closed)
+          @closed = closed
+        end
+
+        def closed?
+          @closed
+        end
+      end
+    end
+
+    it 'closes the connection if connected' do
+      connection = connection_klass.new(false)
+      allow(connection).to receive(:close)
+      serial_port.instance_variable_set(:@connection, connection)
+
+      serial_port.disconnect
+
+      expect(connection).to have_received(:close)
+    end
+
+    it 'does not close the connection if already disconnected' do
+      connection = connection_klass.new(true)
+      allow(connection).to receive(:close)
+      serial_port.instance_variable_set(:@connection, connection)
+
+      serial_port.disconnect
+
+      expect(connection).not_to have_received(:close)
+    end
+  end
+
+  # describe '#send' do
+
+  # end
+
+  # describe '#receive' do
+
+  # end
+end

data/spec/nxt/nxt_brick_spec.rb

@@ -1,205 +1,274 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe NXTBrick do
-  before do
-    @interface = stub(
-      is_a?: true
-    )
-  end
-
-  subject do
-    NXTBrick.new(@interface)
-  end
+  subject(:nxt_brick) { described_class.new(:usb) }
 
   describe 'accessors' do
-    it 'should have read/write accessors for @interface' do
-      should respond_to(:interface)
-      should respond_to(:interface=)
+    it 'has a read accessor for @interface' do
+      expect(nxt_brick).to respond_to(:interface)
+    end
+
+    it 'has write accessor for @interface' do
+      expect(nxt_brick).to respond_to(:interface=)
+    end
+
+    it 'has a read accessor for @a' do
+      expect(nxt_brick).to respond_to(:a)
+    end
+
+    it 'has a write accessor for @a' do
+      expect(nxt_brick).not_to respond_to(:a=)
+    end
+
+    it 'has a read accessor for @b' do
+      expect(nxt_brick).to respond_to(:b)
+    end
+
+    it 'has a write accessor for @b' do
+      expect(nxt_brick).not_to respond_to(:b=)
+    end
+
+    it 'has a read accessor for @c' do
+      expect(nxt_brick).to respond_to(:c)
+    end
+
+    it 'has a write accessor for @c' do
+      expect(nxt_brick).not_to respond_to(:c=)
     end
 
-    it 'should have read/write accessors for @options' do
-      should respond_to(:options)
-      should respond_to(:options=)
+    it 'has a read accessor for @one' do
+      expect(nxt_brick).to respond_to(:one)
     end
 
-    it 'should have a read accessor for @a' do
-      should respond_to(:a)
-      should_not respond_to(:a=)
+    it 'has a write accessor for @one' do
+      expect(nxt_brick).not_to respond_to(:one=)
     end
 
-    it 'should have a read accessor for @b' do
-      should respond_to(:b)
-      should_not respond_to(:b=)
+    it 'has a read accessor for @two' do
+      expect(nxt_brick).to respond_to(:two)
     end
 
-    it 'should have a read accessor for @c' do
-      should respond_to(:c)
-      should_not respond_to(:c=)
+    it 'has a write accessor for @two' do
+      expect(nxt_brick).not_to respond_to(:two=)
     end
 
-    it 'should have a read accessor for @one' do
-      should respond_to(:one)
-      should_not respond_to(:one=)
+    it 'has a read accessor for @three' do
+      expect(nxt_brick).to respond_to(:three)
     end
 
-    it 'should have a read accessor for @two' do
-      should respond_to(:two)
-      should_not respond_to(:two=)
+    it 'has a write accessor for @three' do
+      expect(nxt_brick).not_to respond_to(:three=)
     end
 
-    it 'should have a read accessor for @three' do
-      should respond_to(:three)
-      should_not respond_to(:three=)
+    it 'has a read accessor for @four' do
+      expect(nxt_brick).to respond_to(:four)
     end
 
-    it 'should have a read accessor for @four' do
-      should respond_to(:four)
-      should_not respond_to(:four=)
+    it 'has a write accessor for @four' do
+      expect(nxt_brick).not_to respond_to(:four=)
     end
 
-    it 'should have a read accessor for @port_identifiers' do
-      should respond_to(:port_identifiers)
-      should_not respond_to(:port_identifiers=)
+    it 'has a read accessor for @port_identifiers' do
+      expect(nxt_brick).to respond_to(:port_identifiers)
+    end
+
+    it 'has a write accessor for @port_identifiers' do
+      expect(nxt_brick).not_to respond_to(:port_identifiers=)
     end
   end
 
   describe '#initialize' do
-    it 'should raise an exception if an invalid type of interface is given' do
-      interface_stub = stub()
-      interface_stub.should_receive(:is_a?).with(NXT::Interface::Base).once.and_return(false)
+    it 'raises an exception if an invalid type of interface is given' do
       expect do
-        NXTBrick.new(interface_stub)
+        described_class.new(:foobar)
       end.to raise_exception(InvalidInterfaceError)
     end
 
-    it 'should set the interface to the incomming argument' do
-      subject.interface.should equal(@interface)
+    it 'sets the interface to the incomming argument' do
+      expect(nxt_brick.interface).to be_an_instance_of(NXT::Interface::Usb)
     end
 
-    it 'should set the options to the incomming argument' do
-      options_stub = stub()
-      nxt = NXTBrick.new(@interface, options_stub)
-      nxt.options.should equal(options_stub)
-    end
-
-    it 'should call yield if given a block, passing self' do
+    it 'calls yield if given a block, passing self' do
       block_called = false
 
-      NXTBrick.new(@interface) do |nxt|
+      # rubocop:disable RSpec/AnyInstance
+      allow_any_instance_of(NXT::Interface::Usb).to receive(:connect)
+      # rubocop:enable RSpec/AnyInstance
+
+      described_class.new(:usb) do |_nxt|
         block_called = true
-        nxt.should be_an_instance_of(NXTBrick)
       end
 
-      block_called.should be_true
+      expect(block_called).to be true
     end
-  end
 
-  describe '#add' do
-    it 'should raise an exception if an invalid type of port is given' do
-      expect do
-        subject.add('not a symbol', :symbol, Class)
-      end.to raise_exception(TypeError, 'Expected port to be a Symbol')
+    it 'passes self if given a block' do
+      # rubocop:disable RSpec/AnyInstance
+      allow_any_instance_of(NXT::Interface::Usb).to receive(:connect)
+      # rubocop:enable RSpec/AnyInstance
+
+      described_class.new(:usb) do |nxt|
+        expect(nxt).to be_an_instance_of(described_class)
+      end
     end
+  end
 
-    it 'should raise an exception if an invalid type of identifier is given' do
-      expect do
-        subject.add(:symbol, 'not a symbol', Class)
-      end.to raise_exception(TypeError, 'Expected identifier to be a Symbol')
+  describe '#connect' do
+    let(:interface) { Object.new }
+
+    before do
+      nxt_brick.instance_variable_set(:@interface, interface)
     end
 
-    it 'should raise an exception if an invalid type of klass is given' do
-      expect do
-        subject.add(:symbol, :symbol, 'not a class')
-      end.to raise_exception(TypeError, 'Expected klass to be a Class')
+    it 'calls connect on the interface' do
+      allow(interface).to receive(:connect)
+
+      nxt_brick.connect
+
+      expect(interface).to have_received(:connect)
     end
+  end
 
-    it 'should raise an exception if an invalid port number or letter is given' do
-      expect do
-        subject.add(:invalid_port, :symbol, Class)
-      end.to raise_exception(TypeError, 'Expected port to be one of: :a, :b, :c, :one, :two, :three, :four')
+  describe '#disconnect' do
+    let(:interface) { Object.new }
+
+    before do
+      nxt_brick.instance_variable_set(:@interface, interface)
     end
 
-    it 'should create a new instance of the passed klass and store it in the attribute for the given port' do
-      port = :a
-      class_stub = Class.new
-      class_return_stub = stub()
+    it 'calls disconnect on the interface' do
+      allow(interface).to receive(:disconnect)
 
-      class_stub.should_receive(:new) do
-        class_return_stub
-      end.with(port).once()
+      nxt_brick.disconnect
 
-      subject.add(port, :hello, class_stub)
+      expect(interface).to have_received(:disconnect)
+    end
+  end
 
-      subject.send(port).should equal(class_return_stub)
+  describe '#add' do
+    let(:port) { :a }
+    let(:identifier) { :hello }
+    let(:class_stub) do
+      Class.new do
+        def initialize(*_args)
+          nil
+        end
+      end
     end
 
-    it 'should raise an exception if the port given is already set' do
-      port = :a
+    it 'raises an exception if an invalid port number or letter is given' do
+      expect do
+        nxt_brick.add(:invalid_port, identifier, class_stub)
+      end.to raise_exception(TypeError, 'Expected port to be one of: :a, :b, :c, :one, :two, :three, :four')
+    end
 
-      class_stub = Class.new
-      class_stub.stub(:new)
-      subject.stub(:hello)
-      subject.instance_variable_set(:"@#{port}", 'some value already there')
+    it 'raises an exception if an invalid type of identifier is given' do
+      expect do
+        nxt_brick.add(port, 123, class_stub)
+      end.to raise_exception(TypeError, 'Expected identifier to respond to: to_sym')
+    end
 
+    it 'raises an exception if an invalid type of class is given' do
       expect do
-        subject.add(port, :hello, class_stub)
-      end.to raise_error(PortTakenError, "Port #{port} is already set, call remove first")
+        nxt_brick.add(port, identifier, 'not a class')
+      end.to raise_exception(TypeError, 'Expected klass to be of type Class')
     end
 
-    it 'should raise an exception if trying to use an identifier that is the name of a defined methodz' do
-      port = :a
-      identifier = :hello
+    it 'raises an exception if trying to use an identifier that is the name of a defined method' do
+      expect do
+        nxt_brick.add(port, :add, class_stub)
+      end.to raise_error(
+        InvalidIdentifierError,
+        'Cannot use identifier add, a method on NXTBrick is already using it.'
+      )
+    end
 
-      class_stub = Class.new
-      class_stub.stub(:new)
-      subject.stub(identifier)
+    it 'raises an exception if the port given is already set' do
+      nxt_brick.add(port, identifier, class_stub)
 
       expect do
-        subject.add(port, :hello, class_stub)
-      end.to raise_error(InvalidIdentifierError, "Cannot use identifier #{identifier}, a method on NXTBrick is already using it.")
+        nxt_brick.add(port, identifier, class_stub)
+      end.to raise_error(PortTakenError, "Port #{port} is already set, call remove first")
     end
 
-    it 'should set up the port identifiers correctly' do
-      port = :a
-      identifier = :hello_world
-      class_stub = Class.new
-      class_stub.stub(:new)
-
-      subject.add(port, identifier, class_stub)
+    it 'sets up the port if the given port is not alread in use' do
+      nxt_brick.add(port, identifier, class_stub)
 
-      subject.port_identifiers[identifier].should equal(port)
+      expect(nxt_brick.send(port)).not_to eq(nil)
     end
   end
 
   describe '#remove' do
-    it 'should raise an exception if an invalid type of identifier is given' do
+    it 'raises an exception if an invalid type of identifier is given' do
       expect do
-        subject.remove('not a symbol')
-      end.to raise_exception(TypeError, 'Expected identifier to be a Symbol')
+        nxt_brick.remove(123)
+      end.to raise_exception(TypeError, 'Expected identifier to respond to: to_sym')
+    end
+
+    it 'removes any matching identifiers' do
+      identifier = :hello_world
+      port_identifiers = {}
+      nxt_brick.instance_variable_set(:@port_identifiers, port_identifiers)
+
+      allow(port_identifiers).to receive(:delete)
+
+      nxt_brick.remove(identifier)
+
+      expect(port_identifiers).to have_received(:delete).with(identifier).once
     end
 
-    it 'should remove any matching identifiers' do
+    it 'returns a boolean true if it removed anything' do
       identifier = :hello_world
       port_identifiers = {}
-      subject.instance_variable_set(:@port_identifiers, port_identifiers)
+      port_identifiers[identifier] = true
+      nxt_brick.instance_variable_set(:@port_identifiers, port_identifiers)
 
-      port_identifiers.should_receive(:delete).with(identifier).once()
-      subject.remove(identifier)
+      return_value = nxt_brick.remove(identifier)
+      expect(return_value).to be true
     end
 
-    it 'should return a boolean indicating whether it removed anything' do
+    it 'removes the port if it did delete something' do
       identifier = :hello_world
       port_identifiers = {}
       port_identifiers[identifier] = true
-      subject.instance_variable_set(:@port_identifiers, port_identifiers)
+      nxt_brick.instance_variable_set(:@port_identifiers, port_identifiers)
+
+      nxt_brick.remove(identifier)
+
+      expect(port_identifiers).not_to include(identifier)
+    end
 
-      return_value = subject.remove(identifier)
-      return_value.should be_true
+    it 'returns a boolean false if it did not remove anything' do
+      return_value = nxt_brick.remove(:hello_world)
+      expect(return_value).to be false
+    end
+  end
 
-      port_identifiers.should_not include(identifier)
+  describe '#define_port_handler_method' do
+    let(:port) { :a }
+    let(:identifier) { :hello }
+    let(:class_stub) do
+      Class.new do
+        def initialize(*_args)
+          nil
+        end
+      end
+    end
+
+    it 'stores it in the attribute for the given port' do
+      class_return_stub = double
+      allow(class_stub).to receive(:new) { class_return_stub }
+
+      nxt_brick.send(:define_port_handler_method, port, identifier, class_stub)
+
+      expect(nxt_brick.send(port)).to equal(class_return_stub)
+    end
 
-      return_value = subject.remove(identifier)
-      return_value.should be_false
+    it 'sets up the port identifiers correctly' do
+      nxt_brick.send(:define_port_handler_method, port, identifier, class_stub)
+      expect(nxt_brick.port_identifiers[identifier]).to equal(port)
     end
   end
 end