cultome_player 2.0.0 → 2.0.2

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

@@ -23,8 +23,9 @@ module CultomePlayer
             songs = whole_library
             return failure("No music connected! You should try 'connect /home/yoo/music => main' first") if songs.empty?
             playlists[:current, :focus] <= songs
+            playlists[:current, :focus].shuffle
 
-          else
+          else # with parameters
             songs = select_songs_with cmd
             # checamos si el tipo de comando es para programar una
             # nueva playlist o solo para tocar una cancion
@@ -34,8 +35,8 @@ module CultomePlayer
               playlists[:current] <= songs
             end
           end
-
-          return success(playlist: songs) + execute("next no_history")
+          
+          return success(playlist: songs) + execute("next no_history").first
         end
 
         # For more information on this command refer to user manual or inline help in interactive mode.
@@ -63,16 +64,18 @@ module CultomePlayer
 
         # For more information on this command refer to user manual or inline help in interactive mode.
         def next(cmd)
+          playlists[:history] << current_song if cmd.history?
+          
           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
 
+          # cambiamos la fecha de ultima reproduccion
+          current_song.update_attributes(last_played_at: Time.now)
+          
           return success(message: "Now playing #{current_song}", now_playing: current_song)
         end
 
@@ -80,15 +83,16 @@ module CultomePlayer
         def prev(cmd)
           playlists[:queue] << playlists[:history].pop
           playlists[:current].rewind_by 1
-          execute("next no_history")
+          r = execute("next no_history").first
+          return r
         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!!!!")
+          return success(c15("See you next time!")) unless in_session?
+          return failure(c3("Oops! You should use Ctr-c or throw water to the CPU NOW!!!!"))
         end
       end
     end

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

@@ -1,7 +1,11 @@
+require 'cultome_player/player/interface/helper'
 
 module CultomePlayer::Player::Interface
   module Extended
 
+    include CultomePlayer::Objects
+    include CultomePlayer::Player::Interface::Helper
+
     # For more information on this command refer to user manual or inline help in interactive mode.
     def search(cmd)
       songs = select_songs_with cmd
@@ -10,6 +14,7 @@ module CultomePlayer::Player::Interface
         failure('It matches not even one')
       else
         playlists[:focus] <= songs
+        playlists[:search] <= songs
         success(songs: songs, response_type: :songs)
       end
     end
@@ -19,8 +24,8 @@ module CultomePlayer::Player::Interface
       if cmd.params.empty?
         if playing?
           #mostramos la cancion actual
-          msg = get_progress_bar_with_labels(playback_position, playback_length, 20, format_secs(playback_position), format_secs(playback_length))
-          return success(message: "#{current_song.to_s}\n#{msg}", song: current_song)
+          progress_bar = get_progress_bar_with_labels(playback_position, playback_length, 20, format_secs(playback_position), format_secs(playback_length))
+          return success(message: "#{current_song.to_s}\n#{c7(progress_bar)}", song: current_song)
         else
           return failure("Nothing to show yet. Try with 'play' first.")
         end
@@ -37,22 +42,30 @@ module CultomePlayer::Player::Interface
             when :search then playlists[:search].to_a
 
             when :song then return success(message: current_song.to_s, song: current_song)
-            when :artist then return success(message: current_artist.to_s, artist: current_song)
-            when :album then return success(message: current_album.to_s, album: current_song)
+            when :artist then return success(message: current_artist.to_s, artist: current_artist)
+            when :album then return success(message: current_album.to_s, album: current_album)
+            when :genre then return success(message: current_song.genres.map{|g| g.name}.join(", "), genres: current_song.genres)
 
             when :drives then Drive.all
-            when :artists then return Artist.all
-            when :albums then return Album.all
-            when :genres then return Genre.all
+            when :artists then Artist.all
+            when :albums then Album.all
+            when :genres then Genre.all
 
             when :library then whole_library.to_a
 
-            when :recently_added then [] # TODO implement
-            when :recently_played then [] # TODO implement
-            when :more_played then [] # TODO implement
-            when :less_played then [] # TODO implement
-            when :populars then [] # TODO implement
+            when :recently_added then
+              low_time, high_time = get_recently_added_criteria_limit
+              Song.where({created_at: low_time..high_time}).to_a
+
+            when :recently_played then
+              low_time, high_time = get_recently_played_criteria_limit
+              Song.where({last_played_at: low_time..high_time}).to_a
 
+            when :most_played then Song.where("plays >= ?", get_most_played_criteria_limit).to_a
+            when :less_played then Song.where("plays <= ?",  get_less_played_criteria_limit).to_a
+            when :populars then
+              low_time, up_time, low_count = get_popular_criteria_limits
+              Song.where("last_played_at between ? and ? and plays >= ?", low_time, up_time, low_count)
             else []
           end
         end
@@ -137,6 +150,7 @@ module CultomePlayer::Player::Interface
         # insertamos las nuevas y actualizamos las existentes
         updated = update_song(track_info)
         imported = insert_song(track_info)
+        display "" # para insertar un salto de linea despues de las barras de progreso
 
         success(message: connect_response_msg(imported, updated),
                 files_detected: track_info.size,

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

@@ -32,9 +32,9 @@ module CultomePlayer::Player::Interface
     def get_progress_bar(current, total=100, size=10)
       factor = total > 0 ? current / total.to_f : 0
       bars = ( factor * size ).floor
-      total = "_" * size
+      total = "-" * size
       total[0,bars] = "#" * bars
-      return "|#{total}|"
+      return "|#{total}>"
     end
 
     # Generate a query and a array of values to replace into the query for a given set of parameters.
@@ -49,8 +49,6 @@ module CultomePlayer::Player::Interface
         when :criteria then process_criteria_for_search(params)
         when :literal then process_literal_for_search(params)
       end
-
-      raise 'invalid command:invalid search criteria' if query =~ /^[\(\)]+$/
       return query, values
     end
 
@@ -72,7 +70,9 @@ module CultomePlayer::Player::Interface
     def insert_song(new_info)
       existing_paths = get_unique_paths
       to_be_processed = new_info.select{|s| !existing_paths.include?(s[:file_path]) }
+      progress = progress_label("Adding songs {actual}/{total}", to_be_processed.size)
       return to_be_processed.count do |info|
+        display_over c15(progress.increment)
         write_song(info)
       end
     end
@@ -84,8 +84,10 @@ module CultomePlayer::Player::Interface
     def update_song(new_info)
       existing_paths = get_unique_paths
       to_be_processed = new_info.select{|s| existing_paths.include?(s[:file_path]) }
+      progress = progress_label("Updating song {actual} of {total}", to_be_processed.size)
       return to_be_processed.count do |info|
         # extraemos la cancion almacenada.. si existe
+        display_over c15(progress.increment)
         song = Song.includes(:drive).where("drives.path||'/'||songs.relative_path = ?", info[:file_path]).references(:drives).first
 
         song.nil? ? false : write_song(info, song)
@@ -117,7 +119,7 @@ module CultomePlayer::Player::Interface
       from_focus = get_from_focus(cmd.params(:number))
       from_playlists = get_from_playlists(cmd.params_values(:object))
       results = found_songs + from_focus + from_playlists
-      return results
+      return results.uniq{|s| s.id }
     end
 
     # Search in library for songs that fullfil the command parameters.
@@ -141,7 +143,8 @@ module CultomePlayer::Player::Interface
     # @return [List<Song>] The songs in the valid playlists.
     def get_from_playlists(lists)
       valid_lists = lists.select{|list_name| playlist?(list_name) }
-      return playlists[*valid_lists].songs
+      songs = playlists[*valid_lists].songs
+      return songs.uniq{|s| s.id }
     end
 
     # Try to find the player object by name.
@@ -191,6 +194,19 @@ module CultomePlayer::Player::Interface
 
     private
 
+    def progress_label(label, total)
+      return Class.new do
+        def initialize(lbl, tot)
+          @_label, @_actual = lbl.gsub(/\{total\}/, tot.to_s), 0
+        end
+
+        def increment
+          @_actual += 1
+          return @_label.gsub(/\{actual\}/, @_actual.to_s)
+        end
+      end.new(label, total)
+    end
+
     def get_from_focus(params)
       params.map do |p|
         playlists[:focus].at p.value - 1
@@ -258,10 +274,26 @@ module CultomePlayer::Player::Interface
     def process_object_for_search(params)
       objs = params.collect do |p|
           case p.value
-          when :artist then {query: 'artists.name = ?', value: current_artist.name }
+          when :populars then
+            low_time, up_time, low_count = get_popular_criteria_limits
+            {query: 'last_played_at between ? and ? and plays >= ?', value: [low_time, up_time, low_count]}
+          when :less_played then {query: 'plays <= ?', value: get_less_played_criteria_limit}
+          when :most_played then {query: 'plays >= ?', value: get_most_played_criteria_limit}
+          when :recently_played then
+            low_time, high_time = get_recently_played_criteria_limit
+            {query: 'last_played_at between ? and ?', value: [low_time, high_time]}
+          when :recently_added then
+            low_time, high_time = get_recently_added_criteria_limit
+            {query: 'created_at between ? and ?', value: [low_time, high_time]}
+          when :library then {query: 'songs.id > 0'}
           when :album then {query: 'albums.name = ?', value: current_album.name }
+          when :artist then {query: 'artists.name = ?', value: current_artist.name }
           when :song then {query: 'songs.name = ?', value: current_song.name }
-          when :library then {query: 'songs.id > 0'}
+          when :genre then {query: 'genres.name in (?)', value: current_song.genres.map{|g| g.name} }
+          when :genres then raise 'invalid_search:@genres has no meaning here'
+          when :albums then raise 'invalid_search:@albums has no meaning here'
+          when :artists then raise 'invalid_search:@artists has no meaning here'
+          when :drives then raise 'invalid_search:@drives has no meaning here'
           else raise 'invalid search:unknown type'
           end unless playlist?(p.value)
       end.compact
@@ -269,7 +301,7 @@ module CultomePlayer::Player::Interface
       return nil, [] if objs.empty?
 
       query = objs.collect{|o| o[:query] }.join(" or ")
-      values = objs.collect{|o| o[:value]}.compact
+      values = objs.collect{|o| o[:value]}.flatten.compact
 
       return query, values
     end
@@ -286,6 +318,7 @@ module CultomePlayer::Player::Interface
           when :a then info[:query] << "artists.name like ?"
           when :b then info[:query] << "albums.name like ?"
           when :t then info[:query] << "songs.name like ?"
+          else raise 'invalid command:invalid search criteria'
         end
         info[:values] << "%#{p.value}%"
       end
@@ -295,6 +328,37 @@ module CultomePlayer::Player::Interface
       return query, values
     end
 
+    # Get the low and high date range and the lower play limit for a "popular" songs criteria
+    def get_popular_criteria_limits
+      upper_time = Time.now.midnight + 1.day
+      lower_time = upper_time - 5.day
+      latest_songs = Song.where({last_played_at: (lower_time..upper_time)}).order(plays: :desc)
+      lower_play_count = latest_songs.first.plays * 0-95
+
+      return lower_time,  upper_time, lower_play_count
+    end
+
+    # Get the high limit for a "less played" songs criteria
+    def get_less_played_criteria_limit
+      less_played_song_count = Song.all.order(:plays).limit(1).first.plays
+      return less_played_song_count * 1.05
+    end
+
+    # Get the lower limit for a "most played" songs criteria
+    def get_most_played_criteria_limit
+      most_played_song_count = Song.all.order(plays: :desc).limit(1).first.plays
+      return most_played_song_count * 0.95
+    end
+
+    def get_recently_added_criteria_limit
+      last_song_added_dt = Song.all.order(created_at: :desc).limit(1).first.created_at
+      return last_song_added_dt - 1.day, last_song_added_dt
+    end
+
+    def get_recently_played_criteria_limit
+      last_song_played_dt = Song.all.order(last_played_at: :desc).limit(1).first.last_played_at
+      return last_song_played_dt - 1.hour, last_song_played_dt
+    end
   end
 end
 

data/lib/cultome_player/plugins.rb

@@ -1,23 +1,49 @@
 require 'cultome_player/plugins/help'
+require 'cultome_player/plugins/alias'
+require 'cultome_player/plugins/points'
+require 'cultome_player/plugins/gestures'
+require 'cultome_player/plugins/keyboard_special_keys'
 
 module CultomePlayer
-	module Plugins
-		include Help
+  module Plugins
+    include Help
+    include Alias
+    include Points
+    include Gestures
+    include KeyboardSpecialKeys
 
-		# 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
+    # 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
+    # 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_sintax(cmd_name)
+      return send("sintax_#{cmd_name}".to_sym)
+    end
+
+    # Lazy getter for plugins configurator. Its a persistent store where plugin can put their configurations.
+    #
+    # @param plugin_name [#to_s] The name of the plugin.
+    # @return [Hash] Where plugins can stores their information.
+    def plugin_config(plugin_name)
+      plugin_ns = player_config['plugins'] ||= {}
+      return plugin_ns[plugin_name.to_s] ||= {}
+    end
+
+    # Call init_plugin_<action> to initialize all the plugins that require it.
+    def init_plugins
+      methods.grep(/^init_plugin_/).each{|method_name| send(method_name) }
+    end
+
+    def clean_plugins
+      methods.grep(/^clean_plugin_/).each{|method_name| send(method_name) }
+    end
+  end
+end

data/lib/cultome_player/plugins/alias.rb

@@ -0,0 +1,85 @@
+module CultomePlayer
+  module Plugins
+    module Alias
+
+      def command_alias(cmd)
+        if cmd.params.empty?
+          msg = plugin_config(:alias).to_a.reduce("") do |acc,arr|
+            acc += "#{arr[0]} => #{arr[1]}\n"
+          end
+          return success(c15(msg))
+
+        else
+          command = cmd.params.first.value
+          aka = cmd.params.last.value
+          plugin_config(:alias)[aka] = command
+          return success("Alias '#{aka}' created!")
+        end
+      end
+
+      def respond_to?(name, include_all=false)
+        # si no esta buscando commands lo dejamos pasar
+        return super unless name =~ /^command_(.+?)$/
+        # si el comando existe, lo dejamos pasar
+        return true if super
+        # aqui podria ser un alias
+        aka = $1
+        cmd_aliased = plugin_config(:alias)[aka]
+        # si no es un alias, lo dejamos pasar
+        return false if cmd_aliased.nil?
+        # aqui definimos los metodos requeridos para el alias
+        # alias execution...
+        self.class.send(:define_method, "command_#{aka}".to_sym) do |cmd|
+          prepared_command = cmd_aliased.clone
+          # we replace parameters
+          cmd.params_values(:literal).each.with_index do |p, idx|
+            prepared_command.gsub!(/%#{idx + 1}/, "'#{p}'") # TODO aqui manejar los parametros con quotes
+          end
+          # execute the alias, and returns only the last response
+          if in_session?
+            begin
+              r = execute_interactively(prepared_command)
+              return success(no_response: true)
+              #return success(no_response: true)
+            rescue Exception => e
+              return failure(e.message)
+            end
+          end
+          return execute(prepared_command).last
+        end
+        # ...and sintax
+        self.class.send(:define_method, "sintax_#{aka}".to_sym) do
+          return /^literal(literal|[\s]+)*$/ # devolvemos la sintax para la invocacion del alias, no del comando
+        end
+        ## devolvemos exito
+        return true
+      end
+
+      def sintax_alias
+        /^literal (literal) bubble (literal) $/
+      end
+
+      def description_alias
+        "Create an alias for a command."
+      end
+
+      def usage_alias
+        return <<-USAGE
+usage: alias command => alias
+
+Creates an alias for a command. Similar to what the bash do.
+Can receive parameters in form of %<number>, eg %1, %2, %3... These parameters are passed when the alias is called.
+
+Examples:
+
+Create an alias to always play the first result in a search:
+  alias "search %1 && play 1" => s
+
+And you would call it like
+  s metallica
+
+        USAGE
+      end
+    end
+  end
+end