pretentious 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 711f7f3102783e3fc24a2b9044daed5cd1be70ff
-  data.tar.gz: c237cb52d65cbae1df165e094f25ca7a87f04231
+  metadata.gz: bcb15b476f2169fe2872dd04836ca084b8af85f1
+  data.tar.gz: bc78a261f3d94b73d91157e07a623143111a4d5c
 SHA512:
-  metadata.gz: 1fc605179be58671aedfe0c45a5fa3b6f871901a1f04693e848ce8322e7baab69eba48313679e6147accd99a56cbfc32c10afa229e3ce5e9d9b213b8a5966aad
-  data.tar.gz: 12409641664626a1907833f66bda205457c17c132ab713b182926c5daf925258a4b4dbb360bbe537637335f9e9e465f85742360463df5405dea48316c71af79d
+  metadata.gz: a717cd689858d75a0eb9567c0cfc7994793381e050c3b1025c8abe541955e847163c8187cb09a9a5458605e9e655e3a5cb1fc23ec1fad8771775bc20b521f357
+  data.tar.gz: 8f3110582c6423b258b89fad1482071c416b500469892b0777837c4d97858e611526db475a1c242e2ef35478dd299db2a9ce511a15a1e71853be04b08942b992

data/README.md

@@ -19,10 +19,11 @@ any object, to obtain a ruby code on how it was created.
 2.  [Usage](#usage)
 3.  [Handling complex parameters and object constructors](#handling-complex-parameters-and-object-constructors)
 4.  [Capturing Exceptions](#capturing-exceptions)
-5.  [Object Deconstruction Utility](#object-deconstruction-utility)
+5.  [Auto Stubbing](#Auto stubbing)
+6.  [Object Deconstruction Utility](#object-deconstruction-utility)
     1.  [Using the Object deconstructor in rails](#using-the-object-deconstructor-in-rails)
-6.  [Things to do after](#things-to-do-after)
-7.  [Limitations](#limitations)
+7.  [Things to do after](#things-to-do-after)
+8.  [Limitations](#limitations)
 
 
 ## Installation
@@ -319,6 +320,53 @@ should generate the following in rspec
   # TestClass1#something_is_wrong when passed  should return StandardError
   expect { @fixture.something_is_wrong }.to raise_error
 ```
+
+## Auto stubbing
+
+Too lazy to generate rspec-mocks stubs? Let the Pretentious gem to it for you.
+
+Simply call the _stub method on a class and pass the classes you want to generate
+stubs for when passing calling spec_for (see below):
+
+```ruby
+Pretentious.spec_for(TestClass._stub(ClassUsedByTestClass)) do
+  instance = TestClass.new
+  instance.method_that_uses_the_class_to_stub
+end
+
+```
+
+should auto generate the stub like this:
+
+```ruby
+it 'should pass current expectations' do
+
+  var_2181613400 = ["Hello Glorious world", "HI THERE!!!!"]
+
+  allow_any_instance_of(ClassUsedByTestClass).to receive(:a_stubbed_method).and_return("Hello Glorious world")
+
+  # TestClass#method_that_uses_the_class_to_stub  should return ["Hello Glorious world", "HI THERE!!!!"]
+  expect( @fixture.method_that_uses_the_class_to_stub ).to eq(["Hello Glorious world", "HI THERE!!!!"])
+
+end
+```
+
+stubs that return different values every call are automatically detected an the appropriate rspec stub return
+is generated (similar to below):
+
+```ruby
+allow_any_instance_of(TestMockSubClass).to receive(:increment_val).and_return(2, 3, 4, 5)
+```
+
+Yes, you can pass in multiple classes to be stubbed:
+
+```ruby
+Pretentious.spec_for(TestClass._stub(ClassUsedByTestClass, AnotherClassUsedByTestClass, ....)) do
+  instance = TestClass.new
+  instance.method_that_uses_the_class_to_stub
+end
+```
+
 ## Object Deconstruction Utility
 
 As Pretentious as the gem is, there are other uses other than generating tests specs. Tools are also available to
@@ -365,6 +413,19 @@ The _deconstruct method generates a raw deconstruction data structure used by th
 
 Of course _deconstruct_to_ruby generates the ruby code necessary to create the object!
 
+If you just want to watch certain objects, the watch method accepts a block:
+
+```ruby
+some_other_class = SomeOtherClass.new("me")
+the_object = Pretentious.watch {
+    MyTestClass.new("some parameter", some_other_class).new
+}
+
+the_object._deconstruct_to_ruby
+```
+
+Note that the class SomeOtherClass won't get decomposed.
+
 ## Using the Object deconstructor in rails
 
 In your Gemfile, add the pretentious gem.

data/example.rb

@@ -55,6 +55,27 @@ Pretentious.spec_for(Digest::MD5) do
   Digest::MD5.hexdigest(sample)
 end
 
+Pretentious.spec_for(TestClassForMocks._stub(TestMockSubClass)) do
+  instance = TestClassForMocks.new
+  instance.method_with_assign = "test"
+  instance.method_with_usage
+  instance.method_with_usage2
+  instance.method_with_usage4
+
+  instance2 = TestClassForMocks.new
+  instance2.method_with_usage3("a message")
+end
+
+Pretentious.spec_for(TestClassForAutoStub._stub(ClassUsedByTestClass)) do
+  instance = TestClassForAutoStub.new
+  instance.method_that_uses_the_class_to_stub
+end
+
+Pretentious.spec_for(TestClassForAutoStub._stub(ClassUsedByTestClass, AnotherClassUsedByTestClass)) do
+  instance = TestClassForAutoStub.new
+  instance.method_that_uses_the_class_to_stub
+end
+
 #Pretentious.spec_for(Pretentious::Deconstructor) do
 #  deconstructor = Pretentious::Deconstructor.new
 #  another_object = TestClass1.new("test")

data/lib/pretentious.rb

@@ -1,8 +1,44 @@
 require "pretentious/version"
 require "pretentious/rspec_generator"
+require "pretentious/recorded_proc"
+require "pretentious/generator"
 require 'binding_of_caller'
 require 'pretentious/deconstructor'
 
+Class.class_eval do
+
+  def _stub(*classes)
+    @classes = classes
+    self
+  end
+
+  def _get_mock_classes
+    @classes
+  end
+
+end
+
+Thread.class_eval do
+
+  def _push_context(context)
+    @_context = @_context || []
+    @_context << context
+  end
+
+  def _current_context
+    @_context = @_context || []
+    @_context.last
+  end
+
+  def _all_context
+    @_context = @_context || []
+  end
+
+  def _pop_context
+    @_context.pop
+  end
+end
+
 module Pretentious
 
   def self.spec_for(*klasses, &block)
@@ -49,408 +85,5 @@ module Pretentious
     result
   end
 
-  class RecordedProc < Proc
-
-    def initialize(target_proc, is_given_block = false)
-      @target_proc = target_proc
-      @return_value = []
-      @args = []
-      @given_block = is_given_block
-      @called = false
-    end
-
-    def given_block?
-      @given_block
-    end
-
-    def target_proc
-      @target_proc
-    end
-
-    def return_value
-      @return_value
-    end
-
-    def is_called?
-      @called
-    end
-
-    def call(*args, &block)
-      @called = true
-      @args << args
-      return_value = @target_proc.call(*args, &block)
-
-      unless @return_value.include? return_value
-        @return_value << return_value
-      end
-
-      return_value
-    end
-
-  end
-
-  class Generator
-
-    def self.impostor_for(module_space, klass)
-      newStandInKlass = Class.new()
-      name = klass.name
-      module_space.const_set "#{name.split('::').last}Impostor", newStandInKlass
-
-      common_snippet = "
-              @_method_calls = @_method_calls || []
-              @_method_calls_by_method = @_method_calls_by_method || {}
-              @_methods_for_test = @_methods_for_test || []
-              @_let_variables = @_let_variables || {}
-
-              caller_context = binding.of_caller(1)
-              #puts \"local_variables\"
-              v_locals = caller_context.eval('local_variables')
-
-              v_locals.each { |v|
-                variable_value = caller_context.eval(\"\#{v.to_s}\")
-                @_let_variables[variable_value.object_id] = v
-              }
-
-              #{newStandInKlass}.replace_procs_with_recorders(arguments)
-
-              info_block = {}
-              info_block[:method] = method_sym
-              info_block[:params] = arguments
-
-              recordedProc = if (block)
-                          RecordedProc.new(block, true)
-                         else
-                           nil
-                         end
-              info_block[:block] = recordedProc
-
-              info_block[:names] = @_instance.method(method_sym).parameters
-
-              begin
-                if (@_instance.methods.include? method_sym)
-                  result = @_instance.send(method_sym, *arguments, &recordedProc)
-                else
-                  result = @_instance.send(:method_missing, method_sym, *arguments, &recordedProc)
-                end
-                info_block[:result] = result
-              rescue Exception=>e
-                info_block[:result] = e
-              rescue StandardError=>e
-                info_block[:result] = e
-              end
-
-              @_method_calls << info_block
-
-              if (@_method_calls_by_method[method_sym].nil?)
-                @_method_calls_by_method[method_sym] = []
-              end
-
-              @_method_calls_by_method[method_sym] << info_block
-              raise e if (e.kind_of? Exception)
-              result"
-
-      newStandInKlass.class_eval("
-        def setup_instance(*args, &block)
-          @_instance = #{klass.name}_ddt.new(*args, &block)
-        end
-      ")
-
-      newStandInKlass.class_exec do
-
-
-
-        def initialize(*args, &block)
-
-          @_instance_init = {params: [], block: nil}
-
-          self.class.replace_procs_with_recorders(args)
-
-          @_instance_init[:params] = args
-
-          recordedProc = if (block)
-                          RecordedProc.new(block, true)
-                         else
-                           nil
-                         end
-
-          @_instance_init[:block] = recordedProc
-
-          setup_instance(*args, &recordedProc)
-
-
-          @_method_calls = []
-          @_method_calls_by_method = {}
-          @_methods_for_test = []
-          @_let_variables = {}
-
-
-          @_init_let_variables = {}
-
-          caller_context = binding.of_caller(2)
-          v_locals = caller_context.eval('local_variables')
-
-          v_locals.each { |v|
-            variable_value = caller_context.eval("#{v.to_s}")
-            @_init_let_variables[variable_value.object_id] = v
-          }
-
-          self.class._add_instances(self)
-        end
-
-        def _init_arguments
-          @_instance_init
-        end
-
-        def test_class
-          @_instance.class
-        end
-
-        def include_for_tests(method_list = [])
-          @_methods_for_test = @_methods_for_test + method_list
-        end
-
-        def let_variables
-          @_let_variables
-        end
-
-        def init_let_variables
-          @_init_let_variables
-        end
-
-        def method_calls_by_method
-          @_method_calls_by_method
-        end
-
-        def method_calls
-          @_method_calls
-        end
-
-        def to_s
-          @_instance.to_s
-        end
-
-        def ==(other)
-          @_instance==other
-        end
-
-        def kind_of?(klass)
-          @_instance.kind_of? klass
-        end
-
-        def methods
-          @_instance.methods + [:method_calls]
-        end
-
-        def freeze
-          @_instance.freeze
-        end
-
-        def hash
-          @instance.hash
-        end
-
-        def inspect
-          @_instance.inspect
-        end
-
-        def is_a?(something)
-          @_instance.is_a? something
-        end
-
-        class << self
-
-          def replace_procs_with_recorders(args)
-            (0..args.size).each do |index|
-              if (args[index].kind_of? Proc)
-                args[index] = Pretentious::RecordedProc.new(args[index]) {}
-              end
-            end
-          end
-
-          def _add_instances(instance)
-            @_instances = @_instances || []
-            @_instances << instance unless @_instances.include? instance
-          end
-
-          def let_variables
-            @_let_variables
-          end
-
-          def method_calls_by_method
-            @_method_calls_by_method
-          end
-
-          def method_calls
-            @_method_calls
-          end
-
-          def _add_instances(instance)
-            @_instances = @_instances || []
-            @_instances << instance unless @_instances.include? instance
-          end
-
-          def _instances
-            @_instances
-          end
-
-        end
-
-      end
-
-      newStandInKlass.class_eval("
-        def method_missing(method_sym, *arguments, &block)
-          #puts \"\#{method_sym} \#{arguments}\"
-          #{common_snippet}
-        end
-
-        class << self
-
-            def test_class
-              #{klass.name}
-            end
-
-            def method_missing(method_sym, *arguments, &block)
-              #puts \"method \#{method_sym.to_s}\"
-              _add_instances(self)
-              @_instance = #{klass.name}_ddt
-              #{common_snippet}
-            end
-        end
-      ")
-
-      newStandInKlass
-    end
-
-    def self.generate_for(*klasses_or_instances, &block)
-      all_results = {}
-      klasses = []
-
-      klasses_or_instances.each { |klass_or_instance|
-        klass = klass_or_instance.class == Class ? klass_or_instance : klass_or_instance.class
-
-
-        klass_name_parts = klass.name.split('::')
-        last_part = klass_name_parts.pop
-
-        module_space = Object
-
-        if (klass_name_parts.size > 0)
-          klass_name_parts.each do |part|
-            module_space = module_space.const_get(part)
-          end
-        end
-
-        newStandInKlass = impostor_for module_space, klass
-
-        module_space.send(:remove_const,last_part.to_sym)
-        module_space.const_set("#{last_part}_ddt", klass)
-        module_space.const_set("#{last_part}", newStandInKlass)
-
-        klasses << [module_space, klass, last_part, newStandInKlass]
-      }
-
-      watch_new_instances
-
-      block.call
-
-      unwatch_new_instances
-
-      klasses.each { |module_space, klass, last_part, newStandInKlass|
-
-        module_space.send(:remove_const,"#{last_part}Impostor".to_sym)
-        module_space.send(:remove_const,"#{last_part}".to_sym)
-        module_space.const_set(last_part, klass)
-        module_space.send(:remove_const,"#{last_part}_ddt".to_sym)
-
-        test_generator = Pretentious::RspecGenerator.new
-        test_generator.begin_spec(klass)
-        num = 1
-
-        newStandInKlass._instances.each do |instance|
-          test_generator.generate(instance, num)
-          num+=1
-        end unless newStandInKlass._instances.nil?
-
-        test_generator.end_spec
-
-        result = all_results[klass]
-        if result.nil?
-          all_results[klass] = []
-        end
-
-        all_results[klass] = test_generator.output
-
-      } unless klasses.nil?
-
-      all_results
-    end
-
-    def self.watch_new_instances
-      Object.class_eval do
-        def _get_init_arguments
-          @_init_arguments
-        end
-
-        def _set_init_arguments(*args, &block)
-          @_init_arguments = @_init_arguments || {}
-          @_init_arguments[:params]  = args
-          unless (block.nil?)
-            @_init_arguments[:block] = RecordedProc.new(block) {}
-          end
-          @_variable_names= {}
-
-          index = 0
-          params = method(:initialize).parameters
-
-          args.each do |arg|
-            p = params[index]
-            if p.size > 1
-              @_variable_names[arg.object_id] = p[1].to_s
-            end unless p.nil?
-            index+=1
-          end unless args.nil?
-
-        end
-
-        def _variable_map
-          @_variable_names
-        end
-
-        def _deconstruct
-          Pretentious::Deconstructor.new().deconstruct(self)
-        end
-
-        def _deconstruct_to_ruby(indentation = 0)
-          Pretentious::Deconstructor.new().deconstruct_to_ruby(indentation, _variable_map, {}, self)
-        end
-
-      end
-
-      Class.class_eval do
-        alias_method :_ddt_old_new, :new
-
-        def new(*args, &block)
-          instance = _ddt_old_new(*args, &block)
-          instance._set_init_arguments(*args, &block)
-          instance
-        end
-      end
-    end
-
-    def self.clean_watches
-      Class.class_eval do
-        remove_method :new
-        alias_method :new, :_ddt_old_new
-      end
-    end
-
-    def self.unwatch_new_instances
-      Class.class_eval do
-        remove_method :new
-        alias_method :new, :_ddt_old_new
-      end
-    end
-
-  end
 
 end