boson-more 0.1.0

data/lib/boson/save.rb

@@ -0,0 +1,198 @@
+require 'boson/namespacer'
+require 'boson/repo'
+require 'boson/index'
+require 'boson/repo_index'
+
+module Boson
+  module Save
+    def config
+      repo.config
+    end
+
+    def config=(val)
+      repo.config = val
+    end
+
+    # The main required repository which defaults to ~/.boson.
+    def repo
+      @repo ||= Repo.new("#{ENV['BOSON_HOME'] || Dir.home}/.boson")
+    end
+
+    # An optional local repository which defaults to ./lib/boson or ./.boson.
+    def local_repo
+      @local_repo ||= begin
+        ignored_dirs = (config[:ignore_directories] || []).map {|e| File.expand_path(e) }
+        dir = ["lib/boson", ".boson"].find {|e| File.directory?(e) &&
+            File.expand_path(e) != repo.dir && !ignored_dirs.include?(File.expand_path('.')) }
+        Repo.new(dir) if dir
+      end
+    end
+
+    # The array of loaded repositories containing the main repo and possible local and global repos
+    def repos
+      @repos ||= [repo, local_repo, global_repo].compact
+    end
+
+    # Optional global repository at /etc/boson
+    def global_repo
+      File.exists?('/etc/boson') ? Repo.new('/etc/boson') : nil
+    end
+  end
+  extend Save
+
+  class BareRunner
+    module Save
+      def init
+        add_load_path
+        super
+      end
+
+      def autoload_command(cmd, opts={verbose: Boson.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 BareRunner.autoload_command(method.to_s)
+              send(method, *args, &block) if respond_to?(method)
+            else
+              super
+            end
+          end
+        end
+      end
+
+      def default_libraries
+        Boson.repos.map {|e| e.config[:defaults] || [] }.flatten + super
+      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
+
+      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
+    end
+    extend Save
+  end
+
+  # * 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:
+  #         delete:
+  #           :alias: d
+  #           :desc: 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.
+  class Library
+    module Save
+      attr_accessor :repo_dir
+
+      def before_initialize
+        @repo_dir = set_repo.dir
+      end
+
+      def config
+        set_repo.config
+      end
+
+      def set_repo
+        Boson.repo
+      end
+
+      def marshal_dump
+        [@name, @commands, @gems, @module.to_s, @repo_dir, @indexed_namespace]
+      end
+
+      def marshal_load(ary)
+        @name, @commands, @gems, @module, @repo_dir, @indexed_namespace = ary
+      end
+    end
+    include Save
+  end
+
+  class Command
+    module Save
+      def marshal_dump
+        if @args && @args.any? {|e| e[1].is_a?(Module) }
+          @args.map! {|e| e.size == 2 ? [e[0], e[1].inspect] : e }
+          @file_parsed_args = true
+        end
+        [@name, @alias, @lib, @desc, @options, @render_options, @args, @default_option]
+      end
+
+      def marshal_load(ary)
+        @name, @alias, @lib, @desc, @options, @render_options, @args, @default_option = ary
+      end
+    end
+    include Save
+  end
+
+  if defined? BinRunner
+  # 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.
+  class BinRunner
+    module Save
+      def autoload_command(cmd)
+        if !Boson.can_invoke?(cmd, false)
+          update_index
+          super(cmd, load_options)
+        end
+      end
+
+      def update_index
+        Index.update(verbose: verbose)
+      end
+
+      def execute_command(cmd, args)
+        @command = cmd # for external errors
+        autoload_command cmd
+        super
+      end
+
+      def command_not_found?(cmd)
+        super && (!(Index.read && Index.find_command(cmd[/\w+/])) || cmd.include?(NAMESPACE))
+      end
+
+      def command_name(cmd)
+        cmd.split(Boson::NAMESPACE)[-1]
+      end
+
+      def eval_execute_option(str)
+        define_autoloader
+        super
+      end
+
+      def default_libraries
+        super + Boson.repos.map {|e| e.config[:bin_defaults] || [] }.flatten +
+          Dir.glob('Bosonfile')
+      end
+    end
+    extend Save
+  end
+  end
+end

data/lib/boson/science.rb

@@ -0,0 +1,273 @@
+require 'boson/view'
+require 'boson/pipe'
+require 'boson/pipes'
+require 'boson/more_scientist'
+
+module Boson
+  class OptionCommand
+    BASIC_OPTIONS.update(
+      :delete_options=>{:type=>:array, :desc=>'Deletes global options starting with given strings' },
+      :usage_options=>{:type=>:string, :desc=>"Render options to pass to usage/help"},
+      :render=> {:type=>:boolean, :desc=>"Toggle a command's default rendering behavior"})
+    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"},
+      :pipes=>{:alias=>'P', :type=>:array, :desc=>"Pipe to commands sequentially"}
+    } #: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:
+
+    # Adds render and pipe global options
+    # For more about pipe and render options see Pipe and View respectively.
+    # === 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
+    #  == Additional config keys for the main repo config
+    #  [:render_options] Hash of render options available to all option commands to be passed to a Hirb view (see View). Since
+    # this merges with default render options, it's possible to override default render options.
+    #  [:no_auto_render] When set, turns off commandline auto-rendering of a command's output. Default is false.
+    module ClassRender
+
+      def default_options
+        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
+    end
+    extend ClassRender
+
+    module Render
+      def option_parser
+        @option_parser ||= @command.render_options ? OptionParser.new(all_global_options) :
+          self.class.default_option_parser
+      end
+
+      def all_global_options
+        OptionParser.make_mergeable! @command.render_options
+        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
+    end
+    include Render
+  end
+
+  module Scientist
+    # * Before a method returns its value, it pipes its return value through pipe commands if pipe options are specified. See Pipe.
+    # * Methods can have any number of optional views associated with them via global render options (see View). Views can be toggled
+    #   on/off with the global option --render (see OptionCommand).
+    module Render
+      attr_accessor :rendered, :render
+
+      def after_parse
+        (@global_options[:delete_options] || []).map {|e|
+          @global_options.keys.map {|k| k.to_s }.grep(/^#{e}/)
+        }.flatten.each {|e| @global_options.delete(e.to_sym) }
+      end
+
+      def process_result(result)
+        if (@rendered = can_render?)
+          if @global_options.key?(:class) || @global_options.key?(:method)
+            result = Pipe.scientist_process(result, @global_options, :config=>@command.config, :args=>@args, :options=>@current_options)
+          end
+          View.render(result, OptionCommand.delete_non_render_options(@global_options.dup), false)
+        else
+          Pipe.scientist_process(result, @global_options, :config=>@command.config, :args=>@args, :options=>@current_options)
+        end
+      rescue StandardError
+        raise Scientist::Error, $!.message, $!.backtrace
+      end
+
+      def can_render?
+        render.nil? ? command_renders? : render
+      end
+
+      def command_renders?
+        (!!@command.render_options ^ @global_options[:render]) && !Pipe.any_no_render_pipes?(@global_options)
+      end
+
+      def run_pretend_option(args)
+        super
+        @rendered = true if @global_options[:pretend]
+      end
+
+      def help_options
+        super.tap do |opts|
+          if @global_options[:usage_options]
+            opts << "--render_options=#{@global_options[:usage_options]}"
+          end
+          opts
+        end
+      end
+    end
+    extend Render
+  end
+
+  class Command
+    module ScienceClassMethods
+      attr_accessor :all_option_commands
+
+      def create(name, library)
+        super.tap do |obj|
+          if @all_option_commands && !%w{get method_missing}.include?(name)
+            obj.make_option_command(library)
+          end
+        end
+      end
+    end
+    extend ScienceClassMethods
+
+    module Science
+      # Option parser for command as defined by @render_options.
+      def render_option_parser
+        option_command? ? Boson::Scientist.option_command(self).option_parser : nil
+      end
+
+      def make_option_command(lib=library)
+        @option_command = true
+        @args = [['*args']] unless args(lib) || arg_size
+      end
+
+      def option_command?
+        super || render_options
+      end
+    end
+    include Science
+  end
+
+  # [*:render_options*] Hash of rendering options to pass to OptionParser. If the key :output_class is passed,
+  #                     that class's Hirb config will serve as defaults for this rendering hash.
+  class Command
+    attr_accessor :render_options
+
+    module Science
+      def after_initialize(hash)
+        if hash[:render_options] && (@render_options = hash.delete(:render_options))[:output_class]
+          @render_options = Util.recursive_hash_merge View.class_config(@render_options[:output_class]), @render_options
+        end
+        super
+      end
+    end
+  end
+
+  if defined? BinRunner
+    class BinRunner < BareRunner
+      GLOBAL_OPTIONS.update(
+        option_commands: {
+          :type=>:boolean,
+          :desc=>"Toggles on all commands to be defined as option commands"
+        },
+        render: {:type=>:boolean,
+          :desc=>"Renders a Hirb view from result of command without options"}
+      )
+
+      # [: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.
+      #
+      # ==== 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.
+      module Science
+        def init
+          Command.all_option_commands = true if @options[:option_commands]
+          super
+        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 allowed_argument_error?(err, cmd, args)
+          err.class == OptionCommand::CommandArgumentError || super
+        end
+
+        def execute_command(cmd, args)
+          render_output super
+        end
+      end
+
+      class <<self
+        include Science
+      end
+    end
+  end
+
+  # Additional method attributes:
+  # * render_options: Hash to define an OptionParser object for a command's local/global render options (see View).
+  class MethodInspector
+    METHODS << :render_options
+    METHOD_CLASSES[:render_options] = Hash
+    SCRAPEABLE_METHODS << :render_options
+  end
+
+  module CommentInspector
+    EVAL_ATTRIBUTES << :render_options
+  end
+end

data/lib/boson/view.rb

@@ -0,0 +1,98 @@
+require 'hirb'
+require 'boson/more_option_parser'
+
+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/lib/boson/viewable.rb

@@ -0,0 +1,48 @@
+require 'boson/view'
+
+module Boson
+  if defined? BinRunner
+    class BinRunner
+      module Viewable
+        def print_usage_header
+          super
+          puts "GLOBAL OPTIONS"
+          View.enable
+        end
+      end
+      extend Viewable
+    end
+  end
+
+  class BareRunner
+    module Viewable
+      def init
+        View.enable
+        super
+      end
+    end
+    extend Viewable
+  end
+
+  class OptionParser
+    module Viewable
+      def get_fields_and_options(fields, options)
+        (fields << :default).uniq! if options.delete(:local) || options[:fields] == '*'
+        fields, opts = super(fields, options)
+        fields.delete(:default) if fields.include?(:default) && opts.all? {|e| e[:default].nil? }
+        [fields, opts]
+      end
+
+      def default_render_options #:nodoc:
+        {:header_filter=>:capitalize, :description=>false, :filter_any=>true,
+          :filter_classes=>{Array=>[:join, ',']}, :hide_empty=>true}
+      end
+
+      def render_table(fields, arr, options)
+        options = default_render_options.merge(:fields=>fields).merge(options)
+        View.render arr, options
+      end
+    end
+    include Viewable
+  end
+end

data/test/alias_test.rb

@@ -0,0 +1,55 @@
+# Add library_loaded? and with_config
+describe "Manager" do
+  def load_library(hash)
+    new_attributes = {:name=>hash[:name], :commands=>[], :created_dependencies=>[], :loaded=>true}
+    [:module, :commands].each {|e| new_attributes[e] = hash.delete(e) if hash[e] }
+    Manager.expects(:call_load_action).returns(Library.new(new_attributes))
+    Manager.load([hash[:name]])
+  end
+
+  before { reset_boson }
+
+  describe "command aliases" do
+    before { eval %[module ::Aquateen; def frylock; end; end] }
+    after { Object.send(:remove_const, "Aquateen") }
+
+    it "created with command specific config" do
+      with_config(:command_aliases=>{'frylock'=>'fr'}) do
+        Manager.expects(:create_instance_aliases).with({"Aquateen"=>{"frylock"=>"fr"}})
+        load_library :name=>'aquateen', :commands=>['frylock'], :module=>Aquateen
+        library_loaded? 'aquateen'
+      end
+    end
+
+    it "created with config command_aliases" do
+      with_config(:command_aliases=>{"frylock"=>"fr"}) do
+        Manager.expects(:create_instance_aliases).with({"Aquateen"=>{"frylock"=>"fr"}})
+        load_library :name=>'aquateen', :commands=>['frylock'], :module=>Aquateen
+        library_loaded? 'aquateen'
+      end
+    end
+
+    it "not created and warns for commands with no module" do
+      with_config(:command_aliases=>{'frylock'=>'fr'}) do
+        capture_stderr {
+          load_library(:name=>'aquateen', :commands=>['frylock'])
+        }.should =~ /No aliases/
+        library_loaded? 'aquateen'
+        Aquateen.method_defined?(:fr).should == false
+      end
+    end
+  end
+end
+
+describe "Loader" do
+  describe "load" do
+    before { reset }
+    it "loads a library and creates its class commands" do
+      with_config(:libraries=>{"blah"=>{:class_commands=>{"bling"=>"Blah.bling", "Blah"=>['hmm']}}}) do
+        load :blah, :file_string=>"module Blah; def self.bling; end; def self.hmm; end; end"
+        command_exists? 'bling'
+        command_exists? 'hmm'
+      end
+    end
+  end
+end