deadlist 1.0.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cc3ef0661dbc9d67bc88bae8f63b3b42a273e3376647cfee377b9466c23c0d1
-  data.tar.gz: 5f2424f582c3c5c27f102cf842d64083c35b1d20e675e5513b1767014b064673
+  metadata.gz: a7a8fcc71296e7c196d233a170985d82a143da192420557a869ec6924bc165bc
+  data.tar.gz: 1bffff8c94561151b48ec9adabcdb418e7df13971b810f7deb61d5f4ceda678b
 SHA512:
-  metadata.gz: 5e1ca2667a3a681a0119da589919ed8486b416d7963eeb63a318605a4a0d0d1ad85d02b5c8b086587cbe92101992aedaf9fa6bb39a953ae864ddad32f154ad5a
-  data.tar.gz: 1f64dfee13234319fcbc450192d510e900add592839b32956950fa40c9c8e0cff1383edaec206fc5febaa88d4c1a265011cc089548f7e157265273a8e27097a2
+  metadata.gz: 142ff3d85a10c2ead5b00a14692dbbd0736c3f9b0c8b7ff0ec5a1c92b278bd11038459ae2fc0f175b85035f7222fa8f7a705541315a60bda213beccc1e6247c8
+  data.tar.gz: 6c86fae1e34b504a2385e241ec97b54c1944db52caa4025d6d03f982c8d2199c1c07ec500277d0966a5b0c2d30a3383f844dc995d84087f7149dbd324b3f0d85

data/lib/deadlist/cli/argument_parser.rb

@@ -0,0 +1,74 @@
+class ArgumentParser
+  def self.parse(args, version)
+    params = {}
+    
+    parser = OptionParser.new do |opts|
+      opts.banner = "Usage: deadlist [options]"
+      opts.separator ""
+      opts.separator "Required options:"
+      
+      opts.on("-i", "--id ID", "ID of show(s) to download (comma-separated for multiple)") do |id|
+        params[:ids] = id.split(',').map(&:strip)
+      end
+      
+      opts.on("-f", "--format FORMAT", "Format to download (mp3, flac, ogg)") do |format|
+        params[:format] = format.downcase
+      end
+      
+      opts.separator ""
+      opts.separator "Other options:"
+      
+      opts.on("-d", "--directory PATH", "Directory to save show(s) to. Will default to /shows/ in the execution directory") do |dir|
+        params[:directory] = dir
+      end
+
+      opts.on("-h", "--help", "Show this help") do
+        puts opts
+        exit
+      end
+      
+      opts.on("-v", "--version", "Show version") do
+        puts "deadlist v#{version}"
+        exit
+      end
+
+      opts.on('-q', '--quiet', 'Run silently') do
+        params[:quiet] = true
+      end
+
+      opts.on('--dry-run', 'List tracks to be downloaded') do
+        params[:dry_run] = true
+      end
+    end
+    
+    parser.parse!(args)
+    validate_required_params!(params, parser)
+    params
+  rescue OptionParser::InvalidOption => e
+    puts "Error: #{e.message}"
+    puts parser
+    exit(1)
+  end
+
+  private
+
+  def self.validate_required_params!(params, parser)
+    has_ids = params[:ids]&.any?
+    has_format = params[:format]
+
+    # If one is provided, both must be provided
+    if !has_ids && !has_format
+      puts "Error: Arguments are required for DeadList, try --help for more info"
+      puts parser
+      exit(1)
+    elsif has_ids && !has_format
+      puts "Error: --format is required when --id is provided"
+      puts parser
+      exit(1)
+    elsif has_format && !has_ids
+      puts "Error: --id is required when --format is provided"
+      puts parser
+      exit(1)
+    end
+  end
+end

data/lib/deadlist/cli/client.rb

@@ -1,52 +1,29 @@
 # The Client class manages HTML scraping and parsing for the CLI and other classes above it. Any HTML work should be handled here.
 class Client
-    # Returns a show_data object for helping in the creation of a new Show
-    def scrape_show_info(show_link)
-        doc = get_page_source(show_link)
-        track_divs = doc.css('div[itemprop="track"]')
+    def query_show_info(show_id)
+        url = "https://archive.org/metadata/#{show_id}"
+        response = HTTParty.get(url)
 
-        show_data = {
-            date: extract_metadata(doc, itemprop: 'datePublished'),
-            location: extract_metadata(doc, label: 'Location'),
-            venue: extract_metadata(doc, label: 'Venue'),
-            transferred_by: extract_metadata(doc, label: 'Transferred by'),
-            duration: extract_metadata(doc, label: 'Run time'),
-            tracks: extract_track_data(track_divs)
-        }
-
-        return show_data
-    rescue => e
-        puts "\n❌ Data extraction failed: #{e.message}"
-    end
-
-    private 
-
-    # Returns nokogiri-fied page HTML for use in scraping show info
-    def get_page_source(show_link)
-        return Nokogiri::HTML(HTTParty.get(show_link).body)
-    rescue => e
-        puts "\n❌ Scraping failed: #{e.message}"
-    end
-
-    # Handles finding of values via 'label' and 'itemprop' Xpath values
-    def extract_metadata(doc, label: nil, itemprop: nil)
-        if label
-            # For dt/dd metadata pairs
-            doc.xpath("//dt[normalize-space(text())='#{label}']/following-sibling::dd").first&.text&.strip
-        elsif itemprop  
-            # For itemprop attributes
-            doc.xpath("//*[@itemprop='#{itemprop}']").first&.content&.strip
+        unless response.success?
+            raise "API request failed: #{response.code}"
         end
-    end
 
-    # Hunts through track-divs for data required to create Tracks
-    def extract_track_data(track_divs)
-        track_divs.each_with_index.map do |div, i|
-            {
-                pos: i + 1, 
-                name: div.css('meta[itemprop="name"]').first&.[]('content'),
-                links: div.css('link[itemprop="associatedMedia"]').map { |link| link['href'] }
-            }
+        unless response["metadata"]
+            raise "Invalid show ID: #{show_id}"
         end
+
+        show_data = {
+            date: response["metadata"]["date"],
+            location: response["metadata"]["coverage"],
+            venue: response["metadata"]["venue"],
+            transferred_by: response["metadata"]["transferer"],
+            duration: response["metadata"]["runtime"],
+            dir: response["metadata"]["identifier"],
+            files: response["files"]
+        }
+
+        show_data
+    rescue HTTParty::Error, StandardError => e
+        raise "Failed to fetch show data: #{e.message}"
     end
 end

data/lib/deadlist/cli/downloader.rb

@@ -1,19 +1,41 @@
 # A simple class to download files to a given directory. Expects details for the filename and a link.
 # One Downloader should be created / show being downloaded. Downloaders can run on seperate threads for getting many hows at once.
 class Downloader
-    def initialize(path, format)
+    BASE_API_URL = 'https://archive.org'
+
+    def initialize(path, format, logger: Logger.new($stdout))
+        @logger = logger
         @path = path
         @format = format
     end
+  
+    def download_url_for_show(show_id)
+        "#{BASE_API_URL}/download/#{show_id}/"
+    end
 
     # Goes to a link (assuming the format is already validated), and gets the file, saving with argument names.
-    def get(pos, name, link)
-        uri = URI.parse(link); raise ArgumentError, "Only HTTP(S) URLs allowed" unless uri.is_a?(URI::HTTP)
-            
+    def get(root_url, track_object)
+        uri = URI.parse(root_url + track_object.filename); raise ArgumentError, "Only HTTP(S) URLs allowed" unless uri.is_a?(URI::HTTP)
         download = uri.open
-        filename = "#{@path}/#{pos} -- #{name}.#{@format}"
-        IO.copy_stream(download, filename)
+
+        # Extract disc number from filename
+        disc_match = track_object.filename.match(/(?<!g)d(\d+)/)
+        sanitized_title = track_object.title.gsub('/', '-')
+
+        if disc_match
+            # Multi-disc: use disc-track format (1-01, 2-01, etc.)
+            disc_num = disc_match[1]
+            padded_track = track_object.pos.rjust(2, '0')
+            filename = "#{@path}/#{disc_num}-#{padded_track} -- #{sanitized_title}.#{@format}"
+        else
+            # Single disc: regular format
+            filename = "#{@path}/#{track_object.pos} -- #{sanitized_title}.#{@format}"
+        end
+
+            IO.copy_stream(download, filename)
+        true
     rescue => e
-        puts "❌ Download failed: #{e.message}"
+        @logger.error "❌ Download failed for '#{track_object.title}': #{e.message}"
+        false
     end
 end

data/lib/deadlist/cli.rb

@@ -2,69 +2,92 @@ require_relative 'cli/client'
 require_relative 'cli/downloader'
 require_relative 'models/show'
 require_relative 'models/track'
+require_relative 'cli/argument_parser'
 require 'fileutils'
+require 'optparse'
 
 # The CLI is the 'session' created by the main class, managing arguments passed in and housing methods for scraping and downloading shows.
 class CLI
-    def initialize(version, args)
+    attr_reader :args, :show
+
+    def initialize(version, args, logger: Logger.new($stdout))
         @version = version
         @args = {}
         @show = nil
+        @logger = logger
+        @logger.formatter = proc do |severity, datetime, progname, msg|
+          "#{msg}\n"
+        end
 
         startup_text
         parse_arguments(args)
     end
 
-    # Reads arguments passed at the command line and maps them to an instance object
-    def parse_arguments(args)
-        args.each do |arg|
-            key, value = arg.split('=')
-            @args[key.tr('--', '').to_sym] = value
-        end
-    end
-
     # Creates new show object with link given populated with metadata and track details
-    def scrape_links
-        @show = Show.new(@args[:show])
-        puts "\n💿 #{@show.tracks.length} tracks found!"
+    def create_show
+        show_id = @args[:ids].first
+        extracted_id = extract_show_id(show_id)
+        @show = Show.new(extracted_id, @args[:format], logger: @logger)
+
+        @logger.info "💿 #{@show.name} - #{@show.tracks.length} tracks found!"
     rescue => e
-        puts "\n❌ Scraping failed: #{e.message}"
+        @logger.error "❌ Scraping failed: #{e.message}"
     end
 
-    # Validates format isn't for test, and passes directory + format arguments to the download method of a Show
+    # Downloads show tracks or displays dry-run preview
     def download_show
-        download_format = @args[:format]
-
-        if download_format == "test"
-          puts "Test Download, skipping"
-        elsif @show.has_format?(download_format)
-            download_path = setup_directories(@show)
-            @show.download_tracks(download_path, download_format)
+        if @args[:dry_run]
+            @logger.info "🔍 Dry Run: #{@show.name} will be downloaded with #{@show.tracks.count} tracks"
+            @show.tracks.each do |track|
+                @logger.info "  #{track.pos} - #{track.title}"
+            end
         else
-            puts "\n❌ #{download_format} not found for this show! #{@show.tracks[0].available_formats} available"
+            download_directory = setup_directories(@show, @args[:directory])
+            @show.download_tracks(download_directory)
         end
+    rescue => e
+        @logger.error "❌ Download failed: #{e.message}"
     end
 
     private
 
     # Deadlist starts with some friendly text
     def startup_text
-        puts "\n\n"
-        puts '='*52
-        puts "🌹⚡️ One man gathers what another man spills... ⚡️🌹"
-        puts '='*52
+        @logger.info '='*52
+        @logger.info "🌹⚡️ One man gathers what another man spills... ⚡️🌹"
+        @logger.info '='*52
+    end
+
+    # Reads arguments passed at the command line and maps them to an instance object
+    def extract_show_id(show_input)
+        if show_input.include?('archive.org/details/')
+            show_input.split('/details/').last
+        else
+            show_input
+        end
+    end 
+    
+    def parse_arguments(args)
+        @args = ArgumentParser.parse(args, @version)
     end
 
     # Configures directories that will be used by the downloader
-    def setup_directories(show, base_path = Dir.pwd)
-        # Create base shows directory
-        shows_dir = File.join(base_path, "shows")
-        FileUtils.mkdir_p(shows_dir)
-        
-        # Create specific show directory
-        show_dir = File.join(shows_dir, show.name)
+    def setup_directories(show, custom_path = nil)
+        if custom_path
+            # Custom path: use it directly
+            base_dir = custom_path
+        else
+            # Default: add shows subdirectory
+            base_dir = File.join(Dir.pwd, "shows")
+        end
+
+        FileUtils.mkdir_p(base_dir)
+
+        show_dir = File.join(base_dir, show.name)
         FileUtils.mkdir_p(show_dir)
 
-        return show_dir
+        show_dir
+    rescue => e
+        @logger.error "❌ Directory creation failed: #{e.message}"
     end
-end
+end

data/lib/deadlist/models/show.rb

@@ -1,58 +1,80 @@
 # Object to handle Show data and the array of Track objects to be used in downloading.
 class Show
+    AUDIO_FORMATS = %w[mp3 flac ogg m4a].freeze
+
     attr_reader :name, :venue, :date, :location, :duration, :transferred_by, :tracks, :available_formats
 
-    def initialize(download_url)
-        @show_link = download_url
+    def initialize(show_id, format, logger: Logger.new($stdout))
+        @logger = logger
+        @show_id = show_id
+        @format = format
         @name = nil
         @date = nil
         @location = nil
         @venue = nil
         @duration = nil
         @transferred_by = nil
-        @available_formats = []
+        @url = nil
         @tracks = nil
 
         set_show_info
     end
 
-    # Returns whether or not a given format is available for this show
-    def has_format?(requested_format)
-      @tracks[0].has_format?(requested_format)
-    end
-
     # Initializes a Downloader and passes track details
-    def download_tracks(path, format)
-        dl = Downloader.new(path, format)
+    def download_tracks(path)
+        dl = Downloader.new(path, @format, logger: @logger)
+        download_url = dl.download_url_for_show(@show_id)
+        succesful_downloads = 0
 
         @tracks.each do |track|
-            track_link = track.url_for_format(format)
+            @logger.info "⬇️ Downloading #{track.pos} - #{track.title}..."
 
-            dl.get(track.pos, track.name, track_link)
+            if dl.get(download_url, track)
+                succesful_downloads += 1
+            end
 
-            puts "⚡️ #{track.pos} - #{track.name} downloaded successfully"
+            @logger.info "⚡️ #{track.pos} - #{track.title} downloaded successfully"
         end
+
+        @logger.info "✅ Downloaded #{succesful_downloads}/#{@tracks.length} tracks successfully!"
     end
 
     private
 
     # On initialization, show variables are extracted from the HTML data scraped by the Client.
     def set_show_info
-        show_data = Client.new.scrape_show_info(@show_link)
-        
+        show_data = Client.new.query_show_info(@show_id)
+
         @date = show_data[:date]
         @location = show_data[:location]
         @venue = show_data[:venue]
         @duration = show_data[:duration]
         @transferred_by = show_data[:transferred_by]
         @name = "#{show_data[:date]} - #{show_data[:venue]} - #{show_data[:location]}"
-        @tracks = set_tracks(show_data[:tracks])
+        @tracks = set_tracks(show_data[:files])
+        @url = "https://archive.org/metadata/#{show_data[:dir]}/"
 
-        puts "🌹💀 Downloading #{name}"
+        @logger.info "🌹💀 Show #{name} found!"
     end
     
     # Converts track lists to Track objects
-    def set_tracks(track_data)
-        @tracks = track_data.map { |track| Track.new(track) }
+    def set_tracks(files)
+        audio_files = files.select { |file| audio_file?(file) }
+                            .select { |file| matches_format?(file, @format) }
+                            
+        if audio_files.empty?
+            @logger.error "❌ No #{@format} files found"
+            return []
+        end
+  
+        @tracks = audio_files.map.with_index(1) { |track, index| Track.new(track, index) }
+    end
+
+    def audio_file?(file)
+        AUDIO_FORMATS.include?(File.extname(file["name"]).delete('.').downcase)
+    end
+
+    def matches_format?(file, format)
+        File.extname(file["name"]).delete('.').downcase == format
     end
 end

data/lib/deadlist/models/track.rb

@@ -1,24 +1,9 @@
 class Track
-  attr_reader :pos, :name, :links
+  attr_reader :pos, :title, :filename
 
-  def initialize(track_data)
-    @pos = track_data[:pos]
-    @name = track_data[:name]
-    @links = track_data[:links]
-  end
-
-  # Returns formats available for a given track via the links
-  def available_formats
-    @available_formats ||= links.map { |url| File.extname(url).delete('.') }
-  end
-
-  # Based on the format argument, returns one link containing that format
-  def url_for_format(format)
-    links.find { |url| url.end_with?(".#{format}") }
-  end
-
-  # Returns boolean if a format exists for this Track
-  def has_format?(format)
-    available_formats.include?(format)
+  def initialize(track_data, index)
+    @pos = track_data["track"] || index
+    @title = track_data["title"]
+    @filename = track_data["name"]
   end
 end

data/lib/deadlist/version.rb

@@ -0,0 +1,3 @@
+class DeadList
+  VERSION = '1.2.0'
+end

data/lib/deadlist.rb

@@ -1,29 +1,63 @@
 require 'httparty'
-require 'nokogiri'
 require 'open-uri'
 require 'pry'
+require 'logger'
 
-require_relative 'deadlist/cli.rb'
+require_relative 'deadlist/version'
+require_relative 'deadlist/cli'
 
 # Main DeadList class.
 class DeadList
-    HOSTNAME = 'https://www.archive.org/'
+    attr_reader :current_version
 
-    def initialize
-        @current_version = '1.0.1'
-        @hostname = HOSTNAME
+    def initialize(logger: Logger.new($stdout))
+      @logger = logger
+      @logger.level = Logger::INFO  # Default level
+      @logger.formatter = proc do |severity, datetime, progname, msg|
+          "#{msg}\n"
+      end
+      @current_version = VERSION
     end
 
-    def run        
-        # Start a new CLI session
-        # In future this could be abstracted to pass the show link vs all args, so a 'session' is started per show.
-        session = CLI.new(@current_version, ARGV)
+    def run(argv = ARGV)
+      # Parse arguments to get show IDs and options
+      parsed_args = ArgumentParser.parse(argv, @current_version)
+      show_ids = parsed_args[:ids]
+
+      # Check for --quiet flag and adjust logger level
+      if parsed_args[:quiet]
+          @logger.level = Logger::ERROR
+      end
+
+      # Process each show
+      show_ids.each_with_index do |show_id, index|
+        @logger.info "📻 Processing show #{index + 1}/#{show_ids.count}: #{show_id}"
+
+        # Build arguments for this specific show
+        show_argv = ['--id', show_id, '--format', parsed_args[:format]]
+        show_argv += ['--directory', parsed_args[:directory]] if parsed_args[:directory]
+        show_argv += ['--quiet'] if parsed_args[:quiet]
+        show_argv += ['--dry-run'] if parsed_args[:dry_run]
+
+        # Create CLI session for this show
+        session = CLI.new(@current_version, show_argv, logger: @logger)
 
         # Scrape links and metadata for given show
-        session.scrape_links
+        session.create_show
+
+        # Check if show has tracks in requested format
+        if session.show && session.show.tracks.empty?
+          @logger.error "❌ #{show_id} not available in #{parsed_args[:format]} format"
+          if session.show.available_formats && !session.show.available_formats.empty?
+            @logger.error "   Available formats: #{session.show.available_formats.join(', ')}"
+          end
+          @logger.error "   Skipping..."
+          next  # Skip to next show
+        end
 
-        # Create folder with show date and begin track downloads if format matches
+        # Create folder and begin track downloads
         session.download_show
+      end
     end
 end
 

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deadlist
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.0
 platform: ruby
 authors:
 - nazwr
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -23,20 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.21'
-- !ruby/object:Gem::Dependency
-  name: nokogiri
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.10'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.10'
 description: A Ruby gem for downloading Grateful Dead concert recordings from the
   Internet Archive
 email: nathan@azotiwright.com
@@ -48,15 +35,17 @@ files:
 - bin/deadlist
 - lib/deadlist.rb
 - lib/deadlist/cli.rb
+- lib/deadlist/cli/argument_parser.rb
 - lib/deadlist/cli/client.rb
 - lib/deadlist/cli/downloader.rb
 - lib/deadlist/models/show.rb
 - lib/deadlist/models/track.rb
-- lib/version.rb
+- lib/deadlist/version.rb
 homepage: https://github.com/nazwr/deadlist
 licenses:
 - MIT
 metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -71,7 +60,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: Download Grateful Dead shows from archive.org
 test_files: []

data/lib/version.rb

@@ -1,3 +0,0 @@
-module DeadList
-  VERSION = '1.0.0'
-end