injectedlogger 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8c8f884728a154171e33be54c516bebdd67f1d39
+  data.tar.gz: e476903483e37e687d098c9903eb68c87db01a99
+SHA512:
+  metadata.gz: aa0f517e66beebe541ce91cd99404a8e4578cf6e6ee1ff9ba45c958cc5c93abcc0d0769e1717a5da9349541e7a114e1e8f94385dd1b09de5d971edfd223c0714
+  data.tar.gz: d5ed9228db640c67c965e402b2410612f7a001be754173ca441f4f7419d9756f64564c699edfb3de85907ff096a19aa837b9a865a3bde5f4bc7e8e160ceee2e2

data/.gitignore

@@ -0,0 +1,27 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--format d
+--order rand
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.1

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in infinity2008.gemspec
+gemspec
+
+group :test do
+  gem "codeclimate-test-reporter", require: nil
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Alejandro Martinez Ruiz <alex at flawedcode dot org>
+
+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,33 @@
+# A logger injection gem
+
+This gem can be used to inject a logger in your Ruby code.
+
+It will try to support as many methods and levels as the underlying object supports, and fall back to a supported level in case some levels are not available
+
+## Usage
+
+```ruby
+logger = InjectedLogger.use somelogger
+raise 'No info :(' unless logger.level_info[:supported].include? :info
+logger.info 'You now have a logger!'
+```
+
+## Generating the gem
+
+Both bundler and rspec are required to build the gem:
+
+    $ gem install bundler rspec
+
+Run rake -T to see available tasks. The gem can be built with:
+
+    $ rake build
+
+Or, if you want to make sure everything works correctly:
+
+    $ bundle exec rake build
+
+## Installation
+
+After generating the gem, install it using:
+
+    $ gem install pkg/injectedlogger-*.gem

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+ENV['gem_push'] = 'false'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/injectedlogger.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'injectedlogger/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'injectedlogger'
+  spec.version       = InjectedLogger::VERSION
+  spec.authors       = ["Alejandro Martinez Ruiz"]
+  spec.email         = ['alex@flawedcode.org']
+  spec.description   = %q{This gem injects a given logger into your code}
+  spec.summary       = %q{This gem injects a given logger into your code}
+  spec.homepage      = "http://github.com/unleashed/injectedlogger"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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.required_ruby_version = '>= 2.1.0'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.1"
+end

data/lib/injectedlogger/delegator.rb

@@ -0,0 +1,149 @@
+module InjectedLogger
+  module Delegator
+    class << self
+      # creates methods in klass according to the supported levels in the
+      # object specified. (levels are supposed to be methods)
+      #
+      # Arguments:
+      #
+      # on: class which we'll create methods on
+      # from: underlying logger object, which responds to some levels
+      # prefix: prefix log messages with this string
+      # extra_levels: extra levels we want to use from klass delegating to logger
+      # old_levels: the old levels that the class was delegating previously
+      # fallback: not required, suggested fallback level for non-native lvls
+      # info: not required, suggested level usable for information
+      #
+      # Returns a hash with information about supported and fallback levels:
+      #
+      # native: levels natively supported by the underlying object
+      # nonnative: non-native levels, callable only if there is fallback
+      # fallback: (if existing) native level used as fallback for others
+      # supported: supported levels, some maybe via fallback to native ones
+      # info: level the caller can use to give info (can be nil)
+      #
+      def delegate_levels(on:, from:, prefix:, extra_levels: [],
+                          old_levels: [], fallback: UNKNOWN, info: INFO)
+        self.logger = from
+        self.klass = on
+        self.prefix = prefix
+        supp, unsupp = add_level_methods(extra_levels)
+        { native: supp,
+          nonnative: unsupp,
+          info: preferred_lvl(supp, info) }.
+        tap do |level_info|
+          level_info.merge!(
+            if fallback and unsupp.any?
+              flvl = preferred_lvl(supp, fallback)
+              add_as_fallback(unsupp, flvl)
+              { fallback: flvl, supported: supp + unsupp }
+            else
+              { supported: supp }
+            end)
+          (old_levels - level_info[:supported]).each { |lvl| remove_level lvl }
+        end
+      end
+
+      private
+
+      UNKNOWN = :unk
+      INFO = :info
+
+      attr_accessor :klass, :logger, :prefix
+
+      def remove_level(lvl)
+        klass.singleton_class.send :undef_method, lvl rescue nil
+      end
+
+      def add_level(lvl, &blk)
+        klass.define_singleton_method lvl, &blk
+      end
+
+      def add_as_fallback(nonnative, fallback)
+        nonnative.each do |lvl|
+          remove_level lvl
+          add_level lvl do |msg|
+            public_send fallback, "[#{lvl.upcase}] #{msg}"
+          end
+        end
+      end
+
+      def remove_unsupported(unsupported)
+        unsupported.each do |lvl|
+          remove_level lvl
+        end
+      end
+
+      def add_level_methods(extra_levels)
+        get_all_levels_with(extra_levels).partition do |lvl|
+          remove_level lvl
+          if logger.respond_to? lvl
+            add_level_method lvl
+          elsif logger.respond_to? :log
+            add_log_method lvl
+          end
+        end
+      end
+
+      def get_all_levels_with(extra_levels)
+        (extra_levels + (logger.respond_to?(:levels) ?
+                         logger.levels.map { |l| l.downcase.to_sym } : [])).uniq
+      end
+
+      def add_level_method(lvl)
+        if prefix.nil? or prefix.empty?
+          add_level lvl do |msg|
+            logger.send lvl, msg
+          end
+        else
+          add_level lvl do |msg|
+            logger.send lvl, "#{prefix} #{msg}"
+          end
+        end
+      end
+
+      # Useful for Ruby 'logger' from stdlib and compatible interfaces
+      # called when logger.log exists only
+      def add_log_method(lvl)
+        arity = logger.method(:log).arity
+        if arity.abs == 1
+          # one single mandatory parameter, the string logged
+          prefix_s = "[#{lvl.upcase}]"
+          if prefix and not prefix.empty?
+            prefix_s += " " + prefix
+          end
+          klass.define_singleton_method lvl do |msg|
+            logger.send :log, "#{prefix_s} #{msg}"
+          end
+        else
+          # assume two or more params, best effort with 1st being level
+          if lvl_s = ruby_logger_severity(lvl)
+            klass.define_singleton_method lvl do |msg|
+              logger.send :log, lvl_s, msg
+            end
+          end
+        end
+      end
+
+      # try to map a severity level with one compatible with Ruby's Logger
+      def ruby_logger_severity(level)
+        lvl_s = level.upcase
+        l = logger
+        begin
+          l.const_get(lvl_s)
+        rescue NoMethodError
+          l = l.class
+          retry
+        rescue NameError
+        end
+      end
+
+      # return the preferred level if matched in levels, else first one
+      def preferred_lvl(levels, preference)
+        preference_r = Regexp.new("^#{Regexp.escape(preference.to_s)}")
+        levels.find { |l| preference_r.match l } || levels.first
+      end
+    end
+  end
+
+end

data/lib/injectedlogger/logger.rb

@@ -0,0 +1,89 @@
+require 'injectedlogger/delegator'
+
+module InjectedLogger
+  module Logger
+    Error = Class.new StandardError
+    InUse = Class.new Error
+
+    UNKNOWN = :unknown
+    LOGLEVELS = [:debug, :verbose, :info, :notice, :warn, :error, :critical, :fatal, :unknown]
+
+    class << self
+      attr_reader :prefix, :levels, :level_info, :fallback
+
+      def use(logger_obj, levels: LOGLEVELS, fallback: UNKNOWN)
+        if logger and logger != logger_obj
+          raise InUse, "#{self} was already using logger #{logger}"
+        end
+        use! logger_obj, levels: levels, fallback: fallback
+      end
+
+      def use!(logger_obj, levels: LOGLEVELS, fallback: UNKNOWN)
+        self.logger = logger_obj
+        set_prefix '[core]'
+        set_levels levels
+        set_fallback fallback
+        add_methods
+      end
+
+      def prefix=(prefix)
+        set_prefix prefix
+        add_methods
+      end
+
+      def levels=(levels)
+        set_levels(levels)
+        add_methods
+      end
+
+      def fallback=(level)
+        set_fallback level
+        add_methods
+      end
+
+      def method_missing(method, *args, &blk)
+        logger.send method, *args, &blk
+      end
+
+      private
+
+      attr_accessor :logger
+      attr_writer :level_info
+
+      def set_prefix(prefix)
+        @prefix = prefix
+      end
+
+      def set_levels(levels)
+        @levels = levels
+      end
+
+      def set_fallback(level)
+        @fallback = level
+      end
+
+      def add_methods
+        old_levels = level_info ? level_info[:supported] : []
+        self.level_info = InjectedLogger::Delegator.delegate_levels(
+          from: logger, on: self, prefix: prefix, extra_levels: self.levels,
+          old_levels: old_levels, fallback: fallback)
+        set_levels(level_info[:supported]).tap do
+          info_message(level_info) if level_info[:info]
+        end
+      end
+
+      def info_message(level_info)
+        message = if level_info[:fallback]
+                    "non-native log levels #{level_info[:nonnative].join ', '} emulated" \
+                      " using #{level_info[:fallback].upcase} severity"
+                  elsif level_info[:nonnative].any?
+                    "unsupported log levels #{level_info[:nonnative].join ', '}"
+                  else
+                    nil
+                  end
+        send level_info[:info], message if message
+      end
+    end
+
+  end
+end

data/lib/injectedlogger/version.rb

@@ -0,0 +1,3 @@
+module InjectedLogger
+  VERSION = '0.0.1'
+end

data/lib/injectedlogger.rb

@@ -0,0 +1,2 @@
+require 'injectedlogger/logger'
+require 'injectedlogger/version'

data/spec/helpers.rb

@@ -0,0 +1,84 @@
+module Helpers
+  module LevelsMethod
+    def levels
+      if self.singleton_class.const_defined? :LEVELS
+        self.singleton_class.const_get(:LEVELS).map(&:downcase)
+      else
+        @levels || []
+      end
+    end
+  end
+
+  module RubyLoggerCompat
+    LEVELS = [:DEBUG, :VERBOSE, :INFO, :NOTICE, :WARN, :ERROR, :CRITICAL, :FATAL]
+
+    include LevelsMethod
+
+    def self.included(base)
+      define_constant_levels_on base
+    end
+
+    def self.define_constant_levels_on(base)
+      num = rand(LEVELS.size) + 1
+      num -= 1 if num == LEVELS.size # always leave out at least one level
+      # so that we can spec non-native levels
+      LEVELS.sample(rand(LEVELS.size) + 1).each_with_index do |lvl, i|
+        base.const_set(lvl, i)
+      end.tap do |levels|
+        base.const_set(:LEVELS, levels)
+        #base.define_singleton_method :levels do
+        #  levels
+        #end
+      end
+    end
+
+    def log(level, msg)
+      out.puts "#{level} #{msg}"
+    end
+  end
+
+  class Outputter
+    attr_reader :msgs
+
+    def initialize
+      @msgs = []
+    end
+
+    def puts(msg)
+      msgs << msg
+    end
+
+    def match(re)
+      re = Regexp.new("#{Regexp.escape(re)}$") unless re.is_a? Regexp
+      msgs.any? do |m|
+        re.match m
+      end
+    end
+    alias_method :<<, :puts
+  end
+
+  class SpecLogger
+    attr_accessor :out, :called
+
+    def initialize(levels, out = Outputter.new)
+      @levels = if self.singleton_class.const_defined? :LEVELS
+                  self.singleton_class.const_get :LEVELS
+                else
+                  levels
+                end
+      self.out = out
+      self.called = Hash.new do |h, k|
+        h[k] = 0
+      end
+      @levels.each do |lvl|
+        self.singleton_class.send :define_method, lvl.downcase do |msg|
+          out.puts "#{lvl.upcase} #{msg}"
+        end
+      end
+    end
+  end
+
+  class RubyLikeLogger < SpecLogger
+    include RubyLoggerCompat
+  end
+end

data/spec/logger_spec.rb

@@ -0,0 +1,84 @@
+module InjectedLogger
+  RSpec.describe Logger do
+    RSpec.shared_examples "an injected logger" do
+      subject { InjectedLogger::Logger }
+
+      context 'levels' do
+        it { is_expected.to respond_to :levels }
+
+        it 'provides an array when asked for the levels' do
+          expect(subject.levels).to be_kind_of(Array)
+        end
+
+        it 'lists the supported levels' do
+          expect(subject.levels.sort).to eq(subject.level_info[:supported].sort)
+        end
+      end
+
+      context 'level info' do
+        it { is_expected.to respond_to :level_info }
+
+        it 'provides a hash as information for level info' do
+          expect(subject.level_info).to be_kind_of(Hash)
+        end
+
+        [:supported, :native, :nonnative, :fallback, :info].each do |key|
+          it "provides a :#{key} key in level info" do
+            expect(subject.level_info).to have_key(key)
+          end
+        end
+
+        it 'responds to all native levels' do
+          subject.level_info[:native].each do |lvl|
+            expect(subject).to respond_to lvl
+          end
+        end
+
+        it 'responds to all supported levels' do
+          subject.level_info[:supported].each do |lvl|
+            expect(subject).to respond_to lvl
+          end
+        end
+
+        it 'maps all native levels to the underlying logger methods' do
+          subject.level_info[:native].each do |lvl|
+            expect(logger_object).to respond_to lvl
+          end
+        end
+
+        it 'uses a native level as fallback' do
+          fallback = subject.level_info.fetch :fallback, nil
+          expect(subject.level_info[:native]).to include(fallback) if fallback
+        end
+
+        it 'writes to the logger native methods for each native level' do
+          subject.level_info[:native].each_with_index do |lvl, i|
+            str = lvl.to_s + i.to_s
+            expect(logger_object).to receive(lvl).with(Regexp.new("#{Regexp.escape(str)}$"))
+            subject.send lvl, str
+          end
+        end
+
+      end
+    end
+
+    context 'with a Ruby-like logger' do
+      let(:logger_object) { Helpers::RubyLikeLogger.new [] }
+
+      before do
+        InjectedLogger::Logger.use! logger_object
+        #l = InjectedLogger::Logger
+        #STDERR.puts "Native: #{l.level_info[:native]} Non-native: #{l.level_info[:nonnative]} Fallback: #{l.level_info[:fallback]} Info: #{l.level_info[:info]}"
+      end
+
+      it_behaves_like 'an injected logger'
+
+      it 'responds to all levels defined as constants in the underlying logger' do
+        logger_object.singleton_class.const_get(:LEVELS).each do |lvl|
+          expect(subject).to respond_to lvl.downcase
+        end
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,95 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+$LOAD_PATH << File.expand_path('../lib', __FILE__)
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, make a
+# separate helper file that requires this one and then use it only in the specs
+# that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'stringio'
+require_relative './helpers'
+require 'injectedlogger'
+
+RSpec.configure do |config|
+  orig_stdout = $stdout
+  config.before :all do
+    $stdout = StringIO.new
+  end
+  config.after :all do
+    $stdout = orig_stdout
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+=end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: injectedlogger
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alejandro Martinez Ruiz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: This gem injects a given logger into your code
+email:
+- alex@flawedcode.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- injectedlogger.gemspec
+- lib/injectedlogger.rb
+- lib/injectedlogger/delegator.rb
+- lib/injectedlogger/logger.rb
+- lib/injectedlogger/version.rb
+- spec/helpers.rb
+- spec/logger_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/unleashed/injectedlogger
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: This gem injects a given logger into your code
+test_files:
+- spec/helpers.rb
+- spec/logger_spec.rb
+- spec/spec_helper.rb