dtas 0.0.0

data/TODO

@@ -0,0 +1,4 @@
+* _limited_ frontends for MPRIS/mpd/whatever-standards-are-in-use-today
+  Obviously we can't have untrusted users executing arbitrary commands
+
+* tests for bin/*

data/bin/dtas-console

@@ -0,0 +1,160 @@
+#!/usr/bin/env ruby
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+#
+# Note: no idea what I'm doing, especially w.r.t. curses
+require 'dtas/unix_client'
+require 'curses'
+require 'yaml'
+
+w = DTAS::UNIXClient.new
+w.req_ok('watch')
+c = DTAS::UNIXClient.new
+cur = YAML.load(c.req('current'))
+readable = [ w, $stdin ]
+
+def update_tfmt(prec)
+  prec == 0 ? '%H:%M:%S' : "%H:%M:%S.%#{prec}N"
+end
+trap(:INT) { exit(0) }
+trap(:TERM) { exit(0) }
+
+# time precision
+prec_nr = 1
+prec_step = (0..9).to_a
+prec_max = prec_step.size - 1
+tfmt = update_tfmt(prec_step[prec_nr])
+events = []
+interval = 1.0 / 10 ** prec_nr
+
+def show_events(lineno, screen, events)
+  Curses.setpos(lineno += 1, 0)
+  Curses.clrtoeol
+  Curses.addstr('Events:')
+  maxy = screen.maxy - 1
+  maxx = screen.maxx
+  events.reverse_each do |e|
+    Curses.setpos(lineno += 1, 0)
+    Curses.clrtoeol
+    extra = e.size/maxx
+    break if (lineno + extra) >= maxy
+
+    # deal with long lines
+    if extra
+      rewind = lineno
+      extra.times do
+        Curses.setpos(lineno += 1, 0)
+        Curses.clrtoeol
+      end
+      Curses.setpos(rewind, 0)
+      Curses.addstr(e)
+      Curses.setpos(lineno, 0)
+    else
+      Curses.addstr(e)
+    end
+  end
+
+  # discard events we can't show
+  nr_events = events.size
+  if nr_events > maxy
+    events = events[(nr_events - maxy)..-1]
+    until lineno >= screen.maxy
+      Curses.setpos(lineno += 1, 0)
+      Curses.clrtoeol
+    end
+  else
+    Curses.setpos(maxy + 1, 0)
+    Curses.clrtoeol
+  end
+end
+
+begin
+  Curses.init_screen
+  Curses.nonl
+  Curses.cbreak
+  Curses.noecho
+  screen = Curses.stdscr
+  screen.scrollok(true)
+  screen.keypad(true)
+  loop do
+    lineno = -1
+    if current = cur['current']
+      Curses.setpos(lineno += 1, 0)
+      Curses.clrtoeol
+      Curses.addstr(current['infile'] || current['command'])
+
+      elapsed = Time.now.to_f - current['spawn_at']
+      if (nr = cur['current_initial']) && (current_format = current['format'])
+        rate = current_format['rate'].to_f
+        elapsed += nr / rate
+        total = " [#{Time.at(current['samples'] / rate).strftime(tfmt)}]"
+      else
+        total = ""
+      end
+
+      Curses.setpos(lineno += 1, 0)
+      Curses.clrtoeol
+      Curses.addstr("#{Time.at(elapsed).strftime(tfmt)}#{total}")
+    else
+      Curses.setpos(lineno += 1, 0)
+      Curses.clrtoeol
+      Curses.addstr(cur['paused'] ? 'paused' : 'idle')
+      Curses.setpos(lineno += 1, 0)
+      Curses.clrtoeol
+    end
+
+    show_events(lineno, screen, events)
+
+    Curses.refresh # draw and wait
+    r = IO.select(readable, nil, nil, current ? interval : nil) or next
+    r[0].each do |io|
+      case io
+      when w
+        event = w.res_wait
+        events << "#{Time.now.strftime(tfmt)} #{event}"
+        # something happened, refresh current
+        # we could be more intelligent here, maybe, but too much work.
+        cur = YAML.load(c.req('current'))
+      when $stdin
+        # keybindings taken from mplayer / vi
+        case key = Curses.getch
+        when "j" then c.req_ok("seek +5")
+        when "k" then c.req_ok("seek -5")
+        when Curses::KEY_DOWN then c.req_ok("seek -60")
+        when Curses::KEY_UP then c.req_ok("seek +60")
+        when Curses::KEY_LEFT then c.req_ok("seek -10")
+        when Curses::KEY_RIGHT then c.req_ok("seek +10")
+        when Curses::KEY_BACKSPACE then c.req_ok("seek 0")
+        # yes, some of us have long audio files
+        when Curses::KEY_PPAGE then c.req_ok("seek +600")
+        when Curses::KEY_NPAGE then c.req_ok("seek -600")
+        when " "
+          c.req("play_pause")
+        when "p" # lower precision of time display
+          if prec_nr >= 1
+            prec_nr -= 1
+            tfmt = update_tfmt(prec_step[prec_nr])
+            interval = 1.0 / 10 ** prec_nr
+          end
+        when "P" # increase precision of time display
+          if prec_nr < prec_max
+            prec_nr += 1
+            tfmt = update_tfmt(prec_step[prec_nr])
+            interval = 1.0 / 10 ** prec_nr
+          end
+        when 27 # TODO readline/edit mode?
+        else
+          Curses.setpos(screen.maxy - 1, 0)
+          Curses.clrtoeol
+          Curses.addstr("unknown key=#{key.inspect}")
+        end
+      end
+    end
+  end
+rescue EOFError
+  Curses.close_screen
+  abort "dtas-player exited"
+ensure
+  Curses.close_screen
+end

data/bin/dtas-ctl

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require 'dtas/unix_client'
+
+# Unix paths are encoding agnostic
+ARGV.map! { |arg| arg.b }
+c = DTAS::UNIXClient.new
+puts c.req(ARGV)

data/bin/dtas-cueedit

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require 'tempfile'
+require 'shellwords'
+usage = "Usage: #$0 FILENAME"
+editor = ENV["VISUAL"] || ENV["EDITOR"]
+ARGV.size > 0 or abort usage
+
+def err_msg(cmd, status)
+  err_cmd = cmd.map { |f| Shellwords.escape(f) }.join(' ')
+  "E: #{err_cmd} failed: #{status.inspect}"
+end
+
+def x!(*cmd)
+  system(*cmd) or abort err_msg(cmd, $?)
+end
+
+def tmpfile(file, suffix)
+  tmp = Tempfile.new([File.basename(file), suffix])
+  tmp.sync = true
+  tmp.binmode
+  tmp
+end
+
+ARGV.each do |file|
+  # Unix paths are encoding agnostic
+  file = file.b
+  file =~ /\.flac\z/i or warn "Unsupported suffix, assuming FLAC"
+  tmp = tmpfile(file, '.cue')
+  begin
+    # export the temporary file for the user to edit
+    if system(*%W(metaflac --export-cuesheet-to=#{tmp.path} #{file}))
+      remove_existing = true
+      backup = tmpfile(file, '.backup.cue')
+    else
+      remove_existing = false
+      backup = nil
+      tmp.puts 'FILE "dtas-cueedit.tmp.flac" FLAC'
+      tmp.puts '  TRACK 01 AUDIO'
+      tmp.puts '    INDEX 01 00:00:00'
+    end
+
+    # keep a backup, in case the user screws up the edit
+    original = File.binread(tmp.path)
+    backup.write(original) if backup
+
+    # user edits the file
+    x!("#{editor} #{tmp.path}")
+
+    # avoid an expensive update if the user didn't change anything
+    current = File.binread(tmp.path)
+    if current == original
+      $stderr.puts "tags for #{Shellwords.escape(file)} unchanged" if $DEBUG
+      next
+    end
+
+    # we must remove existing tags before importing again
+    if remove_existing
+      x!(*%W(metaflac --remove --block-type=CUESHEET #{file}))
+    end
+
+    # try to import the new file but restore from the original backup if the
+    # user wrote an improperly formatted cue sheet
+    cmd = %W(metaflac --import-cuesheet-from=#{tmp.path} #{file})
+    if ! system(*cmd) && backup
+      warn err_msg(cmd, $?)
+      warn "E: restoring original from backup"
+      x!(*%W(metaflac --import-cuesheet-from=#{backup.path} #{file}))
+      warn "E: backup cuesheet restored, #{Shellwords.escape(file)} unchanged"
+      exit(false)
+    end
+  ensure
+    tmp.close!
+    backup.close! if backup
+  end
+end

data/bin/dtas-enq

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require 'dtas/unix_client'
+c = DTAS::UNIXClient.new
+
+ARGV.each do |path|
+  # Unix paths are encoding agnostic
+  path = File.expand_path(path.b)
+  res = c.req_ok(%W(enq #{path}))
+  puts "#{path} #{res}"
+end

data/bin/dtas-msinkctl

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require 'yaml'
+require 'dtas/unix_client'
+usage = "#$0 <active-set|active-add|active-sub|nonblock|active> SINK"
+c = DTAS::UNIXClient.new
+action = ARGV.shift
+sink_args = ARGV
+
+buf = c.req("sink ls")
+abort(buf) if buf =~ /\AERR/
+player_sinks = buf.split(/ /)
+
+non_existent = sink_args - player_sinks
+non_existent[0] and
+  abort "non-existent sink(s): #{non_existent.join(' ')}"
+
+def activate_sinks(c, sink_names)
+  sink_names.each { |name| c.req_ok("sink ed #{name} active=true") }
+end
+
+def deactivate_sinks(c, sink_names)
+  sink_names.each { |name| c.req_ok("sink ed #{name} active=false") }
+end
+
+def filter(c, player_sinks, key)
+  rv = []
+  player_sinks.each do |name|
+    buf = c.req("sink cat #{name}")
+    sink = YAML.load(buf)
+    rv << sink["name"] if sink[key]
+  end
+  rv
+end
+
+case action
+when "active-set"
+  activate_sinks(c, sink_args)
+  deactivate_sinks(c, player_sinks - sink_args)
+when "active-add" # idempotent
+  activate_sinks(c, sink_args)
+when "active-sub"
+  deactivate_sinks(c, sink_args)
+when "active", "nonblock"
+  abort "`#$0 #{action}' takes no arguments" if sink_args[0]
+  puts filter(c, player_sinks, action).join(' ')
+else
+  abort usage
+end

data/bin/dtas-player

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+Thread.abort_on_exception = $stderr.sync = $stdout.sync = true
+require 'yaml'
+require 'dtas/player'
+sock = (ENV["DTAS_PLAYER_SOCK"] ||
+        File.expand_path("~/.dtas/player.sock")).b
+state = (ENV["DTAS_PLAYER_STATE"] ||
+         File.expand_path("~/.dtas/player_state.yml")).b
+[ sock, state ].each do |file|
+  dir = File.dirname(file)
+  next if File.directory?(dir)
+  require 'fileutils'
+  FileUtils.mkpath(dir)
+end
+
+state = DTAS::StateFile.new(state)
+if tmp = state.tryload
+  tmp["socket"] ||= sock
+  player = DTAS::Player.load(tmp)
+  player.state_file ||= state
+else
+  player = DTAS::Player.new
+  player.state_file = state
+  player.socket = sock
+end
+
+at_exit { player.close }
+player.bind
+trap(:INT) { exit }
+trap(:TERM) { exit }
+player.run

data/bin/dtas-sinkedit

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require 'dtas/unix_client'
+require 'dtas/disclaimer'
+require 'tempfile'
+require 'yaml'
+editor = ENV["VISUAL"] || ENV["EDITOR"]
+c = DTAS::UNIXClient.new
+usage = "#$0 SINKNAME"
+ARGV.size == 1 or abort usage
+name = ARGV[0]
+
+tmp = Tempfile.new(%w(dtas-sinkedit .yml))
+tmp.sync = true
+tmp.binmode
+
+buf = c.req(%W(sink cat #{name}))
+abort(buf) if buf =~ /\AERR/
+orig = YAML.load(buf)
+
+tmp.write(buf << DTAS_DISCLAIMER)
+cmd = "#{editor} #{tmp.path}"
+system(cmd) or abort "#{cmd} failed: #$?"
+tmp.rewind
+sink = YAML.load(tmp.read)
+
+cmd = %W(sink ed #{name})
+if env = sink["env"]
+  env.each do |k,v|
+    cmd << (v.nil? ? "env##{k}" : "env.#{k}=#{v}")
+  end
+end
+
+# remove deleted env
+if orig_env = orig["env"]
+  env ||= {}
+  deleted_keys = orig_env.keys - env.keys
+  deleted_keys.each { |k| cmd << "env##{k}" }
+end
+
+%w(nonblock active).each do |field|
+  if sink.key?(field)
+    cmd << "#{field}=#{sink[field] ? 'true' : 'false'}"
+  end
+end
+
+%w(prio pipe_size).each do |field|
+  value = sink[field] and cmd << "#{field}=#{value}"
+end
+
+%w(command).each do |field|
+  value = sink[field]
+  cmd << "#{field}=#{value}"
+end
+
+c.req_ok(cmd)

data/bin/dtas-sourceedit

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require 'tempfile'
+require 'yaml'
+require 'dtas/unix_client'
+require 'dtas/disclaimer'
+editor = ENV["VISUAL"] || ENV["EDITOR"]
+c = DTAS::UNIXClient.new
+usage = $0
+ARGV.size == 0 or abort usage
+name = ARGV[0]
+
+tmp = Tempfile.new(%w(dtas-sourceedit .yml))
+tmp.sync = true
+tmp.binmode
+
+buf = c.req(%W(source cat))
+abort(buf) if buf =~ /\AERR/
+orig = YAML.load(buf)
+
+tmp.write(buf << DTAS_DISCLAIMER)
+cmd = "#{editor} #{tmp.path}"
+system(cmd) or abort "#{cmd} failed: #$?"
+tmp.rewind
+source = YAML.load(tmp.read)
+
+cmd = %W(source ed)
+if env = source["env"]
+  env.each do |k,v|
+    cmd << (v.nil? ? "env##{k}" : "env.#{k}=#{v}")
+  end
+end
+
+# remove deleted env
+if orig_env = orig["env"]
+  env ||= {}
+  deleted_keys = orig_env.keys - env.keys
+  deleted_keys.each { |k| cmd << "env##{k}" }
+end
+
+%w(command).each do |field|
+  value = source[field]
+  cmd << "#{field}=#{value}"
+end
+
+c.req_ok(cmd)