rmtools 1.3.3 → 2.0.0.rc5

data/lib/rmtools/enumerable/range.rb

@@ -3,103 +3,143 @@ unless defined? Inf
   Inf = 1.0/0
 end
 
+# Range in Ruby can have at least 2 meanings:
+# 1) interval of real numbers
+# (0...2).include? 1.6 # => true
+# 2) lazy list of array indices (included integers):
+# [0,1,2,3,4,5][1..4] # => [1, 2, 3, 4]
+#
+# There is some basic problems.
+# 1) For the first way of using, Range doesn't have Set operations. Further more Range can not be complex.
+# There is "intervals" gem that partially solves these problems, but it's arithmetic is not Set compatible:
+# -Interval[1,2] # => Interval[-2, -1] 
+# instead of 
+# # => Interval[[-Inf, -2], [-1, +Inf]]
+# 2) Hardly we can use Range second way, when it defined by non-integers:
+# [0,1,2,3,4,5][1.9..4] # => [1, 2, 3, 4]
+# (1.9...4.1).include? 4 # => true, BUT
+# [0,1,2,3,4,5][1.9...4.1] # => [1, 2, 3]
+#
+# This extension leaves the first problem for a purpose of solving the second, saving the capability of a Range syntactic sugar. The present extension applies Set operations to ranges considered as lists of contained integers. 
+# It means: 
+# (x..y) equivalent (x...y+0.5) equivalent (x...y+1) equivalent [x, x+1, ..., y]
+# Note quantity of dots (end exclusion)
 class Range
   
-  # -(1.0..2.0)
-  ### => XRange(-∞..1.0, 2.0..∞)
-  # BUT
-  # -(1..2)
-  ### => XRange(-∞..0, 3..∞)
-  # i.e. all excluding these: (0; 1], [1; 2], [2; 3)
-  def -@
-    self_begin = self.begin
-    self_begin -= 1 if Integer === self_begin
-    self_end = include_end.end
-    self_end += 1 if Integer === self_end
-    XRange(-Inf..self_begin, self_end..Inf)
+  def included_end
+    exclude_end? ? last.integer? ? last - 1 : last.to_i : last
   end
-  def &(range)
-    return range&self if range.is XRange
-    beg = [self.begin, range.begin].max
-    end_ = [self.include_end.end, range.include_end.end].min
-    beg > end_ ? nil : beg..end_
+  
+  def include_end
+    exclude_end? ? first..included_end : self 
   end
   
-  def |(range)
-    return range|self if range.is XRange
-    range = range.include_end
-    self_ = self.include_end
-    return XRange.new self, range if !x?(range)
-    [self.begin, range.begin].min..[self_.end, range.end].max
+  # Since it's not represent an interval...
+  # (0..0).size # => 1 (equivalent list of one zero)
+  # (0...0).size # => 0 (equivalent empty list)
+  # There is no empty ranges with end included (since it includes at least an end, right?)
+  def size
+    exclude_end? ? (last - first).abs : (last - first).abs+1
+  end
+  
+  def empty?
+    exclude_end? && last == first
   end
   
+  def b
+    !empty? && self
+  end
+  
+  # Let significant content of a range used this way be:
+  def integers
+    (first.ceil..included_end).to_a
+  end
+  alias :to_is :integers
+  
+  # -(1..2)   
+  # -(0.5..2.1)
+  # i.e. all excluding these lazy indices: [1, 2]
+  ### => XRange(-∞..0, 3..∞)
+  def -@
+    XRange(-Inf..first.ceil-1, (exclude_end? && last.integer? ? last : last.to_i+1)..Inf)
+  end
+  
+  def &(range)
+    return range & self if range.is XRange
+    fst = [first, range.first].max
+    lst = [included_end, range.included_end].min
+    fst > lst ? nil : fst..lst
+  end
   
   # On the basis of #-@ for non-integers,
-  # (0..1) - (1..2)
-  ### => XRange(0..0)
-  # (0..1.0) - (1..2)
-  ### => XRange(0..0)
-  # (0..1) - (1.0..2)
-  ### => XRange(0..1.0)
-  # (0..1.0) - (1.0..2)
-  ### => XRange(0..1.0)
+  # (0..3) - (0.5..2.1)
+  # (0..3) - (1..2)
+  ### => XRange(0..0, 3..3.0)
   def -(range)
     self & -range
   end
   
-  def ^(range)
-    common = self & range
-    self - common | range - common
+  alias :include_number? :include?
+  # This function corresponds with ruby's default one in that we consider any number as a point on a segment.
+  # Thus, any of these 0..1, 0..1.0
+  # would return true as for 1 so as for 1.0
+  def include?(number_or_range)
+    if Numeric === number_or_range
+      include_number? number_or_range
+    elsif XRange === number_or_range
+      number_or_range.include? self
+    else
+      include_number? number_or_range.first and include_number? number_or_range.last
+    end
   end
   
-  # Statement about non-integers is made with presumption that float presentation of number is a neighborhood of it.
-  # Thus, "1.0" lies in the neighborhood of "1"; [0..1.0] is, mathematically, [0; 1) that not intersects with (1; 2]
-  # and thereby (0..1.0).x?(1.0..2) should be false, although (0..1).x?(1..2) should be true
   def x?(range)
+    return false if empty?
     return range.x? self if range.is XRange
-    range_end = range.include_end.end
-    self_end = self.include_end.end
-    if self_end < range_end
-      if Integer === self_end and Integer === range.begin
-        self_end >= range.begin
-      else
-        self_end > range.begin
-      end
+    range_end = range.included_end
+    if range_end < range.first
+      return x?(range_end..range.first)
+    end
+    self_end = included_end
+    if self_end < first
+      return (first..self_end).x?(range)
+    end
+    case self_end <=> range_end
+    when -1
+      self_end >= range.first
+    when 1
+      first <= range_end >= first
     else
-      if Integer === self.begin and Integer === range_end
-        range_end >= self.begin
-      else
-        range_end > self.begin
-      end
+      true
     end
   end
   alias :intersects? :x?
-    
-  def <=>(range) 
-    (self.begin <=> range.begin).b || self.include_end.end <=> range.include_end.end 
+  
+  def |(range)
+    return range | self if range.is XRange
+    range = range.include_end
+    self_ = self.include_end
+    return XRange.new self, range if !x?(range)
+    [self.begin, range.begin].min..[self_.end, range.end].max
   end
   
-  def include_end
-    exclude_end? ? self.begin..(self.end - 1) : self 
+  def ^(range)
+    common = self & range
+    self - common | range - common
+  end
+    
+  def <=>(range) 
+    (first <=> range.first).b || included_end <=> range.included_end
   end
   
   def center
-    (first + last + (!exclude_end?).to_i)/2 
+    (first + include_end.last)/2 
   end
   
   def part(i, j) 
     first + (i-1)*size/j .. first - 1 + i*size/j unless i < 1 or j < 1 or j < i 
   end
   
-  def size
-    (last - first).abs + (!exclude_end?).to_i 
-  end
-  
-  # Irrespective of include_end to be able to determne ranges created in any way
-  def b
-    self.begin != self.end && self
-  end
-  
   def div(n)
     unless n < 1
       rarray = []
@@ -141,7 +181,7 @@ class Range
     ie*(ie+1)/2 - (1..self.begin-1).sum
   end
   
-  # monotone function definition interval min/max border
+  # minimum of monotone function definition interval
   def min(&fun)
     return first if yield first
     return unless yield last
@@ -152,6 +192,7 @@ class Range
     end
   end 
   
+  # maximum of monotone function definition interval
   def max(&fun)
     return last if yield last
     return unless yield first
@@ -190,7 +231,7 @@ class XRange
     if range.is Range
       XRange.new *intersect(range)
     else
-      @ranges.map {|r| range & r}.foldl(:|)
+      @ranges.map {|r| range & r}.foldl(:|) || XRange.new
     end
   end
   
@@ -204,7 +245,7 @@ class XRange
   end
   
   def -@
-    @ranges.map {|r| -r}.foldl(:&)
+    @ranges.map {|r| -r}.foldl(:&) || XRange.new(-Inf..+Inf)
   end
   
   def -(range)
@@ -240,31 +281,41 @@ public
   end
   
   def of(ary) 
-    @ranges.foldl(:+) {|r| ary[r]} 
+    @ranges.sum_of(ary)
+  end
+  
+  def size
+    @size ||= @ranges.sum_size
   end
   
+  # XRange doesn't support ranges with end excluded, so it's empty only if contains nothing
   def empty?
     @ranges.empty?
   end
   
+  def b
+    !@ranges.empty? && self
+  end
+  
   def include?(number_or_range)
-    @ranges.find {|r| r.include?(number_or_range)}
+    @ranges.find_include?(number_or_range)
   end
   
   def begin
-    @ranges[0].begin
+    @begin ||= @ranges.first && @ranges.first.begin
   end
   
   def end
-    @ranges[-1].end
+    @end ||= @ranges.last && @ranges.last.end
   end
   
-  def size
-    @ranges.sum {|r| r.size}
+  alias :to_a_first :first
+  def first(count=nil)
+    count ? to_a_first(count) : self.begin
   end
-  
-  def b
-    size != 0 && self
+    
+  def last(count=nil)
+    count ? to_a.last(count) : self.end
   end
   
   def div(n)

data/lib/rmtools/enumerable/traversal.rb

@@ -125,7 +125,7 @@ module RMTools
   
   class ValueTraversable < Array
     include ValueTraversal    
-    __init__ if respond_to? :__init__
+    __init__
     
     private
     alias :array_plus :+
@@ -145,7 +145,7 @@ module RMTools
   
   class KeyValueTraversable < Hash
     include KeyValueTraversal    
-    __init__ if respond_to? :__init__
+    __init__
     
     def +(enum)
       if Hash === enum

data/lib/rmtools/functional/unfold.rb

@@ -1,15 +1,13 @@
 # encoding: utf-8
 class Object
 
-  # &splitter must return a pair
-  def unfold(break_if=lambda{|x|x==0}, &splitter)
+  # @ breaker must be callable that returns true value if that's it
+  # @ &splitter must return a pair
+  def unfold(breaker=lambda{|x|x.b}, &splitter)
     obj, container = self, []
-    until begin
-        result = splitter[obj]
-        container.unshift result[1]
-        break_if[result[0]]
-      end
-      obj = result[0]
+    until breaker.call obj
+      obj, next_element = splitter[obj]
+      container.unshift next_element
     end
     container
   end

data/lib/rmtools/rand/array.rb

@@ -18,26 +18,28 @@ class Array
   end
   
   def rand
-    if block_given?
-      h, ua = {}, uniq
-      s = ua.size
-      loop {
-        i = Kernel.rand size
-        if h[i]
-          return if h.size == s
-        elsif yield(e = ua[i])
-          return e
-        else h[i] = true
-        end
-      }
-    else self[Kernel.rand(size)]
-    end
+    self[Kernel.rand(size)]
   end
   
   def rand!
     delete_at Kernel.rand size
   end
   
+  def rand_by
+    return if empty?
+    set, ua = Set.new, uniq
+    s = ua.size
+    loop {
+      i = Kernel.rand size
+      if set.include? i
+        return if set.size == s
+      elsif yield(e = ua[i])
+        return e
+      else set << i
+      end
+    }
+  end
+  
   def randdiv(int)
     dup.randdiv!(int)
   end

data/lib/rmtools/version.rb

@@ -0,0 +1,3 @@
+module RMTools
+  VERSION = '2.0.0.rc5'
+end

data/lib/rmtools.rb

@@ -1,2 +1,10 @@
-require 'rmtools/init'
-RMTools::require 'dev_min'
+SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
+$__MAIN__ = self
+require 'active_support'
+require 'rmtools/require'
+%w[version core enumerable text time functional
+  conversions lang rand console
+  fs db xml dev
+  ../rmtools.so
+].each {|file| RMTools::require file}
+class Object; include RMTools end

data/lib/rmtools_dev.rb

@@ -1,6 +1,3 @@
-SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
-$__MAIN__ = self
-require 'rmtools/init'
-RMTools::require 'dev'
-
-unless defined? Rails; class Object; include RMTools end end
+$stderr.puts 'require "rmtools_dev" is deprecated since 2.0.0. Please require "rmtools"'
+$stderr.puts "called from #{caller(1).find {|line| line !~ /dependencies.rb/}}"
+require 'rmtools'

data/rmtools.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rmtools/version'
+#require 'rmtools/install'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rmtools"
+  spec.version       = RMTools::VERSION
+  spec.authors       = ["Sergey Baev"]
+  spec.email         = ["tinbka@gmail.com"]
+  spec.description   = %q{RMTools is a collection of helpers for debug, text/array/file processing and simply easing a coding process}
+  spec.summary       = %q{Collection of helpers for debug, text/array/file processing and simply easing a coding process}
+  spec.homepage      = "https://github.com/tinbka/rmtools"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  # nonetheless, for this gem spec.files() returns [] after installation
+  spec.require_paths = ["lib"]
+  
+  spec.add_runtime_dependency "activesupport"
+  #unless ext_files_not_modified 'rmtools', RMTools::VERSION
+    spec.extensions << 'ext/extconf.rb'
+  #end
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end