blankity 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c77ee6b4b3f72c8cfa617313fa1a70f14644c140dae8346fc77e8eeb6a9c7bf
-  data.tar.gz: 6d612fe43c3cd9345f27947986a63fc980b2bb95c4f7f003a654fbd8a21c3bd5
+  metadata.gz: 34a522794c85b7f50a815a2a17e455685e5fff40512134a8652d52705fd96946
+  data.tar.gz: 44fe6ca43f7a274e076b00c83fee4da89617102769007615a56f9e8ba8345876
 SHA512:
-  metadata.gz: e267257370d73d2cd537e2d62da15694574ad00390d4385e487c95d9d4591a6ffd40eb5b14afd93209f222c3afb7356d326bb32988bbaaf9509b43b59ba7bcb2
-  data.tar.gz: 56764266af70a160b088875284cfcfa168be5d8d5b1025f2445cafb4c98990affb137564fdaf4176a8a8819c9029acf934c78df176cdcdb03675233e07628402
+  metadata.gz: 2679a4fc2901543f1df080226bcd8d41cde7fff84ffadf084a5a3b54509bc150e5e70ed9cc138624d3a9d9d0ba09f792b11ae7253894b9d35adab64a736c4eb3
+  data.tar.gz: 9102b667417681d9e6c52a83d3e2742513d0ff9a95efaa5925f913c9017c0a841c14ea1d414b36846797d885568547f99feffb729de7e13d012bab88508301df

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2025 SamW
+Copyright (c) 2025 Sam Westerman
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/Rakefile

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "minitest/test_task"
+require 'bundler/gem_tasks'
+require 'minitest/test_task'
 
 Minitest::TestTask.create
 

data/Steepfile

@@ -4,10 +4,7 @@ target :lib do
   signature "sig"
   ignore_signature "sig/test"
 
-  check "lib"                       # Directory name
-  check "path/to/source.rb"         # File name
-  check "app/models/**/*.rb"        # Glob
-  # ignore "lib/templates/*.rb"
+  check 'lib'
 
   # library "pathname"              # Standard libraries
   # library "strong_json"           # Gems

data/lib/blankity/absolutely_blank.rb

@@ -0,0 +1,21 @@
+module Blankity
+  # A Class that has _no_ instance methods on it whatsoever.
+  #
+  # This is actually pretty difficult to use properly, as some methods (e.g. +initialize+
+  # and +singleton_method_defined+) are expected by Ruby to always exist, and restrict a lot of
+  # builtin functionality. (For example, without +singleton_method_defined+, you can't actually
+  # define singleton methods _at all_.)
+  #
+  # @see Blank for a type which doesn't undefine these critical builtin methods
+  class AbsolutelyBlank < BasicObject
+    # We have to disable warnings for just this block, as Ruby warns for `undef`ing some methods
+    previous_warning, $-w = $-w, nil
+
+    (instance_methods + private_instance_methods).each do |name|
+      undef_method(name)
+    end
+
+    # Set warnings to what they used to be
+    $-w = previous_warning
+  end
+end

data/lib/blankity/blank.rb

@@ -4,12 +4,22 @@
 module Blankity
   # A "blank slate" class which removes _all_ methods (from `BasicObject`) other than the "required"
   # ones of `__send__` and `__id__`.
+  #
+  # Notably, it does not remove private instance methods, as Ruby actually requires some of them to
+  # function properly (e.g. {BasicObject#singleton_method_added}.)
   class Blank < BasicObject
     # Remove every method except for `__send__` and `__id__`
     instance_methods.each do |name|
       undef_method(name) unless name == :__send__ || name == :__id__
     end
 
+    # Helper method to create a new instance
+    #
+    # @rbs: () ?{ (Blank) -> void } -> singleton(Blank)
+    def self.blank(&block)
+      ::Class.new(self, &block).new
+    end
+
     # A helper method to define some `Kernel`methods on `self`
     def __with_Object_methods__(*methods)
       dsm = ::Object.instance_method(:define_singleton_method).bind(self)

data/lib/blankity/classes.rb

@@ -2,162 +2,202 @@
 # rbs_inline: enabled
 
 module Blankity
-  class ValueBase < Blank
+  # BlankValue is a superclass of the +ToXXX+ classes, which consolidates their initialization
+  # into one convenient place
+  #
+  # @rbs generic T -- type of @__value__
+  class BlankValue < Blank
+    # @rbs @__value__: T
+
+    DEFINE_SINGLETON_METHOD = ::Kernel.instance_method(:define_singleton_method)
+    private_constant :DEFINE_SINGLETON_METHOD
+
+    # Creates a new {BlankValue}, and defining singleton methods depending on the parameters
+    #
+    # @param value [T] the backing value for this class
+    # @param methods [Array[interned]] a list of methods to define on +self+ that will just forward
+    #                                  everything to +value.<method>+
+    # @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+.
+    #
+    # @rbs (T, ?methods: Array[interned], ?hash: bool) ?{ () [self: self] -> void } -> void
     def initialize(value, methods: [], 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
-
       @__value__ = value
 
-    ::Blankity.blank do
-      # Always define the `to_method`
-      define_singleton_method(:inspect) { to_method.to_s }
-      define_method(to_method) { value }
+      # If `hash` is supplied, then add `hash` and `eql?` to the list of methods to define
+      methods |= %i[hash eql?] if hash
 
-      # For all the `methods` methods, fetch its definition from `value` and use that as the
-      # definition
       methods.each do |method|
-        define_method(method, &::Kernel.instance_method(:method).bind_call(value, method))
+        # We can use `.method` instead of querying `Kernel` because all types that are used here
+        # inherit from `Object`.
+        DEFINE_SINGLETON_METHOD.bind_call(self, method, &@__value__.method(method))
       end
 
-      # If a block's given, execute it.
-      class_exec(&block) if block
+      instance_exec(&block) if block
     end
   end
 
-  class ToI < Blank
-    #: (Integer) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_i+; it implements RBS's +_ToI+ interface.
+  #
+  # @rbs inherits BlankValue[Integer]
+  class ToI < BlankValue
     #: () -> Integer
     def to_i = @__value__
   end
 
-  class ToInt < Blank
-    #: (Integer) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_int+; it implements RBS's +_ToInt+ interface.
+  #
+  # @rbs inherits BlankValue[Integer]
+  class ToInt < BlankValue
     #: () -> Integer
     def to_int = @__value__
   end
 
-  class ToS < Blank
-    #: (String) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_s+; it implements RBS's +_ToS+ interface.
+  #
+  # @rbs inherits BlankValue[String]
+  class ToS < BlankValue
     #: () -> String
     def to_s = @__value__
   end
 
-  class ToStr < Blank
-    #: (String) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_str+; it implements RBS's +_ToStr+ interface.
+  #
+  # @rbs inherits BlankValue[String]
+  class ToStr < BlankValue
     #: () -> String
     def to_str = @__value__
   end
 
+  # A Class which exclusively defines +#to_a+; it implements RBS's +_ToA[T]+ interface.
+  #
   # @rbs generic unchecked out T -- Type of elements
-  class ToA < Blank
-    #: (Array[T]) -> void
-    def initialize(value) = @__value__ = value
-
+  # @rbs inherits BlankValue[Array[T]]
+  class ToA < BlankValue
     #: () -> Array[T]
     def to_a = @__value__
   end
 
+  # A Class which exclusively defines +#to_ary+; it implements RBS's +_ToAry[T]+ interface.
+  #
   # @rbs generic unchecked out T -- Type of elements
-  class ToAry < Blank
-    #: (Array[T]) -> void
-    def initialize(value) = @__value__ = value
-
+  # @rbs inherits BlankValue[Array[T]]
+  class ToAry < BlankValue
     #: () -> Array[T]
     def to_ary = @__value__
   end
 
+  # A Class which exclusively defines +#to_h+; it implements RBS's +_ToH[K, V]+ interface.
+  #
   # @rbs generic unchecked out K -- Type of Key
   # @rbs generic unchecked out V -- Type of Value
-  class ToH < Blank
-    #: (Hash[K, V]) -> void
-    def initialize(value) = @__value__ = value
-
+  # @rbs inherits BlankValue[Hash[K, V]]
+  class ToH < BlankValue
     #: () -> Hash[K, V]
     def to_h = @__value__
   end
 
+  # A Class which exclusively defines +#to_hash+; it implements RBS's +_ToHash[K, V]+ interface.
+  #
   # @rbs generic unchecked out K -- Type of Key
   # @rbs generic unchecked out V -- Type of Value
-  class ToHash < Blank
-    #: (Hash[K, V]) -> void
-    def initialize(value) = @__value__ = value
-
+  # @rbs inherits BlankValue[Hash[K, V]]
+  class ToHash < BlankValue
     #: () -> Hash[K, V]
     def to_hash = @__value__
   end
 
-  class ToSym < Blank
-    #: (Symbol) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_sym+; it implements RBS's +_ToSym+ interface.
+  #
+  # @rbs inherits BlankValue[Symbol]
+  class ToSym < BlankValue
     #: () -> Symbol
     def to_sym = @__value__
   end
 
-  class ToR < Blank
-    #: (Rational) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_r+; it implements RBS's +_ToR+ interface.
+  #
+  # @rbs inherits BlankValue[Rational]
+  class ToR < BlankValue
     #: () -> Rational
     def to_r = @__value__
   end
 
-  class ToC < Blank
-    #: (Complex) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_c+; it implements RBS's +_ToC+ interface.
+  #
+  # @rbs inherits BlankValue[Complex]
+  class ToC < BlankValue
     #: () -> Complex
     def to_C = @__value__
   end
 
-  class ToF < Blank
-    #: (Float) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_f+; it implements RBS's +_ToF+ interface.
+  #
+  # @rbs inherits BlankValue[Float]
+  class ToF < BlankValue
     #: () -> Float
     def to_f = @__value__
   end
 
-  class ToRegexp < Blank
-    #: (Regexp) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_regexp+; it implements RBS's +Regexp::_ToRegexp+ interface.
+  #
+  # @rbs inherits BlankValue[Regexp]
+  class ToRegexp < BlankValue
     #: () -> Regexp
     def to_regexp = @__value__
   end
 
-  class ToPath < Blank
-    #: (String) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_path+; it implements RBS's +_ToPath+ interface.
+  #
+  # @rbs inherits BlankValue[String]
+  class ToPath < BlankValue
     #: () -> String
     def to_path = @__value__
   end
 
-  class ToIO < Blank
-    #: (IO) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_io+; it implements RBS's +_ToIO+ interface.
+  #
+  # @rbs inherits BlankValue[IO]
+  class ToIO < BlankValue
     #: () -> IO
     def to_io = @__value__
   end
 
+  # A Class which exclusively defines +#to_proc+; it implements RBS's +_ToProc+ interface.
+  #
+  # @rbs inherits BlankValue[Proc]
+  class ToProc < BlankValue
+    #: () -> Proc
+    def to_proc = @__value__
+  end
+
+  # A Class which defines `#begin`, `#end`, and `#exclude_end?`. It implements RBS's +_Range[T]+
+  # interface.
+  #
   # @rbs generic out T -- Type to iterate over
   class Range < Blank
+    # @rbs @begin: T?
+    # @rbs @end: T?
+    # @rbs @exclude_end: bool
+
     #: (T?, T?, ?bool) -> void
-    def initialize(begin_, end_, exclude_end = false)
+    def initialize(begin_, end_, exclude_end = false, methods: [], hash: false, &block)
       @__begin__ = begin_
       @__end__ = end_
       @__exclude_end__ = exclude_end
+
+      # If `hash` is supplied, then add `hash` and `eql?` to the list of methods to define
+      methods |= %i[hash eql?] if hash
+
+      methods.each do |method|
+        p method
+        # We can use `.method` instead of querying `Kernel` because all types that are used here
+        # inherit from `Object`.
+        DEFINE_SINGLETON_METHOD.bind_call(self, method, &@__value__.method(method))
+      end
+
+      instance_exec(&block) if block
     end
 
     #: () -> T?
@@ -167,6 +207,6 @@ module Blankity
     def end = @__end__
 
     #: () -> bool
-    def exclude_end = @__exclude_end__
+    def exclude_end? = @__exclude_end__
   end
 end

data/lib/blankity/to.rb

@@ -4,62 +4,21 @@ module Blankity
   module To
     module_function
 
-    # Helper method to create new `BlankSlate`s. Args:
-    # - `to_method`: The method to use, eg `to_i`
-    # - `value`: What to return when `to_method` is called
-    # - `methods`: Optional list of methods from to define, using `value`'s definition
-    # - `hash`: Helper to also add `hash` and `eql?` to `methods`, so it can be used as a hash key
-    # - `block`: If provided, a block to also run
-    def to_helper(to_method, value, methods: [], 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
-
-      ::Blankity.blank do
-        # Always define the `to_method`
-        define_singleton_method(:inspect) { to_method.to_s }
-        define_method(to_method) { value }
-
-        # For all the `methods` methods, fetch its definition from `value` and use that as the
-        # definition
-        methods.each do |method|
-          define_method(method, &::Kernel.instance_method(:method).bind_call(value, method))
-        end
-
-        # If a block's given, execute it.
-        class_exec(&block) if block
-      end
-    end
-
-    # Create a type which _only_ responds to `.to_i`. See `to_helper` for details.
-    def i(value, ...)
-      to_helper(:to_i, value.to_i, ...)
-    end
-
-    # Create a type which _only_ responds to `.to_int`. See `to_helper` for details.
-    def int(value, ...)
-      to_helper(:to_int, value.to_int, ...)
-    end
-
-    # Create a type which _only_ responds to `.to_s`. See `to_helper` for details.
-    def s(value, ...)
-      to_helper(:to_s, value.to_s, ...)
-    end
-
-    # Create a type which _only_ responds to `.to_str`. See `to_helper` for details.
-    def str(value, ...)
-      to_helper(:to_str, value.to_str, ...)
-    end
+    def i(value, ...) = ToI.new(value.to_i, ...)
+    def int(value, ...) = ToInt.new(value.to_int, ...)
+    def s(value, ...) = ToS.new(value.to_s, ...)
+    def str(value, ...) = ToStr.new(value.to_str, ...)
 
     # Create a type which _only_ responds to `.to_a`. See `to_helper` for details.
     #
     # This supports `a(1, 2, 3)` as a convenient shorthand for `a([1, 2, 3])`. To
     # create a `.to_a` that returns an array containing just an array, just use `a([array])`.
     def a(*elements, **, &)
-      if elements.length == 1
-        to_helper(:to_a, Array(elements[0]), **, &)
-      else
-        to_helper(:to_a, elements, **, &)
+      if elements.length == 1 && defined?(elements[0].to_a)
+        elements = elements[0].to_a
       end
+
+      ToA.new(elements, **, &)
     end
 
     # Create a type which _only_ responds to `.to_ary`. See `to_helper` for details.
@@ -67,11 +26,11 @@ module Blankity
     # This supports `ary(1, 2, 3)` as a convenient shorthand for `ary([1, 2, 3])`. To
     # create a `.to_ary` that returns an array containing just an array, use `ary([array])`.
     def ary(*elements, **, &)
-      if elements.length == 1
-        to_helper(:to_ary, Array(elements[0]), **, &)
-      else
-        to_helper(:to_ary, elements, **, &)
+      if elements.length == 1 && defined?(elements[0].to_ary)
+        elements = elements[0].to_ary
       end
+
+      ToAry.new(elements, **, &)
     end
 
     # Create a type which _only_ responds to `.to_h`. See `to_helper` for details.
@@ -81,9 +40,9 @@ module Blankity
     # to supply keyowrd arguments that `to_helper` expects. Use `h({'a' => 'b'}, ...)` for that.
     def h(hash = nohash=true, **, &)
       if nohash
-        to_helper(:to_h, {**}, &)
+        ToH.new({**}, &)
       else
-        to_helper(:to_h, hash.to_h, **, &)
+        ToH.new(hash.to_h, **, &)
       end
     end
 
@@ -94,58 +53,40 @@ module Blankity
     # to supply keyowrd arguments that `to_helper` expects. Use `h({'a' => 'b'}, ...)` for that.
     def hash(hash = nohash=true, **, &)
       if nohash
-        to_helper(:to_hash, {**}, &)
+        ToHash.new({**}, &)
       else
-        to_helper(:to_hash, hash.to_hash, **, &)
+        ToHash.new(hash.to_hash, **, &)
       end
     end
 
-    # Create a type which _only_ responds to `.to_sym`. See `to_helper` for details.
-    def sym(value, ...)
-      to_helper(:to_sym, value.to_sym, ...)
-    end
-
-    # Create a type which _only_ responds to `.to_r`. See `to_helper` for details.
-    def r(value, ...)
-      to_helper(:to_r, value.to_r, ...)
-    end
-
-    # Create a type which _only_ responds to `.to_c`. See `to_helper` for details.
-    def c(value, ...)
-      to_helper(:to_c, value.to_c, ...)
-    end
-
-    # Create a type which _only_ responds to `.to_f`. See `to_helper` for details.
-    def f(value, ...)
-      to_helper(:to_f, value.to_f, ...)
-    end
-
-    # Create a type which _only_ responds to `.to_regexp`. See `to_helper` for details.
-    def regexp(value, ...)
-      to_helper(:to_regexp, value.to_regexp, ...)
-    end
+    def sym(value, ...) = ToSym.new(value.to_sym, ...)
+    def r(value, ...) = ToR.new(value.to_r, ...)
+    def c(value, ...) = ToC.new(value.to_c, ...)
+    def f(value, ...) = ToF.new(value.to_f, ...)
+    def regexp(value, ...) = ToRegexp.new(value.to_regexp, ...)
 
-    # Create a type which _only_ responds to `.to_path`. See `to_helper` for details.
     def path(value, ...)
-      to_helper(:to_path, defined?(value.to_path) ? value.to_path : String(value), ...)
+      ToPath.new(defined?(value.to_path) ? value.to_path : String(value), ...)
     end
 
-    # Create a type which _only_ responds to `.to_io`. See `to_helper` for details.
-    def io(value, ...)
-      to_helper(:to_io, value.to_io, ...)
+    def io(value, ...) = ToIO.new(value.to_io, ...)
+    def proc(proc = noproc=true, **, &block)
+      if noproc
+        unless block_given?
+          raise ArgumentError, 'if an explicit proc is omitted, a block must be passed'
+        end
+
+        ToProc.new(block, **)
+      else
+        ToProc.new(proc.to_proc, **, &block)
+      end
     end
 
     # Create a type which _only_ responds to `.begin`, `.end`, and `.exclude_end?`
     # (the methods required to be considered a "custom range," eg for `Array#[]`.) See
     # `to_helper` for details.
-    def range(begin_, end_, exclude_end = false, &)
-      ::Blankity.blank do
-        define_method(:begin) { begin_ }
-        define_method(:end) { end_ }
-        define_method(:exclude_end?) { exclude_end }
-
-        class_exec(&block) if block
-      end
+    def range(begin_, end_, exclude_end = false, ...)
+      Range.new(begin_, end_, exclude_end, ...)
     end
   end
 end

data/lib/blankity/version.rb

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

metadata

@@ -1,16 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: blankity
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
-- SamW
+- Sam Westerman
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-email:
-- mail@sampersand.me
+description: |
+  There's a lot of conversion methods in Ruby: to_s, to_a, to_i, etc. This gem provides types
+  which *only* respond to these conversion methods, and nothing else.
+email: mail@sampersand.me
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -20,6 +22,7 @@ files:
 - Rakefile
 - Steepfile
 - lib/blankity.rb
+- lib/blankity/absolutely_blank.rb
 - lib/blankity/blank.rb
 - lib/blankity/classes.rb
 - lib/blankity/to.rb
@@ -28,11 +31,11 @@ files:
 - sig/generated/blankity/blank.rbs
 - sig/generated/blankity/tos.rbs
 - sig/generated/blankity/version.rbs
-homepage: https://github.com/sampersand/blankity/blob/master
+homepage: https://github.com/sampersand/blankity
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/sampersand/blankity/blob/master
+  homepage_uri: https://github.com/sampersand/blankity
 rdoc_options: []
 require_paths:
 - lib
@@ -40,7 +43,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -49,5 +52,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.7.0.dev
 specification_version: 4
-summary: Helpers for creating types which _only_ respond to specific conversion methods
+summary: Provides "blank" objects which *only* supply conversion methods
 test_files: []