Class: Dhall::Coder

Inherits:
Object
  • Object
show all
Defined in:
lib/dhall/coder.rb

Defined Under Namespace

Modules: InitWith, ToRuby Classes: Verifier

Constant Summary collapse

JSON_LIKE = 
[
  ::Array, ::Hash,
  ::TrueClass, ::FalseClass, ::NilClass,
  ::Integer, ::Float, ::String
].freeze

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(default: nil, safe: JSON_LIKE) ⇒ Coder

Returns a new instance of Coder.



46
47
48
49
50
 
# File 'lib/dhall/coder.rb', line 46

def initialize(default: nil, safe: JSON_LIKE)
  @default = default
  @verifier = Verifier.new(*Array(safe))
  @verifier.verify(default, "default value")
end

Class Method Details

.dump(obj) ⇒ Object 



42
43
44
 
# File 'lib/dhall/coder.rb', line 42

def self.dump(obj)
  new.dump(obj)
end

.load(source, transform_keys: :to_s) ⇒ Object 



38
39
40
 
# File 'lib/dhall/coder.rb', line 38

def self.load(source, transform_keys: :to_s)
  new.load(source, transform_keys: transform_keys)
end

Instance Method Details

#decode(expr, op = "decode", klass: nil, transform_keys: :to_s) ⇒ Object 



175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'lib/dhall/coder.rb', line 175

def decode(expr, op="decode", klass: nil, transform_keys: :to_s)
  return revive(klass, expr, op, transform_keys: transform_keys) if klass
  @verifier.verify(
    Util.transform_keys(
      expr.to_ruby { |dexpr, dklass|
        decode(dexpr, op, klass: dklass, transform_keys: transform_keys)
      },
      &transform_keys
    ),
    op
  )
end

#dump(obj) ⇒ Object 



188
189
190
191
192
 
# File 'lib/dhall/coder.rb', line 188

def dump(obj)
  return if obj.nil?

  Dhall.dump(@verifier.verify(obj, "dump"))
end

#load(source, transform_keys: :to_s) ⇒ Object 



61
62
63
 
# File 'lib/dhall/coder.rb', line 61

def load(source, transform_keys: :to_s)
  load_async(source, "load", transform_keys: transform_keys).sync
end

#load_async(source, op = "load_async", transform_keys: :to_s) ⇒ Object 



52
53
54
55
56
57
58
59
 
# File 'lib/dhall/coder.rb', line 52

def load_async(source, op="load_async", transform_keys: :to_s)
  return Promise.resolve(@default) if source.nil?
  return Promise.resolve(source) unless source.is_a?(String)

  Dhall.load(source).then do |expr|
    decode(expr, op, transform_keys: transform_keys)
  end
end

#revive(klass, expr, op = "revive", transform_keys: :to_s) ⇒ Object 



163
164
165
166
167
168
169
170
171
172
173
 
# File 'lib/dhall/coder.rb', line 163

def revive(klass, expr, op="revive", transform_keys: :to_s)
  @verifier.verify_class(klass, op)
  return klass.from_dhall(expr) if klass.respond_to?(:from_dhall)

  klass.allocate.tap do |o|
    o.init_with(Util.psych_coder_for(
      klass.name,
      decode(expr, op, transform_keys: transform_keys)
    ))
  end
end