mikeplayer 1.0.0

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/bin/MikePlayer.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'mikeplayer'
+
+options = {}
+OptionParser.new do |opt|
+  opt.banner = <<-EOF
+   Usage: MikePlayer.rb [options] <search || file>
+
+   Example: `MikePlayer.rb --shuffle --directory /User/Catman/Music cats /MyMusic/GreatestBand-Song.mp3`
+     Finds all songs matching 'cats' in directory /User/Catman/Music ignoring case
+      and specific song /MyMusic/GreatestBand-Song.mp3
+      and randomizes the order
+
+  EOF
+  opt.on('-s', '--shuffle', 'Shuffle playlist.') { |o| options[:shuffle] = true }
+  opt.on('-r', '--random n', 'Create playlist with randomly picked n songs.') { |o| options[:random] = o.to_i }
+  opt.on('-o', '--overwrite', 'Overwrite playlist.') { |o| options[:overwrite] = true }
+  opt.on('-v', '--volume n', 'Changes default volume.') { |o| options[:volume] = o }
+  opt.on('-p', '--playlist name', 'Play playlist name.') { |o| options[:playlist] = o }
+  opt.on('-l', '--list', 'List songs in playlist.') { |o| options[:list] = true; }
+  opt.on('-d', '--directory name', 'Directory to find mp3s.') { |o| options[:directory] = o }
+  opt.on('-t', '--time minutes', 'Limit time to number of minutes.') { |o| options[:minutes] = o }
+end.parse!
+
+MikePlayer::Player.new(options, ARGV).play

data/lib/mikeplayer/executable.rb

@@ -0,0 +1,27 @@
+module MikePlayer
+  class PlayThread
+    def initialize(filename)
+      @filename = filename
+      @mp3info  = Mp3Info.new(filename)
+    end
+
+    def info
+      artist = "#{@mp3info.tag.artist}"
+      title  = "#{@mp3info.tag.title}"
+
+      if (true == artist.empty?) && (true == title.empty?)
+        return File.basename(filename, '.mp3')
+      elsif (true == artist.empty?)
+        artist = "?????"
+      elsif (true == title.empty?)
+        title  = "?????"
+      end
+
+      return "#{artist} - #{title}"
+    end
+
+    def to_json
+      return @filename
+    end
+  end
+end

data/lib/mikeplayer/play_thread.rb

@@ -0,0 +1,14 @@
+module MikePlayer
+  class PlayThread
+    def self.run(file, volume)
+      args = [
+        :play,
+        '--no-show-progress',
+        '--volume', volume,
+        song
+      ]
+      Open3.popen2e(*args) do |stdin, out, wait_thr|
+      end
+    end
+  end
+end

data/lib/mikeplayer/playlist.rb

@@ -0,0 +1,101 @@
+module MikePlayer
+  class Playlist
+    attr_reader :songs
+
+    def initialize(filename)
+      @filename = filename
+      @songs    = []
+      @song_i   = 0
+      @length   = 0
+    
+      load_songs
+
+      @loaded_song_count = @songs.size
+    end
+
+    def <<(song)
+      if ((true == File.file?(song)) && (false == @songs.any? { |s| s.filename == song }))
+        @songs << Song.new(song)
+        @length += @songs.last.length
+      end
+
+      return self
+    end
+
+    def add_random(n, directory)
+      files = Dir.glob(File.join(directory, "**", "*.mp3"), File::FNM_CASEFOLD) - @songs
+
+      files.sample(n).each do |file|
+        self << file
+      end
+
+      return self
+    end
+
+    def find_song(file, directory)
+      if (true == File.file?(file))
+        self << file
+      else
+        Dir.glob(File.join(directory, "**", "*#{file}*"), File::FNM_CASEFOLD).each do |f|
+          self << f
+        end
+      end
+
+      return self
+    end
+
+    def current
+      return @songs[@song_i]
+    end
+
+    def next
+      @song_i += 1
+
+      return self.current
+    end
+
+    def previous
+      @song_i -= 1 unless @song_i <= 0
+
+      return self.current
+    end
+
+    def shuffle!
+      @songs.shuffle!
+
+      return self
+    end
+
+    def save
+      File.open(@filename, 'w') do |f|
+        f.puts(JSON.pretty_generate(@songs.map {|s| s.to_json }))
+      end
+    end
+
+    def name
+      return File.basename(@filename, Settings::PL_FILE_ENDING)
+    end
+
+    def info
+      return "#{self.name} loaded #{@loaded_song_count} songs with length #{Song.as_duration_str(@length)}, added #{@songs.size - @loaded_song_count}"
+    end
+
+    def current_song_info
+      song_i_str = "#{@song_i + 1}".rjust(@songs.size.to_s.size)
+
+      return "Playing (#{song_i_str}/#{@songs.size}): #{current.info}".freeze
+    end
+
+    def finished?
+      return @song_i == @songs.size
+    end
+
+    private
+
+    def load_songs
+      if File.file?(@filename)
+        JSON.parse(File.read(@filename)).each {|song| self << song}
+      end
+    end
+  end
+end

data/lib/mikeplayer/settings.rb

@@ -0,0 +1,74 @@
+module MikePlayer
+  class Settings
+    DEFAULT_DIRECTORY  = 'Music'.freeze
+    DEFAULT_VOLUME     = '0.1'
+    SETTINGS_DIRECTORY = '.mikeplayer'.freeze
+    PL_FILE_ENDING     = '.mpl'.freeze
+
+    attr_reader :random, :music_dir, :playlist, :volume
+
+    def initialize(options)
+      @shuffle   = options[:shuffle]
+      @overwrite = options[:overwrite]
+      @list      = options[:list]
+      @home      = options[:home] || Dir.home
+      @volume    = options[:volume] || DEFAULT_VOLUME
+      @music_dir = options[:directory] || File.join(@home, DEFAULT_DIRECTORY)
+      @settings_dir = options[:settings] || File.join(@home, SETTINGS_DIRECTORY)
+      @minutes   = options[:minutes].to_i
+      @random    = options[:random].to_i
+
+      if (false == Dir.exist?(@settings_dir))
+        Dir.mkdir(@settings_dir)
+      end
+
+      @playlist  = find_playlist(options[:playlist])
+
+      remove_playlist_if_needed(@playlist)
+    end
+
+    def shuffle?
+      return true == @shuffle
+    end
+
+    def random?
+      return 0 < @random
+    end
+
+    def overwrite?
+      return true == @overwrite
+    end
+
+    def list?
+      return true == @list
+    end
+
+    private
+
+    def find_playlist(user_option)
+      name = nil
+
+      if (false == user_option.nil?)
+        if (true == File.file?(user_option))
+          return user_option
+        else
+          name = File.basename(user_option, PL_FILE_ENDING)
+        end
+      elsif (true == self.random?)
+        name = "random_n#{@random}"
+      else
+        name = 'default'
+      end
+
+      return File.join(@settings_dir, "#{name}#{PL_FILE_ENDING}")
+    end
+
+    def remove_playlist_if_needed(filename)
+      if (true == File.file?(filename))
+        if ((true == overwrite?) || (true == random?))
+          File.delete(filename)
+        end
+      end
+    end
+  end
+end

data/lib/mikeplayer/song.rb

@@ -0,0 +1,51 @@
+module MikePlayer
+  class Song
+    attr_reader :filename
+
+    def initialize(filename)
+      @filename = filename
+      @mp3info  = Mp3Info.new(filename)
+    end
+
+    def info
+      artist = "#{@mp3info.tag.artist}"
+      title  = "#{@mp3info.tag.title}"
+
+      if (true == artist.empty?) && (true == title.empty?)
+        return File.basename(@filename, '.mp3')
+      elsif (true == artist.empty?)
+        artist = "?????"
+      elsif (true == title.empty?)
+        title  = "?????"
+      end
+
+      return "#{artist} - #{title}"
+    end
+
+    def length
+      return @mp3info.length
+    end
+
+    def length_str(elapsed_time)
+      return Song.as_duration_str(self.length, elapsed_time)
+    end
+
+    def to_json
+      return @filename.to_s
+    end
+
+    def self.as_duration_str(l, t = nil)
+      l_hr  = "%02d" % (l / 3600).floor
+      l_min = "%02d" % ((l % 3600 )/ 60).floor
+      l_sec = "%02d" % (l % 60)
+      e_min = "%02d" % (t / 60).floor unless t.nil?
+      e_sec = "%02d" % (t % 60) unless t.nil?
+
+      result = "#{l_min}:#{l_sec}"
+      result = "#{l_hr}:#{result}" if l >= 3600
+      result = "#{e_min}:#{e_sec} [#{result}]" unless t.nil?
+
+      return result
+    end
+  end
+end

data/lib/mikeplayer/version.rb

@@ -0,0 +1,3 @@
+module MikePlayer
+  VERSION = '1.0.0'.freeze
+end

data/lib/mikeplayer.rb

@@ -0,0 +1,254 @@
+require 'optparse'
+require 'json'
+require 'open3'
+require 'io/console'
+require 'mp3info'
+require 'mikeplayer/version'
+require 'mikeplayer/settings'
+require 'mikeplayer/playlist'
+require 'mikeplayer/song'
+
+module MikePlayer
+  class Player
+    PAUSE_INDICATOR    = " ||".freeze
+    SLEEP_SETTING      = 0.5
+    STOPPED            = :stopped
+    PLAYING            = :playing
+    PAUSED             = :paused
+
+    def initialize(options, *args)
+      @settings  = Settings.new(options)
+      @playlist  = Playlist.new(@settings.playlist)
+      @command   = ''
+      @pid       = nil
+      @timer_start = nil
+      @state     = STOPPED
+
+      check_system
+
+      if (true == @settings.list?)
+        @songs.map { |song| File.basename(song) }.sort.each {|song| puts "#{File.basename(song)}"}
+
+        exit 0
+      end
+
+      args.flatten.each do |arg|
+        @playlist.find_song(arg, @settings.music_dir)
+      end
+
+      if (true == @settings.random?)
+        @playlist.add_random(@settings.random, @settings.music_dir)
+      end
+
+      @playlist.save
+    end
+
+    def play
+      @playlist.shuffle! if @settings.shuffle?
+
+      print "Playlist #{@playlist.info}\n"
+
+      if @playlist.finished?
+        puts "No songs in playlist."
+        
+        exit 1
+      end
+
+      @thread = Thread.new do
+        display_width   = 0
+
+        while (false == @playlist.finished?)
+          song        = @playlist.current
+          @song_start = Time.now
+          info_prefix = "\r#{@playlist.current_song_info}".freeze
+
+          stdin, stdother, thread_info = Open3.popen2e('play', '--no-show-progress', '--volume', @settings.volume, song.filename)
+
+          @state   = PLAYING
+          @pid     = thread_info.pid
+          indicator = ''
+
+          while (true == pid_alive?)
+            pause_if_over_time_limit
+
+            if (true == playing?)
+              indicator = "#{'>' * (playing_time % 4)}"
+              info_changed = true
+            elsif (true == paused?) && (PAUSE_INDICATOR != indicator)
+              indicator = PAUSE_INDICATOR
+              info_changed = true
+            end
+
+            if (true == info_changed)
+              mindicator = ""
+
+              if (0 < minutes_remaining)
+                mindicator = "(#{minutes_remaining}↓) "
+              end
+
+              info  = "#{info_prefix} #{song.length_str(playing_time)} #{mindicator}#{indicator}".ljust(display_width)
+
+              display_width = info.size
+
+              print(info)
+
+              $stdout.flush
+            end
+
+            sleep SLEEP_SETTING
+          end
+
+          stdin.close
+          stdother.close
+
+          @pid = nil
+
+          if (true == playing?)
+            next_song
+          end
+        end
+
+        @pid   = nil
+        exit
+      end
+
+      wait_on_user
+
+      puts ""
+    end
+
+    def cmd_exist?(cmd)
+      if (true != system('command'))
+        raise "Missing 'command' command, which is used to test compatibility."
+      end
+
+      if (true != system("command -v #{cmd} >/dev/null 2>&1"))
+        return false
+      end
+
+      return true
+    end
+
+    private
+
+    def check_system
+      %w(play).each do |cmd|
+        if (false == cmd_exist?(cmd))
+          raise "#{cmd} failed, do you have sox installed?"
+        end
+      end
+
+      return nil
+    end
+
+    def wait_on_user
+      while ('q' != @command)
+        @command = STDIN.getch
+
+        if ('c' == @command)
+          press_pause
+        elsif ('v' == @command)
+          next_song
+        elsif ('z' == @command)
+          previous_song
+        elsif ('q' == @command) && (false == @pid.nil?)
+          stop_song
+          @thread.kill
+        elsif ('t' == @command)
+          @timer_start = Time.now
+        elsif (false == @timer_start.nil?) && ("#{@command.to_i}" == @command)
+          if (0 == @minutes)
+            @minutes = @command.to_i
+          else
+            @minutes *= 10
+            @minutes += @command.to_i
+          end
+        end
+      end
+    end
+
+    def playing?
+      return (PLAYING == @state)
+    end
+
+    def paused?
+      return (PAUSED == @state)
+    end
+
+    def press_pause
+      if (true == playing?)
+        kill("STOP")
+        @state = PAUSED
+      elsif (true == paused?)
+        kill("CONT")
+        @state = PLAYING
+      else
+        print("Confused state #{@state}.")
+      end
+    end
+
+    def stop_song
+      if (true == paused?)
+        kill("CONT")
+      end
+
+      kill("INT")
+
+      sleep 0.2
+
+      if (true == pid_alive?)
+        kill("KILL")
+      end
+
+      @state = STOPPED
+    end
+
+    def pid_alive?(pid = @pid)
+      if (false == pid.nil?)
+        return system("ps -p #{pid} > /dev/null")
+      end
+
+      return false
+    end
+
+    def next_song
+      stop_song
+
+      @playlist.next
+    end
+
+    def previous_song
+      stop_song
+
+      @playlist.previous
+    end
+
+    def kill(signal)
+      if (false == @pid.nil?)
+        Process.kill(signal, @pid)
+      end
+    end
+
+    def pause_if_over_time_limit
+      if (false == @timer_start.nil?) && (0 < @minutes) && (true == playing?)
+        if (0 > minutes_remaining)
+          press_pause
+          @timer_start = nil
+          @minutes    = 0
+        end
+      end
+    end
+
+    def playing_time
+      return (Time.now - @song_start).to_i
+    end
+
+    def minutes_remaining
+      if ((0 == @minutes) || (@timer_start.nil?))
+        return -1
+      else
+        return (@minutes - ((Time.now - @timer_start).to_i / 60).to_i)
+      end
+    end
+  end
+end

data/mikeplayer.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mikeplayer/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'mikeplayer'
+  gem.version       = MikePlayer::VERSION
+  gem.authors       = ['Mike Crockett']
+  gem.email         = ['rubygems@mmcrockett.com']
+  gem.summary       = 'Wraps Sox\'s `play` command, allowing playslists, find, random and time limit.'
+  gem.executables   << 'MikePlayer.rb'
+  gem.description   = <<-EOF.gsub(/^\s+/, '')
+    #{gem.summary}
+
+    Once a song is playing you can:
+      'x' to previous
+      'c' to pause/play
+      'v' to next
+      'q' to quit
+      't' n to set a timer that will pause the music after n minutes
+  EOF
+  gem.homepage      = 'https://github.com/mmcrockett/mikeplayer'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+  gem.licenses      = ['MIT']
+
+  gem.add_dependency 'json', '~> 1.8'
+  gem.add_dependency 'ruby-mp3info', '~> 0.8'
+  gem.add_dependency 'minitest', '~> 5'
+  gem.add_development_dependency 'rake', '~> 12'
+  gem.add_development_dependency 'byebug', '~> 11'
+end

data/test/mikeplayer/settings_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+class SettingsTest < Minitest::Test
+  describe 'settings' do
+    let(:home) { File.join('', 'tmp') }
+    let(:sdir) { File.join(home, MikePlayer::Settings::SETTINGS_DIRECTORY) }
+
+    before do
+      Dir.delete(sdir) if Dir.exist?(sdir)
+    end
+
+    it 'creates a settings directory' do
+      MikePlayer::Settings.new(home: home)
+      assert(Dir.exist?(sdir))
+    end
+  end
+end

data/test/mikeplayer_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class MikePlayerTest < Minitest::Test
+  describe 'mikeplayer' do
+    it 'has a version' do
+      assert(MikePlayer::VERSION)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+require 'mikeplayer'
+
+require 'minitest/autorun'
+require 'byebug'