dtas 0.11.0 → 0.12.0

data/lib/dtas/unix_accepted.rb

@@ -17,55 +17,48 @@ def initialize(sock)
   def emit(msg)
     buffered = @send_buf.size
     if buffered == 0
-      begin
-        @to_io.sendmsg_nonblock(msg, Socket::MSG_EOR)
-        return :wait_readable
-      rescue Errno::EAGAIN
+      case rv = sendmsg_nonblock(msg)
+      when :wait_writable
         @send_buf << msg
-        return :wait_writable
-      rescue => e
-        return e
+        rv
+      else
+        :wait_readable
       end
-    elsif buffered > 100
-      return RuntimeError.new("too many messages buffered")
     else # buffered > 0
       @send_buf << msg
-      return :wait_writable
+      :wait_writable
     end
+  rescue => e
+    e
   end
 
   # flushes pending data if it got buffered
   def writable_iter
-    begin
-      msg = @send_buf.shift or return :wait_readable
-      @to_io.send_nonblock(msg, Socket::MSG_EOR)
-    rescue Errno::EAGAIN
-      @send_buf.unshift(msg)
-      return :wait_writable
-    rescue => e
-      return e
-    end while true
+    case sendmsg_nonblock(@send_buf[0])
+    when :wait_writable then return :wait_writable
+    else
+      @send_buf.shift
+      @send_buf.empty? ? :wait_readable : :wait_writable
+    end
+  rescue => e
+    e
   end
 
   def readable_iter
-    io = @to_io
-    nread = io.nread
+    nread = @to_io.nread
 
     # EOF, assume no spurious wakeups for SOCK_SEQPACKET
     return nil if nread == 0
 
-    begin
-      begin
-        msg, _, _ = io.recvmsg_nonblock(nread, 0, 0)
-      rescue Errno::EAGAIN
-        return :wait_readable
-      rescue EOFError, SystemCallError
-        return nil
-      end
+    case msg = recv_nonblock(nread)
+    when :wait_readable then return msg
+    when '', nil then return nil # EOF
+    else
       yield(self, msg) # DTAS::Player deals with this
-      nread = io.nread
-    end while nread > 0
-    :wait_readable
+    end
+    @send_buf.empty? ? :wait_readable : :wait_writable
+  rescue SystemCallError
+    nil
   end
 
   def close
@@ -75,4 +68,28 @@ def close
   def closed?
     @to_io.closed?
   end
+
+  if RUBY_VERSION.to_f >= 2.3
+    def sendmsg_nonblock(msg)
+      @to_io.sendmsg_nonblock(msg, Socket::MSG_EOR, exception: false)
+    end
+
+    def recv_nonblock(len)
+      @to_io.recv_nonblock(len, exception: false)
+    end
+  else
+    def sendmsg_nonblock(msg)
+      @to_io.sendmsg_nonblock(msg, Socket::MSG_EOR)
+    rescue IO::WaitWritable
+      :wait_writable
+    end
+
+    def recv_nonblock(len)
+      @to_io.recv_nonblock(len)
+    rescue IO::WaitReadable
+      :wait_readable
+    rescue EOFError
+      nil
+    end
+  end
 end

data/lib/dtas/unix_client.rb

@@ -41,6 +41,6 @@ def res_wait(timeout = nil)
     IO.select([@to_io], nil, nil, timeout)
     nr = @to_io.nread
     nr > 0 or raise EOFError, "unexpected EOF from server"
-    @to_io.recvmsg(nr, 0, 0)[0]
+    @to_io.recv(nr)
   end
 end

data/lib/dtas/unix_server.rb

@@ -58,12 +58,10 @@ def write_failed(client, e)
 
   def readable_iter
     # we do not do anything with the block passed to us
-    begin
-      sock, _ = @to_io.accept_nonblock
-      @readers[DTAS::UNIXAccepted.new(sock)] = true
-    rescue Errno::ECONNABORTED # ignore this, it happens
-    rescue Errno::EAGAIN
-      return :wait_readable
+    case rv = accept_nonblock
+    when :wait_readable then return rv
+    else
+      @readers[DTAS::UNIXAccepted.new(rv[0])] = true
     end while true
   end
 
@@ -88,9 +86,7 @@ def wait_ctl(io, err)
       # - a consumer (e.g. DTAS::Sink) just became writable, but the
       #   corresponding DTAS::Buffer was already readable in a previous
       #   call.
-    when nil
-      io.close
-    when StandardError
+    when nil, StandardError
       io.close
     else
       raise "BUG: wait_ctl invalid: #{io} #{err.inspect}"
@@ -117,4 +113,16 @@ def run_once
       wait_ctl(io, io.readable_iter { |_io, msg| yield(_io, msg) })
     end
   end
+
+  if RUBY_VERSION.to_f >= 2.3
+    def accept_nonblock
+      @to_io.accept_nonblock(exception: false)
+    end
+  else
+    def accept_nonblock
+      @to_io.accept_nonblock
+    rescue Errno::EAGAIN, Errno::ECONNABORTED, Errno::EPROTO
+      :wait_readable
+    end
+  end
 end

data/lib/dtas/watchable.rb

@@ -18,7 +18,8 @@ def self.new
     def readable_iter
       or_call = false
       while event = take(true) # drain the buffer
-        if (event.mask & FLAGS) != 0 && @watching[1] == event.name
+        w = @watches[event.wd] or next
+        if (event.mask & FLAGS) != 0 && w[event.name]
           or_call = true
         end
       end
@@ -31,19 +32,29 @@ def readable_iter
     end
 
     # we must watch the directory, since
-    def watch_file(path, blk)
+    def watch_files(paths, blk)
+      @watches = {} # wd -> { basename -> true }
       @on_readable = blk
-      @watching = File.split(File.expand_path(path))
-      add_watch(@watching[0], FLAGS)
+      @dir2wd = {}
+      Array(paths).each do |path|
+        watchdir, watchbase = File.split(File.expand_path(path))
+        wd = @dir2wd[watchdir] ||= add_watch(watchdir, FLAGS)
+        m = @watches[wd] ||= {}
+        m[watchbase] = true
+      end
     end
   end
 
   def watch_begin(blk)
     @ino = InotifyReadableIter.new
-    @ino.watch_file(@infile, blk)
+    @ino.watch_files(@watch_extra << @infile, blk)
     @ino
   end
 
+  def watch_extra(paths)
+    @ino.watch_extra(paths)
+  end
+
   # Closing the inotify descriptor (instead of using inotify_rm_watch)
   # is cleaner because it avoids EINVAL on race conditions in case
   # a directory is deleted: https://lkml.org/lkml/2007/7/9/3

data/test/test_env.rb

@@ -52,4 +52,20 @@ def test_expand
     res = env_expand({"PATH"=>"$PATH"}, expand: true)
     assert_equal ENV["PATH"], res["PATH"]
   end
+
+  def test_ary
+    ENV['HELLO'] = 'HIHI'
+    ENV['PAATH'] = '/usr/local/bin:/usr/bin:/bin'
+    env = { 'BLAH' => [ '$HELLO/WORLD', '$PAATH', '$(echo hello world)' ] }
+    res = env_expand(env, expand: true)
+    exp = [ "HIHI/WORLD", ENV['PAATH'], 'hello world' ]
+    assert_equal exp, Shellwords.split(res['BLAH'])
+    env = {
+      'BLAH' => [ '$(echo hello world)' ],
+      'MOAR' => [ '$BLAH', 'OMG HALP SPACES' ]
+    }
+    res = env_expand(env, expand: true)
+    exp = ["hello\\ world", "OMG HALP SPACES"]
+    assert_equal exp, Shellwords.split(res['MOAR'])
+  end
 end

data/test/test_mlib.rb

@@ -0,0 +1,31 @@
+# Copyright (C) 2013-2015 all contributors <dtas-all@nongnu.org>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require_relative 'helper'
+begin
+  require 'dtas/mlib'
+  require 'sequel/no_core_ext'
+  require 'sqlite3'
+rescue LoadError => err
+  warn "skipping mlib test: #{err.message}"
+  exit 0
+end
+
+class TestMlib < Testcase
+  def setup
+    @db = Sequel.sqlite(':memory:')
+  end
+
+  def test_migrate
+    ml = DTAS::Mlib.new(@db)
+    begin
+      $-w = false
+      ml.migrate
+      tables = @db.tables
+    ensure
+      $-w = true
+    end
+    [ :nodes, :tags, :vals, :comments ].each do |t|
+      assert tables.include?(t), "missing #{t}"
+    end
+  end
+end

data/test/test_parse_freq.rb

@@ -0,0 +1,18 @@
+# Copyright (C) 2015 all contributors <dtas-all@nongnu.org>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require './test/helper'
+
+require 'dtas/parse_freq'
+
+class TestParseFreq < Testcase
+  include DTAS::ParseFreq
+
+  def test_parse_freq
+    assert_equal(4000, parse_freq('4k'))
+    assert_equal(-4000, parse_freq('-4k'))
+    assert_equal(-4900, parse_freq('-4.9k'))
+    assert_equal(-4900, parse_freq('-4.9k', :int))
+
+    assert_equal(4900.5, parse_freq('4.9005k', :float))
+  end
+end

data/test/test_player_client_handler.rb

@@ -19,23 +19,23 @@ def setup
   def test_delete
     @sinks["default"] = DTAS::Sink.new
     @targets = []
-    sink_handler(@io, %w(rm default))
+    dpc_sink(@io, %w(rm default))
     assert @sinks.empty?
     assert_equal %w(OK), @io.to_a
   end
 
   def test_delete_noexist
-    sink_handler(@io, %w(rm default))
+    dpc_sink(@io, %w(rm default))
     assert @sinks.empty?
     assert_equal ["ERR default not found"], @io.to_a
   end
 
   def test_env
-    sink_handler(@io, %w(ed default env.FOO=bar))
+    dpc_sink(@io, %w(ed default env.FOO=bar))
     assert_equal "bar", @sinks["default"].env["FOO"]
-    sink_handler(@io, %w(ed default env.FOO=))
+    dpc_sink(@io, %w(ed default env.FOO=))
     assert_equal "", @sinks["default"].env["FOO"]
-    sink_handler(@io, %w(ed default env#FOO))
+    dpc_sink(@io, %w(ed default env#FOO))
     assert_nil @sinks["default"].env["FOO"]
   end
 
@@ -47,12 +47,12 @@ def test_sink_ed
       --disable-format --disable-resample --disable-channels \
       -t raw -c $SINK_CHANNELS -f S${SINK_BITS}_3LE -r $SINK_RATE
     '
-    sink_handler(@io, %W(ed foo command=#{command}))
+    dpc_sink(@io, %W(ed foo command=#{command}))
     assert_equal command, @sinks["foo"].command
     assert_empty @sinks["foo"].env
-    sink_handler(@io, %W(ed foo env.SINK_BITS=24))
-    sink_handler(@io, %W(ed foo env.SINK_CHANNELS=2))
-    sink_handler(@io, %W(ed foo env.SINK_RATE=48000))
+    dpc_sink(@io, %W(ed foo env.SINK_BITS=24))
+    dpc_sink(@io, %W(ed foo env.SINK_CHANNELS=2))
+    dpc_sink(@io, %W(ed foo env.SINK_RATE=48000))
     expect = {
       "SINK_BITS" => "24",
       "SINK_CHANNELS" => "2",
@@ -68,7 +68,7 @@ def test_cat
     sink.name = "default"
     sink.command += "dither -s"
     @sinks["default"] = sink
-    sink_handler(@io, %W(cat default))
+    dpc_sink(@io, %W(cat default))
     assert_equal 1, @io.size
     hsh = YAML.load(@io[0])
     assert_kind_of Hash, hsh
@@ -79,12 +79,12 @@ def test_cat
   def test_ls
     expect = %w(a b c d)
     expect.each { |s| @sinks[s] = true }
-    sink_handler(@io, %W(ls))
+    dpc_sink(@io, %W(ls))
     assert_equal expect, Shellwords.split(@io[0])
   end
 
   def test_env_dump
-    env_handler(@io, [])
+    dpc_env(@io, [])
     res = @io[0]
     result = {}
     Shellwords.split(res).each do |kv|

data/test/test_splitfx.rb

@@ -70,35 +70,6 @@ def test_example
 
         cmp = "cmp result.s32 expect.s32"
         assert system(cmp), cmp
-
-        # try Ogg Opus, use opusenc/opusdec for now since that's available
-        # in Debian 7.0 (sox.git currently has opusfile support, but that
-        # hasn't made it into Debian, yet)
-        if `which opusenc 2>/dev/null`.size > 0 &&
-           `which opusdec 2>/dev/null`.size > 0
-          WAIT_ALL_MTX.synchronize do
-            tmp_err('opus.err.txt') { sfx.run("opusenc", opts) }
-          end
-          assert_contains_stats('opus.err.txt')
-
-          # ensure opus lengths match flac ones, we decode using opusdec
-          # since sox does not yet have opus support in Debian 7.0
-          %w(1 2).each do |nr|
-            cmd = "opusdec #{nr}.opus #{nr}.wav 2>/dev/null"
-            assert system(cmd), cmd
-            assert_equal `soxi -D #{nr}.flac`, `soxi -D #{nr}.wav`
-          end
-
-          # ensure 16/44.1kHz FLAC works (CDDA-like)
-          File.unlink('1.flac', '2.flac')
-          WAIT_ALL_MTX.synchronize do
-            tmp_err('flac-cdda.err.txt') { sfx.run("flac-cdda", opts) }
-          end
-          assert_contains_stats('flac-cdda.err.txt')
-          %w(1 2).each do |nr|
-            assert_equal `soxi -D #{nr}.flac`, `soxi -D #{nr}.wav`
-          end
-        end
       end
     end
   end

data/test/test_tracklist.rb

@@ -3,10 +3,19 @@
 require_relative 'helper'
 require 'dtas/tracklist'
 class TestTracklist < Testcase
+
+  def list_to_path(tl)
+    tl.instance_variable_get(:@list).map(&:to_path)
+  end
+
+  def list_add(tl, ary)
+    ary.reverse_each { |x| tl.add_track(x) }
+  end
+
   def test_tl_add_tracks
     tl = DTAS::Tracklist.new
     tl.add_track("/foo.flac")
-    assert_equal(%w(/foo.flac), tl.instance_variable_get(:@list))
+    assert_equal(%w(/foo.flac), list_to_path(tl))
 
     oids = tl.tracks
     assert_kind_of Array, oids
@@ -14,26 +23,24 @@ def test_tl_add_tracks
     assert_equal [ [ oids[0], "/foo.flac" ] ], tl.get_tracks(oids)
 
     tl.add_track("/bar.flac")
-    assert_equal(%w(/bar.flac /foo.flac), tl.instance_variable_get(:@list))
+    assert_equal(%w(/bar.flac /foo.flac), list_to_path(tl))
 
     tl.add_track("/after.flac", oids[0])
-    assert_equal(%w(/bar.flac /foo.flac /after.flac),
-                 tl.instance_variable_get(:@list))
+    assert_equal(%w(/bar.flac /foo.flac /after.flac), list_to_path(tl))
   end
 
   def test_add_current
     tl = DTAS::Tracklist.new
-    tl.instance_variable_get(:@list).replace(%w(a b c d e f g))
+    list_add(tl, %w(a b c d e f g))
     tl.add_track('/foo.flac', nil, true)
-    assert_equal '/foo.flac', tl.cur_track
+    assert_equal '/foo.flac', tl.cur_track.to_path
   end
 
   def test_advance_track
     tl = DTAS::Tracklist.new
-    tl.instance_variable_get(:@list).replace(%w(a b c d e f g))
-    %w(a b c d e f g).each do |t|
-      assert_equal t, tl.advance_track[0]
-    end
+    ary = %w(a b c d e f g)
+    list_add(tl, ary)
+    ary.each { |t| assert_equal t, tl.advance_track[0] }
     assert_nil tl.advance_track
     tl.repeat = true
     assert_equal 'a', tl.advance_track[0]
@@ -46,7 +53,7 @@ def _build_mapping(tl)
 
   def test_goto
     tl = DTAS::Tracklist.new
-    tl.instance_variable_get(:@list).replace(%w(a b c d e f g))
+    list_add(tl, %w(a b c d e f g))
     mapping = _build_mapping(tl)
     assert_equal 'f', tl.go_to(mapping['f'])
     assert_equal 'f', tl.advance_track[0]
@@ -54,23 +61,74 @@ def test_goto
     assert_equal 'g', tl.advance_track[0]
   end
 
+  def test_shuffle
+    tl = DTAS::Tracklist.new
+    exp = %w(a b c d e f g)
+    list_add(tl, exp)
+    tl.shuffle = true
+    assert_equal(exp, list_to_path(tl))
+    assert_equal exp.size, tl.shuffle.size
+    assert_equal exp, tl.shuffle.map(&:to_path).sort
+    tl.shuffle = false
+    assert_equal false, tl.shuffle
+
+    tl.instance_variable_set :@pos, 3
+    assert_equal false, tl.shuffle = false
+
+    before = tl.cur_track
+    3.times do
+      tl.shuffle = true
+      assert_equal before, tl.cur_track
+    end
+    x = tl.to_hsh
+    assert_equal true, x['shuffle']
+    3.times do
+      loaded = DTAS::Tracklist.load(x.dup)
+      assert_equal before.to_path, loaded.cur_track.to_path
+    end
+  end
+
   def test_remove_track
     tl = DTAS::Tracklist.new
-    tl.instance_variable_get(:@list).replace(%w(a b c d e f g))
+    ary = %w(a b c d e f g)
+    list_add(tl, ary)
     mapping = _build_mapping(tl)
-    %w(a b c d e f g).each { |t| assert_kind_of Integer, mapping[t] }
+    ary.each { |t| assert_kind_of Integer, mapping[t] }
 
     tl.remove_track(mapping['a'])
-    assert_equal %w(b c d e f g), tl.instance_variable_get(:@list)
+    assert_equal %w(b c d e f g), list_to_path(tl)
 
     tl.remove_track(mapping['d'])
-    assert_equal %w(b c e f g), tl.instance_variable_get(:@list)
+    assert_equal %w(b c e f g), list_to_path(tl)
 
     tl.remove_track(mapping['g'])
-    assert_equal %w(b c e f), tl.instance_variable_get(:@list)
+    assert_equal %w(b c e f), list_to_path(tl)
 
     # it'll be a while before OIDs require >128 bits, right?
     tl.remove_track(1 << 128)
-    assert_equal %w(b c e f), tl.instance_variable_get(:@list), "no change"
+    assert_equal %w(b c e f), list_to_path(tl), "no change"
+  end
+
+  def test_max
+    tl = DTAS::Tracklist.new
+    assert_kind_of Integer, tl.add_track('z')
+    assert_kind_of Integer, tl.max
+    tl.max = 1
+    assert_equal false, tl.add_track('y')
+    assert_equal 1, tl.instance_variable_get(:@list).size
+    tl.max = 2
+    assert_kind_of Integer, tl.add_track('y')
+    assert_equal 2, tl.instance_variable_get(:@list).size
+  end
+
+  def test_swap
+    tl = DTAS::Tracklist.new
+    list_add(tl, %w(a b c d e f g))
+    mapping = _build_mapping(tl)
+    assert tl.swap(mapping['a'], mapping['g'])
+    assert_equal %w(g b c d e f a), list_to_path(tl)
+
+    assert_nil tl.swap(-2, -3), 'no swap on invalid'
+    assert_equal %w(g b c d e f a), list_to_path(tl)
   end
 end