nrser 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4fc19984de203cad2890315d0e0bafec1f58aa7d
-  data.tar.gz: 3c6a1de1643d012fb402d52a10c76ca993441024
+  metadata.gz: cf2ecc0e4643be7c0c21b0e724cfeb4f5103747b
+  data.tar.gz: a476408cd07adb066c09802bf1e5fbc895e0edec
 SHA512:
-  metadata.gz: 2095704201da4fe33298020d606e7340bf641b53a9fe6a062be210cf5bd2638fea6d5aaedc3955e82e0a8de347dfc440d0c10bd527b53fec9d25b36c70e1307a
-  data.tar.gz: 2eb59417a612656f0d3f4ad9d4cfc44d74bcecc17f1ac24d37049c6c2a8df79066d1e71d877dcd53955e399294dc9938ab8467e67316523f6cf7ed0efa75eba2
+  metadata.gz: 40f0ba9542f641d70420844363c3ed87aa2774a4da49ee77b504421a84f5b350164195d2a46de253fb52d1ee75b4dc8e71604fbe132e58c5da391a2288812af9
+  data.tar.gz: 1a86fd85091edc7c449471134e1c05700e0b9c4228431e6bf52099b2110218c5e4189ad37af1d42835ed6e37fbf50f78aed0f21e660e3334d2bd1e4274e0905a

data/lib/nrser/collection.rb

@@ -0,0 +1,61 @@
+module NRSER
+  # include this module in any custom classes to have them treated as
+  # collections instead of individual objects by the methods in this file
+  module Collection
+    
+    # [Array<Class>] stdlib classes that are considered collections.
+    STDLIB = [
+      Array,
+      Hash,
+      Set,
+    ]
+  end
+  
+  class << self
+    
+    # test if an object is considered a collection.
+    # 
+    # @param obj [Object] object to test
+    # @return [Boolean] true if `obj` is a collection.
+    # 
+    def collection? obj
+      Collection::STDLIB.any? {|cls| obj.is_a? cls} || obj.is_a?(Collection)
+    end
+    
+    # yield on each element of a collection or on the object itself if it's
+    # not a collection. avoids having to normalize to an array to iterate over
+    # something that may be an object OR a collection of objects.
+    # 
+    # @param obj [Object] target object.
+    # 
+    # @yield each element of a collection or the target object itself.
+    # 
+    # @return [Object] obj param.
+    # 
+    def each obj, &block
+      if collection? obj
+        obj.each &block
+      else
+        block.call obj
+        obj
+      end
+    end
+    
+    # if `obj` is a collection, calls `#map` with the block. otherwise,
+    # applies block to the object and returns the result.
+    # 
+    # @param obj [Object] target object.
+    # 
+    # @yield each element of a collection or the target object itself.
+    # 
+    # @return [Object] the result of mapping or applying the block.
+    # 
+    def map obj, &block
+      if collection? obj
+        obj.map &block
+      else
+        block.call obj
+      end
+    end
+  end
+end

data/lib/nrser/logger.rb

@@ -0,0 +1,458 @@
+require 'logger'
+require 'yaml'
+require 'pp'
+require 'json'
+
+require 'nrser'
+require 'nrser/refinements'
+
+using NRSER
+
+module NRSER
+  
+  # @todo doc class
+  class Logger
+    # constants
+    # =========
+    
+    # symbols for the level names
+    LEVEL_SYMS = [
+      :debug,
+      :info,
+      :warn,
+      :error,
+      :fatal,
+      :unknown,
+    ]
+    
+    LOGGING_METHODS = LEVEL_SYMS - [:unknown] + [:die]
+
+    SEVERITY_COLORS = {
+      'DEBUG' => :bright_black,
+      'WARN' => :yellow,
+      'INFO' => :green,
+      'ERROR' => :red,
+      'FATAL' => :on_red,
+    }
+    
+    # class variables
+    # ===============
+    
+    # [Pastel, false] if pastel is present, this will be an instance of
+    # `Pastel` otherwise, it will be false
+    @@pastel = begin
+      require 'pastel'
+      Pastel.new
+    rescue LoadError => e
+      false
+    end
+    
+    # [Hash<IO, ::Logger>] map of IO instances (files, STDOUT, STDERR, etc.)
+    # to Ruby stdlib `Logger` instances that handle the actual writing to
+    # that destination.
+    @ruby_loggers = {}
+
+    # class functions
+    # ==============
+
+    # @api util
+    # *pure*
+    #
+    # format a debug message with optional key / values to print
+    #
+    # @param name [String] logger name.
+    # @param level [String, Symbol, Fixnum] the level in string, symbol or 
+    #     integer form.
+    # @param msg [String] message to print.
+    # @param dump [Hash] optional hash of keys and vaues to dump.    
+    def self.format name, level, msg, dump = {}
+      data = {
+        'logger' => name,
+        'time' => Time.now,
+      }
+      
+      data['msg'] = msg unless msg.empty?
+      data['values'] = dump_value(dump) unless dump.empty?
+      
+      YAML.dump level_name(level) => data
+    end
+    # prev:
+    # def self.format msg, dump = {}
+    #   unless dump.empty?
+    #     msg += "\n" + dump.map {|k, v| "  #{ k }: #{ v.inspect }" }.join("\n")
+    #   end
+    #   msg
+    # end
+    
+    def self.dump_value value      
+      case value
+      when String, Fixnum, Float, TrueClass, FalseClass
+        value
+      when Array
+        value.map {|v| dump_value v}
+      when Hash
+        Hash[value.map {|k, v| [k.to_s, dump_value(v)]}]
+      else
+        value.pretty_inspect
+      end
+    end
+
+    # @api util
+    #
+    #
+    def self.check_level level
+      case level
+      when Fixnum
+        unless level >= 0 && level < LEVEL_SYMS.length
+          raise ArgumentError.new "invalid integer level: #{ level.inspect }"
+        end
+      when Symbol
+        unless LEVEL_SYMS.include? level
+          raise ArgumentError.new "invalid level symbol: #{ level.inspect }"
+        end
+      when String
+        unless LEVEL_SYMS.map {|_| _.to_s.upcase}.include? level
+          raise ArgumentError.new "invalid level name: #{ level.inspect }"
+        end
+      else
+        raise TypeError.new binding.erb <<-END
+          level must be Fixnum, Symbol or String, not <%= level.inspect %>
+        END
+      end
+    end # #check_level
+
+    # @api util
+    # *pure*
+    #
+    # get the integer value of a level (like ::Logger::DEBUG, etc.).
+    #
+    # @param level [Fixnum, Symbol, String] the integer level, method symbol,
+    #     or string name (all caps).
+    #
+    # @return [Fixnum] level integer (between 0 and 5 inclusive).
+    #
+    def self.level_int level
+      check_level level
+      case level
+      when Fixnum
+        level
+      when Symbol
+        LEVEL_SYMS.each_with_index {|sym, index|
+          return index if level == sym
+        }
+      when String
+        LEVEL_SYMS.each_with_index {|sym, index|
+          return index if level == sym.to_s.upcase
+        }
+      end
+    end
+
+    # @api util
+    # *pure*
+    #
+    # get the string "name" of a level ('DEBUG', 'INFO', etc.).
+    #
+    # @param level [Fixnum, Symbol, String] the integer level, method symbol,
+    #     or string name (all caps).
+    #
+    # @return ['DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL', 'UNKNOWN']
+    #
+    def self.level_name level
+      check_level level
+      case level
+      when Fixnum
+        LEVEL_SYMS[level].to_s.upcase
+      when Symbol
+        level.to_s.upcase
+      when String
+        level
+      end
+    end
+
+    # @api util
+    # *pure*
+    #
+    # get the symbol for a level as used in method sigs.
+    #
+    # @param level [Fixnum, Symbol, String] the integer level, method symbol,
+    #     or string name (all caps).
+    #
+    # @return [:debug, :info, :warn, :error, :fatal, :unknown]
+    #
+    def self.level_sym level
+      check_level level
+      case level
+      when Fixnum
+        LEVEL_SYMS[level]
+      when Symbol
+        level
+      when String
+        level.downcase.to_sym
+      end
+    end
+    
+    # @api util
+    # *pure*
+    # 
+    # creates methods closed around a `NRSER::Logger` instance to be attached
+    # to objects to access the logger and do logging and 'installs' them on
+    # the target.
+    # 
+    # @param target [Object] object to install methods on.
+    # 
+    # @param logger [NRSER::Logger] the logger to bind the methods to.
+    # 
+    # @return nil
+    # 
+    def self.install_methods! target, logger
+      methods = {
+        logger: {
+          private: false,
+          body: ->() { logger },
+        },
+      }
+      
+      LOGGING_METHODS.each do |sym|
+        methods[sym] = {
+          private: true,
+          body: ->(*args, &block) { logger.send sym, *args, &block },
+        }
+      end
+      
+      if target.is_a? Class
+        methods.each do |sym, stuff|
+          target.define_singleton_method sym, &stuff[:body]
+          target.send :define_method, sym, &stuff[:body]
+          target.send :private, sym if stuff[:private]
+        end
+        
+      elsif target.is_a? Module
+        methods.each do |sym, stuff|
+          target.define_singleton_method sym, &stuff[:body]
+          target.private_class_method sym if stuff[:private]
+        end
+        
+      else
+        methods.each do |sym, stuff|
+          target.send :define_method, sym, &stuff[:body]
+          target.send :private, sym if stuff[:private]
+        end
+      end
+      
+      nil
+    end
+    
+    
+    # creates a new `NRSER::Logger` and 'installs' a logger on target, adding
+    # singleton (class) and instance methods as appropriate
+    #
+    # @param target [Object] the object to install a new logger on, which can
+    #     be a Module, a Class, or just any plain-old instance that you want
+    #     to have it's own logger client.
+    # 
+    # @param options [Hash] options used when creating the `NRSER::Logger`.
+    # @see NRSER::Logger#initialize
+    # 
+    # @return [NRSER::Logger] the new `NRSER::Logger` instance.
+    # 
+    def self.install target, options = {}
+      options[:on] ||= false
+      options[:name] ||= if target.respond_to?(:name) && !target.name.nil?
+        target.name
+      else
+        target.to_s
+      end
+      
+      logger = self.new options
+      install_methods! target, logger
+      
+      logger
+    end # .install
+    
+    
+    # singleton (class) and instance methods as appropriate
+    #
+    # 
+    # @param source [Object] source instance with a logger installed to use
+    #     for the target.
+    # 
+    # @param target [Object] the object to use the source's logger.
+    # 
+    # @return [NRSER::Logger] the new `NRSER::Logger` instance.
+    # 
+    def self.use source, target
+      install_methods! target, source.logger
+    end # .use
+
+    attr_reader :name, :dest, :level, :ruby_logger
+
+    def initialize options = {}
+      options = {
+        dest: $stderr,
+        level: :info,
+        say_hi: true,
+        on: true,
+      }.merge options
+
+      @name = options[:name]
+      @on = options[:on]
+      @level = self.class.level_int options[:level]
+      self.dest = options[:dest]
+
+      if @on && options[:say_hi]
+        info <<-END.squish
+          started to logging to #{ @dest } at level
+          #{ self.class.level_name @level }...
+        END
+      end
+    end
+
+    def on?
+      @on
+    end
+
+    def off?
+      !on?
+    end
+
+    def on &block
+      if block
+        prev = @on
+        @on = true
+        block.call
+        @on = prev
+      else
+        @on = true
+      end
+    end
+
+    def off &block
+      if block
+        prev = @on
+        @on = false
+        block.call
+        @on = prev
+      else
+        @on = false
+      end
+    end
+
+    def level= level
+      @level = self.class.level_int(level)
+      @ruby_loggers.each do |dest, ruby_logger|
+        ruby_logger.level = @level
+      end
+      @level
+    end
+    
+    def with_level level, &block
+      prev_level = self.level
+      self.level = level
+      block.call
+      self.level = prev_level
+    end
+    
+    def dest= dest
+      @ruby_loggers = {}
+      NRSER.each dest do |dest|
+        @ruby_loggers[dest] = ::Logger.new(dest).tap do |ruby_logger|
+          ruby_logger.level = @level
+          ruby_logger.formatter = proc do |severity, datetime, progname, msg|
+            # just pass through
+            msg
+          end
+        end
+      end
+      @dest = dest
+    end
+    
+    # logging api
+    # ===========
+    
+    # @api logging
+    def debug *args, &block
+      send_log :debug, args, block
+    end
+    
+    # @api logging
+    def info *args, &block
+      send_log :info, args, block
+    end
+    
+    # @api logging
+    def warn *args, &block
+      send_log :warn, args, block
+    end
+
+    # @api logging
+    def error *args, &block
+      send_log :error, args, block
+    end
+
+    # @api logging
+    def fatal *args, &block
+      send_log :fatal, args, block
+    end
+    
+    # @api logging
+    def die *args, &block
+      if @on
+        send_log :fatal, args, block
+        abort
+      else
+        abort self.class.format(
+          @name,
+          :fatal,
+          *extract_msg_and_dump(args, block)
+        )
+      end
+    end
+
+    private
+      def extract_msg_and_dump args, block
+        msg = ''
+        dump = {}
+        case args.length
+        when 0
+          # if there is no block, just no-op
+          # @todo is this the right way to go?
+          if block
+            result = block.call
+            result = [result] unless result.is_a? Array
+            
+            return extract_msg_and_dump result, nil
+          end
+        when 1
+          case args[0]
+          when Hash
+            dump = args[0]
+          when String
+            msg = args[0]
+          else
+            msg = args[0].to_s
+          end
+        when 2
+          msg, dump = args
+        else
+          raise "must provide one or two arguments, not #{ args.length }"
+        end
+        
+        [msg, dump]
+      end
+    
+      def send_log level_sym, args, block
+        return unless @on && @level <= self.class.level_int(level_sym)
+        
+        msg, dump = extract_msg_and_dump args, block
+
+        @ruby_loggers.each do |dest, ruby_logger|
+          ruby_logger.send(level_sym, @name) do
+            self.class.format(@name, level_sym, msg, dump)
+          end
+        end
+      end
+      
+    # end private
+
+  end # Logger
+end # NRSER

data/lib/nrser/version.rb

@@ -1,3 +1,3 @@
 module NRSER
-  VERSION = "0.0.13"
+  VERSION = "0.0.14"
 end

data/lib/nrser.rb

@@ -1,4 +1,5 @@
 require "nrser/version"
+require "nrser/collection"
 
 module NRSER
   class << self

data/nrser.gemspec

@@ -20,4 +20,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "yard"
+  spec.add_development_dependency "cmds"
 end

data/spec/nrser/collection/each_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe "NRSER.each" do
+  it "iterates enumerables" do
+    [
+      [1, 2, 3],
+      Set.new([1, 2, 3]),
+      {a: 1, b: 2, c: 3},
+    ].each do |enumerable|
+      count = 0
+      NRSER.each enumerable do |element|
+        count += 1
+      end
+      expect(count).to eq enumerable.count
+    end
+  end
+  
+  [
+    "abc",
+    1,
+    Pathname.new('.').expand_path,
+    File.open('/dev/null'),
+  ].each do |obj|
+    it "iterates a single #{ obj.class }" do
+      count = 0
+      NRSER.each obj do |element|
+        expect(element).to eq obj
+        count += 1
+      end
+      expect(count).to eq 1
+    end
+  end
+end

data/spec/nrser/collection/map_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe "NRSER.map" do
+  it "maps enumerables" do
+    [
+      [1, 2, 3],
+      Set.new([1, 2, 3]),
+      {a: 1, b: 2, c: 3},
+    ].each do |enumerable|
+      count = 0
+      result = NRSER.map enumerable do |element|
+        count += 1
+        :x
+      end
+      expect(count).to eq enumerable.count
+      expect(result).to eq enumerable.map {|_| :x}
+    end
+  end
+  
+  [
+    "abc",
+    1,
+    Pathname.new('.').expand_path,
+    File.open('/dev/null'),
+  ].map do |obj|
+    it "iterates a single #{ obj.class }" do
+      count = 0
+      result = NRSER.map obj do |element|
+        expect(element).to eq obj
+        count += 1
+        :x
+      end
+      expect(count).to eq 1
+      expect(result).to eq :x
+    end
+  end
+end

data/spec/nrser/logger/dest_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'NRSER::Logger.dest=' do
+  it "writes to multiple destinations" do
+    files = [Tempfile.new('f1'), Tempfile.new('f2')]
+    logger = NRSER::Logger.new dest: files, say_hi: false
+    logger.info "hey!"
+    files.each do |file|
+      file.rewind
+      data = YAML.load file.read
+      expect(data['INFO']['msg']).to eq "hey!"
+    end
+  end
+end

data/spec/nrser/logger/die_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+using NRSER
+
+describe 'NRSER::Logger#die' do
+  it "prints the log message when logger is off" do
+    src = <<-END.dedent
+      require 'nrser/logger'
+    
+      NRSER::Logger.install self
+      
+      die "die!", cause: "just 'cause"
+    END
+    
+    err = Cmds.err("bundle exec ruby"){ src }
+    data = YAML.load(err)['FATAL']
+    
+    expect(data['msg']).to eq 'die!'
+    expect(data['values']).to eq({'cause' => "just 'cause"})
+  end
+  
+  it(
+    "prints only to the log when it's on and the log writes to " + 
+    "$stderr"
+  ) do
+    src = <<-END
+      require 'nrser/logger'
+      
+      NRSER::Logger.install self, on: true, say_hi: false
+      
+      die "die!", cause: "just 'cause"
+    END
+    
+    err = Cmds.err("bundle exec ruby"){ src }
+    
+    data = YAML.load(err)['FATAL']
+    
+    expect(data['msg']).to eq 'die!'
+    expect(data['values']).to eq({'cause' => "just 'cause"})
+  end
+end

data/spec/nrser/logger/install_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe 'NRSER::Logger.install' do
+  it "installs on the global instance" do
+    NRSER::Logger.install MAIN
+    
+    expect(logger).to be_a NRSER::Logger
+    expect(logger.name).to eq 'main'
+    
+    expect_to_not_log { info "hey" }
+    
+    logger.on
+    
+    expect_to_log { info "hey" }
+    expect_to_not_log { debug "hey" }
+  end
+  
+  it "is accesible in modules" do
+    
+    mod = Module.new do
+      def self.log
+        info "hey"
+      end
+      
+      def self.logger_name
+        logger.name
+      end
+    end
+    
+    expect_to_log { mod.log }
+    expect(mod.logger_name).to eq 'main'
+  end
+  
+  it "is accessible in classes" do
+    
+    cls = Class.new do
+      def self.log
+        info "hey"
+      end
+      
+      def log
+        info "hey"
+      end
+    end
+    
+    expect_to_log { cls.log }
+    
+    c = cls.new
+    expect_to_log { c.log }
+  end
+  
+  it "installs in modules" do
+    mod = Module.new do
+      NRSER::Logger.install self
+    end
+    
+    expect(mod.logger).to_not be MAIN.logger
+    expect(mod.logger.name).to match /\#\<Module/
+    
+    expect_to_not_log { mod.send :info, "hey" }
+    
+    mod.logger.on
+    
+    expect_to_log { mod.send :info, "hey" }
+  end
+  
+  it "installs in classes" do
+    cls = Class.new do
+      NRSER::Logger.install self
+    end
+    
+    expect(cls.logger).to_not be MAIN.logger
+    expect(cls.logger.name).to match /\#\<Class/
+    
+    c = cls.new
+    
+    expect(c.logger).to be cls.logger
+    expect(c.logger.name).to match /\#\<Class/
+    
+    expect_to_not_log { cls.send :info, "hey" }
+    expect_to_not_log { c.send :info, "hey" }
+    
+    cls.logger.on
+    
+    expect_to_log { cls.send :info, "hey" }
+    expect_to_log { c.send :info, "hey" }
+    
+    expect_to_not_log { cls.send :debug, "hey" }
+    
+    # @todo hmmm... this switches the log level for the entire class, not
+    #     the instance...
+    c.logger.level = :debug
+    
+    expect_to_log { cls.send :debug, "hey" }
+    expect_to_log { c.send :debug, "hey" }
+  end
+  
+end

data/spec/nrser/logger/level_int_spec.rb

@@ -0,0 +1,22 @@
+require 'logger'
+
+require 'spec_helper'
+
+describe 'NRSER::Logger.level_int' do
+  it "translates level ints, names and symbols" do
+    LOG_LEVELS.each do |int, (sym, name)|
+      expect( NRSER::Logger.level_int int ).to eq int
+      expect( NRSER::Logger.level_int sym ).to eq int
+      expect( NRSER::Logger.level_int name ).to eq int
+    end
+  end
+
+  it "pukes on bad a args" do
+    BAD_LOG_LEVELS.each do |arg|
+      expect {
+        NRSER::Logger.level_int arg
+      }.to raise_error ArgumentError
+    end
+  end
+
+end

data/spec/nrser/logger/level_name_spec.rb

@@ -0,0 +1,23 @@
+require 'logger'
+
+require 'spec_helper'
+
+describe 'NRSER::Logger.level_name' do
+
+  it "translates level names, integers and symbols" do
+    LOG_LEVELS.each do |int, (sym, name)|
+      expect( NRSER::Logger.level_name name ).to eq name
+      expect( NRSER::Logger.level_name sym ).to eq name
+      expect( NRSER::Logger.level_name int ).to eq name
+    end
+  end
+
+  it "pukes on bad a args" do
+    BAD_LOG_LEVELS.each do |arg|
+      expect {
+        NRSER::Logger.level_name arg
+      }.to raise_error ArgumentError
+    end
+  end
+
+end

data/spec/nrser/logger/level_sym_spec.rb

@@ -0,0 +1,22 @@
+require 'logger'
+
+require 'spec_helper'
+
+describe 'NRSER::Logger.level_sym' do
+  it "translates level syms, names and symbols" do
+    LOG_LEVELS.each do |int, (sym, name)|
+      expect( NRSER::Logger.level_sym sym ).to eq sym
+      expect( NRSER::Logger.level_sym int ).to eq sym
+      expect( NRSER::Logger.level_sym name ).to eq sym
+    end
+  end
+
+  it "pukes on bad a args" do
+    BAD_LOG_LEVELS.each do |arg|
+      expect {
+        NRSER::Logger.level_sym arg
+      }.to raise_error ArgumentError
+    end
+  end
+
+end

data/spec/nrser/logger/send_log_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+NRSER::Logger.install MAIN, on: true, say_hi: false
+
+describe 'NRSER::Logger.send_log' do
+  it "works with blocks that yield msg strings" do
+    expect_to_log {
+      info {
+        "hey!"
+      }
+    }
+  end
+  
+  it "works with blocks that yield values hashes" do
+    expect_to_log {
+      info {
+        {x: 'ex', y: 'why?'}
+      }
+    }
+  end
+  
+  it "works with blocks that yield msg and values" do
+    expect_to_log {
+      info {
+        ["hey!", {x: 'ex', y: 'why'}]
+      }
+    }
+  end
+  
+  it "doesn't evaluate blocks unless they're going to be logged" do
+    evaled = false
+    
+    expect_to_log {
+      info {
+        evaled = true
+      }
+    }
+    
+    expect(evaled).to be true
+    
+    evaled = false
+    
+    logger.off {
+      expect_to_not_log {
+        info {
+          evaled = true
+        }
+      }
+    }
+    
+    expect(evaled).to be false
+    
+    logger.with_level :fatal do
+      expect_to_not_log {
+        info {
+          evaled = true
+        }
+      }
+    end
+    
+    expect(evaled).to be false
+  end
+end

data/spec/nrser/logger/use_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'NRSER::Logger.use' do
+  it "points to the source logger" do
+    module Source
+      NRSER::Logger.install self, on: true, say_hi: false
+      
+      module Target
+        NRSER::Logger.use Source, self
+      end
+    end
+    
+    expect_to_log { Source::Target.send :info, "here" }
+    expect(Source::Target.logger).to be Source.logger
+  end
+end

data/spec/spec_helper.rb

@@ -1,2 +1,26 @@
+require 'cmds'
+
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'nrser'
+require 'nrser/logger'
+
+MAIN = self
+
+LOG_LEVELS = {
+  Logger::DEBUG => [:debug, 'DEBUG'],
+  Logger::INFO => [:info, 'INFO'],
+  Logger::WARN => [:warn, 'WARN'],
+  Logger::ERROR => [:error, 'ERROR'],
+  Logger::FATAL => [:fatal, 'FATAL'],
+  Logger::UNKNOWN => [:unknown, 'UNKNOWN'],
+}
+
+BAD_LOG_LEVELS = [:blah, -1, 6, "BLAH"]
+
+def expect_to_log &block
+  expect(&block).to output.to_stderr_from_any_process
+end
+
+def expect_to_not_log &block
+  expect(&block).to_not output.to_stderr_from_any_process
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nrser
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - nrser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-08 00:00:00.000000000 Z
+date: 2016-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  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: cmds
+  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'
 description: 
 email:
 - neil@neilsouza.com
@@ -67,13 +95,25 @@ files:
 - README.md
 - Rakefile
 - lib/nrser.rb
+- lib/nrser/collection.rb
+- lib/nrser/logger.rb
 - lib/nrser/refinements.rb
 - lib/nrser/version.rb
 - nrser.gemspec
+- spec/nrser/collection/each_spec.rb
+- spec/nrser/collection/map_spec.rb
 - spec/nrser/common_prefix_spec.rb
 - spec/nrser/dedent_spec.rb
 - spec/nrser/format_exception_spec.rb
 - spec/nrser/indent_spec.rb
+- spec/nrser/logger/dest_spec.rb
+- spec/nrser/logger/die_spec.rb
+- spec/nrser/logger/install_spec.rb
+- spec/nrser/logger/level_int_spec.rb
+- spec/nrser/logger/level_name_spec.rb
+- spec/nrser/logger/level_sym_spec.rb
+- spec/nrser/logger/send_log_spec.rb
+- spec/nrser/logger/use_spec.rb
 - spec/nrser/refinements/erb_spec.rb
 - spec/nrser/refinements/format_exception_spec.rb
 - spec/nrser/refinements/indent_spec.rb
@@ -108,10 +148,20 @@ signing_key:
 specification_version: 4
 summary: basic ruby utils i use in a lot of stuff.
 test_files:
+- spec/nrser/collection/each_spec.rb
+- spec/nrser/collection/map_spec.rb
 - spec/nrser/common_prefix_spec.rb
 - spec/nrser/dedent_spec.rb
 - spec/nrser/format_exception_spec.rb
 - spec/nrser/indent_spec.rb
+- spec/nrser/logger/dest_spec.rb
+- spec/nrser/logger/die_spec.rb
+- spec/nrser/logger/install_spec.rb
+- spec/nrser/logger/level_int_spec.rb
+- spec/nrser/logger/level_name_spec.rb
+- spec/nrser/logger/level_sym_spec.rb
+- spec/nrser/logger/send_log_spec.rb
+- spec/nrser/logger/use_spec.rb
 - spec/nrser/refinements/erb_spec.rb
 - spec/nrser/refinements/format_exception_spec.rb
 - spec/nrser/refinements/indent_spec.rb
@@ -120,3 +170,4 @@ test_files:
 - spec/nrser/truncate_spec.rb
 - spec/nrser_spec.rb
 - spec/spec_helper.rb
+has_rdoc: