jbuilder-schema 1.0.3 → 2.0.1

data/lib/jbuilder/schema/renderer.rb

@@ -1,57 +1,39 @@
-# frozen_string_literal: true
-
-require "jbuilder/schema/template"
-# TODO: Find a better way to load main app's helpers:
-# Helpers don't work in Jbuilder itself, so no need to include them here!
-# ActionController::Base.all_helpers_from_path('app/helpers').each { |helper| require "./app/helpers/#{helper}_helper" }
-
-module JbuilderSchema
-  # Here we initialize all the variables needed for template and pass them to it
-  class Renderer
-    # TODO: Find a better way to load main app's helpers:
-    # Helpers don't work in Jbuilder itself, so no need to include them here!
-    # ActionController::Base.all_helpers_from_path('app/helpers').each { |helper| include Object.const_get("::#{helper.camelize}Helper") }
-
-    attr_reader :locals, :options
-
-    def initialize(**options)
-      @locals = options.delete(:locals) || {}
-      @options = options
-      _define_locals!
-    end
-
-    def render(source)
-      Template.new(**options) do |json|
-        # TODO: Get rid of 'eval'
-        eval source.to_s # standard:disable Security/Eval
-      end
-    end
-
-    def method_missing(method, *args)
-      if method.to_s.end_with?("_path", "_url")
-        method.to_s
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      method_name.to_s.end_with?("_path", "_url") || super
-    end
-
-    private
-
-    def _define_locals!
-      locals.each do |k, v|
-        # Setting instance variables (`@article`):
-        instance_variable_set("@#{k}", v)
-
-        # Setting local variables (`article`):
-        # We can define method:
-        # define_singleton_method(k) { v }
-        # or set attr_reader on an instance, this feels better:
-        singleton_class.instance_eval { attr_reader k }
-      end
-    end
+require "active_support/core_ext/hash/deep_transform_values"
+require_relative "template"
+
+class Jbuilder::Schema::Renderer
+  @@view_renderer = ActionView::Base.with_empty_template_cache
+
+  def initialize(paths, default_locals = nil)
+    @view_renderer = @@view_renderer.with_view_paths(paths)
+    @default_locals = default_locals
+  end
+
+  def yaml(...)
+    normalize(render(...)).to_yaml
+  end
+
+  def json(...)
+    normalize(render(...)).to_json
+  end
+
+  def render(object = nil, title: nil, description: nil, assigns: nil, **options)
+    partial_path = object.respond_to?(:to_partial_path_for_jbuilder_schema) ? object.to_partial_path_for_jbuilder_schema : object.to_partial_path
+    options.merge! partial: partial_path, object: object if object
+
+    options[:locals] ||= {}
+    options[:locals].merge! @default_locals if @default_locals
+    options[:locals][:__jbuilder_schema_options] = { model: object&.class, title: title, description: description }
+
+    @view_renderer.assign assigns if assigns
+    @view_renderer.render(options)
+  end
+
+  private
+
+  def normalize(schema)
+    schema.deep_stringify_keys
+      .deep_transform_values { |v| v.is_a?(Symbol) ? v.to_s : v }
+      .deep_transform_values { |v| v.is_a?(Regexp) ? v.source : v }
   end
 end

data/lib/jbuilder/schema/template.rb

@@ -2,24 +2,49 @@
 
 require "jbuilder/jbuilder_template"
 require "active_support/inflections"
-require "active_support/core_ext/hash/deep_transform_values"
-require "safe_parser"
 
-module JbuilderSchema
-  # Template parser class
+class Jbuilder::Schema
   class Template < ::JbuilderTemplate
-    attr_reader :attributes, :type, :models, :titles, :descriptions
+    attr_reader :attributes, :type
+    attr_reader :model_scope
 
-    def initialize(*args, **options)
+    class Handler < ::JbuilderHandler
+      def self.call(template, source = nil)
+        super.sub("JbuilderTemplate.new(self", "Jbuilder::Schema::Template.new(self, **__jbuilder_schema_options").sub("target!", "schema!")
+      end
+    end
+
+    ::ActiveSupport.on_load :action_view do
+      ::ActionView::Template.register_template_handler :jbuilder, ::Jbuilder::Schema::Template::Handler
+    end
+
+    ModelScope = ::Struct.new(:model, :title, :description, keyword_init: true) do
+      def initialize(**)
+        super
+        @scope = model&.name&.underscore&.pluralize
+      end
+
+      def i18n_title
+        title || ::I18n.t(::Jbuilder::Schema.title_name, scope: @scope)
+      end
+
+      def i18n_description
+        description || ::I18n.t(::Jbuilder::Schema.description_name, scope: @scope)
+      end
+
+      def translate_field(key)
+        ::I18n.t("fields.#{key}.#{::Jbuilder::Schema.description_name}", scope: @scope)
+      end
+    end
+
+    def initialize(context, **options)
       @type = :object
       @inline_array = false
       @collection = false
 
-      @models = [options.delete(:model)]
-      @titles = [options.delete(:title)]
-      @descriptions = [options.delete(:description)]
+      @model_scope = ModelScope.new(**options)
 
-      super(nil, *args)
+      super(context)
 
       @ignore_nil = false
     end
@@ -28,7 +53,7 @@ module JbuilderSchema
       {type: type}.merge(type == :object ? _object(**attributes.merge) : attributes)
     end
 
-    def set!(key, value = BLANK, *args, **schema_options, &block)
+    def set!(key, value = BLANK, *args, schema: {}, **options, &block)
       result = if block
         if !_blank?(value)
           # OBJECTS ARRAY:
@@ -40,18 +65,10 @@ module JbuilderSchema
           # json.comments { ... }
           # { "comments": ... }
           @inline_array = true
-          if schema_options.key?(:object)
-            models << schema_options[:object].class
-            titles << schema_options[:object_title] || nil
-            descriptions << schema_options[:object_description] || nil
-          end
-          r = _merge_block(key) { yield self }
-          if schema_options.key?(:object)
-            models.pop
-            titles.pop
-            descriptions.pop
+
+          _with_model_scope(**schema) do
+            _merge_block(key) { yield self }
           end
-          r
         end
       elsif args.empty?
         if ::Jbuilder === value
@@ -59,7 +76,7 @@ module JbuilderSchema
           # json.age 32
           # json.person another_jbuilder
           # { "age": 32, "person": { ...  }
-          _schema(key, _format_keys(value.attributes!), **schema_options)
+          _schema(key, _format_keys(value.attributes!), **schema)
         elsif _is_collection_array?(value)
           # ATTRIBUTE2:
           _scope { array! value }
@@ -67,7 +84,7 @@ module JbuilderSchema
         else
           # json.age 32
           # { "age": 32 }
-          _schema(key, _format_keys(value), **schema_options)
+          _schema(key, _format_keys(value), **schema)
         end
       elsif _is_collection?(value)
         # COLLECTION:
@@ -77,46 +94,33 @@ module JbuilderSchema
         @collection = true
 
         _scope { array! value, *args }
-      elsif schema_options.key?(:object)
+      else
         # EXTRACT!:
         # json.author @article.creator, :name, :email_address
         # { "author": { "name": "David", "email_address": "david@loudthinking.com" } }
-
-        models << schema_options.delete(:object).class
-        titles << schema_options.delete(:object_title) || nil
-        descriptions << schema_options.delete(:object_description) || nil
-        r = _merge_block(key) { extract! value, *args, **schema_options }
-        models.pop
-        titles.pop
-        descriptions.pop
-        r
-      else
-        _merge_block(key) { extract! value, *args, **schema_options }
+        _with_model_scope(**schema) do
+          _merge_block(key) { extract! value, *args, schema: schema }
+        end
       end
 
-      result = _set_description key, result if models.any?
+      result = _set_description key, result if model_scope.model
       _set_value key, result
     end
 
-    def extract!(object, *attributes, **schema_options)
-      schema_options = schema_options[:schema] if schema_options.key?(:schema)
-
+    def extract!(object, *attributes, schema: {})
       if ::Hash === object
-        _extract_hash_values(object, attributes, **schema_options)
+        _extract_hash_values(object, attributes, schema: schema)
       else
-        _extract_method_values(object, attributes, **schema_options)
+        _extract_method_values(object, attributes, schema: schema)
       end
     end
 
-    def array!(collection = [], *args, &block)
-      args, schema_options = _args_and_schema_options(*args)
-      options = args.first
-
-      if args.one? && _partial_options?(options)
+    def array!(collection = [], *args, schema: {}, **options, &block)
+      if _partial_options?(options)
         @collection = true
         _set_ref(options[:partial].split("/").last)
       else
-        array = _make_array(collection, *args, **schema_options, &block)
+        array = _make_array(collection, *args, schema: schema, &block)
 
         if @inline_array
           @attributes = {}
@@ -139,7 +143,7 @@ module JbuilderSchema
       if args.one? && _is_active_model?(args.first)
         # TODO: Find where it is being used
         _render_active_model_partial args.first
-      elsif args.first.is_a?(Hash)
+      elsif args.first.is_a?(::Hash)
         _set_ref(args.first[:partial].split("/").last)
       else
         @collection = true if args[1].key?(:collection)
@@ -150,10 +154,10 @@ module JbuilderSchema
     def merge!(object)
       hash_or_array = ::Jbuilder === object ? object.attributes! : object
       hash_or_array = _format_keys(hash_or_array)
-      if hash_or_array.is_a?(Hash)
+      if hash_or_array.is_a?(::Hash)
         hash_or_array = hash_or_array.each_with_object({}) do |(key, value), a|
           result = _schema(key, value)
-          result = _set_description(key, result) if models.any?
+          result = _set_description(key, result) if model_scope.model
           a[key] = result
         end
       end
@@ -161,169 +165,127 @@ module JbuilderSchema
     end
 
     def cache!(key = nil, **options)
-      yield
-    end
-
-    def method_missing(*args, &block)
-      args, schema_options = _args_and_schema_options(*args)
-
-      if block
-        set!(*args, **schema_options, &block)
-      else
-        set!(*args, **schema_options)
-      end
+      yield # TODO: Our schema generation breaks Jbuilder's fragment caching.
     end
 
-    def respond_to_missing?(method_name, include_private = false)
-      super
+    def method_missing(*args, **options, &block) # standard:disable Style/MissingRespondToMissing
+      # TODO: Remove once Jbuilder passes keyword arguments along to `set!` in its `method_missing`.
+      set!(*args, **options, &block)
     end
 
     private
 
-    def _object(**attrs)
-      title = titles.last || ::I18n.t("#{models&.last&.name&.underscore&.pluralize}.#{JbuilderSchema.configuration.title_name}")
-      description = descriptions.last || ::I18n.t("#{models&.last&.name&.underscore&.pluralize}.#{JbuilderSchema.configuration.description_name}")
+    def _with_model_scope(object: nil, object_title: nil, object_description: nil, **)
+      old_model_scope, @model_scope = @model_scope, ModelScope.new(model: object.class, title: object_title, description: object_description) if object
+      yield
+    ensure
+      @model_scope = old_model_scope if object
+    end
+
+    def _object(**attributes)
       {
         type: :object,
-        title: title,
-        description: description,
-        required: _required!(**attrs),
-        properties: attrs
+        title: model_scope.i18n_title,
+        description: model_scope.i18n_description,
+        required: _required!(attributes.keys),
+        properties: attributes
       }
     end
 
-    def _args_and_schema_options(*args)
-      schema_options = args.extract! { |a| a.is_a?(::Hash) && a.key?(:schema) }.first.try(:[], :schema) || {}
-      [args, schema_options]
-    end
-
     def _set_description(key, value)
       unless value.key?(:description)
-        description = ::I18n.t("#{models.last&.name&.underscore&.pluralize}.fields.#{key}.#{JbuilderSchema.configuration.description_name}")
+        description = model_scope.translate_field(key)
         value = {description: description}.merge! value
       end
       value
     end
 
     def _set_ref(component)
+      component_path = "#/#{::Jbuilder::Schema.components_path}/#{component}"
+
       if @inline_array
         if @collection
           _set_value(:type, :array)
-          _set_value(:items, {:$ref => _component_path(component)})
+          _set_value(:items, {:$ref => component_path})
         else
           _set_value(:type, :object)
-          _set_value(:$ref, _component_path(component))
+          _set_value(:$ref, component_path)
         end
       else
         @type = :array
-        _set_value(:items, {:$ref => _component_path(component)})
+        _set_value(:items, {:$ref => component_path})
       end
     end
 
-    def _component_path(component)
-      "#/#{JbuilderSchema.configuration.components_path}/#{component}"
-    end
+    FORMATS = {::DateTime => "date-time", ::ActiveSupport::TimeWithZone => "date-time", ::Date => "date", ::Time => "time"}
 
     def _schema(key, value, **options)
-      options.merge!(_guess_type(value)) unless options[:type]
-      options.merge!(_set_enum(key.to_s)) if models.last&.defined_enums&.keys&.include?(key.to_s)
-      options
-    end
+      unless options[:type]
+        options[:type] = _primitive_type value
 
-    def _guess_type(value)
-      type = value.class.name&.downcase&.to_sym
+        if options[:type] == :array && (types = value.map { _primitive_type _1 }.uniq).any?
+          options[:minContains] = 0
+          options[:contains] = {type: types.many? ? types : types.first}
+        end
 
-      case type
-      when :datetime, :"activesupport::timewithzone"
-        {type: :string, format: "date-time"}
-      when :time, :date
-        {type: :string, format: type.to_s}
-      when :array
-        _guess_array_types(value)
-      else
-        {type: _type(type)}
+        format = FORMATS[value.class] and options[:format] ||= format
       end
-    end
 
-    def _guess_array_types(array)
-      hash = {type: :array}
-      types = array.map { |a| _type(a.class.name&.downcase&.to_sym) }.uniq
-
-      unless types.empty?
-        hash[:contains] = {type: types.size > 1 ? types : types.first}
-        hash[:minContains] = 0
+      if (model = model_scope.model) && (defined_enum = model.try(:defined_enums)&.dig(key.to_s))
+        options[:enum] = defined_enum.keys
       end
 
-      hash
+      options
     end
 
-    def _type(type)
+    def _primitive_type(type)
       case type
-      when :float, :bigdecimal
-        :number
-      when :trueclass, :falseclass
-        :boolean
-      when :integer
-        :integer
+      when ::Array then :array
+      when ::Float, ::BigDecimal then :number
+      when true, false then :boolean
+      when ::Integer then :integer
       else
         :string
       end
     end
 
-    def _set_enum(key)
-      enums = models.last&.defined_enums[key].keys
-      {enum: enums}
-    end
-
-    def _make_array(collection, *args, **schema_options, &block)
+    def _make_array(collection, *args, schema: {}, &block)
       if collection.nil?
         []
       elsif block
         _map_collection(collection, &block)
       elsif args.any?
-        _map_collection(collection) { |element| extract! element, *args, **schema_options }
+        _map_collection(collection) { |element| extract! element, *args, schema: schema }
       else
         _format_keys(collection.to_a)
       end
     end
 
     def _is_collection_array?(object)
-      # TODO: Find better way to determine if all array elements are models
-      object.is_a?(Array) && object.map { |a| _is_active_model?(a) }.uniq == [true]
+      object.is_a?(::Array) && object.all? { _is_active_model? _1 }
     end
 
-    def _required!(**attrs)
-      if Object.const_defined?('ActiveRecord')
-        attrs.keys.select { |attribute|
-          models.last&.validators.try(:grep, ::ActiveRecord::Validations::PresenceValidator)
-                .flat_map(&:attributes).unshift(_key(:id))
-                .include?(attribute.to_s.underscore.to_sym)
-        }.uniq
-      else
-        attrs.keys.include?(_key(:id)) ? [_key(:id)] : []
-      end
+    def _required!(keys)
+      presence_validated_attributes = model_scope.model.try(:validators).to_a.flat_map { _1.attributes if _1.is_a?(::ActiveRecord::Validations::PresenceValidator) }
+      keys & [_key(:id), *presence_validated_attributes.map { _key _1 }]
     end
 
     ###
     # Jbuilder methods
     ###
 
-    def _key(key)
-      @key_formatter ? @key_formatter.format(key).to_sym : key.to_sym
-    end
-
-    def _extract_hash_values(object, attributes, **schema_options)
+    def _extract_hash_values(object, attributes, schema:)
       attributes.each do |key|
-        result = _schema(key, _format_keys(object.fetch(key)), **schema_options[key] || {})
-        result = _set_description(key, result) if models.any?
+        result = _schema(key, _format_keys(object.fetch(key)), **schema[key] || {})
+        result = _set_description(key, result) if model_scope.model
         _set_value key, result
       end
     end
 
-    def _extract_method_values(object, attributes, **schema_options)
+    def _extract_method_values(object, attributes, schema:)
       attributes.each do |key|
-        result = _schema(key, _format_keys(object.public_send(key)), **schema_options[key] || {})
-        result = _set_description(key, result) if models.any?
+        result = _schema(key, _format_keys(object.public_send(key)), **schema[key] || {})
+        result = _set_description(key, result) if model_scope.model
         _set_value key, result
       end
     end
@@ -336,25 +298,21 @@ module JbuilderSchema
       current_value = _blank? ? BLANK : @attributes.fetch(_key(key), BLANK)
       raise NullError.build(key) if current_value.nil?
 
-      new_value = _scope { yield self }
-      unless new_value.key?(:type) && new_value[:type] == :array || new_value.key?(:$ref)
-        new_value_properties = new_value
-        new_value = _object(**new_value_properties)
-      end
-      _merge_values(current_value, new_value)
+      value = _scope { yield self }
+      value = _object(**value) unless value.values_at("type", :type).any?(:array) || value.key?(:$ref) || value.key?("$ref")
+      _merge_values(current_value, value)
     end
   end
 end
 
 class Jbuilder
-  # Monkey-patch for Jbuilder::KeyFormatter to ignore schema keys
-  class KeyFormatter
-    alias_method :original_format, :format
+  module SkipFormatting
+    SCHEMA_KEYS = %i[type items properties]
 
     def format(key)
-      return key if %i[type items properties].include?(key)
-
-      original_format(key)
+      SCHEMA_KEYS.include?(key) ? key : super
     end
   end
+
+  KeyFormatter.prepend SkipFormatting
 end

data/lib/jbuilder/schema/version.rb

@@ -1,5 +1,4 @@
-# frozen_string_literal: true
-
-module JbuilderSchema
-  VERSION = "1.0.3"
-end
+# We can't use the standard `Jbuilder::Schema::VERSION =` because
+# `Jbuilder` isn't a regular module namespace, but a class …which also loads Active Support.
+# So we use trickery, and assign the proper version once `jbuilder/schema.rb` is loaded.
+JBUILDER_SCHEMA_VERSION = "2.0.1"

data/lib/jbuilder/schema.rb

@@ -1,12 +1,30 @@
 # frozen_string_literal: true
 
-require "jbuilder/schema/version"
-require "jbuilder/schema/configuration"
-require "jbuilder/schema/builder"
-
-# Main gem module with configuration and helper methods
-module JbuilderSchema
-  def jbuilder_schema(path, **options)
-    Builder.new(path, **options).schema!
+require "active_support/core_ext/module/delegation"
+
+class Jbuilder::Schema
+  VERSION = JBUILDER_SCHEMA_VERSION # See `jbuilder/schema/version.rb`
+
+  module IgnoreSchemaMeta
+    ::Jbuilder.prepend self
+
+    def method_missing(*args, schema: nil, **options, &block) # standard:disable Style/MissingRespondToMissing
+      super(*args, **options, &block)
+    end
+  end
+
+  singleton_class.alias_method :configure, :tap
+  singleton_class.attr_accessor :components_path, :title_name, :description_name
+  @components_path, @title_name, @description_name = "components/schemas", "title", "description"
+
+  autoload :Renderer, "jbuilder/schema/renderer"
+
+  def self.renderer(paths = nil, locals: nil)
+    if paths.nil? && locals.nil?
+      @renderer ||= Renderer.new("app/views")
+    else
+      Renderer.new(paths, locals)
+    end
   end
+  singleton_class.delegate :yaml, :json, :render, to: :renderer
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jbuilder-schema
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 2.0.1
 platform: ruby
 authors:
 - Yuri Sidorov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-15 00:00:00.000000000 Z
+date: 2022-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jbuilder
@@ -24,20 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: safe_parser
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -65,15 +51,10 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- lib/jbuilder/jbuilder.rb
 - lib/jbuilder/schema.rb
-- lib/jbuilder/schema/builder.rb
-- lib/jbuilder/schema/configuration.rb
 - lib/jbuilder/schema/renderer.rb
-- lib/jbuilder/schema/resolver.rb
 - lib/jbuilder/schema/template.rb
 - lib/jbuilder/schema/version.rb
-- sig/jbuilder/schema.rbs
 homepage: https://github.com/bullet-train-co/jbuilder-schema
 licenses:
 - MIT
@@ -95,7 +76,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.16
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Generate JSON Schema from Jbuilder files

data/lib/jbuilder/jbuilder.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require "jbuilder"
-
-# Patches for Jbuilder to make it ignore schema metadata
-class Jbuilder
-  alias_method :original_method_missing, :method_missing
-
-  def method_missing(*args, &block)
-    args = _extract_schema_meta!(*args)
-    original_method_missing(*args, &block)
-  end
-
-  def respond_to_missing?(method_name, include_private = false)
-    super
-  end
-
-  private
-
-  def _extract_schema_meta!(*args)
-    args.delete_if { |a| a.is_a?(::Hash) && a.key?(:schema) }
-  end
-end