lazy_graph 0.1.3 → 0.2.0

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)
+          return path_segment.options.each_with_object(SymbolHash.new) do |part, 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
-            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))
+          if @complex_pattern_properties_a.any?
+            input.keys.each do |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
+          cast(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
-        elsif input.key?(segment)
+          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,34 @@ 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|
+        if val.is_a?(MissingValue)
+          val
+        else
+          val.is_a?(@property_class) ? val : @property_class.new(val.to_h)
+        end
+      })
     end
   end
 end

data/lib/lazy_graph/node/symbol_hash.rb

@@ -1,9 +1,10 @@
 module LazyGraph
   class ObjectNode < Node
     class SymbolHash < ::Hash
-      def initialize(input_hash)
+      def initialize(input_hash = {})
         super
-        merge!(input_hash)
+        merge!(input_hash.transform_keys(&:to_sym))
+        compare_by_identity
       end
 
       def []=(key, value)
@@ -21,6 +22,18 @@ module LazyGraph
         else super(key.to_s.to_sym)
         end
       end
+
+      def method_missing(name, *args, &block)
+        if key?(name)
+          self[name]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        key?(name) || super
+      end
     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,48 @@ 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]
+      @rule_location = node[:rule_location]
       @type = node[:type]
-      @invisible = debug ? false : node[:invisible]
+      @validate_presence = node[:validate_presence]
+      @helpers = helpers
+      @invisible = debug.eql?(true) ? false : node[:invisible]
       @visited = {}.compare_by_identity
+      @namespace = namespace
+
       instance_variable_set("@is_#{@type}", true)
       define_singleton_method(:cast, build_caster)
+      define_singleton_method(:trace!, proc { |*| }) unless @debug
+
       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,11 +100,31 @@ module LazyGraph
       )
     end
 
-    private def build_caster
+    def fetch_and_resolve(path, input, segment, stack_memory, preserve_keys = nil)
+      item = fetch_item(input, segment, stack_memory)
+      unless @simple || item.is_a?(MissingValue)
+        item = resolve(
+          path,
+          stack_memory.push(item, segment)
+        )
+      end
+
+      item = cast(item) if @simple
+
+      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
-        ->(value) { value.is_a?(String) ? Date.parse(value) : value }
+        lambda { |value|
+          if value.is_a?(String)
+            Date.parse(value)
+          else
+            value.is_a?(Symbol) ? Date.parse(value.to_s) : value
+          end
+        }
       elsif @is_boolean
         lambda do |value|
           if value.is_a?(TrueClass) || value.is_a?(FalseClass)
@@ -93,6 +144,8 @@ module LazyGraph
             value
           end
         end
+      elsif @is_string
+        lambda(&:to_s)
       else
         ->(value) { value }
       end
@@ -100,9 +153,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 +166,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 +191,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 +210,25 @@ 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 cast(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,21 +248,35 @@ 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)
+          trace!(stack, exception: 'Infinite Recursion Detected during dependency resolution') do
+            { output: :"#{stack}.#{key}" }
+          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)
-          break missing_value = part if part.is_a?(MissingValue)
+        segments.each do |index, resolver|
+          break missing_value = MissingValue { key } unless resolver
+
+          part = resolver.resolve_relative_input(stack, parts[index].options.first)
+          if part.is_a?(MissingValue)
+            raise_presence_validation_error!(stack, key, parts[index].options.first) if @validate_presence
+            break missing_value = part
+          end
 
           part_sym = part.to_s.to_sym
           parts_identity ^= part_sym.object_id << index
@@ -240,28 +285,30 @@ 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,
-          inputs: @node_context.to_h.except(:itself, :stack_ptr),
-          calc: @src
-        )
+      if result.nil? || result.is_a?(MissingValue)
+        raise_presence_validation_error!(stack, key, path) if @validate_presence
+        input[key] = MissingValue { key }
+      else
+        input[key] = result
       end
-      input[key] = result.nil? ? MissingValue { key } : result
     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)
-            break missing_value = part if part.is_a?(MissingValue)
+          segments.each do |index, resolver|
+            break missing_value = MissingValue { key } unless resolver
+
+            part = resolver.resolve_relative_input(stack, parts[index].options.first)
+            if part.is_a?(MissingValue)
+              raise_presence_validation_error!(stack, key, parts[index].options.first) if @validate_presence
+              break missing_value = part
+            end
 
             part_sym = part.to_s.to_sym
             parts_identity ^= part_sym.object_id << (index * 8)
@@ -269,8 +316,28 @@ 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)
-        @node_context[i] = result.is_a?(MissingValue) ? nil : result
+        result = begin
+          missing_value || resolver.resolve_relative_input(stack, path)
+        rescue AbortError, ValidationError => e
+          raise e
+        rescue StandardError => e
+          ex = e
+          LazyGraph.logger.error("Error in #{self.path}")
+          LazyGraph.logger.error(e)
+          LazyGraph.logger.error(e.backtrace.take_while do |line|
+            !line.include?('lazy_graph/node.rb')
+          end.join("\n"))
+
+          MissingValue { "#{key} raised exception: #{e.message}" }
+        end
+
+        if result.nil? || result.is_a?(MissingValue)
+          raise_presence_validation_error!(stack, key, path) if @validate_presence
+
+          @node_context[i] = nil
+        else
+          @node_context[i] = result
+        end
       end
 
       @node_context[:itself] = input
@@ -285,12 +352,21 @@ module LazyGraph
         if conditions_passed
           output = begin
             cast(@fixed_result || @node_context.process!)
-          rescue LazyGraph::AbortError => e
+          rescue AbortError, ValidationError => e
             raise e
           rescue StandardError => e
             ex = e
             LazyGraph.logger.error(e)
-            LazyGraph.logger.error(e.backtrace.join("\n"))
+            LazyGraph.logger.error(e.backtrace.take_while do |line|
+              !line.include?('lazy_graph/node.rb')
+            end.join("\n"))
+
+            if ENV['LAZYGRAPH_OPEN_ON_ERROR'] && !@revealed_src
+              require 'shellwords'
+              @revealed_src = true
+              `sh -c \"$EDITOR '#{Shellwords.escape(e.backtrace.first[/.*:/][...-1])}'\" `
+            end
+
             MissingValue { "#{key} raised exception: #{e.message}" }
           end
 
@@ -299,24 +375,37 @@ module LazyGraph
           MissingValue { key }
         end
 
-      if @debug
-        stack.log_debug(
-          output: :"#{stack}.#{key}",
-          result: HashUtils.deep_dup(result),
-          inputs: @node_context.to_h.except(:itself, :stack_ptr).transform_keys { |k| @input_mapper&.[](k) || k },
-          calc: @src,
-          **(@conditions ? { conditions: @conditions } : {}),
-          **(if ex
-               { exception: ex, backtrace: ex.backtrace.take_while do |line|
-                 !line.include?('lazy_graph/node.rb')
-               end }
-             else
-               {}
-             end
-            )
-        )
+      if conditions_passed
+        trace!(stack, exception: ex) do
+          {
+            output: :"#{stack}.#{key}",
+            result: HashUtils.deep_dup(result),
+            inputs: @node_context.to_h.except(:itself, :stack_ptr).transform_keys { |k| @input_mapper&.[](k) || k },
+            calc: @src,
+            **(@conditions ? { conditions: @conditions } : {})
+          }
+        end
       end
+
       result
     end
+
+    def trace!(stack, exception: nil)
+      return if @debug == 'exceptions' && !exception
+
+      trace_opts = {
+        **yield,
+        **(exception ? { exception: exception } : {})
+      }
+
+      return if @debug.is_a?(Regexp) && !(@debug =~ trace_opts[:output])
+
+      stack.log_debug(**trace_opts)
+    end
+
+    def raise_presence_validation_error!(stack, key, path)
+      raise ValidationError,
+            "Missing required value for #{stack}.#{key} at #{path.to_path_str}"
+    end
   end
 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