jbuilder-schema 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1a468c68f0ab10f9d02f4b38e5b42ecfaa7a9570d8cc95e4f1a586bcdcd4b8d8
+  data.tar.gz: 9cfbdbc84f0411af2945277c534ad86d3167bc276da4055630a75b9aab56f668
+SHA512:
+  metadata.gz: 5a45615f7ff8b2733fb20a21057ac66b46c8efcb40149dbf54e61d5aafc9d343e8977d3569806e1f5e5d17207db7378941c2b1f8199598faa8fe212886057320
+  data.tar.gz: 516e22d82465a265605237ed8e777ebdfa4a39e6bc3edf49ad2f7bc83d26ad5129a55edc9f4c616c40f49c33ded8cbc0134a192fcb996fd0b1462692106321ab

data/.standard.yml

@@ -0,0 +1,5 @@
+# For available configuration options, see:
+#   https://github.com/testdouble/standard
+ruby_version: 3.0
+fix: true
+parallel: true

data/Gemfile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in jbuilder-schema.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "factory_bot"
+gem "faker"
+
+gem "standard", "~> 1.3"
+
+gem "mocha"

data/Gemfile.lock

@@ -0,0 +1,200 @@
+PATH
+  remote: .
+  specs:
+    jbuilder-schema (1.0.0)
+      jbuilder
+      rails (>= 5.0.0)
+      safe_parser
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actioncable (7.0.3.1)
+      actionpack (= 7.0.3.1)
+      activesupport (= 7.0.3.1)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+    actionmailbox (7.0.3.1)
+      actionpack (= 7.0.3.1)
+      activejob (= 7.0.3.1)
+      activerecord (= 7.0.3.1)
+      activestorage (= 7.0.3.1)
+      activesupport (= 7.0.3.1)
+      mail (>= 2.7.1)
+      net-imap
+      net-pop
+      net-smtp
+    actionmailer (7.0.3.1)
+      actionpack (= 7.0.3.1)
+      actionview (= 7.0.3.1)
+      activejob (= 7.0.3.1)
+      activesupport (= 7.0.3.1)
+      mail (~> 2.5, >= 2.5.4)
+      net-imap
+      net-pop
+      net-smtp
+      rails-dom-testing (~> 2.0)
+    actionpack (7.0.3.1)
+      actionview (= 7.0.3.1)
+      activesupport (= 7.0.3.1)
+      rack (~> 2.0, >= 2.2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actiontext (7.0.3.1)
+      actionpack (= 7.0.3.1)
+      activerecord (= 7.0.3.1)
+      activestorage (= 7.0.3.1)
+      activesupport (= 7.0.3.1)
+      globalid (>= 0.6.0)
+      nokogiri (>= 1.8.5)
+    actionview (7.0.3.1)
+      activesupport (= 7.0.3.1)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activejob (7.0.3.1)
+      activesupport (= 7.0.3.1)
+      globalid (>= 0.3.6)
+    activemodel (7.0.3.1)
+      activesupport (= 7.0.3.1)
+    activerecord (7.0.3.1)
+      activemodel (= 7.0.3.1)
+      activesupport (= 7.0.3.1)
+    activestorage (7.0.3.1)
+      actionpack (= 7.0.3.1)
+      activejob (= 7.0.3.1)
+      activerecord (= 7.0.3.1)
+      activesupport (= 7.0.3.1)
+      marcel (~> 1.0)
+      mini_mime (>= 1.1.0)
+    activesupport (7.0.3.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ast (2.4.2)
+    builder (3.2.4)
+    concurrent-ruby (1.1.10)
+    crass (1.0.6)
+    erubi (1.11.0)
+    factory_bot (6.2.1)
+      activesupport (>= 5.0.0)
+    faker (2.22.0)
+      i18n (>= 1.8.11, < 2)
+    globalid (1.0.0)
+      activesupport (>= 5.0)
+    i18n (1.12.0)
+      concurrent-ruby (~> 1.0)
+    jbuilder (2.11.5)
+      actionview (>= 5.0.0)
+      activesupport (>= 5.0.0)
+    json (2.6.2)
+    loofah (2.19.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    mail (2.7.1)
+      mini_mime (>= 0.1.1)
+    marcel (1.0.2)
+    method_source (1.0.0)
+    mini_mime (1.1.2)
+    mini_portile2 (2.8.0)
+    minitest (5.16.2)
+    mocha (1.14.0)
+    net-imap (0.3.1)
+      net-protocol
+    net-pop (0.1.2)
+      net-protocol
+    net-protocol (0.1.3)
+      timeout
+    net-smtp (0.3.2)
+      net-protocol
+    nio4r (2.5.8)
+    nokogiri (1.13.8)
+      mini_portile2 (~> 2.8.0)
+      racc (~> 1.4)
+    parallel (1.22.1)
+    parser (3.1.2.0)
+      ast (~> 2.4.1)
+    racc (1.6.0)
+    rack (2.2.4)
+    rack-test (2.0.2)
+      rack (>= 1.3)
+    rails (7.0.3.1)
+      actioncable (= 7.0.3.1)
+      actionmailbox (= 7.0.3.1)
+      actionmailer (= 7.0.3.1)
+      actionpack (= 7.0.3.1)
+      actiontext (= 7.0.3.1)
+      actionview (= 7.0.3.1)
+      activejob (= 7.0.3.1)
+      activemodel (= 7.0.3.1)
+      activerecord (= 7.0.3.1)
+      activestorage (= 7.0.3.1)
+      activesupport (= 7.0.3.1)
+      bundler (>= 1.15.0)
+      railties (= 7.0.3.1)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.4.3)
+      loofah (~> 2.3)
+    railties (7.0.3.1)
+      actionpack (= 7.0.3.1)
+      activesupport (= 7.0.3.1)
+      method_source
+      rake (>= 12.2)
+      thor (~> 1.0)
+      zeitwerk (~> 2.5)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.5.0)
+    rexml (3.2.5)
+    rubocop (1.32.0)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.1.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.19.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.19.1)
+      parser (>= 3.1.1.0)
+    rubocop-performance (1.14.3)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.11.0)
+    ruby_parser (3.8.4)
+      sexp_processor (~> 4.1)
+    safe_parser (1.0.0)
+      ruby_parser (~> 3.8.4)
+    sexp_processor (4.16.1)
+    standard (1.14.0)
+      rubocop (= 1.32.0)
+      rubocop-performance (= 1.14.3)
+    thor (1.2.1)
+    timeout (0.3.0)
+    tzinfo (2.0.5)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.2.0)
+    websocket-driver (0.7.5)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    zeitwerk (2.6.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  factory_bot
+  faker
+  jbuilder-schema!
+  mocha
+  rake (~> 13.0)
+  standard (~> 1.3)
+
+BUNDLED WITH
+   2.3.16

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Yuri Sidorov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,234 @@
+# JbuilderSchema
+
+Generate JSON Schema compatible with OpenAPI 3 specs from Jbuilder files
+
+[![Tests](https://github.com/bullet-train-co/jbuilder-schema/actions/workflows/tests.yml/badge.svg)](https://github.com/bullet-train-co/jbuilder-schema/actions)
+[![Standard](https://github.com/bullet-train-co/jbuilder-schema/actions/workflows/standard.yml/badge.svg)](https://github.com/bullet-train-co/jbuilder-schema/actions)
+
+## Installation
+
+In Gemfile put `gem "jbuilder-schema"` **before** `gem "jbuilder"`:
+
+    gem "jbuilder-schema", require: "jbuilder/schema"
+    gem "jbuilder"
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jbuilder-schema
+
+## Usage
+
+Wherever you want to generate schemas, you should extend `JbuilderSchema`:
+
+    extend JbuilderSchema
+
+Then you can use `jbuilder_schema` helper:
+
+    jbuilder_schema('api/v1/articles/_article',
+                    title: 'Article',
+                    description: 'Article in the blog',
+                    format: :yaml,
+                    paths: view_paths.map(&:path),
+                    model: Article,
+                    locals: {
+                      article: @article,
+                      current_user: @user
+                    })
+
+`jbuilder_schema` helper takes `path` to Jbuilder template as a first argument and several optional arguments:
+
+- `title` and `description`: Title and description of schema, if not passed then they will be grabbed from locale files (see *[Titles & Descriptions](#titles--descriptions)*);
+- `format`: Desired output format, can be either `:yaml` or `:json`. If no `format` option is passed, the output will be the Ruby Hash object;
+- `paths`: If you need to scope any other paths than `app/views`, pass them as an array here;
+- `model`: Model described in template, this is needed to populate `required` field in schema;
+- `locals`: Here you should pass all the locals which are met in the jbuilder template. Those could be any objects as long as they respond to methods called on them in template.
+
+Notice that partial templates should be prepended with an underscore just like in the name of the file (i.e. `_article` but not `article` an when using Jbuilder).
+
+### Output
+
+JbuilderSchema automatically sets `description`, `type`, and `required` options in JSON-Schema.
+
+For example, if we have `_articles.json.jbilder` file:
+
+    json.extract! article, :id, :title, :body, :created_at
+
+The output for it will be:
+
+    type: object
+    title: Article
+    description: Article in the blog
+    required:
+      - id
+      - title
+      - body
+    properties:
+      id:
+        description: ID of an article
+        type: integer
+      title:
+        description: Title of an article
+        type: string
+      body:
+        description: Contents of an article
+        type: string
+      created_at:
+        description: Timestamp when article was created
+        type: string
+        format: date-time
+
+### Customization
+
+#### Simple
+
+Sometimes you would want to set you own data in generated JSON-Schema. All you need to do is just pass hash with it under `schema` keyword in your jbuilder template:
+
+    json.id article.id, schema: { type: :number, description: "Custom ID description" }
+    json.title article.title, schema: { minLength: 5, maxLength: 20 }
+    json.body article.body, schema: { type: :text, maxLength: 500 }
+    json.created_at article.created_at.strftime('%d/%m/%Y'), schema: { format: :date, pattern: /^(3[01]|[12][0-9]|0[1-9])\/(1[0-2]|0[1-9])\/[0-9]{4}$/ }
+
+This will produce the following:
+
+    ...
+      properties:
+        id:
+          description: Custom ID description
+          type: number
+        title:
+          description: Title of an article
+          type: string
+          minLength: 5
+          maxLength: 20
+        body:
+          description: Contents of an article
+          type: string
+          maxLength: 500
+        created_at:
+          description: Timestamp when article was created
+          type: string
+          format: date
+          pattern: "^(3[01]|[12][0-9]|0[1-9])\/(1[0-2]|0[1-9])\/[0-9]{4}$"
+
+#### Bulk
+
+You can customize output for multiple fields at once:
+
+    json.extract! user, :id, :name, :email, schema: {id: {type: :string}, email: {type: :email, pattern: /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/}}
+
+### Nested objects
+
+When you have nested objects in jbuilder template, you have to pass it to `schema: {object: <nested_object>}` when the block starts:
+
+    json.extract! article
+    json.author schema: {object: article.user, object_title: "Author", object_description: "Authors are users who write articles"} do
+      json.extract! article.user
+    end
+
+This will help JbuilderSchema to process those fields right.
+
+### Collections
+
+If an object or an array of objects is generated in template, either in root or in some field through Jbuilder partials, JSON-Schema `$ref` is generated pointing to object with the same name as partial. By default those schemas should appear in `"#/components/schemas/"`.
+
+For example, if we have:
+
+    json.user do
+      json.partial! 'api/v1/users/user', user: user
+    end
+
+    json.articles do
+      json.array! user.articles, partial: "api/v1/articles/article", as: :article
+    end
+
+The result would be:
+
+    user:
+      type: object
+      $ref: #/components/schemas/user
+    articles:
+      type: array
+      items:
+        $ref: #/components/schemas/article
+    
+The path to component schemas can be configured with `components_path` variable, which defaults to `components/schemas`. See *[Configuration](#configuration)* for more info.
+
+### Titles & Descriptions
+
+Custom titles and descriptions for objects can be specified when calling `jbuilder-schema` helper (see *[Usage](#usage)*), for fields and nested objects within `schema` attributes (see *[Customization](#simple)* and *[Nested objects](#nested-objects)*). If not set, they will be searched in locale files.
+
+Titles and descriptions for the models are supposed to be found in locale files under `<underscored_plural_model_name>.<title_name>` and `<underscored_plural_model_name>.<description_name>`, for example:
+
+    en:
+      articles:
+        title: Article
+        description: The main object on the blog
+
+Descriptions for the fields are supposed to be found in locale files under `<underscored_plural_model_name>.fields.<field_name>.<description_name>`, for example:
+
+    en:
+      articles:
+        fields:
+          title:
+            description: The title of an article
+
+`<title_name>` and `<description_name>` can be configured (see *[Configuration](#configuration)*), it defaults to `title` and `description`.
+
+### Configuration
+
+You can configure some variables that JbuilderSchema uses (for example, in `config/initializers/jbuilder_schema.rb`):
+
+    JbuilderSchema.configure do |config|
+        config.components_path = "components/schemas"   # could be "definitions/schemas"
+        config.title_name = "title"                     # could be "label"
+        config.description_name = "description"         # could be "heading"
+    end
+
+### RSwag
+
+It's super easy to use JbuilderSchema with RSwag: just add `jbuilder_schema` helper in `swagger_helper.rb` like this:
+
+    RSpec.configure do |config|
+      extend JbuilderSchema
+
+      ...
+
+      config.swagger_docs = {
+
+        ...
+      
+        components: {
+          schemas: {
+            article: jbuilder_schema('api/v1/articles/_article',
+                                     format: :yaml,
+                                     model: Article,
+                                     title: 'Article',
+                                     description: 'Article in the blog',
+                                     locals: {
+                                       article: FactoryBot.build(:article, id: 1),
+                                       current_user: FactoryBot.build(:user, admin: true)
+                                     })
+          }
+        }
+
+        ...
+
+      }
+
+      ...
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/bullet-train-co/jbuilder-schema.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Open-source development sponsored by:
+
+<a href="https://www.clickfunnels.com"><img src="https://images.clickfunnel.com/uploads/digital_asset/file/176632/clickfunnels-dark-logo.svg" width="575" /></a>

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "standard/rake"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+  t.warning = false
+end
+
+task default: %i[test standard]

data/lib/jbuilder/jbuilder.rb

@@ -0,0 +1,23 @@
+# 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

data/lib/jbuilder/schema/builder.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "jbuilder/schema/resolver"
+require "jbuilder/schema/renderer"
+
+module JbuilderSchema
+  # Class that builds schema object from path
+  class Builder
+    attr_reader :path, :template, :model, :locals, :format, :paths
+
+    def initialize(path, **options)
+      @path = path
+      # TODO: Need this for `required`, make it simpler:
+      @model = options[:model]
+      @locals = options[:locals] || {}
+      @format = options[:format]
+      @paths = options[:paths] || ["app/views"]
+      @template = _render_template(**options)
+    end
+
+    def schema!
+      return {} unless template
+
+      case format
+      when :yaml
+        _yaml_schema
+      when :json
+        _json_schema
+      else
+        _schema
+      end
+    end
+
+    private
+
+    def _schema
+      template.schema!
+    end
+
+    def _stringified_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
+
+    def _yaml_schema
+      YAML.dump(_stringified_schema).html_safe
+    end
+
+    def _json_schema
+      JSON.dump(_stringified_schema).html_safe
+    end
+
+    def _find_template
+      prefix, controller, action, partial = _resolve_path
+      found = nil
+      paths.each do |path|
+        found = Resolver.new("#{path}/#{prefix}").find_all(action, controller, partial)
+        break if found
+      end
+      found
+    end
+
+    def _resolve_path
+      action = path.split("/").last
+      controller = path.split("/")[-2]
+      prefix = path.delete_suffix("/#{controller}/#{action}")
+      partial = action[0] == "_"
+
+      action.delete_prefix!("_") if action[0] == "_"
+
+      [prefix, controller, action, partial]
+    end
+
+    def _render_template(**options)
+      Renderer.new(**options).render(_find_template)
+    end
+  end
+end

data/lib/jbuilder/schema/configuration.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Configuration
+module JbuilderSchema
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def reset
+      @configuration = Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+
+  # Configuration class with defaults
+  class Configuration
+    attr_accessor :components_path, :title_name, :description_name
+
+    def initialize
+      @components_path = "components/schemas"
+      @title_name = "title"
+      @description_name = "description"
+    end
+  end
+end

data/lib/jbuilder/schema/renderer.rb

@@ -0,0 +1,57 @@
+# 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
+  end
+end

data/lib/jbuilder/schema/resolver.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "jbuilder/schema/template"
+
+module JbuilderSchema
+  # Resolver finds and returns Jbuilder template.
+  # It basically inherits from ActionView::FileSystemResolver as it does all the job for us.
+  # We're just building our own template in the end of the search.
+  class Resolver < ::ActionView::FileSystemResolver
+    attr_reader :template
+
+    def find_all(name, prefix = nil, partial = false)
+      _find_all(name, prefix, partial)
+    end
+
+    private
+
+    def _find_all(name, prefix, partial)
+      path = ActionView::TemplatePath.build(name, prefix, partial)
+      templates_from_path(path).first
+    end
+
+    def templates_from_path(path)
+      return [] if path.name.include?(".")
+
+      # Instead of checking for every possible path, as our other globs would
+      # do, scan the directory for files with the right prefix.
+      paths = template_glob("#{escape_entry(path.to_s)}*")
+
+      paths.map do |p|
+        _source(p)
+      end
+    end
+
+    def _source(template)
+      source_for_template(template)
+    end
+  end
+end

data/lib/jbuilder/schema/template.rb

@@ -0,0 +1,360 @@
+# frozen_string_literal: true
+
+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 Template < ::JbuilderTemplate
+    attr_reader :attributes, :type, :models, :titles, :descriptions
+
+    def initialize(*args, **options)
+      @type = :object
+      @inline_array = false
+      @collection = false
+
+      @models = [options.delete(:model)]
+      @titles = [options.delete(:title)]
+      @descriptions = [options.delete(:description)]
+
+      super(nil, *args)
+
+      @ignore_nil = false
+    end
+
+    def schema!
+      {type: type}.merge(type == :object ? _object(**attributes.merge) : attributes)
+    end
+
+    def set!(key, value = BLANK, *args, **schema_options, &block)
+      result = if block
+        if !_blank?(value)
+          # OBJECTS ARRAY:
+          # json.comments @article.comments { |comment| ... }
+          # { "comments": [ { ... }, { ... } ] }
+          _scope { array! value, &block }
+        else
+          # BLOCK:
+          # 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
+          end
+          r
+        end
+      elsif args.empty?
+        if ::Jbuilder === value
+          # ATTRIBUTE1:
+          # json.age 32
+          # json.person another_jbuilder
+          # { "age": 32, "person": { ...  }
+          _schema(key, _format_keys(value.attributes!), **schema_options)
+        elsif _is_collection_array?(value)
+          # ATTRIBUTE2:
+          _scope { array! value }
+        # json.articles @articles
+        else
+          # json.age 32
+          # { "age": 32 }
+          _schema(key, _format_keys(value), **schema_options)
+        end
+      elsif _is_collection?(value)
+        # COLLECTION:
+        # json.comments @article.comments, :content, :created_at
+        # { "comments": [ { "content": "hello", "created_at": "..." }, { "content": "world", "created_at": "..." } ] }
+        @inline_array = true
+        @collection = true
+
+        _scope { array! value, *args }
+      elsif schema_options.key?(:object)
+        # 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 }
+      end
+
+      result = _set_description key, result if models.any?
+      _set_value key, result
+    end
+
+    def extract!(object, *attributes, **schema_options)
+      schema_options = schema_options[:schema] if schema_options.key?(:schema)
+
+      if ::Hash === object
+        _extract_hash_values(object, attributes, **schema_options)
+      else
+        _extract_method_values(object, attributes, **schema_options)
+      end
+    end
+
+    def array!(collection = [], *args, &block)
+      args, schema_options = _args_and_schema_options(*args)
+      options = args.first
+
+      if args.one? && _partial_options?(options)
+        @collection = true
+        _set_ref(options[:partial].split("/").last)
+      else
+        array = _make_array(collection, *args, **schema_options, &block)
+
+        if @inline_array
+          @attributes = {}
+          _set_value(:type, :array)
+          _set_value(:items, array)
+        elsif _is_collection_array?(array)
+          @attributes = {}
+          @inline_array = true
+          @collection = true
+          array! array, *array.first&.attribute_names(&:to_sym)
+        else
+          @type = :array
+          @attributes = {}
+          _set_value(:items, array)
+        end
+      end
+    end
+
+    def partial!(*args)
+      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)
+        _set_ref(args.first[:partial].split("/").last)
+      else
+        @collection = true if args[1].key?(:collection)
+        _set_ref(args.first&.split("/")&.last)
+      end
+    end
+
+    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)
+        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?
+          a[key] = result
+        end
+      end
+      @attributes = _merge_values(@attributes, hash_or_array)
+    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
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      super
+    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}")
+      {
+        type: :object,
+        title: title,
+        description: description,
+        required: _required!(**attrs),
+        properties: attrs
+      }
+    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}")
+        value = {description: description}.merge! value
+      end
+      value
+    end
+
+    def _set_ref(component)
+      if @inline_array
+        if @collection
+          _set_value(:type, :array)
+          _set_value(:items, {:$ref => _component_path(component)})
+        else
+          _set_value(:type, :object)
+          _set_value(:$ref, _component_path(component))
+        end
+      else
+        @type = :array
+        _set_value(:items, {:$ref => _component_path(component)})
+      end
+    end
+
+    def _component_path(component)
+      "#/#{JbuilderSchema.configuration.components_path}/#{component}"
+    end
+
+    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
+
+    def _guess_type(value)
+      type = value.class.name&.downcase&.to_sym
+
+      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)}
+      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
+      end
+
+      hash
+    end
+
+    def _type(type)
+      case type
+      when :time, :date, :datetime, :"activesupport::timewithzone", nil, :text, :nilclass, :"actiontext::richtext"
+        :string
+      when :float, :bigdecimal
+        :number
+      when :trueclass, :falseclass
+        :boolean
+      else
+        type
+      end
+    end
+
+    def _set_enum(key)
+      enums = models.last&.defined_enums[key].keys
+      {enum: enums}
+    end
+
+    def _make_array(collection, *args, **schema_options, &block)
+      if collection.nil?
+        []
+      elsif block
+        _map_collection(collection, &block)
+      elsif args.any?
+        _map_collection(collection) { |element| extract! element, *args, **schema_options }
+      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]
+    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
+    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)
+      attributes.each do |key|
+        result = _schema(key, _format_keys(object.fetch(key)), **schema_options[key] || {})
+        result = _set_description(key, result) if models.any?
+        _set_value key, result
+      end
+    end
+
+    def _extract_method_values(object, attributes, **schema_options)
+      attributes.each do |key|
+        result = _schema(key, _format_keys(object.public_send(key)), **schema_options[key] || {})
+        result = _set_description(key, result) if models.any?
+        _set_value key, result
+      end
+    end
+
+    def _map_collection(collection)
+      super.first
+    end
+
+    def _merge_block(key)
+      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)
+    end
+  end
+end
+
+class Jbuilder
+  # Monkey-patch for Jbuilder::KeyFormatter to ignore schema keys
+  class KeyFormatter
+    alias_method :original_format, :format
+
+    def format(key)
+      return key if %i[type items properties].include?(key)
+
+      original_format(key)
+    end
+  end
+end

data/lib/jbuilder/schema/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module JbuilderSchema
+  VERSION = "1.0.0"
+end

data/lib/jbuilder/schema.rb

@@ -0,0 +1,12 @@
+# 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!
+  end
+end

data/sig/jbuilder/schema.rbs

@@ -0,0 +1,4 @@
+module JbuilderSchema
+  VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: jbuilder-schema
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yuri Sidorov
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-10-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jbuilder
+  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: 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
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+description: Generate JSON Schema from Jbuilder files
+email:
+- hey@yurisidorov.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- Gemfile
+- Gemfile.lock
+- 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/newstler/jbuilder-schema
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/newstler/jbuilder-schema
+  source_code_uri: https://github.com/newstler/jbuilder-schema
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Generate JSON Schema from Jbuilder files
+test_files: []