boson 0.2.1 → 0.2.2

data/lib/boson/option_command.rb

@@ -23,10 +23,11 @@ module Boson
   #   Global options: {:pretend=>true}
   #
   # If a global option conflicts with a local option, the local option takes precedence. You can get around
-  # this by passing a --global option which takes a string of options without their dashes. For example:
-  #   foo '-p --fields=f1,f2 -l=1'
+  # this by passing global options after a '-'. For example, if the global option -f (--fields) conflicts with
+  # a local -f (--force):
+  #   foo 'arg1 -v -f - -f=f1,f2'
   #   # is the same as
-  #   foo ' -g "p fields=f1,f2" -l=1 '
+  #   foo 'arg1 -v --fields=f1,f2 -f'
   #
   # === Toggling Views With the Basic Global Option --render
   # One of the more important global options is --render. This option toggles the rendering of a command's
@@ -53,12 +54,15 @@ module Boson
   #   3 rows in set
   #   => true
   class OptionCommand
+    # ArgumentError specific to @command's arguments
+    class CommandArgumentError < ::ArgumentError; end
+
     BASIC_OPTIONS = {
       :help=>{:type=>:boolean, :desc=>"Display a command's help"},
       :render=>{:type=>:boolean, :desc=>"Toggle a command's default rendering behavior"},
       :verbose=>{:type=>:boolean, :desc=>"Increase verbosity for help, errors, etc."},
-      :global=>{:type=>:string, :desc=>"Pass a string of global options without the dashes"},
       :pretend=>{:type=>:boolean, :desc=>"Display what a command would execute without executing it"},
+      :delete_options=>{:type=>:array, :desc=>'Deletes global options starting with given strings' }
     } #:nodoc:
 
     RENDER_OPTIONS = {
@@ -106,9 +110,9 @@ module Boson
         global_opt, parsed_options, args = parse_options Shellwords.shellwords(args[0])
       # last string argument interpreted as args + options
       elsif args.size > 1 && args[-1].is_a?(String)
-        temp_args = Boson.const_defined?(:BinRunner) ? args : Shellwords.shellwords(args.pop)
+        temp_args = Runner.in_shell? ? args : Shellwords.shellwords(args.pop)
         global_opt, parsed_options, new_args = parse_options temp_args
-        args += new_args
+        Runner.in_shell? ? args = new_args : args += new_args
       # add default options
       elsif @command.options.to_s.empty? || (!@command.has_splat_args? &&
         args.size <= (@command.arg_size - 1).abs) || (@command.has_splat_args? && !args[-1].is_a?(Hash))
@@ -124,14 +128,28 @@ module Boson
     #:stopdoc:
     def parse_options(args)
       parsed_options = @command.option_parser.parse(args, :delete_invalid_opts=>true)
-      global_options = option_parser.parse @command.option_parser.leading_non_opts
-      new_args = option_parser.non_opts.dup + @command.option_parser.trailing_non_opts
-      if global_options[:global]
-        global_opts = Shellwords.shellwords(global_options[:global]).map {|str|
-          ((str[/^(.*?)=/,1] || str).length > 1 ? "--" : "-") + str }
-        global_options.merge! option_parser.parse(global_opts)
-      end
+      trailing, unparseable = split_trailing
+      global_options = parse_global_options @command.option_parser.leading_non_opts + trailing
+      new_args = option_parser.non_opts.dup + unparseable
       [global_options, parsed_options, new_args]
+    rescue OptionParser::Error
+      global_options = parse_global_options @command.option_parser.leading_non_opts + split_trailing[0]
+      global_options[:help] ? [global_options, nil, []] : raise
+    end
+
+    def split_trailing
+      trailing = @command.option_parser.trailing_non_opts
+      if trailing[0] == '--'
+        trailing.shift
+        [ [], trailing ]
+      else
+        trailing.shift if trailing[0] == '-'
+        [ trailing, [] ]
+      end
+    end
+
+    def parse_global_options(args)
+      option_parser.parse args
     end
 
     def option_parser
@@ -140,11 +158,7 @@ module Boson
     end
 
     def all_global_options
-      @command.render_options.each {|k,v|
-        if !v.is_a?(Hash) && !v.is_a?(Symbol)
-          @command.render_options[k] = {:default=>v}
-        end
-      }
+      OptionParser.make_mergeable! @command.render_options
       render_opts = Util.recursive_hash_merge(@command.render_options, Util.deep_copy(self.class.default_render_options))
       merged_opts = Util.recursive_hash_merge Util.deep_copy(self.class.default_pipe_options), render_opts
       opts = Util.recursive_hash_merge merged_opts, Util.deep_copy(BASIC_OPTIONS)
@@ -171,7 +185,7 @@ module Boson
       opts
     end
 
-    def prepend_default_option(args)
+    def modify_args(args)
       if @command.default_option && @command.arg_size <= 1 && !@command.has_splat_args? && args[0].to_s[/./] != '-'
         args[0] = "--#{@command.default_option}=#{args[0]}" unless args.join.empty? || args[0].is_a?(Hash)
       end
@@ -181,7 +195,7 @@ module Boson
       if args.size != @command.arg_size && !@command.has_splat_args?
         command_size, args_size = args.size > @command.arg_size ? [@command.arg_size, args.size] :
           [@command.arg_size - 1, args.size - 1]
-        raise ArgumentError, "wrong number of arguments (#{args_size} for #{command_size})"
+        raise CommandArgumentError, "wrong number of arguments (#{args_size} for #{command_size})"
       end
     end
 

data/lib/boson/option_parser.rb

@@ -3,7 +3,7 @@ module Boson
   # merging should assume symbolic keys. Used by OptionParser.
   class IndifferentAccessHash < ::Hash
     #:stopdoc:
-    def initialize(hash)
+    def initialize(hash={})
       super()
       hash.each {|k,v| self[k] = v }
     end
@@ -37,6 +37,7 @@ module Boson
   # * Each option type can have attributes to enable more features (see OptionParser.new).
   # * When options are parsed by parse(), an IndifferentAccessHash hash is returned.
   # * Options are also called switches, parameters, flags etc.
+  # * Option parsing stops when it comes across a '--'.
   #
   # Default option types:
   # [*:boolean*] This option has no passed value. To toogle a boolean, prepend with '--no-'.
@@ -79,10 +80,12 @@ module Boson
     
     attr_reader :leading_non_opts, :trailing_non_opts, :opt_aliases
 
-    # Given options to pass to OptionParser.new, this method parses ARGV and returns a hash of
-    # parsed options. This is useful for scripts outside of Boson.
+    # Given options to pass to OptionParser.new, this method parses ARGV and returns the remaining arguments
+    # and a hash of parsed options. This is useful for scripts outside of Boson.
     def self.parse(options, args=ARGV)
-      (@opt_parser ||= new(options)).parse(args)
+      @opt_parser ||= new(options)
+      parsed_options = @opt_parser.parse(args)
+      [@opt_parser.non_opts, parsed_options]
     end
 
     # Usage string summarizing options defined in parse
@@ -90,6 +93,14 @@ module Boson
       @opt_parser.to_s
     end
 
+    def self.make_mergeable!(opts) #:nodoc:
+      opts.each {|k,v|
+        if !v.is_a?(Hash) && !v.is_a?(Symbol)
+          opts[k] = {:default=>v}
+        end
+      }
+    end
+
     # Array of arguments left after defined options have been parsed out by parse.
     def non_opts
       leading_non_opts + trailing_non_opts
@@ -145,8 +156,11 @@ module Boson
     # [*:split*] For :array and :hash options. A string or regular expression on which an array value splits
     #            to produce an array of values. Default is ','.
     # [*:keys*] :hash option only. An array of values a hash option's keys can have. Keys can be aliased just like :values.
-    # [*:default_keys*] :hash option only. Default keys to assume when only a value is given. Multiple keys can be joined
-    #                 by the :split character. Defaults to first key of :keys if :keys given.
+    # [*:default_keys*] For :hash option only. Default keys to assume when only a value is given. Multiple keys can be joined
+    #                   by the :split character. Defaults to first key of :keys if :keys given.
+    # [*:regexp*] For :array option with a :values attribute. Boolean indicating that each option value does a regular
+    #             expression search of :values. If there are values that match, they replace the original option value. If none,
+    #             then the original option value is used.
     def initialize(opts)
       @defaults = {}
       @opt_aliases = {}
@@ -209,7 +223,8 @@ module Boson
     # recognizes a valid option, it continues to parse until an non option argument is detected.
     # Flags that can be passed to the parser:
     # * :opts_before_args: When true options must come before arguments. Default is false.
-    # * :delete_invalid_opts: When true deletes any invalid options left after parsing. Default is false.
+    # * :delete_invalid_opts: When true deletes any invalid options left after parsing. Will stop deleting if
+    #   it comes across - or --. Default is false.
     def parse(args, flags={})
       @args = args
       # start with defaults
@@ -217,7 +232,7 @@ module Boson
       
       @leading_non_opts = []
       unless flags[:opts_before_args]
-        @leading_non_opts << shift until current_is_option? || @args.empty?
+        @leading_non_opts << shift until current_is_option? || @args.empty? || peek == '--'
       end
 
       while current_is_option?
@@ -299,6 +314,29 @@ module Boson
       (str.length > 1 ? "--" : "-") + str
     end
 
+    # List of option types
+    def types
+      @opt_types.values
+    end
+
+    # List of option names
+    def names
+      @opt_types.keys.map {|e| undasherize e }
+    end
+
+    # List of option aliases
+    def aliases
+      @opt_aliases.keys.map {|e| undasherize e }
+    end
+
+    def option_type(opt)
+      if opt =~ /^--no-(\w+)$/
+        @opt_types[opt] || @opt_types[dasherize($1)] || @opt_types[original_no_opt($1)]
+      else
+        @opt_types[opt]
+      end
+    end
+
     private
     def determine_option_type(value)
       return value if value.is_a?(Symbol)
@@ -327,8 +365,15 @@ module Boson
     end
 
     def auto_alias_value(values, possible_value)
-      values.find {|v| v.to_s =~ /^#{possible_value}/ } or (@option_attributes[@current_option][:enum] ?
-        raise(Error, "invalid value '#{possible_value}' for option '#{@current_option}'") : possible_value)
+      values.find {|v| v.to_s =~ /^#{possible_value}/ } || possible_value
+    end
+
+    def validate_enum_values(values, possible_values)
+      if current_attributes[:enum]
+        Array(possible_values).each {|e|
+          raise(Error, "invalid value '#{e}' for option '#{@current_option}'") if !values.include?(e)
+        }
+      end
     end
 
     def validate_option_value(type)
@@ -340,13 +385,12 @@ module Boson
     end
 
     def delete_invalid_opts
-      [@trailing_non_opts].each do |args|
-        args.delete_if {|e|
-          invalid = e.to_s[/^-/]
-          $stderr.puts "Deleted invalid option '#{e}'" if invalid
-          invalid
-        }
-      end
+      @trailing_non_opts.delete_if {|e|
+        break if %w{- --}.include? e
+        invalid = e.to_s[/^-/]
+        $stderr.puts "Deleted invalid option '#{e}'" if invalid
+        invalid
+      }
     end
 
     def peek
@@ -367,7 +411,7 @@ module Boson
     
     def valid?(arg)
       if arg.to_s =~ /^--no-(\w+)$/
-        @opt_types.key?(arg) or (@opt_types["--#{$1}"] == :boolean) or
+        @opt_types.key?(arg) or (@opt_types[dasherize($1)] == :boolean) or
           (@opt_types[original_no_opt($1)] == :boolean)
       else
         @opt_types.key?(arg) or @opt_aliases.key?(arg)
@@ -387,14 +431,6 @@ module Boson
       @opt_aliases.key?(opt) ? @opt_aliases[opt] : opt
     end
     
-    def option_type(opt)
-      if opt =~ /^--no-(\w+)$/
-        @opt_types[opt] || @opt_types["--#{$1}"] || @opt_types[original_no_opt($1)]
-      else
-        @opt_types[opt]
-      end
-    end
-
     def original_no_opt(opt)
       @opt_aliases[dasherize(opt)]
     end

data/lib/boson/options.rb

@@ -39,7 +39,8 @@ module Boson
     # Parse/create methods
     def create_string(value)
       if (values = current_attributes[:values]) && (values = values.sort_by {|e| e.to_s})
-        (val = auto_alias_value(values, value)) && value = val
+        value = auto_alias_value(values, value)
+        validate_enum_values(values, value)
       end
       value
     end
@@ -61,10 +62,15 @@ module Boson
       splitter = current_attributes[:split] || ','
       array = value.split(splitter)
       if (values = current_attributes[:values]) && (values = values.sort_by {|e| e.to_s })
-        array.each {|e| array.delete(e) && array += values if e == '*'}
-        array.each_with_index {|e,i|
-          (value = auto_alias_value(values, e)) && array[i] = value
-        }
+        if current_attributes[:regexp]
+          array = array.map {|e|
+            (new_values = values.grep(/#{e}/)).empty? ? e : new_values
+          }.compact.flatten.uniq
+        else
+          array.each {|e| array.delete(e) && array += values if e == '*'}
+          array.map! {|e| auto_alias_value(values, e) }
+        end
+        validate_enum_values(values, array)
       end
       array
     end
@@ -79,9 +85,13 @@ module Boson
       aoa = Hash[*value.split(/(?::)([^#{Regexp.quote(splitter)}]+)#{Regexp.quote(splitter)}?/)].to_a
       aoa.each_with_index {|(k,v),i| aoa[i][0] = keys.join(splitter) if k == '*' } if keys
       hash = aoa.inject({}) {|t,(k,v)| k.split(splitter).each {|e| t[e] = v }; t }
-      keys ? hash.each {|k,v|
-              (new_key = auto_alias_value(keys, k)) && hash[new_key] = hash.delete(k)
-             } : hash
+      if keys
+        hash = hash.inject({}) {|h,(k,v)|
+          h[auto_alias_value(keys, k)] = v; h
+        }
+        validate_enum_values(keys, hash.keys)
+      end
+      hash
     end
 
     # Validation methods

data/lib/boson/pipe.rb

@@ -23,8 +23,8 @@ module Boson
   #   # Searches commands in the full_name field for 'lib' and sorts results by that field.
   #   bash> boson commands -q=f:lib -s=f    # or commands --query=full_name:lib --sort=full_name
   #
-  #   # Multiple fields can be searched if separated by a ','. This searches the full_name and description fields.
-  #   bash> boson commands -q=f,d:web   # or commands --query=full_name,description:web
+  #   # Multiple fields can be searched if separated by a ','. This searches the full_name and desc fields.
+  #   bash> boson commands -q=f,d:web   # or commands --query=full_name,desc:web
   #
   #   # All fields can be queried using a '*'.
   #   # Searches all library fields and then reverse sorts on name field

data/lib/boson/repo.rb

@@ -46,7 +46,7 @@ module Boson
     #                     Example:
     #                      :command_aliases=>{'libraries'=>'lib', 'commands'=>'com'}
     # [:defaults] Array of libraries to load at start up for commandline and irb. This is useful for extending boson i.e. adding your
-    #             own option types. Default is no libraries.
+    #             own option types since these are loaded before any other libraries. Default is no libraries.
     # [:console_defaults] Array of libraries to load at start up when used in irb. Default is to load all library files and libraries
     #                     defined in the config.
     # [:bin_defaults] Array of libraries to load at start up when used from the commandline. Default is no libraries.

data/lib/boson/repo_index.rb

@@ -34,7 +34,8 @@ module Boson
     # Reads and initializes index.
     def read
       return if @read
-      @libraries, @commands, @lib_hashes = exists? ? Marshal.load(File.read(marshal_file)) : [[], [], {}]
+      @libraries, @commands, @lib_hashes = exists? ?
+        File.open( marshal_file, 'rb' ){|f| Marshal.load( f.read ) } : [[], [], {}]
       delete_stale_libraries_and_commands
       set_command_namespaces
       @read = true
@@ -62,7 +63,7 @@ module Boson
     end
 
     def save_marshal_index(marshal_string)
-      File.open(marshal_file, 'w') {|f| f.write marshal_string }
+      File.open(marshal_file, 'wb') {|f| f.write marshal_string }
     end
 
     def delete_stale_libraries_and_commands
@@ -96,13 +97,13 @@ module Boson
       File.join(repo.config_dir, 'index.marshal')
     end
 
-    def find_library(command)
+    def find_library(command, object=false)
       read
       namespace_command = command.split('.')[0]
       if (lib = @libraries.find {|e| e.namespace == namespace_command })
-        lib.name
+        object ? lib : lib.name
       elsif (cmd = Command.find(command, @commands))
-        cmd.lib
+        object ? @libraries.find {|e| e.name == cmd.lib} : cmd.lib
       end
     end
 

data/lib/boson/runner.rb

@@ -11,7 +11,7 @@ module Boson
 
       # Libraries that come with Boson
       def default_libraries
-        [Boson::Commands::Core, Boson::Commands::WebCore] + Boson.repos.map {|e| e.config[:defaults] || [] }.flatten
+        Boson.repos.map {|e| e.config[:defaults] || [] }.flatten + [Boson::Commands::Core, Boson::Commands::WebCore]
       end
 
       # Libraries detected in repositories
@@ -24,7 +24,26 @@ module Boson
         Boson.repos.map {|e| e.all_libraries }.flatten.uniq
       end
 
+      # Returns true if commands are being executed from a non-ruby shell i.e. bash. Returns false if
+      # in a ruby shell i.e. irb.
+      def in_shell?
+        !!@in_shell
+      end
+
+      # Returns true if in commandline with verbose flag or if set explicitly. Useful in plugins.
+      def verbose?
+        @verbose.nil? ? Boson.const_defined?(:BinRunner) && BinRunner.options[:verbose] : @verbose
+      end
+
       #:stopdoc:
+      def verbose=(val)
+        @verbose = val
+      end
+
+      def in_shell=(val)
+        @in_shell = val
+      end
+
       def add_load_path
         Boson.repos.each {|repo|
           if repo.config[:add_load_path] || File.exists?(File.join(repo.dir, 'lib'))
@@ -37,12 +56,16 @@ module Boson
         {:verbose=>@options[:verbose]}
       end
 
+      def autoload_command(cmd)
+        Index.read
+        (lib = Index.find_library(cmd)) && Manager.load(lib, :verbose=>verbose?)
+        lib
+      end
+
       def define_autoloader
         class << ::Boson.main_object
           def method_missing(method, *args, &block)
-            Boson::Index.read
-            if lib = Boson::Index.find_library(method.to_s)
-              Boson::Manager.load lib, :verbose=>true
+            if Runner.autoload_command(method.to_s)
               send(method, *args, &block) if respond_to?(method)
             else
               super

data/lib/boson/runners/bin_runner.rb

@@ -32,25 +32,24 @@ module Boson
   # * Any of these cases can be toggled to render/not render with the global option :render
   # To turn off auto-rendering by default, add a :no_auto_render: true entry to the main config.
   class BinRunner < Runner
-    def self.all_libraries #:nodoc:
-      @all_libraries ||= ((libs = super) +  libs.map {|e| File.basename(e) }).uniq
-    end
-
     GLOBAL_OPTIONS =  {
-      :verbose=>{:type=>:boolean, :desc=>"Verbose description of loading libraries or help"},
+      :verbose=>{:type=>:boolean, :desc=>"Verbose description of loading libraries, errors or help"},
       :index=>{:type=>:array, :desc=>"Libraries to index. Libraries must be passed with '='.",
-        :bool_default=>nil, :values=>all_libraries, :enum=>false},
+        :bool_default=>nil, :values=>all_libraries, :regexp=>true, :enum=>false},
       :execute=>{:type=>:string, :desc=>"Executes given arguments as a one line script"},
       :console=>{:type=>:boolean, :desc=>"Drops into irb with default and explicit libraries loaded"},
       :help=>{:type=>:boolean, :desc=>"Displays this help message or a command's help if given a command"},
-      :load=>{:type=>:array, :values=>all_libraries,
-        :enum=>false, :desc=>"A comma delimited array of libraries to load"},
+      :load=>{:type=>:array, :values=>all_libraries, :regexp=>true, :enum=>false,
+        :desc=>"A comma delimited array of libraries to load"},
+      :unload=>{:type=>:string, :desc=>"Acts as a regular expression to unload default libraries"},
       :render=>{:type=>:boolean, :desc=>"Renders a Hirb view from result of command without options"},
-      :pager_toggle=>{:type=>:boolean, :desc=>"Toggles Hirb's pager"}
+      :pager_toggle=>{:type=>:boolean, :desc=>"Toggles Hirb's pager"},
+      :option_commands=>{:type=>:boolean, :desc=>"Toggles on all commands to be defined as option commands" }
     } #:nodoc:
 
     class <<self
       attr_accessor :command
+
       # Starts, processes and ends a commandline request.
       def start(args=ARGV)
         @command, @options, @args = parse_args(args)
@@ -75,6 +74,8 @@ module Boson
 
       # Loads the given command.
       def init
+        Runner.in_shell = true
+        Command.all_option_commands = true if @options[:option_commands]
         super
         Index.update(:verbose=>true, :libraries=>@options[:index]) if @options.key?(:index)
         if @options[:load]
@@ -86,9 +87,14 @@ module Boson
         end
       end
 
+      # Hash of global options passed in from commandline
+      def options
+        @options ||= {}
+      end
+
       #:stopdoc:
       def print_error_message(message)
-        message += "\nOriginal error: #{$!}\n" + $!.backtrace.slice(0,10).map {|e| "  " + e }.join("\n") if @options && @options[:verbose]
+        message += "\nOriginal error: #{$!}\n" + $!.backtrace.slice(0,10).map {|e| "  " + e }.join("\n") if options[:verbose]
         $stderr.puts message
       end
 
@@ -101,16 +107,21 @@ module Boson
       end
 
       def default_libraries
-        super + Boson.repos.map {|e| e.config[:bin_defaults] || [] }.flatten + Dir.glob('Bosonfile')
+        libs = super + Boson.repos.map {|e| e.config[:bin_defaults] || [] }.flatten + Dir.glob('Bosonfile')
+        @options[:unload] ?  libs.select {|e| e !~ /#{@options[:unload]}/} : libs
       end
 
       def execute_command
-        render_output Boson.full_invoke(@command, @args)
-      rescue ArgumentError
-        # for the rare case it's raise outside of boson
-        raise unless $!.backtrace.first.include?('boson/')
-        print_error_message "'#{@command}' was called incorrectly."
-        Boson.invoke(:usage, @command)
+        begin
+          output = Boson.full_invoke(@command, @args)
+        rescue ArgumentError
+          # for the rare case it's raised outside of boson
+          raise unless $!.backtrace.first.include?('boson/')
+          print_error_message "'#{@command}' was called incorrectly."
+          Boson.invoke(:usage, @command)
+          return
+        end
+        render_output output
       end
 
       def parse_args(args)