injectedlogger 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5dd3d22d80668b023317badf017352dd0f0abf70
-  data.tar.gz: d31bae1ac80c58e7bd389d7337c8fe0f16932cf6
+  metadata.gz: b509e96629351ab9e5dad7429cff1942e09a12a6
+  data.tar.gz: a54f79bdf60b07015830f44749b8de05127a47e9
 SHA512:
-  metadata.gz: a32adcb1e875e2d82d57e4bc906f09e0f565e5233009e6e320b99a0b42d7e88f538584b77e20f00ac8b8107a529c31f47b347b36d70ae3761977e7b79d4bb1ac
-  data.tar.gz: 2e22f22c43ef4ad755edd660cbd4be03fe8326bf2fa7dd56fd5b9c4b5b67899fd4470bd143df46a52b15e017972b3b3ee23a5c118820f79f852c7041781c82dd
+  metadata.gz: 8b1cb6ab011b7a7017548f4a271417a97d3458488190e68338465cec18d28eb90b6cd9c48f6c9a39f2635f1b8ef214e6ba9f3ca8663cdb098ddddbc8990af62c
+  data.tar.gz: 426effc3a7dc5e304eb3f8fa43d62c9ba7ca6827808e1cfe6d281e1d6774cc40757894b7fa234697d5f3336c6a93eaebb996f11426632c5dc862c285b3e2af9d

data/README.md

@@ -1,6 +1,6 @@
 # A logger injection gem
 
-This gem can be used to inject a logger in your Ruby code.
+This gem can be used to inject several loggers in different parts of your Ruby project.
 
 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
 
@@ -40,7 +40,13 @@ end
 ### On the code injecting a logger:
 
 ```ruby
-InjectedLogger.inject somelogger
+InjectedLogger.inject somelogger, on: MyLogger
+```
+
+### In case some other dependency needs a logger:
+
+```ruby
+InjectedLogger.inject somelogger, prefix: '[other]', on: Other::Logger
 ```
 
 ## Generating the gem

data/lib/injectedlogger/logger.rb

@@ -2,115 +2,129 @@ require 'injectedlogger/errors'
 require 'injectedlogger/delegator'
 
 module InjectedLogger
-  def self.injected?
-    Logger.injected?
+
+  def self.logger
+    @logger ||= Hash.new { |h, k| h[k] = Logger.new }
+  end
+  private_class_method :logger
+
+  def self.injected?(on:)
+    logger[on].injected?
+  end
+
+  def self.inject(*args, on:, **options)
+    logger[on].inject(*args, **options)
   end
 
-  def self.inject(*args)
-    Logger.inject(*args)
+  def self.inject!(*args, on:, **options)
+    logger[on].inject!(*args, **options)
   end
 
-  def self.inject!(*args)
-    Logger.inject!(*args)
+  def self.after_injection(&blk)
+    on = blk.binding.eval 'self'
+    logger[on].after_hook = blk
   end
 
-  module Logger
+  class Logger
     UNKNOWN = :unknown
     LOGLEVELS = [:debug, :verbose, :notice, :info, :warn, :error, :critical, :fatal, :unknown]
 
-    class << self
-      attr_reader :prefix, :levels, :level_info, :fallback
+    attr_reader :prefix, :levels, :level_info, :fallback
+    attr_accessor :after_hook
 
-      def injected?
-        not logger.nil?
-      end
+    def injected?
+      not logger.nil?
+    end
 
-      def inject(logger_obj, levels: LOGLEVELS, fallback: UNKNOWN, prefix: nil)
-        if logger and logger != logger_obj
-          raise InUse, "#{self} was already using logger #{logger}"
-        end
-        inject! logger_obj, levels: levels, fallback: fallback
+    def inject(logger_obj, levels: LOGLEVELS, fallback: UNKNOWN, prefix: nil)
+      if logger and logger != logger_obj
+        raise InUse, "#{self} was already using logger #{logger}"
       end
+      inject! logger_obj, levels: levels, fallback: fallback
+    end
 
-      def inject!(logger_obj, levels: LOGLEVELS, fallback: UNKNOWN, prefix: nil)
-        self.logger = logger_obj
-        set_prefix prefix
-        set_levels levels
-        set_fallback fallback
-        add_methods
-        self
-      end
+    def inject!(logger_obj, levels: LOGLEVELS, fallback: UNKNOWN, prefix: nil)
+      self.logger = logger_obj
+      set_prefix prefix
+      set_levels levels
+      set_fallback fallback
+      add_methods
+      self
+    end
 
-      def prefix=(prefix)
-        set_prefix prefix
-        add_methods
-      end
+    def prefix=(prefix)
+      set_prefix prefix
+      add_methods
+    end
 
-      def levels=(levels)
-        set_levels(levels)
-        add_methods
-      end
+    def levels=(levels)
+      set_levels(levels)
+      add_methods
+    end
 
-      def add_levels(*levels)
-        lvls = self.levels + levels
-        lvls.uniq!
-        self.levels = lvls
-      end
+    def add_levels(*levels)
+      lvls = self.levels + levels
+      lvls.uniq!
+      self.levels = lvls
+    end
 
-      def fallback=(level)
-        set_fallback level
-        add_methods
-      end
+    def fallback=(level)
+      set_fallback level
+      add_methods
+    end
 
-      def method_missing(method, *args, &blk)
-        logger.send method, *args, &blk
-      rescue NoMethodError
-        super
-      end
+    def method_missing(method, *args, &blk)
+      logger.send method, *args, &blk
+    rescue NoMethodError
+      super
+    end
 
-      def respond_to_missing?(method, priv = false)
-        logger.respond_to?(method, priv) || super
-      end
+    def respond_to_missing?(method, priv = false)
+      logger.respond_to?(method, priv) || super
+    end
 
-      private
+    private
 
-      attr_accessor :logger
-      attr_writer :level_info
+    attr_accessor :logger
+    attr_writer :level_info
 
-      def set_prefix(prefix)
-        @prefix = prefix
-      end
+    def set_prefix(prefix)
+      @prefix = prefix
+    end
 
-      def set_levels(levels)
-        @levels = levels
-      end
+    def set_levels(levels)
+      @levels = levels
+    end
 
-      def set_fallback(level)
-        @fallback = level
-      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 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])
+    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
+    def ready
+      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

data/lib/injectedlogger/version.rb

@@ -1,3 +1,3 @@
 module InjectedLogger
-  VERSION = '0.0.7'
+  VERSION = '0.0.8'
 end

data/lib/injectedlogger.rb

@@ -43,34 +43,27 @@ module InjectedLogger
     on.send :define_method, method_name do
       # avoid recursion if someone calls logger in the block
       on.send :remove_method, method_name
-      unless InjectedLogger.injected?
+      unless InjectedLogger.injected? on: on
         args = blk ? blk.call : nil
-        InjectedLogger.inject_logger args, required
+        InjectedLogger.inject_logger args, required, on: on
       end
+      thislogger = InjectedLogger.send(:logger).[](on)
       required.uniq!
-      required -= InjectedLogger::Logger.level_info[:supported]
+      required -= thislogger.level_info[:supported]
       unless required.empty?
-        InjectedLogger::Logger.add_levels(*required)
-        required -= InjectedLogger::Logger.level_info[:supported]
+        thislogger.add_levels(*required)
+        required -= thislogger.level_info[:supported]
         raise InjectedLogger::UnsupportedLevels.new(required) unless required.empty?
       end
       on.send :define_method, method_name do
-        InjectedLogger::Logger
+        thislogger
       end
-      InjectedLogger.after_hook.call(InjectedLogger::Logger) if InjectedLogger.after_hook
-      InjectedLogger::Logger
+      thislogger.after_hook.call(thislogger) if thislogger.after_hook
+      thislogger.send :ready
+      thislogger
     end
   end
 
-  def self.after_injection(&blk)
-    self.after_hook = blk
-  end
-
-  class << self
-    attr_accessor :after_hook
-    private :after_hook=
-  end
-
   private
 
   def self.default_logger
@@ -78,7 +71,7 @@ module InjectedLogger
     { logger: ::Logger.new(STDERR) }
   end
 
-  def self.inject_logger(args, required)
+  def self.inject_logger(args, required, on:)
     args ||= {}
     args = default_logger.merge(args) unless args.has_key? :logger
     logger = args.delete :logger
@@ -87,6 +80,7 @@ module InjectedLogger
       args[:levels].push(required).flatten!
       args[:levels].uniq!
     end
-    InjectedLogger.inject(logger, args)
+    args[:on] = on
+    InjectedLogger.inject(logger, **args)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: injectedlogger
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Alejandro Martinez Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-09 00:00:00.000000000 Z
+date: 2014-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler