openapi3_parser 0.4.0 → 0.5.0

data/lib/openapi3_parser/node_factory/object.rb

@@ -1,77 +1,87 @@
 # frozen_string_literal: true
 
-require "ostruct"
+require "forwardable"
 
 require "openapi3_parser/context"
-require "openapi3_parser/node_factory"
-require "openapi3_parser/node_factory/field_config"
-require "openapi3_parser/node_factory/object/node_builder"
-require "openapi3_parser/node_factory/object/validator"
-require "openapi3_parser/validation/error_collection"
+require "openapi3_parser/node_factory/object_factory/dsl"
+require "openapi3_parser/node_factory/object_factory/node_builder"
 
 module Openapi3Parser
   module NodeFactory
-    module Object
-      include NodeFactory
+    class Object
+      extend Forwardable
+      extend ObjectFactory::Dsl
+
+      def_delegators "self.class",
+                     :field_configs,
+                     :allowed_extensions?,
+                     :mutually_exclusive_fields,
+                     :allowed_default?,
+                     :validations
+
+      attr_reader :context, :data
+
+      def initialize(context)
+        @context = context
+        @data = build_data(context.input)
+      end
 
-      module ClassMethods
-        def field(name, **options)
-          @field_configs ||= {}
-          @field_configs[name] = FieldConfig.new(options)
-        end
+      def resolved_input
+        @resolved_input ||= build_resolved_input
+      end
 
-        def field_configs
-          @field_configs || {}
-        end
+      def raw_input
+        context.input
+      end
 
-        def allow_extensions
-          @allow_extensions = true
-        end
+      def nil_input?
+        context.input.nil?
+      end
 
-        def disallow_extensions
-          @allow_extensions = false
-        end
+      def valid?
+        errors.empty?
+      end
 
-        def allowed_extensions?
-          @allow_extensions == true
-        end
+      def errors
+        @errors ||= ObjectFactory::NodeBuilder.errors(self)
+      end
 
-        def mutually_exclusive(*fields, required: false)
-          @mutually_exclusive ||= []
-          @mutually_exclusive << OpenStruct.new(
-            fields: fields, required: required
-          )
-        end
+      def node
+        @node ||= build_node
+      end
 
-        def mutually_exclusive_fields
-          @mutually_exclusive || []
-        end
+      def can_use_default?
+        true
       end
 
-      def self.included(base)
-        base.extend(NodeFactory::ClassMethods)
-        base.extend(ClassMethods)
-        base.class_eval do
-          input_type Hash
-        end
+      def default
+        nil
       end
 
-      def allowed_extensions?
-        self.class.allowed_extensions?
+      def allowed_fields
+        field_configs.keys
       end
 
-      def mutually_exclusive_fields
-        self.class.mutually_exclusive_fields
+      def required_fields
+        field_configs.each_with_object([]) do |(key, config), memo|
+          memo << key if config.required?
+        end
       end
 
-      def field_configs
-        self.class.field_configs || {}
+      def inspect
+        %{#{self.class.name}(#{context.source_location.inspect})}
       end
 
       private
 
-      def process_input(input)
-        field_configs.each_with_object(input.dup) do |(field, config), memo|
+      def build_data(raw_input)
+        use_default = nil_input? || !raw_input.is_a?(::Hash)
+        return if use_default && default.nil?
+        process_data(use_default ? default : raw_input)
+      end
+
+      def process_data(raw_data)
+        field_configs.each_with_object(raw_data.dup) do |(field, config), memo|
           memo[field] = nil unless memo[field]
           next unless config.factory?
           next_context = Context.next_field(context, field)
@@ -79,22 +89,10 @@ module Openapi3Parser
         end
       end
 
-      def validate_input
-        validator = Validator.new(processed_input, self)
-        Validation::ErrorCollection.combine(super, validator.errors)
-      end
-
-      def build_node(input)
-        data = NodeBuilder.new(input, self).data
-        build_object(data, context)
-      end
-
-      def build_object(data, _context)
-        data
-      end
-
       def build_resolved_input
-        processed_input.each_with_object({}) do |(key, value), memo|
+        return unless data
+
+        data.each_with_object({}) do |(key, value), memo|
           next if value.respond_to?(:nil_input?) && value.nil_input?
           memo[key] = if value.respond_to?(:resolved_input)
                         value.resolved_input
@@ -103,6 +101,11 @@ module Openapi3Parser
                       end
         end
       end
+
+      def build_node
+        data = ObjectFactory::NodeBuilder.node_data(self)
+        build_object(data, context) if data
+      end
     end
   end
 end

data/lib/openapi3_parser/node_factory/object_factory/dsl.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "ostruct"
+
+require "openapi3_parser/node_factory/object_factory/field_config"
+
+module Openapi3Parser
+  module NodeFactory
+    module ObjectFactory
+      module Dsl
+        def field(name, **options)
+          @field_configs ||= {}
+          @field_configs[name] = FieldConfig.new(options)
+        end
+
+        def field_configs
+          @field_configs || {}
+        end
+
+        def allow_extensions
+          @allow_extensions = true
+        end
+
+        def allowed_extensions?
+          @allow_extensions == true
+        end
+
+        def mutually_exclusive(*fields, required: false)
+          @mutually_exclusive ||= []
+          @mutually_exclusive << OpenStruct.new(
+            fields: fields, required: required
+          )
+        end
+
+        def mutually_exclusive_fields
+          @mutually_exclusive || []
+        end
+
+        def validate(*items, &block)
+          @validations = (@validations || []).concat(items)
+          @validations << block if block
+        end
+
+        def validations
+          @validations || []
+        end
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factory/object_factory/field_config.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/error"
+require "openapi3_parser/node_factory/type_checker"
+
+module Openapi3Parser
+  module NodeFactory
+    module ObjectFactory
+      class FieldConfig
+        def initialize(
+          input_type: nil,
+          factory: nil,
+          required: false,
+          default: nil,
+          validate: nil
+        )
+          @given_input_type = input_type
+          @given_factory = factory
+          @given_required = required
+          @given_default = default
+          @given_validate = validate
+        end
+
+        def factory?
+          !given_factory.nil?
+        end
+
+        def initialize_factory(context, parent_factory)
+          if given_factory.is_a?(Class)
+            given_factory.new(context)
+          elsif given_factory.is_a?(Symbol)
+            parent_factory.send(given_factory, context)
+          else
+            given_factory.call(context)
+          end
+        end
+
+        def required?
+          given_required
+        end
+
+        def check_input_type(validatable, building_node)
+          return true if !given_input_type || validatable.input.nil?
+
+          if building_node
+            TypeChecker.raise_on_invalid_type(validatable.context,
+                                              type: given_input_type)
+          else
+            TypeChecker.validate_type(validatable, type: given_input_type)
+          end
+        end
+
+        def validate_field(validatable, building_node)
+          return true if !given_validate || validatable.input.nil?
+
+          run_validation(validatable)
+
+          return validatable.errors.empty? unless building_node
+          return true if validatable.errors.empty?
+
+          error = validatable.errors.first
+          location_summary = error.context.location_summary
+          raise Error::InvalidData,
+                "Invalid data for #{location_summary}: #{error.message}"
+        end
+
+        def default(factory)
+          return given_default.call if given_default.is_a?(Proc)
+          return factory.send(given_default) if given_default.is_a?(Symbol)
+          given_default
+        end
+
+        private
+
+        attr_reader :given_input_type, :given_factory, :given_required,
+                    :given_default, :given_validate
+
+        def run_validation(validatable)
+          if given_validate.is_a?(Symbol)
+            validatable.factory.send(given_validate, validatable)
+          else
+            given_validate.call(validatable)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factory/object_factory/node_builder.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "openapi3_parser/node_factory/type_checker"
+require "openapi3_parser/node_factory/object_factory/validator"
+require "openapi3_parser/node_factory/recursive_pointer"
+
+module Openapi3Parser
+  module NodeFactory
+    module ObjectFactory
+      class NodeBuilder
+        def self.errors(factory)
+          new(factory).errors
+        end
+
+        def self.node_data(factory)
+          new(factory).node_data
+        end
+
+        def initialize(factory)
+          @factory = factory
+          @validatable = Validation::Validatable.new(factory)
+        end
+
+        def errors
+          return validatable.collection if empty_and_allowed_to_be?
+
+          TypeChecker.validate_type(validatable, type: ::Hash)
+
+          if validatable.errors.empty?
+            validatable.add_errors(validate(raise_on_invalid: false))
+          end
+
+          validatable.collection
+        end
+
+        def node_data
+          return build_node_data if empty_and_allowed_to_be?
+          TypeChecker.raise_on_invalid_type(factory.context, type: ::Hash)
+          validate(raise_on_invalid: true)
+          build_node_data
+        end
+
+        private_class_method :new
+
+        private
+
+        attr_reader :factory, :validatable
+
+        def empty_and_allowed_to_be?
+          factory.nil_input? && factory.can_use_default?
+        end
+
+        def validate(raise_on_invalid:)
+          Validator.call(factory, raise_on_invalid)
+        end
+
+        def build_node_data
+          return if factory.nil_input? && factory.data.nil?
+
+          factory.data.each_with_object(NodeData.new) do |(key, value), memo|
+            memo[key] = if node_is_recursive_pointer?(value)
+                          value.recursive_pointer
+                        else
+                          resolve_value(key, value)
+                        end
+          end
+        end
+
+        def resolve_value(key, value)
+          config = factory.field_configs[key]
+          resolved_value = value.respond_to?(:node) ? value.node : value
+
+          # let a field config default take precedence if value is a nil_input?
+          if (value.respond_to?(:nil_input?) && value.nil_input?) || value.nil?
+            default = config&.default(factory)
+            default.nil? ? resolved_value : default
+          else
+            resolved_value
+          end
+        end
+
+        def node_is_recursive_pointer?(value_factory)
+          return false unless value_factory.respond_to?(:in_recursive_loop?)
+          value_factory.in_recursive_loop?
+        end
+
+        class NodeData < ::Hash
+          def [](key)
+            item = super(key)
+            item.is_a?(NodeFactory::RecursivePointer) ? item.node : item
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openapi3_parser/node_factory/object_factory/validator.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require "openapi3_parser/array_sentence"
+require "openapi3_parser/error"
+require "openapi3_parser/validation/validatable"
+require "openapi3_parser/validators/mutually_exclusive_fields"
+require "openapi3_parser/validators/required_fields"
+require "openapi3_parser/validators/unexpected_fields"
+
+module Openapi3Parser
+  module NodeFactory
+    module ObjectFactory
+      class Validator
+        private_class_method :new
+        attr_reader :factory, :validatable, :building_node
+
+        def self.call(*args)
+          new(*args).call
+        end
+
+        def initialize(factory, building_node)
+          @factory = factory
+          @building_node = building_node
+          @validatable = Validation::Validatable.new(factory)
+        end
+
+        def call
+          check_required_fields
+          check_unexpected_fields
+          check_mutually_exclusive_fields
+          check_invalid_fields
+          check_factory_validations
+          validatable.collection
+        end
+
+        private
+
+        def check_required_fields
+          Validators::RequiredFields.call(
+            validatable,
+            required_fields: factory.required_fields,
+            raise_on_invalid: building_node
+          )
+        end
+
+        def check_unexpected_fields
+          Validators::UnexpectedFields.call(
+            validatable,
+            allow_extensions: factory.allowed_extensions?,
+            allowed_fields: factory.allowed_fields,
+            raise_on_invalid: building_node
+          )
+        end
+
+        def check_mutually_exclusive_fields
+          Validators::MutuallyExclusiveFields.call(
+            validatable,
+            mutually_exclusive_fields: factory.mutually_exclusive_fields,
+            raise_on_invalid: building_node
+          )
+        end
+
+        def check_invalid_fields
+          CheckInvalidFields.call(self)
+        end
+
+        def check_factory_validations
+          CheckFactoryValidations.call(self)
+        end
+
+        class CheckInvalidFields
+          extend Forwardable
+          attr_reader :validator
+          def_delegators :validator, :factory, :building_node, :validatable
+          private_class_method :new
+
+          def self.call(validator)
+            new(validator).call
+          end
+
+          def initialize(validator)
+            @validator = validator
+          end
+
+          def call
+            factory.data.each do |name, field|
+              # references can reference themselves and become in a loop
+              next if in_recursive_loop?(field)
+              has_factory_errors = handle_factory_checks(name)
+
+              next if has_factory_errors || !field.respond_to?(:errors)
+
+              # We don't add errors when we're building a node as they will
+              # be raised when that child node is built
+              validatable.add_errors(field.errors) unless building_node
+            end
+          end
+
+          private
+
+          def handle_factory_checks(name)
+            field_errors = if factory.field_configs[name]
+                             check_field(name, factory.field_configs[name])
+                           end
+
+            (field_errors || []).any?
+          end
+
+          def in_recursive_loop?(field)
+            field.respond_to?(:in_recursive_loop?) && field.in_recursive_loop?
+          end
+
+          def check_field(name, field_config)
+            return if factory.raw_input[name].nil?
+
+            field_validatable = Validation::Validatable.new(
+              factory,
+              context: Context.next_field(factory.context, name)
+            )
+
+            valid_input_type = field_config.check_input_type(field_validatable,
+                                                             building_node)
+
+            if valid_input_type
+              field_config.validate_field(field_validatable, building_node)
+            end
+
+            validatable.add_errors(field_validatable.errors)
+            field_validatable.errors
+          end
+        end
+
+        class CheckFactoryValidations
+          private_class_method :new
+
+          def self.call(validator)
+            new.call(validator)
+          end
+
+          def call(validator)
+            run_validations(validator)
+
+            errors = validator.validatable.errors
+
+            return if errors.empty? || !validator.building_node
+
+            location_summary = errors.first.context.location_summary
+            raise Error::InvalidData,
+                  "Invalid data for #{location_summary}: "\
+                  "#{errors.first.message}"
+          end
+
+          private
+
+          def run_validations(validator)
+            validator.factory.validations.each do |validation|
+              if validation.respond_to?(:call)
+                validation.call(validator.validatable)
+              elsif validation.is_a?(Symbol)
+                validator.factory.send(validation, validator.validatable)
+              else
+                raise Error::NotCallable, "expected a symbol or a callable"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end