Class: Object

Inherits:
BasicObject
Includes:
RMTools
Defined in:
lib/rmtools/core/b.rb,
lib/rmtools.rb,
lib/rmtools/core/object.rb,
lib/rmtools/dev/present.rb,
lib/rmtools/core/aliases.rb,
lib/rmtools/conversions/json.rb,
lib/rmtools/core/deprecation.rb,
lib/rmtools/functional/unfold.rb

Overview

-> self or false with python logic Since 2.3.8 ActiveSupport has similar method: #presence Though, #b is obviously more usable due to it's length, and still intuitive: "Boolean", "Being", "to Be" Differs from #presence in that String#b do not use #strip for check

Constant Summary

Constants included from RMTools

RMTools::ANSI2UTF, RMTools::ASCII_readable, RMTools::Alphanum, RMTools::Chars, RMTools::ENCODINGS_PATTERNS, RMTools::ICONVS, RMTools::IgnoreFiles, RMTools::Numbers, RMTools::RuAlphanum, RMTools::RuChars, RMTools::UTF2ANSI, RMTools::VERSION

Instance Method Summary collapse

Methods included from RMTools

#dump_recurse, format_trace, format_trace_to_html, highlighted_line, prepare_write, putdate, puttime, randarr, randstr, read, read_lines, require, rw, tail, tail_n, threadify, tick!, tick_while, timer, write

Instance Method Details

#b ⇒ Object 



8
 
# File 'lib/rmtools/core/b.rb', line 8

def b; self end

#cached(method, *args) ⇒ Object

def hard_method(args) ... hard_calculation ... end

object.cached(:hard_method, *args1)

... hard calculation ... => result with args1 object.cached(:hard_method, *args1) => instant result with args1 object.cached?(:hard_method, *args2) => false object.cached(:hard_method, *args2) ... hard calculation ... => result with args2 object.cached?(:hard_method, *args2) => true object.clear_cache(:hard_method, *args1) => result with args1 object.cached?(:hard_method, *args1) => false object.cached(:hard_method, *args1) ... hard calculation ... => result with args1 object.cached(:hard_method, *args2) => instant result with args2 object.clear_cache(:hard_method) => => result with args1, args2 => result with args2 [object.cached?(:hard_method, *args1), object.cached?(:hard_method, *args2)] => [false, false]



104
105
106
 
# File 'lib/rmtools/core/object.rb', line 104

def cached(method, *args)
  ((@__method_cache__ ||= {})[method.to_sym] ||= {})[args] ||= __send__ method, *args
end

#cached?(method, *args) ⇒ Boolean

Returns:

  • (Boolean) 


118
119
120
 
# File 'lib/rmtools/core/object.rb', line 118

def cached?(method, *args)
  ((@__method_cache__ ||= {})[method.to_sym] ||= {}).include? args
end

#clear_cache(method, *args) ⇒ Object 



108
109
110
111
112
113
114
115
116
 
# File 'lib/rmtools/core/object.rb', line 108

def clear_cache(method, *args)
  if @__method_cache__
    if args.empty?
      @__method_cache__.delete method.to_sym
    elsif method_cache = @__method_cache__[method.to_sym]
      method_cache.delete args
    end
  end
end

#deep_clone ⇒ Object 



125
126
127
 
# File 'lib/rmtools/core/object.rb', line 125

def deep_clone
  _deep_clone({})
end

#define!(new_obj) ⇒ Object

Assign new value by variable or constant address. Can't process numeric, nil, false and true. Though, it can process containers with all of that shit. a = 'Object.new' => "Object.new" def inspire x x.define! eval x end => nil inspire a => #Object:0xb790bed0 a => #Object:0xb790bed0 It's quite buggy, you can get sudden segfault sometime after using method ^_^'
Maybe it could mark used objects for GC not to collect



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'ext/rmtools.cpp', line 20

static VALUE object_define_new_value(VALUE self, VALUE new_obj)
{
    if (FIXNUM_P(self) || self == Qnil || self == Qfalse || self == Qtrue || self == Qundef) {
        VALUE tmp = rb_mod_name(rb_obj_class(self));
        const char* msg = StringValuePtr(tmp);
        rb_raise(rb_eTypeError, "can't redefine %s", msg);
    }
    if (FIXNUM_P(new_obj) || new_obj == Qnil || new_obj == Qfalse || new_obj == Qtrue  || new_obj == Qundef) {
        VALUE tmp = rb_mod_name(rb_obj_class(self));
        const char* msg = StringValuePtr(tmp);
        rb_raise(rb_eTypeError, "can't define object as %s", msg);
    }
    // Place the definition of the new object in the slot of self
    memcpy(reinterpret_cast<void*>(self), reinterpret_cast<void*>(rb_funcall(new_obj, rb_intern("clone"), 0)), SLOT_SIZE);
    return self;
}

#deprecate_method(message = "", *argv) ⇒ Object

class Klass def old_method *argv deprecate_method :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_method :old_method, :new_method end



17
18
19
20
21
22
23
24
25
 
# File 'lib/rmtools/core/deprecation.rb', line 17

def deprecate_method message="", *argv
  caler = caller[0].parse(:caller)
  sym = nil
  if message.is Symbol
    sym, message = message, "Use ##{message} instead."
  end
  STDERR.puts "DEPRECATION from #{caler.path}: #{self.class}##{caler.func} is deprecated. #{message.capitalize}" if caler
  __send__ sym, *argv if sym
end

#ifndef(ivar = caller(1)[0].parse(:caller).func) ⇒ Object

def result_of_hard_calculation ifndef hard_calculation ... end

def result_of_hard_calculation if defined? @result_of_hard_calculation return @result_of_hard_calculation else ... hard_calculation res = ... @result_of_hard_calculation = res end end



68
69
70
71
72
 
# File 'lib/rmtools/core/object.rb', line 68

def ifndef(ivar=caller(1)[0].parse(:caller).func)
  ivar = :"@#{ivar}"
  return instance_variable_get ivar if instance_variable_defined? ivar
  instance_variable_set ivar, yield 
end

#in(*container) ⇒ Object 



47
48
49
 
# File 'lib/rmtools/core/object.rb', line 47

def in(*container)
  container.size == 1 ? container[0].include?(self) : container.include?(self)
end

#inspect_instance_variables ⇒ Object 



51
52
53
 
# File 'lib/rmtools/core/object.rb', line 51

def inspect_instance_variables
  instance_eval {binding().inspect_instance_variables}
end

#is(klass) ⇒ Object 



4
5
6
7
8
9
 
# File 'lib/rmtools/core/object.rb', line 4

def is klass
  if Array === klass
    instance_of?(Array) && self[0].instance_of?(klass[0])
  else instance_of? klass
  end
end

#kinda(klass) ⇒ Object 



11
12
13
14
15
16
 
# File 'lib/rmtools/core/object.rb', line 11

def kinda klass
  if Array === klass
    kind_of?(Array) && self[0].kind_of?(klass[0])
  else kind_of? klass
  end
end

#load_from(obj) ⇒ Object 



42
43
44
45
 
# File 'lib/rmtools/core/object.rb', line 42

def load_from(obj)
  readable_variables.each {|v| instance_variable_set("@#{v}", obj.instance_variable_get("@#{v}"))}
  self
end

#my_methods(filter = //) ⇒ Object 



18
19
20
 
# File 'lib/rmtools/core/object.rb', line 18

def my_methods filter=//
  (self.public_methods - Object.public_instance_methods).sort!.grep(filter)
end

#my_methods_with(params) ⇒ Object 



26
27
28
29
30
 
# File 'lib/rmtools/core/object.rb', line 26

def my_methods_with params
  m = my_methods
  params.each {|p,val| m.reject! {|_| ''.method(_).send(p) != val}}
  m
end

#personal_methods(filter = //) ⇒ Object 



22
23
24
 
# File 'lib/rmtools/core/object.rb', line 22

def personal_methods filter=//
  (self.public_methods - self.class.superclass.public_instance_methods).sort!.grep(filter)
end

#personal_methods_with(params) ⇒ Object 



32
33
34
35
36
 
# File 'lib/rmtools/core/object.rb', line 32

def personal_methods_with params
  m = personal_methods
  params.each {|p,val| m.reject! {|_| ''.method(_).send(p) != val}}
  m
end

#present ⇒ Object 



4
5
6
7
 
# File 'lib/rmtools/dev/present.rb', line 4

def present
  [true, false, nil, Numeric, String, Regexp].each {|klass| return puts inspect if klass === self}
  Hash[readable_variables.map {|v| [":#{v}", __send__(v)]}].present
end

#readable_variables ⇒ Object 



38
39
40
 
# File 'lib/rmtools/core/object.rb', line 38

def readable_variables
  public_methods.to_ss & instance_variables.map {|v|v[1..-1]}
end

#to_json_safe(options = nil, timeout: 10) ⇒ Object

handy when data may appear non-encodable (active_record objects, recursive structures, etc)



87
88
89
 
# File 'lib/rmtools/conversions/json.rb', line 87

def to_json_safe(options=nil, timeout: 10)
  timeout(timeout) {to_json(options)}
end

#unfold(breaker = lambda{|x|x.b}, &splitter) ⇒ Object

@ breaker must be callable that returns true value if that's it @ &splitter must return a pair



6
7
8
9
10
11
12
13
 
# File 'lib/rmtools/functional/unfold.rb', line 6

def unfold(breaker=lambda{|x|x.b}, &splitter)
  obj, container = self, []
  until breaker.call obj
    obj, next_element = splitter[obj]
    container.unshift next_element
  end
  container
end