osc-access 0.0.15

data/lib/osc-access/translate.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+module OSCAccess
+
+  module Analog
+    
+    def self.new(from, to, options = {})
+      case to
+        when Array then Output::Set.new(Input.new(from), to, options)
+        when ::Range then Output::Range.new(Input.new(from), to, options)
+      end
+    end
+    
+    module Input
+      
+      def self.new(input)
+        case input
+          when Array then Input::Set.new(input)
+          when ::Range then Input::Range.new(input)
+        end
+      end
+      
+      class Range
+        
+        def initialize(range)
+          @range = range
+        end
+        
+        def numerator(input)
+          (input - @range.first).to_f
+        end
+        
+        def denominator
+          (@range.last - @range.first).abs.to_f
+        end
+        
+      end
+      
+      class Set
+
+        def initialize(set)
+          @set = set
+        end
+        
+        def numerator(input)
+          @set.index(input).to_f
+        end
+        
+        def denominator
+          (@set.size - 1).to_f
+        end
+                
+      end
+      
+    end
+
+    module Output
+      
+      class Range
+        
+        def initialize(from, to_range, options = {})
+          @type = options[:type]
+
+          @from = from
+          @to_range = to_range
+        end
+
+        def process(input, options = {})
+          to_range_len = (@to_range.last - @to_range.first).abs
+          
+          proportion = to_range_len.to_f / @from.denominator
+          abs_output = proportion.to_f * @from.numerator(input)
+          output = abs_output + @to_range.first
+
+          type = options[:type] || @type
+          float_requested = !type.nil? && type.to_s.downcase == "float"
+          float_requested ? output : output.to_i
+        end
+
+      end
+
+      class Set
+        
+        def initialize(from, to_set, options = {})
+          @from = from
+          @to_set = to_set
+        end
+
+        def process(input, options = {})
+          proportion = @from.numerator(input) / @from.denominator
+          index = [((proportion * @to_set.size).to_i - 1), 0].max
+          @to_set.at(index)
+        end
+
+      end
+
+    end
+
+  end
+
+  class Translate
+    
+    def self.using(value, range, options = {})
+      to_local = options[:to_local].nil? ? true : options[:to_local]
+      new_vals = [value].flatten.compact.map do |single_val|
+        if range == :boolean
+        to_local ? (single_val <= 0 ? false : true) : (single_val ? 1 : 0)
+        else
+          if range.kind_of?(Range) || range.kind_of?(Array)
+            remote = DefaultRemoteRange
+            local = range
+            type = options[:type]
+          else
+            remote = range[:remote] || DefaultRemoteRange
+            local = range[:local]
+            type = range[:type] || options[:type]
+          end
+          analog = to_local ? Analog.new(remote, local) : Analog.new(local, remote)
+          type = to_local ? type : :float
+          analog.process(single_val, :type => type)
+        end
+      end
+      value.kind_of?(Array) ? new_vals : new_vals.first
+    end
+
+  end
+
+end

data/lib/osc-access/zeroconf.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+#
+# Zeroconf support
+#
+# http://www.zeroconf.org
+#
+#
+
+#
+# much of this code was lifted from Zosc
+# http://github.com/samBiotic/ruby-zosc
+# Copyright (c) 2011 Sam Birkhead and released under the MIT License
+#
+#
+
+require "dnssd"
+
+module OSCAccess
+  
+  module Zeroconf
+
+    class Service
+    
+      def initialize(name, port)
+        @name, @port = name, port
+      end
+        
+      def start
+        @thread = Thread.new do
+          registrar = DNSSD::Service.new
+          registrar.register @name, '_osc._udp', nil, @port do |r|
+          end
+        end
+        self
+      end
+    
+      def stop
+        @thread.kill unless @thread.nil?
+        self
+      end
+    
+    end
+      
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+
+require 'test/unit'
+require 'osc-access'
+
+module TestHelper
+  
+  $port_counter = 8000
+  
+  def self.next_port
+    $port_counter += 1
+  end
+  
+  class StubObject
+    
+    include OSCAccessible
+    
+    attr_accessor :data
+    
+  end
+
+end

data/test/test_accessible.rb

@@ -0,0 +1,334 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class AccessibleTest < Test::Unit::TestCase
+
+  include OSCAccess
+  include TestHelper
+  
+  def test_osc_translate
+    outp = StubObject.new.send(:osc_translate, 0.8, :local => 0..127, :remote => 0..1)
+    assert_equal(101, outp)      
+  end
+  
+  def test_osc_translate_default_remote
+    outp = StubObject.new.send(:osc_translate, 0.5, 0..127)
+    assert_equal(63, outp)      
+  end
+  
+  def test_osc_translate_float
+    outp = StubObject.new.send(:osc_translate, 12, :remote => 0..120, :local => 0..1, :type => :float)
+    assert_equal(0.10, outp)     
+  end
+  
+  def test_osc_send
+    sleep(0.5)
+    received = nil
+    port = TestHelper.next_port
+    
+    server = OSC::EMServer.new(port)
+    server.add_method("/test_osc_output") do |message|
+      received = message.args[0]
+    end 
+    Thread.new { server.run }
+    sleep(0.5)
+    obj = StubObject.new
+    obj.osc_output(:port => port, :host => "localhost")
+    obj.osc_send("/test_osc_output", "hi friend")
+    sleep(0.5)
+    assert_equal("hi friend", received)
+  end
+    
+  def test_osc_send_msg
+    sleep(0.5)
+    received = nil
+    port = TestHelper.next_port
+    
+    server = OSC::EMServer.new(port)
+    server.add_method("/test_osc_output") do |message|
+      received = message.args[0]
+    end 
+    Thread.new { server.run }
+    sleep(0.5)
+    obj = StubObject.new
+    obj.osc_output(:port => port, :host => "localhost")
+    obj.osc_send(OSC::Message.new("/test_osc_output", "hi friend"))
+    sleep(0.5)
+    assert_equal("hi friend", received)
+  end
+  
+  def test_osc_send_accessor_translate
+    sleep(0.5)
+    received = nil
+    port = TestHelper.next_port
+    
+    server = OSC::EMServer.new(port)
+    server.add_method("/test_osc_send_accessor_translate") do |message|
+      received = message.args[0]
+    end 
+    Thread.new { server.run }
+    sleep(0.5)
+    obj = StubObject.new
+    obj.osc_receive("/test_osc_send_accessor_translate", :accessor => :data, :translate => 0..127)
+    obj.osc_output(:port => port, :host => "localhost")
+    obj.data = 63
+    obj.osc_send(:data)
+    sleep(0.5)
+    assert_equal(0.5, received.round(1))
+  end
+  
+  def test_osc_send_accessor
+    sleep(0.5)
+    received = nil
+    port = TestHelper.next_port
+    
+    server = OSC::EMServer.new(port)
+    server.add_method("/test_osc_send_accessor") do |message|
+      received = message.args[0]
+    end 
+    Thread.new { server.run }
+    sleep(0.5)
+    obj = StubObject.new
+    obj.osc_receive("/test_osc_send_accessor", :accessor => :data)
+    obj.osc_output(:port => port, :host => "localhost")
+    obj.data = "blahblah"
+    obj.osc_send(:data)
+    sleep(0.5)
+    assert_equal("blahblah", received)
+  end
+    
+  def test_osc_input
+    sleep(0.5)
+    received = nil
+    port = TestHelper.next_port
+    obj = StubObject.new
+    
+    obj.osc_input(port)
+    obj.osc_start
+    obj.osc_receive("/test_osc_input") do |obj, val|
+      received = val
+    end
+    client = OSC::Client.new("localhost", port)
+    client.send( OSC::Message.new( "/test_osc_input", "hullo from test_osc_input!"))  
+    sleep(0.5)
+    assert_equal("hullo from test_osc_input!", received)  
+  end
+  
+  def test_osc_process_ports_args
+    obj = StubObject.new
+    assert_equal([8000], obj.send(:osc_process_ports_args, [8000]))
+    assert_equal([8000], obj.send(:osc_process_ports_args, [[8000]]))
+    assert_equal((8000..8010).to_a, obj.send(:osc_process_ports_args, [8000..8010]))
+    assert_equal((8000..8010).to_a, obj.send(:osc_process_ports_args, [[8000..8010]]))
+    assert_equal([8000], obj.send(:osc_process_ports_args, [:port => 8000]))
+  end
+  
+  
+  def test_osc_receive_translate
+    sleep(0.5)
+    received = nil
+    port = TestHelper.next_port
+    
+    obj = StubObject.new
+    obj.osc_start(:input_port => port)
+    obj.osc_receive("/test_osc_receive_translate", :translate => 0..127) do |obj, val|
+      received = val
+    end
+    client = OSC::Client.new("localhost", port)
+    client.send( OSC::Message.new( "/test_osc_receive_translate", 0.5))  
+    sleep(0.5)
+    assert_equal(63, received)  
+  end
+  
+  def test_osc_receive_arg
+    sleep(0.5)
+    received = nil
+    port = TestHelper.next_port
+    
+    obj = StubObject.new
+    obj.osc_start(:input_port => port)
+    obj.osc_receive("/test_osc_receive_arg", :arg => 1) do |obj, val|
+      received = val
+    end
+    client = OSC::Client.new("localhost", port)
+    client.send( OSC::Message.new( "/test_osc_receive_arg",5,4,3,2,1))  
+    sleep(0.5)
+    assert_equal(4, received)  
+  end  
+  
+  def test_osc_receive_accessor
+    sleep(0.5)
+    port = TestHelper.next_port
+    obj = StubObject.new
+    
+    obj.osc_start(:input_port => port)
+    obj.osc_receive("/test_osc_receive_accessor", :accessor => :data)
+    client = OSC::Client.new("localhost", port)
+    client.send( OSC::Message.new( "/test_osc_receive_accessor", "hi from test_osc_receive_accessor"))  
+    sleep(0.5)
+    assert_equal("hi from test_osc_receive_accessor", obj.data)  
+  end  
+  
+  def test_load_map_inline_proc
+    received = nil
+    port = TestHelper.next_port
+    map = {
+      "/test_load_map_inline_proc" => Proc.new do |instance, val| 
+          received = val
+        end
+    }
+    obj = StubObject.new
+    obj.osc_input(port)
+    obj.osc_start
+    obj.osc_load_map(map)
+    client = OSC::Client.new("localhost", port)
+    client.send( OSC::Message.new( "/test_load_map_inline_proc", "hullo from test_load_map_inline_proc!"))  
+    sleep(0.5)
+    assert_equal("hullo from test_load_map_inline_proc!", received)  
+  end
+  
+  def test_load_map
+    received = nil
+    port = TestHelper.next_port
+    map = {
+      "/test_load_map" => { 
+        :action => Proc.new do |instance, val| 
+          received = val
+        end
+      }
+    }
+    obj = StubObject.new
+    obj.osc_input(port)
+    obj.osc_start
+    obj.osc_load_map(map)
+    client = OSC::Client.new("localhost", port)
+    sleep(0.5)
+    client.send( OSC::Message.new( "/test_load_map", "hullo from test_load_map!"))  
+    sleep(0.5)
+    assert_equal("hullo from test_load_map!", received)  
+  end
+  
+  def test_load_map_translate
+    received = nil
+    port = TestHelper.next_port
+    map = {
+      "/test_load_map_translate" => { 
+        :translate => 0..127,
+        :action => Proc.new do |instance, val| 
+          received = val
+        end
+      }
+    }
+    obj = StubObject.new
+    obj.osc_input(port)
+    obj.osc_start
+    obj.osc_load_map(map)
+    client = OSC::Client.new("localhost", port)
+    client.send( OSC::Message.new( "/test_load_map_translate", 0.5) ) 
+    sleep(0.5)
+    assert_equal(63, received)  
+  end
+  
+  def test_load_map_arg
+    received = nil
+    port = TestHelper.next_port
+    map = {
+      "/test_load_map_arg" => { 
+        :arg => 2,
+        :action => Proc.new do |instance, val| 
+          received = val
+        end
+      }
+    }
+    obj = StubObject.new
+    obj.osc_input(port)
+    obj.osc_load_map(map)
+    obj.osc_start
+    client = OSC::Client.new("localhost", port)
+    client.send( OSC::Message.new( "/test_load_map_arg",0,1,2,3,4) ) 
+    sleep(0.5)
+    assert_equal(2, received)  
+  end
+    
+  def test_class_included
+    o = StubObject.new
+    assert_equal(true, o.class.kind_of?(OSCAccess::Class))
+  end
+  
+  def test_osc_receive_thru
+    sleep(0.5)
+    received, received_back = nil, nil
+    port1 = TestHelper.next_port
+    port2 = TestHelper.next_port
+    server = OSC::EMServer.new(port1)
+    server.add_method("/test_osc_receive_thru") do |message|
+      received_back = message.args[0]
+    end 
+    Thread.new { server.run }
+    sleep(0.5)
+    obj = StubObject.new
+    obj.osc_start(:input_port => port2, :output => { :host => "localhost", :port => port1 })
+    obj.osc_receive("/test_osc_receive_thru", :thru => true) do |obj, val|
+      received = val
+    end
+    client = OSC::Client.new("localhost", port2)
+    client.send( OSC::Message.new( "/test_osc_receive_thru", "hullo from test_osc_receive_thru!"))  
+    sleep(0.5)
+    assert_equal("hullo from test_osc_receive_thru!", received)  
+    assert_equal("hullo from test_osc_receive_thru!", received_back)       
+  end
+
+  def test_osc_start_input
+    sleep(1)
+    received = nil
+    port = TestHelper.next_port
+    obj = StubObject.new
+    
+    obj.osc_start(:input_port => port)
+    obj.osc_receive("/test_osc_start_input") do |obj, val|
+      received = val
+    end
+    client = OSC::Client.new("localhost", port)
+    client.send( OSC::Message.new( "/test_osc_start_input", "hullo from test_osc_start_input!"))  
+    sleep(0.5)
+    assert_equal("hullo from test_osc_start_input!", received)      
+  end
+  
+  def test_osc_multiplex_input
+    sleep(1)
+    received = 0 
+    
+    obj = StubObject.new
+    obj.osc_start(:input_port => 9080..9082)
+    obj.osc_receive("/test_osc_multiplex_input") do |obj, val|
+      received += 1
+    end
+    sleep(0.5)
+    3.times do |i|
+      client = OSC::Client.new("localhost", 9080 + i)
+      client.send( OSC::Message.new( "/test_osc_multiplex_input", i))  
+    end
+    sleep(0.5)
+    assert_equal(3, received)      
+  end
+  
+  def test_osc_start_output
+    sleep(1)
+    received = nil
+    port = TestHelper.next_port
+    
+    server = OSC::EMServer.new(port)
+    server.add_method("/test_osc_start_output") do |message|
+      received = message.args[0]
+    end 
+    Thread.new { server.run }
+    sleep(0.5)
+    obj = StubObject.new
+    obj.osc_start(:output => { :port => port, :host => "localhost" })
+    obj.osc_send("/test_osc_start_output", "hi from test_osc_start_output")
+    sleep(0.5)
+    assert_equal("hi from test_osc_start_output", received)    
+  end
+  
+end