rangesmaller 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fc2c175fd0a6852787d486eb15569707b6120222
+  data.tar.gz: ffeacff7e8c94e70a96723a34525f6a1a31ba055
+SHA512:
+  metadata.gz: e2e4c8422b98bde05a3caae8c8e4c143ad6a495b30f0930f69f972f5a0ac4085a87d3f2b1b55ebb0d35ba4ffc95edd90ae162917097ee6e8397dbb117328660a
+  data.tar.gz: 1b7f0a09ccd0e66acee41ea4ef08a9d87c5579a4dc47bcbaf2830cae14974bf71d47ca7eee176f28689e6e0ce29acb7b5b4c56799c6c0608cffe9b47de86eebe

data/README.rdoc

@@ -0,0 +1,91 @@
+= Rangesmaller - Range with exclude_begin
+
+This package contains Rangesmaller class, a sub-class of Range and that behaves almost exactly like the super-class Range class, but holds an additional status of whether the boundary of the beginning of the object is included or excluded.
+
+Rangesmaller objects are immutable, just like Range.  Hence once the object is created, it would not change.
+
+Any (pair of) objects that can consist of Range can be given in initialising, though that does not mean it would always successfully run any methods, like (nil..nil).each().
+
+Two methods are added from the original Range:
+
+  :exclude_begin?  # => true or false(Default)
+  :rangepart       # Range object without the flag of :exclude_begin?
+
+In default, both the begin and end boundaries are inclusive, unless specified otherwise in creating it.
+
+== Install
+
+  gem install rangesmaller
+
+A file
+  rangesmaller/rangesmaller.rb
+should be installed in one of your $LOAD_PATH
+
+Then all you need to do now is
+  require 'rangesmaller'
+in your Ruby script (or irb).
+
+Have fun!
+
+== Simple Example
+
+=== How to create an instance
+
+Almost all you need to know is this:
+
+   r = Rangesmaller(5...8, :exclude_begin => true) 
+   r.exclude_begin?  # => true 
+
+Other forms are as follows:
+
+  r1 = Rangesmaller.new((r0=(1..5)), :exclude_begin => false)
+  r2 = Rangesmaller.new(r1)
+  r3 = Rangesmaller.new(1, 5, exclude_end=false)    # This form is not recomended (only for compatibility with Range).
+  r4 = Rangesmaller.new(1, 5, :exclude_begin => true, :exclude_end => false)
+  r5 = Rangesmaller(    1, 5, :exclude_begin => true) 
+  r7 = Rangesmaller.new((?a...?z), :exclude_begin => true)
+  r8 = Rangesmaller.new(r0, :exclude_end => true)   # => warning (r0.exclude_end? is used)
+
+Note: in the last example of new(), it issues a warning.
+In this case a Range object is given in new(); accordingly the status of :exclude_end? of the created Rangesmaller object is inherited from the given Range object, whereas the option given contradicts to it.  What you should do instead is,
+
+  r8 = Rangesmaller.new(r0.begin, r0.end, :exclude_end => true)
+
+They are evaluated as follows:
+
+  r1 == r0   # => true
+  r1 == r2   # => true
+  r1 == r3   # => true
+  r1 == r8   # => true
+  r1 == r4   # => false
+  r4 == r5   # => true
+
+  r1.exclude_end?      # => false
+  r1.exclude_begin?    # => false
+  r4.exclude_begin?    # => true
+  r1.rangepart    # => (1..5)
+  r4.rangepart    # => (1..5)
+
+=== General operation
+
+  s1 = Rangesmaller(1..5, :exclude_begin => true)	# => 1<...5
+  s1.size     # => 3
+  s1.to_a     # => [2, 3, 4]
+  s1.begin    # => 1
+  s1.first(2) # => [2, 3]
+  s1.max{|a,b| -a<=>-b}   # => 2
+
+
+== Known bugs
+
+ * hash() method does not always guarantee to creat a unique number for the equal Rangesmall object, though such an exception is extremely unlikely to happen.
+ * No thorough test for Ruby 1.8 or earlier has been done, although there is no known fault.
+
+
+== Copyright etc
+
+Author::  Masa Sakano < imagine a_t sakano dot co dot uk >
+License:: The same as Ruby.  www.ruby-lang.org
+Warranty:: No warranty whatsoever.
+
+

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test
+

data/lib/rangesmaller/rangesmaller.rb

@@ -0,0 +1,561 @@
+# -*- encoding: utf-8 -*-
+
+# =Class Rangesmaller
+#
+# Authors:: Masa Sakano
+# License:: MIT
+#
+# ==Summary
+#
+# Range with inclusion of include_begin?().
+#
+# Namely, the first element can be tagged as excluded, if specified so.
+# It behaves the same as Range.  Note the method first() (hence each(), size() etc) behaves accordingly, depending whether the smallest boundary is excluded or not (default).
+#
+# ==Examples
+#
+# An instance of a range of 5 to 8 with both ends being exclusive is created as
+#
+#   r = Rangesmaller(5...8, :exclude_begin => true) 
+#   r.exclude_begin?  # => true 
+#
+class Rangesmaller < Range
+
+  # @overload new(rangesmaller)
+  #   @param [Rangesmaller] key describe key param
+  #
+  # @overload new(range, opts)
+  #   @param [Range] standard Range object
+  #   @option opts [Object] :exclude_begin the begin boundary is excluded, if false (Default)
+  #
+  # @overload new(begin, end, exclude_end=false)
+  #   This form is not recomended, but for the sake of compatibility with Range.
+  #   @param [Object] Any object (preferably {#Comparable})
+  #   @param [Object] Any object, compatible with begin
+  #   @param [Object] true or false(Default) or any.
+  #
+  # @overload new(begin, end, opts)
+  #   @param [Object] Any object (preferably {#Comparable})
+  #   @param [Object] Any object, compatible with begin
+  #   @param [Hash] see below
+  #   @option opts [Object] :exclude_end the end boundary is excluded, if false (Default)
+  #   @option opts [Object] :exclude_begin the begin boundary is excluded, if false (Default)
+  #
+  # @note The above-mentioned "any" object means any object that can consist of Range.
+  #   For example, (nil..nil) is accepted, but (Complex(2,3)..Complex(2,3)) is not.
+  #
+  def initialize(*inar)
+
+    @rangepart = nil	# Defined here only if Range is given as
+      # (a part of) the arguments, and in that case it will be
+      # the same object.  If not, left undefined,
+      # but will be defined once rangepart() is called.
+      # Note: it is entirely possible to set @rangepart here if wanted,
+      #  but there is no point to do that, providing no method
+      #  uses @rangepart explicitly, but only via rangepart().
+    @exclude_begin = false	# Default
+
+    case inar.size
+    when 1	# Arg: (Rangesmaller or Range)
+      r = inar[0]
+      if defined?(r.rangepart) && defined?(r.exclude_begin?)
+        # Rangesmaller
+        @exclude_begin = r.exclude_begin?
+        @rangepart = r.rangepart
+        r = @rangepart
+        super(r.begin, r.end, r.exclude_end?)
+      else
+        # Range
+        if defined?(r.begin) && defined?(r.end) && defined?(r.exclude_end?)
+          super(r.begin, r.end, r.exclude_end?)
+          @rangepart = r
+        else
+          raise ArgumentError, "bad (first) value for Rangesmaller"
+        end
+      end
+
+    when 2
+      r = inar[0]
+      if defined? r.exclude_end?
+	# Arg: (Range, :exclude_begin => false)
+        begin
+          @exclude_begin = inar[1][:exclude_begin]
+        rescue
+          # cf., Rangesmaller.new(nil,5)	# => ArgumentError: bad value for range
+          raise ArgumentError, "bad (second) value for Rangesmaller"
+        end
+
+        if defined?(r.begin) && defined?(r.end)	# && defined?(r.exclude_end?)
+          super(r.begin, r.end, r.exclude_end?)
+          @rangepart = r
+          begin
+            if inar[1].has_key?(:exclude_end)
+              if inar[1][:exclude_end] != r.exclude_end?
+                warn "Warning(Rangesmaller.new): Option :exclude_end is given, but is meaningless, as Range is also given."
+              end
+            end
+          rescue
+            # Very unlikely.
+            # The above is just a warning, hence no exception should be raised here, whatever the reason.
+          end
+        else	# Very unlikely, but possible.
+          raise ArgumentError, "bad (first) value for Rangesmaller"
+        end
+      else	# Arg: (Num(Begin), Num(End))
+        super
+      end
+
+    when 3
+      flag_end = false
+      begin
+        @exclude_begin = inar[2][:exclude_begin]
+
+        if inar[2].has_key?(:exclude_end)
+          flag_end = true
+        end
+      rescue NoMethodError, TypeError	# TypeError can be raised if the third argument (inar[2]) is an array or Integer or alike.
+        # Likely conventional argument list as in Range.new().
+        super	# Arg: (begin, end, exclude_end=false)
+      else
+        if flag_end
+          super(inar[0], inar[1], inar[2][:exclude_end])	# Arg: (begin, end, :exclude_end => SOMETHING, :exclude_begin => false)
+        else
+          super(inar[0], inar[1])	# Arg: (begin, end, opt_without_exclude_end)
+        end
+      end
+
+    else
+      raise ArgumentError, "wrong number of arguments (#{inar.size} for 1..3)"
+    end	# case inar.size
+
+    # Adjust @exclude_begin (as it can be anything).
+    if @exclude_begin
+      @exclude_begin = true
+    else
+      @exclude_begin = false
+    end
+
+  end	# def initialize(*inar)
+
+
+  # Returns false if the "begin" boundary is excluded, or true otherwise.
+  # @return [TrueClass]
+  # @return [FalseClass]
+  def exclude_begin?
+    @exclude_begin
+  end
+
+
+  # Return the object equivalent to the Range part (namely, without the definition of exclude_begin?)
+  # @return [Range]
+  def rangepart 
+    @rangepart ||= Range.new(self.begin, self.end, self.exclude_end?)
+  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.
+  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
+  end	# def ==(r)
+
+  alias :eql? :==
+
+
+  # @see {#cover?} and {#Range#===}
+  def ===(obj)
+    # ("a".."z")===("cc")	# => false
+    begin
+      1.0+(obj)	# OK if Numeric.
+
+    rescue TypeError
+      # obj is not Numeric, hence runs brute-force check.
+      each do |ei|
+        if ei == obj
+          return true
+        end
+      end
+      false
+
+    else
+      cover?(obj)
+    end
+  end	# def ===(obj)
+
+  alias :include? :===
+  alias :member? :===
+
+
+  # @note Comment on Rangesmaller#bsearch() :
+  #  bsearch is internally implemented by converting a float into 64-bit integer.
+  #  The following examples demonstrate what is going on.
+  # 
+  #    ary = [0, 4, 7, 10, 12]
+  #    (3...4).bsearch{    |i| ary[i] >= 11}	# => nil
+  #    (3...5).bsearch{    |i| ary[i] >= 11}	# => 4   (Integer)
+  #    (3..5.1).bsearch{   |i| ary[i] >= 11}	# => 4.0 (Float)
+  #    (3.6..4).bsearch{   |i| ary[i] >= 11}	# => 4.0 (Float)
+  #    (3.6...4).bsearch{  |i| ary[i] >= 11}	# => nil
+  #    (3.6...4.1).bsearch{|i| ary[i] >= 11}	# => 4.0 (Float)
+  # 
+  #    class Special
+  #      def [](f)
+  #       (f>3.5 && f<4) ? true : false
+  #      end
+  #    end
+  #    sp = special.new
+  #    (3..4).bsearch{   |i| sp[i]}	# => nil
+  #    (3...4).bsearch{  |i| sp[i]}	# => nil
+  #    (3.0...4).bsearch{|i| sp[i]}	# => 3.5000000000000004
+  #    (3...4.0).bsearch{|i| sp[i]}	# => 3.5000000000000004
+  #    (3.3..4).bsearch{ |i| sp[i]}	# => 3.5000000000000004
+  #
+  #    (Rational(36,10)..5).bsearch{|i| ary[i] >= 11}	=> # TypeError: can't do binary search for Rational (Ruby 2.1)
+  #    (3..Rational(61,10)).bsearch{|i| ary[i] >= 11}	=> # TypeError: can't do binary search for Fixnum (Ruby 2.1)
+  #
+  #  In short, bsearch works only with Integer and/or Float (as in Ruby 2.1).
+  #  If either of begin and end is an Float, the search is conducted in Float and the returned value will be Float, unless nil.
+  #  If Float, it searches on the binary plane.
+  #  If Integer, the search is conducted on the descrete Integer points only,
+  #  and no search will be made in between the adjascent integers.
+  #
+  #  Given that, Rangesmaller#bsearch follows basically the same, even when exclude_begin? is true.
+  #  If either end is Float, it searches between begin*(1+Float::EPSILON) and end.
+  #  If both are Integer, it searches from begin+1.
+  #  When exclude_begin? is false, Rangesmaller#bsearch is identical to Range#bsearch.
+  #
+  def bsearch(*rest, &bloc)
+    if @exclude_begin
+      if ((Float === self.begin()) ||
+          (Integer === self.begin()) && (Float === self.end()))
+        Range.new(self.begin()*(Float::EPSILON+1.0), self.end, exclude_end?).send(__method__, *rest, &bloc)
+        # @note Technically, if begin is Rational, there is no strong reason it should not work.
+        #   However Range#bsearch does not accept Rational, hence this code.
+        #   Users should give a Rangesmaller with begin being Rational.to_f in that case.
+      elsif (defined? self.begin().succ)	# Both non-Float
+        Range.new(self.begin().succ, self.end, exclude_end?).send(__method__, *rest, &bloc)	# In practice it will not raise an Exception, only when both are Integer.
+      else
+        rangepart.send(__method__, *rest, &bloc)	# It will raise an exception anyway!  Such as, (Rational..Rational)
+      end
+    else
+      super
+    end
+  end	# def bsearch(*rest, &bloc)
+
+
+  # @see {#include?} or {#===}, and {#Range#cover?}
+  def cover?(i)
+    # ("a".."z").cover?("cc")	# => true
+    if @exclude_begin
+      if super
+        if self.begin == i
+          false
+        else
+          true
+        end
+      else
+        false
+      end
+    else
+      super
+    end
+  end	# def cover?(i)
+
+
+  # @raise [TypeError] If {#exclude_begin?} is true, and {#begin()} or {#rangepart} does not have a method of #{succ}, then even if no block is given, this method raises TypeError straightaway.
+  #
+  def each(*rest, &bloc)
+    # (1...3.5).each{|i|print i}	# => '123' to STDOUT
+    # (1.3...3.5).each	# => #<Enumerator: 1.3...3.5:each>
+    # (1.3...3.5).each{|i|print i}	# => TypeError: can't iterate from Float
+    if @exclude_begin
+      if defined? self.begin.succ
+        Range.new(self.begin.succ,self.end,exclude_end?).send(__method__, *rest, &bloc)
+      else
+        raise TypeError, "can't iterate from "+self.begin.class.name
+        # if block_given?
+      end
+    else
+      super
+    end
+    self
+  end
+
+
+  # @param [Numeric] Optional.  Must be non-negative.  Consult {#Range#first} for detail.
+  # @note Like {#Range#last}, if no argument is given, it behaves like {#begin()}, that is, it returns the initial value, regardless of {#exclude_begin?}.
+  #  However, if an argument is given (nb., acceptable since Ruby 1.9) when {#exclude_begin?} is true, it returns the array that starts from {#begin()}.{#succ}.
+  # @raise [TypeError] if the argument (Numeric) is given, yet if {#begin()}.{#succ} is not defined.
+  #
+  def first(*rest)
+    # (1...3.1).last	# => 3.1
+    # (1...3.1).last(1)	# => [3]
+    if ! @exclude_begin
+      super
+    else
+      case rest.size
+      when 0
+        self.begin
+      when 1
+        ## Check the argument.
+        Array.new[ rest[0] ]	# Check Type of rest[0] (if invalid, it should cause TypeError)
+
+        begin
+          if rest[0] < 0
+            raise ArgumentError, "negative array size (or size too big)"
+          end
+        rescue NoMethodError
+          # Should not happen, but just to play safe.
+        end
+
+        if (RUBY_VERSION < "1.9.1") && (1 == rest[0])
+          flag_18 = true
+        else
+          flag_18 = false
+        end
+
+        ## Main
+        begin
+          b = self.begin.succ
+        rescue NoMethodError
+          raise TypeError, "can't iterate from "+self.begin.class.name
+        end
+
+          begin
+            Range.new(b, self.end, exclude_end?).send(__method__, *rest)
+          rescue ArgumentError => err
+            if flag_18	# first() does not accept an argument in Ruby 1.8.
+              Range.new(b, self.end, exclude_end?).send(__method__)
+            else
+              raise err
+            end
+          end
+
+      else
+        raise ArgumentError, "wrong number of arguments (#{rest.size} for 2..3)"
+      end
+    end		# if ! @exclude_begin
+  end	# def first(*rest)
+
+
+  # @note When {#exclude_begin?} == true, the returned value for (a<...b) is not strictly guaranteed to be unique, though in pracrtice it is most likely to be so.
+  # 
+  def hash(*rest)
+    if @exclude_begin
+      Range.new(self.begin, self.end, exclude_end?).send(__method__, *rest) - 1
+    else
+      super
+    end
+  end
+
+
+  def inspect
+    if @exclude_begin
+      if exclude_end?
+        midStr = "<..."
+      else
+        midStr = "<.."
+      end
+      self.begin.to_s + midStr + self.end.to_s
+    else
+      super
+    end
+  end
+  alias :to_s :inspect
+
+
+  # @see {#first} for the definition when {#exclude_begin?} is true.
+  #
+  def min(*rest, &bloc)
+    # (1...3.5).max	# => TypeError: cannot exclude non Integer end value
+    if @exclude_begin
+      begin
+        first_val = self.begin.succ
+      rescue NoMethodError
+        raise TypeError, 'cannot exclude non Integer begin value'
+      end
+      Range.new(first_val, self.end, exclude_end?).send(__method__, *rest, &bloc)
+    else
+      super
+    end
+  end
+
+
+  # @see {#first} for the definition when {#exclude_begin?} is true.
+  #
+  def min_by(*rest, &bloc)
+    # (1...3.5).max	# => TypeError: cannot exclude non Integer end value
+    if @exclude_begin
+      begin
+        first_val = self.begin.succ
+      rescue NoMethodError
+        raise TypeError, 'cannot exclude non Integer begin value'
+      end
+      Range.new(first_val, self.end, exclude_end?).send(__method__, *rest, &bloc)
+    else
+      super
+    end
+  end
+
+
+  # @see {#first} for the definition when {#exclude_begin?} is true.
+  #
+  def minmax(*rest, &bloc)
+    # (0...3.5).minmax	# => [0, 3]
+    # (1.3...5).minmax	# => TypeError: can't iterate from Float
+    # Note that max() for the same Range raises an exception.
+    # In that sense, it is inconsistent!
+    if @exclude_begin
+      begin
+        first_val = self.begin.succ
+      rescue NoMethodError
+        raise TypeError, "can't iterate from "+self.begin.class.name
+        # Trap it, just in order to issue the error message that is consisntent with max().
+        # raise TypeError, 'cannot exclude non Integer begin value'
+      end
+      Range.new(first_val, self.end, exclude_end?).send(__method__, *rest, &bloc)
+    else
+      super
+    end
+  end
+
+
+  # @see {#first} for the definition when {#exclude_begin?} is true.
+  #
+  def minmax_by(*rest, &bloc)
+    # (0...3.5).minmax	# => [0, 3]
+    # Note that max() for the same Range raises an exception.
+    # In that sense, it is inconsistent!
+    if @exclude_begin
+      begin
+        first_val = self.begin.succ
+      rescue NoMethodError
+        raise TypeError, "can't iterate from "+self.begin.class.name
+        # Trap it, just in order to issue the error message that is consisntent with max().
+        # raise TypeError, 'cannot exclude non Integer begin value'
+      end
+      Range.new(first_val, self.end, exclude_end?).send(__method__, *rest, &bloc)
+    else
+      super
+    end
+  end	# def minmax_by(*rest)
+
+
+  # @see {#first} for the definition when {#exclude_begin?} is true.
+  # @see [ruby-list:49797] from matz for how {#size} behaves.
+  #
+  def size(*rest)
+    # (1..5).size	# => 5
+    # (1...5).size	# => 4
+    # (0.8...5).size	# => 5	# Why???
+    # (1.2...5).size	# => 4	# Why???
+    # (1.2..5).size	# => 4	# Why???
+    # (Rational(3,2)...5).size	=> 3
+    # (1.5...5).size	# => 4	# Why not 3??
+    # (1.5...4.9).size	# => 4	# Why not 3??
+    # (1.5...4.5).size	# => 3
+    # (0...Float::INFINITY).size	# => Infinity
+
+    if @exclude_begin
+      # Dealing with Infinity.
+      begin
+        inf = Float::INFINITY 
+      rescue	# Ruby 1.8 or earlier.
+        inf = 1/0.0
+      end
+      if -inf == self.begin
+        if -inf == self.end
+          return 0
+        else
+          return inf
+        end
+      elsif inf == self.begin
+        if inf == self.end
+          return 0
+        else
+          return inf
+        end
+      end
+
+      begin
+        1.0 + self.begin()
+        # Numeric
+        Range.new(self.begin()+1, self.end, exclude_end?).send(__method__, *rest)	# Swap the order of '+' from the above, so that Integer/Rational is calculated as it is.
+      rescue TypeError
+        # Non-Numeric
+        Range.new(self.begin().succ, self.end, exclude_end?).send(__method__, *rest)	# => nil in Ruby 2.1
+      end
+
+    else
+      super
+    end
+  end	# def size
+
+
+  # @raise [TypeError] If {#exclude_begin?} is true, and {#begin()} or {#rangepart} does not have a method of #{succ}, then even if no block is given, this method raises TypeError straightaway.
+  # @see {#each}.
+  #
+  def step(*rest, &bloc)
+    # (1...3.5).each{|i|print i}	# => '123' to STDOUT
+    # (1.3...3.5).each	# => #<Enumerator: 1.3...3.5:each>
+    # (1.3...3.5).each{|i|print i}	# => TypeError: can't iterate from Float
+    if @exclude_begin
+      if defined? self.begin.succ
+        Range.new(self.begin.succ,self.end,exclude_end?).send(__method__, *rest, &bloc)
+      else
+        raise TypeError, "can't iterate from "+self.begin.class.name
+        # if block_given?
+      end
+    else
+      super
+    end
+  end
+
+
+end	# class Rangesmaller < Range
+
+
+#
+#=== Redefine a method {#==} so as to handle {#Rangesmaller}.
+#
+class Range
+
+  alias :eql_orig? :==
+
+  def eql?(r)
+    if defined? r.exclude_begin?
+      if r.exclude_begin?
+        false
+      else
+        eql_orig?(r)
+      end
+    else
+      eql_orig?(r)
+    end
+  end	# def :eql?(r)
+  alias :== :eql?
+
+end	# class Range
+
+
+# Constant-form of {#Rangesmaller}.
+# {#Rangesmaller(*)} is equivalent to {#Rangesmaller.new}.
+#
+def Rangesmaller(*rest, &b)
+  Rangesmaller.new(*rest, &b)
+end
+
+

data/rangesmaller.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rangesmaller}
+  s.version = "1.0.0"
+  # 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-22}
+  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}
+  s.extra_rdoc_files = [
+    # "LICENSE",
+     "README.rdoc"
+  ]
+  s.license = 'MIT'
+  s.files = [
+    #".document",
+     #".gitignore",
+     #"VERSION",
+     "README.rdoc",
+     "Rakefile",
+     "rangesmaller.gemspec",
+     "lib/rangesmaller/rangesmaller.rb",
+     "test/test_rangesmaller.rb",
+  ]
+  # s.homepage = %q{http://}
+  s.rdoc_options = ["--charset=UTF-8"]
+  # s.require_paths = ["lib"]
+  # s.required_ruby_version = '>= 1.8.6'
+  s.test_files = [
+     "test/test_rangesmaller.rb",
+  ]
+  # s.test_files = Dir.glob('test/tc_*.rb')
+  # s.requirements << 'libmagick, v6.0'	# Simply, info to users.
+  # s.rubygems_version = %q{1.3.5}	# This is always set automatically!!
+
+end
+

data/test/test_rangesmaller.rb

@@ -0,0 +1,522 @@
+# -*- encoding: utf-8 -*-
+
+libfilebase = 'rangesmaller.rb'
+libfilepath = nil
+er=nil
+pathcand = %w(../lib/rangesmaller/ lib/rangesmaller/ rangesmaller/) + ['']
+pathcand.each do |dir|
+  begin
+    s = dir+libfilebase
+    require s
+    libfilepath = s
+    break
+  rescue LoadError => er
+  end
+end
+if libfilepath.nil?
+  raise er
+end
+
+printf "NOTE: Library relative path: %s\n", libfilepath
+print  "NOTE: Library full path: "
+p $LOADED_FEATURES.grep(/#{Regexp.quote(libfilebase)}$/)
+
+#################################################
+# Unit Test
+#################################################
+
+#if $0 == __FILE__
+  require 'minitest/unit'
+  require 'minitest/autorun'
+  # MiniTest::Unit.autorun
+
+  # Taken from ((<URL:http://www.ruby-doc.org/core-2.1.1/Range.html>))
+  class Xs                # represent a string of 'x's
+    include Comparable
+    attr :length
+    def initialize(n)
+      @length = n
+    end
+    def succ
+      Xs.new(@length + 1)
+    end
+    def <=>(other)
+      @length <=> other.length
+    end
+    def to_s
+      sprintf "%2d #{inspect}", @length
+    end
+    def inspect
+      'x' * @length
+    end
+  end
+
+  # Used in test_bsearch_special
+  class Special
+    def [](f)
+      (f>3.5 && f<4) ? true : false
+    end
+  end
+
+  class TestFoo < MiniTest::Unit::TestCase
+    def setup
+      @ib = 1
+      @ie = 6
+      @r11 = (@ib..@ie)		# incl, incl
+      @r12 = (@ib...@ie)	# incl, excl
+      @s11 = Rangesmaller.new(@r11,  :exclude_begin => false)	# (1..6)   incl, incl
+      @s21 = Rangesmaller.new(@r11,  :exclude_begin => true)	# (1<..6)  excl, incl
+      @s12 = Rangesmaller.new(@r12,  :exclude_begin => false)	# (1...6)  incl, excl
+      @s22 = Rangesmaller.new(@r12,  :exclude_begin => true)	# (1<...6) excl, excl
+    end
+    # teardown is not often used.
+    def teardown
+      @foo = nil
+    end
+
+    def test_new
+      e22 = Rangesmaller.new(@s22)
+      assert  e22.exclude_begin?
+      assert  e22.exclude_end?
+      assert_equal @ib, e22.begin
+      assert_equal @ie, e22.end
+
+      f12 = Rangesmaller.new(@r12)
+      assert !f12.exclude_begin?
+      assert  f12.exclude_end?
+      assert_equal @ib, f12.begin
+      assert_equal @ie, f12.end
+
+      g11 = Rangesmaller.new(@ib, @ie)
+      assert !g11.exclude_begin?
+      assert !g11.exclude_end?
+      assert_equal @ib, g11.begin
+      assert_equal @ie, g11.end
+
+      h12 = Rangesmaller.new(@ib, @ie, true)
+      assert !h12.exclude_begin?
+      assert  h12.exclude_end?
+      assert_equal @ib, h12.begin
+      assert_equal @ie, h12.end
+
+      j22 = Rangesmaller.new(-@ie, -@ib, :exclude_end => true, :exclude_begin => true)
+      assert  j22.exclude_begin?
+      assert  j22.exclude_end?
+      assert_equal(-@ie, j22.begin)
+      assert_equal(-@ib, j22.end)
+    end
+
+    def test_new_const
+      assert_equal @s22, Rangesmaller(@r12, :exclude_begin => true)
+    end
+
+    def test_exclude_begin
+      b = 1
+      e = 4
+      r1 = (b...e)
+      assert !Rangesmaller.new(r1).exclude_begin?
+      assert  Rangesmaller.new(r1).exclude_end?
+      assert  Rangesmaller.new(r1, :exclude_begin => 5).exclude_begin?
+      assert  Rangesmaller.new(r1, :exclude_begin => 5).exclude_end?
+      assert !Rangesmaller.new(b,e).exclude_begin?
+      assert !Rangesmaller.new(b,e).exclude_end?
+      assert !Rangesmaller.new(b,e,nil).exclude_begin?
+      assert !Rangesmaller.new(b,e,nil).exclude_end?
+      assert  Rangesmaller.new(b,e,'c').exclude_end?
+      assert !Rangesmaller.new(b,e,:a =>5).exclude_begin?
+      assert !Rangesmaller.new(b,e,:exclude_end => false, :exclude_begin => false).exclude_begin?
+      assert !Rangesmaller.new(b,e,:exclude_end => false, :exclude_begin => false).exclude_end?
+      assert !Rangesmaller.new(b,e,:exclude_end => true,  :exclude_begin => false).exclude_begin?
+      assert  Rangesmaller.new(b,e,:exclude_end => true,  :exclude_begin => false).exclude_end?
+      assert  Rangesmaller.new(b,e,:exclude_end => true,  :exclude_begin => true ).exclude_begin?
+      assert  Rangesmaller.new(b,e,:exclude_end => true,  :exclude_begin => true ).exclude_end?
+      assert  Rangesmaller.new(b,e,:exclude_end => false, :exclude_begin => true ).exclude_begin?
+      assert !Rangesmaller.new(b,e,:exclude_end => false, :exclude_begin => true ).exclude_end?
+
+      assert_raises ArgumentError do
+        Rangesmaller.new()
+      end
+      assert_raises ArgumentError do
+        Rangesmaller.new(5)
+      end
+      assert_raises ArgumentError do
+        Rangesmaller.new(nil,5)
+      end
+      assert_raises ArgumentError do
+        Rangesmaller.new(nil,5,true)
+      end
+      assert_raises ArgumentError do
+        Rangesmaller.new(3,5,8,9)
+      end
+    end	# def test_exclude_begin
+
+    # Test of Range#== because it has changed first!
+    def test_eql_range
+      assert       (@r11 == (@ib..@ie))
+      assert_equal  @r11, (@ib..@ie)
+      assert       (@r11 != @r12)
+      assert_equal  @r12, (@ib...@ie)
+      assert_equal  @r11, @s11
+      assert       (@r11 != @s12)
+      assert       (@r11 != @s21)
+      assert       (@r11 != @s22)
+      assert_equal  @r12, @s12
+      assert       (@r12 != @s11)
+      assert       (@r12 != @s21)
+      assert       (@r12 != @s22)
+      assert       (@r12 != 'K')
+      assert       (@r12 != @ib)
+    end	# def test_eql_range
+
+    def test_eql
+      t21 = Rangesmaller.new(@ib..@ie, :exclude_begin => true)
+      u11 = Rangesmaller.new(3, @ie, :exclude_begin => false)
+      v11 = Rangesmaller.new(@ib, 4, :exclude_begin => false)
+      v21 = Rangesmaller.new(@ib..4, :exclude_begin => true)
+      v22 = Rangesmaller.new(@ib...4,:exclude_begin => true)
+
+      assert  (@s11 == @r11)
+      assert_equal  @s11, @r11
+      assert !(@s11 == @r12)
+      assert  (@s11 != @r12)
+      assert_equal  @s21, t21
+      assert  (@s21 ==  t21)
+      assert  (@s21 != @s11)
+      assert  (@s21 != @s12)
+      assert  (@s21 != @s22)
+      assert  (@s12 == @r12)
+      assert   @s12.eql?(@r12)
+      assert  (@s11 != u11)
+      assert  (@s11 != v11)
+      assert  (@s21 != v21)
+      assert  (@s22 != v22)
+      assert  (@s22 != u11)
+      assert  (@s22 != 'a')
+
+      sc1 = Rangesmaller.new("D".."F", :exclude_begin => false)
+      sc2 = Rangesmaller.new("D".."F", :exclude_begin => true)
+      assert (sc1 == ("D".."F"))
+      assert (sc1 == Rangesmaller.new(("D".."F")))
+      assert (sc1 != sc2)
+    end	# def test_eql
+
+    def test_begin
+      assert_equal(@ib, @s11.begin)
+      assert_equal(@ib, @s12.begin)
+      assert_equal(@ib, @s21.begin)
+      assert_equal(@ib, @s22.begin)
+    end
+
+    def test_end
+      assert_equal(@ie, @s11.end)
+      assert_equal(@ie, @s12.end)
+      assert_equal(@ie, @s21.end)
+      assert_equal(@ie, @s22.end)
+    end
+
+    def test_first
+      # This is the key method of this class.
+
+      # irb> (5...8.9).last(1)	# => [8]
+      # irb> (5.2..9).last(1)	# => TypeError: can't iterate from Float
+      # irb> (5.2..9).first(1)	# => TypeError: can't iterate from Float
+      # irb> (5.2...9).first(1)	# => TypeError: can't iterate from Float
+      # irb> Rangesmaller(5.2,9,:exclude_begin=>true).first(1)	# => [6]	# Not right!
+      #
+
+      assert_equal(@ib,   @s11.first)
+      assert_equal(@ib,   @s12.first)
+      assert_equal(@ib,   @s21.first)
+      assert_equal(@ib,   @s22.first)
+      assert_equal(@ib,   @s12.first(1)[0])
+      assert_equal(@ib+1, @s21.first(1)[0])
+      assert_equal(@ib+1, @s22.first(1)[0])
+
+      assert_equal(nil, Rangesmaller.new(9, 3, :exclude_begin => true).first(1)[0])
+
+      assert_raises ArgumentError do
+        @s22.first(1, 3)
+      end
+
+      ## String
+      sc1 = Rangesmaller.new("D".."F", :exclude_begin => false)
+      sc2 = Rangesmaller.new("D".."F", :exclude_begin => true)
+      assert_equal('D',  sc1.first)
+      assert_equal('D',  sc2.first)
+      assert_equal('E',  sc2.first(1)[0])
+
+      ## Arbitrary Class
+      sx1 = Rangesmaller.new((Xs.new(3)..Xs.new(6)), :exclude_begin => true)
+      assert_equal(Xs.new(3), sx1.first)
+      assert_equal(Xs.new(4), sx1.first(1)[0])
+
+      ## Float
+      sf1 = Rangesmaller.new((-1.4)..8, :exclude_begin => false)
+      sf2 = Rangesmaller.new((-1.4)..8, :exclude_begin => true)
+      assert_equal(-1.4,  sf1.first)
+      assert_equal(-1.4,  sf2.first)
+      assert_raises TypeError do
+        sf1.first(1)
+      end
+      assert_raises TypeError do
+        sf2.first(1)
+      end
+
+      ## Else
+      sn = Rangesmaller.new(nil..nil, :exclude_begin => true)
+      assert_raises TypeError do
+        sn.first(1)[0]
+      end
+
+      assert_raises ArgumentError do
+        @s22.first(-7)	# "negative array size (or size too big)"
+      end
+      assert_raises TypeError do
+        @s22.first('a')
+      end
+      assert_raises TypeError do
+        @s22.first(nil)
+      end
+    end	# def test_first
+
+
+    def test_each
+      ns=0; @s11.each{|i| ns+=i}
+      assert_equal(@r11.reduce(:+), ns)
+      ns=0; @s12.each{|i| ns+=i}
+      assert_equal(@r12.reduce(:+), ns)
+      ns=0; @s21.each{|i| ns+=i}
+      assert_equal(((@ib+1)..@ie).reduce(:+), ns)
+      ns=0; @s22.each{|i| ns+=i}
+      assert_equal(((@ib+1)...@ie).reduce(:+), ns)
+
+      ## Arbitrary Class
+      sx1 = Rangesmaller.new(Xs.new(3), Xs.new(6), :exclude_begin => true, :exclude_end => true)
+      a=[]; sx1.each{|i| a.push(i)}
+      assert_equal([Xs.new(4), Xs.new(5)], a)
+    end	# def test_each
+
+
+    def test_last	# Apparently it uses each() internally.
+      assert_equal(@ie,   @s11.last)
+      assert_equal(@ie-1, @s12.last(1)[0])
+      assert_equal(@ie,   @s21.last)
+      assert_equal(@ie-1, @s22.last(1)[0])
+    end
+
+
+    def test_include
+      assert  @s11.include?(@ib)
+      assert  @s11.include?(@ie)
+      assert  @s12.include?(@ib)
+      assert !@s12.include?(@ie)
+      assert  @s12.include?(@ie-1)
+      assert !@s21.include?(@ib)
+      assert  @s21.include?(@ib+1)
+      assert  @s21.include?(@ie)
+      assert !@s22.include?(@ib)
+      assert !@s22.include?(@ie)
+      assert  (@s11 === @ib)
+      assert !(@s21 === @ib)
+      assert  (@s21 === @ib+1)
+      assert !(@s22 === @ie)
+
+      assert  (Rangesmaller.new("a", "z") === "c")
+      assert !(Rangesmaller.new("a", "z") === "cc")	# Key! (see cover?)
+      assert  (@s22 === (@ib+@ie)/2.0+0.1)	# Key! (see cover?)
+      assert  (Rangesmaller.new("a", "z").member?("c"))
+      assert !(Rangesmaller.new("a", "z").member?("cc"))
+      assert !(Rangesmaller.new("a", "z", :exclude_begin => 777) === "a")
+      assert  (Rangesmaller.new("a", "z", :exclude_begin => nil) === "a")
+      assert  (Rangesmaller.new("a", "z", :exclude_begin => 777) === "b")
+    end	# def test_include
+
+
+    def test_bsearch
+      ary = [0, 4, 7, 10, 12]
+      assert_equal(2,   Rangesmaller(0, ary.size).bsearch{|i| ary[i] >= 6})
+      # http://www.ruby-doc.org/core-2.1.1/Range.html#method-i-bsearch
+
+      assert_equal(nil, Rangesmaller(3...4).bsearch{  |i| ary[i] >= 11})
+      assert_equal(nil, Rangesmaller(3.6...4).bsearch{|i| ary[i] >= 11})
+      assert_equal(4,   Rangesmaller(3...5).bsearch{  |i| ary[i] >= 11})
+      assert_equal(4.0, Rangesmaller(3...5.1).bsearch{|i| ary[i] >= 11})
+      assert_equal(nil, Rangesmaller(3.6...4).bsearch{|i| ary[i] >= 11})
+
+      assert_equal(4,   Rangesmaller(3...5,   :exclude_begin => 1).bsearch{  |i| ary[i] >= 11})
+      assert_equal(nil, Rangesmaller(4...5,   :exclude_begin => 1).bsearch{  |i| ary[i] >= 11})
+      assert_equal(4.0, Rangesmaller(3...5.1, :exclude_begin => 1).bsearch{|i| ary[i] >= 11})
+      assert_equal(nil, Rangesmaller(3.6...4, :exclude_begin => 1).bsearch{|i| ary[i] >= 11})
+
+      assert_raises TypeError do
+        Rangesmaller.new((?a..?b), :exclude_begin => true).bsearch{|i| ary[i] >= 11}
+      end
+    end	# def test_bsearch
+
+    def test_bsearch_special
+      sp = Special.new
+
+      # Standard Range
+      assert_equal(nil, Rangesmaller(3..4).bsearch{ |i| sp[i]})
+      assert_equal(nil, Rangesmaller(3...4).bsearch{|i| sp[i]})
+      assert(1e-8 > (Rangesmaller(3.0...4).bsearch{|i| sp[i]} - 3.5).abs)
+      assert(1e-8 > (Rangesmaller(3...4.0).bsearch{|i| sp[i]} - 3.5).abs)
+      assert(1e-8 > (Rangesmaller(3.3..4).bsearch{ |i| sp[i]} - 3.5).abs)
+ 
+      # Rangesmaller
+      assert(1e-8 > (Rangesmaller(3...4.1,   :exclude_begin => 1).bsearch{|i| sp[i]} - 3.5).abs)
+      assert(1e-8 > (Rangesmaller(3.7...4,   :exclude_begin => 1).bsearch{|i| sp[i]} - 3.7).abs)
+      assert(1e-8 > (Rangesmaller(3.7...4.2, :exclude_begin => 1).bsearch{|i| sp[i]} - 3.7).abs)	# If end is 4.7, it will be nil (presumably due to the algorithm), whereas still 3.7 if 4.5.
+    end	# def test_bsearch_special
+
+
+    def test_cover
+      assert  @s11.cover?(@ib)
+      assert  @s11.cover?(@ie)
+      assert  @s12.cover?(@ib)
+      assert !@s12.cover?(@ie)
+      assert  @s12.cover?(@ie-1)
+      assert !@s21.cover?(@ib)
+      assert  @s21.cover?(@ib+1)
+      assert  @s21.cover?(@ie)
+      assert !@s22.cover?(@ib)
+      assert !@s22.cover?(@ie)
+      st = Rangesmaller.new((1.4..7), :exclude_begin => true)
+      assert !(st.cover?(1.4))
+      assert  (st.cover?(1.5))
+
+      assert  (Rangesmaller.new("a", "z").cover?("c"))
+      assert  (Rangesmaller.new("a", "z").cover?("cc"))	# Key! (see include?)
+      assert  (@s22.cover?((@ib+@ie)/2.0+0.1))	# Key! (see cover?)
+      su = Rangesmaller.new("a", "z", :exclude_begin => 777)
+      sv = Rangesmaller.new("a", "z", :exclude_begin => nil)
+      assert !(su.cover?("a"))
+      assert  (sv.cover?("a"))
+      assert  (su.cover?("b"))
+    end	# def test_cover
+
+
+    def test_hash
+      assert_equal(@r11.hash, @s11.hash)
+      assert_equal(@r12.hash, @s12.hash)
+      assert (@r12.hash != @s22.hash)
+    end	# def test_hash
+
+
+    def test_min
+      assert_equal(@ib,   @s11.min)
+      assert_equal(@ib,   @s12.min)
+      assert_equal(@ib+1, @s21.min)
+      assert_equal(@ib+1, @s22.min)
+
+      assert_equal(@ie-1, @s22.min{|a,b| -a <=> -b})
+
+      assert_raises TypeError do
+        Rangesmaller.new(1.0, 5, :exclude_begin => true).min
+      end
+    end	# def test_min
+
+
+    def test_min_by
+      assert_equal(@ib+1, @s22.min_by.each{|i| i})
+
+      assert_raises TypeError do
+        Rangesmaller.new(1.0, 5, :exclude_begin => true).min_by
+      end
+
+      assert_equal(@ie-1, @s22.min_by{|a| -a })
+    end	# def test_min_by
+
+
+    def test_minmax
+      assert_equal([@ib,@ie],     @s11.minmax)
+      assert_equal([@ib,@ie-1],   @s12.minmax)
+      assert_equal([@ib+1,@ie],   @s21.minmax)
+      assert_equal([@ib+1,@ie-1], @s22.minmax)
+
+      assert_equal([@ie-1,@ib+1], @s22.minmax{|a,b| -a <=> -b})	# Not the best test...
+
+      assert_raises TypeError do
+        Rangesmaller.new(1.0, 5, :exclude_begin => true).minmax
+      end
+    end	# def test_minmax
+
+
+    def test_minmax_by
+      assert_equal([@ib+1,@ie-1], @s22.minmax_by.each{|i| i})
+
+      assert_raises TypeError do
+        Rangesmaller.new(1.0, 5, :exclude_begin => true).minmax_by
+      end
+
+      assert_equal([@ie-1,@ib+1], @s22.minmax_by{|a| -a })
+    end	# def test_minmax_by
+
+
+    def test_size
+      assert_equal(@ie-@ib+1, @s11.size)
+      assert_equal(@ie-@ib,   @s12.size)
+      assert_equal(@ie-@ib,   @s21.size)
+      assert_equal(@ie-@ib-1, @s22.size)
+      Rangesmaller.new(9, -5, :exclude_begin => true)
+      assert_equal 0, Rangesmaller.new(9, -5, :exclude_begin => true).size
+      assert_equal nil, Rangesmaller.new("a", "c").size
+      assert_equal nil, Rangesmaller.new(nil, nil).size
+
+      # Infinity
+      inf = Float::INFINITY
+      excl_ini = { :exclude_begin => true }
+      assert_equal inf, Rangesmaller.new(-inf, 1).size
+      assert_equal   0, Rangesmaller.new(-inf, -inf, excl_ini).size
+      assert_equal inf, Rangesmaller.new(-inf,    1, excl_ini).size
+      assert_equal   0, Rangesmaller.new( inf,  inf, excl_ini).size
+      assert_equal inf, Rangesmaller.new(   1,  inf, excl_ini).size
+
+      # Float
+      rfi = (2.4..4.4)	# size() => 3	see [ruby-list:49797] from matz
+      rfe = (2.4...4.4)	# size() => 2
+      siz = rfi.size
+      assert_equal siz,   Rangesmaller(rfi).size
+      assert_equal siz-1, Rangesmaller(rfe).size
+      assert_equal siz-1, Rangesmaller(rfi, excl_ini).size
+      assert_equal siz-2, Rangesmaller(rfe, excl_ini).size
+      assert_equal siz-1, Rangesmaller(Rational(24,10)..4.4,  excl_ini).size
+      assert_equal siz-2, Rangesmaller(Rational(24,10)...4.4, excl_ini).size
+      # (0.5...5).size			# => 5 (Ruby 2.1)
+      # (Rational(1,2)...5).size	# => 4 (Ruby 2.1) =>  Bug!
+
+      # String
+      rsi = (?a..?d)
+      if rsi.size.nil?
+        assert_equal nil, Rangesmaller(rsi, excl_ini).size	# Ruby 2.1
+      else
+        assert_equal   3, Rangesmaller(rsi, excl_ini).size	# If the specification ever changes?
+      end
+    end	# def test_size
+
+
+    def test_step
+      ns=0; @s11.step(2){|i| ns+=i}
+      assert_equal(1+3+5, ns)
+      ns=0; @s12.step(2){|i| ns+=i}
+      assert_equal(1+3+5, ns)
+      ns=0; @s21.step(2){|i| ns+=i}
+      assert_equal(2+4+6, ns)
+      ns=0; @s22.step(2){|i| ns+=i}
+      assert_equal(2+4, ns)
+
+      ## Arbitrary Class
+      sx1 = Rangesmaller.new(Xs.new(3), Xs.new(6), :exclude_begin => true, :exclude_end => true)
+      a=[]; sx1.step(2){|i| a.push(i)}
+      assert_equal([Xs.new(4)], a)
+    end	# def test_step
+
+
+  end	# class TestFoo < MiniTest::Unit::TestCase
+
+#end	# if $0 == __FILE__
+
+
+# % ruby1.8 -rlib/rangesmaller/rangesmaller.rb -e 'p Rangesmaller(2.3...7,:exclude_begin=>1).first==2.3'
+# ruby1.8 -rlib/rangesmaller/rangesmaller.rb -e 'i=0;p Rangesmaller(1...4,:exclude_begin=>true).each{|j|i+=j};p i==5'
+# ruby1.8 -rlib/rangesmaller/rangesmaller.rb -e 'p Rangesmaller(-1...7,:exclude_begin=>1).min==0'          

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: rangesmaller
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Masa Sakano
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-22 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
+  as in the standard Range.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- README.rdoc
+- Rakefile
+- rangesmaller.gemspec
+- lib/rangesmaller/rangesmaller.rb
+- test/test_rangesmaller.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Rangesmaller class -- Range with include_begin?()
+test_files:
+- test/test_rangesmaller.rb