boson 0.2.0 → 0.2.1

data/lib/boson/pipe.rb

@@ -0,0 +1,157 @@
+module Boson
+  # This module passes a 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.
+  # * All user-defined pipe options (:pipe_options key in Repo.config) are processed in random order.
+  #
+  # Some points:
+  # * User-defined pipes call a command (the option's name by default). It's the user's responsibility to have this
+  #   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.
+  #
+  # === 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
+  #
+  #   # 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
+  #
+  #   # 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
+  # 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)
+  #      system('open', url)
+  #    end
+  #
+  #    # Copy to clipboard
+  #    def copy(str)
+  #      IO.popen('pbcopy', 'w+') {|clipboard| clipboard.write(str)}
+  #    end
+  #
+  # To configure them, drop the following config in ~/.boson/config/boson.yml:
+  #   :pipe_options:
+  #     :browser:
+  #       :type: :boolean
+  #       :desc: Open in browser
+  #     :copy:
+  #       :type: :boolean
+  #       :desc: Copy to clipboard
+  #
+  # Now for any command that returns a url string, these pipe options can be turned on to execute the url.
+  #
+  # 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
+  #
+  #    # 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)
+    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]}'"
+    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}'"
+    end
+
+    #:stopdoc:
+    def pipe_options
+      @pipe_options ||= Boson.repo.config[:pipe_options] || {}
+    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]
+      }
+      result
+    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)
+      end
+    end
+  end
+end
+Hirb::Helpers::Table.send :include, Boson::Pipe::TableCallbacks

data/lib/boson/repo.rb

@@ -35,7 +35,7 @@ module Boson
     # A hash read from the YAML config file at config/boson.yml.
     # {See here}[http://github.com/cldwalker/irbfiles/blob/master/boson/config/boson.yml] for an example config file.
     # Top level config keys, library attributes and config attributes need to be symbols.
-    # ==== Valid config keys:
+    # ==== Config keys for all repositories:
     # [:libraries] Hash of libraries mapping their name to attribute hashes. See Library.new for configurable attributes.
     #               Example:
     #               :libraries=>{'completion'=>{:namespace=>true}}
@@ -53,12 +53,23 @@ module Boson
     # [:add_load_path] Boolean specifying whether to add a load path pointing to the lib subdirectory/. This is useful in sharing
     #                  classes between libraries without resorting to packaging them as gems. Defaults to false if the lib
     #                  subdirectory doesn't exist in the boson directory.
+    #
+    # ==== Config keys specific to the main repo config ~/.boson/config/boson.yml
+    # [:pipe_options] Hash of options available to all option commands for piping (see Pipe). A pipe option has the
+    #                 {normal option attributes}[link:classes/Boson/OptionParser.html#M000081] and these:
+    #                 * :pipe: Specifies the command to call when piping. Defaults to the pipe's option name.
+    #                 * :filter: Boolean which indicates that the pipe command will modify its input with what it returns.
+    #                   Default is false.
+    # [:render_options] Hash of render options available to all option commands to be passed to a Hirb view (see View). Since
+    #                   this merges with default render options, it's possible to override default render options.
     # [:error_method_conflicts] Boolean specifying library loading behavior when its methods conflicts with existing methods in
     #                           the global namespace. When set to false, Boson automatically puts the library in its own namespace.
     #                           When set to true, the library fails to load explicitly. Default is false.
     # [:console] Console to load when using --console from commandline. Default is irb.
     # [:auto_namespace] Boolean which automatically namespaces all user-defined libraries. Be aware this can break libraries which
     #                   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.
     def config(reload=false)
       if reload || @config.nil?
         begin
@@ -72,5 +83,13 @@ module Boson
       end
       @config
     end
+
+    def detected_libraries #:nodoc:
+      Dir[File.join(commands_dir, '**/*.rb')].map {|e| e.gsub(/^#{commands_dir}\/|\.rb$/, '') }
+    end
+
+    def all_libraries #:nodoc:
+      (detected_libraries + config[:libraries].keys).uniq
+    end
   end
 end

data/lib/boson/repo_index.rb

@@ -0,0 +1,123 @@
+require 'digest/md5'
+module Boson
+  # This class provides an index for commands and libraries of a given a Repo.
+  # When this index updates, it detects library files whose md5 hash have changed and reindexes them.
+  # The index is stored with Marshal at config/index.marshal (relative to a Repo's root directory). 
+  # Since the index is marshaled, putting lambdas/procs in it will break it.If an index gets corrupted,
+  # simply delete it and next time Boson needs it, the index will be recreated.
+  
+  class RepoIndex
+    attr_reader :libraries, :commands, :repo
+    def initialize(repo)
+      @repo = repo
+    end
+
+    # Updates the index.
+    def update(options={})
+      libraries_to_update = !exists? ? repo.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
+    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])
+    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 }
+    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 }
+      }
+    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(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
+    end
+
+    def changed_libraries
+      read
+      latest_hashes.select {|lib, hash| @lib_hashes[lib] != hash}.map {|e| e[0]}
+    end
+
+    def latest_hashes
+      repo.all_libraries.inject({}) {|h, e|
+        lib_file = FileLibrary.library_file(e, repo.dir)
+        h[e] = Digest::MD5.hexdigest(File.read(lib_file)) if File.exists?(lib_file)
+        h
+      }
+    end
+    #:startdoc:
+  end
+end

data/lib/boson/runner.rb

@@ -11,18 +11,17 @@ module Boson
 
       # Libraries that come with Boson
       def default_libraries
-        [Boson::Commands::Core, Boson::Commands::WebCore] + (Boson.repo.config[:defaults] || [])
+        [Boson::Commands::Core, Boson::Commands::WebCore] + Boson.repos.map {|e| e.config[:defaults] || [] }.flatten
       end
 
       # Libraries detected in repositories
       def detected_libraries
-        Boson.repos.map {|repo| Dir[File.join(repo.commands_dir, '**/*.rb')].
-          map {|e| e.gsub(/^#{repo.commands_dir}\/|\.rb$/, '')} }.flatten
+        Boson.repos.map {|e| e.detected_libraries }.flatten.uniq
       end
 
       # Libraries specified in config files and detected_libraries
       def all_libraries
-        (detected_libraries + Boson.repos.map {|e| e.config[:libraries].keys}.flatten).uniq
+        Boson.repos.map {|e| e.all_libraries }.flatten.uniq
       end
 
       #:stopdoc:

data/lib/boson/runners/bin_runner.rb

@@ -2,7 +2,7 @@ module Boson
   # This class handles the boson executable (boson command execution from the commandline). Any changes
   # to your commands are immediately available from the commandline except for changes to the main config file.
   # For those changes to take effect you need to explicitly load and index the libraries with --index.
-  # See Index to understand how Boson can immediately detect the latest commands.
+  # See RepoIndex to understand how Boson can immediately detect the latest commands.
   #
   # Usage for the boson shell command looks like this:
   #   boson [GLOBAL OPTIONS] [COMMAND] [ARGS] [COMMAND OPTIONS]
@@ -20,9 +20,22 @@ module Boson
   # [:index] Updates index for given libraries allowing you to use them. This is useful if Boson's autodetection of
   #          changed libraries isn't picking up your changes. Since this option has a :bool_default attribute, arguments
   #          passed to this option need to be passed with '=' i.e. '--index=my_lib'.
-  # [:render] Pretty formats the results of commands without options. Handy for commands that return arrays.
+  # [:render] Toggles the auto-rendering done for commands that don't have views. Doesn't affect commands that already have views.
+  #           Default is false. Also see Auto Rendering section below.
   # [:pager_toggle] Toggles Hirb's pager in case you'd like to pipe to another command.
+  #
+  # ==== Auto Rendering
+  # Commands that don't have views (defined via render_options) have their return value auto-rendered as a view as follows:
+  # * nil,false and true aren't rendered
+  # * arrays are rendered with Hirb's tables
+  # * non-arrays are printed with inspect()
+  # * 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"},
       :index=>{:type=>:array, :desc=>"Libraries to index. Libraries must be passed with '='.",
@@ -30,7 +43,8 @@ module Boson
       :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,
+        :enum=>false, :desc=>"A comma delimited array of libraries to load"},
       :render=>{:type=>:boolean, :desc=>"Renders a Hirb view from result of command without options"},
       :pager_toggle=>{:type=>:boolean, :desc=>"Toggles Hirb's pager"}
     } #:nodoc:
@@ -87,7 +101,7 @@ module Boson
       end
 
       def default_libraries
-        super + (Boson.repo.config[:bin_defaults] || [])
+        super + Boson.repos.map {|e| e.config[:bin_defaults] || [] }.flatten + Dir.glob('Bosonfile')
       end
 
       def execute_command
@@ -107,10 +121,11 @@ module Boson
       end
 
       def render_output(output)
-        if Scientist.global_options && !Scientist.rendered && !View.silent_object?(output)
-          puts output.inspect
-        elsif !Scientist.global_options && @options[:render]
-          View.render(output, :silence_booleans=>true)
+        if (!Scientist.rendered && !View.silent_object?(output)) ^ @options[:render] ^
+          Boson.repo.config[:no_auto_render]
+            opts = output.is_a?(String) ? {:method=>'puts'} :
+              {:inspect=>!output.is_a?(Array) || (Scientist.global_options || {})[:render] }
+            View.render output, opts
         end
       end
 

data/lib/boson/runners/console_runner.rb

@@ -5,8 +5,7 @@ module Boson
   class ConsoleRunner < Runner
     class <<self
       # Starts Boson by loading configured libraries. If no default libraries are specified in the config,
-      # it will load up all detected libraries.
-      # ==== Options
+      # it will load up all detected libraries. Options:
       # [:libraries] Array of libraries to load.
       # [:verbose] Boolean to be verbose about libraries loading. Default is true.
       # [:no_defaults] Boolean which turns off loading any default libraries. Default is false.

data/lib/boson/scientist.rb

@@ -1,109 +1,54 @@
-require 'shellwords'
 module Boson
-  # Scientist redefines _any_ object's methods to act like shell commands while still receiving ruby arguments normally.
-  # It also let's your method have an optional view generated from a method's return value.
-  # Boson::Scientist.create_option_command redefines an object's method with a Boson::Command while
-  # Boson::Scientist.commandify redefines with just a hash. For an object's method to be redefined correctly,
+  # Scientist wraps around and redefines an object's method to give it the following features:
+  # * Methods can take shell command input with options or receive its normal arguments. See the Commandification
+  #   section.
+  # * Methods have a slew of global options available. See OptionCommand for an explanation of basic global options.
+  # * Before a method returns its value, it pipes its return value through pipe commands if pipe options are specified. See Pipe.
+  # * Methods can have any number of optional views associated with them via global render options (see View). Views can be toggled
+  #   on/off with the global option --render (see OptionCommand).
+  #
+  # The main methods Scientist provides are redefine_command() for redefining an object's method with a Command object
+  # and commandify() for redefining with a hash of method attributes. Note that for an object's method to be redefined correctly,
   # its last argument _must_ expect a hash.
   #
-  # === Examples
+  # === Commandification
   # Take for example this basic method/command with an options definition:
   #   options :level=>:numeric, :verbose=>:boolean
-  #   def foo(arg='', options={})
-  #     [arg, options]
+  #   def foo(*args)
+  #     args
   #   end
   #
-  # When Scientist wraps around foo(), argument defaults are respected:
-  #    foo '', :verbose=>true   # normal call
-  #    foo '-v'                 # commandline call
-  #
-  #    Both calls return: ['', {:verbose=>true}]
-  #
-  # Non-string arguments can be passed in:
-  #    foo Object, :level=>1
-  #    foo Object, 'l1'
+  # When Scientist wraps around foo(), it can take arguments normally or as a shell command:
+  #    foo 'one', 'two', :verbose=>true   # normal call
+  #    foo 'one two -v'                 # commandline call
   #
-  #    Both calls return: [Object, {:level=>1}]
+  #    Both calls return: ['one', 'two', {:verbose=>true}]
   #
-  # === Global Options
-  # Any command with options comes with default global options. For example '-hv' on such a command
-  # prints a help summarizing a command's options as well as the global options.
-  # When using global options along with command options, global options _must_ precede command options.
-  # Take for example using the global --pretend option with the method above:
-  #   irb>> foo '-p -l=1'
-  #   Arguments: ["", {:level=>1}]
-  #   Global options: {:pretend=>true}
+  # Non-string arguments can be passed as well:
+  #    foo Object, 'two', :level=>1
+  #    foo Object, 'two -l1'
   #
-  # If a global option conflicts with a command's option, the command's 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'
-  #   # is the same as
-  #   foo ' -g "p fields=f1,f2" -l=1 '
-  #
-  # === Rendering Views With Global Options
-  # Perhaps the most important global option is --render. This option toggles the rendering of your command's output
-  # with Hirb[http://github.com/cldwalker/hirb]. Since Hirb can be customized to generate any view, this option allows
-  # you toggle a predefined view for a command without embedding view code in your command!
-  #
-  # Here's a simple example, toggling Hirb's table view:
-  #   # Defined in a library file:
-  #   #@options {}
-  #   def list(options={})
-  #     [1,2,3]
-  #   end
-  #
-  #   Using it in irb:
-  #   >> list
-  #   => [1,2,3]
-  #   >> list '-r'
-  #   +-------+
-  #   | value |
-  #   +-------+
-  #   | 1     |
-  #   | 2     |
-  #   | 3     |
-  #   +-------+
-  #   3 rows in set
-  #   => true
-  #
-  # To default to rendering a view for a command, add a render_options {method attribute}[link:classes/Boson/MethodInspector.html]
-  # above list() along with any options you want to pass to your Hirb helper class. In this case, using '-r' gives you the
-  # command's returned object instead of a formatted view!
+  #    Both calls return: [Object, 'two', {:level=>1}]
   module Scientist
     extend self
     # Handles all Scientist errors.
     class Error < StandardError; end
     class EscapeGlobalOption < StandardError; end
 
-    attr_reader :global_options, :rendered, :option_parsers, :command_options
+    attr_accessor :global_options, :rendered
     @no_option_commands ||= []
-    GLOBAL_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"},
-    } #:nodoc:
-    RENDER_OPTIONS = {
-      :fields=>{:type=>:array, :desc=>"Displays fields in the order given"},
-      :class=>{:type=>:string, :desc=>"Hirb helper class which renders"},
-      :max_width=>{:type=>:numeric, :desc=>"Max width of a table"},
-      :vertical=>{:type=>:boolean, :desc=>"Display a vertical table"},
-      :sort=>{:type=>:string, :desc=>"Sort by given field"},
-      :reverse_sort=>{:type=>:boolean, :desc=>"Reverse a given sort"},
-      :query=>{:type=>:hash, :desc=>"Queries fields given field:search pairs"},
-    } #:nodoc:
+    @option_commands ||= {}
 
     # Redefines an object's method with a Command of the same name.
-    def create_option_command(obj, command)
-      cmd_block = create_option_command_block(obj, command)
+    def redefine_command(obj, command)
+      cmd_block = redefine_command_block(obj, command)
       @no_option_commands << command if command.options.nil?
       [command.name, command.alias].compact.each {|e|
         obj.instance_eval("class<<self;self;end").send(:define_method, e, cmd_block)
       }
     end
 
-    # A wrapper around create_option_command that doesn't depend on a Command object. Rather you
+    # A wrapper around redefine_command that doesn't depend on a Command object. Rather you
     # simply pass a hash of command attributes (see Command.new) or command methods and let OpenStruct mock a command.
     # The only required attribute is :name, though to get any real use you should define :options and
     # :arg_size (default is '*'). Example:
@@ -123,19 +68,23 @@ module Boson
       hash[:has_splat_args?] = true if hash[:arg_size] == '*'
       fake_cmd = OpenStruct.new(hash)
       fake_cmd.option_parser ||= OptionParser.new(fake_cmd.options || {})
-      create_option_command(obj, fake_cmd)
+      redefine_command(obj, fake_cmd)
     end
 
-    # The actual method which replaces a command's original method
-    def create_option_command_block(obj, command)
+    # The actual method which redefines a command's original method
+    def redefine_command_block(obj, command)
       lambda {|*args|
         Boson::Scientist.translate_and_render(obj, command, args) {|args| super(*args) }
       }
     end
 
     #:stopdoc:
+    def option_command(cmd=@command)
+      @option_commands[cmd] ||= OptionCommand.new(cmd)
+    end
+
     def translate_and_render(obj, command, args)
-      @global_options = {}
+      @global_options, @command = {}, command
       args = translate_args(obj, command, args)
       if @global_options[:verbose] || @global_options[:pretend]
         puts "Arguments: #{args.inspect}", "Global options: #{@global_options.inspect}"
@@ -149,24 +98,16 @@ module Boson
     end
 
     def translate_args(obj, command, args)
-      @obj, @command, @args = obj, command, args
-      # prepends default option
-      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
-      @command.options ||= {}
-
-      if parsed_options = parse_command_options
-        add_default_args(@args)
-        return @args if @no_option_commands.include?(@command)
-        @args << parsed_options
-        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})"
-        end
+      option_command.prepend_default_option(args)
+      @global_options, parsed_options, args = option_command.parse(args)
+      raise EscapeGlobalOption if @global_options[:help]
+      if parsed_options
+        option_command.add_default_args(args, obj)
+        return args if @no_option_commands.include?(command)
+        args << parsed_options
+        option_command.check_argument_size(args)
       end
-      @args
+      args
     rescue Error, ArgumentError, EscapeGlobalOption
       raise
     rescue Exception
@@ -176,137 +117,19 @@ module Boson
 
     def render_or_raw(result)
       if (@rendered = render?)
-        result = run_pipe_commands(result)
-        render_global_opts = @global_options.dup.delete_if {|k,v| default_global_options.keys.include?(k) }
-        View.render(result, render_global_opts, false)
+        result = Pipe.process(result, @global_options) if @global_options.key?(:class) ||
+          @global_options.key?(:method)
+        View.render(result, OptionCommand.delete_non_render_options(@global_options.dup), false)
       else
-        result = View.search_and_sort(result, @global_options) if !(@global_options.keys & [:sort, :reverse_sort, :query]).empty?
-        run_pipe_commands(result)
+        Pipe.process(result, @global_options)
       end
     rescue Exception
       message = @global_options[:verbose] ? "#{$!}\n#{$!.backtrace.inspect}" : $!.message
       raise Error, message
     end
 
-    def pipe_options
-      @pipe_options ||= Hash[*default_global_options.select {|k,v| v[:pipe] }.flatten]
-    end
-
-    def run_pipe_commands(result)
-      (global_options.keys & pipe_options.keys).each {|e|
-        command = pipe_options[e][:pipe] != true ? pipe_options[e][:pipe] : e
-        pipe_result = pipe_options[e][:type] == :boolean ? Boson.invoke(command, result) :
-          Boson.invoke(command, result, global_options[e])
-        result = pipe_result if pipe_options[e][:filter]
-      }
-      result
-    end
-
-    # choose current parser
-    def option_parser
-      @command.render_options ? command_option_parser : default_option_parser
-    end
-
-    # current command parser
-    def command_option_parser
-      (@option_parsers ||= {})[@command] ||= OptionParser.new current_command_options
-    end
-
-    # set cmd and use its parser
-    def render_option_parser(cmd)
-      @command = cmd
-      option_parser
-    end
-
-    def default_option_parser
-      @default_option_parser ||= OptionParser.new default_render_options.merge(default_global_options)
-    end
-
-    def default_global_options
-      @default_global_options ||= GLOBAL_OPTIONS.merge Boson.repo.config[:global_options] || {}
-    end
-
-    def default_render_options
-      @default_render_options ||= RENDER_OPTIONS.merge Boson.repo.config[:render_options] || {}
-    end
-
-    def current_command_options
-      (@command_options ||= {})[@command] ||= begin
-        @command.render_options.each {|k,v|
-          if !v.is_a?(Hash) && !v.is_a?(Symbol)
-            @command.render_options[k] = {:default=>v}
-          end
-        }
-        render_opts = Util.recursive_hash_merge(@command.render_options, Util.deep_copy(default_render_options))
-        opts = Util.recursive_hash_merge render_opts, Util.deep_copy(default_global_options)
-        if !opts[:fields].key?(:values)
-          if opts[:fields][:default]
-            opts[:fields][:values] = opts[:fields][:default]
-          else
-            opts[:fields][:values] = opts[:change_fields][:default].values if opts[:change_fields] && opts[:change_fields][:default]
-            opts[:fields][:values] ||= opts[:headers][:default].keys if opts[:headers] && opts[:headers][:default]
-          end
-          opts[:fields][:enum] = false if opts[:fields][:values] && !opts[:fields].key?(:enum)
-        end
-        if opts[:fields][:values]
-          opts[:sort][:values] ||= opts[:fields][:values]
-          opts[:query][:keys] ||= opts[:fields][:values]
-          opts[:query][:default_keys] ||= "*"
-        end
-        opts
-      end
-    end
-
     def render?
-      (@command.render_options && !@global_options[:render]) || (!@command.render_options && @global_options[:render])
-    end
-
-    def parse_command_options
-      if @args.size == 1 && @args[0].is_a?(String)
-        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)
-        args = Boson.const_defined?(:BinRunner) ? @args : Shellwords.shellwords(@args.pop)
-        parsed_options, new_args = parse_options args
-        @args += new_args
-      # add default options
-      elsif @command.options.empty? || (!@command.has_splat_args? &&
-        @args.size <= (@command.arg_size - 1).abs) || (@command.has_splat_args? && !@args[-1].is_a?(Hash))
-          parsed_options = parse_options([])[0]
-      # merge default options with given hash of options
-      elsif (@command.has_splat_args? || (@args.size == @command.arg_size)) && @args[-1].is_a?(Hash)
-        parsed_options = parse_options([])[0]
-        parsed_options.merge!(@args.pop)
-      end
-      parsed_options
-    end
-
-    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
-      raise EscapeGlobalOption if @global_options[:help]
-      [parsed_options, new_args]
-    end
-
-    def add_default_args(args)
-      if @command.args && args.size < @command.args.size - 1
-        # leave off last arg since its an option
-        @command.args.slice(0..-2).each_with_index {|arr,i|
-          next if args.size >= i + 1 # only fill in once args run out
-          break if arr.size != 2 # a default arg value must exist
-          begin
-            args[i] = @command.file_parsed_args? ? @obj.instance_eval(arr[1]) : arr[1]
-          rescue Exception
-            raise Error, "Unable to set default argument at position #{i+1}.\nReason: #{$!.message}"
-          end
-        }
-      end
+      !!@command.render_options ^ @global_options[:render]
     end
     #:startdoc:
   end