artoo 0.4.0 → 0.4.1

data/lib/artoo/robot.rb

@@ -26,50 +26,58 @@ module Artoo
 
     attr_reader :connections, :devices, :name
 
+    # Create new robot
+    # @param [Hash] params
+    # @option params [String]     :name
+    # @option params [Collection] :connections
+    # @option params [Collection] :devices
     def initialize(params={})
       @name = params[:name] || "Robot #{random_string}"
       initialize_connections(params[:connections] || {})
       initialize_devices(params[:devices] || {})
     end
-    
+
     class << self
       attr_accessor :device_types, :working_code, :running,
                     :use_api, :api_host, :api_port
-      
+
       def connection_types
         @@connection_types ||= []
       end
 
-      # connection to some hardware that has one or more devices via some specific protocol
-      # Example:
-      #   connection :arduino, :adaptor => :firmata, :port => '/dev/tty.usbmodemxxxxx'
+      # Connection to some hardware that has one or more devices via some specific protocol
+      # @example connection :arduino, :adaptor => :firmata, :port => '/dev/tty.usbmodemxxxxx'
+      # @param [String] name
+      # @param [Hash]   params
       def connection(name, params = {})
         Celluloid::Logger.info "Registering connection '#{name}'..."
         self.connection_types << {:name => name}.merge(params)
       end
 
-      # device that uses a connection to communicate
-      # Example:
-      #   device :collision_detect, :driver => :switch, :pin => 3
+      # Device that uses a connection to communicate
+      # @example device :collision_detect, :driver => :switch, :pin => 3
+      # @param [String] name
+      # @param [Hash]   params
       def device(name, params = {})
         Celluloid::Logger.info "Registering device '#{name}'..."
         self.device_types ||= []
         self.device_types << {:name => name}.merge(params)
       end
 
-      # the work that needs to be performed
-      # Example:
-      #   work do 
+      # The work that needs to be performed
+      # @example
+      #   work do
       #     every(10.seconds) do
       #       puts "hello, world"
       #     end
       #   end
+      # @param [block] work
       def work(&block)
         Celluloid::Logger.info "Preparing work..."
         self.working_code = block if block_given?
       end
 
-      # activate RESTful api
+      # Activate RESTful api
       # Example:
       #   api :host => '127.0.0.1', :port => '1234'
       def api(params = {})
@@ -79,10 +87,11 @@ module Artoo
         self.api_port = params[:port] || '4321'
       end
 
-      # work can be performed by either:
+      # Work can be performed by either:
       #  an existing instance
       #  an array of existing instances
       #  or, a new instance can be created
+      # @param [Robot] robot
       def work!(robot=nil)
         return if !test? && is_running?
         prepare_robots(robot)
@@ -95,6 +104,7 @@ module Artoo
         end
       end
 
+      # Prepare master robots for work
       def prepare_robots(robot=nil)
         if robot.respond_to?(:work)
           robots = [robot]
@@ -107,32 +117,39 @@ module Artoo
         Celluloid::Actor[:master] = Master.new(robots)
       end
 
+      # Master actor
       def master
         Celluloid::Actor[:master]
       end
 
+      # @return [Boolean] True if test env
       def test?
         ENV["ARTOO_TEST"] == 'true'
       end
 
+      # @return [Boolean] True if cli env
       def cli?
         ENV["ARTOO_CLI"] == 'true'
       end
 
+      # @return [Boolean] True if it's running
       def is_running?
         self.running ||= false
         self.running == true
       end
     end
 
+    # @return [String] Name without spaces and downcased
     def safe_name
       name.gsub(' ', '_').downcase
     end
 
+    # @return [String] Api Host
     def api_host
       self.class.api_host
     end
 
+    # @return [String] Api Port
     def api_port
       self.class.api_port
     end
@@ -145,48 +162,59 @@ module Artoo
       execute_working_code
     end
 
+    # pause the work
     def pause_work
       Logger.info "Pausing work..."
       current_instance.timers.pause
     end
 
+    # continue with the work
     def continue_work
       Logger.info "Continuing work..."
       current_instance.timers.continue
     end
 
+    # Terminate all connections
     def disconnect
       connections.each {|k, c| c.async.disconnect}
     end
 
+    # @return [Connection] default connection
     def default_connection
       connections.values.first
     end
 
+    # @return [Collection] connection types
     def connection_types
       current_class.connection_types
     end
 
+    # @return [Collection] device types
     def device_types
       current_class.device_types ||= []
       current_class.device_types
     end
 
+    # @return [Proc] current working code
     def working_code
       current_class.working_code ||= proc {puts "No work defined."}
     end
-    
+
+    # @return [Hash] robot
     def to_hash
-      {:name => name,
-       :connections => connections.each_value.collect {|c|c.to_hash},
-       :devices => devices.each_value.collect {|d|d.to_hash}
+      {
+        :name => name,
+        :connections => connections.each_value.collect {|c|c.to_hash},
+        :devices => devices.each_value.collect {|d|d.to_hash}
       }
     end
 
+    # @return [JSON] robot
     def as_json
       MultiJson.dump(to_hash)
     end
 
+    # @return [String] robot
     def inspect
       "#<Robot #{object_id}>"
     end

data/lib/artoo/utility.rb

@@ -1,38 +1,82 @@
-require 'active_support/inflector'
-
 module Artoo
+  # Utility methods used for convertions
   module Utility
+
+    # Converts camel_cased_word to constant
+    # @example "CamelCasedWord" > CamelCasedWord
+    # @return [Constant] Converted constant
     def constantize(camel_cased_word)
-      ActiveSupport::Inflector.constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant == Object
+          constant.const_get(name)
+        else
+          candidate = constant.const_get(name)
+          next candidate if constant.const_defined?(name, false)
+          next candidate unless Object.const_defined?(name)
+
+          # Go down the ancestors to check it it's owned
+          # directly before we reach Object or the end of ancestors.
+          constant = constant.ancestors.inject do |const, ancestor|
+            break const    if ancestor == Object
+            break ancestor if ancestor.const_defined?(name, false)
+            const
+          end
+
+          # owner is in Object, so raise
+          constant.const_get(name, false)
+        end
+      end
     end
 
-    def classify(underscored)
-      ActiveSupport::Inflector.camelize(underscored.to_s.sub(/.*\./, ''))
+    # Convert a underscore string to a class
+    # @example "underscore_word" > UnderscoreWord
+    # @return [Class] converted class
+    def classify(word)
+      underscore(word).gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
     end
 
+    # @return [String] random string
     def random_string
       (0...8).map{65.+(rand(26)).chr}.join
     end
 
+    # Converts camel cased word to downcased with undercores
+    # @example CamelCase > camel_case
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+
+    # @return [Celluloid::Actor] current instance
     def current_instance
       Celluloid::Actor.current
     end
 
+    # @return [Class] current actor class
     def current_class
       Celluloid::Actor.current.class
     end
   end
 end
 
-# just a bit of syntactic sugar, actually does nothing
-# Example:
-#  20.seconds => 20
-#  1.second => 1
+# Adds syntactic suger for seconds
 class Integer < Numeric
+  # @return [Integer] Plain number, actually does nothing
+  # @example 20.seconds => 20
   def seconds
     return self
   end
 
+  # @return [Integer] Plain number, actually does nothing
+  # @example 1.second => 1
   def second
     return self
   end

data/lib/artoo/version.rb

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

data/test/drivers/driver_test.rb

@@ -1,6 +1,10 @@
 require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
 require 'artoo/drivers/driver'
 
+class Awesome < Artoo::Drivers::Driver
+  COMMANDS = [:awesome].freeze
+end
+
 describe Artoo::Drivers::Driver do
   before do
     @device = mock('device')
@@ -18,4 +22,15 @@ describe Artoo::Drivers::Driver do
     @device.expects(:pin).returns(@pin)
     @driver.pin.must_equal @pin
   end
+
+  it 'Driver#commands' do
+    @awesome_driver = Awesome.new(:parent => @device)
+    @awesome_driver.commands.first.must_equal :awesome
+  end
+
+  it 'Driver#known_command?' do
+    @awesome_driver = Awesome.new(:parent => @device)
+    @awesome_driver.known_command?(:awesome).must_equal true
+    @awesome_driver.known_command?(:crazy).must_equal false
+  end
 end

data/test/drivers/led_test.rb

@@ -49,4 +49,8 @@ describe Artoo::Drivers::Led do
     @connection.expects(:analog_write).with(@pin, val)
     @led.brightness(val)
   end
+
+  it 'Led#commands' do
+    @led.commands.must_include :toggle
+  end
 end

data/test/utility_test.rb

@@ -1,27 +1,44 @@
 require File.expand_path(File.dirname(__FILE__) + "/test_helper")
-
-class UtilityTestRobot < Artoo::Robot
-  connection :test_connection
-  device :test_device_1
-  device :test_device_2
-end
+require File.expand_path(File.dirname(__FILE__) + "/utility_test_cases")
 
 describe Artoo::Utility do
-  before do
-    @robot = UtilityTestRobot.new
+  include UtilityTestCases
+  include Artoo::Utility
+
+  describe "#random_string" do
+    it "returns an 8-character String" do
+      random_string.must_be_kind_of String
+      random_string.size.must_equal 8
+    end
   end
 
-  it 'Artoo::Utility#random_string' do
-    string = @robot.random_string
-    string.must_be_kind_of String
-    string.size.must_equal 8
+  describe "#classify" do
+    it "converts a snake_case string to CamelCase" do
+      classify("firmata").must_equal "Firmata"
+      classify("ardrone_awesome").must_equal "ArdroneAwesome"
+
+      CamelToUnderscore.each do |camel, underscore|
+        classify(underscore).must_equal camel
+      end
+    end
   end
 
-  it 'Artoo::Utility#classify' do
-    string = @robot.classify('firmata')
-    string.must_equal 'Firmata'
+  describe "#underscore" do
+    it "converts CamelCase strings to snake_case" do
+      CamelToUnderscore.each do |camel, underscore|
+        underscore(camel).must_equal underscore
+      end
 
-    string = @robot.classify('ardrone_awesome')
-    string.must_equal 'ArdroneAwesome'
+      underscore("HTMLTidy").must_equal "html_tidy"
+      underscore("HTMLTidyGenerator").must_equal "html_tidy_generator"
+    end
   end
-end
+
+  describe "#constantize" do
+    it "converts strings to constants" do
+      run_constantize_tests_on do |string|
+        constantize(string)
+      end
+    end
+  end
+end

data/test/utility_test_cases.rb

@@ -0,0 +1,56 @@
+module Ace
+  module Base
+    class Case
+      class Dice
+      end
+    end
+    class Fase < Case
+    end
+  end
+  class Gas
+    include Base
+  end
+end
+
+class Object
+  module AddtlGlobalConstants
+    class Case
+      class Dice
+      end
+    end
+  end
+  include AddtlGlobalConstants
+end
+
+module UtilityTestCases
+  def run_constantize_tests_on
+    assert_equal Ace::Base::Case, yield("Ace::Base::Case")
+    assert_equal Ace::Base::Case, yield("::Ace::Base::Case")
+    assert_equal Ace::Base::Case::Dice, yield("Ace::Base::Case::Dice")
+    assert_equal Ace::Base::Fase::Dice, yield("Ace::Base::Fase::Dice")
+    assert_equal Ace::Gas::Case, yield("Ace::Gas::Case")
+    assert_equal Ace::Gas::Case::Dice, yield("Ace::Gas::Case::Dice")
+    assert_equal Case::Dice, yield("Case::Dice")
+    assert_equal Case::Dice, yield("Object::Case::Dice")
+    assert_equal UtilityTestCases, yield("UtilityTestCases")
+    assert_equal UtilityTestCases, yield("::UtilityTestCases")
+    assert_equal Object, yield("")
+    assert_equal Object, yield("::")
+    assert_raises(NameError) { yield("UnknownClass") }
+    assert_raises(NameError) { yield("UnknownClass::Ace") }
+    assert_raises(NameError) { yield("UnknownClass::Ace::Base") }
+    assert_raises(NameError) { yield("An invalid string") }
+    assert_raises(NameError) { yield("InvalidClass\n") }
+    assert_raises(NameError) { yield("Ace::UtilityTestCases") }
+    assert_raises(NameError) { yield("Ace::Base::UtilityTestCases") }
+    assert_raises(NameError) { yield("Ace::Gas::Base") }
+    assert_raises(NameError) { yield("Ace::Gas::UtilityTestCases") }
+  end
+end
+
+CamelToUnderscore = {
+  "Product"               => "product",
+  "SpecialGuest"          => "special_guest",
+  "ApplicationController" => "application_controller",
+  "Area51Controller"      => "area51_controller"
+}