vlcraptor 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6f5abe6fe55f27ec9e8d8188af3617d7ee10134190c283d39d48bec9add7390
-  data.tar.gz: 5a479cec89a39aaaf4347c38affdbe685a4dc0c55b181b353a66b6fe7b515e0c
+  metadata.gz: 62d27be7a5541a19d3e2f69cf98ee1506b8b65560deffa547c9e621f860977b9
+  data.tar.gz: af56137e7d23b949a5ba94453f9d3bb4e0c45020722b3d0456393b7c7bfed4b5
 SHA512:
-  metadata.gz: 76a02e31336c49dd3743e2bc1464f85e11b93eeb32516887fe2998220af99887258a1e1b4ca647a965f6fe13b9399c21cc7113cc8512e6aa7d2f494f45bb2962
-  data.tar.gz: 177485c96740373d117633de088f609bdf9c87ce43dbe4d9a2fd38ab43bdb19d49d7241002d0f1009b82dc4c96f82a4422046f26434fac0b9c9e60854c5901d9
+  metadata.gz: 03d0920671d6dfa40dd866c70a915fe7ac6c13a5d84dd0507cdaa6104d0fc2352b2d4b4ab6af10957b7b3ad078f673a2ceda91552134c0b32172186fcafcb75d
+  data.tar.gz: 8519f300d25106c8138cf4921c03f2394191f28f853220203b09079d39d9f972cf40331f6e30a2a9f8549028014a9d1542f6c1b841fef9a1f772fffa1d86c910

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

@@ -1,19 +1,36 @@
 PATH
   remote: .
   specs:
-    vlcraptor (0.1.0)
+    vlcraptor (0.4.0)
+      curses
+      rainbow
+      vlc-client
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
+    backport (1.2.0)
+    benchmark (0.2.0)
+    curses (1.4.4)
     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 +57,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/README.md

@@ -1,28 +1,73 @@
 # Vlcraptor
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/vlcraptor`. To experiment with that code, run `bin/console` for an interactive prompt.
+This is a queueing daemon for VLC - kind of like `mpd` but nowhere near as flexible or useful.
 
-TODO: Delete this and the text above, and describe your gem
+The player daemon starts two instances of VLC and then uses those to play any tracks placed in the queue.
 
-## Installation
+Why two VLC instances? VLC doesn't support cross fading between tracks so this crossfades by starting the
+other VLC instance playing the next track and adjusting volume between both.
 
-Add this line to your application's Gemfile:
+At the moment, only mac os is supported - minor changes would be required to allow this to work on linux.
 
-```ruby
-gem 'vlcraptor'
-```
+## Installation
 
-And then execute:
+You need to install VLC in the default location for mac os (`/Applications/VLC.app`).
 
-    $ bundle install
+`brew install ffmpeg` is required by the `queue` command for extracting tags to place in the queue.
 
-Or install it yourself as:
+`brew install terminal-notifier` is optional depending if you want terminal notifications when new tracks start.
 
-    $ gem install vlcraptor
+This gem can be installed with `gem install vlcraptor`.
 
 ## Usage
 
-TODO: Write usage instructions here
+Running `vlcraptor` without any parameters will list the available subcommands.
+
+### Player
+
+Run `vlcraptor player` in a shell session.
+
+This is the player daemon that controls two instances
+of VLC and is an ncurses application which will take over the display in that terminal.
+
+You can quit with 'q', pause with ' ', stop with 's', play (resume) with 'p' and skip with 'n'.
+
+### Adding tracks to the queue
+
+`vlcraptor queue folder_containing_audio_files audio_file.mp3` will place any number of audio files in the
+queue and the player should immediately start playing the first track.
+
+### Viewing queue contents
+
+`vlcraptor list` will list currently queued tracks with an estimated start time if the player is currently
+running and playing a track.
+
+### Managing queue
+
+`vlcraptor clear` will clear all queued tracks.
+
+`vlcraptor remove 2` will remove queued track at index position 2.
+
+`vlcraptor swap 2 4` will swap the tracks at index positions 2 and 4.
+
+### Media controls
+
+`vlcraptor pause` will pause, `vlcraptor stop` will stop and `vlcraptor play` will resume.
+
+`vlcraptor skip` will fade out the current track and start the next one (unless the queue is empty). 
+
+### Optional features
+
+A number of features can be turned on/off while the player is running that will determine certain behaviour:
+
+`vlcraptor autoplay off` will cause the player to stop and politely wait after the current track has finished.
+`vlcraptor autoplay on` and tracks will start playing again.
+
+`vlcraptor crossfade off` will turn off crossfading so new tracks will start once the previous one is
+completely finished.
+
+`vlcraptor scrobble on` will turn on last.fm scrobbling - you will require your own application api key
+and secret to enable this.
 
 ## Development
 
@@ -32,4 +77,4 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/vlcraptor.
+Bug reports and pull requests are welcome on GitHub at https://github.com/markryall/vlcraptor.

data/exe/vlcraptor

@@ -0,0 +1,56 @@
+#!/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 "clear"
+  Vlcraptor.clear
+when "crossfade"
+  Vlcraptor.crossfade(ARGV.shift)
+when "history"
+  Vlcraptor.history
+when "list"
+  Vlcraptor.list
+when "pause"
+  Vlcraptor.pause
+when "play"
+  Vlcraptor.play
+when "player"
+  Vlcraptor.player
+when "remove"
+  Vlcraptor.remove(ARGV.shift)
+when "queue"
+  Vlcraptor.queue(ARGV)
+when "scrobble"
+  Vlcraptor.scrobble(ARGV.shift)
+when "skip"
+  Vlcraptor.skip
+when "stop"
+  Vlcraptor.stop
+when "swap"
+  Vlcraptor.swap(ARGV)
+else
+  puts "Unknown command \"#{command}\":"
+  puts "  autoplay on/off: continue playing tracks or stop at the end of current track"
+  puts "  clear: clear queue"
+  puts "  crossfade on/off: 5 second crossfade when changing tracks"
+  puts "  history: display play history"
+  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 "  remove a: remove track from queue at index position a"
+  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)"
+  puts "  swap a b: swap tracks in queue at index positions a and b"
+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,79 @@
+# frozen_string_literal: true
+
+require "rainbow"
+require_relative "preferences"
+require_relative "scrobbler"
+
+module Vlcraptor
+  class Notifiers
+    def initialize
+      @preferences = Vlcraptor::Preferences.new
+      @history = "#{File.expand_path("~")}/.player_history"
+    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_started(track)
+      return unless track
+
+      track[:start_time] = Time.now
+      @preferences[:started] = track[:start_time].to_i
+      scrobbler&.now_playing(track[:artist], track[:title])
+      terminal_notify(
+        message: "#{track[:title]} by #{track[:artist]}",
+        title: "Now Playing",
+      )
+
+      len = if track[:length] > 60
+              "(#{track[:length] / 60}m and #{track[:length] % 60}s)"
+            else
+              "(#{track[:length]}s)"
+            end
+
+      message = [
+        display_time(track[:start_time]),
+        Rainbow(track[:title]).green,
+        "by",
+        Rainbow(track[:artist]).yellow,
+        "from",
+        Rainbow(track[:album]).cyan,
+        len,
+      ].join(" ")
+
+      File.open(@history, "a") { |file| file.puts message }
+    end
+
+    def track_finished(track)
+      @preferences[:started] = nil
+
+      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/player_controller.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative "player"
+require_relative "preferences"
+require_relative "queue"
+require_relative "notifiers"
+
+module Vlcraptor
+  class PlayerController
+    def initialize
+      @player = Vlcraptor::Player.new
+      @preferences = Vlcraptor::Preferences.new
+      @queue = Vlcraptor::Queue.new
+      @notifiers = Vlcraptor::Notifiers.new
+      @track = nil
+      @suspended = false
+    end
+
+    def next
+      return on_pause if @preferences.pause?
+      return on_stop if @preferences.stop?
+      return on_play if @preferences.play?
+      return on_suspended if @suspended
+      return when_playing if @player.playing?
+      return when_auto if @preferences.continue?
+
+      when_manual
+    end
+
+    def cleanup
+      @notifiers.track_suspended
+      @player.fadeout
+      @player.cleanup
+    end
+
+    private
+
+    def on_pause
+      when_suspended("Now Paused", :pause)
+    end
+
+    def on_stop
+      when_suspended("Now Stopped", :stop)
+    end
+
+    def when_suspended(status, method)
+      if @player.playing?
+        @player.fadeout
+        @player.send(method)
+      end
+      @status = status
+      @suspended = true
+      @notifiers.track_suspended
+      on_suspended
+    end
+
+    def on_suspended
+      build
+    end
+
+    def on_play
+      unless @player.playing?
+        @player.fadein
+      end
+      @suspended = false
+      @notifiers.track_resumed(@track, @player.time)
+      when_playing_track(@player.remaining)
+    end
+
+    def when_playing
+      return on_skip if @preferences.skip?
+      return on_crossfade if @preferences.crossfade? && @player.remaining < 5
+
+      when_playing_track(@player.remaining)
+    end
+
+    def on_skip
+      @track = @queue.next
+      @notifiers.track_suspended
+      if @track
+        @notifiers.track_started(@track)
+        @player.crossfade(@track[:path])
+        when_playing_track(@player.remaining)
+      else
+        @player.fadeout
+        when_empty
+      end
+    end
+
+    def on_crossfade
+      @notifiers.track_finished(@track)
+      @track = @queue.next
+      if @track
+        @notifiers.track_started(@track)
+        @player.crossfade(@track[:path])
+        when_playing_track(@player.remaining)
+      else
+        @player.fadeout
+        when_empty
+      end
+    end
+
+    def when_auto
+      @notifiers.track_finished(@track)
+      @track = @queue.next
+      return when_empty unless @track
+
+      @notifiers.track_started(@track)
+      @player.play(@track[:path])
+      when_playing_track(@track[:length])
+    end
+
+    def when_playing_track(remaining)
+      @status = "Now Playing"
+      remaining_color = remaining < 30 ? 9 : 5
+      build(
+        [2, @track[:title]],
+        [0, "by"],
+        [11, @track[:artist]],
+        [0, "from"],
+        [6, @track[:album]],
+        [0, "(#{duration(@track[:length])})"],
+        [remaining_color, "#{duration(remaining)} remaining"],
+      )
+    end
+
+    def when_empty
+      @status = "Now Waiting"
+      build
+    end
+
+    def when_manual
+      @status = "Now Waiting"
+      build
+    end
+
+    def display_time(time)
+      time.strftime("%I:%M:%S")
+    end
+
+    def duration(seconds)
+      if seconds > 60
+        "#{seconds / 60}m and #{seconds % 60}s"
+      else
+        "#{seconds}s"
+      end
+    end
+
+    def build(*extra)
+      autoplay = @preferences[:autoplay] ? "+" : "-"
+      crossfade = @preferences[:crossfade] ? "+" : "-"
+      scrobble = @preferences[:scrobble] ? "+" : "-"
+      [
+        [0, display_time(Time.now)],
+        [0, @status],
+        [0, "#{Vlcraptor::Queue.length} items in queue"],
+        [8, "#{autoplay}autoplay #{crossfade}crossfade #{scrobble}scrobble"],
+      ] + extra
+    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,79 @@
+# 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
+      return unless @current_path
+
+      result = YAML.load_file(@current_path)
+      File.exist?(result[:path]) ? result : self.next
+    end
+
+    def self.clear
+      `rm -rf /tmp/queue`
+    end
+
+    def self.length
+      Dir["/tmp/queue/*.yml"].length
+    end
+
+    def self.each
+      Dir["/tmp/queue/*.yml"].sort.each do |path|
+        yield YAML.load_file path
+      end
+    end
+
+    def self.remove(index)
+      path = Dir["/tmp/queue/*.yml"].sort[index.to_i]
+      if path
+        `rm #{path}`
+        yield
+      else
+        puts "Could not find track at position #{index}"
+      end
+    end
+
+    def self.swap(a, b)
+      all = Dir["/tmp/queue/*.yml"].sort
+      path_a = all[a.to_i]
+      path_b = all[b.to_i]
+
+      if path_a && path_b
+        `mv #{path_a} #{path_a}.tmp`
+        `mv #{path_b} #{path_a}`
+        `mv #{path_a}.tmp #{path_b}`
+        yield
+      else
+        puts "Could not find tracks at positions #{a} and #{b}"
+      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,129 @@
+# 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.strip
+    end
+
+    def self.blank(attribute)
+      (attribute || "").length.zero?
+    end
+
+    def self.load
+      conf = Vlcraptor::Settings.new("~/.lastfm.yml")
+
+      conf[:api_key] = ask("What is the api key? ") if blank(conf[:api_key])
+      conf[:secret] = ask("What is the secret? ") if blank(conf[:secret])
+      conf[:user] = ask("What is your lastfm username? ") if blank(conf[:user])
+
+      return nil if blank(conf[:api_key]) || blank(conf[:secret]) || blank(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
+
+      return nil if blank(conf[:session])
+
+      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.4.0"
 end

data/lib/vlcraptor.rb

@@ -1,8 +1,141 @@
 # frozen_string_literal: true
 
-require_relative "vlcraptor/version"
+require "curses"
+require "rainbow"
+require_relative "vlcraptor/player"
+require_relative "vlcraptor/player_controller"
+require_relative "vlcraptor/preferences"
+require_relative "vlcraptor/queue"
+require_relative "vlcraptor/notifiers"
+require_relative "vlcraptor/scrobbler"
 
 module Vlcraptor
-  class Error < StandardError; end
-  # Your code goes here...
+  def self.autoplay(value)
+    Vlcraptor::Preferences.new[:autoplay] = value == "on"
+  end
+
+  def self.clear
+    Vlcraptor::Queue.clear
+  end
+
+  def self.crossfade(value)
+    Vlcraptor::Preferences.new[:crossfade] = value == "on"
+  end
+
+  def self.history
+    system("cat #{File.expand_path("~")}/.player_history")
+  end
+
+  def self.list
+    started = Vlcraptor::Preferences.new[:started]
+    offset = 0
+    index = 0
+    Vlcraptor::Queue.each do |track|
+      array = [Rainbow(index.to_s).magenta]
+      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]
+      index += 1
+    end
+  end
+
+  def self.pause
+    Vlcraptor::Preferences.new[:pause] = true
+  end
+
+  def self.play
+    Vlcraptor::Preferences.new[:play] = true
+  end
+
+  def self.player
+    Curses.init_screen
+    Curses.start_color
+    Curses.curs_set(0)
+    Curses.noecho
+
+    Curses.init_pair(0, 0, 0) # white
+    Curses.init_pair(2, 2, 0) # green
+    Curses.init_pair(5, 5, 0) # magenta
+    Curses.init_pair(6, 6, 0) # cyan
+    Curses.init_pair(8, 8, 0) # grey
+    Curses.init_pair(9, 9, 0) # orange
+    Curses.init_pair(11, 11, 0) # yellow
+
+    player_controller = Vlcraptor::PlayerController.new
+    window = Curses::Window.new(0, 0, 1, 2)
+    window.nodelay = true
+
+    loop do
+      window.setpos(0, 0)
+
+      player_controller.next.each do |pair|
+        window.attron(Curses.color_pair(pair.first)) { window << pair.last }
+        Curses.clrtoeol
+        window << "\n"
+      end
+      (window.maxy - window.cury).times { window.deleteln }
+      window.refresh
+
+      case window.getch.to_s
+      when " "
+        pause
+      when "n"
+        skip
+      when "p"
+        play
+      when "s"
+        stop
+      when "q"
+        break
+      end
+
+      sleep 0.1
+    end
+  ensure
+    player_controller.cleanup
+    Curses.close_screen
+  end
+
+  def self.remove(index)
+    Vlcraptor::Queue.remove(index) { list }
+  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)
+    preferences = Vlcraptor::Preferences.new
+    preferences[:scrobble] = value == "on"
+    scrobbler = Vlcraptor::Scrobbler.load if preferences.scrobble?
+    preferences[:scrobble] = false unless scrobbler
+  end
+
+  def self.skip
+    Vlcraptor::Preferences.new[:skip] = true
+  end
+
+  def self.stop
+    Vlcraptor::Preferences.new[:stop] = true
+  end
+
+  def self.swap(args)
+    a, b = *args
+    Vlcraptor::Queue.swap(a, b) { list }
+  end
 end

data/vlcraptor.gemspec

@@ -27,9 +27,7 @@ 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 "curses"
+  spec.add_dependency "rainbow"
+  spec.add_dependency "vlc-client"
 end

metadata

@@ -1,31 +1,84 @@
 --- !ruby/object:Gem::Specification
 name: vlcraptor
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Mark Ryall
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-26 00:00:00.000000000 Z
-dependencies: []
+date: 2022-04-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: curses
+  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: 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/ffmpeg.rb
+- lib/vlcraptor/notifiers.rb
+- lib/vlcraptor/player.rb
+- lib/vlcraptor/player_controller.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 +100,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