aberant-osc-ruby 0.1.5 → 0.1.6

data/README.rdoc

@@ -0,0 +1,17 @@
+= An OSC client for Ruby
+
+http://opensoundcontrol.org/
+
+== GOAL
+
+I've used the OSC gem originally created by Tadayoshi Funaba and wanted to update it for ruby 1.9 compatibility.  I'm also writing rspec tests for this library to allow others to more easily understand/update the code.  It's getting closer to awesome every day...
+
+Guaranteed to be compatible with tuio-ruby
+
+== CREDITS
+
+Originally created by...
+Tadayoshi Funaba
+http://www.funaba.org/en/
+
+thx also to Toby Tripp and Obtiva

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:minor: 1
-:patch: 5
 :major: 0
+:minor: 1
+:patch: 6

data/lib/osc-ruby.rb

@@ -4,13 +4,27 @@
 require 'forwardable'
 require 'socket'
 require 'thread'
+require 'monitor'
 
+
+$:.unshift( File.dirname( __FILE__ ) )
+
+# core extensions
+require 'osc-ruby/core_ext/object'
+require 'osc-ruby/core_ext/numeric'
+require 'osc-ruby/core_ext/time'
+
+
+# jus the basics
 require 'osc-ruby/osc_types'
 require 'osc-ruby/packet'
+require 'osc-ruby/osc_packet'
 require 'osc-ruby/message'
 require 'osc-ruby/bundle'
+require 'osc-ruby/address_pattern'
 
-require 'osc-ruby/simple_server'
-require 'osc-ruby/simple_client'
+# now we gettin fancy
+require 'osc-ruby/server'
+require 'osc-ruby/client'
 
 

data/lib/osc-ruby/address_pattern.rb

@@ -0,0 +1,51 @@
+module OSC
+  class AddressPattern
+    def initialize( pattern )
+      @pattern = pattern
+      
+      generate_regex_from_pattern
+    end
+    
+    def match?( address )
+      !!(@re.nil? || @re.match( address ))
+    end
+    
+private 
+    def generate_regex_from_pattern
+      case @pattern
+        when NIL; @re = @pattern
+        when Regexp; @re = @pattern
+        when String
+          
+          # i'm unsure what this does
+          # @pattern.gsub!(/[.^(|)]/, '\\1')
+          
+          # handles osc single char wildcard matching
+          @pattern.gsub!(/\?/, '[^/]')
+          
+          # handles osc * - 0 or more matching
+          @pattern.gsub!(/\*/, '[^/]*')
+          
+          # handles [!] matching
+          @pattern.gsub!(/\[!/, '[^')
+            
+          # handles {} matching
+          @pattern.gsub!(/\{/, '(')
+          @pattern.gsub!(/,/, '|')
+          @pattern.gsub!(/\}/, ')')
+          
+          
+          # keeps from matching before the begining of the pattern
+          @pattern.gsub!(/\A/, '\A')
+          
+          # keeps from matching beyond the end, 
+          # eg. pattern /hi does not match /hidden
+          @pattern.gsub!(/\z/, '\z')
+
+          @re = Regexp.new(@pattern)
+        else
+          raise ArgumentError, 'invalid pattern'
+      end
+    end
+  end
+end

data/lib/osc-ruby/bundle.rb

@@ -7,11 +7,11 @@ module OSC
     
     undef_method :zip
     
-    de = (Array.instance_methods - self.instance_methods)
-    de -= %w(assoc flatten flatten! pack rassoc transpose)
-    de += %w(include? sort)
+    # de = (Array.instance_methods - self.instance_methods)
+    # de -= %w(assoc flatten flatten! pack rassoc transpose)
+    # de += %w(include? sort)
 
-    def_delegators(:@args, *de)
+    # def_delegators(:@args, *de)
 
     
     def initialize(timetag=nil, *args)

data/lib/osc-ruby/{simple_client.rb → client.rb}

@@ -1,5 +1,5 @@
 module OSC
-  class SimpleClient
+  class Client
 
     def initialize(host, port)
       @so = UDPSocket.new

data/lib/osc-ruby/core_ext/numeric.rb

@@ -0,0 +1,17 @@
+class Numeric 
+  # Convert time intervals to seconds 
+  def milliseconds; self/1000.0; end 
+  def seconds; self; end 
+  def minutes; self*60; end 
+  def hours; self*60*60; end 
+  def days; self*60*60*24; end 
+  def weeks; self*60*60*24*7; end 
+  
+  # Convert seconds to other intervals 
+  def to_milliseconds; self*1000; end 
+  def to_seconds; self; end 
+  def to_minutes; self/60.0; end 
+  def to_hours; self/(60*60.0); end 
+  def to_days; self/(60*60*24.0); end 
+  def to_weeks; self/(60*60*24*7.0); end 
+end 

data/lib/osc-ruby/core_ext/object.rb

@@ -0,0 +1,37 @@
+# lifted from the ruby programming language book, thx matz!
+
+# Obtain the Mutex associated with the object o, and then evaluate 
+# the block under the protection of that Mutex. 
+# This works like the synchronized keyword of Java. 
+def synchronized(o) 
+  o.mutex.synchronize { yield } 
+end 
+# Object.mutex does not actually exist. We've got to define it. 
+# This method returns a unique Mutex for every object, and 
+# always returns the same Mutex for any particular object. 
+# It creates Mutexes lazily, which requires synchronization for 
+# thread safety. 
+class Object 
+  # Return the Mutex for this object, creating it if necessary. 
+  # The tricky part is making sure that two threads don't call 
+  # this at the same time and end up creating two different mutexes. 
+  def mutex 
+    # If this object already has a mutex, just return it 
+    return @__mutex if @__mutex 
+        
+    # Otherwise, we've got to create a mutex for the object. 
+    # To do this safely we've got to synchronize on our class object. 
+    synchronized(self.class) { 
+      # Check again: by the time we enter this synchronized block, 
+      # some other thread might have already created the mutex. 
+      @__mutex = @__mutex || Mutex.new 
+    } 
+    # The return value is @__mutex 
+  end 
+end 
+# The Object.mutex method defined above needs to lock the class 
+# if the object doesn't have a Mutex yet. If the class doesn't have 
+# its own Mutex yet, then the class of the class (the Class object) 
+# will be locked. In order to prevent infinite recursion, we must 
+# ensure that the Class object has a mutex. 
+Class.instance_eval { @__mutex = Mutex.new } 

data/lib/osc-ruby/core_ext/time.rb

@@ -0,0 +1,6 @@
+class Time
+  
+  def to_ntp
+    self.to_f + 2208988800
+  end 
+end

data/lib/osc-ruby/message.rb

@@ -1,21 +1,30 @@
 module OSC
   class Message < Packet
     extend Forwardable
-    include Enumerable
+    # include Enumerable
 
     attr_accessor :address
-    undef_method :zip
-
-    de = (Array.instance_methods - self.instance_methods)
-    de -= %w(assoc flatten flatten! pack rassoc transpose)
-    de += %w(include? sort)
+    attr_accessor :time 
+    
+    # undef_method :zip
 
-    def_delegators(:@args, *de)
+    # de = (Array.instance_methods - self.instance_methods)
+    # de -= %w(assoc flatten flatten! pack rassoc transpose)
+    # de += %w(include? sort)
 
+    # def_delegators(:@args, *de)
+    
+    def self.new_with_time( address, time, tags=nil, *args )
+      message = new( address, tags, *args )
+      message.time = time
+      message
+    end
     
     def initialize(address, tags=nil, *args)
       @address = address
       @args = []
+      
+      
       args.each_with_index do |arg, i|
 	      if tags && tags[i]
 	        case tags[i]
@@ -38,14 +47,19 @@ module OSC
     end
 
 
-    def tags() ',' + @args.collect{|x| x.tag}.join end
+    def tags() @args.collect{|x| x.tag}.join end
 
     def encode
-      s = OSCString.new(@address).encode
-      s << OSCString.new(tags).encode
+      s = OSCString.new( @address ).encode
+      s << OSCString.new( ',' + tags ).encode
       s << @args.collect{|x| x.encode}.join
     end
 
     def to_a() @args.collect{|x| x.val} end
+      
+    def eql?( other )
+      @address == other.address &&
+      to_a == other.to_a
+    end
   end
 end

data/lib/osc-ruby/network_packet.rb

@@ -0,0 +1,42 @@
+module OSC
+  class NetworkPacket
+    def initialize(str) 
+      @str, @index = str, 0 
+    end
+    
+    def to_s
+      @str
+    end
+    
+    def rem() 
+      @str.length - @index 
+    end
+    
+    def eof? () 
+      rem <= 0 
+    end
+    
+    def skip(n) 
+      @index += n 
+    end
+    
+    def skip_padding() 
+      skip((4 - (@index % 4)) % 4) 
+    end
+ 
+    def getn(n)
+    	raise EOFError if rem < n
+    	s = @str[@index, n]
+    	skip(n)
+    	s
+    end
+
+    def getc
+    	raise EOFError if rem < 1
+    	c = @str[@index]
+    	skip(1)
+    	c
+    end
+    
+  end
+end

data/lib/osc-ruby/osc_argument.rb

@@ -9,11 +9,10 @@ module OSC
     def to_f() @val.to_f end
     def to_s() @val.to_s end
 
+
+  private
     def padding(s)
       s + ("\000" * ((4 - (s.size % 4)) % 4))
     end
-
-    private :padding
-
   end
 end

data/lib/osc-ruby/osc_packet.rb

@@ -0,0 +1,113 @@
+require File.join( File.dirname( __FILE__ ), 'network_packet')
+require 'ostruct'
+
+module OSC
+  class OSCPacket
+    def self.messages_from_network( string )
+      messages = []
+      osc = new( string )
+      
+      if osc.bundle?
+        bundle = osc.get_string
+        time = osc.get_timestamp
+        
+        osc.get_bundle_messages.each do | message |
+          messages << decode_simple_message( time, OSCPacket.new( message ) )
+        end
+        
+      else
+        messages << decode_simple_message( time, osc )
+      end
+      
+      return messages
+    end
+    
+    def self.decode_simple_message( time, osc_packet )
+      address = osc_packet.get_string
+      args = osc_packet.get_arguments 
+
+      Message.new_with_time(address, time, nil, *args )
+    end
+    
+    def initialize( string )
+      @packet = NetworkPacket.new( string )
+      
+      @types = { "i" => lambda{  OSCInt32.new(   get_int32 ) }, 
+                 "f" => lambda{  OSCFloat32.new( get_float32 ) },
+                 "s" => lambda{  OSCString.new(  get_string ) },
+                 "b" => lambda{  OSCBlob.new(    get_blob )}
+                }
+    end
+    
+    def get_bundle_messages
+      bundle_messages = []
+      
+      until @packet.eof?
+        l = @packet.getn(4).unpack('N')[0]
+        bundle_messages << @packet.getn(l)
+      end
+      bundle_messages
+    end
+    
+    def get_string
+      result = ''
+      until (c = @packet.getc) == 0
+	      result << c
+      end
+      
+      @packet.skip_padding
+      result
+    end
+    
+    def get_timestamp
+      t1 = @packet.getn(4).unpack('N')[0]
+      t2 = @packet.getn(4).unpack('N')[0]
+      @packet.skip_padding
+      
+      if t1 == 0 && t2 == 1
+        time = nil
+      else
+        time = t1 + t2.to_f / (2**32)
+      end
+      
+      time
+    end
+    
+    def get_arguments
+      if @packet.getc == ?,
+        
+        tags = get_string
+        args = []
+        
+        tags.scan(/./) do | tag |
+          args << @types[tag].call
+        end
+        args
+      end
+    end
+    
+    def get_int32
+      i = @packet.getn(4).unpack('N')[0]
+      i -= 2**32 if i > (2**31-1)
+      @packet.skip_padding
+      i
+    end
+    
+    def get_float32
+      f = @packet.getn(4).unpack('g')[0]
+      @packet.skip_padding
+      f
+    end
+    
+    def get_blob
+      l = @packet.getn(4).unpack('N')[0]
+      b = @packet.getn(l)
+      @packet.skip_padding
+      b
+    end
+    
+    def bundle?
+      !(@packet.to_s =~ /\A\#bundle/).nil?
+    end
+  end
+end

data/lib/osc-ruby/osc_types.rb

@@ -11,7 +11,7 @@ require 'osc-ruby/osc_argument'
   class OSCFloat32 < OSCArgument
 
     def tag() 'f' end
-    def encode() [@val].pack('g') end # fake
+    def encode() [@val].pack('g') end # fake - why fake?
 
   end
 

data/lib/osc-ruby/packet.rb

@@ -2,11 +2,25 @@ module OSC
   class Packet
 
     class PO
-      def initialize(str) @str, @index = str, 0 end
-      def rem() @str.length - @index end
-      def eof? () rem <= 0 end
-      def skip(n) @index += n end
-      def skip_padding() skip((4 - (@index % 4)) % 4) end
+      def initialize(str) 
+        @str, @index = str, 0 
+      end
+      
+      def rem() 
+        @str.length - @index 
+      end
+      
+      def eof? () 
+        rem <= 0 
+      end
+      
+      def skip(n) 
+        @index += n 
+      end
+      
+      def skip_padding() 
+        skip((4 - (@index % 4)) % 4) 
+      end
 
       def getn(n)
       	raise EOFError if rem < n

data/lib/osc-ruby/server.rb

@@ -0,0 +1,88 @@
+module OSC
+  class  Server
+
+    def initialize(port)
+      @socket = UDPSocket.new
+      @socket.bind('', port)
+      @cb = []
+      @queue = Queue.new
+    end
+    
+    def run
+      start_dispatcher
+      
+      start_detector
+    end
+    
+    def stop
+      @socket.close
+    end
+
+    def add_method(address_pattern, &proc)
+      matcher = AddressPattern.new( address_pattern )
+      
+      @cb << [matcher, proc]
+    end
+
+private
+
+    def start_detector
+      begin
+	      detector
+      rescue
+	      Thread.main.raise $!
+      end
+    end
+  
+    def start_dispatcher
+      Thread.fork do
+	      begin
+	        dispatcher
+	      rescue
+	        Thread.main.raise $!
+	      end
+      end
+    end
+
+    def sendmesg(mesg)
+      @cb.each do |matcher, obj|
+	      if matcher.match?( mesg.address )
+	        obj.call( mesg )
+	      end
+      end
+    end
+
+    def dispatcher
+      loop do
+	      mesg = @queue.pop
+	      
+        dispatch_message( mesg )
+      end
+    end
+
+    def detector
+      loop do
+	      pa = @socket.recv(16384)
+	      begin
+	        OSCPacket.messages_from_network(pa).each{|x| @queue.push(x)}
+	      rescue EOFError
+	      end
+      end
+    end
+    
+    def dispatch_message( message )
+      diff = ( message.time || 0 ) - Time.now.to_ntp
+      
+      if diff <= 0
+        sendmesg( message)
+      else # spawn a thread to wait until it's time
+        Thread.fork do
+    	    sleep(diff)
+    	    sendmesg(mesg)
+    	    Thread.exit
+    	  end
+      end
+    end
+
+  end
+end

data/spec/builders/message_builder.rb

@@ -0,0 +1,51 @@
+class MessageBuilder
+  
+  def initialize
+    @address = ""
+    @tags = []
+    @values = []
+    @time = nil
+  end
+  
+  def with_address( addr )
+    @address = addr
+    self
+  end
+  
+  def with_float( float )
+    with_arg( "f", float )
+    self
+  end
+  
+  def with_int( int )
+    with_arg( "i", int )
+    self
+  end
+  
+  def with_string( string )
+    with_arg( "s", string )
+    self
+  end
+  
+  def with_blob( blob )
+    with_arg( "b", blob )
+    self
+  end
+  
+  def with_time( time )
+    @time = time
+  end
+  
+  def build
+    message = OSC::Message.new( @address , @tags.join, *@values)
+    message.time = @time
+    message
+  end
+  
+private
+
+  def with_arg( tag, value )
+    @tags << tag 
+    @values << value 
+  end
+end

data/spec/spec_helper.rb

@@ -3,8 +3,10 @@ require 'spec'
 require 'rr'
 
 $:.unshift( File.join( File.dirname( __FILE__), '..', 'lib' ) ) 
+$:.unshift( File.dirname( __FILE__ ) )
 
 require 'osc-ruby'
+require 'builders/message_builder'
 
 Spec::Runner.configure do |config|
     config.mock_with RR::Adapters::Rspec

data/spec/unit/address_pattern_spec.rb

@@ -0,0 +1,83 @@
+require File.join( File.dirname(__FILE__) , '..', 'spec_helper' )
+
+describe OSC::AddressPattern do
+  it "should match anything if the pattern is nil" do
+    ap = OSC::AddressPattern.new( nil )
+    
+    ap.match?( "/some/nonsense").should be_true
+    ap.match?( "/completely.different").should be_true
+  end
+  
+  it "should match based on a regex" do
+    ap = OSC::AddressPattern.new( /hi/ )
+    
+    ap.match?( '/hi' ).should be_true
+    ap.match?( '/hidden' ).should be_true
+    
+    ap.match?( '/bye' ).should be_false
+  end 
+  
+  it "should return a regex if the pattern is a string" do
+    ap = OSC::AddressPattern.new( "/hi" )
+    
+    ap.match?('/hi').should be_true
+    
+    ap.match?('   /hi').should be_false
+    ap.match?('/ahi').should be_false
+    ap.match?( '/hidden' ).should be_false
+    ap.match?( '/bye' ).should be_false
+  end
+  
+  it "should match with question mark" do
+    ap = OSC::AddressPattern.new( "/h?l" )
+    
+    ap.match?('/hal').should be_true
+    ap.match?('/hel').should be_true
+    ap.match?('/hil').should be_true
+    ap.match?('/hol').should be_true
+    ap.match?('/hul').should be_true
+    ap.match?('/hub').should be_false
+  end
+  
+  it "should match with *" do
+    ap = OSC::AddressPattern.new( "/believ*d" )
+    
+    ap.match?('/believd').should be_true
+    ap.match?('/believed').should be_true
+    ap.match?('/believeeed').should be_true
+    ap.match?('/believaeeeioud').should be_true
+    ap.match?('/believaeeeioud').should be_true
+  end
+  
+  it "should match with []" do
+    ap = OSC::AddressPattern.new( "/believ[aeiou]d" )
+    
+    ap.match?('/believad').should be_true
+    ap.match?('/believed').should be_true
+    ap.match?('/believid').should be_true
+    ap.match?('/believod').should be_true
+    ap.match?('/believud').should be_true
+    ap.match?('/believkd').should be_false
+  end
+  
+  it "should match with [!]" do
+    ap = OSC::AddressPattern.new( "/believ[!aeiou]d" )
+    
+    ap.match?('/believad').should be_false
+    ap.match?('/believed').should be_false
+    ap.match?('/believid').should be_false
+    ap.match?('/believod').should be_false
+    ap.match?('/believud').should be_false
+    ap.match?('/believkd').should be_true
+    ap.match?('/believzd').should be_true
+  end
+  
+  it "should match with {}" do
+    ap = OSC::AddressPattern.new( "/{hi,bye}" )
+    
+    ap.match?('/hi').should be_true
+    ap.match?('/bye').should be_true
+    ap.match?('/greetings').should be_false
+  end
+  
+end

data/spec/unit/message_bundle_spec.rb

@@ -0,0 +1,6 @@
+require File.join( File.dirname(__FILE__) , '..', 'spec_helper' )
+
+
+describe OSC::Bundle do
+  
+end

data/spec/unit/message_spec.rb

@@ -0,0 +1,34 @@
+# some test data for when i unit test this
+# @simple_packet = "/hi\000,\000\000\000"
+# @simple_with_integer_arg = "/hi\000,i\000\000\000\000\000*"
+# @simple_with_two_integer_args = "/hi\000,ii\000\000\000\000*\000\000\000!"
+# @simple_with_float_arg = "/hi\000,f\000\000B(\n="
+# @simple_with_two_float_args = "/hi\000,ff\000B(\n=B\004\n="
+# @simple_with_string_arg = "/hi\000,s\000\000greetings\000\000\000"
+# @simple_with_two_string_args = "/hi\000,ss\000greetings\000\000\000how are you?\000\000\000\000"
+# @simple_with_int_float_string = "/hi\000,ifs\000\000\000\000\000\000\000*B\004\n=greetings\000\000\000"
+
+require File.join( File.dirname(__FILE__) , '..', 'spec_helper' )
+
+
+describe OSC::Message do
+  before :each do
+    @builder = MessageBuilder.new
+    @builder.with_int( 42 ).
+             with_int( 33 )
+             
+    @message = @builder.build
+  end
+  
+  it "should have no arguments if you define none" do
+    m = OSC::Message.new( "/hi" )
+    m.to_a.should == []
+  end
+  
+  it "should have accept int arguments" do
+    m = OSC::Message.new( "/hi", "i", 42 )
+    m.to_a.should == [42]
+    m.tags.should == "i"
+  end
+  
+end

data/spec/unit/network_packet_spec.rb

@@ -0,0 +1,33 @@
+require File.join( File.dirname(__FILE__) , '..', 'spec_helper' )
+
+
+describe OSC::NetworkPacket do
+  before :each do
+    @empty = OSC::NetworkPacket.new( "" )
+    @simple = OSC::NetworkPacket.new( "abc" )
+  end
+  
+  it "should know if it's at the end of the stream" do
+    @empty.eof?.should be_true
+  end
+  
+  it "should know the remainder in the stream" do
+    @simple.rem.should == 3
+  end
+  
+  it "should be able to skip positions" do
+    @simple.skip( 1 )
+    @simple.rem.should == 2
+  end
+  
+  it "should be able to get a character from the stream" do
+    @simple.getc.should == ?a
+    @simple.getc.should == ?b
+    @simple.getc.should == ?c
+    @simple.eof?.should be_true
+  end
+  
+  it "should be able to get a number of characters from the stream" do
+    @simple.getn(3).should == "abc"
+  end
+end

data/spec/unit/osc_complex_packets_spec.rb

@@ -0,0 +1,39 @@
+require File.join( File.dirname(__FILE__) , '..', 'spec_helper' )
+
+
+describe OSC::OSCPacket do
+  before :each do
+    @complex_packet = "#bundle\000\316\034\315T\000\003\030\370\000\000\000$/tuio/2Dobj\000,ss\000source\000\000simulator\000\000\000\000\000\000\030/tuio/2Dobj\000,s\000\000alive\000\000\000\000\000\000\034/tuio/2Dobj\000,si\000fseq\000\000\000\000\377\377\377\377"
+    
+    @messages = OSC::OSCPacket.messages_from_network( @complex_packet ) 
+  end
+  
+  it "should have three messages" do
+    @messages.should have(3).items
+  end
+  
+  it "should have the propper address for the messages" do
+    3.times do |i|
+      @messages[i].address.should eql("/tuio/2Dobj")
+    end
+  end
+  
+  it "should have a first message with two strings" do
+    args = @messages[0].to_a
+    
+    args[0].should eql( "source" )
+    args[1].should eql( "simulator" )
+  end
+  
+  it "should have a second message with one string" do
+    args = @messages[1].to_a
+    args[0].should eql( "alive" )
+  end
+  
+  it "should have a third message with a string and an int" do
+    args = @messages[2].to_a
+    
+    args[0].should eql( "fseq" )
+    args[1].should eql(-1)
+  end
+end

data/spec/unit/osc_simple_packets_spec.rb

@@ -0,0 +1,108 @@
+require File.join( File.dirname(__FILE__) , '..', 'spec_helper' )
+
+
+describe OSC::OSCPacket do
+  before :each do
+    @address = "/hi"
+    @first_int = 42
+    @second_int = 33
+    
+    @first_float = 42.01
+    @second_float = 33.01
+    
+    @first_string = "greetings"
+    @second_string = "how are you?"
+    
+    @first_blob = "this is a fake blob"
+    @second_blob = "tis another fake blob"
+    
+    @builder = MessageBuilder.new
+    @builder.with_address( @address )
+  end
+  
+  it "should decode the address of a simple message from the network data" do
+    sent_msg = @builder.build
+    
+    msg = OSC::OSCPacket.messages_from_network( sent_msg.encode )
+    
+    msg.first.address.should == @address
+  end
+  
+  it "should decode the int arg of a simple message from the network data" do
+    sent_msg = @builder.with_int( @first_int ).build
+    
+    msg = OSC::OSCPacket.messages_from_network( sent_msg.encode )
+    
+    msg.first.to_a.should == [@first_int]
+  end
+  
+  it "should decode two int args" do
+    sent_msg = @builder.with_int( @first_int ).with_int( @second_int ).build
+    
+    msg = OSC::OSCPacket.messages_from_network( sent_msg.encode )
+    
+    msg.first.to_a.should == [@first_int, @second_int]
+  end
+  
+  it "shold decode address with float arg" do
+    sent_msg = @builder.with_float( @first_float ).build
+    
+    msg = OSC::OSCPacket.messages_from_network( sent_msg.encode )
+    
+    msg.first.to_a[0].should be_close( @first_float, 0.001 )
+  end
+  
+  
+  it "shold decode address with two float args" do
+    sent_msg = @builder.with_float( @first_float ).with_float( @second_float).build
+    
+    msg = OSC::OSCPacket.messages_from_network( sent_msg.encode )
+    
+    args = msg.first.to_a
+    args.first.should be_close( @first_float, 0.001 )
+    args[1].should be_close( @second_float, 0.0001 )
+  end
+  
+  it "should decode address with string arg" do
+    sent_msg = @builder.with_string( @first_string ).build
+  
+    msg = OSC::OSCPacket.messages_from_network( sent_msg.encode )
+    
+    msg.first.to_a.should == [@first_string]
+  end
+  
+  it "should decode address with multiple string args" do
+    sent_msg = @builder.with_string( @first_string ).with_string( @second_string).build
+    msg = OSC::OSCPacket.messages_from_network( sent_msg.encode )
+    
+    args = msg.first.to_a
+    args[0].should == @first_string
+    args[1].should == @second_string
+  end
+  
+  
+  it "should decode messages with three different types of args" do
+    sent_msg = @builder.with_int( @first_int ).
+                        with_float( @second_float ).
+                        with_string( @first_string ).
+                        build
+    
+    msg = OSC::OSCPacket.messages_from_network( sent_msg.encode )
+    
+    args = msg.first.to_a
+    
+    args[0].should eql( @first_int )
+    args[1].should be_close( @second_float, 0.0001 )
+    args[2].should eql( @first_string )
+  end
+  
+  it "should decode messages with blobs" do
+    sent_msg = @builder.with_blob( @first_blob ).build
+    
+    
+    msg = OSC::OSCPacket.messages_from_network( sent_msg.encode )
+    
+    args = msg.first.to_a
+    args.first.should eql( @first_blob )
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aberant-osc-ruby
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors: 
 - aberant
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-16 00:00:00 -07:00
+date: 2009-08-29 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -20,28 +20,41 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- README
+- README.rdoc
 files: 
+- README.rdoc
 - VERSION.yml
 - lib/osc-ruby
+- lib/osc-ruby/address_pattern.rb
 - lib/osc-ruby/bundle.rb
+- lib/osc-ruby/client.rb
+- lib/osc-ruby/core_ext
+- lib/osc-ruby/core_ext/numeric.rb
+- lib/osc-ruby/core_ext/object.rb
+- lib/osc-ruby/core_ext/time.rb
 - lib/osc-ruby/message.rb
+- lib/osc-ruby/network_packet.rb
 - lib/osc-ruby/osc_argument.rb
+- lib/osc-ruby/osc_packet.rb
 - lib/osc-ruby/osc_types.rb
 - lib/osc-ruby/packet.rb
-- lib/osc-ruby/simple_client.rb
-- lib/osc-ruby/simple_server.rb
+- lib/osc-ruby/server.rb
 - lib/osc-ruby.rb
-- spec/integration
-- spec/integration/send_receive_spec.rb
+- spec/builders
+- spec/builders/message_builder.rb
 - spec/spec_helper.rb
 - spec/unit
+- spec/unit/address_pattern_spec.rb
+- spec/unit/message_bundle_spec.rb
+- spec/unit/message_spec.rb
+- spec/unit/network_packet_spec.rb
 - spec/unit/osc_argument_spec.rb
+- spec/unit/osc_complex_packets_spec.rb
+- spec/unit/osc_simple_packets_spec.rb
 - spec/unit/osc_types_spec.rb
-- spec/unit/simple_client_spec.rb
-- README
 has_rdoc: true
 homepage: http://github.com/aberant/osc-ruby
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --inline-source
@@ -63,7 +76,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
 summary: inital gem

data/README

@@ -1,14 +0,0 @@
-An "OSC" module
-==============
-
-OSC is an "OpenSound Control" module for an object‐oriented
-scripting language Ruby.
-
-
-
-
-
-Originally created by...
-Tadayoshi Funaba
-mailto:tadf@funaba.org
-http://www.funaba.org/en/

data/lib/osc-ruby/simple_server.rb

@@ -1,93 +0,0 @@
-module OSC
-  class SimpleServer
-
-    def initialize(port)
-      @so = UDPSocket.new
-      @so.bind('', port)
-      @cb = []
-      @qu = Queue.new
-    end
-
-    def add_method(pat, obj=nil, &proc)
-      case pat
-        when NIL; re = pat
-        when Regexp; re = pat
-        when String
-	        pat = pat.dup
-	        pat.gsub!(/[.^(|)]/, '\\1')
-	        pat.gsub!(/\?/, '[^/]')
-	        pat.gsub!(/\*/, '[^/]*')
-	        pat.gsub!(/\[!/, '[^')
-	        pat.gsub!(/\{/, '(')
-	        pat.gsub!(/,/, '|')
-	        pat.gsub!(/\}/, ')')
-	        pat.gsub!(/\A/, '\A')
-	        pat.gsub!(/\z/, '\z')
-	        re = Regexp.new(pat)
-        else
-	        raise ArgumentError, 'invalid pattern'
-      end
-      
-      unless  ( obj && !proc) ||
-	            (!obj &&  proc)
-	      raise ArgumentError, 'wrong number of arguments'
-      end
-      @cb << [re, (obj || proc)]
-    end
-
-    def sendmesg(mesg)
-      @cb.each do |re, obj|
-	      if re.nil? || re =~ mesg.address
-	        obj.send(if Proc === obj then :call else :accept end, mesg)
-	      end
-      end
-    end
-
-    def dispatcher
-      loop do
-	      time, mesg = @qu.pop
-	      now = Time.now.to_f + 2208988800
-	      diff = if time.nil?
-	       then 0 else time - now end
-	       
-	      if diff <= 0
-	        sendmesg(mesg)
-	      else
-	        Thread.fork do
-	          sleep(diff)
-	          sendmesg(mesg)
-	          Thread.exit
-	        end
-	      end
-      end
-    end
-
-    def detector
-      loop do
-	      pa = @so.recv(16384)
-	      begin
-	        Packet.decode(pa).each{|x| @qu.push(x)}
-	      rescue EOFError
-	      end
-      end
-    end
-
-    private :sendmesg, :dispatcher, :detector
-
-    def run
-      Thread.fork do
-	      begin
-	        dispatcher
-	      rescue
-	        Thread.main.raise $!
-	      end
-      end
-      
-      begin
-	      detector
-      rescue
-	      Thread.main.raise $!
-      end
-    end
-  end
-end

data/spec/integration/send_receive_spec.rb

@@ -1,25 +0,0 @@
-# require File.join( File.dirname(__FILE__) , '..', 'spec_helper' )
-# TODO: figure out what thread magic i need to get this to work
-
-# describe "send and receive" do
-#   it "should be able to send and receive messages" do
-#     server = OSC::SimpleServer.new( 3333 )
-#     
-#     watcher = Object.new
-#     stub( watcher ).called 
-#     
-#     server.add_method( "/hi") do |m|
-#       watcher.called
-#     end
-#     
-#     Thread.new do
-#       server.run
-#     end
-# 
-#     
-#     client = OSC::SimpleClient.new( "localhost", 3333 )
-#     client.send( OSC::Message.new( "/hi" ) )
-#     
-#     watcher.should have_received.called
-#   end
-# end

data/spec/unit/simple_client_spec.rb

@@ -1,11 +0,0 @@
-require File.join( File.dirname(__FILE__) , '..', 'spec_helper' )
-
-describe OSC::SimpleClient do
-  it "should not blow up" do
-    udp = Object.new
-    stub( udp ).connect
-    stub( UDPSocket ).new.returns( udp )
-    
-    OSC::SimpleClient.new( "localhost", 3333 )
-  end
-end