dhun 0.5.6 → 0.6.0

data/lib/dhun/player.rb

@@ -4,112 +4,137 @@ module Dhun
   class Player
     include Singleton
 
-    attr_reader :queue
-    attr_reader :history
-    attr_reader :status
-    attr_reader :current
-
-    attr_reader :logger
+    attr_accessor :queue,:history,:status,:current,:logger
 
     def initialize
-      @queue = []
-      @history = []
+      @queue,@history = [],[]
       @logger = Logger.instance
       @status = :stopped
     end
 
-    def empty_queue
-      stop
-      @queue.clear
-    end
-
-
-    def play_files(files)
-      if files.empty?
-        logger.log "Empty Queue"
-      else
-        stop
-        empty_queue
-        files.each { |f| self.queue.push f }
-        play
-      end
-    end
-
+    # enqueue files and call play.
     def enqueue(files)
-      files.each { |f| self.queue.push f }
-      play
+      return false if files.empty?
+      files.each { |f| self.queue.push f }; play
+      return true
+    end
+    
+    # clear the queue and stops playback
+    def clear
+      stop ; @queue.clear
+      return true
     end
 
+    # commence playback
     def play
-      return unless self.status == :stopped
+      return :empty if @queue.empty?
+      return false if @status == :playing
+      return resume if @status == :paused
       @status = :playing
-      @player_thread = Thread.new do
-        while  @status == :playing and !queue.empty?
-          @current = @queue.shift
-          logger.log "Playing #{@current}"
-          DhunExt.play_file @current
-          @history.unshift @current
-        end
-        @status = :stopped
-        @current = nil
-      end
+      @player_thread = play_thread
+      return true
     end
 
+    # pause playback
+    # only on :playing
     def pause
       if @status == :playing
         @status = :paused
         DhunExt.pause
+        @logger.debug "pause"
+        return true
       end
+      return false
     end
 
+    # resume playback
+    # only on :paused
     def resume
       if @status == :paused
         @status = :playing
         DhunExt.resume
+        @logger.debug "resume"
+        return true
       end
+      return false
     end
 
+    # stops the song
+    # unless :stopped
     def stop
-      @status = :stopped
-      DhunExt.stop
-      # Wait for @player_thread to exit cleanly
-      @player_thread.join unless @player_thread.nil?
-      logger.debug "Stopped"
+      unless @status == :stopped
+        @status = :stopped
+        DhunExt.stop
+        # Wait for @player_thread to exit cleanly
+        @player_thread.join unless @player_thread.nil?
+        @logger.debug "Stopped"
+        return true
+      end
+      return false
     end
 
+    # plays next song on queue.
+    # returns next_track or false if invalid
     def next(skip_length = 1)
-      logger.debug "Switching to next"
-      unless @queue.size < skip_length
-        stop # stops current track
-        @queue.shift skip_length-1 # Remove skip_length-1 tracks
+      unless skip_length > @queue.size
+        @logger.debug "next invoked"
+        stop
+        @queue.shift(skip_length - 1) #skip_length returns starting with first on queue.
         next_track = @queue.first
-        play # start playing with the next track
+        play
+        return next_track
       end
-      return next_track
+      return false
     end
 
+    # when :stopped
+    # returns the first song in history
+    # when :playing
+    # returns the second song in history as first song is current song
     def prev(skip_length = 1)
-      logger.debug "Switching to prev"
-      unless @history.size < skip_length
-        unless @status == :stopped
-          stop
-          # history has increased by one
-          skip_length = skip_length + 1
-        end
+      # skip current track if playing
+      if @status == :playing
+        stop ; skip_length += 1
+      end
+      unless skip_length > @history.size
+        @logger.debug "previous invoked"
         tracks = @history.shift skip_length
-        logger.debug tracks
-        tracks.each { |t| @queue.unshift t }
-        prev_track = @queue.first
-        play # start playing with the next track
+        tracks.each { |track| @queue.unshift track }
+        previous = @queue.first
+        play
+        return previous
       end
-      return prev_track
+      return false
     end
 
+    # shuffle queue if queue is not empty
+    # ensures that shuffled queue is not equal to previous queue order
+    # NOTE: if they enqueue all the same songs, this will NOT end. should catch that.
     def shuffle
-      return if @queue.empty?
-      s = @queue.size
-      s.downto(1) { |n| @queue.push @queue.delete_at(rand(n)) }
-      logger.debug @queue
+      return false if @queue.empty? or @queue.uniq.size == 1 # this will catch a playlist of same songs
+      q = @queue.clone
+      while q == @queue
+        @queue.size.downto(1) { |n| @queue.push @queue.delete_at(rand(n)) }
+      end
+      @logger.debug @queue
+      return true
+    end
+    
+    private
+    
+    # play method's player thread
+    def play_thread
+      Thread.new do
+        while  @status == :playing and !@queue.empty?
+          @current = @queue.shift
+          @logger.log "Playing #{@current}"
+          DhunExt.play_file @current
+          @history.unshift @current
+        end
+        @status = :stopped
+        @current = nil
+      end
     end
+    
   end
 end

data/lib/dhun/query.rb

@@ -3,64 +3,85 @@ require 'dhun_ext'
 module Dhun
   class Query
 
-    MD_ITEMS = [:kMDItemAlbum, :kMDItemAuthors, :kMDItemComposer, :kMDItemDisplayName, :kMDItemFSName, :kMDItemTitle, :kMDItemMusicalGenre]
-    MAPPINGS = { "file" => :kMDItemFSName, "album" => :kMDItemAlbum, "artist" => :kMDItemAuthors, "title" => :kMDItemTitle, "genre" => :kMDItemMusicalGenre }
+    MAPPINGS = {
+      :file => :kMDItemFSName,
+      :album => :kMDItemAlbum,
+      :artist => :kMDItemAuthors,
+      :title => :kMDItemTitle,
+      :genre => :kMDItemMusicalGenre,
+      :composer => :kMDItemComposer,
+      :display => :kMDItemDisplayName
+    }
 
-    attr_reader :spotlight_query
+    attr_accessor :spotlight_query,:is_valid,:logger,:query_search,:query_fields
 
-    def initialize(args)
-      @query_args = args
-      parse
+    def initialize(search=nil,fields={})
+      @logger = Dhun::Logger.instance
+      @query_search = search
+      @query_fields = fields
+      @is_valid = parse!
     end
 
-    def parse
-      return if @query_args.empty?
-      filters = []
-      strings = []
+    # parses all search terms and stores query
+    # return false if both are empty.
+    def parse!
+      return false if @query_search.nil? and @query_fields.empty?
 
-      @query_args.each do |arg|
-        # Check if it is a filter
-        if filter?(arg)
-          filters.push(arg)
-        else
-          strings.push(arg)
-        end
-      end
+      mappings = MAPPINGS.values   #instantiate mappings to be picked off by query methods
+      #create the queries
+      filter_query = create_filter_query(@query_fields,mappings)
+      string_query = create_string_query(@query_search,mappings)
+      @spotlight_query = create_spotlight_query(filter_query,string_query)
 
-      mappings = MD_ITEMS.clone
-      fq = filters.collect do |f|
-             fltr,query = *(f.split(":"))
-             md_item = MAPPINGS[fltr]
-             mappings.delete md_item
-             "#{md_item} == '#{query.strip}'wc"
-           end.join(" && ")
-
-
-      template = "%s == '%s'wc"
-      sq = strings.collect do |keyword|
-        q = mappings.collect { |key|  template % [key,keyword]  }.join(" || ")
-        "( #{q} )"
-      end.join(" && ")
+      @logger.debug @spotlight_query
+      return true
+    end
 
-      @spotlight_query = ["kMDItemContentTypeTree == 'public.audio'", fq, sq].select { |s| s.length > 0 }.join(" && ")
-      Logger.instance.debug @spotlight_query
-      @is_valid = true
+    # create filter queries
+    # { :album => 'test' } => "kMDItemAlbum == 'test'wc"
+    # ADDITIONALLY, throws out any non matching filters
+    # { :album => 'test', :booger => 'one' } => "kMDItemAlbum == 'test'wc"
+    def create_filter_query(filters,mappings)
+      filters.collect do |field,value|
+        md_item = MAPPINGS[field.to_sym]
+        next unless md_item # makes sure that field is to sym, or funky stuff happens
+        mappings.delete md_item
+        "#{md_item} == '#{value}'wc && "
+      end.join.chomp(" && ")
     end
 
-    def is_valid?
-      @is_valid
+    # create string queries
+    # this sets string to all fields not already matched
+    # by create_filter_query
+    # 'test' => "( kMDItemTitle == 'holy'wc || kMDItemMusicalGenre == 'holy'wc )"
+    # if kMDItemTitle and kMDItemMusicalGenre are the only fields left open.
+    # returns "" if given nil
+    # if given multiple strings:
+    # 'holy','test' =>
+    # ( kMDItemTitle == 'holy'wc || kMDItemMusicalGenre == 'holy'wc ) && ( kMDItemTitle == 'test'wc || kMDItemMusicalGenre == 'test'wc )
+    def create_string_query(strings,mappings)
+      return "" unless strings
+      strings.collect do |keyword|
+        query = mappings.collect { |key| "%s == '%s'wc" % [key,keyword] }.join(" || ")
+        "( #{query} )"
+      end.join(" && ")
     end
 
-    def filter?(str)
-      return false unless str.index ":"
-      a,b = *(str.split(":"))
-      # Check if filter is valid
-      return MAPPINGS.keys.member?(a)
+    # create spotlight queries
+    # with {:album => 'test'},"" =>
+    # "kMDItemContentTypeTree == 'public.audio' && kMDItemAlbum == 'test'wc"
+    def create_spotlight_query(filter_query,string_query)
+      ["kMDItemContentTypeTree == 'public.audio'", filter_query, string_query].select do |s|
+        s.length > 0
+      end.join(" && ")
     end
 
     # Use extension to query spotlight
     def execute_spotlight_query
       return DhunExt.query_spotlight(@spotlight_query)
     end
+
+    def is_valid?; @is_valid; end
+
   end
 end

data/lib/dhun/result.rb

@@ -1,31 +1,31 @@
 require 'json'
 module Dhun
   class Result
+    attr_reader :data
     
     def initialize(result, message, options = {})
-      @response = { :result => result,:message => message}
-      @response.merge!(options)
+      @data = { :result => result.to_sym, :message => message }.merge(options)
     end
 
     def success?
-      @response[:result].to_sym == :success
+      @data[:result] == :success
     end
 
     def error?
-      @response[:result].to_sym == :error
+      @data[:result] == :error
     end
-
+    
     def [](sym)
-      @response[sym] || @response[sym.to_s]
+      @data[sym.to_sym] || @data[sym.to_s]
     end
     
     def to_json
-      @response.to_json
+      @data.to_json
     end
 
     def self.from_json_str(resp_json)
       resp = JSON.parse(resp_json)
-      Result.new(resp["result"],resp["message"],resp)
+      Result.new resp.delete('result'), resp.delete('message'), resp
     end
 
   end

data/lib/dhun/runner.rb

@@ -1,104 +1,222 @@
-require 'optparse'
+require 'thor'
+require 'json'
 
 module Dhun
 
-  # Heavily lifted from Thin codebase
-  class Runner
-    COMMANDS = %w(start query)
-    CLIENT_COMMANDS = %w(stop play pause resume next prev enqueue status shuffle history)
-    # Parsed options
-    attr_accessor :options
-
-    # Name of the command to be runned.
-    attr_accessor :command
-
-    # Arguments to be passed to the command.
-    attr_accessor :arguments
-
-    # Return all available commands
-    def self.commands
-      commands  = COMMANDS + CLIENT_COMMANDS
-      commands
-    end
-
-    def initialize(argv)
-      @argv = argv
-      # Default options values
-      @options = {
-        :socket => "/tmp/dhun.sock",
-        :default_log       => "/tmp/dhun.log"
-      }
-      parse!
-    end
-
-    def parser
-      # NOTE: If you add an option here make sure the key in the +options+ hash is the
-      # same as the name of the command line option.
-      # +option+ keys are used to build the command line to launch other processes,
-      # see <tt>lib/dhun/command.rb</tt>.
-      @parser ||= OptionParser.new do |opts|
-        opts.banner =  <<-EOF
-Usage:
-   dhun start
-   dhun play spirit
-   dhun pause
-   dhun resume
-   dhun enqueue rahman
-   dhun status
-   dhun shuffle
-   dhun stop
-
-   For more details see README at http://github.com/deepakjois/dhun
-EOF
-        opts.separator ""
-        opts.on("-d", "--daemonize", "Run daemonized in the background")                { @options[:daemonize] = true }
-        opts.on("-l", "--log FILE", "File to redirect output " +
-                                      "(default: #{@options[:default_log]})")                   { |file| @options[:log] = file }
-
-        opts.separator "Common options:"
-        opts.on_tail("-h", "--help", "Show this message")  { puts opts; exit }
-        opts.on_tail("-D", "--debug", "Set debugging on")                               { @options[:debug] = true }
-        opts.on_tail("-h", "--help", "Show this message")                               { puts opts; exit }
-        opts.on_tail('-v', '--version', "Show version")                                 { puts "Dhun " + Dhun::VERSION; exit }
+  class Runner < Thor
+    include Thor::Actions
+    include Dhun::Client
 
+    def self.banner(task)
+      task.formatted_usage(self).gsub("dhun:runner:","dhun ")
+    end
+
+    desc "start_server","Starts the Dhun Server."
+    method_option :socket, :type => :string, :default => "/tmp/dhun.sock", :aliases => '-s'
+    method_option :log, :type => :string, :default => "/tmp/dhun.log", :aliases => '-l'
+    method_option :foreground, :type => :boolean, :default => false, :aliases => '-f'
+    method_option :debug, :type => :boolean, :default => false, :aliases => '-D'
+    def start_server
+      unless server_running?(options[:socket],:silent)
+        server_path = File.join File.dirname(__FILE__), 'server.rb'
+        cmd = options[:foreground] ? 'run' : 'start'
+        say "Starting Dhun", :green
+        system("ruby #{server_path} #{cmd} -- #{options[:socket]} #{options[:log]}")
+      else
+        say "Dhun Server is already running", :yellow
       end
     end
 
-    def parse!
-      parser.parse! @argv
-      @command   = @argv.shift
-      @arguments = @argv
+    desc "stop_server","Stop the Dhun Server"
+    def stop_server
+      server_path = File.join File.dirname(__FILE__), 'server.rb'
+      system("ruby #{server_path} stop")
+      say "Stopping Dhun", :green
     end
 
-    # Parse the current shell arguments and run the command.
-    # Exits on error.
-    def run!
-      logger = Logger.instance
-      logger.log_level = :debug if @options[:debug]
-      if self.class.commands.include?(@command)
-        if CLIENT_COMMANDS.include?(@command)
-           unless DhunClient.is_dhun_server_running?(@options[:socket])
-             puts "Please start Dhun server first with : dhun start"
-             exit 1
-           end
+    desc "query SEARCH","Show files matching query. ex: dhun query bob,'the marley'
+    \t\t\t See docs for details on query syntax"
+    method_option :artist, :type => :string, :aliases => '-a'
+    method_option :album, :type => :string, :aliases => '-l'
+    method_option :genre, :type => :string, :aliases => '-g'
+    method_option :file, :type => :string, :aliases => '-f'
+    method_option :title, :type => :string, :aliases => '-t'
+    def query(search=nil)
+      search = search.nil? ? nil : search.split(',')
+      query = Dhun::Query.new(search,options)
+      if query.is_valid?
+        
+        #make the prompt pretty. i think.
+        opts = options.collect {|field,value| "#{field}:#{value}" }.join(" ")
+        term = search.nil? ? '[nil]' : search.join(",")
+        say "Querying: #{term} | #{opts}", :cyan
+
+        # commence the query, and respond as so.
+        files = query.execute_spotlight_query
+        if files.empty?
+          say "No Results Found", :red
+        else
+          say "#{files.size} Results", :green
+          say_list files
         end
-        run_command
-      elsif @command.nil?
-        puts "Command required"
-        puts @parser
-        exit 1
       else
-        abort "Unknown command: #{@command}. Use one of #{self.class.commands.join(', ')}"
+        say "Invalid Query Syntax. See docs for correct syntax", :yellow
+      end
+      files
+    end
+
+    desc "play SEARCH","Play songs matching query. ex: dhun play bob,'the marley'
+    \t\t\t See docs for details on query syntax"
+    method_option :artist, :type => :string, :aliases => '-a'
+    method_option :album, :type => :string, :aliases => '-l'
+    method_option :genre, :type => :string, :aliases => '-g'
+    method_option :file, :type => :string, :aliases => '-f'
+    method_option :title, :type => :string, :aliases => '-t'
+    def play(search=nil)
+      return return_response(:play,[]) if search.nil? and options.empty?
+      return_response(:clear,[])
+      invoke :enqueue, [search], options
+    end
+
+    desc "enqueue SEARCH","Enqueue songs matching query. ex: dhun enqueue bob,'the marley'
+    \t\t\t See docs for details on query syntax"
+    method_option :artist, :type => :string, :aliases => '-a'
+    method_option :album, :type => :string, :aliases => '-l'
+    method_option :genre, :type => :string, :aliases => '-g'
+    method_option :file, :type => :string, :aliases => '-f'
+    method_option :title, :type => :string, :aliases => '-t'
+    def enqueue(search=nil)
+      
+      # invoke query command and return us all the files found.
+      files = invoke :query, [search], options
+      if files and !files.empty?
+        #prompt for index of song to play and return it in pretty format. cough.
+        if files.size == 1 # Dont prompt if result size is 1
+          indexes = [0]
+        else
+          answer = ask "Enter index to queue (ENTER to select all): ",:yellow
+
+          indexes ||=
+          case
+          when answer.include?(',') then answer.split(',')
+          when answer.include?(' ') then answer.split(' ')
+          when answer.size >= 1 then answer.to_a
+          else
+            0..(files.size - 1)
+          end
+        end
+        selected = indexes.map { |index| files[index.to_i] }
+        say "selected:",:green
+        say_list selected
+        
+        return_response(:enqueue,nil,selected)
       end
     end
 
-    def run_command
-      controller = Controller.new(@options)
-      begin
-        controller.send(@command,*@arguments)
-      rescue ArgumentError
-        abort "Illegal arguments passed to #{@command}"
+    desc "next COUNT", "Skips to next song by COUNT"
+    def next(count=1)
+      return_response(:next,[],count.to_i)
+    end
+    
+    desc "prev COUNT", "Skips to previous song by COUNT"
+    def prev(count=1)
+      return_response(:prev,[],count.to_i)
+    end
+
+    desc "status", "Shows the status"
+    def status
+      return unless server_running?
+      response = return_response(:status,[:current,:queue])
+      say "Currently Playing:",:magenta
+      say response[:current],:white
+      say "Queue:",:cyan
+      say_list response[:queue]
+    end
+
+    desc "history", "Shows the previously played songs"
+    def history
+      response = return_response(:history,[:history])
+      if response[:history]
+        say "History:",:cyan
+        say_list response[:history]
+      end
+    end
+    
+    desc "shuffle", "Shuffles the queue"
+    def shuffle
+      response = return_response(:shuffle,[:queue])
+      if response[:queue]
+        say "Queue:",:cyan
+        say_list response[:queue]
       end
     end
+
+    desc "pause", "Pauses playing"
+    def pause
+      return_response(:pause,[])
+    end
+    
+    desc "resume", "Resumes playing"
+    def resume
+      return_response(:resume,[])
+    end
+    
+    desc "stop", "Stops playing"
+    def stop
+      return_response(:stop,[])
+    end
+
+
+    private
+
+    # sends command to dhun client
+    def send_command(command,arguments=[])
+      cmd = { "command" => command.to_s, "arguments" => arguments }.to_json
+      send_message(cmd,"/tmp/dhun.sock")
+    end
+
+    # send command to the server and retrieve response.
+    def get_response(command,arguments=[])
+      if server_running?
+          resp = send_command(command,arguments)
+          return Dhun::Result.from_json_str(resp)
+      end
+    end
+    
+    # prints out list with each index value
+    # in pretty format! (contrasting colors)
+    def say_list(list)
+      list.each_with_index do |item,index|
+        color = index.even? ? :white : :cyan
+        say("#{index} : #{item}",color)
+      end
+    end
+
+    # check to see if Dhun Server is running.
+    # asks to start Dhun server if not
+    # takes argument :silent to quiet its output.
+    # need to make the socket choices more flexible
+    def server_running?(socket = "/tmp/dhun.sock",verbose = :verbose)
+      socket ||= "/tmp/dhun.sock"
+      if is_server?(socket)
+        return true
+      else
+        say("Please start Dhun server first with : dhun start_server", :red) unless verbose == :silent
+        return false
+      end
+    end
+    
+    #send out the command to server and see what it has to say.
+    def return_response(action,keys,argument=[])
+      response = get_response(action,argument)
+      if response
+        color = response.success? ? :red : :cyan
+        say response[:message], color
+        if keys
+          return keys.inject({}) {|base,key| base[key.to_sym] = response[key.to_sym] ; base}
+        end
+      end
+    end
+
   end
 end