boson 0.0.1

data/lib/boson/runners/bin_runner.rb

@@ -0,0 +1,100 @@
+module Boson
+  class BinRunner < Runner
+    GLOBAL_OPTIONS =  {
+      :verbose=>{:type=>:boolean, :desc=>"Verbose description of loading libraries or help"},
+      :index=>{:type=>:boolean, :desc=>"Updates index"},
+      :execute=>{:type=>:string, :desc=>"Executes given arguments as a one line script"},
+      :repl=>{:type=>:boolean, :desc=>"Drops into irb or another given repl/shell 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"}
+    }
+
+    class <<self
+      attr_accessor :command
+      def start(args=ARGV)
+        @command, @options, @args = parse_args(args)
+        return print_usage if args.empty? || (@command.nil? && !@options[:repl] && !@options[:execute])
+        return ReplRunner.bin_start(@options[:repl], @options[:load]) if @options[:repl]
+        init
+
+        if @options[:help]
+          print_command_help
+        elsif @options[:execute]
+          Boson.main_object.instance_eval @options[:execute]
+        else
+          execute_command
+        end
+      rescue Exception
+        message = (@command && !Boson.can_invoke?(@command)) ?
+          "Error: Command '#{@command}' not found" : "Error: #{$!.message}"
+        message += "\nActual error: #{$!}\n" + $!.backtrace.inspect if @options && @options[:verbose]
+        $stderr.puts message
+      end
+
+      def init
+        super
+        Index.update(:verbose=>true) if @options[:index]
+        if @options[:load]
+          Manager.load @options[:load], load_options
+        elsif @options[:execute]
+          define_autoloader
+        else
+          load_command_by_index
+        end
+      end
+
+      def load_command_by_index
+        Index.update(:verbose=>@options[:verbose]) if !@options[:index] && Boson.can_invoke?(@command) && !@options[:help]
+        if !Boson.can_invoke?(@command) && ((lib = Index.find_library(@command)) ||
+          (Index.update(:verbose=>@options[:verbose]) && (lib = Index.find_library(@command))))
+          Manager.load lib, load_options
+        end
+      end
+
+      def default_libraries
+        super + (Boson.repo.config[:bin_defaults] || [])
+      end
+
+      def execute_command
+        command, subcommand = @command.include?('.') ? @command.split('.', 2) : [@command, nil]
+        dispatcher = subcommand ? Boson.invoke(command) : Boson.main_object
+        @args = @args.join(" ") if ((com = Boson::Command.find(@command)) && com.option_command?)
+        render_output dispatcher.send(subcommand || command, *@args)
+      rescue ArgumentError
+        puts "Wrong number of arguments for #{@command}\n\n"
+        print_command_help
+      end
+
+      def print_command_help
+        Boson.invoke(:usage, @command, :verbose=>@options[:verbose])
+      end
+
+      def parse_args(args)
+        @option_parser = OptionParser.new(GLOBAL_OPTIONS)
+        options = @option_parser.parse(args.dup, :opts_before_args=>true)
+        new_args = @option_parser.non_opts
+        [new_args.shift, options, new_args]
+      end
+
+      def render_output(output)
+        if Scientist.global_options
+          puts output.inspect unless Scientist.rendered
+        else
+          View.render(output)
+        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
+    end
+  end
+end

data/lib/boson/runners/repl_runner.rb

@@ -0,0 +1,40 @@
+module Boson
+  class ReplRunner < Runner
+    class <<self
+      def start(options={})
+        @options = options
+        init unless @initialized
+        Manager.load(@options[:libraries], load_options) if @options[:libraries]
+      end
+
+      def init
+        super
+        define_autoloader if @options[:autoload_libraries]
+        @initialized = true
+      end
+
+      def bin_start(repl, libraries)
+        start :no_defaults=>true, :libraries=>libraries
+        repl = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb' unless repl.is_a?(String)
+        unless repl.index('/') == 0 || (repl = Util.which(repl))
+          $stderr.puts "Repl not found. Please specify full path of repl."
+          return
+        end
+        ARGV.replace ['-f']
+        Kernel.load $0 = repl
+      end
+
+      def default_libraries
+        defaults = super
+        unless @options[:no_defaults]
+          new_defaults = Boson.repos.map {|e| e.config[:defaults] }.flatten
+          new_defaults = detected_libraries if new_defaults.empty?
+          defaults += new_defaults
+          defaults.uniq!
+        end
+        defaults
+      end
+    end
+  end
+end
+  

data/lib/boson/scientist.rb

@@ -0,0 +1,168 @@
+require 'shellwords'
+module Boson
+  module Scientist
+    extend self
+    class Error < StandardError; end
+    class EscapeGlobalOption < StandardError; end
+    attr_reader :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 render behavior"},
+      :verbose=>{:type=>:boolean, :desc=>"Increase verbosity for help, errors, etc."},
+      :global=>{:type=>:string, :desc=>"Pass a string of global options without the dashes i.e. '-p -f=f1,f2' -> 'p f=f1,f2'"},
+      :pretend=>{:type=>:boolean, :desc=>"Display what a command would execute without executing it"}
+    }
+    RENDER_OPTIONS = {
+      :fields=>{:type=>:array, :desc=>"Displays fields in the order given"},
+      :sort=>{:type=>:string, :desc=>"Sort by given field"},
+      :as=>{:type=>:string, :desc=>"Hirb helper class which renders"},
+      :reverse_sort=>{:type=>:boolean, :desc=>"Reverse a given sort"},
+      :max_width=>{:type=>:numeric, :desc=>"Max width of a table"},
+      :vertical=>{:type=>:boolean, :desc=>"Display a vertical table"}
+    }
+
+    def create_option_command(obj, command)
+      cmd_block = create_option_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
+
+    def create_option_command_block(obj, command)
+      lambda {|*args|
+        Boson::Scientist.translate_and_render(obj, command, args) {|args| super(*args) }
+      }
+    end
+
+    def translate_and_render(obj, command, args)
+      @global_options = {}
+      args = translate_args(obj, command, args)
+      if @global_options[:verbose] || @global_options[:pretend]
+        puts "Arguments: #{args.inspect}", "Global options: #{@global_options.inspect}"
+      end
+      return @rendered = true if @global_options[:pretend]
+      render_or_raw yield(args)
+    rescue EscapeGlobalOption
+      Boson.invoke(:usage, command.name, :verbose=>@global_options[:verbose]) if @global_options[:help]
+    rescue OptionParser::Error, Error
+      $stderr.puts "Error: " + $!.message
+    end
+
+    def translate_args(obj, command, args)
+      @obj, @command, @args = obj, command, args
+      @command.options ||= {}
+      if parsed_options = 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 > command.arg_size ? command.arg_size : command.arg_size - 1
+          if @args.size - 1 == command_size
+            raise Error, "Arguments are misaligned. Possible causes are incorrect argument "+
+              "size or no argument for this method's options."
+          else
+            raise ArgumentError, "wrong number of arguments (#{@args.size - 1} for #{command_size})"
+          end
+        end
+      end
+      @args
+    rescue Error, ArgumentError, EscapeGlobalOption
+      raise
+    rescue Exception
+      message = @global_options[:verbose] ? "#{$!}\n#{$!.backtrace.inspect}" : $!.message
+      raise Error, message
+    end
+
+    def render_or_raw(result)
+      (@rendered = render?) ? View.render(result, global_render_options) : result
+    rescue Exception
+      message = @global_options[:verbose] ? "#{$!}\n#{$!.backtrace.inspect}" : $!.message
+      raise Error, message
+    end
+
+    def option_parser
+      @command.render_options ? command_option_parser : default_option_parser
+    end
+
+    def command_option_parser
+      (@option_parsers ||= {})[@command] ||= OptionParser.new render_options.merge(GLOBAL_OPTIONS)
+    end
+
+    def render_option_parser(cmd)
+      @command = cmd
+      option_parser
+    end
+
+    def default_option_parser
+      @default_option_parser ||= OptionParser.new RENDER_OPTIONS.merge(GLOBAL_OPTIONS)
+    end
+
+    def render_options
+      @command.render_options ? command_render_options : RENDER_OPTIONS
+    end
+
+    def command_render_options
+      (@command_render_options ||= {})[@command] ||= begin
+        @command.render_options.each {|k,v|
+          if !v.is_a?(Hash) && !v.is_a?(Symbol) && RENDER_OPTIONS.keys.include?(k)
+            @command.render_options[k] = {:default=>v}
+          end
+        }
+        opts = Util.recursive_hash_merge(@command.render_options, RENDER_OPTIONS)
+        opts[:sort][:values] ||= opts[:fields][:values] if opts[:fields][:values]
+        opts
+      end
+    end
+
+    def global_render_options
+      @global_options.dup.delete_if {|k,v| !render_options.keys.include?(k) }
+    end
+
+    def render?
+      (@command.render_options && !@global_options[:render]) || (!@command.render_options && @global_options[:render])
+    end
+
+    def 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)
+        parsed_options, new_args = parse_options @args.pop.split(/\s+/)
+        @args += new_args
+      # default options
+      elsif (@args.size <= @command.arg_size - 1) || (@command.has_splat_args? && !@args[-1].is_a?(Hash))
+        parsed_options = parse_options([])[0]
+      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.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
+    end
+  end
+end

data/lib/boson/util.rb

@@ -0,0 +1,93 @@
+module Boson
+  module Util
+    extend self
+    #From Rails ActiveSupport
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+       gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+       gsub(/([a-z\d])([A-Z])/,'\1_\2').
+       tr("-", "_").
+       downcase
+    end
+
+    # from Rails ActiveSupport
+    def camelize(string)
+      string.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+    
+    def constantize(string)
+      any_const_get(camelize(string))
+    end
+
+    def symbolize_keys(hash)
+      hash.inject({}) {|options, (key, value)|
+        options[key.to_sym] = value; options
+      }
+    end
+
+    # Returns a constant like const_get() no matter what namespace it's nested in.
+    # Returns nil if the constant is not found.
+    def any_const_get(name)
+      return name if name.is_a?(Module)
+      begin
+        klass = Object
+        name.split('::').each {|e|
+          klass = klass.const_get(e)
+        }
+        klass
+      rescue
+         nil
+      end
+    end
+
+    def detect(options={}, &block)
+      options = {:methods=>true, :object_methods=>true}.merge!(options)
+      original_gems = Gem.loaded_specs.keys if Object.const_defined? :Gem
+      original_object_methods = Object.instance_methods
+      original_instance_methods = class << Boson.main_object; instance_methods end
+      original_modules = modules if options[:modules]
+      block.call
+      detected = {}
+      detected[:methods] = options[:methods] ? (class << Boson.main_object; instance_methods end -
+        original_instance_methods) : []
+      detected[:methods] -= (Object.instance_methods - original_object_methods) unless options[:object_methods]
+      detected[:gems] = Gem.loaded_specs.keys - original_gems if Object.const_defined? :Gem
+      detected[:modules] = modules - original_modules if options[:modules]
+      detected
+    end
+
+    def safe_require(lib)
+      begin
+        require lib
+      rescue LoadError
+        false
+      end
+    end
+
+    def modules
+      all_modules = []
+      ObjectSpace.each_object(Module) {|e| all_modules << e}
+      all_modules
+    end
+
+    def common_instance_methods(module1, module2)
+      (module1.instance_methods + module1.private_instance_methods) & (module2.instance_methods + module2.private_instance_methods)
+    end
+
+    def create_module(base_module, name)
+      desired_class = camelize(name)
+      if (suffix = ([""] + (1..10).to_a).find {|e| !base_module.const_defined?(desired_class+e)})
+        base_module.const_set(desired_class+suffix, Module.new)
+      end
+    end
+
+    def which(command)
+      ENV['PATH'].split(File::PATH_SEPARATOR).map {|e| File.join(e, command) }.find {|e| File.exists?(e) }
+    end
+
+    # Recursively merge hash1 with hash2.
+    def recursive_hash_merge(hash1, hash2)
+      hash1.merge(hash2) {|k,o,n| (o.is_a?(Hash)) ? recursive_hash_merge(o,n) : n}
+    end
+  end
+end

data/lib/boson/view.rb

@@ -0,0 +1,31 @@
+module Boson
+  module View
+    extend self
+
+    def enable
+      Hirb::View.enable(:config_file=>File.join(Boson.repo.config_dir, 'hirb.yml')) unless @enabled
+      @enabled = true
+    end
+
+    def render(object, options={})
+      [nil,false,true].include?(object) ? puts(object.inspect) : render_object(object, options)
+    end
+
+    def render_object(object, options={})
+      options[:class] = options.delete(:as) || :auto_table
+      if object.is_a?(Array) && object.size > 0 && (sort = options.delete(:sort))
+        begin
+          sort_lambda = object[0].is_a?(Hash) ? (object[0][sort].respond_to?(:<=>) ?
+            lambda {|e| e[sort] } : lambda {|e| e[sort].to_s }) :
+            (object[0].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 options[:reverse_sort]
+        rescue NoMethodError, ArgumentError
+          $stderr.puts "Sort failed with nonexistant method '#{sort}'"
+        end
+      end
+      Hirb::Console.render_output(object, options)
+    end
+  end
+end

data/test/argument_inspector_test.rb

@@ -0,0 +1,62 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+module Boson
+  class ArgumentInspectorTest < Test::Unit::TestCase
+    context "scrape_with_text" do
+      def args_from(file_string)
+        ArgumentInspector.scrape_with_text(file_string, "blah")
+      end
+
+      test "parses arguments with no spacing" do
+        args_from("def bong; end\ndef blah(arg1,arg2='val2')\nend").should == [["arg1"], ['arg2', "'val2'"]]
+      end
+
+      test "parses arguments with spacing" do
+        args_from("\t def blah(  arg1=val1, arg2 = val2)").should == [["arg1","val1"], ["arg2", "val2"]]
+      end
+
+      test "parses arguments without parenthesis" do
+        args_from(" def blah arg1, arg2, arg3={}").should == [['arg1'], ['arg2'], ['arg3','{}']]
+      end
+    end
+
+    context "scrape_with_eval" do
+      def args_from(string)
+        # methods need options to have their args parsed with ArgumentInspector
+        string.gsub!(/(def blah)/, 'options :a=>1; \1')
+        Inspector.enable
+        ::Boson::Commands::Aaa.module_eval(string)
+        Inspector.disable
+        MethodInspector.store[:method_args]['blah']
+      end
+
+      before(:all) { eval "module ::Boson::Commands::Aaa; end"; }
+      before(:each) { MethodInspector.mod_store[::Boson::Commands::Aaa] = {} }
+
+      test "determines arguments with literal defaults" do
+        args_from("def blah(arg1,arg2='val2'); end").should == [['arg1'], ['arg2','val2']]
+      end
+
+      test "determines splat arguments" do
+        args_from("def blah(arg1, *args); end").should == [['arg1'], ["*args"]]
+      end
+
+      test "determines arguments with local values before a method" do
+        body = "AWESOME='awesome'; def sweet; 'ok'; end; def blah(arg1=AWESOME, arg2=sweet); end"
+        args_from(body).should == [['arg1', 'awesome'], ['arg2', 'ok']]
+      end
+
+      test "doesn't get arguments with local values after a method" do
+        args_from("def blah(arg1=nope) end; def nope; 'nope'; end").should == nil
+      end
+
+      test "doesn't determine arguments of a private method" do
+        args_from("private; def blah(arg1,arg2); end").should == nil
+      end
+
+      test "doesn't determine arguments if an error occurs" do
+        args_from("def blah(arg1,arg2=raise); end").should == nil
+      end
+    end
+  end
+end