aberant-osc-ruby 0.1.5

data/README

@@ -0,0 +1,14 @@
+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/VERSION.yml

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

data/lib/osc-ruby.rb

@@ -0,0 +1,16 @@
+# 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'
+
+require 'osc-ruby/osc_types'
+require 'osc-ruby/packet'
+require 'osc-ruby/message'
+require 'osc-ruby/bundle'
+
+require 'osc-ruby/simple_server'
+require 'osc-ruby/simple_client'
+
+

data/lib/osc-ruby/bundle.rb

@@ -0,0 +1,55 @@
+module OSC
+  class Bundle < Packet
+    extend Forwardable
+    include Enumerable
+    
+    attr_accessor :timetag
+    
+    undef_method :zip
+    
+    de = (Array.instance_methods - self.instance_methods)
+    de -= %w(assoc flatten flatten! pack rassoc transpose)
+    de += %w(include? sort)
+
+    def_delegators(:@args, *de)
+
+    
+    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/message.rb

@@ -0,0 +1,51 @@
+module OSC
+  class Message < Packet
+    extend Forwardable
+    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)
+
+    def_delegators(:@args, *de)
+
+    
+    def initialize(address, tags=nil, *args)
+      @address = address
+      @args = []
+      args.each_with_index do |arg, i|
+	      if tags && tags[i]
+	        case tags[i]
+	          when ?i; @args << OSCInt32.new(arg)
+	          when ?f; @args << OSCFloat32.new(arg)
+	          when ?s; @args << OSCString.new(arg)
+	          when ?b; @args << OSCBlob.new(arg)
+	          when ?*; @args << arg
+	          else; raise ArgumentError, 'unknown type'
+	        end
+	      else
+	        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
+    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
+  end
+end

data/lib/osc-ruby/osc_argument.rb

@@ -0,0 +1,19 @@
+module OSC
+  class OSCArgument
+
+    def initialize(val) @val = val end
+
+    attr_accessor :val
+
+    def to_i() @val.to_i end
+    def to_f() @val.to_f end
+    def to_s() @val.to_s end
+
+    def padding(s)
+      s + ("\000" * ((4 - (s.size % 4)) % 4))
+    end
+
+    private :padding
+
+  end
+end

data/lib/osc-ruby/osc_types.rb

@@ -0,0 +1,31 @@
+require 'osc-ruby/osc_argument'
+
+ module OSC
+  class OSCInt32 < OSCArgument
+
+    def tag() 'i' end
+    def encode() [@val].pack('N') end
+
+  end
+
+  class OSCFloat32 < OSCArgument
+
+    def tag() 'f' end
+    def encode() [@val].pack('g') end # fake
+
+  end
+
+  class OSCString < OSCArgument
+
+    def tag() 's' end
+    def encode() padding(@val.sub(/\000.*\z/, '') + "\000") end
+
+  end
+
+  class OSCBlob < OSCArgument
+
+    def tag() 'b' end
+    def encode() padding([@val.size].pack('N') + @val) end
+
+  end
+end

data/lib/osc-ruby/packet.rb

@@ -0,0 +1,120 @@
+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 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
+
+    def self.decode_int32(io)
+      i = io.getn(4).unpack('N')[0]
+      i -= 2**32 if i > (2**31-1)
+      i
+    end
+
+    def self.decode_float32(io)
+      f = io.getn(4).unpack('g')[0]
+      f
+    end
+
+    def self.decode_string(io)
+      s = ''
+      until (c = io.getc) == 0
+	      s << c
+      end
+      io.skip_padding
+      s
+    end
+
+    def self.decode_blob(io)
+      l = io.getn(4).unpack('N')[0]
+      b = io.getn(l)
+      io.skip_padding
+      b
+    end
+
+    def self.decode_timetag(io)
+      t1 = io.getn(4).unpack('N')[0]
+      t2 = io.getn(4).unpack('N')[0]
+      [t1, t2]
+    end
+
+    def self.decode2(time, packet, list)
+      io = PO.new(packet)
+      id = decode_string(io)
+      if id =~ /\A\#/
+	      if id == '#bundle'
+	        t1, t2 = decode_timetag(io)
+	        if t1 == 0 && t2 == 1
+	          time = nil
+	        else
+	          time = t1 + t2.to_f / (2**32)
+	        end
+	        until io.eof?
+	          l = io.getn(4).unpack('N')[0]
+	          s = io.getn(l)
+	          decode2(time, s, list)
+	        end
+	      end
+      elsif id =~ /\//
+        address = id
+        if io.getc == ?,
+          tags = decode_string(io)
+          args = []
+          tags.scan(/./) do |t|
+            case t
+             when 'i'
+               i = decode_int32(io)
+               args << OSCInt32.new(i)
+             when 'f'
+               f = decode_float32(io)
+               args << OSCFloat32.new(f)
+             when 's'
+               s = decode_string(io)
+               args << OSCString.new(s)
+             when 'b'
+               b = decode_blob(io)
+               args << OSCBlob.new(b)
+             when /[htd]/; io.read(8)
+             when 'S'; decode_string(io)
+             when /[crm]/; io.read(4)
+             when /[TFNI\[\]]/;
+            end
+	        end
+	        list << [time, Message.new(address, nil, *args)]
+        end
+      end
+    end
+    
+    private_class_method  :decode_int32, 
+                          :decode_float32, 
+                          :decode_string, 
+                          :decode_blob, 
+                          :decode_timetag, 
+                          :decode2
+
+    def self.decode(packet)
+      list = []
+      decode2(nil, packet, list)
+      list
+    end
+
+  end
+end

data/lib/osc-ruby/simple_client.rb

@@ -0,0 +1,14 @@
+module OSC
+  class SimpleClient
+
+    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/simple_server.rb

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,25 @@
+# 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/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'spec'
+require 'rr'
+
+$:.unshift( File.join( File.dirname( __FILE__), '..', 'lib' ) ) 
+
+require 'osc-ruby'
+
+Spec::Runner.configure do |config|
+    config.mock_with RR::Adapters::Rspec
+end 

data/spec/unit/osc_argument_spec.rb

@@ -0,0 +1,7 @@
+require File.join( File.dirname(__FILE__) , '..', 'spec_helper' )
+
+describe OSC::OSCArgument do
+  it "should not blow up" do
+    OSC::OSCArgument.new 1
+  end
+end

data/spec/unit/osc_types_spec.rb

@@ -0,0 +1,26 @@
+require File.join( File.dirname(__FILE__) , '..', 'spec_helper' )
+
+describe OSC::OSCInt32 do
+  it "should not blow up" do
+    OSC::OSCInt32.new 1
+  end
+  
+end
+
+describe OSC::OSCFloat32 do
+  it "should not blow up" do
+    OSC::OSCFloat32.new 1.0
+  end
+end
+
+describe OSC::OSCString do
+  it "should not blow up" do
+    OSC::OSCString.new "1"
+  end
+end
+
+describe OSC::OSCBlob do
+  it "should not blow up" do
+    OSC::OSCBlob.new 1
+  end
+end

data/spec/unit/simple_client_spec.rb

@@ -0,0 +1,11 @@
+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

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: aberant-osc-ruby
+version: !ruby/object:Gem::Version 
+  version: 0.1.5
+platform: ruby
+authors: 
+- aberant
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: qzzzq1@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- VERSION.yml
+- lib/osc-ruby
+- lib/osc-ruby/bundle.rb
+- lib/osc-ruby/message.rb
+- lib/osc-ruby/osc_argument.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.rb
+- spec/integration
+- spec/integration/send_receive_spec.rb
+- spec/spec_helper.rb
+- spec/unit
+- spec/unit/osc_argument_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
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: inital gem
+test_files: []
+