empathy 0.0.1.RC0

data/lib/empathy/object.rb

@@ -0,0 +1,19 @@
+
+warn "empathy/object: Monkey patching Object#sleep and Object@at_exit for EM::reactor awareness"
+
+# Monkey patch object to make EM safe
+class Object
+
+  # use EM safe sleep if we are in the reactor
+  def sleep(*args)
+    kernel = Empathy.event_machine? ? Empathy::EM::Kernel : Kernel
+    kernel.sleep(*args)
+  end
+
+  # run exit blocks created in the reactor as reactor shutdown hooks
+  def at_exit(&block)
+    kernel = Empathy.event_machine? ? Empathy::EM::Kernel : Kernel
+    kernel.at_exit(&block)
+  end
+end
+

data/lib/empathy/thread.rb

@@ -0,0 +1,8 @@
+require 'eventmachine'
+require 'empathy'
+require 'empathy/object'
+
+module Empathy
+ map_classes(::EventMachine,::Object,"Thread","Queue","Mutex","ConditionVariable", "ThreadError" )
+ map_classes(::Object,Empathy::EM,"Thread","Queue","Mutex","ConditionVariable", "ThreadError" => FiberError)
+end

data/lib/empathy/version.rb

@@ -0,0 +1,3 @@
+module Empathy
+  VERSION = "0.0.1.RC0"
+end

data/mspec/lib/mspec/empathy.rb

@@ -0,0 +1,19 @@
+require 'empathy/thread'
+require 'mspec'
+require 'mspec/guards/empathy'
+module MSpec
+
+    class << self
+        alias :process_orig :process
+
+        def process
+            # start the EventMachine, and run reactor code within a Fiber,
+            # when the main fiber finishes, stop the event machine
+            Empathy.run do
+               process_orig
+            end
+        end
+    end
+
+end
+

data/mspec/lib/mspec/guards/empathy.rb

@@ -0,0 +1,10 @@
+class SpecGuard
+  alias :implementation_orig :implementation?
+  def implementation?(*args)
+    args.any? { |name| name == :empathy } || implementation_orig(*args)
+  end
+
+  def standard?
+   implementation?(:ruby) && !implementation?(:empathy)
+  end
+end

data/rubyspec/core/kernel/fixtures/__method__.rb

@@ -0,0 +1,25 @@
+module KernelSpecs
+  class MethodTest
+    def f
+      __method__
+    end
+
+    alias_method :g, :f
+
+    def in_block
+      (1..2).map { __method__ }
+    end
+
+    define_method(:dm) do
+      __method__
+    end
+
+    define_method(:dm_block) do
+      (1..2).map { __method__ }
+    end
+
+    def from_eval
+      eval "__method__"
+    end
+  end
+end

data/rubyspec/core/kernel/fixtures/autoload_b.rb

@@ -0,0 +1,5 @@
+module KSAutoloadB
+  def self.loaded
+    :ksautoload_b
+  end
+end

data/rubyspec/core/kernel/fixtures/autoload_c.rb

@@ -0,0 +1,5 @@
+module KSAutoloadC
+  def self.loaded
+    :ksautoload_c
+  end
+end

data/rubyspec/core/kernel/fixtures/autoload_d.rb

@@ -0,0 +1,5 @@
+module KSAutoloadD
+  def self.loaded
+    :ksautoload_d
+  end
+end

data/rubyspec/core/kernel/fixtures/caller_fixture1.rb

@@ -0,0 +1,42 @@
+require File.expand_path('../caller_fixture2', __FILE__)
+2 + 2
+3 + 3
+CallerFixture.capture do
+  5 + 5
+  6 + 6
+  :seven
+  8 + 8
+end
+
+module CallerFixture
+  module_function
+  def example_proc
+    Proc.new do
+      1 + 1
+      2 + 2
+    end
+  end
+
+  def entry_point
+    second
+  end
+
+  def second
+    third
+  end
+
+  def third
+    b = fourth do
+      1 + 1
+      caller(0)
+    end
+    2 + 2
+    3 + 3
+    return b
+  end
+
+  def fourth(&block)
+    return block
+  end
+end
+

data/rubyspec/core/kernel/fixtures/caller_fixture2.rb

@@ -0,0 +1,26 @@
+module CallerFixture
+  def block
+    @block
+  end
+  module_function :block
+
+  def block=(block)
+    @block = block
+  end
+  module_function :block=
+
+  def capture(&block)
+    @block = block
+  end
+  module_function :capture
+
+  def caller_of(block)
+    eval("caller(0)", block.binding)
+  end
+  module_function :caller_of
+
+  def eval_caller(depth)
+    eval("caller(#{depth})")
+  end
+  module_function :eval_caller
+end

data/rubyspec/core/kernel/fixtures/chomp.rb

@@ -0,0 +1,4 @@
+# -*- encoding: utf-8 -*-
+
+$_ = "あれ\r\n"
+print Kernel.chomp

data/rubyspec/core/kernel/fixtures/chomp_f.rb

@@ -0,0 +1,4 @@
+# -*- encoding: utf-8 -*-
+
+$_ = "あれ\r\n"
+print chomp

data/rubyspec/core/kernel/fixtures/chop.rb

@@ -0,0 +1,4 @@
+# -*- encoding: utf-8 -*-
+
+$_ = "あれ"
+print Kernel.chop

data/rubyspec/core/kernel/fixtures/chop_f.rb

@@ -0,0 +1,4 @@
+# -*- encoding: utf-8 -*-
+
+$_ = "あれ"
+print chop

data/rubyspec/core/kernel/fixtures/classes.rb

@@ -0,0 +1,410 @@
+require File.expand_path('../caller_fixture1', __FILE__)
+
+module KernelSpecs
+  def self.Array_function(arg)
+    Array(arg)
+  end
+
+  def self.Array_method(arg)
+    Kernel.Array(arg)
+  end
+
+  def self.putc_function(arg)
+    putc arg
+  end
+
+  def self.putc_method(arg)
+    Kernel.putc arg
+  end
+
+  def self.has_private_method(name)
+    cmd = <<-EOC
+| #{RUBY_EXE} -n -e '
+m = Kernel.private_instance_methods(false).grep(/^#{name}$/)
+print m.map { |x| x.to_s }.join("")
+'
+    EOC
+    ruby_exe("puts", :args => cmd) == name.to_s
+  end
+
+  def self.chop(str, method)
+    cmd = "| #{RUBY_EXE} -n -e '$_ = #{str.inspect}; #{method}; print $_'"
+    ruby_exe "puts", :args => cmd
+  end
+
+  def self.encoded_chop(file)
+    ruby_exe "puts", :args => "| #{RUBY_EXE} -n #{file}"
+  end
+
+  def self.chomp(str, method, sep="\n")
+    cmd = "| #{RUBY_EXE} -n -e '$_ = #{str.inspect}; $/ = #{sep.inspect}; #{method}; print $_'"
+    ruby_exe "puts", :args => cmd
+  end
+
+  def self.encoded_chomp(file)
+    ruby_exe "puts", :args => "| #{RUBY_EXE} -n #{file}"
+  end
+
+  class Method
+    public :abort, :exec, :exit, :exit!, :fork, :system
+    public :spawn if respond_to?(:spawn, true)
+  end
+
+  class Methods
+
+    module MetaclassMethods
+      def peekaboo
+      end
+
+      protected
+
+      def nopeeking
+      end
+
+      private
+
+      def shoo
+      end
+    end
+
+    def self.ichi; end
+    def ni; end
+    class << self
+      def san; end
+    end
+
+    private
+
+    def self.shi; end
+    def juu_shi; end
+
+    class << self
+      def roku; end
+
+      private
+
+      def shichi; end
+    end
+
+    protected
+
+    def self.hachi; end
+    def ku; end
+
+    class << self
+      def juu; end
+
+      protected
+
+      def juu_ichi; end
+    end
+
+    public
+
+    def self.juu_ni; end
+    def juu_san; end
+  end
+
+  class PrivateSup
+    def public_in_sub
+    end
+
+    private :public_in_sub
+  end
+
+  class PublicSub < PrivateSup
+    def public_in_sub
+    end
+  end
+
+  class A
+    # 1.9 as Kernel#public_method, so we don't want this one to clash:
+    def pub_method; :public_method; end
+
+    def undefed_method; :undefed_method; end
+    undef_method :undefed_method
+
+    protected
+    def protected_method; :protected_method; end
+
+    private
+    def private_method; :private_method; end
+
+    public
+    define_method(:defined_method) { :defined }
+  end
+
+  class B < A
+    alias aliased_pub_method pub_method
+  end
+
+  class VisibilityChange
+    class << self
+      private :new
+    end
+  end
+
+  class Binding
+    @@super_secret = "password"
+
+    def initialize(n)
+      @secret = n
+    end
+
+    def square(n)
+      n * n
+    end
+
+    def get_binding
+      a = true
+      @bind = binding
+
+      # Add/Change stuff
+      b = true
+      @secret += 1
+
+      @bind
+    end
+  end
+
+
+  module BlockGiven
+    def self.accept_block
+      block_given?
+    end
+
+    def self.accept_block_as_argument(&block)
+      block_given?
+    end
+
+    class << self
+      define_method(:defined_block) do
+        block_given?
+      end
+    end
+  end
+
+  module KernelBlockGiven
+    def self.accept_block
+      Kernel.block_given?
+    end
+
+    def self.accept_block_as_argument(&block)
+      Kernel.block_given?
+    end
+
+    class << self
+      define_method(:defined_block) do
+        Kernel.block_given?
+      end
+    end
+  end
+
+  module SelfBlockGiven
+    def self.accept_block
+      self.send(:block_given?)
+    end
+
+    def self.accept_block_as_argument(&block)
+      self.send(:block_given?)
+    end
+
+    class << self
+      define_method(:defined_block) do
+        self.send(:block_given?)
+      end
+    end
+  end
+
+  module KernelBlockGiven
+    def self.accept_block
+      Kernel.block_given?
+    end
+
+    def self.accept_block_as_argument(&block)
+      Kernel.block_given?
+    end
+
+    class << self
+      define_method(:defined_block) do
+        Kernel.block_given?
+      end
+    end
+  end
+
+  class IVars
+    def initialize
+      @secret = 99
+    end
+  end
+
+  module InstEvalCVar
+    instance_eval { @@count = 2 }
+  end
+
+  module InstEval
+    def self.included(base)
+      base.instance_eval { @@count = 2 }
+    end
+  end
+
+  class IncludesInstEval
+    include InstEval
+  end
+
+  class InstEvalConst
+    INST_EVAL_CONST_X = 2
+  end
+
+  module InstEvalOuter
+    module Inner
+      obj = InstEvalConst.new
+      X_BY_STR = obj.instance_eval("INST_EVAL_CONST_X") rescue nil
+      X_BY_BLOCK = obj.instance_eval { INST_EVAL_CONST_X } rescue nil
+    end
+  end
+
+  class EvalTest
+    def self.eval_yield_with_binding
+      eval("yield", binding)
+    end
+    def self.call_yield
+      yield
+    end
+  end
+
+  module DuplicateM
+    def repr
+      self.class.name.to_s
+    end
+  end
+
+  class Duplicate
+    attr_accessor :one, :two
+
+    def initialize(one, two)
+      @one = one
+      @two = two
+    end
+
+    def initialize_copy(other)
+      ScratchPad.record object_id
+    end
+  end
+
+  class Clone
+    def initialize_clone(other)
+      ScratchPad.record other.object_id
+    end
+  end
+
+  class Dup
+    def initialize_dup(other)
+      ScratchPad.record other.object_id
+    end
+  end
+
+  module ParentMixin
+    def parent_mixin_method; end
+  end
+
+  class Parent
+    include ParentMixin
+    def parent_method; end
+    def another_parent_method; end
+    def self.parent_class_method; :foo; end
+  end
+
+  class Child < Parent
+    # In case this trips anybody up: This fixtures file must only be loaded
+    # once for the Kernel specs. If it's loaded multiple times the following
+    # line raises a NameError. This is a problem if you require it from a
+    # location outside of core/kernel on 1.8.6, because 1.8.6 doesn't
+    # normalise paths...
+    undef_method :parent_method
+  end
+
+  class Grandchild < Child
+    undef_method :parent_mixin_method
+  end
+
+  # for testing lambda
+  class Lambda
+    def outer(meth)
+      inner(meth)
+    end
+
+    def mp(&b); b; end
+
+    def inner(meth)
+      b = mp { return :good }
+
+      pr = send(meth) { |x| x.call }
+
+      pr.call(b)
+
+      # We shouldn't be here, b should have unwinded through
+      return :bad
+    end
+  end
+
+  class RespondViaMissing
+    def respond_to_missing?(method, priv=false)
+      case method
+        when :handled_publicly
+          true
+        when :handled_privately
+          priv
+        when :not_handled
+          false
+        else
+          raise "Typo in method name"
+      end
+    end
+
+    def method_missing(method, *args)
+      "Done #{method}(#{args})"
+    end
+  end
+
+  class InstanceVariable
+    def initialize
+      @greeting = "hello"
+    end
+  end
+end
+
+class EvalSpecs
+  class A
+    eval "class B; end"
+    def c
+      eval "class C; end"
+    end
+  end
+
+  def f
+    yield
+  end
+
+  def self.call_eval
+    f = __FILE__
+    eval "true", binding, "(eval)", 1
+    return f
+  end
+end
+
+module CallerSpecs
+  def self.recurse(n)
+    return caller if n <= 0
+    recurse(n-1)
+  end
+end
+
+# for Kernel#sleep to have Channel in it's specs
+# TODO: switch directly to queue for both Kernel#sleep and Thread specs?
+unless defined? Channel
+  require 'thread'
+  class Channel < Queue
+    alias receive shift
+  end
+end