boson 0.2.0 → 0.2.1

data/lib/boson/libraries/local_file_library.rb

@@ -0,0 +1,30 @@
+# This class loads any local file and is most commonly used to load a local
+# Bosonfile. Since this file doesn't exist inside a normal Repo, it is not indexed with any repo.
+# Since file-based libraries need to be associated with a repository, Boson associates it
+# with a local repository if it exists or defaults to Boson.repo. See Boson::FileLibrary
+# for more info about this library.
+#
+# Example:
+#   >> load_library 'Bosonfile'
+#   => true
+class Boson::LocalFileLibrary < Boson::FileLibrary
+  handles {|source|
+    @repo = (File.exists?(source.to_s) ? (Boson.local_repo || Boson.repo) : nil)
+    !!@repo
+  }
+
+  #:stopdoc:
+  def set_name(name)
+    @lib_file = File.expand_path(name.to_s)
+    File.basename(@lib_file).downcase
+  end
+
+  def base_module
+    Boson::Commands
+  end
+
+  def library_file
+    @lib_file
+  end
+  #:startdoc:
+end

data/lib/boson/libraries/module_library.rb

@@ -24,7 +24,7 @@ module Boson
     def set_name(name)
       @module = name
       underscore_lib = name.to_s[/^Boson::Commands/] ? name.to_s.split('::')[-1] : name.to_s
-      super Util.underscore(underscore_lib)
+      Util.underscore(underscore_lib)
     end
 
     def initialize_library_module

data/lib/boson/library.rb

@@ -1,7 +1,7 @@
 module Boson
   # A library is a group of commands (Command objects) usually grouped together by a module.
   # Libraries are loaded from different sources depending on the library subclass. Default library
-  # subclasses are FileLibrary, GemLibrary, RequireLibrary and ModuleLibrary.
+  # subclasses are FileLibrary, GemLibrary, RequireLibrary, ModuleLibrary and LocalFileLibrary.
   # See Loader for callbacks a library's module can have.
   #
   # == Naming a Library Module
@@ -15,12 +15,15 @@ module Boson
   #   over the top level module and the top level module has to be prefixed with '::' _everywhere_.
   #
   # == Configuration
-  # To configure a library, pass a hash of {library attributes}[link:classes/Boson/Library.html#M000077] under
-  # {the :libraries key}[link:classes/Boson/Repo.html#M000070] of a config file. When not using FileLibrary,
-  # you can give most commands the functionality FileLibrary naturally gives its commands by configuring
-  # the :commands key. Here's a config example of a GemLibrary that does that:
-  #   :libraries:
-  #     httparty:
+  # Libraries and their commands can be configured in different ways in this order:
+  # * If library is a FileLibrary, commands be configured with a config method attribute (see Inspector).
+  # * If a library has a module, you can set library + command attributes via the config() callback (see Loader).
+  # * All libraries can be configured by passing a hash of {library attributes}[link:classes/Boson/Library.html#M000077] under
+  #   {the :libraries key}[link:classes/Boson/Repo.html#M000070] to the main config file ~/.boson/config/boson.yml.
+  #   For most libraries this may be the only way to configure a library's commands.
+  #   An example of a GemLibrary config:
+  #    :libraries:
+  #      httparty:
   #       :class_commands:
   #         delete: HTTParty.delete
   #       :commands:
@@ -28,6 +31,9 @@ module Boson
   #           :alias: d
   #           :description: Http delete a given url
   #
+  # When installing a third-party library, use the config file as a way to override default library and command attributes
+  # without modifying the library.
+  #
   # === Creating Your Own Library
   # To create your own subclass you need to define what sources the subclass can handle with handles().
   # If handles() returns true then the subclass is chosen to load. See Loader to see what instance methods
@@ -81,7 +87,7 @@ module Boson
     def initialize(hash)
       repo = set_repo
       @repo_dir = repo.dir
-      @name = set_name hash.delete(:name)
+      @name = set_name(hash.delete(:name)) or raise ArgumentError, "Library missing required key :name"
       @loaded = false
       @commands_hash = {}
       @commands = []
@@ -117,7 +123,7 @@ module Boson
     end
 
     def set_name(name)
-      name.to_s or raise ArgumentError, "New library missing required key :name"
+      name.to_s
     end
 
     def set_config(config, force=false)

data/lib/boson/loader.rb

@@ -2,9 +2,9 @@ module Boson
   # Raised if a library has a method which conflicts with existing methods in Boson.main_object.
   class MethodConflictError < LoaderError; end
 
-  # This module is mixed into Library to give it load() and reload() functionality.
-  # When creating your own Library subclass, you should override load_source_and_set_module and
-  # reload_source_and_set_module . You can override other methods in this module as needed.
+  # This module is mixed into Library to give it load() functionality.
+  # When creating your own Library subclass, you should override load_source_and_set_module
+  # You can override other methods in this module as needed.
   #
   # === Module Callbacks
   # For libraries that have a module i.e. FileLibrary and GemLibrary, the following class methods
@@ -47,21 +47,6 @@ module Boson
       !!@module
     end
 
-    # Reloads a library from its source and adds new commands. Only implemented
-    # for FileLibrary for now.
-    def reload
-      original_commands = @commands
-      reload_source_and_set_module
-      detect_additions { load_module_commands } if @new_module
-      @new_commands = @commands - original_commands
-      true
-    end
-
-    # Same as load_source_and_set_module except it reloads.
-    def reload_source_and_set_module
-      raise LoaderError, "Reload not implemented"
-    end
-
     #:stopdoc:
     def module_callbacks
       set_config(@module.config) if @module.respond_to?(:config)

data/lib/boson/manager.rb

@@ -4,7 +4,7 @@ module Boson
   # Raised when a library's append_features returns false.
   class AppendFeaturesFalseError < StandardError; end
 
-  # Handles loading and reloading of libraries and commands.
+  # Handles loading of libraries and commands.
   class Manager
     class <<self
       attr_accessor :failed_libraries
@@ -23,28 +23,6 @@ module Boson
         }.all?
       end
 
-      # Reloads a library or an array of libraries with the following options:
-      # * :verbose: Boolean to print reload status. Default is false.
-      def reload(source, options={})
-        if (lib = Boson.library(source))
-          if lib.loaded
-            command_size = Boson.commands.size
-            @options = options
-            if (result = rescue_load_action(lib.name, :reload) { lib.reload })
-              after_reload(lib)
-              puts "Reloaded library #{source}: Added #{Boson.commands.size - command_size} commands" if options[:verbose]
-            end
-            result
-          else
-            puts "Library hasn't been loaded yet. Loading library #{source}..." if options[:verbose]
-            load(source, options)
-          end
-        else
-          puts "Library #{source} doesn't exist." if options[:verbose]
-          false
-        end
-      end
-
       #:stopdoc:
       def failed_libraries
         @failed_libraries ||= []
@@ -123,11 +101,6 @@ module Boson
         true
       end
 
-      def after_reload(lib)
-        Boson.commands.delete_if {|e| e.lib == lib.name } if lib.new_module
-        create_commands(lib, lib.new_commands)
-      end
-
       def before_create_commands(lib)
         lib.is_a?(FileLibrary) && lib.module && Inspector.add_method_data_to_library(lib)
       end
@@ -136,17 +109,17 @@ module Boson
         before_create_commands(lib)
         commands.each {|e| Boson.commands << Command.create(e, lib)}
         create_command_aliases(lib, commands) if commands.size > 0 && !lib.no_alias_creation
-        create_option_commands(lib, commands)
+        redefine_commands(lib, commands)
       end
 
-      def create_option_commands(lib, commands)
+      def redefine_commands(lib, commands)
         option_commands = lib.command_objects(commands).select {|e| e.option_command? }
         accepted, rejected = option_commands.partition {|e| e.args(lib) || e.arg_size }
         if @options[:verbose] && rejected.size > 0
           puts "Following commands cannot have options until their arguments are configured: " +
             rejected.map {|e| e.name}.join(', ')
         end
-        accepted.each {|cmd| Scientist.create_option_command(lib.namespace_object, cmd) }
+        accepted.each {|cmd| Scientist.redefine_command(lib.namespace_object, cmd) }
       end
 
       def create_command_aliases(lib, commands)

data/lib/boson/option_command.rb

@@ -0,0 +1,204 @@
+require 'shellwords'
+module Boson
+  # A class used by Scientist to wrap around Command objects. It's main purpose is to parse
+  # a command's global options (basic options, render options, pipe options) and local options.
+  # As the names imply, global options are available to all commands while local options are specific to a command.
+  # When passing options to commands, global ones _must_ be passed first, then local ones.
+  # For more about pipe and render options see Pipe and View respectively.
+  #
+  # === Basic Global Options
+  # Any command with options comes with basic global options. For example '-hv' on an option command
+  # prints a help summarizing global and local options. Another basic global option is --pretend. This
+  # option displays what global options have been parsed and the actual arguments to be passed to a
+  # command if executed. For example:
+  #
+  #   # Define this command in a library
+  #   options :level=>:numeric, :verbose=>:boolean
+  #   def foo(*args)
+  #     args
+  #   end
+  #
+  #   irb>> foo 'testin -p -l=1'
+  #   Arguments: ["testin", {:level=>1}]
+  #   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'
+  #   # is the same as
+  #   foo ' -g "p fields=f1,f2" -l=1 '
+  #
+  # === 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
+  # output done with View and Hirb[http://github.com/cldwalker/hirb].
+  #
+  # Here's a simple example of 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'  # or list --render
+  #   +-------+
+  #   | value |
+  #   +-------+
+  #   | 1     |
+  #   | 2     |
+  #   | 3     |
+  #   +-------+
+  #   3 rows in set
+  #   => true
+  class OptionCommand
+    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"},
+    } #: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"},
+    } #:nodoc:
+
+    PIPE_OPTIONS = {
+      :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:
+
+    class <<self
+      #:stopdoc:
+      def default_option_parser
+        @default_option_parser ||= OptionParser.new default_pipe_options.
+          merge(default_render_options.merge(BASIC_OPTIONS))
+      end
+
+      def default_pipe_options
+        @default_pipe_options ||= PIPE_OPTIONS.merge Pipe.pipe_options
+      end
+
+      def default_render_options
+        @default_render_options ||= RENDER_OPTIONS.merge Boson.repo.config[:render_options] || {}
+      end
+
+      def delete_non_render_options(opt)
+        opt.delete_if {|k,v| BASIC_OPTIONS.keys.include?(k) }
+      end
+      #:startdoc:
+    end
+
+    attr_accessor :command
+    def initialize(cmd)
+      @command = cmd
+    end
+
+    # Parses arguments and returns global options, local options and leftover arguments.
+    def parse(args)
+      if args.size == 1 && args[0].is_a?(String)
+        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)
+        global_opt, parsed_options, new_args = parse_options temp_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))
+          global_opt, parsed_options = parse_options([])[0,2]
+      # merge default options with given hash of options
+      elsif (@command.has_splat_args? || (args.size == @command.arg_size)) && args[-1].is_a?(Hash)
+        global_opt, parsed_options = parse_options([])[0,2]
+        parsed_options.merge!(args.pop)
+      end
+      [global_opt || {}, parsed_options, args]
+    end
+
+    #: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
+      [global_options, parsed_options, new_args]
+    end
+
+    def option_parser
+      @option_parser ||= @command.render_options ? OptionParser.new(all_global_options) :
+        self.class.default_option_parser
+    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
+      }
+      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)
+      set_global_option_defaults opts
+    end
+
+    def set_global_option_defaults(opts)
+      if !opts[:fields].key?(:values)
+        if opts[:fields][:default]
+          opts[:fields][:values] = opts[:fields][:default]
+        else
+          if opts[:change_fields] && (changed = opts[:change_fields][:default])
+            opts[:fields][:values] = changed.is_a?(Array) ? changed : changed.values
+          end
+          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
+
+    def prepend_default_option(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
+    end
+
+    def check_argument_size(args)
+      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
+    end
+
+    def add_default_args(args, obj)
+      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 Scientist::Error, "Unable to set default argument at position #{i+1}.\nReason: #{$!.message}"
+          end
+        }
+      end
+    end
+    #:startdoc:
+  end
+end

data/lib/boson/option_parser.rb

@@ -35,7 +35,7 @@ module Boson
   #   String, Integer, Float, Array, Hash, FalseClass, TrueClass.
   # * Users can define their own option types which create objects for _any_ Ruby class. See Options.
   # * Each option type can have attributes to enable more features (see OptionParser.new).
-  # * When options are parsed by OptionParser.parse, an IndifferentAccessHash hash is returned.
+  # * When options are parsed by parse(), an IndifferentAccessHash hash is returned.
   # * Options are also called switches, parameters, flags etc.
   #
   # Default option types:
@@ -79,6 +79,17 @@ 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.
+    def self.parse(options, args=ARGV)
+      (@opt_parser ||= new(options)).parse(args)
+    end
+
+    # Usage string summarizing options defined in parse
+    def self.usage
+      @opt_parser.to_s
+    end
+
     # Array of arguments left after defined options have been parsed out by parse.
     def non_opts
       leading_non_opts + trailing_non_opts
@@ -134,7 +145,7 @@ 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
+    # [*: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.
     def initialize(opts)
       @defaults = {}

data/lib/boson/options.rb

@@ -7,7 +7,7 @@ module Boson
   #   # Drop this in your ~/.irbrc after require 'boson'
   #   module Boson::Options::Date
   #     def create_date(value)
-  #       # value_shift should be mm/dd
+  #       # value should be mm/dd
   #       Date.parse(value + "/#{Date.today.year}")
   #     end
   #   end