boson 0.4.0 → 1.0.0

data/lib/boson/util.rb

@@ -2,7 +2,7 @@ module Boson
   # Collection of utility methods used throughout Boson.
   module Util
     extend self
-    # From Rails ActiveSupport, converts a camelcased string to an underscored string:
+    # From ActiveSupport, converts a camelcased string to an underscored string:
     # 'Boson::MethodInspector' -> 'boson/method_inspector'
     def underscore(camel_cased_word)
       camel_cased_word.to_s.gsub(/::/, '/').
@@ -12,10 +12,11 @@ module Boson
        downcase
     end
 
-    # From Rails ActiveSupport, does the reverse of underscore:
+    # From ActiveSupport, does the reverse of underscore:
     # 'boson/method_inspector' -> 'Boson::MethodInspector'
     def camelize(string)
-      Hirb::Util.camelize(string)
+      string.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.
+        gsub(/(?:^|_)(.)/) { $1.upcase }
     end
 
     # Converts a module/class string to the actual constant.
@@ -24,41 +25,43 @@ module Boson
       any_const_get(camelize(string))
     end
 
-    # Returns a constant like const_get() no matter what namespace it's nested in.
-    # Returns nil if the constant is not found.
+    # 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)
-      Hirb::Util.any_const_get(name)
+      return name if name.is_a?(Module)
+      klass = Object
+      name.split('::').each {|e|
+        klass = klass.const_get(e)
+      }
+      klass
+    rescue
+       nil
     end
 
-    # Detects new object/kernel methods, gems and modules created within a block.
-    # Returns a hash of what's detected.
-    # Valid options and possible returned keys are :methods, :object_methods, :modules, :gems.
+    # Detects new object/kernel methods, gems and modules created within a
+    # block. Returns a hash of what's detected. Valid options and possible
+    # returned keys are :methods, :object_methods, :modules, :gems.
     def detect(options={}, &block)
-      options = {:methods=>true, :object_methods=>true}.merge!(options)
-      original_gems = Object.const_defined?(:Gem) ? Gem.loaded_specs.keys : []
+      options = {methods: true}.merge!(options)
+      original_gems = defined?(Gem) ? Gem.loaded_specs.keys : []
       original_object_methods = Object.instance_methods
-      original_instance_methods = class << Boson.main_object; instance_methods end
+      original_instance_methods = Boson.main_object.singleton_class.instance_methods
       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[:methods] = options[:methods] ?
+        (Boson.main_object.singleton_class.instance_methods -
+           original_instance_methods) : []
+      unless options[:object_methods]
+        detected[:methods] -= (Object.instance_methods - original_object_methods)
+      end
+      detected[:gems] = Gem.loaded_specs.keys - original_gems if defined? Gem
       detected[:modules] = modules - original_modules if options[:modules]
       detected
     end
 
-    # Safely calls require, returning false if LoadError occurs.
-    def safe_require(lib)
-      begin
-        require lib
-        true
-      rescue LoadError
-        false
-      end
-    end
-
     # Returns all modules that currently exist.
     def modules
       all_modules = []
@@ -66,51 +69,23 @@ module Boson
       all_modules
     end
 
-    # Creates a module under a given base module and possible name. If the module already exists or conflicts
-    # per top_level_class_conflict, it attempts to create one with a number appended to the name.
+    # Creates a module under a given base module and possible name. If the
+    # module already exists, it attempts to create one with a number appended to
+    # the name.
     def create_module(base_module, name)
       desired_class = camelize(name)
       possible_suffixes = [''] + %w{1 2 3 4 5 6 7 8 9 10}
-      if (suffix = possible_suffixes.find {|e| !base_module.const_defined?(desired_class+e) &&
-        !top_level_class_conflict(base_module, "#{base_module}::#{desired_class}#{e}") })
-        base_module.const_set(desired_class+suffix, Module.new)
+      if suffix = possible_suffixes.find {|e|
+        !base_module.const_defined?(desired_class+e) }
+          base_module.const_set(desired_class+suffix, Module.new)
       end
     end
 
-    # Behaves just like the unix which command, returning the full path to an executable based on ENV['PATH'].
-    def which(command)
-      ENV['PATH'].split(File::PATH_SEPARATOR).map {|e| File.join(e, command) }.find {|e| File.exists?(e) }
-    end
-
-    # Deep copies any object if it can be marshaled. Useful for deep hashes.
-    def deep_copy(obj)
-      Marshal::load(Marshal::dump(obj))
-    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
 
-    # From Rubygems, determine a user's home.
-    def find_home
-      Hirb::Util.find_home
-    end
-
-    # Returns name of top level class that conflicts if it exists. For example, for base module Boson::Commands,
-    # Boson::Commands::Alias conflicts with Alias if Alias exists.
-    def top_level_class_conflict(base_module, conflicting_module)
-      (conflicting_module =~ /^#{base_module}.*::([^:]+)/) && Object.const_defined?($1) && $1
-    end
-
-    # Splits array into array of arrays with given element
-    def split_array_by(arr, divider)
-      arr.inject([[]]) {|results, element|
-        (divider == element) ? (results << []) : (results.last << element)
-        results
-      }
-    end
-
     # Regular expression search of a list with underscore anchoring of words.
     # For example 'some_dang_long_word' can be specified as 's_d_l_w'.
     def underscore_search(input, list, first_match=false)
@@ -118,12 +93,22 @@ module Boson
       return (first_match ? input : [input]) if list.include?(input)
       input = input.to_s
       if input.include?("_")
-        underscore_regex = input.split('_').map {|e| Regexp.escape(e) }.join("([^_]+)?_")
+        underscore_regex = input.split('_').map {|e|
+          Regexp.escape(e) }.join("([^_]+)?_")
         list.send(meth) {|e| e.to_s =~ /^#{underscore_regex}/ }
       else
         escaped_input = Regexp.escape(input)
         list.send(meth) {|e| e.to_s =~ /^#{escaped_input}/ }
       end
     end
+
+    def format_table(arr_of_arr)
+      name_max = arr_of_arr.map {|arr| arr[0].length }.max
+      desc_max = arr_of_arr.map {|arr| arr[1].length }.max
+
+      arr_of_arr.map do |name, desc|
+        ("  %-*s  %-*s" % [name_max, name, desc_max, desc]).rstrip
+      end
+    end
   end
 end

data/lib/boson/version.rb

@@ -1,3 +1,3 @@
 module Boson
-  VERSION = '0.4.0'
+  VERSION = '1.0.0'
 end

data/test/bin_runner_test.rb

@@ -1,223 +1,85 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
-require 'boson/runners/bin_runner'
+require 'boson/bin_runner'
 BinRunner = Boson::BinRunner
 
 describe "BinRunner" do
-  def start(*args)
-    Hirb.stubs(:enable)
-    BinRunner.start(args)
+  def aborts_with(regex)
+    BinRunner.expects(:abort).with {|e| e[regex] }
+    yield
   end
 
-  before {|e|
-    BinRunner.instance_variables.each {|e| BinRunner.instance_variable_set(e, nil)}
-  }
-  describe "at commandline" do
-    before_all { reset }
+  unless ENV['FAST'] ||
+    # disable rubinius until Open3.spawn defined in Bahia
+    # disable jruby until Open3.spawn works with ENV in Bahia
+    RUBY_DESCRIPTION.include?('rubinius') || RUBY_PLATFORM[/java/]
 
-    it "no arguments prints usage" do
-      capture_stdout { start }.should =~ /^boson/
+    it "prints usage with no arguments" do
+      boson
+      stdout.should =~ /^boson/
     end
 
-    it "invalid option value prints error" do
-      aborts_with(/Error: no value/) { start("-l") }
-    end
-
-    it "help option but no arguments prints usage" do
-      capture_stdout { start '-h' }.should =~ /^boson/
-    end
-
-    it "help option and command prints help" do
-      capture_stdout { start('-h', 'commands') }.should =~ /^commands/
-    end
-
-    it "load option loads libraries" do
-      Manager.expects(:load).with {|*args| args[0][0].is_a?(Module) ? true : args[0][0] == 'blah'}.times(2)
-      BinRunner.stubs(:execute_command)
-      start('-l', 'blah', 'libraries')
-    end
-
-    it "console option starts irb" do
-      ConsoleRunner.expects(:start)
-      Util.expects(:which).returns("/usr/bin/irb")
-      ConsoleRunner.expects(:load_repl).with("/usr/bin/irb")
-      start("--console")
-    end
-
-    it "console option but no irb found prints error" do
-      ConsoleRunner.expects(:start)
-      Util.expects(:which).returns(nil)
-      ConsoleRunner.expects(:abort).with {|arg| arg[/Console not found/] }
-      start '--console'
-    end
-
-    it "execute option executes string" do
-      BinRunner.expects(:define_autoloader)
-      capture_stdout { start("-e", "p 1 + 1") }.should == "2\n"
-    end
-
-    it "global option takes value with whitespace" do
-      View.expects(:render).with {|*args| args[1][:fields] = %w{f1 f2} }
-      start('commands', '-f', 'f1, f2')
-    end
-
-    it "debug option sets Runner.debug" do
-      View.expects(:render)
-      start('-d', 'commands')
-      Runner.debug.should == true
-      Runner.debug = nil
-    end
-
-    it "ruby_debug option sets $DEBUG" do
-      View.expects(:render)
-      start('-D', 'commands')
-      $DEBUG.should == true
-      $DEBUG = nil
-    end
-
-    it "execute option errors are caught" do
-      aborts_with(/^Error:/) { start("-e", "raise 'blah'") }
-    end
-
-    it "option command and too many arguments prints error" do
-      capture_stdout {
-        aborts_with(/'commands'.*incorrect/) { start('commands','1','2','3') }
-      }
-    end
-
-    it "normal command and too many arguments prints error" do
-      capture_stdout {
-        aborts_with(/'render'.*incorrect/) { start('render') }
-      }
-    end
-
-    it "failed subcommand prints error and not command not found" do
-      BinRunner.expects(:execute_command).raises("bling")
-      aborts_with(/Error: bling/) { start("commands.to_s") }
-    end
-
-    it "nonexistant subcommand prints command not found" do
-      aborts_with(/'to_s.bling' not found/) { start("to_s.bling") }
-    end
-
-    it "undiscovered command prints error" do
-      BinRunner.expects(:autoload_command).returns(false)
-      aborts_with(/Error.*not found/) { start 'blah' }
-    end
-
-    it "with backtrace option prints backtrace" do
-      BinRunner.expects(:autoload_command).returns(false)
-      aborts_with(/not found\nOriginal.*runner\.rb:/m) { start("--backtrace", "blah") }
-    end
-
-    it "basic command executes" do
-      BinRunner.expects(:init).returns(true)
-      BinRunner.stubs(:render_output)
-      Boson.main_object.expects(:send).with('kick','it')
-      start 'kick','it'
-    end
-
-    it "sub command executes" do
-      obj = Object.new
-      Boson.main_object.extend Module.new { def phone; Struct.new(:home).new('done'); end }
-      BinRunner.expects(:init).returns(true)
-      BinRunner.expects(:render_output).with('done')
-      start 'phone.home'
-    end
-
-    it "bin_defaults config loads by default" do
-      defaults = Runner.default_libraries + ['yo']
-      with_config(:bin_defaults=>['yo']) do
-        Manager.expects(:load).with {|*args| args[0] == defaults }
-        aborts_with(/blah/) { start 'blah' }
+    it "prints usage with --help" do
+      %w{-h --help}.each do |option|
+        boson option
+        stdout.should =~ /^boson/
       end
     end
-  end
-
-  describe "autoload_command" do
-    def index(options={})
-      Manager.expects(:load).with {|*args| args[0][0].is_a?(Module) ? true : args[0] == options[:load]
-        }.at_least(1).returns(!options[:fails])
-      Index.indexes[0].expects(:write)
-    end
-
-    it "with index option, no existing index and core command updates index and prints index message" do
-      index :load=>Runner.all_libraries
-      Index.indexes[0].stubs(:exists?).returns(false)
-      capture_stdout { start("--index", "libraries") }.should =~ /Generating index/
-    end
 
-    it "with index option, existing index and core command updates incremental index" do
-      index :load=>['changed']
-      Index.indexes[0].stubs(:exists?).returns(true)
-      capture_stdout { start("--index=changed", "libraries")}.should =~ /Indexing.*changed/
+    it 'prints version with --version' do
+      boson '--version'
+      stdout.chomp.should == "boson #{Boson::VERSION}"
     end
 
-    it "with index option, failed indexing prints error" do
-      index :load=>['changed'], :fails=>true
-      Index.indexes[0].stubs(:exists?).returns(true)
-      Manager.stubs(:failed_libraries).returns(['changed'])
-      capture_stderr {
-        capture_stdout { start("--index=changed", "libraries")}.should =~ /Indexing.*changed/
-      }.should =~ /Error:.*failed.*changed/
-    end
-
-    it "with core command updates index and doesn't print index message" do
-      Index.indexes[0].expects(:write)
-      Boson.main_object.expects(:send).with('libraries')
-      capture_stdout { start 'libraries'}.should.not =~ /index/i
-    end
-
-    it "with non-core command not finding library, does update index" do
-      Index.expects(:find_library).returns(nil, 'sweet_lib')
-      Manager.expects(:load).with {|*args| args[0].is_a?(String) ? args[0] == 'sweet_lib' : true}.at_least(1)
-      Index.indexes[0].expects(:update).returns(true)
-      aborts_with(/sweet/) { start 'sweet' }
+    it "executes string with --execute" do
+      %w{--execute -e}.each do |option|
+        boson "#{option} 'print 1 + 1'"
+        stdout.should == '2'
+      end
     end
-  end
 
-  describe "render_output" do
-    before { Scientist.rendered = false; BinRunner.instance_eval "@options = {}" }
-
-    it "doesn't render when nil, false or true" do
-      View.expects(:render).never
-      [nil, false, true].each do |e|
-        BinRunner.render_output e
+    it "sets $DEBUG with --ruby-debug" do
+      %w{--ruby_debug -D}.each do |option|
+        boson "#{option} -e 'print $DEBUG'"
+        stdout.should == 'true'
       end
     end
 
-    it "doesn't render when rendered with Scientist" do
-      Scientist.rendered = true
-      View.expects(:render).never
-      BinRunner.render_output 'blah'
+    # TODO: test actual uses of Runner.debug
+    it "sets Boson.debug with --debug" do
+      boson "--debug -e 'print Boson.debug'"
+      stdout.should == 'true'
     end
 
-    it "render with puts when non-string" do
-      View.expects(:render).with('dude', {:method => 'puts'})
-      BinRunner.render_output 'dude'
+    it "prepends to $: with --load_path" do
+      %w{--load_path -I}.each do |option|
+        boson "#{option}=lib -e 'print $:[0]'"
+        stdout.should == 'lib'
+      end
     end
 
-    it "renders with inspect when non-array and non-string" do
-      [{:a=>true}, :ok].each do |e|
-        View.expects(:puts).with(e.inspect)
-        BinRunner.render_output e
-      end
+    it "prints error for unexpected error" do
+      boson %[-e 'raise "blarg"']
+      stderr.chomp.should == "Error: blarg"
+      process.success?.should == false
     end
 
-    it "renders with inspect when Scientist rendering toggled off with :render" do
-      Scientist.global_options = {:render=>true}
-      View.expects(:puts).with([1,2].inspect)
-      BinRunner.render_output [1,2]
-      Scientist.global_options = nil
+    # TODO: enable once bin runner's fate is decided
+    xit "prints error for too many arguments" do
+      boson "commands 1 2 3"
+      stderr.should =~ /^'commands' was called incorrectly/
+      process.success?.should == false
     end
 
-    it "renders with hirb when array" do
-      View.expects(:render_object)
-      BinRunner.render_output [1,2,3]
+    # TODO: possible error with persistance extraction
+    xit "prints error for invalid command" do
+      boson 'blarg'
+      stderr.chomp.should == "Error: Command 'blarg' not found"
+      process.success?.should == false
     end
   end
 
-  it "parse_args only translates options before command" do
-    BinRunner.parse_args(['-v', 'com', '-v']).should == ["com", {:verbose=>true}, ['-v']]
-    BinRunner.parse_args(['com', '-v']).should == ["com", {}, ['-v']]
+  it ".parse_args only translates options before command" do
+    BinRunner.send(:parse_args, ['-d', 'com', '-v']).should == ["com", {debug: true}, ['-v']]
+    BinRunner.send(:parse_args, ['com', '-v']).should == ["com", {}, ['-v']]
   end
 end