Module: Immutability

Included in:
WithMemory
Defined in:
lib/immutability.rb,
lib/immutability/object.rb,
lib/immutability/with_memory.rb

Overview

Makes the object immutable (deeply frozen) with possibility to remember and forget previous states (snapshots).

Uses ‘ice_nine’ to freeze object deeply by the initializer

Examples:

Without memory

require "immutability"

class User
  include Immutability

  attr_reader :name

  def initialize(name)
    @name = name
  end
end

user = User.new "Andre"
user.name             # => "Andre"
# It is frozen deeply
user.frozen?          # => true
user.name.frozen?     # => true

new_user = user.update { @name = "Andrew" }
new_user.name         # => "Andrew"
# It is frozen deeply
new_user.frozen?      # => true
new_user.name.frozen? # => true

With memory

class User
  include Immutability.with_memory

  attr_reader :name

  def initialize(name)
    @name = name
  end
end

user = User.new "Andre"
user.name             # => "Andre"
# It has version and reference to the parent (nil for the first version)
user.version          # => 0
user.parent           # => nil

new_user = user.update { @name = "Andrew" }
new_user.name         # => "Andrew"
# It stores current version and reference to the parent
new_user.version      # => 1
new_user.parent       # => #<User @name="Andre">

mankurt = new_user.forget_history
mankurt.name          # => "Andrew"
# It doesn't refer to previous states (they can be garbage collected)
mankurt.version       # => 0
mankurt.parent        # => nil

Author:

Defined Under Namespace

Modules: ClassMethods, WithMemory Classes: Object

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.with_memory ⇒ Module

Returns the module extended by features to record history

Returns:

  • (Module) 


109
110
111
 
# File 'lib/immutability.rb', line 109

def self.with_memory
  WithMemory
end

Instance Method Details

#update(&block) ⇒ Object

Returns the new immutable instances that preserves old variables and updates some of them from inside the block

Parameters:

  • block (Proc) —

    The block to be evaluated by new instance’s “initializer”

Returns:

  • (Object) —

    the updated instance



101
102
103
 
# File 'lib/immutability.rb', line 101

def update(&block)
  IceNine.deep_freeze dup.tap { |obj| obj.instance_eval(&block) if block }
end