cultome_player 2.0.0

data/config/environment.yml

@@ -0,0 +1,28 @@
+user:
+  db_adapter: sqlite3
+  db_file: ~/.cultome/db.dat
+  db_log_file: ~/.cultome/db.log
+  file_types: mp3
+  mplayer_pipe: ~/.cultome/mpctr
+  config_file: ~/.cultome/config.yml
+memory:
+  db_adapter: sqlite3
+  db_file: /tmp/db.dat
+  db_log_file: /tmp/db.log
+  file_types: mp3
+  mplayer_pipe: /tmp/mpctr
+  config_file: /tmp/config.yml
+rspec:
+  db_adapter: sqlite3
+  db_file: spec/db.dat
+  db_log_file: spec/db.log
+  file_types: mp3
+  mplayer_pipe: spec/mpctr
+  config_file: spec/config.yml
+test:
+  db_adapter: sqlite3
+  db_file: ~/tmp/db.dat
+  db_log_file: ~/tmp/db.log
+  file_types: mp3
+  mplayer_pipe: ~/tmp/mpctr
+  config_file: ~/tmp/config.yml

data/cultome_player.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cultome_player/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "cultome_player"
+  gem.version       = CultomePlayer::VERSION
+  gem.summary       = "CulToMe Player"
+  gem.description   = "A console music library explorer and player"
+  gem.authors       = ["Carlos Soria"]
+  gem.email         = "cultome@gmail.com"
+  gem.homepage      = "https://github.com/cultome/cultome_player"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency "activerecord"
+  gem.add_runtime_dependency "activesupport"
+  gem.add_runtime_dependency "taglib-ruby"
+  gem.add_runtime_dependency "rb-readline"
+  gem.add_runtime_dependency "sqlite3"
+  gem.add_runtime_dependency "colorize"
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "coveralls"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "bundler"
+  gem.add_development_dependency "database_cleaner"
+  gem.add_development_dependency "pry"
+  gem.add_development_dependency "yard"
+end

data/db/001_create_schema.rb

@@ -0,0 +1,58 @@
+
+class CreateSchema < ActiveRecord::Migration
+  def self.up
+    create_table :songs do |t|
+      t.string :name # If I Had A Gun
+      t.integer :artist_id, default: 0 # Noel Gallagher
+      t.integer :album_id, default: 0 # High Flying Birds
+      t.integer :year # 2011
+      t.integer :track # 3
+      t.integer :duration # 210 sec
+      t.integer :drive_id
+      t.string :relative_path
+      t.integer :points, default: 0
+      t.integer :plays, default: 0
+      t.datetime :last_played_at
+      t.timestamps
+    end
+
+    create_table :albums do |t|
+      t.string :name
+      t.integer :points
+      t.timestamps
+    end
+
+    create_table :artists do |t|
+      t.string :name
+      t.integer :points
+      t.timestamps
+    end
+
+    create_table :genres do |t|
+      t.integer :points
+      t.string :name
+    end
+
+    create_table :genres_songs, id: false do |t|
+      t.integer :song_id
+      t.integer :genre_id
+    end
+
+    create_table :drives do |t|
+      t.string :name
+      t.string :path
+      t.boolean :connected, default: true
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :songs
+    drop_table :albums
+    drop_table :artists
+    drop_table :genres
+    drop_table :genres_songs
+    drop_table :drives
+  end
+end
+

data/lib/cultome_player.rb

@@ -0,0 +1,107 @@
+require "cultome_player/version"
+require "cultome_player/environment"
+require "cultome_player/objects"
+require "cultome_player/command"
+require "cultome_player/player"
+require "cultome_player/media"
+require "cultome_player/utils"
+require "cultome_player/events"
+require "cultome_player/plugins"
+require "cultome_player/state_checker"
+
+module CultomePlayer
+  include Environment
+  include Utils
+  include Objects
+  include Command
+  include Player
+  include Media
+  include Events
+  include Plugins
+  include StateChecker
+
+  # Interpret a user input string as it would be typed in the console.
+  #
+  # @param user_input [String] The user input.
+  # @return [Response] Response object with information about command execution.
+  def execute(user_input)
+    cmd = parse user_input
+    # revisamos si es un built in command o un plugin
+    action = cmd.action
+    plugin_action = "command_#{cmd.action}".to_sym
+    action = plugin_action if respond_to?(plugin_action)
+
+    raise 'invalid command:action unknown' unless respond_to?(action)
+    with_connection do
+      begin
+        send(action, cmd)
+      rescue Exception => e
+        s = e.message.split(":")
+        failure(message: s[0], details: s[1])
+      end
+    end
+  end
+
+  # Creates a generic response
+  #
+  # @param type [Symbol] The response type.
+  # @param data [Hash] The information that the response will contain.
+  # @return [Response] Response object with information in form of getter methods.
+  def create_response(type, data)
+    data[:response_type] = data.keys.first unless data.has_key?(:response_type)
+    return Response.new(type, data)
+  end
+
+  # Creates a success response. Handy method for #create_response
+  #
+  # @param response [Hash] The information that the response will contain.
+  # @return [Response] Response object with information in form of getter methods.
+  def success(response)
+    create_response(:success, get_response_params(response))
+  end
+
+  # Creates a failure response. Handy method for #create_response
+  #
+  # @param response [Hash] The information that the response will contain.
+  # @return [Response] Response object with information in form of getter methods.
+  def failure(response)
+    create_response(:failure, get_response_params(response))
+  end
+
+  class << self
+    class DefaultPlayer
+      include CultomePlayer
+
+      def initialize(env)
+        prepare_environment(env)
+        playlists.register(:current)
+        playlists.register(:history)
+        playlists.register(:queue)
+        playlists.register(:focus)
+        playlists.register(:search)
+        
+        register_listener(:playback_finish, self)
+      end
+
+      def on_playback_finish
+        r = execute("next no_history")
+        display_over("#{r.message}\n#{PROMPT}")
+      end
+    end
+
+    # Get an instance of DefaultPlayer
+    #
+    # @param env [Symbol] The environment from which the configirations will be taken.
+    # @return [DefaultPlayer] A Cultome player ready to rock.
+    def get_player(env=:user)
+      DefaultPlayer.new(env)
+    end
+  end
+
+  private
+
+  def get_response_params(response) 
+    return {message: response} if response.instance_of?(String)
+    return response
+  end
+end

data/lib/cultome_player/command.rb

@@ -0,0 +1,11 @@
+require 'cultome_player/command/language'
+require 'cultome_player/command/processor'
+require 'cultome_player/command/reader'
+
+module CultomePlayer
+  module Command
+    include Language
+    include Processor
+    include Reader
+  end
+end

data/lib/cultome_player/command/language.rb

@@ -0,0 +1,61 @@
+module CultomePlayer::Command
+  module Language
+
+    # Define the sintaxis of the player language.
+    #
+    # @return [Hash] With the keys :command, :parameters, :actions, :param
+    def sintaxis
+      # <command>    : <action> | <action> <parameters>
+      # <action>     : literal
+      # <parameters> : <param> | <param> <parameters>
+      # <param>      : literal | criteria | number | object | path | bubble
+      {
+        command: ["action", "action parameters"],
+        parameters: ["param", "param parameters"],
+        action: [:literal],
+        param: [:literal, :criteria, :number, :object, :path, :boolean, :bubble],
+      }
+    end
+
+    # Returns the semantics of the builtin commands.
+    #
+    # @note The first literal in regex is the command itself.
+    # @return [Hash<String, Regex>] The key is the command name and the regex its format.
+    def semantics
+      {
+        "play" => /^literal(literal|number|criteria|object|[\s]+)*$/,
+        "show" => /^literal(number|object|[\s]+)*$/,
+        "search" => /^literal(literal|criteria|[\s]+)+$/,
+        "enqueue" => /^literal(literal|number|criteria|object|[\s]+)+$/,
+        "connect" => /^literal ((literal)|(path) bubble (literal))$/,
+        "disconnect" => /^literal (literal)$/,
+        "stop" => /^literal[\s]*$/,
+        "pause" => /^literal (boolean)$/,
+        "prev" => /^literal[\s]*$/,
+        "next" => /^literal[\s]*$/,
+        "quit" => /^literal[\s]*$/,
+        "ff" => /^literal(number|[\s]+)*$/,
+        "fb" => /^literal(number|[\s]+)*$/,
+        "shuffle" => /^literal[\s]+(boolean)$/,
+        "repeat" => /^literal[\s]*$/,
+      }
+    end
+
+    # Return the token identities.
+    #
+    # @return [List<Hash>] The has contains the type of the token and their format.
+    def token_identities
+      [
+        {type: :bubble, identity: /^(=>|->)$/},
+        {type: :number, identity: /^([\d]+)$/},
+        {type: :object, identity: /^@([\w\d]+)$/},
+        {type: :path, identity: /^(['"]?(?:\/|~\/)[\/\w\d\s.]+)["']?$/},
+        {type: :criteria, identity: /^([\w]+):([\d\w\s]+)$/, captures: 2, labels: [:criteria, :value]},
+        {type: :boolean, identity: /^(on|off|yes|false|true|si|no|y|n|s|ok)$/},
+        {type: :ip, identity: /^([\d]{1,3}\.[\d]{1,3}\.[\d]{1,3}\.[\d]{1,3})$/},
+        {type: :literal, identity: /^([\w\d\s]+)$/},
+      ]
+    end
+
+  end
+end

data/lib/cultome_player/command/processor.rb

@@ -0,0 +1,165 @@
+module CultomePlayer::Command
+  module Processor
+
+    # Parse a user input into a command
+    #
+    # @param user_input [String] The user input to be parsed.
+    # @return [Command] The parsed command.
+    def parse(user_input)
+      tokens = identify_tokens(get_tokens(user_input))
+      validate_command(:command, tokens)
+      return CultomePlayer::Objects::Command.new(tokens.shift, tokens)
+    end
+
+    # Split the user input into tokens.
+    #
+    # @param user_input [String] The user input.
+    # @return [List<String>] The detected tokens.
+    def get_tokens(user_input)
+      tokens = []
+      token = ""
+      capturing_string = false
+
+      user_input.each_char do |char|
+        case char
+        when /[\d\w\/:@]/
+          token << char
+        when /["']/
+          capturing_string = !capturing_string
+        when /[\s]/
+          if capturing_string
+            token << char
+          else
+            tokens << token
+            token = ""
+          end
+        else
+          token << char
+        end # case
+      end # each
+
+      tokens << token unless token.empty?
+      raise "invalid command:unclosed string" if capturing_string
+
+      return tokens
+    end
+
+    # Identify detected tokens.
+    #
+    # @param tokens [List<String>] The detected tokens.
+    # @return [List<Hash>] The hash contains keys :type and :value.
+    def identify_tokens(tokens)
+      tokens.map do |token|
+        id = guess_token_id(token)
+        id.nil? ?  {type: :unknown, value: token} : get_token_value(token, id)
+      end
+    end
+
+    # Check that a the tokens identifed correspond to a player command.
+    #
+    # @param type [Symbol] The language structure you try to match.
+    # @param tokens [List<Hash>] The list of tokens identified.
+    # @return [Boolean] True if the user command match with a player command format.
+    def validate_command(type, tokens)
+      current_format = get_command_format(type, tokens)
+      # extraemos el primer token, que debe ser el comando
+      cmd = tokens.first[:value]
+      
+      valid_format = semantics[cmd]
+      if valid_format.nil?
+        if plugins_respond_to?(cmd)
+          valid_format = plugin_command_sintaxis(cmd)
+        else
+          raise 'invalid command:invalid action'
+        end
+      end
+      return current_format =~ valid_format 
+    end
+
+    # Creates a string representation of the command prototype.
+    #
+    # @param type [Symbol] The Language structure you try to match.
+    # @param tokens [List<Hash>] The Language structure you try to match.
+    # @return [String] The string representation of the command prototype.
+    def get_command_format(type, tokens)
+      format = guess_command_format(type, tokens)
+
+      return format if format.class == Symbol
+
+      langs = format.split
+      # partimos el formato y validamos cada pedazo
+      tks = tokens.clone
+
+      cmd_format = ""
+      while !langs.empty? do
+        # extraemos el primer elemento del formato
+        lang = langs.shift
+
+        if langs.empty?
+          # volvemos a validar con el nuevo elemento del lenguaje
+          cmd_format << " " << get_command_format(lang.to_sym, tks).to_s
+        else
+          tk = tks.shift
+          cmd_format << " " << get_command_format(lang.to_sym, tk).to_s
+        end
+      end
+      # limpiamos el formato final
+      return cmd_format.strip.gsub(" ", " ")
+    end
+
+    private
+
+    def guess_token_id(token)
+      token_identities.find do |tok_id|
+        token =~ tok_id[:identity]
+      end
+    end
+
+    def get_token_value(token, id)
+      captures = id[:captures] || 1
+      labels = id[:labels] || [:value]
+
+      token_info = {type: id[:type]}
+
+      token =~ id[:identity]
+      (1..captures).to_a.zip(labels).each do |idx, label|
+        token_info[label] = eval("$#{idx}")
+      end
+
+      return token_info
+    end
+
+    def guess_command_format(type, tokens)
+      # buscamos el formato que tenga mas matches con los parametros
+      format = sintaxis[type].find do |stxs_elem| # ["action", "action parameters"]
+        if stxs_elem.is_a?(String)
+           # checamos si el numero de token en el comando corresponde
+           # con el numer de tokens en la sintaxis
+           stxs_elem.split.size >= tokens.size # ej. "play 1 2" === "action paramters"
+        elsif stxs_elem.is_a?(Symbol)
+          if tokens.is_a?(Hash)
+            tokens[:type] == stxs_elem
+          elsif tokens.is_a?(Array) && tokens.size == 1
+            tokens.first[:type] == stxs_elem
+          else
+            false
+          end
+        else
+          raise 'invalid command:invalid command format'
+        end
+      end
+
+      if format.nil?
+        max = sintaxis[type].max{|tk| tk.class == String ? tk.split.size: 0}
+        if max.respond_to?(:split) && tokens.size > max.split.size
+          format = max
+        else
+          raise 'invalid command:invalid command'
+        end
+      end
+
+      return format
+    end
+
+  end
+end