rmtools 1.0.0

data/ext/rmtools.h

@@ -0,0 +1,161 @@
+#ifndef __RUBY_INTERNALS_HH__
+#define __RUBY_INTERNALS_HH__
+
+#include <ruby.h>
+
+#ifdef RUBY_IS_19
+
+#include <ruby/intern.h>
+#include <ruby/defines.h>
+#include <ruby/re.h>
+#include <assert.h>
+
+# define ARY_EMBED_P(ary) \
+    (assert(!FL_TEST(ary, ELTS_SHARED) || !FL_TEST(ary, RARRAY_EMBED_FLAG)), \
+     FL_TEST(ary, RARRAY_EMBED_FLAG))
+#define ARY_SET_EMBED_LEN(ary, n) do { \
+    long tmp_n = n; \
+    RBASIC(ary)->flags &= ~RARRAY_EMBED_LEN_MASK; \
+    RBASIC(ary)->flags |= (tmp_n) << RARRAY_EMBED_LEN_SHIFT; \
+} while (0)
+#define ARY_SET_HEAP_LEN(ary, n) do { \
+    RARRAY(ary)->as.heap.len = n; \
+} while (0)
+#define ARY_SET_LEN(ary, n) do { \
+    if (ARY_EMBED_P(ary)) { \
+        ARY_SET_EMBED_LEN(ary, n); \
+    } \
+    else { \
+        ARY_SET_HEAP_LEN(ary, n); \
+    } \
+} while (0) 
+
+#define BDIGITS(x) ((BDIGIT*)RBIGNUM_DIGITS(x))
+
+// copied from utilrb gem
+typedef struct RNode {
+    unsigned long flags;
+    char *nd_file;
+    union {
+	struct RNode *node;
+	ID id;
+	VALUE value;
+	VALUE (*cfunc)(ANYARGS);
+	ID *tbl;
+    } u1;
+    union {
+	struct RNode *node;
+	ID id;
+	long argc;
+	VALUE value;
+    } u2;
+    union {
+	struct RNode *node;
+	ID id;
+	long state;
+	struct global_entry *entry;
+	long cnt;
+	VALUE value;
+    } u3;
+} NODE;
+
+typedef struct RVALUE {
+    union {
+	struct {
+	    VALUE flags;		/* always 0 for freed obj */
+	    struct RVALUE *next;
+	} free;
+	struct RBasic  basic;
+	struct RObject object;
+	struct RClass  klass;
+	struct RFloat  flonum;
+	struct RString string;
+	struct RArray  array;
+	struct RRegexp regexp;
+	struct RHash   hash;
+	struct RData   data;
+	struct RStruct rstruct;
+	struct RBignum bignum;
+	struct RFile   file;
+	struct RNode   node;
+	struct RMatch  match;
+	struct RRational rational;
+	struct RComplex complex;
+    } as;
+} RVALUE;
+
+static const size_t SLOT_SIZE = sizeof(RVALUE);
+
+#else
+
+#include <intern.h>
+#include <node.h>
+#include <env.h>
+#include <re.h>
+
+# define STR_SET_LEN(x, i) (RSTRING(x)->len = (i))
+ 
+# define RFLOAT_VALUE(f) (RFLOAT(f)->value)
+ 
+# define RBIGNUM_DIGITS(f) (RBIGNUM(f)->digits)
+# define RBIGNUM_LEN(f) (RBIGNUM(f)->len)
+ 
+# define ARY_SET_LEN(x, i) (RARRAY(x)->len = (i))
+
+# define BDIGITS(x) ((BDIGIT*)RBIGNUM(x)->digits)
+
+// copied from utilrb gem
+typedef struct RVALUE {
+    union {
+        struct {
+            unsigned long flags;        /* always 0 for freed obj */
+            struct RVALUE *next;
+        } free;
+        struct RBasic  basic;
+        struct RObject object;
+        struct RClass  klass;
+        struct RFloat  flonum;
+        struct RString string;
+        struct RArray  array;
+        struct RRegexp regexp;
+        struct RHash   hash;
+        struct RData   data;
+        struct RStruct rstruct;
+        struct RBignum bignum;
+        struct RFile   file;
+        struct RNode   node;
+        struct RMatch  match;
+        struct RVarmap varmap;
+        struct SCOPE   scope;
+    } as;
+#ifdef GC_DEBUG
+    char *file;
+    int   line;
+#endif
+} RVALUE;
+static const size_t SLOT_SIZE = sizeof(RVALUE);
+
+
+#endif // 1.9
+
+
+
+// shortcuts for debug r_r
+extern void rb_log_std(const char* str)
+{
+  rb_funcall(rb_gv_get("$log"), rb_intern("debug"), 1, rb_str_new2(str));
+}
+extern void rb_log_obj_std(VALUE obj)
+{
+  rb_funcall(rb_gv_get("$log"), rb_intern("debug"), 1, obj);
+}
+extern void rb_log_file(const char* str)
+{
+  rb_funcall(rb_gv_get("$log"), rb_intern("log"), 1, rb_str_new2(str));
+}
+extern void rb_log_file_obj(VALUE obj)
+{
+  rb_funcall(rb_gv_get("$log"), rb_intern("log"), 1, obj);
+}
+
+#endif

data/lib/rmtools.rb

@@ -0,0 +1,53 @@
+require 'fileutils'
+require 'iconv'
+require 'cgi'
+require 'set'
+require 'strscan'
+
+# why did I put it in here?
+# require "bundler/setup"
+
+# being required *after* rmtools/random it overrides some of a functions and then whine about they are "deprecated", huh
+require 'activesupport' rescue nil
+
+module RMTools
+  rmtools = File.expand_path(__FILE__)[0..-4]
+  require "#{rmtools}/string_to_proc"
+  [ 'string_to_proc',
+    'string', 'object', 'module', 'enum', 'array', 'hash',
+    'numeric',  'stringscanner',  'proc',  'io',  'range',
+      
+    'js',	        #  js hash getter/setter and string concat logic
+    
+    'boolean',	  # {obj.b -> self or false} with python logic
+                  # and native boolean #to_i and #<=>
+                  # Since 2.3.8 active_support has analogue: #presence
+                  # BTW, why so slow?
+                        
+    'logging',  'coloring', # lazy logger
+                            # with caller processing and highlighting
+  #  'traceback',	# python-like traceback for exceptions 
+                  # uses ANSI coloring; kinda buggy, so better
+                  # require 'rmtools/traceback' separately
+      
+                                       
+    'printing', # transparent print: print text (or object info) and erase it
+    'limited_string',       # for compact string inspecting
+    
+    'binding',       # binding inspect
+    'arguments',    # arguments parsing and types validation
+    
+    'cyrilic',  'cyr-time', # String & Regexp methods for Russian processing
+    
+    # some bicycles just for convenience
+    'dumps',  'time',  'random'
+  ].each {|f| require "#{rmtools}/#{f}"}
+end
+
+require "#{rmtools}/rmtools.so" rescue nil
+
+$log = RMTools::RMLogger.new
+
+# Comment out in case of any method conflicts
+# Library methods use module functions explicitly
+class Object; include RMTools end

data/lib/rmtools/arguments.rb

@@ -0,0 +1,24 @@
+class Array
+  
+  def fetch_opts(defaults=[], opts={})
+    if opts and self[-1].is(Hash) and !defaults[size-1].is(Hash)
+      opts = opts.merge pop
+    end
+    each_index {|i| import(defaults, i) if self[i] == :def}
+    defaults.slice! 0, size
+    concat defaults << opts
+  end
+  alias :get_opts :fetch_opts
+
+  def valid_types(pattern_ary)
+    each_with_index.find {|var, i|
+      pattern = pattern_ary[i]
+      if pattern.is Array
+             pattern.find {|j| !(pattern[j] === var[i])}
+      else !(pattern === var[i])
+      end
+    }
+  end
+  
+end
+

data/lib/rmtools/array.rb

@@ -0,0 +1,189 @@
+# encoding: utf-8
+class Array
+
+  def avg
+    sum.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
+  
+  def sorted_uniq_by(&block) 
+    uniq_by(&block).sort_by(&block)
+  end
+      
+  def recursive_find(&b)
+    res = nil
+    each {|e|
+      return e if b[e]
+      if e.resto :recursive_find
+        res = e.recursive_find(&b)
+        return res if res
+      end
+    }
+    res
+  end
+      
+  def recursive_find_all(&b)
+    res = []
+    each {|e|
+      res << e if b[e]
+      if e.resto :recursive_find
+        res.concat e.recursive_find_all(&b)
+      end
+    }
+    res.uniq
+  end
+  
+  def set(value, &block)
+    return unless e = find(&block)
+    self[index(e)] = value
+  end
+  
+  def set_all(value, &block)
+    find_all(&block).each {|e| self[index(e)] = value}
+  end
+  
+  def indice(&block)
+    return unless e = find(&block)
+    index(e)
+  end
+  alias :pos :indice
+  
+  def indices(&block)
+    i = nil
+    find_all(&block).map {|e|
+      i = i ?
+        self[i+1..-1].index(e) + i + 1 :
+        index(e)
+    }
+  end
+  
+  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)
+    len = int.to_i
+    return [self] if len <= 0
+    arr = dup
+    clear
+    while arr.size > 0
+      self << arr.slice!(0, len)
+    end
+    self
+  end
+  
+  def to_dict
+    newhash = {}
+    list = dup
+    list.each {|gr|
+      desc = gr.shift      
+      gr.each {|ex| newhash[ex] = desc}
+    }
+    newhash
+  end
+  
+  def compile_int(base=10)
+    int = 0
+    pos = size
+    each {|i| int += base**(pos -= 1) * i}
+    int
+  end
+  
+  def uniq?
+    uniq == self
+  end  
+  
+  def odds
+    newarr = []
+    each_with_index {|e, i| newarr << e if i%2 == 1}
+    newarr
+  end
+  
+  def evens
+    newarr = []
+    each_with_index {|e, i| newarr << e if i%2 == 0}
+    newarr
+  end
+  
+  def map_hash &b
+    Hash[map(&b)]
+  end
+  
+  def flatmap &b
+    ary = []
+    each {|e| ary.concat yield e}
+    ary
+  end
+  
+  # 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) 
+    !!(if obj.kinda(Array) and obj.size == size
+          each_with_index {|e, i| e == :_ or e === obj[i] or return false}
+        end)
+  end
+    
+  def sum(identity=0, &b) foldl(:+, &b) || identity end
+
+  # should override slower active support's method
+  def group_by(&b) count :group, &b end
+
+if RUBY_VERSION < "1.8.7"
+  def map_with_index
+    a = []
+    each_with_index {|e, i| a << yield(e, i)}
+    a
+  end
+else
+  def map_with_index(&block)
+    each_with_index.map(&block)
+  end
+end
+
+if !defined? RMTools::Iterators
+  alias :throw_no :method_missing
+  RMTools::Iterators = %r{(#{(%w{select reject partition find_all find sum foldr min max flatmap}+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/binding.rb

@@ -0,0 +1,23 @@
+class Binding
+  
+  def inspect_local_variables
+    vars = self.eval('local_variables') # ['a', 'b']
+    values = self.eval "[#{vars * ','}]" # ["a's value", "b's value"]
+    Hash[vars.zip(values)]
+  end
+  
+  def inspect_instance_variables
+    vars = self.eval('instance_variables') # ['@a', '@b']
+    values = self.eval "[#{vars * ','}]" # ["@a's value", "@b's value"]
+    Hash[vars.zip(values)]
+  end
+  
+  def inspect_env
+    self.eval("{'self' => self}").merge(inspect_local_variables).merge(inspect_instance_variables)
+  end
+  
+  def valid_types(pattern_ary)
+    self.eval("[#{self.eval('local_variables')*','}]").valid_types(pattern_ary)
+  end
+  
+end