bosonson 0.304.1

data/lib/boson/commands.rb

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

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

@@ -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

data/lib/boson/index.rb

@@ -0,0 +1,48 @@
+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/inspector.rb

@@ -0,0 +1,120 @@
+module Boson
+  # Scrapes and processes method attributes with the inspectors (MethodInspector, CommentInspector
+  # and ArgumentInspector) and hands off the data to FileLibrary objects.
+  #
+  # === Method Attributes
+  # Method attributes refer to (commented) Module methods placed before a command's method
+  # in a FileLibrary module:
+  #   module SomeMod
+  #      # @render_options :fields=>%w{one two}
+  #      # @config :alias=>'so'
+  #      options :verbose=>:boolean
+  #      option :count, :numeric
+  #      # Something descriptive perhaps
+  #      def some_method(opts)
+  #        # ...
+  #      end
+  #   end
+  #
+  # Method attributes serve as configuration for a method's command. All attributes should only be called once per
+  #   method except for option. Available method attributes:
+  # * config: Hash to define any command attributes (see Command.new).
+  # * desc: String to define a command's description for a command. Defaults to first commented line above a method.
+  # * options: Hash to define an OptionParser object for a command's options.
+  # * option: Option name and value to be merged in with options. See OptionParser for what an option value can be.
+  # * render_options: Hash to define an OptionParser object for a command's local/global render options (see View).
+  #
+  # When deciding whether to use commented or normal Module methods, remember that commented Module methods allow
+  # independence from Boson (useful for testing). See CommentInspector for more about commented method attributes.
+  module Inspector
+    extend self
+    attr_reader :enabled
+
+    # Enable scraping by overridding method_added to snoop on a library while it's
+    # loading its methods.
+    def enable
+      @enabled = true
+      body = MethodInspector::ALL_METHODS.map {|e|
+        %[def #{e}(*args)
+            Boson::MethodInspector.#{e}(self, *args)
+          end]
+      }.join("\n") +
+      %[
+        def new_method_added(method)
+          Boson::MethodInspector.new_method_added(self, method)
+        end
+
+        alias_method :_old_method_added, :method_added
+        alias_method :method_added, :new_method_added
+      ]
+    ::Module.module_eval body
+    end
+
+    # Disable scraping method data.
+    def disable
+      ::Module.module_eval %[
+        Boson::MethodInspector::ALL_METHODS.each {|e| remove_method e }
+        alias_method :method_added, :_old_method_added
+      ]
+      @enabled = false
+    end
+
+    # Adds method attributes scraped for the library's module to the library's commands.
+    def add_method_data_to_library(library)
+      @commands_hash = library.commands_hash
+      @library_file = library.library_file
+      MethodInspector.current_module = library.module
+      @store = MethodInspector.store
+      add_method_scraped_data
+      add_comment_scraped_data
+    end
+
+    #:stopdoc:
+    def add_method_scraped_data
+      (MethodInspector::METHODS + [:args]).each do |key|
+        (@store[key] || []).each do |cmd, val|
+          @commands_hash[cmd] ||= {}
+          add_valid_data_to_config(key, val, cmd)
+        end
+      end
+    end
+
+    def add_valid_data_to_config(key, value, cmd)
+      if valid_attr_value?(key, value)
+        add_scraped_data_to_config(key, value, cmd)
+      else
+        if Runner.debug
+          warn "DEBUG: Command '#{cmd}' has #{key.inspect} attribute with invalid value '#{value.inspect}'"
+        end
+      end
+    end
+
+    def add_scraped_data_to_config(key, value, cmd)
+      if value.is_a?(Hash)
+        if key == :config
+          @commands_hash[cmd] = Util.recursive_hash_merge value, @commands_hash[cmd]
+        else
+          @commands_hash[cmd][key] = Util.recursive_hash_merge value, @commands_hash[cmd][key] || {}
+        end
+      else
+        @commands_hash[cmd][key] ||= value
+      end
+    end
+
+    def valid_attr_value?(key, value)
+      return true if (klass = MethodInspector::METHOD_CLASSES[key]).nil?
+      value.is_a?(klass) || value.nil?
+    end
+
+    def add_comment_scraped_data
+      (@store[:method_locations] || []).select {|k,(f,l)| f == @library_file }.each do |cmd, (file, lineno)|
+        scraped = CommentInspector.scrape(FileLibrary.read_library_file(file), lineno, MethodInspector.current_module)
+        @commands_hash[cmd] ||= {}
+        MethodInspector::METHODS.each do |e|
+          add_valid_data_to_config(e, scraped[e], cmd)
+        end
+      end
+    end
+    #:startdoc:
+  end
+end

data/lib/boson/inspectors/argument_inspector.rb

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