inform-runtime 1.0.4

data/lib/runtime/mixins.rb

@@ -0,0 +1,570 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# Copyright Nels Nelson 2008-2023 but freely usable (see license)
+#
+# This file is part of the Inform Runtime.
+#
+# The Inform Runtime is free software: you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# The Inform Runtime is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with the Inform Runtime.  If not, see <http://www.gnu.org/licenses/>.
+
+
+JoinedTemplate = '%<str>s%<other>s'.freeze
+ObjectIdentityTemplate = '#<%<klass>s:%<name>s:0x%<hex>x:%<id>d>'.freeze
+ObjectIdentityAttributes = %i[name].freeze
+AttributeTemplate = '@%<key>s=%<value>s'.freeze
+
+# These are mixins to support Inform standard library built-ins and some
+# so-called least-surprise idiomatic methods.
+class Object
+  def +(other)
+    format(JoinedTemplate, str: self.to_s, other: other.to_s)
+  end
+
+  def identity
+    identification = { klass: self.class }
+    identifier = (self.respond_to?(:object?) && self.object? ? self.id : self.object_id) || 0
+    identification[:name] = (self.respond_to?(:name) ? self.name : nil) || 'unnamed'
+    identification[:hex] = identifier << 1
+    identification[:id] = identifier
+    format(ObjectIdentityTemplate, identification)
+  end
+
+  def number?
+    self.to_s.match?(/\A[+-]?\d+?(\.\d+)?\Z/)
+  end
+
+  def positive?
+    # TODO: This might be as simple as:
+    # self.to_i.positive?
+    self.to_s.match?(/\A+?\d+?(\.\d+)?\Z/)
+  end
+
+  def negative?
+    # TODO: This might be as simple as:
+    # self.to_i.negative?
+    self.to_s.match?(/\A-?\d+?(\.\d+)?\Z/)
+  end
+
+  def blank?
+    respond_to?(:empty?) ? empty? : self.nil?
+  end
+end
+
+# The NilClass class
+class NilClass
+  def +(other)
+    case other
+    when String then format(JoinedTemplate, str: self.to_s, other: other.to_s)
+    when Integer then 0 + other
+    when Enumerable then [] + other
+    else format(JoinedTemplate, str: self.to_s, other: other.to_s)
+    end
+  end
+
+  def -(other)
+    case other
+    when String then self.to_s.delete other
+    when Integer then 0 - other
+    when Enumerable then [] - other
+    else self.to_s.delete other
+    end
+  end
+
+  def >(other, default = false)
+    other < 0
+  #   return default unless other.respond_to? __method__
+  #   0.send(__method__, other)
+  rescue StandardError => _e
+    default
+  end
+
+  def >=(other, default = false)
+    other <= 0
+  #   return default unless other.respond_to? __method__
+  #   0.send(__method__, other)
+  rescue StandardError => _e
+    default
+  end
+
+  def <(other, default = false)
+    other > 0
+  #   return default unless other.respond_to? __method__
+  #   0.send(__method__, other)
+  rescue StandardError => _e
+    default
+  end
+
+  def <=(other, default = false)
+    other >= 0
+  #   return default unless other.respond_to? __method__
+  #   0.send(__method__, other)
+  rescue StandardError => _e
+    default
+  end
+
+  # def & (other)
+  #   0 & other
+  #   # return self unless other.respond_to? __method__
+  #   # 0.send(__method__, other) rescue self
+  # end
+
+  # def | (other)
+  #   0 | other
+  #   # return self unless other.respond_to? __method__
+  #   # 0.send(__method__, other) rescue self
+  # end
+
+  # Incompatible with RubyUnits::Unit#to_base
+  # def *(other)
+  #   0 * other
+  #   return self unless other.respond_to? __method__
+  #   0.send(__method__, other) rescue self
+  # end
+
+  def [](_key)
+    self
+  end
+
+  def []=(_key, _value)
+    self
+  end
+
+  def to_ary
+    []
+  end
+
+  def to_i
+    0
+  end
+
+  def to_f
+    0.0
+  end
+
+  def to_str
+    self.to_s
+  end
+
+  def to_sym
+    self
+  end
+
+  alias intern to_sym
+  def empty?
+    true
+  end
+
+  include Enumerable
+
+  def each(*_args, &_block)
+    return # Don't do anything, I'm nil
+  end
+
+  def join(s)
+    [].join(s)
+  end
+
+  def refresh
+    self
+  end
+end
+# class NilClass
+
+# The TrueClass class
+class TrueClass
+  def +(other)
+    format(JoinedTemplate, str: self.to_s, other: other.to_s)
+  end
+
+  def >(other)
+    other < 1
+  rescue StandardError => _e
+    false
+  end
+
+  def <(other)
+    other > 1
+  rescue StandardError => _e
+    false
+  end
+
+  def to_i
+    1
+  end
+
+  def to_f
+    1.0
+  end
+end
+
+# The FalseClass class
+class FalseClass
+  def +(other)
+    format(JoinedTemplate, str: self.to_s, other: other.to_s)
+  end
+
+  def >(other)
+    other < 0
+  rescue StandardError => _e
+    false
+  end
+
+  def <(other)
+    other > 0
+  rescue StandardError => _e
+    false
+  end
+
+  # Don't do this, it will almost definitely break a lot of things.
+  # def ==(other)
+  #   other.number? && other.to_i == 0
+  # rescue StandardError => _e
+  #   false
+  # end
+
+  def to_i
+    0
+  end
+
+  def to_f
+    0.0
+  end
+end
+
+# The Numeric class
+class Numeric
+  def commas(delimiter = ',')
+    parts = self.to_s.split('.')
+    parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, format(JoinedTemplate, str: '\1', other: delimiter))
+    parts.join('.')
+  end
+end
+
+# The Integer class
+class Integer
+  alias equals_operator ==
+  def ==(other)
+    case other
+    when NilClass, FalseClass then self == 0
+    when TrueClass then self == 1
+    else equals_operator(other)
+    end
+  end
+
+  alias lessthan_operator <
+  def <(other)
+    case other
+    when NilClass, FalseClass then self < 0
+    when TrueClass then self < 1
+    else lessthan_operator(other)
+    end
+  end
+
+  alias lessthanorequal_operator <=
+  def <=(other)
+    case other
+    when NilClass, FalseClass then self <= 0
+    when TrueClass then self <= 1
+    else lessthanorequal_operator(other)
+    end
+  end
+
+  alias greaterthan_operator >
+  def >(other)
+    case other
+    when NilClass, FalseClass then self > 0
+    when TrueClass then self > 1
+    else greaterthan_operator(other)
+    end
+  end
+
+  alias greaterthanorequal_operator >=
+  def >=(other)
+    case other
+    when NilClass, FalseClass then self >= 0
+    when TrueClass then self >= 1
+    else greaterthanorequal_operator(other)
+    end
+  end
+
+  alias plus_operator +
+  def +(other)
+    case other
+    when String then format(JoinedTemplate, str: self.to_s, other: other.to_s)
+    when NilClass, FalseClass then self + 0
+    when TrueClass then self + 1
+    else plus_operator(other)
+    end
+  end
+
+  def number?
+    true
+  end
+
+  # Some math constants
+  N_BYTES = [42].pack('i').size unless defined? N_BYTES
+  N_BITS = N_BYTES * 8 unless defined? N_BITS
+  MAX = (2**(N_BITS - 2)) - 1 unless defined? MAX
+  MIN = -MAX - 1 unless defined? MIN
+end
+
+# The String class
+class String
+  def +(other)
+    format(JoinedTemplate, str: self, other: other)
+  end
+
+  # Replace the second of three capture groups with the given block.
+  def midsub(regexp, &_block)
+    self.gsub(regexp) { '\1' + yield('\2') + '\3' }
+  end
+
+  def sentence_case
+    self.capitalize
+  end
+
+  def poststrip
+    self.gsub(/\s+$/, '')
+  end
+
+  def poststrip!
+    self.gsub!(/\s+$/, '')
+  end
+
+  def prestrip
+    self.gsub(/^\s+/, '')
+  end
+
+  def prestrip!
+    self.gsub!(/^\s+/, '')
+  end
+
+  def to_n
+    /\./.match?(self) ? self.to_f : self.to_i
+  end
+
+  DefaultUnderscoreOptions = {
+    downcase: true
+  }.freeze
+
+  def underscore(options = {})
+    options = DefaultUnderscoreOptions.merge(options)
+    return snake_case if options[:downcase]
+    self
+      .gsub(/::/, '/')
+      .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      .gsub(/([a-z\d])([A-Z])/,'\1_\2')
+      .tr(' -', '_')
+  end
+
+  def snake_case
+    self
+      .gsub(/::/, '/')
+      .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      .gsub(/([a-z\d])([A-Z])/,'\1_\2')
+      .tr(' -', '_')
+      .downcase
+  end
+
+  def titleize
+    self.split(/[\W_]/).map(&:capitalize).join(' ')
+  end
+
+  def camelize(_s = nil)
+    self.downcase.split(/[^a-z0-9]/).inject('') do |str1, str2|
+      str2.length > 1 ? [str1, str2[0].chr.upcase, str2[1..]].join : str1.to_s
+    end
+  end
+
+  def dequote
+    self.gsub(/(\A['"]|['"]\Z)/, '')
+  end
+
+  def save(file)
+    File.write(file, self)
+  end
+
+  HumanUnits = { b: 'bytes', kb: 'kilobytes', mb: 'megabytes', gb: 'gigabytes', tb: 'terabytes' }.freeze
+  HumanUnitsRegex = /(#{HumanUnits.keys.join('|')})/i.freeze
+
+  def to_human
+    scalar, unit = self.split
+    unit.sub!(HumanUnitsRegex) { |s| HumanUnits[s.downcase.to_sym] }
+    [scalar.to_f.commas, unit].join(' ')
+  end
+end
+# class String
+
+# The Symbol class
+class Symbol
+  def +(other)
+    format(JoinedTemplate, str: self.to_s, other: other.to_s)
+  end
+
+  def to_n
+    to_s.to_n
+  end
+
+  def underscore(options = {})
+    to_s.underscore(options)
+  end
+
+  def snake_case
+    to_s.snake_case
+  end
+
+  def titleize
+    to_s.titleize
+  end
+
+  def camelize(_s = nil)
+    to_s.camelize
+  end
+
+  def dequote
+    to_s.dequote
+  end
+
+  def save(file)
+    to_s.save file
+  end
+end
+
+CommaSpaceString = ', '.freeze
+ListCommaTemplate = '%<str>s, %<other>s %<last>s'.freeze
+ListSansCommaTemplate = '%<str>s, %<other>s %<last>s'.freeze
+SentenceTemplate = '%<str>s %<other>s %<last>s'.freeze
+
+# The Array class
+class Array
+  alias plus_operator +
+  def +(other)
+    case other
+    when String then self.to_s + other
+    else plus_operator(other)
+    end
+  end
+
+  def sum(&block)
+    return inject(0, &block) if block_given?
+    inject(:+)
+  end
+
+  def average
+    return self.first if self.length == 1
+    (self.sum / self.length.to_f)
+  end
+
+  def having(method)
+    select { |a| a.respond_to? method.to_sym }
+  end
+
+  def identities
+    map { |o| "#{o} [#{o.identity}]" }
+  end
+
+  def longest_length
+    inject(0) do |max, x|
+      [x.to_s.length, max].max
+    end
+  end
+
+  def pad(min = 1, max = longest_length + min)
+    each do |x|
+      yield(format(JoinedTemplate, str: x.to_s, other: ' ' * [max - x.to_s.length, min].max), x)
+    end
+  end
+
+  def to_sentence(conjunction = 'and')
+    case length
+    when 0 then ''
+    when 1 then self.first.dup.to_s
+    when 2
+      format(SentenceTemplate, str: self[0], other: conjunction, last: self[1])
+    else
+      format(SentenceTemplate, str: self[0...].join(CommaSpaceString), other: conjunction, last: self[-1])
+    end
+  end
+
+  alias ruby_to_s to_s
+  def to_s(separator = CommaSpaceString)
+    # This will make it possible to print Lists nicely, but not screw up
+    # the behavior of the List.
+    map(&:to_s).join(separator)
+  end
+
+  alias random sample
+end
+# class Array
+
+# The EmptyImmutableEnumerable class
+class EmptyImmutableEnumerable
+  def initialize(klass)
+    @subject = klass.new.freeze
+  end
+
+  def respond_to_missing?(method)
+    @subject.respond_to?(method)
+  end
+
+  def method_missing(method, *args, &block)
+    return @subject.send(method, *args, &block) if @subject.respond_to?(method)
+    super
+  rescue StandardError => _e
+    args.first
+  end
+end
+
+# The Array class
+class Array
+  Empty = EmptyImmutableEnumerable.new(Array)
+end
+
+# The Hash class
+class Hash
+  Empty = EmptyImmutableEnumerable.new(Hash)
+
+  def sort
+    keys.sort.each { |k| self[k] = self.delete(k) }
+    self
+  end
+
+  MethodBooleanPattern = %r{\?$}.freeze
+  MethodWriterPattern = %r{=$}.freeze
+
+  # TODO: Test
+  # def method_missing(method, *args, &block)
+  #   m = method.to_s
+  #   return false if MethodBooleanPattern.match?(m)
+  #   mname = MethodWriterPattern.match?(m) ? m.chop : m
+  #   property = mname.to_sym
+  #   if MethodWriterPattern.match?(m)
+  #     self[mname] = *args
+  #   elsif self.key?(mname)
+  #     self.fetch(mname, Hash::Empty)
+  #   elsif self.key?(property)
+  #     self.fetch(property, Hash::Empty)
+  #   else
+  #     super
+  #   end
+  # end
+end
+
+# The Set class
+class Set
+  alias ruby_to_s to_s
+  def to_s(separator = CommaSpaceString)
+    to_a.to_s(separator)
+  end
+end