fat_core 2.0.1 → 3.0.0

data/lib/fat_core/range.rb

@@ -1,194 +1,198 @@
-class Range
-  # Return a range that concatenates this range with other; return nil
-  # if the ranges are not contiguous.
-  def join(other)
-    if left_contiguous?(other)
-      Range.new(min, other.max)
-    elsif right_contiguous?(other)
-      Range.new(other.min, max)
+module FatCore
+  module Range
+    # Return a range that concatenates this range with other; return nil
+    # if the ranges are not contiguous.
+    def join(other)
+      if left_contiguous?(other)
+        ::Range.new(min, other.max)
+      elsif right_contiguous?(other)
+        ::Range.new(other.min, max)
+      end
     end
-  end
 
-  # Is self on the left of and contiguous to other?
-  def left_contiguous?(other)
-    if max.respond_to?(:succ)
-      max.succ == other.min
-    else
-      max == other.min
+    # Is self on the left of and contiguous to other?
+    def left_contiguous?(other)
+      if max.respond_to?(:succ)
+        max.succ == other.min
+      else
+        max == other.min
+      end
     end
-  end
 
-  # Is self on the right of and contiguous to other?
-  def right_contiguous?(other)
-    if other.max.respond_to?(:succ)
-      other.max.succ == min
-    else
-      other.max == min
+    # Is self on the right of and contiguous to other?
+    def right_contiguous?(other)
+      if other.max.respond_to?(:succ)
+        other.max.succ == min
+      else
+        other.max == min
+      end
     end
-  end
 
-  def contiguous?(other)
-    left_contiguous?(other) || right_contiguous?(other)
-  end
+    def contiguous?(other)
+      left_contiguous?(other) || right_contiguous?(other)
+    end
 
-  def subset_of?(other)
-    min >= other.min && max <= other.max
-  end
+    def subset_of?(other)
+      min >= other.min && max <= other.max
+    end
 
-  def proper_subset_of?(other)
-    min > other.min && max < other.max
-  end
+    def proper_subset_of?(other)
+      min > other.min && max < other.max
+    end
 
-  def superset_of?(other)
-    min <= other.min && max >= other.max
-  end
+    def superset_of?(other)
+      min <= other.min && max >= other.max
+    end
 
-  def proper_superset_of?(other)
-    min < other.min && max > other.max
-  end
+    def proper_superset_of?(other)
+      min < other.min && max > other.max
+    end
 
-  def overlaps?(other)
-    (cover?(other.min) || cover?(other.max) ||
-     other.cover?(min) || other.cover?(max))
-  end
+    def overlaps?(other)
+      (cover?(other.min) || cover?(other.max) ||
+       other.cover?(min) || other.cover?(max))
+    end
 
-  def intersection(other)
-    return nil unless overlaps?(other)
-    ([min, other.min].max..[max, other.max].min)
-  end
-  alias & intersection
+    def intersection(other)
+      return nil unless overlaps?(other)
+      ([min, other.min].max..[max, other.max].min)
+    end
+    alias & intersection
 
-  def union(other)
-    return nil unless overlaps?(other) || contiguous?(other)
-    ([min, other.min].min..[max, other.max].max)
-  end
-  alias + union
-
-  # The difference method, -, removes the overlapping part of the other
-  # argument from self.  Because in the case where self is a superset of the
-  # other range, this will result in the difference being two non-contiguous
-  # ranges, this returns an array of ranges.  If there is no overlap or if
-  # self is a subset of the other range, return an array of self
-  def difference(other)
-    unless max.respond_to?(:succ) && min.respond_to?(:pred) &&
-           other.max.respond_to?(:succ) && other.min.respond_to?(:pred)
-      raise 'Range difference requires objects have pred and succ methods'
-    end
-    if subset_of?(other)
-      # (4..7) - (0..10)
-      []
-    elsif proper_superset_of?(other)
-      # (4..7) - (5..5) -> [(4..4), (6..7)]
-      [(min..other.min.pred), (other.max.succ..max)]
-    elsif overlaps?(other) && other.min <= min
-      # (4..7) - (2..5) -> (6..7)
-      [(other.max.succ..max)]
-    elsif overlaps?(other) && other.max >= max
-      # (4..7) - (6..10) -> (4..5)
-      [(min..other.min.pred)]
-    else
-      [self]
+    def union(other)
+      return nil unless overlaps?(other) || contiguous?(other)
+      ([min, other.min].min..[max, other.max].max)
     end
-  end
-  alias - difference
-
-  # Return whether any of the ranges that are within self overlap one
-  # another
-  def has_overlaps_within?(ranges)
-    result = false
-    unless ranges.empty?
-      ranges.each do |r1|
-        next unless overlaps?(r1)
-        result =
-          ranges.any? do |r2|
+    alias + union
+
+    # The difference method, -, removes the overlapping part of the other
+    # argument from self.  Because in the case where self is a superset of the
+    # other range, this will result in the difference being two non-contiguous
+    # ranges, this returns an array of ranges.  If there is no overlap or if
+    # self is a subset of the other range, return an array of self
+    def difference(other)
+      unless max.respond_to?(:succ) && min.respond_to?(:pred) &&
+             other.max.respond_to?(:succ) && other.min.respond_to?(:pred)
+        raise 'Range difference requires objects have pred and succ methods'
+      end
+      if subset_of?(other)
+        # (4..7) - (0..10)
+        []
+      elsif proper_superset_of?(other)
+        # (4..7) - (5..5) -> [(4..4), (6..7)]
+        [(min..other.min.pred), (other.max.succ..max)]
+      elsif overlaps?(other) && other.min <= min
+        # (4..7) - (2..5) -> (6..7)
+        [(other.max.succ..max)]
+      elsif overlaps?(other) && other.max >= max
+        # (4..7) - (6..10) -> (4..5)
+        [(min..other.min.pred)]
+      else
+        [self]
+      end
+    end
+    alias - difference
+
+    # Return whether any of the ranges that are within self overlap one
+    # another
+    def has_overlaps_within?(ranges)
+      result = false
+      unless ranges.empty?
+        ranges.each do |r1|
+          next unless overlaps?(r1)
+          result =
+            ranges.any? do |r2|
             r1.object_id != r2.object_id && overlaps?(r2) &&
               r1.overlaps?(r2)
           end
-        return true if result
+          return true if result
+        end
       end
+      result
     end
-    result
-  end
 
-  # Return true if the given ranges collectively cover this range
-  # without overlaps.
-  def spanned_by?(ranges)
-    joined_range = nil
-    ranges.sort_by(&:min).each do |r|
-      unless joined_range
-        joined_range = r
-        next
+    # Return true if the given ranges collectively cover this range
+    # without overlaps.
+    def spanned_by?(ranges)
+      joined_range = nil
+      ranges.sort_by(&:min).each do |r|
+        unless joined_range
+          joined_range = r
+          next
+        end
+        joined_range = joined_range.join(r)
+        break if joined_range.nil?
+      end
+      if !joined_range.nil?
+        joined_range.min <= min && joined_range.max >= max
+      else
+        false
       end
-      joined_range = joined_range.join(r)
-      break if joined_range.nil?
-    end
-    if !joined_range.nil?
-      joined_range.min <= min && joined_range.max >= max
-    else
-      false
     end
-  end
 
-  # If this range is not spanned by the ranges collectively, return an array
-  # of ranges representing the gaps in coverage.  Otherwise return an empty
-  # array.
-  def gaps(ranges)
-    if ranges.empty?
-      [clone]
-    elsif spanned_by?(ranges)
-      []
-    else
-      ranges = ranges.sort_by(&:min)
-      gaps = []
-      cur_point = min
-      ranges.each do |rr|
-        break if rr.min > max
-        if rr.min > cur_point
-          start_point = cur_point
-          end_point = rr.min.pred
-          gaps << (start_point..end_point)
-          cur_point = rr.max.succ
-        elsif rr.max >= cur_point
-          cur_point = rr.max.succ
+    # If this range is not spanned by the ranges collectively, return an array
+    # of ranges representing the gaps in coverage.  Otherwise return an empty
+    # array.
+    def gaps(ranges)
+      if ranges.empty?
+        [clone]
+      elsif spanned_by?(ranges)
+        []
+      else
+        ranges = ranges.sort_by(&:min)
+        gaps = []
+        cur_point = min
+        ranges.each do |rr|
+          break if rr.min > max
+          if rr.min > cur_point
+            start_point = cur_point
+            end_point = rr.min.pred
+            gaps << (start_point..end_point)
+            cur_point = rr.max.succ
+          elsif rr.max >= cur_point
+            cur_point = rr.max.succ
+          end
         end
+        gaps << (cur_point..max) if cur_point <= max
+        gaps
       end
-      gaps << (cur_point..max) if cur_point <= max
-      gaps
     end
-  end
 
-  # Similar to gaps, but within this range return the /overlaps/ among the
-  # given ranges.  If there are no overlaps, return an empty array. Don't
-  # consider overlaps in the ranges that occur outside of self.
-  def overlaps(ranges)
-    if ranges.empty? || spanned_by?(ranges)
-      []
-    else
-      ranges = ranges.sort_by(&:min)
-      overlaps = []
-      cur_point = nil
-      ranges.each do |rr|
-        # Skip ranges outside of self
-        next if rr.max < min || rr.min > max
-        # Initialize cur_point to max of first range
-        if cur_point.nil?
+    # Similar to gaps, but within this range return the /overlaps/ among the
+    # given ranges.  If there are no overlaps, return an empty array. Don't
+    # consider overlaps in the ranges that occur outside of self.
+    def overlaps(ranges)
+      if ranges.empty? || spanned_by?(ranges)
+        []
+      else
+        ranges = ranges.sort_by(&:min)
+        overlaps = []
+        cur_point = nil
+        ranges.each do |rr|
+          # Skip ranges outside of self
+          next if rr.max < min || rr.min > max
+          # Initialize cur_point to max of first range
+          if cur_point.nil?
+            cur_point = rr.max
+            next
+          end
+          # We are on the second or later range
+          if rr.min < cur_point
+            start_point = rr.min
+            end_point = cur_point
+            overlaps << (start_point..end_point)
+          end
           cur_point = rr.max
-          next
-        end
-        # We are on the second or later range
-        if rr.min < cur_point
-          start_point = rr.min
-          end_point = cur_point
-          overlaps << (start_point..end_point)
         end
-        cur_point = rr.max
+        overlaps
       end
-      overlaps
     end
-  end
 
-  # Allow erb documents can directly interpolate ranges
-  def tex_quote
-    to_s
+    # Allow erb documents can directly interpolate ranges
+    def tex_quote
+      to_s
+    end
   end
 end
+
+Range.include FatCore::Range