boson 0.2.1 → 0.2.2

data/README.rdoc

@@ -145,8 +145,7 @@ Having done that, let's start up irb:
 == Todo
 * More tests
 * Making commands out of existing gems easier and more powerful
-* Consider managing extensions to core and standard libraries
-* Features based on commands and their argument types i.e. aliasing, completion, piping
+* Features based on commands and their argument types i.e. completing and piping
 * Consider dropping alias gem dependency if not using its full potential
 
 == Bugs/Issues

data/VERSION.yml

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

data/lib/boson.rb

@@ -51,9 +51,14 @@ module Boson
     end
   end
 
-  # The array of loaded repositories containing the main repo and a possible local repo
+  # The array of loaded repositories containing the main repo and possible local and global repos
   def repos
-    @repos ||= [repo, local_repo].compact
+    @repos ||= [repo, local_repo, global_repo].compact
+  end
+
+  # Optional global repository at /etc/boson
+  def global_repo
+    File.exists?('/etc/boson') ? Repo.new('/etc/boson') : nil
   end
 
   def main_object=(value) #:nodoc:

data/lib/boson/command.rb

@@ -1,9 +1,20 @@
 module Boson
   # A command starts with the functionality of a ruby method and adds benefits with options, render_options, etc.
   class Command
+    class <<self; attr_accessor :all_option_commands ; end
+
     # Creates a command given its name and a library.
     def self.create(name, library)
-      new (library.commands_hash[name] || {}).merge({:name=>name, :lib=>library.name, :namespace=>library.namespace})
+      obj = new(new_attributes(name, library))
+      if @all_option_commands && !%w{get method_missing}.include?(name)
+        obj.make_option_command(library)
+      end
+      obj
+    end
+
+    # Used to generate a command's initial attributes when creating a command object
+    def self.new_attributes(name, library)
+      (library.commands_hash[name] || {}).merge({:name=>name, :lib=>library.name, :namespace=>library.namespace})
     end
 
     # Finds a command, namespaced or not and aliased or not. If found returns the
@@ -18,17 +29,18 @@ module Boson
       commands.find(&find_lambda)
     end
 
-    ATTRIBUTES = [:name, :lib, :alias, :description, :options, :args]
+    ATTRIBUTES = [:name, :lib, :alias, :desc, :options, :args, :config]
     attr_accessor *(ATTRIBUTES + [:render_options, :namespace, :default_option])
     # A hash of attributes which map to instance variables and values. :name
     # and :lib are required keys.
     #
     # Attributes that can be configured:
-    # [*:description*] Description that shows up in command listings
+    # [*:desc*] 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.
+    # [*:render_options*] Hash of rendering options to pass to OptionParser. If the key :output_class is passed,
+    #                     that class's Hirb config will serve as defaults for this rendering hash.
+    # [*:option_command*] Boolean to wrap a command with an OptionCommand object i.e. allow commands to have 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
@@ -38,22 +50,29 @@ module Boson
     #                       # 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, :description, :render_options, :options, :namespace, :default_option,
-        :global_options].each do |e|
-          instance_variable_set("@#{e}", hash[e]) if hash[e]
+    # [*:config*] A hash for third party libraries to get and set custom command attributes.
+    def initialize(attributes)
+      hash = attributes.dup
+      @name = hash.delete(:name) or raise ArgumentError
+      @lib = hash.delete(:lib) or raise ArgumentError
+      [:alias, :desc, :options, :namespace, :default_option, :option_command].each do |e|
+          instance_variable_set("@#{e}", hash.delete(e)) if hash.key?(e)
       end
-      if hash[:args]
-        if hash[:args].is_a?(Array)
-          @args = hash[:args]
-        elsif hash[:args].to_s[/^\d+/]
-          @arg_size = hash[:args].to_i
-        elsif hash[:args] == '*'
+
+      if hash[:render_options] && (@render_options = hash.delete(:render_options))[:output_class]
+        @render_options = Util.recursive_hash_merge View.class_config(@render_options[:output_class]), @render_options
+      end
+
+      if (args = hash.delete(:args))
+        if args.is_a?(Array)
+          @args = args
+        elsif args.to_s[/^\d+/]
+          @arg_size = args.to_i
+        elsif args == '*'
           @args = [['*args']]
         end
       end
+      @config = (hash.delete(:config) || {}).merge(hash)
     end
 
     # Library object a command belongs to.
@@ -63,12 +82,12 @@ module Boson
 
     # Array of array args with optional defaults. Scraped with ArgumentInspector.
     def args(lib=library)
-      @args ||= begin
-        if lib && File.exists?(lib.library_file || '')
-          @file_parsed_args = true
-          file_string = Boson::FileLibrary.read_library_file(lib.library_file)
-          ArgumentInspector.scrape_with_text(file_string, @name)
-        end
+      @args = !@args.nil? ? @args : begin
+        if lib
+          file_string, meth = file_string_and_method_for_args(lib)
+          (file_string && meth && (@file_parsed_args = true) &&
+            ArgumentInspector.scrape_with_text(file_string, meth))
+        end || false
       end
     end
 
@@ -101,12 +120,31 @@ module Boson
     end
 
     #:stopdoc:
+    def file_string_and_method_for_args(lib)
+      if !lib.is_a?(ModuleLibrary) && (klass_method = (lib.class_commands || {})[@name])
+        if RUBY_VERSION >= '1.9'
+          klass, meth = klass_method.split('.', 2)
+          if (meth_locations = MethodInspector.find_method_locations_for_19(klass, meth))
+            file_string = File.read meth_locations[0]
+          end
+        end
+      elsif File.exists?(lib.library_file || '')
+        file_string, meth = FileLibrary.read_library_file(lib.library_file), @name
+      end
+      [file_string, meth]
+    end
+
     def has_splat_args?
-      @args && @args.any? {|e| e[0][/^\*/] }
+      !!(@args && @args[-1] && @args[-1][0][/^\*/])
+    end
+
+    def make_option_command(lib=library)
+      @option_command = true
+      @args = [['*args']] unless args(lib) || arg_size
     end
 
     def option_command?
-      options || render_options || @global_options
+      options || render_options || @option_command
     end
 
     def arg_size
@@ -118,16 +156,23 @@ module Boson
       @file_parsed_args
     end
 
+    # Deprecated method
+    def description
+      puts "@command.description has been changed to @command.desc. Delete your old " +
+        "Boson index at ~/.boson/command/index.marshal for Boson to work from the commandline."
+      Kernel.exit
+    end
+
     def marshal_dump
       if @args && @args.any? {|e| e[1].is_a?(Module) }
         @args.map! {|e| e.size == 2 ? [e[0], e[1].inspect] : e }
         @file_parsed_args = true
       end
-      [@name, @alias, @lib, @description, @options, @render_options, @args, @default_option]
+      [@name, @alias, @lib, @desc, @options, @render_options, @args, @default_option]
     end
 
     def marshal_load(ary)
-      @name, @alias, @lib, @description, @options, @render_options, @args, @default_option = ary
+      @name, @alias, @lib, @desc, @options, @render_options, @args, @default_option = ary
     end
     #:startdoc:
   end

data/lib/boson/commands/core.rb

@@ -6,36 +6,43 @@ module Boson::Commands::Core #:nodoc:
     library_attributes = Boson::Library::ATTRIBUTES + [:library_type]
 
     commands = {
-      'render'=>{:description=>"Render any object using Hirb"},
-      'menu'=>{:description=>"Provide a menu to multi-select elements from a given array"},
-      'usage'=>{:description=>"Print a command's usage", :options=>{[:verbose, :V]=>:boolean}},
+      'render'=>{:desc=>"Render any object using Hirb"},
+      'menu'=>{:desc=>"Provide a menu to multi-select elements from a given array"},
+      'usage'=>{:desc=>"Print a command's usage", :options=>{[:verbose, :V]=>:boolean}},
       'commands'=>{
-        :description=>"List or search commands", :default_option=>'query',
-        :options=>{ :index=>{:type=>:boolean, :desc=>"Searches index"}},
+        :desc=>"List or search commands. Query must come before any options.", :default_option=>'query',
+        :options=>{ :index=>{:type=>:boolean, :desc=>"Searches index"},
+          :local=>{:type=>:boolean, :desc=>"Local commands only" } },
         :render_options=>{
+          :headers=>{:default=>{:desc=>'description'}},
           :query=>{:keys=>command_attributes, :default_keys=>'full_name'},
-          :fields=>{:default=>[:full_name, :lib, :alias, :usage, :description], :values=>command_attributes} }
+          :fields=>{:default=>[:full_name, :lib, :alias, :usage, :desc], :values=>command_attributes, :enum=>false},
+          :filters=>{:default=>{:render_options=>:inspect, :options=>:inspect, :args=>:inspect, :config=>:inspect}}
+        }
       },
       'libraries'=>{
-        :description=>"List or search libraries", :default_option=>'query',
-        :options=>{ :index=>{:type=>:boolean, :desc=>"Searches index"} },
+        :desc=>"List or search libraries. Query must come before any options.", :default_option=>'query',
+        :options=>{ :index=>{:type=>:boolean, :desc=>"Searches index"},
+          :local=>{:type=>:boolean, :desc=>"Local libraries only" } },
         :render_options=>{
           :query=>{:keys=>library_attributes, :default_keys=>'name'},
-          :fields=>{:default=>[:name, :commands, :gems, :library_type], :values=>library_attributes},
+          :fields=>{:default=>[:name, :commands, :gems, :library_type], :values=>library_attributes, :enum=>false},
           :filters=>{:default=>{:gems=>[:join, ','],:commands=>:size}, :desc=>"Filters to apply to library fields" }}
       },
-      'load_library'=>{:description=>"Load a library", :options=>{[:verbose,:V]=>true}}
+      'load_library'=>{:desc=>"Load a library", :options=>{[:verbose,:V]=>true}}
     }
 
     {:namespace=>false, :library_file=>File.expand_path(__FILE__), :commands=>commands}
   end
 
   def commands(options={})
-    options[:index] ? (Boson::Index.read || true) && Boson::Index.commands : Boson.commands
+    cmds = options[:index] ? (Boson::Index.read || true) && Boson::Index.commands : Boson.commands
+    options[:local] ? cmds.select {|e| e.library && e.library.local? } : cmds
   end
 
   def libraries(options={})
-    options[:index] ? (Boson::Index.read || true) && Boson::Index.libraries : Boson.libraries
+    libs = options[:index] ? (Boson::Index.read || true) && Boson::Index.libraries : Boson.libraries
+    options[:local] ? libs.select {|e| e.local? } : libs
   end
 
   def load_library(library, options={})
@@ -50,16 +57,16 @@ module Boson::Commands::Core #:nodoc:
     Hirb::Console.format_output(output, options.merge(:class=>"Hirb::Menu"), &block)
   end
 
-  def usage(name, options={})
-    msg = (command = Boson::Command.find(name)) ? "#{name} #{command.usage}" : "Command '#{name}' not found"
+  def usage(command, options={})
+    msg = (cmd = Boson::Command.find(command)) ? "#{command} #{cmd.usage}" : "Command '#{cmd}' not found"
     puts msg
-    if command && options[:verbose]
-      if command.options && !command.options.empty?
+    if cmd && options[:verbose]
+      if cmd.options && !cmd.options.empty?
         puts "\nLOCAL OPTIONS"
-        command.option_parser.print_usage_table
+        cmd.option_parser.print_usage_table
       end
       puts "\nGLOBAL OPTIONS"
-      Boson::Scientist.option_command(command).option_parser.print_usage_table
+      Boson::Scientist.option_command(cmd).option_parser.print_usage_table
     end
   end
 end

data/lib/boson/commands/web_core.rb

@@ -5,11 +5,11 @@ module Boson::Commands::WebCore #:nodoc:
     descriptions = {
       :install=>"Installs a library by url. Library should then be loaded with load_library.",
       :browser=>"Opens urls in a browser on a Mac", :get=>"Gets the body of a url", :post=>'Posts to url' }
-    commands = descriptions.inject({}) {|h,(k,v)| h[k.to_s] = {:description=>v}; h}
+    commands = descriptions.inject({}) {|h,(k,v)| h[k.to_s] = {:desc=>v}; h}
     commands['install'][:options] = {:name=>{:type=>:string, :desc=>"Library name to save to"},
       :force=>{:type=>:boolean, :desc=>'Overwrites an existing library'},
       :module_wrap=>{:type=>:boolean, :desc=>"Wraps a module around install using library name"},
-      :method_wrap=>{:type=>:boolean, :desc=>"Wraps a method and module around installe library using library name"}}
+      :method_wrap=>{:type=>:boolean, :desc=>"Wraps a method and module around installed library using library name"}}
     {:library_file=>File.expand_path(__FILE__), :commands=>commands, :namespace=>false}
   end
 

data/lib/boson/index.rb

@@ -18,10 +18,16 @@ module Boson
       indexes.each {|e| e.read }
     end
 
-    def find_library(command)
+    def find_library(command, object=false)
       indexes.each {|e|
-        lib = e.find_library(command)
-        return lib if lib
+        (lib = e.find_library(command, object)) and return lib
+      }
+      nil
+    end
+
+    def find_command(command)
+      indexes.each {|e|
+        (cmd = Command.find(command, e.commands)) and return(cmd)
       }
       nil
     end

data/lib/boson/inspector.rb

@@ -101,7 +101,7 @@ module Boson
 
     # translates from inspector attribute name to command attribute name
     def command_key(key)
-      {:method_args=>:args, :desc=>:description}[key] || key
+      {:method_args=>:args}[key] || key
     end
     #:startdoc:
   end

data/lib/boson/inspectors/argument_inspector.rb

@@ -6,8 +6,8 @@ module Boson::ArgumentInspector
   # Returns same argument arrays as scrape_with_eval but argument defaults haven't been evaluated.
   def scrape_with_text(file_string, meth)
     tabspace = "[ \t]"
-    if match = /^#{tabspace}*def#{tabspace}+#{meth}\b#{tabspace}*($|\(?\s*([^\)]+)\s*\)?\s*$)/.match(file_string)
-      (match.to_a[2] || '').split(/\s*,\s*/).map {|e| e.split(/\s*=\s*/)}
+    if match = /^#{tabspace}*def#{tabspace}+(?:\w+\.)?#{Regexp.quote(meth)}#{tabspace}*($|(?:\(|\s+)([^\n\)]+)\s*\)?\s*$)/.match(file_string)
+      (match.to_a[2] || '').strip.split(/\s*,\s*/).map {|e| e.split(/\s*=\s*/)}
     end
   end
 

data/lib/boson/inspectors/method_inspector.rb

@@ -57,6 +57,13 @@ module Boson
     end
 
     #:stopdoc:
+    def find_method_locations_for_19(klass, meth)
+      if (klass = Util.any_const_get(klass)) && (meth_location = klass.method(meth).source_location) &&
+        meth_location[0]
+        meth_location
+      end
+    end
+
     # Hash of a module's method attributes i.e. descriptions, options by method and then attribute
     def store(mod=@current_module)
       @mod_store[mod]

data/lib/boson/libraries/file_library.rb

@@ -115,8 +115,8 @@ module Boson
       Inspector.disable
     end
 
-    def create_module_from_path
-      @name.split('/')[0..-2].inject(Boson::Commands) {|base, e|
+    def create_module_from_path(index=-2)
+      @name.split('/')[0..index].inject(Boson::Commands) {|base, e|
         base.const_defined?(sub_mod = Util.camelize(e)) ? base.const_get(sub_mod) :
           Util.create_module(base, e)
       }
@@ -125,20 +125,16 @@ module Boson
     def load_source_and_set_module
       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 determine_lib_module(detected_modules)
+      detected_modules = detected_modules.select {|e| e.to_s[/^#{base_module}::/] }
       case detected_modules.size
       when 1 then lib_module = detected_modules[0]
-      when 0 then raise LoaderError, "Can't detect module. Make sure at least one module is defined in the library."
+      when 0 then lib_module = create_module_from_path(-1)
       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}::/)
-          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
+          raise LoaderError, "Can't detect module. Specify a module in this library's config."
         end
       end
       lib_module

data/lib/boson/library.rb

@@ -29,7 +29,7 @@ module Boson
   #       :commands:
   #         delete:
   #           :alias: d
-  #           :description: Http delete a given url
+  #           :desc: Http delete a given url
   #
   # When installing a third-party library, use the config file as a way to override default library and command attributes
   # without modifying the library.
@@ -53,7 +53,7 @@ module Boson
     ATTRIBUTES = [:gems, :dependencies, :commands, :loaded, :module, :name, :namespace, :indexed_namespace]
     attr_reader *(ATTRIBUTES + [:commands_hash, :library_file, :object_namespace])
     # Private attribute for use within Boson.
-    attr_reader :no_alias_creation, :new_module, :new_commands
+    attr_reader :no_alias_creation, :new_module, :new_commands, :class_commands, :lib_file, :repo_dir
     # Optional namespace name for a library. When enabled defaults to a library's name.
     attr_writer :namespace
 
@@ -69,7 +69,7 @@ module Boson
     #               for the given commands with command names pointing to their configs. See Command.new for a
     #               command's configurable attributes. If an array, the commands are set for the given library,
     #               overidding default command detection. Example:
-    #                :commands=>{'commands'=>{:description=>'Lists commands', :alias=>'com'}}
+    #                :commands=>{'commands'=>{:desc=>'Lists commands', :alias=>'com'}}
     # [*:class_commands*] A hash of commands to create. A hash key-pair can map command names to any string of ruby code
     #                     that ends with a method call. Or a key-pair can map a class to an array of its class methods
     #                     to create commands of the same name. Example:
@@ -122,6 +122,10 @@ module Boson
       @name[/\w+$/]
     end
 
+    def local?
+      is_a?(LocalFileLibrary) || (Boson.local_repo && Boson.local_repo.dir == @repo_dir)
+    end
+
     def set_name(name)
       name.to_s
     end

data/lib/boson/namespace.rb

@@ -8,24 +8,6 @@ module Boson
 
     # Creates a namespace given its name and the library it belongs to.
     def self.create(name, library)
-      if library.object_namespace && library.module.instance_methods.map {|e| e.to_s}.include?(name)
-        library.include_in_universe
-        create_object_namespace(name, library)
-      else
-        create_basic_namespace(name, library)
-      end
-    end
-    #:stopdoc:
-
-    def self.create_object_namespace(name, library)
-      obj = library.namespace_object
-      obj.instance_eval("class<<self;self;end").send(:define_method, :boson_commands) {
-        self.class.instance_methods(false) }
-      obj.instance_eval("class<<self;self;end").send(:define_method, :object_delegate?) { true }
-      namespaces[name.to_s] = obj
-    end
-
-    def self.create_basic_namespace(name, library)
       namespaces[name.to_s] = new(name, library)
       Commands::Namespace.send(:define_method, name) { Boson::Namespace.namespaces[name.to_s] }
     end
@@ -36,11 +18,10 @@ module Boson
       class <<self; self end.send :include, @library.module
     end
 
-    def object_delegate?; false; end
-
     def method_missing(method, *args, &block)
       Boson.can_invoke?(method) ? Boson.invoke(method, *args, &block) : super
     end
+
     #:startdoc:
     # List of subcommands for the namespace.
     def boson_commands