Module: Lotus::Utils::Kernel

Defined in:
lib/lotus/utils/kernel.rb

Overview

Kernel utilities

Since:

  • 0.1.1

Constant Summary collapse

NUMERIC_MATCHER =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future.

Matcher for numeric values

See Also:

Since:

  • 0.3.3

/\A([\d\/\.\+iE]+|NaN|Infinity)\z/.freeze

Class Method Summary collapse

Class Method Details

.Array(arg) ⇒ Array

Coerces the argument to be an Array.

It’s similar to Ruby’s Kernel.Array, but it applies further transformations:

* flatten
* compact
* uniq

Examples:

Basic Usage

require 'lotus/utils/kernel'

Lotus::Utils::Kernel.Array(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]

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"]

Parameters:

  • arg (Object)

    the input

Returns:

  • (Array)

    the result of the coercion

See Also:

Since:

  • 0.1.1



81
82
83
84
85
86
87
# File 'lib/lotus/utils/kernel.rb', line 81

def self.Array(arg)
  super(arg).dup.tap do |a|
    a.flatten!
    a.compact!
    a.uniq!
  end
end

.BigDecimal(arg) ⇒ BigDecimal

Coerces the argument to be a BigDecimal.

Examples:

Basic Usage

require 'lotus/utils/kernel'

Lotus::Utils::Kernel.BigDecimal(1)                        # => 1
Lotus::Utils::Kernel.BigDecimal(1.2)                      # => 1
Lotus::Utils::Kernel.BigDecimal(011)                      # => 9
Lotus::Utils::Kernel.BigDecimal(0xf5)                     # => 245
Lotus::Utils::Kernel.BigDecimal("1")                      # => 1
Lotus::Utils::Kernel.BigDecimal(Rational(0.3))            # => 0.3
Lotus::Utils::Kernel.BigDecimal(Complex(0.3))             # => 0.3
Lotus::Utils::Kernel.BigDecimal(BigDecimal.new(12.00001)) # => 12.00001
Lotus::Utils::Kernel.BigDecimal(176605528590345446089)
  # => 176605528590345446089

BigDecimal Interface

require 'lotus/utils/kernel'

UltimateAnswer = Struct.new(:question) do
  def to_d
    BigDecimal.new(42)
  end
end

answer = UltimateAnswer.new('The Ultimate Question of Life')
Lotus::Utils::Kernel.BigDecimal(answer)
  # => #<BigDecimal:7fabfd148588,'0.42E2',9(27)>

Unchecked exceptions

require 'lotus/utils/kernel'

# When nil
input = nil
Lotus::Utils::Kernel.BigDecimal(nil) # => TypeError

# When true
input = true
Lotus::Utils::Kernel.BigDecimal(input) # => TypeError

# When false
input = false
Lotus::Utils::Kernel.BigDecimal(input) # => TypeError

# When Date
input = Date.today
Lotus::Utils::Kernel.BigDecimal(input) # => TypeError

# When DateTime
input = DateTime.now
Lotus::Utils::Kernel.BigDecimal(input) # => TypeError

# When Time
input = Time.now
Lotus::Utils::Kernel.BigDecimal(input) # => TypeError

# String that doesn't represent a big decimal
input = 'hello'
Lotus::Utils::Kernel.BigDecimal(input) # => TypeError

# Missing #respond_to?
input = BasicObject.new
Lotus::Utils::Kernel.BigDecimal(input) # => TypeError

Parameters:

  • arg (Object)

    the argument

Returns:

Raises:

  • (TypeError)

    if the argument can’t be coerced

See Also:

Since:

  • 0.3.0



421
422
423
424
425
426
427
428
429
430
431
432
433
# File 'lib/lotus/utils/kernel.rb', line 421

def self.BigDecimal(arg)
  case arg
  when ->(a) { a.respond_to?(:to_d) } then arg.to_d
  when Float, Complex, Rational
    BigDecimal(arg.to_s)
  when ->(a) { a.to_s.match(NUMERIC_MATCHER) }
    BigDecimal.new(arg)
  else
    raise TypeError.new "can't convert #{inspect_type_error(arg)}into BigDecimal"
  end
rescue NoMethodError
  raise TypeError.new "can't convert #{inspect_type_error(arg)}into BigDecimal"
end

.Boolean(arg) ⇒ true, false

Coerces the argument to be a Boolean.

Examples:

Basic Usage

require 'lotus/utils/kernel'

Lotus::Utils::Kernel.Boolean(nil)                      # => false
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

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

Unchecked Exceptions

require 'lotus/utils/kernel'

# Missing #respond_to?
input = BasicObject.new
Lotus::Utils::Kernel.Boolean(input) # => TypeError

Parameters:

  • arg (Object)

    the argument

Returns:

  • (true, false)

    the result of the coercion

Raises:

  • (TypeError)

    if the argument can’t be coerced

Since:

  • 0.1.1



911
912
913
914
915
916
917
918
919
920
921
# File 'lib/lotus/utils/kernel.rb', line 911

def self.Boolean(arg)
  case arg
  when Numeric     then arg > 0 && arg <= 1
  when String, '0' then Boolean(arg.to_i)
  when ->(a) { a.respond_to?(:to_bool) } then arg.to_bool
  else
    !!arg
  end
rescue NoMethodError
  raise TypeError.new "can't convert #{inspect_type_error(arg)}into Boolean"
end

.Date(arg) ⇒ Date

Coerces the argument to be a Date.

Examples:

Basic Usage

require 'lotus/utils/kernel'

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)>

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)>

Unchecked Exceptions

require 'lotus/utils/kernel'

# 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) # => TypeError

Parameters:

  • arg (Object)

    the argument

Returns:

  • (Date)

    the result of the coercion

Raises:

  • (TypeError)

    if the argument can’t be coerced

Since:

  • 0.1.1



727
728
729
730
731
732
733
734
735
# File 'lib/lotus/utils/kernel.rb', line 727

def self.Date(arg)
  if arg.respond_to?(:to_date)
    arg.to_date
  else
    Date.parse(arg.to_s)
  end
rescue ArgumentError, NoMethodError
  raise TypeError.new "can't convert #{inspect_type_error(arg)}into Date"
end

.DateTime(arg) ⇒ DateTime

Coerces the argument to be a DateTime.

Examples:

Basic Usage

require 'lotus/utils/kernel'

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)>

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)>

Unchecked Exceptions

require 'lotus/utils/kernel'

# 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) # => TypeError

Parameters:

  • arg (Object)

    the argument

Returns:

  • (DateTime)

    the result of the coercion

Raises:

  • (TypeError)

    if the argument can’t be coerced

Since:

  • 0.1.1



794
795
796
797
798
799
800
801
802
803
# File 'lib/lotus/utils/kernel.rb', line 794

def self.DateTime(arg)
  case arg
  when ->(a) { a.respond_to?(:to_datetime) } then arg.to_datetime
  when Numeric then DateTime(Time.at(arg))
  else
    DateTime.parse(arg.to_s)
  end
rescue ArgumentError, NoMethodError
  raise TypeError.new "can't convert #{inspect_type_error(arg)}into DateTime"
end

.Float(arg) ⇒ Float

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 raise an exception only when the argument can’t be coerced.

Examples:

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

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

Error Handling

require 'bigdecimal'
require 'lotus/utils/kernel'

# nil
Kernel.Float(nil)               # => TypeError
Lotus::Utils::Kernel.Float(nil) # => 0.0

# float represented as a string
Kernel.Float("23.4")               # => TypeError
Lotus::Utils::Kernel.Float("23.4") # => 23.4

# rational represented as a string
Kernel.Float("2/3")               # => TypeError
Lotus::Utils::Kernel.Float("2/3") # => 2.0

# complex represented as a string
Kernel.Float("2.5/1")               # => TypeError
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

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) # => TypeError

# String that doesn't represent a float
input = 'hello'
Lotus::Utils::Kernel.Float(input) # => TypeError

# big rational
input = Rational(-8) ** Rational(1, 3)
Lotus::Utils::Kernel.Float(input) # => TypeError

# big complex represented as a string
input = Complex(2, 3)
Lotus::Utils::Kernel.Float(input) # => TypeError

Parameters:

  • arg (Object)

    the argument

Returns:

  • (Float)

    the result of the coercion

Raises:

  • (TypeError)

    if the argument can’t be coerced

See Also:

Since:

  • 0.1.1



547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
# File 'lib/lotus/utils/kernel.rb', line 547

def self.Float(arg)
  super(arg)
rescue ArgumentError, TypeError
  begin
    case arg
    when NilClass, ->(a) { a.respond_to?(:to_f) && a.to_s.match(NUMERIC_MATCHER) }
      arg.to_f
    else
      raise TypeError.new "can't convert #{inspect_type_error(arg)}into Float"
    end
  rescue NoMethodError
    raise TypeError.new "can't convert #{inspect_type_error(arg)}into Float"
  end
rescue RangeError
  raise TypeError.new "can't convert #{inspect_type_error(arg)}into Float"
end

.Hash(arg) ⇒ Object

Since:

  • 0.1.1



201
202
203
204
205
206
207
208
209
# File 'lib/lotus/utils/kernel.rb', line 201

def self.Hash(arg)
  if arg.respond_to?(:to_h)
    arg.to_h
  else
    super(arg)
  end
rescue NoMethodError
  raise TypeError.new "can't convert #{inspect_type_error(arg)}into Hash"
end

.inspect_type_error(arg) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns the most useful type error possible

If the object does not respond_to?(:inspect), we return the class, else we return nil. In all cases, this method is tightly bound to callers, as this method appends the required space to make the error message look good.

Since:

  • 0.4.3



1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
# File 'lib/lotus/utils/kernel.rb', line 1041

def self.inspect_type_error(arg)
  (arg.respond_to?(:inspect) ? arg.inspect : arg.to_s) << " "
rescue NoMethodError => _
  # missing the #respond_to? method, fall back to returning the class' name
  begin
    arg.class.name << " instance "
  rescue NoMethodError
    # missing the #class method, can't fall back to anything better than nothing
    # Callers will have to guess from their code
    nil
  end
end

.Integer(arg) ⇒ Fixnum

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 raise an exception only when the argument can’t be coerced.

Examples:

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

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

Error Handling

require 'lotus/utils/kernel'

# nil
Kernel.Integer(nil)               # => TypeError
Lotus::Utils::Kernel.Integer(nil) # => 0

# float represented as a string
Kernel.Integer("23.4")               # => TypeError
Lotus::Utils::Kernel.Integer("23.4") # => 23

# rational represented as a string
Kernel.Integer("2/3")               # => TypeError
Lotus::Utils::Kernel.Integer("2/3") # => 2

# complex represented as a string
Kernel.Integer("2.5/1")               # => TypeError
Lotus::Utils::Kernel.Integer("2.5/1") # => 2

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

# String that doesn't represent an integer
input = 'hello'
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

# bigdecimal infinity
input = BigDecimal.new("Infinity")
Lotus::Utils::Kernel.Integer(input) # => TypeError

# bigdecimal NaN
input = BigDecimal.new("NaN")
Lotus::Utils::Kernel.Integer(input) # => TypeError

# big rational
input = Rational(-8) ** Rational(1, 3)
Lotus::Utils::Kernel.Integer(input) # => TypeError

# big complex represented as a string
input = Complex(2, 3)
Lotus::Utils::Kernel.Integer(input) # => TypeError

Parameters:

  • arg (Object)

    the argument

Returns:

  • (Fixnum)

    the result of the coercion

Raises:

  • (TypeError)

    if the argument can’t be coerced

See Also:

Since:

  • 0.1.1



331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
# File 'lib/lotus/utils/kernel.rb', line 331

def self.Integer(arg)
  super(arg)
rescue ArgumentError, TypeError, NoMethodError
  begin
    case arg
    when NilClass, ->(a) { a.respond_to?(:to_i) && a.to_s.match(NUMERIC_MATCHER) }
      arg.to_i
    else
      raise TypeError.new "can't convert #{inspect_type_error(arg)}into Integer"
    end
  rescue NoMethodError
    raise TypeError.new "can't convert #{inspect_type_error(arg)}into Integer"
  end
rescue RangeError
  raise TypeError.new "can't convert #{inspect_type_error(arg)}into Integer"
end

.Pathname(arg) ⇒ Pathname

Coerces the argument to be a Pathname.

Examples:

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>

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>

String Interface

require 'lotus/utils/kernel'

class RootPath
  def to_str
    '/'
  end
end

Lotus::Utils::Kernel.Pathname(RootPath.new) # => #<Pathname:/>

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

Parameters:

  • arg (#to_pathname, #to_str)

    the argument

Returns:

  • (Pathname)

    the result of the coercion

Raises:

  • (TypeError)

    if the argument can’t be coerced

Since:

  • 0.1.2



971
972
973
974
975
976
977
978
979
# File 'lib/lotus/utils/kernel.rb', line 971

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 #{inspect_type_error(arg)}into Pathname"
end

.Set(arg) ⇒ Set

Coerces the argument to be a Set.

Examples:

Basic Usage

require 'lotus/utils/kernel'

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}>
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]}>

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"}>

Unchecked Exceptions

require 'lotus/utils/kernel'

Lotus::Utils::Kernel.Set(BasicObject.new) # => TypeError

Parameters:

  • arg (Object)

    the input

Returns:

  • (Set)

    the result of the coercion

Raises:

  • (TypeError)

    if arg doesn’t implement #respond_to?

Since:

  • 0.1.1



136
137
138
139
140
141
142
143
144
# File 'lib/lotus/utils/kernel.rb', line 136

def self.Set(arg)
  if arg.respond_to?(:to_set)
    arg.to_set
  else
    Set.new(::Kernel.Array(arg))
  end
rescue NoMethodError
  raise TypeError.new("can't convert #{inspect_type_error(arg)}into Set")
end

.String(arg) ⇒ Object

Since:

  • 0.1.1



652
653
654
655
656
657
658
659
660
661
662
663
# File 'lib/lotus/utils/kernel.rb', line 652

def self.String(arg)
  case arg
  when ->(a) { a.respond_to?(:to_str) }
    arg.to_str
  when ->(a) { a.respond_to?(:to_s) }
    arg.to_s
  else
    super(arg)
  end
rescue NoMethodError
  raise TypeError.new "can't convert #{inspect_type_error(arg)}into String"
end

.Symbol(arg) ⇒ Symbol

Coerces the argument to be a Symbol.

Examples:

Basic Usage

require 'lotus/utils/kernel'

Lotus::Utils::Kernel.Symbol(:hello)  # => :hello
Lotus::Utils::Kernel.Symbol('hello') # => :hello

Symbol Interface

require 'lotus/utils/kernel'

class StatusSymbol
  def to_sym
    :success
  end
end

Lotus::Utils::Kernel.Symbol(StatusSymbol.new) # => :success

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

Parameters:

  • arg (#to_sym)

    the argument

Returns:

  • (Symbol)

    the result of the coercion

Raises:

  • (TypeError)

    if the argument can’t be coerced

Since:

  • 0.2.0



1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
# File 'lib/lotus/utils/kernel.rb', line 1022

def self.Symbol(arg)
  case arg
  when '' then raise TypeError.new "can't convert #{inspect_type_error(arg)}into Symbol"
  when ->(a) { a.respond_to?(:to_sym) } then arg.to_sym
  else
    raise TypeError.new "can't convert #{inspect_type_error(arg)}into Symbol"
  end
rescue NoMethodError
  raise TypeError.new "can't convert #{inspect_type_error(arg)}into Symbol"
end

.Time(arg) ⇒ Time

Coerces the argument to be a Time.

Examples:

Basic Usage

require 'lotus/utils/kernel'

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

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

Unchecked Exceptions

require 'lotus/utils/kernel'

# 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) # => TypeError

Parameters:

  • arg (Object)

    the argument

Returns:

  • (Time)

    the result of the coercion

Raises:

  • (TypeError)

    if the argument can’t be coerced

Since:

  • 0.1.1



859
860
861
862
863
864
865
866
867
868
# File 'lib/lotus/utils/kernel.rb', line 859

def self.Time(arg)
  case arg
  when ->(a) { a.respond_to?(:to_time) } then arg.to_time
  when Numeric then Time.at(arg)
  else
    Time.parse(arg.to_s)
  end
rescue ArgumentError, NoMethodError
  raise TypeError.new "can't convert #{inspect_type_error(arg)}into Time"
end