vlcraptor 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6f5abe6fe55f27ec9e8d8188af3617d7ee10134190c283d39d48bec9add7390
-  data.tar.gz: 5a479cec89a39aaaf4347c38affdbe685a4dc0c55b181b353a66b6fe7b515e0c
+  metadata.gz: 6303432e0bfc5db3263ba6121fff94d9652dc0df2b00d427f06febeef2f8f27c
+  data.tar.gz: 2f6af90fb8a4a589f9e58d5bd7dc0bdbdb6fc7520051c4682ea9caa5183c71b3
 SHA512:
-  metadata.gz: 76a02e31336c49dd3743e2bc1464f85e11b93eeb32516887fe2998220af99887258a1e1b4ca647a965f6fe13b9399c21cc7113cc8512e6aa7d2f494f45bb2962
-  data.tar.gz: 177485c96740373d117633de088f609bdf9c87ce43dbe4d9a2fd38ab43bdb19d49d7241002d0f1009b82dc4c96f82a4422046f26434fac0b9c9e60854c5901d9
+  metadata.gz: 88c1e136354b579b937860753c4874f1af62bdf0bd0ebcf7f49e6cea0be96969c16c17423ddd228e745ac72a78936c08a4bc16cc724a973353d90edbab20cb98
+  data.tar.gz: 0e229b3e1db2d596661593d9a85866e5d234fc705b0d019ec468a8a174bb0ae3b1e6d47a19b46390f688e4583d0aa87cfb8fb4f5177ce0528b3c830ed279512c

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.1.0

data/Gemfile

@@ -5,8 +5,7 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in vlcraptor.gemspec
 gemspec
 
-gem "rake", "~> 13.0"
-
-gem "rspec", "~> 3.0"
-
-gem "rubocop", "~> 1.21"
+gem "rake"
+gem "rspec"
+gem "rubocop"
+gem "solargraph"

data/Gemfile.lock

@@ -2,18 +2,33 @@ PATH
   remote: .
   specs:
     vlcraptor (0.1.0)
+      rainbow
+      vlc-client
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
+    backport (1.2.0)
+    benchmark (0.2.0)
     diff-lcs (1.5.0)
+    e2mmap (0.1.0)
+    jaro_winkler (1.5.4)
+    kramdown (2.3.1)
+      rexml
+    kramdown-parser-gfm (1.1.0)
+      kramdown (~> 2.0)
+    nokogiri (1.13.1-x86_64-darwin)
+      racc (~> 1.4)
     parallel (1.22.1)
     parser (3.1.1.0)
       ast (~> 2.4.1)
+    racc (1.6.0)
     rainbow (3.1.1)
     rake (13.0.6)
     regexp_parser (2.2.1)
+    reverse_markdown (2.1.1)
+      nokogiri
     rexml (3.2.5)
     rspec (3.11.0)
       rspec-core (~> 3.11.0)
@@ -40,16 +55,38 @@ GEM
     rubocop-ast (1.16.0)
       parser (>= 3.1.1.0)
     ruby-progressbar (1.11.0)
+    solargraph (0.44.3)
+      backport (~> 1.2)
+      benchmark
+      bundler (>= 1.17.2)
+      diff-lcs (~> 1.4)
+      e2mmap
+      jaro_winkler (~> 1.5)
+      kramdown (~> 2.3)
+      kramdown-parser-gfm (~> 1.1)
+      parser (~> 3.0)
+      reverse_markdown (>= 1.0.5, < 3)
+      rubocop (>= 0.52)
+      thor (~> 1.0)
+      tilt (~> 2.0)
+      yard (~> 0.9, >= 0.9.24)
+    thor (1.2.1)
+    tilt (2.0.10)
     unicode-display_width (2.1.0)
+    vlc-client (0.0.7)
+    webrick (1.7.0)
+    yard (0.9.27)
+      webrick (~> 1.7.0)
 
 PLATFORMS
   x86_64-darwin-21
 
 DEPENDENCIES
-  rake (~> 13.0)
-  rspec (~> 3.0)
-  rubocop (~> 1.21)
+  rake
+  rspec
+  rubocop
+  solargraph
   vlcraptor!
 
 BUNDLED WITH
-   2.2.32
+   2.3.3

data/exe/vlcraptor

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require "vlcraptor"
+
+command = ARGV.shift
+
+case command
+when "autoplay"
+  Vlcraptor.autoplay(ARGV.shift)
+when "crossfade"
+  Vlcraptor.crossfade(ARGV.shift)
+when "list"
+  Vlcraptor.list
+when "pause"
+  Vlcraptor.pause
+when "play"
+  Vlcraptor.play
+when "player"
+  Vlcraptor.player
+when "queue"
+  Vlcraptor.queue(ARGV)
+when "scrobble"
+  Vlcraptor.scrobble(ARGV.shift)
+when "skip"
+  Vlcraptor.skip
+when "stop"
+  Vlcraptor.stop
+else
+  puts "Unknown command \"#{command}\":"
+  puts "  autoplay on/off: continue playing tracks or stop at the end of current track"
+  puts "  crossfade on/off: 5 second crossfade when changing tracks"
+  puts "  list: list current queue"
+  puts "  pause: pause current track (resume with play)"
+  puts "  play: resume after pause/stop"
+  puts "  player: start the player"
+  puts "  queue paths: queue folders or files containing music tracks"
+  puts "  scrobble on/off: send track information to last.fm (requires an api key)"
+  puts "  skip: skip the current track"
+  puts "  stop: stop the player (resume with play)"
+end

data/lib/vlcraptor/console.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Vlcraptor
+  class Console
+    LENGTH = 120
+
+    def initialize
+      @first = true
+    end
+
+    def change(line)
+      print "\b" * LENGTH unless @first
+      @first = false
+      print line[0...LENGTH].ljust LENGTH
+    end
+
+    def replace(line)
+      print "\b" * LENGTH unless @first
+      @first = true
+      puts line
+    end
+  end
+end

data/lib/vlcraptor/ffmpeg.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Vlcraptor
+  class Ffmpeg
+    attr_reader(
+      :title,
+      :album,
+      :artist,
+      :albumartist,
+      :time,
+      :date,
+      :track,
+      :puid,
+      :mbartistid,
+      :mbalbumid,
+      :mbalbumartistid,
+      :asin,
+    )
+
+    CHARS = " `';&!()$".scan(/./)
+
+    def initialize(path)
+      @path = CHARS.inject(path) { |s, char| s.gsub(char) { "\\#{char}" } }
+      `ffmpeg -i #{@path} 2>&1`.each_line do |line|
+        l = line.chomp
+        case l
+        when "  Metadata:"
+          @meta = {}
+        else
+          if @meta
+            m = / *: */.match l
+            add_meta m.pre_match.strip.downcase.to_sym, m.post_match.strip if m
+          end
+        end
+      end
+
+      @title = tag :title, :tit2
+      @album = tag :album, :talb
+      @artist = tag :artist, :tpe1, :tpe2
+      @albumartist = tag :album_artist, :tso2
+      @time = to_duration tag :duration
+      @date = tag :date, :tdrc, :tyer
+      @track = tag :track, :trck
+      @puid = tag :"musicip puid"
+      @mbartistid = tag :musicbrainz_artistid, :"musicbrainz artist id"
+      @mbalbumid = tag :musicbrainz_albumid, :"musicbrainz album id"
+      @mbalbumartistid = tag :musicbrainz_albumartistid, :"musicbrainz album artist id"
+      @asin = tag :asin
+    end
+
+    def add_meta(key, value)
+      @meta[key] ||= value
+    end
+
+    def tag(*names)
+      names.each { |name| return @meta[name] if @meta[name] }
+      nil
+    end
+
+    private
+
+    def to_duration(s)
+      return nil unless s
+
+      first, = s.split ","
+      hours, minutes, seconds = first.split ":"
+      seconds.to_i + (minutes.to_i * 60) + (hours.to_i * 60 * 60)
+    end
+  end
+end

data/lib/vlcraptor/notifiers.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "rainbow"
+require_relative "console"
+require_relative "scrobbler"
+
+module Vlcraptor
+  class Notifiers
+    def initialize(preferences)
+      @preferences = preferences
+      @console = Vlcraptor::Console.new
+    end
+
+    def track_suspended
+      @preferences[:started] = nil
+    end
+
+    def track_resumed(track, elapsed)
+      return unless track
+
+      track[:start_time] = Time.now - elapsed
+      @preferences[:started] = track[:start_time].to_i
+    end
+
+    def track_progress(track, remaining)
+      return unless track
+
+      rem = if remaining > 60
+              "#{remaining / 60} minutes and #{remaining % 60} seconds remaining"
+            else
+              "#{remaining} seconds remaining"
+            end
+      @console.change(
+        [
+          "        ",
+          display_time(Time.now + remaining),
+          remaining < 20 ? Rainbow(rem).tomato : rem,
+        ].join(" ")
+      )
+    end
+
+    def track_started(track)
+      return unless track
+
+      @preferences[:started] = Time.now.to_i
+      track[:start_time] = Time.now
+      scrobbler&.now_playing(track[:artist], track[:title])
+      terminal_notify(
+        message: "#{track[:title]} by #{track[:artist]}",
+        title: "Now Playing",
+      )
+      @console.replace(
+        [
+          display_time(Time.now),
+          display_time(Time.now + track[:length]),
+          Rainbow(track[:title]).green,
+          "by",
+          Rainbow(track[:artist]).yellow,
+          "from",
+          Rainbow(track[:album]).cyan,
+          "(#{track[:length] / 60}:#{track[:length] % 60})",
+        ].join(" ")
+      )
+    end
+
+    def track_finished(track)
+      return unless track
+
+      scrobbler&.scrobble(track[:artist], track[:title], timestamp: track[:start_time].to_i)
+    end
+
+    private
+
+    def display_time(time)
+      time.strftime("%I:%M:%S")
+    end
+
+    def terminal_notify(message:, title:)
+      return if `which terminal-notifier`.empty?
+
+      `terminal-notifier -group vlc -message "#{message}" -title "#{title}"`
+    end
+
+    def scrobbler
+      Vlcraptor::Scrobbler.load if @preferences.scrobble?
+    end
+  end
+end

data/lib/vlcraptor/player.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "vlc-client"
+
+module Vlcraptor
+  class Player
+    def initialize
+      vlc_host = ENV.fetch("VLC_HOST", "localhost")
+      vlc_port_one = ENV.fetch("VLC_PORT", 4212)
+      vlc_port_two = ENV.fetch("VLC_PORT", 4213)
+
+      @pid_one = spawn(
+        "/Applications/VLC.app/Contents/MacOS/VLC --intf rc --rc-host localhost:#{vlc_port_one}",
+        %i[out err] => "/dev/null"
+      )
+
+      @pid_two = spawn(
+        "/Applications/VLC.app/Contents/MacOS/VLC --intf rc --rc-host localhost:#{vlc_port_two}",
+        %i[out err] => "/dev/null"
+      )
+
+      # wait a bit for the VLC processes to be started
+      sleep 0.5
+
+      @vlc = VLC::Client.new(vlc_host, vlc_port_one)
+      @vlc.connect
+
+      @vlc_other = VLC::Client.new(vlc_host, vlc_port_two)
+      @vlc_other.connect
+    end
+
+    def playing?
+      @vlc.playing?
+    end
+
+    def time
+      @vlc.time
+    end
+
+    def remaining
+      @vlc.length - @vlc.time
+    end
+
+    def fadeout
+      (0..10).each do |index|
+        diff = (256 * index) / 10
+        @vlc.volume = 256 - diff
+        sleep 0.5
+      end
+    end
+
+    def fadein
+      @vlc.volume = 0
+      @vlc.play
+
+      (0..10).each do |index|
+        diff = (256 * index) / 10
+        @vlc.volume = diff
+        sleep 0.5
+      end
+    end
+
+    def crossfade(path)
+      @vlc_other.volume = 0
+      @vlc_other.play path
+
+      (0..10).each do |index|
+        diff = (256 * index) / 10
+        @vlc.volume = 256 - diff
+        @vlc_other.volume = diff
+        sleep 0.5
+      end
+
+      @vlc.stop
+      @vlc, @vlc_other = @vlc_other, @vlc
+    end
+
+    def play(path = nil)
+      @vlc.play(path)
+    end
+
+    def pause
+      @vlc.pause
+    end
+
+    def stop
+      @vlc.stop
+    end
+
+    def cleanup
+      `kill -9 #{@pid_one}` if @pid_one
+      `kill -9 #{@pid_two}` if @pid_two
+    end
+  end
+end

data/lib/vlcraptor/preferences.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Vlcraptor
+  class Preferences
+    def initialize
+      @path = "#{File.expand_path("~")}/.player"
+      persist({ autoplay: true, crossfade: true }) unless File.exist?(@path)
+    end
+
+    def continue?
+      self[:autoplay]
+    end
+
+    def crossfade?
+      self[:autoplay] && self[:crossfade]
+    end
+
+    def scrobble?
+      self[:scrobble]
+    end
+
+    def pause?
+      reset(:pause)
+    end
+
+    def stop?
+      reset(:stop)
+    end
+
+    def play?
+      reset(:play)
+    end
+
+    def skip?
+      reset(:skip)
+    end
+
+    def [](key)
+      load_preferences[key]
+    end
+
+    def []=(key, value)
+      preferences = load_preferences
+      preferences[key] = value
+      persist(preferences)
+    end
+
+    def persist(preferences)
+      File.open(@path, "w") { |f| f.puts preferences.to_yaml }
+    end
+
+    private
+
+    def load_preferences
+      YAML.load_file(@path)
+    end
+
+    def reset(key)
+      result = self[key]
+      self[key] = false if result
+      result
+    end
+  end
+end

data/lib/vlcraptor/queue.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "ffmpeg"
+
+module Vlcraptor
+  class Queue
+    def initialize
+      @current_path = nil
+    end
+
+    def next
+      `rm -f #{@current_path}` if @current_path
+      @current_path = Dir["/tmp/queue/*.yml"].min
+      YAML.load_file(@current_path) if @current_path
+    end
+
+    def self.each
+      Dir["/tmp/queue/*.yml"].sort.each do |path|
+        yield YAML.load_file path
+      end
+    end
+
+    def self.add(path)
+      unless %w[.mp3 .m4a].include?(File.extname(path))
+        puts "skipping #{path}"
+        return
+      end
+
+      puts "adding #{path}"
+      tags = Vlcraptor::Ffmpeg.new(path)
+      meta = {
+        title: tags.title,
+        artist: tags.artist,
+        album: tags.album,
+        length: tags.time,
+        path: File.expand_path(path),
+      }
+      `mkdir -p /tmp/queue`
+      File.open("/tmp/queue/#{(Time.now.to_f * 1000).to_i}.yml", "w") { |f| f.puts meta.to_yaml }
+    end
+  end
+end

data/lib/vlcraptor/scrobbler.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "digest/md5"
+require "uri"
+require "cgi"
+require "rexml/document"
+require_relative "settings"
+
+module Vlcraptor
+  class Scrobbler
+    SCROBBLER_URL = "http://ws.audioscrobbler.com/2.0/"
+
+    SubmissionError = Class.new(RuntimeError)
+    SessionError = Class.new(RuntimeError)
+
+    def self.ask(prompt)
+      puts prompt
+      gets.chomp
+    end
+
+    def self.load
+      conf = Vlcraptor::Settings.new("~/lastfm.yaml")
+
+      unless conf["api_key"] && conf["secret"]
+        puts "You will need an api key and secret for last fm integration"
+        conf["api_key"] = ask("What is the api key? ")
+        conf["secret"] = ask("What is the secret ")
+      end
+
+      conf["user"] = ask("What is your lastfm username? ") unless conf["user"]
+
+      scrobbler = Vlcraptor::Scrobbler.new(conf["api_key"], conf["secret"], conf["user"], conf["session"])
+
+      unless conf["session"]
+        conf["session"] = scrobbler.fetch_session_key do |url|
+          puts "A browser will now launch to allow to authorise this application to access your lastfm account"
+          `open '#{url}'`
+          puts "Press enter when you have authorised the application"
+          gets
+        end
+      end
+
+      scrobbler
+    end
+
+    def initialize(api_key, secret, user, session_key = nil)
+      @api_key     = api_key
+      @secret      = secret
+      @user        = user
+      @session_key = session_key
+    end
+
+    attr_reader :user, :api_key, :secret
+
+    def session_key
+      @session_key or raise SessionError, "The session key must be set or fetched"
+    end
+
+    def fetch_session_key
+      doc = lfm :get, "auth.gettoken"
+      request_token = doc.root.elements["token"].text
+      yield "http://www.last.fm/api/auth/?api_key=#{api_key}&token=#{request_token}"
+      doc = lfm :get, "auth.getsession", token: request_token
+      status = doc.root.attributes["status"]
+      raise SubmissionError, status unless status == "ok"
+
+      @session_key = doc.root.elements["session"].elements["key"].text
+    end
+
+    def with_profile_url
+      yield "http://www.last.fm/user/#{user}" if user
+    end
+
+    # http://www.last.fm/api/show?service=443
+    def scrobble(artist, title, params = {})
+      lfm_track "track.scrobble", artist, title, params
+    end
+
+    # See http://www.last.fm/api/show?service=454 for more details
+    def now_playing(artist, title, params = {})
+      lfm_track "track.updateNowPlaying", artist, title, params
+    end
+
+    # http://www.last.fm/api/show?service=260
+    def love(artist, title, params = {})
+      lfm_track "track.love", artist, title, params
+    end
+
+    private
+
+    def lfm_track(method, artist, title, params)
+      doc = lfm :post, method, params.merge(sk: session_key, artist: artist, track: title)
+      status = doc.root.attributes["status"]
+      raise SubmissionError, status unless status == "ok"
+    end
+
+    def lfm(get_or_post, method, parameters = {})
+      p = signed_parameters parameters.merge api_key: api_key, method: method
+      xml = send get_or_post, SCROBBLER_URL, p
+      REXML::Document.new xml
+    end
+
+    def get(url, parameters)
+      query_string = sort_parameters(parameters)
+                     .map { |k, v| "#{k}=#{CGI.escape(v)}" }
+                     .join("&")
+      Net::HTTP.get_response(URI.parse("#{url}?#{query_string}")).body
+    end
+
+    def post(url, parameters)
+      Net::HTTP.post_form(URI.parse(url), parameters).body
+    end
+
+    def signed_parameters(parameters)
+      sorted    = sort_parameters parameters
+      signature = Digest::MD5.hexdigest(sorted.flatten.join + secret)
+      parameters.merge api_sig: signature
+    end
+
+    def sort_parameters(parameters)
+      parameters.map { |k, v| [k.to_s, v.to_s] }.sort
+    end
+  end
+end

data/lib/vlcraptor/settings.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Vlcraptor
+  class Settings
+    attr_reader :path, :preferences
+
+    def initialize(path)
+      @path = path.gsub("~", File.expand_path("~"))
+      FileUtils.mkdir_p File.dirname(@path)
+      @preferences = File.exist?(@path) ? YAML.load_file(@path) : {}
+    end
+
+    def [](key)
+      preferences[key]
+    end
+
+    def []=(key, value)
+      preferences[key] = value
+      persist
+    end
+
+    def persist
+      File.open(path, "w") { |f| f.puts preferences.to_yaml }
+    end
+  end
+end

data/lib/vlcraptor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Vlcraptor
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/vlcraptor.rb

@@ -1,8 +1,147 @@
 # frozen_string_literal: true
 
-require_relative "vlcraptor/version"
+require "rainbow"
+require_relative "vlcraptor/player"
+require_relative "vlcraptor/preferences"
+require_relative "vlcraptor/queue"
+require_relative "vlcraptor/notifiers"
 
 module Vlcraptor
-  class Error < StandardError; end
-  # Your code goes here...
+  def self.autoplay(value)
+    Vlcraptor::Preferences.new[:autoplay] = value == "on"
+  end
+
+  def self.crossfade(value)
+    Vlcraptor::Preferences.new[:crossfade] = value == "on"
+  end
+
+  def self.list
+    started = Vlcraptor::Preferences.new[:started]
+    offset = 0
+    Vlcraptor::Queue.each do |track|
+      array = []
+      array << Time.at(started + offset).strftime("%I:%M:%S") if started
+      array += [Rainbow(track[:title]).green, "by", Rainbow(track[:artist]).yellow]
+      array += ["from", Rainbow(track[:album]).cyan] if (track[:album] || "").length.positive?
+      if track[:length]
+        mins = track[:length] / 60
+        secs = track[:length] % 60
+        array << "(#{mins} minutes and #{secs} seconds)"
+      end
+      puts array.join(" ")
+      offset += track[:length]
+    end
+  end
+
+  def self.pause
+    Vlcraptor::Preferences.new[:pause] = true
+  end
+
+  def self.play
+    Vlcraptor::Preferences.new[:play] = true
+  end
+
+  def self.player
+    player = Vlcraptor::Player.new
+    queue = Vlcraptor::Queue.new
+    preferences = Vlcraptor::Preferences.new
+    notifiers = Vlcraptor::Notifiers.new(preferences)
+    track = nil
+    suspended = false
+
+    loop do
+      sleep 0.2
+
+      if preferences.pause?
+        player.fadeout
+        player.pause
+        suspended = true
+        notifiers.track_suspended
+
+        next
+      end
+
+      if preferences.stop?
+        player.fadeout
+        player.stop
+        suspended = true
+        notifiers.track_suspended
+
+        next
+      end
+
+      if preferences.play?
+        player.fadein
+        suspended = false
+        notifiers.track_resumed(track, player.time)
+
+        next
+      end
+
+      next if suspended
+
+      if player.playing?
+        if preferences.skip?
+          track = queue.next
+          if track
+            notifiers.track_started(track)
+            player.crossfade(track[:path])
+          else
+            player.fadeout
+          end
+          next
+        end
+
+        if preferences.crossfade? && player.remaining < 5
+          notifiers.track_finished(track)
+          track = queue.next
+          if track
+            notifiers.track_started(track)
+            player.crossfade(track[:path])
+          end
+        end
+
+        notifiers.track_progress(track, player.remaining)
+
+        next
+      end
+
+      next unless preferences.continue?
+
+      notifiers.track_finished(track)
+      track = queue.next
+      next unless track
+
+      notifiers.track_started(track)
+      player.play(track[:path])
+    end
+  rescue Interrupt
+    notifiers.track_suspended
+    player.cleanup
+    puts "Exiting"
+  end
+
+  def self.queue(paths)
+    paths.each do |path|
+      if File.file?(path)
+        Vlcraptor::Queue.add(path)
+      else
+        Dir.glob("#{path}/**/*.*").each do |child_path|
+          Vlcraptor::Queue.add(child_path)
+        end
+      end
+    end
+  end
+
+  def self.scrobble(value)
+    Vlcraptor::Preferences.new[:scrobble] = value == "on"
+  end
+
+  def self.skip
+    Vlcraptor::Preferences.new[:skip] = true
+  end
+
+  def self.stop
+    Vlcraptor::Preferences.new[:stop] = true
+  end
 end

data/vlcraptor.gemspec

@@ -27,9 +27,6 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
-
-  # For more information and examples about making a new gem, checkout our
-  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.add_dependency "rainbow"
+  spec.add_dependency "vlc-client"
 end

metadata

@@ -1,31 +1,70 @@
 --- !ruby/object:Gem::Specification
 name: vlcraptor
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Mark Ryall
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-26 00:00:00.000000000 Z
-dependencies: []
+date: 2022-04-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: vlc-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description:
 email:
 - mark@ryall.name
-executables: []
+executables:
+- vlcraptor
 extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
 - ".rubocop.yml"
+- ".tool-versions"
 - Gemfile
 - Gemfile.lock
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
+- exe/vlcraptor
 - lib/vlcraptor.rb
+- lib/vlcraptor/console.rb
+- lib/vlcraptor/ffmpeg.rb
+- lib/vlcraptor/notifiers.rb
+- lib/vlcraptor/player.rb
+- lib/vlcraptor/preferences.rb
+- lib/vlcraptor/queue.rb
+- lib/vlcraptor/scrobbler.rb
+- lib/vlcraptor/settings.rb
 - lib/vlcraptor/version.rb
 - vlcraptor.gemspec
 homepage: https://github.com/markryall/vlcraptor
@@ -47,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Queueing daemon for VLC