rosruby 0.0.1

data/scripts/gensrv_ruby.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+# Software License Agreement (BSD License)
+#
+# Copyright (c) 2012, Takashi Ogura
+#
+# based on 
+#
+# Copyright (c) 2008, Willow Garage, Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+#  * Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+#  * Redistributions in binary form must reproduce the above
+#    copyright notice, this list of conditions and the following
+#    disclaimer in the documentation and/or other materials provided
+#    with the distribution.
+#  * Neither the name of Willow Garage, Inc. nor the names of its
+#    contributors may be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# Revision $Id:$
+
+
+"""
+ROS message source code generation for rospy.
+
+Converts ROS .srv files into Python source code implementations.
+"""
+import roslib
+
+import roslib.srvs
+
+import genmsg_ruby
+
+REQUEST ='Request'
+RESPONSE='Response'
+
+import sys
+import os
+
+def srv_generator(package, name, spec):
+    req, resp = ["%s%s"%(name, suff) for suff in [REQUEST, RESPONSE]]
+
+    fulltype = '%s%s%s'%(package, roslib.srvs.SEP, name)
+
+    gendeps_dict = roslib.gentools.get_dependencies(spec, package)
+    md5 = roslib.gentools.compute_md5(gendeps_dict)
+    yield "module %s\n"%package.capitalize()
+    yield "class %s\n"%name
+    yield """  def self.type
+    '%s'
+  end
+"""%fulltype
+    yield """  def self.md5sum
+    '%s'
+  end
+"""%md5
+    yield """  def self.request_class
+    %s
+  end
+"""%req
+    yield """  def self.response_class
+    %s
+  end
+end
+end"""%resp
+
+def gen_srv(path, output_dir_prefix=None):
+    f = os.path.abspath(path)
+    (package_dir, package) = roslib.packages.get_dir_pkg(f)
+    (name, spec) = roslib.srvs.load_from_file(f, package)
+    base_name = roslib.names.resource_name_base(name)
+    if not output_dir_prefix:
+        output_dir_prefix = '%s/srv_gen/ruby'%package_dir
+    output_dir = '%s/%s'%(output_dir_prefix, package)
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    out = open('%s/%s.rb'%(output_dir, base_name), 'w')
+    for mspec, suffix in ((spec.request, REQUEST), (spec.response, RESPONSE)):
+        out.write(genmsg_ruby.msg_generator(package, base_name+suffix, mspec))
+    for l in srv_generator(package, base_name, spec):
+        out.write(l)
+    out.close()
+
+if __name__ == "__main__":
+    for arg in sys.argv[1:]:
+        gen_srv(arg)
+

data/scripts/rosruby_genmsg.py

@@ -0,0 +1,67 @@
+#! /usr/bin/env python
+
+# msg/srv generator for precompiled system
+# It is useful if you are using precompiled ROS system,
+# because it needs root access and there are ROS_NOBUILD file in the packages.
+# This script generates *.rb files in the rosruby dir.
+
+import genmsg_ruby
+import gensrv_ruby
+from roslib.packages import get_pkg_dir
+
+# for electirc
+try:
+    from roslib.packages import ROSPackages
+    def get_all_deps(packages):
+        rp = ROSPackages()
+        depends = rp.depends(packages)
+        all_deps = set()
+        for packs in depends.values():
+            for pack in packs:
+                all_deps.add(pack)
+        for pack in packages:
+            all_deps.add(pack)
+        return all_deps
+# for fuerte
+except ImportError:
+    from rospkg import RosPack
+    def get_all_deps(packages):
+        rp = RosPack()
+        all_deps = set()
+        for pack in packages:
+            depends = rp.get_depends(pack)
+            for dep in depends:
+                all_deps.add(dep)
+        for pack in packages:
+            all_deps.add(pack)
+        return all_deps
+import sys
+import os
+
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        packages = ['std_msgs', 'rosgraph_msgs', 'roscpp_tutorials']
+    else:
+        packages = sys.argv[1:]
+
+    for pack in get_all_deps(packages):
+        msg_dir = "%s/msg/"%get_pkg_dir(pack)
+        base_dir = os.environ.get("HOME") + "/.ros/rosruby"
+        msg_output_prefix = "%s/msg_gen/ruby"%base_dir
+        if os.path.exists(msg_dir):
+            for file in os.listdir(msg_dir):
+                base, ext = os.path.splitext(file)
+                if ext == '.msg':
+                    print "generating " + file
+                    genmsg_ruby.gen_msg(msg_dir+file, msg_output_prefix)
+
+        srv_dir = "%s/srv/"%get_pkg_dir(pack)
+        srv_output_prefix = "%s/srv_gen/ruby"%base_dir
+        if os.path.exists(srv_dir):
+            for file in os.listdir(srv_dir):
+                base, ext = os.path.splitext(file)
+                if ext == '.srv':
+                    print "generating " + file
+                    gensrv_ruby.gen_srv(srv_dir+file, srv_output_prefix)

data/scripts/run-test.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+
+test_file = "test/test_*.rb"
+
+$:.push("#{File.dirname(__FILE__)}/..")
+$:.unshift(File.join(File.expand_path("."), "lib"))
+$:.unshift(File.join(File.expand_path("."), "test"))
+
+require 'rubygems'
+gem 'simplecov', :require => false, :group => :test
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/test/"
+end
+
+Dir.glob(test_file) do |file|
+  require file.sub(/\.rb$/, '')
+end

data/test/test_header.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'stringio'
+require 'ros/tcpros/header'
+
+class TestParam_Normal < Test::Unit::TestCase
+  def test_serialize
+    header = ROS::TCPROS::Header.new
+    header['aa'] = '5'
+    assert_equal('5', header['aa'])
+    sio = StringIO.new
+    header.serialize(sio)
+    sio.rewind
+    data = sio.read
+    assert_equal("\b\000\000\000\004\000\000\000aa=5", data)
+
+    header2 = ROS::TCPROS::Header.new
+    assert_equal(header2, header2.deserialize("\b\000\000\000\004\000\000\000aa=5"[4..-1]))
+    assert_equal('5', header2['aa'])
+
+    header3 = ROS::TCPROS::Header.new
+    header3['hoge'] = '1'
+
+    # wild_card
+    assert(header3.valid?('hoge', '*'))
+  end
+
+  def test_check_string
+    header = ROS::TCPROS::Header.new
+    assert_raise(ArgumentError) { header['aa'] = 1}
+    assert_raise(ArgumentError) { header[5] = '1'}
+    assert_raise(ArgumentError) { header[:symbol] = '1'}
+    assert_raise(ArgumentError) { header[String] = '1'}
+  end
+end

data/test/test_log.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'ros'
+require 'test/unit'
+
+class TestLog < Test::Unit::TestCase
+  def test_output
+    node1 = ROS::Node.new('/test_log')
+    check_msg = nil
+    sub = node1.subscribe('/rosout', Rosgraph_msgs::Log) do |msg|
+      check_msg = msg
+    end
+    node1.loginfo('msg1')
+    sleep(0.5)
+    node1.spin_once
+    assert_equal('msg1', check_msg.msg)
+    assert_equal(Rosgraph_msgs::Log::INFO, check_msg.level)
+
+    node1.logerror('msg2')
+    sleep(0.1)
+    node1.spin_once
+    assert_equal('msg2', check_msg.msg)
+    assert_equal(Rosgraph_msgs::Log::ERROR, check_msg.level)
+
+    node1.logfatal('msg3')
+    sleep(0.1)
+    node1.spin_once
+    assert_equal('msg3', check_msg.msg)
+    assert_equal(Rosgraph_msgs::Log::FATAL, check_msg.level)
+
+    node1.logfatal('msg4')
+    sleep(0.1)
+    node1.spin_once
+    assert_equal('msg4', check_msg.msg)
+    assert_equal(Rosgraph_msgs::Log::FATAL, check_msg.level)
+
+    node1.logwarn('msg5')
+    sleep(0.1)
+    node1.spin_once
+    assert_equal('msg5', check_msg.msg)
+    assert_equal(Rosgraph_msgs::Log::WARN, check_msg.level)
+
+    node1.shutdown
+  end
+end

data/test/test_master_proxy.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+require 'ros/master_proxy'
+require 'test/unit'
+
+class TestRegister < Test::Unit::TestCase
+  DUMMY_SERVICE_URI = 'rosrpc://dummy:1234'
+  DUMMY_SERVICE_NAME = '/dummy_service'
+
+  DUMMY_TOPIC_NAME = '/dummy_service'
+
+  def test_service
+    proxy = ROS::MasterProxy.new('/test_node', ENV['ROS_MASTER_URI'], 'http://dummy:11111')
+    proxy.register_service(DUMMY_SERVICE_NAME, DUMMY_SERVICE_URI)
+    uri = proxy.lookup_service(DUMMY_SERVICE_NAME)
+    assert_equal(DUMMY_SERVICE_URI, uri)
+    proxy.unregister_service(DUMMY_SERVICE_NAME, DUMMY_SERVICE_URI)
+    result = proxy.lookup_service(DUMMY_SERVICE_NAME)
+    assert(!result)
+  end
+
+  def test_subscriber
+    proxy = ROS::MasterProxy.new('/test_node2', ENV['ROS_MASTER_URI'], 'http://dummy:11111')
+    pub = proxy.register_subscriber('/rosout_agg', 'rosgraph_msgs/Log')
+    assert(pub.length > 0)
+    proxy.unregister_subscriber('/rosout_agg')
+  end
+
+  def test_publisher
+    proxy = ROS::MasterProxy.new('/test_node3', ENV['ROS_MASTER_URI'], 'http://dummy:11111')
+    sub = proxy.register_publisher('/rosout', 'rosgraph_msgs/Log')
+    assert(sub.length > 0)
+    num = proxy.unregister_publisher('/rosout')
+    assert_equal(1, num)
+  end
+
+  def test_param_subscriber
+    proxy = ROS::MasterProxy.new('/test_node4', ENV['ROS_MASTER_URI'], 'http://dummy:11111')
+    assert(proxy.subscribe_param('/rosversion'))
+    assert(proxy.unsubscribe_param('/rosversion'))
+  end
+end
+
+
+class TestSystem < Test::Unit::TestCase
+
+  def test_lookup
+    proxy = ROS::MasterProxy.new('/test_node', ENV['ROS_MASTER_URI'], 'http://dummy:11111')
+    uri = proxy.lookup_node('/rosout')
+    assert(/^http:.*:[0-9]+/ =~ uri)
+    assert(!proxy.lookup_node('/THIS_NODE_DOES_NOT_EXIST'))
+    assert(proxy.get_published_topics('').length > 0)
+    assert(proxy.get_published_topics('/NO_EXIST_NS').length == 0)
+    pub, sub, ser = proxy.get_system_state
+    assert_equal(1, pub.length)
+    assert_equal(1, sub.length)
+    # assert_equal(2, ser.length) # ruby logger has no service
+    assert(/^http:.*:11311/ =~ proxy.get_uri)
+  end
+
+  def test_accessor
+    proxy = ROS::MasterProxy.new('/test_node', ENV['ROS_MASTER_URI'], 'http://dummy:11111')
+    assert_equal(ENV['ROS_MASTER_URI'], proxy.master_uri)
+    assert_equal('http://dummy:11111', proxy.slave_uri)
+    proxy.slave_uri = 'http://dummy2:12345'
+    assert_equal('http://dummy2:12345', proxy.slave_uri)
+    proxy.master_uri = 'http://fail'
+    assert_equal('/test_node', proxy.caller_id)
+    proxy.caller_id = '/changed'
+    assert_equal('/changed', proxy.caller_id)
+    assert_raise(SocketError) {proxy.get_uri}
+  end
+end

data/test/test_message.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require 'ros/message'
+require 'test/unit'
+
+class TestMessage < Test::Unit::TestCase
+  def test_message
+    s = ROS::Struct.new('V')
+    packed = s.pack(4)
+    assert_equal("\004\000\000\000", packed)
+    assert_equal(4, s.unpack(packed)[0])
+  end
+end

data/test/test_node.rb

@@ -0,0 +1,166 @@
+#!/usr/bin/env ruby
+
+require 'ros'
+require 'test/unit'
+
+class TestNode < Test::Unit::TestCase
+  def test_up_down
+    node1 = ROS::Node.new('/test_up_down')
+    assert_equal('/test_up_down', node1.node_name)
+    assert(node1.ok?)
+    node1.shutdown
+    assert(!node1.ok?)
+    node2 = ROS::Node.new('/test2')
+    assert(node2.ok?)
+    node2.shutdown
+    assert(!node2.ok?)
+  end
+
+  def test_multi_up_down
+    node1 = ROS::Node.new('/test_multi_1')
+    node2 = ROS::Node.new('/test_multi_2')
+    assert(node1.ok?)
+    assert(node2.ok?)
+    node1.shutdown
+    node2.shutdown
+    assert(!node1.ok?)
+    assert(!node2.ok?)
+  end
+
+  def test_anonymous
+    node1 = ROS::Node.new('/test_anonymous1', :anonymous=>true)
+    assert_not_equal('/test_anonymous1', node1.node_name)
+    node2 = ROS::Node.new('/test_anonymous1', :anonymous=>true)
+    assert_not_equal('/test_anonymous1', node2.node_name)
+    sleep(0.5)
+    assert(node1.ok?)
+    assert(node2.ok?)
+    node1.shutdown
+    node2.shutdown
+    assert(!node1.ok?)
+    assert(!node2.ok?)
+  end
+
+  def test_not_anonymous
+    node1 = ROS::Node.new('/test_not_anonymous1')
+    node2 = ROS::Node.new('/test_not_anonymous1')
+    sleep(0.5)
+    assert(!node1.ok?) # killed by master
+    assert(node2.ok?)
+    node1.shutdown
+    node2.shutdown
+    assert(!node2.ok?)
+  end
+
+  def test_signal
+    node1 = ROS::Node.new('/test_signal1')
+    Process.kill("INT", Process.pid)
+    sleep(0.5)
+    assert(!node1.ok?)
+  end
+
+  def test_master_uri
+    node1 = ROS::Node.new('/test_master_uri1')
+    assert_equal(node1.master_uri, ENV['ROS_MASTER_URI'])
+
+    node1.shutdown
+  end
+
+  def test_ros_env
+    # check ROS_IP
+    ENV['ROS_IP']='127.0.0.1'
+    node1 = ROS::Node.new('/test_ros_env')
+    assert_equal('127.0.0.1', node1.host)
+    node1.shutdown
+    ENV.delete('ROS_IP')
+
+    # check ROS_HOSTNAME
+    ENV['ROS_HOSTNAME']='localhost'
+    node2 = ROS::Node.new('/test_ros_env2')
+    assert_equal('localhost', node2.host)
+    node2.shutdown
+
+    ENV['ROS_HOSTNAME']='127.0.0.1'
+    node2 = ROS::Node.new('/test_ros_env2')
+    assert_equal('127.0.0.1', node2.host)
+    node2.shutdown
+    ENV.delete('ROS_HOSTNAME')
+  end
+
+  def test_param_set_get
+    node = ROS::Node.new('hoge')
+    # integer
+    assert(node.set_param('/test1', 1))
+    assert_equal(1, node.get_param('/test1'))
+    # float
+    assert(node.set_param('/test_f', 0.1))
+    assert_equal(0.1, node.get_param('/test_f'))
+    assert(node.delete_param('/test_f'))
+    # list
+    assert(node.set_param('/test2', [1,2,3]))
+    assert_equal([1,2,3], node.get_param('/test2'))
+    # string
+    assert(node.set_param('/test_s', 'hoge'))
+    assert_equal('hoge', node.get_param('/test_s'))
+
+    # default param
+    assert_equal('hoge', node.get_param('/test_xxxx', 'hoge'))
+
+    # delete not exist
+    assert(!node.delete_param('/xxxxx'))
+
+    assert(node.has_param('/test_s'))
+    assert(node.delete_param('/test_s'))
+    assert(!node.has_param('/test_s'))
+
+    # clean
+    assert(node.delete_param('/test1'))
+    assert(node.delete_param('/test2'))
+
+    node.shutdown
+  end
+
+  def test_param_private
+    node = ROS::Node.new('/hoge')
+    node.set_param('/hoge/param1', 100)
+    assert_equal(100, node.get_param('~param1'))
+
+    node.set_param('~param2', 10)
+    assert_equal(10, node.get_param('/hoge/param2'))
+    assert(node.delete_param('~param2'))
+    node.shutdown
+  end
+
+  def test_fail
+    node = ROS::Node.new('hoge')
+    assert(!node.get_param('/test_no_exists'))
+    node.shutdown
+  end
+
+  def test_resolve_name
+    node = ROS::Node.new('hoge')
+
+    assert_equal('/aaa', node.resolve_name('aaa'))
+    assert_equal('/aaa/b/c', node.resolve_name('aaa/b////c'))
+    assert_equal('/hoge/private', node.resolve_name('~private'))
+    node.shutdown
+  end
+
+  def test_param_subscribe
+    node = ROS::Node.new('/test_param_sub')
+    called = false
+    subscriber = node.subscribe_parameter('/test_param1') do |param|
+      called = param
+    end
+    node.set_param('/test_param1', 1)
+    sleep(0.5)
+    assert_equal(1, called)
+    subscriber.shutdown
+    node.set_param('/test_param1', 2)
+    sleep(0.5)
+    assert_equal(1, called)
+    assert(node.delete_param('/test_param1'))
+
+    node.shutdown
+  end
+end