openapi_blocks 0.3.1 → 0.4.1

data/lib/openapi_blocks/concerns/documentable.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module OpenapiBlocks
+  module Concerns
+    module Documentable # rubocop:disable Style/Documentation
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods # rubocop:disable Style/Documentation
+        attr_reader :_operations, :_tags
+
+        def operation(action, &block)
+          @_operations ||= {}
+          builder = OperationBuilder.new
+          builder.instance_eval(&block) if block
+          @_operations[action] = builder
+        end
+
+        def tags(*values)
+          values.any? ? @_tags = values : @_tags
+        end
+      end
+    end
+  end
+end

data/lib/openapi_blocks/concerns/schemable.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module OpenapiBlocks
+  module Concerns
+    module Schemable # rubocop:disable Style/Documentation
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods # rubocop:disable Style/Documentation
+        attr_reader :_model, :_ignored, :_associations, :_virtual_attributes, :_serializes
+
+        def model(klass = nil)
+          klass ? @_model = klass : @_model ||= infer_model # rubocop:disable Naming/MemoizedInstanceVariableName
+        end
+
+        def ignore(*attributes)
+          @_ignored ||= []
+          @_ignored.concat(attributes.map(&:to_s))
+        end
+
+        def association(name, type: nil, read_only: false)
+          @_associations ||= []
+          @_associations << { name: name, type: type, read_only: read_only }
+        end
+
+        def attribute(name, **)
+          @_virtual_attributes ||= []
+          @_virtual_attributes << { name: name, ** }
+        end
+
+        def serializes(*models)
+          @_serializes ||= []
+          @_serializes.concat(models)
+        end
+
+        private
+
+        def infer_model
+          raise NotImplementedError, "#{name} must implement infer_model"
+        end
+      end
+    end
+  end
+end

data/lib/openapi_blocks/configuration.rb

@@ -9,14 +9,20 @@ module OpenapiBlocks
     SUPPORTED_VERSIONS = %w[3.1.0 3.0.3].freeze
 
     attr_reader   :openapi_version
-    attr_accessor :watch
+    attr_accessor :watch, :auto_serialize
 
     def initialize
       @openapi_version = "3.1.0"
       @watch           = :development
+      @auto_serialize  = false
       @info            = InfoBuilder.new
       @servers         = []
       @security        = nil
+      @configured      = false
+    end
+
+    def configured?
+      @configured
     end
 
     def openapi_version=(version)
@@ -29,6 +35,7 @@ module OpenapiBlocks
     end
 
     def info(&block)
+      @configured = true if block
       @info.instance_eval(&block) if block
       @info
     end

data/lib/openapi_blocks/controller.rb

@@ -2,8 +2,10 @@
 
 module OpenapiBlocks
   class Controller # rubocop:disable Style/Documentation
+    include Concerns::Documentable
+
     class << self
-      attr_reader :_resource, :_operations, :_tags, :_controller_class
+      attr_reader :_resource, :_controller_class
 
       def resource(klass)
         @_resource = klass
@@ -13,32 +15,10 @@ module OpenapiBlocks
         @_controller_class = klass
       end
 
-      def model
-        @_resource&.model
-      end
-
-      def _associations
-        @_resource&._associations
-      end
-
-      def _virtual_attributes
-        @_resource&._virtual_attributes
-      end
-
-      def _ignored
-        @_resource&._ignored
-      end
-
-      def operation(action, &block)
-        @_operations ||= {}
-        builder = OperationBuilder.new
-        builder.instance_eval(&block) if block
-        @_operations[action] = builder
-      end
-
-      def tags(*values)
-        values.any? ? @_tags = values : @_tags
-      end
+      def model               = @_resource&.model
+      def _associations       = @_resource&._associations
+      def _virtual_attributes = @_resource&._virtual_attributes
+      def _ignored            = @_resource&._ignored
     end
   end
 end

data/lib/openapi_blocks/railtie.rb

@@ -4,16 +4,22 @@ require "rails"
 
 module OpenapiBlocks
   class Railtie < Rails::Railtie # rubocop:disable Style/Documentation
-    initializer "openapi_blocks.middleware" do |app|
-      app.middleware.use OpenapiBlocks::Middleware
-    end
-
     initializer "openapi_blocks.autoload", before: :set_autoload_paths do |app|
       app.config.eager_load_paths << app.root.join("app/openapi")
+      app.config.eager_load_paths << app.root.join("app/serializers")
     end
 
     config.to_prepare do
       Dir[Rails.root.join("app/openapi/**/*.rb")].each { |f| require f }
+      Dir[Rails.root.join("app/serializers/**/*.rb")].each { |f| require f }
+
+      if OpenapiBlocks.configuration.auto_serialize
+        [ActionController::Base, ActionController::API].each do |klass|
+          klass.include(OpenapiBlocks::AutoSerialize) unless klass.ancestors.include?(OpenapiBlocks::AutoSerialize)
+        end
+
+        OpenapiBlocks::Registry.build!
+      end
     end
   end
 end

data/lib/openapi_blocks/registry.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module OpenapiBlocks
+  module Registry # rubocop:disable Style/Documentation
+    @map   = {}
+    @mutex = Mutex.new
+
+    class << self
+      def register(model, serializer)
+        @mutex.synchronize { @map[model] = serializer }
+      end
+
+      def resolve(object)
+        model = extract_model(object)
+        @mutex.synchronize { @map[model] }
+      end
+
+      def build!
+        @mutex.synchronize { @map = {} }
+
+        serializer_classes.each do |klass|
+          register_by_convention(klass)
+          register_by_explicit(klass)
+        end
+      end
+
+      def reset!
+        @mutex.synchronize { @map = {} }
+      end
+
+      private
+
+      def serializer_classes
+        ObjectSpace.each_object(Class).select { |klass| safe_serializer?(klass) }
+      end
+
+      def register_by_convention(klass)
+        model_name = klass_name(klass)
+                     .gsub(/Serializer$/, "")
+                     &.split("::")
+                     &.last
+        return if model_name.blank?
+
+        model = Object.const_get(model_name)
+        return unless model < ActiveRecord::Base
+
+        register(model, klass)
+      rescue NameError
+        nil
+      end
+
+      def register_by_explicit(klass)
+        return unless klass.respond_to?(:_serializes) && klass._serializes&.any?
+
+        klass._serializes.each { |model| register(model, klass) }
+      end
+
+      def safe_serializer?(klass)
+        klass_name(klass)&.end_with?("Serializer") && klass < OpenapiBlocks::Serializer
+      rescue StandardError
+        false
+      end
+
+      def klass_name(klass)
+        Module.instance_method(:name).bind_call(klass)
+      end
+
+      def extract_model(object)
+        case object
+        when Array then object.first&.class
+        else            object.respond_to?(:klass) ? object.klass : object.class
+        end
+      end
+    end
+  end
+end

data/lib/openapi_blocks/serialization.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module OpenapiBlocks
+  module Serialization # rubocop:disable Style/Documentation
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods # rubocop:disable Metrics/ModuleLength,Style/Documentation
+      def serialize(resource, instance: nil) # rubocop:disable Lint/UnusedMethodArgument
+        extractor = compiled_extractor
+        if resource.respond_to?(:each)
+          resource.map { |r| extractor.call(r) }
+        else
+          extractor.call(resource)
+        end
+      end
+
+      def to_json(resource)
+        Oj.dump(serialize(resource), mode: :compat)
+      end
+
+      def fields
+        @fields ||= resolve_fields
+      end
+
+      def compiled_extractor
+        @compiled_extractor ||= build_compiled_extractor
+      end
+
+      private
+
+      def build_compiled_extractor # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        classified = classify_fields
+
+        model_lines = classified[:model].map { |f| %("#{f}" => object.public_send("#{f}")) }
+        virtual_lines   = classified[:virtual].map   { |f| %("#{f}" => inst.public_send("#{f}")) }
+        delegated_lines = classified[:delegated].map { |f| %("#{f}" => object.public_send("#{f}")) }
+        assoc_lines     = classified[:association].map do |f|
+          %("#{f}" => _serialize_assoc_#{f}(object))
+        end
+
+        classified[:association].each { |field| build_assoc_method(field) }
+
+        all_lines = (model_lines + delegated_lines + virtual_lines + assoc_lines).join(",\n        ")
+
+        if classified[:virtual].any?
+          serializer_klass = self
+          class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
+            def self._extract(object)
+              inst = #{serializer_klass}.new(object)
+              {
+                #{all_lines}
+              }
+            end
+          RUBY
+        else
+          class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
+            def self._extract(object)
+              {
+                #{all_lines}
+              }
+            end
+          RUBY
+        end
+
+        method(:_extract)
+      end
+
+      def build_assoc_method(field) # rubocop:disable Metrics/MethodLength
+        assoc = assoc_metadata_by_name[field]
+        assoc_name    = assoc[:name]
+        serializer    = resolve_assoc_serializer(assoc_name)
+
+        if serializer.nil?
+          class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
+            def self._serialize_assoc_#{field}(object)
+              object.public_send(:#{assoc_name}).as_json
+            end
+          RUBY
+          return
+        end
+
+        if assoc[:type] == :array
+          class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
+            def self._serialize_assoc_#{field}(object)
+              val = object.public_send(:#{assoc_name})
+              return nil if val.nil?
+              val.map { |v| #{serializer}.serialize(v) }
+            end
+          RUBY
+        else
+          class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
+            def self._serialize_assoc_#{field}(object)
+              val = object.public_send(:#{assoc_name})
+              val.nil? ? nil : #{serializer}.serialize(val)
+            end
+          RUBY
+        end
+      end
+
+      def classify_fields # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        model_set = Set.new(resolve_model_fields)
+        assoc_set   = Set.new(assoc_metadata_by_name.keys)
+        virtual_set = Set.new(
+          Array(_virtual_attributes).map { |a| a[:name].to_s }
+        )
+
+        result = { model: [], virtual: [], delegated: [], association: [] }
+        fields.each do |field|
+          result[if assoc_set.include?(field)
+                   :association
+                 elsif model_set.include?(field)
+                   :model
+                 elsif virtual_set.include?(field) && method_defined?(field.to_sym)
+                   :virtual       # método definido no resource
+                 elsif virtual_set.include?(field)
+                   :delegated     # método definido no model
+                 else # rubocop:disable Lint/DuplicateBranch
+                   :delegated
+                 end] << field
+        end
+        result
+      end
+
+      def assoc_metadata_by_name
+        @assoc_metadata_by_name ||= begin
+          klass  = self
+          result = {}
+          while klass && klass != serialization_sentinel
+            Array(klass._associations)
+              .each { |a| result[a[:name].to_s] ||= a }
+            klass = klass.superclass
+          end
+          result
+        end
+      end
+
+      def resolve_fields # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        klass = self
+        sentinel = serialization_sentinel
+
+        model_fields   = resolve_model_fields
+        virtual_fields = []
+        ignored_fields = []
+        assoc_fields   = []
+
+        while klass && klass != sentinel
+          virtual_fields += Array(klass._virtual_attributes).map { |a| a[:name].to_s }
+          ignored_fields += Array(klass._ignored)
+          assoc_fields   += Array(klass._associations).map { |a| a[:name].to_s }
+          klass = klass.superclass
+        end
+
+        (model_fields + virtual_fields + assoc_fields - ignored_fields).uniq
+      end
+
+      def resolve_model_fields
+        klass = self
+        sentinel = serialization_sentinel
+        while klass && klass != sentinel
+          begin
+            return klass.model.column_names
+          rescue StandardError
+            klass = klass.superclass
+          end
+        end
+        []
+      end
+
+      def serialization_sentinel
+        raise NotImplementedError
+      end
+
+      def resolve_assoc_serializer(assoc_name)
+        classified = assoc_name.to_s.classify
+
+        ["#{classified}Serializer", "#{classified}Openapi"].each do |name|
+          klass = Object.const_get(name)
+          return klass._resource if klass.respond_to?(:_resource) && klass._resource
+          return klass           if klass.respond_to?(:serialize)
+        rescue NameError
+          next
+        end
+
+        nil
+      end
+    end
+
+    attr_reader :object, :parent
+
+    def initialize(object, parent = nil)
+      @object = object
+      @parent = parent
+    end
+  end
+end

data/lib/openapi_blocks/serializer.rb

@@ -1,193 +1,23 @@
 # frozen_string_literal: true
 
 module OpenapiBlocks
-  module Serializer # rubocop:disable Style/Documentation
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods # rubocop:disable Metrics/ModuleLength,Style/Documentation
-      def serialize(resource, instance: nil) # rubocop:disable Lint/UnusedMethodArgument
-        extractor = compiled_extractor
-        if resource.respond_to?(:each)
-          resource.map { |r| extractor.call(r) }
-        else
-          extractor.call(resource)
-        end
-      end
-
-      def to_json(resource)
-        Oj.dump(serialize(resource), mode: :compat)
-      end
-
-      def fields
-        @fields ||= resolve_fields
-      end
-
-      def compiled_extractor
-        @compiled_extractor ||= build_compiled_extractor
-      end
+  class Serializer # rubocop:disable Style/Documentation
+    include Concerns::Schemable
+    include Serialization
 
+    class << self
       private
 
-      def build_compiled_extractor # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-        classified = classify_fields
-
-        model_lines     = classified[:model].map     { |f| %("#{f}" => object.public_send(:#{f})) }
-        virtual_lines   = classified[:virtual].map   { |f| %("#{f}" => inst.public_send(:#{f})) }
-        delegated_lines = classified[:delegated].map { |f| %("#{f}" => object.public_send(:#{f})) }
-        assoc_lines     = classified[:association].map do |f|
-          %("#{f}" => _serialize_assoc_#{f}(object))
-        end
-
-        classified[:association].each { |field| build_assoc_method(field) }
-
-        all_lines = (model_lines + delegated_lines + virtual_lines + assoc_lines).join(",\n        ")
-
-        if classified[:virtual].any?
-          serializer_klass = self
-          class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
-            def self._extract(object)
-              inst = #{serializer_klass}.new(object)
-              {
-                #{all_lines}
-              }
-            end
-          RUBY
-        else
-          class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
-            def self._extract(object)
-              {
-                #{all_lines}
-              }
-            end
-          RUBY
-        end
-
-        method(:_extract)
-      end
-
-      def build_assoc_method(field) # rubocop:disable Metrics/MethodLength
-        assoc = assoc_metadata_by_name[field]
-        assoc_name    = assoc[:name]
-        serializer    = resolve_assoc_serializer(assoc_name)
-
-        if serializer.nil?
-          class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
-            def self._serialize_assoc_#{field}(object)
-              object.public_send(:#{assoc_name}).as_json
-            end
-          RUBY
-          return
-        end
-
-        if assoc[:type] == :array
-          class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
-            def self._serialize_assoc_#{field}(object)
-              val = object.public_send(:#{assoc_name})
-              return nil if val.nil?
-              val.map { |v| #{serializer}.serialize(v) }
-            end
-          RUBY
-        else
-          class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
-            def self._serialize_assoc_#{field}(object)
-              val = object.public_send(:#{assoc_name})
-              val.nil? ? nil : #{serializer}.serialize(val)
-            end
-          RUBY
-        end
-      end
-
-      def resolve_assoc_serializer(assoc_name)
-        classified = assoc_name.to_s.classify
-
-        ["#{classified}Resource", "#{classified}Openapi"].each do |name|
-          klass = Object.const_get(name)
-          return klass._resource if klass.respond_to?(:_resource) && klass._resource
-          return klass           if klass.respond_to?(:serialize)
-        rescue NameError
-          next
-        end
-
-        nil
-      end
-
-      def classify_fields # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-        model_set = Set.new(resolve_model_fields)
-        assoc_set   = Set.new(assoc_metadata_by_name.keys)
-        virtual_set = Set.new(
-          Array(_virtual_attributes).map { |a| a[:name].to_s }
-        )
-
-        result = { model: [], virtual: [], delegated: [], association: [] }
-        fields.each do |field|
-          result[if assoc_set.include?(field)
-                   :association
-                 elsif model_set.include?(field)
-                   :model
-                 elsif virtual_set.include?(field) && method_defined?(field.to_sym)
-                   :virtual       # método definido no resource
-                 elsif virtual_set.include?(field)
-                   :delegated     # método definido no model
-                 else # rubocop:disable Lint/DuplicateBranch
-                   :delegated
-                 end] << field
-        end
-        result
-      end
-
-      def assoc_metadata_by_name
-        @assoc_metadata_by_name ||= begin
-          klass  = self
-          result = {}
-          while klass && klass != OpenapiBlocks::Base
-            Array(klass._associations)
-              .each { |a| result[a[:name].to_s] ||= a }
-            klass = klass.superclass
-          end
-          result
-        end
-      end
-
-      def resolve_fields # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-        klass = self
-
-        model_fields   = resolve_model_fields
-        virtual_fields = []
-        ignored_fields = []
-        assoc_fields   = []
+      def serialization_sentinel = OpenapiBlocks::Serializer
 
-        while klass && klass != OpenapiBlocks::Base
-          virtual_fields += Array(klass._virtual_attributes)
-                            .map    { |a| a[:name].to_s }
-          ignored_fields += Array(klass._ignored)
-          assoc_fields   += Array(klass._associations)
-                            .map    { |a| a[:name].to_s }
-          klass = klass.superclass
-        end
-
-        (model_fields + virtual_fields + assoc_fields - ignored_fields).uniq
+      def infer_model
+        model_name = name
+                     .gsub(/Serializer$/, "")
+                     .split("::").last
+        Object.const_get(model_name)
+      rescue NameError
+        raise Error, "Could not infer model from #{name}. Use `model ModelClass` to define it explicitly."
       end
-
-      def resolve_model_fields
-        klass = self
-        while klass && klass != OpenapiBlocks::Base
-          begin
-            return klass.model.column_names
-          rescue StandardError
-            klass = klass.superclass
-          end
-        end
-        []
-      end
-    end
-
-    attr_reader :object, :parent
-
-    def initialize(object, parent = nil)
-      @object = object
-      @parent = parent
     end
   end
 end

data/lib/openapi_blocks/spec/components.rb

@@ -16,15 +16,17 @@ module OpenapiBlocks
         schemas = @openapi_classes.each_with_object({}) do |klass, hash|
           schema_klass = klass.respond_to?(:_resource) && klass._resource ? klass._resource : klass
 
-          begin
-            next unless schema_klass.model
+          model = begin
+            schema_klass.model
           rescue StandardError
             next
           end
 
-          schema_name = schema_klass.model.name
+          next unless model
+
+          schema_name = model.name
           extractor   = Schema::Extractor.new(schema_klass)
-          validator   = Schema::Validator.new(schema_klass.model)
+          validator   = Schema::Validator.new(model)
 
           schema              = extractor.extract
           schema[:properties] = merge_validations(schema[:properties], validator.extract)

data/lib/openapi_blocks/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenapiBlocks
-  VERSION = "0.3.1"
+  VERSION = "0.4.1"
 end