arg_list(arity)
click to toggle source
def arg_list(arity)
args = []
if arity == -1
args << "*args"
else
arity.times do |i|
args << "arg#{i}"
end
end
args
end
collect_classes_under_module(mod)
click to toggle source
def collect_classes_under_module(mod)
collect_under_module(mod, Class)
end
collect_modules_under_module(mod)
click to toggle source
def collect_modules_under_module(mod)
collect_under_module(mod, Module)
end
collect_under_module(mod, klass)
click to toggle source
def collect_under_module(mod, klass)
mod.constants.collect do |x|
mod.const_get(x)
end.find_all do |x|
x.is_a?(klass)
end
end
combination(elements)
click to toggle source
def combination(elements)
return [] if elements.empty?
first, *rest = elements
results = combination(rest)
if results.empty?
[[], [first]]
else
results + results.collect {|result| [first, *result]}
end
end
compute_bottom_y(base_y, base_height, target_height, max_y)
click to toggle source
def compute_bottom_y(base_y, base_height, target_height, max_y)
bottom = base_y + base_height - target_height
[[bottom, max_y - target_height].min, 0].max
end
compute_left_x(base_x)
click to toggle source
def compute_left_x(base_x)
[base_x, 0].max
end
compute_right_x(base_x, base_width, target_width, max_x)
click to toggle source
def compute_right_x(base_x, base_width, target_width, max_x)
right = base_x + base_width - target_width
[[right, max_x - target_width].min, 0].max
end
compute_top_y(base_y)
click to toggle source
def compute_top_y(base_y)
[base_y, 0].max
end
corresponding_class_under_module(mod)
click to toggle source
def corresponding_class_under_module(mod)
corresponding_objects(collect_classes_under_module(mod))
end
corresponding_module_under_module(mod)
click to toggle source
def corresponding_module_under_module(mod)
corresponding_objects(collect_modules_under_module(mod))
end
corresponding_objects(objects)
click to toggle source
def corresponding_objects(objects)
objects.find_all do |object|
object.respond_to?(:priority)
end.sort_by do |object|
object.priority
end.last
end
drawable_to_pixbuf(drawable)
click to toggle source
def drawable_to_pixbuf(drawable)
args = [drawable.colormap, drawable, 0, 0, *drawable.size]
Gdk::Pixbuf.from_drawable(*args)
end
ensure_time(object)
click to toggle source
def ensure_time(object)
return nil if object.nil?
return object if object.is_a?(Numeric)
if /\A\s*\z/ =~ object
nil
else
if /\A\s*(\d*\.?\d*)\s*(h|m|s)?\s*\z/ =~ object
time = $1.to_f
unit = $2
if unit
case unit.downcase
when "m"
time *= 60
when "h"
time *= 3600
end
end
time.to_i
else
nil
end
end
end
events_pending_available?()
click to toggle source
def events_pending_available?
!windows?
end
find_path_in_load_path(*name)
click to toggle source
def find_path_in_load_path(*name)
found_path = $LOAD_PATH.find do |path|
File.readable?(File.join(path, *name))
end
if found_path
File.join(found_path, *name)
else
nil
end
end
init_by_constants_as_default_value(obj)
click to toggle source
def init_by_constants_as_default_value(obj)
klass = obj.class
klass.constants.each do |name|
const = klass.const_get(name)
unless const.kind_of?(Class)
var_name = name.downcase
obj.instance_variable_set("@#{var_name}", const.dup)
klass.module_eval {attr_accessor var_name}
end
end
end
move_to(base, target) { |*args| ... }
click to toggle source
def move_to(base, target)
window = base.window
screen = window.screen
num = screen.get_monitor(window)
monitor = screen.monitor_geometry(num)
window_x, window_y = window.origin
window_width, window_height = window.size
target_width, target_height = target.size_request
args = [window_x, window_y, window_width, window_height]
args.concat([target_width, target_height])
args.concat([screen.width, screen.height])
x, y = yield(*args)
target.move(x, y)
end
move_to_bottom_left(base, target)
click to toggle source
def move_to_bottom_left(base, target)
move_to(base, target) do |bx, by, bw, bh, tw, th, sw, sh|
[compute_left_x(bx), compute_bottom_y(by, bh, th, sh)]
end
end
move_to_bottom_right(base, target)
click to toggle source
def move_to_bottom_right(base, target)
move_to(base, target) do |bx, by, bw, bh, tw, th, sw, sh|
[compute_right_x(bx, bw, tw, sw),
compute_bottom_y(by, bh, th, sh)]
end
end
move_to_top_left(base, target)
click to toggle source
def move_to_top_left(base, target)
move_to(base, target) do |bx, by, bw, bh, tw, th, sw, sh|
[compute_left_x(bx), compute_top_y(by)]
end
end
move_to_top_right(base, target)
click to toggle source
def move_to_top_right(base, target)
move_to(base, target) do |bx, by, bw, bh, tw, th, sw, sh|
[compute_right_x(bx, bw, tw, sw), compute_top_y(by)]
end
end
parse_four_way(*values)
click to toggle source
def parse_four_way(*values)
if values.size == 1 and
(values.first.is_a?(Array) or values.first.is_a?(Hash))
values = values.first
end
if values.is_a?(Hash)
extract_four_way(values)
else
case values.size
when 1
left = right = top = bottom = Integer(values.first)
when 2
top, left = values.collect {|x| Integer(x)}
bottom = top
right = left
when 3
top, left, bottom = values.collect {|x| Integer(x)}
right = left
when 4
top, right, bottom, left = values.collect {|x| Integer(x)}
else
raise ArgumentError
end
[top, right, bottom, left]
end
end
process_pending_events()
click to toggle source
def process_pending_events
if events_pending_available?
while Gtk.events_pending?
Gtk.main_iteration
end
end
end
process_pending_events_proc()
click to toggle source
def process_pending_events_proc
Proc.new do
process_pending_events
end
end
quartz?()
click to toggle source
def quartz?
if Gdk.respond_to?(:windowing_quartz?)
Gdk.windowing_quartz?
else
!windows? and !Gdk.windowing_x11?
end
end
require_files_under_directory_in_load_path(dir, silent=true)
click to toggle source
def require_files_under_directory_in_load_path(dir, silent=true)
normalize = Proc.new do |base_path, path|
path.sub(/\A#{Regexp.escape(base_path)}\/?/, '').sub(/\.[^.]+$/, '')
end
$LOAD_PATH.each do |path|
source_glob = ::File.join(path, dir, '*')
Dir.glob(source_glob) do |source|
next if File.directory?(source)
begin
before = Time.now
normalized_path = normalize[path, source]
require_safe normalized_path
unless silent
STDERR.puts([Time.now - before, normalized_path].inspect)
end
rescue LoadError, RuntimeError
if $!.is_a?(RuntimeError)
raise if /\ACannot open display:\s*\d*\z/ !~ $!.message
end
unless silent
STDERR.puts(path)
STDERR.puts($!.message)
STDERR.puts($@)
end
end
end
end
end
require_safe(path)
click to toggle source
def require_safe(path)
require path
rescue LoadError
$".reject! {|x| /\A#{Regexp.escape(path)}/ =~ x}
raise
end
split_number_to_minute_and_second(number)
click to toggle source
def split_number_to_minute_and_second(number)
if number >= 0
sign = " "
else
sign = "-"
end
[sign, *number.abs.divmod(60)]
end
stringify_hash_key(hash)
click to toggle source
def stringify_hash_key(hash)
stringified_hash = {}
hash.each do |key, value|
stringified_hash[key.to_s] = value
end
stringified_hash
end
support_console_output?()
click to toggle source
def support_console_output?
if windows?
begin
File.open("conout$", "w") {}
true
rescue SystemCallError
false
end
else
$stdout.tty? or ENV["TERM"]
end
end
syntax_highlighting_debug?()
click to toggle source
def syntax_highlighting_debug?
ENV["RABBIT_SYNTAX_HIGHLIGHTING_DEBUG"] == "yes"
end
time(message=nil) { || ... }
click to toggle source
def time(message=nil)
before = Time.now
yield
ensure
output = Time.now - before
output = [message, output] if message
p output
end
to_class_name(name)
click to toggle source
def to_class_name(name)
name.gsub(/(?:\A|_|\-)([a-z])/) do |x|
$1.upcase
end
end
unescape_title(title)
click to toggle source
def unescape_title(title)
REXML::Text.unnormalize(title).gsub(/\r|\n/, ' ')
end
windows?()
click to toggle source
def windows?
/cygwin|mingw|mswin32|bccwin32/.match(RUBY_PLATFORM) ? true : false
end