muzak 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1a171d18242a3650ec6a70d1cedb0bb9e156229c
+  data.tar.gz: 5e5552a3b45cd2ced07e1ff2a79508bd8820dcd6
+SHA512:
+  metadata.gz: b02efb2b8ef6f3d2811cf469267c4e4f183459267c8027794a76ce04a2a08738b588ecfbeef8b091aa737b66b6dcea7a7fceadf348a2ae35747c13bb7b0cab50
+  data.tar.gz: b49dea00fefd160228bedc48e5b133b46ce781e5630052068f4f2d632db6c73f35201075173bdf873027821b2dd4e107e74df219834b01ae7027b056909b053f

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 William Woodruff <william @ tuffbizz.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+muzak
+=====
+
+muzak is an attempt at a metamusic player.
+
+It indexes a filesystem tree, providing metadata to a user's preferred media
+player. It also provides a pseudo-shell for controlling the indexed files
+and the state of the player.
+
+### Screenshot
+
+![screenshot](https://sr.ht/A-oS.png)
+
+### Usage
+
+Muzak is still a work in process. Don't expect stability or pleasant output.
+
+On the command-line:
+
+```shell
+$ ruby -Ilib muzak.rb # flags: --verbose, --debug
+muzak> help
+```
+
+Daemonized:
+
+```shell
+$ ruby -Ilib muzakd.rb
+echo "command" > ~/.config/muzak/muzak.fifo
+```
+
+### TODO
+
+* current indexing/sorting logic is terrible
+* index's timestamp should be used for automatic reindexing
+* album art logic for `mpv` is funky
+* all the documentation
+* readline's tab complete is terrible with spaces (maybe use `bond`?)

data/bin/muzak

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require "muzak"
+require "readline"
+require "shellwords"
+
+opts = {
+  debug: ARGV.include?("--debug") || ARGV.include?("-d"),
+  verbose: ARGV.include?("--verbose") || ARGV.include?("-v"),
+  batch: ARGV.include?("--batch") || ARGV.include?("-b")
+}
+
+Thread.abort_on_exception = opts[:debug]
+
+muzak = Muzak::Instance.new(opts)
+
+COMMANDS = Muzak::Cmd.commands
+
+CONFIG_REGEX = /^config-(get)|(set)|(del)/
+ARTIST_REGEX = Regexp.union COMMANDS.select{ |c| c =~ /artist/ }.map { |c| /^#{c}/ }
+ALBUM_REGEX = Regexp.union COMMANDS.select{ |c| c =~ /album/ }.map { |c| /^#{c}/ }
+PLAYLIST_REGEX = /^playlist-(load)|(delete)/
+
+comp = proc do |s|
+  case Readline.line_buffer
+  when CONFIG_REGEX
+    muzak.config.keys.grep(Regexp.new(Regexp.escape(s)))
+  when ARTIST_REGEX
+    ss = Readline.line_buffer.split(" ")
+    muzak.index.artists.grep(Regexp.new(Regexp.escape(ss[1..-1].join(" "))))
+  when ALBUM_REGEX
+    muzak.index.album_names.grep(Regexp.new(Regexp.escape(s)))
+  when PLAYLIST_REGEX
+    Muzak::Playlist.playlist_names.grep(Regexp.new(Regexp.escape(s)))
+  else
+    COMMANDS.grep(Regexp.new(Regexp.escape(s)))
+  end
+end
+
+Readline.completion_append_character = " "
+Readline.completion_proc = comp
+
+# ignore interrupts
+trap("INT", "SIG_IGN")
+
+while line = Readline.readline("muzak> ", true)
+  cmd_argv = Shellwords.split(line) rescue next
+  next if cmd_argv.empty? || cmd_argv.any?(&:empty?)
+  muzak.send Muzak::Cmd.resolve_command(cmd_argv.shift), *cmd_argv
+end

data/bin/muzakd

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require "muzak"
+require "shellwords"
+
+opts = {
+  debug: ARGV.include?("--debug") || ARGV.include?("-d"),
+  verbose: ARGV.include?("--verbose") || ARGV.include?("-v"),
+  batch: ARGV.include?("--batch") || ARGV.include?("-b")
+}
+
+Process.daemon unless opts[:debug] || opts[:verbose]
+Thread.abort_on_exception = opts[:debug]
+
+muzak = Muzak::Instance.new(opts)
+
+fifo_path = File.join(Muzak::CONFIG_DIR, "muzak.fifo")
+File.delete(fifo_path) if File.exist?(fifo_path) # just in case a previous session died
+File.mkfifo(fifo_path)
+
+File.open(fifo_path, "r") do |fifo|
+  loop do
+    cmd_argv = Shellwords.split(fifo.readline) rescue next
+    next if cmd_argv.empty? || cmd_argv.any?(&:empty?)
+    muzak.send Muzak::Cmd.resolve_command(cmd_argv.shift), *cmd_argv
+  end
+end
+
+# there is definitely a cleaner way to do this.
+at_exit do
+  File.delete(fifo_path) if File.exist?(fifo_path)
+end

data/lib/muzak.rb

@@ -0,0 +1,11 @@
+require_relative "muzak/const"
+require_relative "muzak/utils"
+require_relative "muzak/plugin"
+require_relative "muzak/song"
+require_relative "muzak/album"
+require_relative "muzak/playlist"
+require_relative "muzak/index"
+require_relative "muzak/cmd"
+require_relative "muzak/player"
+require_relative "muzak/instance"
+

data/lib/muzak/album.rb

@@ -0,0 +1,11 @@
+module Muzak
+  class Album
+    attr_reader :title, :songs, :cover_art
+
+    def initialize(title, album_hash)
+      @title = title
+      @songs = album_hash["songs"].map { |s| Song.new(s) }
+      @cover_art = album_hash["cover"]
+    end
+  end
+end

data/lib/muzak/cmd.rb

@@ -0,0 +1,18 @@
+Dir.glob(File.join(__dir__, "cmd/*")) { |f| require_relative f }
+
+module Muzak
+  module Cmd
+    def self.resolve_command(cmd)
+      cmd.tr "-", "_"
+    end
+
+    def self.resolve_method(meth)
+      meth.to_s.tr "_", "-"
+    end
+
+    def self.commands
+      commands = instance_methods.map(&:to_s).reject { |m| m.start_with?("_") }
+      commands.map { |c| c.tr "_", "-" }
+    end
+  end
+end

data/lib/muzak/cmd/config.rb

@@ -0,0 +1,76 @@
+require "yaml"
+
+module Muzak
+  module Cmd
+    def _config_available?
+      File.file?(CONFIG_FILE)
+    end
+
+    def _config_loaded?
+      !!@config
+    end
+
+    def _config_sync
+      debug "syncing config hash with #{CONFIG_FILE}"
+      File.open(CONFIG_FILE, "w") { |io| io.write @config.to_yaml }
+    end
+
+    def _config_init
+      debug "creating a config file in #{CONFIG_FILE}"
+
+      @config = {
+        "music" => File.expand_path("~/music"),
+        "player" => "mpv",
+      }
+
+      Dir.mkdir(CONFIG_DIR) unless Dir.exist?(CONFIG_DIR)
+      _config_sync
+    end
+
+    def _config_plugin?(name)
+      @config.key?("plugin-#{name}")
+    end
+
+    def config_load
+      verbose "loading config from #{CONFIG_FILE}"
+
+      @config = YAML::load_file(CONFIG_FILE)
+    end
+
+    def config_set(*args)
+      return unless _config_loaded?
+
+      fail_arity(args, 2)
+      key, value = args
+      return if key.nil? || value.nil?
+
+      debug "setting '#{key}' to '#{value}' in config"
+
+      @config[key] = value
+      _config_sync
+    end
+
+    def config_del(*args)
+      return unless _config_loaded?
+
+      fail_arity(args, 1)
+      key = args.shift
+      return if key.nil?
+
+      debug "removing '#{key}' from config"
+
+      @config.delete(key)
+      _config_sync
+    end
+
+    def config_get(*args)
+      return unless _config_loaded?
+
+      fail_arity(args, 1)
+      key = args.shift
+      return if key.nil?
+
+      info "#{key}: #{@config[key]}"
+    end
+  end
+end

data/lib/muzak/cmd/index.rb

@@ -0,0 +1,63 @@
+module Muzak
+  module Cmd
+    def _index_available?
+      File.file?(INDEX_FILE)
+    end
+
+    def _index_loaded?
+      !!@index
+    end
+
+    def _index_sync
+      debug "syncing index hash with #{INDEX_FILE}"
+      File.open(INDEX_FILE, "w") { |io| io.write @index.hash.to_yaml }
+    end
+
+    def index_load
+      debug "loading index from #{INDEX_FILE}"
+
+      @index = Index.load_index(INDEX_FILE)
+    end
+
+    def index_build(*args)
+      warn_arity(args, 0)
+
+      @index = Index.new(@config["music"])
+      _index_sync
+    end
+
+    def list_artists(*args)
+      return unless _index_loaded?
+
+      warn_arity(args, 0)
+
+      puts @index.artists.join("\n")
+    end
+
+    def list_albums(*args)
+      return unless _index_loaded?
+
+      warn_arity(args, 0)
+
+      puts @index.album_names.join("\n")
+    end
+
+    def albums_by_artist(*args)
+      return unless _index_loaded?
+
+      artist = args.join(" ")
+      return if artist.nil?
+
+      puts @index.albums_by(artist).keys
+    end
+
+    def songs_by_artist(*args)
+      return unless _index_loaded?
+
+      artist = args.join(" ")
+      return if artist.nil?
+
+      puts @index.songs_by(artist)
+    end
+  end
+end

data/lib/muzak/cmd/meta.rb

@@ -0,0 +1,19 @@
+module Muzak
+  module Cmd
+    def help(*args)
+      commands = Muzak::Cmd.commands.join(", ")
+      info "available commands: #{commands}"
+    end
+
+    def list_plugins
+      plugins = Plugin.plugin_names.join(", ")
+      puts "available plugins: #{plugins}"
+    end
+
+    def quit
+      debug "muzak is quitting..."
+      @player.deactivate!
+      exit
+    end
+  end
+end

data/lib/muzak/cmd/player.rb

@@ -0,0 +1,79 @@
+module Muzak
+  module Cmd
+    def player_activate
+      if @player.running?
+        warn "player is already running"
+        return
+      end
+
+      @player.activate!
+    end
+
+    def player_deactivate
+      warn "player is not running" unless @player.running?
+
+      # do cleanup even if the player isn't running, just in case
+      @player.deactivate!
+    end
+
+    def play
+      @player.play
+    end
+
+    def pause
+      @player.pause
+    end
+
+    def next
+      @player.next_song
+    end
+
+    def previous
+      @player.previous_song
+    end
+
+    def enqueue_artist(*args)
+      artist = args.join(" ")
+      return if artist.nil?
+
+      album_hashes = @index.albums_by(artist)
+      return if album_hashes.empty?
+
+      albums = album_hashes.map do |album_name, album_hash|
+        Album.new(album_name, album_hash)
+      end
+
+      albums.each do |album|
+        @player.enqueue_album album
+      end
+    end
+
+    def enqueue_album(*args)
+      album_name = args.join(" ")
+      return if album_name.nil?
+
+      album_hash = @index.albums[album_name]
+      return if album_hash.nil?
+
+      album = Album.new(album_name, album_hash)
+
+      @player.enqueue_album album
+    end
+
+    def list_queue
+      puts @player.list_queue.map(&:title)
+    end
+
+    def shuffle_queue
+      @player.shuffle_queue
+    end
+
+    def clear_queue
+      @player.clear_queue
+    end
+
+    def now_playing
+      info @player.now_playing.full_title
+    end
+  end
+end

data/lib/muzak/cmd/playlist.rb

@@ -0,0 +1,101 @@
+module Muzak
+  module Cmd
+    def _playlist_file(pname)
+      File.join(PLAYLIST_DIR, pname) + ".yml"
+    end
+
+    def _playlist_available?(pname)
+      File.exist?(_playlist_file(pname))
+    end
+
+    def _playlist_loaded?
+      !!@playlist
+    end
+
+    def list_playlists
+      Playlist.playlist_names.each do |playlist|
+        info playlist
+      end
+    end
+
+    def playlist_load(*args)
+      fail_arity(args, 1)
+      pname = args.shift
+
+      if _playlist_available?(pname)
+        info "loading playlist '#{pname}'"
+        @playlist = Playlist.load_playlist(_playlist_file(pname))
+      else
+        info "creating playlist '#{pname}'"
+        @playlist = Playlist.new(pname, [])
+        playlist_sync
+      end
+    end
+
+    def playlist_delete(*args)
+      fail_arity(args, 1)
+      pname = args.shift
+
+      debug "deleting playist '#{pname}'"
+
+      File.delete(_playlist_file(pname)) if _playlist_available?(pname)
+      @playlist = nil
+    end
+
+    def playlist_sync(*args)
+      return unless _playlist_loaded?
+      fail_arity(args, 0)
+
+      debug "syncing playlist '#{@playlist.name}'"
+
+      Dir.mkdir(PLAYLIST_DIR) unless Dir.exist?(PLAYLIST_DIR)
+      File.open(_playlist_file(@playlist.name), "w") { |io| io.write @playlist.to_hash.to_yaml }
+    end
+
+    def enqueue_playlist
+      return unless _playlist_loaded?
+
+      @player.enqueue_playlist(@playlist)
+    end
+
+    def playlist_add_album(*args)
+      return unless _playlist_loaded?
+
+      album_name = args.join(" ")
+      return if album_name.nil?
+
+      album_hash = @index.albums[album_name]
+      return if album_hash.nil?
+
+      album = Album.new(album_name, album_hash)
+
+      album.songs.each { |song| @playlist.add song }
+
+      playlist_sync
+    end
+
+    def playlist_add_current
+      return unless @player.running? && _playlist_loaded?
+
+      @playlist.add @player.now_playing
+
+      playlist_sync
+    end
+
+    def playlist_del_current
+      return unless @player.running? && _playlist_loaded?
+
+      @playlist.delete(@player.now_playing)
+
+      playlist_sync
+    end
+
+    def playlist_shuffle
+      return unless _playlist_loaded?
+
+      @playlist.shuffle!
+
+      playlist_sync
+    end
+  end
+end