blankity 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ef9c8f38f3ffd454aa886ac4d6a8460353dc7b7b10a647fbb6c81da55b895e9
-  data.tar.gz: df4936478873a0b355b87e1d005d0eea43d1deb2038535a6db6710b6b9da1ce1
+  metadata.gz: 77c386d3e2995f2bd9b923e9454b6ea7eee52ab56b0bee93365c38cf3c0c7116
+  data.tar.gz: b590b899c896efe9d843ee456517a30822e85220a89e8ae890fba831975159fd
 SHA512:
-  metadata.gz: d2b0f745cb5b187d730e7425f160bace2177cd012499ce235b6842a31630bd4894873b810928a7a352918a72424c809a41e013f6eba049d7f4b04bf8d72c9153
-  data.tar.gz: c743a30c765309bbb826ccf7be7fa6462b35efb67598c3e85175b937919238ba74d1ac85c8dbb0cc547598bf0f3adf0205592d2428a0c4383be17b79f8b40b13
+  metadata.gz: 614a8f62d477bac3d9809ac2e37201242fe34bca08693af20dd5089f6be99e5b1ef336971e31a0e3c02f355aa572420353288d747767a8f9ae2aa431e62ee6a0
+  data.tar.gz: 3044675608037373cb1d7ff3ff9ee40729289e0d68b3c170cdb8c5302013b70844d556fc359be50281598f598d5afa8b02c713d011b224c1cbcaeefae9b2b773

data/README.md

@@ -24,7 +24,7 @@ p defined?(blank.==)      #=> nil
 p defined?(blank.inspect) #=> nil
 
 # Include specific `Object` methods:
-blank = Blankity::Blank.new(methods: [:==])
+blank = Blankity::Blank.new(with: [:==])
 p blank == blank #=> true
 
 # Also supports blocks, which are `instance_exec`ed

data/lib/blankity/blank.rb

@@ -12,76 +12,57 @@ module Blankity
   # - Private methods are not undefined, as each one of them is expected to be present (most of them
   #   are hooks, eg +singleton_method_added+), and aren't easily accessible from external classes.
   #
-  # To make using +Blank+ easier, its constructor allows you to pass a +methods:+ keyword argument,
+  # To make using +Blank+ easier, its constructor allows you to pass a +with:+ keyword argument,
   # which will define singleton methods based on {Object}.
   class Blank < BasicObject
-    # Remove every public and protected method that we inherit, except for `__xyz__` methods
+    # Define top-level methods that are annoying to not have present.
+
+    # @rbs!
+    #   def __define_singleton_method__: (interned name, Method | UnboundMethod | Proc method) -> Symbol
+    #                                  | (interned name) { (?) [self: self] -> untyped } -> Symbol
+    #   def __instance_exec__: [T] (*untyped, **untyped) { (?) [self: self] -> T } -> T
+    define_method :__define_singleton_method__, ::Kernel.instance_method(:define_singleton_method)
+    alias_method :__instance_exec__, :instance_exec # Use `alias_method` instead of `alias` so rbs-inline won't pick it up
+
+    # Remove every other public and protected method that we inherit, except for `__xyz__` methods
     instance_methods.each do |name|
       undef_method(name) unless name.match?(/\A__.*__\z/)
     end
 
-    # Declare these as constants so we don't constantly look them up.
-    DEFINE_SINGLETON_METHOD = ::Object.instance_method(:define_singleton_method) #: UnboundMethod
-    INSTANCE_EXEC = ::Object.instance_method(:instance_exec) #: UnboundMethod
-    private_constant :DEFINE_SINGLETON_METHOD, :INSTANCE_EXEC
+    class << self
+      # Alias for `new`
+      alias blank new
+    end
 
     # Creates a new {BlankValue}, and defining singleton methods depending on the parameters
     #
-    # @param methods [Array[interned]] a list of {Object} methods to define on +self+.
-    # @param hash [bool] convenience argument, adds +hash+ and +eql?+ to +methods+ so the resulting
+    # @param with [Array[interned]] a list of {Object} methods to define on +self+.
+    # @param hash [bool] convenience argument, adds +hash+ and +eql?+ to +with+ so the resulting
     #                    type can be used as a key in +Hash+es
-    # @yield [] if a block is given, runs it via +instance_exec+.
+    # @yield [] if a block is given, runs it via +__instance_exec__+.
     #
     # === Example
     #   # Make a empty instance
     #   Blankity::Blank.new
     #
     #   # Include `Object#inspect`, so we can print with `p`
-    #   p Blankity::Blank.new(methods: %i[inspect])
+    #   p Blankity::Blank.new(with: %i[inspect])
     #
     #   # Define a singleton method
     #   p Blankity::Blank.new{ def cool?(other) = other == 3 }.cool?(3) #=> true
     #
-    # @rbs (?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
-    def initialize(methods: [], hash: false, &block)
+    # @rbs (?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(with: [], hash: false, &block)
       # If `hash` is supplied, then add `hash` and `eql?` to the list of methods to define
-      methods |= %i[hash eql?] if hash
+      with |= %i[hash eql?] if hash
 
       # Define any object methods requested by the end-user
-      __define_Object_methods__(*methods)
-
-      # If a block's provided, then `instance_exec`
-      INSTANCE_EXEC.bind_call(self, &__any__ = block) if block
-    end
-
-    # A helper method to define {Object} instance methods on +self+
-    #
-    # @param methods [*interned] The list of instance methods from {Object} to define
-    # @return [self]
-    #
-    # === Example
-    #   # Make an empty instance
-    #   blank = Blankity::Blank.blank
-    #
-    #   # Make sure it's printable
-    #   blank.__define_Object_methods__(:inspect, :==)
-    #
-    #   # Now you can use them!
-    #   fail unless blank == blank
-    #   p blank
-    #
-    # @rbs (*interned) -> self
-    def __define_Object_methods__(*methods)
-      methods.each do |method|
-        DEFINE_SINGLETON_METHOD.bind_call(self, method, ::Object.instance_method(method).bind(self))
+      with.each do |method|
+        __define_singleton_method__(method, ::Object.instance_method(method).bind(self))
       end
 
-      self
+      # If a block's provided, then `instance_exec`
+      __instance_exec__(&__any__ = block) if block
     end
   end
-
-  # Shorthand constructor {Blankity::Blank}.
-  #
-  # @rbs (?methods: Array[interned], ?hash: bool) ?{ () [self: Blank] -> void } -> Blank
-  def self.blank(...) = Blank.new(...)
 end

data/lib/blankity/classes.rb

@@ -8,7 +8,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (Integer, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (Integer, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
@@ -24,7 +24,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (Integer, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (Integer, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
@@ -40,7 +40,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (String, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (String, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
@@ -56,7 +56,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (String, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (String, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
@@ -74,7 +74,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (Array[T], ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (Array[T], ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
@@ -92,7 +92,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (Array[T], ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (Array[T], ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
@@ -111,7 +111,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (Hash[K, V], ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (Hash[K, V], ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
@@ -130,7 +130,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (Hash[K, V], ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (Hash[K, V], ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
@@ -146,7 +146,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (Symbol, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (Symbol, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
@@ -162,7 +162,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (Rational, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (Rational, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
@@ -178,7 +178,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (Complex, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (Complex, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
@@ -194,7 +194,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (Float, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (Float, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
@@ -210,7 +210,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (Regexp, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (Regexp, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
@@ -226,7 +226,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (String, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (String, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
@@ -242,7 +242,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (IO, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (IO, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
@@ -258,7 +258,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (Proc, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (Proc, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
@@ -279,7 +279,7 @@ module Blankity
 
     # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (T?, T?, ?bool, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (T?, T?, ?bool, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(begin_, end_, exclude_end = false, ...)
       @__begin__ = begin_
       @__end__ = end_

data/lib/blankity/to.rb

@@ -131,7 +131,7 @@ module Blankity
     #
     # @rbs (_ToProc, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToProc] -> void } -> ToProc
     #    | (?methods: Array[interned], ?hash: bool) { (?) -> untyped } -> ToProc
-    def proc(proc = nil, **, &block)
+    def self.proc(proc = nil, **, &block)
       if proc
         ToProc.new(proc.to_proc, **, &block)
       elsif !block_given?

data/lib/blankity/version.rb

@@ -2,5 +2,5 @@
 # rbs_inline: enabled
 
 module Blankity
-  VERSION = '0.9.2'
+  VERSION = '0.10.0'
 end

data/lib/blankity.rb

@@ -1,7 +1,12 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-module Blankity; end
+module Blankity
+  # Shorthand constructor {Blankity::Blank}.
+  #
+  # @rbs (?with: Array[interned], ?hash: bool) ?{ () [self: Blank] -> void } -> Blank
+  def self.blank(...) = Blank.new(...)
+end
 
 require_relative 'blankity/version'
 require_relative 'blankity/top'

data/sig/generated/blankity/blank.rbs

@@ -14,17 +14,19 @@ module Blankity
   # To make using +Blank+ easier, its constructor allows you to pass a +methods:+ keyword argument,
   # which will define singleton methods based on {Object}.
   class Blank < BasicObject
-    # Declare these as constants so we don't constantly look them up.
-    DEFINE_SINGLETON_METHOD: UnboundMethod
+    def __define_singleton_method__: (interned name, Method | UnboundMethod | Proc method) -> Symbol
+                                   | (interned name) { (?) [self: self] -> untyped } -> Symbol
 
-    INSTANCE_EXEC: UnboundMethod
+    def __instance_exec__: [T] (*untyped, **untyped) { (?) [self: self] -> T } -> T
+
+    alias self.blank self.new
 
     # Creates a new {BlankValue}, and defining singleton methods depending on the parameters
     #
     # @param methods [Array[interned]] a list of {Object} methods to define on +self+.
     # @param hash [bool] convenience argument, adds +hash+ and +eql?+ to +methods+ so the resulting
     #                    type can be used as a key in +Hash+es
-    # @yield [] if a block is given, runs it via +instance_exec+.
+    # @yield [] if a block is given, runs it via +__instance_exec__+.
     #
     # === Example
     #   # Make a empty instance
@@ -38,25 +40,6 @@ module Blankity
     #
     # @rbs (?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize: (?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
-
-    # A helper method to define {Object} instance methods on +self+
-    #
-    # @param methods [*interned] The list of instance methods from {Object} to define
-    # @return [self]
-    #
-    # === Example
-    #   # Make an empty instance
-    #   blank = Blankity::Blank.blank
-    #
-    #   # Make sure it's printable
-    #   blank.__define_Object_methods__(:inspect, :==)
-    #
-    #   # Now you can use them!
-    #   fail unless blank == blank
-    #   p blank
-    #
-    # @rbs (*interned) -> self
-    def __define_Object_methods__: (*interned) -> self
   end
 
   # Shorthand constructor {Blankity::Blank}.

data/sig/test/test/test_blank.rbs

@@ -16,6 +16,4 @@ class TestBlankity_Top < Minitest::Test
   def test_initialize_with_block: () -> untyped
 
   def test_initialize_with_block_is_run_after_methods: () -> untyped
-
-  def test___define_Object_methods__: () -> untyped
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: blankity
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.10.0
 platform: ruby
 authors:
 - Sam Westerman