lyricli 0.0.1

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,63 @@
+PATH
+  remote: .
+  specs:
+    lyricli (0.0.1)
+      launchy (~> 2.1.2)
+      multi_json (~> 1.3.6)
+      nokogiri (~> 1.5.5)
+      rdio (~> 0.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.3.2)
+    archive-tar-minitar (0.5.2)
+    columnize (0.3.6)
+    daemons (1.1.9)
+    diff-lcs (1.1.3)
+    eventmachine (1.0.0)
+    json (1.7.5)
+    launchy (2.1.2)
+      addressable (~> 2.3)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
+    multi_json (1.3.6)
+    nokogiri (1.5.5)
+    oauth (0.4.7)
+    rack (1.4.1)
+    rdio (0.1.0)
+      json
+      oauth (>= 0.3.0)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
+    thin (1.5.0)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
+    yard (0.8.2.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  lyricli!
+  rspec (~> 2.11.0)
+  ruby-debug19 (~> 0.11.6)
+  thin (~> 1.5.0)
+  yard (~> 0.8.2.1)

data/README.md

@@ -0,0 +1,69 @@
+# Lyricli #
+## The command line client for lyrics ##
+
+This is a quick introduction for Lyricli. Right now it's in really early
+stages of development, so it's lacking in a lot of stuff (mainly tests
+and documentation) ... But it generally works and here's a tutorial to
+see how to get it working.
+
+### Installing ###
+
+1. Clone this Repo
+2. `gem build lyricli.gemspec`
+3. `gem install lyricli-0.0.1.gem`
+4. Voila!
+
+### Usage ###
+
+Lyricli can be invoked with the command `lrc` and there are three basic
+ways of using it:
+
+`lrc`
+
+When you run it without arguments, it will look in the available sources
+to try to find a playing song and extract the lyrics.
+
+`lrc artist song`
+
+When you run it with arguments, it will use them to search for the
+lyrics. This won't work if you manually disable the arguments source in
+your configuration file.
+
+#### Commands ####
+
+The third way to use it is by passing it one of the following special
+commands:
+
+* `lrc -l` or `lrc --list-sources` lists the available sources.
+* `lrc -e` or `lrc --enable SOURCE` enable a source from the list.
+* `lrc -d` or `lrc --disable SOURCE` disable a source from the list.
+* `lrc -r` or `lrc --reset SOURCE` reset all configuration for a source.
+* `lrc -v` or `lrc --version` show the installed version of lyricli.
+* `lrc -h` or `lrc --help` display some help
+
+### Roadmap ###
+
+There is not much defined right now as a roadmap, but this needs to be
+done:
+
+* Specs for all the components
+* YARD documentation for all the components
+
+And the first thing I want to work on after that is done is separating
+the Lyrics Engines so we can add/remove lyrics engines in a similar way to how
+we currently add/remove sources.
+
+Also, I want to add the last song to the configuration, so you can check
+that. This would let us "watch" lyricli without hammering the lyrics
+wiki api
+
+Also, during the enable phase, sources like iTunes should check for
+proper OS and stop if they're not in their home turf.
+
+### Leave Feedback Please! ###
+
+If you decide to use or hack away at Lyricly, please don't forget to
+post any issues you find.
+
+### License ###
+Licensed under 3-clause-BSD.

data/bin/lrc

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby -w
+
+require 'optparse'
+require 'lyricli'
+
+
+options = {}
+OptionParser.new do |opts|
+    opts.banner = %{Usage:
+    lrc [options]
+    lrc artist song
+    lrc                              You must enable other sources for this
+
+Options:
+}
+
+    opts.on("-e", "--enable SOURCE", "Enable SOURCE") do |source|
+      Lyricli.enable(source)
+      puts "#{source} has been enabled"
+      exit
+    end
+
+    opts.on("-l", "--list-sources", "List all available Sources") do
+      puts Lyricli.sources
+      exit
+    end
+
+    opts.on("-d", "--disable SOURCE", "Disable SOURCE") do |source|
+      Lyricli.disable(source)
+      puts "#{source} has been disabled"
+      exit
+    end
+
+    opts.on("-r", "--reset SOURCE", "Reset the configuration of SOURCE") do |source|
+      Lyricli.reset(source)
+      puts "#{source} has been disabled and all its configuration reset"
+      exit
+    end
+
+    opts.on("-h", "--help", "Shows this message") do
+      puts opts
+      exit
+    end
+
+    opts.on("-v", "--version", "Show version") do
+      puts Lyricli.version
+      exit
+    end
+end.parse!
+
+
+puts Lyricli.lyrics

data/config/defaults.json

@@ -0,0 +1,5 @@
+{
+  "rdio_key": "sddac5t8akqrzh5b6kg53jfm",
+  "rdio_secret": "PRcB8TggFr",
+  "enabled_sources": ["arguments"]
+}

data/lib/lyricli/configuration.rb

@@ -0,0 +1,90 @@
+module Lyricli
+
+  # This class handles the configuration of Lyricli
+  class Configuration
+
+    # Defines the paths to the default and user configuration files
+    def initialize
+      @config_path = "~/.lyricli.conf"
+      @defaults_path = "defaults.json"
+      @config = nil
+    end
+
+    @@instance = Configuration.new
+
+    # Ensure this is only called once. Only use the instance class variable
+    # to access this method, as its constructor is private.
+    def self.instance
+      @@instance
+    end
+
+    # Access configuration properties, loads config if needed beforehand.
+    #
+    # @param [String] key the configuration key to access
+    # @return [String, Hash, Array] the value of the configuration key.
+    def [](key)
+      load_config unless @config
+      @config[key]
+    end
+
+    # Assigns a new value to a configuration key, loads config if needed and
+    # saves it after updating.
+    #
+    # @param [String] key the configuration key to set
+    # @param [Object] value the value for the configuration key, can be any
+    #                 object as long as it can be converted to JSON
+    def []=(key, value)
+      load_config unless @config
+      @config[key] = value
+      save_config
+    end
+
+    # Deletes a key from the configuration, loads config if needed and saves
+    # it after deleting.
+    #
+    # @param [String] key the key to delete
+    def delete(key)
+      load_config unless @config
+      @config.delete(key)
+      save_config
+    end
+
+    private_class_method :new
+
+    # Loads the configuration from the user file, attempts to create it from
+    # defaults if it's not present. sets the `@config` instance variable.
+    def load_config
+      path = File.expand_path(@config_path)
+
+      if File.exists?(path)
+        file = File.new(path, "r")
+        @config = MultiJson.decode(file.read)
+      else
+        load_default_config
+      end
+    end
+
+    # Serializes the `@config` Hash to JSON and saves it to a file.
+    def save_config
+      path = File.expand_path(@config_path)
+      file = File.new(path, "w")
+      file.print(MultiJson.encode(@config))
+      file.close
+    end
+
+    private
+
+    # Loads the default configuration from a JSON file
+    def load_default_config
+      # Load the default
+      path = File.join(::Lyricli.root, "config", @defaults_path)
+
+      if File.exists?(path)
+        file = File.new(path, "r")
+        @config = MultiJson.decode(file.read)
+      else
+        @config = {}
+      end
+    end
+  end
+end

data/lib/lyricli/exceptions/disable_source_error.rb

@@ -0,0 +1,8 @@
+module Lyricli
+  module Exceptions
+    # There was an error when disabling a source
+    class DisableSourceError < StandardError
+    end
+  end
+end
+

data/lib/lyricli/exceptions/enable_source_error.rb

@@ -0,0 +1,8 @@
+module Lyricli
+  module Exceptions
+    # There was an error when enabling the source
+    class EnableSourceError < StandardError
+    end
+  end
+end
+

data/lib/lyricli/exceptions/invalid_lyrics_error.rb

@@ -0,0 +1,8 @@
+module Lyricli
+  module Exceptions
+    # No artist/song was found.
+    class InvalidLyricsError < StandardError
+    end
+  end
+end
+

data/lib/lyricli/exceptions/lyrics_not_found_error.rb

@@ -0,0 +1,8 @@
+module Lyricli
+  module Exceptions
+    # No lyrics could be found for this artist/song pair
+    class LyricsNotFoundError < StandardError
+    end
+  end
+end
+

data/lib/lyricli/exceptions/reset_source_error.rb

@@ -0,0 +1,8 @@
+module Lyricli
+  module Exceptions
+    # There was an error while resetting a source
+    class ResetSourceError < StandardError
+    end
+  end
+end
+

data/lib/lyricli/exceptions/source_configuration_error.rb

@@ -0,0 +1,9 @@
+module Lyricli
+  module Exceptions
+    # There is an error with the source's configuration and it can't
+    # find its current track.
+    class SourceConfigurationError < StandardError
+    end
+  end
+end
+

data/lib/lyricli/exceptions/start_source_error.rb

@@ -0,0 +1,7 @@
+module Lyricli
+  module Exceptions
+    # There was an error while starting a source
+    class StartSourceError < StandardError
+    end
+  end
+end

data/lib/lyricli/exceptions/unknown_source_error.rb

@@ -0,0 +1,8 @@
+module Lyricli
+  module Exceptions
+    # An unknown source was tried to enable/disable/reset
+    class UnknownSourceError < StandardError
+    end
+  end
+end
+

data/lib/lyricli/exceptions.rb

@@ -0,0 +1,7 @@
+module Lyricli
+  # The namespace for all exceptions in Lyricli. Has no functionality by
+  # itself
+  module Exceptions
+  end
+end
+

data/lib/lyricli/lyricli.rb

@@ -0,0 +1,55 @@
+module Lyricli
+
+  # This class has the basic logic for extracting the lyrics and controlling the
+  # application
+  class Lyricli
+
+    # Constructor, initializes `@source_manager`
+    def initialize
+      @source_manager = SourceManager.new
+    end
+
+    # Raises an InvalidLyricsError which means we did not get any valid
+    # artist/song from any of the sources
+    #
+    # @raise [Lyricli::Exceptions::InvalidLyricsError] because we found nothing
+    def exit_with_error
+      raise Exceptions::InvalidLyricsError
+    end
+
+    # Extracts the current track, validates it and requests the lyrics from our
+    # LyricsEngine
+    #
+    # @return [String] the found lyrics, or a string indicating none were found
+    def get_lyrics
+
+      begin
+        set_current_track
+        check_params
+      rescue Exceptions::InvalidLyricsError
+        return "No Artist/Song could be found :("
+      end
+
+      engine = LyricsEngine.new(@current_track[:artist], @current_track[:song])
+
+      begin
+        return engine.get_lyrics
+      rescue Exceptions::LyricsNotFoundError
+        return "Lyrics not found :("
+      end
+    end
+
+    # Set the `@current_track` instance variable by asking the SourceManager for
+    # its current track
+    def set_current_track
+      @current_track = @source_manager.current_track
+    end
+
+    # Exits with error when there is an empty field from the current track.
+    def check_params
+      self.exit_with_error unless @current_track
+      self.exit_with_error if @current_track[:artist].nil? or @current_track[:artist].empty?
+      self.exit_with_error if @current_track[:song].nil? or @current_track[:song].empty?
+    end
+  end
+end

data/lib/lyricli/lyrics_engine.rb

@@ -0,0 +1,41 @@
+module Lyricli
+
+  # This class gets the lyrics according to a given artist and song name.
+  class LyricsEngine
+
+    include Util
+
+    # Starts a new instance of LyricsEngine
+    #
+    # @param [String] artist the artist
+    # @param [String] song the song to look for
+    def initialize(artist, song)
+      @provider = URI("http://lyrics.wikia.com/api.php?artist=#{sanitize_param artist}&song=#{sanitize_param song}&fmt=realjson")
+    end
+
+    # Asks Lyrics Wiki for the lyrics, also cleans up the output a little.
+    #
+    # @return [String] the lyrics
+    def get_lyrics
+      begin
+        response = Net::HTTP.get(@provider)
+        response = MultiJson.decode(response)
+
+        doc = Nokogiri::HTML(open(response['url']))
+        node = doc.search(".lyricbox").first
+      rescue
+        raise Exceptions::LyricsNotFoundError
+      end
+
+      node.search(".rtMatcher").each do |n|
+        n.remove
+      end
+
+      node.search("br").each do |br|
+        br.replace "\n"
+      end
+
+      node.inner_text
+    end
+  end
+end

data/lib/lyricli/source_manager.rb

@@ -0,0 +1,136 @@
+module Lyricli
+
+  # Manages the different sources. SourceManager is in charge of enabling and
+  # disabling them, as well as getting the current track.
+  class SourceManager
+
+    include Util
+
+    # Creates a new instance of SourceManager
+    def initialize
+      @enabled_sources = []
+      @config = Configuration.instance
+      @config["enabled_sources"].each do |source|
+        if klass = parse_class(camelize(source))
+          current_source = klass.new
+          @enabled_sources << current_source
+        else
+          raise Exceptions::StartSourceError
+        end
+      end
+    end
+
+    # Enables a source. This runs the source's enable method and adds it to the
+    # `enabled_sources` configuration key. It will only enable sources that
+    # are "available" (see #available_sources)
+    #
+    # @param [String] source_name the name of the source to enable
+    def enable(source_name)
+      if available_sources.include?(source_name)
+        if klass = parse_class(camelize(source_name))
+          klass.enable
+          @config["enabled_sources"] << klass.name
+          @config["enabled_sources"].uniq!
+          @config.save_config
+        else
+          raise Exceptions::EnableSourceError
+        end
+      else
+        raise Exceptions::UnknownSourceError
+      end
+    end
+
+    # Disables a source. This only removes the source from the `enabled_sources`
+    # configuration key.
+    #
+    # @param [String] source_name the name of the source to disable
+    def disable(source_name)
+      if available_sources.include?(source_name)
+        if klass = parse_class(camelize(source_name))
+          @config["enabled_sources"].delete(klass.name)
+          @config.save_config
+        else
+          raise Exceptions::DisableSourceError
+        end
+      else
+        raise Exceptions::UnknownSourceError
+      end
+    end
+
+    # Resets a source. This runs the source's reset method. It will also disable
+    # them.
+    #
+    # @param [String] source_name the name of the source to reset.
+    def reset(source_name)
+      if available_sources.include?(source_name)
+        if klass = parse_class(camelize(source_name))
+          klass.reset
+          disable(source_name)
+        else
+          raise Exceptions::ResetSourceError
+        end
+      else
+        raise Exceptions::UnknownSourceError
+      end
+    end
+
+    # Iterates over every source to attempt to retrieve the current song.
+    #
+    # @return [Hash] the current track, has an `:artist` and `:song` key.
+    def current_track
+      track = nil
+      lock = false
+      @enabled_sources.each do |source|
+        begin
+          current_track = source.current_track
+
+          # This is a special thing for arguments. The thing is, they need to
+          # be inputted manually. So, if they are present they won't allow
+          # anyone else to give results. Makes sense, yet a bit hacky.
+          unless current_track[:artist].nil? || current_track[:artist].empty? || current_track[:song].nil? || current_track[:song].empty?
+            track = current_track unless lock
+            lock = true if source.class.name == "arguments"
+          end
+        rescue
+          raise Exceptions::SourceConfigurationError
+        end
+      end
+      track
+    end
+
+    # Returns an array with the available sources. Optionally formats the result
+    # so active sources are identified by an appended *
+    #
+    # @param [Boolean] format whether or not to render the stars for active
+    #                         sources.
+    # @return [Array] the names of the currently available sources.
+    def available_sources(format = false)
+      path_root = File.expand_path(File.dirname(__FILE__))
+      sources = Dir[path_root+"/sources/*.rb"].map{ |s|
+        name = s.split("/").last.gsub(/\.rb/, "")
+        name
+      }
+
+      # Remove arguments (Hack?) We don't want anybody to touch tihs one.
+      sources.delete("arguments")
+      if format
+        # Add a star to denote enabled sources
+        format_sources(sources)
+      else
+        sources
+      end
+    end
+
+    # Adds a star to all members of the array that correspond to an active
+    # source
+    #
+    # @param [Array] sources the array of sources to format
+    # @return [Array] the formatted array
+    def format_sources(sources)
+      sources.map{ |s|
+        s << "*" if @config["enabled_sources"].include?(s)
+        s
+      }
+    end
+  end
+end

data/lib/lyricli/sources/arguments.rb

@@ -0,0 +1,39 @@
+module Lyricli
+  module Sources
+    # The arguments source. This one is special since it expects two
+    # arguments. It is treated specially by the SourceManager.
+    class Arguments
+
+      class << self
+        attr_accessor :name
+      end
+
+      @name = "arguments"
+
+      # The enable method should run all of the tasks needed to validate
+      # the source. In the case of Rdio it has to authenticate with OAuth.
+      def self.enable
+        # Nothing to do.
+      end
+
+      # Instantiates everything it needs to run.
+      def initialize
+        # Nothing to do.
+      end
+
+      # The current_track method should return the name of the current
+      # artist and song.
+      # @return [Hash] A hash containing the current `:song` and `:artist`.
+      def current_track
+        artist = ARGV[0]
+        song = ARGV[1]
+        {:artist => artist, :song => song}
+      end
+
+      # The reset method resets any configurations it may have
+      def self.reset
+        # Reset Code
+      end
+    end
+  end
+end

data/lib/lyricli/sources/itunes.rb

@@ -0,0 +1,41 @@
+module Lyricli
+  module Sources
+    # The source for iTunes
+    class Itunes
+
+      class << self
+        attr_accessor :name
+      end
+
+      @name = "itunes"
+
+      # The enable method should run all of the tasks needed to validate
+      # the source. In the case of Rdio it has to authenticate with OAuth.
+      def self.enable
+        # Nothing to do
+      end
+
+      # Instantiates everything it needs to run.
+      def initialize
+        @config = Configuration.instance
+        @script = "current_song.scpt"
+      end
+
+      # The current_track method should return the name of the current
+      # artist and song.
+      # @return [Hash] A hash containing the current `:song` and `:artist`.
+      def current_track
+        path_root = File.expand_path(File.dirname(__FILE__))
+        path = File.join(path_root, @script)
+        current = `osascript #{path}`
+        current = current.split("<-SEP->")
+        {:artist => current[0], :song => current[1]}
+      end
+
+      # The reset method resets any configurations it may have
+      def self.reset
+        # Nothing to do
+      end
+    end
+  end
+end

data/lib/lyricli/sources/rdio.rb

@@ -0,0 +1,73 @@
+module Lyricli
+  module Sources
+
+    # This is the Source for rdio
+    class Rdio
+
+      class << self
+        attr_accessor :name
+      end
+
+      @name = "rdio"
+
+      # The enable method should run all of the tasks needed to validate
+      # the source. In the case of Rdio it has to authenticate with OAuth.
+      def self.enable
+        # Validation Code
+        @config = Configuration.instance
+        unless @config["rdio_auth_token"] && !@config["rdio_auth_token"].empty?
+          create_auth_token
+        end
+
+        puts "***"
+        puts "Hello, rdio tends to be a bit aggressive and tends to have trouble with other sources. If you're having trouble, you can disable it temporarily. You will not have to reauthenticate."
+        puts "***"
+
+      end
+
+      # Instantiates everything it needs to run.
+      def initialize
+        @name = 'rdio'
+        @config = Configuration.instance
+        @rdio = ::Rdio::SimpleRdio.new([@config["rdio_key"], @config["rdio_secret"]], @config["rdio_auth_token"])
+      end
+
+      # The current_track method should return the name of the current
+      # artist and song.
+      #
+      # @return [Hash] A hash containing the current `:song` and `:artist`.
+      def current_track
+        response = @rdio.call('currentUser', {'extras' => 'lastSongPlayed'})
+        artist = response["result"]["lastSongPlayed"]["artist"]
+        song = response["result"]["lastSongPlayed"]["name"]
+        {:artist => artist, :song => song}
+      end
+
+      # The reset method resets any configurations it may have
+      def self.reset
+        @config = Configuration.instance
+        @config.delete("rdio_auth_token")
+      end
+
+      # Signs in to rdio with our credentials and requests access for a new auth
+      # token.
+      def self.create_auth_token
+        rdio = ::Rdio::SimpleRdio.new([@config["rdio_key"], @config["rdio_secret"]], @config["rdio_auth_token"])
+
+        # Request Authorization
+        puts "Follow this URL to authorize lyricli:"
+        auth_url = rdio.begin_authentication('oob')
+        puts auth_url
+        ::Launchy.open(auth_url)
+
+        # Request Code, Obtain Token
+        print "Please type the authorization code: "
+        auth_code = gets.chomp
+        token = rdio.complete_authentication(auth_code)
+
+        @config["rdio_auth_token"] = token
+        token
+      end
+    end
+  end
+end

data/lib/lyricli/sources.rb

@@ -0,0 +1,6 @@
+module Lyricli
+  # The namespace for all sources in Lyricli. Has no functionality by
+  # itself
+  module Sources
+  end
+end

data/lib/lyricli/util.rb

@@ -0,0 +1,36 @@
+module Lyricli
+  # This module contains several utility functions.
+  module Util
+
+    # Transforms a string from snake_case to UpperCamelCase
+    #
+    # @param [String] str the string that will be Camelized
+    # @return [String] the Camelized string.
+    def camelize(str)
+      str.split('_').map {|w| w.capitalize}.join
+    end
+
+    # Takes a class name in snake_case and attempts to find the corresponding
+    # class from the sources.
+    #
+    # @param [String] class_name the snake_case name of the class to search for.
+    # @return [Class,nil] the found class or nil
+    def parse_class(class_name)
+      begin
+        path = "Sources::#{class_name}"
+        return eval(path)
+      rescue NameError
+        return nil
+      end
+    end
+
+    # Simply escapes a param and substitutes spaces and escaped plus signs for
+    # plus signs.
+    #
+    # @param [String] p the parameter to be sanitized
+    # @return [String] the sanitized parameter
+    def sanitize_param(p)
+      CGI.escape(p.gsub(/ /, "+")).gsub("%2B", "+")
+    end
+  end
+end

data/lib/lyricli.rb

@@ -0,0 +1,96 @@
+require 'uri'
+require 'cgi'
+require 'net/http'
+require 'multi_json'
+require 'nokogiri'
+require 'open-uri'
+require 'launchy'
+
+# This shit causes a lot of warnings. Quick Hack.
+original_verbosity = $VERBOSE
+$VERBOSE = nil
+require 'rdio'
+$VERBOSE = original_verbosity
+
+# Local Dependencies
+require "lyricli/util"
+require "lyricli/configuration"
+require "lyricli/lyricli"
+require "lyricli/lyrics_engine"
+require "lyricli/source_manager"
+require "lyricli/sources"
+require "lyricli/sources/arguments"
+require "lyricli/sources/rdio"
+require "lyricli/sources/itunes"
+require "lyricli/exceptions"
+require "lyricli/exceptions/disable_source_error"
+require "lyricli/exceptions/enable_source_error"
+require "lyricli/exceptions/invalid_lyrics_error"
+require "lyricli/exceptions/lyrics_not_found_error"
+require "lyricli/exceptions/reset_source_error"
+require "lyricli/exceptions/source_configuration_error"
+require "lyricli/exceptions/start_source_error"
+require "lyricli/exceptions/unknown_source_error"
+
+# The Lyricli module allows you to easily search for lyrics by looking for
+# song and artist data from diverse sources.
+module Lyricli
+  # Creates a new Lyricli instance and returns lyrics by going through the
+  # sources.
+  # @return [String] the fetched lyrics
+  def self.lyrics
+    @lyricli = Lyricli.new
+    @lyricli.get_lyrics
+  end
+
+  # Returns the version of the library
+  # @return [String] the version
+  def self.version
+    Gem.loaded_specs["lyricli"].version
+  end
+
+  # Returns a list of the available sources to enable or disable
+  # @return [String] the list of available sources. Enabled sources have
+  #                   a star appended.
+  def self.sources
+    source_manager = SourceManager.new
+    source_manager.available_sources(true).join(", ")
+  end
+
+  # Enables a source via the Source Manager
+  def self.enable(source_name)
+    source_manager = SourceManager.new
+    begin
+      source_manager.enable(source_name)
+    rescue Exceptions::UnknownSourceError
+      "There is no such Source"
+    end
+  end
+
+  # Disables a source via the Source Manager
+  def self.disable(source_name)
+    source_manager = SourceManager.new
+    begin
+      source_manager.disable(source_name)
+    rescue Exceptions::UnknownSourceError
+      "There is no such Source"
+    end
+  end
+
+  # Resets all configuration for a source via the Source Manager
+  def self.reset(source_name)
+    source_manager = SourceManager.new
+    begin
+      source_manager.reset(source_name)
+    rescue Exceptions::UnknownSourceError
+      "There is no such Source"
+    end
+  end
+
+  # Returns the root of the Gem.
+  #
+  # @return [String] the root path for this gem
+  def self.root
+    File.expand_path('../..',__FILE__)
+  end
+end

data/spec/lib/lyricli/source_manager_spec.rb

@@ -0,0 +1,25 @@
+require "rspec"
+require "lyricli"
+
+describe Lyricli::SourceManager do
+  before :each do
+    # Stub the configuration
+    @example_configuration = {"enabled_sources" => "test_class"}
+    Configuration.stub(:'[]').and_return(@example_configuration)
+    Configuration.stub(:delete)
+
+    # Stub the test class.
+    module Lyricli
+      module Sources
+        module TestClass
+        end
+      end
+    end
+
+    @example_artist = {:artist => "The Shins", :song => "Know Your Onion"}
+
+    Lyricli::Sources::TestClass.stub(:enable)
+    Lyricli::Sources::TestClass.stub(:reset)
+    Lyricli::Sources::TestClass.stub(:current_track).and_return(@example_artist)
+  end
+end

data/spec/lib/lyricli/util_spec.rb

@@ -0,0 +1,42 @@
+require "rspec"
+require "lyricli"
+
+describe Lyricli::Util do
+  before :each do
+    class TestClass
+      include Lyricli::Util
+    end
+
+    module Lyricli
+      module Sources
+        class ParsedClass
+        end
+      end
+    end
+
+    @c = TestClass.new
+  end
+
+  describe "#camelize" do
+    it "should convert snake_case to CamelCase" do
+      expect(@c.camelize("test_string")).to eq("TestString")
+    end
+  end
+
+  describe "#parse_class" do
+    it "should parse classes under the Source namespace" do
+      expect(@c.parse_class("ParsedClass")).to eq(Lyricli::Sources::ParsedClass)
+    end
+
+    it "should return nil for nonexistent classes" do
+      expect(@c.parse_class("non_existent_class")).to eq(nil)
+    end
+  end
+
+  describe "#sanitize_param" do
+    it "should escape weird characters, but conserve the +" do
+      str = "one two+three /?&"
+      expect(@c.sanitize_param(str)).to eq("one+two+three+%2F%3F%26")
+    end
+  end
+end

metadata

@@ -0,0 +1,212 @@
+--- !ruby/object:Gem::Specification
+name: lyricli
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ben Beltran
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.5
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+- !ruby/object:Gem::Dependency
+  name: rdio
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: launchy
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+- !ruby/object:Gem::Dependency
+  name: ruby-debug19
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.11.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.11.6
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.2.1
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+description: Lyricli is an awesome CLI tool to read the lyrics of your currently playing
+  song right in the command line
+email: ben@nsovocal.com
+executables:
+- lrc
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/lyricli/configuration.rb
+- lib/lyricli/exceptions/disable_source_error.rb
+- lib/lyricli/exceptions/enable_source_error.rb
+- lib/lyricli/exceptions/invalid_lyrics_error.rb
+- lib/lyricli/exceptions/lyrics_not_found_error.rb
+- lib/lyricli/exceptions/reset_source_error.rb
+- lib/lyricli/exceptions/source_configuration_error.rb
+- lib/lyricli/exceptions/start_source_error.rb
+- lib/lyricli/exceptions/unknown_source_error.rb
+- lib/lyricli/exceptions.rb
+- lib/lyricli/lyricli.rb
+- lib/lyricli/lyrics_engine.rb
+- lib/lyricli/source_manager.rb
+- lib/lyricli/sources/arguments.rb
+- lib/lyricli/sources/itunes.rb
+- lib/lyricli/sources/rdio.rb
+- lib/lyricli/sources.rb
+- lib/lyricli/util.rb
+- lib/lyricli.rb
+- bin/lrc
+- Gemfile
+- Gemfile.lock
+- README.md
+- spec/bin/lrc_spec.rb
+- spec/lib/lyricli/configuration_spec.rb
+- spec/lib/lyricli/exceptions_spec.rb
+- spec/lib/lyricli/lyricli_spec.rb
+- spec/lib/lyricli/lyrics_engine_spec.rb
+- spec/lib/lyricli/source_manager_spec.rb
+- spec/lib/lyricli/sources/arguments.rb
+- spec/lib/lyricli/sources/itunes.rb
+- spec/lib/lyricli/sources/rdio.rb
+- spec/lib/lyricli/sources_spec.rb
+- spec/lib/lyricli/util_spec.rb
+- spec/lib/lyricli_spec.rb
+- config/defaults.json
+- lib/lyricli/sources/current_song.scpt
+homepage: http://nsovocal.com/lyricli
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Lyricli is an awesome lyric client for your Command Line
+test_files: []
+has_rdoc: