sinatra-logger 0.1.0

data/.document

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

data/.gitignore

@@ -0,0 +1,23 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+doc
+
+## PROJECT::SPECIFIC
+spec/fixtures/log/*.log

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 kematzy
+
+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.rdoc

@@ -0,0 +1,168 @@
+= Sinatra::Logger
+
+A Sinatra extension that makes logging within Your apps easy.
+
+
+== Installation
+
+  #  Add Gemcutter to your RubyGems sources 
+  $  gem sources -a http://gemcutter.com
+
+  $  (sudo)? gem install sinatra-logger
+
+== Dependencies
+
+This Gem depends upon the following:
+
+=== Runtime:
+
+* sinatra ( >= 1.0.a )
+* logger
+
+=== Development & Tests:
+
+* rspec (>= 1.3.0 )
+* rack-test (>= 0.5.3)
+* rspec_hpricot_matchers (>= 0.1.0)
+* sinatra-tests (>= 0.1.6)
+
+
+== Getting Started
+
+To get logging in your app, just register the extension 
+in your sub-classed Sinatra app:
+
+  class YourApp < Sinatra::Base
+    
+    register(Sinatra::Logger)
+    <snip...>
+  end
+  
+Then in your App's route or helper method declarations, just use the <tt>#logger</tt>...
+
+  get '/some/route' do
+    logger.debug("some informative message goes here")
+    <snip...>
+  end
+  
+  helpers do
+    def some_helper_method
+      logger.info("some equally informative message goes here")
+      <snip...>
+    end
+  end
+  
+
+That's pretty painless, no?
+
+
+=== Logging Levels
+
+The <b>default Log level</b> is <tt>:warn</tt>.
+
+All the available logging levels are those of Logger[http://ruby-doc.org/stdlib/libdoc/logger/rdoc/classes/Logger.html], which are:
+
+* <tt>logger.fatal(msg)</tt> - - (FATAL) - an unhandleable error that results in a program crash
+
+* <tt>logger.error(msg)</tt> - - (ERROR) - a handleable error condition
+
+* <tt>logger.warn(msg)</tt> - - (WARN) - a warning
+
+* <tt>logger.info(msg)</tt> - - (INFO) - generic (useful) information about system operation
+
+* <tt>logger.debug(msg)</tt> - - (DEBUG) - low-level information for developers
+
+
+OK, by now you might be asking yourself, 
+
+<em>"So where does the log messages go then ?"</em>.
+
+
+=== Logging Locations
+
+By default the logger will log it's message to the following path:
+
+  < the root of your app >/log/< environment >.log
+  
+In other words if your app's root is [ <tt>/home/www/your-great-app/</tt> ] and it's 
+running in <tt>:production</tt> mode, then the log location would become:
+
+  /home/www/your-great-app/log/production.log
+  
+<b>NB!</b> this extension takes for granted that you have a ../log/ directory with write access at the root of your app.
+
+
+=== Custom Logging Location
+
+If the defaults are NOT for you, then just do...
+
+  class YourApp < Sinatra::Base
+    
+    register(Sinatra::Logger)
+    
+    set: :logger_log_file, lambda { "/path/2/your/log/file.ext" }
+    
+    <snip...>
+    
+  end
+
+
+  # the lambda { } is required, especially if you have variables in the path
+
+..., now your log messages will be written to that log file.
+
+
+=== Setting Log Level
+
+Finally, to use a different Log level for your app, other than the default <tt>:warn</tt> just...
+
+  class YourApp < Sinatra::Base
+    
+    register(Sinatra::Logger)
+    
+    set: :logger_level, :fatal # or :error, :warn, :info, :debug
+    <snip...>
+  end
+
+
+That's it. I hope that's easy enough.
+
+
+== RTFM
+
+If the above is not clear enough, please check the Specs for a better understanding.
+
+
+== Errors / Bugs
+
+If something is not behaving intuitively, it is a bug, and should be reported.
+Report it here: http://github.com/kematzy/sinatra-logger/issues 
+
+
+== TODOs
+
+* Making the logging work with Rack::CommonLogger, but still retain it's independence.
+
+* Any other improvements you can think of.
+
+
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  * (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 kematzy. Released under the MIT License.
+
+See LICENSE for details.
+
+== Inspirational Source
+
+* Monk Glue

data/Rakefile

@@ -0,0 +1,90 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "sinatra-logger"
+    gem.summary = %Q{Easy logging with Sinatra}
+    gem.description = %Q{A Sinatra extension that makes logging easy}
+    gem.email = "kematzy@gmail.com"
+    gem.homepage = "http://github.com/kematzy/sinatra-logger"
+    gem.authors = ["kematzy"]
+    gem.add_dependency( "sinatra", ">= 0.10.1")
+    gem.add_development_dependency( "rspec", ">= 1.3.0")
+    gem.add_development_dependency( "sinatra-tests", ">= 0.1.6")
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_opts = ["--color", "--format", "specdoc", "--require", "spec/spec_helper.rb"]  
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_opts = ["--color", "--format", "specdoc", "--require", "spec/spec_helper.rb"]
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+namespace :spec do
+  
+  desc "Run all specifications quietly"
+  Spec::Rake::SpecTask.new(:quiet) do |t|
+    t.libs << "lib"
+    t.spec_opts = ["--color", "--require", "spec/spec_helper.rb"]
+  end
+  
+  desc "Run specific spec (SPEC=/path/2/file)"
+  Spec::Rake::SpecTask.new(:select) do |t|
+    t.libs << "lib"
+    t.spec_files = [ENV["SPEC"]]
+    t.spec_opts = ["--color", "--format", "specdoc", "--require", "spec/spec_helper.rb"] 
+  end
+  
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "sinatra-logger #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+desc 'Build the rdoc HTML Files'
+task :docs do
+  version = File.exist?('VERSION') ? IO.read('VERSION').chomp : "[Unknown]"
+    
+  sh "sdoc -N --title 'Sinatra::Logger v#{version}' lib/ README.rdoc"
+end
+
+namespace :docs do
+  
+  desc 'Remove rdoc products'
+  task :remove => [:clobber_rdoc]
+  
+  desc 'Force a rebuild of the RDOC files'
+  task :rebuild => [:rerdoc]
+  
+  desc 'Build docs, and open in browser for viewing (specify BROWSER)'
+  task :open => [:docs] do
+    browser = ENV["BROWSER"] || "safari"
+    sh "open -a #{browser} doc/index.html"
+  end
+  
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/sinatra/logger.rb

@@ -0,0 +1,185 @@
+
+require 'sinatra/base'
+require 'logger'
+
+module Sinatra 
+  
+  # = Sinatra::Logger
+  # 
+  # A Sinatra extension that makes logging within Your apps easy.
+  # 
+  # 
+  # == Installation
+  # 
+  #   #  Add Gemcutter to your RubyGems sources 
+  #   $  gem sources -a http://gemcutter.com
+  # 
+  #   $  (sudo)? gem install sinatra-logger
+  # 
+  # == Dependencies
+  # 
+  # This Gem depends upon the following:
+  # 
+  # === Runtime:
+  # 
+  # * sinatra ( >= 1.0.a )
+  # * logger
+  # 
+  # === Development & Tests:
+  # 
+  # * rspec (>= 1.3.0 )
+  # * rack-test (>= 0.5.3)
+  # * rspec_hpricot_matchers (>= 0.1.0)
+  # * sinatra-tests (>= 0.1.6)
+  # 
+  # 
+  # == Getting Started
+  # 
+  # To get logging in your app, just register the extension 
+  # in your sub-classed Sinatra app:
+  # 
+  #   class YourApp < Sinatra::Base
+  # 
+  #     register(Sinatra::Logger)
+  #     <snip...>
+  #   end
+  # 
+  # Then in your App's route or helper method declarations, just use the <tt>#logger</tt>...
+  # 
+  #   get '/some/route' do
+  #     logger.debug("some informative message goes here")
+  #     <snip...>
+  #   end
+  # 
+  #   helpers do
+  #     def some_helper_method
+  #       logger.info("some equally informative message goes here")
+  #       <snip...>
+  #     end
+  #   end
+  # 
+  # 
+  # That's pretty painless, no?
+  # 
+  # 
+  # === Logging Levels
+  # 
+  # The <b>default Log level</b> is <tt>:warn</tt>.
+  # 
+  # All the available logging levels are those of Logger[http://ruby-doc.org/stdlib/libdoc/logger/rdoc/classes/Logger.html], which are:
+  # 
+  # * <tt>logger.fatal(msg)</tt> - - (FATAL) - an unhandleable error that results in a program crash
+  # 
+  # * <tt>logger.error(msg)</tt> - - (ERROR) - a handleable error condition
+  # 
+  # * <tt>logger.warn(msg)</tt> - - (WARN) - a warning
+  # 
+  # * <tt>logger.info(msg)</tt> - - (INFO) - generic (useful) information about system operation
+  # 
+  # * <tt>logger.debug(msg)</tt> - - (DEBUG) - low-level information for developers
+  # 
+  # 
+  # OK, by now you might be asking yourself, 
+  # 
+  # <em>"So where does the log messages go then ?"</em>.
+  # 
+  # 
+  # === Logging Locations
+  # 
+  # By default the logger will log it's message to the following path:
+  # 
+  #   < the root of your app >/log/< environment >.log
+  # 
+  # In other words if your app's root is [ <tt>/home/www/your-great-app/</tt> ] and it's 
+  # running in <tt>:production</tt> mode, then the log location would become:
+  # 
+  #   /home/www/your-great-app/log/production.log
+  # 
+  # <b>NB!</b> this extension takes for granted that you have a ../log/ directory with write access at the root of your app.
+  # 
+  # 
+  # === Custom Logging Location
+  # 
+  # If the defaults are NOT for you, then just do...
+  # 
+  #   class YourApp < Sinatra::Base
+  # 
+  #     register(Sinatra::Logger)
+  # 
+  #     set: :logger_log_file, lambda { "/path/2/your/log/file.ext" }
+  # 
+  #     <snip...>
+  # 
+  #   end
+  # 
+  # 
+  #   # the lambda { } is required, especially if you have variables in the path
+  # 
+  # ..., now your log messages will be written to that log file.
+  # 
+  # 
+  # === Setting Log Level
+  # 
+  # Finally, to use a different Log level for your app, other than the default <tt>:warn</tt> just...
+  # 
+  #   class YourApp < Sinatra::Base
+  # 
+  #     register(Sinatra::Logger)
+  # 
+  #     set: :logger_level, :fatal # or :error, :warn, :info, :debug
+  #     <snip...>
+  #   end
+  # 
+  # 
+  # That's it. I hope that's easy enough.
+  # 
+  module Logger 
+    
+    VERSION = '0.1.0'
+    ##
+    # Returns the version string for this extension
+    # 
+    # ==== Examples
+    # 
+    #   Sinatra::Logger.version  => 'Sinatra::Logger v0.1.0'
+    # 
+    def self.version; "Sinatra::Logger v#{VERSION}"; end
+    
+    
+    module Helpers 
+      
+      ##
+      # Provides easy access to the Logger object throughout your 
+      # application
+      #  
+      # ==== Examples
+      # 
+      #   logger.warn("messsage")
+      # 
+      # 
+      # @api public
+      def logger 
+        @logger ||= begin
+          @logger = ::Logger.new(self.class.logger_log_file)
+          @logger.level = ::Logger.const_get((self.class.logger_level || :warn).to_s.upcase)
+          @logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+          @logger
+        end
+      end
+      
+    end #/module Helpers
+    
+    
+    def self.registered(app)
+      app.helpers Sinatra::Logger::Helpers
+      
+      # set the output log level
+      app.set :logger_level, :warn
+      # set the full path to the log file
+      app.set :logger_log_file, lambda { File.join(root, 'log', "#{environment}.log") }
+      
+    end #/ self.registered
+    
+  end #/module Logger
+  
+end #/ Sinatra

data/sinatra-logger.gemspec

@@ -0,0 +1,61 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sinatra-logger}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["kematzy"]
+  s.date = %q{2010-02-23}
+  s.description = %q{A Sinatra extension that makes logging easy}
+  s.email = %q{kematzy@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/sinatra/logger.rb",
+     "sinatra-logger.gemspec",
+     "spec/sinatra/logger_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/kematzy/sinatra-logger}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Easy logging with Sinatra}
+  s.test_files = [
+    "spec/sinatra/logger_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<sinatra>, [">= 0.10.1"])
+      s.add_development_dependency(%q<rspec>, [">= 1.3.0"])
+      s.add_development_dependency(%q<sinatra-tests>, [">= 0.1.6"])
+    else
+      s.add_dependency(%q<sinatra>, [">= 0.10.1"])
+      s.add_dependency(%q<rspec>, [">= 1.3.0"])
+      s.add_dependency(%q<sinatra-tests>, [">= 0.1.6"])
+    end
+  else
+    s.add_dependency(%q<sinatra>, [">= 0.10.1"])
+    s.add_dependency(%q<rspec>, [">= 1.3.0"])
+    s.add_dependency(%q<sinatra-tests>, [">= 0.1.6"])
+  end
+end
+

data/spec/sinatra/logger_spec.rb

@@ -0,0 +1,194 @@
+
+require File.expand_path(File.dirname(File.dirname(__FILE__)) + '/spec_helper')
+
+describe "Sinatra" do 
+  
+  class MyTestApp 
+    register Sinatra::Logger
+    
+    helpers do 
+      
+      def dummy_helper(level, message) 
+        logger.send(level, message)
+        "Level: #{level},  Message: #{message}"
+      end
+    end
+    
+    get '/logger/:msg' do 
+      logger.warn("Message: #{params[:msg]}")
+      erb("Message: #{params[:msg]}", :layout => false )
+    end
+    
+  end
+  
+  it_should_behave_like "MyTestApp"
+  
+  describe "Logger" do 
+    
+    describe "with Default Settings" do 
+      
+      before(:each) do 
+        FileUtils.mkdir_p "#{fixtures_path}/log"
+        @log_file = "#{fixtures_path}/log/#{MyTestApp.environment}.log"
+        `touch #{@log_file}`
+      end
+      
+      after(:each) do
+        `echo '' > #{@log_file}`
+      end
+      
+      describe "Configuration" do 
+        
+        it "should set :logger_level to :warn" do 
+          app.settings.logger_level.should == :warn
+        end
+        
+        it "should set :logger_log_file to [../log/< environment >.log]" do 
+          app.settings.logger_log_file.should == "#{fixtures_path}/log/test.log"
+        end
+        
+      end #/ Configuration
+      
+      describe "Helpers" do 
+        
+        describe "#logger" do 
+          
+          it "should create a #{MyTestApp.environment}.log file when initialized" do 
+            test(?f, @log_file).should == true
+          end
+          
+          it "should return an instance of Logger" do 
+            app.should respond_to(:logger)
+            app.logger.should be_a_kind_of(::Logger)
+          end
+          
+          it "should log when called from within a route" do 
+            get('/logger/this-works')
+            body.should == "Message: this-works"
+            IO.read(@log_file).should match(/WARN -- : Message: this-works/)
+          end
+          
+          it "should log when called from within helper methods" do 
+            erb_app '<%= dummy_helper(:warn, "works too") %>'
+            IO.read(@log_file).should match(/WARN -- : works too/)
+            body.should == "Level: warn,  Message: works too"
+          end
+          
+          it "should NOT log lower levels" do 
+            erb_app '<%= dummy_helper(:info, "default-info") %>'
+            IO.read(@log_file).should_not match(/INFO -- : default-info/)
+            body.should == "Level: info,  Message: default-info"
+            
+            erb_app '<%= dummy_helper(:debug, "default-debug") %>'
+            IO.read(@log_file).should_not match(/DEBUG -- : default-debug/)
+            body.should == "Level: debug,  Message: default-debug"
+          end
+          
+        end #/ #logger
+        
+      end #/ Helpers
+      
+    end #/ with Default Settings
+    
+    describe "with Custom Settings" do 
+      
+      class MyCustomTestApp 
+        register Sinatra::Logger
+        
+        set :logger_level, :debug
+        set :logger_log_file, lambda { "#{fixtures_path}/log/custom.log" }
+        
+        helpers do 
+          
+          def dummy_helper(level, message) 
+            logger.send(level, message)
+            "Level: #{level},  Message: #{message}"
+          end
+        end
+        
+        get '/customlogger/:msg' do 
+          logger.warn("Message: #{params[:msg]}")
+          erb("CustomMessage: #{params[:msg]}", :layout => false )
+        end
+        
+      end
+      
+      before(:each) do 
+        class ::Test::Unit::TestCase 
+          def app; ::MyCustomTestApp.new ; end
+        end
+        @app = app
+        
+        FileUtils.mkdir_p "#{fixtures_path}/log"
+        @custom_log_file = "#{fixtures_path}/log/custom.log"
+        `touch #{@custom_log_file}`
+      end
+      
+      after(:each) do 
+        class ::Test::Unit::TestCase 
+          def app; nil ; end
+        end
+        @app = nil
+        
+        `echo '' > #{@custom_log_file}`
+      end
+      
+      describe "Configuration" do 
+        
+        it "should set :logger_level to :debug" do 
+          app.settings.logger_level.should == :debug
+        end
+        
+        it "should set :logger_log_file to [../log/custom.log]" do 
+          app.settings.logger_log_file.should == "#{fixtures_path}/log/custom.log"
+        end
+        
+      end #/ Configuration
+      
+      describe "Helpers" do 
+        
+        describe "#logger" do 
+          
+          it "should create a custom.log file when initialised" do 
+            test(?f, @custom_log_file).should == true
+          end
+          
+          it "should return an instance of Logger" do 
+            app.logger.should be_a_kind_of(::Logger)
+          end
+          
+          it "should log when called from within a route" do 
+            get('/customlogger/this-works')
+            body.should == "CustomMessage: this-works"
+            IO.read(@custom_log_file).should match(/WARN -- : Message: this-works/)
+          end
+          
+          it "should log when called from within helper methods" do 
+            erb_app '<%= dummy_helper(:info, "works as well") %>'
+            IO.read(@custom_log_file).should match(/INFO -- : works as well/)
+            body.should == "Level: info,  Message: works as well"
+            
+            erb_app '<%= dummy_helper(:warn, "works too") %>'
+            IO.read(@custom_log_file).should match(/WARN -- : works too/)
+            body.should == "Level: warn,  Message: works too"
+          end
+          
+          it "should log higher levels" do 
+            erb_app '<%= dummy_helper(:info, "custom-info") %>'
+            IO.read(@custom_log_file).should match(/INFO -- : custom-info/)
+            body.should == "Level: info,  Message: custom-info"
+            
+            erb_app '<%= dummy_helper(:debug, "custom-debug") %>'
+            IO.read(@custom_log_file).should match(/DEBUG -- : custom-debug/)
+            body.should == "Level: debug,  Message: custom-debug"
+          end
+          
+        end #/ #logger
+        
+      end #/ Helpers
+      
+    end #/ with Custom Settings
+    
+  end #/ Logger
+  
+end #/ Sinatra

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,61 @@
+
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+
+#--
+# DEPENDENCIES
+#++
+%w( 
+sinatra/base 
+fileutils
+).each {|lib| require lib }
+
+#--
+## SINATRA EXTENSIONS
+#++
+%w(
+sinatra/tests
+sinatra/logger
+).each {|ext| require ext }
+
+
+ENV['RACK_ENV'] = 'test'
+
+Spec::Runner.configure do |config|
+  config.include RspecHpricotMatchers
+  config.include Sinatra::Tests::TestCase
+  config.include Sinatra::Tests::RSpec::SharedSpecs
+end
+
+def fixtures_path 
+  "#{File.dirname(File.expand_path(__FILE__))}/fixtures"
+end
+
+class MyTestApp < Sinatra::Base 
+  set :root, "#{fixtures_path}"
+  set :app_dir, "#{fixtures_path}/app"
+  set :public, "#{fixtures_path}/public"
+  set :views, "#{app_dir}/views"
+  enable :raise_errors
+  
+  register(Sinatra::Tests)
+  
+end #/class MyTestApp
+
+class MyCustomTestApp < Sinatra::Base 
+  set :root, "#{fixtures_path}"
+  set :app_dir, "#{fixtures_path}/app"
+  set :public, "#{fixtures_path}/public"
+  set :views, "#{app_dir}/views"
+  enable :raise_errors
+  
+  register(Sinatra::Tests)
+  
+end #/class MyCustomTestApp
+
+
+class Test::Unit::TestCase 
+  Sinatra::Base.set :environment, :test
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification 
+name: sinatra-logger
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- kematzy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-23 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 10
+        - 1
+        version: 0.10.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sinatra-tests
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 6
+        version: 0.1.6
+  type: :development
+  version_requirements: *id003
+description: A Sinatra extension that makes logging easy
+email: kematzy@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/sinatra/logger.rb
+- sinatra-logger.gemspec
+- spec/sinatra/logger_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/kematzy/sinatra-logger
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Easy logging with Sinatra
+test_files: 
+- spec/sinatra/logger_spec.rb
+- spec/spec_helper.rb