lego-nxt 0.2.0 → 0.3.0

data/lib/nxt/connector/output/base.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module NXT
+  module Connector
+    # Holds implementations of connectors that are output based.
+    module Output
+    end
+  end
+end

data/lib/nxt/connector/output/motor.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module NXT
+  module Connector
+    # Holds implementations of connectors that are output based.
+    module Output
+      # Implements the "motor" output for the NXT 2.0 module.
+      class Motor
+        include NXT::Command::Output
+        include NXT::Utils::Assertions
+        extend NXT::Utils::Accessors
+
+        DURATION_TYPE = %i[seconds degrees rotations].freeze
+        DURATION_AFTER = %i[coast brake].freeze
+        DIRECTION = %i[forwards backwards].freeze
+
+        attr_accessor :port, :interface
+
+        attr_combined_accessor :duration, 0
+        attr_combined_accessor :duration_type, :seconds
+        attr_combined_accessor :duration_after, :stop
+        attr_combined_accessor :direction, :forwards
+
+        attr_setter :direction, is_key_in: DIRECTION
+
+        def initialize(port, interface)
+          @port = port
+          @interface = interface
+        end
+
+        def duration=(duration, options = {})
+          raise(TypeError, 'Expected duration to be a number') unless duration.is_a?(Integer)
+
+          @duration = duration
+
+          self.duration_type = options[:type]
+          self.duration_after = options[:after]
+
+          case @duration_type
+          when :rotations
+            self.tacho_limit = @duration * 360
+          when :degrees
+            self.tacho_limit = @duration
+          end
+        end
+
+        def forwards
+          self.direction = :forwards
+          self
+        end
+
+        def backwards
+          self.direction = :backwards
+          self
+        end
+
+        def stop(mode = :coast)
+          self.power = 0
+          self.mode = mode
+
+          move
+        end
+
+        # takes block for response, or can return the response instead.
+        def move
+          update_output_state(duration.positive? && duration_type != :seconds)
+
+          if duration.positive? && duration_type == :seconds
+            wait_after_move
+          else
+            reset
+          end
+        end
+
+        def reset
+          self.duration = 0
+          self.direction = :forwards
+          self.power = 75
+          self.mode = :motor_on
+          self.regulation_mode = :idle
+          self.run_state = :running
+          self.tacho_limit = 0
+        end
+      end
+
+      private
+
+      def duration_type=(type)
+        if type.nil?
+          @duration_type = :seconds
+        else
+          assert_in(:type, type, DURATION_TYPE)
+          @duration_type = type
+        end
+      end
+
+      def duration_after=(after)
+        if after.nil?
+          @duration_after = :stop
+        else
+          unless @duration_type == :seconds
+            raise(TypeError, 'The after option is only available when the unit duration is in seconds.')
+          end
+
+          assert_in(:after, after, DURATION_AFTER)
+          @duration_after = after
+        end
+      end
+
+      def wait_after_move
+        sleep(duration)
+        reset
+        stop(duration_after)
+      end
+    end
+  end
+end

data/lib/nxt/exceptions.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module NXT
   module Exceptions
     # Raised when a class has not implemented a method from the base class
     # that is required to be overriden.
-    class InterfaceNotImplemented < NotImplementedError; end
+    class InterfaceNotImplemented < RuntimeError; end
 
     # Raised when an invalid interface is attempted to be constructed.
     class InvalidInterfaceError < TypeError; end

data/lib/nxt/interface/base.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module NXT
+  module Interface
+    # The base implementation of all communication interfaces. This is
+    # effectively the basic set of abstract methods that an interface needs to
+    # define to slot into this framework.
+    class Base
+      def send
+        raise(InterfaceNotImplemented, 'The #send method must be implemented.')
+      end
+
+      def receive
+        raise(InterfaceNotImplemented, 'The #receive method must be implemented.')
+      end
+    end
+  end
+end

data/lib/nxt/{interfaces → interface}/serial_port.rb

@@ -1,44 +1,47 @@
+# frozen_string_literal: true
+
 require 'serialport'
 
 module NXT
   module Interface
+    # Implements serial port connectivity to the NXT 2.0 module.
     class SerialPort < Base
       include NXT::Exceptions
 
       attr_reader :dev
 
-      BAUD_RATE = 57600
+      BAUD_RATE = 57_600
       DATA_BITS = 8
       STOP_BITS = 1
       PARITY = ::SerialPort::NONE
-      READ_TIMEOUT = 5000
+      READ_TIMEOUT = 5_000
 
       def initialize(dev)
-        self.dev = (dev)
+        super()
+        self.dev = dev
       end
 
       def dev=(dev)
-        raise InvalidDeviceError unless File.exists?(dev)
+        raise InvalidDeviceError unless File.exist?(dev)
+
         @dev = dev
       end
 
       def connect
         @connection = ::SerialPort.new(@dev, BAUD_RATE, DATA_BITS, STOP_BITS, PARITY)
 
-        if @connection.nil?
-          raise SerialPortConnectionError.new("Could not establish a SerialPort connection to #{dev}")
-        end
+        raise SerialPortConnectionError, "Could not establish a SerialPort connection to #{dev}" if @connection.nil?
 
         @connection.flow_control = ::SerialPort::HARD
         @connection.read_timeout = READ_TIMEOUT
 
         @connection
       rescue ArgumentError
-        raise SerialPortConnectionError.new("The #{dev} device is not a valid SerialPort")
+        raise SerialPortConnectionError, "The #{dev} device is not a valid SerialPort"
       end
 
       def disconnect
-        @connection.close if self.connected?
+        @connection.close if connected?
       end
 
       def connected?
@@ -69,7 +72,7 @@ module NXT
         #
         # Reference: Appendix 1, Page 22
         length = @connection.sysread(2)
-        @connection.sysread(length.unpack('v')[0])
+        @connection.sysread(length.unpack1('v')).from_hex_str
       end
     end
   end

data/lib/nxt/{interfaces → interface}/usb.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require 'libusb'
 
 module NXT
   module Interface
+    # Implements USB connectivity to the NXT 2.0 module.
     class Usb < Base
       include NXT::Exceptions
 
@@ -9,7 +12,7 @@ module NXT
       ID_PRODUCT_NXT = 0x0002
       OUT_ENDPOINT = 0x01
       IN_ENDPOINT = 0x82
-      TIMEOUT = 10000
+      TIMEOUT = 10_000
       READSIZE = 64
       INTERFACE = 0
 
@@ -17,9 +20,7 @@ module NXT
         @usb_context = LIBUSB::Context.new
         @dev = @usb_context.devices(idVendor: ID_VENDOR_LEGO, idProduct: ID_PRODUCT_NXT).first
 
-        if @dev.nil?
-          raise UsbConnectionError.new("Could not find NXT attached as USB device")
-        end
+        raise UsbConnectionError, 'Could not find NXT attached as USB device' if @dev.nil?
 
         @connection = @dev.open
         @connection.claim_interface(INTERFACE)
@@ -28,10 +29,10 @@ module NXT
       end
 
       def disconnect
-        if self.connected?
-          @connection.release_interface(INTERFACE)
-          @connection.close
-        end
+        return unless connected?
+
+        @connection.release_interface(INTERFACE)
+        @connection.close
       end
 
       def connected?
@@ -44,7 +45,7 @@ module NXT
       end
 
       def receive
-        @connection.bulk_transfer(endpoint: IN_ENDPOINT, dataIn: READSIZE, timeout: TIMEOUT)
+        @connection.bulk_transfer(endpoint: IN_ENDPOINT, dataIn: READSIZE, timeout: TIMEOUT).from_hex_str
       end
     end
   end

data/lib/nxt/nxt_brick.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This class is the entry point for end-users creating their own list of
 # commands to execute remotely on a Lego NXT brick.
 #
@@ -20,10 +22,11 @@
 #   nxt.disconnect
 class NXTBrick
   include NXT::Exceptions
+  include NXT::Utils::Assertions
 
   # An enumeration of possible ports, both input and output, that the NXT brick
   # can have connectors attached to.
-  PORTS = [:a, :b, :c, :one, :two, :three, :four]
+  PORTS = %i[a b c one two three four].freeze
 
   # Get the instance of the interface that this runner class is using to connect
   # to the NXT brick.
@@ -47,33 +50,31 @@ class NXTBrick
     interface_type = interface_type.to_s.classify
 
     unless NXT::Interface.constants.include?(interface_type.to_sym)
-      raise InvalidInterfaceError.new("There is no interface of type #{interface_type}.")
+      raise(InvalidInterfaceError, "There is no interface of type #{interface_type}.")
     end
 
-    self.interface = NXT::Interface.const_get(interface_type).new(*interface_args)
+    @interface = NXT::Interface.const_get(interface_type).new(*interface_args)
 
-    if block_given?
-      begin
-        self.connect
-        yield(self)
-      rescue Exception => e
-        binding.pry
-      ensure
-        self.disconnect
-      end
+    return unless block_given?
+
+    begin
+      connect
+      yield(self)
+    ensure
+      disconnect
     end
   end
 
   # Connect using the given interface to the NXT brick.
   def connect
-    self.interface.connect
+    @interface.connect
   end
 
   # Close the connection to the NXT brick, and dispose of any resources that
   # this instance of NXTBrick is using. Any commands run against this runner
   # after calling disconnect will fail.
   def disconnect
-    self.interface.disconnect
+    @interface.disconnect
   end
 
   # Add a new connector instance, binding a specific identifier to the given
@@ -90,45 +91,31 @@ class NXTBrick
   #                    be, though it must be able to hook in correctly
   #                    with the NXT library.
   def add(port, identifier, klass)
-    raise TypeError.new('Expected port to be a Symbol') unless port.is_a?(Symbol)
-    raise TypeError.new('Expected identifier to be a Symbol') unless identifier.is_a?(Symbol)
-    raise TypeError.new('Expected klass to be a Class') unless klass.is_a?(Class)
+    assert_in('port', port, PORTS)
+    assert_responds_to('identifier', identifier, :to_sym)
+    assert_type('klass', klass, Class)
+
+    if respond_to?(identifier)
+      if instance_variable_get(:"@#{port}").nil?
+        raise(
+          InvalidIdentifierError,
+          "Cannot use identifier #{identifier}, a method on #{self.class} is already using it."
+        )
+      end
 
-    unless PORTS.include?(port)
-      raise TypeError.new("Expected port to be one of: :#{PORTS.join(', :')}")
+      raise(PortTakenError, "Port #{port} is already set, call remove first")
     end
 
-    port_variable = :"@#{port}"
-
-    if !self.respond_to?(identifier)
-      # Makes a new instance of the class and pushes it into our instance variable
-      # for the given port.
-      self.instance_variable_set(port_variable, klass.new(port, self.interface))
-
-      # Given that that succeeded, all that remains is to add the identifier
-      # to our lookup Hash. We'll use this Hash later on within method_missing.
-      @port_identifiers[identifier] = port
-
-      # Define a method on the eigenclass of this instance.
-      (class << self; self; end).send(:define_method, identifier) do
-        self.instance_variable_get(port_variable)
-      end
-    else
-      if !self.instance_variable_get(port_variable).nil?
-        raise PortTakenError.new("Port #{port} is already set, call remove first")
-      else
-        raise InvalidIdentifierError.new("Cannot use identifier #{identifier}, a method on #{self.class} is already using it.")
-      end
-    end
+    define_port_handler_method(port, identifier, klass)
   end
 
   # Remove the assigned (if any) connector instance from the given
-  # identifier.
+  # identifier.interface
   #
   # @param Symbol identifier The identifier to search for and remove.
   def remove(identifier)
-    raise TypeError.new('Expected identifier to be a Symbol') unless identifier.is_a?(Symbol)
-    !!@port_identifiers.delete(identifier)
+    assert_responds_to('identifier', identifier, :to_sym)
+    !@port_identifiers.delete(identifier.to_sym).nil?
   end
 
   # This will dynamically add methods like:
@@ -146,8 +133,27 @@ class NXTBrick
       # people don't pass in the correct number of params, it says helpfully
       # '1 of 2' args passed (or something similar).
       define_method("add_#{const.to_s.underscore}_#{type_const.to_s.underscore}") do |port, identifier|
-        self.add(port, identifier, NXT::Connector.const_get(type_const).const_get(const))
+        add(port, identifier, NXT::Connector.const_get(type_const).const_get(const))
       end
     end
   end
+
+  private
+
+  def define_port_handler_method(port, identifier, klass)
+    port_variable = :"@#{port}"
+
+    # Makes a new instance of the class and pushes it into our instance variable
+    # for the given port.
+    instance_variable_set(port_variable, klass.new(port, interface))
+
+    # Given that that succeeded, all that remains is to add the identifier
+    # to our lookup Hash. We'll use this Hash later on within method_missing.
+    @port_identifiers[identifier.to_sym] = port
+
+    # Define a method on the eigenclass of this instance.
+    (class << self; self; end).send(:define_method, identifier.to_sym) do
+      instance_variable_get(port_variable)
+    end
+  end
 end

data/lib/nxt/patches/module.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# Some patches that extend the default Ruby Module with some useful methods.
 class Module
   # Creates an invariant accessor that allows getting and setting from the same
   # endpoint. It will operate in getter mode if you don't pass any arguments
@@ -8,10 +11,10 @@ class Module
     define_method(sym) do |*args|
       if args.empty?
         instance_var = :"@#{sym}"
-        if (value = self.instance_variable_get(instance_var))
+        if (value = instance_variable_get(instance_var))
           value
         else
-          self.instance_variable_set(instance_var, default)
+          instance_variable_set(instance_var, default)
           default
         end
       else