rosc 0.1.3

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'echoe'  
+Echoe.new('rosc')
+
+task :default => :rdoc
+Rake::RDocTask.new do |rd|
+  rd.rdoc_files.add ['README','AUTHORS','TODO','lib/**/*.rb']
+  #rd.template = ENV['HOME']+'/src/allison/allison.rb'
+  rd.rdoc_dir = 'doc'
+  rd.options = ['-x_darcs','-xtest']
+  rd.title = 'rosc'
+  rd.options += ['--line-numbers','--inline-source']
+end
+
+Rake::TestTask.new do |t|
+  #t.verbose = true
+end
+
+# vim: filetype=ruby

data/TODO

@@ -0,0 +1,3 @@
+- nonstandard types
+- TCP and UNIX sockets
+- OSC urls

data/examples/readme.rb

@@ -0,0 +1,19 @@
+require 'osc'
+Host = 'localhost'
+Port = 5000
+
+s = OSC::UDPServer.new
+s.bind Host, Port
+
+c = OSC::UDPSocket.new
+m = OSC::Message.new('/foo', 'fi', Math::PI, 42)
+c.send m, 0, Host, Port
+
+s.add_method '/f*', 'fi' do |msg|
+  domain, port, host, ip = msg.source
+  puts "#{msg.address} -> #{msg.args.inspect} from #{host}:#{port}"
+end
+Thread.new do
+  s.serve
+end
+sleep 5

data/lib/osc.rb

@@ -0,0 +1,324 @@
+require 'time'
+require 'forwardable'
+require 'stringio'
+require 'yaml'
+
+# Test for broken pack/unpack
+if [1].pack('n') == "\001\000"
+  class String
+    alias_method :broken_unpack, :unpack
+    def unpack(spec)
+      broken_unpack(spec.tr("nNvV","vVnN"))
+    end
+  end
+  class Array
+    alias_method :broken_pack, :pack
+    def pack(spec)
+      broken_pack(spec.tr("nNvV","vVnN"))
+    end
+  end
+end
+
+
+class StringIO
+  def skip(n)
+    self.seek(n, IO::SEEK_CUR)
+  end
+  def skip_padding 
+    self.skip((4-pos)%4)
+  end
+end
+
+# Of particular interest are OSC::Client, OSC::Server, OSC::Message and
+# OSC::Bundle.
+module OSC
+  # 64-bit big-endian fixed-point time tag
+  class TimeTag
+    JAN_1970 = 0x83aa7e80
+    # nil:: immediately
+    # Numeric:: seconds since January 1, 1900 00:00
+    # Numeric,Numeric:: int,frac parts of a TimeTag.
+    # Time:: convert from Time object
+    def initialize(*args)
+      t = args
+      t = t.first if t and t.size == 1
+      case t
+      when NIL # immediately
+	@int = 0
+	@frac = 1
+      when Numeric
+	@int, fr = t.divmod(1)
+	@frac = (fr * (2**32)).to_i
+      when Array
+	@int,@frac = t
+      when Time
+	@int, fr = (t.to_f+JAN_1970).divmod(1)
+	@frac = (fr * (2**32)).to_i
+      else
+	raise ArgumentError
+      end
+    end
+    attr_accessor :int, :frac
+    def to_i; to_f.to_i; end
+    # Ruby's Float can handle the 64 bits so we have the luxury of dealing with
+    # Float directly
+    def to_f; @int.to_f + @frac.to_f/(2**32); end
+    # [int,frac]
+    def to_a; [@int,@frac]; end
+    # Human-readable, like the output of Time#to_s
+    def to_s; to_time.to_s; end
+    # Ruby Time object
+    def to_time; Time.at(to_f-JAN_1970); end
+    alias :time :to_time
+    def self.now; TimeTag.new(Time.now); end
+    def method_missing(sym, *args)
+      time.__send__(sym, *args)
+    end
+    def to_yaml
+      to_a.to_yaml
+    end
+  end
+
+  class Blob < String
+  end
+
+  class Message
+    attr_accessor :address, :args
+    # The source of this message, usually something like ["AF_INET", 50475,
+    # 'localhost','127.0.0.1']
+    attr_accessor :source
+
+    # address:: The OSC address (a String)
+    # types:: The OSC type tags string
+    # args:: arguments. must match type tags in arity
+    #
+    # Example:
+    #   Message.new('/foo','ff', Math::PI, Math::E)
+    #
+    # Arguments will be coerced as indicated by the type tags. If types is nil,
+    # type tags will be inferred from arguments.
+    def initialize(address, types=nil, *args)
+      if types and types.size != args.size
+        raise ArgumentError, 'type/args arity mismatch'
+      end
+
+      @address = address
+      @args = []
+
+      if types
+        args.each_with_index do |arg, i|
+          case types[i]
+          when ?i; @args << arg.to_i
+          when ?f; @args << arg.to_f
+          when ?s; @args << arg.to_s
+          when ?b; @args << Blob.new(arg)
+          else
+            raise ArgumentError, "unknown type tag '#{@types[i].inspect}'"
+          end
+        end
+      else
+        args.each do |arg|
+          case arg
+          when Fixnum,Float,String,TimeTag,Blob
+            @args << arg
+          else
+            raise ArgumentError, "Object has unknown OSC type: '#{arg}'"
+          end
+        end
+      end
+    end
+
+    def types
+      @args.collect {|a| Packet.tag a}.join
+    end
+    alias :typetag :types
+
+    # Encode this message for transport
+    def encode
+      Packet.encode(self)
+    end
+    # string representation. *not* the raw representation, for that use
+    # encode.
+    def to_s
+      "#{address},#{types},#{args.collect{|a| a.to_s}.join(',')}"
+    end
+    def to_yaml
+      {'address'=>address, 'types'=>types, 'args'=>args}.to_yaml
+    end
+
+    extend Forwardable
+    include Enumerable
+
+    de = (Array.instance_methods - self.instance_methods)
+    de -= %w(assoc flatten flatten! pack rassoc transpose)
+    de += %w(include? sort)
+
+    def_delegators(:@args, *de)
+
+    undef_method :zip
+  end
+
+  # bundle of messages and/or bundles
+  class Bundle
+    attr_accessor :timetag 
+    attr_accessor :args
+    attr_accessor :source
+    alias :timestamp :timetag
+    alias :messages :args
+    alias :contents :args
+    alias :to_a :args
+
+    # New bundle with time and messages
+    def initialize(t=nil, *args)
+      @timetag = 
+	case t
+	when TimeTag
+	  t
+	else
+	  TimeTag.new(t)
+	end
+      @args = args
+    end
+
+    def to_yaml
+      {'timestamp'=>timetag, 'contents'=>contents}.to_yaml
+    end
+
+    extend Forwardable
+    include Enumerable
+
+    de = (Array.instance_methods - self.instance_methods)
+    de -= %w(assoc flatten flatten! pack rassoc transpose)
+    de += %w(include? sort)
+
+    def_delegators(:@args, *de)
+
+    undef_method :zip
+    
+    def encode
+      Packet.encode(self)
+    end
+    
+  end
+
+  # Unit of transmission.  Really needs revamping
+  module Packet
+    # XXX I might fold this and its siblings back into the decode case
+    # statement
+    def self.decode_int32(io)
+      i = io.read(4).unpack('N')[0]
+      i = 2**32 - i if i > (2**31-1) # two's complement
+      i
+    end
+
+    def self.decode_float32(io)
+      f = io.read(4).unpack('g')[0]
+      f
+    end
+
+    def self.decode_string(io)
+      s = io.gets("\0").chomp("\0")
+      io.skip_padding
+      s
+    end
+
+    def self.decode_blob(io)
+      l = io.read(4).unpack('N')[0]
+      b = io.read(l)
+      io.skip_padding
+      b
+    end
+
+    def self.decode_timetag(io)
+      t1 = io.read(4).unpack('N')[0]
+      t2 = io.read(4).unpack('N')[0]
+      TimeTag.new [t1,t2]
+    end
+
+    # Takes a string containing one packet
+    def self.decode(packet)
+      # XXX I think it would have been better to use a StringScanner. Maybe I
+      # will convert it someday...
+      io = StringIO.new(packet)
+      id = decode_string(io)
+      if id == '#bundle'
+        b = Bundle.new(decode_timetag(io))
+        until io.eof?
+          l = io.read(4).unpack('N')[0]
+          s = io.read(l)
+          b << decode(s)
+        end
+        b
+      elsif id =~ /^\//
+	m = Message.new(id)
+	if io.getc == ?,
+	  tags = decode_string(io)
+	  tags.scan(/./) do |t|
+	    case t
+	    when 'i'
+	      m << decode_int32(io)
+	    when 'f'
+	      m << decode_float32(io)
+	    when 's'
+	      m << decode_string(io)
+	    when 'b'
+	      m << decode_blob(io)
+
+	    # right now we skip over nonstandard datatypes, but we'll want to
+	    # add these datatypes too.
+	    when /[htd]/; io.read(8)
+	    when 'S'; decode_string(io)
+	    when /[crm]/; io.read(4)
+	    when /[TFNI\[\]]/;
+	    end
+	  end
+	end
+	m
+      end
+    end
+
+    def self.pad(s)
+      s + ("\000" * ((4 - s.size)%4))
+    end
+
+    def self.tag(o)
+      case o
+      when Fixnum;  'i'
+      when TimeTag; 't'
+      when Float;   'f'
+      when Blob;    'b'
+      when String;  's'
+      else;         nil
+      end
+    end
+
+    def self.encode(o)
+      case o
+      when Fixnum;  [o].pack 'N'
+      when Float;   [o].pack 'g'
+      when Blob;    pad([o.size].pack('N') + o)
+      when String;  pad(o.sub(/\000.*\Z/, '') + "\000")
+      when TimeTag; o.to_a.pack('NN')
+
+      when Message
+	s = encode(o.address)
+	s << encode(','+o.types)
+	s << o.args.collect{|x| encode(x)}.join
+
+      when Bundle
+	s = encode('#bundle')
+	s << encode(o.timetag)
+	s << o.args.collect { |x| 
+	  x2 = encode(x); [x2.size].pack('N') + x2 
+	}.join
+      end
+    end
+
+    private_class_method :decode_int32, :decode_float32, :decode_string,
+      :decode_blob, :decode_timetag
+  end
+end
+
+require 'osc/pattern'
+require 'osc/server'
+require 'osc/udp'

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