mattly-datagrammer 0.2 → 0.4

data/README.mkdn

@@ -21,17 +21,15 @@ encoding/decoding stuff, as well as providing a non-blocking listening thread.
     require 'datagrammer'
     
     server = Datagrammer.new(5000)
-    server.listen do |serv, msg, sender| 
-      serv.speak("thanks for your message #{sender}, I received: #{msg.join(', ')}")
-    end
+    server.register_rule /.*/, lambda {|msg| server.speak("received: #{msg.join(',')}") }
     
     # set to speak at server's default speak destination
-    client = Datagrammer.new(5001, :speak_port => 5000) 
-    client.listen {|serv, msg| puts "rec'd #{msg}"}
-    
+    client = Datagrammer.new(5001, :speak_port => 5000)
+    client.register_rule 'received:', lambda {|msg| puts "rec'd #{msg}.join(' ')" }
+
     client.speak(%w(hey joe))
     sleep 0.1
-    # rec'd thanks for your message 127.0.0.1, I received: hey, joe
+    # rec'd received: hey, joe
 
 ## REQUIREMENTS
 

data/lib/datagrammer.rb

@@ -3,7 +3,6 @@ require 'socket'
 $:.unshift File.dirname(__FILE__)
 require 'datagrammer/packet'
 require 'datagrammer/packet_scanner'
-require 'datagrammer/generic_handler'
 
 # A Datagrammer object will listen on a given address and port for messages and
 # will decode the data (it's assumed to be in a OSC-style format) and perform
@@ -16,36 +15,76 @@ require 'datagrammer/generic_handler'
 #   # OSC-style packet (f.e. from Max/MSP's udpsender) will be echoed back on port
 #   # 5001 in the string format given in the block.
 class Datagrammer
-  attr_accessor :thread, :socket, :speak_address, :speak_port
+  attr_accessor :thread, :socket, :speak_address, :speak_port, :string_rules, :regex_rules
   
   # Creates a new Datagrammer object bound to the specified port. The following
   # options are available:
   # * (({:address})): IP to listen on. defaults to "0.0.0.0"
   # * (({:speak_address})): default IP to send to. defaults to "0.0.0.0"
   # * (({:speak_port})): default port to speak on, defaults to port + 1
+  # * (({:rules})): a hash of key, proc pairs that will become the initial ruleset for figuring out what to do with
+  #   received data. See '#register_rule' for more information
+  # * (({:listen})): boolean, default true, to start listening on instantiation
+  #
+  # Your datagrammer instance will start listening automatically unless otherwise directed by :listen
   def initialize(port, opts={})
     @port          = port
     @address       = opts[:address] || "0.0.0.0"
     @speak_address = opts[:speak_address] || @address
     @speak_port    = opts[:speak_port] || port + 1
+    @string_rules, @regex_rules = {}, {}
+    @default_rule  = nil
+    (opts[:rules]||{}).each_pair {|key, value| register_rule(key, value) }
     @socket        = UDPSocket.new
     @socket.bind(@address, @port)
+    listen unless opts.has_key?(:listen) && ! opts[:listen]
   end
   
+  # Defines a rule to match and a process to run if matched. Rule keys are matched
+  # against the first item in the "data" value passed in from Datagrammer, or the
+  # so-called "path" of the message. Data like (({['/foo/bar', 'baz', 'bee']})) would
+  # use "/foo/bar" as the path to match against.
+  #
+  # Rules are evaluated as follows:
+  # * If a rule key is a string and matches the path exactly, the rule will be used.
+  # * If a rule key is a regex and there are matches against the path, the rule will be used.
+  #   Matches from the regex are prepended to the argument list passed to the process.
+  # * If no string or regex rules match and there is a rule called :default, that rule will be used
+  # * If there is no :default rule and no matches are made, nothing will happen
+  def register_rule(rule, block)
+    @string_rules[rule] = block if rule.kind_of?(String)
+    @regex_rules[rule]  = block if rule.kind_of?(Regexp)
+    @default_rule       = block if rule == :default
+  end
+  
+  # runs the first part of the incoming message against the registered rules.
+  def handle(address, arguments=[])
+    list = []
+    list << [@string_rules[address], arguments]
+    list += @regex_rules.select {|key, value| address =~ key }.map do |regex, action|
+      msg = [address.scan(regex), arguments].flatten
+      msg.delete('')
+      [action, msg]
+    end
+    list.delete_if {|callback, args| callback.nil? }
+    list << [@default_rule, arguments] if list.empty? && @default_rule
+    list.each {|callback, args| callback.call(args) }
+  end
+  
+  
   # Sets the default speak destination
   def speak_destination=(addr, port)
     @speak_address, @speak_port = addr, port
   end
   
-  # Starts the thread to listen on the selected port. A block is required, that will get
-  # three arguments: the datagrammer object itself, the packet data (as an array), and the 
-  # address of the sender.
-  def listen(&block)
+  # Starts the thread to listen on the selected port.
+  def listen
     @thread = Thread.start do
       loop do
         IO.select([@socket])
         data, info = @socket.recvfrom(65535)
-        block.call(self, Packet.decode(data), info.last)
+        data = Packet.decode(data)
+        handle(data.shift, data)
       end
     end
   end
@@ -55,4 +94,6 @@ class Datagrammer
     @socket.send(Packet.encode([message]), 0, addr, port)
   end
   
+  private
+  
 end

data/lib/datagrammer/packet.rb

@@ -12,10 +12,25 @@ class Datagrammer
       message = scanner.scan_string
       argument_types = scanner.scan_string.sub(/^,/,'').split('')
       arguments = argument_types.collect do |type|
-        { 's' => lambda { scanner.scan_string },
-          'i' => lambda { scanner.scan_integer },
-          'f' => lambda { scanner.scan_float }
-        }[type].call()
+        case type
+        when 's'; scanner.scan_string
+        when 'i'; scanner.scan_integer
+        when 'f'; scanner.scan_float
+        when 'T'; true
+        when 'F'; false
+        when 'N'; nil
+          # not supported yet:
+        # when 'b'; # blob
+        # when 'S'; # symbol
+        # when 't'; # OSC timetag
+        # when 'h'; # 64-bit integer
+        # when 'd'; # 64-bit "double" float
+        # when 'r'; # 32-bit RGBA color
+        # when 'm'; # four-byte midi message
+        # when 'I'; # infinity
+        # when '['; # beginning of array
+        # when ']'; # end of array
+        end
       end
       arguments.unshift(message)
     end
@@ -45,6 +60,9 @@ class Datagrammer
         when String; 's' 
         when Integer; 'i'
         when Float; 'f'
+        when TrueClass; 'T'
+        when FalseClass; 'F'
+        when NilClass; 'N'
         end
       end.join
       pad(str)
@@ -56,6 +74,7 @@ class Datagrammer
         when String; pad(argument)
         when Integer; [argument].pack('N')
         when Float; [argument].pack('g')
+        when TrueClass, FalseClass, NilClass; # no arguments
         end
       end.join
     end

data/spec/datagrammer_spec.rb

@@ -16,21 +16,72 @@ describe Datagrammer do
     s
   end
   
-  it "should send an encoded packet out to its speaking port" do
-    Thread.start { sleep 0.1; @serv.speak("hi") }
-    sock = setup_socket(10001)
-    IO.select [sock]
-    data, info = sock.recvfrom(1024)
-    sock.close
-    data.should == "hi\000\000,\000\000\000"
+  describe "sending messages" do
+    it "should send an encoded packet out to its speaking port" do
+      Thread.start { sleep 0.1; @serv.speak("hi") }
+      sock = setup_socket(10001)
+      IO.select [sock]
+      data, info = sock.recvfrom(1024)
+      sock.close
+      data.should == "hi\000\000,\000\000\000"
+    end
   end
   
-  it "should receive encoded packets while listening and feed it to the callback" do
-    @serv.listen {|dg, msg| @foo = msg }
-    s = UDPSocket.new
-    s.send("hi\000\000,\000\000\000", 0, '0.0.0.0', 10000)
-    sleep 0.1
-    @foo.should == ['hi']
+  describe "handling received messages" do
+    
+    before do
+      @bar = 'baz'
+      @foo = lambda {|args| @bar = "foo: #{args.join(', ')}" }
+      @serv.register_rule('foo', @foo)
+    end
+    
+    it "should receive encoded packets while listening and feed it to the handler" do
+      @serv.should_receive(:handle).with('foo', ['hi'])
+      s = UDPSocket.new
+      s.send("foo\000,s\000\000hi\000\000", 0, '0.0.0.0', 10000)
+      sleep 0.1
+    end
+    
+    it "calls the handler for a given address" do
+      @serv.handle('foo', %w(bar baz))
+      @bar.should == "foo: bar, baz"
+    end
+
+    describe "with regex handlers" do
+      before do
+        @i = Hash.new {|hash, key| hash[key] = [] }
+        @serv.register_rule(/^\/reg\/(.*)$/, lambda {|a| @i[a.shift] += a})
+      end
+
+      it "accepts regexes as hanlder keys and calls their values when matched" do
+        @serv.handle('/reg/foo', %w(bar baz))
+        @i.should == {'foo' => %w(bar baz)}
+      end
+
+      it "handles values for ALL regexes that match given string" do
+        @serv.register_rule(/.*/, lambda {|a| @i['default'] += a })
+        @serv.handle('/reg/foo', %w(bar baz))
+        @i.should == {'foo' => %w(bar baz), 'default' => %w(/reg/foo bar baz)}
+      end
+
+      it "uses regexes if exact match from string" do
+        @serv.register_rule('/reg/foo', lambda {|a| @i['exact'] += a })
+        @serv.handle('/reg/foo', %w(bar baz))
+        @i.should == {'exact' => %w(bar baz), 'foo' => %w(bar baz)}
+      end
+    end
+
+    describe "with no handler found" do
+      it "uses 'default' if exists" do
+        @serv.register_rule(:default, lambda {@i = 'default'})
+        @serv.handle('/non-existant')
+        @i.should == 'default'
+      end
+
+      it "does nothing if no default handler" do
+        @serv.handle('/non-existant').should == []
+      end
+    end
   end
   
 end

data/spec/packet_spec.rb

@@ -26,11 +26,22 @@ describe Datagrammer::Packet do
       encoded = "tick\n\000\000\000,ii\000\000\000\000\n\000\000\334\n"
       Datagrammer::Packet.decode(encoded).should == ["tick\n", 10, 56330]
     end
+    
+    it "handles encoded booleans correctly" do
+      encoded = "boolean\000,TF\000"
+      Datagrammer::Packet.decode(encoded).should == ["boolean", true, false]
+    end
+    
+    it "handles encoded nils correctly" do
+      encoded = "nil\000,N\000\000"
+      Datagrammer::Packet.decode(encoded).should == ["nil", nil]
+    end
   end
   
   describe "encode" do
     [ [['hello'], "hello\000\000\000,\000\000\000"],
       [['hello','world'], "hello\000\000\000,s\000\000world\000\000\000"],
+      [['hello', true, false, nil], "hello\000\000\000,TFN\000\000\000\000"],
       [['hello', 'world', 1, 2.0], "hello\000\000\000,sif\000\000\000\000world\000\000\000\000\000\000\001@\000\000\000"]
     ].each do |message, expected|
       describe "message: #{message.join(', ')}" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mattly-datagrammer
 version: !ruby/object:Gem::Version 
-  version: "0.2"
+  version: "0.4"
 platform: ruby
 authors: 
 - Matthew Lyon
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-01 00:00:00 -07:00
+date: 2008-11-07 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -25,12 +25,10 @@ files:
 - README.mkdn
 - Rakefile
 - spec/datagrammer_spec.rb
-- spec/generic_handler_spec.rb
 - spec/packet_scanner_spec.rb
 - spec/packet_spec.rb
 - spec/spec_helper.rb
 - lib/datagrammer
-- lib/datagrammer/generic_handler.rb
 - lib/datagrammer/packet.rb
 - lib/datagrammer/packet_scanner.rb
 - lib/datagrammer.rb

data/lib/datagrammer/generic_handler.rb

@@ -1,54 +0,0 @@
-class Datagrammer
-  # A simple class for registering multiple "handlers" for messages that come from a Datagrammer object.
-  class GenericHandler
-    attr_accessor :rules
-    
-    # Takes a hash of key, proc values for an initial set of rules. Rule keys are matched
-    # against the first item in the "data" value passed in from Datagrammer, or the
-    # so-called "path" of the message. Data like (({['/foo/bar', 'baz', 'bee']})) would
-    # use "/foo/bar" as the path to match against.
-    #
-    # Rules are evaluated in this order:
-    # * If a rule key is a string and it matches the path exactly, that rule will be used.
-    # * If no string rule keys match, any rule keys that are regexes will be run against the 
-    #   path and ALL regexes that match will be called. The match(es) from the regex will be
-    #   prepended to the argument list passed to the proc.
-    # * If there is no match yet and a rule key called '\default' exists, that rule will be used.
-    # * If no match has been made at this point, nothing will happen, the data will be ignored.
-    def initialize(rules={})
-      @rules = rules
-    end
-    
-    # sets a proc to be called when a rule is matched. See #new for more information.
-    def register_rule(address, block)
-      @rules[address] = block
-    end
-    
-    # What Datagrammer calls. Runs the path against registered rules as described in #new
-    def handle(address, arguments=[])
-      list = if @rules.has_key?(address)
-        [[@rules[address], arguments]]
-      else
-        matches = @rules.select {|k,v| k.kind_of?(Regexp) && address =~ k }
-        if ! matches.empty?
-          matches.collect do |regex, p| 
-            msg = [address.scan(regex), arguments].flatten
-            msg.delete('')
-            [p, msg]
-          end
-        elsif @rules.has_key?('\default')
-          [[@rules['\default'], arguments]]
-        else
-          []
-        end
-      end
-      list.map {|callback, args| callback.call(args) }
-    end
-    
-    # returns a lambda for a Datagrammer object's listen method
-    def handler
-      lambda {|dg, args, sender| self.handle(args.shift, args) }
-    end
-    
-  end
-end

data/spec/generic_handler_spec.rb

@@ -1,60 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-describe Datagrammer::GenericHandler do
-  
-  before do
-    @handler = Datagrammer::GenericHandler.new
-    @foo = lambda {|args| "foo: #{args.join(', ')}" }
-    @handler.register_rule('/foo', @foo)
-  end
-  
-  it "registers handlers" do
-    @handler.rules['/foo'].should == @foo
-  end
-  
-  it "calls the handler for a given address" do
-    @handler.handle('/foo', %w(bar baz)).should == ["foo: bar, baz"]
-  end
-  
-  it "spits out a lambda for calling the handler from DG" do
-    @handler.should_receive(:handle).with('/foo',%w(bar baz))
-    @handler.handler.call(nil, %w(/foo bar baz), nil)
-  end
-  
-  describe "regex handlers" do
-    before do
-      @i = Hash.new {|hash, key| hash[key] = [] }
-      @handler.register_rule(/^\/reg\/(.*)$/, lambda {|a| @i[a.shift] += a})
-    end
-
-    it "accepts regexes as hanlder keys and calls their values when matched" do
-      @handler.handle('/reg/foo', %w(bar baz))
-      @i.should == {'foo' => %w(bar baz)}
-    end
-    
-    it "handles values for ALL regexes that match given string" do
-      @handler.register_rule(/.*/, lambda {|a| @i['default'] += a })
-      @handler.handle('/reg/foo', %w(bar baz))
-      @i.should == {'foo' => %w(bar baz), 'default' => %w(/reg/foo bar baz)}
-    end
-    
-    it "does not use regexes if exact match from string" do
-      @handler.register_rule('/reg/foo', lambda {|a| @i['exact'] += a })
-      @handler.handle('/reg/foo', %w(bar baz))
-      @i.should == {'exact' => %w(bar baz)}
-    end
-  end
-  
-  describe "no handler found" do
-    it "uses 'default' if exists" do
-      default = lambda { 'default' }
-      @handler.register_rule('\default', default)
-      @handler.handle('/non-existant').should == ['default']
-    end
-  
-    it "does nothing if no default handler" do
-      @handler.handle('/non-existant').should == []
-    end
-  end
-  
-end