geminfo 0.1.0 → 0.1.1

data/path/gems/lumberjack-1.0.9/lib/lumberjack/device/log_file.rb

@@ -1,18 +0,0 @@
-require 'fileutils'
-
-module Lumberjack
-  class Device
-    # This is a logging device that appends log entries to a file.
-    class LogFile < Writer
-      # The absolute path of the file being logged to.
-      attr_reader :path
-      
-      # Create a logger to the file at +path+. Options are passed through to the Writer constructor.
-      def initialize(path, options = {})
-        @path = File.expand_path(path)
-        FileUtils.mkdir_p(File.dirname(@path))
-        super(File.new(@path, 'a', :encoding => "ascii-8bit"), options)
-      end
-    end
-  end
-end

data/path/gems/lumberjack-1.0.9/lib/lumberjack/device/null.rb

@@ -1,15 +0,0 @@
-require 'date'
-
-module Lumberjack
-  class Device
-    # This is a logging device that produces no output. It can be useful in
-    # testing environments when log file output is not useful.
-    class Null < Device
-      def initialize(*args)
-      end
-      
-      def write(entry)
-      end
-    end
-  end
-end

data/path/gems/lumberjack-1.0.9/lib/lumberjack/device/rolling_log_file.rb

@@ -1,110 +0,0 @@
-module Lumberjack
-  class Device
-    # This is an abstract class for a device that appends entries to a file and periodically archives
-    # the existing file and starts a one. Subclasses must implement the roll_file? and archive_file_suffix
-    # methods.
-    #
-    # The <tt>:keep</tt> option can be used to specify a maximum number of rolled log files to keep.
-    # Older files will be deleted based on the time they were created. The default is to keep all files.
-    class RollingLogFile < LogFile
-      attr_reader :path
-      attr_accessor :keep
-      
-      def initialize(path, options = {})
-        @path = File.expand_path(path)
-        @keep = options[:keep]
-        super(path, options)
-        @file_inode = stream.lstat.ino rescue nil
-        @@rolls = []
-      end
-      
-      # Returns a suffix that will be appended to the file name when it is archived.. The suffix should
-      # change after it is time to roll the file. The log file will be renamed when it is rolled.
-      def archive_file_suffix
-        raise NotImplementedError
-      end
-      
-      # Return +true+ if the file should be rolled.
-      def roll_file?
-        raise NotImplementedError
-      end
-      
-      protected
-      
-      # This method will be called after a file has been rolled. Subclasses can
-      # implement code to reset the state of the device. This method is thread safe.
-      def after_roll
-      end
-      
-      # Handle rolling the file before flushing.
-      def before_flush # :nodoc:
-        path_inode = File.lstat(path).ino rescue nil
-        if path_inode != @file_inode
-          @file_inode = path_inode
-          reopen_file
-        else
-          roll_file! if roll_file?
-        end
-      end
-
-      private
-
-      def reopen_file
-        old_stream = stream
-        self.stream = File.open(path, 'a')
-        stream.sync = true
-        @file_inode = stream.lstat.ino rescue nil
-        old_stream.close
-      end
-      
-      # Roll the log file by renaming it to the archive file name and then re-opening a stream to the log
-      # file path. Rolling a file is safe in multi-threaded or multi-process environments.
-      def roll_file! #:nodoc:
-        do_once(stream) do
-          archive_file = "#{path}.#{archive_file_suffix}"
-          stream.flush
-          current_inode = File.stat(path).ino rescue nil
-          if @file_inode && current_inode == @file_inode && !File.exist?(archive_file) && File.exist?(path)
-            begin
-              File.rename(path, archive_file)
-              after_roll
-              cleanup_files!
-            rescue SystemCallError
-              # Ignore rename errors since it indicates the file was already rolled
-            end
-          end
-          reopen_file
-        end
-      rescue => e
-        STDERR.write("Failed to roll file #{path}: #{e.inspect}\n#{e.backtrace.join("\n")}\n")
-      end
-    end
-    
-    def cleanup_files!
-      if keep
-        files = Dir.glob("#{path}.*").collect{|f| [f, File.ctime(f)]}.sort{|a,b| b.last <=> a.last}.collect{|a| a.first}
-        if files.size > keep
-          files[keep, files.length].each do |f|
-            File.delete(f)
-          end
-        end
-      end
-    end
-    
-    def do_once(file)
-      begin
-        file.flock(File::LOCK_EX)
-      rescue SystemCallError
-        # Most likely can't lock file because the stream is closed
-        return
-      end
-      begin
-        verify = file.lstat rescue nil
-        # Execute only if the file we locked is still the same one that needed to be rolled
-        yield if verify && verify.ino == @file_inode && verify.size > 0
-      ensure
-        file.flock(File::LOCK_UN) rescue nil
-      end
-    end
-  end
-end

data/path/gems/lumberjack-1.0.9/lib/lumberjack/device/size_rolling_log_file.rb

@@ -1,60 +0,0 @@
-module Lumberjack
-  class Device
-    # This is a log device that appends entries to a file and rolls the file when it reaches a specified
-    # size threshold. When a file is rolled, it will have an number extension appended to the file name.
-    # For example, if the log file is named production.log, the first time it is rolled it will be renamed
-    # production.log.1, then production.log.2, etc.
-    class SizeRollingLogFile < RollingLogFile
-      attr_reader :max_size
-      
-      # Create an new log device to the specified file. The maximum size of the log file is specified with
-      # the <tt>:max_size</tt> option. The unit can also be specified: "32K", "100M", "2G" are all valid.
-      def initialize(path, options = {})
-        @max_size = options[:max_size]
-        if @max_size.is_a?(String)
-          if @max_size.match(/^(\d+(\.\d+)?)([KMG])?$/i)
-            @max_size = $~[1].to_f
-            units = $~[3].to_s.upcase
-            case units
-            when "K"
-              @max_size *= 1024
-            when "M"
-              @max_size *= 1024 ** 2
-            when "G"
-              @max_size *= 1024 ** 3
-            end
-            @max_size = @max_size.round
-          else
-            raise ArgumentError.new("illegal value for :max_size (#{@max_size})")
-          end
-        end
-        
-        super
-      end
-
-      def archive_file_suffix
-        next_archive_number.to_s
-      end
-
-      def roll_file?
-        stream.stat.size > @max_size
-      rescue SystemCallError => e
-        false
-      end
-      
-      protected
-      
-      # Calculate the next archive file name extension.
-      def next_archive_number # :nodoc:
-        max = 0
-        Dir.glob("#{path}.*").each do |filename|
-          if filename.match(/\.\d+$/)
-            suffix = filename.split('.').last.to_i
-            max = suffix if suffix > max
-          end
-        end
-        max + 1
-      end
-    end
-  end
-end

data/path/gems/lumberjack-1.0.9/lib/lumberjack/device/writer.rb

@@ -1,129 +0,0 @@
-module Lumberjack
-  class Device
-    # This logging device writes log entries as strings to an IO stream. By default, messages will be buffered
-    # and written to the stream in a batch when the buffer is full or when +flush+ is called.
-    class Writer < Device
-      DEFAULT_FIRST_LINE_TEMPLATE = "[:time :severity :progname(:pid) #:unit_of_work_id] :message".freeze
-      DEFAULT_ADDITIONAL_LINES_TEMPLATE = "#{Lumberjack::LINE_SEPARATOR}> [#:unit_of_work_id] :message".freeze
-
-      # The size of the internal buffer. Defaults to 32K.
-      attr_reader :buffer_size
-      
-      # Internal buffer to batch writes to the stream.
-      class Buffer # :nodoc:
-        attr_reader :size
-        
-        def initialize
-          @values = []
-          @size = 0
-        end
-        
-        def <<(string)
-          @values << string
-          @size += string.size
-        end
-        
-        def empty?
-          @values.empty?
-        end
-        
-        def join(delimiter)
-          @values.join(delimiter)
-        end
-        
-        def clear
-          @values = []
-          @size = 0
-        end
-      end
-      
-      # Create a new device to write log entries to a stream. Entries are converted to strings
-      # using a Template. The template can be specified using the <tt>:template</tt> option. This can
-      # either be a Proc or a string that will compile into a Template object.
-      #
-      # If the template is a Proc, it should accept an LogEntry as its only argument and output a string.
-      #
-      # If the template is a template string, it will be used to create a Template. The
-      # <tt>:additional_lines</tt> and <tt>:time_format</tt> options will be passed through to the
-      # Template constuctor.
-      #
-      # The default template is <tt>"[:time :severity :progname(:pid) #:unit_of_work_id] :message"</tt>
-      # with additional lines formatted as <tt>"\n [#:unit_of_work_id] :message"</tt>. The unit of
-      # work id will only appear if it is present.
-      #
-      # The size of the internal buffer in bytes can be set by providing <tt>:buffer_size</tt> (defaults to 32K).
-      def initialize(stream, options = {})
-        @lock = Mutex.new
-        @stream = stream
-        @stream.sync = true if @stream.respond_to?(:sync=)
-        @buffer = Buffer.new
-        @buffer_size = (options[:buffer_size] || 0)
-        template = (options[:template] || DEFAULT_FIRST_LINE_TEMPLATE)
-        if template.respond_to?(:call)
-          @template = template
-        else
-          additional_lines = (options[:additional_lines] || DEFAULT_ADDITIONAL_LINES_TEMPLATE)
-          @template = Template.new(template, :additional_lines => additional_lines, :time_format => options[:time_format])
-        end
-      end
-      
-      # Set the buffer size in bytes. The device will only be physically written to when the buffer size
-      # is exceeded.
-      def buffer_size=(value)
-        @buffer_size = value
-        flush
-      end
-      
-      # Write an entry to the stream. The entry will be converted into a string using the defined template.
-      def write(entry)
-        string = @template.call(entry)
-        @lock.synchronize do
-          @buffer << string
-        end
-        flush if @buffer.size >= buffer_size
-      end
-      
-      # Close the underlying stream.
-      def close
-        flush
-        stream.close
-      end
-      
-      # Flush the underlying stream.
-      def flush
-        @lock.synchronize do
-          before_flush
-          unless @buffer.empty?
-            out = @buffer.join(Lumberjack::LINE_SEPARATOR) << Lumberjack::LINE_SEPARATOR
-            begin
-              stream.write(out)
-              stream.flush
-            rescue => e
-              $stderr.write("#{e.class.name}: #{e.message}#{' at ' + e.backtrace.first if e.backtrace}")
-              $stderr.write(out)
-              $stderr.flush
-            end
-            @buffer.clear
-          end
-        end
-      end
-      
-      protected
-      
-      # Callback method that will be executed before data is written to the stream. Subclasses
-      # can override this method if needed.
-      def before_flush
-      end
-      
-      # Set the underlying stream.
-      def stream=(stream)
-        @stream = stream
-      end
-      
-      # Get the underlying stream.
-      def stream
-        @stream
-      end
-    end
-  end
-end

data/path/gems/lumberjack-1.0.9/lib/lumberjack/formatter.rb

@@ -1,81 +0,0 @@
-module Lumberjack
-  # This class controls the conversion of log entry messages into strings. This allows you
-  # to log any object you want and have the logging system worry about converting it into a string.
-  #
-  # Formats are added to a Formatter by associating them with a class using the +add+ method. Formats
-  # are any object that responds to the +call+ method.
-  #
-  # By default, all object will be converted to strings using their inspect method except for Strings
-  # and Exceptions. Strings are not converted and Exceptions are converted using the ExceptionFormatter.
-  class Formatter
-    load File.expand_path("../formatter/exception_formatter.rb", __FILE__)
-    load File.expand_path("../formatter/inspect_formatter.rb", __FILE__)
-    load File.expand_path("../formatter/pretty_print_formatter.rb", __FILE__)
-    load File.expand_path("../formatter/string_formatter.rb", __FILE__)
-    
-    def initialize
-      @class_formatters = {}
-      @_default_formatter = InspectFormatter.new
-      add(Object, @_default_formatter)
-      add(String, :string)
-      add(Exception, :exception)
-    end
-    
-    # Add a formatter for a class. The formatter can be specified as either an object
-    # that responds to the +call+ method or as a symbol representing one of the predefined
-    # formatters, or as a block to the method call.
-    #
-    # The predefined formatters are: <tt>:inspect</tt>, <tt>:string</tt>, <tt>:exception</tt>, and <tt>:pretty_print</tt>.
-    #
-    # === Examples
-    #
-    #   # Use a predefined formatter
-    #   formatter.add(MyClass, :pretty_print)
-    #
-    #   # Pass in a formatter object
-    #   formatter.add(MyClass, Lumberjack::Formatter::PrettyPrintFormatter.new)
-    #
-    #   # Use a block
-    #   formatter.add(MyClass){|obj| obj.humanize}
-    #
-    #   # Add statements can be chained together
-    #   formatter.add(MyClass, :pretty_print).add(YourClass){|obj| obj.humanize}
-    def add(klass, formatter = nil, &block)
-      formatter ||= block
-      if formatter.is_a?(Symbol)
-        formatter_class_name = "#{formatter.to_s.gsub(/(^|_)([a-z])/){|m| $~[2].upcase}}Formatter"
-        formatter = Formatter.const_get(formatter_class_name).new
-      end
-      @class_formatters[klass] = formatter
-      self
-    end
-    
-    # Remove the formatter associated with a class. Remove statements can be chained together.
-    def remove(klass)
-      @class_formatters.delete(klass)
-      self
-    end
-    
-    # Format a message object as a string.
-    def format(message)
-      formatter_for(message.class).call(message)
-    end
-    
-    # Hack for compatibility with Logger::Formatter
-    def call(severity, timestamp, progname, msg)
-      "#{format(msg)}\n"
-    end    
-
-    private
-    
-    # Find the formatter for a class by looking it up using the class hierarchy.
-    def formatter_for(klass) #:nodoc:
-      while klass != nil do
-        formatter = @class_formatters[klass]
-        return formatter if formatter
-        klass = klass.superclass
-      end
-      @_default_formatter
-    end
-  end
-end

data/path/gems/lumberjack-1.0.9/lib/lumberjack/formatter/exception_formatter.rb

@@ -1,12 +0,0 @@
-module Lumberjack
-  class Formatter
-    # Format an exception including the backtrace.
-    class ExceptionFormatter
-      def call(exception)
-        message = "#{exception.class.name}: #{exception.message}"
-        message << "#{Lumberjack::LINE_SEPARATOR}  #{exception.backtrace.join("#{Lumberjack::LINE_SEPARATOR}  ")}" if exception.backtrace
-        message
-      end
-    end
-  end
-end

data/path/gems/lumberjack-1.0.9/lib/lumberjack/formatter/inspect_formatter.rb

@@ -1,10 +0,0 @@
-module Lumberjack
-  class Formatter
-    # Format an object by calling +inspect+ on it.
-    class InspectFormatter
-      def call(obj)
-        obj.inspect
-      end
-    end
-  end
-end