maca-rosc 0.0.1

data/lib/osc/pattern.rb

@@ -0,0 +1,131 @@
+require 'set'
+module OSC
+  class Pattern < String
+    # Create an OSC pattern from a string or (experimental) from a Regex.
+    def initialize(s)
+      case s
+      when Regexp # This is experimental
+	      s = Regexp.source s
+      	s.gsub! /(\\\\)*\[^\/\]\*/, "\1*"
+      	s.gsub! /(\\\\)*\[^\/\]/, "\1?"
+      	s.gsub! /(\\\\)*\[^/, "\1[!"
+      	s.gsub! /(\\\\)*\(/, "\1{"
+      	s.gsub! /(\\\\)*\|/, "\1,"
+      	s.gsub! /(\\\\)*\)/, "\1}"
+      	s.gsub! /\\\\/, "\\"
+      end
+      super s
+    end
+
+    # Return a Regex representing this pattern
+    def regexp
+      s = Regexp.escape self
+      s.gsub! /\\\?/, '[^/]'
+      s.gsub! /\\\*/, '[^/]*'
+      s.gsub! /\\\[!/, '[^'
+      s.gsub! /\\\]/, ']'
+      s.gsub! /\\\{/, '('
+      s.gsub! /,/, '|'
+      s.gsub! /\\\}/, ')'
+      Regexp.new s
+    end
+
+    # Do these two patterns intersect?
+    #-- 
+    # This might be improved by following the (much simpler, but related)
+    # algorithm here:
+    #
+    # http://groups.google.com/group/comp.theory/browse_frm/thread/f33e033269bd5ab0/c87e19081f45454c?lnk=st&q=regular+expression+intersection&rnum=1&hl=en#c87e19081f45454c
+    #
+    # That is, convert each regexp into an NFA, then generate the set of valid
+    # state pairs, then check if the pair of final states is included.
+    # That's basically what I'm doing here, but I'm not generating all the
+    # state pairs, I'm just doing a search. My way may be faster and/or
+    # smaller, or it may not.  My initial feeling is that it is faster since
+    # we're basically doing a depth-first search and OSC patterns are going to
+    # tend to be fairly simple. Still it might be a fun experiment for the
+    # masochistic.
+    def self.intersect?(s1,s2)
+      r = /\*|\?|\[[^\]]*\]|\{[^\}]*\}|./
+      a = s1.to_s.scan r
+      b = s2.to_s.scan r
+      q = [[a,b]]
+      until q.empty?
+	q.uniq!
+	a,b = q.pop
+	a = a.dup
+	b = b.dup
+
+	return true if a.empty? and b.empty?
+	next if a.empty? or b.empty?
+
+	x,y = a.shift, b.shift
+
+	# branch {}
+	if x =~ /^\{/
+	  x.scan /[^\{\},]+/ do |x|
+	    q.push [x.scan(/./)+a,[y]+b]
+	  end
+	  next
+	end
+	if y =~ /^\{/
+	  y.scan /[^\{\},]+/ do |y|
+	    q.push [[x]+a,y.scan(/./)+b]
+	  end
+	  next
+	end
+
+	# sort
+	if y =~ /^\[/
+	  x,y = y,x
+	  a,b = b,a
+	end
+	if y =~ /^(\*|\?)/
+	  x,y = y,x
+	  a,b = b,a
+	end
+
+	# match
+	case x
+	when '*'
+	  unless y == '/'
+	    q.push [a,b]
+	    q.push [[x]+a,b]
+	  end
+	  if y == '*'
+	    q.push [a,[y]+b]
+	    q.push [[x]+a,b]
+	  end
+	when '?'
+	  q.push [a,b] unless y == '/'
+	  q.push [a,[y]+b] if y == '*'
+	when /^\[/
+	  xinv = (x[1] == ?!)
+	  yinv = (y =~ /^\[!/)
+	  x = x[(xinv ? 2 : 1)..-2].scan(/./).to_set
+	  if y =~ /^\[/
+	    y = y[(yinv ? 2 : 1)..-2].scan(/./).to_set
+	  else
+	    y = [y].to_set
+	  end
+
+	  # simplifying assumption: nobody in their right mind is going to do
+	  # [^everyprintablecharacter]
+	  if xinv and yinv
+	    q.push [a,b]
+	  elsif xinv and not yinv
+	    q.push [a,b] unless (y-x).empty?
+	  elsif not xinv and yinv
+	    q.push [a,b] unless (x-y).empty?
+	  else
+	    q.push [a,b] unless (x&y).empty?
+	  end
+	else
+	  q.push [a,b] if x == y
+	end
+      end
+
+      false # no intersection
+    end
+  end
+end

data/lib/osc/server.rb

@@ -0,0 +1,94 @@
+module OSC
+  # Mixin for making servers.
+  # Your job is to read a packet and call dispatch(Packet.decode(raw)), ad
+  # infinitum (e.g. in a method named serve).
+  module Server
+    # 	prock.respond_to?(:call) #=> true
+    # Pass an OSC pattern, a typespec, and either prock or a block.
+    # The block/prock will be called if the pattern and typspec match. Numeric
+    # types will be coerced, so e.g. 'fi' would match 'ii' and the float would
+    # be coerced to an int.
+    def add_method(pat, typespec, prock=nil, &block)
+      pat = Pattern.new(pat) unless Pattern === pat
+      if block_given? and prock
+	raise ArgumentError, 'Specify either a block or a Proc, not both.'
+      end
+      prock = block if block_given?
+      unless prock.respond_to?(:call)
+	raise ArgumentError, "Prock doesn't respond to :call"
+      end
+      unless typespec.nil? or typespec =~ /[ifsb]*/
+        raise ArgumentError, "Bad typespec '#{typespec}'"
+      end
+      @cb ||= []
+      @cb << [pat, typespec, prock]
+    end
+
+    # dispatch the provided message. It can be raw or already decoded with
+    # Packet.decode
+    def dispatch(mesg)
+      case mesg
+      when Bundle, Message
+      else
+        mesg = Packet.decode(mesg)
+      end
+
+      case mesg
+      when Bundle; dispatch_bundle(mesg)
+      when Message
+        unless @cb.nil?
+          @cb.each do |pat, typespec, obj|
+            if pat.nil? or Pattern.intersect?(pat, mesg.address)
+              if typespec
+                if typespec.size == mesg.args.size
+                  match = true
+                  typespec.size.times do |i|
+                    c = typespec[i]
+                    case c
+                    when ?i, ?f
+                      match &&= (Numeric === mesg.args[i])
+                    when ?s, ?b
+                      match &&= (String === mesg.args[i])
+                    end
+                  end
+                  if match
+                    typespec.size.times do |i|
+                      case typespec[i]
+                      when ?i
+                        mesg.args[i] = mesg.args[i].to_i
+                      when ?f
+                        mesg.args[i] = mesg.args[i].to_f
+                      when ?s,?b
+                        mesg.args[i] = mesg.args[i].to_s
+                        mesg.args[i] = mesg.args[i].to_s
+                      end
+                    end
+
+                    obj.call(mesg)
+                  end
+                end
+              else # no typespec
+                obj.call(mesg)
+              end
+            end # pattern match
+          end # @cb.each
+        end # unless @cb.nil?
+        else
+          raise "bad mesg"
+        end
+      end
+
+    # May create a new thread to wait to dispatch according to p.timetag.
+    def dispatch_bundle(p)
+      diff = p.timetag.to_f - TimeTag.now.to_f
+      if diff <= 0
+	p.each {|m| m.source = p.source; dispatch m}
+      else
+	Thread.new do
+	  sleep diff
+	  p.each {|m| m.source = p.source; dispatch m}
+	end
+      end
+    end
+  end
+end

data/lib/osc/transport.rb

@@ -0,0 +1,42 @@
+module OSC
+  # Mixin for OSC transports. You implement (or in many cases just alias)
+  # send_raw, recvfrom_raw, and recv_raw, which have the semantics of send,
+  # recvfrom, and recv in e.g. UDPSocket
+  module Transport
+    # Send a Message, Bundle, or even raw data
+    def send(msg, *args)
+      case msg
+      when Message,Bundle
+        send_raw(msg.encode, *args)
+      else
+        send_raw(msg, *args)
+      end
+    end
+
+    # Receive a Message, Bundle, or raw data and the sender. The source
+    # attribute of the Message or Bundle is also set to sender. e.g.
+    #   packet, sender = udp_osc_client.recvfrom(32768)
+    def recvfrom(*args)
+      data, sender = recvfrom_raw(*args)
+      m = Packet.decode(data)
+      m.source = sender
+      [m, sender]
+    rescue
+      [data, sender]
+    end
+
+    # Receive a Message, Bundle, or raw data.
+    def recv(*args)
+      data = recv_raw(*args)
+      Packet.decode(data)
+    rescue
+    end
+
+    # Send a Message/Bundle with a timestamp (a Time or TimeTag object).
+    def send_timestamped(msg, ts, *args)
+      m = Bundle.new(ts, msg)
+      send(m, *args)
+    end
+    alias :send_ts :send_timestamped
+  end
+end

data/lib/osc/udp.rb

@@ -0,0 +1,30 @@
+require 'osc/transport'
+require 'socket'
+
+module OSC
+  # A ::UDPSocket with a send method that accepts a Message or Bundle or
+  # a raw String.
+  class UDPSocket < ::UDPSocket
+    alias :send_raw :send
+    alias :recvfrom_raw :recvfrom
+    alias :recv_raw :recv
+    include Transport
+  end
+
+  class UDPServer < OSC::UDPSocket
+    MAX_MSG_SIZE=32768
+    include Server
+    def serve
+      loop do
+        p, sender = recvfrom(MAX_MSG_SIZE)
+        dispatch p
+      end
+    end
+
+    # send msg2 as a reply to msg1
+    def reply(msg1, msg2)
+      domain, port, host, ip = msg2.source
+      send(msg2, 0, host, port)
+    end
+  end
+end

data/lib/rosc.rb

@@ -0,0 +1,8 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'osc'
+
+module Rosc
+  VERSION = '0.0.1'
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/rosc.rb'}"
+puts "Loading rosc gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/test_osc.rb

@@ -0,0 +1,160 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+require 'osc'
+require 'time'
+require 'test/unit'
+
+class TC_OSC < Test::Unit::TestCase
+  include OSC
+  # def setup
+  # end
+
+  # def teardown
+  # end
+
+  def test_datatype
+    s = 'foo'
+    i = 42
+    f = 3.14
+
+    assert_equal 'i', Packet.tag(i)
+    assert_equal 'f', Packet.tag(f)
+    assert_equal 's', Packet.tag(s)
+    assert_equal s+"\000", Packet.encode(s)
+    b = Blob.new("foobardoobar\0\0x200")
+    assert_equal 'b', Packet.tag(b)
+    assert_equal b.size+4 + (b.size+4)%4, Packet.encode(b).size
+  end
+
+  def test_timetag
+    t1 = TimeTag::JAN_1970
+    t2 = Time.now
+    t3 = t2.to_f+t1
+
+    tt = TimeTag.new t2
+    assert_equal t3, tt.to_f
+    assert_equal t3.floor, tt.to_i
+    assert_equal t3.floor - t3, tt.to_i - tt.to_f
+    assert_equal [0,1].pack('NN'), Packet.encode(TimeTag.new(nil))
+    assert_equal t2.to_i,tt.to_time.to_i # to_f has roundoff error at the lsb
+  end
+
+  def test_message
+    a = 'foo'
+    b = 'quux'
+    m = Message.new '/foobar', 'ssi', a, b, 1
+    assert_equal "/foobar\000"+",ssi\000\000\000\000"+
+      "foo\000"+"quux\000\000\000\000"+"\000\000\000\001", Packet.encode(m)
+  end
+
+  def test_bundle
+    m1 = Message.new '/foo','s','foo'
+    m2 = Message.new '/bar','s','bar'
+    t = Time.now
+    b = Bundle.new(TimeTag.new(Time.at(t + 10)), m1, m2)
+    b2 = Bundle.new(nil, b, m1)
+
+    assert_equal 10, b.timetag.to_time.to_i - t.to_i
+    e = Packet.encode(b2)
+    assert_equal '#bundle', e[0,7]
+    assert_equal "\000\000\000\000\000\000\000\001", e[8,8]
+    assert_equal '#bundle', e[16+4,7]
+    assert_equal '/foo', e[16+4+Packet.encode(b).size+4,4]
+    assert_equal 0, e.size % 4
+
+    assert_instance_of Array, b2.to_a
+    assert_instance_of Bundle, b2.to_a[0]
+    assert_instance_of Message, b2.to_a[1]
+
+    bundle = Packet.decode(e)
+    assert_instance_of Bundle, bundle
+    
+
+  end
+
+
+
+  def test_packet
+    m = Message.new '/foo','s','foo'
+    b = Bundle.new nil,m
+
+    m2 = Packet.decode("/foo\000\000\000\000,s\000\000foo\000")
+    assert_equal m.address,m2.address
+    m2 = Packet.decode(Packet.encode(m))
+    assert_equal m.address,m2.address
+    assert_equal m.typetag,m2.typetag
+    assert_equal m.args.size,m2.args.size
+    b2 = Packet.decode(Packet.encode(b))
+    assert_equal b.args.size,b2.args.size
+  end
+
+  class TestServer
+    include OSC::Transport
+    include OSC::Server
+    def test_request(p)
+      send p
+    end
+    
+    def send_raw(msg, *args)
+      dispatch msg
+    end
+    
+  end
+
+  def test_server
+    s = TestServer.new
+    s.add_method('/foo/bar',nil) { |msg| 
+      assert_equal 'si',msg.typetag
+      assert_equal 'Hello, World!',msg[0]
+      assert_equal 42,msg[1]
+    }    
+    s.test_request Message.new("/foo/bar",'si','Hello, World!',42)
+  end
+
+  def test_server_with_bundle
+    s = TestServer.new
+    s.add_method('/foo/bar',nil) { |msg| 
+      assert_equal 'si',msg.typetag
+      assert_equal 'Hello, World!',msg[0]
+      assert_equal 42,msg[1]
+    }    
+    s.test_request Bundle.new(nil, Message.new("/foo/bar",'si','Hello, World!',42), Message.new("/foo/bar",'si','Hello, World!',42), Message.new("/foo/bar",'si','Hello, World!',42))
+  end
+
+  def test_pattern
+    # test *
+    assert Pattern.intersect?('/*/bar/baz','/foo/*/baz')
+    assert Pattern.intersect?('/f*','/*o')
+    assert ! Pattern.intersect?('/f*','/foo/bar')
+    assert ! Pattern.intersect?('/f*','/bar')
+    # test ?
+    assert Pattern.intersect?('/fo?/bar','/foo/?ar')
+    assert ! Pattern.intersect?('/foo?','/foo')
+    # test []
+    assert Pattern.intersect?('/foo/ba[rz]','/foo/bar')
+    assert Pattern.intersect?('/[!abcde]/a','/[!abcde]/a')
+    assert Pattern.intersect?('/[!abcde]/a','/f/a')
+    assert Pattern.intersect?('/[!abcde]/a','/[abf]/a')
+    assert ! Pattern.intersect?('/[ab]/a','/[!abc]/a')
+    assert ! Pattern.intersect?('/[abcde]','/[!abcde]')
+    assert ! Pattern.intersect?('/[abcde]','/f')
+    assert ! Pattern.intersect?('/[!abcde]','/a')
+    # test {}
+    assert Pattern.intersect?('/{foo,bar,baz}','/foo')
+    assert Pattern.intersect?('/{foo,bar,baz}','/bar')
+    assert Pattern.intersect?('/{foo,bar,baz}','/baz')
+    assert ! Pattern.intersect?('/{foo,bar,baz}','/quux')
+    assert ! Pattern.intersect?('/{foo,bar,baz}','/fo')
+    # * with *,?,[]
+    assert Pattern.intersect?('/*/bar','/*/ba?')
+    assert Pattern.intersect?('/*/bar','/*x/ba?')
+    assert Pattern.intersect?('/*/bar','/?/ba?')
+    assert Pattern.intersect?('/*/bar','/?x/ba?')
+    assert Pattern.intersect?('/*/bar','/[abcde]/ba?')
+    assert Pattern.intersect?('/*/bar','/[abcde]x/ba?')
+    assert Pattern.intersect?('/*/bar','/[!abcde]/ba?')
+    assert Pattern.intersect?('/*/bar','/[!abcde]x/ba?')
+    # ? with []
+    assert Pattern.intersect?('/?','/[abcde]')
+    assert Pattern.intersect?('/?','/[!abcde]')
+  end
+end