musicbox 0.1

data/lib/musicbox/extractor.rb

@@ -0,0 +1,35 @@
+class MusicBox
+
+  class Extractor
+
+    def initialize(catalog:)
+      @catalog = catalog
+    end
+
+    def extract_dir(source_dir)
+      puts "Extracting #{source_dir}"
+      files = @catalog.categorize_files(source_dir)
+      cue_file = files[:cue]&.shift or raise Error, "No cue file found"
+      bin_file = files[:audio]&.shift or raise Error, "No bin file found"
+      dest_dir = @catalog.import_dir / source_dir.basename
+      raise Error, "Extraction directory already exists: #{dest_dir}" if dest_dir.exist?
+      dest_dir.mkpath
+      xld_extract(cue_file: cue_file, bin_file: bin_file, dest_dir: dest_dir)
+      files.values.flatten.each { |p| p.cp_r(dest_dir) }
+      @catalog.extract_done_dir.mkpath unless @catalog.extract_done_dir.exist?
+      source_dir.rename(@catalog.extract_done_dir / source_dir.basename)
+    end
+
+    def xld_extract(cue_file:, bin_file:, dest_dir:)
+      dest_dir.chdir do
+        run_command('xld',
+          '-c', cue_file,
+          '-f', 'alac',
+          '--filename-format', '%D-%n - %t',
+          bin_file)
+      end
+    end
+
+  end
+
+end

data/lib/musicbox/group.rb

@@ -0,0 +1,169 @@
+class MusicBox
+
+  class Group
+
+    attr_accessor :root
+
+    InfoFileName = 'info.json'
+
+    def self.item_class
+      Item
+    end
+
+    def initialize(root:)
+      @root = Path.new(root).expand_path
+      reset
+      load
+    end
+
+    def items
+      @items.values
+    end
+
+    def item_class
+      self.class.item_class
+    end
+
+    def reset
+      @items = {}
+    end
+
+    def load
+      reset
+      if @root.exist?
+        @root.glob("*/#{InfoFileName}").each do |info_file|
+          add_item(item_class.load(info_file.dirname))
+        end
+        ;;warn "* loaded #{@items.length} items from #{@root}"
+      end
+    end
+
+    def [](id)
+      @items[id]
+    end
+
+    def <<(item)
+      add_item(item)
+    end
+
+    def search(query:, fields:, limit: nil)
+      found = []
+      words = [query].flatten.join(' ').tokenize.sort.uniq - ['-']
+      words.each do |word|
+        regexp = Regexp.new(Regexp.quote(word), true)
+        found += @items.values.select do |item|
+          fields.find do |field|
+            case (value = item.send(field))
+            when Array
+              value.find { |v| v.to_s =~ regexp }
+            else
+              value.to_s =~ regexp
+            end
+          end
+        end
+      end
+      found = found.flatten.compact.uniq
+      found = found[0..limit - 1] if limit
+      found
+    end
+
+    def dir_for_id(id)
+      @root / id
+    end
+
+    def new_item(id, args={})
+      item = item_class.new(
+        {
+          id: id,
+          dir: dir_for_id(id),
+        }.merge(args)
+      )
+      add_item(item)
+      item
+    end
+
+    def add_item(item)
+      raise Error, "Item does not have ID" if item.id.nil?
+      raise Error, "Item already exists in #{@root}: #{item.id.inspect}" if @items[item.id]
+      @items[item.id] = item
+    end
+
+    def has_item?(id)
+      @items.has_key?(id)
+    end
+
+    def delete_item(item)
+      @items.delete(item.id)
+    end
+
+    def save_item(id:, item: nil, &block)
+      raise Error, "ID is nil" unless id
+      item = yield if block_given?
+      raise Error, "Item is nil" unless item
+      dir = dir_for_id(id)
+      info_file = dir / InfoFileName
+      dir.mkpath unless dir.exist?
+;;warn "writing to #{info_file}"
+      info_file.write(JSON.pretty_generate(item))
+    end
+
+    def save_item_if_new(id:, item: nil, &block)
+      unless has_item?(id)
+        save_item(id: id, item: item, &block)
+      end
+    end
+
+    def destroy_item(item)
+      dir = dir_for_id(id)
+      dir.rmtree if dir.exist?
+      delete_item(item)
+    end
+
+    def destroy!
+      @root.rmtree if @root.exist?
+    end
+
+    class Item
+
+      attr_accessor :id
+      attr_accessor :dir
+
+      def self.load(dir, params={})
+        dir = Path.new(dir)
+        info_file = dir / Group::InfoFileName
+        raise Error, "Info file does not exist: #{info_file}" unless info_file.exist?
+        new(JSON.load(info_file.read).merge(dir: dir).merge(params))
+      end
+
+      def initialize(params={})
+        params.each { |k, v| send("#{k}=", v) }
+      end
+
+      def info_file
+        @dir / Group::InfoFileName
+      end
+
+      def save
+        ;;warn "* saving item to #{@dir}"
+        raise Error, "dir not defined" unless @dir
+        @dir.mkpath unless @dir.exist?
+        info_file.write(JSON.pretty_generate(serialize))
+      end
+
+      def serialize(args={})
+        { id: @id }.merge(args).compact
+      end
+
+      def fields(keys)
+        keys.map { |k| send(k) }
+      end
+
+      def <=>(other)
+        @id <=> other.id
+      end
+
+    end
+
+  end
+
+end

data/lib/musicbox/importer.rb

@@ -0,0 +1,133 @@
+class MusicBox
+
+  class Importer
+
+    def initialize(catalog:)
+      @catalog = catalog
+      @prompt = TTY::Prompt.new
+    end
+
+    def import_dir(source_dir)
+      @source_dir = Path.new(source_dir).realpath
+      puts; puts "Importing from #{@source_dir}"
+      find_release
+      determine_disc
+      make_album
+      make_copy_plan
+      if @prompt.yes?('Add?')
+        import_album
+        make_label if @prompt.yes?('Make label?')
+        make_cover if @prompt.yes?('Make cover?')
+      end
+    end
+
+    def determine_disc
+      @disc = nil
+      if @album
+        raise Error, "Album already exists" if @release.format_quantity.nil? || @release.format_quantity == 1
+        puts "Release has multiple discs."
+        n = @prompt.ask?('Which disc is this?', required: true, convert: :int)
+        raise Error, "Disc number out of range" unless n >= 1 && n <= @release.format_quantity
+        @disc = n
+      end
+    end
+
+    def find_release
+      releases = @catalog.find(@source_dir.basename.to_s,
+        group: :releases,
+        prompt: true,
+        multiple: false)
+      @release = releases.first
+      @tracklist_flattened = @release.tracklist_flattened
+      print @release.details_to_s
+    end
+
+    def make_album
+      @album = Catalog::Album.new(
+        id: @release.id,
+        title: @release.title,
+        artist: @release.artist,
+        year: @release.original_release_year,
+        discs: @release.format_quantity,
+        dir: @catalog.albums.dir_for_id(@release.id))
+      @release.album = @album
+    end
+
+    def make_album_track(file)
+      tags = Catalog::Tags.load(file)
+      release_track = find_track_for_title(tags[:title])
+      name = '%s%02d - %s' % [
+        @disc ? ('%1d-' % @disc) : '',
+        tags[:track],
+        release_track.title.gsub(%r{[/:]}, '_'),
+      ]
+      album_track = Catalog::AlbumTrack.new(
+        title: release_track.title,
+        artist: release_track.artist || @release.artist,
+        track: tags[:track],
+        disc: @disc || tags[:disc],
+        file: Path.new(name).add_extension(file.extname),
+        tags: tags,
+        album: @album)
+      puts "%-50s ==> %6s - %-50s ==> %-50s" % [
+        file.basename,
+        release_track.position,
+        release_track.title,
+        album_track.file,
+      ]
+      album_track
+    end
+
+    def find_track_for_title(title)
+      release_track = @tracklist_flattened.find { |t| t.title.downcase == title.downcase }
+      unless release_track
+        puts "Can't find release track with title #{title.inspect}"
+        choices = @tracklist_flattened.map { |t| [t.title, t] }.to_h
+        release_track = @prompt.select('Track?', choices, per_page: 100)
+      end
+      release_track
+    end
+
+    def import_album
+      raise Error, "No tracks were added to album" if @album.tracks.empty?
+      @album.save
+      copy_files
+      @album.update_tags
+      extract_cover
+    end
+
+    def make_copy_plan
+      @copy_plan = @source_dir.children.select(&:file?).sort.map do |source_file|
+        dest_file = case source_file.extname.downcase
+        when '.m4a'
+          album_track = make_album_track(source_file) or next
+          @album.tracks << album_track
+          album_track.file
+        else
+          source_file.basename
+        end
+        [source_file, @album.dir / dest_file]
+      end.to_h
+    end
+
+    def copy_files
+      @copy_plan.each do |source_file, dest_file|
+        source_file.cp(dest_file)
+      end
+      @catalog.import_done_dir.mkpath unless @catalog.import_done_dir.exist?
+      @source_dir.rename(@catalog.import_done_dir / @source_dir.basename)
+    end
+
+    def make_label
+      output_file = '/tmp/labels.pdf'
+      LabelMaker.make_labels(@release.to_label, output_file: output_file)
+      run_command('open', output_file)
+    end
+
+    def make_cover
+      #FIXME
+    end
+
+  end
+
+end

data/lib/musicbox/info_to_s.rb

@@ -0,0 +1,18 @@
+class MusicBox
+
+  def self.info_to_s(info, indent: 0)
+    io = StringIO.new
+    width = info.map { |i| i.first.length }.max
+    info.each do |label, value, sub_info|
+      io.puts '%s%*s: %s' % [
+        ' ' * indent,
+        width,
+        label,
+        value,
+      ]
+      io.print info_to_s(sub_info, indent: indent + width + 2) if sub_info
+    end
+    io.string
+  end
+
+end

data/lib/musicbox/label_maker.rb

@@ -0,0 +1,61 @@
+class MusicBox
+
+  class LabelMaker
+
+    def self.make_labels(*labels, output_file:)
+      label_maker = new
+      label_maker.make_labels(labels)
+      label_maker.write(output_file)
+    end
+
+    def initialize
+      @font_dir = Path.new('~/Fonts/D/DejaVu Sans')
+      @pdf = Prawn::Document.new(page_size: [3.5.in, 1.14.in], margin: 0)
+      @pdf.font_families.update(font_families)
+      @pdf.font('DejaVuSans')
+      @pdf.font_size(12)
+    end
+
+    def make_labels(labels)
+      labels.sort_by { |l| l.values_at(:key, :year) }.each_with_index do |label, i|
+        @pdf.start_new_page if i > 0
+        @pdf.bounding_box([0, 1.in], width: 2.5.in, height: 1.in) do
+          # ;;@pdf.transparent(0.5) { @pdf.stroke_bounds }
+          @pdf.text_box <<~END, inline_format: true
+            <b>#{label[:artist]}</b>
+            <i>#{label[:title]}</i>
+          END
+        end
+        @pdf.bounding_box([2.7.in, 1.in], width: 0.8.in, height: 1.in) do
+          # ;;@pdf.transparent(0.5) { @pdf.stroke_bounds }
+          @pdf.text_box <<~END, align: :right, inline_format: true
+            <b>#{label[:key]}
+            #{label[:year]}</b>
+
+            #{label[:format]}
+            #{label[:id]}
+          END
+        end
+      end
+    end
+
+    def write(output_file)
+      @pdf.render_file(output_file.to_s)
+    end
+
+    def font_families
+      {
+        'DejaVuSans' => {
+          normal: 'DejaVuSans',
+          italic: 'DejaVuSans-Oblique',
+          bold: 'DejaVuSans-Bold',
+          bold_italic: 'DejaVuSans-BoldOblique',
+        }.map { |style, file|
+          [style, (@font_dir / file).add_extension('.ttf').realpath.to_s ]
+        }.to_h
+      }
+    end
+
+  end
+
+end

data/lib/musicbox/player.rb

@@ -0,0 +1,289 @@
+class MusicBox
+
+  class Player
+
+    Keymap = {
+      'a' => :play_random_album,
+      't' => :play_random_tracks,
+      'r' => :play_album_for_current_track,
+      'n' => :play_next_track,
+      'p' => :play_previous_track,
+      ' ' => :toggle_pause,
+      '<' => :skip_backward,
+      '>' => :skip_forward,
+      '^' => :skip_to_beginning,
+      'e' => :toggle_equalizer,
+      'E' => :next_equalizer,
+      'q' => :quit,
+      '.' => :show_playlist,
+      '?' => :show_keymap,
+    }
+    ObservedProperties = {
+      'playlist' => :playlist,
+      'playlist-pos' => :playlist_position,
+      'pause' => :pause_state,
+      'time-pos' => :time_position,
+    }
+    SeekSeconds = 30
+
+    attr_accessor :albums
+    attr_accessor :audio_device
+    attr_accessor :mpv_log_level
+    attr_accessor :equalizers
+
+    def initialize(**params)
+      {
+        mpv_log_level: 'error',
+      }.merge(params).each { |k, v| send("#{k}=", v) }
+      @playlist_file = Path.new('/tmp/mpv_playlist')
+    end
+
+    def play
+      raise Error, "No albums to play" if @albums.nil? || @albums.empty?
+      read_albums
+      @dispatcher = IO::Dispatcher.new
+      setup_interface
+      setup_mpv
+      puts "[ready]"
+      play_random_album
+      @dispatcher.run
+    end
+
+    def setup_mpv
+      @mpv = MPVClient.new(
+        'mpv-log-level' => @mpv_log_level,
+        'audio-device' => @audio_device,
+        'audio-display' => 'no',
+        'vo' => 'null',
+        'volume' => 100)
+      @mpv.register_event('log-message') do |event|
+        ;;pp(log: event)
+      end
+      @mpv.command('request_log_messages', @mpv_log_level) if @mpv_log_level
+      @properties = HashStruct.new
+      ObservedProperties.each do |name, key|
+        @mpv.observe_property(name) { |n, v| property_changed(n, v) }
+      end
+      if @equalizers
+        @equalizer_enabled = true
+        next_equalizer
+      end
+      @dispatcher.add_io_handler(input: @mpv.socket) do |io|
+        @mpv.process_response
+      end
+      @dispatcher.add_io_handler(exception: @mpv.socket) do |io|
+        shutdown_mpv
+      end
+      at_exit { shutdown_mpv }
+    end
+
+    def shutdown_mpv
+      if @mpv
+        @mpv.command('quit')
+        @dispatcher.remove_io_handler(input: @mpv.socket, exception: @mpv.socket)
+        @mpv.stop
+        @mpv = nil
+      end
+    end
+
+    def setup_interface
+      @stty_old_params = `stty -g`.chomp
+      at_exit { system('stty', @stty_old_params) }
+      system('stty', 'cbreak', '-echo')
+      @dispatcher.add_io_handler(input: STDIN) do |io|
+        key = io.sysread(1)
+        if (command = Keymap[key])
+          puts "[#{command_description(command)}]"
+          send(command)
+        else
+          puts "unknown key: %p" % key
+        end
+      end
+    end
+
+    def read_albums
+      @album_for_track_path = {}
+      @albums.each do |album|
+        album.tracks.each do |track|
+          @album_for_track_path[track.path] = album
+        end
+      end
+    end
+
+    def random_album
+      @albums.shuffle.first
+    end
+
+    def random_tracks(length:)
+      tracks = Set.new
+      while tracks.length < length
+        tracks << random_album.tracks.shuffle.first
+      end
+      tracks.to_a
+    end
+
+    def playlist_changed(value)
+      @current_track = @playlist = nil
+      if @properties.playlist
+        @playlist = @properties.playlist.map do |entry|
+          track_path = Path.new(entry.filename)
+          album = @album_for_track_path[track_path] \
+            or raise Error, "Can't determine album for track file: #{track_path}"
+          track = album.tracks.find { |t| t.path == track_path } \
+            or raise Error, "Can't determine track for track file: #{track_path}"
+          @current_track = track if entry.current
+          track
+        end
+      end
+      show_playlist
+    end
+
+    #
+    # commands called by interface
+    #
+
+    def quit
+      Kernel.exit(0)
+    end
+
+    def play_next_track
+      if @properties.playlist_position && @properties.playlist_position < @properties.playlist.count - 1
+        @mpv.command('playlist-next')
+      else
+        puts 'no next track'
+      end
+    end
+
+    def play_previous_track
+      if @properties.playlist_position && @properties.playlist_position > 0
+        @mpv.command('playlist-prev')
+      else
+        puts 'no previous track'
+      end
+    end
+
+    def play_random_album
+      play_tracks(random_album.tracks)
+    end
+
+    def play_random_tracks
+      play_tracks(random_tracks(length: 10))
+    end
+
+    def play_album_for_current_track
+      if @properties.playlist_position
+        entry = @properties.playlist[@properties.playlist_position]
+        track_path = Path.new(entry.filename)
+        album = @album_for_track_path[track_path] \
+          or raise Error, "Can't determine album for track file: #{track_path}"
+        play_tracks(album.tracks)
+      else
+        puts "no current track"
+      end
+    end
+
+    def toggle_pause
+      @mpv.set_property('pause', !@properties.pause_state)
+    end
+
+    def skip_backward
+      if @properties.time_position && @properties.time_position > 0
+        @mpv.command('seek', -SeekSeconds)
+      end
+    end
+
+    def skip_forward
+      if @properties.time_position
+        @mpv.command('seek', SeekSeconds)
+      end
+    end
+
+    def skip_to_beginning
+      if @properties.time_position && @properties.time_position > 0
+        @mpv.command('seek', 0, 'absolute-percent')
+      end
+    end
+
+    def show_playlist
+      if @playlist
+        system('clear')
+        if @current_track
+          @current_track.album.show_cover(width: 'auto', height: 20, preserve_aspect_ratio: false)
+          puts
+        end
+        @playlist.each_with_index do |track, i|
+          puts '%1s %2d. %-40.40s | %-40.40s | %-40.40s' % [
+            track == @current_track ? '>' : '',
+            i + 1,
+            track.title,
+            track.album.title,
+            track.album.artist,
+          ]
+        end
+      end
+    end
+
+    def show_keymap
+      Keymap.each do |key, command|
+        puts "%-8s %s" % [key_description(key), command_description(command)]
+      end
+    end
+
+    def play_tracks(tracks)
+      @playlist_file.dirname.mkpath
+      @playlist_file.write(tracks.map(&:path).join("\n"))
+      @mpv.command('loadlist', @playlist_file.to_s)
+    end
+
+    def toggle_equalizer
+      @equalizer_enabled = !@equalizer_enabled
+      set_current_equalizer
+    end
+
+    def next_equalizer
+      if @equalizers
+        @current_equalizer &&= @equalizers[@equalizers.index(@current_equalizer) + 1]
+        @current_equalizer ||= @equalizers.first
+        set_current_equalizer
+      end
+    end
+
+    def set_current_equalizer
+      if @current_equalizer
+        puts "[equalizer: %s <%s>]" % [
+          @current_equalizer.name,
+          @equalizer_enabled ? 'enabled' : 'disabled',
+        ]
+        @mpv.command('af', 'set', @current_equalizer.to_s(enabled: @equalizer_enabled))
+      end
+    end
+
+    #
+    # callbacks from MPV
+    #
+
+    def property_changed(name, value)
+# ;;pp(name => value) unless name == 'time-pos'
+      key = ObservedProperties[name] or raise
+      @properties[key] = value
+      send("#{key}_changed", value) rescue NoMethodError
+    end
+
+    private
+
+    def key_description(key)
+      case key
+      when ' '
+        'space'
+      else
+        key
+      end
+    end
+
+    def command_description(command)
+      command.to_s.gsub('_', ' ')
+    end
+
+  end
+
+end