feat: initial rbs support

Author: mattkhan

lib/anchor/json_schema/serializer.rb

@@ -21,6 +21,7 @@ def type_property(type)
         when Anchor::Types::Object, Anchor::Types::Object.singleton_class then serialize_object(type)
         when Anchor::Types::Enum.singleton_class then { enum: type.values.map(&:second) }
         when Anchor::Types::Unknown.singleton_class then {}
+        when Anchor::Types::Intersection then {}
         else raise RuntimeError
         end
       end

lib/anchor/resource.rb

@@ -79,7 +79,13 @@ def anchor_attributes_properties(included_fields:)
           enum = Anchor.config.infer_ar_enums && !method_defined && _model_class.try(:defined_enums).try(:[], model_method.to_s)
           column = !method_defined && _model_class.try(:columns_hash).try(:[], model_method.to_s)
 
-          if column
+          rbs_defined = defined?(::RBS) && ::RBS::VERSION.first == "3"
+
+          if resource_method_defined && rbs_defined
+            Anchor::Types::Inference::RBS.from(name.to_sym, resource_method)
+          elsif model_method_defined && rbs_defined
+            Anchor::Types::Inference::RBS.from(_model_class.name.to_sym, model_method.to_sym)
+          elsif column
             type = Anchor::Types::Inference::ActiveRecord::SQL.from(column)
 
             if enum
@@ -109,6 +115,12 @@ def anchor_attributes_properties(included_fields:)
             else
               type
             end
+          elsif rbs_defined
+            # TODO: Methods may not be defined on the class at generation time?
+            [
+              Anchor::Types::Inference::RBS.from(name.to_sym, resource_method),
+              Anchor::Types::Inference::RBS.from(_model_class.name.to_sym, model_method.to_sym),
+            ].find { |t| t != Anchor::Types::Unknown } || Anchor::Types::Unknown
           else
             Anchor::Types::Unknown
           end

lib/anchor/type_script/serializer.rb

@@ -11,6 +11,7 @@ def type_string(type, depth = 1)
         when Anchor::Types::Null.singleton_class then "null"
         when Anchor::Types::Record, Anchor::Types::Record.singleton_class then "Record<string, #{type_string(type.try(:value_type) || Anchor::Types::Unknown)}>"
         when Anchor::Types::Union then type.types.map { |type| type_string(type, depth) }.join(" | ")
+        when Anchor::Types::Intersection then type.types.map { |type| "(#{type_string(type, depth)})" }.join(" & ")
         when Anchor::Types::Maybe then Anchor.config.maybe_as_union ? type_string(Anchor::Types::Union.new([type.type, Anchor::Types::Null]), depth) : "Maybe<#{type_string(type.type, depth)}>"
         when Anchor::Types::Array then Anchor.config.array_bracket_notation ? "(#{type_string(type.type, depth)})[]" : "Array<#{type_string(type.type, depth)}>"
         when Anchor::Types::Literal then serialize_literal(type.value)

lib/anchor/types.rb

@@ -12,6 +12,7 @@ class Unknown; end
     Array = Struct.new(:type)
     Literal = Struct.new(:value)
     Union = Struct.new(:types)
+    Intersection = Struct.new(:types)
     Reference = Struct.new(:name) do
       def anchor_schema_name
         name

lib/anchor/types/inference/rbs.rb

@@ -0,0 +1,83 @@
+module Anchor::Types::Inference
+  module RBS
+    class << self
+      # @param class_name [Symbol] e.g. :Exhaustive
+      # @param method_name [Symbol] e.g. :model_overridden
+      def from(class_name, method_name)
+        @loader ||= ::RBS::EnvironmentLoader.new.tap do |l|
+          l.add(path: Rails.root.join("sig"))
+        end
+
+        @env ||= ::RBS::Environment.from_loader(@loader).resolve_type_names
+
+        # TODO: Do we need both the absolute and non-absolute namespaces?
+        klass = @env.class_decls.keys.find { |kl| [class_name.to_s, "::#{class_name}"].include?(kl.to_s) }
+        return Types::Unknown unless klass
+
+        @builder ||= ::RBS::DefinitionBuilder.new(env: @env)
+        instance = @builder.build_instance(klass)
+
+        instance_method = instance.methods[method_name]
+        return Types::Unknown unless instance_method
+
+        method_types = instance.methods[method_name].method_types
+        return Types::Unknown unless method_types.length == 1
+
+        return_type = method_types.first.type.return_type
+        from_rbs_type(return_type)
+      end
+
+      private
+
+      def from_rbs_type(type)
+        case type
+        when ::RBS::Types::ClassInstance then from_class_instance(type)
+        when ::RBS::Types::Literal then Types::Literal.new(type.literal)
+        when ::RBS::Types::Bases::Bool then Types::Boolean
+        when ::RBS::Types::Bases::Nil then Types::Null
+        when ::RBS::Types::Bases::Void then Types::Unknown
+        when ::RBS::Types::Bases::Any then Types::Unknown
+        when ::RBS::Types::Optional then Types::Maybe.new(from_rbs_type(type.type))
+        when ::RBS::Types::Record then from_record(type)
+        when ::RBS::Types::Union then from_union(type)
+        when ::RBS::Types::Intersection then from_intersection(type)
+        when ::RBS::Types::Tuple then Types::Unknown # TODO
+        else Types::Unknown
+        end
+      end
+
+      def from_record(type)
+        properties = type.fields.map do |name, type|
+          Types::Property.new(name, from_rbs_type(type))
+        end
+        optional_properties = type.optional_fields.map do |name, type|
+          Types::Property.new(name, from_rbs_type(type), true)
+        end
+        Types::Object.new(properties + optional_properties)
+      end
+
+      def from_union(type)
+        types = type.types.map { |type| from_rbs_type(type) }
+        Types::Union.new(types)
+      end
+
+      def from_intersection(type)
+        types = type.types.map { |type| from_rbs_type(type) }
+        Types::Intersection.new(types)
+      end
+
+      def from_class_instance(type)
+        case type.name.to_s
+        when "::String" then Types::String
+        when "::Numeric" then Types::Float
+        when "::Integer" then Types::Integer
+        when "::Float" then Types::Float
+        when "::BigDecimal" then Types::String
+        when "::Boolean" then Types::Boolean
+        when "::Array" then Types::Array.new(from_rbs_type(type.args.first))
+        else Types::Unknown
+        end
+      end
+    end
+  end
+end

lib/jsonapi-resources-anchor.rb

@@ -12,6 +12,7 @@
 require "anchor/schema"
 require "anchor/types/inference/jsonapi"
 require "anchor/types/inference/active_record"
+require "anchor/types/inference/rbs"
 require "anchor/type_script/file_structure"
 require "anchor/type_script/types"
 require "anchor/type_script/schema_generator"

spec/example/app/resources/exhaustive_resource.rb

@@ -7,14 +7,14 @@ class AssertedObject < Types::Object
   end
 
   attribute :asserted_string, Types::String, description: "My asserted string."
-  attribute :asserted_number, Types::Integer
+  attribute :asserted_number
   attribute :asserted_boolean, Types::Boolean
-  attribute :asserted_null, Types::Null
+  attribute :asserted_null
   attribute :asserted_unknown, Types::Unknown
   attribute :asserted_object, AssertedObject
   attribute :asserted_maybe_object, Types::Maybe.new(AssertedObject)
   attribute :asserted_array_record, Types::Array.new(Types::Record.new(Types::Integer))
-  attribute :asserted_union, Types::Union.new([Types::String, Types::Float])
+  attribute :asserted_union
   attribute :asserted_union_array, Types::Array.new(Types::Union.new([Types::String, Types::Float]))
   attribute :with_description, Types::String, description: "This is a provided description."
   attribute :inferred_unknown

spec/example/db/schema.rb

@@ -1,3 +1,3 @@
 class Exhaustive < ApplicationRecord
-  def model_overridden: () -> String
+  def model_overridden: () -> 'model_overridden'
 end

spec/example/sig/models/exhaustive.rbs

@@ -0,0 +1,2 @@
+class ApplicationResource
+end