mocktail 1.2.3 → 3.0.0

data/rbi/mocktail.rbi

@@ -0,0 +1,77 @@
+# typed: true
+
+class Mocktail::MatcherPresentation
+  sig {
+    returns(T.untyped)
+  }
+  def any
+  end
+
+  sig {
+    type_parameters(:T)
+      .params(expected: T::Class[T.type_parameter(:T)])
+      .returns(T.type_parameter(:T))
+  }
+  def is_a(expected)
+  end
+
+  sig {
+    type_parameters(:T)
+      .params(expecteds: T.type_parameter(:T))
+      .returns(T::Array[T.type_parameter(:T)])
+  }
+  def includes(*expecteds)
+  end
+
+  sig {
+    type_parameters(:T)
+      .params(expecteds: T.type_parameter(:T))
+      .returns(T.type_parameter(:T))
+  }
+  def includes_string(*expecteds)
+  end
+
+  sig {
+    type_parameters(:K, :V)
+      .params(expecteds: T::Hash[T.type_parameter(:K), T.type_parameter(:V)])
+      .returns(T::Hash[T.type_parameter(:K), T.type_parameter(:V)])
+  }
+  def includes_hash(*expecteds)
+  end
+
+  sig {
+    type_parameters(:K, :V)
+      .params(expecteds: T.type_parameter(:K))
+      .returns(T::Hash[T.type_parameter(:K), T.type_parameter(:V)])
+  }
+  def includes_key(*expecteds)
+  end
+
+  sig {
+    params(pattern: T.any(String, Regexp)).returns(String)
+  }
+  def matches(pattern)
+  end
+
+  sig {
+    returns(T.untyped)
+  }
+  def numeric
+  end
+
+  sig {
+    params(
+      blk: T.proc.params(arg: T.untyped).returns(T::Boolean)
+    ).returns(T.untyped)
+  }
+  def that(&blk)
+  end
+
+  sig {
+    type_parameters(:T)
+      .params(unexpected: T.type_parameter(:T))
+      .returns(T.type_parameter(:T))
+  }
+  def not(unexpected)
+  end
+end

data/rbi/sorbet-runtime.rbi

@@ -0,0 +1,29 @@
+# typed: true
+
+# sorbet gem fails to export some of these constants, so we need to in order to
+# pass static typecheck
+module T
+  module Private
+    module RuntimeLevels
+      class << self
+        sig { returns(Symbol) }
+        def default_checked_level
+        end
+      end
+    end
+
+    module Methods
+      class Signature
+        sig { returns(T::Array[T::Array[Symbol]]) }
+        def parameters
+        end
+      end
+
+      module MethodHooks
+      end
+
+      module SingletonMethodHooks
+      end
+    end
+  end
+end

data/script/build

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+
+set -xeuo pipefail
+
+echo "-----> Deleting lib/ and copying src/ to lib/"
+rm -rf lib
+cp -r src/ lib
+
+echo "-----> Erasing sorbet sigs from lib/ (for non-Sorbet users)"
+bundle exec sorbet-eraser "lib/**/*.rb"
+echo "-----> Overwriting Mocktail::TYPED constant for lib/"
+cat << RUBY > lib/mocktail/typed.rb
+module Mocktail
+  TYPED = false
+end
+RUBY
+
+echo "-----> Erasing sorbet 'typed: ' sigils from lib/mocktail"
+./script/strip_sigils
+
+echo "-----> Copying src/ to lib/mocktail/sorbet/ (for Sorbet users)"
+cp -r src/ lib/mocktail/sorbet
+
+echo "-----> Running Standard against all code"
+bundle exec rake standard:fix
+
+echo "-----> Generating RBIs to publish with the gems"
+
+echo "----------> ❶ Faking out mocktail.rb and pointing it to mocktail/sorbet"
+mv lib/mocktail.rb lib/mocktail.rb.nope
+cat << RUBY > lib/mocktail.rb
+require_relative "mocktail/sorbet"
+RUBY
+
+echo "----------> ❷ Generating sorbet sigs via tapioca in sub_projects/rbi_generator"
+cd sub_projects/rbi_generator
+rm -f rbi/mocktail-pregenerated.rbi
+rm -f sorbet/rbi/gems/mocktail@*.rbi
+bundle
+bundle exec tapioca gem --all --exclude=tapioca ast diff-lcs erubi netrc parser prettier_print racc rbi spoom syntax_tree thor unparser sorbet yard parallel yard-sorbet
+cd ../..
+
+echo "----------> ❸ Moving the generated RBI to rbi/mocktail-pregenerated.rbi"
+cp sub_projects/rbi_generator/sorbet/rbi/gems/mocktail@*.rbi rbi/mocktail-pregenerated.rbi
+mv lib/mocktail.rb.nope lib/mocktail.rb
+
+

data/script/setup

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+set -xeuo pipefail
+
+bundle
+
+cd sub_projects/rbi_generator/
+bundle
+cd ../..
+
+cd sub_projects/sorbet_user/
+bundle
+cd ../..
+
+cd sub_projects/untyped_user/
+bundle
+cd ../..

data/script/spoom_me

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+set -xeuo pipefail
+
+bundle exec spoom coverage --save
+bundle exec spoom coverage report
+bundle exec spoom coverage open

data/script/strip_sigils

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+# Removes all the sigil comments from the top of our sorbet-free code
+
+# Find all files that start with "# typed" in the first line
+files=$(grep -rl '^# typed' --exclude-dir=lib/mocktail/sorbet lib/*)
+
+# Loop through each file and delete the first line
+for file in $files
+do
+    # Check if we're on a Mac
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        sed -i '' '1d' $file
+    else
+        sed -i '1d' $file
+    fi
+done

data/script/test

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+
+set -xeuo pipefail
+
+echo "-----> Running Mocktail's test against src"
+COVER=true bundle exec rake
+
+echo "-----> Type-checking Mocktail source"
+bundle exec srb tc
+
+echo "-----> Building src/mocktail into lib/mocktail and lib/mocktail/sorbet"
+./script/build
+
+echo "-----> Running Mocktail's test against lib"
+MOCKTAIL_TEST_SRC_DIRECTORY="lib" bundle exec rake
+
+echo "-----> Running Mocktail's test against lib/mocktail/sorbet"
+MOCKTAIL_TEST_SRC_DIRECTORY="lib/mocktail/sorbet" bundle exec rake
+
+echo "-----> Ensuring that double-requiring Mocktail produces the right warning and bails out of redefining constants"
+script/test_double_require_warnings
+
+echo "-----> Type-checking the copy of Mocktail in lib/mocktail/sorbet"
+bundle exec srb tc --ignore src/ --dir lib/mocktail/sorbet
+
+echo "-----> Running sample project tests"
+cd sub_projects/sorbet_user
+./script/test
+cd ../..
+
+cd sub_projects/untyped_user
+./script/test
+cd ../..

data/script/test_double_require_warnings

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+require "open3"
+
+def assert_warning(command:, warning:)
+  stdout, stderr, status = Open3.capture3(command)
+  # Ignore incidental Ruby/RubyGems/Bundler runtime warnings (e.g. from a
+  # Ruby version shipping a newer RubyGems than an older pinned Bundler
+  # expects) -- they always follow Ruby's "path:line: warning: message"
+  # format, unlike Mocktail's own warning below.
+  relevant_stderr = stderr.lines.reject { |line| line.match?(/\A\S+:\d+: warning: /) }.join
+  if relevant_stderr != warning
+    fail <<~MSG
+      Expected the correct error message on STDERR but it was wrong"
+
+      Expected:
+      #{warning}
+
+      Actual:
+      #{stderr}
+    MSG
+
+  end
+  fail "Expected empty STDOUT, but was #{stdout.inspect}" unless stdout.empty?
+  fail "Expected command to exit 0, but was #{status.exitstatus}" unless status.success?
+end
+
+puts "Test requiring 'mocktail' and then 'mocktail/sorbet' gives the right warning"
+assert_warning(
+  command: <<~CMD,
+    bundle exec ruby -e 'require "#{Dir.pwd}/lib/mocktail/sorbet"; require "#{Dir.pwd}/lib/mocktail"'
+  CMD
+  warning: <<~WARN
+    `require "mocktail"' was called, but Mocktail was already required as `require "mocktail/sorbet"', so we're NOT going to load it to avoid constants from being redefined. If you want to use Mocktail WITHOUT sorbet runtime checks, remove whatever is requiring `mocktail/sorbet'.
+  WARN
+)
+
+puts "Test requiring 'mocktail/sorbet' and then 'mocktail' gives the right warning"
+assert_warning(
+  command: <<~CMD,
+    bundle exec ruby -e 'require "#{Dir.pwd}/lib/mocktail"; require "#{Dir.pwd}/lib/mocktail/sorbet"'
+  CMD
+  warning: <<~WARN
+    `require "mocktail/sorbet"' was called, but Mocktail was already required as `require "mocktail"', so we're NOT going to load it to avoid constants from being redefined. If you want to use Mocktail WITH sorbet runtime checks, remove whatever is requiring `mocktail'.
+  WARN
+)

data/script/update

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+set -xeuo pipefail
+
+echo "-----> Updating root gems"
+bundle update
+
+echo "-----> Updating 'sub_projects/rbi_generator' gems"
+cd sub_projects/rbi_generator
+bundle update
+cd ../..
+
+echo "-----> Updating 'sub_projects/sorbet_user' gems"
+cd sub_projects/sorbet_user
+bundle update
+cd ../..
+
+echo "-----> Updating 'sub_projects/untyped_user' gems"
+cd sub_projects/untyped_user
+bundle update
+cd ../..

data/sorbet/config

@@ -0,0 +1,12 @@
+--dir
+.
+--ignore=tmp/
+--ignore=Rakefile
+--ignore=vendor/
+--ignore=sub_projects/sorbet_user/
+--ignore=sub_projects/rbi_generator/
+--ignore=lib/
+# Ignore b/c these stubs will confuse the typechecker and generate a bunch of errors, even tho #typed: false
+--ignore=test/support/sorbet_stubs.rb
+# Ignore b/c this pregenerated rbi is for consumers of the gem, not the gem itself
+--ignore=rbi/mocktail-pregenerated.rbi

data/sorbet/rbi/annotations/rainbow.rbi

@@ -0,0 +1,269 @@
+# typed: strict
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Rainbow
+  # @shim: https://github.com/sickill/rainbow/blob/master/lib/rainbow.rb#L10-L12
+  sig { returns(T::Boolean) }
+  attr_accessor :enabled
+
+  class Color
+    sig { returns(Symbol) }
+    attr_reader :ground
+
+    sig { params(ground: Symbol, values: T.any([Integer], [Integer, Integer, Integer])).returns(Color) }
+    def self.build(ground, values); end
+
+    sig { params(hex: String).returns([Integer, Integer, Integer]) }
+    def self.parse_hex_color(hex); end
+
+    class Indexed < Rainbow::Color
+      sig { returns(Integer) }
+      attr_reader :num
+
+      sig { params(ground: Symbol, num: Integer).void }
+      def initialize(ground, num); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+    end
+
+    class Named < Rainbow::Color::Indexed
+      NAMES = T.let(nil, T::Hash[Symbol, Integer])
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+
+    class RGB < Rainbow::Color::Indexed
+      sig { returns(Integer) }
+      attr_reader :r, :g, :b
+
+      sig { params(ground: Symbol, values: Integer).void }
+      def initialize(ground, *values); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+
+      sig { params(value: Numeric).returns(Integer) }
+      def self.to_ansi_domain(value); end
+    end
+
+    class X11Named < Rainbow::Color::RGB
+      include Rainbow::X11ColorNames
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+    end
+  end
+
+  sig { returns(Wrapper) }
+  def self.global; end
+
+  sig { returns(T::Boolean) }
+  def self.enabled; end
+
+  sig { params(value: T::Boolean).returns(T::Boolean) }
+  def self.enabled=(value); end
+
+  sig { params(string: String).returns(String) }
+  def self.uncolor(string); end
+
+  class NullPresenter < String
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def bg(*values); end
+
+    sig { returns(NullPresenter) }
+    def reset; end
+
+    sig { returns(NullPresenter) }
+    def bright; end
+
+    sig { returns(NullPresenter) }
+    def faint; end
+
+    sig { returns(NullPresenter) }
+    def italic; end
+
+    sig { returns(NullPresenter) }
+    def underline; end
+
+    sig { returns(NullPresenter) }
+    def blink; end
+
+    sig { returns(NullPresenter) }
+    def inverse; end
+
+    sig { returns(NullPresenter) }
+    def hide; end
+
+    sig { returns(NullPresenter) }
+    def cross_out; end
+
+    sig { returns(NullPresenter) }
+    def black; end
+
+    sig { returns(NullPresenter) }
+    def red; end
+
+    sig { returns(NullPresenter) }
+    def green; end
+
+    sig { returns(NullPresenter) }
+    def yellow; end
+
+    sig { returns(NullPresenter) }
+    def blue; end
+
+    sig { returns(NullPresenter) }
+    def magenta; end
+
+    sig { returns(NullPresenter) }
+    def cyan; end
+
+    sig { returns(NullPresenter) }
+    def white; end
+
+    sig { returns(NullPresenter) }
+    def bold; end
+
+    sig { returns(NullPresenter) }
+    def dark; end
+
+    sig { returns(NullPresenter) }
+    def strike; end
+  end
+
+  class Presenter < String
+    TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer])
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def bg(*values); end
+
+    sig { returns(Presenter) }
+    def reset; end
+
+    sig { returns(Presenter) }
+    def bright; end
+
+    sig { returns(Presenter) }
+    def faint; end
+
+    sig { returns(Presenter) }
+    def italic; end
+
+    sig { returns(Presenter) }
+    def underline; end
+
+    sig { returns(Presenter) }
+    def blink; end
+
+    sig { returns(Presenter) }
+    def inverse; end
+
+    sig { returns(Presenter) }
+    def hide; end
+
+    sig { returns(Presenter) }
+    def cross_out; end
+
+    sig { returns(Presenter) }
+    def black; end
+
+    sig { returns(Presenter) }
+    def red; end
+
+    sig { returns(Presenter) }
+    def green; end
+
+    sig { returns(Presenter) }
+    def yellow; end
+
+    sig { returns(Presenter) }
+    def blue; end
+
+    sig { returns(Presenter) }
+    def magenta; end
+
+    sig { returns(Presenter) }
+    def cyan; end
+
+    sig { returns(Presenter) }
+    def white; end
+
+    sig { returns(Presenter) }
+    def bold; end
+
+    sig { returns(Presenter) }
+    def dark; end
+
+    sig { returns(Presenter) }
+    def strike; end
+  end
+
+  class StringUtils
+    sig { params(string: String, codes: T::Array[Integer]).returns(String) }
+    def self.wrap_with_sgr(string, codes); end
+
+    sig { params(string: String).returns(String) }
+    def self.uncolor(string); end
+  end
+
+  VERSION = T.let(nil, String)
+
+  class Wrapper
+    sig { returns(T::Boolean) }
+    attr_accessor :enabled
+
+    sig { params(enabled: T::Boolean).void }
+    def initialize(enabled = true); end
+
+    sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) }
+    def wrap(string); end
+  end
+
+  module X11ColorNames
+    NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]])
+  end
+end
+
+sig { params(string: String).returns(Rainbow::Presenter) }
+def Rainbow(string); end