musicbox 0.1

data/lib/extensions/string.rb

@@ -0,0 +1,35 @@
+class String
+
+  IgnoredWords = %w{
+    a
+    an
+    and
+    but
+    de
+    des
+    for
+    from
+    le
+    les
+    of
+    on
+    or
+    the
+    to
+  }
+
+  def normalize
+    downcase.                     # lowercase
+      unaccent.                   # 'normalize' accents
+      delete(%q{'"‘’“”}).         # remove quotes
+      gsub(/[^a-z0-9]+/, ' ').    # convert non-alphanumeric to whitespace
+      strip.squeeze(' ')          # compress/remove whitespace
+  end
+
+  def tokenize
+    words = normalize.split(/\s+/)
+    new_words = words - IgnoredWords
+    new_words.empty? ? words : new_words    # handles 'The The', etc.
+  end
+
+end

data/lib/musicbox.rb

@@ -0,0 +1,268 @@
+require 'csv'
+require 'base64'
+require 'discogs-wrapper'
+require 'http'
+require 'io-dispatcher'
+require 'json'
+require 'mpv_client'
+require 'path'
+require 'prawn'
+require 'prawn/measurement_extensions'
+require 'run-command'
+require 'set'
+require 'set_params'
+require 'sixarm_ruby_unaccent'
+require 'tty-prompt'
+require 'yaml'
+
+require 'extensions/string'
+
+require 'musicbox/version'
+require 'musicbox/error'
+require 'musicbox/group'
+require 'musicbox/info_to_s'
+
+require 'musicbox/catalog'
+require 'musicbox/catalog/album'
+require 'musicbox/catalog/album_track'
+require 'musicbox/catalog/albums'
+require 'musicbox/catalog/artist'
+require 'musicbox/catalog/artists'
+require 'musicbox/catalog/format'
+require 'musicbox/catalog/collection_item'
+require 'musicbox/catalog/collection'
+require 'musicbox/catalog/release'
+require 'musicbox/catalog/release_artist'
+require 'musicbox/catalog/releases'
+require 'musicbox/catalog/tags'
+require 'musicbox/catalog/track'
+
+require 'musicbox/cover_maker'
+require 'musicbox/discogs'
+require 'musicbox/equalizer'
+require 'musicbox/exporter'
+require 'musicbox/extractor'
+require 'musicbox/importer'
+require 'musicbox/label_maker'
+require 'musicbox/player'
+
+class MusicBox
+
+  attr_accessor :catalog
+
+  def initialize(root:)
+    @catalog = Catalog.new(root: root)
+    @prompt = TTY::Prompt.new
+  end
+
+  def export(args, **params)
+    exporter = Exporter.new(catalog: @catalog, **params)
+    @catalog.find(args, group: :releases).each do |release|
+      album = release.album or raise Error, "Album does not exist for release #{release.id}"
+      exporter.export_album(album)
+    end
+  end
+
+  def extract(args)
+    extractor = Extractor.new(catalog: @catalog)
+    @catalog.dirs_for_args(@catalog.extract_dir, args).each do |dir|
+      extractor.extract_dir(dir)
+    end
+  end
+
+  def fix(args)
+    # key_map = {
+    #   :title => :title,
+    #   :artist => :artist,
+    #   :original_release_year => :year,
+    #   :format_quantity => :discs,
+    # }
+    # find(args, group: :releases).select(&:cd?).each do |release|
+    #   diffs = {}
+    #   key_map.each do |release_key, album_key|
+    #     release_value = release.send(release_key)
+    #     album_value = release.album.send(album_key)
+    #     if album_value && release_value != album_value
+    #       diffs[release_key] = [release_value, album_value]
+    #     end
+    #   end
+    #   unless diffs.empty?
+    #     puts release
+    #     diffs.each do |key, values|
+    #       puts "\t" + '%s: %p => %p' % [key, *values]
+    #     end
+    #     puts
+    #   end
+    # end
+  end
+
+  def formats(args)
+    formats = {}
+    @catalog.find(args, group: :releases).each do |release|
+      release.formats.each do |format|
+        formats[format.name] ||= 0
+        formats[format.name] += 1
+      end
+    end
+    formats.each do |name, count|
+      puts '%5d %s' % [count, name]
+    end
+  end
+
+  def extract_cover(args)
+    @catalog.find(args, group: :releases).select(&:album).each do |release|
+      release.album.extract_cover
+    end
+  end
+
+  def download_images(args)
+    @catalog.find(args, group: :releases).select(&:cd?).each do |release|
+      release.download_images
+    end
+  end
+
+  def cover(args, prompt: false, output_file: '/tmp/cover.pdf')
+    releases = []
+    @catalog.find(args, group: :releases, prompt: prompt).select(&:album).each do |release|
+      release.select_cover unless release.album.has_cover?
+      releases << release if release.album.has_cover?
+    end
+    CoverMaker.make_covers(*releases, output_file: output_file)
+    run_command('open', output_file)
+  end
+
+  def select_cover(args, prompt: false)
+    @catalog.find(args, group: :releases, prompt: prompt).select(&:album).each do |release|
+      release.select_cover
+    end
+  end
+
+  def import(args)
+    importer = Importer.new(catalog: @catalog)
+    @catalog.dirs_for_args(@catalog.import_dir, args).each do |dir|
+      begin
+        importer.import_dir(dir)
+      rescue Error => e
+        warn "Error: #{e}"
+      end
+    end
+  end
+
+  def label(args)
+    labels = @catalog.find(args, group: :releases, prompt: true).map(&:to_label)
+    output_file = '/tmp/labels.pdf'
+    label_maker = LabelMaker.new
+    label_maker.make_labels(labels)
+    label_maker.write(output_file)
+    run_command('open', output_file)
+  end
+
+  def dir(args, group: nil)
+    @catalog.find(args, group: group).each do |release|
+      puts "%-10s %s" % [release.id, release.dir]
+    end
+  end
+
+  def open(args, group: nil)
+    @catalog.find(args, group: group).each do |release|
+      run_command('open', release.dir)
+    end
+  end
+
+  def orphaned
+    @catalog.orphaned.each do |group, items|
+      unless items.empty?
+        puts "#{group}:"
+        items.sort.each do |item|
+          puts item
+        end
+        puts
+      end
+    end
+    images = @catalog.orphaned_images
+    unless images.empty?
+      puts "Images:"
+      images.sort.each do |image|
+        puts "\t" + image.to_s
+      end
+      puts
+    end
+  end
+
+  def show(args, group: nil, mode: :summary, prompt: false)
+    @catalog.find(args, group: group, prompt: prompt).each do |release|
+      case mode
+      when :cover
+        release.album.show_cover if release.album&.has_cover?
+      when :details
+        puts release.details_to_s
+        puts
+      when :summary
+        puts release
+      end
+    end
+  end
+
+  def csv(args)
+    print Catalog::Release.csv_header
+    @catalog.find(args, group: :releases).each do |release|
+      print release.to_csv
+    end
+  end
+
+  def dups(args)
+    dups = @catalog.find_dups(@catalog.find(args, group: :releases))
+    dups.each do |id, formats|
+      formats.each do |format, releases|
+        if releases.length > 1
+          puts
+          releases.each { |r| puts r }
+        end
+      end
+    end
+  end
+
+  def artist_keys(args)
+    if args.empty?
+      args = @catalog.releases.items.map { |r| r.artists.map(&:name) }.flatten
+    end
+    ;;pp @catalog.artist_keys(args)
+  end
+
+  def play(args, prompt: false, equalizer_name: nil, **params)
+    albums = @catalog.find(args, prompt: prompt).map(&:album).compact
+    if equalizer_name
+      equalizers = Equalizer.load_equalizers(
+        dir: Path.new(@catalog.config['equalizers_dir']),
+        name: equalizer_name)
+    else
+      equalizers = nil
+    end
+    player = MusicBox::Player.new(
+      albums: albums,
+      equalizers: equalizers,
+      **params)
+    player.play
+  end
+
+  def select(args)
+    ids = []
+    loop do
+      releases = @catalog.find(args, group: :releases, prompt: true) or break
+      ids += releases.map(&:id)
+      puts ids.join(' ')
+    end
+  end
+
+  def update
+    Discogs.new(catalog: @catalog).update
+  end
+
+  def update_tags(args, force: false)
+    @catalog.find(args, group: :releases).select(&:album).each do |release|
+      puts release
+      release.album.update_tags(force: force)
+    end
+  end
+
+end

data/lib/musicbox/catalog.rb

@@ -0,0 +1,205 @@
+class MusicBox
+
+  class Catalog
+
+    attr_accessor :root_dir
+    attr_accessor :import_dir
+    attr_accessor :import_done_dir
+    attr_accessor :extract_dir
+    attr_accessor :extract_done_dir
+    attr_accessor :catalog_dir
+    attr_accessor :images_dir
+    attr_accessor :config
+    attr_accessor :collection
+    attr_accessor :releases
+    attr_accessor :masters
+    attr_accessor :artists
+    attr_accessor :albums
+    attr_accessor :groups
+
+    def initialize(root: nil)
+      @root_dir = Path.new(root || ENV['MUSICBOX_ROOT'] || '~/Music/MusicBox').expand_path
+      raise Error, "#{@root_dir} doesn't exist" unless @root_dir.exist?
+      load_config
+      @import_dir = @root_dir / 'import'
+      @import_done_dir = @root_dir / 'import-done'
+      @extract_dir = @root_dir / 'extract'
+      @extract_done_dir = @root_dir / 'extract-done'
+      @catalog_dir = @root_dir / 'catalog'
+      @collection = Collection.new(root: @catalog_dir / 'collection')
+      @releases = Releases.new(root: @catalog_dir / 'releases')
+      @masters = Releases.new(root: @catalog_dir / 'masters')
+      @artists = Artists.new(root: @catalog_dir / 'artists')
+      @albums = Albums.new(root: @catalog_dir / 'albums')
+      @images_dir = @catalog_dir / 'images'
+      link_groups
+      @prompt = TTY::Prompt.new
+    end
+
+    def load_config
+      @config = YAML.load((@root_dir / 'config.yaml').read)
+      ReleaseArtist.class_variable_set(:@@personal_names, @config['personal_names'])
+      ReleaseArtist.class_variable_set(:@@canonical_names, @config['canonical_names'])
+    end
+
+    def orphaned
+      orphaned = %i[releases masters artists albums].map { |k| [k, send(k).items.dup] }.to_h
+      @collection.items.each do |item|
+        release = item.release or raise
+        orphaned[:releases].delete(release)
+        orphaned[:masters].delete(release.master) if release.master
+        release.artists.each do |release_artist|
+          orphaned[:artists].delete(release_artist.artist)
+        end
+        orphaned[:albums].delete(release.album) if release.album
+      end
+      orphaned
+    end
+
+    def orphaned_images
+      all_files = [@releases, @masters].map do |group|
+        group.items.select(&:images).map do |release|
+          release.images.map { |image| image['file'].basename.to_s }
+        end
+      end.flatten.compact
+      @images_dir.children.map(&:basename).map(&:to_s) - all_files
+    end
+
+    def artist_keys(artists)
+      keys = {}
+      names = {}
+      non_personal_names = Set.new
+      artists.map { |a| a.kind_of?(ReleaseArtist) ? a : ReleaseArtist.new(name: a) }.each do |artist|
+        non_personal_names << artist.name if artist.name == artist.canonical_name
+        key = artist.key
+        (keys[key] ||= Set.new) << artist.name
+        (names[artist.name] ||= Set.new) << key
+      end
+      {
+        non_personal_names: non_personal_names.sort,
+        keys: keys.sort.map { |k, s| [k, s.to_a] }.to_h,
+        names: names.sort.map { |k, s| [k, s.to_a] }.to_h,
+      }
+    end
+
+    def find_dups(releases)
+      dups = {}
+      releases.select(&:master_id).each do |release|
+        dups[release.master_id] ||= {}
+        #FIXME: wrong
+        release.formats.map(&:name).each do |format_name|
+          dups[release.master_id][format_name] ||= []
+          dups[release.master_id][format_name] << release
+        end
+      end
+      dups
+    end
+
+    def find(*selectors, group: nil, prompt: false, multiple: true)
+      unless group.kind_of?(Group)
+        group = case group&.to_sym
+        when :releases, nil
+          @releases
+        when :masters
+          @masters
+        when :albums
+          @albums
+        else
+          raise Error, "Unknown group: #{group.inspect}"
+        end
+      end
+      ;;puts "searching #{group.items.count} items in #{group.class}"
+      selectors = [selectors].compact.flatten
+      selectors = [':all'] if selectors.empty?
+      selected = []
+      selectors.each do |selector|
+        case selector.to_s
+        when ':all'
+          selected += group.items
+        when ':recent'
+          selected += group.items.select { |c| (Date.today - c.date_added) < 7 }
+        when ':recently-added'
+          selected += @collection.items.select { |c| (Date.today - c.date_added) < 30 }.map(&:release)
+        when ':multiformat'
+          selected += group.items.select { |r| r.formats&.length > 1 }
+        when ':cd'
+          selected += group.items.select(&:cd?)
+        when ':unripped'
+          selected += group.items.select(&:cd?).reject(&:album)
+        when ':no-cover'
+          selected += group.items.select(&:album).reject { |r| r.album.has_cover? }
+        when ':odd-positions'
+          selected += group.items.select(&:cd?).select { |r| r.tracklist_flattened.find { |t| t.position !~ /^\d+$/ } }
+        when /^-?\d+$/
+          n = selector.to_i
+          item = group[n.abs] or raise Error, "Can't find item #{selector.inspect} in #{group.class}"
+          if n > 0
+            selected += [group[n]]
+          else
+            selected -= [group[-n]]
+          end
+        else
+          selected += group.search(query: selector.to_s, fields: [:title, :artists, :id])
+        end
+      end
+      selected.uniq.sort!
+      if prompt
+        choices = selected.map { |r| [r.to_s, r.id] }.to_h
+        if multiple
+          ids = @prompt.multi_select('Item?', filter: true, per_page: 100, quiet: true) do |menu|
+            # menu.default *(1..choices.length).to_a
+            choices.each do |name, value|
+              menu.choice name, value
+            end
+          end
+          selected = ids.map { |id| group[id] }
+        else
+          id = @prompt.select('Item?', choices, filter: true, per_page: 100, quiet: true)
+          selected = [group[id]] if id
+        end
+      end
+      selected
+    end
+
+    def link_groups
+      @releases.items.each do |release|
+        release.master = @masters[release.master_id] if release.master_id
+        release.artists.each do |release_artist|
+          release_artist.artist = @artists[release_artist.id]
+        end
+        release.album = @albums[release.id]
+        release.link_images(@images_dir)
+        release.master&.link_images(@images_dir)
+      end
+      @collection.items.each do |item|
+        item.release = @releases[item.id]
+      end
+    end
+
+    def categorize_files(dir)
+      categories = {}
+      dir.children.sort.each do |path|
+        type = case (ext = path.extname.downcase)
+        when '.m4a', '.m4p', '.mp3'
+          :audio
+        else
+          ext.delete_prefix('.').to_sym
+        end
+        categories[type] ||= []
+        categories[type] << path
+      end
+      categories
+    end
+
+    def dirs_for_args(base_dir, args)
+      if args.empty?
+        dirs = base_dir.children.select(&:dir?)
+      else
+        dirs = args.map { |p| Path.new(p) }
+      end
+      dirs.sort_by { |d| d.to_s.downcase }
+    end
+
+  end
+
+end