Class: JSONP3::Pointer

Inherits:
Object
  • Object
show all
Defined in:
lib/json_p3/pointer.rb,
lib/json_p3/errors.rb

Overview

Identify a single value in JSON-like data, as per RFC 6901.

Defined Under Namespace

Classes: Error, IndexError, SyntaxError, TypeError

Constant Summary collapse

RE_INT = 
/\A(0|[1-9][0-9]*)\z/
UNDEFINED = 
:__undefined

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(pointer) ⇒ Pointer

Returns a new instance of Pointer.

Parameters:

  • pointer (String) 


29
30
31
32
 
# File 'lib/json_p3/pointer.rb', line 29

def initialize(pointer)
  @tokens = parse(pointer)
  @pointer = Pointer.encode(@tokens)
end

Instance Attribute Details

#tokens ⇒ Object (readonly)

Returns the value of attribute tokens.



9
10
11
 
# File 'lib/json_p3/pointer.rb', line 9

def tokens
  @tokens
end

Class Method Details

.encode(tokens) ⇒ String

Encode an array of strings and integers into a JSON Pointer.

Parameters:

  • tokens (Array<String | Integer> | nil)

Returns:

  • (String) 


18
19
20
21
22
23
24
25
26
 
# File 'lib/json_p3/pointer.rb', line 18

def self.encode(tokens)
  return "" if tokens.nil? || tokens.empty?

  encoded = tokens.map do |token|
    token.is_a?(Integer) ? token.to_s : token.gsub("~", "~0").gsub("/", "~1")
  end

  "/#{encoded.join("/")}"
end

.resolve(pointer, value, default: UNDEFINED) ⇒ Object 



11
12
13
 
# File 'lib/json_p3/pointer.rb', line 11

def self.resolve(pointer, value, default: UNDEFINED)
  new(pointer).resolve(value, default: default)
end

Instance Method Details

#exist?(value) ⇒ Boolean

Return true if this pointer can be resolved against value, even if the resolved value is false or nil.

Parameters:

  • value (Object)

Returns:

  • (Boolean) 


87
88
89
 
# File 'lib/json_p3/pointer.rb', line 87

def exist?(value)
  resolve(value) != UNDEFINED
end

#join(*parts) ⇒ Pointer

Parameters:

  • parts (String)

Returns:



76
77
78
79
80
81
82
 
# File 'lib/json_p3/pointer.rb', line 76

def join(*parts)
  pointer = self
  parts.each do |part|
    pointer = pointer._join(part)
  end
  pointer
end

#parent ⇒ Object

Return this pointer's parent as a new pointer. If this pointer points to the document root, self is returned.



93
94
95
96
97
 
# File 'lib/json_p3/pointer.rb', line 93

def parent
  return self if @tokens.empty?

  Pointer.new(Pointer.encode(@tokens[...-1] || raise))
end

#relative_to?(pointer) ⇒ bool

Return true if this pointer is relative to pointer.

Parameters:

Returns:

  • (bool) 


70
71
72
 
# File 'lib/json_p3/pointer.rb', line 70

def relative_to?(pointer)
  pointer.tokens.length < @tokens.length && @tokens[...pointer.tokens.length] == pointer.tokens
end

#resolve(value, default: UNDEFINED) ⇒ Object

Resolve this pointer against JSON-like data value.

Parameters:

  • value (Object)
  • default (Object) (defaults to: UNDEFINED) —

    the value to return if this pointer can not be resolved against value.



38
39
40
41
42
43
44
45
46
47
 
# File 'lib/json_p3/pointer.rb', line 38

def resolve(value, default: UNDEFINED)
  item = value

  @tokens.each do |token|
    item = get_item(item, token)
    return default if item == UNDEFINED
  end

  item
end

#resolve_with_parent(value) ⇒ Array<Object>

Resolve this pointer against value, returning the resolved object and its parent object.

Parameters:

  • value (Object)

Returns:

  • (Array<Object>) —

    an array with exactly two elements, one or both of which could be undefined.



55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/json_p3/pointer.rb', line 55

def resolve_with_parent(value)
  return [UNDEFINED, resolve(value)] if @tokens.empty?

  parent = value
  (@tokens[...-1] || raise).each do |token|
    parent = get_item(parent, token)
    break if parent == UNDEFINED
  end

  [parent, get_item(parent, @tokens.last)]
end

#to(rel) ⇒ Pointer

Return a new pointer relative to this pointer using Relative JSON Pointer syntax.

Parameters:

Returns:



102
103
104
105
 
# File 'lib/json_p3/pointer.rb', line 102

def to(rel)
  p = rel.is_a?(String) ? RelativePointer.new(rel) : rel
  p.to(self)
end

#to_s ⇒ Object 



107
108
109
 
# File 'lib/json_p3/pointer.rb', line 107

def to_s
  @pointer
end