rbs_json_schema 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c42556d48a48168a502401070844f1d77e797044fce25023d5afbed1129e46f5
+  data.tar.gz: 4cf37da298eb6c81ce8868b7bc1733d27e66c2de394d08e05d66cdb0e4c32072
+SHA512:
+  metadata.gz: '0871e0d1ef8128f33e2493981b97c1d244d26f8d8b08f649cc0bbdd61a4775b44f40449acfb68c3025fb93ea1dbfede0ef73f1ff88177522adaa761529a460b9'
+  data.tar.gz: 8ff79062b035258cd8c33a4570fbd711a220a9b85ffcac19d5183cb2e844ca3744d3157db29893fb2141036320d335f3f637b5928f7901aaef975587b4baa4d8

data/.github/workflows/test.yml

@@ -0,0 +1,33 @@
+name: Test
+
+on:
+  push:
+    branches:
+      - main
+  pull_request: {}
+
+jobs:
+  test:
+    runs-on: "ubuntu-latest"
+    strategy:
+      matrix:
+        container_tag:
+        - master-nightly-focal
+        - 3.0-focal
+        - 2.7-bionic
+        job:
+        - test
+    container:
+      image: rubylang/ruby:${{ matrix.container_tag }}
+    steps:
+    - uses: actions/checkout@v2
+    - name: Update rubygems & bundler
+      run: |
+        ruby -v
+        gem update --system
+    - name: bin/setup
+      run: |
+        bin/setup
+    - name: Run test
+      run: |
+        bundle exec rake ${{ matrix.job }}

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.ruby-version

@@ -0,0 +1 @@
+3.0.2

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.5
+before_install: gem install bundler -v 2.1.4

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# CHANGELOG
+
+## master
+
+* Initial release

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in rbs_json_schema.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "minitest", "~> 5.0"
+gem "steep"

data/Gemfile.lock

@@ -0,0 +1,62 @@
+PATH
+  remote: .
+  specs:
+    rbs_json_schema (0.1.0)
+      activesupport (>= 5.0.0)
+      rbs (>= 1.5.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (6.1.4.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    ast (2.4.2)
+    concurrent-ruby (1.1.9)
+    ffi (1.15.3)
+    i18n (1.8.10)
+      concurrent-ruby (~> 1.0)
+    language_server-protocol (3.16.0.3)
+    listen (3.7.0)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    minitest (5.14.4)
+    parallel (1.20.1)
+    parser (3.0.2.0)
+      ast (~> 2.4.1)
+    rainbow (3.0.0)
+    rake (12.3.3)
+    rb-fsevent (0.11.0)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
+    rbs (1.5.1)
+    steep (0.46.0)
+      activesupport (>= 5.1)
+      language_server-protocol (>= 3.15, < 4.0)
+      listen (~> 3.0)
+      parallel (>= 1.0.0)
+      parser (>= 3.0)
+      rainbow (>= 2.2.2, < 4.0)
+      rbs (>= 1.2.0)
+      terminal-table (>= 2, < 4)
+    terminal-table (3.0.1)
+      unicode-display_width (>= 1.1.1, < 3)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.0.0)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  minitest (~> 5.0)
+  rake (~> 12.0)
+  rbs_json_schema!
+  steep
+
+BUNDLED WITH
+   2.2.22

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Soutaro Matsumoto
+
+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/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Soutaro Matsumoto
+
+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,47 @@
+# rbs_json_schema
+
+rbs_json_schema is a RBS type definition generator from JSON Schema.
+It loads JSON files and writes RBS type definitioins.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rbs_json_schema'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rbs_json_schema
+
+## Usage
+
+Execute `rbs_json_schema` command with JSON schema files.
+
+```
+$ bundle exec rbs_json_schema schemas/address.json
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Acknowledgement
+
+This software is based on the work of Sushanth Sathesh Rao ([@raosush](https://github.com/raosush)) with the support from Google Summer of Code 2021.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/rbs_json_schema.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/Steepfile

@@ -0,0 +1,19 @@
+D = Steep::Diagnostic
+
+target :lib do
+  signature "sig"
+  check "lib"
+
+  library "rbs", "json", "uri", "pathname", "strscan", "tsort", "optparse", "logger", "monitor", "rubygems", "net-http"
+
+  configure_code_diagnostics do |hash|
+    hash[D::Ruby::MethodDefinitionMissing] = :hint
+  end
+end
+
+target :test do
+  signature "sig"
+  check "test"
+
+  library "rbs", "json", "uri", "pathname", "strscan", "tsort", "optparse", "logger", "monitor", "rubygems", "tmpdir"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rbs_json_schema"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/rbs_json_schema

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.join(__dir__, "../lib")
+require "rbs_json_schema"
+require "rbs_json_schema/cli"
+
+RBSJsonSchema::CLI.new(stdout: STDOUT, stderr: STDERR).run(ARGV)

data/lib/rbs_json_schema/cli.rb

@@ -0,0 +1,57 @@
+require "optparse"
+
+module RBSJsonSchema
+  class CLI
+    attr_reader :stdout
+    attr_reader :stderr
+
+    def initialize(stdout:, stderr:)
+      @stdout = stdout
+      @stderr = stderr
+      @options = {}
+    end
+
+    def run(args)
+      OptionParser.new do |opts|
+        opts.banner = <<~USAGE
+        Usage: rbs_json_schema [options...] [path...]
+
+        Generates RBS files from JSON Schema.
+
+        Options:
+        USAGE
+
+        opts.on("--[no-]stringify-keys", "Generate record types with string keys") do |bool|
+          @options[:stringify_keys] = bool
+        end
+
+        opts.on("-o OUTPUT", "Output the generated RBS to a specific location") do |location|
+          @options[:output] = location
+        end
+      end.parse!(args)
+
+      generator = Generator.new(stringify_keys: @options[:stringify_keys], output: @options[:output], stdout: stdout, stderr: stderr)
+      args.each do |path|
+        path =
+          begin
+            Pathname(path).realpath
+          rescue Errno::ENOENT => _
+            raise ValidationError.new(message: "#{path}: No such file or directory found!")
+          end
+
+        case
+        when path.file?
+          generator.generate(URI.parse("file://#{path}"))
+        when path.directory?
+          Dir["#{path}/*.{json}"].sort.each do |file|
+            file = Pathname(file).realpath
+            generator.generate(URI.parse("file://#{file}"))
+          end
+        else
+          raise ValidationError.new(message: "#{path}: No such file or directory found!")
+        end
+      end
+      generator.write_output
+    end
+  end
+end

data/lib/rbs_json_schema/generator.rb

@@ -0,0 +1,308 @@
+module RBSJsonSchema
+  class Generator
+    attr_reader :stringify_keys
+    attr_reader :output
+    attr_reader :stdout
+    attr_reader :stderr
+    attr_reader :path_decls
+    attr_reader :generated_schemas
+
+    Alias = RBS::AST::Declarations::Alias
+
+    def initialize(stringify_keys:, output:, stdout:, stderr:)
+      @stringify_keys = stringify_keys ? true : false
+      @output = output
+      @stdout = stdout
+      @stderr = stderr
+      @path_decls = {}
+      @generated_schemas = {}
+    end
+
+    # IMPORTANT: Function invoked to generate RBS from JSON schema
+    # Generates RBS from JSON schema after validating options & writes to file/STDOUT
+    def generate(uri)
+      # Validate options received from CLI
+      validate_options()
+
+      @path_decls[uri.path] ||= RBS::AST::Declarations::Module.new(
+        name: generate_type_name_for_uri(uri, module_name: true),
+        type_params: RBS::AST::Declarations::ModuleTypeParams.empty,
+        members: [],
+        self_types: [],
+        annotations: [],
+        location: nil,
+        comment: nil
+      )
+      generate_rbs(uri, read_from_uri(uri))
+    end
+
+    # IMPORTANT: Function used to generate AST alias declarations from a URI & a schema document
+    def generate_rbs(uri, document)
+      # If schema is already generated for a URI, do not re-generate declarations/types
+      if fragment = uri.fragment
+        # return if fragment.empty? # If fragment is empty, implies top level schema which is always generated since it is the starting point of the algorithm
+
+        if @generated_schemas.dig(uri.path, fragment.empty? ? "#" : fragment) # Check if types have been generated for a particular path & fragment
+          return
+        end
+      else
+        if @generated_schemas.dig(uri.path, "#") # Check if types have been generated for a particular path
+          return
+        end
+      end
+
+      unless document.is_a?(Hash)
+        raise ValidationError.new(message: "Invalid JSON Schema: #{document}")
+      end
+
+      @generated_schemas[uri.path] ||= {}
+      if fragment = uri.fragment
+        @generated_schemas[uri.path][fragment.empty? ? "#" : fragment] = true
+      else
+        @generated_schemas[uri.path]["#"] = true
+      end
+      # Parse & generate declarations from remaining schema content
+      decl = Alias.new(
+        name: generate_type_name_for_uri(uri), # Normal type name with no prefix
+        type: translate_type(uri, document), # Obtain type of alias by parsing the schema document
+        annotations: [],
+        location: nil,
+        comment: nil
+      )
+      # Append the declaration if & only if the declaration has a valid RBS::Type assigned
+      if @path_decls[uri.path]
+        @path_decls[uri.path].members << decl if !decl.type.nil?
+      else
+        @path_decls[uri.path] = RBS::AST::Declarations::Module.new(
+          name: generate_type_name_for_uri(uri, module_name: true),
+          type_params: RBS::AST::Declarations::ModuleTypeParams.empty,
+          members: [],
+          self_types: [],
+          annotations: [],
+          location: nil,
+          comment: nil
+        )
+        @path_decls[uri.path].members << decl if !decl.type.nil?
+      end
+    end
+
+    def literal_type(literal)
+      # Assign literal type
+      case literal
+      when String, Integer, TrueClass, FalseClass
+        RBS::Types::Literal.new(literal: literal, location: nil)
+      when nil
+        RBS::Types::Bases::Nil.new(location: nil)
+      else
+        raise ValidationError.new(message: "Unresolved literal found: #{literal}")
+      end
+    end
+
+    def untyped_type
+      RBS::Types::Bases::Any.new(location: nil)
+    end
+
+    # Parse JSON schema & return the `RBS::Types` to be assigned
+    def translate_type(uri, schema)
+      case
+      when values = schema["enum"]
+        unless values.is_a?(Array)
+          raise ValidationError.new(message: "Invalid JSON Schema: enum: #{values}")
+        end
+
+        types = values.map { |literal| literal_type(literal) }
+        RBS::Types::Union.new(types: types, location: nil)
+      when const = schema["const"]
+        literal_type(const)
+      when schema["type"] == "array" || schema.key?("items")
+        case
+        when schema["items"].is_a?(Array)
+          # tuple
+          types = schema["items"].map { |definition| translate_type(uri, definition) }
+          RBS::Types::Tuple.new(types: types, location: nil)
+        when schema["items"].is_a?(Hash)
+          # array
+          elem_type = translate_type(uri, schema["items"])
+          RBS::BuiltinNames::Array.instance_type(elem_type)
+        else
+          RBS::BuiltinNames::Array.instance_type(untyped_type)
+        end
+      when schema["type"] == "object" || schema.key?("properties") || schema.key?("additionalProperties")
+        case
+        when properties = schema["properties"]
+          # @type var properties: json_schema
+          fields = properties.each.with_object({}) do |pair, hash|
+            # @type var hash: Hash[Symbol, RBS::Types::t]
+            key, value = pair
+
+            hash[key.to_sym] = translate_type(uri, value)
+          end
+
+          RBS::Types::Record.new(fields: fields, location: nil)
+        when prop = schema["additionalProperties"]
+          RBS::BuiltinNames::Hash.instance_type(
+            RBS::BuiltinNames::String.instance_type,
+            translate_type(uri, prop)
+          )
+        else
+          RBS::BuiltinNames::Hash.instance_type(
+            RBS::BuiltinNames::String.instance_type,
+            untyped_type
+          )
+        end
+      when one_of = schema["oneOf"]
+        RBS::Types::Union.new(
+          types: one_of.map { |defn| translate_type(uri, defn) },
+          location: nil
+        )
+      when all_of = schema["allOf"]
+        RBS::Types::Intersection.new(
+          types: all_of.map { |defn| translate_type(uri, defn) },
+          location: nil
+        )
+      when ty = schema["type"]
+        case ty
+        when "integer"
+          RBS::BuiltinNames::Integer.instance_type
+        when "number"
+          RBS::BuiltinNames::Numeric.instance_type
+        when "string"
+          RBS::BuiltinNames::String.instance_type
+        when "boolean"
+          RBS::Types::Bases::Bool.new(location: nil)
+        when "null"
+          RBS::Types::Bases::Nil.new(location: nil)
+        else
+          raise ValidationError.new(message: "Invalid JSON Schema: type: #{ty}")
+        end
+      when ref = schema["$ref"]
+        ref_uri =
+          begin
+            # Parse URI of `$ref`
+            URI.parse(schema["$ref"])
+          rescue URI::InvalidURIError => _
+            raise ValidationError.new(message: "Invalid URI encountered in: $ref = #{ref}")
+          end
+
+        resolved_uri = resolve_uri(uri, ref_uri) # Resolve `$ref` URI with respect to current URI
+        # Generate AST::Declarations::Alias
+        generate_rbs(resolved_uri, read_from_uri(resolved_uri))
+
+        # Assign alias type with appropriate namespace
+        RBS::Types::Alias.new(
+          name: generate_type_name_for_uri(resolved_uri, namespace: resolved_uri.path != uri.path),
+          location: nil
+        )
+      else
+        raise ValidationError.new(message: "Invalid JSON Schema: #{schema.keys.join(", ")}")
+      end
+    end
+
+    # Read contents from a URI
+    def read_from_uri(uri)
+      schema_source =
+        case uri.scheme
+        when "file", nil
+          File.read(uri.path)
+        when "http", "https"
+          Net::HTTP.get(uri)
+        else
+          raise ValidationError.new(message: "Could not read content from URI: #{uri}")
+        end
+
+      schema = JSON.parse(schema_source)
+
+      if (fragment = uri.fragment) && !fragment.empty?
+        case
+        when fragment.start_with?("/")
+          path = fragment.split("/")
+          path.shift()
+
+          schema.dig(*path) or
+            raise ValidationError.new(message: "JSON pointer doesn't point a schema: #{uri.fragment}")
+        else
+          raise ValidationError.new(message: "JSON pointer is expected: #{uri.fragment}")
+        end
+      else
+        schema
+      end
+    end
+
+    # Write output using `RBS::Writer` to a particular `IO`
+    def write_output
+      # If an output directory is given, open a file & write to it
+      if output = self.output
+        @path_decls.each do |path, decls|
+          name = decls.name.name.to_s.underscore
+          file_path = File.join(output, "#{name}.rbs")
+          File.open(file_path, 'w') do |io|
+            stdout.puts "Writing output to file: #{file_path}"
+            RBS::Writer.new(out: io).write([decls])
+          end
+        end
+      # If no output directory is given write to STDOUT
+      else
+        RBS::Writer.new(out: stdout).write(@path_decls.values)
+      end
+    end
+
+    # Utility function to assign type name from URI
+    private def generate_type_name_for_uri(uri, module_name: false, namespace: false)
+      dup_uri = uri.dup # Duplicate URI object for processing
+      path = dup_uri.path.split("/").last or raise # Extract path
+      path.gsub!(/(.json$)?/, '') # Remove JSON file extension if found
+      prefix = path.camelize # prefix is used to write module name, hence converted to camel case
+
+      # Return module_name
+      if module_name
+        return RBS::TypeName.new(
+          name: prefix.to_sym,
+          namespace: RBS::Namespace.empty
+        )
+      end
+
+      name = :t
+
+      if fragment = dup_uri.fragment
+        unless fragment.empty?
+          fragment[0] = "" if fragment.start_with?("/") # Remove initial slash if present in fragment
+          name = fragment.downcase.tr("/", "_")
+        end
+      end
+
+      # Return type name for type alias
+      RBS::TypeName.new(
+        name: name.to_sym,
+        namespace: namespace ? RBS::Namespace.new(path: [prefix.to_sym], absolute: false) : RBS::Namespace.empty
+      )
+    end
+
+    # Returns type name with prefixes & appropriate namespace
+    private def type_name(name, absolute: nil)
+      RBS::TypeName.new(
+        name: name.to_sym,
+        namespace: absolute ? RBS::Namespace.root : RBS::Namespace.empty
+      )
+    end
+
+    # Utility function to resolve two URIs
+    private def resolve_uri(uri, ref_uri)
+      begin
+        # Attempt to merge the two URIs
+        uri + ref_uri
+      rescue URI::BadURIError, ArgumentError => _
+        # Raise error in case of invalid URI
+        raise ValidationError.new(message: "Could not resolve URI: #{uri} + #{ref_uri}")
+      end
+    end
+
+    # Validate options given to the CLI
+    private def validate_options
+      if output = self.output
+        path = Pathname(output)
+        # Check if a valid directory exists?
+        raise ValidationError.new(message: "#{output}: Directory not found!") if !path.directory?
+      end
+    end
+  end
+end

data/lib/rbs_json_schema/validation_error.rb

@@ -0,0 +1,11 @@
+module RBSJsonSchema
+  class ValidationError < StandardError
+    attr_reader :message
+
+    def initialize(message:)
+      @message = message
+
+      super message
+    end
+  end
+end

data/lib/rbs_json_schema/version.rb

@@ -0,0 +1,3 @@
+module RBSJsonSchema
+  VERSION = "0.1.0"
+end

data/lib/rbs_json_schema.rb

@@ -0,0 +1,13 @@
+require "uri"
+require "json"
+require "rbs"
+require "active_support/core_ext/string/inflections"
+
+require "rbs_json_schema/version"
+require "rbs_json_schema/generator"
+require "rbs_json_schema/validation_error"
+
+module RBSJsonSchema
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/rbs_json_schema.gemspec

@@ -0,0 +1,30 @@
+require_relative 'lib/rbs_json_schema/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rbs_json_schema"
+  spec.version       = RBSJsonSchema::VERSION
+  spec.authors       = ["Soutaro Matsumoto"]
+  spec.email         = ["matsumoto@soutaro.com"]
+
+  spec.summary       = %q{Generate RBS type definitions from JSON Schema}
+  spec.description   = %q{Generate RBS type definitions from JSON Schema}
+  spec.homepage      = "https://github.com/ruby/rbs_json_schema"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/ruby/rbs_json_schema"
+  spec.metadata["changelog_uri"] = "https://github.com/soutaro/rbs_json_schema/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "rbs", ">=1.5.0"
+  spec.add_runtime_dependency "activesupport", ">=5.0.0"
+end

data/sig/_patches/activesupport.rbs

@@ -0,0 +1,5 @@
+class String
+  def underscore: () -> String
+
+  def camelize: () -> String
+end

data/sig/_patches/dir.rbs

@@ -0,0 +1,3 @@
+module Kernel
+  def __dir__: () -> String | ...
+end

data/sig/_patches/minitest.rbs

@@ -0,0 +1,9 @@
+module Minitest
+  class Test
+    def assert_equal: (untyped, untyped) -> void
+
+    def assert: (boolish) -> void
+
+    def assert_raises: (singleton(Exception)) { () -> void } -> Exception
+  end
+end

data/sig/_patches/uri.rbs

@@ -0,0 +1,8 @@
+module URI
+  class Generic
+    def fragment=: (String?) -> String?
+                 | ...
+
+    def +: (URI::Generic other) -> URI::Generic
+  end
+end

data/sig/_test/cli_test.rbs

@@ -0,0 +1,12 @@
+class CLITest < Minitest::Test
+  include RBSJsonSchema
+
+  RBS_PATH: Pathname
+  SCHEMA_PATH: Pathname
+
+  attr_reader stdout (): StringIO
+
+  attr_reader stderr (): StringIO
+
+  def with_cli: () { (RBSJsonSchema::CLI) -> void } -> void
+end

data/sig/_test/generator_test.rbs

@@ -0,0 +1,13 @@
+class GeneratorTest < Minitest::Test
+  include RBSJsonSchema
+
+  attr_reader output (): String
+
+  attr_reader stdout (): StringIO
+
+  attr_reader stderr (): StringIO
+
+  def in_tmpdir: () { (Pathname) -> void } -> void
+
+  def generator: () -> RBSJsonSchema::Generator
+end

data/sig/rbs_json_schema/cli.rbs

@@ -0,0 +1,21 @@
+module RBSJsonSchema
+  class CLI
+    interface _IO
+      def puts: (*untyped) -> void
+
+      def print: (*untyped) -> void
+
+      def flush: () -> void
+    end
+
+    attr_reader stdout: _IO
+
+    attr_reader stderr: _IO
+
+    @options: Hash[Symbol, untyped]
+
+    def initialize: (stdout: _IO, stderr: _IO) -> void
+
+    def run: (Array[String] args) -> void
+  end
+end

data/sig/rbs_json_schema/generator.rbs

@@ -0,0 +1,67 @@
+module RBSJsonSchema
+  class Generator
+    attr_reader options: Hash[Symbol, value]
+
+    Alias: singleton(RBS::AST::Declarations::Alias)
+
+    interface _IO
+      def puts: (*untyped) -> void
+
+      def print: (*untyped) -> void
+
+      def flush: () -> void
+    end
+
+    attr_reader stdout: _IO
+
+    attr_reader stderr: _IO
+
+    attr_reader name: String
+
+    attr_reader path_decls: Hash[String, RBS::AST::Declarations::Module]
+
+    attr_reader generated_schemas: Hash[String, Hash[String, bool]]
+
+    type value = String | bool
+
+    type json_schema = Hash[String, untyped]
+
+    attr_reader stringify_keys: bool
+    attr_reader output: String?
+
+    def initialize: (stringify_keys: boolish, output: String?, stdout: _IO, stderr: _IO) -> untyped
+
+    def generate: (URI::Generic uri) -> void
+
+    def generate_rbs: (URI::Generic uri, json_schema document) -> void
+
+    def translate_type: (URI::Generic uri, json_schema schema) -> RBS::Types::t
+
+    # Returns JSON Schema object from given URI.
+    #
+    # ```rb
+    # generator.read_from_uri(URI.parse("file://./foo.json"))
+    # generator.read_from_uri(URI.parse("http://localhost/schemas/foo#/$defs/bar"))
+    # ```
+    #
+    # Reading from URI with `file` schema and `http` schema is supported.
+    #
+    def read_from_uri: (URI::Generic uri) -> json_schema
+
+    def write_output: () -> void
+
+    private
+
+    def literal_type: (untyped) -> (RBS::Types::Literal | RBS::Types::Bases::Nil)
+
+    def untyped_type: () -> RBS::Types::Bases::Any
+
+    def generate_type_name_for_uri: (URI::Generic uri, ?module_name: boolish, ?namespace: boolish) -> RBS::TypeName
+
+    def type_name: (String name, ?absolute: boolish) -> RBS::TypeName
+
+    def resolve_uri: (URI::Generic uri, URI::Generic ref_uri) -> URI::Generic
+
+    def validate_options: () -> void
+  end
+end

data/sig/rbs_json_schema/validation_error.rbs

@@ -0,0 +1,7 @@
+module RBSJsonSchema
+  class ValidationError < StandardError
+    attr_reader message: String
+
+    def initialize: (message: String) -> void
+  end
+end

data/sig/rbs_json_schema/version.rbs

@@ -0,0 +1,3 @@
+module RBSJsonSchema
+  VERSION: String
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: rbs_json_schema
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Soutaro Matsumoto
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-08-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rbs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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 RBS type definitions from JSON Schema
+email:
+- matsumoto@soutaro.com
+executables:
+- rbs_json_schema
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/test.yml"
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- Steepfile
+- bin/console
+- bin/setup
+- exe/rbs_json_schema
+- lib/rbs_json_schema.rb
+- lib/rbs_json_schema/cli.rb
+- lib/rbs_json_schema/generator.rb
+- lib/rbs_json_schema/validation_error.rb
+- lib/rbs_json_schema/version.rb
+- rbs_json_schema.gemspec
+- sig/_patches/activesupport.rbs
+- sig/_patches/dir.rbs
+- sig/_patches/minitest.rbs
+- sig/_patches/uri.rbs
+- sig/_test/cli_test.rbs
+- sig/_test/generator_test.rbs
+- sig/rbs_json_schema/cli.rbs
+- sig/rbs_json_schema/generator.rbs
+- sig/rbs_json_schema/validation_error.rbs
+- sig/rbs_json_schema/version.rbs
+homepage: https://github.com/ruby/rbs_json_schema
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ruby/rbs_json_schema
+  source_code_uri: https://github.com/ruby/rbs_json_schema
+  changelog_uri: https://github.com/soutaro/rbs_json_schema/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: Generate RBS type definitions from JSON Schema
+test_files: []