range_extd 1.0 → 2.0

data/test/test_range_extd_nowhere.rb

@@ -0,0 +1,84 @@
+# -*- encoding: utf-8 -*-
+
+$stdout.sync=true
+$stderr.sync=true
+# print '$LOAD_PATH=';p $LOAD_PATH
+arlibbase = %w(range_extd range_extd/nowhere.rb)	# range_extd/nowhere.rb is actually loaded from range_extd.  But by writing here, the absolute path will be displayed.
+
+arlibrelbase = arlibbase.map{|i| "../lib/"+i}
+
+arlibrelbase.each do |elibbase|
+  require_relative elibbase
+end
+
+print "NOTE: Running: "; p File.basename(__FILE__)
+print "NOTE: Library relative paths: "; p arlibrelbase
+arlibbase4full = arlibbase.map{|i| i.sub(%r@^(../)+@, "")}+%w(range_extd)
+puts  "NOTE: Library full paths for #{arlibbase4full.inspect}: "
+arlibbase4full.each do |elibbase|
+  ar = $LOADED_FEATURES.grep(/(^|\/)#{Regexp.quote(File.basename(elibbase))}(\.rb)?$/).uniq
+  print elibbase+": " if ar.empty?; p ar
+end
+
+
+#################################################
+# Unit Test
+#################################################
+
+require 'rational' if !defined?(Rational) # For Ruby 1.8
+
+gem "minitest"
+require 'minitest/autorun'
+
+class TestUnitNowhere < MiniTest::Test
+  T = true
+  F = false
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_nowhere
+    nowhere = RangeExtd::Nowhere::NOWHERE
+    assert(RangeExtd::Nowhere.instance.eql?(nowhere), "Const.id=#{RangeExtd::Nowhere::NOWHERE.__id__} nowhere.id=#{nowhere.__id__}; nil=#{RangeExtd::Nowhere::NOWHERE.nil?.inspect}=#{nowhere.nil?.inspect}; nowhere?=#{RangeExtd::Nowhere::NOWHERE.nowhere?.inspect}=#{nowhere.nowhere?.inspect}; hash=#{RangeExtd::Nowhere::NOWHERE.hash}=#{nowhere.hash}")
+    refute(nowhere.eql?(nil))
+    assert( nowhere == nil )
+    assert_equal 0, ( nowhere <=> nil )
+
+    assert nowhere.nowhere?
+    assert_equal RangeExtd::Nowhere, nowhere.class_raw
+    assert_equal NilClass,           nowhere.class
+
+    assert( nowhere )  # Unfortunately, there is no way in Ruby to make the object behave like false/nil in the conditional statement: see <https://stackoverflow.com/a/14449380/3577922>
+    assert( nowhere.nil? )
+    refute RangeExtd.valid?(RangeExtd::Nowhere::NOWHERE..nil), 'NOWHERE cannot reside in other than RangeExtd::NONE'
+  end	# def test_nowhere
+
+  # 'nil_class.rb' is always required, and so these should hold.
+  def test_nil_class
+    nowhere = RangeExtd::Nowhere::NOWHERE
+    refute(nil.eql?(nowhere))
+    assert( nil == nowhere )
+    assert_equal 0, ( nil <=> nowhere )
+
+    refute nil.nowhere?
+    assert_equal NilClass, nil.class_raw
+    assert_equal NilClass, nil.class
+  end  # def test_nil_class
+
+  ## when 'nil_class.rb' is not required, these are the cases.
+  #def test_nil_class
+  #  nowhere = RangeExtd::Nowhere::NOWHERE
+  #  refute(nil.eql?(nowhere))
+  #
+  #  refute(     nil == nowhere )
+  #  assert_nil( nil <=> nowhere )
+  #
+  #  refute nil.respond_to?(:nowhere?)
+  #  refute nil.respond_to?(:class_raw)
+  #  assert_equal NilClass, nil.class
+  #end  # def test_nil_class
+end # class TestUnitNowhere < MiniTest::Test
+

metadata

@@ -1,22 +1,24 @@
 --- !ruby/object:Gem::Specification
 name: range_extd
 version: !ruby/object:Gem::Version
-  version: '1.0'
+  version: '2.0'
 platform: ruby
 authors:
 - Masa Sakano
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-30 00:00:00.000000000 Z
+date: 2022-09-08 00:00:00.000000000 Z
 dependencies: []
-description: Package for a subclass of Range, RangeExtd and RangeExtd::Infinity.  The
-  former defines a range that enables an exclusion of the begin boundary, in addition
-  to the end boundary as in the built-in Range, and accepts open-ended ranges to infinity
-  for either (or both) positive/negative direction.  The latter has the two constant
-  objects, POSITIVE and NEGATIVE, and they are a generalised Infinity of Float::INFINITY
-  to any Comparable objects.
-email: 
+description: Package for a subclass of Range, RangeExtd, containing RangeExtd::Infinity
+  and RangeExtd::Nowhere. RangeExtd defines ranges that enable an exclusion of the
+  begin boundary, in addition to the end boundary as in the built-in Range, and accepts
+  open-ended ranges to infinity for either (or both) positive/negative direction.  The
+  open-ended boundaries are represented by two constant objects, POSITIVE and NEGATIVE
+  of RangeExtd::Infinity, and they are a generalised Infinity of Float::INFINITY to
+  any Comparable objects, which are in practice similar to built-in beginless/endless
+  Ranges.
+email:
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -30,15 +32,24 @@ files:
 - README.en.rdoc
 - README.ja.rdoc
 - Rakefile
-- lib/range_extd/infinity/infinity.rb
-- lib/range_extd/range_extd.rb
+- lib/range_extd.rb
+- lib/range_extd/infinity.rb
+- lib/range_extd/load_all.rb
+- lib/range_extd/nil_class.rb
+- lib/range_extd/nowhere.rb
+- lib/range_extd/numeric.rb
+- lib/range_extd/object.rb
+- lib/range_extd/range.rb
+- range_extd.gemspec
+- test/all_required_test.rb
 - test/test_range_extd.rb
+- test/test_range_extd_nowhere.rb
 homepage: https://www.wisebabel.com
 licenses:
 - MIT
 metadata:
   yard.run: yri
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--charset=UTF-8"
 require_paths:
@@ -47,16 +58,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: RangeExtd - Extended Range class with exclude_begin and open-ends
 test_files:
+- test/all_required_test.rb
 - test/test_range_extd.rb
+- test/test_range_extd_nowhere.rb

data/lib/range_extd/infinity/infinity.rb

@@ -1,392 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-if ! defined?(Rational)
-  require 'rational'	# For Ruby 1.8
-end
-
-# This file is required from range_open/range_open.rb
-class RangeExtd < Range
-  #
-  # =Class RangeExtd::Infinity
-  #
-  # Authors:: Masa Sakano
-  # License:: MIT
-  #
-  # ==Summary
-  #
-  # Class to hold just two constants: 
-  # * RangeExtd::Infinity::NEGATIVE
-  # * RangeExtd::Infinity::POSITIVE
-  # and two more:
-  # * FLOAT_INFINITY  (OBSOLETE; workaround for Ruby 1.8 to represent Float::INFINITY)
-  # * CLASSES_ACCEPTABLE (see below)
-  #
-  # There is no other object in this class (you can not create a new one).
-  #
-  # This class includes Comparable module.
-  #
-  # ==Description
-  #
-  # Both the two constant are an abstract value which is always smaller/larger,
-  # respectively, than any other Comparable objects (1 or -1 by i{#<=>}(obj))
-  # except for infinities with the same polarity, that is, positive or negative,
-  # in which case 0 is returned.
-  # See the document of the method {#==} for the definition of "infinity".
-  # Also, {#succ} is defined, which just returns self.
-  #
-  # There is a note of caution.
-  # The method {#<=>} is defined in this class as mentioned above.
-  # However any operator is, by Ruby's definition, not commutative,
-  # unless both the classes define so.
-  #
-  # There are only three built-in classes that are Comparable: String, Time and Numeric
-  # (except for Complex).
-  # Note Date and DateTime objects are so, too, however practically
-  # they need "require", hence are (and must be) treated, the same as any other class.
-  # For String and Time class objects, the [#<=>] operator work as expected
-  # in the commutative way.
-  #    ?z <=> RangeExtd::Infinity::POSITIVE    # => nil
-  #    RangeExtd::Infinity::POSITIVE <=> ?z    # => 1.
-  #
-  # For Numeric, it does not.
-  #    50 <=> RangeExtd::Infinity::POSITIVE    # => nil
-  #    RangeExtd::Infinity::POSITIVE <=> 50    # => 1.
-  #
-  # For that reason, for example,
-  #   ( 50 .. RangeExtd::Infinity::POSITIVE)
-  # raises an exception, because the Numeric instance 50 does not
-  # know how to compare itself with a RangeExtd::Infinity instance,
-  # and Range class does not allow such a case.
-  #
-  # For Numeric, this is deliberately so.
-  # Please use {Float::INFINITY} instead in principle;
-  # it will be a lot faster in run-time, though it is
-  # perfectly possible for you to implement the feature
-  # in Numeric sub-classes, if need be.
-  #
-  # Any other Comparable classes are defined by users by definition,
-  # whether you or authors of libraries.
-  # The comparison with {RangeExtd::Infinity} instances are
-  # implemented in {Object#<=>} in this library.  Hence, as long as
-  # the method [#<=>] in the classes is written sensibly, that is, if it
-  # respects the method of the super-class when it does not know
-  # how to deal with an unknown object, there is no need for
-  # modification.  Any object in your class (say, YourComparable) 
-  # is immediately comparable with the {RangeExtd::Infinity} instances,
-  #    YourComparable.new <=> RangeExtd::Infinity::POSITIVE    # => -1
-  #    RangeExtd::Infinity::POSITIVE <=> YourComparable.new    # => 1
-  # except for the infinity inscances in YourComparable (see {#==}).
-  #
-  # See the document in {Object#<=>} in this code/package for detail.
-  #
-  # However, some existing Comparable classes, perhaps written by some
-  # one else may not be so polite, and has disabled comparison
-  # with any object but those intended.  Unlucky you!
-  # For example, the classes like Date and DateTime are one of them.
-  #
-  # For that sort of circumstances,
-  # the class method {RangeExtd::Infinity.overwrite_compare} provides
-  # a convenient way to overcome this problem to make
-  # the operator [#<=>] commutative for a given Comparable class.
-  #
-  # Note {RangeExtd::Infinity.overwrite_compare} does nothing for the classes
-  # registered in the Class constant Array {RangeExtd::Infinity::CLASSES_ACCEPTABLE}.
-  # So, if you want to avoid such modification of the method [#<=>], perhaps
-  # by some other end users, you can register the class in that array.
-  #
-  # Only the methods defined in this class are
-  # {#===}, {#==}, {#<=>}, {#succ}, {#to_s}, {#inspect},
-  # {#infinity?}, {#positive?} and {#negative?}.
-  #
-  # Note that the unary operand [#-@] is not defined.
-  #
-  class Infinity
-  
-    include Comparable
-
-    # Obsolete Constant FLOAT_INFINITY (for the sake of Ruby 1.8 or earlier).
-    # Please do not use it - it will be removed some time in the future.
-    # n.b., Module#private_constant is introduced in Ruby 1.9.3.
-    begin
-      FLOAT_INFINITY = Float::INFINITY 
-    rescue	# Ruby 1.8 or earlier.
-      FLOAT_INFINITY = 1/0.0
-    end
-
-    # Class that accept to be compared with Infinity instances.
-    CLASSES_ACCEPTABLE = [self, Float, Integer, Rational, Numeric, String]  # Fixnum, Bignum deprecated now.
-    # CLASSES_ACCEPTABLE = [self, Float, Fixnum, Bignum, Rational, Numeric, String]	# , BigFloat
-    CLASSES_ACCEPTABLE.push BigFloat if defined? BigFloat
-
-    def infinity?
-      true
-    end
-  
-    def positive?
-      @positive 
-    end
-  
-    def negative?
-      !@positive 
-    end
-
-    alias_method :cmp_before_rangeextd_infinity?, :==  if ! self.method_defined?(:cmp_before_rangeextd_infinity?)	# No overwriting.
-
-    # Always -1 or 1 except for itself and the corresponding infinities (== 0).  See {#==}.
-    # Or, nil (as defined by Object), if the argument is not Comparable, such as, nil and IO.
-    # @return [Integer, nil]
-    def <=>(c)
-      if c.nil?
-        super
-      elsif !defined?(c.<=)	# Not Comparable?
-        super
-      elsif @positive 
-        if self == c
-          0
-        else
-          1
-        end
-      else	# aka negative
-        if self == c
-          0
-        else
-          -1
-        end
-      end
-    end
-  
-    # Always false except for itself and the corresponding {Float::INFINITY}
-    # and those that have methods of {#infinity?} and {#positive?}
-    # with the corresponding true/false values, in which case this returns true.
-    def ==(c)
-      if (Infinity === c)
-        (@positive ^! c.positive?)	# It should be OK to compare object_id?
-      elsif c ==  FLOAT_INFINITY &&  @positive
-        true
-      elsif c == -FLOAT_INFINITY && !@positive
-        true
-      elsif defined?(c.infinity?) && defined?(c.positive?)
-        (c.infinity? && (@positive ^! c.positive?))
-      else
-        false
-      end
-    end
-  
-    # Equivalent to {#==}
-    def ===(c)
-      self == c
-    end
-  
-    # @return [Infinity] self
-    def succ
-      self
-    end
-  
-    # @return [String]
-    def inspect
-      if @positive 
-        "INFINITY"
-      else
-        "-INFINITY"
-      end
-    end
-  
-    alias_method :to_s, :inspect
-  
-
-  # Overwrite [#<=>] method of the given class, if necessary,
-  # to make its instances be comparable with RangeExtd::Infinity objects (constants).
-  # For example,
-  #   RangeExtd::Infinity::NEGATIVE.<=>(any_comparable)
-  # always gives back -1 (except for same infinities).  However the other way around,
-  #   SomeClass.new.<=>(RangeExtd::Infinity::NEGATIVE)
-  # usually returns nil, which is not handy.
-  # Therefore, this function (Class method) provides a convenient
-  # way to overcome it, that is, if the given class
-  # (or the class of the given object) is Comparable,
-  # its [#<=>] method is modified (and true is returned),
-  # unless it has been already done so, or some classes as listed below,
-  # such as Numeric and String, in which case nil is returned.
-  # If it is not Comparable, false is returned.
-  # The judgement whether it is Comparable or not is based
-  # whether the class has an instance method ThatClass#<=
-  #
-  # In processing, this method first looks up at an Array
-  # {RangeExtd::Infinity::CLASSES_ACCEPTABLE},
-  # and if the given class is registered in it,
-  # it does nothing.  If not, and if all the othe conditions
-  # are met, it overwrites its <=> method and register
-  # the class in the array.
-  #
-  # @param obj [Object] Either Class or its object.
-  # @return [Boolean, nil] (see the description).
-  def self.overwrite_compare(obj)
-    if defined? obj.instance_methods
-      klass = obj
-    else
-      klass = obj.class
-
-      begin
-        _ = 1.0 + obj	# Use  "rescue ArgumentError"  if using "1.0<obj"
-        return nil	# No change for Numeric
-      rescue TypeError
-      end
-    end		# if defined? obj.instance_methods
-
-    # [Numeric, Fixnum, Bignum, Float, Rational, String, Complex].each do |i|	# , BigFloat
-    (self::CLASSES_ACCEPTABLE+[self]).each do |i|	# , BigFloat
-      # The class itself (RangeExtd::Infinity) must be rejected!
-      # Otherwise the rewrites itself, and may cause an infinite loop.
-      # In fact it is pre-defined in RangeExtd::Infinity, so the above addition is a duplication - just to make sure.
-      return nil if i == klass		# No change for Numeric etc
-      # Built-in String, Numeric etc try to flip over "<=>" if it doesn't know the object!
-    end
-    self::CLASSES_ACCEPTABLE.push(klass)	# The class is registered, so it would not come here again for the class.
-
-    a = klass.instance_methods
-    if !a.include?( :<= )	# NOT Comparable
-      return false
-    elsif a.include?(:compare_before_infinity)
-      return nil
-    else
-      # Overwrite the definition of "<=>" so that it is fliped over for Infinity.
-
-      code = <<__EOF__
-  alias_method :compare_before_infinity, :<=> if ! self.method_defined?(:compare_before_infinity)
-  def <=>(c)
-    if defined?(self.<=) && RangeExtd::Infinity === c
-      if defined?(self.infinity?) && defined?(self.positive?)
-        if (self.positive? ^! c.positive?)
-          0
-        elsif self.positive?
-          1
-        else
-          -1
-        end
-      else
-        if c.positive?
-          -1
-        else
-          1
-        end
-      end
-    else
-      compare_before_infinity(c)
-    end
-  end
-__EOF__
-#<<__EOF__	# for Emacs hilit.
-
-      klass.class_eval(code)
-
-      true
-    end
-  end	# def self.overwrite_compare(obj)
-
-
-    private
-  
-    def initialize(t)
-      @positive = (t && true)
-    end
-  
-    NEGATIVE = new(false)
-    POSITIVE = new(true)
-
-    #NEGATIVE.freeze
-    #POSITIVE.freeze
-
-  end	# class Infinity
-  
-  
-  class Infinity
-    # Disable new() so no other object will be created.
-    private_class_method :new
-  
-    warn_level = $VERBOSE
-    begin
-      $VERBOSE = nil	# Suppress the warning in the following line.
-      remove_method :initialize
-    ensure
-      $VERBOSE = warn_level
-    end
-    #undef_method :initialize
-
-  end	# class Infinity
-  
-end	# class RangeExtd < Range
-
-
-#
-# = class Object
-#
-# Overwrite {Object#<=>}() so all its sub-classes can be
-# aware of {RangeExtd::Infinity} objects (the two constants).
-#
-class Object
-  alias_method :compare_obj_before_infinity, :<=>  if ! self.method_defined?(:compare_obj_before_infinity)	# No overwriting.
-
-  # Overwrite {Object#<=>}().  Then, all its sub-classes can be
-  # aware of RangeExtd::Infinity objects (the two constants).
-  #
-  # In this definition of {#<=>}, if self is Comparable
-  # (by judging whether it has the method [#<=]),
-  # it always returns, unless infinity? and positive? are set
-  # accordingly, either -1 or 1, depending which of
-  #   RangeExtd::Infinity::(NEGATIVE|POSITIVE)
-  # is compared.  If self is not Comparable, the original [#<=>]
-  # is called, which should return nil (unless both the object_id
-  # agree, eg., nil and nil, in which case 0 is returned).
-  #
-  # If you define your own class, which is Comparable, you should
-  # define the method "<=>" as follows, as in the standard practice
-  # when you redefine a method that exists in a superclass;
-  #
-  # @example A method definition of user-defined Comparable class
-  #    class MyComparableClass 
-  #      include Comparable
-  #      # alias :cmp_orig :<=> if !self.method_defined?(:cmp_orig)	# if you want
-  #      def <=>(c)
-  #        if c._is_what_i_expect?
-  #          # Write your definition.
-  #        else       # When self does not know what to do with c.
-  #          super    # to call Object#<=>
-  #        end
-  #      end
-  #    end
-  #
-  def <=>(c)
-    if defined?(self.<=) && RangeExtd::Infinity === c
-      # if defined?(self.<=) && defined?(c.infinity?) && defined?(c.positive?)
-      # NOTE: Duck-typing is inappropriate here.
-      #   Only the objects that self wants to deal with here are
-      #   the instances of RangeExtd::Infinity, and not other
-      #   "infinity" object, such as, Float::INFINITY.  So,
-      #     (self <=> RangeExtd::Infinity::POSITIVE)  # => -1
-      #     (self <=> Float::INFINITY)                # => nil
-      #   in default.
-      if defined?(self.infinity?) && defined?(self.positive?)
-        if (self.positive? ^! c.positive?)
-          0
-        elsif self.positive?
-          1
-        else
-          -1
-        end
-      else
-        # (c <=> self) * (-1)
-        if c.positive?
-          -1
-        else
-          1
-        end
-      end
-    elsif object_id == c.object_id	# (nil <=> nil)  # => 0
-      0
-    else
-      nil
-    end	# if defined?(self.<=) && RangeExtd::Infinity === c
-  end	# def <=>(c)
-end	# class Object
-
-