class DumbLogger

# File lib/dumb-logger/version.rb, line 70
def self.VERSION
  return self.const_get('VERSION')
end

# File lib/dumb-logger.rb, line 53
def finalize(obj)
  if (obj.instance_variable_get(:@options)[:needs_close])
    obj.sink.close
  end
end

# File lib/dumb-logger.rb, line 406
def initialize(args={})
  unless (args.kind_of?(Hash))
    raise ArgumentError.new("#{self.class.name}.new requires a hash")
  end
  @options = {
    :labels           => {},
  }
  #
  # Here are the default settings for a new instance with no
  # arguments.  We put 'em here so they don't show up in docco under
  # the Constants heading.
  #
  default_opts        = {
    :append           => true,
    :level_style      => USE_LEVELS,
    :loglevel         => 0,
    :prefix           => '',
    :sink             => :$stderr,
  }
  #
  # Make a new hash merging the user arguments on top of the
  # defaults.  This avoids altering the user's hash.
  #
  temp_opts           = default_opts.merge(args)
  #
  # Throw out any option keys we don't recognise.
  #
  temp_opts.delete_if { |k,v| (! CONSTRUCTOR_OPTIONS.include?(k)) }
  #
  # Do loglevel stuff.  We're going to run this through the writer
  # method, since it has argument validation code.
  #
  # If the user wants to use bitmasks, then the :logmask argument
  # key takes precedence over the :loglevel one.
  #
  self.level_style = temp_opts[:level_style]
  temp_opts.delete(:level_style)
  if (self.log_masks?)
    temp_opts[:loglevel] = temp_opts[:logmask] if (temp_opts.key?(:logmask))
  end
  temp_opts.delete(:logmask)
  #
  # Now go through the remaining options and handle them.  If the
  # option has an associated writer method, call it -- otherwise,
  # just load it into the `@options` hash.
  #
  temp_opts.each do |opt,val|
    wmethod   = (opt.to_s + '=').to_sym
    if (self.respond_to?(wmethod))
      self.send(wmethod, val)
    else
      @options[opt] = val
    end
  end
end

# File lib/dumb-logger/version.rb, line 60
def self.version
  return @version
end

# File lib/dumb-logger.rb, line 486
def append
  return (@options[:append] ? true : false)
end

# File lib/dumb-logger.rb, line 490
def append=(arg)
  @options[:append]   = (arg ? true : false)
  return self.append
end

# File lib/dumb-logger.rb, line 500
def append?
  return self.append
end

# File lib/dumb-logger.rb, line 199
def label_levels(labelhash)
  unless (labelhash.kind_of?(Hash))
    raise ArgumentError.new('level labels must be supplied as a hash')
  end
  unless (labelhash.values.all? { |o| o.kind_of?(Integer) })
    raise ArgumentError.new('labeled levels must be integers')
  end
  newhash = labelhash.inject({}) { |memo,(label,level)|
    label_sym = label.to_s.downcase.to_sym
    memo[label_sym] = level
    memo
  }
  @options[:labels].merge!(newhash)
  newhash.each do |label,level|
    self.define_singleton_method(label) do |*args|
      (scratch, newargs) = args.partition { |o| o.kind_of?(Integer) }
      return self.message(level, *newargs)
    end
  end
  return newhash
end

# File lib/dumb-logger.rb, line 232
def labeled_levels
  return Hash[@options[:labels].sort].freeze
end

# File lib/dumb-logger.rb, line 96
def level_style
  return @options[:level_style]
end

# File lib/dumb-logger.rb, line 100
def level_style=(style)
  unless ([ USE_LEVELS, USE_BITMASK ].include?(style))
    raise ArgumentError.new('invalid loglevel style')
  end
  @options[:level_style] = style
end

# File lib/dumb-logger.rb, line 153
def log_levels?
  return (@options[:level_style] == USE_LEVELS) ? true : false
end

# File lib/dumb-logger.rb, line 173
def log_masks?
  return (@options[:level_style] == USE_BITMASK) ? true : false
end

# File lib/dumb-logger.rb, line 137
def loglevel
  return @options[:loglevel].to_i
end

# File lib/dumb-logger.rb, line 128
def loglevel=(arg)
  unless (arg.respond_to?(:to_i))
    raise ArgumentError.new('loglevels are integers')
  end
  @options[:loglevel] = arg.to_i
  return @options[:loglevel]
end

# File lib/dumb-logger.rb, line 559
def message(*args)
  #
  # Extract any symbols, hashes, and integers from the argument
  # list.  This makes the calling format very flexible.
  #
  (symopts, args)     = args.partition { |elt| elt.kind_of?(Symbol) }
  #
  # Pull out any symbols that are actually names for levels (or
  # masks).  The args variable now contains no Symbol elements.
  #
  symlevels           = (symopts & self.labeled_levels.keys).map { |o|
    self.labeled_levels[o]
  }.compact
  #
  # Now any option hashes.
  #
  (hashopts, args)    = args.partition { |elt| elt.kind_of?(Hash) }
  hashopts            = hashopts.reduce(:merge) || {}
  #
  # All hashes have been removed from the args array, and merged
  # together into a single *per*-message options hash.
  #

  #
  # Now some fun stuff.  The appropriate loglevel/mask for this
  # message can come from
  #
  # * Integers in the argument array (last one takes precedence); or
  # * Values of symbolic level/mask labels (again, last one takes
  #   precedence, and overrides any explicit integers); or
  # * Any `:level` or `:mask` value in the options hash (which one
  #   of those takes precedence depends on the current logging
  #   style).
  #
  (lvls, args)        = args.partition { |elt| elt.kind_of?(Integer) }
  if (self.log_levels?)
    level             = hashopts[:level] || hashopts[:mask]
  else
    level             = hashopts[:mask] || hashopts[:level]
  end
  if (level.nil?)
    if (self.log_levels?)
      level           = symlevels.empty? ? lvls.last : symlevels.min
    else
      level           = symlevels.empty? ? lvls.last : symlevels.reduce(:|)
    end
  end
  level               ||= 0
  #
  # We should now have a minimum logging level, or an ORed bitmask,
  # in variable 'level'.  Time to see if it meets our criteria.
  #
  unless (level.zero?)
    if (self.log_levels?)
      return nil if (self.loglevel < level)
    elsif (self.log_masks?)
      level &=  self.logmask
      return nil if (level.zero?)
    end
  end
  #
  # Looks like the request loglevel/mask is within the logger's
  # requirements, so let's build the output string.
  #
  prefix_text         = hashopts[:prefix] || self.prefix
  text                = prefix_text + args.join("\n#{prefix_text}")
  #
  # The :return option is overridden by :newline, and renamed to it
  # if :newline isn't already in the options hash.
  #
  if (hashopts.key?(:return) && (! hashopts.key?(:newline)))
    hashopts[:newline] = hashopts[:return]
    hashopts.delete(:return)
  end
  unless (hashopts.key?(:newline))
    hashopts[:newline]= (! symopts.include?(NO_NL))
  end
  text << "\n" if (hashopts[:newline])
  #
  # Okey.  If the output stream is marked 'volatile', it's one of
  # our special sinks and we need to evaluate it on every write.
  #
  stream = @options[:volatile] ? eval(self.sink.to_s) : @sink_io
  #
  # If this is our first write to this sink, make sure we position
  # properly before writing!
  #
  if (@options[:needs_seek] && stream.respond_to?(:seek))
    poz       = (self.append? \
                 ? IO::SEEK_END \
                 : IO::SEEK_SET)
    begin
      #
      # Can't seek on some things, so just catch the exception and
      # ignore it.
      #
      stream.seek(0, poz)
    rescue Errno::ESPIPE => exc
      #
      # Do nothing..
      #
    end
    @options[:needs_seek] = false
  end
  stream.write(text)
  stream.flush if (@options[:volatile])
  #
  # All done!  Return the level, or mask bits, that resulted in the
  # text being transmitted.
  #
  return level
end

# File lib/dumb-logger.rb, line 258
def options
  return @options.dup.freeze
end

# File lib/dumb-logger.rb, line 275
def prefix
  return @options[:prefix]
end

# File lib/dumb-logger.rb, line 279
def prefix=(arg)
  @options[:prefix] = arg.to_s
  return self.prefix
end

# File lib/dumb-logger.rb, line 297
def reopen
  return false unless (@options[:needs_close] && self.sink.kind_of?(String))
  raise IOError.new('sink stream is already closed') if (@sink_io.closed?)
  @sink_io.reopen(self.sink, (self.append? ? 'a' : 'w'))
  @sink_io.sync = true if (@sink_io.respond_to?(:sync=))
  return true
end

# File lib/dumb-logger.rb, line 333
def sink
  return @options[:sink]
end

# File lib/dumb-logger.rb, line 337
def sink=(arg)
  if (@options[:needs_close] \
      && @sink_io.respond_to?(:close) \
      && (! [ self.sink, @sink_io ].include?(arg)))
    @sink_io.close unless (@sink_io.closed?)
    @sink_io = nil
  end

  @options[:volatile] = false
  if (arg.kind_of?(IO))
    #
    # If it's an IO, then we assume it's already open.
    #
    @options[:sink] = @sink_io = arg
    @options[:needs_close] = false
  elsif (SPECIAL_SINKS.include?(arg))
    #
    # If it's one of our special symbols, we don't actually do
    # anything except record the fact -- because they get
    # interpreted at each #message call.
    #
    @options[:sink] = arg
    @sink_io = nil
    @options[:volatile] = true
  else
    #
    # If it's a string, we treat it as a file name, open it, and
    # flag it for closing later.
    #
    @options[:sink] = arg
    @sink_io = File.open(@options[:sink], (self.append? ? 'a' : 'w'))
    @options[:needs_close] = true
  end
  #
  # Note that you cannot seek-position the $stdout or $stderr
  # streams.  However, there doesn't seem to be a clear way to
  # determine that, so we'll wrap the actual seek (in {#message}) in
  # a rescue block.
  #
  @options[:needs_seek] = true
  @sink_io.sync = true if (@sink_io.respond_to?(:sync=))
  return self.sink
end