osc-ruby 0.2.0

data/README.rdoc

@@ -0,0 +1,72 @@
+= An OSC client for Ruby
+
+http://opensoundcontrol.org/
+
+== Description
+
+This OSC gem originally created by Tadayoshi Funaba has been updated for ruby 1.9 compatibility.  I've made a point to make this code as expressive as possible and provide a test suite for confident hacking.  It also should be flexible enough to support most crazy ideas.
+
+Compatible with ruby 1.8, 1.9, and jruby
+
+== Install
+
+  sudo gem install aberant-osc-ruby
+  
+for the EMServer, you will need EventMachine
+
+  sudo gem install eventmachine
+
+== Event Machine example
+  
+  # compatible with ruby 1.8, 1.9, and jruby
+  require 'rubygems'
+  require 'osc-ruby'
+  require 'osc-ruby/em_server'
+  
+  @server = OSC::EMServer.new( 3333 )
+  @client = OSC::Client.new( 'localhost', 3333 )
+
+  @server.add_method '/greeting' do | message |
+    puts message.to_a
+  end
+
+  Thread.new do
+    @server.run
+  end
+
+  @client.send( OSC::Message.new( "/greeting" , "hullo!" ))
+
+  sleep( 3 )
+  
+== Classic example
+
+  # compatible with ruby 1.8
+  require 'rubygems'
+  require 'osc-ruby'
+
+
+  @server = OSC::Server.new( 3333 )
+  @client = OSC::Client.new( 'localhost', 3333 )
+
+  @server.add_method '/greeting' do | message |
+    puts message.inspect
+  end
+
+  Thread.new do
+    @server.run
+  end
+
+  @client.send( OSC::Message.new( "/greeting", "hullo!" ))
+
+  sleep( 3 )
+  
+  
+== Credits
+
+Originally created by...
+
+Tadayoshi Funaba
+
+http://www.funaba.org/en/
+
+thx also to Toby Tripp and Obtiva

data/Rakefile

@@ -0,0 +1,31 @@
+require 'spec/rake/spectask'
+
+
+task :default => :spec
+
+Spec::Rake::SpecTask.new do |t|
+  t.warning = false
+  t.rcov = false
+  t.spec_opts = ["--colour"]
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "osc-ruby"
+    gem.summary = %Q{inital gem}
+    gem.email = "qzzzq1@gmail.com"
+    gem.homepage = "http://github.com/aberant/osc-ruby"
+    gem.authors = ["aberant"]
+    gem.files = FileList['Rakefile', 'examples/**/*', 'lib/**/*'].to_a
+    gem.test_files = FileList['spec/**/*.rb']
+    gem.rubyforge_project = "osc-ruby"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "rdoc"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/examples/classic_server.rb

@@ -0,0 +1,18 @@
+# compatible with ruby 1.8
+require File.join( File.dirname( __FILE__ ), '..', 'lib', 'osc-ruby' )
+
+
+@server = OSC::Server.new( 3333 )
+@client = OSC::Client.new( 'localhost', 3333 )
+
+@server.add_method '/greeting' do | message |
+  puts message.to_a
+end
+
+Thread.new do
+  @server.run
+end
+
+@client.send( OSC::Message.new( "/greeting", "hullo!" ))
+
+sleep( 3 )

data/examples/event_machine_server.rb

@@ -0,0 +1,17 @@
+# compatible with ruby 1.8, 1.9, and jruby
+require File.join( File.dirname( __FILE__ ), '..', 'lib', 'osc-ruby', 'em_server' )
+
+@server = OSC::EMServer.new( 3333 )
+@client = OSC::Client.new( 'localhost', 3333 )
+
+@server.add_method '/greeting' do | message |
+  puts message.to_a
+end
+
+Thread.new do
+  @server.run
+end
+
+@client.send( OSC::Message.new( "/greeting" , "hullo!" ))
+
+sleep( 3 )

data/lib/osc-ruby.rb

@@ -0,0 +1,29 @@
+# osc.rb: Written by Tadayoshi Funaba 2005,2006
+# $Id: osc.rb,v 1.4 2006-11-10 21:54:37+09 tadf Exp $
+
+require 'forwardable'
+require 'socket'
+require 'thread'
+
+
+$:.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'
+
+# 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

@@ -0,0 +1,45 @@
+require File.join( File.dirname( __FILE__ ), "packet" )
+
+module OSC
+  class Bundle < Packet
+    attr_accessor :timetag
+    
+    def initialize(timetag=nil, *args)
+      @timetag = timetag
+      @args = args
+    end
+    
+    def encode()
+      s = OSCString.new('#bundle').encode
+      s << encode_timetag(@timetag)
+      s << @args.collect do |x|
+	      x2 = x.encode; [x2.size].pack('N') + x2
+	    end.join
+    end
+
+
+    def to_a() @args.collect{|x| x.to_a} end
+
+
+    
+    private
+
+    def encode_timetag(t)
+      case t
+        when NIL # immediately
+	        t1 = 0
+	        t2 = 1
+        when Numeric
+	        t1, fr = t.divmod(1)
+	        t2 = (fr * (2**32)).to_i
+        when Time
+	        t1, fr = (t.to_f + 2208988800).divmod(1)
+	        t2 = (fr * (2**32)).to_i
+        else
+	        raise ArgumentError, 'invalid time'
+      end
+      [t1, t2].pack('N2')
+    end
+
+  end
+end

data/lib/osc-ruby/client.rb

@@ -0,0 +1,14 @@
+module OSC
+  class Client
+
+    def initialize(host, port)
+      @so = UDPSocket.new
+      @so.connect(host, port)
+    end
+
+    def send(mesg)
+      @so.send(mesg.encode, 0)
+    end
+
+  end
+end

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/em_server.rb

@@ -0,0 +1,68 @@
+require 'rubygems'
+require 'eventmachine'
+require File.join( File.dirname( __FILE__), '..', 'osc-ruby')
+
+
+module OSC
+  Channel = EM::Channel.new
+  
+  class Connection < EventMachine::Connection 
+
+    def receive_data data    
+     Channel << OSC::OSCPacket.messages_from_network( data )
+    end
+  end
+
+
+  class EMServer
+  
+    def initialize( port = 3333 )
+      @port = port
+      setup_dispatcher
+      @tuples = []
+    end
+  
+    def run
+      EM::run { EM::open_datagram_socket "localhost",  @port, Connection }
+    end
+    
+    def add_method(address_pattern, &proc)
+      matcher = AddressPattern.new( address_pattern )
+    
+      @tuples << [matcher, proc]
+    end  
+    
+  private
+    def setup_dispatcher
+      Channel.subscribe do  |messages|
+        messages.each do |message|         
+          diff =  ( message.time || 0 ) - Time.now.to_ntp 
+
+          if diff <=  0 
+            sendmesg( message )
+          else  
+            EM.defer  do   
+              sleep(  diff  )  
+              sendmesg( message )
+            end  
+          end  
+        end  
+      end
+    end
+  
+    def sendmesg(mesg)
+      @tuples.each do |matcher, obj|
+        if matcher.match?( mesg.address )
+          obj.call( mesg )
+        end
+      end
+    end
+  
+  end
+end
+
+
+
+
+
+

data/lib/osc-ruby/message.rb

@@ -0,0 +1,45 @@
+require File.join( File.dirname( __FILE__ ), "packet" )
+
+module OSC
+  class Message < Packet
+    attr_accessor :address
+    attr_accessor :time 
+
+    
+    def self.new_with_time( address, time, tags=nil, *args )
+      message = new( address, tags, *args )
+      message.time = time
+      message
+    end
+    
+    def initialize(address, *args)
+      @address = address
+      @args = []
+      
+      args.each_with_index do |arg, i|
+        case arg
+          when Integer;     @args << OSCInt32.new(arg)
+          when Float;       @args << OSCFloat32.new(arg)
+          when String;      @args << OSCString.new(arg)
+          when OSCArgument; @args << arg
+        end
+      end
+    end
+
+
+    def tags() @args.collect{|x| x.tag}.join end
+
+    def 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