clicube

s=%(s=%(X);s.sub!('X',s);puts s);s.sub!('X',s);puts s

clicube

class Module

  def wrap_package_private name
    wraped_method = instance_method(name)
    define_method(name) do |*args|
      # check
      puts "checking package_private: #{name}"
      if true
        e = NoMethodError.new("package private method is called from outside of the package")
        e.set_backtrace caller

clicube

module Process

  class ProcessError < StandardError; end

  class Process

    attr_reader :pid

    def initialize(*args, &block)
      raise ArgumentError.new("block must be given") unless block_given?

clicube

#include <sys/types.h>
#include <sys/wait.h>
#include <ruby.h>

/* include/ruby/ruby.h */
#ifndef IDTYPET2NUM
#define IDTYPET2NUM(v) INT2FIX(v)
#endif
#ifndef NUM2IDTYPET
#define NUM2IDTYPET(v) FIX2INT(v)

clicube

LIMIT = {}
def limit n
  key = [caller,Thread.current]
  LIMIT[key] ||= n
  LIMIT[key] -= 1
  n = LIMIT[key]
  if n > 0
    n
  else
    LIMIT.delete key

clicube

class Thread
  def self.try_handle_interrupt *args
    if respond_to?(:handle_interrupt)
      self.handle_interrupt(*args){ yield }
    else
      yield
    end
  end
end

clicube

module MyModule
  def pid 
    "MyModule.pid"
  end 
end

module ExtendModule
  def pid 
    "ExtendModule.pid"
  end 

clicube

pid = Process.pid
SimpleCov.at_exit do
  SimpleCov.result.format! if Process.pid == pid
end

clicube

# coding: utf-8
require_relative 'protocol'

# TODO: チェックサムを確認する
class IPv4Header

  attr_reader :version,:header_length,:packet_length,:identification,:frag_dont,:frag_more,:frag_offset,:ttl,:protocol,:checksum,:sndr_addr,:dest_addr,
    :data_length

  def initialize(packet,offset=0)

clicube

require 'mechanize'

class HumanlikeMechanize < Mechanize

  def initialize min,max
    raise ArgumentError.new("min > max") if min > max
    raise ArgumentError.new("min < 0") if min < 0
    raise ArgumentError.new("max < 0") if max < 0
    @sleep_min = min
    @sleep_max = max