5106848293

pending completion

Build # 5106848293

Build Type

push

github

Committed by

notEthan

Commit Message

Merge branch 'new', remote-tracking branches 'origin/node', 'origin/property_accessor', 'origin/slash', 'origin/described_by', 'origin/metaschema_instance_modules', 'origin/registration', 'origin/super', 'origin/ptr', 'origin/uri', 'origin/json_schema_test_suite', 'origin/yardopts' and 'origin/dependabot/github_actions/coverallsapp/github-action-2.1.2'; commit 'c660cfd30' into HEAD

Run Details

262 of 272 new or added lines in 24 files covered. (96.32%)

3708 of 3809 relevant lines covered (97.35%)

357182.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.28

/lib/jsi/ptr.rb

# frozen_string_literal: true

module JSI
    # a representation to work with JSON Pointer, as described by RFC 6901 https://tools.ietf.org/html/rfc6901
    #
    # a pointer is a sequence of tokens pointing to a node in a document.
    class Ptr
      class Error < StandardError
      end

      # raised when attempting to parse a JSON Pointer string with invalid syntax
      class PointerSyntaxError < Error
      end

      # raised when a pointer refers to a path in a document that could not be resolved
      class ResolutionError < Error
      end

      # instantiates a pointer or returns the given pointer
      # @param ary_ptr [#to_ary, JSI::Ptr] an array of tokens, or a pointer
      # @return [JSI::Ptr]
      def self.ary_ptr(ary_ptr)
        if ary_ptr.is_a?(Ptr)
          ary_ptr
        else
          new(ary_ptr)
        end
      end

      # instantiates a pointer from the given tokens.
      #
      #     JSI::Ptr[]
      #
      # instantiates a root pointer.
      #
      #     JSI::Ptr['a', 'b']
      #     JSI::Ptr['a']['b']
      #
      # are both ways to instantiate a pointer with tokens ['a', 'b']. the latter example chains the
      # class .[] method with the instance #[] method.
      #
      # @param tokens any number of tokens
      # @return [JSI::Ptr]
      def self.[](*tokens)
        tokens.empty? ? EMPTY : new(tokens)
      end

      # parse a URI-escaped fragment and instantiate as a JSI::Ptr
      #
      #     JSI::Ptr.from_fragment('/foo/bar')
      #     => JSI::Ptr["foo", "bar"]
      #
      # with URI escaping:
      #
      #     JSI::Ptr.from_fragment('/foo%20bar')
      #     => JSI::Ptr["foo bar"]
      #
      # Note: A fragment does not include a leading '#'. The string "#/foo" is a URI containing the
      # fragment "/foo", which should be parsed by `Addressable::URI` before passing to this method, e.g.:
      #
      #     JSI::Ptr.from_fragment(Addressable::URI.parse("#/foo").fragment)
      #     => JSI::Ptr["foo"]
      #
      # @param fragment [String] a fragment containing a pointer
      # @return [JSI::Ptr]
      # @raise [JSI::Ptr::PointerSyntaxError] when the fragment does not contain a pointer with
      #   valid pointer syntax
      def self.from_fragment(fragment)
        from_pointer(Addressable::URI.unescape(fragment))
      end

      # parse a pointer string and instantiate as a JSI::Ptr
      #
      #     JSI::Ptr.from_pointer('/foo')
      #     => JSI::Ptr["foo"]
      #
      #     JSI::Ptr.from_pointer('/foo~0bar/baz~1qux')
      #     => JSI::Ptr["foo~bar", "baz/qux"]
      #
      # @param pointer_string [String] a pointer string
      # @return [JSI::Ptr]
      # @raise [JSI::Ptr::PointerSyntaxError] when the pointer_string does not have valid pointer syntax
      def self.from_pointer(pointer_string)
        pointer_string = pointer_string.to_str
        if pointer_string[0] == ?/
          tokens = pointer_string.split('/', -1).map! do |piece|
            piece.gsub('~1', '/').gsub('~0', '~')
          end
          tokens.shift
          new(tokens)
        elsif pointer_string.empty?
          EMPTY
        else
          raise(PointerSyntaxError, "Invalid pointer syntax in #{pointer_string.inspect}: pointer must begin with /")
        end
      end

      # initializes a JSI::Ptr from the given tokens.
      #
      # @param tokens [Array<Object>]
      def initialize(tokens)
        unless tokens.respond_to?(:to_ary)
          raise(TypeError, "tokens must be an array. got: #{tokens.inspect}")
        end
        @tokens = tokens.to_ary.map(&:freeze).freeze
      end

      EMPTY = new(Util::EMPTY_ARY)

      attr_reader :tokens

      # takes a root json document and evaluates this pointer through the document, returning the value
      # pointed to by this pointer.
      #
      # @param document [#to_ary, #to_hash] the document against which we will evaluate this pointer
      # @param a arguments are passed to each invocation of `#[]`
      # @return [Object] the content of the document pointed to by this pointer
      # @raise [JSI::Ptr::ResolutionError] the document does not contain the path this pointer references
      def evaluate(document, *a, **kw)
        res = tokens.inject(document) do |value, token|
          _, child = node_subscript_token_child(value, token, *a, **kw)
          child
        end
        res
      end

      # the pointer string representation of this pointer
      # @return [String]
      def pointer
        tokens.map { |t| '/' + t.to_s.gsub('~', '~0').gsub('/', '~1') }.join('')
      end

      # the fragment string representation of this pointer
      # @return [String]
      def fragment
        Addressable::URI.escape(pointer)
      end

      # a URI consisting of a fragment containing this pointer's fragment string representation
      # @return [Addressable::URI]
      def uri
        Addressable::URI.new(fragment: fragment).freeze
      end

      # whether this pointer is empty, i.e. it has no tokens
      # @return [Boolean]
      def empty?
        tokens.empty?
      end

      # whether this is a root pointer, indicated by an empty array of tokens
      # @return [Boolean]
      alias_method :root?, :empty?

      # pointer to the parent of where this pointer points
      # @return [JSI::Ptr]
      # @raise [JSI::Ptr::Error] if this pointer has no parent (points to the root)
      def parent
        if root?
          raise(Ptr::Error, "cannot access parent of root pointer: #{pretty_inspect.chomp}")
        end
        Ptr.new(tokens[0...-1])
      end

      # whether this pointer contains the other_ptr - that is, whether this pointer is an ancestor
      # of `other_ptr`, a descendent pointer. `contains?` is inclusive; a pointer does contain itself.
      # @return [Boolean]
      def contains?(other_ptr)
        tokens == other_ptr.tokens[0...tokens.size]
      end

      # part of this pointer relative to the given ancestor_ptr
      # @return [JSI::Ptr]
      # @raise [JSI::Ptr::Error] if the given ancestor_ptr is not an ancestor of this pointer
      def relative_to(ancestor_ptr)
        unless ancestor_ptr.contains?(self)
          raise(Error, "ancestor_ptr #{ancestor_ptr.inspect} is not ancestor of #{inspect}")
        end
        Ptr.new(tokens[ancestor_ptr.tokens.size..-1])
      end

      # a pointer with the tokens of this one plus the given `ptr`'s.
      # @param ptr [JSI::Ptr, #to_ary]
      # @return [JSI::Ptr]
      def +(ptr)
        if ptr.is_a?(Ptr)
          ptr_tokens = ptr.tokens
        elsif ptr.respond_to?(:to_ary)
          ptr_tokens = ptr
        else
          raise(TypeError, "ptr must be a #{Ptr} or Array of tokens; got: #{ptr.inspect}")
        end
        Ptr.new(tokens + ptr_tokens)
      end

      # a pointer consisting of the first `n` of our tokens
      # @param n [Integer]
      # @return [JSI::Ptr]
      # @raise [ArgumentError] if n is not between 0 and the size of our tokens
      def take(n)
        unless n.is_a?(Integer) && n >= 0 && n <= tokens.size
          raise(ArgumentError, "n not in range (0..#{tokens.size}): #{n.inspect}")
        end
        Ptr.new(tokens.take(n))
      end

      # appends the given token to this pointer's tokens and returns the result
      #
      # @param token [Object]
      # @return [JSI::Ptr] pointer to a child node of this pointer with the given token
      def [](token)
        Ptr.new(tokens.dup.push(token))
      end

      # takes a document and a block. the block is yielded the content of the given document at this
      # pointer's location. the block must result a modified copy of that content (and MUST NOT modify
      # the object it is given). this modified copy of that content is incorporated into a modified copy
      # of the given document, which is then returned. the structure and contents of the document outside
      # the path pointed to by this pointer is not modified.
      #
      # @param document [Object] the document to apply this pointer to
      # @yield [Object] the content this pointer applies to in the given document
      #   the block must result in the new content which will be placed in the modified document copy.
      # @return [Object] a copy of the given document, with the content this pointer applies to
      #   replaced by the result of the block
      def modified_document_copy(document, &block)
        # we need to preserve the rest of the document, but modify the content at our path.
        #
        # this is actually a bit tricky. we can't modify the original document, obviously.
        # we could do a deep copy, but that's expensive. instead, we make a copy of each array
        # or hash in the path above the node we point to. this node's content is modified by the
        # caller, and that is recursively merged up to the document root.
        if empty?
          Util.modified_copy(document, &block)
        else
          car = tokens[0]
          cdr = Ptr.new(tokens[1..-1])
          token, document_child = node_subscript_token_child(document, car)
          modified_document_child = cdr.modified_document_copy(document_child, &block)
          if modified_document_child.object_id == document_child.object_id
            document
          else
            modified_document = document.respond_to?(:[]=) ? document.dup :
              document.respond_to?(:to_hash) ? document.to_hash.dup :
              document.respond_to?(:to_ary) ? document.to_ary.dup :
              raise(Bug) # not possible; node_subscript_token_child would have raised
            modified_document[token] = modified_document_child
            modified_document
          end
        end
      end

      # a string representation of this pointer
      # @return [String]
      def inspect
        "#{self.class.name}[#{tokens.map(&:inspect).join(", ")}]"
      end

      alias_method :to_s, :inspect

      # see {Util::Private::FingerprintHash}
      # @api private
      def jsi_fingerprint
        {class: Ptr, tokens: tokens}
      end
      include Util::FingerprintHash

      private

      def node_subscript_token_child(value, token, *a, **kw)
        if value.respond_to?(:to_ary)
          if token.is_a?(String) && token =~ /\A\d|[1-9]\d+\z/
            token = token.to_i
          elsif token == '-'
            # per rfc6901, - refers "to the (nonexistent) member after the last array element" and is
            # expected to raise an error condition.
            raise(ResolutionError, "Invalid resolution: #{token.inspect} refers to a nonexistent element in array #{value.inspect}")
          end
          unless token.is_a?(Integer)
            raise(ResolutionError, "Invalid resolution: #{token.inspect} is not an integer and cannot be resolved in array #{value.inspect}")
          end
          unless (0...(value.respond_to?(:size) ? value : value.to_ary).size).include?(token)
            raise(ResolutionError, "Invalid resolution: #{token.inspect} is not a valid index of #{value.inspect}")
          end

          ary = (value.respond_to?(:[]) ? value : value.to_ary)
          if kw.empty?
            # TODO remove eventually (keyword argument compatibility)
            child = ary[token, *a]
          else
            child = ary[token, *a, **kw]
          end
        elsif value.respond_to?(:to_hash)
          unless (value.respond_to?(:key?) ? value : value.to_hash).key?(token)
            raise(ResolutionError, "Invalid resolution: #{token.inspect} is not a valid key of #{value.inspect}")
          end

          hsh = (value.respond_to?(:[]) ? value : value.to_hash)
          if kw.empty?
            # TODO remove eventually (keyword argument compatibility)
            child = hsh[token, *a]
          else
            child = hsh[token, *a, **kw]
          end
        else
          raise(ResolutionError, "Invalid resolution: #{token.inspect} cannot be resolved in #{value.inspect}")
        end
        [token, child]
      end
    end
end

1	# frozen_string_literal: true
2
3	module JSI	42✔
4	# a representation to work with JSON Pointer, as described by RFC 6901 https://tools.ietf.org/html/rfc6901
5	#
6	# a pointer is a sequence of tokens pointing to a node in a document.
7	class Ptr	42✔
8	class Error < StandardError	42✔
9	end
10
11	# raised when attempting to parse a JSON Pointer string with invalid syntax
12	class PointerSyntaxError < Error	42✔
13	end
14
15	# raised when a pointer refers to a path in a document that could not be resolved
16	class ResolutionError < Error	42✔
17	end
18
19	# instantiates a pointer or returns the given pointer
20	# @param ary_ptr [#to_ary, JSI::Ptr] an array of tokens, or a pointer
21	# @return [JSI::Ptr]
22	def self.ary_ptr(ary_ptr)	42✔
23	if ary_ptr.is_a?(Ptr)	1,348,456✔
24	ary_ptr	105,278✔
25	else
26	new(ary_ptr)	1,243,178✔
27	end
28	end
29
30	# instantiates a pointer from the given tokens.
31	#
32	# JSI::Ptr[]
33	#
34	# instantiates a root pointer.
35	#
36	# JSI::Ptr['a', 'b']
37	# JSI::Ptr['a']['b']
38	#
39	# are both ways to instantiate a pointer with tokens ['a', 'b']. the latter example chains the
40	# class .[] method with the instance #[] method.
41	#
42	# @param tokens any number of tokens
43	# @return [JSI::Ptr]
44	def self.[](*tokens)	42✔
45	tokens.empty? ? EMPTY : new(tokens)	328,728✔
46	end
47
48	# parse a URI-escaped fragment and instantiate as a JSI::Ptr
49	#
50	# JSI::Ptr.from_fragment('/foo/bar')
51	# => JSI::Ptr["foo", "bar"]
52	#
53	# with URI escaping:
54	#
55	# JSI::Ptr.from_fragment('/foo%20bar')
56	# => JSI::Ptr["foo bar"]
57	#
58	# Note: A fragment does not include a leading '#'. The string "#/foo" is a URI containing the
59	# fragment "/foo", which should be parsed by `Addressable::URI` before passing to this method, e.g.:
60	#
61	# JSI::Ptr.from_fragment(Addressable::URI.parse("#/foo").fragment)
62	# => JSI::Ptr["foo"]
63	#
64	# @param fragment [String] a fragment containing a pointer
65	# @return [JSI::Ptr]
66	# @raise [JSI::Ptr::PointerSyntaxError] when the fragment does not contain a pointer with
67	# valid pointer syntax
68	def self.from_fragment(fragment)	42✔
69	from_pointer(Addressable::URI.unescape(fragment))	60,284✔
70	end
71
72	# parse a pointer string and instantiate as a JSI::Ptr
73	#
74	# JSI::Ptr.from_pointer('/foo')
75	# => JSI::Ptr["foo"]
76	#
77	# JSI::Ptr.from_pointer('/foo~0bar/baz~1qux')
78	# => JSI::Ptr["foo~bar", "baz/qux"]
79	#
80	# @param pointer_string [String] a pointer string
81	# @return [JSI::Ptr]
82	# @raise [JSI::Ptr::PointerSyntaxError] when the pointer_string does not have valid pointer syntax
83	def self.from_pointer(pointer_string)	42✔
84	pointer_string = pointer_string.to_str	60,466✔
85	if pointer_string[0] == ?/	60,466✔
86	tokens = pointer_string.split('/', -1).map! do \|piece\|	17,276✔
87	piece.gsub('~1', '/').gsub('~0', '~')	51,646✔
88	end
89	tokens.shift	17,276✔
90	new(tokens)	17,276✔
91	elsif pointer_string.empty?	43,184✔
92	EMPTY	42,966✔
93	else
94	raise(PointerSyntaxError, "Invalid pointer syntax in #{pointer_string.inspect}: pointer must begin with /")	288✔
95	end
96	end
97
98	# initializes a JSI::Ptr from the given tokens.
99	#
100	# @param tokens [Array<Object>]
101	def initialize(tokens)	42✔
102	unless tokens.respond_to?(:to_ary)	1,922,946✔
103	raise(TypeError, "tokens must be an array. got: #{tokens.inspect}")	36✔
104	end
105	@tokens = tokens.to_ary.map(&:freeze).freeze	1,922,918✔
106	end
107
108	EMPTY = new(Util::EMPTY_ARY)	42✔
109
110	attr_reader :tokens	42✔
111
112	# takes a root json document and evaluates this pointer through the document, returning the value
113	# pointed to by this pointer.
114	#
115	# @param document [#to_ary, #to_hash] the document against which we will evaluate this pointer
116	# @param a arguments are passed to each invocation of `#[]`
117	# @return [Object] the content of the document pointed to by this pointer
118	# @raise [JSI::Ptr::ResolutionError] the document does not contain the path this pointer references
119	def evaluate(document, a, *kw)	42✔
120	res = tokens.inject(document) do \|value, token\|	42,604,928✔
121	_, child = node_subscript_token_child(value, token, a, *kw)	76,624,088✔
122	child	76,623,990✔
123	end
124	res	42,604,830✔
125	end
126
127	# the pointer string representation of this pointer
128	# @return [String]
129	def pointer	42✔
130	tokens.map { \|t\| '/' + t.to_s.gsub('~', '~0').gsub('/', '~1') }.join('')	127,162✔
131	end
132
133	# the fragment string representation of this pointer
134	# @return [String]
135	def fragment	42✔
136	Addressable::URI.escape(pointer)	1,092✔
137	end
138
139	# a URI consisting of a fragment containing this pointer's fragment string representation
140	# @return [Addressable::URI]
141	def uri	42✔
142	Addressable::URI.new(fragment: fragment).freeze	448✔
143	end
144
145	# whether this pointer is empty, i.e. it has no tokens
146	# @return [Boolean]
147	def empty?	42✔
148	tokens.empty?	1,004,808✔
149	end
150
151	# whether this is a root pointer, indicated by an empty array of tokens
152	# @return [Boolean]
153	alias_method :root?, :empty?	42✔
154
155	# pointer to the parent of where this pointer points
156	# @return [JSI::Ptr]
157	# @raise [JSI::Ptr::Error] if this pointer has no parent (points to the root)
158	def parent	42✔
159	if root?	70✔
160	raise(Ptr::Error, "cannot access parent of root pointer: #{pretty_inspect.chomp}")	18✔
161	end
162	Ptr.new(tokens[0...-1])	56✔
163	end
164
165	# whether this pointer contains the other_ptr - that is, whether this pointer is an ancestor
166	# of `other_ptr`, a descendent pointer. `contains?` is inclusive; a pointer does contain itself.
167	# @return [Boolean]
168	def contains?(other_ptr)	42✔
169	tokens == other_ptr.tokens[0...tokens.size]	248,520✔
170	end
171
172	# part of this pointer relative to the given ancestor_ptr
173	# @return [JSI::Ptr]
174	# @raise [JSI::Ptr::Error] if the given ancestor_ptr is not an ancestor of this pointer
175	def relative_to(ancestor_ptr)	42✔
176	unless ancestor_ptr.contains?(self)	24,276✔
177	raise(Error, "ancestor_ptr #{ancestor_ptr.inspect} is not ancestor of #{inspect}")	22✔
178	end
179	Ptr.new(tokens[ancestor_ptr.tokens.size..-1])	24,262✔
180	end
181
182	# a pointer with the tokens of this one plus the given `ptr`'s.
183	# @param ptr [JSI::Ptr, #to_ary]
184	# @return [JSI::Ptr]
185	def +(ptr)	42✔
186	if ptr.is_a?(Ptr)	105,546✔
187	ptr_tokens = ptr.tokens	105,546✔
188	elsif ptr.respond_to?(:to_ary)
189	ptr_tokens = ptr	×
190	else
191	raise(TypeError, "ptr must be a #{Ptr} or Array of tokens; got: #{ptr.inspect}")	×
192	end
193	Ptr.new(tokens + ptr_tokens)	105,546✔
194	end
195
196	# a pointer consisting of the first `n` of our tokens
197	# @param n [Integer]
198	# @return [JSI::Ptr]
199	# @raise [ArgumentError] if n is not between 0 and the size of our tokens
200	def take(n)	42✔
NEW 201	unless n.is_a?(Integer) && n >= 0 && n <= tokens.size	×
202	raise(ArgumentError, "n not in range (0..#{tokens.size}): #{n.inspect}")	×
203	end
204	Ptr.new(tokens.take(n))	×
205	end
206
207	# appends the given token to this pointer's tokens and returns the result
208	#
209	# @param token [Object]
210	# @return [JSI::Ptr] pointer to a child node of this pointer with the given token
211	def [](token)	42✔
212	Ptr.new(tokens.dup.push(token))	531,004✔
213	end
214
215	# takes a document and a block. the block is yielded the content of the given document at this
216	# pointer's location. the block must result a modified copy of that content (and MUST NOT modify
217	# the object it is given). this modified copy of that content is incorporated into a modified copy
218	# of the given document, which is then returned. the structure and contents of the document outside
219	# the path pointed to by this pointer is not modified.
220	#
221	# @param document [Object] the document to apply this pointer to
222	# @yield [Object] the content this pointer applies to in the given document
223	# the block must result in the new content which will be placed in the modified document copy.
224	# @return [Object] a copy of the given document, with the content this pointer applies to
225	# replaced by the result of the block
226	def modified_document_copy(document, &block)	42✔
227	# we need to preserve the rest of the document, but modify the content at our path.
228	#
229	# this is actually a bit tricky. we can't modify the original document, obviously.
230	# we could do a deep copy, but that's expensive. instead, we make a copy of each array
231	# or hash in the path above the node we point to. this node's content is modified by the
232	# caller, and that is recursively merged up to the document root.
233	if empty?	1,790✔
234	Util.modified_copy(document, &block)	740✔
235	else
236	car = tokens[0]	1,050✔
237	cdr = Ptr.new(tokens[1..-1])	1,050✔
238	token, document_child = node_subscript_token_child(document, car)	1,050✔
239	modified_document_child = cdr.modified_document_copy(document_child, &block)	1,050✔
240	if modified_document_child.object_id == document_child.object_id	1,050✔
241	document	574✔
242	else
243	modified_document = document.respond_to?(:[]=) ? document.dup :	612✔
244	document.respond_to?(:to_hash) ? document.to_hash.dup :	26✔
245	document.respond_to?(:to_ary) ? document.to_ary.dup :	12✔
246	raise(Bug) # not possible; node_subscript_token_child would have raised
247	modified_document[token] = modified_document_child	476✔
248	modified_document	476✔
249	end
250	end
251	end
252
253	# a string representation of this pointer
254	# @return [String]
255	def inspect	42✔
256	"#{self.class.name}[#{tokens.map(&:inspect).join(", ")}]"	66✔
257	end
258
259	alias_method :to_s, :inspect	42✔
260
261	# see {Util::Private::FingerprintHash}
262	# @api private
263	def jsi_fingerprint	42✔
264	{class: Ptr, tokens: tokens}	35,215,484✔
265	end
266	include Util::FingerprintHash	42✔
267
268	private	42✔
269
270	def node_subscript_token_child(value, token, a, *kw)	42✔
271	if value.respond_to?(:to_ary)	76,625,138✔
272	if token.is_a?(String) && token =~ /\A\d\|[1-9]\d+\z/	6,790,178✔
273	token = token.to_i	112✔
274	elsif token == '-'	6,790,060✔
275	# per rfc6901, - refers "to the (nonexistent) member after the last array element" and is
276	# expected to raise an error condition.
277	raise(ResolutionError, "Invalid resolution: #{token.inspect} refers to a nonexistent element in array #{value.inspect}")	22✔
278	end
279	unless token.is_a?(Integer)	6,790,164✔
280	raise(ResolutionError, "Invalid resolution: #{token.inspect} is not an integer and cannot be resolved in array #{value.inspect}")	44✔
281	end
282	unless (0...(value.respond_to?(:size) ? value : value.to_ary).size).include?(token)	10,645,552✔
283	raise(ResolutionError, "Invalid resolution: #{token.inspect} is not a valid index of #{value.inspect}")	22✔
284	end
285
286	ary = (value.respond_to?(:[]) ? value : value.to_ary)	8,717,826✔
287	if kw.empty?	6,790,122✔
288	# TODO remove eventually (keyword argument compatibility)
289	child = ary[token, *a]	6,771,908✔
290	else
291	child = ary[token, a, *kw]	18,214✔
292	end
293	elsif value.respond_to?(:to_hash)	69,834,954✔
294	unless (value.respond_to?(:key?) ? value : value.to_hash).key?(token)	89,700,398✔
295	raise(ResolutionError, "Invalid resolution: #{token.inspect} is not a valid key of #{value.inspect}")	44✔
296	end
297
298	hsh = (value.respond_to?(:[]) ? value : value.to_hash)	89,700,362✔
299	if kw.empty?	69,834,918✔
300	# TODO remove eventually (keyword argument compatibility)
301	child = hsh[token, *a]	69,770,980✔
302	else
303	child = hsh[token, a, *kw]	63,938✔
304	end
305	else
306	raise(ResolutionError, "Invalid resolution: #{token.inspect} cannot be resolved in #{value.inspect}")	22✔
307	end
308	[token, child]	76,625,040✔
309	end
310	end
311	end

notEthan / jsi / 5106848293

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous