types_from_serializers 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ab46cb83091bc01087646a3e9c1eee590d4148ea16f86fcca2c83ad91b24d2a5
+  data.tar.gz: 95e62afbb4b49ab897434fe33926322964439af03726c570bec6296eb4c51ca1
+SHA512:
+  metadata.gz: 8280b0616181a1b13b4192bc6cd9ceb6b43498d31bd83b871d3da0bba924c63b52d67598df83df8d8ccac535999f81a99e42b530cbc0ab6afeddbfa9366928e2
+  data.tar.gz: ee8d6f445603ef26932c631a2064f337186c6f27451771b2f31577df37c587f318b1abe22e9277e7db48f2d65d47ca7c62f1177a67cbc35df615e5277931bce1

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# 0.1.0 (2022-07-12)
+
+
+### Bug Fixes
+
+* handle non-ActiveRecord models and extract types from unions ([ea9b2a7](https://github.com/ElMassimo/types_from_serializers/commit/ea9b2a71cb85503ff691e5ef115ab73f89b005af))
+
+
+### Features
+
+* make the DSL is available without manually requiring ([04a4f3a](https://github.com/ElMassimo/types_from_serializers/commit/04a4f3ad3c96658639cbe75de07f19cc7f79f4c6))
+* support specifying base serializers and additional dirs to scan ([164cfe1](https://github.com/ElMassimo/types_from_serializers/commit/164cfe17bb0527c59cf95441381aef7bf797a568))
+
+
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2021 Máximo Mussini
+
+MIT License
+
+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,33 @@
+<h1 align="center">
+Types From Serializers
+<p align="center">
+<a href="https://travis-ci.org/ElMassimo/types_from_serializers"><img alt="Build Status" src="https://travis-ci.org/ElMassimo/types_from_serializers.svg"/></a>
+<a href="http://inch-ci.org/github/ElMassimo/types_from_serializers"><img alt="Inline docs" src="http://inch-ci.org/github/ElMassimo/types_from_serializers.svg"/></a>
+<a href="https://codeclimate.com/github/ElMassimo/types_from_serializers"><img alt="Maintainability" src="https://codeclimate.com/github/ElMassimo/types_from_serializers/badges/gpa.svg"/></a>
+<a href="https://codeclimate.com/github/ElMassimo/types_from_serializers"><img alt="Test Coverage" src="https://codeclimate.com/github/ElMassimo/types_from_serializers/badges/coverage.svg"/></a>
+<a href="https://rubygems.org/gems/types_from_serializers"><img alt="Gem Version" src="https://img.shields.io/gem/v/types_from_serializers.svg?colorB=e9573f"/></a>
+<a href="https://github.com/ElMassimo/types_from_serializers/blob/main/LICENSE.txt"><img alt="License" src="https://img.shields.io/badge/license-MIT-428F7E.svg"/></a>
+</p>
+</h1>
+
+[aliases]: https://vite-ruby.netlify.app/guide/development.html#import-aliases-%F0%9F%91%89
+[config options]: https://github.com/ElMassimo/types_from_serializers/blob/main/lib/types_from_serializers/generator.rb#L82-L85
+[readme]: https://github.com/ElMassimo/types_from_serializers
+
+For more information, check the main [README].
+
+### Installation 💿
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'types_from_serializers'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install types_from_serializers

data/lib/types_from_serializers/dsl.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+# Internal: A DSL to specify types for serializer attributes.
+module TypesFromSerializer
+  module DSL
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Override: Capture the name of the model related to the serializer.
+      #
+      # name - An alias for the internal object in the serializer.
+      # model - The name of an ActiveRecord model to infer types from the schema.
+      # types_from - The name of a TypeScript interface to infer types from.
+      def object_as(name, model: nil, types_from: nil)
+        # NOTE: Avoid taking memory for type information that won't be used.
+        if Rails.env.development?
+          model ||= name.is_a?(Symbol) ? name : try(:_serializer_model_name)
+          @_serializer_model_name = model || name
+          @_serializer_types_from = types_from if types_from
+        end
+
+        super(name)
+      end
+
+      # Public: Like `attributes`, but providing type information for each field.
+      def typed_attributes(attrs)
+        attributes(*attrs.keys)
+
+        # NOTE: Avoid taking memory for type information that won't be used.
+        if Rails.env.development?
+          _typed_attributes.update(attrs.map { |key, type|
+            [key.to_s, type.is_a?(Hash) ? type : {type: type}]
+          }.to_h)
+        end
+      end
+
+      # Public: Allows to specify the type for a serializer method that will
+      # be defined immediately after calling this method.
+      def type(type = :unknown, optional: false)
+        @_current_attribute_type = {type: type, optional: optional}
+      end
+
+      # Internal: Intercept a method definition, tying a type that was
+      # previously specified to the name of the attribute.
+      def method_added(name)
+        super(name)
+        if @_current_attribute_type
+          serializer_attributes name
+
+          # NOTE: Avoid taking memory for type information that won't be used.
+          if Rails.env.development?
+            _typed_attributes[name.to_s] = @_current_attribute_type
+          end
+
+          @_current_attribute_type = nil
+        end
+      end
+
+      # NOTE: Avoid taking memory for type information that won't be used.
+      if Rails.env.development?
+        # Internal: Contains type information for serializer attributes.
+        def _typed_attributes
+          unless defined?(@_typed_attributes)
+            @_typed_attributes = superclass.try(:_typed_attributes)&.dup || {}
+          end
+          @_typed_attributes
+        end
+
+        # Internal: The name of the model that will be serialized by this
+        # serializer, used to infer field types from the SQL columns.
+        def _serializer_model_name
+          unless defined?(@_serializer_model_name)
+            @_serializer_model_name = superclass.try(:_serializer_model_name)
+          end
+          @_serializer_model_name
+        end
+
+        # Internal: The TypeScript interface that will be used by default to
+        # infer the serializer field types when not explicitly provided.
+        def _serializer_types_from
+          unless defined?(@_serializer_types_from)
+            @_serializer_types_from = superclass.try(:_serializer_types_from)
+          end
+          @_serializer_types_from
+        end
+      end
+    end
+  end
+end

data/lib/types_from_serializers/generator.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "pathname"
+
+# Public: Automatically generates TypeScript interfaces for Ruby serializers.
+module TypesFromSerializers
+  # Internal: The configuration for TypeScript generation.
+  Config = Struct.new(
+    :base_serializers,
+    :serializers_dirs,
+    :output_dir,
+    :name_from_serializer,
+    :native_types,
+    :sql_to_typescript_type_mapping,
+    keyword_init: true,
+  )
+
+  # Internal: The type metadata for a serializer.
+  SerializerMetadata = Struct.new(
+    :attributes,
+    :associations,
+    :model_name,
+    :types_from,
+    keyword_init: true,
+  )
+
+  # Internal: The type metadata for a serializer field.
+  FieldMetadata = Struct.new(:name, :type, :optional, :many, keyword_init: true) do
+    def typescript_name
+      name.to_s.camelize(:lower)
+    end
+  end
+
+  # Internal: Extensions that simplify the implementation of the generator.
+  module SerializerRefinements
+    refine String do
+      # Internal: Converts a name such as :user to the User constant.
+      def to_model
+        classify.safe_constantize
+      end
+    end
+
+    refine Symbol do
+      def safe_constantize
+        to_s.classify.safe_constantize
+      end
+
+      delegate :to_model, to: :to_s
+    end
+    # rubocop:enable Rails/Delegate
+
+    refine Class do
+      # Internal: Name of the TypeScript interface.
+      def typescript_interface_name
+        TypesFromSerializers.config.name_from_serializer.call(name).tr_s(":", "")
+      end
+
+      # Internal: The base name of the TypeScript file to be written.
+      def typescript_interface_basename
+        TypesFromSerializers.config.name_from_serializer.call(name).gsub("::", "/")
+      end
+
+      # Internal: A first pass of gathering types for the serializer fields.
+      def typescript_metadata
+        SerializerMetadata.new(
+          model_name: _serializer_model_name,
+          types_from: _serializer_types_from,
+          attributes: _attributes.map { |key, options|
+            typed_attrs = _typed_attributes.fetch(key, {})
+            FieldMetadata.new(
+              **typed_attrs,
+              name: key,
+              optional: typed_attrs[:optional] || options.key?(:if),
+            )
+          },
+          associations: _associations.map { |key, options|
+            FieldMetadata.new(
+              name: options.fetch(:root, key),
+              type: options.fetch(:serializer),
+              optional: options.key?(:if),
+              many: options.fetch(:write_method) == :write_many,
+            )
+          },
+        )
+      end
+
+      # Internal: Infers field types by checking the SQL columns for the model
+      # serialized, or from a TypeScript interface if provided.
+      def typescript_infer_types(metadata)
+        model = metadata.model_name&.to_model
+        interface = metadata.types_from
+
+        metadata.attributes.reject(&:type).each do |meta|
+          if model&.respond_to?(:columns_hash) && (column = model.columns_hash[meta.name.to_s])
+            meta[:type] = TypesFromSerializers.config.sql_to_typescript_type_mapping[column.type]
+            meta[:optional] ||= column.null
+          elsif interface
+            meta[:type] = "#{interface}['#{meta.typescript_name}']"
+          end
+        end
+      end
+
+      def typescript_imports(metadata)
+        assoc_imports = metadata.associations.map { |meta|
+          [meta.type.typescript_interface_name, "~/types/serializers/#{meta.type.typescript_interface_basename}"]
+        }
+
+        attr_imports = metadata.attributes
+          .flat_map { |meta| extract_typescript_types(meta.type.to_s) }
+          .uniq
+          .reject { |type| typescript_native_type?(type) }
+          .map { |type|
+            [type, "~/types/#{type}"]
+          }
+
+        (assoc_imports + attr_imports).uniq.map { |interface, filename|
+          "import type #{interface} from '#{filename}'\n"
+        }.uniq
+      end
+
+      # Internal: Extracts any types inside generics or array types.
+      def extract_typescript_types(type)
+        type.split(/[<>\[\],\s|]+/)
+      end
+
+      # NOTE: Treat uppercase names as custom types.
+      # Lowercase names would be native types, such as :string and :boolean.
+      def typescript_native_type?(type)
+        type[0] == type[0].downcase || TypesFromSerializers.config.native_types.include?(type)
+      end
+
+      def typescript_fields(metadata)
+        (metadata.attributes + metadata.associations).map { |meta|
+          type = meta.type.is_a?(Class) ? meta.type.typescript_interface_name : meta.type || :unknown
+          type = meta.many ? "#{type}[]" : type
+          "  #{meta.typescript_name}#{"?" if meta.optional}: #{type}"
+        }
+      end
+    end
+  end
+
+  # Internal: Structure to keep track of changed files.
+  class Changes
+    def initialize(dirs)
+      @added = Set.new
+      @removed = Set.new
+      @modified = Set.new
+      track_changes(dirs)
+    end
+
+    def updated?
+      @modified.any? || @added.any? || @removed.any?
+    end
+
+    def any_removed?
+      @removed.any?
+    end
+
+    def modified_files
+      @modified
+    end
+
+    def only_modified?
+      @added.empty? && @removed.empty?
+    end
+
+    def clear
+      @added.clear
+      @removed.clear
+      @modified.clear
+    end
+
+  private
+
+    def track_changes(dirs)
+      Listen.to(*dirs, only: %r{.rb$}) do |modified, added, removed|
+        modified.each { |file| @modified.add(file) }
+        added.each { |file| @added.add(file) }
+        removed.each { |file| @removed.add(file) }
+      end.start
+    end
+  end
+
+  class << self
+    using SerializerRefinements
+
+    attr_reader :force_generation
+
+    # Public: Configuration of the code generator.
+    def config
+      (@config ||= default_config(root)).tap do |config|
+        yield(config) if block_given?
+      end
+    end
+
+    # Public: Generates code for all serializers in the app.
+    def generate(force: ENV["SERIALIZER_TYPES_FORCE"])
+      @force_generation = force
+      generate_index_file
+
+      loaded_serializers.each do |serializer|
+        generate_interface_for(serializer)
+      end
+    end
+
+    def generate_changed
+      if changes.updated?
+        config.output_dir.rmtree if changes.any_removed?
+        load_serializers(changes.modified_files)
+        generate
+        changes.clear
+      end
+    end
+
+    # Internal: Defines a TypeScript interface for the serializer.
+    def generate_interface_for(serializer)
+      metadata = serializer.typescript_metadata
+      filename = serializer.typescript_interface_basename
+
+      write_if_changed(filename: filename, cache_key: metadata.inspect) {
+        serializer.typescript_infer_types(metadata)
+        <<~TS
+          //
+          // DO NOT MODIFY: This file was automatically generated by TypesFromSerializers.
+          #{serializer.typescript_imports(metadata).join}
+          export default interface #{serializer.typescript_interface_name} {
+          #{serializer.typescript_fields(metadata).join("\n")}
+          }
+        TS
+      }
+    end
+
+    # Internal: Allows to import all serializer types from a single file.
+    def generate_index_file
+      write_if_changed(filename: "index", cache_key: all_serializer_files.join) {
+        load_serializers(all_serializer_files)
+        <<~TS
+          //
+          // DO NOT MODIFY: This file was automatically generated by TypesFromSerializers.
+          #{loaded_serializers.map { |s| "export type { default as #{s.typescript_interface_name} } from './#{s.typescript_interface_basename}'" }.join("\n")}
+        TS
+      }
+    end
+
+    # Internal: Checks if it should avoid generating an interface.
+    def skip_serializer?(name)
+      name.include?("BaseSerializer") || name.in?(config.base_serializers)
+    end
+
+    # Internal: Returns an object compatible with FileUpdateChecker.
+    def track_changes
+      changes
+    end
+
+  private
+
+    def root
+      defined?(Rails) ? Rails.root : Pathname.new(Dir.pwd)
+    end
+
+    def changes
+      @changes ||= Changes.new(config.serializers_dirs)
+    end
+
+    def all_serializer_files
+      config.serializers_dirs.flat_map { |dir| Dir["#{dir}/**/*.rb"] }
+    end
+
+    def load_serializers(files)
+      files.each { |file| require file }
+    end
+
+    def loaded_serializers
+      config.base_serializers.map(&:constantize)
+        .flat_map(&:descendants)
+        .uniq
+        .sort_by(&:name)
+        .reject { |s| skip_serializer?(s.name) }
+    rescue NameError
+      raise ArgumentError, "Please ensure all your serializers extend BaseSerializer, or configure `config.base_serializers`."
+    end
+
+    def default_config(root)
+      Config.new(
+        # The base serializers that all other serializers extend.
+        base_serializers: ["BaseSerializer"],
+
+        # The dirs where the serializer files are located.
+        serializers_dirs: [root.join("app/serializers").to_s],
+
+        # The dir where interface files are placed.
+        output_dir: root.join(defined?(ViteRuby) ? ViteRuby.config.source_code_dir : "app/frontend").join("types/serializers"),
+
+        # Remove the serializer suffix from the class name.
+        name_from_serializer: ->(name) { name.delete_suffix("Serializer") },
+
+        # Types that don't need to be imported in TypeScript.
+        native_types: [
+          "Array",
+          "Record",
+          "Date",
+        ].to_set,
+
+        # Maps SQL column types to TypeScript native and custom types.
+        sql_to_typescript_type_mapping: {
+          boolean: :boolean,
+          date: "string | Date",
+          datetime: "string | Date",
+          decimal: :number,
+          integer: :number,
+          string: :string,
+          text: :string,
+        }.tap do |types|
+          types.default = :unknown
+        end,
+      )
+    end
+
+    # Internal: Writes if the file does not exist or the cache key has changed.
+    # The cache strategy consists of a comment on the first line of the file.
+    #
+    # Yields to receive the rendered file content when it needs to.
+    def write_if_changed(filename:, cache_key:)
+      filename = config.output_dir.join("#{filename}.ts")
+      FileUtils.mkdir_p(filename.dirname)
+      cache_key_comment = "// TypesFromSerializers CacheKey #{Digest::MD5.hexdigest(cache_key)}\n"
+      File.open(filename, "a+") { |file|
+        if stale?(file, cache_key_comment)
+          file.truncate(0)
+          file.write(cache_key_comment)
+          file.write(yield)
+        end
+      }
+    end
+
+    # Internal: Returns true if the cache key has changed since the last codegen.
+    def stale?(file, cache_key_comment)
+      @force_generation || file.gets != cache_key_comment
+    end
+  end
+end

data/lib/types_from_serializers/railtie.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+class TypesFromSerializers::Railtie < Rails::Railtie
+  railtie_name :types_from_serializers
+
+  # Automatically generates code whenever a serializer is loaded.
+  if defined?(Rails.env) && Rails.env.development?
+    require_relative "generator"
+
+    initializer "types_from_serializers.reloader" do |app|
+      if Gem.loaded_specs["listen"]
+        require "listen"
+
+        app.config.after_initialize do
+          app.reloaders << TypesFromSerializers.track_changes
+        end
+
+        app.config.to_prepare do
+          TypesFromSerializers.generate_changed
+        end
+      else
+        app.config.to_prepare do
+          TypesFromSerializers.generate
+        end
+
+        Rails.logger.warn "Add 'listen' to your Gemfile to automatically generate code on serializer changes."
+      end
+    end
+  end
+
+  # Suitable when triggering code generation manually.
+  rake_tasks do |app|
+    namespace :types_from_serializers do
+      desc "Generates TypeScript interfaces for each serializer in the app."
+      task generate: :environment do
+        require_relative "generator"
+        serializers = TypesFromSerializers.generate(force: true)
+        puts "Generated TypeScript interfaces for #{serializers.size} serializers:"
+        puts serializers.map { |s| "\t#{s.name}" }.join("\n")
+      end
+    end
+  end
+end

data/lib/types_from_serializers/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module TypesFromSerializers
+  # Public: This library adheres to semantic versioning.
+  VERSION = "0.1.0"
+end

data/lib/types_from_serializers.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "types_from_serializers/version"
+require_relative "types_from_serializers/dsl"
+require_relative "types_from_serializers/railtie"

metadata

@@ -0,0 +1,228 @@
+--- !ruby/object:Gem::Specification
+name: types_from_serializers
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Máximo Mussini
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-07-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+- !ruby/object:Gem::Dependency
+  name: oj_serializers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13'
+- !ruby/object:Gem::Dependency
+  name: rspec-given
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: types_from_serializers helps you by automatically generating TypeScript
+  interfaces for your JSON serializers, allowing you typecheck your frontend code
+  to ship fast and with confidence.
+email:
+- maximomussini@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/types_from_serializers.rb
+- lib/types_from_serializers/dsl.rb
+- lib/types_from_serializers/generator.rb
+- lib/types_from_serializers/railtie.rb
+- lib/types_from_serializers/version.rb
+homepage: https://github.com/ElMassimo/types_from_serializers
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '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 TypeScript interfaces from your JSON serializers.
+test_files: []