dumb-logger 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a310511e9401162dbea1264cfc0688d9bd1b4fb
-  data.tar.gz: 811167e870e502ece41b9ec4a0172036c506ec84
+  metadata.gz: 97dcaa8c2a86896da031d59fce6d9e76629ae0ad
+  data.tar.gz: cc24b7b01e23defa63650a640f71d264dfa0d122
 SHA512:
-  metadata.gz: 3c6dc6168a885f2c18284fdc58cafa7cb14dee853795216007462e702717ca4530f1dc4268c25b90d6e2b755d5a5dd119d2613495a4a8a94f31fcf8b90e8fdfc
-  data.tar.gz: 1004d15fe2bf9e469e47fa90621821ef47ff877c41289c67b115a73357ab4fb62ddbd7cb1aca9453ee29bbec08545b064fcc9b39c4d2cf72bcb2495199e01e6b
+  metadata.gz: 1502f4709b0138d8618fdae48cde9e614c9371795734f6a8f8491f0ffbc923f626ff41d68301d6a52bc8d4312b5beeb32124cc0a2e71c10da37e5ed5d5145667
+  data.tar.gz: a01939fc773088661a1865147f6be643017227cd620a7d854b00784852c7174665c79e4fd54fef36b886a7561e7f29eae610b4ba970bd9c3c45f9d6d38452ace

data/features/output.feature

@@ -41,8 +41,20 @@ Feature: Test the output generated
     And stderr should contain exactly "a message"
     And stdout should contain exactly ""
 
-  Scenario: Single-line message with no newline (alternate)
-    When I invoke the logger with ("a message", :newline=>false)
+  Scenario: Single-line message with no newline (alternate 1)
+    When I invoke the logger with ("a message", {:newline=>false})
+    Then the return value should be 0
+    And stderr should contain exactly "a message"
+    And stdout should contain exactly ""
+
+  Scenario: Single-line message with no newline (alternate 2)
+    When I invoke the logger with ("a message", {:return=>false})
+    Then the return value should be 0
+    And stderr should contain exactly "a message"
+    And stdout should contain exactly ""
+
+  Scenario: Single-line message with :newline overriding :return
+    When I invoke the logger with ("a message", {:newline=>false,:return=>true})
     Then the return value should be 0
     And stderr should contain exactly "a message"
     And stdout should contain exactly ""
@@ -53,12 +65,24 @@ Feature: Test the output generated
     And stderr should contain exactly "line 1\nline 2"
     And stdout should contain exactly ""
 
-  Scenario: Multi-line message with no newline (alternate)
+  Scenario: Multi-line message with no newline (alternate 1)
     When I invoke the logger with ("line 1",{:newline=>false},"line 2")
     Then the return value should be 0
     And stderr should contain exactly "line 1\nline 2"
     And stdout should contain exactly ""
 
+  Scenario: Multi-line message with no newline (alternate 2)
+    When I invoke the logger with ("line 1",{:return=>false},"line 2")
+    Then the return value should be 0
+    And stderr should contain exactly "line 1\nline 2"
+    And stdout should contain exactly ""
+
+  Scenario: Multi-line message with :newline overriding :return
+    When I invoke the logger with ("line 1",{:return=>true,:newline=>false},"line 2")
+    Then the return value should be 0
+    And stderr should contain exactly "line 1\nline 2"
+    And stdout should contain exactly ""
+
   Scenario: Single-line message with instance prefix
     When I set the prefix to '[instance-prefix] '
     And I invoke the logger with ("a message")

data/lib/dumb-logger.rb

@@ -368,6 +368,13 @@ class DumbLogger
       @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                           # def sink=
@@ -504,21 +511,42 @@ class DumbLogger
   # @param [Array<Array,String,Symbol,Integer,Hash>] args
   #  * The last integer in the array will be treated as the report's
   #    loglevel; default is `0`.
+  #
+  #    **Overridden by `:level` or `:mask` in an options hash passed
+  #    to the method.**
   #  * Any `Array` elements in the arguments will be merged and the
   #    values interpreted as level labels (see {#label_levels}).  If
-  #    loglevels are bitmasks, the labeled levels are ORed together;
-  #    otherwise the lowest labeled level will be used for the message.
+  #    loglevels are bitmasks (see {#level_style}), the labeled levels
+  #    are `OR`ed together; otherwise the lowest labeled level will be
+  #    used for the message.
+  #
+  #    **Overridden by `:level` or `:mask` in an options hash passed
+  #    to the method.**
   #  * Any `Hash` elements in the array will be merged and will
   #    temporarily override instance-wide options -- *e.g.*,
-  #    `{ :prefix => 'alt' }` .
-  #  * If the `DumbLogger::NO_NL` value (a `Symbol`) appears in the
-  #    array, or a hash element of `:return => false`, the report will
-  #    not include a terminating newline (useful for
-  #    `"progress:..done"` reports).
+  #    `{ :prefix  => 'alt' }` .  Valid *per*-call options are:
+  #    * `:prefix  => String`
+  #    * `:level   => Integer`
+  #      (takes precedence over `:mask` if {#level_style} is {USE_LEVELS}.)
+  #    * `:mask    => Integer`
+  #      (takes precedence over `:level` if {#level_style} is {USE_BITMASK}.)
+  #    * `:newline => Boolean`
+  #      (takes precedence over {DumbLogger::NO_NL} in the argument list)
+  #    * `:return  => Boolean`
+  #      (alias for `:newline`; **deprecated after 1.0.0**)
+  #  * If the {DumbLogger::NO_NL} value (a `Symbol`) appears in the
+  #    array, or a hash element of `:newline => false` (or `:return =>
+  #    false`), the report will not include a terminating newline
+  #    (useful for `"progress:..done"` reports).
   #  * Any strings in the array are treated as text to be reported,
-  #    one _per_ line.  Each line will begin with the value of
-  #    #prefix, and only the final line is subject to the
-  #    DumbLogger::NO_NL special-casing.
+  #    one *per* line.  Each line will begin with the value of
+  #    logger's value of {#prefix} (or any overriding value set with
+  #    `:prefix` in a hash of options), and only the final line is
+  #    subject to the {DumbLogger::NO_NL} special-casing.
+  #
+  # @note
+  #  Use of the `:return` hash option is deprecated in versions after
+  #  1.0.0.  Use `:newline` instead.
   #
   # @return [nil,Integer]
   #  Returns either `nil` if the message's loglevel is higher than the
@@ -527,7 +555,7 @@ class DumbLogger
   #  If integer levels are being used, a non-`nil` return value is
   #  that of the message.  If bitmask levels are being used, the
   #  return value is a mask of the active level bits that applied to
-  #  the message -- *i.e.*, `msg_bits & logging_mask` .
+  #  the message -- *i.e.*, `message_mask & logging_mask` .
   #
   def message(*args)
     #
@@ -535,32 +563,110 @@ class DumbLogger
     # 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) || {}
-    (level, args)	= args.partition { |elt| elt.kind_of?(Integer) }
-    level		= level.last || hashopts[:level] || hashopts[:mask] || 0
-    cur_loglevel	= self.loglevel
-    cur_style		= self.level_style
+    #
+    # 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 ([ cur_loglevel, *symlevels ].min < level)
+        return nil if (self.loglevel < level)
       elsif (self.log_masks?)
-        level = [ level, *symlevels ].reduce(:|) & cur_loglevel
+        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                           # def message
 

data/lib/dumb-logger/version.rb

@@ -31,6 +31,15 @@ class DumbLogger
   @version	= @version.change(:major	=> 1,
                                   :tiny		=> 0)
 
+  #
+  # * Corrected & deprecated `:return` {#message} option key
+  # * Added seek-to on first write to a sink
+  # * Corrected (and documented) applicable level/mask determination
+  #   for {#message}
+  # * Added some tests for `:return` *versus* `:newline`
+  #
+  @version	= @version.bump(:tiny)
+
   #
   # How to advance the version number.
   #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dumb-logger
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Ken Coar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-06 00:00:00.000000000 Z
+date: 2015-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler