hearken 0.1.2 → 0.1.3

data/bin/hearken_scrobble

@@ -1,35 +0,0 @@
-#!/usr/bin/env ruby
-
-$: << File.dirname(__FILE__)+'/../lib'
-
-command = ARGV.shift
-
-unless %w{setup start finish}.include? command
-  puts 'usage:'
-  puts '  hearken_scrobble setup'
-  puts '  hearken_scrobble start PATH_TO_AUDIO_FILE'
-  puts '  hearken_scrobble finish PATH_TO_AUDIO_FILE'
-  exit 0
-end
-
-require 'hearken/indexing/ffmpeg_file'
-require 'hearken/scrobbler'
-
-scrobbler = Hearken::Scrobbler.new
-scrobbler.enabled = true
-
-if command == 'setup'
-  scrobbler.setup
-  exit 0
-end
-
-file = ARGV.shift
-track = Hearken::Indexing::FfmpegFile.from_file file
-
-if command == 'start'
-  scrobbler.started track
-elsif command == 'finish'
-  scrobbler.finished track
-else
-  puts 'unknown command'
-end

data/bin/hearken_tags

@@ -1,11 +0,0 @@
-#!/usr/bin/env ruby
-
-$: << File.dirname(__FILE__)+'/../lib'
-
-
-require 'pp'
-require 'hearken/indexing/ffmpeg_file'
-
-ARGV.each do |path|
-  pp Hearken::Indexing::FfmpegFile.from_file path
-end

data/lib/hearken/command/list.rb

@@ -1,32 +0,0 @@
-require 'hearken/command'
-require 'hearken/colour'
-
-class Hearken::Command::List
-  include Hearken::Command
-  include Hearken::Colour
-
-  usage '*<word>'
-  help <<EOF
-lists the contents of the track queue
-these results can optionally be filtered by specified words
-when playing, approximate times for each track will be displayed
-EOF
-  execute do |text|
-    @terms = text.split(/\W/)
-    current = @player.current
-    if current
-      next_start_time = Time.at current.started
-      show next_start_time, current
-    end
-    next_start_time += current.time.to_i if next_start_time && current.time
-    @player.each do |track|
-      show next_start_time, track
-      next_start_time += track.time.to_i if next_start_time && track.time
-    end
-  end
-
-  def show time, track
-    return unless @terms.empty? or @terms.all? {|term| track.search_string.include? term }
-    puts time ? "#{c time.strftime("%H:%M:%S %d/%m/%Y"), :blue} #{track}" : track
-  end
-end

data/lib/hearken/command/love.rb

@@ -1,7 +0,0 @@
-require 'hearken/command'
-
-class Hearken::Command::Love
-  include Hearken::Command
-  help 'sends love for the current track to last fm'
-  execute {|ignored| @player.love }
-end

data/lib/hearken/command/profile.rb

@@ -1,7 +0,0 @@
-require 'hearken/command'
-
-class Hearken::Command::Profile
-  include Hearken::Command
-  help 'launches last fm profile'
-  execute {|ignored| @player.profile }
-end

data/lib/hearken/command/recent.rb

@@ -1,38 +0,0 @@
-require 'hearken/command'
-require 'hearken/colour'
-
-class Hearken::Command::Recent
-  include Hearken::Command
-  include Hearken::Colour
-
-  usage '<count>'
-  help 'lists the specified number of recently added albums'
-  execute do |text|
-    @player.library.reload unless @player.library.tracks
-    all_tracks = @player.library.tracks.sort do |a, b|
-      tc = a.timestamp <=> b.timestamp
-      tc == 0 ? a.id <=> b.id : tc
-    end
-    maximum, current_album, tracks, total_count = text.to_i, nil, [], 0
-    all_tracks.reverse.each do |track|
-      unless current_album
-        current_album = track.album
-        tracks = [track]
-        next
-      end
-      if current_album==track.album
-        tracks << track
-      else
-        puts "#{c extract_artist(tracks), :yellow} #{c current_album, :cyan} #{tracks.size} tracks [#{tracks.last.search_id}-#{tracks.first.search_id}]"
-        current_album = track.album
-        tracks = [track]
-        total_count += 1
-      end
-      break if total_count >= maximum
-    end
-  end
-private
-  def extract_artist tracks
-    tracks.map{|t| t.artist}.uniq.size == 1 ? tracks.first.artist : 'various artists'
-  end
-end

data/lib/hearken/command/remove.rb

@@ -1,15 +0,0 @@
-require 'hearken/command'
-
-class Hearken::Command::Remove
-  include Hearken::Command
-  usage '*<word>'
-  help 'removes all tracks that match the specified criteria - specifying no criteria will flush entire queue'
-  execute do |text|
-    @terms = text.split(/\W/)
-    ids = []
-    while track = @player.dequeue
-      ids << track.id unless @terms.all? {|term| track.search_string.include? term }
-    end
-    ids.each {|id| @player.enqueue id }
-  end
-end

data/lib/hearken/command/restart.rb

@@ -1,7 +0,0 @@
-require 'hearken/command'
-
-class Hearken::Command::Restart
-  include Hearken::Command
-  help 'stops and restarts the player (which will kill the current track)'
-  execute {|ignored| @player.restart }
-end

data/lib/hearken/command/scrobbling.rb

@@ -1,14 +0,0 @@
-require 'hearken/command'
-
-class Hearken::Command::Scrobbling
-  include Hearken::Command
-  usage '<on|off>'
-  help 'turns interaction with lastfm on or off'
-  execute do |text|
-    scrobbling = (text == 'on')
-    return if @player.scrobbling == scrobbling
-    puts scrobbling ? 'Turning scrobbling on' : 'Turning scrobbling off'
-    @player.scrobbling = scrobbling
-    @player.restart
-  end
-end

data/lib/hearken/command/setup_scrobbling.rb

@@ -1,7 +0,0 @@
-require 'hearken/command'
-
-class Hearken::Command::SetupScrobbling
-  include Hearken::Command
-  help 'runs through the steps required to get lastfm scrobbling working'
-  execute {|ignored| @player.scrobbler.setup }
-end

data/lib/hearken/command/shuffle.rb

@@ -1,13 +0,0 @@
-require 'hearken/command'
-
-class Hearken::Command::Shuffle
-  include Hearken::Command
-  help 'shuffles the current queue'
-  execute do |ignored=nil|
-    ids = []
-    while track = @player.dequeue
-      ids << track.id
-    end
-    ids.sort_by { rand }.each {|id| @player.enqueue id }
-  end
-end

data/lib/hearken/command/start.rb

@@ -1,7 +0,0 @@
-require 'hearken/command'
-
-class Hearken::Command::Start
-  include Hearken::Command
-  help 'starts the player'
-  execute {|ignored| @player.start }
-end

data/lib/hearken/command/status.rb

@@ -1,7 +0,0 @@
-require 'hearken/command'
-
-class Hearken::Command::Status
-  include Hearken::Command
-  help 'shows the current player status'
-  execute {|ignored| puts @player.status }
-end

data/lib/hearken/command/stop.rb

@@ -1,7 +0,0 @@
-require 'hearken/command'
-
-class Hearken::Command::Stop
-  include Hearken::Command
-  help 'stops the player'
-  execute {|ignored| @player.stop }
-end

data/lib/hearken/command.rb

@@ -1,35 +0,0 @@
-module Hearken
-  module Command
-    attr_reader :usage, :help
-
-    def self.included cls
-      cls.extend ClassMethods
-    end
-
-    def self.load name, *args
-      require "hearken/command/#{name}"
-      classname = name.to_s.split('_').map{|s|s.capitalize}.join
-      Hearken::Command.const_get(classname).new *args
-    end
-
-    def initialize player
-      @player = player
-      @usage = ''
-      @help = ''
-    end
-
-    module ClassMethods
-      def usage usage
-        define_method(:usage) { usage }
-      end
-
-      def help help
-        define_method(:help) { help }
-      end
-
-      def execute &block
-        define_method :execute, block
-      end
-    end
-  end
-end

data/lib/hearken/notification/growl_notifier.rb

@@ -1,15 +0,0 @@
-require 'hearken/monkey_violence'
-
-module Hearken::Notification
-end
-
-class Hearken::Notification::GrowlNotifier
-  def initialize preferences
-    @growlnotify = !`which growlnotify`.chomp.empty?
-    @image_path = File.expand_path File.dirname(__FILE__)+'/../../../media/ice_cream.png'
-  end
-
-  def started track
-    `growlnotify -t "Hearken unto ..." --image #{@image_path} -m \"#{track.to_short_s.escape_for_sh_quoted}\"` if @growlnotify
-  end
-end

data/lib/hearken/player.rb

@@ -1,130 +0,0 @@
-require 'fileutils'
-
-require 'hearken/queue'
-require 'hearken/scrobbler'
-require 'hearken/notification/growl_notifier'
-require 'hearken/library'
-require 'hearken/colour'
-
-module Hearken
-  class Player
-    include Queue
-    include Colour
-    attr_reader :library, :scrobbler
-
-    def initialize preferences
-      @scrobbler = Scrobbler.new preferences
-      @scrobbler.enabled = true
-      @growl = Hearken::Notification::GrowlNotifier.new preferences
-      @notifiers = [@scrobbler, @growl]
-      @library = Library.new preferences
-      @library.reload
-      create_paths
-    end
-
-    def status
-      if @pid
-        track = self.current
-        played = Time.now.to_i-track.started
-        timing = "(#{c track.time.to_i-played, :yellow} remaining)" if track.time
-        puts "#{c Time.at(track.started).strftime("%H:%M:%S %d/%m/%Y"), :blue}: #{track} #{timing}"
-      else
-        puts c 'not playing', :yellow
-      end
-    end
-
-    def love
-      @scrobbler.love current
-    end
-
-    def profile
-      @scrobbler.profile
-    end
-
-    def current
-      in_base_dir do
-        (@pid and File.exist?('current_song')) ? YAML.load_file('current_song') : nil
-      end
-    end
-
-    def register track
-      track.started = Time.now.to_i
-      in_base_dir do
-        File.open('current_song', 'w') {|f| f.print track.to_yaml }
-        File.open('history', 'a') {|f| f.puts "#{track.started},#{track.path}"}
-      end
-    end
-
-    def notify_started track
-      @notifiers.each {|notifier| notifier.started track if notifier.respond_to? :started}
-    end
-
-    def notify_finished track
-      @notifiers.each {|notifier| notifier.finished track if notifier.respond_to? :finished}
-    end
-
-    def scrobbling
-      @scrobbler.enabled
-    end
-
-    def scrobbling= tf
-      @scrobbler.enabled = tf
-    end
-
-    def random_track
-      @library.row (rand * @library.count).to_i
-    end
-
-    def start
-      return if @pid
-      if @library.count == 0
-        puts 'Player can not be started with an empty library'
-        puts 'Please run "hearken_index" in another shell and then \'reload\''
-        return
-      end
-      @pid = fork do
-        player_pid = nil
-        Signal.trap('TERM') do
-          Process.kill 'TERM', player_pid if player_pid
-          exit
-        end
-        loop do
-          track = dequeue || random_track
-          next unless track
-          unless File.exist? track.path
-            puts "skipping track as #{track.path} does not exist"
-            next
-          end
-          notify_started track
-          register track
-          player_pid = spawn play_command track.path
-          Process.wait player_pid
-          notify_finished track
-        end
-      end
-    end
-
-    def play_command path
-      if %w{m4a mp3}.include? path.split('.').last
-        "afplay \"#{path.escape("\`")}\""
-      else
-        "play -q \"#{path.escape("\`")}\""
-      end.tap do |command|
-        in_base_dir do
-          File.open('player', 'a') {|f| f.puts command }
-        end
-      end
-    end
-
-    def stop
-      return unless @pid
-      Process.kill 'TERM', @pid
-      @pid = nil
-    end
-
-    def restart
-      stop
-      start
-    end
-  end
-end

data/lib/hearken/preferences.rb

@@ -1,33 +0,0 @@
-require 'yaml'
-require 'hearken/paths'
-require 'hearken/monkey_violence'
-
-module Hearken; end
-
-module Hearken
-  class Preferences
-    include Hearken::Paths
-
-    def initialize
-      create_paths
-      if File.exists? preferences_path
-        @preferences = YAML.load_file preferences_path
-      else
-        @preferences = {}
-      end
-    end
-
-    def [] key
-      @preferences[key]
-    end
-
-    def []= key, value
-      @preferences[key] = value
-      persist
-    end
-
-    def persist
-      File.open(preferences_path, 'w') {|f| f.puts @preferences.to_yaml}
-    end
-  end
-end

data/lib/hearken/queue.rb

@@ -1,33 +0,0 @@
-require 'hearken/paths'
-
-module Hearken::Queue
-  include Hearken::Paths
-
-  def enqueue id
-    in_queue_dir do 
-      @sequence ||= 0
-      @library.with_track id do |track|
-        File.open("#{Time.now.to_i}-#{@sequence.to_s.rjust(8,'0')}.song", 'w') {|f| f.print track.to_yaml }
-        @sequence += 1
-      end
-    end
-  end
-
-  def each
-    in_queue_dir do
-      Dir.glob('*.song').sort.each do |file|
-        yield YAML.load_file file
-      end
-    end
-  end
-
-  def dequeue
-    in_queue_dir do
-      file = Dir.glob('*.song').sort.first
-      return nil unless file
-      hash = YAML.load_file file
-      FileUtils.rm file
-      hash
-    end
-  end
-end

data/lib/hearken/scrobbler.rb

@@ -1,82 +0,0 @@
-require 'hearken/preferences'
-require 'hearken/simple_scrobbler'
-require 'hearken/debug'
-
-# Modified version of simple_scrobbler gem from https://github.com/threedaymonk/simple_scrobbler
-module Hearken
-  class Scrobbler
-    API_KEY = '21f8c75ad38637220b20a03ad61219a4'
-    SECRET = 'ab77019c84eef8bc16bcfd5ba8db0c5d'
-    include Debug
-
-    def initialize preferences=Hearken::Preferences.new
-      @preferences = preferences
-    end
-
-    def enabled
-      !!@scrobbler
-    end
-
-    def enabled= tf
-      @scrobbler = nil
-      if @preferences['lastfm'] and tf
-        debug "Configuring scrobbler with #{@preferences['lastfm'].inspect}"
-        user, session = *%w{user session_key}.map{|k| @preferences['lastfm'][k]}
-        @scrobbler = SimpleScrobbler.new API_KEY, SECRET, user, session
-      end
-    end
-
-    def finished track
-      return unless @scrobbler
-      debug "Scrobbling to last fm: #{track}"
-      send_to_scrobbler :scrobble, track
-    end
-
-    def started track
-      return unless @scrobbler
-      debug "Updating now listening with last fm: #{track}"
-      send_to_scrobbler :now_playing, track
-    end
-
-    def love track
-      return unless @scrobbler and track
-      debug "Sending love to last fm: #{track}"
-      send_to_scrobbler :love, track
-    end
-
-    def profile
-      return unless @scrobbler
-      @scrobbler.with_profile_url {|url| system "open #{url}" }
-    end
-
-    def ask question
-      print question
-      $stdin.gets.chomp
-    end
-
-    def setup
-      preferences = {}
-      preferences['user'] = ask 'What is your lastfm user name ? '
-      @scrobbler = SimpleScrobbler.new API_KEY, SECRET, preferences['user']
-      preferences['session_key'] = @scrobbler.fetch_session_key do |url|
-        system "open '#{url}'"
-        ask 'Please hit enter when you\'ve allowed this application access to your account'
-      end
-      @preferences['lastfm'] = preferences
-    end
-private
-    def send_to_scrobbler message, track
-      begin
-        debug %w{artist title time album track}.map {|k| "#{k}=#{track.send(k)}"}.join(',')
-        @scrobbler.send message, track.artist,
-          track.title,
-          :duration => track.time,
-          :album => track.album,
-          :trackNumber => track.track.to_i,
-          :timestamp => Time.now.to_i
-      rescue Exception => e
-        puts "Failed to scrobble: #{e}"
-      end
-    end
-  end
-end

data/lib/hearken/simple_scrobbler.rb

@@ -1,94 +0,0 @@
-require "net/http"
-require "digest/md5"
-require "uri"
-require "cgi"
-require 'nokogiri'
-require 'hearken/debug'
-
-module Hearken; end
-
-class Hearken::SimpleScrobbler
-  include Hearken::Debug
-
-  SCROBBLER_URL = 'http://ws.audioscrobbler.com/2.0/'
-
-  SubmissionError = Class.new(RuntimeError)
-  SessionError    = Class.new(RuntimeError)
-
-  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, :session_key
-
-  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.at('token').inner_text
-    yield "http://www.last.fm/api/auth/?api_key=#{api_key}&token=#{request_token}"
-    doc = lfm :get, 'auth.getsession', :token => request_token
-    @session_key = doc.at('key').inner_text
-    @user        = doc.at('name').inner_text
-    @session_key
-  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.at('lfm')['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
-    debug p.inspect
-    xml = self.send get_or_post, SCROBBLER_URL, p
-    debug xml
-    Nokogiri::XML 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

data/spec/hearken/command/enqueue_spec.rb

@@ -1,24 +0,0 @@
-require_relative '../../spec_helper'
-require 'hearken/command/enqueue'
-
-describe Hearken::Command::Enqueue do
-  extend ShellShock::CommandSpec
-
-  with_usage '*<id>'
-  with_help 'enqueues the list of songs with the specified ids'
-
-  before do
-    @player = double 'player'
-    @command = Hearken::Command::Enqueue.new @player
-  end
-
-  it 'should enqueue whatever is returned from the expander' do
-    expander = double 'expander'
-    allow(Hearken::RangeExpander).to receive(:new) { expander }
-    allow(expander).to receive(:expand).with('some text') { [1,2,3] }
-
-    [1,2,3].each {|id| expect(@player).to receive(:enqueue).with(id) }
-
-    @command.execute "some text"
-  end
-end