tapioca 0.4.0 → 0.4.1

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

@@ -0,0 +1,144 @@
+# typed: strict
+# frozen_string_literal: true
+require "parlour"
+
+begin
+  require "google/protobuf"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::Protobuf` decorates RBI files for subclasses of
+      # `Google::Protobuf::MessageExts`.
+      # (see https://github.com/coinbase/protoc-gen-rbi).
+      #
+      # For example, with the following "cart.rb" file:
+      #
+      # ~~~rb
+      # Google::Protobuf::DescriptorPool.generated_pool.build do
+      # add_file("cart.proto", :syntax => :proto3) do
+      #   add_message "MyCart" do
+      #     optional :shop_id, :int32, 1
+      #     optional :customer_id, :int64, 2
+      #     optional :number_value, :double, 3
+      #     optional :string_value, :string, 4
+      #   end
+      # end
+      # ~~~
+      #
+      # this generator will produce the RBI file `cart.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # cart.rbi
+      # # typed: strong
+      # class Cart
+      #   sig { returns(Integer) }
+      #   def customer_id; end
+      #
+      #   sig { params(month: Integer).returns(Integer) }
+      #   def customer_id=(value); end
+      #
+      #   sig { returns(Integer) }
+      #   def shop_id; end
+      #
+      #   sig { params(value: Integer).returns(Integer) }
+      #   def shop_id=(value); end
+      #
+      #   sig { returns(String) }
+      #   def string_value; end
+      #
+      #   sig { params(value: String).returns(String) }
+      #   def string_value=(value); end
+      #
+      #
+      #   sig { returns(Float) }
+      #   def number_value; end
+      #
+      #   sig { params(value: Float).returns(Float) }
+      #   def number_value=(value); end
+      # end
+      # ~~~
+      class Protobuf < Base
+        extend T::Sig
+
+        sig do
+          override.params(
+            root: Parlour::RbiGenerator::Namespace,
+            constant: T.class_of(Google::Protobuf::MessageExts)
+          ).void
+        end
+        def decorate(root, constant)
+          descriptor = T.let(T.unsafe(constant).descriptor, Google::Protobuf::Descriptor)
+          return unless descriptor.any?
+
+          root.path(constant) do |klass|
+            descriptor.each do |desc|
+              create_descriptor_method(klass, desc)
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          classes = T.cast(ObjectSpace.each_object(Class), T::Enumerable[Class])
+          classes.select { |c| c < Google::Protobuf::MessageExts && !c.singleton_class? }
+        end
+
+        private
+
+        sig do
+          params(
+            descriptor: Google::Protobuf::FieldDescriptor
+          ).returns(String)
+        end
+        def type_of(descriptor)
+          case descriptor.type
+          when :enum
+            descriptor.subtype.enummodule.name
+          when :message
+            descriptor.subtype.msgclass.name
+          when :int32, :int64, :uint32, :uint64
+            "Integer"
+          when :double, :float
+            "Float"
+          when :bool
+            "T::Boolean"
+          when :string, :bytes
+            "String"
+          else
+            "T.untyped"
+          end
+        end
+
+        sig do
+          params(
+            klass: Parlour::RbiGenerator::Namespace,
+            desc: Google::Protobuf::FieldDescriptor,
+          ).void
+        end
+        def create_descriptor_method(klass, desc)
+          name = desc.name
+          type = type_of(desc)
+
+          create_method(
+            klass,
+            name,
+            return_type: type
+          )
+
+          create_method(
+            klass,
+            "#{name}=",
+            parameters: [
+              Parlour::RbiGenerator::Parameter.new("value", type: type),
+            ],
+            return_type: type
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "parlour"
+
+begin
+  require "smart_properties"
+rescue LoadError
+  # means SmartProperties is not installed,
+  # so let's not even define the generator.
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::SmartProperties` generates RBI files for classes that include
+      # `SmartProperties` (see https://github.com/t6d/smart_properties).
+      #
+      # For example, with the following class that includes `SmartProperties`:
+      #
+      # ~~~rb
+      # # post.rb
+      # class Post
+      #   include(SmartProperties)
+      #
+      #   property :title, accepts: String
+      #   property! :description, accepts: String
+      #   property :published, accepts: [true, false], reader: :published?
+      #   property :enabled, accepts: [true, false], default: false
+      # end
+      # ~~~
+      #
+      # this generator will produce the RBI file `post.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # post.rbi
+      # # typed: true
+      # class Post
+      #   sig { returns(T.nilable(::String)) }
+      #   def title; end
+      #
+      #   sig { params(title: T.nilable(::String)).returns(T.nilable(::String)) }
+      #   def title=(title); end
+      #
+      #   sig { returns(::String) }
+      #   def description; end
+      #
+      #   sig { params(description: ::String).returns(::String) }
+      #   def description=(description); end
+      #
+      #   sig { returns(T.nilable(T::Boolean)) }
+      #   def published?; end
+      #
+      #   sig { params(published: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+      #   def published=(published); end
+      #
+      #   ssig { returns(T.nilable(T::Boolean)) }
+      #   def enabled; end
+      #
+      #   sig { params(enabled: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+      #   def enabled=(enabled); end
+      # end
+      # ~~~
+      class SmartProperties < Base
+        extend T::Sig
+
+        sig do
+          override
+            .params(
+              root: Parlour::RbiGenerator::Namespace,
+              constant: T.class_of(::SmartProperties)
+            )
+            .void
+        end
+        def decorate(root, constant)
+          properties = T.let(
+            T.unsafe(constant).properties,
+            ::SmartProperties::PropertyCollection
+          )
+          return if properties.keys.empty?
+
+          instance_methods = constant.instance_methods(false).map(&:to_s).to_set
+
+          root.path(constant) do |k|
+            properties.values.each do |property|
+              generate_methods_for_property(k, property) do |method_name|
+                !instance_methods.include?(method_name.to_sym)
+              end
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          classes = T.cast(ObjectSpace.each_object(Class), T::Enumerable[Class])
+          classes.select do |c|
+            c < ::SmartProperties
+          end.reject do |c|
+            c.name.nil? || c == ::SmartProperties::Validations::Ancestor
+          end
+        end
+
+        private
+
+        sig do
+          params(
+            klass: Parlour::RbiGenerator::Namespace,
+            property: ::SmartProperties::Property,
+            block: T.proc.params(arg: String).returns(T::Boolean)
+          ).void
+        end
+        def generate_methods_for_property(klass, property, &block)
+          type = type_for(property)
+
+          if property.writable?
+            name = property.name.to_s
+            method_name = "#{name}="
+
+            klass.create_method(
+              method_name,
+              parameters: [Parlour::RbiGenerator::Parameter.new(name, type: type)],
+              return_type: type
+            ) if block.call(method_name)
+          end
+
+          klass.create_method(property.reader.to_s, return_type: type) if block.call(property.reader.to_s)
+        end
+
+        BOOLEANS = T.let([
+          [true, false],
+          [false, true],
+        ].freeze, T::Array[[T::Boolean, T::Boolean]])
+
+        sig { params(property: ::SmartProperties::Property).returns(String) }
+        def type_for(property)
+          converter = property.converter
+          return "T.untyped" if converter
+
+          accepter = property.accepter
+
+          type = if accepter.nil? || accepter.respond_to?(:to_proc)
+            "T.untyped"
+          elsif accepter == Array
+            "T::Array[T.untyped]"
+          elsif BOOLEANS.include?(accepter)
+            "T::Boolean"
+          elsif Array(accepter).all? { |a| a.is_a?(Module) }
+            accepters = Array(accepter)
+            types = accepters.map { |mod| name_of(mod) }.join(', ')
+            types = "T.any(#{types})" if accepters.size > 1
+            types
+          else
+            "T.untyped"
+          end
+
+          required_attr = property.instance_variable_get(:@required)
+          required = !required_attr.is_a?(Proc) && !!required_attr
+          property_required = type == "T.untyped" || required
+          type = "T.nilable(#{type})" unless property_required
+
+          type
+        end
+
+        sig { params(type: Module).returns(String) }
+        def name_of(type)
+          name = Module.instance_method(:name).bind(type).call
+          name.start_with?("::") ? name : "::#{name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,378 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "parlour"
+require "tapioca/core_ext/class"
+
+begin
+  require "state_machines"
+rescue LoadError
+  # means StateMachines is not installed,
+  # so let's not even define the generator.
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `RbiGenerator::StateMachines` generates RBI files for classes that setup a `state_machine`
+      # (see https://github.com/state-machines/state_machines). The generator also processes the extra
+      # methods generated by [StateMachines Active Record](https://github.com/state-machines/state_machines-activerecord)
+      # and [StateMachines ActiveModel](https://github.com/state-machines/state_machines-activemodel) integrations.
+      #
+      # For example, with the following `Vehicle` class:
+      #
+      # ~~~rb
+      # class Vehicle
+      #   state_machine :alarm_state, initial: :active, namespace: :'alarm' do
+      #     event :enable do
+      #       transition all => :active
+      #     end
+      #
+      #     event :disable do
+      #       transition all => :off
+      #     end
+      #
+      #     state :active, :value => 1
+      #     state :off, :value => 0
+      #   end
+      # end
+      # ~~~
+      #
+      # this generator will produce the RBI file `vehicle.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # vehicle.rbi
+      # # typed: true
+      # class Vehicle
+      #   include Vehicle::StateMachineInstanceHelperModule
+      #   extend Vehicle::StateMachineClassHelperModule
+      # end
+      #
+      # module Vehicle::StateMachineClassHelperModule
+      #   sig { params(event: T.any(String, Symbol)).returns(String) }
+      #   def human_alarm_state_event_name(event); end
+      #
+      #   sig { params(state: T.any(String, Symbol)).returns(String) }
+      #   def human_alarm_state_name(state); end
+      # end
+      #
+      # module Vehicle::StateMachineInstanceHelperModule
+      #   sig { returns(T::Boolean) }
+      #   def alarm_active?; end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def alarm_off?; end
+      #
+      #   sig { returns(Integer) }
+      #   def alarm_state; end
+      #
+      #   sig { params(value: Integer).returns(Integer) }
+      #   def alarm_state=(value); end
+      #
+      #   sig { params(state: T.any(String, Symbol)).returns(T::Boolean) }
+      #   def alarm_state?(state); end
+      #
+      #   sig { params(args: T.untyped).returns(T::Array[T.any(String, Symbol)]) }
+      #   def alarm_state_events(*args); end
+      #
+      #   sig { returns(T.any(String, Symbol)) }
+      #   def alarm_state_name; end
+      #
+      #   sig { params(args: T.untyped).returns(T::Array[::StateMachines::Transition]) }
+      #   def alarm_state_paths(*args); end
+      #
+      #   sig { params(args: T.untyped).returns(T::Array[::StateMachines::Transition]) }
+      #   def alarm_state_transitions(*args); end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def can_disable_alarm?; end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def can_enable_alarm?; end
+      #
+      #   sig { params(args: T.untyped).returns(T::Boolean) }
+      #   def disable_alarm(*args); end
+      #
+      #   sig { params(args: T.untyped).returns(T::Boolean) }
+      #   def disable_alarm!(*args); end
+      #
+      #   sig { params(args: T.untyped).returns(T.nilable(::StateMachines::Transition)) }
+      #   def disable_alarm_transition(*args); end
+      #
+      #   sig { params(args: T.untyped).returns(T::Boolean) }
+      #   def enable_alarm(*args); end
+      #
+      #   sig { params(args: T.untyped).returns(T::Boolean) }
+      #   def enable_alarm!(*args); end
+      #
+      #   sig { params(args: T.untyped).returns(T.nilable(::StateMachines::Transition)) }
+      #   def enable_alarm_transition(*args); end
+      #
+      #   sig { params(event: T.any(String, Symbol), args: T.untyped).returns(T::Boolean) }
+      #   def fire_alarm_state_event(event, *args); end
+      #
+      #   sig { returns(String) }
+      #   def human_alarm_state_name; end
+      # end
+      # ~~~
+      class StateMachines < Base
+        extend T::Sig
+
+        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: ::StateMachines::ClassMethods).void }
+        def decorate(root, constant)
+          return if constant.state_machines.empty?
+
+          instance_module_name = "#{constant}::StateMachineInstanceHelperModule"
+          class_module_name = "#{constant}::StateMachineClassHelperModule"
+
+          instance_module = root.create_module(instance_module_name)
+          class_module = root.create_module(class_module_name)
+
+          constant.state_machines.each_value do |machine|
+            state_type = state_type_for(machine)
+
+            define_state_accessor(instance_module, machine, state_type)
+            define_state_predicate(instance_module, machine)
+            define_event_helpers(instance_module, machine)
+            define_path_helpers(instance_module, machine)
+            define_name_helpers(instance_module, class_module, machine)
+            define_scopes(class_module, machine)
+
+            define_state_methods(instance_module, machine)
+            define_event_methods(instance_module, machine)
+          end
+
+          matching_integration_name = ::StateMachines::Integrations.match(constant)&.integration_name
+
+          case matching_integration_name
+          when :active_record
+            define_activerecord_methods(instance_module)
+          end
+
+          root.path(constant) do |klass|
+            klass.create_include(instance_module_name)
+            klass.create_extend(class_module_name)
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          Object.descendants.select { |mod| mod < ::StateMachines::InstanceMethods }
+        end
+
+        private
+
+        sig { params(machine: ::StateMachines::Machine).returns(String) }
+        def state_type_for(machine)
+          value_types = machine.states.map { |state| state.value.class.name }.uniq
+
+          if value_types.size == 1
+            value_types.first
+          else
+            "T.any(#{value_types.join(', ')})"
+          end
+        end
+
+        sig { params(instance_module: Parlour::RbiGenerator::Namespace).void }
+        def define_activerecord_methods(instance_module)
+          create_method(
+            instance_module,
+            "changed_for_autosave?",
+            return_type: "T::Boolean"
+          )
+        end
+
+        sig { params(instance_module: Parlour::RbiGenerator::Namespace, machine: ::StateMachines::Machine).void }
+        def define_state_methods(instance_module, machine)
+          machine.states.each do |state|
+            create_method(
+              instance_module,
+              "#{state.qualified_name}?",
+              return_type: "T::Boolean"
+            )
+          end
+        end
+
+        sig { params(instance_module: Parlour::RbiGenerator::Namespace, machine: ::StateMachines::Machine).void }
+        def define_event_methods(instance_module, machine)
+          machine.events.each do |event|
+            create_method(
+              instance_module,
+              "can_#{event.qualified_name}?",
+              return_type: "T::Boolean"
+            )
+            create_method(
+              instance_module,
+              "#{event.qualified_name}_transition",
+              parameters: [Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped")],
+              return_type: "T.nilable(::StateMachines::Transition)"
+            )
+            create_method(
+              instance_module,
+              event.qualified_name.to_s,
+              parameters: [Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped")],
+              return_type: "T::Boolean"
+            )
+            create_method(
+              instance_module,
+              "#{event.qualified_name}!",
+              parameters: [Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped")],
+              return_type: "T::Boolean"
+            )
+          end
+        end
+
+        sig do
+          params(
+            instance_module: Parlour::RbiGenerator::Namespace,
+            machine: ::StateMachines::Machine,
+            state_type: String
+          ).void
+        end
+        def define_state_accessor(instance_module, machine, state_type)
+          attribute = machine.attribute.to_s
+          create_method(
+            instance_module,
+            attribute,
+            return_type: state_type
+          )
+          create_method(
+            instance_module,
+            "#{attribute}=",
+            parameters: [Parlour::RbiGenerator::Parameter.new("value", type: state_type)],
+            return_type: state_type
+          )
+        end
+
+        sig { params(instance_module: Parlour::RbiGenerator::Namespace, machine: ::StateMachines::Machine).void }
+        def define_state_predicate(instance_module, machine)
+          create_method(
+            instance_module,
+            "#{machine.name}?",
+            parameters: [Parlour::RbiGenerator::Parameter.new("state", type: "T.any(String, Symbol)")],
+            return_type: "T::Boolean"
+          )
+        end
+
+        sig { params(instance_module: Parlour::RbiGenerator::Namespace, machine: ::StateMachines::Machine).void }
+        def define_event_helpers(instance_module, machine)
+          events_attribute = machine.attribute(:events).to_s
+          transitions_attribute = machine.attribute(:transitions).to_s
+          event_attribute = machine.attribute(:event).to_s
+          event_transition_attribute = machine.attribute(:event_transition).to_s
+
+          create_method(
+            instance_module,
+            events_attribute,
+            parameters: [Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped")],
+            return_type: "T::Array[T.any(String, Symbol)]"
+          )
+          create_method(
+            instance_module,
+            transitions_attribute,
+            parameters: [Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped")],
+            return_type: "T::Array[::StateMachines::Transition]"
+          )
+          create_method(
+            instance_module,
+            "fire_#{event_attribute}",
+            parameters: [
+              Parlour::RbiGenerator::Parameter.new("event", type: "T.any(String, Symbol)"),
+              Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped"),
+            ],
+            return_type: "T::Boolean"
+          )
+          if machine.action
+            create_method(
+              instance_module,
+              event_attribute,
+              return_type: "T.nilable(Symbol)"
+            )
+            create_method(
+              instance_module,
+              "#{event_attribute}=",
+              parameters: [Parlour::RbiGenerator::Parameter.new("value", type: "T.any(String, Symbol)")],
+              return_type: "T.any(String, Symbol)"
+            )
+            create_method(
+              instance_module,
+              event_transition_attribute,
+              return_type: "T.nilable(::StateMachines::Transition)"
+            )
+            create_method(
+              instance_module,
+              "#{event_transition_attribute}=",
+              parameters: [Parlour::RbiGenerator::Parameter.new("value", type: "::StateMachines::Transition")],
+              return_type: "::StateMachines::Transition"
+            )
+          end
+        end
+
+        sig { params(instance_module: Parlour::RbiGenerator::Namespace, machine: ::StateMachines::Machine).void }
+        def define_path_helpers(instance_module, machine)
+          paths_attribute = machine.attribute(:paths).to_s
+
+          create_method(
+            instance_module,
+            paths_attribute,
+            parameters: [Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped")],
+            return_type: "T::Array[::StateMachines::Transition]"
+          )
+        end
+
+        sig do
+          params(
+            instance_module: Parlour::RbiGenerator::Namespace,
+            class_module: Parlour::RbiGenerator::Namespace,
+            machine: ::StateMachines::Machine
+          ).void
+        end
+        def define_name_helpers(instance_module, class_module, machine)
+          name_attribute = machine.attribute(:name).to_s
+          event_name_attribute = machine.attribute(:event_name).to_s
+
+          create_method(
+            class_module,
+            "human_#{name_attribute}",
+            parameters: [Parlour::RbiGenerator::Parameter.new("state", type: "T.any(String, Symbol)")],
+            return_type: "String"
+          )
+          create_method(
+            class_module,
+            "human_#{event_name_attribute}",
+            parameters: [Parlour::RbiGenerator::Parameter.new("event", type: "T.any(String, Symbol)")],
+            return_type: "String"
+          )
+          create_method(
+            instance_module,
+            name_attribute,
+            return_type: "T.any(String, Symbol)"
+          )
+          create_method(
+            instance_module,
+            "human_#{name_attribute}",
+            return_type: "String"
+          )
+        end
+
+        sig { params(class_module: Parlour::RbiGenerator::Namespace, machine: ::StateMachines::Machine).void }
+        def define_scopes(class_module, machine)
+          helper_modules = machine.instance_variable_get(:@helper_modules)
+          class_methods = helper_modules[:class].instance_methods(false)
+
+          class_methods
+            .select { |method| method.to_s.start_with?("with_", "without_") }
+            .each do |method|
+              create_method(
+                class_module,
+                method.to_s,
+                parameters: [Parlour::RbiGenerator::Parameter.new("*states", type: "T.any(String, Symbol)")],
+                return_type: "T.untyped"
+              )
+            end
+        end
+      end
+    end
+  end
+end