lumber 0.10.0 → 0.10.2

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

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

data/.idea/dictionaries/mconway.xml

@@ -0,0 +1,3 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="mconway" />
+</component>

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode
+  # - rbx-18mode
+  # - rbx-19mode
+script: bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lumber.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,74 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "lumber #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :changelog do
+
+  changelog_file = 'CHANGELOG'
+  entries = ""
+
+  # Get a list of current tags
+  tags = `git tag -l`.split
+
+  # If we already have a changelog, make the last tag be the
+  # last one in the changelog, and the next one be the one
+  # following that in the tag list
+  if File.exist?(changelog_file)
+    entries = File.read(changelog_file)
+    head = entries.split.first
+    if head =~ /\d\.\d\.\d/
+      last_tag = "v#{head}"
+      idx = tags.index(last_tag)
+      current_tag = tags[idx + 1]
+    end
+  end
+
+  # Figure out last/current tags dn do some validation
+  last_tag ||= tags[-2]
+  current_tag ||= tags[-1]
+
+  if last_tag.nil? && current_tag.nil?
+    puts "Cannot generate a changelog without first tagging your repository"
+    puts "Tags should be in the form vN.N.N"
+    exit
+  end
+  
+  if last_tag == current_tag
+    puts "Nothing to do for equal revisions: #{last_tag}..#{current_tag}"
+    exit
+  end
+
+
+  # Generate changelog from repo
+  log=`git log --pretty='format:%s <%h> [%cn]' #{last_tag}..#{current_tag}`
+
+  # Strip out maintenance entries
+  log = log.lines.to_a.delete_if {|l| l =~ /^Regenerated gemspec/ || l =~ /^Version bump/ || l =~ /^Updated changelog/ }
+
+  # Write out changelog file
+  File.open(changelog_file, 'w') do |out|
+    out.puts current_tag.gsub(/^v/, '')
+    out.puts "-----"
+    out.puts "\n"
+    out.puts log
+    out.puts "\n"
+    out.puts entries
+  end
+
+  # Commit and push
+  sh "git ci -m'Updated changelog' #{changelog_file}"
+  sh "git push"
+end

data/lib/lumber/lumber.rb

@@ -63,6 +63,10 @@ module Lumber
     self.register_inheritance_handler()
   end
 
+  def self.find_or_create_logger(fullname)
+    Log4r::Logger[fullname] || Log4r::Logger.new(fullname)
+  end
+  
   # Makes :logger exist independently for subclasses and sets that logger
   # to one that inherits from base_class for each subclass as it is created.
   # This allows you to have a finer level of control over logging, for example,
@@ -90,7 +94,7 @@ module Lumber
         if clazz.respond_to? class_attribute_method
           clazz.class_eval do
             send class_attribute_method, :logger
-            self.logger = Log4r::Logger.new(class_logger_fullname)
+            self.logger = Lumber.find_or_create_logger(class_logger_fullname)
           end
 
           break
@@ -143,7 +147,7 @@ module Lumber
         class_inheritable_accessor :logger
       end
 
-      self.logger = Log4r::Logger.new(logger_name)
+      self.logger = Lumber.find_or_create_logger(logger_name)
 
       class << self
 
@@ -168,7 +172,8 @@ module Lumber
       parent_logger_name = parent.logger.fullname rescue ''
       parent_is_registered = @@registered_loggers.values.find {|v| parent_logger_name.index(v) == 0}
       if parent_is_registered && parent.method_defined?(:logger=)
-        clazz.logger = Log4r::Logger.new("#{parent_logger_name}::#{clazz.name.nil? ? 'anonymous' : clazz.name.split('::').last}")
+        fullname = "#{parent_logger_name}::#{clazz.name.nil? ? 'anonymous' : clazz.name.split('::').last}"
+        clazz.logger = Lumber.find_or_create_logger(fullname)
         break
       end
       parent = parent.superclass

data/lib/lumber/version.rb

@@ -0,0 +1,3 @@
+module Lumber
+  VERSION = "0.10.2"
+end

data/lumber.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/lumber/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Matt Conway"]
+  gem.email         = ["matt@conwaysplace.com"]
+  gem.description   = %q{Lumber tries to make it easy to use the more robust log4r logging system within your rails application.  To do this it sets up log4r configuration from a yml file, and provides utility methods for adding a :logger accessor to classes dynamicaly as they get created.}
+  gem.summary       = %q{Lumber integrates the log4r logging system within your application.}
+  gem.homepage      = "http://github.com/wr0ngway/lumber"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "lumber"
+  gem.require_paths = ["lib"]
+  gem.version       = Lumber::VERSION
+
+  gem.add_dependency("log4r", "~> 1.1.10")
+  gem.add_dependency("activesupport")
+
+  gem.add_development_dependency("rake")
+  gem.add_development_dependency("rspec")
+  gem.add_development_dependency("awesome_print")
+  # gem.add_development_dependency("simplecov")
+
+end

data/spec/logger_support_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper.rb'
+
+describe Lumber::LoggerSupport do
+
+  before(:each) do
+    root = "#{File.dirname(__FILE__)}/.."
+    Lumber.init(:root => root,
+                :env => 'test',
+                :config_file => "#{root}/generators/lumber/templates/log4r.yml",
+                :log_file => "/tmp/lumber-test.log")
+  end
+
+  after(:each) do
+    self.class.constants.grep(/^Foo/).each do |c|
+      self.send(:remove_const, c)
+    end
+  end
+
+  it "should create logger for chain" do
+    class Foo; include Lumber::LoggerSupport; end
+    class Bar < Foo; end;
+    Foo.logger.should == Log4r::Logger["rails::Foo"]
+    Bar.logger.should == Log4r::Logger["rails::Foo::Bar"]
+    Bar.logger.parent.should == Log4r::Logger["rails::Foo"]
+  end
+
+  it "should have a logger instance accessible from an instance method" do
+    class Foo; include Lumber::LoggerSupport; def member_method; logger.debug('hi'); end; end
+    logger = Log4r::Logger["rails::Foo"]
+    logger.should_receive(:debug).with('hi')
+    Foo.new.member_method
+  end
+
+  it "should have a logger instance accessible from a class method " do
+    class Foo; include Lumber::LoggerSupport; def self.class_method; logger.debug('hi'); end; end
+    logger = Log4r::Logger["rails::Foo"]
+    logger.should_receive(:debug).with('hi')
+    Foo.class_method
+  end
+
+  it "should allow configuration of levels from yml" do
+    yml = <<-EOF
+      log4r_config:
+        pre_config:
+          root:
+            level: 'DEBUG'
+        loggers:
+          - name: "rails::Foo"
+            level: WARN
+        outputters: []
+    EOF
+    
+    cfg = Log4r::YamlConfigurator
+    cfg.load_yaml_string(yml)
+    logger = Log4r::Logger['rails::Foo']
+    sio = StringIO.new 
+    logger.outputters = [Log4r::IOOutputter.new("sbout", sio)]
+    class Foo; include Lumber::LoggerSupport; end
+    
+    Foo.logger.debug("noshow")
+    Foo.logger.warn("yesshow")
+    sio.string.should =~ /yesshow/
+    sio.string.should_not =~ /noshow/
+  end
+    
+end

data/spec/lumber_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+require 'delegate'
+
+def new_class(class_name, super_class=nil, super_module=nil)
+  s = "class #{class_name}"
+  s << " < #{super_class}" if super_class
+  s << "; end"
+
+  s = "module #{super_module}; #{s}; end" if super_module
+
+  eval s
+end
+  
+describe Lumber do
+
+  before(:each) do
+    root = "#{File.dirname(__FILE__)}/.."
+    Lumber.init(:root => root,
+                :env => 'test',
+                :config_file => "#{root}/generators/lumber/templates/log4r.yml",
+                :log_file => "/tmp/lumber-test.log")
+  end
+
+  after(:each) do
+    Object.constants.grep(/^Foo/).each do |c|
+      Object.send(:remove_const, c)
+    end
+  end
+
+  def assert_valid_logger(class_name, logger_name)
+    clazz = eval class_name
+    clazz.should_not be_nil
+    clazz.respond_to?(:logger).should be_true
+    lgr = clazz.logger
+    lgr.should be_an_instance_of(Log4r::Logger)
+    logger_name.should == lgr.fullname
+  end
+
+  it "should not do anything if no loggers registered" do
+    defined?(Object.inherited_with_lumber_log4r).should be_true
+    defined?(Object.logger).should be_false
+  end
+
+  it "should allow registering logger for a class before the class is defined" do
+    defined?(Foo1).should be_false
+    Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
+    new_class('Foo1')
+    assert_valid_logger('Foo1', "root::foo1")
+  end
+
+  it "should not register new logger for subclasses of classes that delegate logger" do
+    defined?(Foo1).should be_false # ActionController::Base
+    defined?(Foo2).should be_false # ActionView::Base
+    defined?(Foo3).should be_false # Subclass of ActionView::Base
+    Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
+    eval "class ::Foo1; end"
+    eval "class ::Foo2; delegate :logger, :to => Foo1; end"
+    eval "class ::Foo3 < Foo2; end"
+    assert_valid_logger('Foo1', "root::foo1")
+    Foo2.new.logger.should == Foo1.logger
+    Foo3.new.logger.should == Foo1.logger
+  end
+
+  it "should no logger when parent is via delegate class" do
+    defined?(Foo1).should be_false
+    defined?(Foo2).should be_false
+    defined?(Foo3).should be_false
+    Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
+    eval "class ::Foo1; end"
+    eval "class ::Foo2 < DelegateClass(Foo1); end"
+    eval "class ::Foo3 < Foo2; end"
+    assert_valid_logger('Foo1', "root::foo1")
+    defined?(Foo3.logger).should be_false
+  end
+
+  it "should allow registering independent loggers for classes in a hierarchy" do
+    defined?(Foo1).should be_false
+    defined?(Foo2).should be_false
+    Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
+    Lumber.setup_logger_hierarchy("Foo2", "root::foo2")
+    new_class('Foo1')
+    new_class('Foo2', 'Foo1')
+    assert_valid_logger('Foo1', "root::foo1")
+    assert_valid_logger('Foo2', "root::foo2")
+  end
+
+  it "should prevent cattr_accessor for a class registered before the class is defined" do
+    defined?(Foo1).should be_false
+    Lumber.setup_logger_hierarchy("Foo1", "root::foo1")
+    new_class('Foo1')
+    Foo1.class_eval do
+      cattr_accessor :logger, :foo
+    end
+    defined?(Foo1.foo).should be_true
+    assert_valid_logger('Foo1', "root::foo1")
+  end
+
+  it "should allow registering logger for a nested class before the class is defined" do
+    defined?(Bar1::Foo1).should be_false
+    Lumber.setup_logger_hierarchy("Bar1::Foo1", "root::foo1")
+    new_class('Foo1', nil, 'Bar1')
+    assert_valid_logger('Bar1::Foo1', "root::foo1")
+  end
+
+  it "should allow registering logger for a class after the class is defined" do
+    defined?(Foo1).should be_false
+    new_class('Foo1')
+    defined?(Foo1).should be_true
+
+    Lumber.setup_logger_hierarchy("Foo1", "root::Foo1")
+    assert_valid_logger('Foo1', "root::Foo1")
+  end
+
+  it "should register loggers for subclasses of registered classes" do
+    defined?(Foo1).should be_false
+    defined?(Foo2).should be_false
+    defined?(Foo3).should be_false
+    Lumber.setup_logger_hierarchy("Foo1", "root::Foo1")
+    new_class('Foo1')
+    new_class('Foo2', 'Foo1')
+    new_class('Foo3')
+    assert_valid_logger('Foo1', "root::Foo1")
+    assert_valid_logger('Foo2', "root::Foo1::Foo2")
+    defined?(Foo3.logger).should be_false
+  end
+
+  it "should register loggers for sub-subclasses of registered classes" do
+    defined?(Foo1).should be_false
+    defined?(Foo2).should be_false
+    defined?(Foo3).should be_false
+    Lumber.setup_logger_hierarchy("Foo1", "root::Foo1")
+    new_class('Foo1')
+    new_class('Foo2', 'Foo1')
+    new_class('Foo3', 'Foo2')
+    assert_valid_logger('Foo1', "root::Foo1")
+    assert_valid_logger('Foo2', "root::Foo1::Foo2")
+    assert_valid_logger('Foo3', "root::Foo1::Foo2::Foo3")
+  end
+
+  it "should register loggers for sub-subclasses of registered classes even when middle class not a logger" do
+    defined?(Foo1).should be_false
+    defined?(Foo2).should be_false
+    defined?(Foo3).should be_false
+    new_class('Foo1')
+    new_class('Foo2', 'Foo1')
+    Lumber.setup_logger_hierarchy("Foo1", "root::Foo1")
+    new_class('Foo3', 'Foo2')
+    assert_valid_logger('Foo1', "root::Foo1")
+    # this will behave differently depending on the version of ActiveSupport being used. on ActiveSupport >= 3.2, we use class_attribute to define
+    # the logger method, which will cause subclasses to fall back to the parent class's logger if one isn't defined (Foo2.logger == Foo1.logger)
+    # if on ActiveSupport < 3.2, we use class_inheritable_accessor, which will leave the logger undefined in the subclass unless LoggerSupport
+    # is explicitly included
+    ((!defined?(Foo2.logger) || Foo2.logger.nil?) || (Foo2.logger == Foo1.logger)).should be_true
+    assert_valid_logger('Foo3', "root::Foo1::Foo3")
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,8 @@
+--colour
+--format
+specdoc
+--reverse
+--timeout
+20
+--loadby
+mtime

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rspec'
+require 'ap'
+
+require 'lumber'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lumber
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,43 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-23 00:00:00.000000000 Z
+date: 2012-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: shoulda
-  requirement: &70359307360500 !ruby/object:Gem::Requirement
+  name: log4r
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.10
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,44 +53,63 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70359307360500
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: log4r
-  requirement: &70359307359560 !ruby/object:Gem::Requirement
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
-  version_requirements: *70359307359560
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: &70359307345720 !ruby/object:Gem::Requirement
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
-  version_requirements: *70359307345720
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Lumber tries to make it easy to use the more robust log4r logging system
   within your rails application.  To do this it sets up log4r configuration from a
   yml file, and provides utility methods for adding a :logger accessor to classes
   dynamicaly as they get created.
-email: matt@conwaysplace.com
+email:
+- matt@conwaysplace.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- LICENSE
-- README.rdoc
-- TODO
+extra_rdoc_files: []
 files:
+- .document
+- .gitignore
+- .idea/dictionaries/mconway.xml
+- .travis.yml
 - CHANGELOG
+- Gemfile
 - LICENSE
 - README.rdoc
+- Rakefile
 - TODO
 - VERSION
 - generators/lumber/USAGE
@@ -68,6 +119,12 @@ files:
 - lib/lumber/log4r.rb
 - lib/lumber/logger_support.rb
 - lib/lumber/lumber.rb
+- lib/lumber/version.rb
+- lumber.gemspec
+- spec/logger_support_spec.rb
+- spec/lumber_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
 homepage: http://github.com/wr0ngway/lumber
 licenses: []
 post_install_message: 
@@ -88,8 +145,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: Lumber integrates the log4r logging system within your application.
-test_files: []
+test_files:
+- spec/logger_support_spec.rb
+- spec/lumber_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: