mangrove 0.1.0

data/lib/mangrove/result.rb

@@ -0,0 +1,167 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "result/control_signal"
+
+module Mangrove
+  # Result is a type that represents either success (`Ok`) or failure (`Err`).
+  module Result
+    extend T::Sig
+    extend T::Generic
+    extend T::Helpers
+
+    include Kernel
+
+    sealed!
+    interface!
+
+    OkType = type_member
+    ErrType = type_member
+
+    # Mangrove::Result::Ok
+    class Ok
+      extend T::Sig
+      extend T::Generic
+      extend T::Helpers
+
+      include Result
+
+      OkType = type_member
+      ErrType = type_member
+
+      sig { params(inner: OkType).void }
+      def initialize(inner)
+        @inner = inner
+      end
+
+      sig { override.params(other: BasicObject).returns(T::Boolean) }
+      def ==(other)
+        case other
+        when Result::Ok
+          other.instance_variable_get(:@inner) == @inner
+        when Result::Err
+          false
+        else
+          false
+        end
+      end
+
+      sig { returns(OkType) }
+      def unwrap
+        @inner
+      end
+
+      sig { override.returns(OkType) }
+      def unwrap!
+        @inner
+      end
+
+      sig { override.params(_message: String).returns(OkType) }
+      def expect!(_message)
+        @inner
+      end
+
+      sig { override.returns(T::Boolean) }
+      def ok? = true
+
+      sig { override.returns(T::Boolean) }
+      def err? = false
+
+      sig { override.params(block: T.proc.params(this: OkType).returns(Result[OkType, ErrType])).returns(Result[OkType, ErrType]) }
+      def map_ok(&block)
+        block.call(@inner)
+      end
+
+      sig { override.params(_block: T.proc.params(this: ErrType).returns(Result[OkType, ErrType])).returns(Result[OkType, ErrType]) }
+      def map_err(&_block)
+        self
+      end
+    end
+
+    # Mangrove::Result::Err
+    class Err
+      extend T::Sig
+      extend T::Generic
+      extend T::Helpers
+
+      include Result
+
+      OkType = type_member
+      ErrType = type_member
+
+      sig { params(inner: ErrType).void }
+      def initialize(inner)
+        @inner = inner
+      end
+
+      sig { override.params(other: BasicObject).returns(T::Boolean) }
+      def ==(other)
+        case other
+        when Result::Ok
+          false
+        when Result::Err
+          other.instance_variable_get(:@inner) == @inner
+        else
+          false
+        end
+      end
+
+      sig { override.returns(OkType) }
+      def unwrap!
+        raise Result::ControlSignal, Result::Err.new("called `Result#unwrap!` on an `Err` value: #{self}")
+      end
+
+      sig { override.params(message: String).returns(OkType) }
+      def expect!(message)
+        raise Result::ControlSignal, Result::Err.new(message)
+      end
+
+      sig { override.returns(T::Boolean) }
+      def ok? = false
+
+      sig { override.returns(T::Boolean) }
+      def err? = true
+
+      sig do
+        override.params(_block: T.proc.params(this: OkType).returns(Result[OkType, ErrType])).returns(Result[OkType, ErrType])
+      end
+      def map_ok(&_block)
+        self
+      end
+
+      sig do
+        override.params(block: T.proc.params(this: ErrType).returns(Result[OkType, ErrType])).returns(Result[OkType, ErrType])
+      end
+      def map_err(&block)
+        block.call(@inner)
+      end
+    end
+
+    sig { abstract.params(other: BasicObject).returns(T::Boolean) }
+    def ==(other); end
+
+    sig { abstract.returns(T::Boolean) }
+    def ok?; end
+
+    sig { abstract.returns(T::Boolean) }
+    def err?; end
+
+    sig { abstract.returns(OkType) }
+    def unwrap!; end
+
+    sig { abstract.params(message: String).returns(OkType) }
+    def expect!(message); end
+
+    sig do
+      abstract.params(block: T.proc.params(this: OkType).returns(Result[OkType,
+                                                                        ErrType])).returns(Result[OkType, ErrType])
+    end
+    def map_ok(&block); end
+
+    sig do
+      abstract.params(block: T.proc.params(this: ErrType).returns(Result[OkType,
+                                                                         ErrType])).returns(Result[OkType, ErrType])
+    end
+    def map_err(&block); end
+  end
+end

data/lib/mangrove/version.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mangrove
+  VERSION = "0.1.0"
+end

data/lib/mangrove.rb

@@ -0,0 +1,8 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require_relative "mangrove/version"
+
+# Mangrove
+module Mangrove; end

data/sig/mangrove.rbs

@@ -0,0 +1,4 @@
+module Mangrove
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/

data/sorbet/rbi/annotations/rainbow.rbi

@@ -0,0 +1,269 @@
+# typed: true
+
+# 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