rmtools 2.0.0.rc5 → 2.0.0

data/README.md

@@ -44,9 +44,9 @@ It's still randomly documented since it's just my working tool.
   * Added private #alias_constant
 
 * Array
-  * #avg and #avg_by for an empty array now return 0
-  * Fixed #rand_by for an empty array
-  * Added #intersects? aliased as #x?
+  * Fixed #avg, #avg_by, #rand_by in case of an empty array: return nil
+  * Added #intersects? (alias #x?)
+  * Added #rfind_by, #runiq_by and few more iterators
 
 * Symbol
   * Added #+, #split and #method_missing to proxy all possible methods to #to_s

data/lib/rmtools/enumerable/array.rb

@@ -69,12 +69,12 @@ class Array
 
   # arithmetics
   def avg
-    empty? ? 0 : sum.to_f/size
+    empty? ? nil : sum.to_f/size
   end
   
   # for use with iterators
-  def avg_by(&b)
-    empty? ? 0 : sum(&b).to_f/size
+  def avg_by(&block)
+    empty? ? nil : sum(&block).to_f/size
   end
   
   def scale(top)
@@ -140,7 +140,7 @@ class Array
   end
   
   
-  # selectors  
+  # filters  
   def odds
     values_at(*(0...size).odds)
   end
@@ -150,10 +150,6 @@ class Array
   end
   
   # conditional
-  def uniq?
-    uniq == self
-  end  
-  
   def every?
     !find {|e| !yield(e)}
   end
@@ -162,10 +158,24 @@ class Array
     !find {|e| yield(e)}
   end
   
+  # rightmost #find
+  def rfind
+    reverse_each {|e| return e if yield e}
+    nil
+  end
+  
+  # find-by-value filters
+  # It's more of a pattern. Use of respective meta-iterators is prefered.
   def find_by(key, value)
     find {|e| e.__send__(key) == value}
   end
   
+  # rightmost #find_by
+  def rfind_by(key, value)
+    reverse_each {|e| return e if e.__send__(key) == value}
+    nil
+  end
+  
   def select_by(key, value)
     select {|e| e.__send__(key) == value}
   end
@@ -174,11 +184,28 @@ class Array
     reject {|e| e.__send__(key) == value}
   end
   
+  
+  # uniqs
+  def uniq?
+    uniq == self
+  end  
+  
+  # rightmost #uniq
+  def runiq
+    reverse.uniq.reverse
+  end
+  
+  # rightmost #uniq_by
+  def runiq_by(&block)
+    reverse.uniq_by(&block).reverse
+  end
+  
   # sort / group
   def sorted_uniq_by(&block) 
     uniq_by(&block).sort_by(&block)
   end
   
+  # C-function, see it in /ext
   def arrange_by(*args, &block)
     arrange(*args, &block)
   end
@@ -243,23 +270,13 @@ class Array
     
     
   # mapreduce
-  def sum(identity=0, &b) foldl(:+, &b) || identity end
-  
-  # fastering activesupport's method
-  def group_by(&b) arrange(:group, &b) end
-  
-  
-  
-  
-  # rightmost #find
-  def rfind
-    reverse_each {|e| return e if yield e}
-    nil
+  def sum(identity=0, &b) 
+    foldl(:+, &b) || identity 
   end
   
-  # rightmost #uniq
-  def runiq
-    reverse.uniq.reverse
+  # fastering activesupport's method
+  def group_by(&b) 
+    arrange(:group, &b) 
   end
   
 end

data/lib/rmtools/enumerable/array_iterators.rb

@@ -236,7 +236,7 @@ class Array
         err.message << " (`#{method}' interpreted as decorator-function `#{meth}')"
         raise err
       end}
-      when :find_by, :select_by, :reject_by
+      when :find_by, :rfind_by,:select_by, :reject_by
         Array.class_eval %{
       def #{method}(val)
         # select_by_count(max_count) =>
@@ -268,11 +268,11 @@ class Array
         if Array === value
           # owner_ids = users_ids  =>  
           # each_with_index {|e, i| e.owner_id = users_ids[i]}
-          each_with_index {|e, i| e.__send__ meth, value[i]}
+          each_with_index {|e, i| e.#{meth} value[i]}
         else
           # owner_ids = user_id  =>  
           # each {|e, i| e.owner_id = user_id}
-          each {|e| e.__send__ meth, value}
+          each {|e| e.#{meth} value}
         end
       rescue NoMethodError => err
         err.message << " (`#{method}' interpreted as map-function `#{meth}')"

data/lib/rmtools/enumerable/range.rb

@@ -17,53 +17,91 @@ end
 # # => 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
+# (1.9...4.1).include? 4 # => true, AND
+# (1.9...4.1).include? 1 # => false, 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)
+# A domain of the present extension is Set operations with ranges considered as lazy lists of integers.
+# The present extension is solving the second problem, yet
+# * saving the capability of a Range syntactic sugar;
+# * does exactly extend and not modify the Range behaviour.
+# These methods support only numeric ranges, it won't work with chars and datetime borders,
+# though I'll make a support for the Date and Time in a future version.
 class Range
   
-  def included_end
-    exclude_end? ? last.integer? ? last - 1 : last.to_i : last
+  private
+  def next_int(n)
+    n.integer? || n.to_i == n ? n.to_i + 1 : n.ceil
+  end
+  
+  def prev_int(n)
+    n.integer? || n.to_i == n ? n.to_i - 1 : n.to_i
+  end
+  
+  def int_end
+    exclude_end? ? prev_int(last) : last.to_i
   end
+  public
   
+  # End inclusion need to universalize ranges for use in XRange list.
+  # Considering the extension domain, one simply should not use "..." notation, but if such a range nevertheless appears as an argument, we reduce that to an operable one at the cost of a fractional accuracy
+  # #include_end should not be coupled with #size and #empty? which have their own "..." handling
+  # (0.9...1.3).include_end # => 0.9..1, BUT
+  # (0.3...0.5).include_end # => 0.3..0
   def include_end
-    exclude_end? ? first..included_end : self 
+    exclude_end? ? first..prev_int(last) : self
   end
   
-  # 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 included_end
+    exclude_end? ? prev_int(last) : last
+  end
+  
+  # Represent a count of integers that range include and not real interval length
+  # (0..0).size
+  # => 1 (equivalent list of one 0)
+  # (0...0).size 
+  # => 0 (equivalent empty list)
+  # (0.3..0.5).size 
+  # => 0 (there is no integer between 0.3 and 0.5)
+  # (0.9...1.1).size 
+  # => 1 (equivalent list of one 1 which is between 0.9 and 1.1)
+  # (2..1).size 
+  # => 0 (such a range just does't make sense)
   def size
-    exclude_end? ? (last - first).abs : (last - first).abs+1
+    [int_end - first.ceil + 1, 0].max
   end
   
+  # Include any integer?
   def empty?
-    exclude_end? && last == first
+    size == 0
   end
   
   def b
-    !empty? && self
+    size != 0 && self
+  end
+  
+  # Simplify a range to in-domain equivalent with integer edges.
+  def integerize
+    first.ceil..int_end
   end
   
-  # Let significant content of a range used this way be:
+  # Significant content of a range then.
   def integers
-    (first.ceil..included_end).to_a
+    integerize.to_a
   end
   alias :to_is :integers
   
-  # -(1..2)   
+  # Unfortunately, Range's start point can not be excluded, thus there is no *true inversion* of a range with included end.
+  # Though, is this domain we can "integerize" range, then
+  # -(1..2)
   # -(0.5..2.1)
-  # i.e. all excluding these lazy indices: [1, 2]
-  ### => XRange(-∞..0, 3..∞)
+  # (i.e. all excluding these indices: [1, 2])
+  ### => XRange(-∞..0, 3..+∞)
   def -@
-    XRange(-Inf..first.ceil-1, (exclude_end? && last.integer? ? last : last.to_i+1)..Inf)
+    XRange(-Inf..prev_int(first), (exclude_end? ? last.ceil : next_int(last))..Inf)
   end
   
+  # Intersection
   def &(range)
     return range & self if range.is XRange
     fst = [first, range.first].max
@@ -72,17 +110,20 @@ class Range
   end
   
   # On the basis of #-@ for non-integers,
-  # (0..3) - (0.5..2.1)
   # (0..3) - (1..2)
-  ### => XRange(0..0, 3..3.0)
+  # (0..3) - (0.5..2.1)
+  ### => XRange(0..0, 3..3)
   def -(range)
     self & -range
   end
   
   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
+  # #include? corresponds with Ruby's default one, which considers a range as an interval
+  # (0..1).include? 1.0
+  # 1.in 0..1
+  # => true
+  # and (0...1.0).include? 1.0
+  # => false
   def include?(number_or_range)
     if Numeric === number_or_range
       include_number? number_or_range
@@ -93,36 +134,38 @@ class Range
     end
   end
   
-  def x?(range)
-    return false if empty?
+  # Does these ranges have at least one common point?
+  # (0..1).x? 1..2
+  # (1...2).x? 0..1
+  # (0..3).x? 1..2
+  # (1..2).x? 0..3
+  # => true
+  # (0..1.4).x? 1.5..2
+  # (0...1).x? 1..2
+  # (2..3).x? 0..1
+  # => false
+  def x?(range, pretend_not_exclude=false)
     return range.x? self if range.is XRange
-    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
-      true
-    end
+    (range.last > first or ((!range.exclude_end? or pretend_not_exclude) and range.last == first)) and
+    (range.first < last or ((!exclude_end? or pretend_not_exclude) and range.first == last))
   end
   alias :intersects? :x?
   
+  # Union
+  # (1..3) | (2..4)
+  # => 1..4
+  # (1...2) | (2..4)
+  # => 1..4
+  # (1..2) | (3..4)
+  # => XRange(1..2, 3..4)
+  # A result will be inadequate if any range is not integered and excludes 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
+    return XRange.new self, range if !x?(range, true)
+    [first, range.first].min..[included_end, range.included_end].max
   end
   
+  # Diff
   def ^(range)
     common = self & range
     self - common | range - common
@@ -132,53 +175,12 @@ class Range
     (first <=> range.first).b || included_end <=> range.included_end
   end
   
-  def center
-    (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 div(n)
-    unless n < 1
-      rarray = []
-      j = self.begin
-      iend = include_end.end
-      rarray << (j..(j+=n)-1) until j+n > iend
-      rarray << (j..iend)
-    end
-  end
-  
-  def /(i)
-    part 1, i
-  end
-  
-  def >>(i)
-    self.begin + i .. include_end.end + i
-  end
-  
-  def <<(i)
-    self.begin - i .. include_end.end - i
-  end
-  
-  def of(ary) 
-    ary[self] 
-  end
-  
-  def odds
-    select {|i| i%2 != 0}
-  end
-  
-  def evens
-    select {|i| i%2 == 0}
-  end
-  
+  # Sum of integers in a range
   def sum
-    ie = include_end.end
-    return (1..ie).sum - (0..-self.begin).sum if self.begin < 0
-    return 0 if ie < self.begin
-    ie*(ie+1)/2 - (1..self.begin-1).sum
+    last = included_end
+    return (1..last).sum - (0..-first).sum if first < 0
+    return 0 if last <= first
+    last*(last+1)/2 - (1..first-1).sum
   end
   
   # minimum of monotone function definition interval
@@ -203,6 +205,30 @@ class Range
     end
   end 
   
+  def odds
+    select {|i| i%2 != 0}
+  end
+  
+  def evens
+    select {|i| i%2 == 0}
+  end
+  
+  # Average
+  def center
+    (first + included_end)/2 
+  end
+  alias :avg :center
+  
+  # Move range as interval right
+  def >>(i)
+    first + i .. included_end + i
+  end
+  
+  # Move range as interval left
+  def <<(i)
+    first - i .. included_end - i
+  end
+  
 end
 
 class XRange
@@ -337,7 +363,7 @@ public
   end
   
   def inspect
-    "XRange(#{@ranges.join(', ').gsub('Infinity', '∞')})"
+    "XRange(#{@ranges.join(', ').gsub('-Infinity', '-∞').gsub('Infinity', '+∞')})"
   end
   
 end

data/lib/rmtools/version.rb

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

data/lib/rmtools/xml/xpath.rb

@@ -19,11 +19,11 @@ module LibXML
         x.gsub! %r{(^|/)([^.#\w*/'"])}, '\1*\2'
         x.gsub! %r{\[([a-z]+)}, '[@\1'
         x.gsub! %r{(\[(?:@\w+!?=)?)['"]?([^'"\]@]+)['"]?\]}, '\1"\2"]'
-        if x !~%r{^(#{
-                        }(\./|\.//|/|//)?#{
-                        }(\w+:)?(\w+|\*)#{                         #  [ns:]name
-                        }(\[(@\w+(!?="[^"]+")?|"[^"]+")\])*#{#  attributes [@href!="pics/xynta.jpeg"]
-                        }(\[-?\d+\]|\{[^\}]+\})?#{               #  inruby-filters (see finder functions ^)
+        if x !~%r{^(?:#{
+                        }(?:\./|\.//|/|//)?#{
+                        }(?:(?:[\w\-]+:)?[\w\-]+|\*)#{                         #  [ns:]name
+                        }(?:\[(?:@\w+(!?="[^"]+")?|"[^"]+")\])*#{#  attributes [@href!="pics/xynta.jpeg"]
+                        }(?:\[-?\d+\]|\{[^\}]+\})?#{               #  inruby-filters (see finder functions ^)
                         })+$}
           raise XML::Error, "can't process `#{xpath}`; #{x}" 
         end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rmtools
 version: !ruby/object:Gem::Version
-  version: 2.0.0.rc5
-  prerelease: 6
+  version: 2.0.0
+  prerelease: 
 platform: ruby
 authors:
 - Sergey Baev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-21 00:00:00.000000000 Z
+date: 2013-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -182,9 +182,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24