dry-monads-sorbet 1.1.0.pre.6 → 1.1.0.pre.11

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 01a587a745c74e7403e001687906bb86f47f9207f421078129bc6725ffae6727
4
- data.tar.gz: 6282cf4854b839968987673dbca89c225e0d24c8d8b84361216fc84b25e981a7
3
+ metadata.gz: dc959005a547da04b1abb2c034035c42d38bf090e0b9655b27cf043f7fcc4b10
4
+ data.tar.gz: 18237d14463293d2b09050e4ef18195c1e78517316b57bd7ee685a2834f25d65
5
5
  SHA512:
6
- metadata.gz: 3559837cf125ff9c02ba899bd141b56d788fe7b4c435250d8a6852629a9be050aadcd503224f18acf29faaaeebef79c3396d85fff5d6c5152764b63708c34455
7
- data.tar.gz: 732d53844aa4998458378508e0edf2826f7b078617a42b557e8dc5c9c66812cb4646710cff36d1b00edcaed6c891e26bd0e698184f127c901ec1a91d89cd85c5
6
+ metadata.gz: 633bfd82f597a03899c183813972cd78db85f06445322f6c8ad2477de44b5f40101f7c28dbd987cb1b3547b6f40c3436594a49b23e8b7e1dc7026d19d8d28fa6
7
+ data.tar.gz: 8d3f1acb482d1122e9b5b9c1099593cf4cca8f5daee8872ab7d263705079c4a8ed530c3cdc7af62e5c045086c1c9fe7b2134c70cb3eb537e73355b67a3799ae3
data/README.md CHANGED
@@ -4,10 +4,40 @@
4
4
 
5
5
  Sorbet type hints for Dry::Monads.
6
6
 
7
- ## Install
7
+ ## Installation
8
+
9
+ Add the gem to your Gemfile:
8
10
 
9
11
  `gem 'dry-monads-sorbet'`
10
12
 
13
+ ### Copying the bundled RBI
14
+
15
+ You must copy in the bundled `.rbi` file that this gem maintains to add type annotations to your own project to type check your usage of `Dry::Monads`.
16
+
17
+ Following in the footsteps of `sorbet-rails` we've extracted this process to a rake task.
18
+
19
+ ### In a Rails project:
20
+
21
+ The rake task that copies the bundled `.rbi` files into your project should already be loaded. You can run it by entering:
22
+
23
+ ```bash
24
+ bundle exec rake dry_monads_sorbet:update_rbi
25
+ ```
26
+
27
+ ### Outside of Rail's projects:
28
+
29
+ Include the `Rakefile` in your own projects `Rakefile` to get access to the rbi update command:
30
+
31
+ ```ruby
32
+ require 'dry-monads-sorbet'
33
+
34
+ spec = Gem::Specification.find_by_name 'dry-monads-sorbet'
35
+ rakefile = "#{spec.gem_dir}/lib/dry-monads-sorbet/Rakefile"
36
+ load rakefile
37
+ ```
38
+
39
+ After including the Rakefile you should then have access to the task as described in the Rails project section.
40
+
11
41
  ## Usage
12
42
 
13
43
  ```ruby
@@ -1,7 +1,8 @@
1
1
  # typed: strong
2
2
  #
3
- # dry-monads-1.3.1
4
- #
3
+ # Any changes to the type annotations for Dry::Monads should be made
4
+ # in the dry-monads-sorbet gem itself in its bundled_rbi directory.
5
+
5
6
  module Dry
6
7
  end
7
8
  module Dry::Monads
@@ -594,3 +595,512 @@ class Dry::Monads::Result::Fixed < Module
594
595
  def initialize(error, **options); end
595
596
  def self.[](error, **options); end
596
597
  end
598
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
599
+ # srb rbi gems
600
+
601
+ # typed: true
602
+ #
603
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
604
+ #
605
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/dry-monads/all/dry-monads.rbi
606
+ #
607
+ # dry-monads-1.3.5
608
+ module Dry
609
+ end
610
+ module Dry::Monads
611
+ def self.Result(error, **options); end
612
+ def self.[](*monads); end
613
+ def self.all_loaded?; end
614
+ def self.constructors; end
615
+ def self.included(base); end
616
+ def self.known_monads; end
617
+ def self.load_monad(name); end
618
+ def self.register_mixin(name, mod); end
619
+ def self.registry; end
620
+ def self.registry=(registry); end
621
+ extend Dry::Monads::Maybe::Mixin::Constructors
622
+ extend Dry::Monads::Maybe::Mixin::Constructors
623
+ extend Dry::Monads::Result::Mixin::Constructors
624
+ extend Dry::Monads::Validated::Mixin::Constructors
625
+ include Dry::Core::Constants
626
+ end
627
+ module Dry::Monads::Curry
628
+ def self.call(value); end
629
+ end
630
+ class Dry::Monads::UnwrapError < StandardError
631
+ def initialize(ctx); end
632
+ end
633
+ class Dry::Monads::InvalidFailureTypeError < StandardError
634
+ def initialize(failure); end
635
+ end
636
+ class Dry::Monads::ConstructorNotAppliedError < NoMethodError
637
+ def initialize(method_name, constructor_name); end
638
+ end
639
+ module Dry::Monads::RightBiased
640
+ end
641
+ module Dry::Monads::RightBiased::Right
642
+ def ===(other); end
643
+ def and(mb); end
644
+ def apply(val = nil); end
645
+ def bind(*args, **kwargs); end
646
+ def curry; end
647
+ def deconstruct; end
648
+ def deconstruct_keys(keys); end
649
+ def destructure(*args, **kwargs); end
650
+ def discard; end
651
+ def flatten; end
652
+ def fmap(*arg0); end
653
+ def or(*arg0); end
654
+ def or_fmap(*arg0); end
655
+ def self.included(m); end
656
+ def tee(*args, &block); end
657
+ def value!; end
658
+ def value_or(_val = nil); end
659
+ end
660
+ module Dry::Monads::RightBiased::Left
661
+ def and(_); end
662
+ def apply(*arg0); end
663
+ def bind(*arg0); end
664
+ def deconstruct; end
665
+ def deconstruct_keys(keys); end
666
+ def discard; end
667
+ def flatten; end
668
+ def fmap(*arg0); end
669
+ def or(*arg0); end
670
+ def or_fmap(*arg0); end
671
+ def self.trace_caller; end
672
+ def tee(*arg0); end
673
+ def value!; end
674
+ def value_or(val = nil); end
675
+ end
676
+ module Dry::Monads::Transformer
677
+ def fmap2(*args); end
678
+ def fmap3(*args); end
679
+ end
680
+ class Dry::Monads::Maybe
681
+ def failure?; end
682
+ def monad; end
683
+ def none?; end
684
+ def self.coerce(value); end
685
+ def self.lift(*args, &block); end
686
+ def self.pure(value = nil, &block); end
687
+ def self.to_proc; end
688
+ def some?; end
689
+ def success?; end
690
+ def to_maybe; end
691
+ def to_monad; end
692
+ include Dry::Monads::Transformer
693
+ end
694
+ class Dry::Monads::Maybe::Some < Dry::Monads::Maybe
695
+ def fmap(*args, &block); end
696
+ def initialize(value = nil); end
697
+ def inspect; end
698
+ def maybe(*args, &block); end
699
+ def self.[](*value); end
700
+ def self.call(*arg0); end
701
+ def self.to_proc; end
702
+ def to_result(_fail = nil); end
703
+ def to_s; end
704
+ include Anonymous_Dry_Equalizer_40
705
+ include Dry::Equalizer::Methods
706
+ include Dry::Monads::RightBiased::Right
707
+ end
708
+ module Anonymous_Dry_Equalizer_40
709
+ def cmp?(comparator, other); end
710
+ def hash; end
711
+ def inspect; end
712
+ end
713
+ class Dry::Monads::Maybe::None < Dry::Monads::Maybe
714
+ def ==(other); end
715
+ def deconstruct; end
716
+ def eql?(other); end
717
+ def hash; end
718
+ def initialize(trace = nil); end
719
+ def inspect; end
720
+ def maybe(*arg0); end
721
+ def or(*args); end
722
+ def or_fmap(*args, &block); end
723
+ def self.instance; end
724
+ def self.method_missing(m, *arg1); end
725
+ def to_result(fail = nil); end
726
+ def to_s; end
727
+ def trace; end
728
+ include Dry::Monads::RightBiased::Left
729
+ end
730
+ module Dry::Monads::Maybe::Mixin
731
+ include Dry::Monads::Maybe::Mixin::Constructors
732
+ end
733
+ module Dry::Monads::Maybe::Mixin::Constructors
734
+ def Maybe(value); end
735
+ def None; end
736
+ def Some(value = nil, &block); end
737
+ end
738
+ module Dry::Monads::Maybe::Hash
739
+ def self.all(hash, trace = nil); end
740
+ def self.filter(hash); end
741
+ end
742
+ class Dry::Monads::Result
743
+ def failure; end
744
+ def monad; end
745
+ def self.pure(value = nil, &block); end
746
+ def success; end
747
+ def to_monad; end
748
+ def to_result; end
749
+ include Anonymous_Module_41
750
+ include Dry::Monads::Transformer
751
+ end
752
+ class Dry::Monads::Result::Success < Dry::Monads::Result
753
+ def either(f, _); end
754
+ def failure?; end
755
+ def flip; end
756
+ def fmap(*args, &block); end
757
+ def initialize(value); end
758
+ def inspect; end
759
+ def result(_, f); end
760
+ def self.[](*value); end
761
+ def self.call(*arg0); end
762
+ def self.to_proc; end
763
+ def success; end
764
+ def success?; end
765
+ def to_maybe; end
766
+ def to_s; end
767
+ def to_validated; end
768
+ include Anonymous_Dry_Equalizer_42
769
+ include Dry::Equalizer::Methods
770
+ include Dry::Monads::RightBiased::Right
771
+ end
772
+ class Dry::Monads::Result::Failure < Dry::Monads::Result
773
+ def ===(other); end
774
+ def either(_, g); end
775
+ def failure; end
776
+ def failure?; end
777
+ def flip; end
778
+ def initialize(value, trace = nil); end
779
+ def inspect; end
780
+ def or(*args); end
781
+ def or_fmap(*args, &block); end
782
+ def result(f, _); end
783
+ def self.[](*value); end
784
+ def self.call(*arg0); end
785
+ def self.to_proc; end
786
+ def success?; end
787
+ def to_maybe; end
788
+ def to_s; end
789
+ def to_validated; end
790
+ def trace; end
791
+ def value_or(val = nil); end
792
+ include Anonymous_Dry_Equalizer_43
793
+ include Dry::Equalizer::Methods
794
+ include Dry::Monads::RightBiased::Left
795
+ end
796
+ class Dry::Monads::Task
797
+ def ==(other); end
798
+ def apply(val = nil); end
799
+ def bind(&block); end
800
+ def compare_promises(x, y); end
801
+ def complete?; end
802
+ def curry(value); end
803
+ def discard; end
804
+ def fmap(&block); end
805
+ def initialize(promise); end
806
+ def inspect; end
807
+ def monad; end
808
+ def or(&block); end
809
+ def or_fmap(&block); end
810
+ def promise; end
811
+ def self.[](executor, &block); end
812
+ def self.failed(exc); end
813
+ def self.new(promise = nil, &block); end
814
+ def self.pure(value = nil, &block); end
815
+ def then(&block); end
816
+ def to_maybe; end
817
+ def to_monad; end
818
+ def to_result; end
819
+ def to_s; end
820
+ def value!; end
821
+ def value_or(&block); end
822
+ def wait(timeout = nil); end
823
+ include Anonymous_Module_44
824
+ end
825
+ class Dry::Monads::Try
826
+ def error?; end
827
+ def exception; end
828
+ def failure?; end
829
+ def self.[](*exceptions, &block); end
830
+ def self.lift(*args, &block); end
831
+ def self.pure(value = nil, exceptions = nil, &block); end
832
+ def self.run(exceptions, f); end
833
+ def success?; end
834
+ def to_monad; end
835
+ def value?; end
836
+ include Anonymous_Module_45
837
+ end
838
+ class Dry::Monads::Try::Value < Dry::Monads::Try
839
+ def bind(*args); end
840
+ def bind_call(*args, **kwargs); end
841
+ def catchable; end
842
+ def fmap(*args, &block); end
843
+ def initialize(exceptions, value); end
844
+ def inspect; end
845
+ def self.call(*arg0); end
846
+ def self.to_proc; end
847
+ def to_maybe; end
848
+ def to_result; end
849
+ def to_s; end
850
+ include Anonymous_Dry_Equalizer_46
851
+ include Dry::Equalizer::Methods
852
+ include Dry::Monads::RightBiased::Right
853
+ end
854
+ class Dry::Monads::Try::Error < Dry::Monads::Try
855
+ def ===(other); end
856
+ def initialize(exception); end
857
+ def inspect; end
858
+ def or(*args); end
859
+ def self.call(*arg0); end
860
+ def to_maybe; end
861
+ def to_result; end
862
+ def to_s; end
863
+ include Anonymous_Dry_Equalizer_47
864
+ include Dry::Equalizer::Methods
865
+ include Dry::Monads::RightBiased::Left
866
+ end
867
+ class Dry::Monads::Validated
868
+ def bind(*arg0); end
869
+ def self.pure(value = nil, &block); end
870
+ def to_monad; end
871
+ include Anonymous_Module_48
872
+ end
873
+ class Dry::Monads::Validated::Valid < Dry::Monads::Validated
874
+ def ===(other); end
875
+ def alt_map(_ = nil); end
876
+ def apply(val = nil); end
877
+ def fmap(proc = nil, &block); end
878
+ def initialize(value); end
879
+ def inspect; end
880
+ def or(_ = nil); end
881
+ def to_maybe; end
882
+ def to_result; end
883
+ def to_s; end
884
+ def value!; end
885
+ include Anonymous_Dry_Equalizer_49
886
+ include Dry::Equalizer::Methods
887
+ end
888
+ class Dry::Monads::Validated::Invalid < Dry::Monads::Validated
889
+ def ===(other); end
890
+ def alt_map(proc = nil, &block); end
891
+ def apply(val = nil); end
892
+ def error; end
893
+ def fmap(_ = nil); end
894
+ def initialize(error, trace = nil); end
895
+ def inspect; end
896
+ def or(proc = nil, &block); end
897
+ def to_maybe; end
898
+ def to_result; end
899
+ def to_s; end
900
+ def trace; end
901
+ include Anonymous_Dry_Equalizer_50
902
+ include Dry::Equalizer::Methods
903
+ end
904
+ module Dry::Monads::ConversionStubs
905
+ def self.[](*method_names); end
906
+ end
907
+ module Dry::Monads::ConversionStubs::Methods
908
+ def self.to_maybe; end
909
+ def self.to_result; end
910
+ def self.to_validated; end
911
+ def to_maybe; end
912
+ def to_result; end
913
+ def to_validated; end
914
+ end
915
+ class Dry::Monads::Task::Promise < Concurrent::Promise
916
+ def on_fulfill(result); end
917
+ def on_reject(reason); end
918
+ end
919
+ module Anonymous_Module_44
920
+ def to_maybe(*arg0); end
921
+ def to_result(*arg0); end
922
+ end
923
+ module Dry::Monads::Task::Mixin
924
+ def self.[](executor); end
925
+ include Dry::Monads::Task::Mixin::Constructors
926
+ end
927
+ module Dry::Monads::Task::Mixin::Constructors
928
+ def Task(&block); end
929
+ end
930
+ module Anonymous_Module_41
931
+ def to_maybe(*arg0); end
932
+ def to_validated(*arg0); end
933
+ end
934
+ module Anonymous_Dry_Equalizer_42
935
+ def cmp?(comparator, other); end
936
+ def hash; end
937
+ def inspect; end
938
+ end
939
+ module Anonymous_Dry_Equalizer_43
940
+ def cmp?(comparator, other); end
941
+ def hash; end
942
+ def inspect; end
943
+ end
944
+ module Dry::Monads::Result::Mixin
945
+ include Dry::Monads::Result::Mixin::Constructors
946
+ end
947
+ module Dry::Monads::Result::Mixin::Constructors
948
+ def Failure(value = nil, &block); end
949
+ def Success(value = nil, &block); end
950
+ end
951
+ module Anonymous_Module_45
952
+ def to_maybe(*arg0); end
953
+ def to_result(*arg0); end
954
+ end
955
+ module Anonymous_Dry_Equalizer_46
956
+ def cmp?(comparator, other); end
957
+ def hash; end
958
+ def inspect; end
959
+ end
960
+ module Anonymous_Dry_Equalizer_47
961
+ def cmp?(comparator, other); end
962
+ def hash; end
963
+ def inspect; end
964
+ end
965
+ module Dry::Monads::Try::Mixin
966
+ def Error(error = nil, &block); end
967
+ def Value(value = nil, exceptions = nil, &block); end
968
+ include Dry::Monads::Try::Mixin::Constructors
969
+ end
970
+ module Dry::Monads::Try::Mixin::Constructors
971
+ def Try(*exceptions, &f); end
972
+ end
973
+ module Anonymous_Module_48
974
+ def to_maybe(*arg0); end
975
+ def to_result(*arg0); end
976
+ end
977
+ module Anonymous_Dry_Equalizer_49
978
+ def cmp?(comparator, other); end
979
+ def hash; end
980
+ def inspect; end
981
+ end
982
+ module Anonymous_Dry_Equalizer_50
983
+ def cmp?(comparator, other); end
984
+ def hash; end
985
+ def inspect; end
986
+ end
987
+ module Dry::Monads::Validated::Mixin
988
+ include Dry::Monads::Validated::Mixin::Constructors
989
+ end
990
+ module Dry::Monads::Validated::Mixin::Constructors
991
+ def Invalid(value = nil, &block); end
992
+ def Valid(value = nil, &block); end
993
+ end
994
+ class Dry::Monads::List
995
+ def +(other); end
996
+ def apply(list = nil); end
997
+ def bind(*args); end
998
+ def coerce(other); end
999
+ def collect; end
1000
+ def deconstruct; end
1001
+ def empty?; end
1002
+ def filter; end
1003
+ def first; end
1004
+ def fmap(*args); end
1005
+ def fold_left(initial); end
1006
+ def fold_right(initial); end
1007
+ def foldl(initial); end
1008
+ def foldr(initial); end
1009
+ def head; end
1010
+ def initialize(value, type = nil); end
1011
+ def inspect; end
1012
+ def last; end
1013
+ def map(&block); end
1014
+ def monad; end
1015
+ def reduce(initial); end
1016
+ def reverse; end
1017
+ def select; end
1018
+ def self.[](*values); end
1019
+ def self.coerce(value, type = nil); end
1020
+ def self.pure(value = nil, type = nil, &block); end
1021
+ def self.unfold(state, type = nil); end
1022
+ def size; end
1023
+ def sort; end
1024
+ def tail; end
1025
+ def to_a; end
1026
+ def to_ary; end
1027
+ def to_monad; end
1028
+ def to_s; end
1029
+ def traverse(proc = nil, &block); end
1030
+ def type; end
1031
+ def typed(type = nil); end
1032
+ def typed?; end
1033
+ def value; end
1034
+ extend Anonymous_Dry_Core_Deprecations_Tagged_51
1035
+ extend Dry::Core::Deprecations::Interface
1036
+ include Anonymous_Dry_Equalizer_52
1037
+ include Dry::Equalizer::Methods
1038
+ include Dry::Monads::Transformer
1039
+ end
1040
+ module Anonymous_Dry_Core_Deprecations_Tagged_51
1041
+ end
1042
+ module Anonymous_Dry_Equalizer_52
1043
+ def cmp?(comparator, other); end
1044
+ def hash; end
1045
+ def inspect; end
1046
+ end
1047
+ class Dry::Monads::List::ListBuilder
1048
+ def [](*args); end
1049
+ def coerce(value); end
1050
+ def initialize(type); end
1051
+ def pure(val = nil, &block); end
1052
+ def self.[](*arg0); end
1053
+ def type; end
1054
+ end
1055
+ module Dry::Monads::List::Mixin
1056
+ def List(value); end
1057
+ end
1058
+ module Dry::Monads::Do
1059
+ def self.coerce_to_monad(monads); end
1060
+ def self.for(*methods); end
1061
+ def self.halt(result); end
1062
+ def self.included(base); end
1063
+ def self.wrap_method(target, method_name); end
1064
+ extend Dry::Monads::Do::Mixin
1065
+ end
1066
+ module Dry::Monads::Do::Mixin
1067
+ def bind(monads); end
1068
+ def call; end
1069
+ end
1070
+ class Dry::Monads::Do::Halt < StandardError
1071
+ def initialize(result); end
1072
+ def result; end
1073
+ end
1074
+ module Dry::Monads::Do::All
1075
+ def self.included(base); end
1076
+ extend Dry::Monads::Do::All::InstanceMixin
1077
+ end
1078
+ class Dry::Monads::Do::All::MethodTracker < Module
1079
+ def extend_object(target); end
1080
+ def initialize(wrappers); end
1081
+ def wrap_method(target, method); end
1082
+ def wrappers; end
1083
+ end
1084
+ module Dry::Monads::Do::All::InstanceMixin
1085
+ def extended(object); end
1086
+ end
1087
+ class Dry::Monads::Lazy < Dry::Monads::Task
1088
+ def force!; end
1089
+ def force; end
1090
+ def inspect; end
1091
+ def self.[](executor, &block); end
1092
+ def self.new(promise = nil, &block); end
1093
+ def to_s; end
1094
+ def value!; end
1095
+ end
1096
+ module Dry::Monads::Lazy::Mixin
1097
+ include Dry::Monads::Lazy::Mixin::Constructors
1098
+ end
1099
+ module Dry::Monads::Lazy::Mixin::Constructors
1100
+ def Lazy(&block); end
1101
+ end
1102
+ class Dry::Monads::Result::Fixed < Module
1103
+ def included(base); end
1104
+ def initialize(error, **_options); end
1105
+ def self.[](error, **options); end
1106
+ end
@@ -2,3 +2,4 @@
2
2
 
3
3
  require 'dry/monads/all'
4
4
  require 'dry/monads/sorbet'
5
+ require 'dry-monads-sorbet/railtie' if defined?(Rails)
@@ -0,0 +1,2 @@
1
+ path = File.expand_path(__dir__)
2
+ Dir.glob("#{path}/tasks/**/*.rake").each { |f| import f }
@@ -0,0 +1,14 @@
1
+ # frozen_string_literal: true
2
+
3
+ require 'rails'
4
+
5
+ module DryMonadsSorbet
6
+ class Railtie < Rails::Railtie
7
+ railtie_name 'dry-monads-sorbet'
8
+
9
+ rake_tasks do
10
+ path = File.expand_path(__dir__)
11
+ Dir.glob("#{path}/tasks/**/*.rake").each { |f| load f }
12
+ end
13
+ end
14
+ end
@@ -0,0 +1,23 @@
1
+ require 'dry-monads-sorbet'
2
+
3
+ DRY_MONADS_SORBET_RAKE_DIR = File.dirname(__FILE__)
4
+
5
+ namespace :dry_monads_sorbet do
6
+ task :update_rbi, :environment do |t, args|
7
+ FileUtils.rm_rf(dry_monads_sorbet_rbi_path)
8
+
9
+ copy_bundled_rbi('dry-monads.rbi')
10
+ end
11
+
12
+ def dry_monads_sorbet_rbi_path
13
+ Rake.original_dir.join('sorbet', 'dry-monads-sorbet')
14
+ end
15
+
16
+ def copy_bundled_rbi(filename)
17
+ puts "Copy bundled file #{filename}"
18
+ bundled_rbi_file_path = File.join(DRY_MONADS_SORBET_RAKE_DIR, '..', '..', 'bundled_rbi', filename)
19
+ copy_to_path = dry_monads_sorbet_rbi_path.join(filename)
20
+ FileUtils.mkdir_p(File.dirname(copy_to_path))
21
+ FileUtils.cp(bundled_rbi_file_path, copy_to_path)
22
+ end
23
+ end
@@ -3,7 +3,7 @@
3
3
  module Dry
4
4
  module Monads
5
5
  module Sorbet
6
- VERSION = '1.1.0.pre.6'
6
+ VERSION = '1.1.0.pre.11'
7
7
  end
8
8
  end
9
9
  end
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: dry-monads-sorbet
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.1.0.pre.6
4
+ version: 1.1.0.pre.11
5
5
  platform: ruby
6
6
  authors:
7
7
  - Luke Worth
@@ -129,10 +129,13 @@ files:
129
129
  - bin/console
130
130
  - bin/setup
131
131
  - dry-monads-sorbet.gemspec
132
+ - lib/bundled_rbi/dry-monads.rbi
132
133
  - lib/dry-monads-sorbet.rb
134
+ - lib/dry-monads-sorbet/Rakefile
135
+ - lib/dry-monads-sorbet/railtie.rb
136
+ - lib/dry-monads-sorbet/tasks/dry_monads_sorbet.rake
133
137
  - lib/dry/monads/sorbet.rb
134
138
  - lib/dry/monads/sorbet/version.rb
135
- - rbi/dry-monads-sorbet.rbi
136
139
  homepage: https://github.com/tricycle/dry-monads-sorbet
137
140
  licenses:
138
141
  - MIT