lazy_graph 0.1.6 → 0.2.0

data/lib/lazy_graph/builder/dsl.rb

@@ -39,6 +39,8 @@ module LazyGraph
       end
 
       def set_pattern_property(pattern, value)
+        raise 'Trying to set a property without a name' unless pattern.is_a?(String) || pattern.is_a?(Symbol)
+
         pattern = pattern.to_sym
         properties = schema[:patternProperties] ||= {}
         properties[pattern] = \
@@ -51,6 +53,8 @@ module LazyGraph
       end
 
       def set_property(key, value)
+        raise 'Trying to set a property without a name' unless key.is_a?(String) || key.is_a?(Symbol)
+
         key = key.to_sym
         properties = schema[:properties] ||= {}
         properties[key] = \
@@ -63,8 +67,8 @@ module LazyGraph
       end
 
       def object_conditional(
-        name = nil, required: false, pattern_property: false, rule: nil,
-        default: nil, description: nil, **opts, &blk
+        name = nil, required: false, pattern_property: false, rule: nil, copy: nil,
+        default: nil, description: nil, extend: nil, conditions: nil, **opts, &blk
       )
         new_object = {
           type: :object,
@@ -72,19 +76,24 @@ module LazyGraph
           additionalProperties: false,
           **(!default.nil? ? { default: default } : {}),
           **(description ? { description: description } : {}),
+          validate_presence: required,
           **opts
         }
         @prev_match_cases = @match_cases
         @match_cases = []
-        yields(new_object, &blk)
+        yields(new_object, &lambda {
+          blk&.call
+          extend&.call
+        })
 
         object_names = @match_cases.map do |match_case|
           rule = rule_from_when(match_case[:when_clause])
-          set_property(match_case[:name], { type: :object, rule: rule, **match_case[:schema] })
+          set_property(match_case[:name],
+                       { type: :object, rule: rule, rule_location: rule_location, **match_case[:schema] })
           match_case[:name]
         end
 
-        new_object[:rule] = rule_from_first_of(object_names)
+        new_object[:rule] = rule_from_first_of(object_names, conditions)
         @match_cases = @prev_match_cases
         required(name) if required && default.nil? && rule.nil?
         pattern_property ? set_pattern_property(name, new_object) : set_property(name, new_object)
@@ -95,23 +104,32 @@ module LazyGraph
         yields(@match_cases.last[:schema], &blk)
       end
 
+      def rule_location
+        @dir ||= File.expand_path(File.dirname(__FILE__), '../../../../')
+        caller.find { |c| !c.include?(@dir) }.split(':').first(2)
+      end
+
       def object(
-        name = nil, required: false, pattern_property: false, rule: nil,
-        default: nil, description: nil, **opts, &blk
+        name = nil, required: false, pattern_property: false, rule: nil, copy: nil,
+        default: nil, description: nil, extend: nil, **opts, &blk
       )
         rule ||= rule_from_when(opts.delete(:when)) if opts[:when]
         rule ||= rule_from_first_of(opts.delete(:first_of)) if opts[:first_of]
+        rule ||= rule_from_copy(copy)
         new_object = {
           type: :object,
           properties: {},
           additionalProperties: false,
-
           **(!default.nil? ? { default: default } : {}),
           **(description ? { description: description } : {}),
-          **(rule ? { rule: rule } : {}),
+          **(rule ? { rule: rule, rule_location: rule_location } : {}),
+          validate_presence: required,
           **opts
         }
-        yields(new_object, &blk)
+        yields(new_object, &lambda {
+          blk&.call
+          extend&.call
+        })
         required(name) if required && default.nil? && rule.nil?
         pattern_property ? set_pattern_property(name, new_object) : set_property(name, new_object)
       end
@@ -119,14 +137,15 @@ module LazyGraph
       def primitive(
         name = nil, type, required: false, pattern_property: false,
         default: nil, description: nil, enum: nil,
-        rule: nil, **additional_options, &blk
+        rule: nil, copy: nil, **additional_options, &blk
       )
+        rule ||= rule_from_copy(copy)
         new_primitive = {
           type: type,
           **(enum ? { enum: enum } : {}),
           **(!default.nil? ? { default: default } : {}),
           **(description ? { description: description } : {}),
-          **(rule ? { rule: rule } : {}),
+          **(rule ? { rule: rule, rule_location: rule_location } : {}),
           **additional_options
         }
         yields(new_primitive, &blk)
@@ -134,8 +153,9 @@ module LazyGraph
         pattern_property ? set_pattern_property(name, new_primitive) : set_property(name, new_primitive)
       end
 
-      def decimal(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil,
+      def decimal(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil, copy: nil,
                   **opts, &blk)
+        rule ||= rule_from_copy(copy)
         # Define the decimal schema supporting multiple formats
         new_decimal = {
           anyOf: [
@@ -156,7 +176,8 @@ module LazyGraph
           type: :decimal,
           **(!default.nil? ? { default: default } : {}),
           **(description ? { description: description } : {}),
-          **(rule ? { rule: rule } : {}),
+          **(rule ? { rule: rule, rule_location: rule_location } : {}),
+          validate_presence: required,
           **opts
         }
         yields(new_decimal, &blk)
@@ -164,8 +185,9 @@ module LazyGraph
         pattern_property ? set_pattern_property(name, new_decimal) : set_property(name, new_decimal)
       end
 
-      def timestamp(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil,
+      def timestamp(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil, copy: nil,
                     **opts, &blk)
+        rule ||= rule_from_copy(copy)
         new_timestamp = {
           anyOf: [
             {
@@ -183,7 +205,8 @@ module LazyGraph
           type: :timestamp, # Custom extended type
           **(!default.nil? ? { default: default } : {}),
           **(description ? { description: description } : {}),
-          **(rule ? { rule: rule } : {}),
+          **(rule ? { rule: rule, rule_location: rule_location } : {}),
+          validate_presence: required,
           **opts
         }
         yields(new_timestamp, &blk)
@@ -191,15 +214,17 @@ module LazyGraph
         pattern_property ? set_pattern_property(name, new_timestamp) : set_property(name, new_timestamp)
       end
 
-      def time(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil,
+      def time(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil, copy: nil,
                **opts, &blk)
+        rule ||= rule_from_copy(copy)
         new_time = {
           type: :time, # Custom extended type
           # Matches HH:mm[:ss[.SSS]]
           pattern: '^\\d{2}:\\d{2}(:\\d{2}(\\.\\d{1,3})?)?$',
           **(!default.nil? ? { default: default } : {}),
           **(description ? { description: description } : {}),
-          **(rule ? { rule: rule } : {}),
+          **(rule ? { rule: rule, rule_location: rule_location } : {}),
+          validate_presence: required,
           **opts
         }
         yields(new_time, &blk)
@@ -207,8 +232,9 @@ module LazyGraph
         pattern_property ? set_pattern_property(name, new_time) : set_property(name, new_time)
       end
 
-      def date(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil,
+      def date(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil, copy: nil,
                **opts, &blk)
+        rule ||= rule_from_copy(copy)
         new_date = {
           anyOf: [
             {
@@ -220,7 +246,8 @@ module LazyGraph
           type: :date, # Custom extended type
           **(!default.nil? ? { default: default } : {}),
           **(description ? { description: description } : {}),
-          **(rule ? { rule: rule } : {}),
+          **(rule ? { rule: rule, rule_location: rule_location } : {}),
+          validate_presence: required,
           **opts
         }
         yields(new_date, &blk)
@@ -231,10 +258,11 @@ module LazyGraph
       %i[boolean string const integer number null].each do |type|
         define_method(type) do |
           name = nil, required: false, pattern_property: false,
-          default: nil, description: nil, enum: nil, rule: nil, **additional_options, &blk|
+          default: nil, description: nil, enum: nil, rule: nil, copy: nil,
+          **additional_options, &blk|
           primitive(
             name, type, required: required, pattern_property: pattern_property, enum: enum,
-                        default: default, rule: rule, description: description,
+                        default: default, rule: rule, rule_location: rule_location, description: description,
                         **additional_options, &blk
           )
         end
@@ -252,17 +280,18 @@ module LazyGraph
         schema[:anyOf] = (schema[:any_of] || []).concat(any_of).uniq
       end
 
-      def array(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil,
-                type: :object, **opts, &blk)
+      def array(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil, copy: nil,
+                type: :object, extend: nil, **opts, &block)
+        rule ||= rule_from_copy(copy)
         new_array = {
           type: :array,
           **(!default.nil? ? { default: default } : {}),
           **(description ? { description: description } : {}),
-          **(rule ? { rule: rule } : {}),
+          **(rule ? { rule: rule, rule_location: rule_location } : {}),
           **opts,
           items: { properties: {} }.tap do |items|
             yields(items) do
-              send(type, :items, &blk)
+              send(type, :items, extend: extend, &block)
             end
           end[:properties][:items]
         }
@@ -275,6 +304,7 @@ module LazyGraph
       end
 
       def yields(other)
+        raise ArgumentError, 'Builder DSL used outside of rules module' unless schema
         return unless block_given?
 
         prev_schema = schema
@@ -283,6 +313,12 @@ module LazyGraph
         self.schema = prev_schema
       end
 
+      def rule_from_copy(copy)
+        return unless copy
+
+        "${#{copy}}"
+      end
+
       def rule_from_when(when_clause)
         inputs = when_clause.keys
         conditions = when_clause
@@ -295,17 +331,19 @@ module LazyGraph
         }
       end
 
-      def rule_from_first_of(prop_list)
+      def rule_from_first_of(prop_list, conditions = nil)
+        prop_list += conditions.keys if conditions
         {
           inputs: prop_list,
-          calc: "itself.get_first_of(:#{prop_list.join(', :')})"
+          calc: "itself.get_first_of(:#{prop_list.join(', :')})",
+          **(conditions ? { conditions: conditions } : {})
         }
       end
 
       def depends_on(*dependencies)
         @resolved_dependencies ||= Hash.new do |h, k|
-          send(k) # Load dependency once
           h[k] = true
+          send(k) # Load dependency once
         end
         dependencies.each(&@resolved_dependencies.method(:[]))
       end

data/lib/lazy_graph/builder.rb

@@ -1,4 +1,5 @@
 # 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.
 #
@@ -6,15 +7,14 @@ 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: ENV.fetch('LAZY_GRAPH_GRAPH_CACHE_MAX_ENTRIES', 1000).to_i, cache: {}},
+      graph: { size: ENV.fetch('LAZY_GRAPH_GRAPH_CACHE_MAX_ENTRIES', 1000).to_i, cache: {} },
       # Store up to 5000 configs
-      context: {size: ENV.fetch('LAZY_GRAPH_CONTEXT_CACHE_MAX_ENTRIES', 5000).to_i, cache: {}},
+      context: { size: ENV.fetch('LAZY_GRAPH_CONTEXT_CACHE_MAX_ENTRIES', 5000).to_i, cache: {} },
       # Store up to 5000 queries
-      query: {size: ENV.fetch('LAZY_GRAPH_QUERY_CACHE_MAX_ENTRIES', 5000).to_i, cache: {}}
+      query: { size: ENV.fetch('LAZY_GRAPH_QUERY_CACHE_MAX_ENTRIES', 5000).to_i, cache: {} }
     }.compare_by_identity.freeze
 
     include DSL
@@ -23,10 +23,13 @@ module LazyGraph
     attr_accessor :schema
 
     def initialize(schema: { type: 'object', properties: {} }) = @schema = schema
-    def context(value, debug: false, validate: false) = build!(debug: debug, validate: validate).context(value)
-    def eval!(context, *value, debug: false, validate: false) = context(context, validate: validate, debug: debug).query(*value)
+    def context(value, debug: false, validate: true) = build!(debug: debug, validate: validate).context(value)
+
+    def eval!(context, *value, debug: false,
+              validate: true) = context(context, validate: validate, debug: debug).get(*value)
+    alias feed context
 
-    def build!(debug: false, validate: false) = @schema.to_lazy_graph(
+    def build!(debug: false, validate: true) = @schema.to_lazy_graph(
       debug: debug,
       validate: validate,
       helpers: self.class.helper_modules,
@@ -38,6 +41,7 @@ module LazyGraph
       module_body_func_name = :"_#{name}"
       define_method(module_body_func_name, &blk)
       define_method(name) do |**args, &inner_blk|
+        @path = @path.nil? ? "#{name}" : "#{@path}+#{name}" unless @path.to_s.include?(name.to_s)
         send(module_body_func_name, **args, &inner_blk)
         self
       end
@@ -58,6 +62,8 @@ module LazyGraph
       attr_reader :helper_modules
     end
 
+    def self.register_helper_modules(*mods) = mods.each(&method(:register_helper_module))
+
     def self.register_helper_module(mod)
       (@helper_modules ||= []) << mod
     end
@@ -70,6 +76,12 @@ module LazyGraph
       @helper_modules = nil
     end
 
+    def self.clear_caches!
+      clear_rules_modules!
+      clear_helper_modules!
+      BUILD_CACHE_CONFIG.each_value { |v| v[:cache].clear }
+    end
+
     def self.rules_modules
       @rules_modules ||= {
         type: :object,
@@ -93,8 +105,8 @@ module LazyGraph
       }
     end
 
-    def self.eval!(modules:, context:, query:, debug: false, validate: false)
-      builder = cache_as(:graph, [modules, debug, validate].hash) do
+    def self.eval!(modules:, context:, query:, debug: false, validate: true)
+      graph = cache_as(:graph, [modules, debug, validate]) 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?
 
@@ -105,22 +117,23 @@ module LazyGraph
         builder = build_modules(modules)
         return builder if builder.is_a?(Hash)
 
-        builder
+        builder.build!(debug: debug, validate: validate)
       end
 
-      context_result = cache_as(:context, [builder, context]) do
-        evaluate_context(builder, context, debug: debug, validate: validate)
+      context_result = cache_as(:context, [graph, context]) do
+        build_context(graph, context)
       end
 
       return context_result if context_result.is_a?(Hash) && context_result[:type].equal?(:error)
 
       cache_as(:query, [context_result, query]) do
-        HashUtils.strip_missing({
-          type: :success,
-          result: context_result.resolve(*(query || ''))
-        })
+        HashUtils.strip_missing(
+          {
+            type: :success,
+            result: context_result.resolve(*(query || ''))
+          }
+        )
       end
-
     rescue SystemStackError => e
       LazyGraph.logger.error(e.message)
       LazyGraph.logger.error(e.backtrace.join("\n"))
@@ -139,9 +152,12 @@ module LazyGraph
       cache.delete(cache.keys.first) while cache.size > max_size
     end
 
+    def to_str
+      "LazyGraph(modules=#{@path})"
+    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
-
     private_class_method def self.validate_modules(input_options)
       JSON::Validator.validate!(rules_modules, input_options)
       ''
@@ -163,15 +179,19 @@ module LazyGraph
         acc.send(k, **v.to_h.transform_keys(&:to_sym))
       end
     rescue ArgumentError => e
-      format_error_response('Invalid Module Argument', e.message)
+      LazyGraph.logger.error(e.message)
       LazyGraph.logger.error(e.backtrace.join("\n"))
+      format_error_response('Invalid Module Argument', e.message)
     end
 
-    private_class_method def self.evaluate_context(builder, context, debug: false, validate: false)
-      builder.context(context, debug: debug, validate: validate)
-    rescue ArgumentError => e
+    private_class_method def self.build_context(graph, context)
+      graph.context(context)
+    rescue StandardError => e
+      if graph.debug?
+        LazyGraph.logger.error(e.message)
+        LazyGraph.logger.error(e.backtrace.join("\n"))
+      end
       format_error_response('Invalid Context Input', e.message)
-      LazyGraph.logger.error(e.backtrace.join("\n"))
     end
   end
 end

data/lib/lazy_graph/builder_group.rb

@@ -2,8 +2,13 @@ module LazyGraph
   class BuilderGroup
     # A builder group is simply a named colleciton of builders (each a subclass of LazyGraph::Builder)
     # That can be reloaded in bulk, and exposed via a simple HTTP server interface.
-    def self.bootstrap!(reload_paths: [], listen: ENV['RACK_ENV'] == 'development')
+    # If a script file defining a builder group is run directly, it will start a Puma server
+    # to host itself
+    def self.bootstrap!(reload_paths: nil, exclude_paths: [], listen: Environment.development?, enable_server: true)
+      bootstrap_script_name = caller.drop_while { |r| r =~ /builder_group/ }[0][/[^:]+/]
+      reload_paths ||= File.join(File.dirname(bootstrap_script_name), '**/*.rb')
       reload_paths = Array(reload_paths)
+
       Module.new do
         define_singleton_method(:included) do |base|
           def base.each_builder(const = self, &blk)
@@ -18,27 +23,30 @@ module LazyGraph
             end
           end
 
-          def base.server
-            LazyGraph::Server.new(
+          def base.rack_app(**opts)
+            unless defined?(Rack)
+              raise AbortError,
+                    'You must install rack first to be able to run a LazyGraph BuilderGroup as a server'
+            end
+
+            LazyGraph::RackApp.new(
               routes: each_builder.map do |builder|
                 [
-                  builder.to_s.downcase.gsub('::', '/').gsub(/^#{name.downcase}/, ''),
+                  builder.to_s.downcase.gsub('::', '/').gsub(/^#{name.to_s.downcase}/, ''),
                   builder
                 ]
-              end.to_h
+              end.to_h,
+              **opts
             )
           end
 
           base.define_singleton_method(:reload_lazy_graphs!) do |clear_previous: false|
-            if clear_previous
-              each_builder do |builder|
-                builder.clear_rules_modules!
-                builder.clear_helper_modules!
-              end
-            end
+            each_builder(&:clear_caches!) if clear_previous
 
-            reload_paths.flat_map { |p| Dir[p] }.each do |file|
-              load file
+            reload_paths.flat_map { |p|
+              Dir[p]
+            }.-([bootstrap_script_name]).sort_by { |file| file.count(File::SEPARATOR) }.each do |file|
+              load file unless exclude_paths.any? { |p| p =~ file }
             rescue StandardError => e
               LazyGraph.logger.error("Failed to load #{file}: #{e.message}")
             end
@@ -46,14 +54,17 @@ module LazyGraph
 
           base.reload_lazy_graphs! if reload_paths.any?
 
-          return unless listen
+          if listen && defined?(Listen)
+            Listen.to(*reload_paths.map { |p| p.gsub(%r{(?:/\*\*)*/\*\.rb}, '') }) do
+              base.reload_lazy_graphs!(clear_previous: true)
+            end.start
+          end
 
-          require 'listen'
-          Listen.to(*reload_paths.map { |p| p.gsub(%r{(?:/\*\*)*/\*\.rb}, '') }) do
-            base.reload_lazy_graphs!(clear_previous: true)
-          end.start
+          CLI.invoke!(base.rack_app) if enable_server && bootstrap_script_name == $0
         end
       end
     end
   end
+
+  define_singleton_method(:bootstrap_app!, &BuilderGroup.method(:bootstrap!))
 end

data/lib/lazy_graph/cli.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module LazyGraph
+  class CLI
+    # A builder group rack-app can be exposed via a simple rack based HTTP server
+    # with routes corresponding to each builder class deeply nested
+    # withhin the builder group module.
+    def self.invoke!(rack_app)
+      require 'etc'
+      require 'optparse'
+      require 'rack'
+
+      options = {
+        port: 9292,
+        workers: (Environment.development? ? 1 : Etc.nprocessors)
+      }
+
+      OptionParser.new do |opts|
+        opts.banner = "Usage: #{$0} [options]"
+
+        opts.on('-p PORT', '--port PORT', Integer, "Set the port (default: #{options[:port]})") do |p|
+          options[:port] = p
+        end
+
+        opts.on('-w WORKERS', '--workers WORKERS', Integer,
+                "Set the number of workers (default: #{options[:workers]})") do |w|
+          options[:workers] = w
+        end
+
+        opts.on('-h', '--help', 'Print this help') do
+          puts opts
+          exit
+        end
+      end.parse!
+      # A builder group can be exposed as a simple rack based HTTP server
+      # with routes corresponding to each builder class deeply nested
+      # withhin the builder group module.
+
+      RackServer.new(
+        Rack::Builder.new do
+          use Rack::Lint if Environment.development?
+          run rack_app
+        end
+      ).start(port: options[:port], workers: options[:workers])
+    end
+  end
+end

data/lib/lazy_graph/context.rb

@@ -22,14 +22,14 @@ module LazyGraph
 
     def get(path)
       result = resolve(path)
-      raise AbortError, result[:err], cause: result[:error] if result[:err]
+      raise result[:error] if result[:err]
 
       result[:output]
     end
 
     def debug(path)
       result = resolve(path)
-      raise AbortError, result[:err], cause: result[:error] if result[:err]
+      raise result[:error] if result[:err]
 
       result[:debug_trace]
     end
@@ -52,13 +52,15 @@ module LazyGraph
         output: result,
         debug_trace: debug_trace
       }
-    rescue LazyGraph::AbortError => e
+    rescue AbortError, ValidationError => e
       {
         output: nil, err: e.message, status: :abort, error: e
       }
     rescue StandardError => e
-      LazyGraph.logger.error(e.message)
-      LazyGraph.logger.error(e.backtrace.join("\n"))
+      if @graph.debug?
+        LazyGraph.logger.error(e.message)
+        LazyGraph.logger.error(e.backtrace.join("\n"))
+      end
       {
         output: nil, err: e.message, backtrace: e.backtrace, error: e
       }
@@ -78,6 +80,8 @@ module LazyGraph
       end
     end
 
-    alias [] get
+    def [](*parts)
+      get(parts.map { |p| p.is_a?(Integer) ? "[#{p}]" : p.to_s }.join('.').gsub('.[', '['))
+    end
   end
 end

data/lib/lazy_graph/environment.rb

@@ -0,0 +1,6 @@
+module LazyGraph
+  module Environment
+    def self.development? = env == 'development'
+    def self.env = ENV.fetch('RACK_ENV', 'development')
+  end
+end

data/lib/lazy_graph/graph.rb

@@ -4,14 +4,16 @@ 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, namespace: nil)
       @json_schema = HashUtils.deep_dup(input_schema, symbolize: true, signature: signature = [0]).merge(type: :object)
@@ -57,7 +59,7 @@ module LazyGraph
     def validate!(input, schema = @json_schema)
       JSON::Validator.validate!(schema, input)
     rescue JSON::Schema::ValidationError => e
-      raise AbortError, "Input validation failed: #{e.message}", cause: e
+      raise ValidationError, "Input validation failed: #{e.message}", cause: e
     end
 
     def pretty_print(q)

data/lib/lazy_graph/hash_utils.rb

@@ -57,12 +57,15 @@ 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_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_missing(obj[key], parent_list)