artoo 0.1.0

data/lib/artoo/adaptors/loopback.rb

@@ -0,0 +1,8 @@
+require 'artoo/adaptors/adaptor'
+
+module Artoo
+  module Adaptors
+    class Loopback < Adaptor
+    end
+  end
+end

data/lib/artoo/adaptors/sphero.rb

@@ -0,0 +1,46 @@
+require 'artoo/adaptors/adaptor'
+
+module Artoo
+  module Adaptors
+    # Connect to a Sphero (http://gosphero.com)
+    class Sphero < Adaptor
+      RETRY_COUNT = 5
+      attr_reader :sphero
+
+      def finalize
+        if connected?
+          #sphero.stop
+          sphero.close
+        end
+      end
+
+      def connect
+        @retries_left = RETRY_COUNT
+        require 'sphero' unless defined?(::Sphero)
+        begin
+          @sphero = ::Sphero.new(connect_to)
+          super
+          return true
+        rescue Errno::EBUSY => e
+          @retries_left -= 1
+          if @retries_left > 0
+            retry
+          else
+            Logger.error e.message
+            Logger.error e.backtrace.inspect
+            return false
+          end
+        end
+      end
+
+      def disconnect
+        sphero.close
+        super
+      end
+
+      def method_missing(method_name, *arguments, &block)
+        sphero.send(method_name, *arguments, &block)
+      end
+    end
+  end
+end

data/lib/artoo/api.rb

@@ -0,0 +1,48 @@
+require 'reel'
+require 'artoo/api_route_helpers'
+require 'artoo/device_event_client'
+
+module Artoo
+  class Api < Reel::Server
+    include Artoo::ApiRouteHelpers
+
+    def initialize(host = "127.0.0.1", port = 3000)
+      super(host, port, &method(:on_connection))
+    end
+
+    def on_connection(connection)
+      while request = connection.request
+        dispatch!(connection, request)
+      end
+    end
+
+    get '/robots' do
+      MultiJson.dump(Actor[:master].robots.collect {|r|r.to_hash})
+    end
+
+    get '/robots/:robotid' do
+      Actor[:master].get_robot_by_name(@params['robotid']).as_json
+    end
+
+    get '/robots/:robotid/devices' do
+      MultiJson.dump(Actor[:master].get_robot_by_name(@params['robotid']).devices.each_value.collect {|d| d.to_hash})
+    end
+
+    get '/robots/:robotid/devices/:deviceid' do
+      Actor[:master].get_robot_by_name(@params['robotid']).devices[@params['deviceid'].intern].as_json
+    end
+
+    get_ws '/robots/:robotid/devices/:deviceid/events' do
+      DeviceEventClient.new(@req, Actor[:master].get_robot_by_name(@params['robotid']).devices[@params['deviceid'].intern].event_topic_name('update'))
+      return nil
+    end
+
+    get '/robots/:robotid/connections' do
+      MultiJson.dump(Actor[:master].get_robot_by_name(@params['robotid']).connections.each_value.collect {|c| c.to_hash})
+    end
+
+    get '/robots/:robotid/connections/:connectionid' do
+      Actor[:master].get_robot_by_name(@params['robotid']).connections[@params['connectionid'].intern].as_json
+    end
+  end
+end

data/lib/artoo/api_route_helpers.rb

@@ -0,0 +1,197 @@
+# route helpers used within the Artoo::Api class
+module Artoo
+  module ApiRouteHelpers
+    class ResponseHandled < StandardError; end
+    module ClassMethods
+
+      def static_path(default=File.join(File.dirname(__FILE__), "..", "..", "api/public"))
+        @static_path ||= default
+      end
+
+      def routes
+        @routes ||= {}
+      end
+
+      def route(verb, path, &block)
+        signature = compile!(verb, path, block, {})
+        (routes[verb] ||= []) << signature
+      end
+
+      ## Ripped from Sinatra 'cause it's so sexy in there
+      def generate_method(method_name, &block)
+        define_method(method_name, &block)
+        method = instance_method method_name
+        remove_method method_name
+        method
+      end
+
+      def compile!(verb, path, block, options = {})
+        options.each_pair { |option, args| send(option, *args) }
+        method_name             = "#{verb} #{path}"
+        unbound_method          = generate_method(method_name, &block)
+        pattern, keys           = compile path
+        conditions, @conditions = @conditions, []
+
+        [ pattern, keys, conditions, block.arity != 0 ?
+            proc { |a,p| unbound_method.bind(a).call(*p) } :
+            proc { |a,p| unbound_method.bind(a).call } ]
+      end
+
+      def compile(path)
+        keys = []
+        if path.respond_to? :to_str
+          ignore = ""
+          pattern = path.to_str.gsub(/[^\?\%\\\/\:\*\w]/) do |c|
+            ignore << escaped(c).join if c.match(/[\.@]/)
+            patt = encoded(c)
+            patt.gsub(/%[\da-fA-F]{2}/) do |match|
+              match.split(//).map {|char| char =~ /[A-Z]/ ? "[#{char}#{char.tr('A-Z', 'a-z')}]" : char}.join
+            end
+          end
+          pattern.gsub!(/((:\w+)|\*)/) do |match|
+            if match == "*"
+              keys << 'splat'
+              "(.*?)"
+            else
+              keys << $2[1..-1]
+              ignore_pattern = safe_ignore(ignore)
+
+              ignore_pattern
+            end
+          end
+          [/\A#{pattern}\z/, keys]
+        elsif path.respond_to?(:keys) && path.respond_to?(:match)
+          [path, path.keys]
+        elsif path.respond_to?(:names) && path.respond_to?(:match)
+          [path, path.names]
+        elsif path.respond_to? :match
+          [path, keys]
+        else
+          raise TypeError, path
+        end
+      end
+
+      def safe_ignore(ignore)
+        unsafe_ignore = []
+        ignore = ignore.gsub(/%[\da-fA-F]{2}/) do |hex|
+          unsafe_ignore << hex[1..2]
+          ''
+        end
+        unsafe_patterns = unsafe_ignore.map do |unsafe|
+          chars = unsafe.split(//).map do |char|
+            if char =~ /[A-Z]/
+              char <<= char.tr('A-Z', 'a-z')
+            end
+            char
+          end
+
+          "|(?:%[^#{chars[0]}].|%[#{chars[0]}][^#{chars[1]}])"
+        end
+        if unsafe_patterns.length > 0
+          "((?:[^#{ignore}/?#%]#{unsafe_patterns.join()})+)"
+        else
+          "([^#{ignore}/?#]+)"
+        end
+      end
+
+      # Helper route functions
+      def get(path, &block)
+        route 'GET', path, &block
+      end
+      def get_ws(path, &block)
+        route 'GET', path, &block
+      end
+      def put(path, &block)
+        route 'PUT', path, &block
+      end
+    end
+
+    module InstanceMethods
+      ## Handle the request
+      def dispatch!(connection, req)
+        resp = catch(:halt) do
+          try_static! connection, req
+          route!      connection, req
+        end
+        if resp && !resp.nil?
+          return if req.is_a?(Reel::WebSocket)
+          status, body = resp
+          req.respond status, body
+        else
+          req.respond :not_found, "NOT FOUND"
+        end
+      end
+
+      # Exit the current block, halts any further processing
+      # of the request, and returns the specified response.
+      def halt(*response)
+        response = response.first if response.length == 1
+        throw :halt, response
+      end
+
+      def try_static!(connection, req)
+        fpath = req.url == '/' ? 'index.html' : req.url[1..-1]
+        filepath = File.expand_path(fpath, self.class.static_path)
+        if File.file?(filepath)
+          # TODO: stream this?
+          data = open(filepath).read
+          halt :ok, data
+        end
+      end
+
+      def route!(connection, req)
+        if routes = self.class.routes[req.method]
+          routes.each do |pattern, keys, conditions, block|
+            route = req.url
+            next unless match = pattern.match(route)
+            values = match.captures.to_a.map { |v| URI.decode_www_form_component(v) if v }
+            if values.any?
+              params = {}
+              keys.zip(values) { |k,v| Array === params[k] ? params[k] << v : params[k] = v if v }
+              @params = params
+            end
+
+            @connection = connection
+            @req = req
+
+            begin
+              body = block ? block[self, values] : yield(self, values)
+              halt [:ok, body]
+            rescue Exception => e
+              p [:e, e]
+            end
+          end
+        end
+        nil
+      end
+
+      # Fixes encoding issues by
+      # * defaulting to UTF-8
+      # * casting params to Encoding.default_external
+      #
+      # The latter might not be necessary if Rack handles it one day.
+      # Keep an eye on Rack's LH #100.
+      def force_encoding(*args) settings.force_encoding(*args) end
+      if defined? Encoding
+        def self.force_encoding(data, encoding = default_encoding)
+          return if data == settings || data.is_a?(Tempfile)
+          if data.respond_to? :force_encoding
+            data.force_encoding(encoding).encode!
+          elsif data.respond_to? :each_value
+            data.each_value { |v| force_encoding(v, encoding) }
+          elsif data.respond_to? :each
+            data.each { |v| force_encoding(v, encoding) }
+          end
+          data
+        end
+      else
+        def self.force_encoding(data, *) data end
+      end
+    end
+
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+end

data/lib/artoo/connection.rb

@@ -0,0 +1,70 @@
+require 'artoo/utility'
+
+module Artoo
+  # The Connection class represents the interface to 
+  # a specific group of hardware devices. Examples would be an
+  # Arduino, a Sphero, or an ARDrone.
+  class Connection
+    include Celluloid
+    include Artoo::Utility
+
+    attr_reader :parent, :name, :port, :adaptor
+
+    def initialize(params={})
+      @name = params[:name].to_s
+      @port = Port.new(params[:port])
+      @parent = params[:parent]
+
+      require_adaptor(params[:adaptor] || :loopback)
+    end
+
+    def connect
+      Logger.info "Connecting to '#{name}' on port '#{port}'..."
+      adaptor.connect
+    rescue Exception => e
+      Logger.error e.message
+      Logger.error e.backtrace.inspect
+    end
+
+    def disconnect
+      Logger.info "Disconnecting from '#{name}' on port '#{port}'..."
+      adaptor.disconnect
+    end
+
+    def connected?
+      adaptor.connected?
+    end
+
+    def to_hash
+      {:name => name,
+       :port => port.to_s,
+       :adaptor => adaptor.class.name.demodulize,
+       :connected => connected?
+      }
+    end
+
+    def as_json
+      MultiJson.dump(to_hash)
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      unless adaptor.connected?
+        Logger.warn "Cannot call unconnected adaptor '#{name}', attempting to reconnect..."
+        adaptor.reconnect
+        return nil
+      end
+      adaptor.send(method_name, *arguments, &block)
+    rescue Exception => e
+      Logger.error e.message
+      Logger.error e.backtrace.inspect
+      return nil
+    end
+
+    private
+
+    def require_adaptor(type)
+      require "artoo/adaptors/#{type.to_s}"
+      @adaptor = constantize("Artoo::Adaptors::#{classify(type.to_s)}").new(:port => port, :parent => current_instance)
+    end
+  end
+end

data/lib/artoo/delegator.rb

@@ -0,0 +1,49 @@
+
+module Artoo
+  # Execution context for top-level robots
+  # DSL methods executed on main are delegated to this class like Sinatra
+  class MainRobot < Robot
+    #set :logging, Proc.new { ! test? }
+    #set :method_override, true
+    set :start_work, false #Proc.new { ! test? }
+    #set :app_file, nil
+
+    # def self.register(*extensions, &block) #:nodoc:
+    #   added_methods = extensions.map {|m| m.public_instance_methods }.flatten
+    #   Delegator.delegate(*added_methods)
+    #   super(*extensions, &block)
+    # end
+  end
+  
+  # Artoo delegation mixin that acts like Sinatra. 
+  # Mixing this module into an object causes all
+  # methods to be delegated to the Artoo::MainRobot class. 
+  # Used primarily at the top-level.
+  module Delegator #:nodoc:
+    def self.delegate(*methods)
+      methods.each do |method_name|
+        define_method(method_name) do |*args, &block|
+          return super(*args, &block) if respond_to? method_name
+          Delegator.target.send(method_name, *args, &block)
+        end
+        private method_name
+      end
+    end
+
+    delegate :connection, :device, :work, :api, :set, :test?
+
+    class << self
+      attr_accessor :target
+    end
+
+    self.target = Artoo::MainRobot
+  end
+
+  # Create a new Artoo robot. The block is evaluated
+  # in the new robot's class scope.
+  def self.new(robot=Robot, options={}, &block)
+    robot = Class.new(robot)
+    robot.class_eval(&block) if block_given?
+    robot
+  end
+end

data/lib/artoo/device.rb

@@ -0,0 +1,61 @@
+module Artoo
+  # The Artoo::Device class represents the interface to 
+  # a specific individual hardware devices. Examples would be a digital
+  # thermometer connected to an Arduino, or a Sphero's accelerometer.
+  class Device
+    include Celluloid
+    include Artoo::Utility
+    
+    attr_reader :parent, :name, :driver, :pin, :connection, :interval
+
+    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
+
+      require_driver(params[:driver] || :passthru)
+    end
+
+    def determine_connection(c)
+      parent.connections[c] unless c.nil?
+    end
+
+    def default_connection
+      parent.default_connection
+    end
+
+    def start_device
+      driver.start_driver
+    end
+
+    def event_topic_name(event)
+      "#{parent.safe_name}_#{name}_#{event}"  
+    end
+
+    def to_hash
+      {:name => name,
+       :driver => driver.class.name.demodulize,
+       :pin => pin.to_s,
+       :connection => connection.to_hash,
+       :interval => interval
+      }
+    end
+
+    def as_json
+      MultiJson.dump(to_hash)
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      driver.send(method_name, *arguments, &block)
+    end
+
+    private
+
+    def require_driver(d)
+      require "artoo/drivers/#{d.to_s}"
+      @driver = constantize("Artoo::Drivers::#{classify(d.to_s)}").new(:parent => current_instance)
+    end
+  end
+end