sawmill 0.0.1

data/lib/sawmill/rotater/date_based_log_file.rb

@@ -0,0 +1,145 @@
+# -----------------------------------------------------------------------------
+# 
+# Sawmill formatter utility
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2009 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+module Sawmill
+  
+  class Rotater
+    
+    
+    # A rotation strategy that produces log files with the date stamp in the
+    # file name. For example, you could set up an hourly log rotation that
+    # produces the following files:
+    # 
+    #  rails.2009-10-09-22.log
+    #  rails.2009-10-09-23.log
+    #  rails.2009-10-10-00.log
+    #  rails.2009-10-10-01.log
+    #  etc...
+    # 
+    # The exact format depends on the rotation frequency, which could be
+    # anywhere from yearly to hourly. For settings less frequent than
+    # hourly, fewer fields will appear in the date stamp portion of the
+    # file name.
+    
+    class DateBasedLogFile
+      
+      
+      # Create a new date-based log file rotation strategy.
+      # 
+      # Recognized options include:
+      # 
+      # <tt>:turnover_frequency</tt>::
+      #   How often the log files should turn over. Allowed values are:
+      #   <tt>:yearly</tt>, <tt>:monthly</tt>, <tt>:daily</tt>, 
+      #   <tt>:hourly</tt>, and <tt>:never</tt>.
+      # <tt>:dirname</tt>::
+      #   The directory for the logfiles to be output.
+      #   If not specified, the current working directory is used.
+      # <tt>:prefix</tt>::
+      #   The logfile name prefix.
+      #   In the filename "rails.2009-10-11.log", the prefix is "rails".
+      #   If not specified, defaults to "sawmill".
+      # <tt>:suffix</tt>::
+      #   The logfile name prefix.
+      #   In the filename "rails.2009-10-11.log", the suffix is ".log".
+      #   If not specified, defaults to ".log".
+      # <tt>:local_timezone</tt>::
+      #   If true, use the local timezone to create datestamps.
+      #   The default is to use UTC.
+      
+      def initialize(options_)
+        @turnover_frequency = options_[:turnover_frequency] || :none
+        dirname_ = options_[:dirname] || Dir.getwd
+        @prefix = File.join(dirname_, options_[:prefix] || 'sawmill')
+        @suffix = options_[:suffix] || '.log'
+        @local_timezone = options_[:local_timezone]
+        @date_pattern =
+          case @turnover_frequency
+          when :yearly then "%Y"
+          when :monthly then "%Y-%m"
+          when :daily then "%Y-%m-%d"
+          when :hourly then "%Y-%m-%d-%H"
+          else nil
+          end
+      end
+      
+      
+      # Implements the rotation strategy contract.
+      
+      def preferred_handle
+        if @date_pattern
+          time_ = Time.now
+          time_.utc unless @local_timezone
+          time_.strftime(@date_pattern)
+        else
+          ''
+        end
+      end
+      
+      
+      # Implements the rotation strategy contract.
+      
+      def open_handle(handle_)
+        if @date_pattern
+          path_ = "#{@prefix}.#{handle_}#{@suffix}"
+        else
+          path_ = @prefix+@suffix
+        end
+        file_ = File.open(path_, File::CREAT | File::WRONLY | File::APPEND)
+        file_.sync = true
+        file_
+      end
+      
+      
+      # Implements the rotation strategy contract.
+      
+      def close_handle(handle_, io_)
+        io_.close
+      end
+      
+      
+      # Implements the rotation strategy contract.
+      
+      def before_write
+      end
+      
+      
+    end
+    
+    
+  end
+  
+end

data/lib/sawmill/rotater/shifting_log_file.rb

@@ -0,0 +1,166 @@
+# -----------------------------------------------------------------------------
+# 
+# Sawmill formatter utility
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2009 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+module Sawmill
+  
+  class Rotater
+    
+    
+    # A rotation strategy that "shifts" log files by appending index numbers
+    # to the filename when the file reaches a certain size or age. So when
+    # the file "foo.log" is ready to rotate, it is renamed "foo.log.0", and
+    # a new "foo.log" is started. When that one is ready to rotate, the
+    # oldest "foo.log.0" is shifted down to "foo.log.1", "foo.log" is
+    # renamed to "foo.log.0", and a new "foo.log" is started. So the oldest
+    # logfile is always the one with the largest number suffix, and the
+    # file currently being written to has no suffix.
+    # This is a common rotation strategy for many unix tools.
+    
+    class ShiftingLogFile
+      
+      
+      # Create a new shifting log file rotation strategy.
+      # 
+      # Recognized options include:
+      # 
+      # <tt>:dirname</tt>::
+      #   The directory for the logfiles to be output.
+      #   If not specified, the current working directory is used.
+      # <tt>:filename</tt>::
+      #   The logfile name.
+      #   If not specified, defaults to "sawmill.log".
+      # <tt>:max_logfile_size</tt>::
+      #   A logfile will try to rotate once it has reached this size in
+      #   bytes. If not specified, the file size is not checked.
+      # <tt>:shift_period</tt>::
+      #   A logfile will try to rotate once it has been in service for
+      #   this many seconds. This parameter also recognizes the values
+      #   <tt>:yearly</tt>, <tt>:monthly</tt>, <tt>:daily</tt>, 
+      #   and <tt>:hourly</tt>. If not specified, the file's age is
+      #   not checked.
+      # <tt>:history_size</tt>::
+      #   The maximum number of old logfiles (files with indexes) to
+      #   keep. Files beyond this history size will be automatically
+      #   deleted. Default is 1. This value must be at least 1.
+      
+      def initialize(options_)
+        @max_logfile_size = options_[:max_logfile_size]
+        @shift_period = options_[:shift_period]
+        case @shift_period
+        when :yearly
+          @shift_period = 60*60*24*365
+        when :monthly
+          @shift_period = 60*60*24*30
+        when :daily
+          @shift_period = 60*60*24
+        when :hourly
+          @shift_period = 60*60
+        end
+        @history_size = options_[:history_size].to_i
+        @history_size = 1 if @history_size < 1 && (@max_logfile_size || @shift_period)
+        dirname_ = options_[:dirname] || Dir.getwd
+        @normal_path = File.join(dirname_, options_[:filename] || 'sawmill.log')
+        @preferred_handle = 0
+        @open_handles = {}
+        @last_shift = Time.now
+      end
+      
+      
+      # Implements the rotation strategy contract.
+      
+      def preferred_handle
+        @preferred_handle
+      end
+      
+      
+      # Implements the rotation strategy contract.
+      
+      def open_handle(handle_)
+        if handle_ == @preferred_handle
+          path_ = @normal_path
+        else
+          path_ = "#{@normal_path}.#{@preferred_handle-handle_-1}"
+        end
+        file_ = File.open(path_, File::CREAT | File::WRONLY | File::APPEND)
+        file_.sync = true
+        @open_handles[handle_] = true
+        file_
+      end
+      
+      
+      # Implements the rotation strategy contract.
+      
+      def close_handle(handle_, io_)
+        io_.close
+        if @preferred_handle - handle_ > @history_size
+          File.delete("#{@normal_path}.#{@preferred_handle-handle_-1}") rescue nil
+        end
+        @open_handles.delete(handle_)
+        nil
+      end
+      
+      
+      # Implements the rotation strategy contract.
+      
+      def before_write
+        return unless @max_logfile_size || @shift_period
+        turnover_ = false
+        if @max_logfile_size && File.file?(@normal_path) && File.size(@normal_path) > @max_logfile_size
+          turnover_ = true
+        end
+        if @shift_period && (Time.now - @last_shift) > @shift_period
+          turnover_ = true
+        end
+        if turnover_
+          max_ = @preferred_handle - @open_handles.keys.min + 1
+          max_ = @history_size if max_ < @history_size
+          File.delete("#{@normal_path}.#{max_-1}") rescue nil
+          (max_-1).downto(1) do |index_|
+            File.rename("#{@normal_path}.#{index_-1}", "#{@normal_path}.#{index_}") rescue nil
+          end
+          File.rename("#{@normal_path}", "#{@normal_path}.0") rescue nil
+          @preferred_handle += 1
+          @last_shift = Time.now
+        end
+      end
+      
+      
+    end
+    
+    
+  end
+  
+end

data/lib/sawmill/rotater.rb

@@ -0,0 +1,236 @@
+# -----------------------------------------------------------------------------
+# 
+# Sawmill log rotation utility
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2009 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+require 'thread'
+
+
+module Sawmill
+  
+  
+  # The Sawmill Rotater provides log rotation services for logfile
+  # formatting, supporting several different log rotation strategies.
+  # 
+  # The formatter implemented by Sawmill::EntryProcessor::Format already
+  # recognizes a Rotater as a supported destination, and automatically
+  # interfaces with it to ensure that log records aren't split into
+  # multiple files by rotation.
+  # 
+  # You may also interface with a rotater manually. The core of rotater
+  # usage is the Channel, which lets you ensure that groups of log
+  # entries end up in the same log file regardless of log rotation.
+  # Generally, to use a rotater, you obtain one or more channels and
+  # write formatted entries to them, either telling them explicitly
+  # where the allowable file breaks are, or by letting the rotater
+  # break the file anywhere it wants. See the create_channel method
+  # and the Channel object for more details.
+  
+  class Rotater
+    
+    
+    # Create a rotater using the given rotation strategy.
+    # See Sawmill::Rotater::DateBasedLogFile and
+    # Sawmill::Rotater::ShiftingLogFile for examples of common strategies.
+    # 
+    # The rotation strategy can be passed as an object or as a class with a
+    # set of options that will be used to instantiate the strategy.
+    # In addition to those options, the following options are recognized:
+    # 
+    # <tt>:omit_directives</tt>::
+    #   If true, omit standard logfile directives. Default is false.
+    
+    def initialize(io_manager_, opts_={})
+      @omit_directives = opts_.delete(:omit_directives)
+      if io_manager_.kind_of?(Class)
+        @io_manager = io_manager_.new(opts_)
+      else
+        @io_manager = io_manager_
+      end
+      @handles ||= {}
+      @mutex ||= Monitor.new
+    end
+    
+    
+    # Create a new Channel for this Rotater. See Sawmill::Rotater::Channel
+    # for details on the Channel object.
+    # 
+    # The following options are recognized:
+    # 
+    # <tt>:auto_rotate</tt>::
+    #   Put the channel in auto-rotate mode. In this mode, the rotater is
+    #   allowed to rotate the logfile at any time for that channel. It is
+    #   the equivalent of calling check_rotate on the channel after every
+    #   write. Default is false.
+    
+    def create_channel(opts_={})
+      Channel.new(self, opts_)
+    end
+    
+    
+    def _obtain_handle  # :nodoc:
+      handle_ = @io_manager.preferred_handle
+      if @handles.include?(handle_)
+        @handles[handle_][2] += 1
+      else
+        io_ = @io_manager.open_handle(handle_)
+        unless @omit_directives
+          io_.write("# sawmill_format: version=1\n")
+        end
+        @handles[handle_] = [handle_, io_, 1]
+      end
+      handle_
+    end
+    
+    
+    def _release_handle(handle_)  # :nodoc:
+      info_ = @handles[handle_]
+      info_[2] -= 1
+      if info_[2] == 0
+        @io_manager.close_handle(handle_, info_[1])
+        @handles.delete(handle_)
+      end
+      nil
+    end
+    
+    
+    def _check_rotate_handle(handle_)  # :nodoc:
+      if handle_ != @io_manager.preferred_handle
+        _release_handle(handle_)
+        _obtain_handle
+      else
+        handle_
+      end
+    end
+    
+    
+    def _do_open  # :nodoc:
+      @mutex.synchronize do
+        _obtain_handle
+      end
+    end
+    
+    
+    def _do_write(handle_, str_, auto_rotate_)  # :nodoc:
+      @mutex.synchronize do
+        @io_manager.before_write
+        if auto_rotate_
+          handle_ = _check_rotate_handle(handle_)
+        end
+        info_ = @handles[handle_]
+        info_[1].write(str_)
+        handle_
+      end
+    end
+    
+    
+    def _do_close(handle_)  # :nodoc:
+      @mutex.synchronize do
+        _release_handle(handle_)
+      end
+    end
+    
+    
+    def _do_check_rotate(handle_)  # :nodoc:
+      @mutex.synchronize do
+        _check_rotate_handle(handle_)
+      end
+    end
+    
+    
+    # A channel is a lightweight object that responds to the write and close
+    # methods; that is, it is sufficient for Sawmill::Formatter.
+    # 
+    # When a channel is opened, it locks down a path to the logfile and
+    # ensures that the logfile will not rotate out from under it; that is,
+    # writes to a channel are ensured to end up in the same physical file.
+    # 
+    # You may choose, at intervals, to explicitly tell the channel that it
+    # is okay to rotate the logfile now, by calling check_rotate.
+    # 
+    # You must close a channel when you are done with it. Closing a channel
+    # does not close the underlying logfile, but instead tells the rotater
+    # that you are done with this channel and that the logfile is free to
+    # rotate independent of it.
+    # 
+    # You may have any number of channels open at any time, each on a
+    # different rotation schedule. Each may possibly be writing to different
+    # files in the rotation at any time, but this is all done automatically
+    # behind the scenes.
+    
+    class Channel
+      
+      def initialize(rotater_, opts_={})  # :nodoc:
+        @rotater = rotater_
+        @auto_rotate = opts_[:auto_rotate]
+        @io_handle = @rotater._do_open
+      end
+      
+      
+      # Write a string to this channel.
+      
+      def write(str_)
+        if @io_handle
+          @rotater._do_write(@io_handle, str_, @auto_rotate)
+        end
+      end
+      
+      
+      # Close this channel, telling the rotater that this channel no longer
+      # needs to constrain the log rotation.
+      
+      def close
+        if @io_handle
+          @rotater._do_close(@io_handle)
+          @io_handle = nil
+        end
+      end
+      
+      
+      # Manually tell the rotater that this channel is at a stopping point
+      # and that the log file may rotate at this time.
+      
+      def check_rotate
+        if @io_handle
+          @io_handle = @rotater._do_check_rotate(@io_handle)
+        end
+      end
+      
+      
+    end
+    
+    
+  end
+  
+end

data/lib/sawmill/util/queue.rb

@@ -0,0 +1,138 @@
+# -----------------------------------------------------------------------------
+# 
+# Sawmill entry stream processor interface
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2009 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+module Sawmill
+  
+  module Util
+    
+    
+    # A simple queue that optionally provides an upper size limit.
+    
+    class Queue
+      
+      
+      # Recognized options include:
+      # 
+      # <tt>:limit</tt>::
+      #   Size limit for the queue. If not specified, the queue can grow
+      #   arbitrarily large.
+      # <tt>:drop_oldest</tt>::
+      #   If set to true, then when an item is added to a full queue, the
+      #   oldest item is dropped. If set to false or not specified, then
+      #   the new item is not added.
+      
+      def initialize(opts_={})
+        limit_ = opts_[:limit]
+        @buffer = limit_ ? ::Array.new(limit_) : []
+        @push_ptr = limit_ ? 0 : nil
+        @pop_ptr = nil
+        @drop_oldest = limit_ && opts_[:drop_oldest]
+      end
+      
+      
+      # Attempt to push an item on the queue.
+      # 
+      # If the queue is full, then the behavior is determined by the
+      # :drop_oldest setting provided to the constructor.
+      # 
+      # Returns true if the object was pushed on the queue, or false if the
+      # queue was full.
+      
+      def enqueue(object_)
+        result_ = true
+        if @push_ptr
+          if @pop_ptr == @push_ptr
+            if @drop_oldest
+              @pop_ptr += 1
+              @pop_ptr = 0 if @pop_ptr == @buffer.size
+              result_ = false
+            else
+              return false
+            end
+          elsif @pop_ptr.nil?
+            @pop_ptr = @push_ptr
+          end
+          @buffer[@push_ptr] = object_
+          @push_ptr += 1
+          @push_ptr = 0 if @push_ptr == @buffer.size
+        else
+          @buffer.push(object_)
+        end
+        result_
+      end
+      
+      
+      # Return the oldest item in the queue, or nil if the queue is empty.
+      
+      def dequeue
+        if @push_ptr
+          if @pop_ptr
+            object_ = @buffer[@pop_ptr]
+            @pop_ptr += 1
+            @pop_ptr = 0 if @pop_ptr == @buffer.size
+            @pop_ptr = nil if @pop_ptr == @push_ptr
+            object_
+          else
+            nil
+          end
+        else
+          @buffer.shift
+        end
+      end
+      
+      
+      # Return the size of the queue, which is 0 if the queue is empty.
+      
+      def size
+        if @push_ptr
+          if @pop_ptr
+            value_ = @push_ptr - @pop_ptr
+            value_ > 0 ? value_ : value_ + @buffer.size
+          else
+            0
+          end
+        else
+          @buffer.size
+        end
+      end
+      
+      
+    end
+    
+    
+  end
+  
+end