lazy_graph 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df09bd7d0c4f8a82c1cdbaf387dfc6e18ec9f9b6f492a1aa17b2942f1e14a947
-  data.tar.gz: c9887fff1a0eacb38b5ec426f13ce5a8fc23e7d6602a1876a398773628a3461e
+  metadata.gz: 29043baea3639e83c226d8e157af818466d50d4e3c125853dac64ae411aa0c0a
+  data.tar.gz: f137caa57317cd9046bc16384bf657ca7c43d10b12701f30be6bc7a31580c6db
 SHA512:
-  metadata.gz: a90efb82622865574cffd51c996ceeaec5f8f29534da07869ef3c0bb2de3056031ec4c0357b41a3e4fe0390e4e8e364bd07b76f1073b08a8beb95124f7eda301
-  data.tar.gz: 508a463c441ebd661871d8655e52dd230bbdc2e4458898a6399099dcc6ef70d90455042f5e960c471f64c77fb56b1456a2c8919b6f0ac28ba769b0a2374fb8a0
+  metadata.gz: b1c5107a005882da016caa1fd54afa5131f296637fd6a7b18810d3b2c1f18893ae11938e63fc42ceec05def4ceba76afbe016b152d1c107225af148b06f6db52
+  data.tar.gz: b5a2126ac97b38e1e0d4ce23a1d46859a89979b0b09a2d3ad3e3676b763d6277745310ee08a0c49fbbc85bcd930d246362bd79793899726c2f763b0aa1f6fe44

data/README.md

@@ -273,12 +273,10 @@ module ShoppingCart
     rules_module :cart_base do
       object :cart do
         array :items, required: true do
-          items do
-            string :name, required: true
-            number :price, default: 1.0
-            number :quantity, default: 1
-            number :total, rule: '${price} * ${quantity}'
-          end
+          string :name, required: true
+          number :price, default: 1.0
+          number :quantity, default: 1
+          number :total, rule: '${price} * ${quantity}'
         end
 
         number :cart_total, rule: '${items.total}.sum'
@@ -301,6 +299,30 @@ context = cart_schema.context({
 puts context['cart.cart_total'] # => 21.0
 ```
 
+We can create any number of modules within a builder, and then merge them together in any combination to create a final schema.
+E.g.
+
+```ruby
+# A second module that can be merged into the schema
+rules_module :stock do
+  object :stock do
+    number :available, default: 100
+    number :reserved, default: 0
+    number :total, rule: '${available} - ${reserved}'
+  end
+end
+```
+
+You can then merge these, by chaining module builder calls
+
+```ruby
+# Combine two modules
+cart_schema = ShoppingCart::CartBuilder.cart_base.stock.build! # (also accepts optional args like :debug and :validate)
+
+# Use just a single module
+cart_schema = ShoppingCart::CartBuilder.cart_base.build!
+```
+
 ### Rules and Dependency Resolution
 
 Rules let you define logic for computing new values from existing ones. LazyGraph:
@@ -371,6 +393,14 @@ Just type a variable by name and it will automatically be recursively resolved t
 *However* it is essential that you explicitly define all inputs to the rule to ensure resolution is correct,
 as LazyGraph will not automatically resolve any variables that are dynamically accessed.
 This is advanced functionality, and should be used with caution. In general, it is best to define all input dependencies explicitly.
+You can put a breakpoint inside a lambda rule to inspect the current scope and understand what is available to you.
+Check out:
+
+`stack_ptr` - The current stack pointer, which is the current node in the graph.
+`stack_ptr.parent` - The parent node in the graph (you can traverse up the graph by following the parent pointers).
+`stack_ptr.key` - The key in the parent node where the current node is stored (e.g. an index in an array or property name)
+`stack_ptr.frame` - The current frame in the graph, which contains actual graph data.
+`itself` - The current node in the graph (same as stack_ptr.frame)
 
 ### Debug Mode & Recursive Dependency Detection
 
@@ -406,6 +436,9 @@ puts result[:debug_trace]
 In cases where you accidentally create **circular dependencies**, LazyGraph will log warnings to the debug logs, and detect and break infinite loops
 in the dependency resolution, ensuring that the remainder of the graph is still computed correctly.
 
+### Conditional Sub-Graphs
+[TODO]
+
 ### Advanced Path Syntax
 
 LazyGraph’s query engine supports a flexible path notation:
@@ -429,7 +462,6 @@ For situations where you want to serve rules over HTTP:
 
 A minimal example might look like:
 
-[TODO] Verify example.
 ```ruby
 require 'lazy_graph'
 require 'lazy_graph/server'
@@ -453,20 +485,29 @@ module CartAPI
   #    - context: { cart: { items: [ { name: "Widget", price: 2.5, quantity: 4 } ] } } # The input data to the schema
   module Cart
     class V1 < LazyGraph::Builder
+
+      # A module that can be merged into the schema
       rules_module :cart_base do |foo:, bar:|
         object :cart do
           array :items, required: true do
-            items do
-              string :name, required: true
-              number :price, default: 1.0
-              number :quantity, default: 1
-              number :total, rule: '${price} * ${quantity}'
-            end
+            string :name, required: true
+            number :price, default: 1.0
+            number :quantity, default: 1
+            number :total, rule: '${price} * ${quantity}'
           end
 
           number :cart_total, rule: '${items.total}.sum'
         end
       end
+
+      # A second module that can be merged into the schema
+      rules_module :stock do
+        object :stock do
+          number :available, default: 100
+          number :reserved, default: 0
+          number :total, rule: '${available} - ${reserved}'
+        end
+      end
     end
   end
 
@@ -488,7 +529,7 @@ Then send requests like:
 curl -X POST http://localhost:9292/cart/v1 \
   -H 'Content-Type: application/json' \
   -d '{
-    "modules": { "cart" : {} },
+    "modules": { "cart" : {}, "stock": {} },
     "query": "cart.cart_total",
     "context": {
       "cart": {

data/examples/performance_tests.rb

@@ -8,29 +8,21 @@ class PerformanceBuilder < LazyGraph::Builder
     integer :employees_count, rule: { inputs: 'employees', calc: 'employees.size' }
 
     array :employees, required: true do
-      items do
-        string :id
-        array :positions, required: true, default: [] do
-          items do
-            string :pay_schedule_id, invisible: true
-            string :position_id, invisible: true
+      string :id
+      array :positions, required: true, default: [] do
+        string :pay_schedule_id, invisible: true
+        string :position_id, invisible: true
 
-            object :position, rule: :"${$.positions[position_id]}" do
-              number :base_rate
-              number :salary
-              number :bonus, rule: :'${base_rate} * 0.1'
-            end
-            object :pay_schedule, rule: :'${pay_schedules[pay_schedule_id]}'
-            number :base_rate, rule: :"${position.base_rate}"
-            string :employee_id, rule: :id
-          end
-        end
+        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
 
     object :positions do
       object :".*", pattern_property: true do
-        number :base_rate
+        number :pay_rate
         number :salary, default: 100_000
       end
     end
@@ -64,7 +56,7 @@ def gen_employees(n, m = 10)
     end.to_h,
     positions: [*1..m].map do |i|
       [i, {
-        base_rate: Random.rand(10..100)
+        pay_rate: Random.rand(10..100)
       }]
     end.to_h
   }

data/lib/lazy_graph/builder/dsl.rb

@@ -39,7 +39,7 @@ module LazyGraph
       end
 
       def set_pattern_property(pattern, value)
-        pattern = pattern.to_s
+        pattern = pattern.to_sym
         properties = schema[:patternProperties] ||= {}
         properties[pattern] = \
           if properties.key?(pattern) && %i[object array].include?(properties[pattern][:type])
@@ -261,13 +261,12 @@ module LazyGraph
           **(description ? { description: description } : {}),
           **(rule ? { rule: rule } : {}),
           **opts,
-          items: {
-            type: type,
-            properties: {},
-            additionalProperties: false
-          }
+          items: { properties: {} }.tap do |items|
+            yields(items) do
+              send(type, :items, &blk)
+            end
+          end[:properties][:items]
         }
-        yields(new_array, &blk)
         required(name) if required && default.nil? && rule.nil?
         pattern_property ? set_pattern_property(name, new_array) : set_property(name, new_array)
       end
@@ -288,18 +287,19 @@ module LazyGraph
       def rule_from_when(when_clause)
         inputs = when_clause.keys
         conditions = when_clause
-        rule = "{#{when_clause.keys.map { |k| "#{k}: #{k}}" }.join(', ')}"
+        calc = "{#{when_clause.keys.map { |k| "#{k}: #{k}}" }.join(', ')}"
         {
           inputs: inputs,
           conditions: conditions,
-          rule: rule
+          fixed_result: when_clause,
+          calc: calc
         }
       end
 
       def rule_from_first_of(prop_list)
         {
           inputs: prop_list,
-          rule: "itself.get_first_of(:#{prop_list.join(', :')})"
+          calc: "itself.get_first_of(:#{prop_list.join(', :')})"
         }
       end
 

data/lib/lazy_graph/builder.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 # Subclass LazyGraph::Builder to create new builder classes
 # which can be used to easily build a rule-set to be used as a LazyGraph.
 #
@@ -7,6 +6,17 @@ require_relative 'builder/dsl'
 
 module LazyGraph
   class Builder
+
+    # Cache up to a fixed number of graphs, context and queries
+    BUILD_CACHE_CONFIG = {
+      # Store up to 1000 graphs
+      graph: {size: 1000, cache: {}},
+      # Store up to 5000 configs
+      context: {size: 5000, cache: {}},
+      # Store up to 5000 queries
+      query: {size: 5000, cache: {}}
+    }.compare_by_identity.freeze
+
     include DSL
     # This class is responsible for piece-wise building of rules,
     # as a combined schema definition.
@@ -27,6 +37,17 @@ module LazyGraph
       end
     end
 
+    # Helper for defining a new entity in the schema (just a shorthand for defining a new method for now)
+    def self.entity(name, &blk)
+      module_body_func_name = :"_#{name}"
+      define_method(module_body_func_name, &blk)
+      define_method(name) do |**args, &inner_blk|
+        send(module_body_func_name, **args)
+        inner_blk&.call
+        self
+      end
+    end
+
     class << self
       attr_reader :helper_modules
     end
@@ -67,7 +88,7 @@ module LazyGraph
     end
 
     def self.eval!(modules:, context:, query:, debug: false, validate: false)
-      context_result = (@eval_cache ||= {})[[modules, context, query, debug, validate].hash] ||= begin
+      builder = cache_as(:graph, [modules, debug, validate].hash) do
         invalid_modules = modules.reject { |k, _v| rules_modules[:properties].key?(k.to_sym) }
         return format_error_response('Invalid Modules', invalid_modules.keys.join(',')) unless invalid_modules.empty?
 
@@ -78,21 +99,24 @@ module LazyGraph
         builder = build_modules(modules)
         return builder if builder.is_a?(Hash)
 
-        evaluate_context(builder, context, debug: debug, validate: validate)
+        builder
       end
 
-      @eval_cache.delete(@eval_cache.keys.first) if @eval_cache.size > 1000
+      context_result = cache_as(:context, [builder, context]) do
+        evaluate_context(builder, context, debug: debug, validate: validate)
+      end
 
       return context_result if context_result.is_a?(Hash) && context_result[:type] == :error
 
+      query_result = cache_as(:query, [context_result, query]){ context_result.query(*(query || '')) }
+
       {
         type: :success,
-        result: context_result.query(*(query || ''))
+        result: query_result
       }
-
     rescue SystemStackError => e
       LazyGraph.logger.error(e.message)
-      LazyGraph.logger.error(e.backtrace)
+      LazyGraph.logger.error(e.backtrace.join("\n"))
       {
         type: :error,
         message: 'Recursive Query Detected',
@@ -100,6 +124,14 @@ module LazyGraph
       }
     end
 
+    def self.cache_as(type, key)
+      cache, max_size = BUILD_CACHE_CONFIG[type].values_at(:cache, :size)
+      key = key.hash
+      cache[key] = cache[key] ? cache.delete(key) : yield
+    ensure
+      cache.delete(cache.keys.first) while cache.size > max_size
+    end
+
     private_class_method def self.method_missing(method_name, *args, &block) = new.send(method_name, *args, &block)
     private_class_method def self.respond_to_missing?(_, _ = false) = true
 

data/lib/lazy_graph/context.rb

@@ -7,23 +7,25 @@ module LazyGraph
     attr_accessor :ruleset, :input
 
     def initialize(graph, input)
-      HashUtils.deep_symbolize!(input)
+      input = HashUtils.deep_dup(input, symbolize: true)
       graph.validate!(input) if [true, 'input'].include?(graph.validate)
       @graph = graph
       @input = input
     end
 
     def query(paths)
-      paths.is_a?(Array) ? paths.map { |path| resolve(input, path) } : resolve(input, paths)
+      paths.is_a?(Array) ? paths.map { |path| resolve(path) } : resolve(paths)
     end
 
-    def resolve(input, path)
-      @input = @graph.root_node.fetch_item({ input: input }, :input, nil)
+    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)
       stack.root = stack
 
       result = @graph.root_node.resolve(query, stack)
+
       @graph.root_node.clear_visits!
       if @graph.debug?
         debug_trace = stack.frame[:DEBUG]

data/lib/lazy_graph/graph.rb

@@ -13,18 +13,13 @@ module LazyGraph
     def context(input) = Context.new(self, input)
     def debug? = @debug
 
-    def initialize(json_schema, debug: false, validate: true, helpers: nil)
-      @json_schema = HashUtils.deep_dup!(json_schema).merge(type: :object)
-
+    def initialize(input_schema, debug: false, validate: true, helpers: nil)
+      @json_schema = HashUtils.deep_dup(input_schema, symbolize: true, signature: signature = [0]).merge(type: :object)
       @debug = debug
       @validate = validate
       @helpers = helpers
 
-      signature = HashUtils.deep_symbolize!(@json_schema)
-      if [true, 'schema'].include?(validate)
-        VALIDATION_CACHE[signature] ||= validate!(@json_schema, METASCHEMA)
-        true
-      end
+      VALIDATION_CACHE[signature[0]] ||= validate!(@json_schema, METASCHEMA) if [true, 'schema'].include?(validate)
 
       if @json_schema[:type].to_sym != :object || @json_schema[:properties].nil?
         raise ArgumentError, 'Root schema must be a non-empty object'
@@ -35,31 +30,26 @@ module LazyGraph
 
     def build_node(schema, path = :'$', name = :root, parent = nil)
       schema[:type] = schema[:type].to_sym
-      case schema[:type]
-      when :object then ObjectNode
-      when :array then ArrayNode
-      else Node
-      end.new(name, path, schema, parent, debug: @debug, helpers: @helpers).tap do |node|
-        node.children = build_children(node, schema, path)
+      node = case schema[:type]
+             when :object then ObjectNode
+             when :array then ArrayNode
+             else Node
+             end.new(name, path, schema, parent, debug: @debug, helpers: @helpers)
+
+      if node.type == :object
+        node.children = \
+          {
+            properties: schema.fetch(:properties, {}).map do |key, value|
+              [key, build_node(value, :"#{path}.#{key}", key, node)]
+            end.to_h.compare_by_identity,
+            pattern_properties: schema.fetch(:patternProperties, {}).map do |key, value|
+              [Regexp.new(key.to_s), build_node(value, :"#{path}.#{key}", :'<property>', node)]
+            end
+          }
+      elsif node.type == :array
+        node.children = build_node(schema.fetch(:items, {}), :"#{path}[]", :items, node)
       end
-    end
-
-    def build_children(node, schema, path)
-      case node.type
-      when :object then build_object_children(schema, path, node)
-      when :array then build_node(schema.fetch(:items, {}), :"#{path}[]", :items, node)
-      end
-    end
-
-    def build_object_children(schema, path, parent)
-      {
-        properties: schema.fetch(:properties, {}).map do |key, value|
-          [key, build_node(value, "#{path}.#{key}", key, parent)]
-        end.to_h,
-        pattern_properties: schema.fetch(:patternProperties, {}).map do |key, value|
-          [Regexp.new(key.to_s), build_node(value, :"#{path}.#{key}", :'<property>', parent)]
-        end.to_h
-      }
+      node
     end
 
     def validate!(input, schema = @json_schema)

data/lib/lazy_graph/hash_utils.rb

@@ -4,28 +4,43 @@ module LazyGraph
   module HashUtils
     module_function
 
-    def deep_dup!(hash)
-      case hash
+    # Deeply duplicates a nested hash or array, preserving object identity.
+    # Optionally symbolizes keys on the way, and/or generates a signature.
+    def deep_dup(obj, symbolize: false, signature: nil)
+      case obj
       when Hash
-        hash = hash.dup
-        hash.each do |key, value|
-          hash[key] = deep_dup!(value)
+        obj.each_with_object(symbolize ? {}.compare_by_identity : {}) do |(key, value), result|
+          key = \
+            if !symbolize || key.is_a?(Symbol)
+              key
+            else
+              key.is_a?(String) ? key.to_sym : key.to_s.to_sym
+            end
+
+          signature[0] ^= key.object_id if signature
+          result[key] = deep_dup(value, symbolize: symbolize, signature: signature)
         end
       when Array
-        hash.map { |value| deep_dup!(value) }
+        obj.map { |value| deep_dup(value, symbolize: symbolize, signature: signature) }
+      when String, Numeric, TrueClass, FalseClass, NilClass
+        signature[0] ^= obj.hash if signature
+        obj
+      else
+        obj
       end
-      hash
     end
 
-    def deep_merge(hash, other_hash, path = :'')
+    def deep_merge(hash, other_hash, path = '')
       hash.merge(other_hash.transform_keys(&:to_sym)) do |key, this_val, other_val|
+        current_path = path.empty? ? key.to_s : "#{path}.#{key}"
+
         if this_val.is_a?(Hash) && other_val.is_a?(Hash) && other_val != this_val
-          deep_merge(this_val, other_val, :"#{path}.#{key}")
+          deep_merge(this_val, other_val, current_path)
         elsif this_val.is_a?(Array) && other_val.is_a?(Array) && other_val != this_val
-          this_val.concat(other_val).uniq
+          (this_val | other_val)
         else
           if this_val != other_val && !(this_val.is_a?(Proc) && other_val.is_a?(Proc))
-            LazyGraph.logger.warn("Warning: Conflicting values at #{path}.#{key}. #{this_val}  != #{other_val} ")
+            LazyGraph.logger.warn("Conflicting values at #{current_path}: #{this_val.inspect} != #{other_val.inspect}")
           end
           other_val
         end
@@ -51,37 +66,14 @@ module LazyGraph
           res[key] = strip_invalid(obj[key], parent_list)
         end
       when Array
-        obj.map! { |value| strip_invalid(value, parent_list) }
+        obj.map { |value| strip_invalid(value, parent_list) }
+      when MissingValue
+        nil
       else
         obj
       end
     ensure
       parent_list.delete(obj) unless circular_dependency
     end
-
-    def deep_symbolize!(obj)
-      case obj
-      when Hash
-        hash = 0
-        obj.to_a.each do |key, value|
-          hash ^= deep_symbolize!(value)
-          unless key.is_a?(Symbol)
-            key.to_s.to_sym
-            obj[key.to_s.to_sym] = obj.delete(key)
-          end
-          hash ^= key.object_id
-        end
-        obj.compare_by_identity
-        hash
-      when Array
-        hash = 0
-        obj.each { |item| hash ^= deep_symbolize!(item) }
-        hash
-      when String, Numeric, TrueClass, FalseClass, NilClass
-        obj.hash
-      else
-        0
-      end
-    end
   end
 end

data/lib/lazy_graph/missing_value.rb

@@ -12,6 +12,8 @@ module LazyGraph
     def inspect = to_s
     def coerce(other) = [self, other]
     def as_json = 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

@@ -15,9 +15,9 @@ module LazyGraph
       **
     )
       input = stack_memory.frame
-      @visited[input.object_id ^ (path.object_id << 8)] ||= begin
+      @visited[input.object_id >> 2 ^ path.shifted_id] ||= begin
         if (path_segment = path.segment).is_a?(PathParser::PathGroup)
-          unless path_segment.options.all?(&:index?)
+          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))
@@ -46,7 +46,7 @@ module LazyGraph
             @children.resolve(path.next, stack_memory.push(item, index))
           end
         else
-          if @children.is_object && @children.children[:properties].keys.include?(segment) || input&.first&.key?(segment)
+          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))
@@ -60,8 +60,13 @@ module LazyGraph
       should_recycle&.recycle!
     end
 
+    def children=(value)
+      @children = value
+      @child_properties = @children.children[:properties].compare_by_identity if @children.is_object
+    end
+
     def cast(value)
-      value.dup
+      value
     end
   end
 end

data/lib/lazy_graph/node/derived_rules.rb

@@ -29,6 +29,7 @@ module LazyGraph
         derived = interpret_derived_proc(derived) if derived.is_a?(Proc)
         derived = { inputs: derived.to_s } if derived.is_a?(String) || derived.is_a?(Symbol)
         derived[:inputs] = parse_derived_inputs(derived)
+        @fixed_result = derived[:fixed_result]
         @copy_input = true if !derived[:calc] && derived[:inputs].size == 1
         extract_derived_src(derived) if @debug
 
@@ -42,7 +43,7 @@ module LazyGraph
       end
 
       def interpret_derived_proc(derived)
-        src, requireds, optionals, keywords, = DerivedRules.extract_expr_from_source_location(derived.source_location)
+        src, requireds, optionals, keywords, proc_line, = DerivedRules.extract_expr_from_source_location(derived.source_location)
         src = src.body&.slice || ''
         @src = src.lines.map(&:strip)
         inputs, conditions = parse_args_with_conditions(requireds, optionals, keywords)
@@ -56,7 +57,7 @@ module LazyGraph
             # rubocop:disable:next-line
             derived.source_location.first,
             # rubocop:enable
-            derived.source_location.last.succ
+            derived.source_location.last.succ.succ
           )
         }
       end
@@ -116,7 +117,7 @@ module LazyGraph
             keywords =  (src.parameters&.parameters&.keywords || []).map do |kw|
               [kw.name, kw.value.slice.gsub(/^_\./, '$.')]
             end.to_h
-            [src, requireds, optionals, keywords, mtime]
+            [src, requireds, optionals, keywords, proc_line, mtime]
           end
         end
 
@@ -132,16 +133,21 @@ module LazyGraph
         case inputs
         when Symbol, String
           if inputs =~ PLACEHOLDER_VAR_REGEX && !derived[:calc]
+            @src ||= inputs
             input_hash = {}
+            @input_mapper = {}
             derived[:calc] = inputs.gsub(PLACEHOLDER_VAR_REGEX) do |match|
-              input_hash[match[2...-1]] ||= "a#{::SecureRandom.hex(8)}"
+              sub = input_hash[match[2...-1]] ||= "a#{::SecureRandom.hex(8)}"
+              @input_mapper[sub.to_sym] = match[2...-1].to_sym
+              sub
             end
             input_hash.invert
           else
-            { inputs.to_str.gsub(/[^(?:[A-Za-z][A-Za-z0-9_])]/, '__') => inputs.to_str.freeze }
+            { inputs.to_s.gsub(/[^(?:[A-Za-z][A-Za-z0-9_])]/, '__') => inputs.to_s.freeze }
           end
         when Array
-          inputs.map { |v| { v.to_s.gsub(/[^(?:[A-Za-z][A-Za-z0-9_])]/, '__') => v } }.reduce({}, :merge)
+          pairs = inputs.last.is_a?(Hash) ? inputs.pop : {}
+          inputs.map { |v| { v.to_s.gsub(/[^(?:[A-Za-z][A-Za-z0-9_])]/, '__') => v } }.reduce(pairs, :merge)
         when Hash
           inputs
         else
@@ -150,7 +156,7 @@ module LazyGraph
       end
 
       def extract_derived_src(derived)
-        return @src = derived[:calc].to_s.lines unless derived[:calc].is_a?(Proc)
+        return @src ||= derived[:calc].to_s.lines unless derived[:calc].is_a?(Proc)
 
         @src ||= begin
           extract_expr_from_source_location(derived[:calc].source_location).body.slice.lines.map(&:strip)
@@ -160,7 +166,11 @@ module LazyGraph
       end
 
       def parse_rule_string(derived)
-        instance_eval("->{ #{derived[:calc]} }", __FILE__, __LINE__)
+        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__
+        )
       rescue SyntaxError
         missing_value = MissingValue { "Syntax error in #{derived[:src]}" }
         -> { missing_value }
@@ -172,7 +182,8 @@ module LazyGraph
         Struct.new(*(derived[:inputs].keys.map(&:to_sym) + %i[itself stack_ptr])) do
           def missing?(value) = value.is_a?(LazyGraph::MissingValue) || value.nil?
           helpers&.each { |h| include h }
-          define_method(:process!, &derived[:calc])
+
+          define_method(:process!, &derived[:calc]) if derived[:calc].is_a?(Proc)
           def method_missing(name, *args, &block)
             stack_ptr.send(name, *args, &block)
           end

data/lib/lazy_graph/node/node_properties.rb

@@ -5,13 +5,11 @@ module LazyGraph
     def self.build(members:, invisible:)
       Struct.new(*members, keyword_init: true) do
         define_method(:initialize) do |kws|
-          members.each { |k| self[k] = kws[k] || MissingValue::BLANK }
+          members.each { |k| self[k] = kws[k].then { |v| v.nil? ? MissingValue::BLANK : v } }
         end
 
         define_method(:key?) do |x|
           !self[x].equal?(MissingValue::BLANK)
-        rescue StandardError
-          nil
         end
 
         define_method(:[]=) do |key, val|
@@ -26,12 +24,16 @@ module LazyGraph
           invisible
         end
 
+        def to_hash
+          to_h
+        end
+
         define_method(:each_key, &members.method(:each))
 
         def dup
-          self.class.new(members.map do |k|
-            [k, self[k].dup]
-          end.to_h)
+          duplicate = self.class.new
+          members.each { duplicate[_1] = self[_1].dup }
+          duplicate
         end
 
         def get_first_of(*props)
@@ -42,18 +44,13 @@ module LazyGraph
         end
 
         def pretty_print(q)
-          # Start the custom pretty print
           q.group(1, '<Props ', '>') do
             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}="
-                if value.respond_to?(:pretty_print)
-                  q.pp(value) # Delegate to the nested value's pretty_print
-                else
-                  q.text value.inspect
-                end
+                value.respond_to?(:pretty_print) ? q.pp(value) : q.text(value.inspect)
               end
             end
           end

data/lib/lazy_graph/node/object_node.rb

@@ -1,5 +1,7 @@
 module LazyGraph
   class ObjectNode < Node
+    require_relative 'symbol_hash'
+
     # 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 }
@@ -11,7 +13,10 @@ module LazyGraph
       preserve_keys: false
     )
       input = stack_memory.frame
-      @visited[input.object_id ^ (path.object_id << 8)] ||= begin
+
+      @visited[input.object_id >> 2 ^ path.shifted_id] ||= begin
+        return input if input.is_a?(MissingValue)
+
         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)
@@ -23,9 +28,9 @@ module LazyGraph
             item = node.fetch_item(input, key, stack_memory)
             node.resolve(path.next, stack_memory.push(item, key))
           end
-          if @pattern_properties_a.any? && input.keys.length > @properties_a.length
+          if @pattern_properties.any? && input.keys.length > @properties_a.length
             input.each_key do |key|
-              node = !@properties[key] && @pattern_properties_a.find { |pattern, _value| pattern.match?(key) }&.last
+              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))
             end
@@ -40,14 +45,14 @@ module LazyGraph
         elsif segment == :*
           # rubocop:disable
           (input.keys | @properties_a.map(&:first)).each do |key|
-            next unless (node = @properties[key] || @pattern_properties_a.find do |pattern, _value|
+            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
-        elsif (_, prop = @pattern_properties_a.find { |key, _val| key.match?(segment) })
+        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)
@@ -85,28 +90,29 @@ module LazyGraph
 
       @properties = @children.fetch(:properties, {})
       @properties.compare_by_identity
-      @pattern_properties = @children.fetch(:pattern_properties, {})
+      @pattern_properties = @children.fetch(:pattern_properties, [])
 
       @properties_a = @properties.to_a
-      @pattern_properties_a = @pattern_properties.to_a
 
       @has_properties = @properties.any? || @pattern_properties.any?
-      return if @pattern_properties.any?
-      return unless @properties.any?
 
-      invisible = @properties.select { |_k, v| v.invisible }.map(&:first)
-      @property_class = PROPERTY_CLASSES[{ members: @properties.keys + (@debug && !parent ? [:DEBUG] : []),
-                                           invisible: invisible }]
+      return unless @properties.any? || @pattern_properties.any?
+
+      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
 
-    def cast(value)
-      if !@property_class && value.is_a?(Hash)
-        value.default_proc = ->(h, k) { k.is_a?(Symbol) ? nil : h[k.to_s.to_sym] }
-        value.compare_by_identity
-      elsif @property_class && !value.is_a?(@property_class)
-        @property_class.new(value.to_h)
+    private def build_caster
+      if @property_class
+        ->(value) { value.is_a?(@property_class) ? value : @property_class.new(value.to_h) }
       else
-        value
+        ->(value) { value }
       end
     end
   end

data/lib/lazy_graph/node/symbol_hash.rb

@@ -0,0 +1,26 @@
+module LazyGraph
+  class ObjectNode < Node
+    class SymbolHash < ::Hash
+      def initialize(input_hash)
+        super
+        merge!(input_hash)
+      end
+
+      def []=(key, value)
+        case key
+        when Symbol then super(key, value)
+        when String then super(key.to_sym, value)
+        else super(key.to_s.to_sym, value)
+        end
+      end
+
+      def [](key)
+        case key
+        when Symbol then super(key)
+        when String then super(key.to_sym)
+        else super(key.to_s.to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/lazy_graph/node.rb

@@ -1,3 +1,4 @@
+require 'debug'
 # frozen_string_literal: true
 
 require 'bigdecimal/util'
@@ -48,16 +49,16 @@ module LazyGraph
       @depth = parent ? parent.depth + 1 : 0
       @root = parent ? parent.root : self
       @type = node[:type]
-      @invisible = node[:invisible]
+      @invisible = debug ? false : node[:invisible]
       @visited = {}.compare_by_identity
-
+      instance_variable_set("@is_#{@type}", true)
+      define_singleton_method(:cast, build_caster)
       define_missing_value_proc!
 
       @has_default = node.key?(:default)
-      @default = @has_default ? node[:default] : MissingValue { @name }
+      @default = @has_default ? cast(node[:default]) : MissingValue { @name }
       @resolution_stack = []
 
-      instance_variable_set("@is_#{@type}", true)
       build_derived_inputs(node[:rule], helpers) if node[:rule]
     end
 
@@ -68,16 +69,46 @@ module LazyGraph
       )
     end
 
+    private 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 }
+      elsif @is_boolean
+        lambda do |value|
+          if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+            value
+          else
+            value.is_a?(MissingValue) ? false : !!value
+          end
+        end
+      elsif @is_timestamp
+        lambda do |value|
+          case value
+          when String
+            DateTime.parse(value).to_time
+          when Numeric
+            Time.at(value)
+          else
+            value
+          end
+        end
+      else
+        ->(value) { value }
+      end
+    end
+
     def clear_visits!
       @visited.clear
+      @resolution_stack.clear
+      @path_cache = {}.clear
+      @resolvers = {}.clear
+
       return unless @children
       return @children.clear_visits! if @children.is_a?(Node)
 
-      @children[:properties]&.each do |_, node|
-        node.clear_visits!
-      end
-
-      @children[:pattern_properties]&.each do |_, node|
+      @children[:properties]&.each_value(&:clear_visits!)
+      @children[:pattern_properties]&.each do |(_, node)|
         node.clear_visits!
       end
     end
@@ -101,7 +132,7 @@ module LazyGraph
       case input
       when Hash
         node = Node.new(key, "#{path}.#{key}", { type: :object }, self)
-        node.children = { properties: {}, pattern_properties: {} }
+        node.children = { properties: {}, pattern_properties: [] }
         node
       when Array
         node = Node.new(key, :"#{path}.#{key}[]", { type: :array }, self)
@@ -111,7 +142,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 == :object
         node
       else
         Node.new(key, :"#{path}.#{key}", {}, self)
@@ -131,7 +162,7 @@ module LazyGraph
     end
 
     def resolve_input(stack_memory, path, key)
-      input_id = key.object_id ^ (stack_memory.object_id << 8)
+      input_id = key.object_id >> 2 ^ stack_memory.shifted_id
       if @resolution_stack.include?(input_id)
         if @debug
           stack_memory.log_debug(
@@ -143,8 +174,9 @@ module LazyGraph
       end
 
       @resolution_stack << (input_id)
-      first_segment = path.parts.first.part
-      resolver_node = @resolvers[first_segment] ||= (first_segment == key ? parent.parent : parent).find_resolver_for(first_segment)
+      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)
@@ -161,35 +193,13 @@ module LazyGraph
     end
 
     def ancestors
-      @ancestors ||= [self, *(parent ? parent.ancestors : [])]
+      @ancestors ||= [self, *(@parent ? @parent.ancestors : [])]
     end
 
     def find_resolver_for(segment)
       segment == :'$' ? root : @parent&.find_resolver_for(segment)
     end
 
-    def cast(value)
-      if @is_decimal
-        value.is_a?(BigDecimal) ? value : value.to_d
-      elsif @is_date
-        value.is_a?(String) ? Date.parse(value) : value
-      elsif @is_boolean
-        if value.is_a?(TrueClass) || value.is_a?(FalseClass)
-          value
-        else
-          value.is_a?(MissingValue) ? false : !!value
-        end
-      elsif @is_timestamp
-        case value
-        when String then DateTime.parse(value).to_time
-        when Numeric then Time.at(value)
-        else value
-        end
-      else
-        value
-      end
-    end
-
     def fetch_item(input, key, stack)
       return MissingValue { key } unless input
 
@@ -214,7 +224,7 @@ module LazyGraph
       end
     end
 
-    def copy_item!(input, key, stack, (path, i, segment_indexes))
+    def copy_item!(input, key, stack, (path, _i, segment_indexes))
       if segment_indexes
         missing_value = nil
         parts = path.parts.dup
@@ -240,7 +250,6 @@ module LazyGraph
           calc: @src
         )
       end
-
       input[key] = result.nil? ? MissingValue { key } : result
     end
 
@@ -255,12 +264,11 @@ module LazyGraph
             break missing_value = part if part.is_a?(MissingValue)
 
             part_sym = part.to_s.to_sym
-            parts_identity ^= part_sym.object_id << index
+            parts_identity ^= part_sym.object_id << (index * 8)
             parts[index] = @path_cache[part_sym] ||= PathParser::PathPart.new(part: part_sym)
           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
       end
@@ -268,22 +276,24 @@ module LazyGraph
       @node_context[:itself] = input
       @node_context[:stack_ptr] = stack
 
-      conditions_passed = !@conditions || @conditions.all? do |field, allowed_value|
-        allowed_value.is_a?(Array) ? allowed_value.include?(@node_context[field]) : allowed_value == @node_context[field]
-      end
+      conditions_passed = !(@conditions&.any? do |field, allowed_value|
+        allowed_value.is_a?(Array) ? !allowed_value.include?(@node_context[field]) : allowed_value != @node_context[field]
+      end)
 
       ex = nil
       result = \
         if conditions_passed
           output = begin
-            cast(@node_context.process!)
+            cast(@fixed_result || @node_context.process!)
           rescue LazyGraph::AbortError => e
             raise e
           rescue StandardError => e
             ex = e
+            LazyGraph.logger.error(e)
+            LazyGraph.logger.error(e.backtrace.join("\n"))
             MissingValue { "#{key} raised exception: #{e.message}" }
           end
-          output = output.dup if @has_properties
+
           input[key] = output.nil? ? MissingValue { key } : output
         else
           MissingValue { key }
@@ -292,22 +302,18 @@ module LazyGraph
       if @debug
         stack.log_debug(
           output: :"#{stack}.#{key}",
-          result: result,
-          inputs: @node_context.to_h.except(:itself, :stack_ptr),
+          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 ex
+               { exception: ex, backtrace: ex.backtrace.take_while do |line|
+                 !line.include?('lazy_graph/node.rb')
+               end }
+             else
+               {}
+             end
+            )
         )
       end
       result

data/lib/lazy_graph/path_parser/path.rb

@@ -11,9 +11,10 @@ module LazyGraph
       def next        = @next ||= parts.length <= 1 ? Path::BLANK : Path.new(parts: parts[1..])
       def empty?      = @empty ||= parts.empty?
       def segment     = @segment ||= parts&.[](0)
-      def index?      = @index   ||= parts.any? && parts.first.index?
-      def identity    = @identity ||= parts&.each_with_index&.reduce(0) { |acc, (p, i)| acc ^ (p.object_id) << (i * 4) }
+      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 merge(other)
         (@merged ||= {})[other] ||= \

data/lib/lazy_graph/server.rb

@@ -11,6 +11,7 @@ module LazyGraph
 
     def call(env)
       # Rack environment contains request details
+      env[:X_REQUEST_TIME_START] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       request = Rack::Request.new(env)
 
       unless (graph_module = @routes[request.path.to_sym])
@@ -73,13 +74,17 @@ module LazyGraph
       error!(request, 404, 'Not Found', details)
     end
 
+    def request_ms(request)
+      ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - request.env[:X_REQUEST_TIME_START]) * 1000.0).round(3)
+    end
+
     def success!(request, result, status: 200)
-      LazyGraph.logger.info("#{request.request_method}: #{request.path} => #{status}")
+      LazyGraph.logger.info("#{request.request_method}: #{request.path} => #{status} #{request_ms(request)}ms")
       [status, { 'Content-Type' => 'text/json' }, [result.to_json]]
     end
 
     def error!(request, status, message, details = '')
-      LazyGraph.logger.info("#{request.request_method}: #{request.path} => #{status}")
+      LazyGraph.logger.info("#{request.request_method}: #{request.path} => #{status} #{request_ms(request)}ms")
       [status, { 'Content-Type' => 'text/json' }, [{ 'error': message, 'details': details }.to_json]]
     end
   end

data/lib/lazy_graph/stack_pointer.rb

@@ -5,13 +5,21 @@ module LazyGraph
   POINTER_POOL = []
 
   StackPointer = Struct.new(:parent, :frame, :depth, :key, :root) do
+    attr_accessor :pointer_cache
+
+    def shifted_id  = @shifted_id ||= object_id << 28
+
     def push(frame, key)
-      (POINTER_POOL.pop || StackPointer.new).tap do |pointer|
-        pointer.parent = self
-        pointer.frame = frame
-        pointer.key = key
-        pointer.depth = depth + 1
-        pointer.root = root || self
+      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
     end
 
@@ -21,9 +29,8 @@ module LazyGraph
     end
 
     def ptr_at(index)
-      return self if depth == index
-
-      parent&.ptr_at(index)
+      @pointer_cache ||= {}.compare_by_identity
+      @pointer_cache[index] ||= depth == index ? self : parent&.ptr_at(index)
     end
 
     def method_missing(name, *args, &block)
@@ -36,9 +43,14 @@ module LazyGraph
       end
     end
 
+    def index
+      key
+    end
+
     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
 
     def respond_to_missing?(name, include_private = false)

data/lib/lazy_graph/version.rb

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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: lazy_graph
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Wouter Coppieters
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-12-22 00:00:00.000000000 Z
+date: 2024-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema
@@ -164,6 +163,7 @@ files:
 - lib/lazy_graph/node/derived_rules.rb
 - lib/lazy_graph/node/node_properties.rb
 - lib/lazy_graph/node/object_node.rb
+- lib/lazy_graph/node/symbol_hash.rb
 - lib/lazy_graph/path_parser.rb
 - lib/lazy_graph/path_parser/path.rb
 - lib/lazy_graph/path_parser/path_group.rb
@@ -178,7 +178,6 @@ licenses:
 metadata:
   homepage_uri: https://github.com/wouterken/lazy_graph
   source_code_uri: https://github.com/wouterken/lazy_graph
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -193,8 +192,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: JSON Driven, Stateless Rules Engine
 test_files: []