ruby_utils

Various ruby core extensions and class utilities.

Status

TBD

Installation

Add this line to your application's Gemfile:

gem 'ruby_utils'

And then execute:

$ bundle

Or install it yourself as:

$ gem install ruby-utils

Usage

TBD

Features

Ruby::Utils::Option

A scala like container for zero or one element. An option can be either Some[Object] or None object.

Creating a Some or None option:

  def find_person(id)
    person = Person.find_by_id
    person ? Some(person) : None
  end

  person = find_person(1)
  person.class # None if not found else Some(person)

#empty? True if None, false if Some

  none = None
  none.empty? # => true
  none.defined? # => false

  some = Some(Class.new)
  some.empty? # => false
  some.defined? # => true

#defined? True if Some else false on None

get Returns the option's value or an exception is raised on empty option.

  none = None
  none.get # => NoSuchElementError

  some = Some(12)
  some.get # => 12

get_or_else(default) Returns the option's value if the option is nonempty, otherwise return the result of evaluating default.

  none = None
  none.get_or_else("default") # => 'default'


  some = Some(12)
  some.get_or_else("default") # => 12

map(f=nil, &block) Returns a Some containing the result of applying f / or evaluating the block to self option's value if this option is nonempty. Otherwise return None

  f = ->(x) { x*x }

  none = None
  none.map(f) #=> None
  none.map { |e| e* 100 } # -> none

  some = Some(10)
  some.map(f) # => Some(100)
  some.map { |e| e*2 } # => Some(20)

flat_map(f, &block) If the option is nonempty, return a function applied to its value.

Otherwise return None.

  f = ->(x) { x * 10 }
  none = None
  none.flat_map(f) # => None
  none.flat_map { |a| a } # => None

  some = Some(20)
  some.flat_map(f) # => 200
  some.flat_map { |e| e * 2 } # => 40

filter(p=nil, &block) If the option is nonempty and the given predicate p yields false on its value, return None. Otherwise return the option value itself.

  p = ->(x) { x % 2 == 0 }

  none = None
  none.filter(p) # => None
  none.filter { |a| a == 1 } # => None

  some = Some(10)
  some.filter(p) # => Some(10)

  some = Some(3)
  some.filter(p) # => None

or_else(alternative) If the option is nonempty return it, otherwise return the result of evaluating an alternative expression.

  none = None
  none.or_else(12) # => 12
  none.or_else(Some(12)) # => Some(12)

  some = Some(10)
  some.or_else(111) # => Some(10)

match [Experimental] Provides pseudo pattern match for option classes (see also List#match)

  def get(id)
    if id == 1
      None
    else
      Some(id)
    end
  end

  some_value = get(1) # None
  result = some_value.match {
    on None => 'missing'
    on Some(x) => x * 100
  }

  purs result # => 'missing'


  other_value = get(10)
  res2 = other_value.match {
    on None => 'missing2'
    on Some(y) => y * 10
  }

  puts res2 # => 100

Ruby::Utils::Param

A wrapper around a ruby hash that takes a hash on initialization:

hash = {
    a: 1,
    b: 2,
    c: {
      d: 3,
      e: {
        f: [{ ff: 1}, { ff: 2 }]
      }
    }
  }

param = Ruby::Utils::Param(hash)

param.c.d # => 3
param.c.missing_key # => Raises error
param.get('c.d') # => 3

To get access to the original has you can call params.to_hash

#get

Fetch the value of a key if one exist or raise an exception of no key can be found.

param.get('a') # => 1
params.get('c.d') #=> 3
params.get('c.d.missing_key') # => raised an error

#getOrElse

Fetch the value of a key if any or else returns nil by default unless one is provided.

params.getOrElse('a') # => 1
params.getOrElse('a.missing_key') # => nil
params.getOrElse('c.d') # => 3

params.getOrElse('a.missing_key', 'default_value') # => 'default_value'

#defined?

Returns true if key is defined else false

param.defined?('a') # => true
param.defined?('c.e.f') # => true
param.defined('a.missing') # => false

#all?

Returns true when all keys are present:

param.all?('c.e.f') # => true
params.all?(c.missing) # => false

#with

It call the block specified when a key can be found in the hash:

param.with('c.e.f') do |cef_value|
  puts cef_value # => [{ ff: 1}, { ff: 2 }]
end

param.with('c.missing_key') do |some|
  raise "This will never be called"
end

#map

It calls the given block for each value when the key can be found in the hash.

hash = { a: { b: 'some string' } }
param = Ruby::Utils::Param(hash)

puts param.map('a.b', &upcase) # => SOME STRING

puts param.map('a.b') do |value|
  value.upcase
end # => SOME STRING

Ruby::Utils::Hash