lotus-utils 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b6a206acbf5c8f3f36aecb39a8a834faba7f40d9
-  data.tar.gz: fdeea0a0daf779be52a3f17a62460dbc5dd30f53
+  metadata.gz: 1937436164015390ea262191b1535441167f1e9c
+  data.tar.gz: 65bb8ce1f1d128fdca98e1918f96c08cf9fa4175
 SHA512:
-  metadata.gz: bfe9cc4e5ef901a898905aff9eea8ffa39c56b0e5fce80c8d40e6493d7a5c15ad3189bec6ebebe50b87185b78a66189f38b45e299df3a258253bfce182e4d854
-  data.tar.gz: d928d2cf1dc04a209144be6e03d9f25a1a4f064d079a809f82cd15877858b298a106ab378f025f14f09488cc78fad9ef1c352275af3febf46ecae6b189158dac
+  metadata.gz: aace7eede8b7e773ea4401d70e5537e89a965d5ed0000ffe9767ad5f78bcd5629080c17755770f3a4358fa61adb63da604df641a685073be6ea2fef9eb44bd88
+  data.tar.gz: 380a90d0b5df6cc0e52bf4bfea010f55e57fc207864268d39d3ba3f6d3f3e86541951fda027edbcef7da968be26779ab88b5e22dfb508b8a8fca86c72638568d

data/CHANGELOG.md

@@ -1,3 +1,52 @@
+## v0.2.0
+### Jun 23, 2014
+
+a969fda 2014-06-12 **Luca Guidi** Implemented Lotus::Utils::Kernel.Symbol
+
+13532f5 2014-06-13 **Luca Guidi** [breaking] Implemented Lotus::Utils::Callbacks::Chain#freeze in order to prevent modification after the object has been frozen
+
+e438da8 2014-06-13 **Luca Guidi** [breaking] All the Utils::Kernel methods will raise TypeError in case of failed coercion.
+
+7fd90d1 2014-06-13 **Luca Guidi** Make Kernel.Pathname to raise an error when nil is passed as argument
+
+6437791 2014-06-13 **Luca Guidi** [breaking] Make Kernel.Time to raise an error when nil is passed as argument
+
+c7f428b 2014-06-13 **Luca Guidi** [breaking] Make Kernel.DateTime to raise an error when nil is passed as argument
+
+ab0dc0c 2014-06-13 **Luca Guidi** [breaking] Make Kernel.Date to raise an error when nil is passed as argument
+
+11d5c1c 2014-06-13 **Luca Guidi** [breaking] Make Kernel.Boolean to return false when nil is passed as argument
+
+c3bcaea 2014-06-13 **Luca Guidi** [breaking] Make Kernel.String to return an empty string when nil is passed as argument
+
+0bd3826 2014-06-13 **Luca Guidi** [breaking] Make Kernel.Float to return 0.0 when nil is passed as argument
+
+7ce8018 2014-06-13 **Luca Guidi** [breaking] Make Kernel.Integer to return 0 when nil is passed as argument
+
+0377326 2014-06-13 **Luca Guidi** [breaking] Make Kernel.Hash to return an empty hash when nil is passed as argument
+
+d3b0e2a 2014-06-13 **Luca Guidi** [breaking] Make Kernel.Set to return an empty set when nil is passed as argument
+
+cd2d1b8 2014-06-13 **Luca Guidi** [breaking] Make Kernel.Array to return an empty array when nil is passed as argument
+
+32c15d6 2014-06-09 **Luca Guidi** Implemented Lotus::Utils::LoadPaths#freeze in order to prevent modification after the object has been frozen
+
+2b8d8d5 2014-06-09 **Luca Guidi** Implemented Lotus::Utils::LoadPaths#initialize_copy in order to safely dup and clone
+
+9a91222 2014-06-09 **Luca Guidi** Implemented Lotus::Utils::LoadPaths#push, also aliased as #<<
+
+1d3d986 2014-06-08 **Luca Guidi** Use composition over inheritance for Lotus::Utils::LoadPaths
+
+82d0af3 2014-06-08 **Luca Guidi** [breaking] Use composition over inheritance for Lotus::Utils::Callbacks::Chain
+
+442175b 2014-06-04 **Luca Guidi** Introduced Lotus::Utils::LoadPaths
+
+2734a87 2014-05-28 **Luca Guidi** Introduced Lotus::Utils::String#namespace, in order to return the top level Ruby namespace for the given string
+
+a2a19e9 2014-05-10 **Luca Guidi** Support for Ruby 2.1.2
+
+07146a1 2014-05-08 **Luca Guidi** Implemented Lotus::Utils::Kernel.Pathname
+
 ## v0.1.1
 ### Apr 23, 2014
 

data/README.md

@@ -41,10 +41,9 @@ Or install it yourself as:
 ## Usage
 
 __Lotus::Utils__ is designed to enhance Ruby's code and stdlib.
-By default this gem doesn't load any code, require yourself what you need.
+By default this gem doesn't load any code, you must require what you need.
 
-Please read the documentation of each module, in order to understand how to use
-each feature.
+Please read the documentation of each module.
 
 ## Versioning
 

data/lib/lotus/utils/callbacks.rb

@@ -9,7 +9,16 @@ module Lotus
       #
       # @since 0.1.0
       # @private
-      class Chain < ::Array
+      class Chain
+        # Return a new chain
+        #
+        # @return [Lotus::Utils::Callbacks::Chain]
+        #
+        # @since 0.2.0
+        def initialize
+          @chain = Array.new
+        end
+
         # Adds the given callbacks to the chain
         #
         # @param callbacks [Array] one or multiple callbacks to add
@@ -17,9 +26,12 @@ module Lotus
         #
         # @return [void]
         #
+        # @raise [RuntimeError] if the object was previously frozen
+        #
         # @see #run
         # @see Lotus::Utils::Callbacks::Callback
         # @see Lotus::Utils::Callbacks::MethodCallback
+        # @see Lotus::Utils::Callbacks::Chain#freeze
         #
         # @since 0.1.0
         #
@@ -40,10 +52,10 @@ module Lotus
         def add(*callbacks, &blk)
           callbacks.push blk if block_given?
           callbacks.each do |c|
-            push Factory.fabricate(c)
+            @chain.push Factory.fabricate(c)
           end
 
-          uniq!
+          @chain.uniq!
         end
 
         # Runs all the callbacks in the chain.
@@ -92,10 +104,30 @@ module Lotus
         #
         #   Those callbacks will be invoked within the context of `action`.
         def run(context, *args)
-          each do |callback|
+          @chain.each do |callback|
             callback.call(context, *args)
           end
         end
+
+        # It freezes the object by preventing further modifications.
+        #
+        # @since 0.2.0
+        #
+        # @see http://ruby-doc.org/core-2.1.2/Object.html#method-i-freeze
+        #
+        # @example
+        #   require 'lotus/utils/callbacks'
+        #
+        #   chain = Lotus::Utils::Callbacks::Chain.new
+        #   chain.freeze
+        #
+        #   chain.frozen?  # => true
+        #
+        #   chain.add :authenticate! # => RuntimeError
+        def freeze
+          super
+          @chain.freeze
+        end
       end
 
       # Callback factory

data/lib/lotus/utils/kernel.rb

@@ -1,6 +1,7 @@
 require 'set'
 require 'date'
 require 'time'
+require 'pathname'
 
 module Lotus
   module Utils
@@ -20,20 +21,18 @@ module Lotus
       #
       # @return [Array] the result of the coercion
       #
-      # @raise [NoMethodError] if arg doesn't implement #nil?
-      #
       # @since 0.1.1
       #
-      # @see http://www.ruby-doc.org/core-2.1.1/Kernel.html#method-i-Array
+      # @see http://www.ruby-doc.org/core-2.1.2/Kernel.html#method-i-Array
       #
-      # @see http://www.ruby-doc.org/core-2.1.1/Array.html#method-i-flatten
-      # @see http://www.ruby-doc.org/core-2.1.1/Array.html#method-i-compact
-      # @see http://www.ruby-doc.org/core-2.1.1/Array.html#method-i-uniq
+      # @see http://www.ruby-doc.org/core-2.1.2/Array.html#method-i-flatten
+      # @see http://www.ruby-doc.org/core-2.1.2/Array.html#method-i-compact
+      # @see http://www.ruby-doc.org/core-2.1.2/Array.html#method-i-uniq
       #
       # @example Basic Usage
       #   require 'lotus/utils/kernel'
       #
-      #   Lotus::Utils::Kernel.Array(nil)              # => nil
+      #   Lotus::Utils::Kernel.Array(nil)              # => []
       #   Lotus::Utils::Kernel.Array(true)             # => [true]
       #   Lotus::Utils::Kernel.Array(false)            # => [false]
       #   Lotus::Utils::Kernel.Array(1)                # => [1]
@@ -63,7 +62,7 @@ module Lotus
       #   response = Response.new(200, {}, 'hello')
       #   Lotus::Utils::Kernel.Array(response)         # => [200, {}, "hello"]
       def self.Array(arg)
-        super(arg).flatten.compact.uniq unless arg.nil?
+        super(arg).flatten.compact.uniq
       end
 
       # Coerces the argument to be a set.
@@ -72,14 +71,14 @@ module Lotus
       #
       # @return [Set] the result of the coercion
       #
-      # @raise [NoMethodError] if arg doesn't implement #respond_to?
+      # @raise [TypeError] if arg doesn't implement #respond_to?
       #
       # @since 0.1.1
       #
       # @example Basic Usage
       #   require 'lotus/utils/kernel'
       #
-      #   Lotus::Utils::Kernel.Set(nil)              # => nil
+      #   Lotus::Utils::Kernel.Set(nil)              # => #<Set: {}>
       #   Lotus::Utils::Kernel.Set(true)             # => #<Set: {true}>
       #   Lotus::Utils::Kernel.Set(false)            # => #<Set: {false}>
       #   Lotus::Utils::Kernel.Set(1)                # => #<Set: {1}>
@@ -112,33 +111,33 @@ module Lotus
       # @example Unchecked Exceptions
       #   require 'lotus/utils/kernel'
       #
-      #   Lotus::Utils::Kernel.Set(BasicObject.new) # => NoMethodError
+      #   Lotus::Utils::Kernel.Set(BasicObject.new) # => TypeError
       def self.Set(arg)
         if arg.respond_to?(:to_set)
           arg.to_set
         else
           Set.new(::Kernel.Array(arg))
-        end unless arg.nil?
+        end
+      rescue NoMethodError
+        raise TypeError.new("can't convert into Set")
       end
 
       # Coerces the argument to be an hash.
       #
       # @param arg [Object] the input
       #
-      # @return [Hash, nil] the result of the coercion
+      # @return [Hash] the result of the coercion
       #
-      # @raise [NoMethodError] if arg doesn't implement #nil?
-      # @raise [NoMethodError] if arg doesn't implement #respond_to?
       # @raise [TypeError] if arg can't be coerced
       #
       # @since 0.1.1
       #
-      # @see http://www.ruby-doc.org/core-2.1.1/Kernel.html#method-i-Hash
+      # @see http://www.ruby-doc.org/core-2.1.2/Kernel.html#method-i-Hash
       #
       # @example Basic Usage
       #   require 'lotus/utils/kernel'
       #
-      #   Lotus::Utils::Kernel.Hash(nil)                 # => nil
+      #   Lotus::Utils::Kernel.Hash(nil)                 # => {}
       #   Lotus::Utils::Kernel.Hash({a: 1})              # => { :a => 1 }
       #   Lotus::Utils::Kernel.Hash([[:a, 1]])           # => { :a => 1 }
       #   Lotus::Utils::Kernel.Hash(Set.new([[:a, 1]]))  # => { :a => 1 }
@@ -176,47 +175,45 @@ module Lotus
       #   require 'lotus/utils/kernel'
       #
       #   input = BasicObject.new
-      #   Lotus::Utils::Kernel.Hash(input) # => NoMethodError
+      #   Lotus::Utils::Kernel.Hash(input) # => TypeError
       if RUBY_VERSION >= '2.1'
         def self.Hash(arg)
           if arg.respond_to?(:to_h)
             arg.to_h
           else
             super(arg)
-          end unless arg.nil?
+          end
+        rescue NoMethodError
+          raise TypeError.new "can't convert into Hash"
         end
       else
         def self.Hash(arg)
           case arg
-          when NilClass                       then nil
           when ::Hash                         then arg
           when ::Array, ::Set                 then Hash[*self.Array(arg)]
           when ->(a) { a.respond_to?(:to_h) } then arg.to_h
           else
             super(arg)
           end
-        rescue ArgumentError
-          raise TypeError
+        rescue ArgumentError, NoMethodError
+          raise TypeError.new "can't convert into Hash"
         end
       end
 
       # Coerces the argument to be an integer.
       #
       # It's similar to Ruby's Kernel.Integer, but it doesn't stop at the first
-      # error and tries to be less "whiny".
+      # error and raise an exception only when the argument can't be coerced.
       #
       # @param arg [Object] the argument
       #
-      # @return [Fixnum,nil] the result of the coercion
+      # @return [Fixnum] the result of the coercion
       #
       # @raise [TypeError] if the argument can't be coerced
-      # @raise [NoMethodError] if the argument doesn't implenent #nil?
-      # @raise [TypeError,FloatDomainError,RangeError] if the argument it's too
-      #   big.
       #
       # @since 0.1.1
       #
-      # @see http://www.ruby-doc.org/core-2.1.1/Kernel.html#method-i-Integer
+      # @see http://www.ruby-doc.org/core-2.1.2/Kernel.html#method-i-Integer
       #
       # @example Basic Usage
       #   require 'bigdecimal'
@@ -252,18 +249,18 @@ module Lotus
       #
       #   # nil
       #   Kernel.Integer(nil)               # => TypeError
-      #   Lotus::Utils::Kernel.Integer(nil) # => nil
+      #   Lotus::Utils::Kernel.Integer(nil) # => 0
       #
       #   # float represented as a string
-      #   Kernel.Integer("23.4")               # => ArgumentError
+      #   Kernel.Integer("23.4")               # => TypeError
       #   Lotus::Utils::Kernel.Integer("23.4") # => 23
       #
       #   # rational represented as a string
-      #   Kernel.Integer("2/3")               # => ArgumentError
+      #   Kernel.Integer("2/3")               # => TypeError
       #   Lotus::Utils::Kernel.Integer("2/3") # => 2
       #
       #   # complex represented as a string
-      #   Kernel.Integer("2.5/1")               # => ArgumentError
+      #   Kernel.Integer("2.5/1")               # => TypeError
       #   Lotus::Utils::Kernel.Integer("2.5/1") # => 2
       #
       # @example Unchecked Exceptions
@@ -291,48 +288,51 @@ module Lotus
       #   input = DateTime.now
       #   Lotus::Utils::Kernel.Integer(input) # => TypeError
       #
-      #   # Missing #nil?
-      #   input = BasicObject.new
-      #   Lotus::Utils::Kernel.Integer(input) # => NoMethodError
-      #
       #   # bigdecimal infinity
       #   input = BigDecimal.new("Infinity")
-      #   Lotus::Utils::Kernel.Integer(input) # => FloatDomainError
+      #   Lotus::Utils::Kernel.Integer(input) # => TypeError
       #
       #   # bigdecimal NaN
       #   input = BigDecimal.new("NaN")
-      #   Lotus::Utils::Kernel.Integer(input) # => FloatDomainError
+      #   Lotus::Utils::Kernel.Integer(input) # => TypeError
       #
       #   # big rational
       #   input = Rational(-8) ** Rational(1, 3)
-      #   Lotus::Utils::Kernel.Integer(input) # => RangeError
+      #   Lotus::Utils::Kernel.Integer(input) # => TypeError
       #
       #   # big complex represented as a string
       #   input = Complex(2, 3)
-      #   Lotus::Utils::Kernel.Integer(input) # => RangeError
+      #   Lotus::Utils::Kernel.Integer(input) # => TypeError
       def self.Integer(arg)
-        super(arg) unless arg.nil?
-      rescue ArgumentError
-        arg.to_i
+        super(arg)
+      rescue ArgumentError, TypeError
+        begin
+          if arg.respond_to?(:to_i)
+            arg.to_i
+          else
+            raise TypeError.new "can't convert into Integer"
+          end
+        rescue NoMethodError
+          raise TypeError.new "can't convert into Integer"
+        end
+      rescue RangeError
+        raise TypeError.new "can't convert into Integer"
       end
 
       # Coerces the argument to be a float.
       #
       # It's similar to Ruby's Kernel.Float, but it doesn't stop at the first
-      # error and tries to be less "whiny".
+      # error and raise an exception only when the argument can't be coerced.
       #
       # @param arg [Object] the argument
       #
-      # @return [Float,nil] the result of the coercion
+      # @return [Float] the result of the coercion
       #
       # @raise [TypeError] if the argument can't be coerced
-      # @raise [NoMethodError] if the argument doesn't implenent #nil?
-      # @raise [TypeError,FloatDomainError,RangeError] if the argument it's too
-      #   big.
       #
       # @since 0.1.1
       #
-      # @see http://www.ruby-doc.org/core-2.1.1/Kernel.html#method-i-Float
+      # @see http://www.ruby-doc.org/core-2.1.2/Kernel.html#method-i-Float
       #
       # @example Basic Usage
       #   require 'bigdecimal'
@@ -369,18 +369,18 @@ module Lotus
       #
       #   # nil
       #   Kernel.Float(nil)               # => TypeError
-      #   Lotus::Utils::Kernel.Float(nil) # => nil
+      #   Lotus::Utils::Kernel.Float(nil) # => 0.0
       #
       #   # float represented as a string
-      #   Kernel.Float("23.4")               # => ArgumentError
+      #   Kernel.Float("23.4")               # => TypeError
       #   Lotus::Utils::Kernel.Float("23.4") # => 23.4
       #
       #   # rational represented as a string
-      #   Kernel.Float("2/3")               # => ArgumentError
+      #   Kernel.Float("2/3")               # => TypeError
       #   Lotus::Utils::Kernel.Float("2/3") # => 2.0
       #
       #   # complex represented as a string
-      #   Kernel.Float("2.5/1")               # => ArgumentError
+      #   Kernel.Float("2.5/1")               # => TypeError
       #   Lotus::Utils::Kernel.Float("2.5/1") # => 2.5
       #
       #   # bigdecimal infinity
@@ -418,35 +418,45 @@ module Lotus
       #
       #   # Missing #nil?
       #   input = BasicObject.new
-      #   Lotus::Utils::Kernel.Float(input) # => NoMethodError
+      #   Lotus::Utils::Kernel.Float(input) # => TypeError
       #
       #   # big rational
       #   input = Rational(-8) ** Rational(1, 3)
-      #   Lotus::Utils::Kernel.Float(input) # => RangeError
+      #   Lotus::Utils::Kernel.Float(input) # => TypeError
       #
       #   # big complex represented as a string
       #   input = Complex(2, 3)
-      #   Lotus::Utils::Kernel.Float(input) # => RangeError
+      #   Lotus::Utils::Kernel.Float(input) # => TypeError
       def self.Float(arg)
-        super(arg) unless arg.nil?
-      rescue ArgumentError
-        arg.to_f
+        super(arg)
+      rescue ArgumentError, TypeError
+        begin
+          if arg.respond_to?(:to_f)
+            arg.to_f
+          else
+            raise TypeError.new "can't convert into Float"
+          end
+        rescue NoMethodError
+          raise TypeError.new "can't convert into Float"
+        end
+      rescue RangeError
+        raise TypeError.new "can't convert into Float"
       end
 
       # Coerces the argument to be a string.
       #
-      # It's similar to Ruby's Kernel.String, but it's less "whiny".
+      # Identical behavior of Ruby's Kernel.Array, still here because we want
+      # to keep the interface consistent
       #
       # @param arg [Object] the argument
       #
-      # @return [String,nil] the result of the coercion
+      # @return [String] the result of the coercion
       #
       # @raise [TypeError] if the argument can't be coerced
-      # @raise [NoMethodError] if the argument doesn't implement #nil?
       #
       # @since 0.1.1
       #
-      # @see http://www.ruby-doc.org/core-2.1.1/Kernel.html#method-i-String
+      # @see http://www.ruby-doc.org/core-2.1.2/Kernel.html#method-i-String
       #
       # @example Basic Usage
       #   require 'date'
@@ -490,10 +500,6 @@ module Lotus
       #   require 'lotus/utils/kernel'
       #
       #   SimpleObject = Class.new(BasicObject) do
-      #     def nil?
-      #       false
-      #     end
-      #
       #     def to_s
       #       'simple object'
       #     end
@@ -511,49 +517,36 @@ module Lotus
       #   Lotus::Utils::Kernel.String(simple) # => "simple object"
       #   Lotus::Utils::Kernel.String(isbn)   # => "123"
       #
-      # @example Error Handling
+      # @example Comparison with Ruby
       #   require 'lotus/utils/kernel'
       #
       #   # nil
       #   Kernel.String(nil)               # => ""
-      #   Lotus::Utils::Kernel.String(nil) # => nil
+      #   Lotus::Utils::Kernel.String(nil) # => ""
       #
       # @example Unchecked Exceptions
       #   require 'lotus/utils/kernel'
       #
-      #   BaseObject = Class.new(BasicObject) do
-      #     def nil?
-      #       false
-      #     end
-      #   end
-      #
-      #   # Missing #nil?
-      #   input = BasicObject.new
-      #   Lotus::Utils::Kernel.String(input)  # => NoMethodError
-      #
       #   # Missing #to_s or #to_str
       #   input = BaseObject.new
       #   Lotus::Utils::Kernel.Integer(input) # => TypeError
       def self.String(arg)
-        super(arg) unless arg.nil?
+        super(arg)
       end
 
       # Coerces the argument to be a Date.
       #
       # @param arg [Object] the argument
       #
-      # @return [Date,nil] the result of the coercion
+      # @return [Date] the result of the coercion
       #
-      # @raise [NoMethodError] if the argument doesn't implement #respond_to? or #to_s
-      # @raise [ArgumentError] if the argument can't be coerced
+      # @raise [TypeError] if the argument can't be coerced
       #
       # @since 0.1.1
       #
       # @example Basic Usage
       #   require 'lotus/utils/kernel'
       #
-      #   Lotus::Utils::Kernel.Date(nil)                      # => nil
-      #
       #   Lotus::Utils::Kernel.Date(Date.today)
       #     # => #<Date: 2014-04-17 ((2456765j,0s,0n),+0s,2299161j)>
       #
@@ -584,33 +577,40 @@ module Lotus
       # @example Unchecked Exceptions
       #   require 'lotus/utils/kernel'
       #
-      #   # Missing #nil?
+      #   # nil
+      #   input = nil
+      #   Lotus::Utils::Kernel.Date(input) # => TypeError
+      #
+      #   # Missing #respond_to?
+      #   input = BasicObject.new
+      #   Lotus::Utils::Kernel.Date(input) # => TypeError
+      #
+      #   # Missing #to_s?
       #   input = BasicObject.new
-      #   Lotus::Utils::Kernel.Date(input) # => NoMethodError
+      #   Lotus::Utils::Kernel.Date(input) # => TypeError
       def self.Date(arg)
         if arg.respond_to?(:to_date)
           arg.to_date
         else
           Date.parse(arg.to_s)
-        end unless arg.nil?
+        end
+      rescue ArgumentError, NoMethodError
+        raise TypeError.new "can't convert into Date"
       end
 
       # Coerces the argument to be a DateTime.
       #
       # @param arg [Object] the argument
       #
-      # @return [DateTime,nil] the result of the coercion
+      # @return [DateTime] the result of the coercion
       #
-      # @raise [NoMethodError] if the argument doesn't implement #respond_to? or #to_s
-      # @raise [ArgumentError] if the argument can't be coerced
+      # @raise [TypeError] if the argument can't be coerced
       #
       # @since 0.1.1
       #
       # @example Basic Usage
       #   require 'lotus/utils/kernel'
       #
-      #   Lotus::Utils::Kernel.DateTime(nil)                # => nil
-      #
       #   Lotus::Utils::Kernel.DateTime(3483943)
       #     # => Time.at(3483943).to_datetime #<DateTime: 1970-02-10T08:45:43+01:00 ((2440628j,27943s,0n),+3600s,2299161j)>
       #
@@ -644,35 +644,41 @@ module Lotus
       # @example Unchecked Exceptions
       #   require 'lotus/utils/kernel'
       #
-      #   # Missing #nil?
+      #   # When nil
+      #   input = nil
+      #   Lotus::Utils::Kernel.DateTime(input) # => TypeError
+      #
+      #   # Missing #respond_to?
+      #   input = BasicObject.new
+      #   Lotus::Utils::Kernel.DateTime(input) # => TypeError
+      #
+      #   # Missing #to_s?
       #   input = BasicObject.new
-      #   Lotus::Utils::Kernel.DateTime(input) # => NoMethodError
+      #   Lotus::Utils::Kernel.DateTime(input) # => TypeError
       def self.DateTime(arg)
         case arg
         when ->(a) { a.respond_to?(:to_datetime) } then arg.to_datetime
         when Numeric then DateTime(Time.at(arg))
-        when NilClass then nil
         else
           DateTime.parse(arg.to_s)
         end
+      rescue ArgumentError, NoMethodError
+        raise TypeError.new "can't convert into DateTime"
       end
 
       # Coerces the argument to be a Time.
       #
       # @param arg [Object] the argument
       #
-      # @return [Time,nil] the result of the coercion
+      # @return [Time] the result of the coercion
       #
-      # @raise [NoMethodError] if the argument doesn't implement #respond_to? or #to_s
-      # @raise [ArgumentError] if the argument can't be coerced
+      # @raise [TypeError] if the argument can't be coerced
       #
       # @since 0.1.1
       #
       # @example Basic Usage
       #   require 'lotus/utils/kernel'
       #
-      #   Lotus::Utils::Kernel.Time(nil)                # => nil
-      #
       #   Lotus::Utils::Kernel.Time(Time.now)
       #     # => 2014-04-18 15:56:39 +0200
       #
@@ -703,33 +709,42 @@ module Lotus
       # @example Unchecked Exceptions
       #   require 'lotus/utils/kernel'
       #
-      #   # Missing #nil?
+      #   # When nil
+      #   input = nil
+      #   Lotus::Utils::Kernel.Time(input) # => TypeError
+      #
+      #   # Missing #respond_to?
+      #   input = BasicObject.new
+      #   Lotus::Utils::Kernel.Time(input) # => TypeError
+      #
+      #   # Missing #to_s?
       #   input = BasicObject.new
-      #   Lotus::Utils::Kernel.Time(input) # => NoMethodError
+      #   Lotus::Utils::Kernel.Time(input) # => TypeError
       def self.Time(arg)
         case arg
         when ->(a) { a.respond_to?(:to_time) } then arg.to_time
         when Numeric then Time.at(arg)
-        when NilClass then nil
         else
           Time.parse(arg.to_s)
         end
+      rescue ArgumentError, NoMethodError
+        raise TypeError.new "can't convert into Time"
       end
 
       # Coerces the argument to be a boolean.
       #
       # @param arg [Object] the argument
       #
-      # @return [true,false,nil] the result of the coercion
+      # @return [true,false] the result of the coercion
       #
-      # @raise [NoMethodError] if the argument doesn't implenent #respond_to?
+      # @raise [TypeError] if the argument can't be coerced
       #
       # @since 0.1.1
       #
       # @example Basic Usage
       #   require 'lotus/utils/kernel'
       #
-      #   Lotus::Utils::Kernel.Boolean(nil)                      # => nil
+      #   Lotus::Utils::Kernel.Boolean(nil)                      # => false
       #   Lotus::Utils::Kernel.Boolean(0)                        # => false
       #   Lotus::Utils::Kernel.Boolean(1)                        # => true
       #   Lotus::Utils::Kernel.Boolean('0')                      # => false
@@ -756,16 +771,127 @@ module Lotus
       #
       #   # Missing #respond_to?
       #   input = BasicObject.new
-      #   Lotus::Utils::Kernel.Boolean(input) # => NoMethodError
+      #   Lotus::Utils::Kernel.Boolean(input) # => TypeError
       def self.Boolean(arg)
         case arg
         when Numeric     then arg > 0 && arg <= 1
         when String, '0' then Boolean(arg.to_i)
-        when NilClass    then nil
         when ->(a) { a.respond_to?(:to_bool) } then arg.to_bool
         else
           !!arg
         end
+      rescue NoMethodError
+        raise TypeError.new "can't convert into Boolean"
+      end
+
+      # Coerces the argument to be a Pathname.
+      #
+      # @param arg [#to_pathname,#to_str] the argument
+      #
+      # @return [Pathname] the result of the coercion
+      #
+      # @raise [TypeError] if the argument can't be coerced
+      #
+      # @since 0.1.2
+      #
+      # @example Basic Usage
+      #   require 'lotus/utils/kernel'
+      #
+      #   Lotus::Utils::Kernel.Pathname(Pathname.new('/path/to')) # => #<Pathname:/path/to>
+      #   Lotus::Utils::Kernel.Pathname('/path/to')               # => #<Pathname:/path/to>
+      #
+      # @example Pathname Interface
+      #   require 'lotus/utils/kernel'
+      #
+      #   class HomePath
+      #     def to_pathname
+      #       Pathname.new Dir.home
+      #     end
+      #   end
+      #
+      #   Lotus::Utils::Kernel.Pathname(HomePath.new) # => #<Pathname:/Users/luca>
+      #
+      # @example String Interface
+      #   require 'lotus/utils/kernel'
+      #
+      #   class RootPath
+      #     def to_str
+      #       '/'
+      #     end
+      #   end
+      #
+      #   Lotus::Utils::Kernel.Pathname(RootPath.new) # => #<Pathname:/>
+      #
+      # @example Unchecked Exceptions
+      #   require 'lotus/utils/kernel'
+      #
+      #   # When nil
+      #   input = nil
+      #   Lotus::Utils::Kernel.Pathname(input) # => TypeError
+      #
+      #   # Missing #respond_to?
+      #   input = BasicObject.new
+      #   Lotus::Utils::Kernel.Pathname(input) # => TypeError
+      def self.Pathname(arg)
+        case arg
+        when ->(a) { a.respond_to?(:to_pathname) } then arg.to_pathname
+        else
+          super
+        end
+      rescue NoMethodError
+        raise TypeError.new "can't convert into Pathname"
+      end
+
+      # Coerces the argument to be a String.
+      #
+      # @param arg [#to_sym] the argument
+      #
+      # @return [Symbol] the result of the coercion
+      #
+      # @raise [TypeError] if the argument can't be coerced
+      #
+      # @since 0.2.0
+      #
+      # @example Basic Usage
+      #   require 'lotus/utils/kernel'
+      #
+      #   Lotus::Utils::Kernel.Symbol(:hello)  # => :hello
+      #   Lotus::Utils::Kernel.Symbol('hello') # => :hello
+      #
+      # @example Symbol Interface
+      #   require 'lotus/utils/kernel'
+      #
+      #   class StatusSymbol
+      #     def to_sym
+      #       :success
+      #     end
+      #   end
+      #
+      #   Lotus::Utils::Kernel.Symbol(StatusSymbol.new) # => :success
+      #
+      # @example Unchecked Exceptions
+      #   require 'lotus/utils/kernel'
+      #
+      #   # When nil
+      #   input = nil
+      #   Lotus::Utils::Kernel.Symbol(input) # => TypeError
+      #
+      #   # When empty string
+      #   input = ''
+      #   Lotus::Utils::Kernel.Symbol(input) # => TypeError
+      #
+      #   # Missing #respond_to?
+      #   input = BasicObject.new
+      #   Lotus::Utils::Kernel.Symbol(input) # => TypeError
+      def self.Symbol(arg)
+        case arg
+        when '' then raise TypeError.new "can't convert into Symbol"
+        when ->(a) { a.respond_to?(:to_sym) } then arg.to_sym
+        else
+          raise TypeError.new "can't convert into Symbol"
+        end
+      rescue NoMethodError
+        raise TypeError.new "can't convert into Symbol"
       end
     end
   end