cultome_player 2.0.0

data/lib/cultome_player/objects/response.rb

@@ -0,0 +1,42 @@
+module CultomePlayer
+  module Objects
+    class Response
+      attr_reader :data
+
+      def initialize(type, data)
+        @success = type == :success
+        @data = data
+
+        @data.each do |k,v|
+          self.class.send(:define_method, k) do
+            v
+          end
+        end
+      end
+
+      # Check if the success data associated to the response is false.
+      #
+      # @return [Boolean] True if success data is false, False otherwise.
+      def failure?
+        !@success
+      end
+
+      # Check if the success data associated to the response is true.
+      #
+      # @return [Boolean] True if success data is true, False otherwise.
+      def success?
+        @success
+      end
+
+      # Join two response together. The response type makes an OR and parameter response's data is merged into.
+      #
+      # @param response [Response] The response to join.
+      # @return [Response] The calculated new response.
+      def +(response)
+        type = success? && response.success? ? :success : :failure
+        data = @data.merge response.data
+        return Response.new(type, data)
+      end
+    end
+  end
+end

data/lib/cultome_player/objects/song.rb

@@ -0,0 +1,38 @@
+require 'active_record'
+
+module CultomePlayer
+  module Objects
+    # The ActiveRecord model for Song objects.
+    class Song < ActiveRecord::Base
+      belongs_to :artist
+      belongs_to :album
+      has_and_belongs_to_many :genres
+      belongs_to :drive
+      has_many :similars, as: :similar
+
+      scope :connected, -> {joins(:drive).where('drives.connected' => true)}
+      # Get the full path to the song file.
+      #
+      # @return [String] The full path to the song file.
+      def path
+        File.join(self.drive.path, self.relative_path)
+      end
+
+      def to_s
+        str = c4(":::: Song: ")
+        str += c10(self.name)
+
+        unless self.artist.nil?
+          str += c4(" \\ Artist: ")
+          str += c11(self.artist.name)
+        end
+
+        unless self.album.nil?
+          str += c4(" \\ Album: ")
+          str += c13(self.album.name)
+        end
+        str += c4(" ::::")
+      end
+    end
+  end
+end

data/lib/cultome_player/player.rb

@@ -0,0 +1,13 @@
+require 'cultome_player/player/interface'
+require 'cultome_player/player/interactive'
+require 'cultome_player/player/playlist'
+require 'cultome_player/player/adapter'
+
+module CultomePlayer
+  module Player
+    include Interface
+    include Interactive
+    include Playlist
+    include Adapter
+  end
+end

data/lib/cultome_player/player/adapter.rb

@@ -0,0 +1,14 @@
+require 'cultome_player/player/adapter/mpg123'
+
+module CultomePlayer::Player::Adapter
+  include Mpg123
+
+  # Check if media player is running.
+  #
+  # @return [Boolean] True is player is running. False otherwise.
+  def player_running?
+    @is_player_running
+  end
+
+end
+

data/lib/cultome_player/player/adapter/mpg123.rb

@@ -0,0 +1,143 @@
+module CultomePlayer::Player::Adapter
+  module Mpg123
+
+    # Start a playback in the media player.
+    #
+    # @contract Adapter
+    # @param song [Song] The song to be played.
+    def play_in_player(song)
+      @current_song = song
+      unless player_running?
+      	start_player
+      end
+
+      loadfile(song)
+    end
+
+    # Activate the pause in media player.
+    #
+    # @contract Adapter
+    def pause_in_player
+      toggle_pause
+    end
+
+    # Resume playback in media player. If is paused or stopped.
+    #
+    # @contract Adapter
+    def resume_in_player
+      if paused?
+        toggle_pause
+      else
+        play_in_player current_song
+      end
+    end
+
+    # Stop playback in media player.
+    #
+    # @contract Adapter
+    def stop_in_player
+      @user_stopped = true
+      send_to_player "stop"
+    end
+
+    # Fast forward the playback
+    #
+    # @contract Adapter
+    # @param secs [Integer] Number of seconds to fast forward.
+    def ff_in_player(secs)
+      send_to_player "jump +#{secs}s"
+    end
+
+    # Fast backward the playback
+    #
+    # @contract Adapter
+    # @param secs [Integer] Number of seconds to fast backward.
+    def fb_in_player(secs)
+      send_to_player "jump -#{secs}s"
+    end
+
+    # Turn off the media player
+    def quit_in_player
+      begin
+        send_to_player "quit"
+      rescue Exception => e
+      end
+    end
+
+    # Play from the begining the current playback.
+    def repeat_in_player
+      send_to_player "jump 0"
+    end
+
+    private
+
+    def toggle_pause
+      send_to_player "pause"
+    end
+
+    def loadfile(song)
+      send_to_player "load #{song.path}"
+    end
+
+    def send_to_player(cmd)
+      raise 'invalid state:player is not running' unless player_running?
+      control_pipe.puts cmd
+      control_pipe.flush
+    end
+
+    def control_pipe
+      unless pipe_alive?
+        @pipe = File.open(mplayer_pipe, 'a+')
+      end
+      @pipe
+    end
+
+    def pipe_alive?
+      return !(@pipe.nil? || @pipe.closed?)
+    end
+
+    def start_player
+      # creamos el thread que lea la salida del mpg123
+      Thread.new do
+        start_cmd = "mpg123 --fifo #{mplayer_pipe} -R"
+        IO.popen(start_cmd).each do |line|
+          case line
+          	when /^@R MPG123/
+      				@is_player_running = true
+          	when /^@P ([\d])$/
+          		case $1.to_i
+	          		when 0 # stopped
+	          			@playing = @paused = false
+	            		@stopped = true
+                  emit_event(:playback_finish) unless @user_stopped
+                  @user_stopped = false
+	          		when 1 # paused
+			            @stopped = @playing = false
+			            @paused = true
+                  emit_event(:playback_paused)
+	          		when 2 # unpaused
+									@playing = true
+	            		@paused = @stopped = false
+                  emit_event(:playback_resumed)
+            	end
+            when /^@F ([\d]+) ([\d]+) ([\d.]+) ([\d.]+)$/
+	            @playback_time_position = $3.to_f
+	            @playback_time_length = @playback_time_position + $4.to_f
+					end # case line
+        end # IO
+      end # Thread
+
+      wait_player
+    end
+
+    def wait_player
+      count = 0
+      while !player_running?
+        sleep(0.1)
+        count += 1
+        return if count > 50 # 5 seg
+      end
+    end
+
+  end
+end

data/lib/cultome_player/player/interactive.rb

@@ -0,0 +1,56 @@
+module CultomePlayer::Player
+  module Interactive
+
+    PROMPT = "cultome> "
+
+    # Begin a REP loop inside player.
+    def begin_session
+      @in_session = true
+      display "Cultome Player v#{CultomePlayer::VERSION}"
+
+      while in_session?
+        begin
+          r = execute read_command(PROMPT)
+          show_response(r)
+        rescue Exception => e
+          display e.message
+        end
+      end
+    end
+
+    # Check if there is an interactive session in progress.
+    #
+    # @return [Boolean] True if session in progress. False otherwise.
+    def in_session?
+      @in_session ||= false
+    end
+
+    # Terminates a interactive session.
+    def terminate_session
+      @in_session = false
+    end
+
+    private
+
+    def show_response(r)
+      if r.respond_to?(:response_type)
+        res_obj = r.send(r.response_type)
+        if res_obj.respond_to?(:each)
+          res_obj.each.with_index do |elem, idx|
+            display "#{(idx + 1).to_s.ljust(3)} | #{elem.to_s}"
+          end
+        elsif res_obj.class == String
+          display res_obj.to_s
+        else
+          display "(((#{res_obj.to_s})))"
+        end
+
+      elsif r.respond_to?(:message)
+        display r.message
+      else
+        display "!!!#{r}!!!"
+      end
+    end
+
+  end
+end

data/lib/cultome_player/player/interface.rb

@@ -0,0 +1,13 @@
+require 'cultome_player/player/interface/basic'
+require 'cultome_player/player/interface/extended'
+require 'cultome_player/player/interface/helper'
+require 'cultome_player/player/interface/builtin_help'
+
+module CultomePlayer::Player
+  module Interface
+    include Basic
+    include Extended
+    include Helper
+    include BuiltinHelp
+  end
+end

data/lib/cultome_player/player/interface/basic.rb

@@ -0,0 +1,96 @@
+module CultomePlayer
+  module Player
+    module Interface
+      module Basic
+
+        # For more information on this command refer to user manual or inline help in interactive mode.
+        def play(cmd)
+          if cmd.params.empty?
+            # Estos los consideramos comportamientos inteligentes
+            # porque checan el contexto y toman una descision,
+            # por lo tanto la logica no aplica a el comando play normal
+
+            # tocar mientras ya estamos tocando algo??
+            return failure("What you mean? Im already playing!") if playing?
+            # quitamos la pausa
+            return execute "pause off" if paused?
+            # iniciamos ultima la reproduccion desde el principio
+            if stopped? && current_song
+              curr_song = player_object :song
+              return execute "play @song"
+            end
+            # tocamos toda la libreria
+            songs = whole_library
+            return failure("No music connected! You should try 'connect /home/yoo/music => main' first") if songs.empty?
+            playlists[:current, :focus] <= songs
+
+          else
+            songs = select_songs_with cmd
+            # checamos si el tipo de comando es para programar una
+            # nueva playlist o solo para tocar una cancion
+            if play_inline?(cmd)
+              playlists[:queue] << songs
+            else
+              playlists[:current] <= songs
+            end
+          end
+
+          return success(playlist: songs) + execute("next no_history")
+        end
+
+        # For more information on this command refer to user manual or inline help in interactive mode.
+        def pause(cmd)
+          if cmd.params.empty?
+            is_pause = !paused?
+          else
+            is_pause = cmd.params(:boolean).first.value
+          end
+
+          if is_pause
+            pause_in_player
+          else
+            resume_in_player
+          end
+
+          success(message: is_pause ? "Holding your horses" : "Letting it flow", paused: paused?, stopped: stopped?, playing: playing?)
+        end
+
+        # For more information on this command refer to user manual or inline help in interactive mode.
+        def stop(cmd)
+          stop_in_player
+          success(message: "Stoped it!", paused: paused?, stopped: stopped?, playing: playing?)
+        end
+
+        # For more information on this command refer to user manual or inline help in interactive mode.
+        def next(cmd)
+          if playlists[:queue].empty?
+            unless cmd.params(:literal).any?{|p| p.value == 'no_history'}
+              playlists[:history] << current_song
+            end
+            playlists[:queue] << playlists[:current].next
+          end
+
+          # aqui enviamos al reproductor externo a tocar
+          play_queue
+
+          return success(message: "Now playing #{current_song}", now_playing: current_song)
+        end
+
+        # For more information on this command refer to user manual or inline help in interactive mode.
+        def prev(cmd)
+          playlists[:queue] << playlists[:history].pop
+          playlists[:current].rewind_by 1
+          execute("next no_history")
+        end
+
+        # For more information on this command refer to user manual or inline help in interactive mode.
+        def quit(cmd)
+          quit_in_player
+          terminate_session
+          return success("See you next time!") unless in_session?
+          return failure("Oops! You should use Ctr-c or throw water to the CPU NOW!!!!")
+        end
+      end
+    end
+  end
+end

data/lib/cultome_player/player/interface/builtin_help.rb

@@ -0,0 +1,368 @@
+module CultomePlayer
+  module Player
+  	module BuiltinHelp
+  		def description_play
+  			"Creates a playlist and start playing. Resumes playback."
+  		end
+
+			def description_pause
+				"Toggle pause."
+			end
+
+			def description_stop
+				"Stops current playback."
+			end
+
+			def description_next
+				"Play the next song in current playlist."
+			end
+
+			def description_prev
+				"Play the last song in history playlist."
+			end
+
+			def description_quit
+				"Quits the playback and exit the player."
+			end
+
+			def description_search
+				"Search into the connected music drives."
+			end
+
+			def description_show
+				"Shows representations of diverse objects in the player."
+			end
+
+			def description_enqueue
+				"Append a playlist to the queue playlist."
+			end
+
+			def description_shuffle
+				"Check the state of shuffle. Can turn it on and off."
+			end
+
+			def description_connect
+				"Add or reconnect a drive to the music library."
+			end
+
+			def description_disconnect
+				"Disconnect a drive from the music library."
+			end
+
+			def description_ff
+				"Fast forward 10 seconds the current playback."
+			end
+
+			def description_fb
+				"Fast backward 10 seconds the current playback."
+			end
+
+			def description_repeat
+				"Repeat the current playback from the begining."
+			end
+			
+	    def usage_cultome_player
+		    cmds_availables = methods.grep(/^description_/).collect do |method_name|
+		      [method_name.to_s.gsub("description_", ""), send(method_name)]
+		    end
+
+		    border_width = 5
+		    cmd_column_width = cmds_availables.reduce(0){|sum, arr| sum > arr[0].length ? sum : arr[0].length}
+		    desc_column_width = 90 - border_width - cmd_column_width
+
+		    cmds_availables_formatted = cmds_availables.collect do |arr|
+		      "   " + arrange_in_columns(arr, [cmd_column_width, desc_column_width], border_width)
+		    end
+
+		    return <<-HELP
+usage: <command> [param param ...]
+
+The following commands are availables:
+#{cmds_availables_formatted.join("\n")}
+
+The params can be of any of these types:
+   criterio     A key:value pair. Only a,b,t are recognized.
+   literal      Any valid string. If contains spaces quotes or double quotes are required.
+   object       Identifiers preceded with an @.
+   number       An integer number.
+   path         A string representing a path in filesystem.
+   boolean      Can be true, false. Accept some others.
+   ip           An IP4 address.
+
+See 'help <command>' for more information on a especific command.
+
+Refer to the README file for a complete user guide.
+	    HELP
+	  	end
+
+			def usage_play
+				return <<-USAGE
+usage: play [literal|number|criteria|object]
+
+This command is intelligent, so it reacts depending on its context. 
+Without parameters, if the current playlist is empty, play without parameters crate a playlist with all the music in your library and start playing, also if you stop or pause the player, this command resumes the playback where you left it.
+With parameters works as if you make a search and then create a playlist from the results.
+If you select songs from the *focus* playlist, this command dont replace the *current* playlist, just append the song to the *queue* playlist.
+
+Examples:
+
+Create a playlist with songs that contains "super" in its title, artist name o album name:
+	play super
+
+Create a playlist with all the songs in the current album:
+	play @album
+
+Create a playlist with songs whose artists contains the string "llica" or "gori":
+	play a:llica a:gori
+
+If you use a command that modifies the *focus* playlist, you can play songs associated with their index in the list:
+	play 1 5 9
+
+				USAGE
+			end
+
+			def usage_pause
+				return <<-USAGE
+usage: pause [boolean]
+
+Without parameters, toggle pause. Whit a boolean parameter... well, just you what is been told.
+
+Examples:
+	
+If there is an active playback, pause it:
+	pause
+
+If is paused, resume:
+	pause
+
+If you wanna make sure is paused:
+	pause on
+
+				USAGE
+			end
+
+			def usage_stop
+				return <<-USAGE
+usage: stop
+
+Stop the current playback. If *play* is called after *stop*, the playback will begin again.
+
+Examples:
+
+Stop current playback:
+	stop
+
+				USAGE
+			end
+
+			def usage_next
+				return <<-USAGE
+usage: next
+
+Select the next song in the *current* playlist and play it, if there is any or if *repeat* is on.
+
+Examples:
+
+You dont like the music and wanna try lunk with the next:
+	next
+
+				USAGE
+			end
+
+			def usage_prev
+				return <<-USAGE
+usage: prev
+
+Select the last song in the *history* playlist and plays it again.
+
+Examples:
+
+"OMG! I love that song, lets hear it again":
+	prev
+
+				USAGE
+			end
+
+			def usage_quit
+				return <<-USAGE
+usage: quit
+
+Stop playback and exit player.
+
+Examples:
+
+You wanna quit the player:
+	quit
+
+				USAGE
+			end
+
+			def usage_search
+				return <<-USAGE
+usage: search (literal|criteria)
+
+Search in the connected drives for song that fullfil the parameters criteria.
+When a search is made, the results go to the *search* and *focus* playlist. From there, they can be manipulated.
+To understand the results, I will explain the rules the search algorith uses:
+	1. Similar criteria creates an OR filter and differents create AND filter.
+		Example:
+
+			search t:tres a:uno a:dos
+
+			This extract songs whose title contains "tres" and whose artist contains "uno" OR "dos" in their names
+
+	2. Literal words form and OR
+
+			search uno dos tres
+
+			This extract songs whose title, artist name or album name contains "uno" OR "dos" OR "tres".
+
+Examples:
+
+Get all my Gorillaz's songs
+	search a:gorillaz
+
+Im in love and I wanna hear love-related songs:
+	search love
+
+				USAGE
+			end
+
+			def usage_show
+				return <<-USAGE
+usage: show [number|object]
+
+Display a representation of player's objects.
+Without parameters show the status of the current playback, if any.
+
+Examples:
+
+See how much time left of this song:
+	show
+
+See what songs are in the *focus* playlist:
+	show @focus
+
+				USAGE
+			end
+
+			def usage_enqueue
+				return <<-USAGE
+usage: enqueue [literal|number|criteria|object]
+
+Search, pick and extract the song defined in the parameters and creates a playlist that is appended to the *queue* playlist.
+Similar to a search with the literal and criteria parameters, but with number takes songs from the *focus* playlist, and with object extract the songs from the respective object.
+
+Examples:
+
+After the current song I want to play all Jugulator album:
+	enqueue b:Jugulator
+
+Play te third song in the list after this:
+	enqueue 3
+
+				USAGE
+			end
+
+			def usage_shuffle
+				return <<-USAGE
+usage: shuffle [boolean]
+
+Without parameters, check the shuffle state. When parameters are provided, you can turn it on and off.
+
+Examples:
+
+Is shuffling?:
+	shuffle
+
+Turn shuffle off:
+	shuffle off
+
+				USAGE
+			end
+
+			def usage_connect
+				return <<-USAGE
+usage: connect (literal | path => literal)
+
+This command allows you to create a new drive or reconnect an existing one.
+A drive is a logical folder or container that groups songs by path. This player uses this concept to organize your music directories.
+You can disconnect it to avoid the music search look in there.
+
+Examples:
+
+To connect a drive you use the following form:
+	connect path/to/my/music => my_library
+
+To reconnect the same drive in the future (if you disconnect it for some reason):
+	connect my_library
+
+				USAGE
+			end
+
+			def usage_disconnect
+				return <<-USAGE
+usage: disconnect literal
+
+Disconnect a previously connected drive. With the drive disconnected the searches are not made in this drives.
+
+Examples:
+
+Disconnect a temporal download music drive:
+	disconnect my_downloads
+
+				USAGE
+			end
+
+			def usage_ff
+				return <<-USAGE
+usage: ff [number]
+
+Fast forward the current playback 10 seconds by default. This time can be customized passing a parameter with the seconds to fast forward.
+
+Examples:
+
+Fas forward 10 seconds:
+	ff
+
+Fas forward 35 seconds:
+	ff 35
+
+				USAGE
+			end
+
+			def usage_fb
+				return <<-USAGE
+usage: fb [number]
+
+Fast backward the current playback 10 seconds by default. This time can be customized passing a parameter with the seconds to fast backward.
+
+Examples:
+
+Fas backward 10 seconds:
+	fb
+
+Fas backward 5 seconds:
+	fb 5
+
+				USAGE
+			end
+
+			def usage_repeat
+				return <<-USAGE
+usage: stop
+
+Stop current playback.
+
+Examples
+
+Stop current playback:
+	stop
+
+				USAGE
+			end
+
+
+  	end
+  end
+end