cultome_player 2.0.0

data/lib/cultome_player/command/reader.rb

@@ -0,0 +1,86 @@
+require 'readline'
+
+module CultomePlayer::Command
+  module Reader
+
+    # Display a prompt and read user input.
+    #
+    # @param prompt [String] The message to display to user for arcking for input.
+    # @return [String] The user input readed.
+    def read_command(prompt)
+      command_reader.readline(prompt, true)
+    end
+
+    # Lazy getter for readline object.
+    #
+    # @return [Readline] The readline object
+    def command_reader
+      return Readline if @command_reader_initialized
+
+      Readline.completion_append_character = ""
+      Readline.basic_word_break_characters = Readline.basic_word_break_characters.delete("@")
+      Readline.completion_proc = completion_proc
+      @command_reader_initialized = true
+      return Readline
+    end
+
+    private
+
+    def completion_proc
+      proc do |word|
+        if Readline.line_buffer.empty?
+          # linea en blanco y no sabe los comandos
+          options = semantics.keys #return
+        else
+          tks = Readline.line_buffer.split
+          if tks.length == 1
+            options = complete_action(tks[0], word)
+          elsif tks.length > 1
+            options = complete_parameter(tks[0], word)
+          end
+        end
+
+        options = [] if options.nil?
+        options << word if options.empty?
+        options << " " if options.all?{|o| o.start_with?("<")}
+        options # final return
+      end # proc
+    end
+
+    def get_command_param_options(cmd, word)
+      if word.empty?
+        # completa! mostramos los parametros disponibles para el comando
+        if semantics.keys.include?(cmd)
+          # mostramos las opciones de parametros IFF acepta parametros
+          params = semantics[cmd].source.gsub(/^\^literal/, '').gsub(/\[\\s\][+*]/, "").gsub(/[()*$]/, '')
+
+          params.split(/[| ]/).collect{|p| "<#{p}>"} unless params.empty?
+        end
+      else
+        yield if block_given?
+      end
+    end
+
+    def complete_parameter(cmd, word)
+      options = get_command_param_options(cmd, word) do
+        # esta acompletando un parametro
+        if word.start_with?("/") || word.start_with?("~/")
+          expanded_path = File.expand_path(word)
+          expanded_path += "/" if File.directory?(expanded_path)
+          Dir[expanded_path + "*"].grep(/^#{Regexp.escape(expanded_path)}/).collect{|d| "#{d}/"}
+        elsif word.start_with?("@")
+          %w{@library @search @playlist @history @queue @song @artist @album @drives}.grep(/^#{word}/)
+        end
+      end
+    end
+
+    def complete_action(cmd, word)
+      # escribio una parabra..
+      get_command_param_options(cmd, word) do
+        # incompleta! require acompletar el action actual
+        semantics.keys.grep(/^#{Regexp.escape(Readline.line_buffer)}/).collect{|s| "#{s} "}
+      end
+    end
+
+  end
+end

data/lib/cultome_player/environment.rb

@@ -0,0 +1,130 @@
+require 'yaml'
+require 'rake'
+
+module CultomePlayer
+  module Environment
+
+    # Get the db_adapter environment configuration value.
+    #
+    # @return [String] The db_adapter value for teh selected environment.
+    def db_adapter
+      env_config['db_adapter'] || raise('environment problem:environment information not loaded')
+    end
+
+    # Get the db_file environment configuration value.
+    #
+    # @return [String] The db_file value for teh selected environment.
+    def db_file
+      env_config['db_file'] || raise('environment problem:environment information not loaded')
+    end
+
+    # Get the db_log_file environment configuration value.
+    #
+    # @return [String] The db_log_file value for teh selected environment.
+    def db_log_file
+      env_config['db_log_file'] || raise('environment problem:environment information not loaded')
+    end
+
+    # Get the file_types environment configuration value.
+    #
+    # @return [String] The file_types value for teh selected environment.
+    def file_types
+      env_config['file_types'] || raise('environment problem:environment information not loaded')
+    end
+
+    # Get the config_file environment configuration value.
+    #
+    # @return [String] The config_file value for teh selected environment.
+    def config_file
+      env_config['config_file'] || raise('environment problem:environment information not loaded')
+    end
+
+    # Get the mplayer_pipe environment configuration value.
+    #
+    # @return [String] The mplayer_pipe value for teh selected environment.
+    def mplayer_pipe
+      env_config['mplayer_pipe'] || raise('environment problem:environment information not loaded')
+    end
+
+    # Get the stdout (not STDOUT) for the player.
+    #
+    # @return [IO] The stdout for the player.
+    def stdout
+      STDOUT
+    end
+
+    # Gets the player configurations.
+    #
+    # @return [Hash] Player configuration.
+    def player_config
+      @player_config ||= {}
+    end
+
+    # Gets the environment configurations.
+    #
+    # @return [Hash] Environment configuration.
+    def env_config
+      @env_config ||= {}
+    end
+
+    # Get the current environment name.
+    #
+    # @return [Symbol] The current environment name.
+    def current_env
+      @current_env
+    end
+
+    # Extract the configuration for the environment and setup valriables.
+    #
+    # @param env [Symbol] The name of the environment to load.
+    # @param check_db [Boolean] Flag to decide if the database schema should be checked.
+    def prepare_environment(env, check_db=true)
+      env_config = YAML.load_file File.expand_path('config/environment.yml')
+      @env_config = env_config[env.to_s]
+      @current_env = env.to_sym
+      raise 'environment problem:environment not found' if @env_config.nil?
+      expand_paths @env_config
+      create_required_files @env_config
+      load_master_config @env_config['config_file']
+      check_db_schema if check_db
+    end
+
+    private
+
+    def check_db_schema
+      Rake.load_rakefile 'Rakefile'
+      Rake.application.load_imports
+      swallow_stdout{ Rake.application.invoke_task("db:create[#{current_env}]") }
+    end
+
+    def load_master_config(config_file)
+      @player_config = YAML.load_file(config_file) || {}
+      @player_config['main'] ||= {}
+    end
+
+    def create_required_files(env_config)
+      env_config.each do |k,v|
+        if k.end_with?('_file')
+          unless File.exist?(v)
+            %x[mkdir -p '#{File.dirname(v)}' && touch '#{v}']
+            raise 'environment problem:cannot create required files' unless $?.success?
+          end
+        elsif k.end_with?('_pipe')
+          unless File.exist?(v)
+            %x[mkfifo '#{v}']
+            raise 'environment problem:cannot create required pipe' unless $?.success?
+          end
+        end
+      end
+    end
+
+    def expand_paths(env_config)
+      env_config.each do |k,v|
+        if k.end_with?('_file') || k.end_with?('_pipe')
+          env_config[k] = File.expand_path(v)
+        end
+      end
+    end
+
+  end
+end

data/lib/cultome_player/events.rb

@@ -0,0 +1,29 @@
+module CultomePlayer
+  module Events
+
+    # Lazy getter of registered event listeners.
+    #
+    # @return [Hash] With event names as the keys and values are the listeners registered to that event.
+    def listeners
+      @listeners ||= Hash.new{|h,k| h[k] = [] }
+    end
+
+    # Register a listener to an event.
+    #
+    # @param event [Symbol] The event name.
+    # @param listener [Object] Implements a callback with the name on_<event name>.
+    # @return [Object] The registered listener.
+    def register_listener(event, listener)
+      listeners[event] << listener
+      return listener
+    end
+
+    # Broadcast an event to all the registered listeners.
+    #
+    # @param event [Symbol] The event name.
+    # @param data [Array] The information sended to the listeners.
+    def emit_event(event, *data)
+      listeners[event].collect{|l| l.send("on_#{event}".to_sym, *data) }
+    end
+  end
+end

data/lib/cultome_player/media.rb

@@ -0,0 +1,47 @@
+require 'taglib'
+
+module CultomePlayer
+  module Media
+
+    # Get information from ID3 tags in a mp3.
+    #
+    # @param filepath [String] The absolute path to the mp3 file.
+    # @param opc [Hash] Additional parameters. Actually only :library_path is supported.
+    # @return [Hash] With information extracted from ID3 tags.
+    def extract_from_mp3(filepath, opc={})
+      info = nil
+      TagLib::FileRef.open(filepath) do |mp3|
+        unless mp3.nil?
+          info = {
+            # file information
+            file_path: filepath,
+            library_path: opc[:library_path],
+            # song information
+            album: mp3.tag.album,
+            artist: mp3.tag.artist,
+            genre: mp3.tag.genre,
+            name: mp3.tag.title,
+            track: mp3.tag.track,
+            year: mp3.tag.year,
+            duration: mp3.audio_properties.length,
+          }
+        end
+      end
+      # si no se encontro nombre de la cancion en las etiquestas, usamos el nombre del archivo
+      info[:name] = filepath.split('/').last if info[:name].nil?
+      # limpiamos la informacion un poco
+      return polish_mp3_info(info)
+    end
+
+    private 
+
+    def polish_mp3_info(info)
+      [:genre, :name, :artist, :album].each{|k| info[k] = info[k].downcase.strip.titleize unless info[k].nil? }
+      [:track, :year].each{|k| info[k] = info[k].to_i if info[k] =~ /\A[\d]+\Z/ }
+      info[:duration] = info[:duration].to_i
+
+      return info
+    end
+
+  end
+end

data/lib/cultome_player/objects.rb

@@ -0,0 +1,15 @@
+require 'cultome_player/utils'
+
+require 'cultome_player/objects/command'
+require 'cultome_player/objects/parameter'
+require 'cultome_player/objects/response'
+require 'cultome_player/objects/song'
+require 'cultome_player/objects/artist'
+require 'cultome_player/objects/album'
+require 'cultome_player/objects/genre'
+require 'cultome_player/objects/drive'
+
+module CultomePlayer
+  module Objects
+  end
+end

data/lib/cultome_player/objects/album.rb

@@ -0,0 +1,21 @@
+require 'active_record'
+
+module CultomePlayer
+  module Objects
+    # The ActiveRecord model for Album objects.
+    class Album < ActiveRecord::Base
+      has_many :songs
+      has_many :artists, through: :songs
+
+      def to_s
+        str = c4(":::: Album: ")
+        str += c13(self.name)
+        str += c4(" \\ Artist: ")
+        unless self.artists.nil? || self.artists.empty?
+          str += c11(self.artists.uniq.collect{|a| a.name}.join(', '))
+        end
+        str += c4(" ::::")
+      end
+    end
+  end
+end

data/lib/cultome_player/objects/artist.rb

@@ -0,0 +1,18 @@
+require 'active_record'
+
+module CultomePlayer
+  module Objects
+    # The ActiveRecord model for Artist objects.
+    class Artist < ActiveRecord::Base
+      has_many :songs
+      has_many :albums, through: :songs
+      has_many :similars, as: :similar
+
+      def to_s
+        str = c4(":::: Artist: ")
+        str += c11(self.name)
+        str += c4(" ::::")
+      end
+    end
+  end
+end

data/lib/cultome_player/objects/command.rb

@@ -0,0 +1,37 @@
+module CultomePlayer
+  module Objects
+    class Command
+      attr_reader :action
+      attr_reader :parameters
+
+      def initialize(action, parameters)
+        @action = action[:value]
+        @parameters = parameters.collect{|p| Parameter.new(p) }
+      end
+
+      # Returns the parameters, optionally filtered by type
+      #
+      # @param type [Symbol] Parameter type to filter the results
+      # @return [List<Parameter>] The parameters associated with the command, optionally filtered.
+      def params(type=nil)
+        return @parameters if type.nil?
+        @parameters.select{|p| p.type == type}
+      end
+
+      # Returns a map that contains parameter type as key and a list of the parameters of that type as value.
+      #
+      # @return [Hash<Symbol, List<Parameter>>] Parameters grouped by type.
+      def params_groups
+        @parameters.collect{|p| p.type }.each_with_object({}){|type,acc| acc[type] = params(type) }
+      end
+
+      # Returns a list with only the parameters values of certain type.
+      #
+      # @param type [Symbol] The type of parameters.
+      # @return [List<Object>] The values of the parameters.
+      def params_values(type)
+        params(type).map{|p| p.value }
+      end
+    end
+  end
+end

data/lib/cultome_player/objects/drive.rb

@@ -0,0 +1,26 @@
+require 'active_record'
+
+module CultomePlayer
+  module Objects
+    # The ActiveRecord model for Drive objects.
+    class Drive < ActiveRecord::Base
+      has_many :songs
+
+      def connected?
+        connected
+      end
+
+      def to_s
+        str = c4(":::: Drive: ")
+        str += c14(self.name)
+        str += c4(" => ")
+        str += c14(self.songs.size.to_s)
+        str += c4(" songs => ")
+        str += c14(self.path)
+        str += c4(" => ")
+        str += connected ? c3("Online") : c2("Offline")
+        str += c4(" ::::")
+      end
+    end
+  end
+end

data/lib/cultome_player/objects/genre.rb

@@ -0,0 +1,16 @@
+require 'active_record'
+
+module CultomePlayer
+  module Objects
+    # The ActiveRecord model for Genre objects.
+    class Genre < ActiveRecord::Base
+      has_and_belongs_to_many :songs
+
+      def to_s
+        str = c4(":::: Genre: ")
+        str += c15(self.name)
+        str += c4(" ::::")
+      end
+    end
+  end
+end

data/lib/cultome_player/objects/parameter.rb

@@ -0,0 +1,37 @@
+module CultomePlayer
+  module Objects
+    class Parameter
+      include CultomePlayer::Utils
+
+      # Initialize a parameter with the data provided.
+      #
+      # @param data [Hash] Contains the keys :criteria, :value, :type
+      def initialize(data)
+        @data = data
+      end
+
+      # Get the criteria asocciated with the parameter, if any.
+      def criteria
+        return nil if @data[:criteria].nil?
+        @data[:criteria].to_sym
+      end
+
+      # Returns the value associated with the parameter in its appropiated type.
+      #
+      # @return [Object] The value of the parameter.
+      def value
+        return is_true_value?(@data[:value]) if @data[:type] == :boolean
+        return @data[:value].to_i if @data[:type] == :number
+        return @data[:value].to_sym if @data[:type] == :object
+        @data[:value]
+      end
+
+      # Returns the type associated with the parameter.
+      #
+      # @return [Symbol] The type of the parameter.
+      def type
+        @data[:type]
+      end
+    end
+  end
+end