cross-stub 0.1.4 → 0.2.0

data/lib/cross-stub/pseudo_class.rb

@@ -1,82 +0,0 @@
-module CrossStub
-
-  private
-
-  class PseudoClass
-
-    @@translator ||= lambda do |metaclass, method|
-      @@convertor ||= lambda {|sexp| Ruby2Ruby.new.process(Unifier.new.process(sexp)) }
-      @@convertor[ParseTree.translate(metaclass, method)] rescue nil
-    end
-
-    def initialize(klass)
-      @klass = get_class(klass)
-      @metaclass = (class << @klass ; self ; end)
-    end
-
-    def get_class(klass)
-      if klass.is_a?(String)
-        klass.split(/::/).inject(Object) { |const_train, const| const_train.const_get(const) }
-      else
-        klass
-      end
-    end
-
-    def id
-      @klass.to_s
-    end
-
-    def method_code(method)
-      @@translator[@metaclass, method]
-    end
-
-    def replace_method(method, value_or_code)
-      status = backup_method(method)
-      @klass.instance_eval "#{value_or_code}" =~ /^def / ? value_or_code :
-          %\def #{method}; Marshal.load(%|#{Marshal.dump(value_or_code)}|) ; end\
-      status
-    end
-
-    def revert_method(method)
-      new_name = before_stubbing_method_name(method)
-      @metaclass.instance_eval("alias_method :#{method}, :#{new_name}") rescue nil
-      remove_method(new_name)
-    end
-
-    def backup_method(method)
-      if @klass.respond_to?(method)
-        !@klass.respond_to?(new_name = before_stubbing_method_name(method)) &&
-          @metaclass.instance_eval("alias_method :#{new_name}, :#{method}")
-        true
-      else
-        false
-      end
-    end
-
-    def remove_method(method)
-      @metaclass.send(:remove_method, method) rescue nil
-    end
-
-    def replace_methods(&blk)
-      (tmp = BlankObject.new).__instance_eval__(&blk)
-      methods_in_block = tmp.__methods__ - BlankObject.new.__methods__
-      is_method_implemented_flags = methods_in_block.inject({}) do |memo, method|
-        memo.merge(method => backup_method(method))
-      end
-      @klass.instance_eval(&blk)
-      is_method_implemented_flags
-    end
-
-    def before_stubbing_method_name(method)
-      :"__#{method}_before_xstubbing"
-    end
-
-  end
-
-  class BlankObject
-    alias_method :__instance_eval__, :instance_eval
-    alias_method :__methods__, :methods
-    instance_methods.each {|m| undef_method m unless m =~ /^__.*__$/ }
-  end
-
-end

data/lib/cross-stub/setup_helpers.rb

@@ -1,13 +0,0 @@
-module CrossStub
-
-  private
-
-  module SetupHelpers
-
-    def setup_for_current_process
-      setup_cache
-    end
-
-  end
-
-end

data/lib/cross-stub/stub_helpers.rb

@@ -1,64 +0,0 @@
-module CrossStub
-
-  private
-
-  module StubHelpers
-
-    def clear_stubs_for_current_process
-      if File.exists?(options[:file])
-        unapply_stubs ; delete_cache
-      end
-    end
-
-    def apply_stubs_for_current_process(*args, &blk)
-      pk, args = PseudoClass.new(args[0]), args[1]
-      update_cache do |entire_cache|
-        hash = (args[0].is_a?(Hash) ? args[0] : args.inject({}){|h, k| h.merge(k => nil) })
-        cache = entire_cache[pk.id] || {}
-        cache = create_stub_from_hash(pk, cache, hash)
-        cache = create_stub_from_block(pk, cache, &blk) if block_given?
-        entire_cache.merge(pk.id => cache)
-      end
-    end
-
-    def apply_or_unapply_stubs_for_other_process
-      lambda {
-        unapply_stubs(load_backup_cache)
-        load_cache.each do |klass, hash|
-          pk = PseudoClass.new(klass)
-          hash.each {|method, codes| pk.replace_method(method, codes[:after]) }
-        end
-      }[] rescue nil
-    end
-
-    def unapply_stubs(cache=nil)
-      cache ||= load_cache
-      cache.each do |klass, hash|
-        pk = PseudoClass.new(klass)
-        hash.each do |method, codes|
-          codes[:before] ? pk.revert_method(method) : pk.remove_method(method)
-        end
-      end
-    end
-
-    def create_stub_from_hash(pk, cache, hash)
-      hash.inject(cache) do |cache, args|
-        method, value = args
-        is_method_implemented = pk.replace_method(method, value)
-        cache[method] ||= {:before => is_method_implemented}
-        cache[method][:after] = pk.method_code(method)
-        cache
-      end
-    end
-
-    def create_stub_from_block(pk, cache, &blk)
-      pk.replace_methods(&blk).inject(cache) do |cache, args|
-        method, is_method_implemented = args
-        cache[method] ||= {:before => is_method_implemented}
-        cache[method][:after] = pk.method_code(method)
-        cache
-      end
-    end
-
-  end
-end

data/spec/cross-stub/clearing_stubs_spec.rb

@@ -1,112 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-describe 'Clearing Stubs' do
-
-  behaves_like 'has standard setup'
-
-  %w{current other}.each do |mode|
-
-    behaves_like "has #{mode} process setup"
-
-    %w{AnyClass AnyClass::Inner AnyModule AnyModule::Inner}.each do |klass_or_module|
-
-      before do
-        @context = @get_context[klass_or_module]
-      end
-
-      it "should clear hash generated stub and return original value for #{klass_or_module} in #{mode} process" do
-        original_value = @context.say_world
-        @context.xstub(:say_world => 'i say world')
-        CrossStub.clear
-        @get_value["#{@context}.say_world"].should.equal original_value
-      end
-
-      it "should clear hash generated stub and raise NoMethodError for #{klass_or_module} in #{mode} process" do
-        should.raise(NoMethodError) do
-          @context.xstub(:say_hello => 'i say hello')
-          CrossStub.clear
-          @get_value["#{@context}.say_hello"]
-        end
-      end
-
-      it "should clear symbol generated stub and return original value for #{klass_or_module} in #{mode} process" do
-        original_value = @context.say_world
-        @context.xstub(:say_world)
-        CrossStub.clear
-        @get_value["#{@context}.say_world"].should.equal original_value
-      end
-
-      it "should clear symbol generated stub and raise NoMethodError for #{klass_or_module} in #{mode} process" do
-        should.raise(NoMethodError) do
-          @context.xstub(:say_hello)
-          CrossStub.clear
-          @get_value["#{@context}.say_hello"]
-        end
-      end
-
-      it "should clear block generated stub and return original value for #{klass_or_module} in #{mode} process" do
-        original_value = @context.say_world
-        @context.xstub do
-          def say_world ; 'i say world' ; end
-        end
-        CrossStub.clear
-        @get_value["#{@context}.say_world"].should.equal original_value
-      end
-
-      it "should clear block generated stub and raise NoMethodError for #{klass_or_module} in #{mode} process" do
-        should.raise(NoMethodError) do
-          @context.xstub do
-            def say_hello ; 'i say hello' ; end
-          end
-          CrossStub.clear
-          @get_value["#{@context}.say_hello"]
-        end
-      end
-
-      it "should always clear previously generated stub for #{klass_or_module} in #{mode} process" do
-        original_value = @context.say_world
-
-        # Stub an existing method
-        @context.xstub(:say_world => 'i say world')
-        @get_value["#{@context}.say_world"]
-
-        # Clear stubs without refreshing another process
-        CrossStub.clear
-        CrossStub.setup(:file => $cache_file)
-
-        # Stub a non-existing method
-        @context.xstub(:say_hello => 'i say hello')
-        @get_value["#{@context}.say_hello"]
-
-        # Make sure existing method returns to original method
-        @get_value["#{@context}.say_world"].should.equal original_value
-      end
-
-      it "should always clear previously generated stub and raise NoMethodError for #{klass_or_module} in #{mode} process" do
-        # Stub a non-existing method
-        @context.xstub(:say_hello => 'i say hello')
-        @get_value["#{@context}.say_hello"]
-
-        # Clear stubs without refreshing another process
-        CrossStub.clear
-        CrossStub.setup(:file => $cache_file)
-
-        # Stub an existing method
-        @context.xstub(:say_world => 'i say world')
-        @get_value["#{@context}.say_world"]
-
-        # Make sure accessing non-existing method throws error
-        should.raise(NoMethodError) { @get_value["#{@context}.say_hello"] }
-      end
-
-      it "should clear for method not implemented in ruby and return original value for #{klass_or_module} in #{mode} process" do
-        Time.xstub(:now => 'abc')
-        CrossStub.clear
-        value = nil
-        should.not.raise(NoMethodError) { value = @get_value['Time.now'] }
-        value.should.not.equal 'abc'
-      end
-    end
-  end
-
-end

data/spec/cross-stub/creating_stubs_spec.rb

@@ -1,110 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-describe 'Creating Stubs' do
-
-  behaves_like 'has standard setup'
-
-  %w{current other}.each do |mode|
-
-    behaves_like "has #{mode} process setup"
-
-    %w{AnyClass AnyClass::Inner AnyModule AnyModule::Inner}.each do |klass_or_module|
-
-      before do
-        @context = @get_context[klass_or_module]
-      end
-
-      it "should create with hash argument(s) for #{klass_or_module} class in #{mode} process" do
-        @context.xstub(:say_hello => 'i say hello', :say_world => 'i say world')
-        @get_value["#{@context}.say_hello"].should.equal 'i say hello'
-        @get_value["#{@context}.say_world"].should.equal 'i say world'
-      end
-
-      it "should create with symbol argument(s) for #{klass_or_module} class in #{mode} process" do
-        @context.xstub(:say_hello)
-        @get_value["#{@context}.say_hello"].should.equal nil
-      end
-
-      it "should create with block with no argument for #{klass_or_module} class in #{mode} process" do
-        @context.xstub do
-          def say_hello ; 'i say hello' ; end
-        end
-        @get_value["#{@context}.say_hello"].should.equal 'i say hello'
-      end
-
-      it "should create with symbol & block with no argument for #{klass_or_module} class in #{mode} process" do
-        @context.xstub(:say_hello) do
-          def say_world
-            'i say world'
-          end
-        end
-        @get_value["#{@context}.say_hello"].should.equal nil
-        @get_value["#{@context}.say_world"].should.equal 'i say world'
-      end
-
-      it "should create with hash & block with no argument for #{klass_or_module} class in #{mode} process" do
-        @context.xstub(:say_hello => 'i say hello') do
-          def say_world
-            'i say world'
-          end
-        end
-        @get_value["#{@context}.say_hello"].should.equal 'i say hello'
-        @get_value["#{@context}.say_world"].should.equal 'i say world'
-      end
-
-      it "should always create the most recent for #{klass_or_module} class in #{mode} process" do
-        found, expected = [], ['i say hello', 'i say something else', 'i say something else again']
-        stub_and_get_value = lambda do |value|
-          @context.xstub(:say_hello => value)
-          @get_value["#{@context}.say_hello"]
-        end
-
-        found << stub_and_get_value[expected[0]]
-        found << stub_and_get_value[expected[1]]
-
-        CrossStub.clear
-        CrossStub.setup(:file => $cache_file)
-
-        found << stub_and_get_value[expected[2]]
-        found.should.equal expected
-      end
-
-      it "should create stub with dependency on other stub for #{klass_or_module} class in #{mode} process" do
-        @context.xstub(:something => 'hello') do
-          def do_action(who, action)
-            %\#{who} #{action} #{something}\
-          end
-        end
-        @get_value["#{@context}.do_action.i.say"].should.equal 'i say hello'
-      end
-
-      it "should create for method not implemented in ruby for #{klass_or_module} class in #{mode} process" do
-        now = Time.now - 365*60*60*24
-        Time.xstub(:now => now)
-        @get_value['Time.now'].should.equal now
-      end
-
-      #    it "should create with block that takes argument(s) for #{mode} process" do
-      #      # a, b = 1, 2
-      #      # AnyClass.xstub do |a, b|
-      #      #   def say_hello
-      #      #     "i say #{a+b} hellos"
-      #      #   end
-      #      # end
-      #      # AnyClass.say_hello.should.equal 'i say 3 hellos'
-      #    end
-      #
-      #    it "should create with hash & block that takes argument(s) for #{mode} process" do
-      #      # a, b = 1, 2
-      #      # AnyClass.xstub(:say_world => 'i say world') do |a, b|
-      #      #   def say_hello
-      #      #     "i say #{a+b} hellos"
-      #      #   end
-      #      # end
-      #      # AnyClass.say_hello.should.equal 'i say 3 hellos'
-      #      # AnyClass.say_world.should.equal 'i say world'
-      #    end
-    end
-  end
-
-end

data/spec/cross-stub/stubbing_error_spec.rb

@@ -1,38 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-describe 'Stubbing Error' do
-
-  behaves_like 'has standard setup'
-
-  it 'should not be raised when stubbing module' do
-    should.not.raise(CrossStub::Error) {
-      AnyModule.xstub(:say_hello => 'i say hello')
-    }
-  end
-
-  it 'should not be raised when stubbing class' do
-    should.not.raise(CrossStub::Error) {
-      AnyClass.xstub(:say_hello => 'i say hello')
-    }
-  end
-
-  it 'should not be raised when stubbing nested class' do
-    should.not.raise(CrossStub::Error) {
-      AnyClass::Inner.xstub(:say_hello => 'i say hello')
-    }
-  end
-
-  it 'should not be raised when stubbing nested module' do
-    should.not.raise(CrossStub::Error) {
-      AnyModule::Inner.xstub(:say_hello => 'i say hello')
-    }
-  end
-
-  it 'should be raised when stubbing instance' do
-    should.raise(CrossStub::CannotStubInstanceError) do
-      o = AnyClass.new
-      o.xstub(:say_hello => 'i say hello')
-    end
-  end
-
-end

data/spec/helpers.rb

@@ -1,125 +0,0 @@
-require 'rubygems'
-require 'eventmachine'
-
-$cache_file = File.join(File.dirname(__FILE__), '..', 'tmp', 'stubbing.cache')
-$log_file = File.join(File.dirname(__FILE__), '..', 'tmp', 'echoserver.log')
-$sleep_time = 1.5  # may need to increase this depending on ur machine's prowess
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'cross-stub'
-
-class AnyClass
-  def self.say_world
-    'u say world'
-  end
-  class Inner
-    def self.say_world
-      'u say world'
-    end
-  end
-end
-
-module AnyModule
-  def self.say_world
-    'u say world'
-  end
-  module Inner
-    def self.say_world
-      'u say world'
-    end
-  end
-end
-
-module EchoClient
-
-  class << self
-
-    attr_accessor :result
-
-    def get(klass_and_method)
-      address, port = EchoServer::ADDRESS, EchoServer::PORT
-      EventMachine::run do
-        (EventMachine::connect(address, port, EM)).
-          execute(klass_and_method) {|data| self.result = Marshal.load(data) }
-      end
-      self.result
-    end
-
-  end
-
-  private
-
-    module EM
-      def receive_data(data)
-        @callback[data]
-        EventMachine::stop_event_loop
-      end
-      def execute(method, &blk)
-        @callback = blk
-        send_data method
-      end
-    end
-
-end
-
-module EchoServer
-
-  ADDRESS, PORT = '127.0.0.1', 8081
-
-  class << self
-
-    def pid
-      @process.pid
-    end
-
-    def start(other_process=false)
-      unless other_process
-        @process = IO.popen("ruby #{__FILE__}")
-        sleep $sleep_time
-      else
-        EventMachine::run { EventMachine::start_server(ADDRESS, PORT, EM) }
-      end
-    end
-
-    def stop
-      Process.kill('SIGHUP', pid)
-    end
-
-  end
-
-  private
-
-    module EM
-      def receive_data(klass_and_method)
-        log "(1) EchoServer::EM#receive_data ... receives: #{klass_and_method}"
-        CrossStub.refresh(:file => $cache_file)
-        log "(2) EchoServer::EM#receive_data ... completes stubs refresh"
-        klass, method, *args = klass_and_method.split('.')
-        konst = klass.split(/::/).inject(Object) { |const_train, const| const_train.const_get(const) }
-        log "(3) EchoServer::EM#receive_data ... parses arguments to:",
-            "    * klass  ... #{klass}",
-            "    * method ... #{method}",
-            "    * args   ... #{args.inspect}"
-        value = args.empty? ? konst.send(method) :
-          konst.send(method, *args) rescue $!.message
-        log "(4) EchoServer::EM#receive_data ... returns: #{value.inspect}"
-        send_data(Marshal.dump(value))
-        log "(5) EchoServer::EM#receive_data ... end"
-      end
-
-      def log(*msg)
-        $logger << [msg, ""].flatten.join("\n")
-      end
-    end
-
-end
-
-if $0 == __FILE__
-  begin
-    require 'logger'
-    $logger = Logger.new($log_file)
-    EchoServer.start(true)
-  ensure
-    $logger.close
-  end
-end