cross-stub 0.1.4 → 0.2.0

data/lib/cross-stub/arguments/array.rb

@@ -0,0 +1,16 @@
+module CrossStub
+  module Arguments #:nodoc:
+    module Array
+      class << self
+
+        def parse(symbols)
+          symbols.inject({}) do |memo, name|
+            code = "def #{name} ; nil ; end"
+            memo.merge(:"#{name}" => code)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/cross-stub/arguments/hash.rb

@@ -0,0 +1,17 @@
+module CrossStub
+  module Arguments #:nodoc:
+    module Hash
+      class << self
+
+        def parse(hash)
+          hash.inject({}) do |memo, (name, val)|
+            marshalized = Base64.encode64(Marshal.dump(val)).gsub('|','\|')
+            code = "def #{name} ; Marshal.load(Base64.decode64(%|#{marshalized}|)) ; end"
+            memo.merge(:"#{name}" => code)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/cross-stub/arguments/proc.rb

@@ -0,0 +1,73 @@
+module CrossStub
+  module Arguments #:nodoc:
+    module Proc
+
+      class << self
+        def parse(&block)
+          CodeBlock.new(&block).methods_hash
+        end
+      end
+
+      class CodeBlock
+
+        RUBY_PARSER = RubyParser.new
+        RUBY_2_RUBY = Ruby2Ruby.new
+
+        def initialize(&block)
+          @block = block
+          @methods_hash = ref_methods.inject({}) do |memo, method|
+            memo.merge(:"#{method}" => extract_code(method))
+          end
+        end
+
+        attr_reader :methods_hash
+
+        private
+
+          def extract_code(method)
+            ignore, _, code = source_code.match(code_regexp(method))[1..3]
+            remaining = source_code.sub(ignore,'')
+            while frag = remaining[/^(.*?\Wend)/m,1]
+              begin
+                sexp = RUBY_PARSER.parse(code += frag)
+                return RUBY_2_RUBY.process(sexp) if sexp.inspect =~ sexp_regexp(method)
+              rescue SyntaxError, Racc::ParseError, NoMethodError
+                remaining.sub!(frag,'')
+              end
+            end
+          end
+
+          def ref_methods
+            @ref_methods ||= (
+              (object = Minimalist.new).__instance_eval__(&@block)
+              object.__methods__ - Minimalist.instance_methods
+            )
+          end
+
+          def source_code
+            @source_code ||= (
+              file, line_no = /^#<Proc:0x[0-9A-Fa-f]+@(.+):(\d+).*?>$/.match(@block.inspect)[1..2]
+              File.readlines(file)[line_no.to_i.pred .. -1].join
+            )
+          end
+
+          def code_regexp(method)
+            /^(.*?(do|\{)\s*.*?(def\s*#{method}\W))/m
+          end
+
+          def sexp_regexp(method)
+            /^(s\(:defn,\ :#{method},\ s\(:args.*\),\ s\(:scope,\ s\(:block,\ .*\))$/
+          end
+
+          class Minimalist
+            orig_verbosity, $VERBOSE = $VERBOSE, nil
+            alias_method :__instance_eval__, :instance_eval
+            alias_method :__methods__, :methods
+            instance_methods.each{|meth| undef_method(meth) if meth.to_s !~ /^__.*?__$/ }
+            $VERBOSE = orig_verbosity
+          end
+
+      end
+    end
+  end
+end

data/lib/cross-stub/cache.rb

@@ -0,0 +1,36 @@
+module CrossStub
+
+  class UnsupportedCacheStore < Exception ; end
+
+  module Cache
+    class << self
+
+      extend Forwardable
+      def_delegator :@store, :clear
+      def_delegator :@store, :get
+      def_delegator :@store, :set
+
+      def setup(opts)
+        init(opts, true)
+      end
+
+      def refresh(opts)
+        init(opts, false)
+      end
+
+      private
+
+        def init(opts, truncate)
+          type, arg = opts.to_a[0].map(&:to_s)
+          @store =
+            begin
+              store_name = '%s%s' % [type[0..0].upcase, type[1..-1].downcase]
+              Stores.const_get(store_name).new(arg, truncate)
+            rescue
+              raise UnsupportedCacheStore.new('Store type :%s is not supported !!' % type)
+            end
+        end
+
+    end
+  end
+end

data/lib/cross-stub/stores.rb

@@ -0,0 +1,4 @@
+require 'cross-stub/stores/base'
+require 'cross-stub/stores/file'
+require 'cross-stub/stores/memcache'
+require 'cross-stub/stores/redis'

data/lib/cross-stub/stores/base.rb

@@ -0,0 +1,38 @@
+module CrossStub
+
+  class UnsupportedStoreGetMode < Exception ; end
+
+  module Stores
+    class Base
+
+      def initialize(truncate)
+        truncate && dump(current, {})
+      end
+
+      def get(mode = :current)
+        case mode
+        when :current then load(current)
+        when :previous
+          data = load(previous)
+          delete(previous)
+          data
+        else raise UnsupportedStoreGetMode
+        end
+      end
+
+      def set(data, mode = :current)
+        case mode
+        when :current then dump(current, data)
+        when :previous then dump(previous, data)
+        else raise UnsupportedStoreGetMode
+        end
+      end
+
+      def clear
+        set(get(:current), :previous) unless exists?(previous)
+        delete(current)
+      end
+
+    end
+  end
+end

data/lib/cross-stub/stores/file.rb

@@ -0,0 +1,39 @@
+module CrossStub
+  module Stores
+    class File < Base
+
+      def initialize(file, truncate = true)
+        @file = file
+        super(truncate)
+      end
+
+      def current
+        @file
+      end
+
+      def previous
+        "#{@file}.stale"
+      end
+
+      private
+
+
+        def exists?(file)
+          ::File.exists?(file)
+        end
+
+        def dump(file, data)
+          ::File.open(file,'w') {|f| Marshal.dump(data, f) } rescue nil
+        end
+
+        def load(file)
+          ::File.open(file,'r') {|f| Marshal.load(f) } rescue {}
+        end
+
+        def delete(file)
+          ::File.delete(file) if exists?(file)
+        end
+
+    end
+  end
+end

data/lib/cross-stub/stores/memcache.rb

@@ -0,0 +1,40 @@
+module CrossStub
+  module Stores
+    class Memcache < Base
+
+      def initialize(connection_and_cache_id, truncate = true)
+        require 'memcache'
+        connection, @cache_id = connection_and_cache_id.split('/')
+        @memcache = MemCache.new(connection)
+        super(truncate)
+      end
+
+      def current
+        @cache_id
+      end
+
+      def previous
+        "#{@cache_id}.stale"
+      end
+
+      private
+
+        def exists?(cache_id)
+          not @memcache[cache_id].nil?
+        end
+
+        def dump(cache_id, data)
+          @memcache[cache_id] = data
+        end
+
+        def load(cache_id)
+          @memcache[cache_id] || {}
+        end
+
+        def delete(cache_id)
+          @memcache.delete(cache_id)
+        end
+
+    end
+  end
+end

data/lib/cross-stub/stores/redis.rb

@@ -0,0 +1,41 @@
+module CrossStub
+  module Stores
+    class Redis < Base
+
+      def initialize(connection_and_cache_id, truncate = true)
+        require 'redis'
+        connection, @cache_id = connection_and_cache_id.split('/')
+        host, port = connection.split(':')
+        @redis = ::Redis.new(:host => host, :port => port.to_i)
+        super(truncate)
+      end
+
+      def current
+        @cache_id
+      end
+
+      def previous
+        "#{@cache_id}.stale"
+      end
+
+      private
+
+        def exists?(cache_id)
+          not @redis[cache_id].nil?
+        end
+
+        def dump(cache_id, data)
+          @redis[cache_id] = Marshal.dump(data)
+        end
+
+        def load(cache_id)
+          (data = @redis[cache_id] ) ? Marshal.load(data) : {}
+        end
+
+        def delete(cache_id)
+          @redis.del(cache_id)
+        end
+
+    end
+  end
+end

data/lib/cross-stub/stubber.rb

@@ -0,0 +1,132 @@
+module CrossStub
+  module Stubber #:nodoc:
+
+    class << self
+
+      EXIST, CODE = 0, 1
+
+      extend Forwardable
+      def_delegator :@thing, :m_eval
+      def_delegator :@thing, :t_eval
+      def_delegator :@thing, :has_method?
+
+      def apply(type, thing, stubs)
+        initialize_vars(type, thing, stubs)
+        @stubs.values[0].is_a?(::Hash) ?
+          apply_stubbing_only : apply_stubbing_and_return_cacheables
+      end
+
+      def unapply(type, thing, stubs)
+        initialize_vars(type, thing, stubs)
+        @stubs.each do |method, args|
+          args[EXIST] ? unapply_aliasing(method) : remove_method(method)
+          unstubbify(method)
+        end
+      end
+
+      private
+
+        def initialize_vars(type, thing, stubs)
+          @thing, @stubs = (type == :class ? Klass : Instance).new(thing), stubs
+        end
+
+        def apply_stubbing_and_return_cacheables
+          @stubs.inject({}) do |memo, (method, code)|
+            args = {EXIST => really_has_method?(method), CODE => code}
+            apply_aliasing(method) if args[EXIST]
+            t_eval(code)
+            stubbify(method)
+            memo.merge(method => args)
+          end
+        end
+
+        def really_has_method?(method)
+          (!stubbified?(method) && has_method?(method)) || has_method?(backup_method(method))
+        end
+
+        def apply_stubbing_only
+          @stubs.each do |method, args|
+            apply_aliasing(method) if args[EXIST]
+            t_eval(args[CODE])
+          end
+        end
+
+        def apply_aliasing(method)
+          unless has_method?(backup_meth = backup_method(method))
+            m_eval("alias_method :#{backup_meth}, :#{method}")
+          end
+        end
+
+        def unapply_aliasing(method)
+          if has_method?(backup_meth = backup_method(method))
+            m_eval("alias_method :#{method}, :#{backup_meth}")
+            remove_method(backup_meth)
+          end
+        end
+
+        def remove_method(method)
+          m_eval("undef_method :#{method}") rescue nil
+        end
+
+        def stubbified?(method)
+          has_method?(flag_method(method))
+        end
+
+        def stubbify(method)
+          t_eval("def #{flag_method(method)} ; end") rescue nil
+        end
+
+        def unstubbify(method)
+          remove_method(flag_method(method))
+        end
+
+        def backup_method(method)
+          "__#{method}_before_xstubbing"
+        end
+
+        def flag_method(method)
+          "__#{method}_has_been_xstubbed"
+        end
+
+    end
+
+    class Instance
+
+      def initialize(thing)
+        @thing = thing
+      end
+
+      def m_eval(str)
+        @thing.class_eval(str)
+      end
+
+      alias_method :t_eval, :m_eval
+
+      def has_method?(method)
+        @thing.instance_methods.map(&:to_s).include?(method.to_s)
+      end
+
+    end
+
+    class Klass
+
+      def initialize(thing)
+        @thing = thing
+      end
+
+      def m_eval(str)
+        (class << @thing ; self ; end).instance_eval(str)
+      end
+
+      def t_eval(str)
+        @thing.instance_eval(str)
+      end
+
+      def has_method?(method)
+        @thing.respond_to?(method)
+      end
+
+    end
+
+  end
+end