rangesmaller 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb2dd52eccdf235b18ce0aa93c9a55fb4816eaf7
-  data.tar.gz: bccb5a3d21d6f41ee58cca2692cc06c77178df69
+  metadata.gz: 7a8fc91323af75d4f7492a97d055976a3f333edd
+  data.tar.gz: faaae7c9bdeddc5865edf8887b3daafcff404913
 SHA512:
-  metadata.gz: 187dd3c240b5cad7f8f084bcca0ba36f242d5a7d8ff9272e1fac16b36f535dc64c650ff66c88fc870ebec0e4b9afd7098edc430bcb11f6237d60d3d8350455dc
-  data.tar.gz: 6f3f41877a00fb9e17e5c4d8216c9b7224dd53289e42e2a257555fb01d1d3a7bcecd77abcca0176f32e251e07e98e58574c075aabd8cc6541d7c6e3af6dafbf4
+  metadata.gz: a9e077d5e101043cd3a2f379ae30d5fb652481f784e653060f85f7c1b71d20c7322fb485ef4110f5ff313fed4147af82ddfb1a30af76c476b0a7e1534bb0b575
+  data.tar.gz: 3c96ed1780b5dbccfea2d458c390646b8fc1dafc94855c4111b1224e31ae293e800d00cc001f947489bf133e66265f3411699db9f05ea824ddc3b3e2ef023f7c

data/ChangeLog

@@ -1,6 +1,12 @@
+-----
+(Version: v1.0.4)
+2014-04-25  Masa Saskano
+ * The methods ==() and eql?() now calls the method of the same name for each element, like Range and Array.
+
 -----
 (Version: v1.0.3)
-2014-04-24  Masa Saskano
+2014-04-24  Masa Sakano
+
  * Cosmetic minor changes.
 
 -----

data/lib/rangesmaller/rangesmaller.rb

@@ -25,8 +25,8 @@ class Rangesmaller < Range
   #   @param [Rangesmaller] key describe key param
   #
   # @overload new(range, opts)
-  #   @param range range [Range] standard Range object
-  #   @option opts opts [Object] :exclude_begin the begin boundary is excluded, if false (Default)
+  #   @param range [Range] standard Range object
+  #   @option opts [Object] :exclude_begin the begin boundary is excluded, if false (Default)
   #
   # @overload new(obj_begin, obj_end, exclude_end=false)
   #   This form is not recomended, but for the sake of compatibility with Range.
@@ -151,27 +151,17 @@ class Rangesmaller < Range
   end
 
 
-  # Like {Range}, returns true only if it is either {Rangesmaller} or {Range}, and in addition if both {#exclude_begin?} and {#exclude_end?} match between the two objects.
+  # Like {Range}, returns true only if it is either {Range} (or its subclasses), and in addition if both {#exclude_begin?} and {#exclude_end?} match between the two objects.
+  # See {#eql?}
   # @return [Boolean]
   def ==(r)
-    if defined? r.rangepart 
-      rangepart = r.rangepart 
-    else
-      rangepart = r
-    end
-
-    if super(rangepart)	# Check the Range part, ie., ignoring exclude_begin?
-      if defined? r.exclude_begin?
-        (@exclude_begin == r.exclude_begin?)	# && (exclude_end? == r.exclude_end?)
-      else
-        !  @exclude_begin
-      end
-    else
-      false
-    end
+    rs_equal_core(r, :==)
   end	# def ==(r)
 
-  alias :eql? :==
+  # The same as {:==} but uses eql?() as each comparison.
+  def eql?(r)
+    rs_equal_core(r, :eql?)
+  end	# def eql?(r)
 
 
   # See also {#cover?} and {Range#===}
@@ -555,6 +545,31 @@ class Rangesmaller < Range
       "<.."
     end
   end
+
+  # @param r [Object] to compare.
+  # @param method [Symbol] of the method name.
+  def rs_equal_core(r, method)
+    if ! defined? r.exclude_end?
+      false	# Not Range family.
+    elsif empty? && defined?(r.is_none?) && r.is_none?	# r is RangeOpen::NONE
+      true
+    elsif defined? r.exclude_begin?
+      (self.exclude_begin? ^! r.exclude_begin?) &&
+        (self.exclude_end? ^! r.exclude_end?) &&
+        (self.begin.send(method, r.begin)) &&
+        (self.end.send(  method, r.end))
+        # (self.begin == r.begin) &&
+        # (self.end == r.end)
+    else 
+      # r is Range
+      if self.exclude_begin?
+        false
+      else
+        @rangepart.send(method, r)	# Comparison as two Range-s.
+      end
+    end
+  end	# def rs_equal_core(r, method)
+
 end	# class Rangesmaller < Range
 
 
@@ -563,23 +578,182 @@ end	# class Rangesmaller < Range
 #
 class Range
 
-  alias :eql_orig? :==
+  alias :equal_prerangesmaller? :==
+
+  # When compared with either {Rangesmaller} object,
+  # it will deal with it.  For each element, that is, {#begin} and {#end},
+  # this uses ==() method of each element.  See {#eql?}.
+  def ==(r)
+    equal_core(r, :==, :equal_prerangesmaller?)
+  end
+
 
-  # When compared with a {Rangesmaller} object, it compares with {Rangesmaller#rangepart}.
-  # Namely, if {#begin}, {#end}, {#exclude_end?} agree between them and if {Rangesmaller#exclude_begin?} of the argument is false, it returns true, or false otherwise.
+  alias :eql_prerangesmaller? :eql?
+
+  # Same as {#==}, but the comparison is made with eql?() method.
   def eql?(r)
-    if defined? r.exclude_begin?
-      if r.exclude_begin?
+    equal_core(r, :eql?, :eql_prerangesmaller?)
+  end
+
+
+  ############## pravate methods of Range ##############
+
+  private
+
+  # Returns true if self is valid as a Range (or Rangesmaller or RangeOpen),
+  # even if it is empty.  To construct a valid range, the elements have to
+  # be Comparable, and {#end} is larger than, or equal to, {#begin}.
+  # 
+  # === Examples
+  # 
+  #    (nil..nil).valid? # => false
+  #    (0..0).valid?     # => true
+  #    (0...0).valid?    # => false
+  #    (2..-1).valid?    # => false
+  #    Rangesmaller(0...0, :exclude_begin => false)  # => false
+  #    Rangesmaller(0...0, :exclude_begin => true)   # => true
+  #    RangeOpen::NONE.valid? #=> true
+  #    RangeOpen(5).valid?    #=> true
+  #    RangeOpen::ALL.valid?  #=> true
+  #
+  # See {#empty?} and {#null?}
+  def valid?
+    if defined?(self.is_none?) && self.is_none?
+      return true
+    end
+    begin
+      t = (self.begin() <=> self.end())
+    rescue NoMethodError
+      false	# return
+    else
+      case t
+      when -1
+        true
+      when 0
+        if is_comparable?(self.begin())
+          if defined?(self.exclude_begin?)
+            t = self.exclude_begin?
+          else
+            t = false
+          end
+          (t ^! exclude_end?)	# True if single value or empty.
+        else
+          false		# Not Comparable; eg., nil..nil
+        end
+      when 1
         false
       else
-        eql_orig?(r)
+        false	# Not Comparable.
       end
+      # All statements of return above.
+    end
+  end	# def valid?
+
+
+  # Returns true if self is empty, namely, there is
+  # no possible member, and if it is still valid.
+  # If it is not valid, it returns nil.
+  # Otherwise, false.
+  #
+  # === Examples
+  #
+  #   (nil..nil).empty?       # => nil
+  #   Rangesmaller(1..2).empty?   # => false
+  #   Rangesmaller(1...2).empty?  # => nil
+  #   Rangesmaller(1...2,   :exclude_begin => true).empty?  => true
+  #   Rangesmaller(1.0...2, :exclude_begin => true).empty?  => true
+  #   Rangesmaller(1...2,   :exclude_begin => true).empty?  => true
+  #   Rangesmaller(1.0...2, :exclude_begin => true).empty?  => false
+  #   Rangesmaller(?a...?b, :exclude_begin => true).empty?  => true
+  #   RangeOpen::NONE.empty?  # => true
+  #
+  # @note to check whether it is either empty or invalid, use {#null?}.
+  #   See {#valid?}, too.
+  def empty?
+    if !valid?
+      return nil
+    elsif defined?(self.is_none?) && self.is_none?
+      return true
+    end
+
+    t = (self.begin() <=> self.end())
+    case t
+    when -1
+      if (defined?(self.exclude_begin?)) &&
+          exclude_begin? &&
+          exclude_end? &&
+          defined?(self.begin().succ) &&
+          (self.begin().succ == self.end())
+        true	# e.g., ("a"<..."b")
+      else
+        false
+      end
+    when 0
+      if defined?(self.boundary) && self.boundary.nil?
+        # RangeOpen::NONE or RangeOpen::All
+        if self.exclude_end?
+          true	# RangeOpen::Null
+        else
+          false	# RangeOpen::All
+        end
+      else
+        if defined?(self.exclude_begin?)
+          t2 = self.exclude_begin?
+        else
+          t2 = false
+        end
+        (t2 && exclude_end?)
+      end
+    when 1
+      nil
     else
-      eql_orig?(r)
+      nil	# eg. (nil..nil)
     end
-  end	# def :eql?(r)
-  alias :== :eql?
+  end	# def empty?
+
 
+  # Returns true if it is either empty or invalid.
+  # See {#empty?} and {#valid?}.
+  def null?
+    (! valid?) || empty?
+  end
+
+
+  # True if obj is Comparable.
+  def is_comparable?(obj)
+    if defined?(obj.<=)	# Comparable?
+      true
+    else
+      false
+    end
+  end
+
+  # @param r [Object] to compare.
+  # @param method [Symbol] of the method name.
+  # @param method_pre [Symbol] of the backed-up original method name.
+  def equal_core(r, method, method_pre)
+    if ! defined? r.exclude_end?
+      false	# Not Range family.
+    elsif defined? r.exclude_begin?
+      # Either Rangesmaller or RangeOpen object.
+      if r.exclude_begin?
+        false	# self(Range) has always the inclusive begin.
+      else
+        # It could do with a single line,
+        #    self.begin.send(method_pre, r)
+        # if this was for Rangesmaller===r, but not for RangeOpen.
+        if (self.exclude_end? ^ r.exclude_end?)
+          false
+        elsif (self.begin.send(method, r.begin) && self.end.send(method, r.end))
+          true
+        else
+          false
+        end
+      end
+    else
+      self.send(method_pre, r)	# r is Range.
+    end
+  end	# def equal_core(r, method, method_pre)
 end	# class Range
 
 

data/rangesmaller.gemspec

@@ -2,12 +2,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rangesmaller}
-  s.version = "1.0.3"
+  s.version = "1.0.4"
   # s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   # s.executables << 'hola'
   # s.bindir = 'bin'
   s.authors = ["Masa Sakano"]
-  s.date = %q{2014-04-24}
+  s.date = %q{2014-04-25}
   s.summary = %q{Rangesmaller class -- Range with include_begin?()}
   s.description = %q{This defines a subclass of Range, Rangesmaller class.  Users can define whether the begin boundary is exclusive or inclusive, in addition to the end boundary as in the standard Range.}
   # s.email = %q{abc@example.com}

data/test/test_rangesmaller.rb

@@ -1,5 +1,7 @@
 # -*- encoding: utf-8 -*-
 
+$stdout.sync=true
+$stderr.sync=true
 libfilebase = 'rangesmaller.rb'
 libfilepath = nil
 er=nil
@@ -200,6 +202,16 @@ p $LOADED_FEATURES.grep(/#{Regexp.quote(libfilebase)}$/)
       assert (sc1 != sc2)
     end	# def test_eql
 
+    def test_eql2
+      assert  ((1..2) == (1..2))
+      assert  ((1..2) == (1.0..2))
+      assert  ((1..2).eql? (1..2))	# 1==(1.0)     == true
+      assert !((1..2).eql? (1.0..2))	# 1.eql?(1.0)  == false
+      r12 = Rangesmaller(1..2, :exclude_begin => true)
+      assert  (r12.eql? Rangesmaller(1..2, :exclude_begin => true))
+      assert !(r12.eql? Rangesmaller(1.0..2, :exclude_begin => true))
+    end
+
     def test_begin
       assert_equal(@ib, @s11.begin)
       assert_equal(@ib, @s12.begin)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rangesmaller
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Masa Sakano
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-24 00:00:00.000000000 Z
+date: 2014-04-25 00:00:00.000000000 Z
 dependencies: []
 description: This defines a subclass of Range, Rangesmaller class.  Users can define
   whether the begin boundary is exclusive or inclusive, in addition to the end boundary