feat(sorbet): add manual RBI files for various modules and classes (#214)

Author: stefan-burke

sorbet/rbi/manual/action_controller_helpers.rbi

@@ -0,0 +1,31 @@
+# typed: strict
+
+# ActionController helpers and methods
+module ActionController
+  class Base
+    extend T::Sig
+    
+    # I18n helpers
+    sig { params(key: T.any(String, Symbol), options: T.untyped).returns(String) }
+    def t(key, **options); end
+    
+    sig { params(key: T.any(String, Symbol), options: T.untyped).returns(String) }
+    def translate(key, **options); end
+    
+    sig { params(key: T.any(String, Symbol), count: T.untyped, options: T.untyped).returns(String) }
+    def l(key, count = nil, **options); end
+    
+    sig { params(key: T.any(String, Symbol), count: T.untyped, options: T.untyped).returns(String) }
+    def localize(key, count = nil, **options); end
+  end
+end
+
+# EN14960 CalculatorResponse
+module EN14960
+  class CalculatorResponse
+    extend T::Sig
+    
+    sig { returns(T.nilable(String)) }
+    def value_suffix; end
+  end
+end

sorbet/rbi/manual/active_record_callbacks.rbi

@@ -0,0 +1,81 @@
+# typed: strict
+
+# ActiveRecord callback methods
+module ActiveRecord
+  module Callbacks
+    module ClassMethods
+      extend T::Sig
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def after_create(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def after_destroy(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def after_save(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def after_update(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def after_validation(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def around_create(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def around_destroy(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def around_save(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def around_update(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def before_create(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def before_destroy(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def before_save(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def before_update(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def before_validation(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def after_commit(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def after_rollback(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def after_initialize(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def after_find(*args, &block); end
+      
+      sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void }
+      def after_touch(*args, &block); end
+    end
+  end
+end
+
+# Make callbacks available on ActiveRecord::Base
+class ActiveRecord::Base
+  extend ActiveRecord::Callbacks::ClassMethods
+end
+
+# Make callbacks available on concerns
+module ActiveSupport
+  module Concern
+    module ClassMethods
+      include ActiveRecord::Callbacks::ClassMethods
+    end
+  end
+end

sorbet/rbi/manual/active_support_extensions.rbi

@@ -0,0 +1,92 @@
+# typed: strict
+
+# ActiveSupport extensions to core Ruby classes
+
+class Date
+  extend T::Sig
+  
+  sig { returns(Date) }
+  def self.current; end
+  
+  sig { returns(Date) }
+  def self.today; end
+  
+  sig { returns(Date) }
+  def self.tomorrow; end
+  
+  sig { returns(Date) }
+  def self.yesterday; end
+end
+
+class Integer
+  extend T::Sig
+  
+  sig { returns(ActiveSupport::Duration) }
+  def days; end
+  
+  sig { returns(ActiveSupport::Duration) }
+  def hours; end
+  
+  sig { returns(ActiveSupport::Duration) }
+  def minutes; end
+  
+  sig { returns(ActiveSupport::Duration) }
+  def seconds; end
+  
+  sig { returns(ActiveSupport::Duration) }
+  def weeks; end
+  
+  sig { returns(ActiveSupport::Duration) }
+  def months; end
+  
+  sig { returns(ActiveSupport::Duration) }
+  def years; end
+  
+  sig { returns(ActiveSupport::Duration) }
+  def day; end
+  
+  sig { returns(ActiveSupport::Duration) }
+  def hour; end
+  
+  sig { returns(ActiveSupport::Duration) }
+  def minute; end
+  
+  sig { returns(ActiveSupport::Duration) }
+  def second; end
+  
+  sig { returns(ActiveSupport::Duration) }
+  def week; end
+  
+  sig { returns(ActiveSupport::Duration) }
+  def month; end
+  
+  sig { returns(ActiveSupport::Duration) }
+  def year; end
+end
+
+module ActiveSupport
+  class Duration
+    extend T::Sig
+    
+    sig { returns(Float) }
+    def to_f; end
+    
+    sig { returns(Integer) }
+    def to_i; end
+    
+    sig { params(time: T.any(Time, Date, DateTime)).returns(T.any(Time, Date, DateTime)) }
+    def ago(time = Time.current); end
+    
+    sig { params(time: T.any(Time, Date, DateTime)).returns(T.any(Time, Date, DateTime)) }
+    def since(time = Time.current); end
+    
+    sig { params(time: T.any(Time, Date, DateTime)).returns(T.any(Time, Date, DateTime)) }
+    def from_now(time = Time.current); end
+    
+    sig { params(time: T.any(Time, Date, DateTime)).returns(T.any(Time, Date, DateTime)) }
+    def before(time); end
+    
+    sig { params(time: T.any(Time, Date, DateTime)).returns(T.any(Time, Date, DateTime)) }
+    def after(time); end
+  end
+end

sorbet/rbi/manual/active_support_missing.rbi

@@ -0,0 +1,26 @@
+# typed: strict
+
+module ActiveSupport
+  class ArrayInquirer < Array; end
+  class StringInquirer < String; end
+  class SafeBuffer < String; end
+  class TimeZone; end
+  class TimeWithZone; end
+  
+  class HashWithIndifferentAccess < Hash
+    extend T::Sig
+    extend T::Generic
+    
+    K = type_member
+    V = type_member
+  end
+  
+  module Multibyte
+    class Chars; end
+  end
+end
+
+module DateAndTime
+  module Zones; end
+  module Calculations; end
+end

sorbet/rbi/manual/chobble_forms.rbi

@@ -0,0 +1,17 @@
+# typed: strict
+
+# ChobbleForms module and its utilities
+module ChobbleForms
+  class FieldUtils
+    extend T::Sig
+
+    sig { params(field: T.any(Symbol, String)).returns(T::Boolean) }
+    def self.is_comment_field?(field); end
+
+    sig { params(field: T.any(Symbol, String)).returns(T::Boolean) }
+    def self.is_pass_field?(field); end
+
+    sig { params(field: T.any(Symbol, String)).returns(Symbol) }
+    def self.strip_field_suffix(field); end
+  end
+end

sorbet/rbi/manual/model_associations.rbi

@@ -0,0 +1,98 @@
+# typed: strict
+
+# Additional model associations and methods not captured by Tapioca
+
+class User < ApplicationRecord
+  extend T::Sig
+  
+  sig { returns(T.nilable(InspectorCompany)) }
+  def inspection_company; end
+  
+  sig { params(value: T.nilable(InspectorCompany)).void }
+  def inspection_company=(value); end
+end
+
+class Inspection < ApplicationRecord
+  extend T::Sig
+  
+  # Attributes from database
+  sig { returns(T.nilable(DateTime)) }
+  def complete_date; end
+  
+  sig { params(value: T.nilable(DateTime)).void }
+  def complete_date=(value); end
+  
+  sig { returns(T.nilable(DateTime)) }
+  def inspection_date; end
+  
+  sig { params(value: T.nilable(DateTime)).void }
+  def inspection_date=(value); end
+  
+  sig { returns(T.nilable(Float)) }
+  def length; end
+  
+  sig { params(value: T.nilable(Float)).void }
+  def length=(value); end
+  
+  sig { returns(T.nilable(Float)) }
+  def width; end
+  
+  sig { params(value: T.nilable(Float)).void }
+  def width=(value); end
+  
+  sig { returns(T.nilable(Float)) }
+  def height; end
+  
+  sig { params(value: T.nilable(Float)).void }
+  def height=(value); end
+  
+  sig { returns(T::Boolean) }
+  def has_slide; end
+  
+  sig { params(value: T::Boolean).void }
+  def has_slide=(value); end
+  
+  sig { returns(T::Boolean) }
+  def has_slide?; end
+  
+  sig { returns(T::Boolean) }
+  def is_totally_enclosed; end
+  
+  sig { params(value: T::Boolean).void }
+  def is_totally_enclosed=(value); end
+  
+  sig { returns(T::Boolean) }
+  def is_totally_enclosed?; end
+  
+  sig { returns(T::Boolean) }
+  def indoor_only; end
+  
+  sig { params(value: T::Boolean).void }
+  def indoor_only=(value); end
+  
+  sig { returns(T::Boolean) }
+  def indoor_only?; end
+  
+  sig { returns(T::Boolean) }
+  def passed; end
+  
+  sig { params(value: T::Boolean).void }
+  def passed=(value); end
+  
+  sig { returns(T::Boolean) }
+  def bouncing_pillow?; end
+  
+  # Associations
+  sig { returns(T.nilable(Unit)) }
+  def unit; end
+  
+  sig { params(value: T.nilable(Unit)).void }
+  def unit=(value); end
+  
+  # ActiveRecord methods
+  sig { params(args: T.untyped).void }
+  def update!(args); end
+  
+  sig { returns(T::Boolean) }
+  def complete?; end
+end