cultome_player 2.0.0

data/lib/cultome_player/player/playlist.rb

@@ -0,0 +1,280 @@
+require 'cultome_player/utils'
+
+module CultomePlayer::Player::Playlist
+
+  # Lazy getter for playlists.
+  #
+  # @return [Playlists] The playlists handled by the system.
+  def playlists
+    @playlists ||= Playlists.new
+  end
+
+  # (see Playlists#registered?)
+  def playlist?(name)
+    playlists.registered?(name)
+  end
+
+  class Playlists
+    include Enumerable
+    include CultomePlayer::Utils
+
+    # Initialize a playlist with optional information to fill.
+    #
+    # @param data [#each] A collection of items to add to playlist
+    def initialize(data=nil)
+      @data = {}
+      data.each{|arr| register(*arr) } unless data.nil?
+    end
+
+    # Register a playlist.
+    #
+    # @param name [Symbol] The name of the new playlist.
+    # @param value [List<Object>] Optional data to initialize the playlist.
+    def register(name, value=nil)
+      raise 'invalid registry:playlist already registered' unless @data[name].nil?
+      @data[name] = value.nil? ? {list: [], idx: -1, repeat: true, shuffled: false} : value
+    end
+
+    # Check if a playlist is registered.
+    #
+    # @param name [Symbol] The name of the new playlist.
+    # @return [Boolean] True if previously registered, False otherwise.
+    def registered?(name)
+      @data.has_key?(name)
+    end
+
+    # Creates an interator for all the songs in all the playlists
+    #
+    # @return [Iterator] Iterator over all the songs.
+    def each_song
+      idx = 0
+      @data.values.each{|info| info[:list].each{|song| yield song, idx += 1 } }
+    end
+
+    # Creates an interator for the playlists
+    #
+    # @return [Iterator] Iterator over the playlists.
+    def each
+      @data.values.each{|info| yield info[:list] }
+    end
+
+    # Check if there is playlists registered.
+    #
+    # @return [Boolean] True if there is any playlist registered. False otherwise.
+    def empty?
+      return @data.values.first[:list].empty? if @data.size == 1
+      @data.empty?
+    end
+
+    # Creates a new playlist object that contains the playlists named in parameters.
+    #
+    # @return [Playlists] Playlists with selected playlists inside.
+    def [](*names)
+      validate names
+      selected = @data.select{|name,info| names.include?(name) }
+      return Playlists.new(selected)
+    end
+
+    # Replace the content of the playlist with the content of parameter.
+    #
+    # @param value [List<Object>] The new contents of the playlist.
+    def <=(value)
+      @data.keys.each{|name| replace(name, value) }
+    end
+
+    # Append the content of the playlist with the content of parameter.
+    #
+    # @param value [List<Object>] The appended of the playlist.
+    def <<(value)
+      if value.respond_to?(:each)
+        @data.values.each{|info| value.each{|v| info[:list] << v } }
+      else
+        @data.values.each{|info| info[:list] << value }
+      end
+    end
+
+    # Removes the last element in the playlists.
+    #
+    # @return [List<Object>, Object] The las elements in the playlists.
+    def pop
+      last_ones = collect{|list| list.pop }
+      return last_ones.first if last_ones.size == 1
+      return last_ones 
+    end
+
+    # Shuffle the playlists and reset the indexes.
+    def shuffle
+      @data.values.each do |info|
+        info[:list].shuffle!
+        info[:shuffled] = true
+        info[:idx] = -1
+      end
+    end
+
+    # Order the playlists and reset the indexes.
+    def order
+      @data.values.each do |info|
+        info[:list].sort!
+        info[:idx] = -1
+        info[:shuffled] = false
+      end
+    end
+
+    # Returns the next song in playlist, which means the new current song.
+    #
+    # @return [List<Object>,Object] The next element(s) in playlist(s).
+    def next
+      each_next do |info, nxt_idx|
+        info[:idx] = nxt_idx
+        info[:list].at nxt_idx
+      end
+    end
+
+    # Returns the previous song in playlist.
+    #
+    # @return [List<Object>,Object] The previous element(s) in playlist(s).
+    def rewind_by(idx)
+      each_next do |info, nxt_idx|
+        info[:idx] -= idx
+        info[:list].at info[:idx]
+      end
+    end
+
+    # Remove the next element in playlist.
+    #
+    # @return [List<Object>,Object] The next element(s) in playlist(s).
+    def remove_next
+      each_next do |info, nxt_idx|
+        info[:list].delete_at nxt_idx
+      end
+    end
+
+    # Return the play index in the playlists.
+    #
+    # @return [List<Integer>, Integer] Indexes of the playlists.
+    def play_index
+      return first_or_map :idx
+    end
+
+    # Return the repeat status in the playlists.
+    #
+    # @return [List<Boolean>, Boolean] Indexes of the playlists.
+    def repeat?
+      return first_or_map :repeat
+    end
+
+    # Change the repeat status in the playlists.
+    def repeat(value)
+      @data.values.each{|info| info[:repeat] = is_true_value?(value) }
+    end
+
+    # Returns the current element in playlists.
+    #
+    # @return [List<Object>, Object] The current element(s) in playlist(s).
+    def current
+      currents = @data.values
+      .select{|info| info[:idx] >= 0}
+      .map do |info|
+        info[:list].at info[:idx]
+      end
+
+      return nil if currents.empty?
+      raise 'no current:no current song in one of the playlists' if @data.size != currents.size
+      return currents.first if currents.size == 1
+      return currents
+    end
+
+    # The number of registered playlists.
+    #
+    # @return [Integer] The size of registered playlist.
+    def size
+      @data.size
+    end
+
+    # Return a list with all the songs in all the playlists.
+    #
+    # @return [List<Object>] A list with all the songs in all the playlists.
+    def to_a
+      @data.values.reduce([]){|acc,info| acc + info[:list]}
+    end
+
+    alias :songs :to_a
+
+    # Returns the elements in the playlist.
+    #
+    # @param idx [Integer] The positional index of the element required.
+    # @return [List<Object>, Object] The positional elements in the playlists.
+    def at(idx)
+      return @data.values.first[:list].at(idx) if @data.size == 1
+      return @data.values.collect{|info| info[:list].at(idx) }
+    end
+
+    # Returns a string representation of the playlists.
+    #
+    # @return [String] A representation of the playlists.
+    def as_list
+      list = ""
+      each_song{|s,i| list << "#{i}. #{s.to_s}\n" }
+      return list
+    end
+
+    # Check if there is another element in playlists.
+    #
+    # @return [List<Boolean>, Boolean] True if the the playlist has more elements, False otherwise.
+    def next?
+      nexts = each_next_with_index{|info, nxt_idx| nxt_idx }
+      has_nexts = nexts.map{|nxt_idx| !nxt_idx.nil? }
+      return has_nexts.first if has_nexts.size == 1
+      return has_nexts
+    end
+
+    # Check the status of shuffling in playlists.
+    #
+    # @return [List<Boolean>, Boolean] True if playlist is shuffling. False otherwise.
+    def shuffling?
+      return first_or_map :shuffled
+    end
+
+    private
+
+    def first_or_map(attr)
+      return @data.values.first[attr] if @data.size == 1
+      return @data.values.map{|info| info[attr] }
+    end
+
+    # Returns the non-empty playlists yielded by the block
+    def each_next_with_index
+      @data.values
+      .select{|info| !info[:list].empty? }
+      .map do |info|
+        nxt_idx = next_idx(info[:idx], info[:list].size, info[:repeat])
+        nxt_idx.nil? ? nil : yield(info, nxt_idx)
+      end
+    end
+
+    # Returns an array with songs, if multiple playlists and only one if single playlist is available
+    def each_next(&block)
+      nexts = each_next_with_index(&block).compact
+      raise "playlist empty:no songs in playlists" if nexts.empty?
+      raise "playlist empty:no songs in one of the playlists" if nexts.size != @data.size
+      return nexts.first if nexts.size == 1
+      return nexts
+    end
+
+    def next_idx(actual_idx, size, repeat)
+      next_idx = actual_idx + 1
+      next_idx = next_idx % size if repeat
+      return nil if next_idx >= size
+      return next_idx
+    end
+
+    def replace(name, value)
+      @data[name][:list].replace value
+      @data[name][:idx] = -1
+    end
+
+    def validate(names)
+      raise 'unknown playlist:playlist is not registered' if names.any?{|n| !@data.keys.include?(n) }
+    end
+  end
+end

data/lib/cultome_player/plugins.rb

@@ -0,0 +1,23 @@
+require 'cultome_player/plugins/help'
+
+module CultomePlayer
+	module Plugins
+		include Help
+
+		# Check if a plugin implements the given command.
+		#
+		# @param cmd_name [String] The command name.
+		# @return [Boolean] True is the given command is implemented by a plugin.
+		def plugins_respond_to?(cmd_name)
+			return respond_to?("command_#{cmd_name}".to_sym)
+		end
+
+		# Get a command format for a command implemented by a plugin
+		#
+		# @param cmd_name [String] The command name.
+		# @return [Regex] The regex to validate a command format that is implemented by a plugin.
+		def plugin_command_sintaxis(cmd_name)
+			return send("sintaxis_#{cmd_name}".to_sym)
+		end
+	end
+end

data/lib/cultome_player/plugins/help.rb

@@ -0,0 +1,58 @@
+module CultomePlayer
+	module Plugins
+		module Help
+
+			# Command implementation for action "help".
+			# Shows usage information for the actions of the player if called with an action as parameter and shows a player usage information if called without parameters.
+			#
+			# @contract Plugin
+			# @param cmd [Command] Command information parsed from user input
+			# @return [Response] Contains a message to be displayed with the help required.
+	    def command_help(cmd)
+	    	if cmd.params.empty?
+	    		success(message: usage_cultome_player)
+	    	else
+	    		help = send("usage_#{cmd.params.first.value}")
+	    		if help.nil?
+	    			failure("No help is available for '#{cmd.first.value}'.")
+	    		else
+	    			success(message: help)
+	    		end
+	    	end
+	    end
+
+	    def sintaxis_help
+	    	return /^literal (literal)$/
+	    end
+
+	    # Description of the action help.
+	    #
+	    # @contract Help Plugin.
+	    # @return [String] The description of the action.
+	    def description_help
+	    	"Provides information for player features."
+	    end
+
+			# Usage information of the action help.
+	    #
+	    # @contract Help Plugin.
+	    # @return [String] The usage information of the action.
+	    def usage_help
+	    	return <<-USAGE
+usage: help [command]
+
+Provides usage information for player commands. If called without parameters, shows the player usage.
+
+Examples:
+
+To see all the commands availables in the player:
+	help
+
+To see the usage for play command:
+	help play
+
+	    	USAGE
+	    end
+		end
+	end
+end

data/lib/cultome_player/state_checker.rb

@@ -0,0 +1,74 @@
+module CultomePlayer
+	module StateChecker
+
+		# Check the status of pause.
+		#
+		# @return [Boolean] True if paused, False otherwise
+	  def paused?
+	    @paused ||= false
+	  end
+
+		# Check the status of stop.
+		#
+		# @return [Boolean] True if stopped, False otherwise
+	  def stopped?
+	    @stopped ||= true
+	  end
+
+		# Check the status of play.
+		#
+		# @return [Boolean] True if playing, False otherwise
+	  def playing?
+	    @playing ||= false
+	  end
+
+		# Check the status of shuffle.
+		#
+		# @return [Boolean] True if shuffling, False otherwise
+	  def shuffling?
+	    playlists[:current].shuffling?
+	  end
+
+		# Returns the current song.
+		#
+		# @return [Song] The current song or nil if any.
+	  def current_song
+	    @current_song
+	  end
+
+		# Returns the current artist.
+		#
+		# @return [Artist] The current artist or nil if any.
+	  def current_artist
+	    current_song.artist
+	  end
+
+		# Returns the current album.
+		#
+		# @return [Album] The current album or nil if any.
+	  def current_album
+	    current_song.album
+	  end
+
+		# Returns the current playlist.
+		#
+		# @return [Playlist] The current playlist or nil if any.
+	  def current_playlist
+	    playlists[:current]
+	  end
+
+		# Returns the current playback position.
+		#
+		# @return [Integer] The current playback position in seconds.
+	  def playback_position
+	    @playback_time_position ||= 0
+	  end
+
+		# Returns the current playback length.
+		#
+		# @return [Integer] The current playback length in seconds.
+	  def playback_length
+	    @playback_time_length ||= 0
+	  end
+	end
+end

data/lib/cultome_player/utils.rb

@@ -0,0 +1,95 @@
+require 'active_record'
+
+module CultomePlayer
+  module Utils
+
+    # Check if a string value can be a positive boolean value.
+    #
+    # @param value [String] String to check if can be a positive boolean value.
+    # @return [Boolean] True if value is a positive boolean value. False otherwise.
+    def is_true_value?(value)
+      /true|yes|on|y|n|s|si|cierto/ === value 
+    end
+
+    # Print a string into stdout (not STDOUT) and finish with a newline character.
+    #
+    # @param msg [String] The value to be printed.
+    # @return [String] The value printed.
+    def display(msg)
+      stdout.puts msg
+      return msg
+    end
+
+    # Print a string into stdout (not STDOUT) but before insert a carriage return and dont append a newline character at the end.
+    #
+    # @param msg [String] The value to be printed.
+    # @return [String] The value printed.
+    def display_over(msg)
+      stdout.print "\r#{msg}"
+      return msg
+    end
+
+    # Define the 15 colors allowed in my console scheme
+    (1..15).each do |idx|
+      define_method :"c#{idx}" do |str|
+        str
+      end
+    end
+
+    # Arrange an array of string into single string arranged by columns separed by an inner border.
+    #
+    # @param cols [List<String>] The strings to be arranged.
+    # @param widths [List<Integer>] The width of the columns.
+    # @param border [Integer] The width of the inner borders.
+    # @return [String] The string representation of columns.
+    def arrange_in_columns(cols, widths, border)
+      row = ""
+      idxs = cols.collect{|c| 0 }
+      
+      while cols.zip(idxs).any?{|col| col[0].length > col[1] }
+        cols.each.with_index do |col, idx|
+          slice_width = widths[idx]
+          
+          slice = col.slice(idxs[idx], slice_width) || "" # sacamos el pedazo de la columna
+          row << slice.ljust(slice_width) # concatenamos a la fila
+          idxs[idx] += slice_width # recorremos el indice
+          row << " " * border # agregamos el border de la derecha
+        end
+
+        row = row.strip << "\n" # quitamos el ultimo border
+      end
+
+      return row.strip # quitamos el ultimo salto de linea
+    end
+
+    # Capture and dispose the standard output sended inside the block provided.
+    #
+    # @return [String] The swallowed data.
+    def swallow_stdout
+      s = StringIO.new
+      oldstd = $stdout
+      $stdout = s
+      yield
+      return s.string
+    ensure
+      $stdout = oldstd
+    end
+
+    # Provides a wrapper for database connection.
+    #
+    # @param db_block [Block] The block to be executed inside a database connection.
+    def with_connection(&db_logic)
+      begin
+        ActiveRecord::Base.connection_pool
+      rescue Exception => e
+        ActiveRecord::Base.establish_connection(
+          adapter: db_adapter,
+          database: db_file
+        )
+        ActiveRecord::Base.logger = Logger.new(File.open(db_log_file, 'a'))
+      end
+
+      ActiveRecord::Base.connection_pool.with_connection(&db_logic)
+    end
+  end
+end