lotus-utils 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab1fa641a480652c1773fc1808f2f920e10e0ffa
-  data.tar.gz: 6c59b62ec336ef0a4e13c64a0e8f71f45dded958
+  metadata.gz: b6a206acbf5c8f3f36aecb39a8a834faba7f40d9
+  data.tar.gz: fdeea0a0daf779be52a3f17a62460dbc5dd30f53
 SHA512:
-  metadata.gz: 7dd6940ce3dbebec5d04ae5f05ecb67e2c41cca40579d09d637f0c5a1c64cad083408bff258ec815cfce93480b17d871662e23bc85ae7b7b88a986e115a36978
-  data.tar.gz: 17686034d0c2003a2e42dc1d386b5cd22dc55ebb45cce29707e4283c47a05036b0aefb13e3ad00a34a43547e0efb9dca2f8369ad716b65d24838efd3e6cbe42d
+  metadata.gz: bfe9cc4e5ef901a898905aff9eea8ffa39c56b0e5fce80c8d40e6493d7a5c15ad3189bec6ebebe50b87185b78a66189f38b45e299df3a258253bfce182e4d854
+  data.tar.gz: d928d2cf1dc04a209144be6e03d9f25a1a4f064d079a809f82cd15877858b298a106ab378f025f14f09488cc78fad9ef1c352275af3febf46ecae6b189158dac

data/.gitignore

@@ -2,6 +2,7 @@
 *.rbc
 .bundle
 .config
+.devnotes
 .greenbar
 .yardoc
 Gemfile.lock
@@ -16,3 +17,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+bin

data/.travis.yml

@@ -1,5 +1,6 @@
 language: ruby
-script: 'bundle exec rake'
+script: 'bundle exec rake test:coverage'
 rvm:
   - 2.0.0
   - 2.1.0
+  - 2.1.1

data/CHANGELOG.md

@@ -0,0 +1,39 @@
+## v0.1.1
+### Apr 23, 2014
+
+c125e0c _2014-04-18_ **Luca Guidi** Implemented Lotus::Utils::Kernel.Time
+
+b366672 _2014-04-18_ **Luca Guidi** Implemented Lotus::Utils::Kernel.DateTime
+
+37a010f _2014-04-17_ **Luca Guidi** Implemented Lotus::Utils::Kernel.Date
+
+484ec9d _2014-04-17_ **Luca Guidi** Implemented Lotus::Utils::Kernel.Float
+
+69dd6eb _2014-04-16_ **Christopher Keele** Add missing stdlib Set require to ClassAttribute.
+
+82c0f54 _2014-04-12_ **Luca Guidi** Implemented Lotus::Utils::Kernel.Boolean
+
+48ba6fb _2014-04-11_ **Luca Guidi** Implemented Lotus::Utils::Kernel.Hash
+
+c10d561 _2014-04-11_ **Luca Guidi** Implemented Lotus::Utils::Kernel.Set
+
+5582e72 _2014-04-11_ **Karl Freeman** add Github contributing guidelines
+
+012f266 _2014-04-11_ **Luca Guidi** Implemented Lotus::Utils::Kernel.String
+
+e1a35e2 _2014-04-08_ **Luca Guidi** Implemented Lotus::Utils::Kernel.Integer
+
+152c856 _2014-04-08_ **Luca Guidi** Implemented Lotus::Utils::Kernel.Array
+
+## v0.1.0
+### Jan 23, 2014
+
+1212e9d _2014-01-16_ **Luca Guidi** Introduced Lotus::Utils::String#demodulize
+
+f9badc2 _2014-01-16_ **Luca Guidi** Fix for ClassAttribute: ensure class attributes to be inherited even the subclass is defined into a different namespace
+
+c19d26b _2014-01-07_ **Luca Guidi** Introducing Lotus::Utils::IO
+
+0453716 _2013-08-08_ **Luca Guidi** Added Class loading mechanism
+
+272304b _2013-08-07_ **Luca Guidi** Initial mess

data/CONTRIBUTING.md

@@ -0,0 +1,44 @@
+## Contributing
+In the spirit of [free software][free-sw], **everyone** is encouraged to help
+improve this project.
+
+[free-sw]: http://www.fsf.org/licensing/essays/free-sw.html
+
+Here are some ways *you* can contribute:
+
+* by using alpha, beta, and prerelease versions
+* by reporting bugs
+* by suggesting new features
+* by writing or editing documentation
+* by writing specifications
+* by writing code (**no patch is too small**: fix typos, add comments, clean up
+  inconsistent whitespace)
+* by refactoring code
+* by closing [issues][]
+* by reviewing patches
+
+[issues]: https://github.com/lotus/utils/issues
+
+## Submitting an Issue
+We use the [GitHub issue tracker][issues] to track bugs and features. Before
+submitting a bug report or feature request, check to make sure it hasn't
+already been submitted. When submitting a bug report, please include a [Gist][]
+that includes a stack trace and any details that may be necessary to reproduce
+the bug, including your gem version, Ruby version, and operating system.
+Ideally, a bug report should include a pull request with failing specs.
+
+[gist]: https://gist.github.com/
+
+## Submitting a Pull Request
+1. [Fork the repository.][fork]
+2. [Create a topic branch.][branch]
+3. Add specs for your unimplemented feature or bug fix.
+4. Run `bundle exec rake`. If your specs pass, return to step 3.
+5. Implement your feature or bug fix.
+6. Run `bundle exec rake`. If your specs fail, return to step 5.
+7. Add, commit, and push your changes.
+8. [Submit a pull request.][pr]
+
+[fork]: http://help.github.com/fork-a-repo/
+[branch]: http://learn.github.com/p/branching.html
+[pr]: http://help.github.com/send-pull-requests/

data/Gemfile

@@ -2,9 +2,9 @@ source 'https://rubygems.org'
 gemspec
 
 unless ENV['TRAVIS']
-  gem 'debugger',  require: false, platforms: :ruby
-  gem 'yard',      require: false
-  gem 'simplecov', require: false
+  gem 'byebug', require: false, platforms: :ruby if RUBY_VERSION == '2.1.1'
+  gem 'yard',   require: false
 end
 
+gem 'simplecov', require: false
 gem 'coveralls', require: false

data/README.md

@@ -4,11 +4,12 @@ Ruby core extentions and class utilities for [Lotus](http://lotusrb.org)
 
 ## Status
 
-[![Gem Version](https://badge.fury.io/rb/lotus-utils.png)](http://badge.fury.io/rb/lotus-utils)
-[![Build Status](https://secure.travis-ci.org/lotus/utils.png?branch=master)](http://travis-ci.org/lotus/utils?branch=master)
-[![Test Coverage](https://coveralls.io/repos/lotus/utils/badge.png?branch=master)](https://coveralls.io/r/lotus/utils)
-[![Code quality](https://codeclimate.com/github/lotus/utils.png)](https://codeclimate.com/github/lotus/utils)
-[![Dependencies](https://gemnasium.com/lotus/utils.png)](https://gemnasium.com/lotus/utils)
+[![Gem Version](http://img.shields.io/gem/v/lotus-utils.svg)](https://badge.fury.io/rb/lotus-utils)
+[![Build Status](http://img.shields.io/travis/lotus/utils/master.svg)](https://travis-ci.org/lotus/utils?branch=master)
+[![Coverage](http://img.shields.io/coveralls/lotus/utils/master.svg)](https://coveralls.io/r/lotus/utils)
+[![Code Climate](http://img.shields.io/codeclimate/github/lotus/utils.svg)](https://codeclimate.com/github/lotus/utils)
+[![Dependencies](http://img.shields.io/gemnasium/lotus/utils.svg)](https://gemnasium.com/lotus/utils)
+[![Inline Docs](http://inch-pages.github.io/github/lotus/utils.svg)](http://inch-pages.github.io/github/lotus/utils)
 
 ## Contact
 
@@ -16,7 +17,8 @@ Ruby core extentions and class utilities for [Lotus](http://lotusrb.org)
 * Mailing List: http://lotusrb.org/mailing-list
 * API Doc: http://rdoc.info/gems/lotus-utils
 * Bugs/Issues: https://github.com/lotus/utils/issues
-* Support: http://stackoverflow.com/questions/tagged/lotusrb
+* Support: http://stackoverflow.com/questions/tagged/lotus-ruby
+* Chat: https://gitter.im/lotus/chat
 
 ## Rubies
 
@@ -50,7 +52,7 @@ __Lotus::Utils__ uses [Semantic Versioning 2.0.0](http://semver.org)
 
 ## Contributing
 
-1. Fork it
+1. Fork it ( https://github.com/lotus/utils/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/Rakefile

@@ -7,4 +7,11 @@ Rake::TestTask.new do |t|
   t.libs.push 'test'
 end
 
+namespace :test do
+  task :coverage do
+    ENV['COVERAGE'] = 'true'
+    Rake::Task['test'].invoke
+  end
+end
+
 task default: :test

data/lib/lotus/utils.rb

@@ -1,7 +1,7 @@
 require 'lotus/utils/version'
 
 module Lotus
-  # Ruby core extentions and Louts utilities
+  # Ruby core extentions and Lotus utilities
   module Utils
   end
 end

data/lib/lotus/utils/class_attribute.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module Lotus
   module Utils
     # Inheritable class level variable accessors.

data/lib/lotus/utils/kernel.rb

@@ -0,0 +1,773 @@
+require 'set'
+require 'date'
+require 'time'
+
+module Lotus
+  module Utils
+    # Kernel utilities
+    # @since 0.1.1
+    module Kernel
+      # Coerces the argument to be an array.
+      #
+      # It's similar to Ruby's Kernel.Array, but it applies further
+      # transformations:
+      #
+      #   * flatten
+      #   * compact
+      #   * uniq
+      #
+      # @param arg [Object] the input
+      #
+      # @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.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
+      #
+      # @example Basic Usage
+      #   require 'lotus/utils/kernel'
+      #
+      #   Lotus::Utils::Kernel.Array(nil)              # => nil
+      #   Lotus::Utils::Kernel.Array(true)             # => [true]
+      #   Lotus::Utils::Kernel.Array(false)            # => [false]
+      #   Lotus::Utils::Kernel.Array(1)                # => [1]
+      #   Lotus::Utils::Kernel.Array([1])              # => [1]
+      #   Lotus::Utils::Kernel.Array([1, [2]])         # => [1,2]
+      #   Lotus::Utils::Kernel.Array([1, [2, nil]])    # => [1,2]
+      #   Lotus::Utils::Kernel.Array([1, [2, nil, 1]]) # => [1,2]
+      #
+      # @example Array Interface
+      #   require 'lotus/utils/kernel'
+      #
+      #   ResultSet = Struct.new(:records) do
+      #     def to_a
+      #       records.to_a.sort
+      #     end
+      #   end
+      #
+      #   Response = Struct.new(:status, :headers, :body) do
+      #     def to_ary
+      #       [status, headers, body]
+      #     end
+      #   end
+      #
+      #   set = ResultSet.new([2,1,3])
+      #   Lotus::Utils::Kernel.Array(set)              # => [1,2,3]
+      #
+      #   response = Response.new(200, {}, 'hello')
+      #   Lotus::Utils::Kernel.Array(response)         # => [200, {}, "hello"]
+      def self.Array(arg)
+        super(arg).flatten.compact.uniq unless arg.nil?
+      end
+
+      # Coerces the argument to be a set.
+      #
+      # @param arg [Object] the input
+      #
+      # @return [Set] the result of the coercion
+      #
+      # @raise [NoMethodError] 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(true)             # => #<Set: {true}>
+      #   Lotus::Utils::Kernel.Set(false)            # => #<Set: {false}>
+      #   Lotus::Utils::Kernel.Set(1)                # => #<Set: {1}>
+      #   Lotus::Utils::Kernel.Set([1])              # => #<Set: {1}>
+      #   Lotus::Utils::Kernel.Set([1, 1])           # => #<Set: {1}>
+      #   Lotus::Utils::Kernel.Set([1, [2]])         # => #<Set: {1, [2]}>
+      #   Lotus::Utils::Kernel.Set([1, [2, nil]])    # => #<Set: {1, [2, nil]}>
+      #   Lotus::Utils::Kernel.Set({a: 1})           # => #<Set: {[:a, 1]}>
+      #
+      # @example Set Interface
+      #   require 'securerandom'
+      #   require 'lotus/utils/kernel'
+      #
+      #   UuidSet = Class.new do
+      #     def initialize(*uuids)
+      #       @uuids = uuids
+      #     end
+      #
+      #     def to_set
+      #       Set.new.tap do |set|
+      #         @uuids.each {|uuid| set.add(uuid) }
+      #       end
+      #     end
+      #   end
+      #
+      #   uuids = UuidSet.new(SecureRandom.uuid)
+      #   Lotus::Utils::Kernel.Set(uuids)
+      #     # => #<Set: {"daa798b4-630c-4e11-b29d-92f0b1c7d075"}>
+      #
+      # @example Unchecked Exceptions
+      #   require 'lotus/utils/kernel'
+      #
+      #   Lotus::Utils::Kernel.Set(BasicObject.new) # => NoMethodError
+      def self.Set(arg)
+        if arg.respond_to?(:to_set)
+          arg.to_set
+        else
+          Set.new(::Kernel.Array(arg))
+        end unless arg.nil?
+      end
+
+      # Coerces the argument to be an hash.
+      #
+      # @param arg [Object] the input
+      #
+      # @return [Hash, nil] 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
+      #
+      # @example Basic Usage
+      #   require 'lotus/utils/kernel'
+      #
+      #   Lotus::Utils::Kernel.Hash(nil)                 # => 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 }
+      #
+      # @example Hash Interface
+      #   require 'lotus/utils/kernel'
+      #
+      #   Room = Class.new do
+      #     def initialize(*args)
+      #       @args = args
+      #     end
+      #
+      #     def to_h
+      #       Hash[*@args]
+      #     end
+      #   end
+      #
+      #   Record = Class.new do
+      #     def initialize(attributes = {})
+      #       @attributes = attributes
+      #     end
+      #
+      #     def to_hash
+      #       @attributes
+      #     end
+      #   end
+      #
+      #   room = Room.new(:key, 123456)
+      #   Lotus::Utils::Kernel.Hash(room)        # => { :key => 123456 }
+      #
+      #   record = Record.new(name: 'L')
+      #   Lotus::Utils::Kernel.Hash(record)      # => { :name => "L" }
+      #
+      # @example Unchecked Exceptions
+      #   require 'lotus/utils/kernel'
+      #
+      #   input = BasicObject.new
+      #   Lotus::Utils::Kernel.Hash(input) # => NoMethodError
+      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
+      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
+        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".
+      #
+      # @param arg [Object] the argument
+      #
+      # @return [Fixnum,nil] 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
+      #
+      # @example Basic Usage
+      #   require 'bigdecimal'
+      #   require 'lotus/utils/kernel'
+      #
+      #   Lotus::Utils::Kernel.Integer(1)                        # => 1
+      #   Lotus::Utils::Kernel.Integer(1.2)                      # => 1
+      #   Lotus::Utils::Kernel.Integer(011)                      # => 9
+      #   Lotus::Utils::Kernel.Integer(0xf5)                     # => 245
+      #   Lotus::Utils::Kernel.Integer("1")                      # => 1
+      #   Lotus::Utils::Kernel.Integer(Rational(0.3))            # => 0
+      #   Lotus::Utils::Kernel.Integer(Complex(0.3))             # => 0
+      #   Lotus::Utils::Kernel.Integer(BigDecimal.new(12.00001)) # => 12
+      #   Lotus::Utils::Kernel.Integer(176605528590345446089)
+      #     # => 176605528590345446089
+      #
+      #   Lotus::Utils::Kernel.Integer(Time.now)                 # => 1396947161
+      #
+      # @example Integer Interface
+      #   require 'lotus/utils/kernel'
+      #
+      #   UltimateAnswer = Struct.new(:question) do
+      #     def to_int
+      #       42
+      #     end
+      #   end
+      #
+      #   answer = UltimateAnswer.new('The Ultimate Question of Life')
+      #   Lotus::Utils::Kernel.Integer(answer) # => 42
+      #
+      # @example Error Handling
+      #   require 'lotus/utils/kernel'
+      #
+      #   # nil
+      #   Kernel.Integer(nil)               # => TypeError
+      #   Lotus::Utils::Kernel.Integer(nil) # => nil
+      #
+      #   # float represented as a string
+      #   Kernel.Integer("23.4")               # => ArgumentError
+      #   Lotus::Utils::Kernel.Integer("23.4") # => 23
+      #
+      #   # rational represented as a string
+      #   Kernel.Integer("2/3")               # => ArgumentError
+      #   Lotus::Utils::Kernel.Integer("2/3") # => 2
+      #
+      #   # complex represented as a string
+      #   Kernel.Integer("2.5/1")               # => ArgumentError
+      #   Lotus::Utils::Kernel.Integer("2.5/1") # => 2
+      #
+      # @example Unchecked Exceptions
+      #   require 'date'
+      #   require 'bigdecimal'
+      #   require 'lotus/utils/kernel'
+      #
+      #   # Missing #to_int and #to_i
+      #   input = OpenStruct.new(color: 'purple')
+      #   Lotus::Utils::Kernel.Integer(input) # => TypeError
+      #
+      #   # When true
+      #   input = true
+      #   Lotus::Utils::Kernel.Integer(input) # => TypeError
+      #
+      #   # When false
+      #   input = false
+      #   Lotus::Utils::Kernel.Integer(input) # => TypeError
+      #
+      #   # When Date
+      #   input = Date.today
+      #   Lotus::Utils::Kernel.Integer(input) # => TypeError
+      #
+      #   # When DateTime
+      #   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
+      #
+      #   # bigdecimal NaN
+      #   input = BigDecimal.new("NaN")
+      #   Lotus::Utils::Kernel.Integer(input) # => FloatDomainError
+      #
+      #   # big rational
+      #   input = Rational(-8) ** Rational(1, 3)
+      #   Lotus::Utils::Kernel.Integer(input) # => RangeError
+      #
+      #   # big complex represented as a string
+      #   input = Complex(2, 3)
+      #   Lotus::Utils::Kernel.Integer(input) # => RangeError
+      def self.Integer(arg)
+        super(arg) unless arg.nil?
+      rescue ArgumentError
+        arg.to_i
+      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".
+      #
+      # @param arg [Object] the argument
+      #
+      # @return [Float,nil] 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
+      #
+      # @example Basic Usage
+      #   require 'bigdecimal'
+      #   require 'lotus/utils/kernel'
+      #
+      #   Lotus::Utils::Kernel.Float(1)                        # => 1.0
+      #   Lotus::Utils::Kernel.Float(1.2)                      # => 1.2
+      #   Lotus::Utils::Kernel.Float(011)                      # => 9.0
+      #   Lotus::Utils::Kernel.Float(0xf5)                     # => 245.0
+      #   Lotus::Utils::Kernel.Float("1")                      # => 1.0
+      #   Lotus::Utils::Kernel.Float(Rational(0.3))            # => 0.3
+      #   Lotus::Utils::Kernel.Float(Complex(0.3))             # => 0.3
+      #   Lotus::Utils::Kernel.Float(BigDecimal.new(12.00001)) # => 12.00001
+      #   Lotus::Utils::Kernel.Float(176605528590345446089)
+      #     # => 176605528590345446089.0
+      #
+      #   Lotus::Utils::Kernel.Float(Time.now) # => 397750945.515169
+      #
+      # @example Float Interface
+      #   require 'lotus/utils/kernel'
+      #
+      #   class Pi
+      #     def to_f
+      #       3.14
+      #     end
+      #   end
+      #
+      #   pi = Pi.new
+      #   Lotus::Utils::Kernel.Float(pi) # => 3.14
+      #
+      # @example Error Handling
+      #   require 'bigdecimal'
+      #   require 'lotus/utils/kernel'
+      #
+      #   # nil
+      #   Kernel.Float(nil)               # => TypeError
+      #   Lotus::Utils::Kernel.Float(nil) # => nil
+      #
+      #   # float represented as a string
+      #   Kernel.Float("23.4")               # => ArgumentError
+      #   Lotus::Utils::Kernel.Float("23.4") # => 23.4
+      #
+      #   # rational represented as a string
+      #   Kernel.Float("2/3")               # => ArgumentError
+      #   Lotus::Utils::Kernel.Float("2/3") # => 2.0
+      #
+      #   # complex represented as a string
+      #   Kernel.Float("2.5/1")               # => ArgumentError
+      #   Lotus::Utils::Kernel.Float("2.5/1") # => 2.5
+      #
+      #   # bigdecimal infinity
+      #   input = BigDecimal.new("Infinity")
+      #   Lotus::Utils::Kernel.Float(input) # => Infinity
+      #
+      #   # bigdecimal NaN
+      #   input = BigDecimal.new("NaN")
+      #   Lotus::Utils::Kernel.Float(input) # => NaN
+      #
+      # @example Unchecked Exceptions
+      #   require 'date'
+      #   require 'bigdecimal'
+      #   require 'lotus/utils/kernel'
+      #
+      #   # Missing #to_f
+      #   input = OpenStruct.new(color: 'purple')
+      #   Lotus::Utils::Kernel.Float(input) # => TypeError
+      #
+      #   # When true
+      #   input = true
+      #   Lotus::Utils::Kernel.Float(input) # => TypeError
+      #
+      #   # When false
+      #   input = false
+      #   Lotus::Utils::Kernel.Float(input) # => TypeError
+      #
+      #   # When Date
+      #   input = Date.today
+      #   Lotus::Utils::Kernel.Float(input) # => TypeError
+      #
+      #   # When DateTime
+      #   input = DateTime.now
+      #   Lotus::Utils::Kernel.Float(input) # => TypeError
+      #
+      #   # Missing #nil?
+      #   input = BasicObject.new
+      #   Lotus::Utils::Kernel.Float(input) # => NoMethodError
+      #
+      #   # big rational
+      #   input = Rational(-8) ** Rational(1, 3)
+      #   Lotus::Utils::Kernel.Float(input) # => RangeError
+      #
+      #   # big complex represented as a string
+      #   input = Complex(2, 3)
+      #   Lotus::Utils::Kernel.Float(input) # => RangeError
+      def self.Float(arg)
+        super(arg) unless arg.nil?
+      rescue ArgumentError
+        arg.to_f
+      end
+
+      # Coerces the argument to be a string.
+      #
+      # It's similar to Ruby's Kernel.String, but it's less "whiny".
+      #
+      # @param arg [Object] the argument
+      #
+      # @return [String,nil] 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
+      #
+      # @example Basic Usage
+      #   require 'date'
+      #   require 'bigdecimal'
+      #   require 'lotus/utils/kernel'
+      #
+      #   Lotus::Utils::Kernel.String('')                            # => ""
+      #   Lotus::Utils::Kernel.String('ciao')                        # => "ciao"
+      #
+      #   Lotus::Utils::Kernel.String(true)                          # => "true"
+      #   Lotus::Utils::Kernel.String(false)                         # => "false"
+      #
+      #   Lotus::Utils::Kernel.String(:lotus)                        # => "lotus"
+      #
+      #   Lotus::Utils::Kernel.String(Picture)                       # => "Picture" # class
+      #   Lotus::Utils::Kernel.String(Lotus)                         # => "Lotus" # module
+      #
+      #   Lotus::Utils::Kernel.String([])                            # => "[]"
+      #   Lotus::Utils::Kernel.String([1,2,3])                       # => "[1, 2, 3]"
+      #   Lotus::Utils::Kernel.String(%w[a b c])                     # => "[\"a\", \"b\", \"c\"]"
+      #
+      #   Lotus::Utils::Kernel.String({})                            # => "{}"
+      #   Lotus::Utils::Kernel.String({a: 1, 'b' => 'c'})            # => "{:a=>1, \"b\"=>\"c\"}"
+      #
+      #   Lotus::Utils::Kernel.String(Date.today)                    # => "2014-04-11"
+      #   Lotus::Utils::Kernel.String(DateTime.now)                  # => "2014-04-11T10:15:06+02:00"
+      #   Lotus::Utils::Kernel.String(Time.now)                      # => "2014-04-11 10:15:53 +0200"
+      #
+      #   Lotus::Utils::Kernel.String(1)                             # => "1"
+      #   Lotus::Utils::Kernel.String(3.14)                          # => "3.14"
+      #   Lotus::Utils::Kernel.String(013)                           # => "11"
+      #   Lotus::Utils::Kernel.String(0xc0ff33)                      # => "12648243"
+      #
+      #   Lotus::Utils::Kernel.String(Rational(-22))                 # => "-22/1"
+      #   Lotus::Utils::Kernel.String(Complex(11, 2))                # => "11+2i"
+      #   Lotus::Utils::Kernel.String(BigDecimal.new(7944.2343, 10)) # => "0.79442343E4"
+      #   Lotus::Utils::Kernel.String(BigDecimal.new('Infinity'))    # => "Infinity"
+      #   Lotus::Utils::Kernel.String(BigDecimal.new('NaN'))         # => "Infinity"
+      #
+      # @example String interface
+      #   require 'lotus/utils/kernel'
+      #
+      #   SimpleObject = Class.new(BasicObject) do
+      #     def nil?
+      #       false
+      #     end
+      #
+      #     def to_s
+      #       'simple object'
+      #     end
+      #   end
+      #
+      #   Isbn = Struct.new(:code) do
+      #     def to_str
+      #       code.to_s
+      #     end
+      #   end
+      #
+      #   simple = SimpleObject.new
+      #   isbn   = Isbn.new(123)
+      #
+      #   Lotus::Utils::Kernel.String(simple) # => "simple object"
+      #   Lotus::Utils::Kernel.String(isbn)   # => "123"
+      #
+      # @example Error Handling
+      #   require 'lotus/utils/kernel'
+      #
+      #   # nil
+      #   Kernel.String(nil)               # => ""
+      #   Lotus::Utils::Kernel.String(nil) # => 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?
+      end
+
+      # Coerces the argument to be a Date.
+      #
+      # @param arg [Object] the argument
+      #
+      # @return [Date,nil] 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
+      #
+      # @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)>
+      #
+      #   Lotus::Utils::Kernel.Date(DateTime.now)
+      #     # => #<Date: 2014-04-17 ((2456765j,0s,0n),+0s,2299161j)>
+      #
+      #   Lotus::Utils::Kernel.Date(Time.now)
+      #     # => #<Date: 2014-04-17 ((2456765j,0s,0n),+0s,2299161j)>
+      #
+      #   Lotus::Utils::Kernel.Date('2014-04-17')
+      #     # => #<Date: 2014-04-17 ((2456765j,0s,0n),+0s,2299161j)>
+      #
+      #   Lotus::Utils::Kernel.Date('2014-04-17 22:37:15')
+      #     # => #<Date: 2014-04-17 ((2456765j,0s,0n),+0s,2299161j)>
+      #
+      # @example Date Interface
+      #   require 'lotus/utils/kernel'
+      #
+      #   class Christmas
+      #     def to_date
+      #       Date.parse('Dec, 25')
+      #     end
+      #   end
+      #
+      #   Lotus::Utils::Kernel.Date(Christmas.new)
+      #     # => #<Date: 2014-12-25 ((2457017j,0s,0n),+0s,2299161j)>
+      #
+      # @example Unchecked Exceptions
+      #   require 'lotus/utils/kernel'
+      #
+      #   # Missing #nil?
+      #   input = BasicObject.new
+      #   Lotus::Utils::Kernel.Date(input) # => NoMethodError
+      def self.Date(arg)
+        if arg.respond_to?(:to_date)
+          arg.to_date
+        else
+          Date.parse(arg.to_s)
+        end unless arg.nil?
+      end
+
+      # Coerces the argument to be a DateTime.
+      #
+      # @param arg [Object] the argument
+      #
+      # @return [DateTime,nil] 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
+      #
+      # @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)>
+      #
+      #   Lotus::Utils::Kernel.DateTime(DateTime.now)
+      #     # => #<DateTime: 2014-04-18T09:33:49+02:00 ((2456766j,27229s,690849000n),+7200s,2299161j)>
+      #
+      #   Lotus::Utils::Kernel.DateTime(Date.today)
+      #     # => #<DateTime: 2014-04-18T00:00:00+00:00 ((2456766j,0s,0n),+0s,2299161j)>
+      #
+      #   Lotus::Utils::Kernel.Date(Time.now)
+      #     # => #<DateTime: 2014-04-18T09:34:49+02:00 ((2456766j,27289s,832907000n),+7200s,2299161j)>
+      #
+      #   Lotus::Utils::Kernel.DateTime('2014-04-18')
+      #     # => #<DateTime: 2014-04-18T00:00:00+00:00 ((2456766j,0s,0n),+0s,2299161j)>
+      #
+      #   Lotus::Utils::Kernel.DateTime('2014-04-18 09:35:42')
+      #     # => #<DateTime: 2014-04-18T09:35:42+00:00 ((2456766j,34542s,0n),+0s,2299161j)>
+      #
+      # @example DateTime Interface
+      #   require 'lotus/utils/kernel'
+      #
+      #   class NewYearEve
+      #     def to_datetime
+      #       DateTime.parse('Jan, 1')
+      #     end
+      #   end
+      #
+      #   Lotus::Utils::Kernel.Date(NewYearEve.new)
+      #     # => #<DateTime: 2014-01-01T00:00:00+00:00 ((2456659j,0s,0n),+0s,2299161j)>
+      #
+      # @example Unchecked Exceptions
+      #   require 'lotus/utils/kernel'
+      #
+      #   # Missing #nil?
+      #   input = BasicObject.new
+      #   Lotus::Utils::Kernel.DateTime(input) # => NoMethodError
+      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
+      end
+
+      # Coerces the argument to be a Time.
+      #
+      # @param arg [Object] the argument
+      #
+      # @return [Time,nil] 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
+      #
+      # @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
+      #
+      #   Lotus::Utils::Kernel.Time(DateTime.now)
+      #     # => 2014-04-18 15:56:39 +0200
+      #
+      #   Lotus::Utils::Kernel.Time(Date.today)
+      #     # => 2014-04-18 00:00:00 +0200
+      #
+      #   Lotus::Utils::Kernel.Time('2014-04-18')
+      #     # => 2014-04-18 00:00:00 +0200
+      #
+      #   Lotus::Utils::Kernel.Time('2014-04-18 15:58:02')
+      #     # => 2014-04-18 15:58:02 +0200
+      #
+      # @example Time Interface
+      #   require 'lotus/utils/kernel'
+      #
+      #   class Epoch
+      #     def to_time
+      #       Time.at(0)
+      #     end
+      #   end
+      #
+      #   Lotus::Utils::Kernel.Time(Epoch.new)
+      #     # => 1970-01-01 01:00:00 +0100
+      #
+      # @example Unchecked Exceptions
+      #   require 'lotus/utils/kernel'
+      #
+      #   # Missing #nil?
+      #   input = BasicObject.new
+      #   Lotus::Utils::Kernel.Time(input) # => NoMethodError
+      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
+      end
+
+      # Coerces the argument to be a boolean.
+      #
+      # @param arg [Object] the argument
+      #
+      # @return [true,false,nil] the result of the coercion
+      #
+      # @raise [NoMethodError] if the argument doesn't implenent #respond_to?
+      #
+      # @since 0.1.1
+      #
+      # @example Basic Usage
+      #   require 'lotus/utils/kernel'
+      #
+      #   Lotus::Utils::Kernel.Boolean(nil)                      # => nil
+      #   Lotus::Utils::Kernel.Boolean(0)                        # => false
+      #   Lotus::Utils::Kernel.Boolean(1)                        # => true
+      #   Lotus::Utils::Kernel.Boolean('0')                      # => false
+      #   Lotus::Utils::Kernel.Boolean('1')                      # => true
+      #   Lotus::Utils::Kernel.Boolean(Object.new)               # => true
+      #
+      # @example Boolean Interface
+      #   require 'lotus/utils/kernel'
+      #
+      #   Answer = Struct.new(:answer) do
+      #     def to_bool
+      #       case answer
+      #       when 'yes' then true
+      #       else false
+      #       end
+      #     end
+      #   end
+      #
+      #   answer = Answer.new('yes')
+      #   Lotus::Utils::Kernel.Boolean(answer) # => true
+      #
+      # @example Unchecked Exceptions
+      #   require 'lotus/utils/kernel'
+      #
+      #   # Missing #respond_to?
+      #   input = BasicObject.new
+      #   Lotus::Utils::Kernel.Boolean(input) # => NoMethodError
+      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
+      end
+    end
+  end
+end
+