boson 0.4.0 → 1.0.0

data/deps.rip

@@ -1,2 +0,0 @@
-hirb >=0.5.0
-alias >=0.2.2

data/lib/boson/commands.rb

@@ -1,7 +0,0 @@
-# Module under which most library modules are evaluated.
-module Boson::Commands
-  # Used for defining namespaces.
-  module Namespace; end
-end
-require 'boson/commands/core'
-require 'boson/commands/web_core'

data/lib/boson/commands/core.rb

@@ -1,77 +0,0 @@
-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 = {
-      'render'=>{:desc=>"Render any object using Hirb"},
-      'menu'=>{:desc=>"Provide a menu to multi-select elements from a given array"},
-      '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 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
-
-  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/web_core.rb

@@ -1,153 +0,0 @@
-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

data/lib/boson/index.rb

@@ -1,48 +0,0 @@
-module Boson
-  # This class manages indexing/storing all commands and libraries. See RepoIndex for details
-  # about the index created for each Repo.
-  module Index
-    extend self
-    # Array of indexes, one per repo in Boson.repos.
-    def indexes
-      @indexes ||= Boson.repos.map {|e| RepoIndex.new(e) }
-    end
-
-    # Updates all repo indexes.
-    def update(options={})
-      indexes.each {|e| e.update(options) }
-    end
-
-    #:stopdoc:
-    def read
-      indexes.each {|e| e.read }
-    end
-
-    def find_library(command, object=false)
-      indexes.each {|e|
-        (lib = e.find_library(command, object)) and return lib
-      }
-      nil
-    end
-
-    def find_command(command)
-      indexes.each {|e|
-        (cmd = Command.find(command, e.commands)) and return(cmd)
-      }
-      nil
-    end
-
-    def commands
-      indexes.map {|e| e.commands}.flatten
-    end
-
-    def libraries
-      indexes.map {|e| e.libraries}.flatten
-    end
-
-    def all_main_methods
-      indexes.map {|e| e.all_main_methods}.flatten
-    end
-    #:startdoc:
-  end
-end

data/lib/boson/inspectors/argument_inspector.rb

@@ -1,97 +0,0 @@
-# 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
-  # Returns same argument arrays as scrape_with_eval but argument defaults haven't been evaluated.
-  def scrape_with_text(file_string, meth)
-    tabspace = "[ \t]"
-    if match = /^#{tabspace}*def#{tabspace}+(?:\w+\.)?#{Regexp.quote(meth)}#{tabspace}*($|(?:\(|\s+)([^\n\)]+)\s*\)?\s*$)/.match(file_string)
-      (match.to_a[2] || '').strip.split(/\s*,\s*/).map {|e| e.split(/\s*=\s*/)}
-    end
-  end
-
-  # 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::Runner.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::Runner.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/inspectors/comment_inspector.rb

@@ -1,100 +0,0 @@
-module Boson
-  # Scrapes comments right before a method for its attributes. Method attributes must begin with '@' i.e.:
-  #    # @desc Does foo
-  #    # @options :verbose=>true
-  #    def foo(options={})
-  #
-  # Some rules about these attributes:
-  # * Attribute definitions can span multiple lines. When a new attribute starts a line or the comments end,
-  #   then a definition ends.
-  # * If no @desc is found in the comment block, then the first comment line directly above the method
-  #   is assumed to be the value for @desc. This means that no multi-line attribute definitions can occur
-  #   without a description since the last line is assumed to be a description.
-  # * options, option, config and render_options attributes can take any valid ruby since they're evaled in
-  #   their module's context.
-  # * desc attribute is not evaled and is simply text to be set as a string.
-  #
-  # This module was inspired by
-  # {pragdave}[http://github.com/pragdavespc/rake/commit/45231ac094854da9f4f2ac93465ed9b9ca67b2da].
-  module CommentInspector
-    extend self
-    EVAL_ATTRIBUTES = [:options, :render_options, :config]
-
-    # Given a method's file string, line number and defining module, returns a hash
-    # of attributes defined for that method.
-    def scrape(file_string, line, mod, attribute=nil)
-      hash = scrape_file(file_string, line) || {}
-      options = (arr = hash.delete(:option)) ? parse_option_comments(arr, mod) : {}
-      hash.select {|k,v| v && (attribute.nil? || attribute == k) }.each do |k,v|
-        hash[k] = EVAL_ATTRIBUTES.include?(k) ? eval_comment(v.join(' '), mod, k) : v.join(' ')
-      end
-      (hash[:options] ||= {}).merge!(options) if !options.empty?
-      attribute ? hash[attribute] : hash
-    end
-
-    #:stopdoc:
-    def parse_option_comments(arr, mod)
-      arr.inject({}) {|t,e|
-        key, val = e.join(' ').split(/\s*,\s*/, 2)
-        if val
-          key = key.sub(/^\s*:/, '').to_sym
-          t[key] = eval_comment(val, mod, 'option')
-        end
-        t
-      }
-    end
-
-    def eval_comment(value, mod, mattr)
-      value = "{#{value}}" if !value[/^\s*\{/] && value[/=>/]
-      mod.module_eval(value)
-    rescue Exception
-      if Runner.debug
-        warn "DEBUG: Error while evaluating @#{mattr} in module #{mod.to_s[/\w+$/]}:\n  " +
-          $!.message.gsub(/\n/, "\n  ")
-      end
-      nil
-    end
-
-    # Scrapes a given string for commented @keywords, starting with the line above the given line
-    def scrape_file(file_string, line)
-      lines = file_string.split("\n")
-      saved = []
-      i = line -2
-      while lines[i] =~ /^\s*#\s*(\S+)/ && i >= 0
-        saved << lines[i]
-        i -= 1
-      end
-
-      saved.empty? ? {} : splitter(saved.reverse)
-    end
-
-    def splitter(lines)
-      hash = {}
-      i = 0
-      # to magically make the last comment a description
-      unless lines.any? {|e| e =~  /^\s*#\s*@desc/ }
-        last_line = lines.pop
-        hash[:desc] = (last_line =~ /^\s*#\s*([^@\s].*)/) ? [$1] : nil
-        lines << last_line unless hash[:desc]
-      end
-
-      option = []
-      while i < lines.size
-        while lines[i] =~ /^\s*#\s*@(\w+)\s*(.*)/
-          key = $1.to_sym
-          hash[key] = [$2]
-          i += 1
-          while lines[i] =~ /^\s*#\s*([^@\s].*)/
-            hash[key] << $1
-            i+= 1
-          end
-          option << hash.delete(:option) if key == :option
-        end
-        i += 1
-      end
-      hash[:option] = option if !option.empty?
-      hash
-    end
-    #:startdoc:
-  end
-end