blankity 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6c77ee6b4b3f72c8cfa617313fa1a70f14644c140dae8346fc77e8eeb6a9c7bf
+  data.tar.gz: 6d612fe43c3cd9345f27947986a63fc980b2bb95c4f7f003a654fbd8a21c3bd5
+SHA512:
+  metadata.gz: e267257370d73d2cd537e2d62da15694574ad00390d4385e487c95d9d4591a6ffd40eb5b14afd93209f222c3afb7356d326bb32988bbaaf9509b43b59ba7bcb2
+  data.tar.gz: 56764266af70a160b088875284cfcfa168be5d8d5b1025f2445cafb4c98990affb137564fdaf4176a8a8819c9029acf934c78df176cdcdb03675233e07628402

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 SamW
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# Blankity
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/blankity`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/blankity.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: :test

data/Steepfile

@@ -0,0 +1,32 @@
+D = Steep::Diagnostic
+
+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"
+
+  # library "pathname"              # Standard libraries
+  # library "strong_json"           # Gems
+
+  # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)
+  # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
+  # configure_code_diagnostics do |hash|             # You can setup everything yourself
+  #   hash[D::Ruby::NoMethod] = :information
+  # end
+end
+
+# target :test do
+#   unreferenced!                     # Skip type checking the `lib` code when types in `test` target is changed
+#   signature "sig/test"              # Put RBS files for tests under `sig/test`
+#   check "test"                      # Type check Ruby scripts under `test`
+
+#   configure_code_diagnostics(D::Ruby.lenient)      # Weak type checking for test code
+
+#   # library "pathname"              # Standard libraries
+# end

data/lib/blankity/blank.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Blankity
+  # A "blank slate" class which removes _all_ methods (from `BasicObject`) other than the "required"
+  # ones of `__send__` and `__id__`.
+  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
+
+    # A helper method to define some `Kernel`methods on `self`
+    def __with_Object_methods__(*methods)
+      dsm = ::Object.instance_method(:define_singleton_method).bind(self)
+
+      methods.each do |method|
+        dsm.call(method, ::Object.instance_method(method))
+      end
+
+      self
+    end
+
+    # Same as `__with_Object_methods__`, but adds them to subclasses. This shouldn't
+    # be called on `Blankity::Blank` directly, as that affects subclasses
+    def self.__with_Object_methods__(*methods)
+      if ::Blankity::Blank.equal?(self)
+        raise ArgumentError, 'Cannot call `__with_Object_methods__` on Blank, as that will affect all blank slates'
+      end
+
+      methods.each do |method|
+        define_method(method, ::Kernel.instance_method(method))
+      end
+
+      self
+    end
+
+    # Helper method to create a new `Blank` with a block
+    def self.blank(&block)
+      ::Class.new(self, &block).new
+    end
+  end
+
+  def self.blank(...) = Blank.blank(...)
+end

data/lib/blankity/classes.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Blankity
+  class ValueBase < Blank
+    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 }
+
+      # 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
+
+  class ToI < Blank
+    #: (Integer) -> void
+    def initialize(value) = @__value__ = value
+
+    #: () -> Integer
+    def to_i = @__value__
+  end
+
+  class ToInt < Blank
+    #: (Integer) -> void
+    def initialize(value) = @__value__ = value
+
+    #: () -> Integer
+    def to_int = @__value__
+  end
+
+  class ToS < Blank
+    #: (String) -> void
+    def initialize(value) = @__value__ = value
+
+    #: () -> String
+    def to_s = @__value__
+  end
+
+  class ToStr < Blank
+    #: (String) -> void
+    def initialize(value) = @__value__ = value
+
+    #: () -> String
+    def to_str = @__value__
+  end
+
+  # @rbs generic unchecked out T -- Type of elements
+  class ToA < Blank
+    #: (Array[T]) -> void
+    def initialize(value) = @__value__ = value
+
+    #: () -> Array[T]
+    def to_a = @__value__
+  end
+
+  # @rbs generic unchecked out T -- Type of elements
+  class ToAry < Blank
+    #: (Array[T]) -> void
+    def initialize(value) = @__value__ = value
+
+    #: () -> Array[T]
+    def to_ary = @__value__
+  end
+
+  # @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
+
+    #: () -> Hash[K, V]
+    def to_h = @__value__
+  end
+
+  # @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
+
+    #: () -> Hash[K, V]
+    def to_hash = @__value__
+  end
+
+  class ToSym < Blank
+    #: (Symbol) -> void
+    def initialize(value) = @__value__ = value
+
+    #: () -> Symbol
+    def to_sym = @__value__
+  end
+
+  class ToR < Blank
+    #: (Rational) -> void
+    def initialize(value) = @__value__ = value
+
+    #: () -> Rational
+    def to_r = @__value__
+  end
+
+  class ToC < Blank
+    #: (Complex) -> void
+    def initialize(value) = @__value__ = value
+
+    #: () -> Complex
+    def to_C = @__value__
+  end
+
+  class ToF < Blank
+    #: (Float) -> void
+    def initialize(value) = @__value__ = value
+
+    #: () -> Float
+    def to_f = @__value__
+  end
+
+  class ToRegexp < Blank
+    #: (Regexp) -> void
+    def initialize(value) = @__value__ = value
+
+    #: () -> Regexp
+    def to_regexp = @__value__
+  end
+
+  class ToPath < Blank
+    #: (String) -> void
+    def initialize(value) = @__value__ = value
+
+    #: () -> String
+    def to_path = @__value__
+  end
+
+  class ToIO < Blank
+    #: (IO) -> void
+    def initialize(value) = @__value__ = value
+
+    #: () -> IO
+    def to_io = @__value__
+  end
+
+  # @rbs generic out T -- Type to iterate over
+  class Range < Blank
+    #: (T?, T?, ?bool) -> void
+    def initialize(begin_, end_, exclude_end = false)
+      @__begin__ = begin_
+      @__end__ = end_
+      @__exclude_end__ = exclude_end
+    end
+
+    #: () -> T?
+    def begin = @__begin__
+
+    #: () -> T?
+    def end = @__end__
+
+    #: () -> bool
+    def exclude_end = @__exclude_end__
+  end
+end

data/lib/blankity/to.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+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
+
+    # 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, **, &)
+      end
+    end
+
+    # Create a type which _only_ responds to `.to_ary`. See `to_helper` for details.
+    #
+    # 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, **, &)
+      end
+    end
+
+    # Create a type which _only_ responds to `.to_h`. See `to_helper` for details.
+    #
+    # This supports passing in key/values directly via `h('a' => 'b')` as a convenient
+    # shorthand for `h({'a' => 'b'})`, but the shorthand version doesn't allow you
+    # 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, {**}, &)
+      else
+        to_helper(:to_h, hash.to_h, **, &)
+      end
+    end
+
+    # Create a type which _only_ responds to `.to_hash`. See `to_helper` for details.
+    #
+    # This supports passing in key/values directly via `h('a' => 'b')` as a convenient
+    # shorthand for `h({'a' => 'b'})`, but the shorthand version doesn't allow you
+    # 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, {**}, &)
+      else
+        to_helper(:to_hash, 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
+
+    # 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), ...)
+    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, ...)
+    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
+    end
+  end
+end

data/lib/blankity/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Blankity
+  VERSION = '0.0.2'
+end

data/lib/blankity.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Blankity; end
+
+require_relative 'blankity/version'
+require_relative 'blankity/blank'
+require_relative 'blankity/classes'
+require_relative 'blankity/to'

data/sig/generated/blankity/blank.rbs

@@ -0,0 +1,19 @@
+# Generated from lib/blankity/blank.rb with RBS::Inline
+
+module Blankity
+  # A "blank slate" class which removes _all_ methods (from `BasicObject`) other than the "required"
+  # ones of `__send__` and `__id__`.
+  class Blank < BasicObject
+    # A helper method to define some `Kernel`methods on `self`
+    def __with_Object_methods__: (*untyped methods) -> untyped
+
+    # Same as `__with_Object_methods__`, but adds them to subclasses. This shouldn't
+    # be called on `Blankity::Blank` directly, as that affects subclasses
+    def self.__with_Object_methods__: (*untyped methods) -> untyped
+
+    # Helper method to create a new `Blank` with a block
+    def self.blank: () ?{ (?) -> untyped } -> untyped
+  end
+
+  def self.blank: () -> untyped
+end

data/sig/generated/blankity/tos.rbs

@@ -0,0 +1,44 @@
+# Generated from lib/blankity/tos.rb with RBS::Inline
+
+module Blankity
+  class ToI < Blank
+    # : (Integer) -> void
+    def initialize: (Integer) -> void
+
+    # : () -> Integer
+    def to_i: () -> Integer
+  end
+
+  class ToInt < Blank
+    # : (Integer) -> void
+    def initialize: (Integer) -> void
+
+    # : () -> Integer
+    def to_int: () -> Integer
+  end
+
+  class ToS < Blank
+    # : (String) -> void
+    def initialize: (String) -> void
+
+    # : () -> String
+    def to_s: () -> String
+  end
+
+  class ToStr < Blank
+    # : (String) -> void
+    def initialize: (String) -> void
+
+    # : () -> String
+    def to_str: () -> String
+  end
+
+  # @rbs generic unchecked out T -- Type of elements
+  class ToA[unchecked out T] < Blank
+    # : (Array[T]) -> void
+    def initialize: (Array[T]) -> void
+
+    # : () -> String
+    def to_a: () -> String
+  end
+end

data/sig/generated/blankity/version.rbs

@@ -0,0 +1,5 @@
+# Generated from lib/blankity/version.rb with RBS::Inline
+
+module Blankity
+  VERSION: ::String
+end

data/sig/generated/blankity.rbs

@@ -0,0 +1,4 @@
+# Generated from lib/blankity.rb with RBS::Inline
+
+module Blankity
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: blankity
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- SamW
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+email:
+- mail@sampersand.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- Steepfile
+- lib/blankity.rb
+- lib/blankity/blank.rb
+- lib/blankity/classes.rb
+- lib/blankity/to.rb
+- lib/blankity/version.rb
+- sig/generated/blankity.rbs
+- sig/generated/blankity/blank.rbs
+- sig/generated/blankity/tos.rbs
+- sig/generated/blankity/version.rbs
+homepage: https://github.com/sampersand/blankity/blob/master
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/sampersand/blankity/blob/master
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.0.dev
+specification_version: 4
+summary: Helpers for creating types which _only_ respond to specific conversion methods
+test_files: []