lazy_graph 0.1.3 → 0.2.0

data/lib/lazy_graph/graph.rb

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

data/lib/lazy_graph/hash_utils.rb

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

data/lib/lazy_graph/logger.rb

@@ -0,0 +1,87 @@
+require 'logger'
+require_relative 'environment'
+
+module LazyGraph
+  class << self
+    attr_accessor :logger
+  end
+
+  module Logger
+    COLORIZED_LOGS = !ENV['DISABLED_COLORIZED_LOGS'] && ENV.fetch('RACK_ENV', 'development') == 'development'
+
+    module_function
+
+    class << self
+      attr_accessor :color_enabled, :structured
+    end
+
+    def structured
+      return @structured if defined?(@structured)
+      @structured = !LazyGraph::Environment.development?
+    end
+
+    def default_logger
+      logger = ::Logger.new($stdout)
+      self.color_enabled ||= Logger::COLORIZED_LOGS
+      if self.color_enabled
+        logger.formatter = proc do |severity, datetime, progname, message|
+          light_gray_timestamp = "\e[90m[##{Process.pid}] #{datetime.strftime('%Y-%m-%dT%H:%M:%S.%6N')}\e[0m" # Light gray timestamp
+          "#{light_gray_timestamp} \e[1m#{severity}\e[0m #{progname}: #{message}\n"
+        end
+      elsif self.structured
+        logger.formatter = proc do |severity, datetime, progname, message|
+          "#{{severity:, datetime:, progname:, **(message.is_a?(Hash) ? message : {message: }) }.to_json}\n"
+        end
+      else
+        logger.formatter = proc do |severity, datetime, progname, message|
+          "[##{Process.pid}] #{datetime.strftime('%Y-%m-%dT%H:%M:%S.%6N')} #{severity} #{progname}: #{message}\n"
+        end
+      end
+      logger
+    end
+
+    def build_color_string(&blk)
+      return unless block_given?
+
+      instance_eval(&blk)
+    end
+
+    def colorize(text, color_code)
+      @color_enabled ? "\e[#{color_code}m#{text}\e[0m" : text
+    end
+
+    def green(text)
+      colorize(text, 32) # Green for success
+    end
+
+    def red(text)
+      colorize(text, 31) # Red for errors
+    end
+
+    def yellow(text)
+      colorize(text, 33) # Yellow for warnings or debug
+    end
+
+    def blue(text)
+      colorize(text, 34) # Blue for info
+    end
+
+    def light_gray(text)
+      colorize(text, 90) # Light gray for faded text
+    end
+
+    def orange(text)
+      colorize(text, '38;5;214')
+    end
+
+    def bold(text)
+      colorize(text, 1) # Bold text
+    end
+
+    def dim(text)
+      colorize(text, 2) # Italic text
+    end
+  end
+
+  self.logger = Logger.default_logger
+end

data/lib/lazy_graph/missing_value.rb

@@ -8,13 +8,20 @@ module LazyGraph
 
     def initialize(details) = @details = details
     def to_s = "MISSING[#{@details}]"
-
     def inspect = to_s
     def coerce(other) = [self, other]
     def as_json = nil
+    def to_h = nil
     def +(other) = other
-
     def respond_to_missing?(_method_name, _include_private = false) = true
+    def to_i = 0
+    def to_f = 0.0
+
+    def ==(other)
+      return true if other.nil?
+
+      super
+    end
 
     def method_missing(method, *args, &block)
       return super if method == :to_ary

data/lib/lazy_graph/node/array_node.rb

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

data/lib/lazy_graph/node/derived_rules.rb

@@ -25,6 +25,7 @@ module LazyGraph
       def build_derived_inputs(derived, helpers)
         @resolvers = {}.compare_by_identity
         @path_cache = {}.compare_by_identity
+        @resolution_stack = {}.compare_by_identity
 
         derived = interpret_derived_proc(derived) if derived.is_a?(Proc)
         derived = { inputs: derived.to_s } if derived.is_a?(String) || derived.is_a?(Symbol)
@@ -43,9 +44,10 @@ module LazyGraph
       end
 
       def interpret_derived_proc(derived)
-        src, requireds, optionals, keywords, proc_line, = DerivedRules.extract_expr_from_source_location(derived.source_location)
-        src = src.body&.slice || ''
-        @src = src.lines.map(&:strip)
+        src, requireds, optionals, keywords, loc = DerivedRules.extract_expr_from_source_location(derived.source_location)
+        body = src.body&.slice || ''
+        @src = body.lines.map(&:strip)
+        offset = src.slice.lines.length - body.lines.length
         inputs, conditions = parse_args_with_conditions(requireds, optionals, keywords)
 
         {
@@ -53,11 +55,11 @@ module LazyGraph
           mtime: File.mtime(derived.source_location.first),
           conditions: conditions,
           calc: instance_eval(
-            "->(#{inputs.keys.map { |k| "#{k}=self.#{k}" }.join(', ')}){ #{src}}",
+            "->(#{inputs.keys.map { |k| "#{k}=self.#{k}" }.join(', ')}){ #{body}}",
             # rubocop:disable:next-line
             derived.source_location.first,
             # rubocop:enable
-            derived.source_location.last.succ.succ
+            derived.source_location.last + offset
           )
         }
       end
@@ -77,13 +79,21 @@ module LazyGraph
         [keywords, conditions.any? ? conditions : nil]
       end
 
+      def self.get_file_body(file_path)
+        @file_body_cache ||= {}
+        if @file_body_cache[file_path]&.last.to_i < File.mtime(file_path).to_i
+          @file_body_cache[file_path] = [IO.readlines(file_path), File.mtime(file_path).to_i]
+        end
+        @file_body_cache[file_path]&.first
+      end
+
       def self.extract_expr_from_source_location(source_location)
         @derived_proc_cache ||= {}
         mtime = File.mtime(source_location.first).to_i
-
         if @derived_proc_cache[source_location]&.last.to_i.< mtime
           @derived_proc_cache[source_location] = begin
-            source_lines = IO.readlines(source_location.first)
+            source_lines = get_file_body(source_location.first)
+
             proc_line = source_location.last - 1
             first_line = source_lines[proc_line]
             until first_line =~ /(?:lambda|proc|->)/ || proc_line.zero?
@@ -124,7 +134,7 @@ module LazyGraph
         @derived_proc_cache[source_location]
       rescue StandardError => e
         LazyGraph.logger.error(e.message)
-        LazyGraph.logger.error(e.backtrace)
+        LazyGraph.logger.error(e.backtrace.join("\n"))
         raise "Failed to extract expression from source location: #{source_location}. Ensure the file exists and the line number is correct. Extraction from a REPL is not supported"
       end
 
@@ -132,15 +142,16 @@ module LazyGraph
         inputs = derived[:inputs]
         case inputs
         when Symbol, String
-          if inputs =~ PLACEHOLDER_VAR_REGEX && !derived[:calc]
+          if !derived[:calc]
             @src ||= inputs
             input_hash = {}
             @input_mapper = {}
-            derived[:calc] = inputs.gsub(PLACEHOLDER_VAR_REGEX) do |match|
+            calc = inputs.gsub(PLACEHOLDER_VAR_REGEX) do |match|
               sub = input_hash[match[2...-1]] ||= "a#{::SecureRandom.hex(8)}"
               @input_mapper[sub.to_sym] = match[2...-1].to_sym
               sub
             end
+            derived[:calc] = calc unless calc == input_hash.values.first
             input_hash.invert
           else
             { inputs.to_s.gsub(/[^(?:[A-Za-z][A-Za-z0-9_])]/, '__') => inputs.to_s.freeze }
@@ -167,10 +178,20 @@ module LazyGraph
 
       def parse_rule_string(derived)
         calc_str = derived[:calc]
-        src = @src
-        instance_eval(
-          "->{ begin; #{calc_str}; rescue StandardError => e; LazyGraph.logger.error(\"Exception in \#{src}. \#{e.message}\"); LazyGraph.logger.error(e.backtrace.join(\"\\n\")); raise; end  }", __FILE__, __LINE__
-        )
+        node_path = path
+
+        src = <<~RUBY, @rule_location&.first, @rule_location&.last.to_i - 2
+          ->{
+            begin
+              #{calc_str}
+            rescue StandardError => e;
+              LazyGraph.logger.error("Exception in \#{calc_str} => \#{node_path}. \#{e.message}")
+              raise e
+            end
+            }
+        RUBY
+
+        instance_eval(*src)
       rescue SyntaxError
         missing_value = MissingValue { "Syntax error in #{derived[:src]}" }
         -> { missing_value }
@@ -194,12 +215,46 @@ module LazyGraph
         end.new
       end
 
+      def resolver_for(path)
+        segment = path.segment.part
+        return root.properties[path.next.segment.part] if segment == :'$'
+
+        (segment == name ? parent.parent : @parent).find_resolver_for(segment)
+      end
+
+      def rule_definition_backtrace
+        if @rule_location && @rule_location.size >= 2
+          rule_file, rule_line = @rule_location
+          rule_entry = "#{rule_file}:#{rule_line}:in `rule`"
+        else
+          rule_entry = 'unknown_rule_location'
+        end
+
+        current_backtrace = caller.reverse.take_while { |line| !line.include?('/lib/lazy_graph/') }.reverse
+        [rule_entry] + current_backtrace
+      end
+
       def map_derived_inputs_to_paths(inputs)
         inputs.values.map.with_index do |path, idx|
-          segment_indexes = path.parts.map.with_index do |segment, i|
-            segment.is_a?(PathParser::PathGroup) && segment.options.length == 1 ? i : nil
+          segments = path.parts.map.with_index do |segment, i|
+            if segment.is_a?(PathParser::PathGroup) &&
+               segment.options.length == 1 && !((resolver = resolver_for(segment.options.first)) || segment.options.first.segment.part.to_s =~ /\d+/)
+              raise(ValidationError.new(
+                "Invalid dependency in #{@path}: #{segment.options.first.to_path_str}  cannot be resolved."
+              ).tap { |e| e.set_backtrace(rule_definition_backtrace) })
+            end
+
+            resolver ? [i, resolver] : nil
           end.compact
-          [path, idx, segment_indexes.any? ? segment_indexes : nil]
+          resolver = resolver_for(path)
+
+          unless resolver
+            raise(ValidationError.new(
+              "Invalid dependency in #{@path}: #{path.to_path_str}  cannot be resolved."
+            ).tap { |e| e.set_backtrace(rule_definition_backtrace) })
+          end
+
+          [path, resolver, idx, segments.any? ? segments : nil]
         end
       end
     end

data/lib/lazy_graph/node/node_properties.rb

@@ -8,14 +8,27 @@ module LazyGraph
           members.each { |k| self[k] = kws[k].then { |v| v.nil? ? MissingValue::BLANK : v } }
         end
 
+        members.each do |m|
+          define_method(m) do
+            self[m]
+          end
+        end
+
+        alias_method :original_get, :[]
+
         define_method(:key?) do |x|
-          !self[x].equal?(MissingValue::BLANK)
+          !original_get(x).equal?(MissingValue::BLANK)
         end
 
         define_method(:[]=) do |key, val|
           super(key, val)
         end
 
+        define_method(:[]) do |key|
+          res = original_get(key)
+          res.is_a?(MissingValue) ? nil : res
+        end
+
         define_method(:members) do
           members
         end
@@ -28,6 +41,17 @@ module LazyGraph
           to_h
         end
 
+        def to_h
+          HashUtils.strip_missing(self)
+        end
+
+        def ==(other)
+          return super if other.is_a?(self.class)
+          return to_h.eql?(other.to_h.keep_if { |_, v| !v.nil? }) if other.respond_to?(:to_h)
+
+          super
+        end
+
         define_method(:each_key, &members.method(:each))
 
         def dup
@@ -36,23 +60,24 @@ module LazyGraph
 
         def get_first_of(*props)
           key = props.find do |prop|
-            !self[prop].is_a?(MissingValue)
+            !original_get(prop).is_a?(MissingValue)
           end
           key ? self[key] : MissingValue::BLANK
         end
 
         def pretty_print(q)
-          q.group(1, '<Props ', '>') do
+          q.group(1, '<', '>') do
+            q.text "#{self.class.name} "
             q.seplist(members.zip(values).reject do |m, v|
-              m == :DEBUG && (v.nil? || v.is_a?(MissingValue))
-            end) do |member, value|
-              q.group do
-                q.text "#{member}="
-                value.respond_to?(:pretty_print) ? q.pp(value) : q.text(value.inspect)
-              end
+              m == :DEBUG || v.nil? || v.is_a?(MissingValue)
+            end.to_h) do |k, v|
+              q.text "#{k}: "
+              q.pp v
             end
           end
         end
+
+        alias_method :keys, :members
       end
     end
   end