lazy_graph 0.1.6 → 0.2.0

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

@@ -14,6 +14,14 @@ module LazyGraph
     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,7 +14,8 @@ 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)
@@ -61,7 +62,7 @@ module LazyGraph
     end
 
     def cast(value)
-      value
+      Array(value)
     end
   end
 end

data/lib/lazy_graph/node/derived_rules.rb

@@ -44,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)
 
         {
@@ -54,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
@@ -78,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?
@@ -133,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 }
@@ -168,9 +178,20 @@ module LazyGraph
 
       def parse_rule_string(derived)
         calc_str = derived[:calc]
-        instance_eval(
-          "->{ begin; #{calc_str}; rescue StandardError => e; LazyGraph.logger.error(\"Exception in \#{calc_str}. \#{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 }
@@ -201,18 +222,39 @@ module LazyGraph
         (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|
           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))
-              [i, resolver]
-            else
-              nil
+               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, resolver_for(path), idx, segments.any? ? segments : 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
@@ -34,7 +47,7 @@ module LazyGraph
 
         def ==(other)
           return super if other.is_a?(self.class)
-          return to_h.eql?(other.to_h) if other.respond_to?(:to_h)
+          return to_h.eql?(other.to_h.keep_if { |_, v| !v.nil? }) if other.respond_to?(:to_h)
 
           super
         end
@@ -47,7 +60,7 @@ 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

data/lib/lazy_graph/node/object_node.rb

@@ -22,7 +22,7 @@ module LazyGraph
         path_next = path.next
 
         if (path_segment = path.segment).is_a?(PathParser::PathGroup)
-          return path_segment.options.each_with_object({}.tap(&:compare_by_identity)) do |part, object|
+          return path_segment.options.each_with_object(SymbolHash.new) do |part, object|
             resolve(part.merge(path_next), stack_memory, nil, preserve_keys: object)
           end
         end
@@ -31,7 +31,7 @@ module LazyGraph
             node.fetch_and_resolve(path_next, input, key, stack_memory)
           end
           if @complex_pattern_properties_a.any?
-            input.each_key do |key|
+            input.keys.each do |key|
               node = !@properties[key] && @complex_pattern_properties_a.find do |(pattern, _value)|
                 pattern.match?(key)
               end&.last
@@ -40,12 +40,12 @@ module LazyGraph
               node.fetch_and_resolve(path_next, input, key, stack_memory)
             end
           end
-          input
+          cast(input)
         elsif (prop = @properties[segment])
           prop.fetch_and_resolve(path_next, input, segment, stack_memory, preserve_keys)
         elsif (_, prop = @pattern_properties.find { |(key, _val)| key.match?(segment) })
           prop.fetch_and_resolve(path_next, input, segment, stack_memory, preserve_keys)
-        elsif input.key?(segment)
+        elsif input&.key?(segment)
           prop = @properties[segment] = lazy_init_node!(input[segment], segment)
           @properties_a = @properties.to_a
           prop.fetch_and_resolve(path_next, input, segment, stack_memory, preserve_keys)
@@ -93,7 +93,11 @@ module LazyGraph
         )
       end
       define_singleton_method(:cast, lambda { |val|
-        val.is_a?(@property_class) ? val : @property_class.new(val.to_h)
+        if val.is_a?(MissingValue)
+          val
+        else
+          val.is_a?(@property_class) ? val : @property_class.new(val.to_h)
+        end
       })
     end
   end

data/lib/lazy_graph/node/symbol_hash.rb

@@ -1,9 +1,10 @@
 module LazyGraph
   class ObjectNode < Node
     class SymbolHash < ::Hash
-      def initialize(input_hash)
+      def initialize(input_hash = {})
         super
-        merge!(input_hash)
+        merge!(input_hash.transform_keys(&:to_sym))
+        compare_by_identity
       end
 
       def []=(key, value)
@@ -21,6 +22,18 @@ module LazyGraph
         else super(key.to_s.to_sym)
         end
       end
+
+      def method_missing(name, *args, &block)
+        if key?(name)
+          self[name]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        key?(name) || super
+      end
     end
   end
 end

data/lib/lazy_graph/node.rb

@@ -61,14 +61,18 @@ module LazyGraph
       @depth = parent ? parent.depth + 1 : 0
       @root = parent ? parent.root : self
       @rule = node[:rule]
+      @rule_location = node[:rule_location]
       @type = node[:type]
+      @validate_presence = node[:validate_presence]
       @helpers = helpers
-      @invisible = debug ? false : node[:invisible]
+      @invisible = debug.eql?(true) ? false : node[:invisible]
       @visited = {}.compare_by_identity
       @namespace = namespace
 
       instance_variable_set("@is_#{@type}", true)
       define_singleton_method(:cast, build_caster)
+      define_singleton_method(:trace!, proc { |*| }) unless @debug
+
       define_missing_value_proc!
 
       @has_default = node.key?(:default)
@@ -96,7 +100,7 @@ module LazyGraph
       )
     end
 
-    def fetch_and_resolve(path, input, segment, stack_memory, preserve_keys = nil, recurse: false)
+    def fetch_and_resolve(path, input, segment, stack_memory, preserve_keys = nil)
       item = fetch_item(input, segment, stack_memory)
       unless @simple || item.is_a?(MissingValue)
         item = resolve(
@@ -104,6 +108,9 @@ module LazyGraph
           stack_memory.push(item, segment)
         )
       end
+
+      item = cast(item) if @simple
+
       preserve_keys ? preserve_keys[segment] = item : item
     end
 
@@ -111,7 +118,13 @@ module LazyGraph
       if @is_decimal
         ->(value) { value.is_a?(BigDecimal) ? value : value.to_d }
       elsif @is_date
-        ->(value) { value.is_a?(String) ? Date.parse(value) : value }
+        lambda { |value|
+          if value.is_a?(String)
+            Date.parse(value)
+          else
+            value.is_a?(Symbol) ? Date.parse(value.to_s) : value
+          end
+        }
       elsif @is_boolean
         lambda do |value|
           if value.is_a?(TrueClass) || value.is_a?(FalseClass)
@@ -131,6 +144,8 @@ module LazyGraph
             value
           end
         end
+      elsif @is_string
+        lambda(&:to_s)
       else
         ->(value) { value }
       end
@@ -206,7 +221,8 @@ module LazyGraph
     def resolve_relative_input(stack_memory, path)
       input_frame_pointer = path.absolute? ? stack_memory.root : stack_memory.ptr_at(depth - 1)
       input_frame_pointer.recursion_depth += 1
-      return input_frame_pointer.frame[path.first_path_segment.part] if @simple
+
+      return cast(input_frame_pointer.frame[path.first_path_segment.part]) if @simple
 
       fetch_and_resolve(
         path.absolute? ? path.next.next : path.next, input_frame_pointer.frame, path.first_path_segment.part, input_frame_pointer
@@ -235,11 +251,8 @@ module LazyGraph
       if stack.recursion_depth >= 8
         input_id = key.object_id >> 2 ^ input.object_id << 28
         if @resolution_stack.key?(input_id)
-          if @debug
-            stack.log_debug(
-              output: :"#{stack}.#{key}",
-              exception: 'Infinite Recursion Detected during dependency resolution'
-            )
+          trace!(stack, exception: 'Infinite Recursion Detected during dependency resolution') do
+            { output: :"#{stack}.#{key}" }
           end
           return MissingValue { "Infinite Recursion in #{stack} => #{key}" }
         end
@@ -260,7 +273,10 @@ module LazyGraph
           break missing_value = MissingValue { key } unless resolver
 
           part = resolver.resolve_relative_input(stack, parts[index].options.first)
-          break missing_value = part if part.is_a?(MissingValue)
+          if part.is_a?(MissingValue)
+            raise_presence_validation_error!(stack, key, parts[index].options.first) if @validate_presence
+            break missing_value = part
+          end
 
           part_sym = part.to_s.to_sym
           parts_identity ^= part_sym.object_id << index
@@ -271,15 +287,12 @@ module LazyGraph
 
       result = missing_value || cast(resolver.resolve_relative_input(stack, path))
 
-      if @debug
-        stack.log_debug(
-          output: :"#{stack}.#{key}",
-          result: HashUtils.deep_dup(result),
-          inputs: @node_context.to_h.except(:itself, :stack_ptr),
-          calc: @src
-        )
+      if result.nil? || result.is_a?(MissingValue)
+        raise_presence_validation_error!(stack, key, path) if @validate_presence
+        input[key] = MissingValue { key }
+      else
+        input[key] = result
       end
-      input[key] = result.nil? ? MissingValue { key } : result
     end
 
     def derive_item!(input, key, stack)
@@ -292,7 +305,10 @@ module LazyGraph
             break missing_value = MissingValue { key } unless resolver
 
             part = resolver.resolve_relative_input(stack, parts[index].options.first)
-            break missing_value = part if part.is_a?(MissingValue)
+            if part.is_a?(MissingValue)
+              raise_presence_validation_error!(stack, key, parts[index].options.first) if @validate_presence
+              break missing_value = part
+            end
 
             part_sym = part.to_s.to_sym
             parts_identity ^= part_sym.object_id << (index * 8)
@@ -300,8 +316,28 @@ module LazyGraph
           end
           path = @path_cache[parts_identity] ||= PathParser::Path.new(parts: parts) unless missing_value
         end
-        result = missing_value || resolver.resolve_relative_input(stack, path)
-        @node_context[i] = result.is_a?(MissingValue) ? nil : result
+        result = begin
+          missing_value || resolver.resolve_relative_input(stack, path)
+        rescue AbortError, ValidationError => e
+          raise e
+        rescue StandardError => e
+          ex = e
+          LazyGraph.logger.error("Error in #{self.path}")
+          LazyGraph.logger.error(e)
+          LazyGraph.logger.error(e.backtrace.take_while do |line|
+            !line.include?('lazy_graph/node.rb')
+          end.join("\n"))
+
+          MissingValue { "#{key} raised exception: #{e.message}" }
+        end
+
+        if result.nil? || result.is_a?(MissingValue)
+          raise_presence_validation_error!(stack, key, path) if @validate_presence
+
+          @node_context[i] = nil
+        else
+          @node_context[i] = result
+        end
       end
 
       @node_context[:itself] = input
@@ -316,12 +352,21 @@ module LazyGraph
         if conditions_passed
           output = begin
             cast(@fixed_result || @node_context.process!)
-          rescue LazyGraph::AbortError => e
+          rescue AbortError, ValidationError => e
             raise e
           rescue StandardError => e
             ex = e
             LazyGraph.logger.error(e)
-            LazyGraph.logger.error(e.backtrace.join("\n"))
+            LazyGraph.logger.error(e.backtrace.take_while do |line|
+              !line.include?('lazy_graph/node.rb')
+            end.join("\n"))
+
+            if ENV['LAZYGRAPH_OPEN_ON_ERROR'] && !@revealed_src
+              require 'shellwords'
+              @revealed_src = true
+              `sh -c \"$EDITOR '#{Shellwords.escape(e.backtrace.first[/.*:/][...-1])}'\" `
+            end
+
             MissingValue { "#{key} raised exception: #{e.message}" }
           end
 
@@ -330,24 +375,37 @@ module LazyGraph
           MissingValue { key }
         end
 
-      if @debug
-        stack.log_debug(
-          output: :"#{stack}.#{key}",
-          result: HashUtils.deep_dup(result),
-          inputs: @node_context.to_h.except(:itself, :stack_ptr).transform_keys { |k| @input_mapper&.[](k) || k },
-          calc: @src,
-          **(@conditions ? { conditions: @conditions } : {}),
-          **(if ex
-               { exception: ex, backtrace: ex.backtrace.take_while do |line|
-                 !line.include?('lazy_graph/node.rb')
-               end }
-             else
-               {}
-             end
-            )
-        )
+      if conditions_passed
+        trace!(stack, exception: ex) do
+          {
+            output: :"#{stack}.#{key}",
+            result: HashUtils.deep_dup(result),
+            inputs: @node_context.to_h.except(:itself, :stack_ptr).transform_keys { |k| @input_mapper&.[](k) || k },
+            calc: @src,
+            **(@conditions ? { conditions: @conditions } : {})
+          }
+        end
       end
+
       result
     end
+
+    def trace!(stack, exception: nil)
+      return if @debug == 'exceptions' && !exception
+
+      trace_opts = {
+        **yield,
+        **(exception ? { exception: exception } : {})
+      }
+
+      return if @debug.is_a?(Regexp) && !(@debug =~ trace_opts[:output])
+
+      stack.log_debug(**trace_opts)
+    end
+
+    def raise_presence_validation_error!(stack, key, path)
+      raise ValidationError,
+            "Missing required value for #{stack}.#{key} at #{path.to_path_str}"
+    end
   end
 end