Class: JsonPath

Inherits:
Object
  • Object
show all
Defined in:
lib/jsonpath.rb,
lib/jsonpath/proxy.rb,
lib/jsonpath/parser.rb,
lib/jsonpath/version.rb,
lib/jsonpath/enumerable.rb

Overview

JsonPath: initializes the class with a given JsonPath and parses that path into a token array.

Defined Under Namespace

Classes: Enumerable, Parser, Proxy

Constant Summary collapse

PATH_ALL = 
'$..*'.freeze
VERSION = 
'1.0.3'.freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(path, opts = {}) ⇒ JsonPath

Returns a new instance of JsonPath.



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/jsonpath.rb', line 17

def initialize(path, opts = {})
  @opts = opts
  scanner = StringScanner.new(path.strip)
  @path = []
  until scanner.eos?
    if token = scanner.scan(/\$\B|@\B|\*|\.\./)
      @path << token
    elsif token = scanner.scan(/[\$@a-zA-Z0-9:{}_-]+/)
      @path << "['#{token}']"
    elsif token = scanner.scan(/'(.*?)'/)
      @path << "[#{token}]"
    elsif token = scanner.scan(/\[/)
      @path << find_matching_brackets(token, scanner)
    elsif token = scanner.scan(/\]/)
      raise ArgumentError, 'unmatched closing bracket'
    elsif scanner.scan(/\./)
      nil
    elsif token = scanner.scan(/[><=] \d+/)
      @path.last << token
    elsif token = scanner.scan(/./)
      begin
        @path.last << token
      rescue RuntimeError
        raise ArgumentError, "character '#{token}' not supported in query"
      end
    end
  end
end

Instance Attribute Details

#path ⇒ Object

Returns the value of attribute path.



15
16
17
 
# File 'lib/jsonpath.rb', line 15

def path
  @path
end

Class Method Details

.for(obj_or_str) ⇒ Object 



94
95
96
 
# File 'lib/jsonpath.rb', line 94

def self.for(obj_or_str)
  Proxy.new(process_object(obj_or_str))
end

.on(obj_or_str, path, opts = {}) ⇒ Object 



90
91
92
 
# File 'lib/jsonpath.rb', line 90

def self.on(obj_or_str, path, opts = {})
  new(path, opts).on(process_object(obj_or_str))
end

Instance Method Details

#enum_on(obj_or_str, mode = nil) ⇒ Object Also known as: [] 



84
85
86
87
 
# File 'lib/jsonpath.rb', line 84

def enum_on(obj_or_str, mode = nil)
  JsonPath::Enumerable.new(self, self.class.process_object(obj_or_str), mode,
                           @opts)
end

#find_matching_brackets(token, scanner) ⇒ Object 



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/jsonpath.rb', line 46

def find_matching_brackets(token, scanner)
  count = 1
  until count.zero?
    if t = scanner.scan(/\[/)
      token << t
      count += 1
    elsif t = scanner.scan(/\]/)
      token << t
      count -= 1
    elsif t = scanner.scan(/[^\[\]]+/)
      token << t
    elsif scanner.eos?
      raise ArgumentError, 'unclosed bracket'
    end
  end
  token
end

#first(obj_or_str, *args) ⇒ Object 



80
81
82
 
# File 'lib/jsonpath.rb', line 80

def first(obj_or_str, *args)
  enum_on(obj_or_str).first(*args)
end

#join(join_path) ⇒ Object 



64
65
66
67
68
 
# File 'lib/jsonpath.rb', line 64

def join(join_path)
  res = deep_clone
  res.path += JsonPath.new(join_path).path
  res
end

#on(obj_or_str, opts = {}) ⇒ Object 



70
71
72
73
74
75
76
77
78
 
# File 'lib/jsonpath.rb', line 70

def on(obj_or_str, opts = {})
  a = enum_on(obj_or_str).to_a
  if opts[:symbolize_keys]
    a.map! do |e|
      e.each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v; }
    end
  end
  a
end