lazy_graph 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df09bd7d0c4f8a82c1cdbaf387dfc6e18ec9f9b6f492a1aa17b2942f1e14a947
-  data.tar.gz: c9887fff1a0eacb38b5ec426f13ce5a8fc23e7d6602a1876a398773628a3461e
+  metadata.gz: e561f823062b3d3aedb3274a14d80e6bf1a17547bc3fbcb691cab37fc22ee014
+  data.tar.gz: c353086cec79a6ceaf1c38db742f222474172be184307dab69f00c5f054eb081
 SHA512:
-  metadata.gz: a90efb82622865574cffd51c996ceeaec5f8f29534da07869ef3c0bb2de3056031ec4c0357b41a3e4fe0390e4e8e364bd07b76f1073b08a8beb95124f7eda301
-  data.tar.gz: 508a463c441ebd661871d8655e52dd230bbdc2e4458898a6399099dcc6ef70d90455042f5e960c471f64c77fb56b1456a2c8919b6f0ac28ba769b0a2374fb8a0
+  metadata.gz: 2ed546ebffbcefd7d5ed3aa2651dec8d692cc8354e37f05ac2cf99f1e059417a603d22aa54e37ef1bdcd9ef0e498f30e4ef38337a2ec4dc412553a2e385f2bd9
+  data.tar.gz: 67735a1964a486e136aeb03ce355fc1c0a873dca5a86a6a953cabbcaa33f49b3ca4ab6082dadef92157ac94eb78c8bfb37b40c9ab1f0354c39807c3d97032042

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,23 +8,15 @@ 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 :base_rate, rule: :"${position.base_rate}"
+        string :employee_id, rule: :id
       end
     end
 

data/lib/lazy_graph/builder/dsl.rb

@@ -263,11 +263,14 @@ module LazyGraph
           **opts,
           items: {
             type: type,
-            properties: {},
-            additionalProperties: false
+            **(
+              type == :object ? { properties: {}, additionalProperties: false } : {}
+            )
           }
         }
-        yields(new_array, &blk)
+        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

data/lib/lazy_graph/builder.rb

@@ -27,6 +27,11 @@ 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)
+      define_method(name, &blk)
+    end
+
     class << self
       attr_reader :helper_modules
     end

data/lib/lazy_graph/context.rb

@@ -7,6 +7,7 @@ module LazyGraph
     attr_accessor :ruleset, :input
 
     def initialize(graph, input)
+      input = HashUtils.deep_dup(input)
       HashUtils.deep_symbolize!(input)
       graph.validate!(input) if [true, 'input'].include?(graph.validate)
       @graph = graph

data/lib/lazy_graph/graph.rb

@@ -14,7 +14,7 @@ module LazyGraph
     def debug? = @debug
 
     def initialize(json_schema, debug: false, validate: true, helpers: nil)
-      @json_schema = HashUtils.deep_dup!(json_schema).merge(type: :object)
+      @json_schema = HashUtils.deep_dup(json_schema).merge(type: :object)
 
       @debug = debug
       @validate = validate
@@ -55,7 +55,7 @@ module LazyGraph
       {
         properties: schema.fetch(:properties, {}).map do |key, value|
           [key, build_node(value, "#{path}.#{key}", key, parent)]
-        end.to_h,
+        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

data/lib/lazy_graph/hash_utils.rb

@@ -4,15 +4,12 @@ module LazyGraph
   module HashUtils
     module_function
 
-    def deep_dup!(hash)
+    def deep_dup(hash)
       case hash
       when Hash
-        hash = hash.dup
-        hash.each do |key, value|
-          hash[key] = deep_dup!(value)
-        end
+        hash.dup.each { |key, value| hash[key] = deep_dup(value) }
       when Array
-        hash.map { |value| deep_dup!(value) }
+        hash.map { |value| deep_dup(value) }
       end
       hash
     end

data/lib/lazy_graph/node/array_node.rb

@@ -15,7 +15,7 @@ module LazyGraph
       **
     )
       input = stack_memory.frame
-      @visited[input.object_id ^ (path.object_id << 8)] ||= begin
+      @visited[input.object_id ^ path.shifted_id] ||= begin
         if (path_segment = path.segment).is_a?(PathParser::PathGroup)
           unless path_segment.options.all?(&:index?)
             return input.length.times.map do |index|

data/lib/lazy_graph/node/derived_rules.rb

@@ -132,9 +132,13 @@ 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
@@ -150,7 +154,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)

data/lib/lazy_graph/node/object_node.rb

@@ -11,7 +11,7 @@ module LazyGraph
       preserve_keys: false
     )
       input = stack_memory.frame
-      @visited[input.object_id ^ (path.object_id << 8)] ||= begin
+      @visited[input.object_id ^ path.shifted_id] ||= begin
         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)
@@ -101,7 +101,12 @@ module LazyGraph
 
     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.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)

data/lib/lazy_graph/node.rb

@@ -131,7 +131,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 ^ stack_memory.shifted_id
       if @resolution_stack.include?(input_id)
         if @debug
           stack_memory.log_debug(
@@ -240,7 +240,6 @@ module LazyGraph
           calc: @src
         )
       end
-
       input[key] = result.nil? ? MissingValue { key } : result
     end
 
@@ -255,7 +254,7 @@ 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
@@ -284,6 +283,7 @@ module LazyGraph
             MissingValue { "#{key} raised exception: #{e.message}" }
           end
           output = output.dup if @has_properties
+
           input[key] = output.nil? ? MissingValue { key } : output
         else
           MissingValue { key }
@@ -293,7 +293,7 @@ module LazyGraph
         stack.log_debug(
           output: :"#{stack}.#{key}",
           result: result,
-          inputs: @node_context.to_h.except(:itself, :stack_ptr),
+          inputs: @node_context.to_h.except(:itself, :stack_ptr).transform_keys { |k| @input_mapper&.[](k) || k },
           calc: @src,
           **(@conditions ? { conditions: @conditions } : {}),
           **(

data/lib/lazy_graph/path_parser/path.rb

@@ -12,8 +12,9 @@ module LazyGraph
       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 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 merge(other)
         (@merged ||= {})[other] ||= \

data/lib/lazy_graph/stack_pointer.rb

@@ -5,6 +5,8 @@ module LazyGraph
   POINTER_POOL = []
 
   StackPointer = Struct.new(:parent, :frame, :depth, :key, :root) do
+    def shifted_id  = @shifted_id ||= object_id << 32
+
     def push(frame, key)
       (POINTER_POOL.pop || StackPointer.new).tap do |pointer|
         pointer.parent = self

data/lib/lazy_graph/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lazy_graph
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Wouter Coppieters