dumb-logger 1.0.0

data/dumb-logger.gemspec

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+#--
+#   Copyright © 2015 Ken Coar
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#++
+
+Proc.new {
+  libdir = File.join(File.dirname(__FILE__), 'lib')
+  xlibdir = File.expand_path(libdir)
+  $:.unshift(xlibdir) unless ($:.include?(libdir) || $:.include?(xlibdir))
+}.call
+require('dumb-logger/version')
+
+Gem::Specification.new do |spec|
+  spec.name          	= 'dumb-logger'
+  spec.version       	= DumbLogger::VERSION
+  spec.authors       	= [
+                           'Ken Coar',
+                          ]
+  spec.email         	= [
+                           'kcoar@redhat.com',
+                          ]
+  spec.summary       	= %q{Primitive level/mask-driven stream logger.}
+  spec.description   	= %q{Primitive no-frills level/mask-driven stream logger.}
+  spec.homepage      	= ''
+  spec.license       	= 'Apache 2.0'
+
+  spec.files         	= `git ls-files -z`.split("\x0")
+  spec.executables   	= spec.files.grep(%r!^bin/!) { |f| File.basename(f) }
+  spec.test_files    	= spec.files.grep(%r!^(test|spec|features)/!)
+  spec.require_paths 	= [
+                           'lib',
+                          ]
+
+  spec.add_development_dependency('bundler', '~> 1.7')
+  spec.add_development_dependency('rake', '~> 10.0')
+
+  spec.add_dependency('versionomy')
+end

data/features/attributes.feature

@@ -0,0 +1,70 @@
+Feature: Test default attributes and setting/pinging them
+  In order to use the basic functionality of the DumbLogger class
+  A developer
+  Should be able to manipulate all of the logger's attributes
+
+#  Things to test:
+#   o constructor
+#     - no args
+#     - :append => {true,false,bogus}
+#     - :level_style => {USE_LEVELS,USE_BITMASK,bogus}
+#     - :loglevel => {number,bogus}
+#     - :logmask => {number,bogus}
+#     - :prefix => {string,bogus}
+#     - :sink => {path,IO,bogus}
+
+  Background:
+    Given I have a DumbLogger object
+
+  Scenario: Check the defaults
+    Then the log-level should be 0
+    And the sink should be :$stderr
+    And the style should be DumbLogger::USE_LEVELS
+    And the prefix should be ''
+    And append-mode should be true
+
+  Scenario: Test setting the logging level to an integer
+    When I set attribute loglevel to 5
+    Then the return value should be 5
+    And the log-level should be 5
+
+  Scenario: Test setting the logging level to a float
+    When I set attribute loglevel to 5.7
+    Then the return value should be 5
+    And the log-level should be 5
+
+  Scenario: Test setting the logging level to a string
+    When I set attribute loglevel to "5"
+    Then the return value should be 5
+    And the log-level should be 5
+
+  Scenario: Test setting the logging level to something bogus
+    When I set attribute loglevel to Object
+    Then it should raise an exception of type ArgumentError
+    And the log-level should be 0
+
+  Scenario: Test setting the logging style
+    When I set attribute level_style to DumbLogger::USE_BITMASK
+    Then the return value should be DumbLogger::USE_BITMASK
+    And the style should be DumbLogger::USE_BITMASK
+
+  Scenario: Test setting the prefix
+    When I set attribute prefix to 'Testing: '
+    Then the return value should be 'Testing: '
+    And the prefix should be 'Testing: '
+
+  Scenario: Test turning off append-mode
+    When I set attribute append to false
+    Then the return value should be false
+    And append-mode should be false
+
+  Scenario: Test changing the sink to a path
+    When I set attribute 'sink' to '/dev/null'
+    Then the return value should be '/dev/null'
+    And the sink should be '/dev/null'
+
+  Scenario: Test changing the sink to stdout
+    When I set attribute 'sink' to :$stdout
+    Then the return value should be :$stdout
+    And the sink should be :$stdout
+

data/features/bitmasks.feature

@@ -0,0 +1,44 @@
+Feature: Test reporting using bitmasks
+  In order to use the basic functionality of the DumbLogger class
+  A developer
+  Should be able to assign meaning to bits in a mask
+
+  Background:
+    Given I have a DumbLogger object
+    And I set attribute 'sink' to :$stderr
+    And I set attribute level_style to DumbLogger::USE_BITMASK
+    And I set attribute loglevel to 0b01101
+
+  Scenario: Default Level-0 1-liner text always gets sent and returns 0)
+    When I invoke the logger with ("a message")
+    Then the return value should be 0
+    And stderr should contain exactly "a message\n"
+
+  Scenario: Default Level-0 multi-line text always gets sent and returns 0
+    When I invoke the logger with ("a message line 1","message line 2")
+    Then the return value should be 0
+    And stderr should contain exactly:
+      """
+      a message line 1
+      message line 2
+
+      """
+      #
+      # Note the final blank line above indicating the trailing newline
+      #
+
+  Scenario: Explicit out-of-mask message gets ignored and returns nil
+    When I invoke the logger with (0b10010, "a message")
+    Then the return value should be nil
+    And stderr should contain exactly ""
+
+  Scenario: Explicit out-of-mask multi-line text is ignored and returns nil
+    When I invoke the logger with (0b10010, "message line 1", "message line 2")
+    Then the return value should be nil
+    And stderr should contain exactly ""
+
+  Scenario: Explicit in-mask message is sent and the matching mask returned
+    When I invoke the logger with (0b10111, "a message")
+    Then the return value should be 0b00101
+    And stderr should contain exactly "a message\n"
+

data/features/labels.feature

@@ -0,0 +1,39 @@
+Feature: Test reporting using labeled levels
+  In order to report using different methods,
+  A developer
+  Should be able to assign labels to loglevels.
+
+  Background:
+    Given I have a DumbLogger object
+    And I set 'sink' to :$stderr
+    And I set 'level_style' to DumbLogger::USE_LEVELS
+    And I set 'loglevel' to 5
+
+  Scenario: Assign 'ok' to level 0
+    When I label level 0 with name "ok"
+    And I invoke the logger with ok("a message")
+    Then the return value should be 0
+    And stderr should contain exactly "a message\n"
+
+  Scenario: Assign 'ok' to level 0 and 'debug' to level 1
+    When I label level 0 with name "ok"
+    And I label level 1 with name "debug"
+    And I invoke the logger with debug("a message")
+    Then the return value should be 1
+    And stderr should contain exactly "a message\n"
+
+  Scenario: Assign 'ok' to level 0, 'debug' to 1, and 'silent' to 6
+    When I label level 0 with name "ok"
+    And I label level 1 with name "debug"
+    And I label level 6 with name "silent"
+    And I invoke the logger with silent("a message")
+    Then the return value should be nil
+    And stderr should contain exactly ""
+
+  Scenario: Check the label assignments
+    When I label level 0 with name "ok"
+    And I label level 1 with name "debug"
+    And I label level 6 with name "silent"
+    And I query method "labeled_levels"
+    Then the return value should be {:debug=>1, :ok=>0, :silent=>6}
+

data/features/levels.feature

@@ -0,0 +1,46 @@
+Feature: Test reporting using numeric levels
+  In order to use the basic functionality of the DumbLogger class
+  A developer
+  Should be able to specify at what levels messages should be written
+
+  Background:
+    Given I have a DumbLogger object
+    And I set attribute 'sink' to :$stderr
+    And I set attribute level_style to DumbLogger::USE_LEVELS
+    And I set attribute loglevel to 5
+
+  Scenario: Default Level-0 1-liner text always gets sent and returns 0)
+    When I invoke the logger with ("a message")
+    Then the return value should be 0
+    And stderr should contain exactly:
+      """
+      a message
+
+      """
+      #
+      # Note the final blank line above indicating the trailing newline
+      #
+
+  Scenario: Default Level-0 multi-line text always gets sent and returns 0
+    When I invoke the logger with ("a message line 1","message line 2")
+    Then the return value should be 0
+    And stderr should contain exactly:
+      """
+      a message line 1
+      message line 2
+
+      """
+      #
+      # Note the final blank line above indicating the trailing newline
+      #
+
+  Scenario: Explicit level-too-high 1-liner text is ignored and returns nil
+    When I invoke the logger with (6, "a message")
+    Then stderr should contain exactly ""
+    And the return value should be nil
+
+  Scenario: Explicit level-too-high multi-line text is ignored and returns nil
+    When I invoke the logger with (6, "a message line 1", "message line 2")
+    Then stderr should contain exactly ""
+    And the return value should be nil
+

data/features/output.feature

@@ -0,0 +1,136 @@
+Feature: Test the output generated
+  In order to use the basic functionality of the DumbLogger class
+  A developer
+  Should be able to depend on the correct output
+
+  Background:
+    Given I have a DumbLogger object
+    And I set attribute 'sink' to :$stderr
+    And I set attribute level_style to DumbLogger::USE_LEVELS
+    And I set attribute loglevel to 5
+
+  Scenario: Single-line message sent to stderr
+    When I invoke the logger with ("a message")
+    Then the return value should be 0
+    And stderr should contain exactly "a message\n"
+    And stdout should contain exactly ""
+
+  Scenario: Single-line message sent to stdout
+    When I set the sink to :$stdout
+    And I invoke the logger with ("a message")
+    Then the return value should be 0
+    And stderr should contain exactly ""
+    And stdout should contain exactly "a message\n"
+
+  Scenario: Multi-line message sent to stderr
+    When I invoke the logger with ("line 1","line 2")
+    Then the return value should be 0
+    And stderr should contain exactly "line 1\nline 2\n"
+    And stdout should contain exactly ""
+
+  Scenario: Multi-line message sent to stdout
+    When I set the sink to :$stdout
+    And I invoke the logger with ("line 1","line 2")
+    Then the return value should be 0
+    And stderr should contain exactly ""
+    And stdout should contain exactly "line 1\nline 2\n"
+
+  Scenario: Single-line message with no newline
+    When I invoke the logger with ("a message", :no_nl)
+    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)
+    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: Multi-line message with no newline
+    When I invoke the logger with ("line 1",:no_nl,"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)
+    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: Single-line message with instance prefix
+    When I set the prefix to '[instance-prefix] '
+    And I invoke the logger with ("a message")
+    Then the prefix should be '[instance-prefix] '
+    And the return value should be 0
+    And stderr should contain exactly "[instance-prefix] a message\n"
+    And stdout should contain exactly ""
+
+  Scenario: Multi-line message with instance prefix
+    When I set the prefix to '[instance-prefix] '
+    And I invoke the logger with ("line 1","line 2")
+    Then the prefix should be '[instance-prefix] '
+    And the return value should be 0
+    And stderr should contain exactly:
+      """
+      [instance-prefix] line 1
+      [instance-prefix] line 2
+
+      """
+    And stdout should contain exactly ""
+
+  Scenario: Single-line message with method prefix
+    When I invoke the logger with ("a message", :prefix => "[method-prefix] ")
+    Then the prefix should be ''
+    And the return value should be 0
+    And stderr should contain exactly "[method-prefix] a message\n"
+    And stdout should contain exactly ""
+
+  Scenario: Multi-line message with method prefix
+    When I invoke the logger with ("line 1","line 2",:prefix => "[method-prefix] ")
+    Then the prefix should be ''
+    And the return value should be 0
+    And stderr should contain exactly:
+      """
+      [method-prefix] line 1
+      [method-prefix] line 2
+
+      """
+    And stdout should contain exactly ""
+
+  Scenario: Single-line message with differing instance and method prefices
+    When I set the prefix to '[instance-prefix] '
+    And I invoke the logger with ("a message", :prefix => "[method-prefix] ")
+    Then the prefix should be '[instance-prefix] '
+    And the return value should be 0
+    And stderr should contain exactly "[method-prefix] a message\n"
+    And stdout should contain exactly ""
+
+  Scenario: Multi-line message with differing method and instance prefices
+    When I set the prefix to '[instance-prefix] '
+    And I invoke the logger with ("line 1","line 2",:prefix => "[method-prefix] ")
+    Then the prefix should be '[instance-prefix] '
+    And the return value should be 0
+    And stderr should contain exactly:
+      """
+      [method-prefix] line 1
+      [method-prefix] line 2
+
+      """
+    And stdout should contain exactly ""
+
+  Scenario: Single-line message with multiple options
+    When I invoke the logger with ("line 1",:newline=>false,:prefix=>"[method-prefix] ")
+    Then the prefix should be ''
+    And the return value should be 0
+    And stderr should contain exactly "[method-prefix] line 1"
+    And stdout should contain exactly ""
+
+  Scenario: Multi-line message with method prefix
+    When I invoke the logger with ("line 1",{:newline=>false,:prefix=>"[method-prefix] "},"line 2")
+    Then the prefix should be ''
+    And the return value should be 0
+    And stderr should contain exactly "[method-prefix] line 1\n[method-prefix] line 2"
+    And stdout should contain exactly ""
+

data/features/step_definitions/parts.rb

@@ -0,0 +1,97 @@
+Given(/^I have a DumbLogger object$/) do
+  @duml					= DumbLogger.new
+end
+
+And(/^it is sinking to (\S+)$/) do |sink|
+  @return_value = @duml.sink		= eval(sink)
+end
+
+And(/^the logging style is (\S+)$/) do |style|
+  @return_value = @duml.level_style	= DumbLogger.const_get(style)
+end
+
+And(/^append mode is set to (\S+)$/) do |mode|
+  @return_value = @duml.append			= eval(mode)
+end
+
+And(/^the prefix is set to "([^"]*)"$/) do |prefix|
+  @return_value = @duml.prefix			= prefix
+end
+
+And(/^the loglevel is set to (\S+)$/) do |level|
+  @return_value = @duml.loglevel		= level.to_i
+end
+
+And(/^I label (?:level|mask|bitmask) (\d+) with name "(.+)"$/) do |level,label|
+  @return_value = @duml.label_levels(eval("{#{label.to_sym.inspect}=>#{level}}"))
+end
+
+And(/^I label loglevels with:$/) do |labelhash|
+  @return_value = @duml.label_levels(eval("{#{labelhash}}"))
+end
+
+And(/^I invoke the logger with (\S*)\((.*)\)$/) do |label,args|
+  traffic = capture_streams(:$stdout, :$stderr) {
+    invocation = "@duml.#{label.empty? ? 'message' : label}(#{args})"
+    @return_value = eval(invocation)
+  }
+  @stdout_text = traffic[:$stdout]
+  @stderr_text = traffic[:$stderr]
+end
+
+Then(/^stdout should contain exactly (.+)$/) do |xval|
+  expect(@stdout_text).to eq eval(xval)
+end
+
+Then(/^stdout should contain exactly:$/) do |xval|
+  expect(@stdout_text).to eq xval
+end
+
+Then(/^stderr should contain exactly (.+)$/) do |xval|
+  expect(@stderr_text).to eq eval(xval)
+end
+
+Then(/^stderr should contain exactly:$/) do |xval|
+  expect(@stderr_text).to eq xval
+end
+
+Then(/^the return value should be (.*)$/) do |xval|
+  expect(@return_value).to eq eval(xval)
+end
+
+Then(/^the (?:log-level|logging-mask) should\s+(?:still)?\s*be (\d+)$/) do |xval|
+  expect(@duml.loglevel).to eq xval.to_i
+end
+
+Then(/^the sink should be (.+)$/) do |xval|
+  expect(@duml.sink).to eq eval(xval)
+end
+
+Then(/^the style should be (.+)$/) do |xval|
+  expect(@duml.level_style).to eq eval(xval)
+end
+
+Then(/^the prefix should be (.+)$/) do |xval|
+  expect(@duml.prefix).to eq eval(xval)
+end
+
+Then(/^append-mode should be (.+)$/) do |xval|
+  expect(@duml.append?).to eq eval(xval)
+end
+
+When(/^I query (?:attribute|method) ["']?([_A-Za-z0-9?]+)["']?$/) do |attr|
+  @return_value = @duml.send(attr.to_sym)
+end
+
+When(/^I set (?:attribute|the)?\s*["']?([_A-Za-z0-9]+)["']? to (.+?)$/) do |attr,val|
+  begin
+    @return_value = @duml.send((attr + '=').to_sym, eval(val))
+  rescue Exception => e
+    @exception_raised	= e
+    @return_value	= nil
+  end
+end
+
+Then(/^it should raise an exception of type (\S+)$/) do |xval|
+  expect(@exception_raised.class).to eq eval(xval)
+end