Add gen-sig script

This is adds the `gen-sig` script to generate signatures as well as a
signatures for the project.

Author: aaronmallen

Gemfile

@@ -18,6 +18,11 @@ group :docs do
   gem "yard-junk"
 end
 
+group :sig do
+  gem "rbs"
+  gem "rbs-inline"
+end
+
 group :test do
   gem "debug_inspector"
   gem "dry-types"

bin/gen-sig

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+root_path = Pathname.new(File.expand_path("../", __dir__))
+
+manifest_path = root_path.join("sig/manifest.yaml")
+manifest      = manifest_path.exist? ? manifest_path.read : "dependencies: []"
+
+FileUtils.rm_rf(root_path.join("sig"))
+
+system "rbs-inline lib --opt-out --output=./sig"
+
+EMPTY_COMMENT_BEFORE_CODE = /
+  ^[ \t]*\#[ \t]*\n
+  (?=^[ \t]*[^#\s])
+/mx
+EMPTY_STRING = ""
+GENERATED_LINE = /^ *# Generated from .+.rb with RBS::Inline *$/
+RBS_COMMENT_BLOCK = /
+  ^[ \t]*\#[ \t]*@rbs.*\n
+  (?:^[ \t]*\#.*\n)*
+/x
+
+root_path.glob("sig/**/*.rbs").each do |file|
+  contents = file.read
+
+  contents.gsub!(GENERATED_LINE, EMPTY_STRING)
+    &.gsub!(RBS_COMMENT_BLOCK, EMPTY_STRING)
+    &.gsub!(EMPTY_COMMENT_BEFORE_CODE, EMPTY_STRING)
+    &.strip
+
+  if contents.nil? || contents.strip.empty?
+    File.delete(file)
+  else
+    File.write(file, "#{contents}\n")
+  end
+end
+
+File.write(manifest_path, manifest)

lib/dry/monads.rb

@@ -14,6 +14,7 @@ module Dry
   # @api public
   module Monads
     # @api private
+    # @rbs () -> Zietwerk::Loader
     def self.loader
       @loader ||= ::Zeitwerk::Loader.new.tap do |loader|
         root = ::File.expand_path("..", __dir__)
@@ -31,6 +32,7 @@ def self.loader
     end
 
     # @private
+    # @rbs (Class | Module base) -> void
     def self.included(base)
       if all_loaded?
         base.include(*constructors)
@@ -68,6 +70,7 @@ def self.included(base)
     # @param [Array<Symbol>] monads
     # @return [Module]
     # @api public
+    # @rbs (*Symbol monads) -> Module
     def self.[](*monads)
       monads.sort!
       @mixins.fetch_or_store(monads.hash) do

lib/dry/monads/conversion_stubs.rb

@@ -3,6 +3,7 @@
 module Dry
   module Monads
     module ConversionStubs
+      # @rbs (*Symbol method_names) -> void
       def self.[](*method_names)
         ::Module.new do
           method_names.each do |name|
@@ -16,14 +17,17 @@ def self.[](*method_names)
       module Methods
         module_function
 
+        # @rbs () -> Maybe
         def to_maybe
           raise "Load Maybe first with require 'dry/monads/maybe'"
         end
 
+        # @rbs () -> Result
         def to_result
           raise "Load Result first with require 'dry/monads/result'"
         end
 
+        # @rbs () -> Validated
         def to_validated
           raise "Load Validated first with require 'dry/monads/validated'"
         end

lib/dry/monads/do.rb

@@ -102,6 +102,7 @@ class << self
         #
         # @param [Array<Symbol>] methods
         # @return [Module]
+        # @rbs (*Symbol methods) -> Module
         def for(*methods)
           ::Module.new do
             singleton_class.define_method(:included) do |base|
@@ -113,6 +114,7 @@ def for(*methods)
         end
 
         # @api private
+        # @rbs (Class | Module base) -> void
         def included(base)
           super
 

lib/dry/monads/do/all.rb

@@ -57,8 +57,9 @@ module Do
       module All
         # @private
         class MethodTracker < ::Module
-          attr_reader :wrappers
+          attr_reader :wrappers #: Hash[Class | Module, Module]
 
+          # @rbs (Hash[Class | Module, Module] wrappers) -> void
           def initialize(wrappers)
             super()
 
@@ -86,11 +87,13 @@ def included(base)
             end
           end
 
+          # @rbs (Class | Module target) -> void
           def extend_object(target)
             super
             target.prepend(wrappers[target])
           end
 
+          # @rbs (Class | Module target, Symbol method) -> void
           def wrap_method(target, method)
             visibility = Do.method_visibility(target, method)
             Do.wrap_method(wrappers[target], method, visibility)
@@ -99,6 +102,7 @@ def wrap_method(target, method)
 
         class << self
           # @api private
+          # @rbs (Class | Module base) -> void
           def included(base)
             super
 
@@ -110,6 +114,7 @@ def included(base)
           end
 
           # @api private
+          # @rbs (Class klass, __todo__ target) -> void
           def wrap_defined_methods(klass, target)
             klass.public_instance_methods(false).each do |m|
               Do.wrap_method(target, m, :public)
@@ -128,6 +133,7 @@ def wrap_defined_methods(klass, target)
         # @api private
         module InstanceMixin
           # @api private
+          # @rbs (Class | Module object) -> void
           def extended(object)
             super
 

lib/dry/monads/lazy.rb

@@ -27,25 +27,29 @@ def new(promise = nil, &)
       # Forces the compution and returns its value.
       #
       # @return [Object]
+      # @rbs () -> Object
       def value! = @promise.execute.value!
       alias_method :force!, :value!
 
       # Forces the computation. Note that if the computation
       # thrown an error it won't be re-raised as opposed to value!/force!.
       #
       # @return [Lazy]
+      # @rbs () -> Lazy
       def force
         @promise.execute
         self
       end
 
       # @return [Boolean]
+      # @rbs () -> bool
       def evaluated? = @promise.complete?
       deprecate :complete?, :evaluated?
 
       undef_method :wait
 
       # @return [String]
+      # @rbs () -> String
       def to_s
         state =
           case promise.state
@@ -76,6 +80,7 @@ module Constructors
           #
           # @param block [Proc]
           # @return [Lazy]
+          # @rbs () {(?) -> __todo__ } -> Lazy
           def Lazy(&) = Lazy.new(&)
         end
 

sig/dry/monads.rbs

@@ -0,0 +1,46 @@
+
+
+module Dry
+  # Common, idiomatic monads for Ruby
+  #
+  # @api public
+  module Monads
+    # @api private
+    def self.loader: () -> Zietwerk::Loader
+
+    # @private
+    def self.included: (Class | Module base) -> void
+
+    # Build a module with cherry-picked monads.
+    # It saves a bit of typing when you add multiple
+    # monads to one class. Not loaded monads get loaded automatically.
+    #
+    # @example
+    #   require 'dry/monads'
+    #
+    #   class CreateUser
+    #     include Dry::Monads[:result, :do]
+    #
+    #     def initialize(repo, send_email)
+    #       @repo = repo
+    #       @send_email = send_email
+    #     end
+    #
+    #     def call(name)
+    #       if @repo.user_exist?(name)
+    #         Failure(:user_exists)
+    #       else
+    #         user = yield @repo.add_user(name)
+    #         yield @send_email.(user)
+    #         Success(user)
+    #       end
+    #     end
+    #   end
+    #
+    # @param [Array<Symbol>] monads
+    # @return [Module]
+    # @api public
+    def self.[]: (*Symbol monads) -> Module
+  end
+end
+

sig/dry/monads/all.rbs

@@ -0,0 +1,7 @@
+
+
+module Dry
+  module Monads
+  end
+end
+

sig/dry/monads/constants.rbs

@@ -0,0 +1,8 @@
+
+
+module Dry
+  module Monads
+    include Core::Constants
+  end
+end
+