boson 0.4.0 → 1.0.0

data/lib/boson/pipes.rb

@@ -1,75 +0,0 @@
-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)
-        if sort.to_s[/^\d+$/]
-          sort = sort.to_i
-        elsif object[0].keys.all? {|e| e.is_a?(Symbol) }
-          sort = sort.to_sym
-        end
-        sort_lambda = untouched_sort?(object.map {|e| e[sort] }) ? lambda {|e| e[sort] } : lambda {|e| e[sort].to_s }
-      else
-        sort_lambda = untouched_sort?(object.map {|e| e.send(sort) }) ? 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
-
-    def untouched_sort?(values) #:nodoc:
-      values.all? {|e| e.respond_to?(:<=>) } && values.map {|e| e.class }.uniq.size == 1
-    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

@@ -1,107 +0,0 @@
-%w{yaml fileutils}.each {|e| require e }
-module Boson
-  # A class for repositories. A repository has a root directory with required subdirectories config/ and
-  # commands/ and optional subdirectory lib/. Each repository has a primary config file at config/boson.yml.
-  class Repo
-    def self.commands_dir(dir) #:nodoc:
-      File.join(dir, 'commands')
-    end
-
-    attr_accessor :dir, :config
-    # Creates a repository given a root directory.
-    def initialize(dir)
-      @dir = dir
-    end
-
-    # Points to the config/ subdirectory and is automatically created when called. Used for config files.
-    def config_dir
-      @config_dir ||= FileUtils.mkdir_p(config_dir_path) && config_dir_path
-    end
-
-    def config_dir_path
-      "#{dir}/config"
-    end
-
-    # Path name of main config file. If passed true, parent directory of file is created.
-    def config_file(create_dir=false)
-      File.join((create_dir ? config_dir : config_dir_path), 'boson.yml')
-    end
-
-    # Points to the commands/ subdirectory and is automatically created when called. Used for command libraries.
-    def commands_dir
-      @commands_dir ||= (cdir = self.class.commands_dir(@dir)) && FileUtils.mkdir_p(cdir) && cdir
-    end
-
-    # 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.
-    # ==== 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}}
-    # [:command_aliases] Hash of commands names and their aliases. Since this is global it will be read by _all_ libraries.
-    #                    This is useful for quickly creating aliases without having to worry about placing them under
-    #                    the correct library config. For non-global aliasing, aliases should be placed under the :command_aliases
-    #                    key of a library entry in :libraries.
-    #                     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 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.
-    # [: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.
-    # [: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=>[], :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 :
-            "Error: Syntax error in line #{$1} of config file '#{config_file}'"
-          Kernel.abort message
-        end
-      end
-      @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
-
-    def all_libraries #:nodoc:
-      (detected_libraries + config[:libraries].keys).uniq
-    end
-  end
-end

data/lib/boson/runners/bin_runner.rb

@@ -1,208 +0,0 @@
-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 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]
-  #
-  # The boson executable comes with these global options:
-  # [:help]  Gives a basic help of global options. When a command is given the help shifts to a command's help.
-  # [:verbose] Using this along with :help option shows more help. Also gives verbosity to other actions i.e. loading.
-  # [:execute] Like ruby -e, this executes a string of ruby code. However, this has the advantage that all
-  #            commands are available as normal methods, automatically loading as needed. This is a good
-  #            way to call commands that take non-string arguments.
-  # [:console] This drops Boson into irb after having loaded default commands and any explict libraries with
-  #            :load option. This is a good way to start irb with only certain libraries loaded.
-  # [:load] Explicitly loads a list of libraries separated by commas. Most useful when used with :console option.
-  #         Can also be used to explicitly load libraries that aren't being detected automatically.
-  # [: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] 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.
-  # [:backtrace] Prints full backtrace on error. Default is false.
-  #
-  # ==== 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
-    GLOBAL_OPTIONS =  {
-      :verbose=>{:type=>:boolean, :desc=>"Verbose description of loading libraries, errors or help"},
-      :version=>{:type=>:boolean, :desc=>"Prints the current version"},
-      :index=>{:type=>:array, :desc=>"Libraries to index. Libraries must be passed with '='.",
-        :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, :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"},
-      :option_commands=>{:type=>:boolean, :desc=>"Toggles on all commands to be defined as option commands" },
-      :ruby_debug=>{:type=>:boolean, :desc=>"Sets $DEBUG", :alias=>'D'},
-      :debug=>{:type=>:boolean, :desc=>"Prints debug info for boson"},
-      :load_path=>{:type=>:string, :desc=>"Add to front of $LOAD_PATH", :alias=>'I'},
-      :backtrace=>{:type=>:boolean, :desc=>'Prints full backtrace'}
-    } #:nodoc:
-
-    PIPE = '+'
-
-    class <<self
-      attr_accessor :command
-
-      # Starts, processes and ends a commandline request.
-      def start(args=ARGV)
-        @command, @options, @args = parse_args(args)
-        return puts("boson #{Boson::VERSION}") if @options[:version]
-        return print_usage if args.empty? || (@command.nil? && !@options[:console] && !@options[:execute])
-        $:.unshift(*options[:load_path].split(":")) if options[:load_path]
-        Runner.debug = true if @options[:debug]
-        return ConsoleRunner.bin_start(@options[:console], @options[:load]) if @options[:console]
-        $DEBUG = true if options[:ruby_debug]
-        init
-
-        if @options[:help]
-          autoload_command @command
-          Boson.invoke(:usage, @command, :verbose=>@options[:verbose])
-        elsif @options[:execute]
-          define_autoloader
-          Boson.main_object.instance_eval @options[:execute]
-        else
-          execute_command
-        end
-      rescue NoMethodError
-        abort_with no_method_error_message
-      rescue
-        abort_with default_error_message
-      end
-
-      def no_method_error_message #:nodoc:
-        @command = @command.to_s
-        if $!.backtrace.grep(/`(invoke|full_invoke)'$/).empty? ||
-          !$!.message[/undefined method `(\w+\.)?#{@command.split(NAMESPACE)[-1]}'/]
-            default_error_message
-        else
-          @command.to_s[/\w+/] &&
-            (!(Index.read && Index.find_command(@command[/\w+/])) || @command.include?(NAMESPACE)) ?
-            "Error: Command '#{@command}' not found" : default_error_message
-        end
-      end
-
-      # Loads libraries and handles non-critical options
-      def init
-        Runner.in_shell = true
-        Command.all_option_commands = true if @options[:option_commands]
-        super
-
-        if @options.key?(:index)
-          Index.update(:verbose=>true, :libraries=>@options[:index])
-          @index_updated = true
-        elsif !@options[:help] && @command && Boson.can_invoke?(@command)
-          Index.update(:verbose=>@options[:verbose])
-          @index_updated = true
-        end
-        Manager.load @options[:load], load_options if @options[:load]
-        View.toggle_pager if @options[:pager_toggle]
-      end
-
-      # Hash of global options passed in from commandline
-      def options
-        @options ||= {}
-      end
-
-      # Commands to executed, in order given by user
-      def commands
-        @commands ||= @all_args.map {|e| e[0]}
-      end
-
-      #:stopdoc:
-      def abort_with(message)
-        message += "\nOriginal error: #{$!}\n  #{$!.backtrace.join("\n  ")}" if options[:verbose] || options[:backtrace]
-        abort message
-      end
-
-      def default_error_message
-        "Error: #{$!.message}"
-      end
-
-      def autoload_command(cmd)
-        if !Boson.can_invoke?(cmd, false)
-          unless @index_updated
-            Index.update(:verbose=>@options[:verbose])
-            @index_updated = true
-          end
-          super(cmd, load_options)
-        end
-      end
-
-      def default_libraries
-        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
-        output = @all_args.inject(nil) {|acc, (cmd,*args)|
-          begin
-            @command = cmd # for external errors
-            autoload_command cmd
-            args = translate_args(args, acc)
-            Boson.full_invoke(cmd, args)
-          rescue ArgumentError
-            if $!.class == OptionCommand::CommandArgumentError || ($!.message[/wrong number of arguments/] &&
-              (cmd_obj = Command.find(cmd)) && cmd_obj.arg_size != args.size)
-              abort_with "'#{cmd}' was called incorrectly.\n" + Command.usage(cmd)
-            else
-              raise
-            end
-          end
-        }
-        render_output output
-      end
-
-      def translate_args(args, piped)
-        args.unshift piped if piped
-        args
-      end
-
-      def parse_args(args)
-        @all_args = Util.split_array_by(args, PIPE)
-        args = @all_args[0]
-        @option_parser = OptionParser.new(GLOBAL_OPTIONS)
-        options = @option_parser.parse(args.dup, :opts_before_args=>true)
-        new_args = @option_parser.non_opts
-        @all_args[0] = new_args
-        [new_args[0], options, new_args[1..-1]]
-      end
-
-      def render_output(output)
-        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
-
-      def print_usage
-        puts "boson [GLOBAL OPTIONS] [COMMAND] [ARGS] [COMMAND OPTIONS]\n\n"
-        puts "GLOBAL OPTIONS"
-        View.enable
-        @option_parser.print_usage_table
-        if @options[:verbose]
-          Manager.load [Boson::Commands::Core]
-          puts "\n\nDEFAULT COMMANDS"
-          Boson.invoke :commands, :fields=>["name", "usage", "description"], :description=>false
-        end
-      end
-      #:startdoc:
-    end
-  end
-end

data/lib/boson/runners/console_runner.rb

@@ -1,58 +0,0 @@
-module Boson
-  # Runner used when starting irb. To use in irb, drop this in your ~/.irbrc:
-  #   require 'boson'
-  #   Boson.start
-  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:
-      # [:libraries] Array of libraries to load.
-      # [:verbose] Boolean to be verbose about libraries loading. Default is true.
-      # [:no_defaults] Boolean or :all which turns off loading default libraries. If set to true,
-      #                effects loading user's console default libraries. If set to :all, effects
-      #                all libraries including boson's. Default is false.
-      # [:autoload_libraries] Boolean which makes any command execution easier. It redefines
-      #                       method_missing on Boson.main_object so that commands with unloaded
-      #                       libraries are automatically loaded. Default is false.
-      def start(options={})
-        @options = {:verbose=>true}.merge options
-        init unless @initialized
-        Manager.load(@options[:libraries], load_options) if @options[:libraries]
-      end
-
-      # Loads libraries and then starts irb (or the configured console) from the commandline.
-      def bin_start(repl, libraries)
-        start :no_defaults=>true, :libraries=>libraries
-        repl = Boson.repo.config[:console] if Boson.repo.config[:console]
-        repl = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb' unless repl.is_a?(String)
-        unless repl.index('/') == 0 || (repl = Util.which(repl))
-          abort "Console not found. Please specify full path in config[:console]."
-        else
-          load_repl(repl)
-        end
-      end
-
-      def load_repl(repl) #:nodoc:
-        ARGV.replace ['-f']
-        $progname = $0
-        alias $0 $progname
-        Kernel.load $0 = repl
-      end
-
-      def init #:nodoc:
-        super
-        define_autoloader if @options[:autoload_libraries]
-        @initialized = true
-      end
-
-      def default_libraries #:nodoc:
-        return [] if @options[:no_defaults] == :all
-        return super if @options[:no_defaults]
-        defaults = super + Boson.repos.map {|e| e.config[:console_defaults] }.flatten
-        defaults += detected_libraries if defaults.empty?
-        defaults.uniq
-      end
-    end
-  end
-end
-