artoo 1.6.7 → 1.8.0

data/lib/artoo/connection.rb

@@ -9,7 +9,7 @@ module Artoo
     include Artoo::Utility
     include Comparable
 
-    attr_reader :parent, :name, :port, :adaptor, :connection_id
+    attr_reader :parent, :name, :port, :adaptor, :connection_id, :details
 
     # Create new connection
     # @param [Hash] params
@@ -23,6 +23,7 @@ module Artoo
       @name = params[:name].to_s
       @port = Port.new(params[:port])
       @parent = params[:parent]
+      @details = remove_keys(params, :name, :parent, :id, :loopback)
 
       require_adaptor(params[:adaptor] || :loopback, params)
     end
@@ -58,10 +59,8 @@ module Artoo
     def to_hash
       {
         :name => name,
-        :connection_id => connection_id,
-        :port => port.to_s,
         :adaptor => adaptor_name.to_s.gsub(/^.*::/, ''),
-        :connected => connected?
+        :details => @details
       }
     end
 
@@ -90,11 +89,15 @@ module Artoo
       return nil
     end
 
+    def respond_to_missing?(method_name, include_private = false)
+      # TODO: verify that the adaptor supprts the method we're calling
+      true
+    end
+
     private
 
     def require_adaptor(type, params)
       if Artoo::Robot.test?
-        original_type = type
         type = :test
       end
 

data/lib/artoo/device.rb

@@ -6,7 +6,7 @@ module Artoo
     include Celluloid
     include Artoo::Utility
 
-    attr_reader :parent, :name, :driver, :pin, :connection, :interval
+    attr_reader :parent, :name, :driver, :pin, :connection, :interval, :interface, :details
 
     # Create new device
     # @param  [Hash] params
@@ -17,11 +17,15 @@ module Artoo
     # @option params :interval   [String]
     # @option params :driver     [String]
     def initialize(params={})
-      @name = params[:name].to_s
-      @pin = params[:pin]
-      @parent = params[:parent]
-      @connection = determine_connection(params[:connection]) || default_connection
-      @interval = params[:interval] || 0.5
+      @name       = params[:name].to_s
+      @pin        = params[:pin]
+      @parent     = params[:parent]
+      @connection = determine_connection(params[:connection]) ||
+        default_connection
+      @interval   = params[:interval] || 0.5
+
+      @details = remove_keys(params, :name, :parent, :connection,
+                             :passthru, :driver)
 
       require_driver(params[:driver] || :passthru, params)
     end
@@ -60,10 +64,9 @@ module Artoo
       {
         :name => name,
         :driver => driver.class.name.to_s.gsub(/^.*::/, ''),
-        :pin => pin.to_s,
-        :connection => connection.to_hash,
-        :interval => interval,
-        :commands => driver.commands
+        :connection => connection.name,
+        :commands => driver.commands,
+        :details => @details
       }
     end
 
@@ -87,9 +90,24 @@ module Artoo
       command(method_name, *arguments, &block)
     end
 
+    def respond_to_missing?(method_name, include_private = false)
+      commands.include?(method_name) || super
+    end
+
     # @return [String] pretty inspect
     def inspect
-      "#<Device @id=#{object_id}, @name='name', @driver='driver'>"
+      "#<Device @id=#{object_id}, @name='name', @driver='#{driver.class.name}'>"
+    end
+
+    def add_interface(i)
+      @parent.add_interface(i)  
+    end
+
+    def require_interface(i)
+      Logger.info "Require interface #{i}"
+      require "artoo/interfaces/#{i.to_s}"
+      @interface = constantize("Artoo::Interfaces::#{classify(i.to_s)}").new(:name => i.to_s, :robot => parent, :device => current_instance)      
+      add_interface(@interface)
     end
 
     private

data/lib/artoo/drivers/driver.rb

@@ -77,6 +77,10 @@ module Artoo
         return false
       end
 
+      def require_interface(i)
+        parent.require_interface(i)
+      end
+
       # Sends missing methods to connection
       def method_missing(method_name, *arguments, &block)
         connection.send(method_name, *arguments, &block)

data/lib/artoo/drivers/{pinger.rb → ping.rb}

@@ -3,22 +3,22 @@ require 'artoo/drivers/driver'
 module Artoo
   module Drivers
     # Test driver that can be pinged itself
-    class Pinger < Driver
+    class Ping < Driver
 
       COMMANDS = [:ping].freeze
 
       def start_driver
-        @count = 0
         super
       end
 
       # Publishes events to update event topic
       # when pinged
       def ping
-        @count += 1
-        publish(event_topic_name("update"), "ping", @count)
-        publish(event_topic_name("ping"), @count)
-        "ping #{@count}"
+        data = 'pong'
+        publish(event_topic_name("update"), "ping", data)
+        publish(event_topic_name("ping"), data)
+
+        data
       end
     end
   end

data/lib/artoo/interfaces/interface.rb

@@ -0,0 +1,37 @@
+module Artoo
+  module Interfaces
+    # The Interface class is the base class used to
+    # implement behavior for a specific category of robot. Examples
+    # would be a Rover or Copter.
+    #
+    # Derive a class from this class, in order to implement higher-order 
+    # behavior for a new category of robot.
+    class Interface
+      include Celluloid
+      include Celluloid::Notifications
+
+      attr_accessor :name, :robot, :device
+
+      def interface_type
+        :raw
+      end
+
+      COMMANDS = [].freeze
+
+      # Create new interface
+      # @param [Hash] params
+      # @option params [Object] :robot
+      # @option params [Object] :device
+      def initialize(params={})
+        @name = params[:name]
+        @robot = params[:robot]
+        @device = params[:device]
+      end
+
+      # @return [Collection] commands
+      def commands
+        self.class.const_get('COMMANDS')
+      end
+    end
+  end
+end

data/lib/artoo/interfaces/ping.rb

@@ -0,0 +1,17 @@
+require 'artoo/interfaces/interface'
+
+module Artoo
+  module Interfaces
+    # The Ping interface.
+    class Ping < Interface
+      def interface_type
+        :ping
+      end
+
+      COMMANDS = [:ping]
+
+      def ping
+      end
+    end
+  end
+end

data/lib/artoo/interfaces/rover.rb

@@ -0,0 +1,35 @@
+require 'artoo/interfaces/interface'
+
+module Artoo
+  module Interfaces
+    # The Rover interface.
+    class Rover < Interface
+      def interface_type
+        :rover
+      end
+
+      COMMANDS = [:forward, :backward, :left, :right, :turn_left, :turn_right, :stop]
+
+      def forward(speed)
+      end
+
+      def backward(speed)
+      end
+
+      def left(speed)
+      end
+
+      def right(speed)
+      end
+
+      def turn_left(degrees)
+      end
+
+      def turn_right(degrees)
+      end
+
+      def stop
+      end
+    end
+  end
+end

data/lib/artoo/master.rb

@@ -22,6 +22,10 @@ module Artoo
         current.robot(name)
       end
 
+      def robot?(name)
+        current.robot?(name)
+      end
+
       def start_work
         current.start_work
       end
@@ -37,12 +41,26 @@ module Artoo
       def continue_work
         current.continue_work
       end
+
+      def command(name, params)
+        current.command(name, params)
+      end
+
+      def add_command(name, behaviour)
+        current.add_command(name, behaviour)
+      end
+
+      def commands
+        current.commands
+      end
+
     end
 
     # Create new master
     # @param [Collection] robots
     def initialize(bots=[])
       @robots = []
+      @commands = []
       assign(bots)
     end
 
@@ -56,9 +74,11 @@ module Artoo
     # @param  [String] name
     # @return [Robot]  robot
     def robot(name)
-      r = robots.find {|r| r.name == name}
-      raise RobotNotFound if r.nil?
-      r
+      robots.find {|r| r.name == name}
+    end
+
+    def robot?(name)
+      robots.find {|r| r.name == name}
     end
 
     # @param  [String]     name
@@ -111,5 +131,27 @@ module Artoo
       robots.each {|r| r.terminate} unless !Artoo::Robot.is_running?
       Artoo::Robot.stopped!
     end
+
+    # return list of master command names
+    def commands
+      @commands.map{ |c| c[:name] }
+    end
+
+    # execute master command
+    def command(name, params)
+      command = @commands.find{ |c| c[:name] == name.to_sym }
+      if command
+        if params.nil?
+          command[:behaviour].call
+        else
+          command[:behaviour].call(params)
+        end
+      end
+    end
+
+    # add command to master
+    def add_command(name, behaviour)
+      @commands << { name: name.to_sym, behaviour: behaviour }
+    end
   end
 end

data/lib/artoo/robot.rb

@@ -1,8 +1,6 @@
 require 'celluloid/autostart'
 require 'celluloid/io'
 require 'multi_json'
-require 'artoo/ext/timers'
-require 'artoo/ext/actor'
 
 require 'artoo/robot_class_methods'
 require 'artoo/basic'
@@ -16,6 +14,9 @@ require 'artoo/api/api'
 require 'artoo/master'
 require 'artoo/port'
 require 'artoo/utility'
+require 'artoo/interfaces/interface'
+require 'artoo/interfaces/ping'
+require 'artoo/interfaces/rover'
 
 module Artoo
   # The most important class used by Artoo is Robot. This represents the primary
@@ -30,7 +31,7 @@ module Artoo
     include Artoo::Utility
     include Artoo::Events
 
-    attr_reader :connections, :devices, :name, :commands
+    attr_reader :connections, :devices, :name, :commands, :interfaces
 
     exclusive :execute_startup
 
@@ -42,6 +43,7 @@ module Artoo
     def initialize(params={})
       @name = params[:name] || current_class.name || "Robot #{random_string}"
       @commands = params[:commands] || []
+      @interfaces = {}
       initialize_connections(params[:connections] || {})
       initialize_devices(params[:devices] || {})
     end
@@ -134,12 +136,14 @@ module Artoo
       "#<Robot #{object_id}>"
     end
 
-    def command(method_name, *arguments)
-      if known_command?(method_name)
+    # @return [Object] whatever result is passed back from the wrapped robot
+    def command(method_name, *arguments, &block)
+      t = interface_for_command(method_name)
+      if t
         if arguments.first
-          self.send(method_name, *arguments)
+          t.send(method_name, *arguments)
         else
-          self.send(method_name)
+          t.send(method_name)
         end
       else
         "Unknown Command"
@@ -151,10 +155,31 @@ module Artoo
     end
 
     # @return [Boolean] True if command exists
-    def known_command?(method_name)
+    def own_command?(method_name)
       return commands.include?(method_name.intern)
     end
 
+    def add_interface(i)
+      @interfaces[i.interface_type.intern] = i
+    end
+
+    # @return [Boolean] True if command exists in any of the robot's interfaces
+    def interface_for_command(method_name)
+      return self if own_command?(method_name)
+      @interfaces.each_value {|i|
+        return i if i.commands.include?(method_name.intern)
+      }
+      return nil
+    end
+
+    # Sends missing methods to command
+    def method_missing(method_name, *arguments, &block)
+      command(method_name, *arguments, &block)
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      own_command?(method_name)|| interface_for_command(method_name)
+    end
 
     private
 

data/lib/artoo/utility.rb

@@ -85,5 +85,15 @@ module Artoo
         end
       )
     end
+
+    # Removes selected keys from hash
+    # @example {one: 'one', two: 'two'} => {two: 'two'}
+    # @return [Hash] new object without selected keys
+    def remove_keys(h, *keys)
+      hash = h.dup
+      keys.each { |key| hash.delete(key)  }
+      hash
+    end
+
   end
 end

data/lib/artoo/version.rb

@@ -1,5 +1,5 @@
 module Artoo
   unless const_defined?('VERSION')
-    VERSION = "1.6.7"
+    VERSION = "1.8.0"
   end
 end

data/test/api/api_routes_test.rb

@@ -0,0 +1,46 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+
+describe "API routes" do
+
+  let(:base) { 'http://localhost:8080' }
+
+  def validate_route(relative_path, status=200)
+    res = HTTP.get(base + relative_path)
+    res.status.must_equal status
+  end
+
+  def validate_form(relative_path, params)
+    res = HTTP.post base + '/api/commands/echo', :body => JSON.dump(params)
+
+    res.status.must_equal 200
+  end
+
+  before :all do
+    @pid = fork { require_relative '../../examples/test_bot' }
+    sleep 1
+  end
+
+  after (:all) { system("kill -9 #{@pid}") }
+
+  it 'must respond to expected routes' do
+    validate_route('/api')
+    validate_route('/api/commands')
+    validate_route('/api/robots')
+    validate_route('/api/robots/TestBot')
+    validate_route('/api/robots/NonExistentBot', 404)
+    validate_route('/api/robots/TestBot/commands')
+    validate_route('/api/robots/TestBot/commands/hello')
+    validate_route('/api/robots/TestBot/devices')
+    validate_route('/api/robots/TestBot/devices/ping')
+    validate_route('/api/robots/TestBot/devices/ping/commands')
+    validate_route('/api/robots/TestBot/connections')
+    validate_route('/api/robots/TestBot/connections/loopback')
+  end
+
+  it 'must respond to command calls' do
+    validate_form('/api/commands/echo', { param: 'pong' })
+    validate_form('/api/robots/TestBot/devices/ping/commands/ping',
+                  { name: 'bot' })
+  end
+
+end

data/test/connection_test.rb

@@ -23,10 +23,10 @@ describe Artoo::Connection do
 
   it 'Artoo::Connection#as_json' do
     MultiJson.load(@connection.as_json, :symbolize_keys => true)[:name].must_equal "my_test_connection"
-    MultiJson.load(@connection.as_json, :symbolize_keys => true)[:connected].must_equal false
+    MultiJson.load(@connection.as_json, :symbolize_keys => true)[:adaptor].must_equal "Loopback"
   end
 
   it 'Artoo::Connection#additional_params' do
     @robot.default_connection.adaptor.additional_params[:awesomeness].must_equal :high
   end
-end
+end

data/test/device_test.rb

@@ -43,4 +43,11 @@ describe Artoo::Device do
     @device = @robot.devices[:test_device_2]
     @device.driver.additional_params[:cool_factor].must_equal 11
   end
-end
+
+  it 'Artoo::Device#require_interface' do
+    @device = @robot.devices[:test_device_1]
+    @device.require_interface(:ping)
+    @device.interface.name.must_equal 'ping'
+    @robot.interfaces[:ping].name.must_equal 'ping'
+  end
+end

data/test/interfaces/interface_test.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+
+class Awesomeness < Artoo::Interfaces::Interface
+  COMMANDS = [:awesome].freeze
+
+  def interface_type
+    :awesomeness
+  end
+
+  def awesome
+    true
+  end
+end
+
+describe Artoo::Interfaces::Interface do
+  before do
+    @robot = mock('robot')
+    @device = mock('device')
+    @interface = Awesomeness.new(:robot => @robot, :device => @device)
+  end
+
+  it 'Interface#interface_type' do
+    @interface.interface_type.must_equal :awesomeness
+  end
+
+  it 'Interface#commands' do
+    @interface.commands.first.must_equal :awesome
+  end  
+end

data/test/master_test.rb

@@ -23,7 +23,7 @@ describe Artoo::Master do
     @robot1 = MockRobot.new("robot1")
     @robot2 = MockRobot.new("robot2")
     @robot3 = MockRobot.new("robot3")
-    
+
     @robots << @robot1
     @robots << @robot2
     @robots << @robot3
@@ -36,14 +36,20 @@ describe Artoo::Master do
   end
 
   it 'Artoo::Master#robot with invalid robot name' do
-    proc {@master.robot("robotno")}.must_raise(Artoo::RobotNotFound)
+    @master.robot("robotno").must_equal(nil)
+  end
+
+  it 'Artoo::Master::#commands' do
+    @master.commands.must_equal []
   end
 
-  it 'Artoo::Master#robot_devices' do
-    @master.robot_devices("robot2").first.must_equal "robot2-device1"
+  it 'Artoo::Master::#add_command' do
+    @master.add_command :test, lambda{}
+    @master.commands.must_equal [:test]
   end
 
-  it 'Artoo::Master#robot_connections' do
-    @master.robot_connections("robot2").last.must_equal "robot2-connection3"
+  it 'Artoo::Master::#command' do
+    @master.add_command :test, lambda{'test'}
+    @master.command(:test, nil).must_equal 'test'
   end
-end
+end