rmtools 1.0.0 → 1.1.0

data/lib/rmtools/enumerable/array.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+require 'active_support/core_ext/array'
+require_with_path 'functional/fold'
+
+class Array
+
+  # arithmetics
+  def avg
+    sum.to_f/size
+  end
+  
+  # for use with iterators
+  def avg_by(&b)
+    sum(&b).to_f/size
+  end
+  
+  def scale(top)
+    case top
+      when Numeric; ratio = max.to_f/top
+      when Array; ratio = zip(top).map {|a,b| b ? a.to_f/b : 0}.max
+      else raise TypeError, "number or array of numbers expceted, #{top.class} given"
+    end
+    map {|e| e/ratio}
+  end
+  
+  
+  # setters/getters
+  def set_where(value, &block)
+    return unless e = find(&block)
+    self[index(e)] = value
+  end
+  
+  def set_all_where(value, &block)
+    select(&block).each {|e| self[index(e)] = value}
+  end
+  
+  def indice_where(&block)
+    return unless e = find(&block)
+    index(e)
+  end
+  alias :pos :indice_where
+  
+  def indices_where(&block)
+    i = nil
+    find_all(&block).map {|e|
+      i = i ?
+        self[i+1..-1].index(e) + i + 1 :
+        index(e)
+    }
+  end
+  
+  
+  # splitters
+  def div(int, to_int_parts=nil)
+    len = int.to_i
+    return [self] if len <= 0
+    arr = dup
+    newarr = []
+    while arr.size > 0
+      newarr << arr.slice!(0, len)
+    end
+    newarr
+  end
+  
+  def div!(int, to_int_parts=nil)
+    replace(div(int, to_int_parts))
+  end
+  
+  
+  # selectors
+  def sorted_uniq_by(&block) 
+    uniq_by(&block).sort_by(&block)
+  end
+  
+  def odds
+    values_at(*(0...size).odds)
+  end
+  
+  def evens
+    values_at(*(0...size).evens)
+  end
+  
+  # conditional
+  def uniq?
+    uniq == self
+  end  
+  
+  def every?
+    !find {|e| !yield(e)}
+  end
+  
+  # concatenation  
+  # analogue to String#>>
+  def >>(ary)
+    ary.replace(self + ary)
+  end
+  
+  
+  
+  alias :casecmp :===
+  # making multiple pattern matching possible:
+  # a, b = '3', '10'
+  # case [a, b]
+  #   when [Integer, Integer]; a+b
+  #   when [/\d/, '10']; '%*d'%[a, b]
+  #   ...
+  # end
+  def ===(obj)
+    return true if casecmp(obj) 
+    !!(obj.kinda(Array) and obj.size == size and 
+        each_with_index {|e, i| e == :_ or e === obj[i] or return false})
+  end
+  
+  
+  
+  
+  def map_hash(&b)
+    Hash[map(&b)]
+  end
+
+  def map_with_index(&block)
+    each_with_index.map(&block)
+  end
+    
+    
+    
+    
+  # mapreduce
+  def sum(identity=0, &b) foldl(:+, &b) || identity end
+  
+  # fastering activesupport's method
+  def group_by(&b) count(:group, &b) end
+  
+end

data/lib/rmtools/enumerable/array_iterators.rb

@@ -0,0 +1,33 @@
+require_with_path 'enumerable/array'
+
+unless defined? RMTools::Iterators
+  
+  # [1, 2, 3].to_ss # => ['1', '2', '3']
+  # [[1,2,3], [4,5,6], [7,8,9]].to_sss
+  # => [["1", "2", "3"], ["4", "5", "6"], ["7", "8", "9"]]
+  # [["1", "2", "3"], ["4", "5", "6"], ["7", "8", "9"]].subss!(/\d+/) {|m| (m.to_i % 3).to_s}
+  # => [["1", "2", "0"], ["1", "2", "0"], ["1", "2", "0"]]
+  # [[1, 2, 0], [1, 2, 0], [1, 2, 0]].sum_zeros?
+  # => [false, false, true, false, false, true, false, false, true]
+  # [[1, 2, 3], [3, 4, 6], [3, 8, 0]].uniq_by_odds?
+  # => [[1, 2, 3], [3, 4, 6]]
+  class Array
+    alias :throw_no :method_missing
+    RMTools::Iterators = %r{(#{(%w{select reject partition find_all find sum foldr min max}+instance_methods.grep(/_by$/))*'|'})_([\w\d\_]+[!?]?)}
+    
+    def method_missing(method, *args, &block)
+      if match = (meth = method.to_s).match(RMTools::Iterators)
+        iterator, meth = match[1..2]
+        meth = meth.to_sym
+        return send(iterator) {|i| i.__send__ meth, *args, &block}
+      elsif meth.sub!(/sses([!?]?)$/, 'ss\1') or meth.sub!(/ies([!?]?)$/, 'y\1') or meth.sub!(/s([!?]?)$/, '\1')
+        return map {|i| i.__send__ meth.to_sym, *args, &block}
+      else
+        throw_no method
+      end
+    rescue NoMethodError
+      throw_no method
+    end
+  end
+
+end

data/lib/rmtools/enumerable/common.rb

@@ -0,0 +1,49 @@
+require 'set'
+
+module Enumerable
+  
+  def import(arr, index)
+    self[index] = arr[index]
+  end
+  
+  def export(arr, index)
+    arr[index] = self[index]
+  end
+  
+  def xprod(obj, inverse=false)
+    obj = obj.to_a if obj.is_a? Set
+    obj = [obj] unless obj.is_a? Array
+    inverse ? obj.to_a.product(self) : product(obj)
+  end
+      
+  def recursive_find(&b)
+    res = nil
+    to_a.each {|e|
+      return e if b[e]
+      if e.resto :recursive_find and res = e.recursive_find(&b)
+        return res
+      end
+    }
+    res
+  end
+      
+  def recursive_find_all(&b)
+    res = []
+    to_a.each {|e|
+      res << e if b[e]
+      if e.resto :recursive_find
+        res.concat e.recursive_find_all(&b)
+      end
+    }
+    res.uniq
+  end
+  
+  def present
+    to_a.present
+  end
+  
+  def +(array)
+    to_a + array.to_a
+  end
+
+end

data/lib/rmtools/{hash.rb → enumerable/hash.rb}

@@ -1,15 +1,11 @@
-# encoding: utf-8
 class Hash
+  alias :>> :reverse_merge!
   
   def +(other_hash)
     merge(other_hash || {})
   end
   
-  def concat(other_hash)
-    merge!(other_hash || {})
-  end
-  
-  def unify_strs
+  def unify_keys
     each {|k, v|
       if k.is String
         sk = k.to_sym
@@ -21,9 +17,13 @@ class Hash
     }
   end
   
-  def max; [(m = keys.max), self[m]] end
+  def max_by_key; [(m = keys.max), self[m]] end
+  
+  def min_by_key; [(m = keys.min), self[m]] end
+  
+  def max_by_value; [(m = values.max), self[m]] end
   
-  def min; [(m = keys.min), self[m]] end
+  def min_by_value; [(m = values.min), self[m]] end
   
   # should be overriden by extension maps
   def map2

data/lib/rmtools/enumerable/object_space.rb

@@ -0,0 +1,19 @@
+require_with_path 'enumerable/common'
+
+module ObjectSpace
+  extend Enumerable
+ 
+  def self.each(&b) each_object(&b) end
+  
+  def self.size; each_object {} end
+  
+  def self.find(id=nil)
+    if id
+      find {|obj| obj.object_id == id} 
+    else
+      each_object {|obj| return obj if yield obj}
+      nil
+    end
+  end
+ 
+end

data/lib/rmtools/enumerable/range.rb

@@ -0,0 +1,201 @@
+# encoding: utf-8
+unless defined? Inf
+  Inf = 1.0/0
+end
+
+class Range
+  
+  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_
+  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 -@
+    XRange(-Inf..self.begin-1, include_end.end+1..Inf)
+  end
+  
+  def -(range)
+    self & -range
+  end
+  
+  def x?(range)
+    range_end = range.include_end.end
+    self_end = self.include_end.end
+    if self_end < range_end
+      self_end >= range.begin - (self_end.kinda Integer and range.begin.kinda Integer).to_i
+    else
+      range_end >= self.begin - (self.begin.kinda Integer and range_end.kinda Integer).to_i
+    end
+  end
+    
+  def <=>(range) 
+    (self.begin <=> range.begin).b || self.include_end.end <=> range.include_end.end 
+  end
+  
+  def include_end() 
+    exclude_end? ? self.begin..(self.end - 1) : self 
+  end
+  
+  def center() 
+    (first + last + (!exclude_end?).to_i)/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 + (!exclude_end?).to_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
+  
+end
+
+class XRange
+  attr_accessor :ranges
+  __init__
+  
+  def initialize *args
+    if (str = args[0]).is String
+      str.scan(/([&|v\^])?((-?\d+)\.\.(\.)?(-?\d+))/).each {|s|
+        s[2], s[4] = s[2].to_i, s[4].to_i
+        r = s[3] ? s[2]..s[4]-1 : s[2]..s[4]
+        @ranges = case s[0]
+                          when '&', '^'; intersect r
+                          when '|', 'v'; union r
+                          else [r]
+                        end
+      }
+      @ranges.sort!
+    else
+      0.upto(args.sort!.size-2) {|i| args[i,2] = [nil, args[i]|args[i+1]] if args[i].x? args[i+1]}
+      @ranges = args.compact.include_ends
+    end
+  end
+  
+  def &(range)
+    if range.is Range
+      XRange.new *intersect(range)
+    else
+      @ranges.map {|r| range & r}.foldl(:|)
+    end
+  end
+  
+  def |(range)
+    if range.is Range
+      XRange.new *union(range)
+    else
+      @ranges.each {|r| range |= r}
+      range
+    end
+  end
+  
+  def -@
+    @ranges.map {|r| -r}.foldl(:&)
+  end
+  
+  def -(range)
+    self & -range
+  end
+  
+private
+  
+  def intersect(range)
+    @ranges.map {|r| r&range}.compact
+  end
+  
+  def union(range)
+    changed = (rs = @ranges.map {|r| (r.x?range) ? r|range : r}) != @ranges
+    changed ? rs : rs << range
+  end
+    
+  include Enumerable
+  
+public
+  def each(&b) 
+    @ranges.each {|r| r.each &b} 
+  end
+  
+  def of(ary) 
+    @ranges.foldl(:+) {|r| ary[r]} 
+  end
+  
+  def empty?
+    @range.empty?
+  end
+  
+  def include?(number_or_range)
+    @ranges.find_include?(number_or_range)
+  end
+  
+  def size
+    @ranges.sum_size
+  end
+  
+  def div(n)
+    unless n < 1
+      i = 0
+      rarray = []
+      j = @ranges[0].begin
+      while range = @ranges[i]
+        if j+n > range.end
+          rarray << (j..range.end)
+          i += 1
+          j = @ranges[i].begin if @ranges[i]
+        else
+          rarray << (j..(j+=n)-1)
+        end
+      end
+      rarray
+    end
+  end
+  
+  def inspect
+    "XRange(#{@ranges.join(', ').gsub('Infinity', '∞')})"
+  end
+  
+end
+

data/lib/rmtools/enumerable.rb

@@ -0,0 +1 @@
+require_with_path __FILE__, '*'

data/lib/rmtools/experimental/blackhole.rb

@@ -0,0 +1,12 @@
+class BlackHole
+
+  # abc = BlackHole.new
+  # (abc.first.get {|_| !_}.something << 'blah blah')[123].raise!
+  # => #<BlackHole:0xb66367b0>
+  # 
+  # Think twice before use it. It may devour your code!
+  def method_missing *args
+    BlackHole.new
+  end
+  
+end

data/lib/rmtools/experimental/deprecation.rb

@@ -0,0 +1,36 @@
+require_with_path 'console/coloring'
+
+class Object
+  # class Klass
+  #   def old_method *argv
+  #     deprecation :new_method, *argv
+  #   end
+  # end
+  # Klass.new.old_method
+  #   gives:
+  # DEPRECATION from /path/to/libs/lib.rb: Klass#old_method is deprecated. Use #new_method instead.
+  # => <new_method(*argv) result>
+  #
+  # Same shit:
+  # class Klass
+  #   deprecate :old_method, :new_method
+  # end
+  def deprecation message="", *argv
+    caler = caller[0].parse(:caller)
+    sym = nil
+    if message.is Symbol
+      sym, message = message, "Use ##{message} instead."
+    end
+    STDERR.puts "#{RMTools::Painter.red 'DEPRECATION'} from #{RMTools::Painter.gray caler.path}: #{self.class}##{caler.func} is deprecated. #{message.capitalize}" if caler
+    __send__ sym, *argv if sym
+  end
+  
+end
+
+class Class
+  
+  def deprecate old_method, new_method
+    define_method(new_method) {|*argv| deprecation old_method, *argv}
+  end
+  
+end

data/lib/rmtools/experimental/dumps.rb

@@ -0,0 +1,28 @@
+class Array
+  
+  def dump(depth=5)
+    res = "[ "
+    res << map_with_index {|j, i|
+      j = 'nil' if j.nil?
+      "%0*d: %s、"%[i, (size-1).to_s.size, dump_recurse(j,0,depth)]
+    }*"\n  "
+    res << "]\n"
+  end
+  
+end
+
+class Hash
+  
+  def dump(depth=5)
+    res = "{ "
+    res << map {|i, j|
+      i = 'nil' if i.nil?
+      j = 'nil' if j.nil?
+      "%0*s => %s、\n"%[i, keys.to_ss.max, dump_recurse(j,0,depth)]
+    }*"\n  "
+    res << "}\n"
+  end
+  
+end
+
+

data/lib/rmtools/{numeric.rb → experimental/numeric.rb}

@@ -1,4 +1,18 @@
-# encoding: utf-8
+class Float
+  
+  def partial(range=100)
+    return to_i.to_s if to_i == self
+    a = abs
+    (2..range-1).each {|i| (1..range).each {|j|
+        n = j.to_f/i
+        break if n > a
+        return "#{'-' if self != a}#{j}/#{i}" if n == a
+    } }
+    self
+  end
+      
+    end
+    
 class Integer
   
   def digits
@@ -10,22 +24,10 @@ class Integer
     nums
   end
   
-  def mult_of(subj) # allready implemented in ActiveSupport though
-    self%subj == 0
-  end
-  
   def each_bit # descending order
     to_s(2).each_byte {|b| yield(b == 49)}
   end
   
-  def blur_bm
-    to_s(2).gsub(/.?1.?/) {|m| m.size==3?'111':'11'}.to_i(2)
-  end
-  
-  def hex
-    sprintf "%x", self
-  end
-  
   def to_array(base=10)
     int = self
     ary = []
@@ -36,47 +38,16 @@ class Integer
     end while int != 0
     ary.reverse!
   end
-  
+    
 end
 
-class Numeric
-  
-  def ceil_to(i)
-    self + i - self%i 
-  end
+class Array
   
-  def floor_to(i)
-    self - self%i
+  def compile_int(base=10)
+    int = 0
+    pos = size
+    each {|i| int += base**(pos -= 1) * i}
+    int
   end
   
-  def round_to(i)
-    [ceil_to(i), floor_to(i)].max
-  end
-  
-  def between(min, max)
-    min < self and self < max
-  end
-  
-end    
-
-class Float
-  
-  def partial(range=100)
-    return to_i.to_s if to_i == self
-    a = abs
-    (2..range-1).each {|i| (1..range).each {|j|
-        n = j.to_f/i
-        break if n > a
-        return "#{'-' if self != a}#{j}/#{i}" if n == a
-    } }
-    self
-  end
-      
-end
-
-module Math
-
-  def logb(b, x) log(x)/log(b) end
-
 end
-    

data/lib/rmtools/experimental/rails_backtrace.rb

@@ -0,0 +1,29 @@
+module RMTools
+  def highlighted_line_html file, line
+    if File.file?(file)
+      "   >>   <a style=\"color:#0A0; text-decoration: none;\"#{
+        " href=\"http://#{
+          defined?(DEBUG_SERVER) ? DEBUG_SERVER : 'localhost:8888'
+        }/code/#{CGI.escape CGI.escape(file).gsub('.', '%2E')}/#{line}\""
+      }>#{read_lines(file, line.to_i).chop}</a>" 
+    end
+  end
+
+  def format_trace_html a
+    bt, calls, i = [], [], 0
+    m = a[0].match(/^(.+):(\d+)(?::in `([^']+)')?$/)
+    while i < a.size
+      m2 = a[i+1] && a[i+1].match(/^(.+):(\d+)(?::in `([^']+)')?$/)
+      if m and m[3] and m2 and m[1..2] == m2[1..2]
+        calls.unshift " <- `#{m[3]}'"
+      elsif m and m[1] !~ /\.gemspec$/ and line = highlighted_line_html(*m[1..2])
+        bt << "#{a[i]}#{calls.join}\n#{line}"
+        calls = []
+      else bt << a[i]
+      end
+      i += 1
+      m = m2
+    end
+    bt
+  end
+end