boson 0.2.2 → 0.2.3

data/lib/boson/options.rb

@@ -4,7 +4,7 @@ module Boson
   # === Creating Your Own Option Type
   # Defining your own option type simply requires one method (create_@type) to parse the option value and create
   # the desired object. To create an option type :date, you could create the following create_date method:
-  #   # Drop this in your ~/.irbrc after require 'boson'
+  #   # Drop this in ~/.boson/commands/date_option.rb
   #   module Boson::Options::Date
   #     def create_date(value)
   #       # value should be mm/dd
@@ -13,6 +13,10 @@ module Boson
   #   end
   #   Boson::OptionParser.send :include, Boson::Options::Date
   #
+  # Modify your config to load this new library by default:
+  #   :defaults:
+  #   - date_option
+  #
   # In a FileLibrary, we could then use this new option:
   #   module Calendar
   #     #@options :day=>:date
@@ -76,15 +80,8 @@ module Boson
     end
 
     def create_hash(value)
-      splitter = current_attributes[:split] || ','
       (keys = current_attributes[:keys]) && keys = keys.sort_by {|e| e.to_s }
-      if !value.include?(':') && current_attributes[:default_keys]
-        value = current_attributes[:default_keys].to_s + ":#{value}"
-      end
-      # Creates array pairs, grouping array of keys with a value
-      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 }
+      hash = parse_hash(value, keys)
       if keys
         hash = hash.inject({}) {|h,(k,v)|
           h[auto_alias_value(keys, k)] = v; h
@@ -94,6 +91,18 @@ module Boson
       hash
     end
 
+    def parse_hash(value, keys)
+      splitter = current_attributes[:split] || ','
+      if !value.include?(':') && current_attributes[:default_keys]
+        value = current_attributes[:default_keys].to_s + ":#{value}"
+      end
+
+      # Creates array pairs, grouping array of keys with a value
+      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
+      aoa.inject({}) {|t,(k,v)| k.split(splitter).each {|e| t[e] = v }; t }
+    end
+
     # Validation methods
     def validate_string(value)
       raise OptionParser::Error, "cannot pass '#{value}' as an argument to option '#{@current_option}'" if valid?(value)

data/lib/boson/pipe.rb

@@ -1,8 +1,10 @@
 module Boson
-  # This module passes a command's return value through methods/commands specified as pipe options. Pipe options
+  # This module passes an original command's return value through methods/commands specified as pipe options. Pipe options
   # are processed in this order:
-  # * A :query option searches an array of objects or hashes using Pipe.search_object.
-  # * A :sort option sorts an array of objects or hashes using Pipe.sort_object.
+  # * A :query option searches an array of objects or hashes using Pipes.query_pipe.
+  # * A :sort option sorts an array of objects or hashes using Pipes.sort_pipe.
+  # * A :reverse_sort pipe option reverses an array.
+  # * A :pipes option takes an array of commands that modify the return value using Pipes.pipes_pipe.
   # * All user-defined pipe options (:pipe_options key in Repo.config) are processed in random order.
   #
   # Some points:
@@ -10,35 +12,27 @@ module Boson
   #   command loaded when used. The easiest way to do this is by adding the pipe command's library to :defaults in main config.
   # * By default, pipe commands do not modify the value their given. This means you can activate multiple pipes using
   #   a method's original return value.
-  # * If you want a pipe command to modify the value its given, set its pipe option's :filter attribute to true.
   # * A pipe command expects a command's return value as its first argument. If the pipe option takes an argument, it's passed
   #   on as a second argument.
   # * When piping occurs in relation to rendering depends on the Hirb view. With the default Hirb view, piping occurs
   #   occurs in the middle of the rendering, after Hirb has converted the return value into an array of hashes.
   #   If using a custom Hirb view, piping occurs before rendering.
+  # * What the pipe command should expect as a return value depends on the type of command. If it's a command rendered with hirb's
+  #   tables, the return value is a an array of hashes. For everything else, it's the method's original return value.
   #
-  # === Default Pipes: Search and Sort
-  # The default pipe options, :query, :sort and :reverse_sort, are quite useful for searching and sorting arrays:
-  # Some examples using default commands:
-  #   # 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
+  # === User Pipes
+  # User pipes have the following attributes which alter their behavior:
+  # [*:pipe*] Pipe command the pipe executes when called. Default is the pipe's name.
+  # [*:env*] Boolean which enables passing an additional hash to the pipe command. This hash contains information from the first
+  #          command's input with the following keys: :args (command's arguments), :options (command's options),
+  #          :global_options (command's global options) and :config (a command's configuration hash). Default is false.
+  # [*:filter*] Boolean which has the pipe command modify the original command's output with the value it returns. Default is false.
+  # [*:no_render*] Boolean to turn off auto-rendering of the original command's final output. Only applicable to :filter enabled
+  #                pipes. Default is false.
+  # [*:solo*] Boolean to indicate this pipe can't run with other user pipes or pipes from :pipes option.
+  #           If a user calls multiple solo pipes, only the first one detected is called.
   #
-  #   # 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
-  #   bash> boson libraries -q=*:core -s=n -R  # or libraries --query=*:core --sort=name --reverse_sort
-  #
-  #   # Multiple searches can be joined together by ','
-  #   # Searches for libraries that have the name matching core or a library_type matching gem
-  #   bash> boson libraries -q=n:core,l:gem   # or libraries --query=name:core,library_type:gem
-  #
-  # In these examples, we queried commands and examples with an explicit --query. However, -q or --query isn't necessary
-  # for these commands because they already default to it when not present. This behavior comes from the default_option
-  # attribute a command can have.
-  #
-  # === User-defined Pipes
+  # === User Pipes Example
   # Let's say you want to have two commands, browser and copy, you want to make available as pipe options:
   #    # Opens url in browser. This command already ships with Boson.
   #    def browser(url)
@@ -63,93 +57,89 @@ module Boson
   #
   # Some examples of these options using commands from {my libraries}[http://github.com/cldwalker/irbfiles]:
   #    # Creates a gist and then opens url in browser and copies it.
-  #    bash> cat some_file | boson gist -bC        # or cat some_file | boson gist --browser --copy
+  #    $ cat some_file | boson gist -bC        # or cat some_file | boson gist --browser --copy
   #
   #    # Generates rdoc in current directory and then opens it in browser
   #    irb>> rdoc '-b'    # or rdoc '--browser'
   module Pipe
     extend self
 
-    # Main method which processes all pipe commands, both default and user-defined ones.
-    def process(object, options)
-      if object.is_a?(Array)
-        object = search_object(object, options[:query]) if options[:query]
-        object = sort_object(object, options[:sort], options[:reverse_sort]) if options[:sort]
-      end
-      process_user_pipes(object, options)
+    # Process pipes for Scientist
+    def scientist_process(object, global_opt, env={})
+      @env = env
+      [:query, :sort, :reverse_sort].each {|e| global_opt.delete(e) } unless object.is_a?(Array)
+      process_pipes(object, global_opt)
     end
 
-    # Searches an array of objects or hashes using the :query option.
-    # This option is a hash of fields mapped to their search terms. Searches are OR-ed.
-    def search_object(object, query_hash)
-      if object[0].is_a?(Hash)
-        TableCallbacks.search_callback(object, :query=>query_hash)
-      else
-        query_hash.map {|field,query| object.select {|e| e.send(field).to_s =~ /#{query}/i } }.flatten.uniq
-      end
-    rescue NoMethodError
-      $stderr.puts "Query failed with nonexistant method '#{$!.message[/`(.*)'/,1]}'"
+    # Main method which processes all pipe commands, both default and user-defined ones.
+    def process_pipes(obj, options)
+      internal_pipes(options).each {|pipe|
+        obj = Pipes.send("#{pipe}_pipe", obj, options[pipe]) if options[pipe]
+      }
+      process_user_pipes(obj, options)
     end
 
-    # Sorts an array of objects or hashes using a sort field. Sort is reversed with reverse_sort set to true.
-    def sort_object(object, sort, reverse_sort=false)
-      if object[0].is_a?(Hash)
-        TableCallbacks.sort_callback(object, :sort=>sort, :reverse_sort=>reverse_sort)
-      else
-        sort_lambda = object.all? {|e| e.send(sort).respond_to?(:<=>) } ? lambda {|e| e.send(sort) || ''} :
-          lambda {|e| e.send(sort).to_s }
-        object = object.sort_by &sort_lambda
-        object = object.reverse if reverse_sort
-        object
-      end
-    rescue NoMethodError, ArgumentError
-      $stderr.puts "Sort failed with nonexistant method '#{sort}'"
+    # A hash that defines user pipes in the same way as the :pipe_options key in Repo.config.
+    # This method should be called when a pipe's library is loading.
+    def add_pipes(hash)
+      pipe_options.merge! setup_pipes(hash)
     end
 
     #:stopdoc:
+    def internal_pipes(global_opt)
+      internals = [:query, :sort, :reverse_sort, :pipes]
+      internals.delete(:pipes) if pipes_to_process(global_opt).any? {|e| pipe(e)[:solo] }
+      internals
+    end
+
     def pipe_options
-      @pipe_options ||= Boson.repo.config[:pipe_options] || {}
+      @pipe_options ||= setup_pipes(Boson.repo.config[:pipe_options] || {})
+    end
+
+    def setup_pipes(hash)
+      hash.each {|k,v| v[:pipe] ||= k }
     end
 
-    def process_user_pipes(result, options)
-      (options.keys & pipe_options.keys).each {|e|
-        command = pipe_options[e][:pipe] ||= e
-        pipe_result = pipe_options[e][:type] == :boolean ? Boson.invoke(command, result) :
-          Boson.invoke(command, result, options[e])
-        result = pipe_result if pipe_options[e][:filter]
+    def pipe(key)
+      pipe_options[key] || {}
+    end
+
+    # global_opt can come from Hirb callback or Scientist
+    def process_user_pipes(result, global_opt)
+      pipes_to_process(global_opt).each {|e|
+        args = [pipe(e)[:pipe], result]
+        args << global_opt[e] unless pipe(e)[:type] == :boolean
+        args << get_env(e, global_opt) if pipe(e)[:env]
+        pipe_result = Boson.invoke(*args)
+        result = pipe_result if pipe(e)[:filter]
       }
       result
     end
+
+    def get_env(key, global_opt)
+      { :global_options=>global_opt.merge(:delete_callbacks=>[:z_boson_pipes]),
+        :config=>(@env[:config].dup[key] || {}),
+        :args=>@env[:args],
+        :options=>@env[:options] || {}
+      }
+    end
+
+    def any_no_render_pipes?(global_opt)
+      !(pipes = pipes_to_process(global_opt)).empty? &&
+        pipes.any? {|e| pipe(e)[:no_render] }
+    end
+
+    def pipes_to_process(global_opt)
+      pipes = (global_opt.keys & pipe_options.keys)
+      (solo_pipe = pipes.find {|e| pipe(e)[:solo] }) ? [solo_pipe] : pipes
+    end
     #:startdoc:
 
     # Callbacks used by Hirb::Helpers::Table to search,sort and run custom pipe commands on arrays of hashes.
     module TableCallbacks
-      extend self
-      # Case-insensitive searches an array of hashes using the option :query. Numerical string keys
-      # in :query are converted to actual numbers to interface with Hirb. See Pipe.search_object for more
-      # about :query.
-      def search_callback(obj, options)
-        !options[:query] ? obj : begin
-          options[:query].map {|field,query|
-            field = field.to_i if field.to_s[/^\d+$/]
-            obj.select {|e| e[field].to_s =~ /#{query}/i }
-          }.flatten.uniq
-        end
-      end
-
-      # Sorts an array of hashes using :sort option and reverses the sort with :reverse_sort option.
-      def sort_callback(obj, options)
-        return obj unless options[:sort]
-        sort =  options[:sort].to_s[/^\d+$/] ? options[:sort].to_i : options[:sort]
-        sort_lambda = (obj.all? {|e| e[sort].respond_to?(:<=>) } ? lambda {|e| e[sort] } : lambda {|e| e[sort].to_s })
-        obj = obj.sort_by &sort_lambda
-        obj = obj.reverse if options[:reverse_sort]
-        obj
-      end
-
-      # Processes user-defined pipes in random order.
-      def z_user_pipes_callback(obj, options)
-        Pipe.process_user_pipes(obj, options)
+      # Processes boson's pipes
+      def z_boson_pipes_callback(obj, options)
+        Pipe.process_pipes(obj, options)
       end
     end
   end

data/lib/boson/pipes.rb

@@ -0,0 +1,67 @@
+module Boson
+  # === Default Pipes: Search and Sort
+  # The default pipe options, :query, :sort and :reverse_sort, are quite useful for searching and sorting arrays:
+  # Some examples using default commands:
+  #   # Searches commands in the full_name field for 'lib' and sorts results by that field.
+  #   $ 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 desc fields.
+  #   $ 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
+  #   $ boson libraries -q=*:core -s=n -R  # or libraries --query=*:core --sort=name --reverse_sort
+  #
+  #   # Multiple searches can be joined together by ','
+  #   # Searches for libraries that have the name matching core or a library_type matching gem
+  #   $ boson libraries -q=n:core,l:gem   # or libraries --query=name:core,library_type:gem
+  #
+  # In these examples, we queried commands and examples with an explicit --query. However, -q or --query isn't necessary
+  # for these commands because they already default to it when not present. This behavior comes from the default_option
+  # attribute a command can have.
+  module Pipes
+    extend self
+
+    # Case-insensitive search an array of objects or hashes for the :query option.
+    # This option is a hash of fields mapped to their search terms. Searches are OR-ed.
+    # When searching hashes, numerical string keys in query_hash are converted to actual numbers to
+    # interface with Hirb.
+    def query_pipe(object, query_hash)
+      if object[0].is_a?(Hash)
+        query_hash.map {|field,query|
+          field = field.to_i if field.to_s[/^\d+$/]
+          object.select {|e| e[field].to_s =~ /#{query}/i }
+        }.flatten.uniq
+      else
+        query_hash.map {|field,query| object.select {|e| e.send(field).to_s =~ /#{query}/i } }.flatten.uniq
+      end
+    rescue NoMethodError
+      $stderr.puts "Query failed with nonexistant method '#{$!.message[/`(.*)'/,1]}'"
+    end
+
+    # Sorts an array of objects or hashes using a sort field. Sort is reversed with reverse_sort set to true.
+    def sort_pipe(object, sort)
+      sort_lambda = lambda {}
+      if object[0].is_a?(Hash)
+        sort = sort.to_i if sort.to_s[/^\d+$/]
+        sort_lambda = (object.all? {|e| e[sort].respond_to?(:<=>) } ? lambda {|e| e[sort] } : lambda {|e| e[sort].to_s })
+      else
+        sort_lambda = object.all? {|e| e.send(sort).respond_to?(:<=>) } ? lambda {|e| e.send(sort) || ''} :
+          lambda {|e| e.send(sort).to_s }
+      end
+      object.sort_by &sort_lambda
+    rescue NoMethodError, ArgumentError
+      $stderr.puts "Sort failed with nonexistant method '#{sort}'"
+    end
+
+    # Reverse an object
+    def reverse_sort_pipe(object, extra=nil)
+      object.reverse
+    end
+
+    # Pipes output of multiple commands recursively, given initial object
+    def pipes_pipe(obj, arr)
+      arr.inject(obj) {|acc,e| Boson.full_invoke(e, [acc]) }
+    end
+  end
+end

data/lib/boson/repo.rb

@@ -70,10 +70,12 @@ module Boson
     #                   depend on commands from other libraries. Default is false.
     # [:ignore_directories] Array of directories to ignore when detecting local repositories for Boson.local_repo.
     # [:no_auto_render] When set, turns off commandline auto-rendering of a command's output. Default is false.
+    # [:option_underscore_search] When set, OptionParser option values (with :values or :keys) are auto aliased with underscore searching.
+    #                             Default is true. See Util.underscore_search.
     def config(reload=false)
       if reload || @config.nil?
         begin
-          @config = {:libraries=>{}, :command_aliases=>{}, :console_defaults=>[]}
+          @config = {:libraries=>{}, :command_aliases=>{}, :console_defaults=>[], :option_underscore_search=>true}
           @config.merge!(YAML::load_file(config_file(true))) if File.exists?(config_file)
         rescue ArgumentError
           message = $!.message !~ /syntax error on line (\d+)/ ? "Error"+$!.message :
@@ -84,6 +86,16 @@ module Boson
       @config
     end
 
+    # Updates main config file by passing config into a block to be modified and then saved
+    def update_config
+      yield(config)
+      write_config_file
+    end
+
+    def write_config_file #:nodoc:
+      File.open(config_file, 'w') {|f| f.write config.to_yaml }
+    end
+
     def detected_libraries #:nodoc:
       Dir[File.join(commands_dir, '**/*.rb')].map {|e| e.gsub(/^#{commands_dir}\/|\.rb$/, '') }
     end

data/lib/boson/runners/bin_runner.rb

@@ -65,10 +65,10 @@ module Boson
         else
           execute_command
         end
-      rescue Exception
+      rescue
         is_invalid_command = lambda {|command| !Boson.can_invoke?(command[/\w+/]) ||
           (Boson.can_invoke?(command[/\w+/]) && command.include?('.') && $!.is_a?(NoMethodError)) }
-        print_error_message @command && is_invalid_command.call(@command) ?
+        print_error_message @command.to_s[/\w+/] && is_invalid_command.call(@command) ?
           "Error: Command '#{@command}' not found" : "Error: #{$!.message}"
       end
 
@@ -115,10 +115,11 @@ module Boson
         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/')
+          raise unless $!.message[/wrong number of arguments/] &&
+            # Throw out errors that aren't external or from option_command
+            ($!.backtrace.first[/boson/].nil? || $!.backtrace.first[/boson\/option_command.rb/])
           print_error_message "'#{@command}' was called incorrectly."
-          Boson.invoke(:usage, @command)
+          Boson.invoke(:usage, @command, :one_line=>true)
           return
         end
         render_output output

data/lib/boson/scientist.rb

@@ -88,12 +88,12 @@ module Boson
 
     def translate_and_render(obj, command, args, &block)
       @global_options, @command, original_args = {}, command, args.dup
-      args = translate_args(obj, args)
+      @args = translate_args(obj, args)
       return run_help_option if @global_options[:help]
-      run_pretend_option(args)
-      render_or_raw call_original_command(args, &block) unless @global_options[:pretend]
+      run_pretend_option(@args)
+      render_or_raw call_original_command(@args, &block) unless @global_options[:pretend]
     rescue OptionCommand::CommandArgumentError
-      run_pretend_option(args ||= [])
+      run_pretend_option(@args ||= [])
       return if !@global_options[:pretend] && run_verbose_help(option_command, original_args)
       raise unless @global_options[:pretend]
     rescue OptionParser::Error, Error
@@ -104,17 +104,17 @@ module Boson
 
     def translate_args(obj, args)
       option_command.modify_args(args)
-      @global_options, parsed_options, args = option_command.parse(args)
+      @global_options, @current_options, args = option_command.parse(args)
       return if @global_options[:help]
 
       (@global_options[:delete_options] || []).map {|e|
         @global_options.keys.map {|k| k.to_s }.grep(/^#{e}/)
       }.flatten.each {|e| @global_options.delete(e.to_sym) }
 
-      if parsed_options
+      if @current_options
         option_command.add_default_args(args, obj)
         return args if @no_option_commands.include?(@command)
-        args << parsed_options
+        args << @current_options
         option_command.check_argument_size(args)
       end
       args
@@ -131,7 +131,9 @@ module Boson
     end
 
     def run_help_option
-      Boson.invoke(:usage, @command.name, :verbose=>@global_options[:verbose])
+      opts = @global_options[:verbose] ? ['--verbose'] : []
+      opts << "--render_options=#{@global_options[:usage_options]}" if @global_options[:usage_options]
+      Boson.invoke :usage, @command.name + " " + opts.join(' ')
     end
 
     def run_pretend_option(args)
@@ -143,18 +145,19 @@ module Boson
 
     def render_or_raw(result)
       if (@rendered = render?)
-        result = Pipe.process(result, @global_options) if @global_options.key?(:class) ||
-          @global_options.key?(:method)
+        if @global_options.key?(:class) || @global_options.key?(:method)
+          result = Pipe.scientist_process(result, @global_options, :config=>@command.config, :args=>@args, :options=>@current_options)
+        end
         View.render(result, OptionCommand.delete_non_render_options(@global_options.dup), false)
       else
-        Pipe.process(result, @global_options)
+        Pipe.scientist_process(result, @global_options, :config=>@command.config, :args=>@args, :options=>@current_options)
       end
     rescue StandardError
       raise Error, $!.message, $!.backtrace
     end
 
     def render?
-      !!@command.render_options ^ @global_options[:render]
+      (!!@command.render_options ^ @global_options[:render]) && !Pipe.any_no_render_pipes?(@global_options)
     end
     #:startdoc:
   end