bosonson 0.304.1

data/lib/boson/repo_index.rb

@@ -0,0 +1,124 @@
+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? ?
+        File.open( marshal_file, 'rb' ){|f| Marshal.load( f.read ) } : [[], [], {}]
+      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, 'wb') {|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, object=false)
+      read
+      namespace_command = command.split(NAMESPACE)[0]
+      if (lib = @libraries.find {|e| e.namespace == namespace_command })
+        object ? lib : lib.name
+      elsif (cmd = Command.find(command, @commands))
+        object ? @libraries.find {|e| e.name == cmd.lib} : 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

@@ -0,0 +1,81 @@
+module Boson
+  # Base class for runners.
+  class Runner
+    class<<self
+      attr_accessor :debug
+
+      # Enables view, adds local load path and loads default_libraries
+      def init
+        View.enable
+        add_load_path
+        Manager.load default_libraries, load_options
+      end
+
+      # Libraries that come with Boson
+      def default_libraries
+        Boson.repos.map {|e| e.config[:defaults] || [] }.flatten + [Boson::Commands::Core, Boson::Commands::WebCore]
+      end
+
+      # Libraries detected in repositories
+      def detected_libraries
+        Boson.repos.map {|e| e.detected_libraries }.flatten.uniq
+      end
+
+      # Libraries specified in config files and detected_libraries
+      def all_libraries
+        Boson.repos.map {|e| e.all_libraries }.flatten.uniq
+      end
+
+      # Returns true if commands are being executed from a non-ruby shell i.e. bash. Returns false if
+      # in a ruby shell i.e. irb.
+      def in_shell?
+        !!@in_shell
+      end
+
+      # Returns true if in commandline with verbose flag or if set explicitly. Useful in plugins.
+      def verbose?
+        @verbose.nil? ? Boson.const_defined?(:BinRunner) && BinRunner.options[:verbose] : @verbose
+      end
+
+      #:stopdoc:
+      def verbose=(val)
+        @verbose = val
+      end
+
+      def in_shell=(val)
+        @in_shell = val
+      end
+
+      def add_load_path
+        Boson.repos.each {|repo|
+          if repo.config[:add_load_path] || File.exists?(File.join(repo.dir, 'lib'))
+            $: <<  File.join(repo.dir, 'lib') unless $:.include? File.expand_path(File.join(repo.dir, 'lib'))
+          end
+        }
+      end
+
+      def load_options
+        {:verbose=>@options[:verbose]}
+      end
+
+      def autoload_command(cmd, opts={:verbose=>verbose?})
+        Index.read
+        (lib = Index.find_library(cmd)) && Manager.load(lib, opts)
+        lib
+      end
+
+      def define_autoloader
+        class << ::Boson.main_object
+          def method_missing(method, *args, &block)
+            if Runner.autoload_command(method.to_s)
+              send(method, *args, &block) if respond_to?(method)
+            else
+              super
+            end
+          end
+        end
+      end
+      #:startdoc:
+    end
+  end
+end

data/lib/boson/runners/bin_runner.rb

@@ -0,0 +1,208 @@
+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

@@ -0,0 +1,58 @@
+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
+