ruby-osc 0.31.0 → 1.0.0

data/README.rdoc

@@ -13,6 +13,8 @@ Concise OSC implementation for Ruby
     require 'rubygems'
     require 'ruby-osc'
     
+    include OSC
+
     OSC.run do
       server = Server.new 9090
       client = Client.new 9090

data/Rakefile

@@ -1,7 +1,7 @@
-require 'bundler/gem_tasks'
-require "rspec/core/rake_task"
-
-desc "Run specs"
-RSpec::Core::RakeTask.new(:spec)
-
-task :default => :spec
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/examples/localtest.rb

@@ -1,5 +1,5 @@
-$:.unshift( File.join( File.dirname( __FILE__), '..', 'lib' ) ) 
-require 'ruby-osc'
+require "rubygems"
+require "ruby-osc"
 
 include OSC
 
@@ -7,7 +7,7 @@ OSC.run do
   server = Server.new 9090
   client = Client.new 9090
 
-  server.add_pattern /.*/ do |*args|       # this will match any address
+  server.add_pattern(/.*/) do |*args|       # this will match any address
     p "/.*/:       #{ args.join(', ') }"
   end
 
@@ -19,11 +19,12 @@ OSC.run do
     p "'/foo/bar': #{ args.join(', ') }"
   end
 
-  server.add_pattern "/exit" do |*args|    # this will just match /exit address
+  server.add_pattern "/exit" do |*_args|    # this will just match /exit address
     exit
   end
 
-  client.send Message.new('/foo/bar', 1, 1.2, 'a string')
-  client.send Message.new('/foo/bar/zar', 1, 1.2, 'a string')
-  client.send Bundle.new(Time.now + 2, Message.new('/exit'))
+
+  client.send Message.new("/foo/bar", 1, 1.2, "a string")
+  client.send Message.new("/foo/bar/zar", 1, 1.2, "a string")
+  client.send Bundle.new(Time.now + 2, Message.new("/exit"))
 end

data/lib/ruby-osc.rb

@@ -1,61 +1,65 @@
-require 'rubygems'
-require 'eventmachine'
-require 'socket' # Strange side effects with eventmachine udp client and SuperCollider
-require 'strscan'
-require 'thread'
-
-$:.unshift( File.join( File.dirname( __FILE__), '..', 'lib' ) ) 
-require 'ruby-osc/message'
-require 'ruby-osc/bundle'
-require 'ruby-osc/server'
-require 'ruby-osc/client'
+require "rubygems"
+require "eventmachine"
+require "socket" # Strange side effects with eventmachine udp client and SuperCollider
+require "strscan"
+require "thread"
+
+$LOAD_PATH.unshift( File.join( File.dirname( __FILE__), "..", "lib" ) )
+
+# encoding: UTF-8
+require "ruby-osc/message"
+require "ruby-osc/bundle"
+require "ruby-osc/server"
+require "ruby-osc/client"
 require "ruby-osc/version"
 
 module OSC
   class DecodeError < StandardError; end
-  
+
   class Blob < String; end
-  
+
   module OSCArgument
     def to_osc_type
       raise NotImplementedError, "#to_osc_type method should be implemented for #{ self.class }"
     end
   end
-  
-  def self.coerce_argument arg
+
+  def self.coerce_argument(arg)
     case arg
     when OSCArgument then arg.to_osc_type
     when Symbol      then arg.to_s
-    when String, Float, Fixnum, Blob, String then arg # Pure osc 1.0 specification
-    else raise(TypeError, "#{ arg.inspect } is not a valid Message argument") end
+    when String, Float, Integer, Blob, String then arg # Osc 1.0 spec
+    else
+      raise(TypeError, "#{ arg.inspect } is not a valid Message argument")
+    end
   end
-  
-  def self.decode str #:nodoc:
+
+  def self.decode(str) #:nodoc:
     str.match(/^#bundle/) ? Bundle.decode(str) : Message.decode(str)
   end
-  
-  def self.padding_size size
-    (4 - (size) % 4) % 4 
+
+  def self.padding_size(size)
+    (4 - (size) % 4) % 4
   end
 
   def self.run
     EM.run do
       EM.error_handler { |e| puts e }
-      EM.set_quantum 5 
+      EM.set_quantum 5
       yield
     end
   end
-  
-  def self.encoding_directive obj #:nodoc:
+
+  def self.encoding_directive(obj) #:nodoc:
     case obj
-    when Float  then [obj, 'f', 'g']
-    when Fixnum then [obj, 'i', 'N']
-    when Blob   then [[obj.size, obj], 'b', "Na*x#{ padding_size obj.size + 4 }"]
-    when String then [obj, 's', "Z*x#{ padding_size obj.size + 1 }"]
+    when Float then [obj, "f", "g"]
+    when Integer then [obj, "i", "N"]
+    when Blob then [[obj.bytesize, obj], "b", "Na*x#{ padding_size obj.bytesize + 4 }"]
+    when String then [obj, "s", "Z*x#{ padding_size obj.bytesize + 1 }"]
     when Time
-      t1, fr = (obj.to_f + 2208988800).divmod(1)
+      t1, fr = (obj.to_f + 2_208_988_800).divmod(1)
       t2 = (fr * (2**32)).to_i
-      [[t1, t2], 't', 'N2']
+      [[t1, t2], "t", "N2"]
     end
   end
 end

data/lib/ruby-osc/bundle.rb

@@ -1,52 +1,59 @@
+# encoding: UTF-8
 module OSC
   class Bundle < Array
     attr_accessor :timetag
 
-    def initialize timetag = nil, *args
+    def initialize(timetag = nil, *args)
       args.each{ |arg| raise TypeError, "#{ arg.inspect } is required to be a Bundle or Message" unless Bundle === arg or Message === arg }
-      raise TypeError, "#{ timetag.inspect } is required to be Time or nil" unless timetag == nil or Time === timetag
+      raise TypeError, "#{ timetag.inspect } is required to be Time or nil" unless timetag.nil? or Time === timetag
       super args
       @timetag = timetag
     end
 
     def encode
       timetag =
-      if @timetag
-        time, tag, dir = OSC.encoding_directive @timetag
-        time.pack dir
-      else "\000\000\000\000\000\000\000\001" end
-        
+        if @timetag
+          time, _tag, dir = OSC.encoding_directive(@timetag)
+          time.pack dir
+        else
+          "\000\000\000\000\000\000\000\001"
+        end
+
       "#bundle\000#{ timetag }" + collect do |x|
         x = x.encode
-        [x.size].pack('N') + x
+        [x.size].pack("N") + x
       end.join
     end
 
-    def self.decode string
-      string.sub! /^#bundle\000/, ''
-      t1, t2, content_str = string.unpack('N2a*')
-      
+    def self.decode(string)
+      string.sub!(/^#bundle\000/, "")
+      t1, t2, content_str = string.unpack("N2a*")
+
       timetag   = t1 == 0 && t2 == 1 ? nil : Time.at(t1 + t2 / (2**32.0) - 2_208_988_800)
       scanner   = StringScanner.new content_str
       args      = []
-      
+
       until scanner.eos?
-        size    = scanner.scan(/.{4}/).unpack('N').first
-        arg_str = scanner.scan(/.{#{ size }}/nm) rescue raise(DecodeError, "An error occured while trying to decode bad formatted osc bundle")
-        args   << OSC.decode(arg_str)
+        size    = scanner.scan(/.{4}/).unpack("N").first
+        arg_str = begin
+                    scanner.scan(/.{#{ size }}/nm)
+                  rescue
+                    raise(DecodeError, "An error occured while trying to decode bad formatted osc bundle")
+                  end
+        args << OSC.decode(arg_str)
       end
-      
+
       new timetag, *args
     end
-    
-    def == other
-      self.class == other.class and self.timetag == other.timetag and self.to_a == other.to_a
+
+    def ==(other)
+      self.class == other.class and timetag == other.timetag and to_a == other.to_a
     end
 
     def to_a; Array.new self; end
-    
+
     def to_s
-      "OSC::Bundle(#{ self.join(', ') })"
+      "OSC::Bundle(#{ join(', ') })"
     end
   end
 end

data/lib/ruby-osc/client.rb

@@ -1,13 +1,17 @@
+# encoding: UTF-8
+require "socket" # Strange side effects with eventmachine udp client and SuperCollider
+
 # From the Funaba osc gem:
 module OSC
   class Client
- 
-    def initialize port, host = '127.0.0.1'
+    def initialize(port, host = "127.0.0.1")
       @socket = UDPSocket.new
+      @socket = UDPSocket.open
+      @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
       @socket.connect host, port
     end
- 
-    def send mesg, *args
+
+    def send(mesg, *_args)
       @socket.send mesg.encode, 0
     end
   end
@@ -15,24 +19,24 @@ end
 
 # module OSC
 #   class Client
-#     
+#
 #     def initialize port, address = 'localhost'
 #       @address, @port = address, port
 #       run
 #     end
-#     
+#
 #     def run
 #       @connection = EventMachine.open_datagram_socket 'localhost', 0, Connection
 #     end
-#  
+#
 #     def stop
 #       @connection.close_connection if @connection
 #     end
-#  
+#
 #     def send item
-#       @connection.send_datagram item.encode, @address, @port 
+#       @connection.send_datagram item.encode, @address, @port
 #     end
-#     
+#
 #     class Connection < EventMachine::Connection #:nodoc:
 #     end
 #   end

data/lib/ruby-osc/message.rb

@@ -2,7 +2,7 @@ module OSC
   class Message
     attr_accessor :address, :time, :args
 
-    def initialize address = '', *args
+    def initialize(address = "", *args)
       args.collect! { |arg| OSC.coerce_argument arg }
       args.flatten! # won't harm we're not accepting arrays anyway, in case an custom coerced arg coerces to Array eg. Hash
       raise(TypeError, "Expected address to be a string") unless String === address
@@ -14,7 +14,7 @@ module OSC
       dirs ||= [] and objs ||= []
 
       [",#{ tags and tags.join }", @address].each do |str|
-        obj, tag, dir = OSC.encoding_directive str
+        obj, _tag, dir = OSC.encoding_directive(str)
         objs.unshift obj
         dirs.unshift dir
       end
@@ -22,45 +22,62 @@ module OSC
       objs.flatten.compact.pack dirs.join
     end
 
-    def == other
+    def ==(other)
       self.class == other.class and to_a == other.to_a
     end
 
     def to_a; @args.dup.unshift(@address) end
     def to_s; "OSC::Message(#{ args.join(', ') })" end
 
-    def self.decode string
+    def self.decode(string)
       scanner        = StringScanner.new string
-      address, tags  = (1..2).map do
-        string       = scanner.scan(/[^\000]+\000/)
-        scanner.pos += OSC.padding_size(string.size)
-        string.chomp("\000")
-      end
+      msg            = decode_message scanner
+      raise DecodeError unless scanner.eos?
+      msg
+    end
 
-      args = []
-      tags.scan(/\w/) do |tag|
-        case tag
-        when 'i'
-          int = scanner.scan(/.{4}/nm).unpack('N').first
-          args.push( int > (2**31-1) ? int - 2**32 : int )
-        when 'f'
-          args.push scanner.scan(/.{4}/nm).unpack('g').first
-        when 's'
-          str = scanner.scan(/[^\000]+\000/)
-          scanner.pos += OSC.padding_size(str.size)
-          args.push str.chomp("\000")
-        when 'b'
-          size = scanner.scan(/.{4}/).unpack('N').first
-          str  = scanner.scan(/.{#{ size }}/nm)
-          scanner.pos += OSC.padding_size(size + 4)
-          args.push Blob.new(str)
-        else
-          raise DecodeError, "#{ t } is not a known tag"
+    def self.decode_message(scanner)
+      pos = scanner.pos
+      begin
+        address, tags  = (1..2).map do
+          string       = scanner.scan(/[^\000]+\000/)
+          raise DecodeError, "no address or tags" if string.nil?
+          scanner.pos += OSC.padding_size(string.bytesize)
+          string.chomp("\000")
         end
-      end
 
-      new address, *args
+        args = []
+        tags.scan(/\w/) do |tag|
+          case tag
+          when "i"
+            int = scanner.scan(/.{4}/nm).unpack("N").first
+            args.push( int > (2**31 - 1) ? int - 2**32 : int )
+          when "f"
+            args.push scanner.scan(/.{4}/nm).unpack("g").first
+          when "d"
+            args.push scanner.scan(/.{8}/nm).unpack("G").first
+          when "s"
+            str = scanner.scan(/[^\000]+\000/)
+            scanner.pos += OSC.padding_size(str.size)
+            str = str.respond_to?(:force_encoding) ? str.force_encoding("UTF-8") : str
+            args.push str.chomp("\000")
+          when "b"
+            size = scanner.scan(/.{4}/).unpack("N").first
+            str  = scanner.scan(/.{#{ size }}/nm)
+            scanner.pos += OSC.padding_size(size + 4)
+            args.push Blob.new(str)
+          else
+            raise DecodeError, "#{ tag } is not a known tag"
+          end
+        end
+        new address, *args
+      end
+    rescue DecodeError => e
+      scanner.pos = pos
+      raise e
+    rescue => e
+      scanner.pos = pos
+      raise DecodeError, e
     end
-
   end
 end

data/lib/ruby-osc/server.rb

@@ -2,7 +2,7 @@ module OSC
   class Server
     attr_accessor :port, :address
 
-    def initialize port, address = '127.0.0.1'
+    def initialize(port, address = "127.0.0.1")
       @port, @address   = port, address
       @queue, @patterns = [], []
       @mutex = Mutex.new
@@ -20,27 +20,28 @@ module OSC
       @timer.cancel
     end
 
-    def add_pattern pattern, &block
-      raise ArgumentError.new("A block must be given") unless block
+    def add_pattern(pattern, &block)
+      raise ArgumentError, "A block must be given" unless block
       @patterns << [pattern, block]
     end
 
-    def delete_pattern pattern
+    def delete_pattern(pattern)
       @patterns.delete pattern
     end
 
-    def receive data
+    def receive(data)
       case decoded = OSC.decode(data)
       when Bundle
         decoded.timetag.nil? ? decoded.each{ |m| dispatch m } : @mutex.synchronize{@queue.push(decoded)}
       when Message
         dispatch decoded
       end
-      rescue => e 
-        warn "Bad data received: #{ e }"
+    rescue => e
+      warn "Bad data received: #{ e }"
     end
 
     private
+
     def check_queue
       @timer = EventMachine::PeriodicTimer.new 0.002 do
         now  = Time.now
@@ -53,19 +54,19 @@ module OSC
       end
     end
 
-    def dispatch message
-      @patterns.each do |pat, block| 
+    def dispatch(message)
+      @patterns.each do |pat, block|
         block.call(*message.to_a) if pat === message.address
       end
     end
 
     class Connection < EventMachine::Connection #:nodoc:
-      def initialize server
+      def initialize(server)
         @server = server
       end
 
-      def receive_data data
-        @server.receive(data) 
+      def receive_data(data)
+        @server.receive(data)
       end
     end
   end