boson-more 0.1.0

data/.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require 'rubygems' unless Object.const_defined?(:Gem)
+require File.dirname(__FILE__) + "/lib/boson/more/version"
+
+Gem::Specification.new do |s|
+  s.name        = "boson-more"
+  s.version     = Boson::More::VERSION
+  s.authors     = ["Gabriel Horner"]
+  s.email       = "gabriel.horner@gmail.com"
+  s.homepage    = "http://github.com/cldwalker/boson-more"
+  s.summary = "boson2 plugins"
+  s.description =  "A collection of boson plugins that can be mixed and matched"
+  s.required_rubygems_version = ">= 1.3.6"
+  s.add_dependency 'boson', '>= 1.0.0'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'bacon', '>= 1.1.0'
+  s.add_development_dependency 'mocha-on-bacon'
+  s.add_development_dependency 'bacon-bits'
+  s.files = Dir.glob(%w[{lib,test}/**/*.rb bin/* [A-Z]*.{txt,rdoc} ext/**/*.{rb,c} **/deps.rip]) + %w{Rakefile .gemspec}
+  s.extra_rdoc_files = ["README.md", "LICENSE.txt"]
+  s.license = 'MIT'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT LICENSE
+
+Copyright (c) 2010 Gabriel Horner
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,97 @@
+## Description
+
+boson-more is a collection of useful boson plugins. These plugins add features
+such as allowing boson to be used from irb, optional automated views generated
+by hirb and allowing libraries to be written as plain ruby. For my libraries
+that use this, see [irbfiles](http://github.com/cldwalker/irbfiles).
+
+## Usage
+
+To use all of the plugins, add this to ~/.bosonrc:
+
+    require 'boson/more'
+
+To only use certain plugins, require those plugins in ~/.bosonrc.
+
+When using all plugins, you can use boson in irb/ripl by dropping this in ~/.irbrc:
+
+    require 'boson'
+    Boson.start
+
+
+## List of Plugins
+
+* boson/alias - Adds aliasing to commands. Requires alias gem.
+* boson/console - Allows for boson to be used in a ruby console.
+* boson/libraries - Adds several libraries. Necessary for using old boson.
+* boson/more\_commands - Adds set of default commands
+* boson/more\_inspector - Adds commenting-based command configuration.
+* boson/more\_manager - Adds ability for libraries to have dependencies.
+* boson/more\_method\_inspector - Adds ability to scrape argument names and
+  default values from commands.
+* boson/more\_scientist - Adds a few global options to option commands.
+* boson/runner\_options - Adds additional options to the boson executable.
+* boson/science - Adds pipes and several global options to option commands.
+  Requires hirb.
+* boson/namespacer - Adds namespaces to commands.
+* boson/save - Allows libraries and commands to be saved and loaded quickly.
+  Necessary for using old boson.
+* boson/viewable - Adds rendering to commands. Requires hirb.
+
+## Features
+
+When using all these plugins, they have the following features:
+
+* Simple organization: Commands are just methods on an object (default is main)
+  and command libraries are just modules.
+* Commands are accessible from the commandline (Boson::BinRunner) or irb
+  (Boson::ConsoleRunner).
+* Libraries
+  * can be written in plain ruby which allows for easy testing and use
+    independent of boson (Boson::FileLibrary).
+  * can exist locally as a Bosonfile (Boson::LocalFileLibrary) and under
+    lib/boson/commands or .boson/commands.
+  * can be made from gems (Boson::GemLibrary) or any require-able file
+    (Boson::RequireLibrary).
+  * are encouraged to be shared. Libraries can be installed with a given url.
+    Users can customize any aspect of a third-party library without modifying it
+    (Boson::Library).
+* Commands
+  * can have any number of local and global options (Boson::OptionCommand).
+    Options are defined with Boson::OptionParser.
+  * can have any view associated to it (via Hirb) without adding view code to
+    the command's method.  These views can be toggled on and manipulated via
+    global render options (Boson::View and Boson::OptionCommand).
+  * can pipe their return value into custom pipe options (Boson::Pipe).
+  * has default pipe options to search and sort an array of any objects
+    (Boson::Pipes).
+* Option parser (Boson::OptionParser)
+  * provides option types that map to objects i.e. :array type creates Array
+    objects.
+  * come with 5 default option types: boolean, array, string, hash and numeric.
+  * can have have custom option types defined by users (Boson::Options).
+* Comes with default commands to load, search, list and install commands and
+  libraries (Boson::Commands::Core).
+* Namespaces are optional and when used are methods which allow for
+  method\_missing magic.
+
+
+## Bugs/Issues
+
+Please report them [on github](http://github.com/cldwalker/boson-more/issues).
+
+## Contributing
+
+[See here](http://tagaholic.me/contributing.html)
+
+## Links
+
+* http://tagaholic.me/2009/10/14/boson-command-your-ruby-universe.html
+* http://tagaholic.me/2009/10/15/boson-and-hirb-interactions.html
+* http://tagaholic.me/2009/10/19/how-boson-enhances-your-irb-experience.html
+## TODO
+
+* Actually have working tests
+* Clean up plugins and move their files into separates directories
+* Clean up plugins that unintentionally depend on each other
+* Clean up docs which are currently strewn across plugins

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rake'
+require 'fileutils'
+
+def gemspec
+  @gemspec ||= eval(File.read('.gemspec'), binding, '.gemspec')
+end
+
+desc "Build the gem"
+task :gem=>:gemspec do
+  sh "gem build .gemspec"
+  FileUtils.mkdir_p 'pkg'
+  FileUtils.mv "#{gemspec.name}-#{gemspec.version}.gem", 'pkg'
+end
+
+desc "Install the gem locally"
+task :install => :gem do
+  sh %{gem install pkg/#{gemspec.name}-#{gemspec.version}}
+end
+
+desc "Generate the gemspec"
+task :generate do
+  puts gemspec.to_ruby
+end
+
+desc "Validate the gemspec"
+task :gemspec do
+  gemspec.validate
+end
+
+desc 'Run tests'
+task :test do |t|
+  sh 'bacon -q -Ilib -I. test/*_test.rb'
+end
+
+task :default => :test

data/deps.rip

@@ -0,0 +1 @@
+boson >=1.0.0

data/lib/boson/alias.rb

@@ -0,0 +1,75 @@
+require 'alias'
+
+module Boson
+  class Library
+    # [*:class_commands*] A hash of commands to create. A hash key-pair can map command names to any string of ruby code
+    #                     that ends with a method call. Or a key-pair can map a class to an array of its class methods
+    #                     to create commands of the same name. Example:
+    #                      :class_commands=>{'spy'=>'Bond.spy', 'create'=>'Alias.manager.create',
+    #                       'Boson::Util'=>['detect', 'any_const_get']}
+    # [*:no_alias_creation*] Boolean which doesn't create aliases for a library. Useful for libraries that configure command
+    #                        aliases outside of Boson's control. Default is false.
+    module Alias
+      attr_reader :class_commands, :no_alias_creation
+    end
+    include Alias
+
+    module AliasLoader
+      def load_commands?
+        super || @class_commands
+      end
+
+      def before_load_commands
+        unless @class_commands.nil? || @class_commands.empty? || @method_conflict
+          Boson::Manager.create_class_aliases(@module, @class_commands)
+        end
+        super
+      end
+    end
+    include AliasLoader
+  end
+
+  class Manager
+    def self.create_class_aliases(mod, class_commands)
+      class_commands.dup.each {|k,v|
+        if v.is_a?(Array)
+          class_commands.delete(k).each {|e| class_commands[e] = "#{k}.#{e}"}
+        end
+      }
+      Alias.manager.create_aliases(:any_to_instance_method, mod.to_s=>class_commands.invert)
+    end
+
+    module AliasLib
+      def after_create_commands(lib, commands)
+        create_command_aliases(lib, commands) if commands.size > 0 && !lib.no_alias_creation
+      end
+
+      def create_command_aliases(lib, commands)
+        lib.module ? prep_and_create_instance_aliases(commands, lib.module) : check_for_uncreated_aliases(lib, commands)
+      end
+
+      def prep_and_create_instance_aliases(commands, lib_module)
+        aliases_hash = {}
+        select_commands = Boson.commands.select {|e| commands.include?(e.name)}
+        select_commands.each do |e|
+          if e.alias
+            aliases_hash[lib_module.to_s] ||= {}
+            aliases_hash[lib_module.to_s][e.name] = e.alias
+          end
+        end
+        create_instance_aliases(aliases_hash)
+      end
+
+      def create_instance_aliases(aliases_hash)
+        Alias.manager.create_aliases(:instance_method, aliases_hash)
+      end
+
+      def check_for_uncreated_aliases(lib, commands)
+        if (found_commands = Boson.commands.select {|e| commands.include?(e.name)}) && found_commands.find {|e| e.alias }
+          $stderr.puts "No aliases created for library #{lib.name} because it has no module"
+        end
+      end
+    end
+    include AliasLib
+  end
+end

data/lib/boson/argument_inspector.rb

@@ -0,0 +1,90 @@
+# Extracts arguments and their default values from methods either by
+# by scraping a method's text or with method_added and brute force eval (thanks to
+# {eigenclass}[http://eigenclass.org/hiki/method+arguments+via+introspection]).
+module Boson::ArgumentInspector
+  extend self
+
+  # Max number of arguments extracted per method with scrape_with_eval
+  MAX_ARGS = 10
+  # Scrapes non-private methods for argument names and default values.
+  # Returns arguments as array of argument arrays with optional default value as a second element.
+  # ====Examples:
+  #   def meth1(arg1, arg2='val', options={}) -> [['arg1'], ['arg2', 'val'], ['options', {}]]
+  #   def meth2(*args) -> [['*args']]
+  def scrape_with_eval(meth, klass, object)
+    unless %w[initialize].include?(meth.to_s)
+      return if class << object; private_instance_methods(true).map {|e| e.to_s } end.include?(meth.to_s)
+    end
+    params, values, arity, num_args = trace_method_args(meth, klass, object)
+    return if local_variables == params # nothing new found
+    format_arguments(params, values, arity, num_args)
+    rescue Exception
+      print_debug_message(klass, meth) if Boson.debug
+    ensure
+      set_trace_func(nil)
+  end
+
+  def print_debug_message(klass, meth) #:nodoc:
+    warn "DEBUG: Error while scraping arguments from #{klass.to_s[/\w+$/]}##{meth}: #{$!.message}"
+  end
+
+  # process params + values to return array of argument arrays
+  def format_arguments(params, values, arity, num_args) #:nodoc:
+    params ||= []
+    params = params[0,num_args]
+    params.inject([[], 0]) do |(a, i), x|
+      if Array === values[i]
+        [a << ["*#{x}"], i+1]
+      else
+        if arity < 0 && i >= arity.abs - 1
+          [a << [x.to_s, values[i]], i + 1]
+        else
+          [a << [x.to_s], i+1]
+        end
+      end
+    end.first
+  end
+
+  def trace_method_args(meth, klass, object) #:nodoc:
+    file = line = params = values = nil
+    arity = klass.instance_method(meth).arity
+    set_trace_func lambda{|event, file, line, id, binding, classname|
+      begin
+        if event[/call/] && classname == klass && id == meth
+          params = eval("local_variables", binding)
+          values = eval("local_variables.map{|x| eval(x.to_s)}", binding)
+          throw :done
+        end
+      rescue Exception
+        print_debug_message(klass, meth) if Boson.debug
+      end
+    }
+    if arity >= 0
+      num_args = arity
+      catch(:done){ object.send(meth, *(0...arity)) }
+    else
+      num_args = 0
+      # determine number of args (including splat & block)
+      MAX_ARGS.downto(arity.abs - 1) do |i|
+        catch(:done) do
+          begin
+            object.send(meth, *(0...i))
+          rescue Exception
+          end
+        end
+        # all nils if there's no splat and we gave too many args
+        next if !values || values.compact.empty?
+        k = nil
+        values.each_with_index{|x,j| break (k = j) if Array === x}
+        num_args = k ? k+1 : i
+        break
+      end
+      args = (0...arity.abs-1).to_a
+      catch(:done) do
+        args.empty? ? object.send(meth) : object.send(meth, *args)
+      end
+    end
+    set_trace_func(nil)
+    return [params, values, arity, num_args]
+  end
+end

data/lib/boson/commands/core.rb

@@ -0,0 +1,67 @@
+module Boson::Commands::Core #:nodoc:
+  extend self
+
+  def config
+    command_attributes = Boson::Command::ATTRIBUTES + [:usage, :full_name, :render_options]
+    library_attributes = Boson::Library::ATTRIBUTES + [:library_type]
+
+    commands = {
+      'usage'=>{:desc=>"Print a command's usage", :options=>{
+        :verbose=>{:desc=>"Display global options", :type=>:boolean},
+        :render_options=>{:desc=>"Render options for option tables", :default=>{},
+          :keys=>[:vertical, :fields, :hide_empty]} } },
+      'commands'=>{
+        :desc=>"List or search commands. Query must come before any options.", :default_option=>'query',
+        :options=>{ :index=>{:type=>:boolean, :desc=>"Searches index"},
+          :local=>{:type=>:boolean, :desc=>"Local commands only" } },
+        :render_options=>{
+          [:headers,:H]=>{:default=>{:desc=>'description'}},
+          :query=>{:keys=>command_attributes, :default_keys=>'full_name'},
+          :fields=>{:default=>[:full_name, :lib, :alias, :usage, :desc], :values=>command_attributes, :enum=>false},
+          :filters=>{:default=>{:render_options=>:inspect, :options=>:inspect, :args=>:inspect, :config=>:inspect}}
+        }
+      },
+      'libraries'=>{
+        :desc=>"List or search libraries. Query must come before any options.", :default_option=>'query',
+        :options=>{ :index=>{:type=>:boolean, :desc=>"Searches index"},
+          :local=>{:type=>:boolean, :desc=>"Local libraries only" } },
+        :render_options=>{
+          :query=>{:keys=>library_attributes, :default_keys=>'name'},
+          :fields=>{:default=>[:name, :commands, :gems, :library_type], :values=>library_attributes, :enum=>false},
+          :filters=>{:default=>{:gems=>[:join, ','],:commands=>:size}, :desc=>"Filters to apply to library fields" }}
+      },
+      'load_library'=>{:desc=>"Load a library", :options=>{[:verbose,:V]=>true}}
+    }
+
+    {:namespace=>false, :library_file=>File.expand_path(__FILE__), :commands=>commands}
+  end
+
+  def commands(options={})
+    cmds = options[:index] ? (Boson::Index.read || true) && Boson::Index.commands : Boson.commands
+    options[:local] ? cmds.select {|e| e.library && e.library.local? } : cmds
+  end
+
+  def libraries(options={})
+    libs = options[:index] ? (Boson::Index.read || true) && Boson::Index.libraries : Boson.libraries
+    options[:local] ? libs.select {|e| e.local? } : libs
+  end
+
+  def load_library(library, options={})
+    Boson::Manager.load(library, options)
+  end
+
+  def usage(command, options={})
+    puts Boson::Command.usage(command)
+
+    if (cmd = Boson::Command.find(command))
+      if cmd.options && !cmd.options.empty?
+        puts "\nLOCAL OPTIONS"
+        cmd.option_parser.print_usage_table options[:render_options].dup.merge(:local=>true)
+      end
+      if options[:verbose] && cmd.render_option_parser
+        puts "\nGLOBAL OPTIONS"
+        cmd.render_option_parser.print_usage_table options[:render_options].dup
+      end
+    end
+  end
+end

data/lib/boson/commands/view_core.rb

@@ -0,0 +1,19 @@
+module Boson::Commands::ViewCore
+  extend self
+
+  def config
+    commands = {
+      'render'=>{:desc=>"Render any object using Hirb"},
+      'menu'=>{:desc=>"Provide a menu to multi-select elements from a given array"}
+    }
+    {:namespace=>false, :library_file=>File.expand_path(__FILE__), :commands=>commands}
+  end
+
+  def render(object, options={})
+    Boson::View.render(object, options)
+  end
+
+  def menu(arr, options={}, &block)
+    Hirb::Console.format_output(arr, options.merge(:class=>"Hirb::Menu"), &block)
+  end
+end

data/lib/boson/commands/web_core.rb

@@ -0,0 +1,153 @@
+module Boson::Commands::WebCore
+  extend self
+
+  def config #:nodoc:
+    commands = {
+      'get'=>{ :desc=>"Gets the body of a url", :args=>[['url'],['options', {}]]},
+      'post'=>{ :desc=>'Posts to a url', :args=>[['url'],['options', {}]]},
+      'build_url'=>{ :desc=>"Builds a url, escaping the given params", :args=>[['url'],['params']]},
+      'browser'=>{ :desc=>"Opens urls in a browser on a Mac"},
+      'install'=>{ :desc=>"Installs a library by url. Library should then be loaded with load_library.",
+        :args=>[['url'],['options', {}]],
+        :options=> { :name=>{:type=>:string, :desc=>"Library name to save to"},
+          :force=>{:type=>:boolean, :desc=>'Overwrites an existing library'},
+          :default=>{:type=>:boolean, :desc=>'Adds library as a default library to main config file'},
+          :module_wrap=>{:type=>:boolean, :desc=>"Wraps a module around install using library name"},
+          :method_wrap=>{:type=>:boolean, :desc=>"Wraps a method and module around installed library using library name"}}
+      }
+    }
+
+    {:library_file=>File.expand_path(__FILE__), :commands=>commands, :namespace=>false}
+  end
+
+  # Requires libraries only once before defining method with given block
+  def self.def_which_requires(meth, *libs, &block)
+    define_method(meth) do |*args|
+      libs.each {|e| require e }
+      define_method(meth, block).call(*args)
+    end
+  end
+
+  def_which_requires(:get, 'net/https') do |*args|
+    url, options = args[0], args[1] || {}
+    url = build_url(url, options[:params]) if options[:params]
+    Get.new(url).request(options)
+  end
+
+  def_which_requires(:build_url, 'cgi') do |url, params|
+    url + (url[/\?/] ? '&' : "?") + params.map {|k,v|
+      v = v.is_a?(Array) ? v.join(' ') : v.to_s
+      "#{k}=#{CGI.escape(v)}"
+    }.join("&")
+  end
+
+  def_which_requires(:post, 'uri', 'net/http') do |*args|
+    url, options = args[0], args[1] || {}
+    (res = Net::HTTP.post_form(URI.parse(url), options)) && res.body
+  end
+
+  def install(url, options={}) #:nodoc:
+    options[:name] ||= strip_name_from_url(url)
+    return puts("Please give a library name for this url.") if options[:name].empty?
+    filename = File.join ::Boson.repo.commands_dir, "#{options[:name]}.rb"
+    return puts("Library name #{options[:name]} already exists. Try a different name.") if File.exists?(filename) && !options[:force]
+
+    file_string = get(url) or raise "Unable to fetch url"
+    file_string = "# Originally from #{url}\n"+file_string
+    file_string = wrap_install(file_string, options) if options[:method_wrap] || options[:module_wrap]
+
+    File.open(filename, 'w') {|f| f.write file_string }
+    Boson.repo.update_config {|c| (c[:defaults] ||= []) << options[:name] } if options[:default]
+    puts "Saved to #{filename}."
+  end
+
+  # non-mac users should override this with the launchy gem
+  def browser(*urls)
+    system('open', *urls)
+  end
+
+  private
+  def wrap_install(file_string, options)
+    indent = "  "
+    unless (mod_name = ::Boson::Util.camelize(options[:name]))
+      return puts("Can't wrap install with name #{options[:name]}")
+    end
+
+    file_string.gsub!(/(^)/,'\1'+indent)
+    file_string = "def #{options[:name]}\n#{file_string}\nend".gsub(/(^)/,'\1'+indent) if options[:method_wrap]
+    "module #{mod_name}\n#{file_string}\nend"
+  end
+
+  def strip_name_from_url(url)
+    url[/\/([^\/.]+)(\.[a-z]+)?$/, 1].to_s.gsub('-', '_').gsub(/[^a-zA-Z_]/, '')
+  end
+
+  # Used by the get command to make get requests and optionally parse json and yaml.
+  # Ruby 1.8.x is dependent on json gem for parsing json.
+  # See Get.request for options a request can take.
+  class Get
+    FORMAT_HEADERS = {
+      :json=>%w{application/json text/json application/javascript text/javascript},
+      :yaml=>%w{application/x-yaml text/yaml}
+    } #:nodoc:
+
+    def initialize(url, options={})
+      @url, @options = url, options
+    end
+
+    # Returns the response body string or a parsed data structure. Returns nil if request fails. By default expects response
+    # to be 200.
+    # ==== Options:
+    # [:any_response] Returns body string for any response code. Default is false.
+    # [:parse] Parse the body into either json or yaml. Expects a valid format or if true autodetects one.
+    #          Default is false.
+    # [:raise_error] Raises any original errors when parsing or fetching url instead of handling errors silently.
+    def request(options={})
+      @options.merge! options
+      body = get_body
+      body && @options[:parse] ? parse_body(body) : body
+    end
+
+    private
+    # Returns body string if successful or nil if not.
+    def get_body
+      uri = URI.parse(@url)
+      @response = get_response(uri)
+      (@options[:any_response] || @response.code == '200') ? @response.body : nil
+    rescue
+      @options[:raise_error] ? raise : puts("Error: GET '#{@url}' -> #{$!.class}: #{$!.message}")
+    end
+
+    def get_response(uri)
+      net = Net::HTTP.new(uri.host, uri.port)
+      net.verify_mode = OpenSSL::SSL::VERIFY_NONE if uri.scheme == 'https'
+      net.use_ssl = true if uri.scheme == 'https'
+      net.start {|http|  http.request_get(uri.request_uri) }
+    end
+
+    # Returns nil if dependencies or parsing fails
+    def parse_body(body)
+      format = determine_format(@options[:parse])
+      case format
+      when :json
+        unless ::Boson::Util.safe_require 'json'
+          return puts("Install the json gem to parse json: sudo gem install json")
+        end
+        JSON.parse body
+      when :yaml
+        YAML::load body
+      else
+        puts "Can't parse this format."
+      end
+    rescue
+      @options[:raise_error] ? raise : puts("Error while parsing #{format} response of '#{@url}': #{$!.class}")
+    end
+
+    def determine_format(format)
+      return format.to_sym if %w{json yaml}.include?(format.to_s)
+      return :json if FORMAT_HEADERS[:json].include?(@response.content_type)
+      return :yaml if FORMAT_HEADERS[:yaml].include?(@response.content_type)
+      nil
+    end
+  end
+end