lazy_graph 0.1.2 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29043baea3639e83c226d8e157af818466d50d4e3c125853dac64ae411aa0c0a
-  data.tar.gz: f137caa57317cd9046bc16384bf657ca7c43d10b12701f30be6bc7a31580c6db
+  metadata.gz: 2cb285016525832f149dd41b91340c71f6f6c68d7aebcc0de6376dbf81c71cd8
+  data.tar.gz: fc0bee81e2e2b45dfad51c822c421d0496bda877d8e77598d29875b66f261286
 SHA512:
-  metadata.gz: b1c5107a005882da016caa1fd54afa5131f296637fd6a7b18810d3b2c1f18893ae11938e63fc42ceec05def4ceba76afbe016b152d1c107225af148b06f6db52
-  data.tar.gz: b5a2126ac97b38e1e0d4ce23a1d46859a89979b0b09a2d3ad3e3676b763d6277745310ee08a0c49fbbc85bcd930d246362bd79793899726c2f763b0aa1f6fe44
+  metadata.gz: 0d156ef5344d260232771fa272d5a318342a46293a5991abb9c47948fd0b79c096f2f1f219cf9383a677435ec0e9e9f1bc95011b254d9828e2b19b86f991a5fe
+  data.tar.gz: e9c44f0ff222e41ad1992703b3f8adf1a4424f073bc80b89bb1d0f85f515fbe8413d023f9072141fbeaff5b242bf9e91fd415c43b8445cc10d2754a17af73b0a

data/examples/performance_tests.rb

@@ -13,9 +13,9 @@ class PerformanceBuilder < LazyGraph::Builder
         string :pay_schedule_id, invisible: true
         string :position_id, invisible: true
 
-        object :position, rule: :"${$.positions[position_id]}"
-        object :pay_schedule, rule: :'${pay_schedules[pay_schedule_id]}'
-        number :pay_rate, rule: :"${position.pay_rate}"
+        object :position, rule: :"$.positions[position_id]"
+        object :pay_schedule, rule: :'pay_schedules[pay_schedule_id]'
+        number :pay_rate, rule: :"position.pay_rate"
         string :employee_id, rule: :id
       end
     end
@@ -67,7 +67,7 @@ def profile_n(n, debug: false, validate: false)
   graph = PerformanceBuilder.performance.build!(debug: debug, validate: validate)
   Vernier.profile(out: './examples/time_profile.json') do
     start = Time.now
-    graph.context(employees).query('')
+    graph.context(employees).get('')
     ends = Time.now
     puts "Time elapsed: #{ends - start}"
   end
@@ -77,7 +77,7 @@ def memory_profile_n(n, debug: false, validate: false)
   employees = gen_employees(n)
   graph = PerformanceBuilder.performance.build!(debug: debug, validate: validate)
   report = MemoryProfiler.report do
-    graph.context(employees).query('')
+    graph.context(employees).get('')
   end
   report.pretty_print
 end
@@ -87,7 +87,7 @@ def benchmark_ips_n(n, debug: false, validate: false)
   employees = gen_employees(n)
   Benchmark.ips do |x|
     x.report('performance') do
-      graph.context(employees).query('')
+      graph.context(employees).get('')
     end
     x.compare!
   end
@@ -97,7 +97,7 @@ def console_n(n, debug: false, validate: false)
   require 'debug'
   graph = PerformanceBuilder.performance.build!(debug: debug, validate: validate)
   employees = gen_employees(n)
-  result = graph.context(employees).query('')
+  result = graph.context(employees).get('')
   binding.b
 end
 

data/lib/lazy_graph/builder/dsl.rb

@@ -76,7 +76,6 @@ module LazyGraph
         }
         @prev_match_cases = @match_cases
         @match_cases = []
-
         yields(new_object, &blk)
 
         object_names = @match_cases.map do |match_case|

data/lib/lazy_graph/builder.rb

@@ -10,11 +10,11 @@ module LazyGraph
     # Cache up to a fixed number of graphs, context and queries
     BUILD_CACHE_CONFIG = {
       # Store up to 1000 graphs
-      graph: {size: 1000, cache: {}},
+      graph: {size: ENV.fetch('LAZY_GRAPH_GRAPH_CACHE_MAX_ENTRIES', 1000).to_i, cache: {}},
       # Store up to 5000 configs
-      context: {size: 5000, cache: {}},
+      context: {size: ENV.fetch('LAZY_GRAPH_CONTEXT_CACHE_MAX_ENTRIES', 5000).to_i, cache: {}},
       # Store up to 5000 queries
-      query: {size: 5000, cache: {}}
+      query: {size: ENV.fetch('LAZY_GRAPH_QUERY_CACHE_MAX_ENTRIES', 5000).to_i, cache: {}}
     }.compare_by_identity.freeze
 
     include DSL
@@ -23,10 +23,16 @@ module LazyGraph
     attr_accessor :schema
 
     def initialize(schema: { type: 'object', properties: {} }) = @schema = schema
-    def build!(debug: false, validate: false) = @schema.to_lazy_graph(debug: debug, validate: validate, helpers: self.class.helper_modules)
     def context(value, debug: false, validate: false) = build!(debug: debug, validate: validate).context(value)
     def eval!(context, *value, debug: false, validate: false) = context(context, validate: validate, debug: debug).query(*value)
 
+    def build!(debug: false, validate: false) = @schema.to_lazy_graph(
+      debug: debug,
+      validate: validate,
+      helpers: self.class.helper_modules,
+      namespace: self.class
+    )
+
     def self.rules_module(name, schema = { type: 'object', properties: {} }, &blk)
       rules_modules[:properties][name.to_sym] = { type: :object, properties: schema }
       module_body_func_name = :"_#{name}"
@@ -106,14 +112,15 @@ module LazyGraph
         evaluate_context(builder, context, debug: debug, validate: validate)
       end
 
-      return context_result if context_result.is_a?(Hash) && context_result[:type] == :error
+      return context_result if context_result.is_a?(Hash) && context_result[:type].equal?(:error)
 
-      query_result = cache_as(:query, [context_result, query]){ context_result.query(*(query || '')) }
+      cache_as(:query, [context_result, query]) do
+        HashUtils.strip_missing({
+          type: :success,
+          result: context_result.resolve(*(query || ''))
+        })
+      end
 
-      {
-        type: :success,
-        result: query_result
-      }
     rescue SystemStackError => e
       LazyGraph.logger.error(e.message)
       LazyGraph.logger.error(e.backtrace.join("\n"))
@@ -157,14 +164,14 @@ module LazyGraph
       end
     rescue ArgumentError => e
       format_error_response('Invalid Module Argument', e.message)
-      LazyGraph.logger.error(e.backtrace)
+      LazyGraph.logger.error(e.backtrace.join("\n"))
     end
 
     private_class_method def self.evaluate_context(builder, context, debug: false, validate: false)
       builder.context(context, debug: debug, validate: validate)
     rescue ArgumentError => e
       format_error_response('Invalid Context Input', e.message)
-      LazyGraph.logger.error(e.backtrace)
+      LazyGraph.logger.error(e.backtrace.join("\n"))
     end
   end
 end

data/lib/lazy_graph/builder_group.rb

@@ -29,10 +29,12 @@ module LazyGraph
             )
           end
 
-          base.define_singleton_method(:reload_lazy_graphs!) do
-            each_builder do |builder|
-              builder.clear_rules_modules!
-              builder.clear_helper_modules!
+          base.define_singleton_method(:reload_lazy_graphs!) do |clear_previous: false|
+            if clear_previous
+              each_builder do |builder|
+                builder.clear_rules_modules!
+                builder.clear_helper_modules!
+              end
             end
 
             reload_paths.flat_map { |p| Dir[p] }.each do |file|
@@ -42,13 +44,13 @@ module LazyGraph
             end
           end
 
-          base.reload_lazy_graphs!
+          base.reload_lazy_graphs! if reload_paths.any?
 
           return unless listen
 
           require 'listen'
           Listen.to(*reload_paths.map { |p| p.gsub(%r{(?:/\*\*)*/\*\.rb}, '') }) do
-            base.reload_lazy_graphs!
+            base.reload_lazy_graphs!(clear_previous: true)
           end.start
         end
       end

data/lib/lazy_graph/context.rb

@@ -11,17 +11,34 @@ module LazyGraph
       graph.validate!(input) if [true, 'input'].include?(graph.validate)
       @graph = graph
       @input = input
+      @graph.root_node.properties.each_key do |key|
+        define_singleton_method(key) { get(key) }
+      end
     end
 
-    def query(paths)
-      paths.is_a?(Array) ? paths.map { |path| resolve(path) } : resolve(paths)
+    def get_json(path)
+      HashUtils.strip_missing(get(path))
+    end
+
+    def get(path)
+      result = resolve(path)
+      raise AbortError, result[:err], cause: result[:error] if result[:err]
+
+      result[:output]
+    end
+
+    def debug(path)
+      result = resolve(path)
+      raise AbortError, result[:err], cause: result[:error] if result[:err]
+
+      result[:debug_trace]
     end
 
     def resolve(path)
       @input = @graph.root_node.fetch_item({ input: @input }, :input, nil)
 
-      query = PathParser.parse(path, true)
-      stack = StackPointer.new(nil, @input, 0, :'$', nil)
+      query = PathParser.parse(path, strip_root: true)
+      stack = StackPointer.new(nil, @input, 0, 0, :'$', nil)
       stack.root = stack
 
       result = @graph.root_node.resolve(query, stack)
@@ -32,18 +49,18 @@ module LazyGraph
         stack.frame[:DEBUG] = nil
       end
       {
-        output: HashUtils.strip_invalid(result),
-        debug_trace: HashUtils.strip_invalid(debug_trace)
+        output: result,
+        debug_trace: debug_trace
       }
     rescue LazyGraph::AbortError => e
       {
-        output: { err: e.message, status: :abort }
+        output: nil, err: e.message, status: :abort, error: e
       }
     rescue StandardError => e
       LazyGraph.logger.error(e.message)
-      LazyGraph.logger.error(e.backtrace)
+      LazyGraph.logger.error(e.backtrace.join("\n"))
       {
-        output: { err: e.message, backtrace: e.backtrace }
+        output: nil, err: e.message, backtrace: e.backtrace, error: e
       }
     end
 
@@ -54,9 +71,13 @@ module LazyGraph
           q.text 'graph='
           q.pp(@graph)
         end
+        q.group do
+          q.text 'input='
+          q.pp(@input)
+        end
       end
     end
 
-    alias [] query
+    alias [] get
   end
 end

data/lib/lazy_graph/graph.rb

@@ -13,7 +13,7 @@ module LazyGraph
     def context(input) = Context.new(self, input)
     def debug? = @debug
 
-    def initialize(input_schema, debug: false, validate: true, helpers: nil)
+    def initialize(input_schema, debug: false, validate: true, helpers: nil, namespace: nil)
       @json_schema = HashUtils.deep_dup(input_schema, symbolize: true, signature: signature = [0]).merge(type: :object)
       @debug = debug
       @validate = validate
@@ -25,18 +25,20 @@ module LazyGraph
         raise ArgumentError, 'Root schema must be a non-empty object'
       end
 
-      @root_node = build_node(@json_schema)
+      @root_node = build_node(@json_schema, namespace: namespace)
+      @root_node.build_derived_inputs!
     end
 
-    def build_node(schema, path = :'$', name = :root, parent = nil)
+    def build_node(schema, path = :'$', name = :root, parent = nil, namespace: nil)
       schema[:type] = schema[:type].to_sym
-      node = case schema[:type]
-             when :object then ObjectNode
-             when :array then ArrayNode
-             else Node
-             end.new(name, path, schema, parent, debug: @debug, helpers: @helpers)
+      node = \
+        case schema[:type]
+        when :object then ObjectNode
+        when :array then ArrayNode
+        else Node
+        end.new(name, path, schema, parent, debug: @debug, helpers: @helpers, namespace: namespace)
 
-      if node.type == :object
+      if node.type.equal?(:object)
         node.children = \
           {
             properties: schema.fetch(:properties, {}).map do |key, value|
@@ -46,7 +48,7 @@ module LazyGraph
               [Regexp.new(key.to_s), build_node(value, :"#{path}.#{key}", :'<property>', node)]
             end
           }
-      elsif node.type == :array
+      elsif node.type.equal?(:array)
         node.children = build_node(schema.fetch(:items, {}), :"#{path}[]", :items, node)
       end
       node
@@ -54,6 +56,18 @@ module LazyGraph
 
     def validate!(input, schema = @json_schema)
       JSON::Validator.validate!(schema, input)
+    rescue JSON::Schema::ValidationError => e
+      raise AbortError, "Input validation failed: #{e.message}", cause: e
+    end
+
+    def pretty_print(q)
+      # Start the custom pretty print
+      q.group(1, '<LazyGraph::Graph ', '>') do
+        q.group do
+          q.text 'props='
+          q.text root_node.children[:properties].keys
+        end
+      end
     end
   end
 

data/lib/lazy_graph/hash_utils.rb

@@ -20,6 +20,8 @@ module LazyGraph
           signature[0] ^= key.object_id if signature
           result[key] = deep_dup(value, symbolize: symbolize, signature: signature)
         end
+      when Struct
+        deep_dup(obj.to_h, symbolize: symbolize, signature: signature)
       when Array
         obj.map { |value| deep_dup(value, symbolize: symbolize, signature: signature) }
       when String, Numeric, TrueClass, FalseClass, NilClass
@@ -47,7 +49,7 @@ module LazyGraph
       end
     end
 
-    def strip_invalid(obj, parent_list = {}.compare_by_identity)
+    def strip_missing(obj, parent_list = {}.compare_by_identity)
       return { '^ref': :circular } if (circular_dependency = parent_list[obj])
 
       parent_list[obj] = true
@@ -56,17 +58,17 @@ module LazyGraph
         obj.each_with_object({}) do |(key, value), obj|
           next if value.is_a?(MissingValue)
 
-          obj[key] = strip_invalid(value, parent_list)
+          obj[key] = strip_missing(value, parent_list)
         end
       when Struct
         obj.members.each_with_object({}) do |key, res|
           next if obj[key].is_a?(MissingValue)
           next if obj.invisible.include?(key)
 
-          res[key] = strip_invalid(obj[key], parent_list)
+          res[key] = strip_missing(obj[key], parent_list)
         end
       when Array
-        obj.map { |value| strip_invalid(value, parent_list) }
+        obj.map { |value| strip_missing(value, parent_list) }
       when MissingValue
         nil
       else

data/lib/lazy_graph/missing_value.rb

@@ -8,12 +8,11 @@ module LazyGraph
 
     def initialize(details) = @details = details
     def to_s = "MISSING[#{@details}]"
-
     def inspect = to_s
     def coerce(other) = [self, other]
     def as_json = nil
+    def to_h = nil
     def +(other) = other
-
     def respond_to_missing?(_method_name, _include_private = false) = true
 
     def method_missing(method, *args, &block)

data/lib/lazy_graph/node/array_node.rb

@@ -16,40 +16,35 @@ module LazyGraph
     )
       input = stack_memory.frame
       @visited[input.object_id >> 2 ^ path.shifted_id] ||= begin
+        path_next = path.next
         if (path_segment = path.segment).is_a?(PathParser::PathGroup)
           unless path_segment.index?
             return input.length.times.map do |index|
-              item = children.fetch_item(input, index, stack_memory)
-              children.resolve(path, stack_memory.push(item, index))
+              children.fetch_and_resolve(path, input, index, stack_memory)
             end
           end
 
-          return resolve(path_segment.options.first.merge(path.next), stack_memory, nil) if path_segment.options.one?
+          return resolve(path_segment.options.first.merge(path_next), stack_memory, nil) if path_segment.options.one?
 
-          return path_segment.options.map { |part| resolve(part.merge(path.next), stack_memory, nil) }
+          return path_segment.options.map { |part| resolve(part.merge(path_next), stack_memory, nil) }
         end
 
         segment = path_segment&.part
         case segment
         when nil
-          input.length.times do |index|
-            item = children.fetch_item(input, index, stack_memory)
-            children.resolve(path, stack_memory.push(item, index))
+
+          unless @children.simple?
+            input.length.times do |index|
+              @children.fetch_and_resolve(path, input, index, stack_memory)
+            end
           end
           input
         when DIGIT_REGEXP
-          item = @children.fetch_item(input, segment.to_s.to_i, stack_memory)
-          children.resolve(path.next, stack_memory.push(item, segment))
-        when :*
-          input.length.times.map do |index|
-            item = children.fetch_item(input, index, stack_memory)
-            @children.resolve(path.next, stack_memory.push(item, index))
-          end
+          @children.fetch_and_resolve(path_next, input, segment.to_s.to_i, stack_memory)
         else
           if @child_properties&.key?(segment) || input&.first&.key?(segment)
             input.length.times.map do |index|
-              item = children.fetch_item(input, index, stack_memory)
-              @children.resolve(path, stack_memory.push(item, index))
+              @children.fetch_and_resolve(path, input, index, stack_memory)
             end
           else
             MissingValue()

data/lib/lazy_graph/node/derived_rules.rb

@@ -25,6 +25,7 @@ module LazyGraph
       def build_derived_inputs(derived, helpers)
         @resolvers = {}.compare_by_identity
         @path_cache = {}.compare_by_identity
+        @resolution_stack = {}.compare_by_identity
 
         derived = interpret_derived_proc(derived) if derived.is_a?(Proc)
         derived = { inputs: derived.to_s } if derived.is_a?(String) || derived.is_a?(Symbol)
@@ -124,7 +125,7 @@ module LazyGraph
         @derived_proc_cache[source_location]
       rescue StandardError => e
         LazyGraph.logger.error(e.message)
-        LazyGraph.logger.error(e.backtrace)
+        LazyGraph.logger.error(e.backtrace.join("\n"))
         raise "Failed to extract expression from source location: #{source_location}. Ensure the file exists and the line number is correct. Extraction from a REPL is not supported"
       end
 
@@ -167,9 +168,8 @@ module LazyGraph
 
       def parse_rule_string(derived)
         calc_str = derived[:calc]
-        src = @src
         instance_eval(
-          "->{ begin; #{calc_str}; rescue StandardError => e; LazyGraph.logger.error(\"Exception in \#{src}. \#{e.message}\"); LazyGraph.logger.error(e.backtrace.join(\"\\n\")); raise; end  }", __FILE__, __LINE__
+          "->{ begin; #{calc_str}; rescue StandardError => e; LazyGraph.logger.error(\"Exception in \#{calc_str}. \#{e.message}\"); LazyGraph.logger.error(e.backtrace.join(\"\\n\")); raise; end  }", __FILE__, __LINE__
         )
       rescue SyntaxError
         missing_value = MissingValue { "Syntax error in #{derived[:src]}" }
@@ -194,12 +194,25 @@ module LazyGraph
         end.new
       end
 
+      def resolver_for(path)
+        segment = path.segment.part
+        return root.properties[path.next.segment.part] if segment == :'$'
+
+        (segment == name ? parent.parent : @parent).find_resolver_for(segment)
+      end
+
       def map_derived_inputs_to_paths(inputs)
         inputs.values.map.with_index do |path, idx|
-          segment_indexes = path.parts.map.with_index do |segment, i|
-            segment.is_a?(PathParser::PathGroup) && segment.options.length == 1 ? i : nil
+          segments = path.parts.map.with_index do |segment, i|
+            if segment.is_a?(PathParser::PathGroup) &&
+               segment.options.length == 1 &&
+               (resolver = resolver_for(segment.options.first))
+              [i, resolver]
+            else
+              nil
+            end
           end.compact
-          [path, idx, segment_indexes.any? ? segment_indexes : nil]
+          [path, resolver_for(path), idx, segments.any? ? segments : nil]
         end
       end
     end

data/lib/lazy_graph/node/node_properties.rb

@@ -28,12 +28,21 @@ module LazyGraph
           to_h
         end
 
+        def to_h
+          HashUtils.strip_missing(self)
+        end
+
+        def ==(other)
+          return super if other.is_a?(self.class)
+          return to_h.eql?(other.to_h) if other.respond_to?(:to_h)
+
+          super
+        end
+
         define_method(:each_key, &members.method(:each))
 
         def dup
-          duplicate = self.class.new
-          members.each { duplicate[_1] = self[_1].dup }
-          duplicate
+          self.class.new(members.each_with_object({}) { _2[_1] = _2[_1].dup })
         end
 
         def get_first_of(*props)
@@ -44,17 +53,18 @@ module LazyGraph
         end
 
         def pretty_print(q)
-          q.group(1, '<Props ', '>') do
+          q.group(1, '<', '>') do
+            q.text "#{self.class.name} "
             q.seplist(members.zip(values).reject do |m, v|
-              m == :DEBUG && (v.nil? || v.is_a?(MissingValue))
-            end) do |member, value|
-              q.group do
-                q.text "#{member}="
-                value.respond_to?(:pretty_print) ? q.pp(value) : q.text(value.inspect)
-              end
+              m == :DEBUG || v.nil? || v.is_a?(MissingValue)
+            end.to_h) do |k, v|
+              q.text "#{k}: "
+              q.pp v
             end
           end
         end
+
+        alias_method :keys, :members
       end
     end
   end

data/lib/lazy_graph/node/object_node.rb

@@ -2,6 +2,8 @@ module LazyGraph
   class ObjectNode < Node
     require_relative 'symbol_hash'
 
+    attr_reader :properties
+
     # An object supports the following types of path resolutions.
     # 1. Property name: obj.property => value
     # 2. Property name group: obj[property1, property2] =>  { property1: value1, property2: value2 }
@@ -14,58 +16,39 @@ module LazyGraph
     )
       input = stack_memory.frame
 
-      @visited[input.object_id >> 2 ^ path.shifted_id] ||= begin
+      @visited[(input.object_id >> 2 ^ path.shifted_id) + preserve_keys.object_id] ||= begin
         return input if input.is_a?(MissingValue)
 
+        path_next = path.next
+
         if (path_segment = path.segment).is_a?(PathParser::PathGroup)
           return path_segment.options.each_with_object({}.tap(&:compare_by_identity)) do |part, object|
-            resolve(part.merge(path.next), stack_memory, nil, preserve_keys: object)
+            resolve(part.merge(path_next), stack_memory, nil, preserve_keys: object)
           end
         end
-
         if !segment = path_segment&.part
-          @properties_a.each do |key, node|
-            item = node.fetch_item(input, key, stack_memory)
-            node.resolve(path.next, stack_memory.push(item, key))
+          @complex_properties_a.each do |key, node|
+            node.fetch_and_resolve(path_next, input, key, stack_memory)
           end
-          if @pattern_properties.any? && input.keys.length > @properties_a.length
+          if @complex_pattern_properties_a.any?
             input.each_key do |key|
-              node = !@properties[key] && @pattern_properties.find { |(pattern, _value)| pattern.match?(key) }&.last
-              item = node.fetch_item(input, key, stack_memory)
-              node.resolve(path.next, stack_memory.push(item, key))
+              node = !@properties[key] && @complex_pattern_properties_a.find do |(pattern, _value)|
+                pattern.match?(key)
+              end&.last
+              next unless node
+
+              node.fetch_and_resolve(path_next, input, key, stack_memory)
             end
           end
           input
         elsif (prop = @properties[segment])
-          item = prop.fetch_item(input, segment, stack_memory)
-          value = prop.resolve(
-            path.next, stack_memory.push(item, segment)
-          )
-          preserve_keys ? preserve_keys[segment] = value : value
-        elsif segment == :*
-          # rubocop:disable
-          (input.keys | @properties_a.map(&:first)).each do |key|
-            next unless (node = @properties[key] || @pattern_properties.find do |(pattern, _value)|
-              pattern.match?(key)
-            end&.last)
-
-            item = node.fetch_item(input, key, stack_memory)
-            preserve_keys[key] = node.resolve(path.next, stack_memory.push(item, key))
-          end
+          prop.fetch_and_resolve(path_next, input, segment, stack_memory, preserve_keys)
         elsif (_, prop = @pattern_properties.find { |(key, _val)| key.match?(segment) })
-          item = prop.fetch_item(input, segment, stack_memory)
-          value = prop.resolve(
-            path.next, stack_memory.push(item, segment)
-          )
-          preserve_keys ? preserve_keys[segment] = value : value
+          prop.fetch_and_resolve(path_next, input, segment, stack_memory, preserve_keys)
         elsif input.key?(segment)
           prop = @properties[segment] = lazy_init_node!(input[segment], segment)
           @properties_a = @properties.to_a
-          item = prop.fetch_item(input, segment, stack_memory)
-          value = prop.resolve(
-            path.next, stack_memory.push(item, segment)
-          )
-          preserve_keys ? preserve_keys[segment] = value : value
+          prop.fetch_and_resolve(path_next, input, segment, stack_memory, preserve_keys)
         else
           value = MissingValue()
           preserve_keys ? preserve_keys[segment] = value : value
@@ -76,10 +59,10 @@ module LazyGraph
     end
 
     def find_resolver_for(segment)
-      if segment == :'$'
+      if segment.equal?(:'$')
         root
       elsif @properties.key?(segment)
-        self
+        @properties[segment]
       else
         @parent&.find_resolver_for(segment)
       end
@@ -88,32 +71,30 @@ module LazyGraph
     def children=(value)
       @children = value
 
-      @properties = @children.fetch(:properties, {})
-      @properties.compare_by_identity
+      @properties = @children.fetch(:properties, {}).compare_by_identity
       @pattern_properties = @children.fetch(:pattern_properties, [])
 
-      @properties_a = @properties.to_a
+      @complex_properties_a = @properties.to_a.reject { _2.simple? }
+      @complex_pattern_properties_a = @pattern_properties.reject { _2.simple? }
 
       @has_properties = @properties.any? || @pattern_properties.any?
 
-      return unless @properties.any? || @pattern_properties.any?
+      return unless @has_properties
 
       if @pattern_properties.any?
         @property_class = SymbolHash
       else
         invisible = @properties.select { |_k, v| v.invisible }.map(&:first)
-        @property_class = PROPERTY_CLASSES[{ members: @properties.keys + (@debug && !parent ? [:DEBUG] : []),
-                                             invisible: invisible }]
-      end
-      define_singleton_method(:cast, build_caster)
-    end
-
-    private def build_caster
-      if @property_class
-        ->(value) { value.is_a?(@property_class) ? value : @property_class.new(value.to_h) }
-      else
-        ->(value) { value }
+        @property_class = LazyGraph.fetch_property_class(
+          path,
+          { members: @properties.keys + (@debug && !parent ? [:DEBUG] : []),
+            invisible: invisible },
+          namespace: root.namespace
+        )
       end
+      define_singleton_method(:cast, lambda { |val|
+        val.is_a?(@property_class) ? val : @property_class.new(val.to_h)
+      })
     end
   end
 end

data/lib/lazy_graph/node.rb

@@ -1,4 +1,3 @@
-require 'debug'
 # frozen_string_literal: true
 
 require 'bigdecimal/util'
@@ -12,8 +11,19 @@ module LazyGraph
 
   DIGIT_REGEXP = /^-?\d+$/
   SAFE_TOKEN_REGEXP = /^[A-Za-z][A-Za-z0-9]*$/
-  PROPERTY_CLASSES = Hash.new do |h, members|
-    h[members] = LazyGraph.const_set("NodeProperties#{h.hash.abs}", NodeProperties.build(**members))
+  PROPERTY_CLASSES = {}
+  UNIQUE_NAME_COUNTER = Hash.new(0)
+
+  def self.fetch_property_class(name, members, namespace: nil)
+    namespace ||= LazyGraph
+    PROPERTY_CLASSES[members] ||= begin
+      name = name.to_s.capitalize.gsub(/(\.|_)([a-zA-Z])/) do |m|
+        m[1].upcase
+      end.gsub(/[^a-zA-Z]/, '').then { |n| n.length > 0 ? n : 'NodeProps' }
+      index = UNIQUE_NAME_COUNTER[[name, namespace]] += 1
+      full_name = "#{name}#{index > 1 ? index : ''}"
+      namespace.const_set(full_name, NodeProperties.build(**members))
+    end
   end
 
   # Class: Node
@@ -39,27 +49,44 @@ module LazyGraph
     include DerivedRules
     attr_accessor :name, :path, :type, :derived, :depth, :parent, :root, :invisible
     attr_accessor :children
-    attr_reader :is_object
+    attr_reader :is_object, :namespace
+
+    def simple? = @simple
 
-    def initialize(name, path, node, parent, debug: false, helpers: nil)
+    def initialize(name, path, node, parent, debug: false, helpers: nil, namespace: nil)
       @name = name
       @path = path
       @parent = parent
       @debug = debug
       @depth = parent ? parent.depth + 1 : 0
       @root = parent ? parent.root : self
+      @rule = node[:rule]
       @type = node[:type]
+      @helpers = helpers
       @invisible = debug ? false : node[:invisible]
       @visited = {}.compare_by_identity
+      @namespace = namespace
+
       instance_variable_set("@is_#{@type}", true)
       define_singleton_method(:cast, build_caster)
       define_missing_value_proc!
 
       @has_default = node.key?(:default)
       @default = @has_default ? cast(node[:default]) : MissingValue { @name }
-      @resolution_stack = []
 
-      build_derived_inputs(node[:rule], helpers) if node[:rule]
+      # Simple nodes are not a container type, and do not have rule or default
+      @simple = !(%i[object array date time timestamp decimal].include?(@type) || node[:rule] || @has_default)
+    end
+
+    def build_derived_inputs!
+      build_derived_inputs(@rule, @helpers) if @rule
+      return unless @children
+      return @children.build_derived_inputs! if @children.is_a?(Node)
+
+      @children[:properties]&.each_value(&:build_derived_inputs!)
+      @children[:pattern_properties]&.each do |(_, node)|
+        node.build_derived_inputs!
+      end
     end
 
     def define_missing_value_proc!
@@ -69,7 +96,18 @@ module LazyGraph
       )
     end
 
-    private def build_caster
+    def fetch_and_resolve(path, input, segment, stack_memory, preserve_keys = nil, recurse: false)
+      item = fetch_item(input, segment, stack_memory)
+      unless @simple || item.is_a?(MissingValue)
+        item = resolve(
+          path,
+          stack_memory.push(item, segment)
+        )
+      end
+      preserve_keys ? preserve_keys[segment] = item : item
+    end
+
+    def build_caster
       if @is_decimal
         ->(value) { value.is_a?(BigDecimal) ? value : value.to_d }
       elsif @is_date
@@ -100,9 +138,9 @@ module LazyGraph
 
     def clear_visits!
       @visited.clear
-      @resolution_stack.clear
-      @path_cache = {}.clear
-      @resolvers = {}.clear
+      @resolution_stack&.clear
+      @path_cache&.clear
+      @resolvers&.clear
 
       return unless @children
       return @children.clear_visits! if @children.is_a?(Node)
@@ -113,10 +151,6 @@ module LazyGraph
       end
     end
 
-    # When we assign children to a node, we preemptively extract the properties, and pattern properties
-    # in both hash and array form. This micro-optimization pays off when we resolve values in the graph at
-    # very high frequency.
-
     def resolve(
       path,
       stack_memory,
@@ -142,7 +176,7 @@ module LazyGraph
           when Array then :array
           end
         node.children = Node.new(:items, :"#{path}.#{key}[].items", { type: child_type }, node)
-        node.children.children = { properties: {}, pattern_properties: [] } if child_type == :object
+        node.children.children = { properties: {}, pattern_properties: [] } if child_type.equal? :object
         node
       else
         Node.new(key, :"#{path}.#{key}", {}, self)
@@ -161,43 +195,24 @@ module LazyGraph
       end
     end
 
-    def resolve_input(stack_memory, path, key)
-      input_id = key.object_id >> 2 ^ stack_memory.shifted_id
-      if @resolution_stack.include?(input_id)
-        if @debug
-          stack_memory.log_debug(
-            property: "#{stack_memory}.#{key}",
-            exception: 'Infinite Recursion Detected during dependency resolution'
-          )
-        end
-        return MissingValue { "Infinite Recursion in #{stack_memory} => #{path.to_path_str}" }
-      end
-
-      @resolution_stack << (input_id)
-      first_segment = path.segment.part
-
-      resolver_node = @resolvers[first_segment] ||= (first_segment == key ? parent.parent : @parent).find_resolver_for(first_segment)
-
-      if resolver_node
-        input_frame_pointer = stack_memory.ptr_at(resolver_node.depth)
-        resolver_node.resolve(
-          first_segment == :'$' ? path.next : path,
-          input_frame_pointer,
-          nil
-        )
-      else
-        MissingValue { path.to_path_str }
-      end
-    ensure
-      @resolution_stack.pop
-    end
-
     def ancestors
       @ancestors ||= [self, *(@parent ? @parent.ancestors : [])]
     end
 
     def find_resolver_for(segment)
-      segment == :'$' ? root : @parent&.find_resolver_for(segment)
+      segment.equal?(:'$') ? root : @parent&.find_resolver_for(segment)
+    end
+
+    def resolve_relative_input(stack_memory, path)
+      input_frame_pointer = path.absolute? ? stack_memory.root : stack_memory.ptr_at(depth - 1)
+      input_frame_pointer.recursion_depth += 1
+      return input_frame_pointer.frame[path.first_path_segment.part] if @simple
+
+      fetch_and_resolve(
+        path.absolute? ? path.next.next : path.next, input_frame_pointer.frame, path.first_path_segment.part, input_frame_pointer
+      )
+    ensure
+      input_frame_pointer.recursion_depth -= 1
     end
 
     def fetch_item(input, key, stack)
@@ -217,20 +232,34 @@ module LazyGraph
 
       return input[key] = @default unless derived
 
-      if @copy_input
-        copy_item!(input, key, stack, @inputs.first)
-      else
-        derive_item!(input, key, stack)
+      if stack.recursion_depth >= 8
+        input_id = key.object_id >> 2 ^ input.object_id << 28
+        if @resolution_stack.key?(input_id)
+          if @debug
+            stack.log_debug(
+              output: :"#{stack}.#{key}",
+              exception: 'Infinite Recursion Detected during dependency resolution'
+            )
+          end
+          return MissingValue { "Infinite Recursion in #{stack} => #{key}" }
+        end
+        @resolution_stack[input_id] = true
       end
+
+      @copy_input ? copy_item!(input, key, stack, @inputs.first) : derive_item!(input, key, stack)
+    ensure
+      @resolution_stack.delete(input_id) if input_id
     end
 
-    def copy_item!(input, key, stack, (path, _i, segment_indexes))
-      if segment_indexes
-        missing_value = nil
+    def copy_item!(input, key, stack, (path, resolver, _i, segments))
+      missing_value = resolver ? nil : MissingValue { key }
+      if resolver && segments
         parts = path.parts.dup
         parts_identity = path.identity
-        segment_indexes.each do |index|
-          part = resolve_input(stack, parts[index].options.first, key)
+        segments.each do |index, resolver|
+          break missing_value = MissingValue { key } unless resolver
+
+          part = resolver.resolve_relative_input(stack, parts[index].options.first)
           break missing_value = part if part.is_a?(MissingValue)
 
           part_sym = part.to_s.to_sym
@@ -240,12 +269,12 @@ module LazyGraph
         path = @path_cache[parts_identity] ||= PathParser::Path.new(parts: parts) unless missing_value
       end
 
-      result = missing_value || cast(resolve_input(stack, path, key))
+      result = missing_value || cast(resolver.resolve_relative_input(stack, path))
 
       if @debug
         stack.log_debug(
           output: :"#{stack}.#{key}",
-          result: result,
+          result: HashUtils.deep_dup(result),
           inputs: @node_context.to_h.except(:itself, :stack_ptr),
           calc: @src
         )
@@ -254,13 +283,15 @@ module LazyGraph
     end
 
     def derive_item!(input, key, stack)
-      @inputs.each do |path, i, segment_indexes|
-        if segment_indexes
+      @inputs.each do |path, resolver, i, segments|
+        if segments
           missing_value = nil
           parts = path.parts.dup
           parts_identity = path.identity
-          segment_indexes.each do |index|
-            part = resolve_input(stack, parts[index].options.first, key)
+          segments.each do |index, resolver|
+            break missing_value = MissingValue { key } unless resolver
+
+            part = resolver.resolve_relative_input(stack, parts[index].options.first)
             break missing_value = part if part.is_a?(MissingValue)
 
             part_sym = part.to_s.to_sym
@@ -269,7 +300,7 @@ module LazyGraph
           end
           path = @path_cache[parts_identity] ||= PathParser::Path.new(parts: parts) unless missing_value
         end
-        result = missing_value || resolve_input(stack, path, key)
+        result = missing_value || resolver.resolve_relative_input(stack, path)
         @node_context[i] = result.is_a?(MissingValue) ? nil : result
       end
 

data/lib/lazy_graph/path_parser/path.rb

@@ -10,25 +10,33 @@ module LazyGraph
     Path = Struct.new(:parts, keyword_init: true) do
       def next        = @next ||= parts.length <= 1 ? Path::BLANK : Path.new(parts: parts[1..])
       def empty?      = @empty ||= parts.empty?
+      def length      = @length ||= parts.length
       def segment     = @segment ||= parts&.[](0)
-      def index?      = @index   ||= !empty? && segment&.index?
+      def absolute?   = instance_variable_defined?(:@absolute) ? @absolute : (@absolute = segment&.part.equal?(:'$'))
+      def index?      = @index ||= !empty? && segment&.index?
       def identity    = @identity ||= parts&.each_with_index&.reduce(0) { |acc, (p, i)| acc ^ (p.object_id) << (i * 8) }
       def map(&block) = empty? ? self : Path.new(parts: parts.map(&block))
       def shifted_id  = @shifted_id ||= object_id << 28
+      def first_path_segment = @first_path_segment ||= absolute? ? self.next.segment : segment
 
       def merge(other)
-        (@merged ||= {})[other] ||= \
-          if other.empty?
-            self
-          else
-            empty? ? other : Path.new(parts: parts + other.parts)
-          end
+        if other.empty?
+          self
+        else
+          empty? ? other : Path.new(parts: parts + other.parts)
+        end
       end
 
       def to_path_str
         @to_path_str ||= create_path_str
       end
 
+      def ==(other)
+        return parts == other if other.is_a?(Array)
+
+        super
+      end
+
       private
 
       def create_path_str

data/lib/lazy_graph/path_parser/path_group.rb

@@ -7,6 +7,12 @@ module LazyGraph
       def index?
         @index ||= options.all?(&:index?)
       end
+
+      def ==(other)
+        return options == other if other.is_a?(Array)
+
+        super
+      end
     end
   end
 end

data/lib/lazy_graph/path_parser/path_part.rb

@@ -8,6 +8,14 @@ module LazyGraph
       def index?
         @index ||= part =~ INDEX_REGEXP
       end
+
+      def ==(other)
+        return part == other.to_sym if other.is_a?(String)
+        return part == other if other.is_a?(Symbol)
+        return part == other if other.is_a?(Array)
+
+        super
+      end
     end
   end
 end

data/lib/lazy_graph/path_parser.rb

@@ -19,7 +19,7 @@ module LazyGraph
     require_relative 'path_parser/path_part'
     # This module is responsible for parsing complex path strings into structured components.
     # Public class method to parse the path string
-    def self.parse(path, strip_root = false)
+    def self.parse(path, strip_root: false)
       return Path::BLANK if path.nil? || path.empty?
 
       start = strip_root && path.to_s.start_with?('$.') ? 2 : 0

data/lib/lazy_graph/server.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
+require 'rack'
+
 module LazyGraph
   class Server
     ALLOWED_VALUES_VALIDATE = [true, false, nil, 'input', 'context'].to_set.freeze
     ALLOWED_VALUES_DEBUG = [true, false, nil].to_set.freeze
 
+    attr_reader :routes
+
     def initialize(routes: {})
       @routes = routes.transform_keys(&:to_sym).compare_by_identity
     end
@@ -59,6 +63,7 @@ module LazyGraph
         rescue StandardError => e
           LazyGraph.logger.error(e.message)
           LazyGraph.logger.error(e.backtrace.join("\n"))
+
           return error!(request, 500, 'Internal Server Error', e.message)
         end
       end

data/lib/lazy_graph/stack_pointer.rb

@@ -4,35 +4,38 @@ module LazyGraph
   # Module to provide lazy graph functionalities using stack pointers.
   POINTER_POOL = []
 
-  StackPointer = Struct.new(:parent, :frame, :depth, :key, :root) do
+  StackPointer = Struct.new(:parent, :frame, :depth, :recursion_depth, :key, :root) do
     attr_accessor :pointer_cache
 
-    def shifted_id  = @shifted_id ||= object_id << 28
-
+    # Pushes a new frame onto the stack, creating or reusing a StackPointer.
+    # Frames represent activation contexts; keys are identifiers within those frames.
     def push(frame, key)
-      if (ptr = POINTER_POOL.pop)
-        ptr.parent = self
-        ptr.parent = self
-        ptr.frame = frame
-        ptr.key = key
-        ptr.depth = depth + 1
-        ptr.pointer_cache&.clear
-        ptr
-      else
-        StackPointer.new(parent: self, frame: frame, key: key, depth: depth + 1, root: root || self)
-      end
+      ptr = POINTER_POOL.pop || StackPointer.new
+      ptr.parent = self
+      ptr.root = root || self
+      ptr.frame = frame
+      ptr.key = key
+      ptr.depth = depth + 1
+      ptr.recursion_depth = recursion_depth
+      ptr.pointer_cache&.clear
+      ptr
     end
 
+    # Recycles the current StackPointer by adding it back to the pointer pool.
+    # Once recycled, this instance should no longer be used unless reassigned by push.
     def recycle!
       POINTER_POOL.push(self)
       nil
     end
 
+    # Retrieves the StackPointer at a specific index in the upward chain of parents.
     def ptr_at(index)
       @pointer_cache ||= {}.compare_by_identity
       @pointer_cache[index] ||= depth == index ? self : parent&.ptr_at(index)
     end
 
+    # Handles method calls not explicitly defined in this class by delegating them
+    # first to the frame, then to the parent, recursively up the stack.
     def method_missing(name, *args, &block)
       if frame.respond_to?(name)
         frame.send(name, *args, &block)
@@ -43,20 +46,25 @@ module LazyGraph
       end
     end
 
+    # Returns the key associated with this stack pointer's frame.
     def index
       key
     end
 
+    # Logs debugging information related to this stack pointer in the root frame's DEBUG section.
     def log_debug(**log_item)
       root.frame[:DEBUG] = [] if !root.frame[:DEBUG] || root.frame[:DEBUG].is_a?(MissingValue)
       root.frame[:DEBUG] << { **log_item, location: to_s }
       nil
     end
 
+    # Determines if the stack pointer can respond to a missing method by mimicking the behavior
+    # of the frame or any parent stack pointers recursively.
     def respond_to_missing?(name, include_private = false)
       frame.respond_to?(name, include_private) || parent.respond_to?(name, include_private)
     end
 
+    # Returns a string representation of the stacking path of keys up to this pointer.
     def to_s
       if parent
         "#{parent}#{key.to_s =~ /\d+/ ? "[#{key}]" : ".#{key}"}"

data/lib/lazy_graph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LazyGraph
-  VERSION = '0.1.2'
+  VERSION = '0.1.6'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: lazy_graph
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.6
 platform: ruby
 authors:
 - Wouter Coppieters
 bindir: exe
 cert_chain: []
-date: 2024-12-25 00:00:00.000000000 Z
+date: 2024-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema