vagrant-shell 0.2.9 → 0.2.11

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/log4r-1.1.10/lib/log4r/configurator.rb

@@ -1,224 +0,0 @@
-# :include: rdoc/configurator
-#
-# == Other Info
-#
-# Version:: $Id$
-
-require "log4r/logger"
-require "log4r/outputter/staticoutputter"
-require "log4r/lib/xmlloader"
-require "log4r/logserver"
-require "log4r/outputter/remoteoutputter"
-
-# TODO: catch unparsed parameters #{FOO} and die
-module Log4r
-  # Gets raised when Configurator encounters bad XML.
-  class ConfigError < Exception
-  end
-
-  # See log4r/configurator.rb
-  class Configurator
-    include REXML if HAVE_REXML
-    @@params = Hash.new
-
-    # Get a parameter's value
-    def self.[](param); @@params[param] end
-    # Define a parameter with a value
-    def self.[]=(param, value); @@params[param] = value end
-
-    # Sets the custom levels. This method accepts symbols or strings.
-    #
-    #   Configurator.custom_levels('My', 'Custom', :Levels)
-    #
-    # Alternatively, you can specify custom levels in XML:
-    # 
-    #   <log4r_config>
-    #     <pre_config>
-    #       <custom_levels>
-    #         My, Custom, Levels
-    #       </custom_levels>
-    #       ...
-
-    def self.custom_levels(*levels)
-      return Logger.root if levels.size == 0
-      for i in 0...levels.size
-        name = levels[i].to_s
-        if name =~ /\s/ or name !~ /^[A-Z]/
-          raise TypeError, "#{name} is not a valid Ruby Constant name", caller
-        end
-      end
-      Log4r.define_levels *levels
-    end
-
-    # Given a filename, loads the XML configuration for Log4r.
-    def self.load_xml_file(filename)
-      detect_rexml
-      actual_load Document.new(File.new(filename))
-    end
-
-    # You can load a String XML configuration instead of a file.
-    def self.load_xml_string(string)
-      detect_rexml
-      actual_load Document.new(string)
-    end
-
-    #######
-    private
-    #######
-
-    def self.detect_rexml
-      unless HAVE_REXML
-        raise LoadError,
-        "Need REXML to load XML configuration", caller[1..-1]
-      end
-    end
-
-    def self.actual_load(doc)
-      confignode = doc.elements['//log4r_config']
-      if confignode.nil?
-        raise ConfigError, 
-        "<log4r_config> element not defined", caller[1..-1]
-      end
-      decode_xml(confignode)
-    end
-    
-    def self.decode_xml(doc)
-      decode_pre_config(doc.elements['pre_config'])
-      doc.elements.each('outputter') {|e| decode_outputter(e)}
-      doc.elements.each('logger') {|e| decode_logger(e)}
-      doc.elements.each('logserver') {|e| decode_logserver(e)}
-    end
-
-    def self.decode_pre_config(e)
-      return Logger.root if e.nil?
-      decode_custom_levels(e.elements['custom_levels'])
-      global_config(e.elements['global'])
-      global_config(e.elements['root'])
-      decode_parameters(e.elements['parameters'])
-      e.elements.each('parameter') {|p| decode_parameter(p)}
-    end
-
-    def self.decode_custom_levels(e)
-      return Logger.root if e.nil? or e.text.nil?
-      begin custom_levels *Log4rTools.comma_split(e.text)
-      rescue TypeError => te
-        raise ConfigError, te.message, caller[1..-4]
-      end
-    end
-    
-    def self.global_config(e)
-      return if e.nil?
-      globlev = e.value_of 'level'
-      return if globlev.nil?
-      lev = LNAMES.index(globlev)     # find value in LNAMES
-      Log4rTools.validate_level(lev, 4)  # choke on bad level
-      Logger.global.level = lev
-    end
-
-    def self.decode_parameters(e)
-      e.elements.each{|p| @@params[p.name] = p.text} unless e.nil?
-    end
-
-    def self.decode_parameter(e)
-      @@params[e.value_of('name')] = e.value_of 'value'
-    end
-
-    def self.decode_outputter(e)
-      # fields
-      name = e.value_of 'name'
-      type = e.value_of 'type'
-      level = e.value_of 'level'
-      only_at = e.value_of 'only_at'
-      # validation
-      raise ConfigError, "Outputter missing name", caller[1..-3] if name.nil?
-      raise ConfigError, "Outputter missing type", caller[1..-3] if type.nil?
-      Log4rTools.validate_level(LNAMES.index(level)) unless level.nil?
-      only_levels = []
-      unless only_at.nil?
-        for lev in Log4rTools.comma_split(only_at)
-          alev = LNAMES.index(lev)
-          Log4rTools.validate_level(alev, 3)
-          only_levels.push alev
-        end
-      end
-      formatter = decode_formatter(e.elements['formatter'])
-      # build the eval string
-      buff = "Outputter[name] = #{type}.new name"
-      buff += ",:level=>#{LNAMES.index(level)}" unless level.nil?
-      buff += ",:formatter=>formatter" unless formatter.nil?
-      params = decode_hash_params(e)
-      buff += "," + params.join(',') if params.size > 0
-      begin eval buff
-      rescue Exception => ae
-        raise ConfigError, 
-        "Problem creating outputter: #{ae.message}", caller[1..-3]
-      end
-      Outputter[name].only_at *only_levels if only_levels.size > 0
-      Outputter[name]
-    end
-
-    def self.decode_formatter(e)
-      return nil if e.nil?
-      type = e.value_of 'type' 
-      raise ConfigError, "Formatter missing type", caller[1..-4] if type.nil?
-      buff = "#{type}.new " + decode_hash_params(e).join(',')
-      begin return eval(buff)
-      rescue Exception => ae
-        raise ConfigError,
-        "Problem creating outputter: #{ae.message}", caller[1..-4]
-      end
-    end
-
-    ExcludeParams = %w{formatter level name type}
-
-    # Does the fancy parameter to hash argument transformation
-    def self.decode_hash_params(e)
-      buff = []
-      e.attributes.each_attribute {|p| 
-        next if ExcludeParams.include? p.name
-        buff << ":" + p.name + "=>" + paramsub(p.value)
-      }
-      e.elements.each {|p| 
-        next if ExcludeParams.include? p.name
-        buff << ":" + p.name + "=>" + paramsub(p.text)
-      }
-      buff
-    end
-    
-    # Substitues any #{foo} in the XML with Parameter['foo']
-    def self.paramsub(str)
-      return nil if str.nil?
-      @@params.each {|param, value| str.sub! '#{'+param+'}', value}
-      "'" + str + "'"
-    end
-
-    def self.decode_logger(e)
-      l = Logger.new e.value_of('name')
-      decode_logger_common(l, e)
-    end
-
-    def self.decode_logserver(e)
-      return unless HAVE_REXML
-      name = e.value_of 'name'
-      uri = e.value_of 'uri'
-      l = LogServer.new name, uri
-      decode_logger_common(l, e)
-    end
-
-    def self.decode_logger_common(l, e)
-      level = e.value_of 'level'
-      additive = e.value_of 'additive'
-      trace = e.value_of 'trace'
-      l.level = LNAMES.index(level) unless level.nil?
-      l.additive = additive unless additive.nil?
-      l.trace = trace unless trace.nil?
-      # and now for outputters
-      outs = e.value_of 'outputters'
-      Log4rTools.comma_split(outs).each {|n| l.add n.strip} unless outs.nil?
-      e.elements.each('outputter') {|e|
-        name = (e.value_of 'name' or e.text)
-        l.add Outputter[name]
-      }
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/log4r-1.1.10/lib/log4r/formatter/formatter.rb

@@ -1,105 +0,0 @@
-# :include: ../rdoc/formatter
-#
-# Version:: $Id$
-
-require "singleton"
-
-require "log4r/base"
-
-module Log4r
-
-  # Formatter is an abstract class and a null object
-  class Formatter
-    def initialize(hash={})
-    end
-    # Define this method in a subclass to format data.
-    def format(logevent)
-    end
-  end
-
-  # SimpleFormatter produces output like this:
-  # 
-  #   WARN loggername> Danger, Will Robinson, danger!
-  #
-  # Does not write traces and does not inspect objects.
-  
-  class SimpleFormatter < Formatter
-    def format(event)
-      sprintf("%*s %s> %s\n", MaxLevelLength, LNAMES[event.level], 
-              event.name, event.data)
-    end
-  end
-
-  # BasicFormatter produces output like this:
-  # 
-  #   WARN loggername: I dropped my Wookie!
-  #   
-  # Or like this if trace is on:
-  # 
-  #   WARN loggername(file.rb at 12): Hot potato!
-  #   
-  # Also, it will pretty-print any Exception it gets and
-  # +inspect+ everything else.
-  #
-  # Hash arguments include:
-  #
-  # +depth+::  How many lines of the stacktrace to display.
-
-  class BasicFormatter < SimpleFormatter
-    @@basicformat = "%*s %s"
-
-    def initialize(hash={})
-      @depth = (hash[:depth] or hash['depth'] or 7).to_i
-    end
-    
-    def format(event)
-      buff = sprintf(@@basicformat, MaxLevelLength, LNAMES[event.level],
-             event.name)
-      buff << (event.tracer.nil? ? "" : "(#{event.tracer[0]})") + ": "
-      buff << format_object(event.data) + "\n"
-      buff
-    end
-
-    # Formats data according to its class:
-    #
-    # String::     Prints it out as normal.
-    # Exception::  Produces output similar to command-line exceptions.
-    # Object::     Prints the type of object, then the output of
-    #              +inspect+. An example -- Array: [1, 2, 3]
-
-    def format_object(obj)
-      if obj.kind_of? Exception
-        return "Caught #{obj.class}: #{obj.message}\n\t" +\
-               (obj.backtrace.nil? ? [] : obj.backtrace[0...@depth]).join("\n\t")
-      elsif obj.kind_of? String
-        return obj
-      else # inspect the object
-        return "#{obj.class}: #{obj.inspect}"
-      end
-    end
-  end
-
-  # Formats objects the same way irb does:
-  #
-  #   loggername:foo.rb in 12> 
-  #   [1, 3, 4]
-  #   loggername:foo.rb in 13> 
-  #   {1=>"1"}
-  #
-  # Strings don't get inspected. just printed. The trace is optional.
-
-  class ObjectFormatter < Formatter
-    def format(event)
-      buff = event.logger.name
-      buff << (event.tracer.nil? ? "" : ":#{event.tracer[0]}") + ">\n"
-      buff << (event.data.kind_of?(String) ? event.data : event.data.inspect)
-      buff << "\n"
-    end
-  end
-  
-  # Outputters that don't define a Formatter will get this, which
-  # is currently BasicFormatter
-  class DefaultFormatter < BasicFormatter
-  end
-  
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/log4r-1.1.10/lib/log4r/formatter/log4jxmlformatter.rb

@@ -1,65 +0,0 @@
-# :include: ../rdoc/log4jxmlformatter
-#
-# == Other Info
-#
-# Version:: $Id$
-
-require "log4r/formatter/formatter"
-
-require "rubygems"
-begin
-  require "builder"
-rescue LoadError
-  puts "builder gem is required to use log4jxmlformatter, i.e. gem install builder"
-end
-
-module Log4r
-
-  class Log4jXmlFormatter < BasicFormatter
-    
-    def format(logevent)
-      logger = logevent.fullname.gsub('::', '.')
-      timestamp = (Time.now.to_f * 1000).to_i
-      level = LNAMES[logevent.level]
-      message = format_object(logevent.data)
-      exception = message if logevent.data.kind_of? Exception
-      file, line, method = parse_caller(logevent.tracer[0]) if logevent.tracer
-      
-      builder = Builder::XmlMarkup.new
-      xml = builder.log4j :event, :logger => logger,
-                                  :timestamp => timestamp,
-                                  :level => level,
-                                  :thread => '' do |e|
-              e.log4j :NDC, NDC.get
-              e.log4j :message, message
-              e.log4j :throwable, exception if exception
-              e.log4j :locationInfo, :class => '',
-                                     :method => method,
-                                     :file => file,
-                                     :line => line
-              e.log4j :properties do |p|
-                MDC.get_context.each do |key, value|
-                  p.log4j :data, :name => key, :value => value
-                end
-              end
-            end
-      xml
-    end
-
-    #######
-    private
-    #######
-
-    def parse_caller(line)
-      if /^(.+?):(\d+)(?::in `(.*)')?/ =~ line
-        file = Regexp.last_match[1]
-        line = Regexp.last_match[2].to_i
-        method = Regexp.last_match[3]
-        [file, line, method]
-      else
-        []
-      end
-    end
-  end
-
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/log4r-1.1.10/lib/log4r/formatter/patternformatter.rb

@@ -1,145 +0,0 @@
-# :include: ../rdoc/patternformatter
-#
-# == Other Info
-#
-# Version:: $Id$
-
-require "log4r/formatter/formatter"
-require "log4r/GDC"
-require "log4r/MDC"
-require "log4r/NDC"
-  
-module Log4r
-  # See log4r/formatter/patternformatter.rb
-  class PatternFormatter < BasicFormatter
-  
-    # Arguments to sprintf keyed to directive letters<br>
-    # %c - event short name<br>
-    # %C - event fullname<br>
-    # %d - date<br>
-    # %g - Global Diagnostic Context (GDC)<br>
-    # %t - trace<br>
-    # %m - message<br>
-    # %h - thread name<br>
-    # %p - process ID aka PID<br>
-    # %M - formatted message<br>
-    # %l - Level in string form<br>
-    # %x - Nested Diagnostic Context (NDC)<br>
-    # %X - Mapped Diagnostic Context (MDC), syntax is "%X{key}"<br>
-    # %% - Insert a %<br>
-    DirectiveTable = {
-      "c" => 'event.name',
-      "C" => 'event.fullname',
-      "d" => 'format_date',
-      "g" => 'Log4r::GDC.get()',
-      "t" => '(event.tracer.nil? ? "no trace" : event.tracer[0])',
-      "T" => '(event.tracer.nil? ? "no trace" : event.tracer[0].split(File::SEPARATOR)[-1])',
-      "m" => 'event.data',
-      "h" => '(Thread.current[:name] or Thread.current.to_s)',
-      "p" => 'Process.pid.to_s',
-      "M" => 'format_object(event.data)',
-      "l" => 'LNAMES[event.level]',
-      "x" => 'Log4r::NDC.get()',
-      "X" => 'Log4r::MDC.get("DTR_REPLACE")',
-      "%" => '"%"'
-    }
-  
-    # Matches the first directive encountered and the stuff around it.
-    #
-    # * $1 is the stuff before directive or "" if not applicable
-    # * $2 is the directive group or nil if there's none
-    # * $3 is the %#.# match within directive group
-    # * $4 is the .# match which we don't use (it's there to match properly)
-    # * $5 is the directive letter
-    # * $6 is the stuff after the directive or "" if not applicable
-    # * $7 is the remainder
-  
-    DirectiveRegexp = /([^%]*)((%-?\d*(\.\d+)?)([cCdgtTmhpMlxX%]))?(\{.+?\})?(.*)/
-  
-    # default date format
-    ISO8601 = "%Y-%m-%d %H:%M:%S"
-    
-    attr_reader :pattern, :date_pattern, :date_method
-  
-    # Accepts the following hash arguments (either a string or a symbol):
-    #
-    # [<tt>pattern</tt>]         A pattern format string.
-    # [<tt>date_pattern</tt>]    A Time#strftime format string. See the
-    #                            Ruby Time class for details.
-    # [+date_method+]     
-    #   As an option to date_pattern, specify which
-    #   Time.now method to call. For 
-    #   example, +usec+ or +to_s+.
-    #   Specify it as a String or Symbol.
-    #
-    # The default date format is ISO8601, which looks like this:
-    # 
-    #   yyyy-mm-dd hh:mm:ss    =>    2001-01-12 13:15:50
-  
-    def initialize(hash={})
-      super(hash)
-      @pattern = (hash['pattern'] or hash[:pattern] or nil)
-      @date_pattern = (hash['date_pattern'] or hash[:date_pattern] or nil)
-      @date_method = (hash['date_method'] or hash[:date_method] or nil)
-      @date_pattern = ISO8601 if @date_pattern.nil? and @date_method.nil?
-      PatternFormatter.create_format_methods(self)
-    end
-
-    # PatternFormatter works by dynamically defining a <tt>format</tt> method
-    # based on the supplied pattern format. This method contains a call to 
-    # Kernel#sptrintf with arguments containing the data requested in
-    # the pattern format.
-    #
-    # How is this magic accomplished? First, we visit each directive
-    # and change the %#.# component to  %#.#s. The directive letter is then 
-    # used to cull an appropriate entry from the DirectiveTable for the
-    # sprintf argument list. After assembling the method definition, we
-    # run module_eval on it, and voila.
-    
-    def PatternFormatter.create_format_methods(pf) #:nodoc:
-      # first, define the format_date method
-      if pf.date_method
-        module_eval "def pf.format_date; Time.now.#{pf.date_method}; end"
-      else
-        module_eval <<-EOS
-          def pf.format_date
-            Time.now.strftime "#{pf.date_pattern}"
-          end
-        EOS
-      end
-      # and now the main format method
-      ebuff = "def pf.format(event)\n sprintf(\""
-      _pattern = pf.pattern.dup
-      args = [] # the args to sprintf which we'll append to ebuff lastly
-      while true # work on each match in turn
-        match = DirectiveRegexp.match _pattern
-        ebuff << match[1] unless match[1].empty?
-        break if match[2].nil?
-        # deal with the directive by inserting a %#.#s where %#.# is copied
-        # directy from the match
-        ebuff << match[3] + "s"
-
-	if ( match[5] == 'X' && match[6] != nil ) then
-
-	  # MDC matches, need to be able to handle String, Symbol or Number
-	  match6sub = /[\{\}\"]/
-	  mdcmatches = match[6].match /\{(:?)(\d*)(.*)\}/
-
-	  if ( mdcmatches[1] == "" && mdcmatches[2] == "" )
-	    match6sub = /[\{\}]/ # don't remove surrounding "'s if String
-	  end
-	  
-	  args <<
-	    DirectiveTable[match[5]].gsub("DTR_REPLACE", match[6]).gsub(match6sub,'')
-	else
-	  args << DirectiveTable[match[5]]  # cull the data for our argument list
-	end
-        break if match[7].empty?
-        _pattern = match[7]
-      end
-      ebuff << '\n", ' + args.join(', ') + ")\n"
-      ebuff << "end\n"
-      module_eval ebuff
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/log4r-1.1.10/lib/log4r/lib/drbloader.rb

@@ -1,52 +0,0 @@
-#:nodoc:
-module Log4r
-  begin 
-    require 'romp'
-    HAVE_ROMP = true
-  rescue LoadError
-    HAVE_ROMP = false
-  end
-  
-  if HAVE_ROMP
-
-    module ROMPServer #:nodoc:
-      private
-      def start_server(_uri, accept)
-        @server = ROMP::Server.new(_uri, accept) # what if accept is nil?
-        @server.bind(self, "Log4r::LogServer")
-      end
-    end
-
-    module ROMPClient #:nodoc:
-      private
-      def connect
-        begin
-          @client = ROMP::Client.new(@uri, false)
-          @remote_logger = @client.resolve("Log4r::LogServer")
-        rescue Exception => e
-          Logger.log_internal(-2) {
-            "RemoteOutputter '#{@name}' failed to connect to #{@uri}!"
-          }
-          Logger.log_internal {e}
-          self.level = OFF
-        end
-      end
-      # we use propagated = true
-      def send_buffer
-        begin
-          @buff.each {|levent| 
-            lname = LNAMES[levent.level].downcase
-            @remote_logger.oneway(lname, levent, true)
-          }
-        rescue Exception => e
-          Logger.log_internal(-2) {"RemoteOutputter '#{@name}' can't log!"}
-          Logger.log_internal {e}
-          self.level = OFF
-        ensure @buff.clear
-        end
-      end
-    end
-
-  end
-
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/log4r-1.1.10/lib/log4r/lib/xmlloader.rb

@@ -1,24 +0,0 @@
-#:nodoc:
-module Log4r
-  begin
-    require 'rexml/document'
-    HAVE_REXML = true
-  rescue LoadError
-    HAVE_REXML = false
-  end
-end
-
-if Log4r::HAVE_REXML
-  module REXML #:nodoc: all
-    class Element
-      def value_of(elmt)
-        val = attributes[elmt]
-        if val.nil?
-          sub = elements[elmt]
-          val = sub.text unless sub.nil?
-        end
-        val
-      end
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/log4r-1.1.10/lib/log4r/logevent.rb

@@ -1,28 +0,0 @@
-# :nodoc:
-module Log4r
-
-  ##
-  # LogEvent wraps up all the miscellaneous data associated with a logging
-  # statement. It gets passed around to the varied components of Log4r and
-  # should be of interest to those creating extensions.
-  #
-  # Data contained: 
-  #
-  # [level]    The integer level of the log event. Use LNAMES[level]
-  #            to get the actual level name.
-  # [tracer]   The execution stack returned by <tt>caller</tt> at the
-  #            log event. It is nil if the invoked Logger's trace is false.
-  # [data]     The object that was passed into the logging method.
-  # [name]     The name of the logger that was invoked.
-  # [fullname] The fully qualified name of the logger that was invoked.
-  #
-  # Note that creating timestamps is a task left to formatters.
-
-  class LogEvent
-    attr_reader :level, :tracer, :data, :name, :fullname
-    def initialize(level, logger, tracer, data)
-      @level, @tracer, @data = level, tracer, data
-      @name, @fullname = logger.name, logger.fullname
-    end
-  end
-end