lazy_graph 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e561f823062b3d3aedb3274a14d80e6bf1a17547bc3fbcb691cab37fc22ee014
-  data.tar.gz: c353086cec79a6ceaf1c38db742f222474172be184307dab69f00c5f054eb081
+  metadata.gz: 29043baea3639e83c226d8e157af818466d50d4e3c125853dac64ae411aa0c0a
+  data.tar.gz: f137caa57317cd9046bc16384bf657ca7c43d10b12701f30be6bc7a31580c6db
 SHA512:
-  metadata.gz: 2ed546ebffbcefd7d5ed3aa2651dec8d692cc8354e37f05ac2cf99f1e059417a603d22aa54e37ef1bdcd9ef0e498f30e4ef38337a2ec4dc412553a2e385f2bd9
-  data.tar.gz: 67735a1964a486e136aeb03ce355fc1c0a873dca5a86a6a953cabbcaa33f49b3ca4ab6082dadef92157ac94eb78c8bfb37b40c9ab1f0354c39807c3d97032042
+  metadata.gz: b1c5107a005882da016caa1fd54afa5131f296637fd6a7b18810d3b2c1f18893ae11938e63fc42ceec05def4ceba76afbe016b152d1c107225af148b06f6db52
+  data.tar.gz: b5a2126ac97b38e1e0d4ce23a1d46859a89979b0b09a2d3ad3e3676b763d6277745310ee08a0c49fbbc85bcd930d246362bd79793899726c2f763b0aa1f6fe44

data/examples/performance_tests.rb

@@ -15,14 +15,14 @@ class PerformanceBuilder < LazyGraph::Builder
 
         object :position, rule: :"${$.positions[position_id]}"
         object :pay_schedule, rule: :'${pay_schedules[pay_schedule_id]}'
-        number :base_rate, rule: :"${position.base_rate}"
+        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
@@ -56,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,16 +261,12 @@ module LazyGraph
           **(description ? { description: description } : {}),
           **(rule ? { rule: rule } : {}),
           **opts,
-          items: {
-            type: type,
-            **(
-              type == :object ? { properties: {}, additionalProperties: false } : {}
-            )
-          }
+          items: { properties: {} }.tap do |items|
+            yields(items) do
+              send(type, :items, &blk)
+            end
+          end[:properties][:items]
         }
-        yields(new_array) do
-          items(&blk)
-        end
         required(name) if required && default.nil? && rule.nil?
         pattern_property ? set_pattern_property(name, new_array) : set_property(name, new_array)
       end
@@ -291,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.
@@ -29,7 +39,13 @@ module LazyGraph
 
     # Helper for defining a new entity in the schema (just a shorthand for defining a new method for now)
     def self.entity(name, &blk)
-      define_method(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
@@ -72,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?
 
@@ -83,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',
@@ -105,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,24 +7,25 @@ module LazyGraph
     attr_accessor :ruleset, :input
 
     def initialize(graph, input)
-      input = HashUtils.deep_dup(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.compare_by_identity,
-        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,25 +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.dup.each { |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
@@ -48,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.shifted_id] ||= 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
 
@@ -142,10 +143,11 @@ module LazyGraph
             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
@@ -164,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 }
@@ -176,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.shifted_id] ||= 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,33 +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.define_singleton_method(:[]=) do |k, v|
-          super(!k.is_a?(Symbol) ? k.to_s.to_sym : k, v)
-        end
-        value.define_singleton_method(:[]) do |k|
-          super(!k.is_a?(Symbol) ? k.to_s.to_sym : k)
-        end
-        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.shifted_id
+      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
@@ -259,7 +269,6 @@ 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
       end
@@ -267,22 +276,23 @@ 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
@@ -292,22 +302,18 @@ module LazyGraph
       if @debug
         stack.log_debug(
           output: :"#{stack}.#{key}",
-          result: result,
+          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,10 +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 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 << 32
+      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,15 +5,21 @@ module LazyGraph
   POINTER_POOL = []
 
   StackPointer = Struct.new(:parent, :frame, :depth, :key, :root) do
-    def shifted_id  = @shifted_id ||= object_id << 32
+    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
 
@@ -23,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)
@@ -38,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.1'
+  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.1
+  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: []