music_blender 0.0.1

data/lib/music_blender/music_folder.rb

@@ -0,0 +1,51 @@
+module MusicBlender
+  class MusicFolder < ActiveRecord::Base
+    has_many :tracks
+
+    def self.current
+      @current ||= MusicFolder.find_or_create_by(path: music_path)
+    end
+
+    def self.music_path
+      MUSIC_PATH
+    end
+
+    def pick_a_track
+      tracks.
+        except_missing.
+        except_recently_played.
+        except_by_recently_played_artists.
+        by_weighted_random.
+        last
+    end
+
+    def load_tracks
+      relative_paths.each do |relative_path|
+        track = tracks.find_or_create_by(:relative_path => relative_path)
+        track.import_id3_tag_attributes!
+      end
+    end
+
+    def update_missing_flags
+      tracks.each do |track|
+        track.update_column(:missing, ! File.exists?(track.full_path))
+      end
+    end
+
+    #######
+    private
+    #######
+
+    def relative_paths
+      Array.new.tap do |files|
+        Dir["#{path}/**/*.mp3"].each do |file_path|
+          files << relative_path(file_path)
+        end
+      end
+    end
+
+    def relative_path(absolute_path)
+      absolute_path.gsub(/#{self.path}\//,'')
+    end
+  end
+end

data/lib/music_blender/player.rb

@@ -0,0 +1,83 @@
+module MusicBlender
+  class Player
+
+    PLAYING_STATUS_CODE_MAP = {
+      -1 => 'Started',
+      0 => 'Stopped',
+      1 => 'Paused',
+      2 => 'Resumed',
+    }
+
+    METHODS_DELEGATED_TO_MONITOR = [
+      :frames,
+      :frames_remaining,
+      :playing,
+      :seconds,
+      :seconds_remaining,
+      :song_name,
+      :stop_pause_status
+    ]
+
+    attr_reader :current_track, :logger, :stdin, :stdout, :stderr
+
+    METHODS_DELEGATED_TO_MONITOR.each do |delegated_method_name|
+      define_method(delegated_method_name) do
+        monitor.send(delegated_method_name)
+      end
+    end
+
+    def initialize
+      @stdin, @stdout, @stderr, @wait_thread =
+        Open3.popen3('mpg123 --rva-mix -R')
+      @logger = Logger.new("#{BLENDER_ROOT}/log/player.log",'daily')
+      Thread.new { monitor.run }
+    end
+
+    def play
+      set_current_track_last_played_at
+      stdin.puts "LOAD #{pick_a_track.full_path}"
+    end
+
+    def pause
+      stdin.puts 'PAUSE'
+    end
+
+    def stop
+      stdin.puts 'STOP'
+    end
+
+    def quit
+      stdin.puts 'QUIT'
+    end
+
+    def status_string
+      PLAYING_STATUS_CODE_MAP[stop_pause_status]
+    end
+
+    #######
+    private
+    #######
+
+    def set_current_track_last_played_at
+      if current_track
+        current_track.update_column(:last_played_at, Time.now)
+      end
+    end
+
+    def pick_a_track
+      music_folder.pick_a_track.tap do |track|
+        @current_track = track
+        logger.debug("Picked Next Track: #{track.id} - #{track.full_path}")
+      end
+    end
+
+    def monitor
+      @monitor ||= PlayerMonitor.new(self)
+    end
+
+    def music_folder
+      MusicFolder.current
+    end
+
+  end
+end

data/lib/music_blender/player_monitor.rb

@@ -0,0 +1,77 @@
+module MusicBlender
+  class PlayerMonitor
+    attr_accessor :frames, :frames_remaining, :player, :playing, :seconds, :seconds_remaining,
+      :song_name, :stop_pause_status
+
+    def initialize(player)
+      @player = player
+    end
+
+    def run
+      loop do
+        process_output_line(stdout.readline) while stdout.ready?
+        sleep 0.001
+      end
+    end
+
+    #######
+    private
+    #######
+
+    def stdout
+      player.stdout
+    end
+
+    def stderr
+      player.stderr
+    end
+
+    def process_output_line(line)
+      if line.match(/^@F (.+)/)
+        process_frame_message($1)
+      elsif line.match(/^@I (.+)/)
+        process_information_message($1)
+      elsif line.match(/^@P ([0-3])/)
+        process_stop_pause_status($1.to_i)
+      end
+    rescue Exception => e
+      logger.error("Monitor failed to process line: #{line}")
+      logger.error("Exception -> #{e.class}: #{e.message}.")
+      e.backtrace.each do |backtrace_line|
+        logger.error(backtrace_line)
+      end
+    end
+
+    def process_frame_message(message)
+      self.frames, self.frames_remaining, self.seconds, self.seconds_remaining =
+        message.split(/\s/).map { |value| value.to_f }
+    end
+
+    def process_information_message(message)
+      @song_name = message
+      @stop_pause_status = -1
+      @playing = true
+    end
+
+    def process_stop_pause_status(status)
+      @stop_pause_status = status
+      case status
+      when 0 then #STOPPED
+        @playing = false
+        play_next_track if seconds_remaining < 1
+      when 1 then #PAUSED
+        @playing = false
+      when 2 then #RESUMED
+        @playing = true
+      end
+    end
+
+    def play_next_track
+      player.play
+    end
+
+    def logger
+      player.logger
+    end
+  end
+end

data/lib/music_blender/shell.rb

@@ -0,0 +1,59 @@
+module MusicBlender
+  class Shell
+
+    COMMANDS = {
+      exit: ->() { player.stop; player.quit; throw(:exited, 'Exited Successfully'); },
+      info: ->() { print_info },
+      pause: ->() { player.pause },
+      play: ->() { player.play },
+      quit: ->() { player.quit },
+      rate: ->(rating) { update_rating(rating) },
+      stop: ->() { player.stop },
+    }.with_indifferent_access
+
+    def run
+      loop do
+        print 'mmp> '
+        execute(*next_command_with_args)
+      end
+    end
+
+    #######
+    private
+    #######
+
+    def next_command_with_args
+      gets.strip.split(/\s+/)
+    end
+
+    def self.player
+      @player ||= Player.new
+    end
+
+    def self.print_info
+      puts player.current_track.full_path
+      puts player.current_track.title
+      puts player.current_track.artist.name
+      puts "Rating: #{player.current_track.rating}"
+      puts "Last Played: #{player.current_track.last_played_at}"
+      puts "Seconds: #{player.seconds} (#{player.seconds_remaining})"
+    end
+
+    def self.update_rating(rating)
+      player.current_track.update_attribute(:rating,rating)
+      puts "Rating Updated To: #{player.current_track.rating}"
+    end
+
+    def execute(command, *args)
+      if COMMANDS.has_key?(command)
+        args.any? ? COMMANDS[command].call(*args) : COMMANDS[command].call
+      else
+        puts "Unrecognized Command: #{command}"
+      end
+    end
+
+    def player
+      self.class.player
+    end
+  end
+end

data/lib/music_blender/track.rb

@@ -0,0 +1,68 @@
+module MusicBlender
+  class Track < ActiveRecord::Base
+
+    validates_uniqueness_of :relative_path, :scope => :music_folder_id
+    validates_numericality_of :rating, :greater_than => 0, :only_integer => true
+
+    before_validation :import_id3_tag_attributes, :on => :create
+
+    before_save :persist_rating_to_id3_tag, :on => :update, :if => :rating_changed?
+
+    belongs_to :artist
+    belongs_to :music_folder
+
+    scope :by_weighted_random, ->() {
+      select(%Q{*, ((strftime('%s','now') - strftime('%s', ifnull(last_played_at,created_at)))/#{1.month.seconds.to_f})*rating*random() AS weighted_random}).order('weighted_random')
+    }
+
+    scope :except_recently_played, ->() {
+      where(['last_played_at IS NULL OR last_played_at < ?', unscoped.most_recent((count*0.1)+1).last.last_played_at])
+    }
+
+    scope :except_by_recently_played_artists, ->() {
+      where(['artist_id NOT IN (?)', unscoped.most_recent((count*0.02)+1).select(:artist_id).map(&:artist_id)])
+    }
+
+    scope :except_missing, ->() { where(:missing => false) }
+    scope :most_recent, ->(number) { order('last_played_at DESC').limit(number) }
+
+    def full_path
+      "#{music_folder.path}/#{relative_path}"
+    end
+
+    def import_id3_tag_attributes!
+      import_id3_tag_attributes
+      save
+    end
+
+    #######
+    private
+    #######
+
+    def import_id3_tag_attributes
+      self.title = id3_title
+      self.artist = Artist.find_or_create_by(:name => id3_artist)
+      self.rating = id3_rating
+    end
+
+    def id3_title
+      id3_adapter.title
+    end
+
+    def id3_artist
+      id3_adapter.artist
+    end
+
+    def id3_rating
+      id3_adapter.rating
+    end
+
+    def persist_rating_to_id3_tag
+      id3_adapter.set_rating(rating.to_s)
+    end
+
+    def id3_adapter
+      @id3_adapter ||= Id3Adapter.new(full_path,rating)
+    end
+  end
+end

data/lib/music_blender/version.rb

@@ -0,0 +1,3 @@
+module MusicBlender
+  VERSION = '0.0.1'
+end

data/music_blender.gemspec

@@ -0,0 +1,28 @@
+require File.expand_path('../lib/music_blender/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = "music_blender"
+  s.version = MusicBlender::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Jonathan S. Garvin"]
+  s.email = ["jon@5valleys.com"]
+  s.homepage = "https://github.com/jsgarvin/music_blender"
+  s.summary = %q{Simple MP3 player written in Ruby.}
+  s.description = %q{A simple MP3 player written in Ruby. Depends on mpg123.}
+
+  s.add_dependency('activerecord')
+  s.add_dependency('sqlite3')
+  s.add_dependency('taglib-ruby')
+
+  s.add_development_dependency('assert_difference')
+  s.add_development_dependency('factory_girl')
+  s.add_development_dependency('fakefs')
+  s.add_development_dependency('mocha')
+  s.add_development_dependency('pry')
+  s.add_development_dependency('simplecov')
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- test/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/factories/artists.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+
+  factory :artist, :class => MusicBlender::Artist do
+    sequence(:name) { |counter| "Factory Generated #{counter}" }
+  end
+
+end

data/test/factories/music_folders.rb

@@ -0,0 +1,15 @@
+FactoryGirl.define do
+
+  factory :music_folder, :class => MusicBlender::MusicFolder do
+    path '/some/music/path/'
+
+    factory :music_folder_with_tracks do
+      after(:create) do |music_folder|
+        3.times { music_folder.tracks << create(:track) }
+      end
+    end
+
+  end
+
+end
+

data/test/factories/tracks.rb

@@ -0,0 +1,12 @@
+FactoryGirl.define do
+
+  factory :track, :class => MusicBlender::Track do
+    association :artist
+    association :music_folder
+    sequence(:title) { |counterx| "Factory Generated #{counterx}" }
+    sequence(:relative_path) { |counter| "/some/path/#{counter}.mp3" }
+    sequence(:last_played_at) { |counter| counter.hours.ago }
+    rating 5
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'simplecov'
+require 'minitest/autorun'
+require 'factory_girl'
+require 'pry'
+require 'assert_difference'
+
+SimpleCov.start
+
+require 'music_blender'
+
+FactoryGirl.find_definitions
+module MusicBlender
+  MUSIC_PATH = "#{BLENDER_ROOT}/test/music"
+
+  class MiniTest::Unit::TestCase
+    include AssertDifference
+    include FactoryGirl::Syntax::Methods
+
+    ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+    silence_stream(STDOUT)  { load("#{BLENDER_ROOT}/db/schema.rb") }
+
+    def before_setup
+      super
+      capture_stdout
+      Track.any_instance.stubs(:persist_rating_to_id3_tag)
+      Track.any_instance.stubs(:id3_adapter => OpenStruct.new(:title => 'foo', :artist => 'bar', :rating => 42))
+    end
+
+    def after_teardown
+      super
+      release_stdout
+    end
+
+    #Capture STDOUT from program for testing and not cluttering test output
+    def capture_stdout
+      @stdout = $stdout
+      $stdout = StringIO.new
+    end
+
+    def release_stdout
+      $stdout = @stdout
+    end
+
+    #Redirect intentional puts from within tests to the real STDOUT for troublshooting purposes.
+    def puts(*args)
+      @stdout.puts(*args)
+    end
+
+  end
+end
+require 'mocha/setup'