logsly 1.0.0.rc1

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.log
+*.rbc
+.bundle
+.config
+.yardoc
+.rvmrc
+.rbenv-version
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem 'bundler', '~>1.1'
+gem 'rake',    '~>0.9.2'

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 <TODO: copyright holders>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,118 @@
+# Logsly
+
+Logsly is a DSL and a mixin to setup and create custom logger objects.  Define your color schemes and log outputs.  Then mixin Logsly to make your logger classes.  Create instances of your loggers specifying outputs for each, then use your loggers to log stuff to those outputs.
+
+## Usage
+
+```ruby
+
+# define a named output for your logger to use
+Logsly.stdout('my_stdout')
+
+# define your logger
+class MyLogger
+  include Logsly
+end
+
+# build a logger instance with a name and use it
+logger = MyLogger.new(:outputs => ['my_stdout'])
+logger.info "whatever"
+
+# build another logger and use it
+bg_logger = MyLogger.new('bg', :level => 'debug', :outputs => ['my_logger_stdout'])
+bg_logger.debug "something"
+```
+
+## Implementation
+
+Logsly creates and delegates to a [Logging logger](https://github.com/TwP/logging).  When you create an instance of your logger class, Logsly sets up and configures Logging for you.
+
+## Settings
+
+* `log_type`: custom string used to identify the type of the logger
+* `level`: the level in use (default: `'debug'`)
+* `outputs`: list of named outputs to log to (default: `[]`)
+
+## Outputs
+
+### Stdout
+
+```ruby
+Logsly.stdout('my_stdout') do |logger|
+  pattern '[%d %-5l] : %m\n'
+  colors  'my_colors'  # use the 'my_colors' color scheme
+end
+```
+
+Define a named stdout output to use with your loggers.  Pass a block to customize it.  The block will be lazy-eval'd when a logger using it is initialized.  The block is passed the logger instance.
+
+### File
+
+```ruby
+Logsly.file('my_file') do |logger|
+  path "development.log"
+
+  pattern '[%d %-5l] : %m\n'
+  # don't use a color scheme
+end
+```
+
+Define a named file output to use with your loggers.  Takes the same parameters as its stdout counterpart.  Specify the path (relative or absolute) to the log file using the `path` method.
+
+### Syslog
+
+```ruby
+Logsly.syslog('my_syslog') do |logger|
+  identity "my_syslog_logger" # or whatever
+  facility Syslog::LOG_LOCAL0 # or whatever (default: `LOG_LOCAL0`)
+  log_opts Syslog::LOG_PID    # or whatever (default: `(LOG_PID | LOG_CONS)`)
+
+  pattern '%m\n'
+  # don't use a color scheme
+end
+```
+
+Define a named syslog output to use with your loggers.  Takes the same parameters as its stdout counterpart.  Specify the identity and facility using the respective methods.
+
+### Patterns
+
+Each output can define what pattern to format its messages with using the `pattern' method.  See [Logging's patterns](https://github.com/TwP/logging/blob/master/lib/logging/layouts/pattern.rb) for details.
+
+### Colors
+
+```ruby
+Logsly.colors('my_colors') do
+  debug :magenta
+  info  :cyan
+  warn  :yellow
+  error :red
+  fatal [:white, :on_red]
+
+  date    :blue
+  message :white
+end
+```
+
+Define a named color scheme to use on your outputs.  Essentially creates a [Logging::ColorScheme](https://github.com/TwP/logging/blob/master/lib/logging/color_scheme.rb) object.  See that file for configuration and details.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'logsly'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install logsly
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+
+require 'assert/rake_tasks'
+Assert::RakeTasks.install
+
+require 'bundler/gem_tasks'
+
+task :default => :build

data/lib/logsly/base_output.rb

@@ -0,0 +1,64 @@
+require 'ostruct'
+require 'ns-options'
+require 'logging'
+
+module Logsly
+
+  class NullOutput < OpenStruct
+    def to_appender(*args); nil; end
+    def to_layout(*args);   nil; end
+  end
+
+  class BaseOutput
+
+    attr_reader :build
+
+    def initialize(&build)
+      @build = build || Proc.new {}
+    end
+
+    def to_appender(*args)
+      self.instance_exec(*args, &@build)
+      self.colors_obj.run_build(*args)
+      self
+    end
+
+    def to_layout(data)
+      Logging.layouts.pattern(data.to_pattern_opts)
+    end
+
+    def to_appender(*args)
+      raise NotImplementedError
+    end
+
+  end
+
+  class BaseOutputData
+    include NsOptions::Proxy
+    option :pattern, String, :default => '%m\n'
+    option :colors,  String
+
+    def initialize(*args, &build)
+      @args = args
+      self.instance_exec(*@args, &build)
+    end
+
+    def to_pattern_opts
+      Hash.new.tap do |opts|
+        opts[:pattern] = self.pattern if self.pattern
+
+        if scheme_name = colors_obj.to_scheme(*@args)
+          opts[:color_scheme] = scheme_name
+        end
+      end
+    end
+
+    protected
+
+    def colors_obj
+      Logsly.colors(self.colors)
+    end
+
+  end
+
+end

data/lib/logsly/colors.rb

@@ -0,0 +1,115 @@
+require 'ostruct'
+require 'ns-options'
+
+# This class provides a DSL for setting color scheme values and lazy eval's
+# the DSL to generate a Logging color scheme object.
+# See https://github.com/TwP/logging/blob/master/lib/logging/color_scheme.rb
+# for details on Logging color schemes.
+
+module Logsly
+
+  class NullColors < OpenStruct
+    def to_scheme(*args); nil;  end
+  end
+
+  class Colors
+
+    attr_reader :name, :build
+
+    def initialize(name, &build)
+      @name, @build = name, build
+    end
+
+    def to_scheme(*args)
+      "#{@name}-#{args.map{|a| a.object_id}.join('-')}".tap do |scheme_name|
+        Logging.color_scheme(scheme_name, ColorsData.new(*args, &@build).to_scheme_opts)
+      end
+    end
+
+  end
+
+  class ColorsData
+    include NsOptions::Proxy
+
+    # color for the level text only
+    option :debug
+    option :info
+    option :warn
+    option :error
+    option :fatal
+
+    # color for the entire log message based on the value of the log level
+    option :debug_line
+    option :info_line
+    option :warn_line
+    option :error_line
+    option :fatal_line
+
+    option :logger      # [%c] name of the logger that generate the log event
+    option :date        # [%d] datestamp
+    option :message     # [%m] the user supplied log message
+    option :pid         # [%p] PID of the current process
+    option :time        # [%r] the time in milliseconds since the program started
+    option :thread      # [%T] the name of the thread Thread.current[:name]
+    option :thread_id   # [%t] object_id of the thread
+    option :file        # [%F] filename where the logging request was issued
+    option :line        # [%L] line number where the logging request was issued
+    option :method_name # [%M] method name where the logging request was issued
+
+    def initialize(*args, &build)
+      self.instance_exec(*args, &build)
+
+      @properties     = properties.map{|p| self.send(p)}
+      @method         = self.method_name
+      @level_settings = levels.map{|l| self.send(l)}
+      @line_settings  = levels.map{|l| self.send("#{l}_line")}
+
+      if has_level_settings? && has_line_settings?
+        raise ArgumentError, "can't set line and level settings in the same scheme"
+      end
+    end
+
+    def to_scheme_opts
+      Hash.new.tap do |opts|
+        # set general properties
+        properties.each_with_index do |property, idx|
+          opts[property] = @properties[idx] if @properties[idx]
+        end
+
+        # set special properties (reserved names)
+        opts[:method] = @method if @method
+
+        # set level settings - only add :levels key if one exists
+        if has_level_settings?
+          opts[:levels] = {}
+          levels.each_with_index do |level, idx|
+            opts[:levels][level] = @level_settings[idx] if @level_settings[idx]
+          end
+        end
+
+        # set line-level settings - only :lines key if one exists
+        if has_line_settings?
+          opts[:lines] = {}
+          levels.each_with_index do |level, idx|
+            opts[:lines][level] = @line_settings[idx] if @line_settings[idx]
+          end
+        end
+      end
+    end
+
+    private
+
+    def has_level_settings?; !@level_settings.compact.empty?; end
+    def has_line_settings?;  !@line_settings.compact.empty?;  end
+
+    def properties
+      [:logger, :date, :message, :time, :pid, :thread, :thread_id, :file, :line]
+    end
+
+    def levels
+      [:debug, :info, :warn, :error, :fatal]
+    end
+
+  end
+
+end

data/lib/logsly/file_output.rb

@@ -0,0 +1,17 @@
+require 'logging'
+require 'logsly/base_output'
+
+module Logsly
+
+  class FileOutput < BaseOutput
+    def to_appender(*args)
+      data = FileOutputData.new(*args, &self.build)
+      Logging.appenders.file(data.path, :layout => self.to_layout(data))
+    end
+  end
+
+  class FileOutputData < BaseOutputData
+    option :path, String
+  end
+
+end

data/lib/logsly/settings.rb

@@ -0,0 +1,45 @@
+require 'ns-options'
+require 'logging'
+require 'logsly/colors'
+require 'logsly/base_output'
+
+module Logsly
+
+  module Settings
+    include NsOptions::Proxy
+
+    option :colors,  ::Hash, :default => ::Hash.new(NullColors.new)
+    option :outputs, ::Hash, :default => ::Hash.new(NullOutput.new)
+  end
+
+  def self.reset
+    Settings.reset
+    Logging.reset
+  end
+
+  def self.colors(name, &block)
+    require 'logsly/colors'
+    Settings.colors[name.to_s] = Colors.new(name, &block) if !block.nil?
+    Settings.colors[name.to_s]
+  end
+
+  def self.stdout(name, &block)
+    require 'logsly/stdout_output'
+    Settings.outputs[name.to_s] = StdoutOutput.new(&block)
+  end
+
+  def self.file(name, &block)
+    require 'logsly/file_output'
+    Settings.outputs[name.to_s] = FileOutput.new(&block)
+  end
+
+  def self.syslog(name, &block)
+    require 'logsly/syslog_output'
+    Settings.outputs[name.to_s] = SyslogOutput.new(&block)
+  end
+
+  def self.outputs(name)
+    Settings.outputs[name.to_s]
+  end
+
+end

data/lib/logsly/stdout_output.rb

@@ -0,0 +1,13 @@
+require 'logging'
+require 'logsly/base_output'
+
+module Logsly
+
+  class StdoutOutput < BaseOutput
+    def to_appender(*args)
+      data = BaseOutputData.new(*args, &self.build)
+      Logging.appenders.stdout(:layout => self.to_layout(data))
+    end
+  end
+
+end

data/lib/logsly/syslog_output.rb

@@ -0,0 +1,26 @@
+require 'syslog'
+require 'logging'
+require 'logsly/base_output'
+
+module Logsly
+
+  class SyslogOutput < BaseOutput
+    def to_appender(*args)
+      Syslog.close if Syslog.opened?
+
+      data = SyslogOutputData.new(*args, &self.build)
+      Logging.appenders.syslog(data.identity, {
+        :logopt   => data.log_opts,
+        :facility => data.facility,
+        :layout   => self.to_layout(data)
+      })
+    end
+  end
+
+  class SyslogOutputData < BaseOutputData
+    option :identity, String
+    option :log_opts, Integer, :default => (Syslog::LOG_PID | Syslog::LOG_CONS)
+    option :facility, Integer, :default => Syslog::LOG_LOCAL0
+  end
+
+end

data/lib/logsly/version.rb

@@ -0,0 +1,3 @@
+module Logsly
+  VERSION = "1.0.0.rc1"
+end

data/lib/logsly.rb

@@ -0,0 +1,69 @@
+require 'ns-options'
+require 'logging'
+require 'logsly/settings'
+
+module Logsly
+
+  def self.included(receiver)
+    receiver.class_eval do
+      attr_reader :log_type, :level, :outputs, :logger
+      include LoggerMethods
+    end
+  end
+
+  module LoggerMethods
+
+    def initialize(log_type, opts_hash=nil)
+      opts = NsOptions::Struct.new(opts_hash) do
+        option :level,   String, :default => 'info'
+        option :outputs, Array,  :default => []
+      end
+      @log_type, @level, @outputs = log_type.to_s, opts.level, opts.outputs
+
+      unique_name   = "#{self.class.name}-#{@log_type}-#{self.object_id}"
+      @logger       = Logging.logger[unique_name]
+      @logger.level = @level
+
+      @outputs.each do |output|
+        add_appender(Logsly.outputs(output).to_appender(self))
+      end
+    end
+
+    # delegate all calls to the @logger
+
+    def method_missing(method, *args, &block)
+      @logger.send(method, *args, &block)
+    end
+    def respond_to?(method)
+      super || @logger.respond_to?(method)
+    end
+
+    def ==(other_logger)
+      other_logger.log_type == @log_type &&
+      other_logger.level    == @level    &&
+      other_logger.outputs  == @outputs
+    end
+
+    def inspect
+      reference = '0x0%x' % (self.object_id << 1)
+      "#<#{self.class}:#{reference} "\
+      "@log_type=#{@log_type.inspect} "\
+      "@level=#{@level.inspect} "\
+      "@outputs=#{@outputs.inspect}"
+    end
+
+    private
+
+    def add_appender(appender)
+      @logger.add_appenders(appender) if appender && !appender_added?(appender)
+    end
+
+    def appender_added?(appender)
+      @logger.appenders.detect do |existing|
+        existing.kind_of?(appender.class) && existing.name == appender.name
+      end
+    end
+
+  end
+
+end

data/logsly.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/logsly/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = "logsly"
+  gem.version     = Logsly::VERSION
+  gem.description = %q{Create custom loggers.}
+  gem.summary     = %q{Create custom loggers.}
+
+  gem.authors     = ["Kelly Redding", "Collin Redding"]
+  gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
+  gem.homepage    = "http://github.com/redding/logsly"
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency("assert", ["~> 1.0"])
+
+  gem.add_dependency("ns-options",  ["~> 1.1"])
+  gem.add_dependency("logging",     ["~> 1.8.0"])
+
+end

data/test/helper.rb

@@ -0,0 +1,5 @@
+# this file is automatically required in when you require 'assert' in your tests
+# put test helpers here
+
+# add root dir to the load path
+$LOAD_PATH.unshift(File.expand_path("../..", __FILE__))

data/test/irb.rb

@@ -0,0 +1,9 @@
+require 'assert/setup'
+
+# this file is required in when the 'irb' rake test is run.
+# b/c 'assert/setup' is required above, the test helper will be
+# required in as well.
+
+# put any IRB setup code here
+
+require 'logsly'

data/test/support/logger.rb

@@ -0,0 +1,9 @@
+require 'logsly'
+
+module Logsly
+
+  class TestLogger
+    include Logsly
+  end
+
+end

data/test/unit/base_output_tests.rb

@@ -0,0 +1,100 @@
+require 'assert'
+require 'logging'
+require 'logsly/settings'
+require 'logsly/base_output'
+
+class Logsly::BaseOutput
+
+  class DataTests < Assert::Context
+    desc "the BaseOutputData handler"
+    setup do
+      Logsly.colors('a_color_scheme') do
+        debug :white
+      end
+      @arg = '%d : %m\n'
+      @lay = Logsly::BaseOutputData.new(@arg) do |*args|
+        pattern args.first
+        colors  'a_color_scheme'
+      end
+    end
+    subject { @lay }
+
+    should have_readers :pattern, :colors
+
+    should "know its defaults" do
+      lay = Logsly::BaseOutputData.new {}
+      assert_equal '%m\n', lay.pattern
+      assert_nil lay.colors
+    end
+
+    should "instance exec its build with args" do
+      assert_equal '%d : %m\n',      subject.pattern
+      assert_equal 'a_color_scheme', subject.colors
+    end
+
+    should "know its layout pattern opts hash" do
+      expected = {
+        :pattern      => subject.pattern,
+        :color_scheme => "#{subject.colors}-#{@arg.object_id}"
+      }
+      assert_equal expected, subject.to_pattern_opts
+
+      out = Logsly::BaseOutputData.new do
+        pattern '%m\n'
+      end
+      out_expected = {:pattern => out.pattern}
+      assert_equal out_expected, out.to_pattern_opts
+    end
+
+  end
+
+  class BaseTests < Assert::Context
+    desc "the BaseOutput handler"
+    setup do
+      @out = Logsly::BaseOutput.new {}
+    end
+    subject { @out }
+
+    should have_reader :build
+    should have_imeths :to_layout, :to_appender
+
+    should "know its build" do
+      build_proc = Proc.new {}
+      out = Logsly::BaseOutput.new &build_proc
+
+      assert_same build_proc, out.build
+    end
+
+    should "expect `to_appender` to be defined by subclasses" do
+      assert_raises NotImplementedError do
+        subject.to_appender
+      end
+    end
+
+  end
+
+  class BuildTests < BaseTests
+    desc "given a build"
+    setup do
+      Logsly.colors('a_color_scheme') do
+        debug :white
+      end
+      @out = Logsly::BaseOutput.new do |*args|
+        pattern args.to_s
+        colors  'a_color_scheme'
+      end
+    end
+
+    should "build a Logging pattern layout" do
+      data = Logsly::BaseOutputData.new('%d : %m\n', &@out.build)
+      lay = subject.to_layout(data)
+
+      assert_kind_of Logging::Layout, lay
+      assert_equal   '%d : %m\n', lay.pattern
+      assert_kind_of Logging::ColorScheme, lay.color_scheme
+    end
+
+  end
+
+end
+

data/test/unit/colors_tests.rb

@@ -0,0 +1,112 @@
+require 'assert'
+require 'logging'
+require 'logsly/colors'
+
+class Logsly::Colors
+
+  class DataTests < Assert::Context
+    desc "the ColorsData handler"
+    setup do
+      @data = Logsly::ColorsData.new('white') do |color|
+        debug color
+      end
+    end
+    subject { @data }
+
+    should have_imeths :to_scheme_opts
+    should have_imeths :debug, :info, :warn, :error, :fatal
+    should have_imeths :debug_line, :info_line, :warn_line, :error_line, :fatal_line
+    should have_imeths :logger, :date, :message, :pid, :time, :thread, :thread_id
+    should have_imeths :file, :line, :method_name
+
+    should "instance exec its build with args" do
+      assert_equal 'white', subject.debug
+    end
+
+    should "complain if setting both a level and a line setting" do
+      err = begin
+        Logsly::ColorsData.new do
+          info       :blue
+          debug_line :white
+        end
+        nil
+      rescue ArgumentError => err
+        err
+      end
+
+      assert_kind_of ArgumentError, err
+      assert_includes "can't set line and level settings in the same scheme", err.message
+    end
+
+    should "know its scheme opts hash and only include specified opts" do
+      general_only = Logsly::ColorsData.new do
+        date        :blue
+        message     :cyan
+        method_name :white
+        info        :blue
+      end
+      expected = {
+        :date    => :blue,
+        :message => :cyan,
+        :method  => :white,
+        :levels  => {:info  => :blue},
+      }
+
+      assert_equal expected, general_only.to_scheme_opts
+    end
+
+    should "only include :levels and :lines if at least one is set" do
+      no_levels_lines = Logsly::ColorsData.new { date :blue }
+      expected = { :date => :blue }
+
+      assert_equal expected, no_levels_lines.to_scheme_opts
+    end
+
+  end
+
+  class BaseTests < Assert::Context
+    desc "the Colors handler"
+    setup do
+      @colors = Logsly::Colors.new('test_colors') do |*args|
+        debug args.first
+      end
+    end
+    subject { @colors }
+
+    should have_readers :name, :build
+    should have_imeths  :to_scheme
+
+    should "know its name" do
+      assert_equal 'test_colors', subject.name
+    end
+
+    should "know its build" do
+      build_proc = Proc.new {}
+      out = Logsly::Colors.new 'test', &build_proc
+
+      assert_same build_proc, out.build
+    end
+
+  end
+
+  class BuildTests < BaseTests
+    desc "given a build"
+    setup do
+      @colors = Logsly::Colors.new 'test' do |fatal_color|
+        fatal [fatal_color, :on_red]
+        date  :blue
+      end
+    end
+
+    should "build a unique Logging color scheme based on called args" do
+      arg = 'white'
+      scheme_name = subject.to_scheme(arg)
+
+      assert_equal   "test-#{arg.object_id}", scheme_name
+      assert_kind_of Logging::ColorScheme, Logging.color_scheme(scheme_name)
+    end
+
+  end
+
+end
+

data/test/unit/file_output_tests.rb

@@ -0,0 +1,56 @@
+require 'assert'
+require 'ostruct'
+require 'logging'
+require 'logsly/settings'
+require 'logsly/file_output'
+
+class Logsly::FileOutput
+
+  class DataTests < Assert::Context
+    desc "the FileOutputData handler"
+    setup do
+      @data = Logsly::FileOutputData.new {}
+    end
+    subject { @data }
+
+    should have_imeth :path
+
+  end
+
+  class BaseTests < Assert::Context
+    desc "the StdoutOutput handler"
+    setup do
+      @logger = OpenStruct.new
+      @logger.debug_level = :white
+      @logger.pattern = '%d : %m\n'
+      @logger.file = "dev.log"
+
+      Logsly.colors('a_color_scheme') do |logger|
+        debug logger.debug_level
+      end
+
+      @out = Logsly::FileOutput.new do |logger|
+        path logger.file
+
+        pattern logger.pattern
+        colors  'a_color_scheme'
+      end
+    end
+    subject { @out }
+
+    should "be an output handler" do
+      assert_kind_of Logsly::BaseOutput, subject
+    end
+
+    should "build a Logging file appender, passing args to the builds" do
+      appender = subject.to_appender @logger
+
+      assert_kind_of Logging::Appenders::File,  appender
+      assert_equal   'dev.log',                 appender.name
+      assert_kind_of Logging::Layouts::Pattern, appender.layout
+      assert_equal   '%d : %m\n',               appender.layout.pattern
+      assert_kind_of Logging::ColorScheme,      appender.layout.color_scheme
+    end
+  end
+
+end

data/test/unit/logger_tests.rb

@@ -0,0 +1,123 @@
+require 'assert'
+require 'logging'
+require 'logsly'
+require 'test/support/logger'
+
+module Logsly
+
+  class BaseTests < Assert::Context
+    desc "a logger with Logsly mixed in"
+    setup do
+      Logsly.reset
+      @logger = TestLogger.new(:testy_log_logger)
+    end
+    subject { @logger }
+
+    should have_readers :log_type, :level, :outputs, :logger
+
+    should "know its log_type" do
+      assert_equal 'testy_log_logger', subject.log_type
+    end
+
+    should "know its default opt values" do
+      assert_equal 'info', subject.level
+      assert_equal [],     subject.outputs
+    end
+
+    should "allow overridding the default opt values" do
+      log = TestLogger.new(:testy_debug_logger, :level => :debug, :outputs => [:stdout])
+      assert_equal 'debug',   log.level
+      assert_equal [:stdout], log.outputs
+    end
+
+  end
+
+  class LoggerTests < BaseTests
+
+    should "create a Logging::Logger" do
+      assert_not_nil subject.logger
+      assert_kind_of Logging::Logger, subject.logger
+    end
+
+    should "create the Logging::Logger with a unique name" do
+      expected = "#{subject.class.name}-testy_log_logger-#{subject.object_id}"
+      assert_equal expected, subject.logger.name
+    end
+
+    should "set the logger's level" do
+      assert_equal Logging::LEVELS['info'], subject.logger.level
+
+      log = TestLogger.new('test', :level => :debug)
+      assert_equal Logging::LEVELS['debug'], log.logger.level
+    end
+
+  end
+
+  class AppenderTests < LoggerTests
+    setup do
+      Logsly.stdout 'my_stdout'
+      Logsly.file('my_file') do |logger|
+        path "development-#{logger.log_type}.log"
+      end
+      Logsly.file('my_other_file') do |logger|
+        path "other-#{logger.log_type}.log"
+      end
+      Logsly.syslog('my_syslog') do |logger|
+        identity "my_syslog_logger-#{logger.log_type}"
+      end
+    end
+
+    should "add a named stdout appender" do
+      log = TestLogger.new(:test, :outputs => 'my_stdout')
+      assert_includes_appender Logging::Appenders::Stdout, log
+    end
+
+    should "add a named file appender" do
+      log     = TestLogger.new(:test, :outputs => 'my_file')
+      filelog = extract_appender_from_logger(log, :file)
+
+      assert_includes_appender Logging::Appenders::File, log
+      assert_equal 'development-test.log', filelog.name
+    end
+
+    should "add a named syslog appender" do
+      log = TestLogger.new(:test, :outputs => 'my_syslog')
+      assert_includes_appender Logging::Appenders::Syslog, log
+    end
+
+    should "not add duplicate appenders" do
+      outputs = ['my_stdout', 'my_stdout', 'my_file', 'my_other_file']
+      log = TestLogger.new(:test, :outputs => outputs)
+
+      assert_equal 3, log.appenders.size
+    end
+
+    should "not add undefined appenders" do
+      outputs = ['my_stdout', 'undefined']
+      log = TestLogger.new(:test, :outputs => outputs)
+
+      assert_equal 1, log.appenders.size
+    end
+
+    protected
+
+    def assert_includes_appender(appender_class, logger)
+      assert_includes appender_class, logger.appenders.collect(&:class)
+    end
+
+    def extract_appender_from_logger(logger, type)
+      klass = case type
+      when :syslog
+        Logging::Appenders::Syslog
+      when :file
+        Logging::Appenders::File
+      when :stdout
+        Logging::Appenders::Stdout
+      end
+
+      logger.appenders.select{|a| a.is_a?(klass)}.first
+    end
+
+  end
+
+end

data/test/unit/settings_tests.rb

@@ -0,0 +1,98 @@
+require 'assert'
+require 'logsly/settings'
+
+module Logsly
+
+  class SettingsTests < Assert::Context
+    desc "Logsly settings"
+    setup do
+      Logsly::Settings.reset
+    end
+    subject { Logsly }
+
+    should have_imeths :reset, :colors, :stdout, :file, :syslog, :outputs
+
+    should "return a NullColors obj when requesting a color scheme that isn't defined" do
+      assert_kind_of NullColors, Logsly.colors('not_defined_yet')
+    end
+
+    should "return a NullOutput obj when requesting an output that isn't defined" do
+      assert_kind_of NullOutput, Logsly.outputs('not_defined_yet')
+    end
+
+    should "add a named color scheme using the `colors` method" do
+      assert_kind_of NullColors, Logsly.colors('test_colors')
+      Logsly.colors('test_colors') {}
+
+      assert_kind_of Colors, Logsly.colors('test_colors')
+    end
+
+    should "add a named stdout output using the `stdout` method" do
+      assert_kind_of NullOutput, Logsly.outputs('test_stdout')
+      Logsly.stdout('test_stdout') {}
+
+      assert_not_nil Logsly.outputs('test_stdout')
+      assert_kind_of StdoutOutput, Logsly.outputs('test_stdout')
+    end
+
+    should "add a named file output using the `file` method" do
+      assert_kind_of NullOutput, Logsly.outputs('test_file')
+      Logsly.file('test_file') {}
+
+      assert_not_nil Logsly.outputs('test_file')
+      assert_kind_of FileOutput, Logsly.outputs('test_file')
+    end
+
+    should "add a named syslog output using the `syslog` method" do
+      assert_kind_of NullOutput, Logsly.outputs('test_syslog')
+      Logsly.syslog('test_syslog') {}
+
+      assert_not_nil Logsly.outputs('test_syslog')
+      assert_kind_of SyslogOutput, Logsly.outputs('test_syslog')
+    end
+
+    should "convert non-string setting names to string" do
+      Logsly.colors(:test_colors) {}
+
+      assert_not_nil Logsly.colors(:test_colors)
+      assert_kind_of Colors, Logsly.colors(:test_colors)
+    end
+
+    should "overwrite same-named colors settings" do
+      Logsly.colors('something') {}
+      orig = Logsly.colors('something')
+      Logsly.colors('something') {}
+
+      assert_not_same orig, Logsly.colors('something')
+    end
+
+    should "overwrite same-named outputs settings" do
+      Logsly.stdout('something') {}
+      assert_kind_of StdoutOutput, Logsly.outputs('something')
+
+      Logsly.file('something') {}
+      assert_kind_of FileOutput, Logsly.outputs('something')
+    end
+
+  end
+
+  class ResetTests < SettingsTests
+    desc "`reset` method"
+    setup do
+      Logsly.colors('test_colors') {}
+      Logsly.stdout('test_stdout') {}
+    end
+
+    should "reset the Settings" do
+      assert_kind_of Colors,       Logsly.colors('test_colors')
+      assert_kind_of StdoutOutput, Logsly.outputs('test_stdout')
+
+      Logsly.reset
+
+      assert_kind_of NullColors, Logsly.colors('test_colors')
+      assert_kind_of NullOutput, Logsly.outputs('test_stdout')
+    end
+
+  end
+
+end

data/test/unit/stdout_output_tests.rb

@@ -0,0 +1,41 @@
+require 'assert'
+require 'ostruct'
+require 'logging'
+require 'logsly/settings'
+require 'logsly/stdout_output'
+
+class Logsly::StdoutOutput
+
+  class BaseTests < Assert::Context
+    desc "the StdoutOutput handler"
+    setup do
+      @logger = OpenStruct.new
+      @logger.debug_level = :white
+      @logger.pattern = '%d : %m\n'
+
+      Logsly.colors('a_color_scheme') do |logger|
+        debug logger.debug_level
+      end
+
+      @out = Logsly::StdoutOutput.new do |logger|
+        pattern logger.pattern
+        colors  'a_color_scheme'
+      end
+    end
+    subject { @out }
+
+    should "be an output handler" do
+      assert_kind_of Logsly::BaseOutput, subject
+    end
+
+    should "build a Logging stdout appender, passing args to the builds" do
+      appender = subject.to_appender @logger
+
+      assert_kind_of Logging::Appenders::Stdout, appender
+      assert_kind_of Logging::Layouts::Pattern,  appender.layout
+      assert_equal   '%d : %m\n',                appender.layout.pattern
+      assert_kind_of Logging::ColorScheme,       appender.layout.color_scheme
+    end
+  end
+
+end

data/test/unit/syslog_output_tests.rb

@@ -0,0 +1,66 @@
+require 'assert'
+require 'ostruct'
+require 'syslog'
+require 'logging'
+require 'logsly/settings'
+require 'logsly/syslog_output'
+
+class Logsly::SyslogOutput
+
+  class DataTests < Assert::Context
+    desc "the FileOutputData handler"
+    setup do
+      @data = Logsly::SyslogOutputData.new {}
+    end
+    subject { @data }
+
+    should have_imeth :identity, :log_opts, :facility
+
+    should "default :log_opts" do
+      assert_equal (Syslog::LOG_PID | Syslog::LOG_CONS), subject.log_opts
+    end
+
+    should "default :facility" do
+      assert_equal Syslog::LOG_LOCAL0, subject.facility
+    end
+
+  end
+
+  class BaseTests < Assert::Context
+    desc "the SyslogOutput handler"
+    setup do
+      @logger = OpenStruct.new
+      @logger.debug_level = :white
+      @logger.pattern  = '%d : %m\n'
+      @logger.identity = "whatever"
+      @logger.facility = Syslog::LOG_LOCAL3
+
+      Logsly.colors('a_color_scheme') do |logger|
+        debug logger.debug_level
+      end
+
+      @out = Logsly::SyslogOutput.new do |logger|
+        identity logger.identity
+        facility logger.facility
+
+        pattern logger.pattern
+        colors  'a_color_scheme'
+      end
+    end
+    subject { @out }
+
+    should "be an output handler" do
+      assert_kind_of Logsly::BaseOutput, subject
+    end
+
+    should "build a Logging syslog appender, passing args to the builds" do
+      appender = subject.to_appender @logger
+
+      assert_kind_of Logging::Appenders::Syslog, appender
+      assert_kind_of Logging::Layouts::Pattern,  appender.layout
+      assert_equal   '%d : %m\n',                appender.layout.pattern
+      assert_kind_of Logging::ColorScheme,       appender.layout.color_scheme
+    end
+  end
+
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification 
+name: logsly
+version: !ruby/object:Gem::Version 
+  hash: 2488903281
+  prerelease: 6
+  segments: 
+  - 1
+  - 0
+  - 0
+  - rc
+  - 1
+  version: 1.0.0.rc1
+platform: ruby
+authors: 
+- Kelly Redding
+- Collin Redding
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-12-10 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: assert
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :development
+  requirement: *id001
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: ns-options
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 1
+        version: "1.1"
+  type: :runtime
+  requirement: *id002
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: logging
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 55
+        segments: 
+        - 1
+        - 8
+        - 0
+        version: 1.8.0
+  type: :runtime
+  requirement: *id003
+  prerelease: false
+description: Create custom loggers.
+email: 
+- kelly@kellyredding.com
+- collin.redding@me.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/logsly.rb
+- lib/logsly/base_output.rb
+- lib/logsly/colors.rb
+- lib/logsly/file_output.rb
+- lib/logsly/settings.rb
+- lib/logsly/stdout_output.rb
+- lib/logsly/syslog_output.rb
+- lib/logsly/version.rb
+- logsly.gemspec
+- test/helper.rb
+- test/irb.rb
+- test/support/logger.rb
+- test/unit/base_output_tests.rb
+- test/unit/colors_tests.rb
+- test/unit/file_output_tests.rb
+- test/unit/logger_tests.rb
+- test/unit/settings_tests.rb
+- test/unit/stdout_output_tests.rb
+- test/unit/syslog_output_tests.rb
+homepage: http://github.com/redding/logsly
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Create custom loggers.
+test_files: 
+- test/helper.rb
+- test/irb.rb
+- test/support/logger.rb
+- test/unit/base_output_tests.rb
+- test/unit/colors_tests.rb
+- test/unit/file_output_tests.rb
+- test/unit/logger_tests.rb
+- test/unit/settings_tests.rb
+- test/unit/stdout_output_tests.rb
+- test/unit/syslog_output_tests.rb