mumble-ruby 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e46d3df87918f5012997b654c5f47a78ed4e19e3
-  data.tar.gz: 345f9359d29321c10a4a69cceec83c9468d1d8af
+  metadata.gz: e8dc2810d57d5afb6c1f6c7ad838e296c0f5b074
+  data.tar.gz: 9239fee6276e50cbbad6fdc773556d5abbb4ead4
 SHA512:
-  metadata.gz: c3f904facc7c604f718701924fa1b5809e1268eb442b55906800efcfb78c13dea30c324bc3ff432435ac2343c4e7d7a54d573cd70e419538c3e72ec35e1abf5e
-  data.tar.gz: 0628cfddb4b8e04c2bb34f18e9c17de8a29d151c7371af35918b022346f793a9e23fe5d38decd448160a18f6abe59ce2a9fe930dacb7e37bf9312ff3b4fb703c
+  metadata.gz: 0c2ef16226e6063220e1ddfa34f94f673240ae7bbecc09873bd0784771601e5ee7822bfa998d75e0d48f1ba6b85f7673d6f1348dd816a3aa8bc63b3fe9f07e69
+  data.tar.gz: 37a828c91ea9df41015fb3be82bedc85d9e168bcf86ef2f2e8b7444788cee2a29582b7c710ae66a775ec2dbfaf610c2534db5fe506b353048badebf20a00b7c1

data/.ruby-version

@@ -1 +1 @@
-ruby-2.1.0
+ruby-2.1.1

data/README.rdoc

@@ -16,10 +16,15 @@ There is huge room for improvement in this library and I am willing to accept al
 
 * Ruby >= 2.1.0
 * OPUS Audio Codec
-* Murmur server > 1.2.4
+* Murmur server > 1.2.4 -- NOTE: mumble-ruby will not be able to stream audio to servers that don't support OPUS anymore. I haven't looked into backwards-compatability with CELT.
 
 == RECENT CHANGES:
 
+* Merged changes for proper user/channel objects
+* Merged changes for recording feature
+* Added half-broken support for playing files (Something is wrong, wouldn't recommend using it)
+* Bit of refactoring and renaming
+
 * Added OPUS support
 * Added more configuration options
 * Added image text messages
@@ -62,23 +67,25 @@ There is huge room for improvement in this library and I am willing to accept al
     cli.connect
     # => #<Thread:0x000000033d7388 run>
 
-    # Mute and Deafen yourself
-    cli.mute
-    cli.deafen
+    # Mute and Deafen yourself after connecting
+    cli.on_connect do
+        cli.me.mute
+        cli.me.deafen
+    end
 
-    # Join the channel titled "Chillen" (this returns the number of bytes written to the socket)
+    # Join the channel titled "Chillen" (this will return a channel object for that channel)
     cli.join_channel('Chillen')
-    # => 11
 
     # Get a list of channels
     cli.channels
-    # Returns a hash of channel_id: ChannelState Messages
+    # Returns a hash of channel_id: Channel objects
 
     # Join Channel using ID
     cli.join_channel(0)
 
-    # Join Channel using ChannelState Message
+    # Join Channel using Channel object
     cli.join_channel(cli.channels[0])
+    cli.channels[0].join
 
     # Get a list of users
     cli.users
@@ -86,14 +93,20 @@ There is huge room for improvement in this library and I am willing to accept al
 
     # Text user
     cli.text_user('perrym5', "Hello there, I'm a robot!")
-    # => 35
 
     # Text an image to a channel
     cli.text_channel_img('Chillen', '/path/to/image.jpg')
 
     # Start streaming from a FIFO queue of raw PCM data
-    cli.stream_raw_audio('/tmp/mpd.fifo')
-    # => #<Mumble::AudioStream ...>
+    cli.player.stream_named_pipe('/tmp/mpd.fifo')
+
+    # EXPERIMENTAL: Recording feature
+    cli.recorder.start('/home/matt/record.wav')
+    sleep(2)
+    cli.recorder.stop
+
+    # EXPERIMENTAL: Play wav files
+    cli.player.play_file('/home/matt/record.wav')
 
     # Safely disconnect
     cli.disconnect

data/lib/mumble-ruby.rb

@@ -1,13 +1,19 @@
 require 'opus-ruby'
-require 'active_support/inflector.rb'
+require 'active_support/inflector'
 require 'mumble-ruby/version'
-require 'mumble-ruby/messages.rb'
-require 'mumble-ruby/connection.rb'
-require 'mumble-ruby/client.rb'
-require 'mumble-ruby/audio_stream.rb'
-require 'mumble-ruby/packet_data_stream.rb'
-require 'mumble-ruby/img_reader.rb'
-require 'mumble-ruby/cert_manager.rb'
+require 'mumble-ruby/thread_tools'
+require 'mumble-ruby/messages'
+require 'mumble-ruby/connection'
+require 'mumble-ruby/model'
+require 'mumble-ruby/user'
+require 'mumble-ruby/channel'
+require 'mumble-ruby/client'
+require 'mumble-ruby/audio_player'
+require 'mumble-ruby/packet_data_stream'
+require 'mumble-ruby/img_reader'
+require 'mumble-ruby/cert_manager'
+require 'mumble-ruby/audio_recorder'
+require 'hashie'
 
 module Mumble
   DEFAULTS = {

data/lib/mumble-ruby/audio_player.rb

@@ -0,0 +1,102 @@
+require 'wavefile'
+
+module Mumble
+  class AudioPlayer
+    include ThreadTools
+    COMPRESSED_SIZE = 960
+
+    def initialize(type, connection, sample_rate, bitrate)
+      @packet_header = (type << 5).chr
+      @conn = connection
+      @pds = PacketDataStream.new
+      @queue = Queue.new
+      @wav_format = WaveFile::Format.new :mono, :pcm_16, sample_rate
+
+      create_encoder sample_rate, bitrate
+    end
+
+    def volume
+      @volume ||= 100
+    end
+
+    def volume=(volume)
+      @volume = volume
+    end
+
+    def playing?
+      @playing ||= false
+    end
+
+    def play_file(file)
+      unless playing?
+        @file = WaveFile::Reader.new(file, @wav_format)
+        Thread.new { bounded_produce }
+        @playing = true
+      end
+    end
+
+    def stream_named_pipe(pipe)
+      unless playing?
+        @file = File.open(pipe, 'rb')
+        spawn_thread :produce, :consume
+        @playing = true
+      end
+    end
+
+    def stop
+      if playing?
+        kill_threads
+        @encoder.reset
+        @file.close unless @file.closed?
+        @playing = false
+      end
+    end
+
+    private
+    def create_encoder(sample_rate, bitrate)
+      @encoder = Opus::Encoder.new sample_rate, sample_rate / 100, 1
+      @encoder.vbr_rate = 0 # CBR
+      @encoder.bitrate = bitrate
+    end
+
+    def change_volume(pcm_data)
+      pcm_data.unpack('s*').map { |s| s * (volume / 100.0) }.pack('s*')
+    end
+
+    def bounded_produce
+      @file.each_buffer(@encoder.frame_size) do |buffer|
+        encode_sample buffer.samples.pack('s*')
+        consume
+      end
+
+      stop
+    end
+
+    def produce
+      encode_sample @file.read(@encoder.frame_size * 2)
+    end
+
+    def encode_sample(sample)
+      pcm_data = change_volume sample
+      @queue << @encoder.encode(pcm_data, COMPRESSED_SIZE)
+    end
+
+    def consume
+      @seq ||= 0
+      @seq %= 1000000 # Keep sequence number reasonable for long runs
+
+      @pds.rewind
+      @seq += 1
+      @pds.put_int @seq
+
+      frame = @queue.pop
+      @pds.put_int frame.size
+      @pds.append_block frame
+
+      size = @pds.size
+      @pds.rewind
+      data = [@packet_header, @pds.get_block(size)].flatten.join
+      @conn.send_udp_packet data
+    end
+  end
+end

data/lib/mumble-ruby/audio_recorder.rb

@@ -0,0 +1,79 @@
+require 'wavefile'
+require 'thread'
+
+module Mumble
+  class AudioRecorder
+    include ThreadTools
+
+    def initialize(client, sample_rate)
+      @client = client
+      @wav_format = WaveFile::Format.new(:mono, :pcm_16, sample_rate)
+      @pds = PacketDataStream.new
+      @pds_lock = Mutex.new
+
+      @decoders = Hash.new do |h, k|
+        h[k] = Opus::Decoder.new sample_rate, sample_rate / 100, 1
+      end
+
+      @queues = Hash.new do |h, k|
+        h[k] = Queue.new
+      end
+    end
+
+    def recording?
+      @recording ||= false
+    end
+
+    def start(file)
+      unless recording?
+        @file = WaveFile::Writer.new(file, @wav_format)
+        @callback = @client.on_udp_tunnel { |msg| process_udp_tunnel msg }
+        spawn_thread :write_audio
+        @recording = true
+      end
+    end
+
+    def stop
+      if recording?
+        @client.remove_callback :udp_tunnel, @callback
+        kill_threads
+        @decoders.values.each &:destroy
+        @decoders.clear
+        @queues.clear
+        @file.close
+        @recording = false
+      end
+    end
+
+    private
+    def process_udp_tunnel(message)
+      @pds_lock.synchronize do
+        @pds.rewind
+        @pds.append_block message.packet[1..-1]
+
+        @pds.rewind
+        source = @pds.get_int
+        seq = @pds.get_int
+        len = @pds.get_int
+        opus = @pds.get_block len
+
+        @queues[source] << @decoders[source].decode(opus.join)
+      end
+    end
+
+    # TODO: Better audio stream merge with normalization
+    def write_audio
+      pcms = @queues.values
+        .reject { |q| q.empty? }                      # Remove empty queues
+        .map { |q| q.pop.unpack 's*' }                # Grab the top element of each queue and expand
+
+      head, *tail = pcms
+      if head
+        samples = head.zip(*tail)
+          .map { |pcms| pcms.reduce(:+) / pcms.size }   # Average together all the columns of the matrix (merge audio streams)
+          .flatten                                      # Flatten the resulting 1d matrix
+        @file.write WaveFile::Buffer.new(samples, @wav_format)
+      end
+    end
+  end
+end

data/lib/mumble-ruby/channel.rb

@@ -0,0 +1,48 @@
+module Mumble
+  class Channel < Model
+    attribute :channel_id do
+      self.data.fetch('channel_id', 0)
+    end
+    attribute :name
+    attribute :parent_id do
+      self.data['parent']
+    end
+    attribute :links do
+      self.data.fetch('links', [])
+    end
+
+    def parent
+      client.channels[parent_id]
+    end
+
+    def children
+      client.channels.values.select do |channel|
+        channel.parent_id == channel_id
+      end
+    end
+
+    def linked_channels
+      links.map do |channel_id|
+        client.channels[channel_id]
+      end
+    end
+
+    def users
+      client.users.values.select do |user|
+        user.channel_id == channel_id
+      end
+    end
+
+    def join
+      client.join_channel(self)
+    end
+
+    def send_text(string)
+      client.text_channel(self, string)
+    end
+
+    def send_image(file)
+      client.text_channel_img(self, file)
+    end
+  end
+end

data/lib/mumble-ruby/client.rb

@@ -1,4 +1,3 @@
-require 'thread'
 require 'hashie'
 
 module Mumble
@@ -7,14 +6,14 @@ module Mumble
   class NoSupportedCodec < StandardError; end
 
   class Client
-    attr_reader :users, :channels, :connected
+    include ThreadTools
+    attr_reader :users, :channels
 
     CODEC_OPUS = 4
 
     def initialize(host, port=64738, username="RubyClient", password="")
       @users, @channels = {}, {}
       @callbacks = Hash.new { |h, k| h[k] = [] }
-      @connected = false
 
       @config = Mumble.configuration.dup.tap do |c|
         c.host = host
@@ -26,91 +25,69 @@ module Mumble
     end
 
     def connect
-      cert_manager = CertManager.new(@config.username, @config.ssl_cert_opts)
       @conn = Connection.new @config.host, @config.port, cert_manager
       @conn.connect
 
-      create_encoder
+      init_callbacks
       version_exchange
       authenticate
-      init_callbacks
 
-      @read_thread = spawn_thread :read
-      @ping_thread = spawn_thread :ping
+      spawn_threads :read, :ping
+      connected? # just to get a nice return value
     end
 
     def disconnect
-      @encoder.destroy
-      @read_thread.kill
-      @ping_thread.kill
+      kill_threads
       @conn.disconnect
       @connected = false
     end
 
-    def me
-      users[@session]
+    def connected?
+      @connected ||= false
     end
 
-    def current_channel
-      channels[me.channel_id]
+    def cert_manager
+      @cert_manager ||= CertManager.new @config.username, @config.ssl_cert_opts
     end
 
-    def stream_raw_audio(file)
+    def recorder
       raise NoSupportedCodec unless @codec
-      AudioStream.new(@codec, 0, @encoder, file, @conn)
+      @recorder ||= AudioRecorder.new self, @config.sample_rate
     end
 
-    Messages.all_types.each do |msg_type|
-      define_method "on_#{msg_type}" do |&block|
-        @callbacks[msg_type] << block
-      end
-
-      define_method "send_#{msg_type}" do |opts|
-        @conn.send_message(msg_type, opts)
-      end
-    end
-
-    def mute(bool=true)
-      send_user_state self_mute: bool
+    def player
+      raise NoSupportedCodec unless @codec
+      @audio_streamer ||= AudioPlayer.new @codec, @conn, @config.sample_rate, @config.bitrate
     end
 
-    def deafen(bool=true)
-      send_user_state self_deaf: bool
+    def me
+      users[@session]
     end
 
     def join_channel(channel)
-      send_user_state({
-        session: me.session,
-        channel_id: channel_id(channel)
-      })
+      id = channel_id channel
+      send_user_state(session: @session, channel_id: id)
+      channels[id]
     end
 
     def text_user(user, string)
-      send_text_message({
-        session: [user_session(user)],
-        message: string
-      })
+      session = user_session user
+      send_text_message(session: [user_session(user)], message: string)
+      users[session]
     end
 
     def text_user_img(user, file)
-      img = ImgReader.new file
-      text_user(user, img.to_msg)
+      text_user(user, ImgReader.msg_from_file(file))
     end
 
     def text_channel(channel, string)
-      send_text_message({
-        channel_id: [channel_id(channel)],
-        message: string
-      })
+      id = channel_id channel
+      send_text_message(channel_id: [id], message: string)
+      channels[id]
     end
 
     def text_channel_img(channel, file)
-      img = ImgReader.new file
-      text_channel(channel, img.to_msg)
-    end
-
-    def user_stats(user)
-      send_user_stats session: user_session(user)
+      text_channel(channel, ImgReader.msg_from_file(file))
     end
 
     def find_user(name)
@@ -125,11 +102,21 @@ module Mumble
       @callbacks[:connected] << block
     end
 
-    private
-    def spawn_thread(sym)
-      Thread.new { loop { send sym } }
+    def remove_callback(symbol, callback)
+      @callbacks[symbol].delete callback
+    end
+
+    Messages.all_types.each do |msg_type|
+      define_method "on_#{msg_type}" do |&block|
+        @callbacks[msg_type] << block
+      end
+
+      define_method "send_#{msg_type}" do |opts|
+        @conn.send_message(msg_type, opts)
+      end
     end
 
+    private
     def read
       message = @conn.read_message
       sym = message.class.to_s.demodulize.underscore.to_sym
@@ -153,9 +140,9 @@ module Mumble
       end
       on_channel_state do |message|
         if channel = channels[message.channel_id]
-          channel.merge! message.to_hash
+          channel.update message.to_hash
         else
-          channels[message.channel_id] = Hashie::Mash.new(message.to_hash)
+          channels[message.channel_id] = Channel.new(self, message.to_hash)
         end
       end
       on_channel_remove do |message|
@@ -163,9 +150,9 @@ module Mumble
       end
       on_user_state do |message|
         if user = users[message.session]
-          user.merge! message.to_hash
+          user.update(message.to_hash)
         else
-          users[message.session] = Hashie::Mash.new(message.to_hash)
+          users[message.session] = User.new(self, message.to_hash)
         end
       end
       on_user_remove do |message|
@@ -176,15 +163,9 @@ module Mumble
       end
     end
 
-    def create_encoder
-      @encoder = Opus::Encoder.new @config.sample_rate, @config.sample_rate / 100, 1
-      @encoder.vbr_rate = 0 # CBR
-      @encoder.bitrate = @config.bitrate
-    end
-
     def version_exchange
       send_version({
-        version: encode_version(1, 2, 5),
+        version: encode_version(1, 2, 7),
         release: "mumble-ruby #{Mumble::VERSION}",
         os: %x{uname -s}.strip,
         os_version: %x{uname -v}.strip

data/lib/mumble-ruby/img_reader.rb

@@ -14,26 +14,24 @@ module Mumble
   end
 
   class ImgReader
-    attr_reader :file
-    FORMATS = %w(png jpg jpeg svg)
+    class << self
+      FORMATS = %w(png jpg jpeg svg)
 
-    def initialize(file)
-      @file = file
-      raise LoadError.new("#{file} not found") unless File.exists? file
-      raise UnsupportedImgFormat unless FORMATS.include? ext
-      raise ImgTooLarge unless File.size(file) <= 128 * 1024
-    end
-
-    def ext
-      @ext ||= File.extname(@file)[1..-1]
-    end
+      def msg_from_file(file)
+        @@file = file
+        @@ext = File.extname(@@file)[1..-1]
+        validate_file
 
-    def data
-      @data ||= File.read @file
-    end
+        data = File.read @@file
+        "<img src='data:image/#{@@ext};base64,#{Base64.encode64(data)}'/>"
+      end
 
-    def to_msg
-      "<img src='data:image/#{ext};base64,#{Base64.encode64(data)}'/>"
+      private
+      def validate_file
+        raise LoadError.new("#{@@file} not found") unless File.exists? @@file
+        raise UnsupportedImgFormat unless FORMATS.include? @@ext
+        raise ImgTooLarge unless File.size(@@file) <= 128 * 1024
+      end
     end
   end
 end

data/lib/mumble-ruby/model.rb

@@ -0,0 +1,48 @@
+require 'forwardable'
+
+module Mumble
+  class Model
+    extend ::Forwardable
+
+    class << self
+      def attribute(name, &block)
+        attributes << name
+        define_method(name) do
+          if block_given?
+            self.instance_eval(&block)
+          else
+            @data[name.to_s]
+          end
+        end
+      end
+
+      def attributes
+        @attributes ||= []
+      end
+    end
+
+    def initialize(client, data)
+      @client = client
+      @data   = data
+    end
+
+    def update(data)
+      @data.merge!(data)
+    end
+
+    def inspect
+      attrs = self.class.attributes.map do |attr|
+        [attr, send(attr)].join("=")
+      end.join(" ")
+      %Q{#<#{self.class.name} #{attrs}>}
+    end
+
+    protected def data
+      @data
+    end
+
+    protected def client
+      @client
+    end
+  end
+end

data/lib/mumble-ruby/thread_tools.rb

@@ -0,0 +1,24 @@
+module Mumble
+  module ThreadTools
+    class DuplicateThread < StandardError; end
+
+    protected
+    def spawn_thread(sym)
+      raise DuplicateThread if threads.has_key? sym
+      threads[sym] = Thread.new { loop { send sym } }
+    end
+
+    def spawn_threads(*symbols)
+      symbols.map { |sym| spawn_thread sym }
+    end
+
+    def kill_threads
+      threads.values.map(&:kill)
+      threads.clear
+    end
+
+    def threads
+      @threads ||= {}
+    end
+  end
+end

data/lib/mumble-ruby/user.rb

@@ -0,0 +1,46 @@
+module Mumble
+  class User < Model
+    attribute :session
+    attribute :actor
+    attribute :name
+    attribute :channel_id
+    attribute :hash
+    attribute :comment
+    attribute :mute
+    attribute :deaf
+    attribute :self_mute
+    attribute :self_deaf
+
+    def current_channel
+      client.channels[channel_id]
+    end
+
+    def send_text(string)
+      client.text_user(self, string)
+    end
+
+    def send_image(file)
+      client.text_user_img(self, file)
+    end
+
+    def mute(bool=true)
+      client.send_user_state self_mute: bool
+    end
+
+    def deafen(bool=true)
+      client.send_user_state self_deaf: bool
+    end
+
+    def muted?
+      !!mute || !!self_mute
+    end
+
+    def deafened?
+      !!deaf || !!self_deaf
+    end
+
+    def stats
+      client.send_user_stats session: session
+    end
+  end
+end

data/lib/mumble-ruby/version.rb

@@ -1,3 +1,3 @@
 module Mumble
-  VERSION = "1.0.2"
+  VERSION = "1.1.0"
 end

data/mumble-ruby.gemspec

@@ -19,4 +19,5 @@ Gem::Specification.new do |gem|
   gem.add_dependency "ruby_protobuf"
   gem.add_dependency "hashie"
   gem.add_dependency "opus-ruby"
+  gem.add_dependency "wavefile"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mumble-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Matthew Perry
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-26 00:00:00.000000000 Z
+date: 2014-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: wavefile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Ruby API for interacting with a mumble server
 email:
 - perrym5@rpi.edu
@@ -81,14 +95,19 @@ files:
 - README.rdoc
 - Rakefile
 - lib/mumble-ruby.rb
-- lib/mumble-ruby/audio_stream.rb
+- lib/mumble-ruby/audio_player.rb
+- lib/mumble-ruby/audio_recorder.rb
 - lib/mumble-ruby/cert_manager.rb
+- lib/mumble-ruby/channel.rb
 - lib/mumble-ruby/client.rb
 - lib/mumble-ruby/connection.rb
 - lib/mumble-ruby/img_reader.rb
 - lib/mumble-ruby/messages.rb
+- lib/mumble-ruby/model.rb
 - lib/mumble-ruby/mumble.proto
 - lib/mumble-ruby/packet_data_stream.rb
+- lib/mumble-ruby/thread_tools.rb
+- lib/mumble-ruby/user.rb
 - lib/mumble-ruby/version.rb
 - mumble-ruby.gemspec
 homepage: http://www.github.com/perrym5/mumble-ruby

data/lib/mumble-ruby/audio_stream.rb

@@ -1,67 +0,0 @@
-module Mumble
-  class AudioStream
-    attr_reader :volume
-
-    def initialize(type, target, encoder, file, connection)
-      @type = type
-      @target = target
-      @encoder = encoder
-      @file = File.open(file, 'rb')
-      @conn = connection
-      @seq = 0
-      @compressed_size = 960
-      @pds = PacketDataStream.new
-      @volume = 1.0
-
-      @queue = Queue.new
-      @producer = spawn_thread :produce
-      @consumer = spawn_thread :consume
-    end
-
-    def volume=(volume)
-      @volume = volume / 100.0
-    end
-
-    def stop
-      @producer.kill
-      @consumer.kill
-      @file.close
-    end
-
-    private
-    def change_volume(pcm_data)
-      pcm_data.unpack('s*').map { |s| s * @volume }.pack('s*')
-    end
-
-    def packet_header
-      ((@type << 5) | @target).chr
-    end
-
-    def produce
-      pcm_data = change_volume @file.read(@encoder.frame_size * 2)
-      @queue << @encoder.encode(pcm_data, @compressed_size)
-    end
-
-    def consume
-      @seq %= 1000000 # Keep sequence number reasonable for long runs
-
-      @pds.rewind
-      @seq += 1
-      @pds.put_int @seq
-
-      frame = @queue.pop
-      len = frame.size
-      @pds.put_int len
-      @pds.append_block frame
-
-      size = @pds.size
-      @pds.rewind
-      data = [packet_header, @pds.get_block(size)].flatten.join
-      @conn.send_udp_packet data
-    end
-
-    def spawn_thread(sym)
-      Thread.new { loop { send sym } }
-    end
-  end
-end