raap 0.3.0 → 0.4.0

data/lib/raap/type.rb

@@ -13,25 +13,37 @@ module RaaP
 
       def self.positive_float
         x = Random.rand
-        x / Math.sqrt(1 - x * x)
+        x / Math.sqrt(1 - (x * x))
       end
     end
 
     GENERATORS = {}
     SIMPLE_SOURCE = ('a'..'z').to_a << '_'
-    RECURSION = Hash.new { |h, k| h[k] = { count: 0, logged: false } }
 
     # Type.register "::Integer::positive" { sized { |size| size } }
     def self.register(type_name, &block)
       raise ArgumentError, "block is required" unless block
+
       GENERATORS[type_name] = __skip__ = block
     end
 
+    def self.random
+      Type.new("Integer | Float | Rational | Complex | String | Symbol | bool | Encoding | BasicObject | nil | Time")
+    end
+
+    def self.random_without_basic_object
+      random.tap do |r|
+        # @type var rtype: ::RBS::Types::Union
+        rtype = r.type
+        rtype.types.reject! { |t| t.to_s == "BasicObject" }
+      end
+    end
+
     # Special class case
     register("::Array") do
-      _type = __skip__ = type
-      t = _type.args[0] || 'untyped'
-      array(Type.new(t, range: range))
+      instance = __skip__ = type
+      t = instance.args[0] ? Type.new(instance.args[0], range:) : Type.random
+      array(t)
     end
     register("::Binding") { sized { binding } }
     register("::Complex") { complex }
@@ -40,14 +52,10 @@ module RaaP
     register("::FalseClass") { sized { false } }
     register("::Float") { float }
     register("::Hash") do
-      sized do |size|
-        Array.new(integer.pick(size: size).abs).to_h do
-          _type = __skip__ = type
-          k = _type.args[0] || 'untyped'
-          v = _type.args[1] || 'untyped'
-          [Type.new(k).pick(size: size), Type.new(v).pick(size: size)]
-        end
-      end
+      instance = __skip__ = type
+      key = instance.args[0] ? Type.new(instance.args[0]) : Type.random_without_basic_object
+      value = instance.args[1] ? Type.new(instance.args[1]) : Type.random
+      dict(key, value)
     end
     register("::Integer") { integer }
     register("::IO") { sized { $stdout } }
@@ -55,11 +63,11 @@ module RaaP
     register("::NilClass") { sized { nil } }
     register("::Proc") { sized { Proc.new {} } }
     register("::Rational") { rational }
-    register("::Regexp") { sized { |size| Regexp.new(string.pick(size: size)) } }
+    register("::Regexp") { sized { |size| Regexp.new(string.pick(size:)) } }
     register("::String") { string }
     register("::Struct") { sized { Struct.new(:foo, :bar).new } }
     register("::Symbol") { symbol }
-    register("::Time") { sized { Time.now } }
+    register("::Time") { sized { [:call, Time, :now, [], {}, nil] } }
     register("::TrueClass") { sized { true } }
     register("::UnboundMethod") { sized { temp_method_object.unbind } }
 
@@ -79,15 +87,18 @@ module RaaP
 
     def sized(&block)
       Sized.new(&block).tap do |sized|
-        if s = @such_that
+        if (s = @such_that)
           sized.such_that(&s)
         end
       end
     end
 
-    def pick(size: 10, eval: true)
-      symb = to_symbolic_call(size:)
-      eval ? SymbolicCaller.new(symb).eval : symb
+    def pick(size: 10)
+      to_symbolic_caller(size:).eval
+    end
+
+    def to_symbolic_caller(size: 10)
+      SymbolicCaller.new(to_symbolic_call(size:))
     end
 
     def to_symbolic_call(size: 10)
@@ -96,15 +107,23 @@ module RaaP
 
       case type
       when ::RBS::Types::Tuple
-        type.types.map { |t| Type.new(t).pick(size:) }
+        type.types.map { |t| Type.new(t).to_symbolic_call(size:) }
       when ::RBS::Types::Union
-        type.types.sample&.then { |t| Type.new(t).pick(size:) }
+        type.types.sample&.then { |t| Type.new(t).to_symbolic_call(size:) }
       when ::RBS::Types::Intersection
-        [:call, Value::Intersection, :new, [type], {size:}, nil]
+        if type.free_variables.empty?
+          [:call, Value::Intersection, :new, [type.to_s], { size: }, nil]
+        else
+          [:call, Value::Intersection, :new, [type], { size: }, nil]
+        end
       when ::RBS::Types::Interface
-        [:call, Value::Interface, :new, [type], {size:}, nil]
+        if type.free_variables.empty?
+          [:call, Value::Interface, :new, [type.to_s], { size: }, nil]
+        else
+          [:call, Value::Interface, :new, [type], { size: }, nil]
+        end
       when ::RBS::Types::Variable
-        [:call, Value::Variable, :new, [type], {}, nil]
+        [:call, Value::Variable, :new, [type.to_s], {}, nil]
       when ::RBS::Types::Bases::Void
         [:call, Value::Void, :new, [], {}, nil]
       when ::RBS::Types::Bases::Top
@@ -113,13 +132,13 @@ module RaaP
         [:call, Value::Bottom, :new, [], {}, nil]
       when ::RBS::Types::Optional
         case Random.rand(2)
-        in 0 then Type.new(type.type).pick(size:)
+        in 0 then Type.new(type.type).to_symbolic_call(size: size / 2)
         in 1 then nil
         end
       when ::RBS::Types::Alias
         case gen = GENERATORS[type.name.absolute!.to_s]
         in Proc then instance_exec(&gen)
-        in nil then Type.new(RBS.builder.expand_alias2(type.name, type.args)).pick(size:)
+        in nil then Type.new(RBS.builder.expand_alias2(type.name, type.args)).to_symbolic_call(size:)
         end
       when ::RBS::Types::Bases::Class
         raise "cannot resolve `class` type"
@@ -131,29 +150,29 @@ module RaaP
         Object.const_get(type.name.to_s)
       when ::RBS::Types::ClassInstance
         case gen = GENERATORS[type.name.absolute!.to_s]
-        in Proc then instance_exec(&gen).pick(size: size)
-        in nil then pick_from_initialize(type, size:)
+        in Proc then instance_exec(&gen).pick(size:)
+        in nil then to_symbolic_call_from_initialize(type, size:)
         end
       when ::RBS::Types::Record
-        type.fields.transform_values { |t| Type.new(t).pick(size:) }
+        type.fields.transform_values { |t| Type.new(t).to_symbolic_call(size: size / 2) }
       when ::RBS::Types::Proc
-        Proc.new { Type.new(type.type.return_type).pick(size:) }
+        Proc.new { Type.new(type.type.return_type).to_symbolic_call(size:) }
       when ::RBS::Types::Literal
         type.literal
       when ::RBS::Types::Bases::Bool
-        bool.pick(size: size)
+        bool.pick(size:)
       when ::RBS::Types::Bases::Any
-        untyped.pick(size: size)
+        Type.random.to_symbolic_call(size:)
       when ::RBS::Types::Bases::Nil
         nil
       else
-        raise "not implemented #{type.to_s}"
+        raise "not implemented #{type}"
       end
     end
 
     private
 
-    def pick_from_initialize(type, size:)
+    def to_symbolic_call_from_initialize(type, size:)
       type_name = type.name.absolute!
       const = Object.const_get(type_name.to_s)
       definition = RBS.builder.build_singleton(type_name)
@@ -163,13 +182,12 @@ module RaaP
         rbs_method_type = snew.method_types.sample or raise
         type_params = definition.type_params_decl.concat(rbs_method_type.type_params.drop(definition.type_params_decl.length))
         ts = TypeSubstitution.new(type_params, type.args)
-        maped_rbs_method_type = rbs_method_type
         maped_rbs_method_type = ts.method_type_sub(rbs_method_type)
         method_type = MethodType.new(maped_rbs_method_type)
 
         begin
-          try(times: 5, size: size) do |size|
-            args, kwargs, block = method_type.pick_arguments(size: size, eval: false)
+          try(times: 5, size:) do |size|
+            args, kwargs, block = method_type.arguments_to_symbolic_call(size:)
             [:call, const, :new, args, kwargs, block]
           end
         rescue
@@ -177,7 +195,7 @@ module RaaP
           raise
         end
       else
-        [:call, Value::Module, :new, [type], {}, nil]
+        [:call, Value::Module, :new, [type.to_s], { size: }, nil]
       end
     end
 
@@ -218,7 +236,7 @@ module RaaP
     end
 
     def integer
-      sized { |size| float.pick(size: size).round }
+      sized { |size| float.pick(size:).round }
     end
 
     def none_zero_integer
@@ -231,9 +249,9 @@ module RaaP
         in nil, nil
           Arithmetic.float * size
         in nil, high
-          high - Arithmetic.positive_float * size
+          high - (Arithmetic.positive_float * size)
         in low, nil
-          low + Arithmetic.positive_float * size
+          low + (Arithmetic.positive_float * size)
         in low, high
           Random.rand(Range.new(low.to_f, high.to_f, @range.exclude_end?))
         end.round(2)
@@ -242,16 +260,16 @@ module RaaP
 
     def rational
       sized do |size|
-        a = integer.pick(size: size)
-        b = none_zero_integer.pick(size: size)
+        a = integer.pick(size:)
+        b = none_zero_integer.pick(size:)
         [:call, Kernel, :Rational, [a, b], {}, nil]
       end
     end
 
     def complex
       sized do |size|
-        a = integer.pick(size: size)
-        b = none_zero_integer.pick(size: size)
+        a = integer.pick(size:)
+        b = none_zero_integer.pick(size:)
         [:call, Kernel, :Complex, [a, b], {}, nil]
       end
     end
@@ -262,13 +280,11 @@ module RaaP
           +""
         else
           case [@range.begin, @range.end]
-          in nil, nil
+          in [nil, nil]
             size.times.map { SIMPLE_SOURCE.sample }.join
-          in nil, _
+          in [nil, _] | [_, nil]
             raise "Should set range.begin and range.end"
-          in _, nil
-            raise "Should set range.begin and range.end"
-          in s, e
+          in [s, e]
             a = (s..e).to_a
             size.times.map { a.sample }.join
           end
@@ -278,14 +294,28 @@ module RaaP
 
     def symbol
       sized do |size|
-        string.pick(size: size).to_sym
+        string.pick(size:).to_sym
       end
     end
 
     def array(type)
       sized do |size|
-        Array.new(integer.pick(size: size).abs) do
-          type.pick(size: size)
+        Array.new(integer.pick(size:).abs) do
+          type.to_symbolic_call(size: size / 2)
+        end
+      end
+    end
+
+    # Create Hash object. But not `hash`.
+    # Avoid to use `hash` since core method name
+    def dict(key_type, value_type)
+      sized do |size|
+        csize = size / 2
+        Array.new(integer.pick(size:).abs).to_h do
+          [
+            key_type.to_symbolic_call(size: csize),
+            value_type.to_symbolic_call(size: csize)
+          ]
         end
       end
     end
@@ -293,7 +323,7 @@ module RaaP
     def encoding
       sized do
         e = Encoding.list.sample or raise
-        [:call, Encoding, :find, [e.name], {} , nil]
+        [:call, Encoding, :find, [e.name], {}, nil]
       end
     end
 
@@ -303,24 +333,10 @@ module RaaP
       end
     end
 
-    def untyped
-      case Random.rand(9)
-      in 0 then integer
-      in 1 then float
-      in 2 then rational
-      in 3 then complex
-      in 4 then string
-      in 5 then symbol
-      in 6 then bool
-      in 7 then encoding
-      in 8 then sized { [:call, BasicObject, :new, [], {}, nil] }
-      end
-    end
-
     def temp_method_object
       o = Object.new
       m = 6.times.map { SIMPLE_SOURCE.sample }.join
-      o.define_singleton_method(m) { }
+      o.define_singleton_method(m) {}
       o.method(m)
     end
   end

data/lib/raap/type_substitution.rb

@@ -14,7 +14,7 @@ module RaaP
         elsif bound.upper_bound
           [bound.name, bound.upper_bound]
         else
-          [bound.name, ::RBS::Types::Bases::Top.new(location: nil)]
+          [bound.name, ::RBS::Types::Variable.new(name: bound.name, location: nil)]
         end
       end
       ::RBS::Substitution.build(bound_map.keys, bound_map.values)
@@ -36,6 +36,7 @@ module RaaP
       if self_type.nil? && instance_type.nil? && class_type.nil?
         return search
       end
+
       search.map_type do |ty|
         case ty
         when ::RBS::Types::Bases::Self

data/lib/raap/value/interface.rb

@@ -5,22 +5,26 @@ module RaaP
     class Interface < BasicObject
       def initialize(type, size: 3, self_type: nil, instance_type: nil, class_type: nil)
         @type = type.is_a?(::String) ? RBS.parse_type(type) : type
+        unless @type.instance_of?(::RBS::Types::Interface)
+          ::Kernel.raise ::TypeError, "not an interface type: #{@type}"
+        end
         @size = size
 
-        definition = RBS.builder.build_interface(@type.name.absolute!)
-        definition.methods.each do |name, method|
+        @definition = RBS.builder.build_interface(@type.name.absolute!)
+        @definition.methods.each do |name, method|
           method_type = method.method_types.sample or Kernel.raise
-          type_params = definition.type_params_decl.concat(method_type.type_params.drop(definition.type_params_decl.length))
+          type_params = @definition.type_params_decl.concat(method_type.type_params.drop(@definition.type_params_decl.length))
           ts = TypeSubstitution.new(type_params, @type.args)
 
           subed_method_type = ts.method_type_sub(method_type, self_type:, instance_type:, class_type:)
 
-          BindCall.define_singleton_method(self, name) do |*, &b|
-            @fixed_return_value ||= Type.new(subed_method_type.type.return_type).pick(size: size)
+          BindCall.define_singleton_method(self, name) do |*_, &b|
+            # @type var b: Proc?
+            @fixed_return_value ||= Type.new(subed_method_type.type.return_type).pick(size:)
             if subed_method_type.block
               @fixed_block_arguments ||= size.times.map do
                 fun_type = FunctionType.new(subed_method_type.block.type)
-                fun_type.pick_arguments(size: size)
+                fun_type.pick_arguments(size:)
               end
             else
               @fixed_block_arguments = []
@@ -38,12 +42,16 @@ module RaaP
         end
       end
 
+      def respond_to?(name, _include_all = false)
+        @definition.methods.has_key?(name.to_sym)
+      end
+
       def class
         Interface
       end
 
       def inspect
-        "#<interface @type=#{@type.to_s} @methods=#{RBS.builder.build_interface(@type.name.absolute!).methods.keys} @size=#{@size}>"
+        "#<interface @type=#{@type} @methods=#{@definition.methods.keys} @size=#{@size}>"
       end
     end
   end

data/lib/raap/value/intersection.rb

@@ -3,14 +3,17 @@
 module RaaP
   module Value
     class Intersection < BasicObject
-      def initialize(type, size:)
-        @type = type
-        @children = type.types.map { |t| Type.new(t).pick(size: size) }
+      def initialize(type, size: 3)
+        @type = type.is_a?(::String) ? RBS.parse_type(type) : type
+        unless @type.instance_of?(::RBS::Types::Intersection)
+          ::Kernel.raise ::TypeError, "not an intersection type: #{@type}"
+        end
+        @children = @type.types.map { |t| Type.new(t).pick(size:) }
         @size = size
       end
 
       def inspect
-        "#<intersection @type=#{@type.to_s.inspect} @size=#{@size.inspect}>"
+        "#<intersection @type.to_s=#{@type.to_s.inspect} @size=#{@size.inspect}>"
       end
 
       def class
@@ -18,16 +21,25 @@ module RaaP
       end
 
       def method_missing(name, *args, **kwargs, &block)
-        @children.each do |child|
-          if BindCall.respond_to?(child, name)
-            return child.__send__(name, *args, **kwargs, &block)
+        if respond_to?(name)
+          @children.each do |child|
+            if BindCall.respond_to?(child, name)
+              return child.__send__(name, *args, **kwargs, &block)
+            end
           end
+          ::Kernel.raise
+        else
+          super
         end
       end
 
-      def respond_to?(...)
-        @children.any? do |type|
-          BindCall.respond_to?(type, ...)
+      def respond_to?(name, include_all = false)
+        @children.any? do |child|
+          if BindCall.instance_of?(child, ::BasicObject)
+            BindCall.respond_to?(child, name, include_all)
+          else
+            child.respond_to?(name, include_all)
+          end
         end
       end
     end

data/lib/raap/value/module.rb

@@ -2,16 +2,55 @@ module RaaP
   module Value
     # FIXME: consider self_types
     # HINT: intersection?
-    class Module
-      attr_reader :type
+    class Module < BasicObject
+      def initialize(type, size: 3)
+        @type = type.is_a?(::String) ? ::RaaP::RBS.parse_type(type) : type
+        @size = size
+        unless @type.instance_of?(::RBS::Types::ClassInstance)
+          ::Kernel.raise ::TypeError, "not a module type: #{@type}"
+        end
 
-      def initialize(type)
-        @type = type
-        const = ::Object.const_get(type.name.absolute!.to_s)
-        extend(const)
+        one_instance_ancestors = ::RaaP::RBS.builder.ancestor_builder.one_instance_ancestors(@type.name.absolute!).self_types
+        @self_type = if one_instance_ancestors.nil? || one_instance_ancestors.empty?
+                       ::Object.new
+                     else
+                       one_instance_ancestors.map do |a_instance|
+                         if a_instance.args.empty?
+                           # : BasicObject
+                           a_instance.name.absolute!.to_s
+                         else
+                           # : _Each[Integer]
+                           args = a_instance.args.zip(@type.args).map do |_var, instance|
+                             if instance
+                               instance.to_s
+                             else
+                               'untyped'
+                             end
+                           end
+                           "#{a_instance.name}[#{args.map(&:to_s).join(', ')}]"
+                         end
+                       end.then do |ts|
+                         ts << 'Object' if !ts.include?('::BasicObject')
+                         Type.new(ts.join(' & ')).pick(size:)
+                       end
+                     end
+        const = ::Object.const_get(@type.name.absolute!.to_s)
+        BindCall.extend(@self_type, const)
       end
 
-      def inspect = "#<module #{@type}>"
+      def method_missing(name, *args, **kwargs, &block)
+        @self_type.__send__(name, *args, **kwargs, &block)
+      end
+
+      def respond_to?(name, include_all = false)
+        if BindCall.instance_of?(@self_type, ::BasicObject)
+          BindCall.respond_to?(@self_type, name, include_all)
+        else
+          @self_type.respond_to?(name, include_all)
+        end
+      end
+
+      def inspect = "#<module #{@type} : #{BindCall.class(@self_type)} size=#{@size}>"
       def class = Value::Module
     end
   end

data/lib/raap/value/variable.rb

@@ -4,7 +4,16 @@ module RaaP
       attr_reader :type
 
       def initialize(type)
-        @type = type
+        @type =
+          if type.respond_to?(:to_sym)
+            # @type var type: String | Symbol
+            ::RBS::Types::Variable.new(name: type.to_sym, location: nil)
+          else
+            type
+          end
+        unless @type.instance_of?(::RBS::Types::Variable)
+          ::Kernel.raise ::TypeError, "not a variable type: #{@type}"
+        end
       end
 
       def inspect = "#<var #{type}>"

data/lib/raap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RaaP
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/raap.rb

@@ -15,7 +15,9 @@ module RaaP
     attr_accessor :logger
   end
 
-  self.logger = ::Logger.new($stdout)
+  self.logger = ::Logger.new($stdout, formatter: proc { |severity, _datetime, _progname, msg|
+    "[RaaP] #{severity}: #{msg}\n"
+  })
   self.logger.level = ::Logger::INFO
 
   autoload :BindCall, "raap/bind_call"
@@ -23,7 +25,6 @@ module RaaP
   autoload :FunctionType, "raap/function_type"
   autoload :MethodProperty, "raap/method_property"
   autoload :MethodType, "raap/method_type"
-  autoload :Minitest, "raap/minitest"
   autoload :RBS, "raap/rbs"
   autoload :Result, "raap/result"
   autoload :Sized, "raap/sized"

data/rbs_collection.lock.yaml

@@ -5,10 +5,58 @@ gems:
   version: '0'
   source:
     type: stdlib
+- name: activesupport
+  version: '7.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: bc4cbee282cfb013be8c44a3fe7a374491492400
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: base64
+  version: '0'
+  source:
+    type: stdlib
+- name: bigdecimal
+  version: '0'
+  source:
+    type: stdlib
+- name: concurrent-ruby
+  version: '1.1'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: bc4cbee282cfb013be8c44a3fe7a374491492400
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: connection_pool
+  version: '2.4'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: bc4cbee282cfb013be8c44a3fe7a374491492400
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: date
+  version: '0'
+  source:
+    type: stdlib
+- name: erb
+  version: '0'
+  source:
+    type: stdlib
 - name: fileutils
   version: '0'
   source:
     type: stdlib
+- name: i18n
+  version: '1.10'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: bc4cbee282cfb013be8c44a3fe7a374491492400
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
 - name: io-console
   version: '0'
   source:
@@ -46,7 +94,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: be76a75932e8ed6ee91a95ba936cf88b674bf044
+    revision: bc4cbee282cfb013be8c44a3fe7a374491492400
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: rbs
@@ -57,6 +105,18 @@ gems:
   version: '0'
   source:
     type: stdlib
+- name: securerandom
+  version: '0'
+  source:
+    type: stdlib
+- name: singleton
+  version: '0'
+  source:
+    type: stdlib
+- name: time
+  version: '0'
+  source:
+    type: stdlib
 - name: timeout
   version: '0'
   source:

data/rbs_collection.yaml

@@ -15,6 +15,5 @@ path: .gem_rbs_collection
 
 gems:
   - name: activesupport
-    ignore: true
   - name: steep
     ignore: true