musicbox 0.1

data/lib/musicbox/catalog/album.rb

@@ -0,0 +1,179 @@
+class MusicBox
+
+  class Catalog
+
+    class Album < Group::Item
+
+      attr_accessor :title
+      attr_accessor :artist
+      attr_accessor :year
+      attr_accessor :discs
+      attr_accessor :tracks
+
+      def initialize(params={})
+        @tracks = []
+        super
+      end
+
+      def tracks=(tracks)
+        @tracks = tracks.map { |h| AlbumTrack.new(h.merge(album: self)) }
+      end
+
+      def date=(date)
+        @year = case date
+        when Date
+          date.year
+        when String
+          date.to_i
+        else
+          date
+        end
+      end
+
+      def release_id=(id)
+        @id = id
+      end
+
+      def log_files=(*); end
+
+      def artist
+        @artist || @tracks&.first&.artist
+      end
+
+      def cover_file
+        files = @dir.glob('cover.{jpg,png}')
+        raise Error, "Multiple cover files" if files.length > 1
+        files.first
+      end
+
+      def has_cover?
+        !cover_file.nil?
+      end
+
+      def show_cover(width: nil, height: nil, preserve_aspect_ratio: nil)
+        # see https://iterm2.com/documentation-images.html
+        file = cover_file
+        if file && file.exist?
+          data = Base64.strict_encode64(file.read)
+          args = {
+            name: Base64.strict_encode64(file.to_s),
+            size: data.length,
+            width: width,
+            height: height,
+            preserveAspectRatio: preserve_aspect_ratio,
+            inline: 1,
+          }.compact
+          puts "\033]1337;File=%s:%s\a" % [
+            args.map { |a| a.join('=') }.join(';'),
+            data,
+          ]
+        end
+      end
+
+      def validate_logs
+        log_files = @dir.glob('*.log')
+        raise Error, "No rip logs" if log_files.empty?
+        state = :initial
+        log_files.each do |log_file|
+          log_file.readlines.map(&:chomp).each do |line|
+            case state
+            when :initial
+              if line =~ /^AccurateRip Summary/
+                state = :accuraterip_summary
+              end
+            when :accuraterip_summary
+              if line =~ /^\s+Track \d+ : (\S+)/
+                raise Error, "Not accurately ripped" unless $1 == 'OK'
+              else
+                break
+              end
+            end
+          end
+        end
+      end
+
+      def update_tags(force: false)
+        changes = []
+        @tracks.each do |track|
+          track.update_tags
+          changes << track if track.tags.changed?
+        end
+        unless changes.empty?
+          puts
+          puts "#{@title} [#{@dir}]"
+          changes.each do |track|
+            puts "\t" + track.file.to_s
+            track.tags.changes.each do |change|
+              puts "\t\t" + change.inspect
+            end
+          end
+          if force || TTY::Prompt.new.yes?('Update track files?')
+            changes.each do |track|
+              track.save_tags
+            end
+          end
+        end
+        if has_cover?
+          # --replace apparently doesn't work, so must do --remove, then --add
+          @tracks.each do |track|
+            begin
+              run_command('mp4art',
+                '--quiet',
+                '--remove',
+                track.path)
+            rescue RunCommandFailed => e
+              # ignore
+            end
+            run_command('mp4art',
+              '--quiet',
+              '--add',
+              cover_file,
+              track.path)
+          end
+        end
+      end
+
+      def extract_cover
+        if has_cover?
+          puts "#{@id}: already has cover"
+          return
+        end
+        file = @dir / @tracks.first.file
+        begin
+          run_command('mp4art',
+            '--extract',
+            '--art-index', 0,
+            '--overwrite',
+            '--quiet',
+            file)
+        rescue RunCommandFailed => e
+          # ignore
+        end
+        # cover is in FILE.art[0].TYPE
+        files = @dir.glob('*.art*.*').reject { |f| f.extname.downcase == '.gif' }
+        if files.length == 0
+          puts "#{@id}: no cover to extract"
+        elsif files.length > 1
+          raise Error, "Multiple covers found"
+        else
+          file = files.first
+          new_cover_file = (@dir / 'cover').add_extension(file.extname)
+          puts "#{@id}: extracted cover: #{new_cover_file.basename}"
+          file.rename(new_cover_file)
+        end
+      end
+
+      def serialize
+        super(
+          title: @title,
+          artist: @artist,
+          year: @year,
+          discs: @discs,
+          tracks: @tracks.map(&:to_h))
+      end
+
+    end
+
+  end
+
+end

data/lib/musicbox/catalog/album_track.rb

@@ -0,0 +1,66 @@
+class MusicBox
+
+  class Catalog
+
+    class AlbumTrack
+
+      attr_accessor :title
+      attr_accessor :artist
+      attr_accessor :track
+      attr_accessor :disc
+      attr_accessor :album
+      attr_accessor :file
+      attr_accessor :tags
+
+      def initialize(params={})
+        params.each { |k, v| send("#{k}=", v) }
+      end
+
+      def file=(file)
+        @file = Path.new(file)
+      end
+
+      def path
+        @album.dir / @file
+      end
+
+      def load_tags
+        @tags ||= Tags.load(path)
+      end
+
+      def save_tags
+        @tags.save(path)
+      end
+
+      def update_tags
+        load_tags
+        @tags.update(
+          {
+            title: @title,
+            album: @album.title,
+            track: @track,
+            disc: @disc,
+            discs: @album.discs,
+            artist: @artist || @album.artist,
+            album_artist: @album.artist,
+            grouping: @album.title,
+            year: @album.year,
+          }.reject { |k, v| v.to_s.empty? }
+        )
+      end
+
+      def to_h
+        {
+          title: @title,
+          artist: @artist,
+          track: @track,
+          disc: @disc,
+          file: @file.to_s,
+        }.compact
+      end
+
+    end
+
+  end
+
+end

data/lib/musicbox/catalog/albums.rb

@@ -0,0 +1,19 @@
+class MusicBox
+
+  class Catalog
+
+    class Albums < Group
+
+      def self.item_class
+        Album
+      end
+
+      def new_album(id, args={})
+        new_item(id, args)
+      end
+
+    end
+
+  end
+
+end

data/lib/musicbox/catalog/artist.rb

@@ -0,0 +1,52 @@
+class MusicBox
+
+  class Catalog
+
+    class Artist < Group::Item
+
+      attr_accessor :aliases
+      attr_accessor :data_quality
+      attr_accessor :groups
+      attr_accessor :images   #FIXME: make Image class?
+      attr_accessor :members
+      attr_accessor :name
+      attr_accessor :namevariations
+      attr_accessor :profile
+      attr_accessor :realname
+      attr_accessor :releases_url
+      attr_accessor :resource_url
+      attr_accessor :uri
+      attr_accessor :urls
+
+      def aliases=(aliases)
+        @aliases = aliases.map { |a| ReleaseArtist.new(a) }
+      end
+
+      def groups=(groups)
+        @groups = groups.map { |a| ReleaseArtist.new(a) }
+      end
+
+      def members=(members)
+        @members = members.map { |a| ReleaseArtist.new(a) }
+      end
+
+      def to_s
+        @name
+      end
+
+      def summary_to_s
+        '%-8s | %s' % [
+          @id,
+          @name,
+        ]
+      end
+
+      def <=>(other)
+        @name <=> other.name
+      end
+
+    end
+
+  end
+
+end

data/lib/musicbox/catalog/artists.rb

@@ -0,0 +1,15 @@
+class MusicBox
+
+  class Catalog
+
+    class Artists < Group
+
+      def self.item_class
+        Artist
+      end
+
+    end
+
+  end
+
+end

data/lib/musicbox/catalog/collection.rb

@@ -0,0 +1,15 @@
+class MusicBox
+
+  class Catalog
+
+    class Collection < Group
+
+      def self.item_class
+        CollectionItem
+      end
+
+    end
+
+  end
+
+end

data/lib/musicbox/catalog/collection_item.rb

@@ -0,0 +1,35 @@
+class MusicBox
+
+  class Catalog
+
+    class CollectionItem < Group::Item
+
+      attr_accessor :basic_information
+      attr_accessor :date_added
+      attr_accessor :folder_id
+      attr_accessor :instance_id
+      attr_accessor :notes
+      attr_accessor :rating
+      attr_accessor :resource_url
+      attr_accessor :release    # linked on load
+
+      def date_added=(date)
+        @date_added = DateTime.parse(date.to_s)
+      end
+
+      def serialize(args={})
+        super(
+          basic_information: @basic_information,
+          date_added: @date_added,
+          folder_id: @folder_id,
+          instance_id: @instance_id,
+          notes: @notes,
+          rating: @rating,
+          resource_url: @resource_url)
+      end
+
+    end
+
+  end
+
+end

data/lib/musicbox/catalog/format.rb

@@ -0,0 +1,52 @@
+class MusicBox
+
+  class Catalog
+
+    class Format
+
+      attr_accessor :descriptions
+      attr_accessor :name
+      attr_accessor :qty
+      attr_accessor :text
+
+      def self.to_s(formats)
+        formats.map(&:short_to_s).join(', ')
+      end
+
+      def initialize(params={})
+        params.each { |k, v| send("#{k}=", v) }
+      end
+
+      def qty=(n)
+        @qty = n.to_i
+      end
+
+      def to_s
+        @name + descriptions_to_s + qty_to_s
+      end
+
+      def short_to_s
+        @name + qty_to_s
+      end
+
+      def descriptions_to_s
+        @descriptions ? " (#{@descriptions.join(', ')})" : ''
+      end
+
+      def qty_to_s
+        (@qty && @qty > 1) ? " [#{@qty}]" : ''
+      end
+
+      def cd?
+        @name == 'CD'
+      end
+
+      def vinyl?
+        @name == 'Vinyl'
+      end
+
+    end
+
+  end
+
+end

data/lib/musicbox/catalog/release.rb

@@ -0,0 +1,243 @@
+class MusicBox
+
+  class Catalog
+
+    class Release < Group::Item
+
+      attr_accessor :artists
+      attr_accessor :artists_sort
+      attr_accessor :blocked_from_sale
+      attr_accessor :community
+      attr_accessor :companies
+      attr_accessor :country
+      attr_accessor :data_quality
+      attr_accessor :date_added
+      attr_accessor :date_changed
+      attr_accessor :estimated_weight
+      attr_accessor :extraartists
+      attr_accessor :format_quantity
+      attr_accessor :formats
+      attr_accessor :genres
+      attr_accessor :identifiers
+      attr_accessor :images
+      attr_accessor :labels
+      attr_accessor :lowest_price
+      attr_accessor :main_release
+      attr_accessor :main_release_url
+      attr_accessor :master_id
+      attr_accessor :master_url
+      attr_accessor :most_recent_release
+      attr_accessor :most_recent_release_url
+      attr_accessor :notes
+      attr_accessor :num_for_sale
+      attr_accessor :released
+      attr_accessor :released_formatted
+      attr_accessor :resource_url
+      attr_accessor :series
+      attr_accessor :status
+      attr_accessor :styles
+      attr_accessor :thumb
+      attr_accessor :tracklist
+      attr_accessor :title
+      attr_accessor :uri
+      attr_accessor :versions_url
+      attr_accessor :videos
+      attr_accessor :year
+      attr_accessor :master    # linked on load
+      attr_accessor :album     # linked on load
+
+      def self.csv_header
+        %w[ID year artist title].to_csv
+      end
+
+      def artists=(artists)
+        @artists = artists.map { |a| ReleaseArtist.new(a) }
+      end
+
+      def extraartists=(artists)
+        @extraartists = artists.map { |a| ReleaseArtist.new(a) }
+      end
+
+      def date_added=(date)
+        @date_added = DateTime.parse(date.to_s)
+      end
+
+      def date_changed=(date)
+        @date_changed = DateTime.parse(date.to_s)
+      end
+
+      def formats=(formats)
+        @formats = formats.map { |f| Format.new(f) }
+      end
+
+      def tracklist=(tracklist)
+        @tracklist = tracklist.map { |t| Track.new(t) }
+      end
+
+      def release_year
+        if @year && @year != 0
+          @year
+        elsif @released
+          @released.to_s.split('-').first&.to_i
+        end
+      end
+
+      def original_release_year
+        @master&.release_year || release_year
+      end
+
+      def cd?
+        @formats.find(&:cd?) != nil
+      end
+
+      def artist
+        ReleaseArtist.artists_to_s(@artists)
+      end
+
+      def artist_key
+        @artists.first.key
+      end
+
+      def <=>(other)
+        sort_tuple <=> other.sort_tuple
+      end
+
+      def sort_tuple
+        [artist_key, original_release_year || 0, @title]
+      end
+
+      def to_csv
+        [@id, original_release_year, artist, @title].to_csv
+      end
+
+      def to_s
+        summary_to_s
+      end
+
+      def summary_to_s
+        '%-8s | %1s%1s | %-4s %4s | %-50.50s | %-60.60s | %-6s' % [
+          @id,
+          @album ? 'A' : '',
+          @album&.has_cover? ? 'C' : '',
+          artist_key,
+          original_release_year || '-',
+          artist,
+          @title,
+          Format.to_s(@formats),
+        ]
+      end
+
+      def details_to_s
+        info = [
+          ['ID', @id],
+          ['Master ID', @master_id || '-'],
+          ['Artist', ReleaseArtist.artists_to_s(@artists)],
+          ['Title', @title],
+          ['Formats', Format.to_s(@formats)],
+          ['Released', release_year || '-'],
+          ['Originally released', original_release_year || '-'],
+          ['Discogs URI', @uri || '-'],
+          ['Album dir', @album&.dir || '-'],
+          ['Tracks', nil, tracklist_to_info],
+        ]
+        MusicBox.info_to_s(info)
+      end
+
+      def tracklist_flattened(tracklist=nil)
+        tracklist ||= @tracklist
+        tracks = []
+        tracklist.each do |track|
+          tracks << track
+          tracks += tracklist_flattened(track.sub_tracks) if track.type == 'index'
+        end
+        tracks
+      end
+
+      def tracklist_to_info(tracklist=nil)
+        tracklist ||= @tracklist
+        max_position_length = tracklist.select(&:position).map { |t| t.position.to_s.length }.max
+        tracklist.map do |track|
+          [
+            track.type,
+            [
+              !track.position.to_s.empty? ? ('%*s:' % [max_position_length, track.position]) : nil,
+              track.title || '-',
+              track.artists ? "(#{ReleaseArtist.artists_to_s(track.artists)})" : nil,
+              !track.duration.to_s.empty? ? "[#{track.duration}]" : nil,
+            ].compact.join(' '),
+            track.sub_tracks ? tracklist_to_info(track.sub_tracks) : nil,
+          ]
+        end
+      end
+
+      def to_label
+        {
+          artist: artist,
+          title: title,
+          key: artist_key,
+          year: original_release_year,
+          format: Format.to_s(@formats),
+          id: id,
+        }
+      end
+
+      def link_images(images_dir)
+        if @images
+          @images.each do |image|
+            uri = URI.parse(image['uri'])
+            image['file'] = images_dir / Path.new(uri.path).basename
+          end
+        end
+      end
+
+      def download_images
+        image = @images.find { |image| image['type'] == 'primary' }
+        if image
+          download_image(uri: image['uri'], file: image['file'])
+        else
+          @images.each do |image|
+            download_image(uri: image['uri'], file: image['file'])
+          end
+        end
+        @master.download_images if @master
+      end
+
+      def download_image(uri:, file:)
+        if uri && file
+          unless file.exist?
+            puts "#{@id}: downloading #{uri}"
+            file.dirname.mkpath unless file.dirname.exist?
+            file.write(HTTP.get(uri))
+            sleep(1)
+          end
+        end
+      end
+
+      def select_cover
+        if @album.has_cover?
+          puts "#{@id}: cover already exists"
+          return
+        end
+        download_images
+        @album.extract_cover
+        choices = [
+          @master&.images&.map { |i| i['file'] },
+          @images&.map { |i| i['file'] },
+          @album.cover_file,
+        ].flatten.compact.uniq.select(&:exist?)
+        if choices.empty?
+          puts "#{@id}: no covers exist"
+        else
+          choices.each { |f| run_command('open', f) }
+          choice = TTY::Prompt.new.select('Cover?', choices)
+          cover_file = (album.dir / 'cover').add_extension(choice.extname)
+          choice.cp(cover_file)
+          @album.update_tags
+        end
+      end
+
+    end
+
+  end
+
+end