Class: Remap::Compiler

Inherits:
Proxy
  • Object
show all
Defined in:
lib/remap/compiler.rb

Overview

Constructs a Rule from the block passed to Base.define

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Proxy

const_missing, #tap

Class Method Details

.call(&block) ⇒ Rule

Constructs a rule tree given block

Examples:

Compiles two rules, [get] and [map]

rule = Remap::Compiler.call do
  get :name
  get :age
end

state = Remap::State.call({
  name: "John",
  age: 50
})

error = -> failure { raise failure.exception }

rule.call(state, &error).fetch(:value) # => { name: "John", age: 50 }

Returns:



30
31
32
33
34
35
36
37
38
 
# File 'lib/remap/compiler.rb', line 30

def self.call(&block)
  unless block
    return Rule::Void.new
  end

  new([]).tap do |compiler|
    compiler.instance_exec(&block)
  end.rule
end

Instance Method Details

#all(&block) ⇒ Rule::Path::Segment::Quantifier::All

Selects all elements

Examples:

Select all keys in array

rule = Remap::Compiler.call do
  map all, :name, to: :names
end

state = Remap::State.call([
  { name: "John" },
  { name: "Jane" }
])

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => { names: ["John", "Jane"] }

Returns:

  • (Rule::Path::Segment::Quantifier::All) 


379
380
381
382
383
384
385
 
# File 'lib/remap/compiler.rb', line 379

def all(&block)
  if block
    raise ArgumentError, "all selector does not take a block"
  end

  Selector::All.new(EMPTY_HASH)
end

#at(index, &block) ⇒ Path::Segment::Key

Selects index element in input

Examples:

Select value at index

rule = Remap::Compiler.call do
  map :names, at(1), to: :name
end

state = Remap::State.call({
  names: ["John", "Jane"]
})

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => { name: "Jane" }

Parameters:

  • index (Integer)

Returns:

  • (Path::Segment::Key)

Raises:

  • (ArgumentError) —

    if index is not an Integer



460
461
462
463
464
465
466
467
468
469
 
# File 'lib/remap/compiler.rb', line 460

def at(index, &block)
  if block
    raise ArgumentError, "first selector does not take a block"
  end

  Selector::Index.new(index: index)
rescue Dry::Struct::Error
  raise ArgumentError,
        "Selector at(index) requires an integer argument, got [#{index}] (#{index.class})"
end

#call ⇒ Rule

Returns:



10
 
# File 'lib/remap/compiler.rb', line 10

delegate :call, to: Compiler

#each(&block) ⇒ Rule::Each

Iterates over the input value, passes each value to its block and merges the result back together

Examples:

Map an array of hashes

rule = Remap::Compiler.call do
  each do
    map :name
  end
end

state = Remap::State.call([{
  name: "John"
}, {
  name: "Jane"
}])

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => ["John", "Jane"]

Returns:

Raises:

  • (ArgumentError) —

    if no block given



317
318
319
320
321
322
323
 
# File 'lib/remap/compiler.rb', line 317

def each(&block)
  unless block
    raise ArgumentError, "#each requires a block"
  end

  add Rule::Each.new(rule: call(&block))
end

#embed(mapper, &block) ⇒ Rule::Embed

Maps using mapper

Examples:

Embed mapper Car into a person

class Car < Remap::Base
  define do
    map :car do
      map :name, to: :car
    end
  end
end

rule = Remap::Compiler.call do
  map :person do
    embed Car
  end
end

state = Remap::State.call({
  person: {
    car: {
      name: "Volvo"
    }
  }
})

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => { car: "Volvo" }

Parameters:

Returns:



187
188
189
190
191
192
193
194
195
 
# File 'lib/remap/compiler.rb', line 187

def embed(mapper, &block)
  if block
    raise ArgumentError, "#embed does not take a block"
  end

  add Rule::Embed.new(mapper: mapper)
rescue Dry::Struct::Error
  raise ArgumentError, "Embeded mapper must be [Remap::Mapper], got [#{mapper}]"
end

#first(&block) ⇒ Path::Segment::Key Also known as: any

Selects first element in input

Examples:

Select first value in an array

rule = Remap::Compiler.call do
  map :names, first, to: :name
end

state = Remap::State.call({
  names: ["John", "Jane"]
})

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => { name: "John" }

Returns:

  • (Path::Segment::Key) —

    ]



489
490
491
492
493
494
495
 
# File 'lib/remap/compiler.rb', line 489

def first(&block)
  if block
    raise ArgumentError, "first selector does not take a block"
  end

  at(0)
end

#get(*path, backtrace: Kernel.caller, &block) ⇒ Rule::Map::Required

Select a path and uses the same path as output

Examples:

Map from [:name] to [:name]

rule = Remap::Compiler.call do
  get :name
end

state = Remap::State.call({
  name: "John"
})

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => { name: "John" }

Parameters:

  • path ([]) —
    Array<Segment>, Segment

Returns:



124
125
126
 
# File 'lib/remap/compiler.rb', line 124

def get(*path, backtrace: Kernel.caller, &block)
  map(path, to: path, backtrace: backtrace, &block)
end

#get?(*path, backtrace: Kernel.caller, &block) ⇒ Rule::Map::Optional

Optional version of #get

Examples:

Map from [:name] to [:name]

rule = Remap::Compiler.call do
  get :name
  get? :age
end

state = Remap::State.call({
  name: "John"
})

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => { name: "John" }

Returns:

See Also:



149
150
151
 
# File 'lib/remap/compiler.rb', line 149

def get?(*path, backtrace: Kernel.caller, &block)
  map?(path, to: path, backtrace: backtrace, &block)
end

#last(&block) ⇒ Path::Segment::Key

Selects last element in input

Examples:

Select last value in an array

rule = Remap::Compiler.call do
  map :names, last, to: :name
end

state = Remap::State.call({
  names: ["John", "Jane", "Linus"]
})

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => { name: "Linus" }

Returns:

  • (Path::Segment::Key) 


516
517
518
519
520
521
522
 
# File 'lib/remap/compiler.rb', line 516

def last(&block)
  if block
    raise ArgumentError, "last selector does not take a block"
  end

  at(-1)
end

#map(*path, to: EMPTY_ARRAY, backtrace: Kernel.caller, &block) ⇒ Rule::Map::Required

Maps input path [input] to output path [to]

Examples:

From path [:name] to [:nickname]

rule = Remap::Compiler.call do
  map :name, to: :nickname
end

state = Remap::State.call({
  name: "John"
})

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => { nickname: "John" }

Parameters:

  • path ([]) —
    Array<Segment>, Segment
  • to ([]) (defaults to: EMPTY_ARRAY) —
    Array<Symbol>, Symbol

Returns:



61
62
63
64
65
66
67
68
69
 
# File 'lib/remap/compiler.rb', line 61

def map(*path, to: EMPTY_ARRAY, backtrace: Kernel.caller, &block)
  add Rule::Map::Required.call(
    path: {
      output: [to].flatten,
      input: path.flatten
    },
    backtrace: backtrace,
    rule: call(&block))
end

#map?(*path, to: EMPTY_ARRAY, backtrace: Kernel.caller, &block) ⇒ Rule::Map::Optional

Optional version of #map

Examples:

Map an optional field

rule = Remap::Compiler.call do
  to :person do
    map? :age, to: :age
    map :name, to: :name
  end
end

state = Remap::State.call({
  name: "John"
})

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => { person: { name: "John" } }

Returns:

See Also:



94
95
96
97
98
99
100
101
102
 
# File 'lib/remap/compiler.rb', line 94

def map?(*path, to: EMPTY_ARRAY, backtrace: Kernel.caller, &block)
  add Rule::Map::Optional.call(
    path: {
      output: [to].flatten,
      input: path.flatten
    },
    backtrace: backtrace,
    rule: call(&block))
end

#option(id, backtrace: Kernel.caller, &block) ⇒ Rule::Static::Option

Static option to be selected

Examples:

Set path to option

rule = Remap::Compiler.call do
  set :meaning_of_life, to: option(:number)
end

state = Remap::State.call({}, options: { number: 42 })

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => { meaning_of_life: 42 }

Parameters:

  • id (Symbol)

Returns:

  • (Rule::Static::Option) 


431
432
433
434
435
436
437
 
# File 'lib/remap/compiler.rb', line 431

def option(id, backtrace: Kernel.caller, &block)
  if block
    raise ArgumentError, "option selector does not take a block"
  end

  Static::Option.new(name: id, backtrace: backtrace)
end

#rule ⇒ Rule

The final rule

Returns:



527
528
529
 
# File 'lib/remap/compiler.rb', line 527

def rule
  Rule::Collection.call(rules: rules)
end

#rules ⇒ Array<Rule>

Returns:



7
 
# File 'lib/remap/compiler.rb', line 7

param :rules, type: Types.Array(Rule)

#set(*path, to:, &block) ⇒ Rule::Set

Set a static value

Examples:

Set static value to { name: “John” }

rule = Remap::Compiler.call do
  set :name, to: value("John")
end

state = Remap::State.call({})

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => { name: "John" }

Reference an option

rule = Remap::Compiler.call do
  set :name, to: option(:name)
end

state = Remap::State.call({}, options: { name: "John" })

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => { name: "John" }

Parameters:

  • path ([]) —
    Symbol, Array<Symbol>
  • to (Hash) —

    a customizable set of options

Options Hash (to:):

Returns:

Raises:

  • (ArgumentError) —

    if no path given if path is not a Symbol or Array<Symbol>



232
233
234
235
236
237
238
239
240
 
# File 'lib/remap/compiler.rb', line 232

def set(*path, to:, &block)
  if block
    raise ArgumentError, "#set does not take a block"
  end

  add Rule::Set.new(path: path.flatten, value: to)
rescue Dry::Struct::Error => e
  raise ArgumentError, e.message
end

#to(*path, map: EMPTY_ARRAY, backtrace: Kernel.caller, &block) ⇒ Rule::Map

Maps to path from map with block in between

Examples:

From path [:name] to [:nickname]

rule = Remap::Compiler.call do
  to :nickname, map: :name
end

state = Remap::State.call({
  name: "John"
})

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => { nickname: "John" }

Parameters:

  • path (Array<Symbol>, Symbol)
  • map (Array<Segment>, Segment) (defaults to: EMPTY_ARRAY)

Returns:



263
264
265
 
# File 'lib/remap/compiler.rb', line 263

def to(*path, map: EMPTY_ARRAY, backtrace: Kernel.caller, &block)
  map(*map, to: path, backtrace: backtrace, &block)
end

#to?(*path, map: EMPTY_ARRAY, &block) ⇒ Rule::Map::Optional

Optional version of #to

Examples:

Map an optional field

rule = Remap::Compiler.call do
  to :person do
    to? :age, map: :age
    to :name, map: :name
  end
end

state = Remap::State.call({
  name: "John"
})

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => { person: { name: "John" } }

Returns:

See Also:



289
290
291
 
# File 'lib/remap/compiler.rb', line 289

def to?(*path, map: EMPTY_ARRAY, &block)
  map?(*map, to: path, &block)
end

#value(value, &block) ⇒ Rule::Static::Fixed

Static value to be selected

Examples:

Set path to static value

rule = Remap::Compiler.call do
  set :api_key, to: value("<SECRET>")
end

state = Remap::State.call({})

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => { api_key: "<SECRET>" }

Parameters:

  • value (Any)

Returns:

  • (Rule::Static::Fixed) 


405
406
407
408
409
410
411
 
# File 'lib/remap/compiler.rb', line 405

def value(value, &block)
  if block
    raise ArgumentError, "option selector does not take a block"
  end

  Static::Fixed.new(value: value)
end

#wrap(type, &block) ⇒ Rule::Wrap

Wraps output in type

Examples:

Wrap an output value in an array

rule = Remap::Compiler.call do
  wrap(:array) do
    map :name
  end
end

state = Remap::State.call({
  name: "John"
})

output = rule.call(state) do |failure|
  raise failure.exception
end

output.fetch(:value) # => ["John"]

Parameters:

  • type (:array)

Yield Returns:

Returns:

Raises:

  • (ArgumentError) —

    if type is not :array



350
351
352
353
354
355
356
357
358
 
# File 'lib/remap/compiler.rb', line 350

def wrap(type, &block)
  unless block
    raise ArgumentError, "#wrap requires a block"
  end

  add Rule::Wrap.new(type: type, rule: call(&block))
rescue Dry::Struct::Error => e
  raise ArgumentError, e.message
end