openapi_blocks 0.3.1 → 0.5.0

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.5.0"
 end

data/lib/openapi_blocks.rb

@@ -18,13 +18,17 @@ require_relative "openapi_blocks/spec/components"
 require_relative "openapi_blocks/spec/paths"
 require_relative "openapi_blocks/spec/document"
 require_relative "openapi_blocks/builder"
-require_relative "openapi_blocks/serializer"
-require_relative "openapi_blocks/base"
 require_relative "openapi_blocks/engine"
 require_relative "openapi_blocks/railtie"
 require_relative "openapi_blocks/operation_builder"
-require_relative "openapi_blocks/resource"
+require_relative "openapi_blocks/concerns/schemable"
+require_relative "openapi_blocks/concerns/documentable"
+require_relative "openapi_blocks/serialization"
+require_relative "openapi_blocks/base"
+require_relative "openapi_blocks/serializer"
 require_relative "openapi_blocks/controller"
+require_relative "openapi_blocks/registry"
+require_relative "openapi_blocks/auto_serialize"
 
 module OpenapiBlocks # rubocop:disable Style/Documentation
   class Error < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openapi_blocks
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Caio Santos
@@ -122,7 +122,9 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.1'
 description: Generates OpenAPI specs automatically from ActiveRecord models, ActiveModel
-  validations and Rails routes, inspired by ActiveModel::Serializer.
+  validations and Rails routes. Includes a built-in serializer ~3.6x faster than as_json,
+  Scalar and Swagger UI out of the box, and optional auto-serialization via render
+  json:. Inspired by ActiveModel::Serializer.
 email:
 - caio.francelinosena@gmail.com
 executables: []
@@ -137,10 +139,19 @@ files:
 - Rakefile
 - app/controllers/openapi_blocks/spec_controller.rb
 - config/routes.rb
+- lib/generators/openapi_blocks/install/install_generator.rb
+- lib/generators/openapi_blocks/install/templates/initializer.rb.tt
+- lib/generators/openapi_blocks/openapi/openapi_generator.rb
+- lib/generators/openapi_blocks/openapi/templates/openapi.rb.tt
+- lib/generators/openapi_blocks/serializer/serializer_generator.rb
+- lib/generators/openapi_blocks/serializer/templates/serializer.rb.tt
 - lib/openapi_blocks.rb
+- lib/openapi_blocks/auto_serialize.rb
 - lib/openapi_blocks/base.rb
 - lib/openapi_blocks/builder.rb
 - lib/openapi_blocks/cache.rb
+- lib/openapi_blocks/concerns/documentable.rb
+- lib/openapi_blocks/concerns/schemable.rb
 - lib/openapi_blocks/configuration.rb
 - lib/openapi_blocks/configuration/contact_builder.rb
 - lib/openapi_blocks/configuration/info_builder.rb
@@ -154,12 +165,13 @@ files:
 - lib/openapi_blocks/middleware.rb
 - lib/openapi_blocks/operation_builder.rb
 - lib/openapi_blocks/railtie.rb
-- lib/openapi_blocks/resource.rb
+- lib/openapi_blocks/registry.rb
 - lib/openapi_blocks/routing/extractor.rb
 - lib/openapi_blocks/routing/operation.rb
 - lib/openapi_blocks/schema/extractor.rb
 - lib/openapi_blocks/schema/types.rb
 - lib/openapi_blocks/schema/validator.rb
+- lib/openapi_blocks/serialization.rb
 - lib/openapi_blocks/serializer.rb
 - lib/openapi_blocks/spec/components.rb
 - lib/openapi_blocks/spec/document.rb
@@ -188,7 +200,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.9
+rubygems_version: 4.0.3
 specification_version: 4
-summary: DSL to generate OpenAPI 3.0/3.1 documentation for Rails applications
+summary: OpenAPI 3.0/3.1 documentation and high-performance serializer for Rails
 test_files: []

data/lib/openapi_blocks/resource.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module OpenapiBlocks
-  class Resource < Base # rubocop:disable Style/Documentation
-    class << self
-      private
-
-      def infer_model
-        model_name = name
-                     .gsub(/Resource$/, "")
-                     .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
-    end
-  end
-end