boson 0.4.0 → 1.0.0

data/lib/boson/view.rb

@@ -1,95 +0,0 @@
-module Boson
-  # This module generates views for a command by handing it to {Hirb}[http://tagaholic.me/hirb/]. Since Hirb can be customized
-  # to generate any view, commands can have any views associated with them!
-  #
-  # === Views with Render Options
-  # To pass rendering options to a Hirb helper as command options, a command has to define the options with
-  # the render_options method attribute:
-  #
-  #   # @render_options :fields=>[:a,:b]
-  #   def list(options={})
-  #     [{:a=>1, :b=>2}, {:a=>10,:b=>11}]
-  #   end
-  #
-  #   # To see that the render_options method attribute actually passes the :fields option by default:
-  #   >> list '-p'   # or list '--pretend'
-  #   Arguments: []
-  #   Global options: {:pretend=>true, :fields=>[:a, :b]}
-  #
-  #   >> list
-  #   +----+----+
-  #   | a  | b  |
-  #   +----+----+
-  #   | 1  | 2  |
-  #   | 10 | 11 |
-  #   +----+----+
-  #   2 rows in set
-  #
-  #   # To create a vertical table, we can pass --vertical, one of the default global render options.
-  #   >> list '-V'   # or list '--vertical'
-  #   *** 1. row ***
-  #   a: 1
-  #   b: 2
-  #   ...
-  #
-  #   # To get the original return value use the global option --render
-  #   >> list '-r'  # or list '--render'
-  #   => [{:a=>1, :b=>2}, {:a=>10,:b=>11}]
-  #
-  # === Boson and Hirb
-  # Since Boson uses {Hirb's auto table helper}[http://tagaholic.me/hirb/doc/classes/Hirb/Helpers/AutoTable.html]
-  # by default, you may want to read up on its many options. To use any of them in commands, define them locally
-  # with render_options or globally by adding them under the :render_options key of the main config.
-  # What if you want to use your own helper class? No problem. Simply pass it with the global :class option.
-  #
-  # When using the default helper, one of the most important options to define is :fields. Aside from controlling what fields
-  # are displayed, it's used to set :values option attributes for related options i.e. :sort and :query. This provides handy option
-  # value aliasing via OptionParser. If you don't set :fields, Boson will try to set its :values with field-related options i.e.
-  # :change_fields, :filters and :headers.
-  module View
-    extend self
-
-    # Enables hirb and reads a config file from the main repo's config/hirb.yml.
-    def enable
-      unless @enabled
-        Hirb::View.enable(:config_file=>File.join(Boson.repo.config_dir, 'hirb.yml'))
-        Hirb::Helpers::Table.filter_any = true
-      end
-      @enabled = true
-    end
-
-    # Renders any object via Hirb. Options are passed directly to
-    # {Hirb::Console.render_output}[http://tagaholic.me/hirb/doc/classes/Hirb/Console.html#M000011].
-    def render(object, options={}, return_obj=false)
-      if options[:inspect]
-        puts(object.inspect)
-      else
-        render_object(object, options, return_obj) unless silent_object?(object)
-      end
-    end
-
-    #:stopdoc:
-    def class_config(klass)
-      opts = (Hirb::View.formatter_config[klass] || {}).dup
-      opts.delete(:ancestor)
-      opts.merge!((opts.delete(:options) || {}).dup)
-      OptionParser.make_mergeable!(opts)
-      opts
-    end
-
-    def toggle_pager
-      Hirb::View.toggle_pager
-    end
-
-    def silent_object?(obj)
-      [nil,false,true].include?(obj)
-    end
-
-    def render_object(object, options={}, return_obj=false)
-      options[:class] ||= :auto_table
-      render_result = Hirb::Console.render_output(object, options)
-      return_obj ? object : render_result
-    end
-    #:startdoc:
-  end
-end

data/test/argument_inspector_test.rb

@@ -1,62 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-describe "scrape_with_text" do
-  def args_from(file_string)
-    ArgumentInspector.scrape_with_text(file_string, "blah")
-  end
-
-  it "parses arguments of class method" do
-    args_from("    def YAML.blah( filepath )\n").should == [['filepath']]
-  end
-
-  it "parses arguments with no spacing" do
-    args_from("def bong; end\ndef blah(arg1,arg2='val2')\nend").should == [["arg1"], ['arg2', "'val2'"]]
-  end
-
-  it "parses arguments with spacing" do
-    args_from("\t def blah(  arg1=val1, arg2 = val2)").should == [["arg1","val1"], ["arg2", "val2"]]
-  end
-
-  it "parses arguments without parenthesis" do
-    args_from(" def blah arg1, arg2, arg3={}").should == [['arg1'], ['arg2'], ['arg3','{}']]
-  end
-end
-
-describe "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[:args]['blah']
-  end
-
-  before_all { eval "module ::Boson::Commands::Aaa; end"; }
-  before { MethodInspector.mod_store[::Boson::Commands::Aaa] = {} }
-
-  it "determines arguments with literal defaults" do
-    args_from("def blah(arg1,arg2='val2'); end").should == [['arg1'], ['arg2','val2']]
-  end
-
-  it "determines splat arguments" do
-    args_from("def blah(arg1, *args); end").should == [['arg1'], ["*args"]]
-  end
-
-  it "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
-
-  it "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
-
-  it "doesn't determine arguments of a private method" do
-    args_from("private; def blah(arg1,arg2); end").should == nil
-  end
-
-  it "doesn't determine arguments if an error occurs" do
-    args_from("def blah(arg1,arg2=raise); end").should == nil
-  end
-end

data/test/commands_test.rb

@@ -1,22 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-describe "WebCore" do
-  it "#get with no options" do
-    request = mock { expects(:request).with({}) }
-    Commands::WebCore::Get.expects(:new).with('blah.com').returns(request)
-    Commands::WebCore.get 'blah.com'
-  end
-
-  it "#post with no options" do
-    Net::HTTP.expects(:post_form).with(anything, {}).returns(nil)
-    Commands::WebCore.post 'blah.com'
-  end
-
-  it "#build_url with string params" do
-    Commands::WebCore.build_url('ababd.com', :q=>'search').should == 'ababd.com?q=search'
-  end
-
-  it "#build_url with array params" do
-    Commands::WebCore.build_url('ababd.com', :q=>%w{multi word search}).should == 'ababd.com?q=multi+word+search'
-  end
-end

data/test/comment_inspector_test.rb

@@ -1,126 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-describe "CommentInspector" do
-  before_all { eval "module ::Optional; def self.bling; {:a=>'bling'}; end; end" }
-  describe "scrapes description" do
-    before { 
-      @lines = ["module Foo", "  # some comments yay", "  def foo", "  end", "end"]
-    }
-    def description(options={})
-      CommentInspector.scrape(@lines.join("\n"), options[:line] || 3, Optional)[:desc]
-    end
-
-    it "directly above method returns desc" do
-      description.should == "some comments yay"
-    end
-
-    it "with explicit @desc returns desc" do
-      @lines[1] = '#@desc   some comments yay'
-      description.should == "some comments yay"
-    end
-
-    it "of multiple lines returns desc" do
-      @lines.delete_at(1)
-      @lines.insert(1, '#@options :b=>1', '#@desc here be', '# comments')
-      description(:line=>5).should == "here be comments"
-    end
-
-    it "that is empty returns nil" do
-      @lines[1] = ""
-      description.should == nil
-    end
-
-    it "that is empty with options keyword returns nil" do
-      @lines[1] = '#@options {:a=>1}'
-      description.should == nil
-    end
-
-    it "not directly above returns nil" do
-      @lines.insert(2, "   ")
-      description(:line=>4).should == nil
-    end
-  end
-
-  describe "scrapes options" do
-    before {
-      @lines = ["module Foo", '  #@options {:a=>true}', "  def foo", "  end", "end"]
-    }
-    def options(opts={})
-      @lines[1] = opts[:value] if opts[:value]
-      args = [@lines.join("\n"), opts[:line] || 3, Optional]
-      CommentInspector.scrape(*args)[:options]
-    end
-
-    it "that are basic" do
-      options.should == {:a=>true}
-    end
-
-    it "that are hash-like" do
-      options(:value=>'#@options :a => 2').should == {:a=>2}
-    end
-
-    it "that are whitespaced" do
-      options(:value=>"\t"+ '#    @options {:a=>1}').should == {:a=>1}
-    end
-
-    it "that have a local value" do
-      options(:value=>'#@options bling').should == {:a=>'bling'}
-    end
-
-    it "that are multi-line" do
-      @lines.delete_at(1)
-      @lines.insert(1, '#@options {:a =>', " # 1}", "# some comments")
-      options(:line=>5).should == {:a=>1}
-    end
-
-    it "with failed eval and returns nil" do
-      options(:value=>'#@options !--').should == nil
-    end
-
-    it "that are empty and returns nil" do
-      options(:value=>"# nada").should == nil
-    end
-
-    it "when @option overwrites @options" do
-      @lines.insert(1, '  #@option :a, :boolean')
-      options(:line=>4).should == {:a=>:boolean}
-    end
-
-    it "when set by @option and @options" do
-      @lines.insert(1, '  #@option :b, :boolean')
-      options(:line=>4).should == {:b=>:boolean, :a=>true}
-    end
-
-    it "when set by @option" do
-      @lines.delete_at(1)
-      @lines.insert(1, ' #@option :b, :string', '  #@option :a, 4')
-      options(:line=>4).should == {:b=>:string, :a=>4}
-    end
-
-    it "when set by multi-line @option" do
-      @lines.delete_at(1)
-      @lines.insert(1, ' #@option :b, :type=>:string,', '  # :values=>%w{one two}', '# some comments')
-      options(:line=>5).should == {:b=>{:type=>:string, :values=>%w{one two}}}
-    end
-
-    it "and ignores invalid @option's" do
-      @lines.delete_at(1)
-      @lines.insert(1, '  #@option :b=>:string', '  #@option :a, :string')
-      options(:line=>4).should == {:a=>:string}
-    end
-  end
-
-  it "scrapes all comment types with implicit desc" do
-    @lines = ["module Foo", '# @config :a=>true', '# @render_options :b=>1', '  # @options {:a=>true}',
-      '#blah', "  def foo", "  end", "end"]
-    expected = {:desc=>"blah", :options=>{:a=>true}, :render_options=>{:b=>1}, :config=>{:a=>true}}
-    CommentInspector.scrape(@lines.join("\n"), 6, Optional).should == expected
-  end
-
-  it "scrapes all comment types with explicit desc" do
-    @lines = ["module Foo",  '#@desc blah', '# @render_options :b=>1,', '# :c=>2',
-      '  # @options {:a=>true}', '  # @config :a=>true', "  def foo", "  end", "end"]
-    expected = {:desc=>"blah", :options=>{:a=>true}, :render_options=>{:b=>1, :c=>2}, :config=>{:a=>true}}
-    CommentInspector.scrape(@lines.join("\n"), 7, Optional).should == expected
-  end
-end

data/test/file_library_test.rb

@@ -1,42 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-describe "file library" do
-  before { reset; FileLibrary.reset_file_cache }
-  before { Gem.stubs(:loaded_specs).returns({}) } if RUBY_VERSION >= '1.9.2' && defined? Gem
-
-  it "loads" do
-    load :blah, :file_string=>"module Blah; def blah; end; end"
-    library_has_module('blah', 'Boson::Commands::Blah')
-    command_exists?('blah')
-  end
-
-  it "in a subdirectory loads" do
-    load 'site/delicious', :file_string=>"module Delicious; def blah; end; end"
-    library_has_module('site/delicious', "Boson::Commands::Site::Delicious")
-    command_exists?('blah')
-  end
-
-  it "in a sub subdirectory loads" do
-    load 'web/site/delicious', :file_string=>"module Delicious; def blah; end; end"
-    library_has_module('web/site/delicious', "Boson::Commands::Web::Site::Delicious")
-    command_exists?('blah')
-  end
-
-  it "loads by basename" do
-    Dir.stubs(:[]).returns([RUBY_VERSION < '1.9.2' ? './test/commands/site/github.rb' :
-      File.expand_path('./test/commands/site/github.rb')])
-    load 'github', :file_string=>"module Github; def blah; end; end", :exists=>false
-    library_has_module('site/github', "Boson::Commands::Site::Github")
-    command_exists?('blah')
-  end
-
-  it "loads a plugin library by creating its module" do
-    load(:blah, :file_string=>"def blah; end")
-    library_has_module('blah', "Boson::Commands::Blah")
-    command_exists?('blah', false)
-  end
-
-  it "prints error for file library with multiple modules" do
-    capture_stderr { load(:blah, :file_string=>"module Doo; end; module Daa; end") }.should =~ /Can't.*config/
-  end
-end

data/test/pipes_test.rb

@@ -1,65 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-describe "Pipes" do
-  before_all { ::Ab = Struct.new(:a, :b) }
-  describe "query_pipe" do
-    before_all {
-      @hashes = [{:a=>'some', :b=>'thing'}, {:a=>:more, :b=>:yep}]
-      @objects = [Ab.new('some', 'thing'), Ab.new(:more, :yep)]
-    }
-
-    it "searches one query" do
-      [@hashes, @objects].each {|e|
-        Pipes.query_pipe(e, :a=>'some').should == e[0,1]
-      }
-    end
-
-    it "searches non-string values" do
-      [@hashes, @objects].each {|e|
-        Pipes.query_pipe(e, :a=>'more').should == e[1,1]
-      }
-    end
-
-    it "searches multiple search terms" do
-      [@hashes, @objects].each {|e|
-        Pipes.query_pipe(e, :a=>'some', :b=>'yep').size.should == 2
-      }
-    end
-
-    it "prints error for invalid search field" do
-      capture_stderr { Pipes.query_pipe(@objects, :blah=>'blah') }.should =~ /failed.*'blah'/
-    end
-  end
-
-  describe "sort_pipe" do
-    before_all {
-      @hashes = [{:a=>'some', :b=>'thing'}, {:a=>:more, :b=>:yep}]
-      @objects = [Ab.new('some', 'thing'), Ab.new(:more, :yep)]
-    }
-    it "sorts objects with values of different types" do
-      Pipes.sort_pipe(@objects, :a).should == @objects.reverse
-    end
-
-    it "sorts hashes with values of different types" do
-      Pipes.sort_pipe(@hashes, :a).should == @hashes.reverse
-    end
-
-    it "sorts numeric values" do
-      hashes = [{:a=>10, :b=>4}, {:a=>5, :b=>3}]
-      Pipes.sort_pipe(hashes, :a).should == hashes.reverse
-    end
-
-    it "sorts numeric hash keys by string" do
-      hashes = [{2=>'thing'}, {2=>'some'}]
-      Pipes.sort_pipe(hashes, '2').should == hashes.reverse
-    end
-
-    it "sorts numeric hash keys by string" do
-      Pipes.sort_pipe(@hashes, 'a').should == @hashes.reverse
-    end
-
-    it "prints error for invalid sort field" do
-      capture_stderr { Pipes.sort_pipe(@objects, :blah)}.should =~ /failed.*'blah'/
-    end
-  end
-end

data/test/repo_index_test.rb

@@ -1,122 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-describe "RepoIndex" do
-  # since we're defining our own @commands, @libraries, @lib_hashes
-  def index
-    @index ||= begin
-      ind = RepoIndex.new(Boson.repo)
-      ind.instance_variable_set "@read", true
-      ind
-    end
-  end
-
-  describe "read_and_transfer" do
-    before { reset_boson; index.instance_eval "@libraries = @commands = nil" }
-
-    def transfers(options={})
-      index.instance_variable_set "@libraries", [Library.new(:name=>'blah', :commands=>['blurb']),
-        Library.new(:name=>'bling')]
-      index.instance_variable_set "@commands", [Command.new(:name=>'blurb', :lib=>'blah')]
-      index.read_and_transfer options[:ignored] || []
-      Boson.libraries.map {|e| e.name}.should == options[:libraries]
-      Boson.commands.map {|e| e.name}.should == options[:commands]
-    end
-
-    it "transfers libraries with no libraries to ignore" do
-      transfers :libraries=>%w{blah bling}, :commands=>%w{blurb}, :ignored=>[]
-    end
-
-    it "transfers libraries and commands except for ignored libraries and its commands" do
-      transfers :libraries=>%w{bling}, :commands=>[], :ignored=>%w{blah}
-    end
-
-    it "doesn't replace existing libraries" do
-      lib = Library.new(:name=>'blah')
-      cmd = Command.new(:name=>'blurb', :lib=>'blah')
-      Boson.libraries << lib
-      Boson.commands << cmd
-      transfers :libraries=>%w{blah bling}, :commands=>%w{blurb}
-      Boson.libraries.include?(lib).should == true
-      Boson.commands.include?(cmd).should == true
-    end
-  end
-
-  describe "find_library" do
-    before_all {
-      reset_boson
-      commands = [Command.new(:name=>'blurb', :lib=>'blah', :alias=>'bb'), 
-        Command.new(:name=>'sub', :lib=>'bling', :alias=>'s')
-      ]
-      index.instance_variable_set "@commands", commands
-      index.instance_variable_set "@libraries", [Library.new(:name=>'blah'), Library.new(:name=>'bling', :namespace=>'bling')]
-    }
-
-    it "finds command aliased or not" do
-      index.find_library('blurb').should == 'blah'
-      index.find_library('bb').should == 'blah'
-    end
-
-    it "doesn't find command" do
-      index.find_library('blah').should == nil
-    end
-
-    it "finds a subcommand aliased or not" do
-      index.find_library('bling.sub').should == 'bling'
-      # @index.find_library('bl.s').should == 'bling'
-    end
-
-    it "finds namespace command aliased or not without a subcommand" do
-      index.find_library('bling').should == 'bling'
-      # @index.find_library('bl').should == 'bling'
-    end
-
-    it "doesn't find a subcommand" do
-      index.find_library('d.d').should == nil
-    end
-  end
-
-  describe "changed_libraries" do
-    before_all { index.instance_eval "@lib_hashes = nil" }
-
-    def changed(string, all_libs=['file1'])
-      index.repo.expects(:all_libraries).returns(all_libs)
-      index.instance_variable_set "@lib_hashes", {"file1"=>Digest::MD5.hexdigest("state1")}
-      File.stubs(:exists?).returns(true)
-      File.expects(:read).returns(string)
-      index.changed_libraries
-    end
-
-    it "detects changed libraries" do
-      changed("state2").should == %w{file1}
-    end
-
-    it "detects new libraries" do
-      changed("state1", ['file2']).should == %w{file2}
-    end
-
-    it "detects no changed libraries" do
-      changed("state1").should == []
-    end
-  end
-
-  describe "write" do
-    before_all {
-      reset_boson
-      Boson.commands << Command.new(:name=>'blah', :lib=>'blah', :args=>[['arg1', {}], ['arg2', self.class]])
-      Boson.libraries << Library.new(:name=>'blah', :module=>self.class)
-      index.expects(:latest_hashes)
-      libraries = commands = []
-      index.expects(:save_marshal_index).with {|str| libraries, commands, hashes = Marshal.load(str) ; true}
-      index.write
-      @index_hash = {:libraries=>libraries, :commands=>commands}
-    }
-
-    it "saves library module constants as strings" do
-      @index_hash[:libraries][0].module.class.should == String
-    end
-
-    it "save commands with arg values as strings" do
-      @index_hash[:commands][0].args.each {|e| e[1].class.should == String}
-    end
-  end
-end