tapioca 0.3.1 → 0.4.4

data/lib/tapioca/compilers/dsl/active_resource.rb

@@ -0,0 +1,140 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "parlour"
+
+begin
+  require "active_resource"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::ActiveResource` decorates RBI files for subclasses of
+      # `ActiveResource::Base` which declare `schema` fields
+      # (see https://github.com/rails/activeresource).
+      #
+      # For example, with the following `ActiveResource::Base` subclass:
+      #
+      # ~~~rb
+      # class Post < ActiveResource::Base
+      #   schema do
+      #     integer 'id', 'month', 'year'
+      #   end
+      # end
+      # ~~~
+      #
+      # this generator will produce the RBI file `post.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # post.rbi
+      # # typed: true
+      # class Post
+      #   sig { returns(Integer) }
+      #   def id; end
+      #
+      #   sig { params(id: Integer).returns(Integer) }
+      #   def id=(id); end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def id?; end
+      #
+      #   sig { returns(Integer) }
+      #   def month; end
+      #
+      #   sig { params(month: Integer).returns(Integer) }
+      #   def month=(month); end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def month?; end
+      #
+      #   sig { returns(Integer) }
+      #   def year; end
+      #
+      #   sig { params(year: Integer).returns(Integer) }
+      #   def year=(year); end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def year?; end
+      # end
+      # ~~~
+      class ActiveResource < Base
+        extend T::Sig
+
+        sig do
+          override.params(
+            root: Parlour::RbiGenerator::Namespace,
+            constant: T.class_of(::ActiveResource::Base)
+          ).void
+        end
+        def decorate(root, constant)
+          return if constant.schema.blank?
+          root.path(constant) do |klass|
+            constant.schema.each do |attribute, type|
+              create_schema_methods(klass, attribute, type)
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          ::ActiveResource::Base.descendants
+        end
+
+        private
+
+        TYPES = T.let({
+          boolean: "T::Boolean",
+          integer: "Integer",
+          string: "String",
+          float: "Float",
+          date: "Date",
+          time: "Time",
+          datetime: "DateTime",
+          decimal: "BigDecimal",
+          binary: "String",
+          text: "String",
+        }.freeze, T::Hash[Symbol, String])
+
+        sig { params(attr_type: Symbol).returns(String) }
+        def type_for(attr_type)
+          TYPES.fetch(attr_type, "T.untyped")
+        end
+
+        sig do
+          params(
+            klass: Parlour::RbiGenerator::Namespace,
+            attribute: String,
+            type: String
+          ).void
+        end
+        def create_schema_methods(klass, attribute, type)
+          return_type = type_for(type.to_sym)
+
+          create_method(
+            klass,
+            attribute,
+            return_type: return_type
+          )
+
+          create_method(
+            klass,
+            "#{attribute}?",
+            return_type: "T::Boolean"
+          )
+
+          create_method(
+            klass,
+            "#{attribute}=",
+            parameters: [
+              Parlour::RbiGenerator::Parameter.new("value", type: return_type),
+            ],
+            return_type: return_type
+          )
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/compilers/dsl/active_support_current_attributes.rb

@@ -0,0 +1,126 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "parlour"
+
+begin
+  require "active_support"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::ActiveSupportCurrentAttributes` decorates RBI files for all
+      # subclasses of `ActiveSupport::CurrentAttributes`
+      #
+      # To add attributes see https://api.rubyonrails.org/classes/ActiveSupport/CurrentAttributes.html
+      #
+      # For example, with the following singleton class
+      #
+      # ~~~rb
+      # class Current < ActiveSupport::CurrentAttributes
+      #   extend T::Sig
+      #
+      #   attribute :account
+      #
+      #   def helper
+      #     # ...
+      #   end
+      #
+      #   sig { params(user_id: Integer).void }
+      #   def authenticate(user_id)
+      #     # ...
+      #   end
+      # end
+      # ~~~rb
+      #
+      # this generator will produce an RBI file with the following content:
+      # ~~~rbi
+      # # typed: true
+      #
+      # class Current
+      #   sig { returns(T.untyped) }
+      #   def self.account; end
+      #
+      #   sig { returns(T.untyped) }
+      #   def account; end
+      #
+      #   sig { params(account: T.untyped).returns(T.untyped) }
+      #   def self.account=(account); end
+      #
+      #   sig { params(account: T.untyped).returns(T.untyped) }
+      #   def account=(account); end
+      #
+      #   sig { params(user_id: Integer).void }
+      #   def self.authenticate(user_id); end
+      #
+      #   sig { returns(T.untyped) }
+      #   def self.helper; end
+      # end
+      # ~~~
+      class ActiveSupportCurrentAttributes < Base
+        extend T::Sig
+
+        sig do
+          override
+            .params(
+              root: Parlour::RbiGenerator::Namespace,
+              constant: T.class_of(::ActiveSupport::CurrentAttributes)
+            )
+            .void
+        end
+        def decorate(root, constant)
+          dynamic_methods = dynamic_methods_for(constant)
+          instance_methods = instance_methods_for(constant) - dynamic_methods
+          return if dynamic_methods.empty? && instance_methods.empty?
+
+          root.path(constant) do |k|
+            dynamic_methods.each do |method|
+              method = method.to_s
+              # We want to generate each method both on the class
+              generate_method(k, method, class_method: true)
+              # and on the instance
+              generate_method(k, method, class_method: false)
+            end
+
+            instance_methods.each do |method|
+              # instance methods are only elevated to class methods
+              # no need to add separate instance methods for them
+              method = constant.instance_method(method)
+              create_method_from_def(k, method, class_method: true)
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          ::ActiveSupport::CurrentAttributes.descendants
+        end
+
+        private
+
+        sig { params(constant: T.class_of(::ActiveSupport::CurrentAttributes)).returns(T::Array[Symbol]) }
+        def dynamic_methods_for(constant)
+          constant.instance_variable_get(:@generated_attribute_methods)&.instance_methods(false) || []
+        end
+
+        sig { params(constant: T.class_of(::ActiveSupport::CurrentAttributes)).returns(T::Array[Symbol]) }
+        def instance_methods_for(constant)
+          constant.instance_methods(false)
+        end
+
+        sig { params(klass: Parlour::RbiGenerator::Namespace, method: String, class_method: T::Boolean).void }
+        def generate_method(klass, method, class_method:)
+          if method.end_with?("=")
+            parameter = Parlour::RbiGenerator::Parameter.new("value", type: "T.untyped")
+            klass.create_method(method, class_method: class_method, parameters: [parameter], return_type: "T.untyped")
+          else
+            klass.create_method(method, class_method: class_method, return_type: "T.untyped")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/compilers/dsl/base.rb

@@ -0,0 +1,165 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "parlour"
+
+module Tapioca
+  module Compilers
+    module Dsl
+      class Base
+        extend T::Sig
+        extend T::Helpers
+
+        abstract!
+
+        sig { returns(T::Set[Module]) }
+        attr_reader :processable_constants
+
+        sig { void }
+        def initialize
+          @processable_constants = T.let(Set.new(gather_constants), T::Set[Module])
+        end
+
+        sig { params(constant: Module).returns(T::Boolean) }
+        def handles?(constant)
+          processable_constants.include?(constant)
+        end
+
+        sig do
+          abstract
+            .type_parameters(:T)
+            .params(
+              root: Parlour::RbiGenerator::Namespace,
+              constant: T.type_parameter(:T)
+            )
+            .void
+        end
+        def decorate(root, constant); end
+
+        sig { abstract.returns(T::Enumerable[Module]) }
+        def gather_constants; end
+
+        private
+
+        SPECIAL_METHOD_NAMES = T.let(
+          %w[! ~ +@ ** -@ * / % + - << >> & | ^ < <= => > >= == === != =~ !~ <=> [] []= `].freeze,
+          T::Array[String]
+        )
+
+        sig { params(name: String).returns(T::Boolean) }
+        def valid_method_name?(name)
+          return true if SPECIAL_METHOD_NAMES.include?(name)
+          !!name.match(/^[a-zA-Z_][[:word:]]*[?!=]?$/)
+        end
+
+        sig do
+          params(
+            namespace: Parlour::RbiGenerator::Namespace,
+            name: String,
+            options: T::Hash[T.untyped, T.untyped]
+          ).void
+        end
+        def create_method(namespace, name, options = {})
+          return unless valid_method_name?(name)
+          T.unsafe(namespace).create_method(name, options)
+        end
+
+        # Create a Parlour method inside `namespace` from its Ruby definition
+        sig do
+          params(
+            namespace: Parlour::RbiGenerator::Namespace,
+            method_def: T.any(Method, UnboundMethod),
+            class_method: T::Boolean
+          ).void
+        end
+        def create_method_from_def(namespace, method_def, class_method: false)
+          create_method(
+            namespace,
+            method_def.name.to_s,
+            parameters: compile_method_parameters_to_parlour(method_def),
+            return_type: compile_method_return_type_to_parlour(method_def),
+            class_method: class_method
+          )
+        end
+
+        # Compile a Ruby method parameters into Parlour parameters
+        sig do
+          params(method_def: T.any(Method, UnboundMethod))
+            .returns(T::Array[Parlour::RbiGenerator::Parameter])
+        end
+        def compile_method_parameters_to_parlour(method_def)
+          signature = T::Private::Methods.signature_for_method(method_def)
+          method_def = signature.nil? ? method_def : signature.method
+          method_types = parameters_types_from_signature(method_def, signature)
+
+          method_def.parameters.each_with_index.map do |(type, name), i|
+            name ||= :_
+            name = name.to_s.gsub(/&|\*/, '_') # avoid incorrect names from `delegate`
+            case type
+            when :req
+              ::Parlour::RbiGenerator::Parameter.new(name, type: method_types[i])
+            when :opt
+              ::Parlour::RbiGenerator::Parameter.new(name, type: method_types[i], default: 'T.unsafe(nil)')
+            when :rest
+              ::Parlour::RbiGenerator::Parameter.new("*#{name}", type: method_types[i])
+            when :keyreq
+              ::Parlour::RbiGenerator::Parameter.new("#{name}:", type: method_types[i])
+            when :key
+              ::Parlour::RbiGenerator::Parameter.new("#{name}:", type: method_types[i], default: 'T.unsafe(nil)')
+            when :keyrest
+              ::Parlour::RbiGenerator::Parameter.new("**#{name}", type: method_types[i])
+            when :block
+              ::Parlour::RbiGenerator::Parameter.new("&#{name}", type: method_types[i])
+            else
+              raise "Unknown type `#{type}`."
+            end
+          end
+        end
+
+        # Compile a Ruby method return type into a Parlour type
+        sig do
+          params(method_def: T.any(Method, UnboundMethod))
+            .returns(String)
+        end
+        def compile_method_return_type_to_parlour(method_def)
+          signature = T::Private::Methods.signature_for_method(method_def)
+          return_type = signature.nil? ? 'T.untyped' : signature.return_type.to_s
+          # Map <VOID> to `nil` since `nil` means a `void` return for Parlour
+          return_type = nil if return_type == "<VOID>"
+          # Map <NOT-TYPED> to `T.untyped`
+          return_type = "T.untyped" if return_type == "<NOT-TYPED>"
+          return_type
+        end
+
+        # Get the types of each parameter from a method signature
+        sig do
+          params(
+            method_def: T.any(Method, UnboundMethod),
+            signature: T.untyped # as `T::Private::Methods::Signature` is private
+          ).returns(T::Array[String])
+        end
+        def parameters_types_from_signature(method_def, signature)
+          params = T.let([], T::Array[String])
+
+          return method_def.parameters.map { 'T.untyped' } unless signature
+
+          # parameters types
+          signature.arg_types.each { |arg_type| params << arg_type[1].to_s }
+
+          # keyword parameters types
+          signature.kwarg_types.each { |_, kwarg_type| params << kwarg_type.to_s }
+
+          # rest parameter type
+          params << signature.rest_type.to_s if signature.has_rest
+
+          # special case `.void` in a proc
+          unless signature.block_name.nil?
+            params << signature.block_type.to_s.gsub('returns(<VOID>)', 'void')
+          end
+
+          params
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/compilers/dsl/frozen_record.rb

@@ -0,0 +1,96 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "parlour"
+
+begin
+  require "frozen_record"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::FrozenRecord` generates RBI files for subclasses of `FrozenRecord::Base`
+      # (see https://github.com/byroot/frozen_record).
+      #
+      # For example, with the following FrozenRecord class:
+      #
+      # ~~~rb
+      # # student.rb
+      # class Student < FrozenRecord::Base
+      # end
+      # ~~~
+      #
+      # and the following YAML file:
+      #
+      # ~~~ yaml
+      # # students.yml
+      # - id: 1
+      #   first_name: John
+      #   last_name: Smith
+      # - id: 2
+      #   first_name: Dan
+      #   last_name:  Lord
+      # ~~~
+      #
+      # this generator will produce the RBI file `student.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # Student.rbi
+      # # typed: strong
+      # class Student
+      #   include Student::FrozenRecordAttributeMethods
+      # end
+      #
+      # module Student::FrozenRecordAttributeMethods
+      #   sig { returns(T.untyped) }
+      #   def first_name; end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def first_name?; end
+      #
+      #   sig { returns(T.untyped) }
+      #   def id; end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def id?; end
+      #
+      #   sig { returns(T.untyped) }
+      #   def last_name; end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def last_name?; end
+      # end
+      # ~~~
+      class FrozenRecord < Base
+        extend T::Sig
+
+        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::FrozenRecord::Base)).void }
+        def decorate(root, constant)
+          attributes = constant.attributes
+          return if attributes.empty?
+
+          module_name = "#{constant}::FrozenRecordAttributeMethods"
+
+          root.create_module(module_name) do |mod|
+            attributes.each do |attribute|
+              create_method(mod, "#{attribute}?", return_type: 'T::Boolean')
+              create_method(mod, attribute.to_s, return_type: 'T.untyped')
+            end
+          end
+
+          root.path(constant) do |klass|
+            klass.create_include(module_name)
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          ::FrozenRecord::Base.descendants.reject(&:abstract_class?)
+        end
+      end
+    end
+  end
+end