muzak 0.0.1

data/lib/muzak/const.rb

@@ -0,0 +1,14 @@
+module Muzak
+  VERSION = "0.0.1".freeze
+
+  CONFIG_DIR = File.expand_path("~/.config/muzak").freeze
+  CONFIG_FILE = File.join(CONFIG_DIR, "muzak.yml").freeze
+  INDEX_FILE = File.join(CONFIG_DIR, "index.yml").freeze
+  PLAYLIST_DIR = File.join(CONFIG_DIR, "playlists").freeze
+
+  PLUGIN_EVENTS = [
+    :player_activated,
+    :player_deactivated,
+    :song_loaded
+  ]
+end

data/lib/muzak/index.rb

@@ -0,0 +1,84 @@
+module Muzak
+  class Index
+    include Utils
+    attr_accessor :hash
+
+    def self.load_index(file)
+      instance = allocate
+      instance.hash = YAML::load_file(file)
+
+      instance
+    end
+
+    def initialize(tree)
+      @hash = {
+        "timestamp" => Time.now.to_i,
+        "artists" => {}
+      }
+
+      Dir.entries(tree).each do |artist|
+        next unless File.directory?(File.join(tree, artist))
+        next if artist.start_with?(".")
+
+        @hash["artists"][artist] = {}
+        @hash["artists"][artist]["albums"] = {}
+
+        Dir.entries(File.join(tree, artist)).each do |album|
+          next if album.start_with?(".")
+
+          @hash["artists"][artist]["albums"][album] = {}
+          @hash["artists"][artist]["albums"][album]["songs"] = []
+
+          Dir.glob(File.join(tree, artist, album, "**")) do |file|
+            @hash["artists"][artist]["albums"][album]["cover"] = file if album_art?(file)
+            @hash["artists"][artist]["albums"][album]["songs"] << file if music?(file)
+          end
+
+          @hash["artists"][artist]["albums"][album]["songs"].sort!
+        end
+      end
+    end
+
+    def artists
+      @hash["artists"].keys
+    end
+
+    def albums
+      albums_hash = {}
+
+      artists.each do |a|
+        @hash["artists"][a]["albums"].keys.each do |ak|
+          albums_hash[ak] = @hash["artists"][a]["albums"][ak]
+        end
+      end
+
+      albums_hash
+    end
+
+    def album_names
+      artists.map { |a| @hash["artists"][a]["albums"].keys }.flatten
+    end
+
+    def albums_by(artist)
+      error "no such artist: '#{artist}'" unless @hash["artists"].key?(artist)
+
+      begin
+        @hash["artists"][artist]["albums"]
+      rescue Exception => e
+        {}
+      end
+    end
+
+    def songs_by(artist)
+      error "no such artist: '#{artist}'" unless @hash["artists"].key?(artist)
+
+      begin
+        albums_by(artist).map do |_, album|
+          album["songs"].map { |s| File.basename(s) }.sort
+        end.flatten
+      rescue Exception => e
+        []
+      end
+    end
+  end
+end

data/lib/muzak/instance.rb

@@ -0,0 +1,47 @@
+module Muzak
+  class Instance
+    include Cmd
+    include Utils
+
+    def method_missing(meth, *args)
+      warn "unknown command: #{Cmd.resolve_method(meth)}"
+      help
+    end
+
+    attr_reader :config, :player, :index, :playlist
+
+    def initialize(opts = {})
+      $debug = opts[:debug]
+      $verbose = opts[:verbose]
+
+      debug "muzak is starting..."
+
+      _config_init unless _config_available?
+      config_load
+
+      index_build unless _index_available?
+      index_load
+
+      @player = Player::PLAYER_MAP[@config["player"]].new(self)
+
+      playlist_load @config["default-playlist"] if @config["default-playlist"]
+
+      @plugins = initialize_plugins!
+    end
+
+    def initialize_plugins!
+      pks = Plugin.plugin_classes.select { |pk| _config_plugin? pk.plugin_name }
+      pks.map { |pk| pk.new(self) }
+    end
+
+    def event(type, *args)
+      return unless PLUGIN_EVENTS.include?(type)
+
+      @plugins.each do |plugin|
+        Thread.new do
+          plugin.send(type, *args)
+        end.join
+      end
+    end
+  end
+end

data/lib/muzak/player.rb

@@ -0,0 +1,13 @@
+# we have to require StubPlayer first because ruby's module resolution is bad
+require_relative "player/stub_player"
+
+Dir.glob(File.join(__dir__, "player/*")) { |file| require_relative file }
+
+module Muzak
+  module Player
+    PLAYER_MAP = {
+      "stub" => Player::StubPlayer,
+      "mpv" => Player::MPV
+    }
+  end
+end

data/lib/muzak/player/mpv.rb

@@ -0,0 +1,222 @@
+require "tempfile"
+require "socket"
+require "json"
+require "thread"
+
+module Muzak
+  module Player
+    class MPV < StubPlayer
+      def running?
+        begin
+          !!@pid && Process.waitpid(@pid, Process::WNOHANG).nil?
+        rescue Errno::ECHILD
+          false
+        end
+      end
+
+      def activate!
+        return if running?
+
+        debug "activating #{self.class}"
+
+        @sock_path = Dir::Tmpname.make_tmpname("/tmp/mpv", ".sock")
+        mpv_args = [
+          "--idle",
+          "--no-osc",
+          "--no-osd-bar",
+          "--no-input-default-bindings",
+          "--no-input-cursor",
+          "--no-terminal",
+          "--load-scripts=no", # autoload and other scripts with clobber our mpv management
+          "--input-ipc-server=%{socket}" % { socket: @sock_path }
+        ]
+
+        mpv_args << "--geometry=#{instance.config["art-geometry"]}" if instance.config["art-geometry"]
+
+        @pid = Process.spawn("mpv", *mpv_args)
+
+        until File.exists?(@sock_path)
+          sleep 0.1
+        end
+
+        @socket = UNIXSocket.new(@sock_path)
+
+        @command_queue = Queue.new
+        @result_queue = Queue.new
+        @event_queue = Queue.new
+
+        @command_thread = Thread.new { pump_commands! }
+        @results_thread = Thread.new { pump_results! }
+        @events_thread = Thread.new { dispatch_events! }
+
+        instance.event :player_activated
+      end
+
+      def deactivate!
+        return unless running?
+
+        debug "deactivating #{self.class}"
+
+        command "quit"
+
+        Process.kill :TERM, @pid
+        Process.wait @pid
+        @pid = nil
+
+        @socket.close
+      ensure
+        instance.event :player_deactivated
+        File.delete(@sock_path) if @sock_path && File.exists?(@sock_path)
+      end
+
+      def play
+        return unless running?
+
+        set_property "pause", false
+      end
+
+      def pause
+        return unless running?
+
+        set_property "pause", true
+      end
+
+      def playing?
+        return false unless running?
+
+        !get_property "pause"
+      end
+
+      def next_song
+        command "playlist-next"
+      end
+
+      def previous_song
+        command "playlist-prev"
+      end
+
+      def enqueue_song(song)
+        activate! unless running?
+
+        load_song song, song.best_guess_album_art
+      end
+
+      def enqueue_album(album)
+        activate! unless running?
+
+        album.songs.each do |song|
+          load_song song, album.cover_art
+        end
+      end
+
+      def enqueue_playlist(playlist)
+        activate! unless running?
+
+        playlist.songs.each do |song|
+          load_song song, song.best_guess_album_art
+        end
+      end
+
+      def list_queue
+        entries = get_property "playlist/count"
+
+        playlist = []
+
+        entries.times do |i|
+          playlist << Song.new(get_property("playlist/#{i}/filename"))
+        end
+
+        playlist
+      end
+
+      def shuffle_queue
+        command "playlist-shuffle"
+      end
+
+      def clear_queue
+        command "playlist-clear"
+      end
+
+      def now_playing
+        Song.new(get_property "path")
+      end
+
+      private
+
+      def load_song(song, art)
+        cmds = ["loadfile", song.path, "append-play"]
+        cmds << "external-file=#{art}" if art
+        command *cmds
+      end
+
+      def pump_commands!
+        loop do
+          begin
+            @socket.puts(@command_queue.pop)
+          rescue EOFError # the player is deactivating
+            Thread.exit
+          end
+        end
+      end
+
+      def pump_results!
+        loop do
+          begin
+            response = JSON.parse(@socket.readline)
+
+            if response["event"]
+              @event_queue << response["event"]
+            else
+              @result_queue << response
+            end
+          rescue EOFError # the player is deactivating
+            Thread.exit
+          end
+        end
+      end
+
+      def dispatch_events!
+        loop do
+          event = @event_queue.pop
+
+          Thread.new do
+            case event
+            when "file-loaded"
+              # this really isn't ideal, since we already have access
+              # to Song objects earlier in the object's lifetime.
+              # the "correct" way to do this would be to sync an external
+              # playlist with mpv's internal one and access that instead
+              # of re-creating the Song from mpv properties.
+              # another idea: serialize Song objects into mpv's properties
+              # somehow.
+              song = Song.new(get_property "path")
+              instance.event :song_loaded, song
+            end
+          end
+        end
+      end
+
+      def command(*args)
+        return unless running?
+
+        payload = {
+          "command" => args
+        }
+
+        debug "mpv payload: #{payload.to_s}"
+
+        @command_queue << JSON.generate(payload)
+
+        @result_queue.pop
+      end
+
+      def set_property(*args)
+        command "set_property", *args
+      end
+
+      def get_property(*args)
+        command("get_property", *args)["data"]
+      end
+    end
+  end
+end

data/lib/muzak/player/stub_player.rb

@@ -0,0 +1,69 @@
+module Muzak
+  module Player
+    class StubPlayer
+      include Utils
+
+      attr_reader :instance
+
+      def initialize(instance)
+        @instance = instance
+      end
+
+      def running?
+        debug "#running?"
+      end
+
+      def activate!
+        debug "#activate!"
+      end
+
+      def deactivate!
+        debug "#deactivate!"
+      end
+
+      def play
+        debug "#play"
+      end
+
+      def pause
+        debug "#pause"
+      end
+
+      def next_song
+        debug "#next_song"
+      end
+
+      def previous_song
+        debug "#previous_song"
+      end
+
+      def enqueue_song(song)
+        debug "#enqueue_song"
+      end
+
+      def enqueue_album(album)
+        debug "#enqueue_album"
+      end
+
+      def enqueue_playlist(playlist)
+        debug "#enqueue_playlist"
+      end
+
+      def list_queue
+        debug "#list_queue"
+      end
+
+      def shuffle_queue
+        debug "#shuffle_queue"
+      end
+
+      def clear_queue
+        debug "#clear_queue"
+      end
+
+      def now_playing
+        debug "#now_playing"
+      end
+    end
+  end
+end