boson 0.2.0 → 0.2.1

data/README.rdoc

@@ -6,20 +6,30 @@ Works with Ruby 1.8.6 and 1.9.1.
 Note: To read a linkable version of this README, {see here}[http://tagaholic.me/boson/doc/].
 
 == Features
-* Commands are just methods extended for a given object, the default being the top level object, main.
+* Simple organization: Commands are just methods on an object (default is main) and command libraries are just modules.
 * Commands are accessible from the commandline (Boson::BinRunner) or irb (Boson::ConsoleRunner).
-* Command libraries, which are just modules, are written in non-dsl ruby which allows for easy testing
-  and use outside of boson (Boson::FileLibrary).
+* Libraries
+  * can be written in plain ruby which allows for easy testing and use independent of boson (Boson::FileLibrary).
+  * can exist locally as a Bosonfile (Boson::LocalFileLibrary) and under lib/boson/commands or .boson/commands.
+  * can be made from gems (Boson::GemLibrary) or any require-able file (Boson::RequireLibrary).
+  * are encouraged to be shared. Libraries can be installed with a given url. Users can customize any aspect of a third-party
+    library without modifying it (Boson::Library).
+* Commands
+  * can have any number of local and global options (Boson::OptionCommand). Options are defined with Boson::OptionParser.
+  * can have any view associated to it (via Hirb) without adding view code to the command's method.
+    These views can be toggled on and manipulated via global render options (Boson::View and Boson::OptionCommand).
+  * can pipe their return value into multiple commands with pipe options. Default pipe options give the ability
+    to search and sort an array of any objects (Boson::Pipe).
+* Option parser (Boson::OptionParser)
+  * provides option types that map to objects i.e. :array type creates Array objects.
+  * come with 5 default option types: boolean, array, string, hash and numeric.
+  * can have have custom option types defined by users (Boson::Options).
 * Comes with default commands to load, search, list and install commands and libraries (Boson::Commands::Core).
-* Commands can be full-blown commandline apps thanks to powerful options (Boson::OptionParser)
-  and hirb's views.
-* There are 5 default option types: boolean, array, string, hash and numeric. Custom option types
-  can be defined to map to any Ruby class with one method (Boson::Options).
-* Commands can have views toggled without adding view code to the original command (Boson::Scientist).
-* Command libraries are social as a user can install them from a url and then customize command
-  names and options without changing the original library.
 * Namespaces are optional and when used are methods which allow for method_missing magic.
 
+== Creating Command Libraries
+See Boson::FileLibrary or here[http://tagaholic.me/boson/doc/classes/Boson/FileLibrary.html].
+
 == Irb Example
 
 To use in irb, drop this in your ~/.irbrc:
@@ -132,14 +142,11 @@ Having done that, let's start up irb:
 
     # Sweet! Now we have a list and description of commands that come with irb.
 
-== Creating Command Libraries
-See Boson::FileLibrary or here[http://tagaholic.me/boson/doc/classes/Boson/FileLibrary.html].
-
 == Todo
 * More tests
 * Making commands out of existing gems easier and more powerful
-* Better local repositories, perhaps a BosonFile
 * Consider managing extensions to core and standard libraries
+* Features based on commands and their argument types i.e. aliasing, completion, piping
 * Consider dropping alias gem dependency if not using its full potential
 
 == Bugs/Issues

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 2
-:patch: 0
+:patch: 1

data/lib/boson.rb

@@ -3,9 +3,9 @@ $:.unshift File.dirname(__FILE__) unless $:.include? File.expand_path(File.dirna
 %w{runner runners/console_runner repo manager loader inspector library}.each {|e| require "boson/#{e}" }
 %w{argument method comment}.each {|e| require "boson/inspectors/#{e}_inspector" }
 # order of library subclasses matters
-%w{module file gem require}.each {|e| require "boson/libraries/#{e}_library" }
+%w{module file gem require local_file}.each {|e| require "boson/libraries/#{e}_library" }
 (%w{namespace view command util commands option_parser options} +
-  %w{index scientist}).each {|e| require "boson/#{e}" }
+  %w{index repo_index scientist option_command pipe}).each {|e| require "boson/#{e}" }
 
 # This module stores the libraries, commands, repos and main object used throughout Boson.
 #
@@ -17,7 +17,6 @@ $:.unshift File.dirname(__FILE__) unless $:.include? File.expand_path(File.dirna
 # * Boson::FileLibrary - Explains creating libraries as files
 # * Boson::Loader - Explains library module callbacks
 # * Boson::OptionParser - All about options
-# * Boson::Scientist - Explains how commands can be both shell-commands and normal ruby methods
 module Boson
   # Module which is extended by Boson.main_object to give it command functionality.
   module Universe; include Commands::Namespace; end
@@ -45,13 +44,14 @@ module Boson
   # An optional local repository which defaults to ./lib/boson or ./.boson.
   def local_repo
     @local_repo ||= begin
+      ignored_dirs = (repo.config[:ignore_directories] || []).map {|e| File.expand_path(e) }
       dir = ["lib/boson", ".boson"].find {|e| File.directory?(e) &&
-         File.expand_path(e) != repo.dir }
+          File.expand_path(e) != repo.dir && !ignored_dirs.include?(File.expand_path('.')) }
       Repo.new(dir) if dir
     end
   end
 
-  # The array of loaded repositories
+  # The array of loaded repositories containing the main repo and a possible local repo
   def repos
     @repos ||= [repo, local_repo].compact
   end

data/lib/boson/command.rb

@@ -24,28 +24,27 @@ module Boson
     # and :lib are required keys.
     #
     # Attributes that can be configured:
-    # * *:description*: Description that shows up in command listings
-    # * *:alias*: Alternative name for command
-    # * *:options*: Hash of options passed to OptionParser
-    # * *:render_options*: Hash of rendering options passed to OptionParser
-    # * *:args*: Should only be set if not automatically set. This attribute is only
-    #   important for commands that have options/render_options. Its value can be an array
-    #   (as ArgumentInspector.scrape_with_eval produces), a number representing
-    #   the number of arguments or '*' if the command has a variable number of arguments.
-    # * *:default_option* Only for an option command that has one argument. This treats the given
-    #   option as an optional first argument. Example:
-    #     # For a command with default option 'query' and options --query and -v
-    #     'some -v'   -> '--query=some -v'
-    #     '-v'        -> '-v'
+    # [*:description*] Description that shows up in command listings
+    # [*:alias*] Alternative name for command
+    # [*:options*] Hash of options passed to OptionParser
+    # [*:render_options*] Hash of rendering options passed to OptionParser
+    # [*:global_options*] Boolean to enable using global options without having to define render_options or options.
+    # [*:args*] Should only be set if not automatically set. This attribute is only
+    #           important for commands that have options/render_options. Its value can be an array
+    #           (as ArgumentInspector.scrape_with_eval produces), a number representing
+    #           the number of arguments or '*' if the command has a variable number of arguments.
+    # [*:default_option*] Only for an option command that has one or zero arguments. This treats the given
+    #                     option as an optional first argument. Example:
+    #                       # For a command with default option 'query' and options --query and -v
+    #                       'some -v'   -> '--query=some -v'
+    #                       '-v'        -> '-v'
     def initialize(hash)
       @name = hash[:name] or raise ArgumentError
       @lib = hash[:lib] or raise ArgumentError
-      @alias = hash[:alias] if hash[:alias]
-      @description = hash[:description] if hash[:description]
-      @render_options = hash[:render_options] if hash[:render_options]
-      @options = hash[:options] if hash[:options]
-      @namespace = hash[:namespace] if hash[:namespace]
-      @default_option = hash[:default_option] if hash[:default_option]
+      [:alias, :description, :render_options, :options, :namespace, :default_option,
+        :global_options].each do |e|
+          instance_variable_set("@#{e}", hash[e]) if hash[e]
+      end
       if hash[:args]
         if hash[:args].is_a?(Array)
           @args = hash[:args]
@@ -75,7 +74,7 @@ module Boson
 
     # Option parser for command as defined by @options.
     def option_parser
-      @option_parser ||= (@options ? OptionParser.new(@options) : nil)
+      @option_parser ||= OptionParser.new(@options || {})
     end
 
     # Help string for options if a command has it.
@@ -107,7 +106,7 @@ module Boson
     end
 
     def option_command?
-      options || render_options
+      options || render_options || @global_options
     end
 
     def arg_size

data/lib/boson/commands/core.rb

@@ -24,7 +24,7 @@ module Boson::Commands::Core #:nodoc:
           :fields=>{:default=>[:name, :commands, :gems, :library_type], :values=>library_attributes},
           :filters=>{:default=>{:gems=>[:join, ','],:commands=>:size}, :desc=>"Filters to apply to library fields" }}
       },
-      'load_library'=>{:description=>"Load/reload a library", :options=>{:reload=>:boolean, [:verbose,:V]=>true}}
+      'load_library'=>{:description=>"Load a library", :options=>{[:verbose,:V]=>true}}
     }
 
     {:namespace=>false, :library_file=>File.expand_path(__FILE__), :commands=>commands}
@@ -39,8 +39,7 @@ module Boson::Commands::Core #:nodoc:
   end
 
   def load_library(library, options={})
-    options[:reload] ? Boson::Manager.reload(library, options) :
-      Boson::Manager.load(library, options)
+    Boson::Manager.load(library, options)
   end
 
   def render(object, options={})
@@ -56,11 +55,11 @@ module Boson::Commands::Core #:nodoc:
     puts msg
     if command && options[:verbose]
       if command.options && !command.options.empty?
-        puts "\nCOMMAND OPTIONS"
+        puts "\nLOCAL OPTIONS"
         command.option_parser.print_usage_table
       end
-      puts "\nGLOBAL/RENDER OPTIONS"
-      Boson::Scientist.render_option_parser(command).print_usage_table
+      puts "\nGLOBAL OPTIONS"
+      Boson::Scientist.option_command(command).option_parser.print_usage_table
     end
   end
 end

data/lib/boson/index.rb

@@ -1,118 +1,41 @@
-require 'digest/md5'
 module Boson
-  # This class is used by BinRunner to index/store all of Boson's commands and libraries. When this index updates,
-  # it detects library files whose md5 hash have changed and reindexes them. The index is stored with Marshal
-  # at ~/.boson/config/index.marshal. Since the index is marshaled, putting lambdas/procs in it will break it.
-  # If your index gets corrupted, simply delete it and next time Boson needs it, the index will be recreated.
+  # This class manages indexing/storing all commands and libraries. See RepoIndex for details
+  # about the index created for each Repo.
   module Index
     extend self
-    attr_reader :libraries, :commands
-
-    # Updates the index.
-    def update(options={})
-      libraries_to_update = !exists? ? Runner.all_libraries : options[:libraries] || changed_libraries
-      read_and_transfer(libraries_to_update)
-      if options[:verbose]
-        puts !exists? ? "Generating index for all #{libraries_to_update.size} libraries. Patience ... is a bitch" :
-          (libraries_to_update.empty? ? "No libraries indexed" :
-          "Indexing the following libraries: #{libraries_to_update.join(', ')}")
-      end
-      Manager.failed_libraries = []
-      unless libraries_to_update.empty?
-        Manager.load(libraries_to_update, options.merge(:index=>true))
-        unless Manager.failed_libraries.empty?
-          $stderr.puts("Error: These libraries failed to load while indexing: #{Manager.failed_libraries.join(', ')}")
-        end
-      end
-      write(Manager.failed_libraries)
-    end
-
-    # Reads and initializes index.
-    def read
-      return if @read
-      @libraries, @commands, @lib_hashes = exists? ? Marshal.load(File.read(marshal_file)) : [[], [], {}]
-      delete_stale_libraries_and_commands
-      set_command_namespaces
-      @read = true
+    # Array of indexes, one per repo in Boson.repos.
+    def indexes
+      @indexes ||= Boson.repos.map {|e| RepoIndex.new(e) }
     end
 
-    # Writes/saves current index to config/index.marshal.
-    def write(failed_libraries=[])
-      latest = latest_hashes
-      failed_libraries.each {|e| latest.delete(e) }
-      save_marshal_index Marshal.dump([Boson.libraries, Boson.commands, latest])
+    # Updates all repo indexes.
+    def update(options={})
+      indexes.each {|e| e.update(options) }
     end
 
     #:stopdoc:
-    def read_and_transfer(ignored_libraries=[])
-      read
-      existing_libraries = (Boson.libraries.map {|e| e.name} + ignored_libraries).uniq
-      libraries_to_add = @libraries.select {|e| !existing_libraries.include?(e.name)}
-      Boson.libraries += libraries_to_add
-      # depends on saved commands being correctly associated with saved libraries
-      Boson.commands += libraries_to_add.map {|e| e.command_objects(e.commands, @commands) }.flatten
-    end
-
-    def exists?
-      File.exists? marshal_file
-    end
-
-    def save_marshal_index(marshal_string)
-      File.open(marshal_file, 'w') {|f| f.write marshal_string }
-    end
-
-    def delete_stale_libraries_and_commands
-      cached_libraries = @lib_hashes.keys
-      libs_to_delete = @libraries.select {|e| !cached_libraries.include?(e.name) && e.is_a?(FileLibrary) }
-      names_to_delete = libs_to_delete.map {|e| e.name }
-      libs_to_delete.each {|e| @libraries.delete(e) }
-      @commands.delete_if {|e| names_to_delete.include? e.lib }
+    def read
+      indexes.each {|e| e.read }
     end
 
-    # set namespaces for commands
-    def set_command_namespaces
-      lib_commands = @commands.inject({}) {|t,e| (t[e.lib] ||= []) << e; t }
-      namespace_libs = @libraries.select {|e| e.namespace(e.indexed_namespace) }
-      namespace_libs.each {|lib|
-        (lib_commands[lib.name] || []).each {|e| e.namespace = lib.namespace }
+    def find_library(command)
+      indexes.each {|e|
+        lib = e.find_library(command)
+        return lib if lib
       }
+      nil
     end
 
-    def namespaces
-      nsps = @libraries.map {|e| e.namespace }.compact
-      nsps.delete(false)
-      nsps
-    end
-
-    def all_main_methods
-      @commands.reject {|e| e.namespace }.map {|e| [e.name, e.alias]}.flatten.compact + namespaces
-    end
-
-    def marshal_file
-      File.join(Boson.repo.config_dir, 'index.marshal')
-    end
-
-    def find_library(command)
-      read
-      namespace_command = command.split('.')[0]
-      if (lib = @libraries.find {|e| e.namespace == namespace_command })
-        lib.name
-      elsif (cmd = Command.find(command, @commands))
-        cmd.lib
-      end
+    def commands
+      indexes.map {|e| e.commands}.flatten
     end
 
-    def changed_libraries
-      read
-      latest_hashes.select {|lib, hash| @lib_hashes[lib] != hash}.map {|e| e[0]}
+    def libraries
+      indexes.map {|e| e.libraries}.flatten
     end
 
-    def latest_hashes
-      Runner.all_libraries.inject({}) {|h, e|
-        lib_file = FileLibrary.library_file(e, Boson.repo.dir)
-        h[e] = Digest::MD5.hexdigest(File.read(lib_file)) if File.exists?(lib_file)
-        h
-      }
+    def all_main_methods
+      indexes.map {|e| e.all_main_methods}.flatten
     end
     #:startdoc:
   end

data/lib/boson/inspector.rb

@@ -1,6 +1,28 @@
 module Boson
   # Scrapes and processes method attributes with the inspectors (MethodInspector, CommentInspector
-  # and ArgumentInspector) and hands off the usable data to FileLibrary objects.
+  # and ArgumentInspector) and hands off the data to FileLibrary objects.
+  #
+  # === Method Attributes
+  # Method attributes refer to (commented) Module methods placed before a command's method
+  # in a FileLibrary module:
+  #   module SomeMod
+  #      # @render_options :fields=>%w{one two}
+  #      # @config :alias=>'so'
+  #      options :verbose=>:boolean
+  #      # Something descriptive perhaps
+  #      def some_method(opts)
+  #        # ...
+  #      end
+  #   end
+  #
+  # Method attributes serve as configuration for a method's command. Available method attributes:
+  # * config: Hash to define any command attributes (see Command.new).
+  # * desc: String to define a command's description for a command. Defaults to first commented line above a method.
+  # * options: Hash to define an OptionParser object for a command's options.
+  # * render_options: Hash to define an OptionParser object for a command's local/global render options (see View).
+  #
+  # When deciding whether to use commented or normal Module methods, remember that commented Module methods allow
+  # independence from Boson (useful for testing). See CommentInspector for more about commented method attributes.
   module Inspector
     extend self
     attr_reader :enabled
@@ -57,7 +79,11 @@ module Boson
 
     def add_scraped_data_to_config(key, value, cmd)
       if value.is_a?(Hash)
-        @commands_hash[cmd][key] = Util.recursive_hash_merge value, @commands_hash[cmd][key] || {}
+        if key == :config
+          @commands_hash[cmd] = Util.recursive_hash_merge value, @commands_hash[cmd]
+        else
+          @commands_hash[cmd][key] = Util.recursive_hash_merge value, @commands_hash[cmd][key] || {}
+        end
       else
         @commands_hash[cmd][key] ||= value
       end

data/lib/boson/inspectors/comment_inspector.rb

@@ -1,25 +1,23 @@
 module Boson
-  # Scrapes comments right before a method for its attributes. Metadata attributes are the
-  # same as MethodInspector : desc, options, render_options. Attributes must begin with '@' i.e.:
-  #
+  # Scrapes comments right before a method for its attributes. Method attributes must begin with '@' i.e.:
   #    # @desc Does foo
   #    # @options :verbose=>true
   #    def foo(options={})
   #
-  # Some rules about comment attributes:
-  # * Attribute definitions can span multiple lines. When a new attribute starts a line or the comments end
+  # Some rules about these attributes:
+  # * Attribute definitions can span multiple lines. When a new attribute starts a line or the comments end,
   #   then a definition ends.
   # * If no @desc is found in the comment block, then the first comment line directly above the method
   #   is assumed to be the value for @desc. This means that no multi-line attribute definitions can occur
   #   without a description since the last line is assumed to be a description.
-  # * options and render_options attributes can take any valid ruby since they're evaled in their module's context.
+  # * options, config and render_options attributes can take any valid ruby since they're evaled in their module's context.
   # * desc attribute is not evaled and is simply text to be set as a string.
   #
   # This module was inspired by
   # {pragdave}[http://github.com/pragdavespc/rake/commit/45231ac094854da9f4f2ac93465ed9b9ca67b2da].
   module CommentInspector
     extend self
-    EVAL_ATTRIBUTES = [:options, :render_options]
+    EVAL_ATTRIBUTES = [:options, :render_options, :config]
 
     # Given a method's file string, line number and defining module, returns a hash
     # of attributes defined for that method.

data/lib/boson/inspectors/method_inspector.rb

@@ -1,26 +1,13 @@
 module Boson
-  # Gathers method attributes with new_method_added and the
-  # following Module methods:
-  # * desc: Defines a description for a method/command.
-  # * options: Defines an OptionParser object for a method's options.
-  # * render_options: Defines an OptionParser object for a method's rendering options. These options
-  #   are passed to View.render when rendering a command.
-  #
-  # These method calls must come immediately before a method i.e.:
-  #
-  #     desc "Does foo"
-  #     options :verbose=>:boolean
-  #     def foo(options={})
-  #
-  # This module also allows for defining method attributes as comments. Although the actual
-  # scraping of comments is handled by CommentInspector, MethodInspector gather's the method
-  # location it needs with with find_method_locations().
+  # Gathers method attributes by redefining method_added and capturing method
+  # calls before a method. This module also saves method locations so CommentInspector
+  # can scrape their commented method attributes.
   module MethodInspector
     extend self
     attr_accessor :current_module
     attr_reader :mod_store
     @mod_store ||= {}
-    METHODS = [:desc, :options, :render_options]
+    METHODS = [:config, :desc, :options, :render_options]
 
     # The method_added used while scraping method attributes.
     def new_method_added(mod, meth)

data/lib/boson/libraries/file_library.rb

@@ -1,12 +1,16 @@
 module Boson
-  # This library is based on a file of the same name under the commands directory of a repository.
-  # Since there can be multiple repositories, a library's file is looked for in the order given by
+  # This class loads a file by its path relative to the commands directory of a repository.
+  # For example the library 'public/misc' could refer to the file '~/.boson/commands/public/misc.rb'.
+  # If a file's basename is unique in its repository, then it can be loaded with its basename i.e. 'misc'
+  # for the previous example. When loading a library, this class searches repositories in the order given by
   # Boson.repos.
   #
-  # To create this library, simply create a file with a module and some methods (See Library
-  # for naming a module). Non-private methods are automatically loaded as a library's commands.
+  # === Creating a FileLibrary
+  # Start by creating a file with a module and some methods (See Library for naming a module).
+  # Non-private methods are automatically loaded as a library's commands.
   #
   # Take for example a library brain.rb:
+  #   # Drop this in ~/.boson/commands/brain.rb
   #   module Brain
   #     def take_over(destination)
   #       puts "Pinky, it's time to take over the #{destination}!"
@@ -32,10 +36,8 @@ module Boson
   #   bash> boson take_over world -e initiate_brainiac
   #   irb>> take_over 'world -e initiate_brainiac'
   #
-  # To learn more about the depth of option types available to a command, see OptionParser.
-  #
-  # Since boson aims to make your libraries just standard ruby, we can achieve the above
-  # by placing options in comments above a method:
+  # Since Boson aims to make your libraries just standard ruby, we can achieve the above
+  # by making options a commented method attribute:
   #   module Brain
   #     # @options :execute=>:string
   #     # Help Brain live the dream
@@ -46,10 +48,9 @@ module Boson
   #   end
   #
   # Some points about the above:
-  # * A '@' must prefix options and other method calls that become comments.
+  # * A '@' must prefix options and other method attributes that become comments.
   # * Note the comment above the method. One-line comments right before a method set a command's description.
-  # * See MethodInspector for other command attributes, like options, that can be placed above a method.
-  # * See CommentInspector for the rules about commenting command attributes.
+  # * See Inspector for other method attributes, like config and render_options, that can be placed above a method.
   #
   # Once a command has a defined option, a command can also recognize a slew of global options:
   #   irb>> take_over '-h'
@@ -58,7 +59,7 @@ module Boson
   #   # prints much more verbose help
   #   irb>> take_over '-hv'
   #
-  # For more about these global options see Scientist.
+  # For more about these global options see OptionCommand and View.
   class FileLibrary < Library
     #:stopdoc:
     def self.library_file(library, dir)
@@ -75,8 +76,7 @@ module Boson
 
     def self.reset_file_cache(name=nil)
       if name && @file_cache
-        #td: tia other repos
-        @file_cache.delete(library_file(name, Boson.repo.dir))
+        @file_cache.delete(library_file(name, (matched_repo || Boson.repo).dir))
       else
         @file_cache = nil
       end
@@ -101,14 +101,17 @@ module Boson
     def set_name(name)
       @lib_file = File.exists?(library_file(name.to_s)) ? library_file(name.to_s) :
         Dir[self.class.matched_repo.commands_dir.to_s+'/**/*.rb'].find {|e| e =~ /\/#{name}\.rb$/}
-      super @lib_file.gsub(/^#{self.class.matched_repo.commands_dir}\/|\.rb$/, '')
+      @lib_file.gsub(/^#{self.class.matched_repo.commands_dir}\/|\.rb$/, '')
+    end
+
+    def base_module
+      @base_module ||= @name.include?('/') ? create_module_from_path : Commands
     end
 
     def load_source(reload=false)
       library_string = self.class.read_library_file(@lib_file, reload)
-      @base_module = @name.include?('/') ? create_module_from_path : Commands
       Inspector.enable
-      @base_module.module_eval(library_string, @lib_file)
+      base_module.module_eval(library_string, @lib_file)
       Inspector.disable
     end
 
@@ -123,15 +126,7 @@ module Boson
       detected = detect_additions(:modules=>true) { load_source }
       @module = determine_lib_module(detected[:modules]) unless @module
       #without this, module's class methods weren't showing up
-      @module = Util.constantize(@module) if @base_module != Commands
-    end
-
-    def reload_source_and_set_module
-      detected = detect_additions(:modules=>true) { load_source(true) }
-      if (@new_module = !detected[:modules].empty?)
-        @commands = []
-        @module = determine_lib_module(detected[:modules])
-      end
+      @module = Util.constantize(@module) if base_module != Commands
     end
 
     def determine_lib_module(detected_modules)
@@ -140,7 +135,7 @@ module Boson
       when 0 then raise LoaderError, "Can't detect module. Make sure at least one module is defined in the library."
       else
         unless (lib_module = Util.constantize("boson/commands/#{@name}")) && lib_module.to_s[/^Boson::Commands/]
-          command_modules = detected_modules.map {|e| e.to_s}.grep(/^#{@base_module}::/)
+          command_modules = detected_modules.map {|e| e.to_s}.grep(/^#{base_module}::/)
           unless command_modules.size == 1 && (lib_module = command_modules[0])
             raise LoaderError, "Can't detect module. Specify a module in this library's config."
           end