pretentious 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e52b4207be07ea0604174f928860a43de276e6d
-  data.tar.gz: 113710e58638b64cd72ce2c6c5ed8f74171440c2
+  metadata.gz: 7e21f093e245689b1e0b11740feb69b07164660d
+  data.tar.gz: 5c214fe704474d5e4e87d1ba1535ea9dd6b5b979
 SHA512:
-  metadata.gz: 3c3cf391ac3e937eb694d0362216a1f50d5c5603a7ee3a6f917067a7a96a26ec23a4f23a80b0f1a5492c32bf49b5962b338f41fdd8266dcb16f5fcfaeef206ad
-  data.tar.gz: bba29d6250c4da2835b94c65742473689a89eeef29ffeca71e1003ed60ea831071a0d2906125fc91ee103807b5564a04efc5d70b2e125b98a199a59d0e1786db
+  metadata.gz: 1b3f5c14dbe2b9f74fc991dc52bda85941b6fe765f24a88295965014c0b604e5447d40eab429d498aafc665888df771a6ffe575d9fdba178590bb53a6e67853b
+  data.tar.gz: 4db89660c5be4c23ddb368db29f43d6411f6a756fc399818d188e86c6b54fcdb0bd6c930ea55983f1afda3f07d9e7a6b8321f9f05d3cfabf401283388f5305ab

data/README.md

@@ -18,13 +18,14 @@ an Object Deconstructor which allows you, given any object, to obtain a ruby cod
 1.  [Installation](#installation)
 2.  [Usage](#usage)
     1.  [Minitest](#minitest)
-3.  [Handling complex parameters and object constructors](#handling-complex-parameters-and-object-constructors)
-4.  [Capturing Exceptions](#capturing-exceptions)
-5.  [Auto Stubbing](#auto-stubbing)
-6.  [Object Deconstruction Utility](#object-deconstruction-utility)
+3.  [Declarative generation without using example files](#declarative-generation-without-using-example-files)
+4.  [Handling complex parameters and object constructors](#handling-complex-parameters-and-object-constructors)
+5.  [Capturing Exceptions](#capturing-exceptions)
+6.  [Auto Stubbing](#auto-stubbing)
+7.  [Object Deconstruction Utility](#object-deconstruction-utility)
     1.  [Using the Object deconstructor in rails](#using-the-object-deconstructor-in-rails)
-7.  [Things to do after](#things-to-do-after)
-8.  [Limitations](#limitations)
+8.  [Things to do after](#things-to-do-after)
+9.  [Limitations](#limitations)
 
 
 ## Installation
@@ -247,6 +248,45 @@ class Scenario1 < TestMeme
 end
 ```
 
+## Declarative generation without using example files
+
+Instead of using Pretentious.spec_for and wrapping the target code around a block, you may declaratively define
+when test generation should occur beforehand. This allows you to generate tests around code blocks without
+modifying source codes. This is useful for testing code embedded inside frameworks like rails where your
+"example" is already embedded inside existing code.
+
+For example lets say you want to generate tests for UserAuthenticaion that is used inside the
+login method inside the UsersController inside a rails app. You'd simply define like below:
+
+
+```ruby
+# initializers/pretentious.rb
+
+Pretentious.on(UsersController).method_called(:login).spec_for(UserAuthentication) #RSPEC
+Pretentious.on(UsersController).method_called(:login, :logout, ...).minitest_for(UserAuthentication) #minitest
+
+# spec files will be written to the project root
+```
+
+The above code is equivalent to adding a spec_for inside the target method.
+
+Note that you must include the setup code in a place that you know runs before the target code block is run. For
+example, if you want to test a class that is used inside a controller in rails, it is best to put it in an initializer.
+It is also recommended to call Pretentious.install_watcher early on to be able to generate better fixtures.
+
+You can pass a block for manually handling for example
+
+```ruby
+# initializers/pretentious.rb
+
+Pretentious.on(UsersController).method_called(:login).spec_for(UserAuthentication) do |results|
+  puts results[UserAuthentication][:output]
+end
+
+# spec files will be written to the project root
+```
+
+
 ## Handling complex parameters and object constructors
 
 No need to do anything special, just do as what you would do normally and the pretentious gem will figure it out.

data/bin/ddtgen

@@ -40,14 +40,6 @@ eval(example_body, binding, filename, 1)
 #collect results
 
 
-
-module DdtUtils
-   def self.to_underscore(str)
-     str.gsub(/(.)([A-Z])/,'\1_\2').downcase
-   end
-end
-
-
 Pretentious.last_results.each { |g, result_per_generator|
   puts "#{g}:"
   result_per_generator.each { |klass, result|

data/lib/pretentious.rb

@@ -6,6 +6,7 @@ require "pretentious/recorded_proc"
 require "pretentious/generator"
 require 'binding_of_caller'
 require 'pretentious/deconstructor'
+require 'pretentious/trigger'
 
 Class.class_eval do
 
@@ -43,6 +44,13 @@ end
 
 module Pretentious
 
+  module DdtUtils
+    def self.to_underscore(str)
+      str.gsub(/(.)([A-Z])/,'\1_\2').downcase
+    end
+  end
+
+
   def self.spec_for(*klasses, &block)
     @spec_results ||= {}
     Pretentious::Generator.test_generator = Pretentious::RspecGenerator
@@ -95,5 +103,7 @@ module Pretentious
     result
   end
 
-
+  def self.on(target_class)
+    Pretentious::Trigger.new(target_class)
+  end
 end

data/lib/pretentious/generator.rb

@@ -12,6 +12,10 @@ module Pretentious
     def self.impostor_for(module_space, klass)
       newStandInKlass = Class.new()
       name = klass.name
+
+      #return if already an impostor
+      return klass if (klass.respond_to?(:test_class))
+
       module_space.const_set "#{name.split('::').last}Impostor", newStandInKlass
 
       newStandInKlass.class_eval("
@@ -449,29 +453,33 @@ module Pretentious
 
       end
 
-      Class.class_eval do
-        alias_method :_ddt_old_new, :new
+      #make sure it is set only once
+      if (!Class.instance_methods.include?(:_ddt_old_new))
+        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
+          def new(*args, &block)
+            instance = _ddt_old_new(*args, &block)
+            instance._set_init_arguments(*args, &block)
+            instance
+          end
 
+        end
       end
+
     end
 
     def self.clean_watches
-      Class.class_eval do
-        remove_method :new
-        alias_method :new, :_ddt_old_new
-      end
+      unwatch_new_instances
     end
 
     def self.unwatch_new_instances
-      Class.class_eval do
-        remove_method :new
-        alias_method :new, :_ddt_old_new
+      if (Class.respond_to?(:_ddt_old_new))
+        Class.class_eval do
+          remove_method :new
+          alias_method :new, :_ddt_old_new
+          remove_method :_ddt_old_new
+        end
       end
     end
 

data/lib/pretentious/minitest_generator.rb

@@ -307,7 +307,7 @@ class Pretentious::MinitestGenerator < Pretentious::GeneratorBase
   def self.naming(output_folder, klass)
     klass_name_parts = klass.name.split('::')
     last_part = klass_name_parts.pop
-    File.join(output_folder, "test_#{DdtUtils.to_underscore(last_part)}.rb")
+    File.join(output_folder, "test_#{Pretentious::DdtUtils.to_underscore(last_part)}.rb")
   end
 
   def self.helper(output_folder)

data/lib/pretentious/rspec_generator.rb

@@ -284,7 +284,7 @@ class Pretentious::RspecGenerator < Pretentious::GeneratorBase
   def self.naming(output_folder, klass)
     klass_name_parts = klass.name.split('::')
     last_part = klass_name_parts.pop
-    File.join(output_folder, "#{DdtUtils.to_underscore(last_part)}_spec.rb")
+    File.join(output_folder, "#{Pretentious::DdtUtils.to_underscore(last_part)}_spec.rb")
   end
 
   def self.helper(output_folder)

data/lib/pretentious/trigger.rb

@@ -0,0 +1,102 @@
+module Pretentious
+  class Trigger
+    class Options
+      attr_accessor :output_folder
+    end
+
+    def initialize(target_class)
+      @target_class = target_class
+      @target_class_methods = []
+      @target_methods = []
+    end
+
+    def method_called(*target_methods)
+      @target_methods = target_methods
+      self
+    end
+
+    def class_method_called(*target_methods)
+      @target_class_methods = target_methods
+      self
+    end
+
+    def spec_for(*klasses, &results_block)
+      @generator = Pretentious::RspecGenerator
+      @spec_classes = klasses
+      @results_block = results_block
+      install_trigger
+    end
+
+    def minitest_for(*klasses, &results_block)
+      @generator = Pretentious::MinitestGenerator
+      @spec_classes = klasses
+      @results_block = results_block
+      install_trigger
+    end
+
+    def self.output_file(result, klass, output_folder)
+      FileUtils.mkdir_p output_folder
+      result[:generator].helper(output_folder)
+      filename = result[:generator].naming(output_folder, klass)
+      File.open(filename, 'w') {
+          |f| f.write(result[:output])
+      }
+      filename
+    end
+
+    private
+
+    def attach_generator(generator, target, method, spec_classes, results_block, options)
+      target.send(:define_method, method.to_sym) do |*args, &block|
+          result = nil
+          Pretentious::Generator.test_generator = generator
+          generator_result = Pretentious::Generator.generate_for(*spec_classes) do
+            result = send(:"_pretentious_orig_#{method}", *args, &block)
+          end
+
+          results_block.call(generator_result, options) if results_block
+
+          result
+        end
+    end
+
+    def install_trigger
+      @options = Pretentious::Trigger::Options.new
+
+      default_callback = Proc.new { |result_per_generator, options|
+        output_files = []
+        result_per_generator.each { |klass, result|
+          output_folder = result[:generator].location(options.output_folder)
+          filename = Pretentious::Trigger::output_file(result, klass, output_folder)
+          output_files << filename
+        }
+        output_files
+      }
+
+      @results_block = default_callback unless @results_block
+
+      @target_methods.each { |method|
+          @target_class.class_exec(@target_class, method) do |klass, m|
+
+            if !klass.instance_methods.include? :"_pretentious_orig_#{m}"
+              alias_method :"_pretentious_orig_#{m}", :"#{m}"
+            end
+
+          end
+
+          attach_generator(@generator, @target_class, method, @spec_classes, @results_block, @options)
+      }
+
+      @target_class_methods.each { |method|
+        @target_class.singleton_class.class_exec(@target_class, method) do |klass, m|
+          if !klass.methods.include? :"_pretentious_orig_#{m}"
+            alias_method :"_pretentious_orig_#{m}", :"#{m}"
+          end
+        end
+        attach_generator(@generator, @target_class.singleton_class, method, @spec_classes, @results_block, @options)
+      }
+
+      @options
+    end
+  end
+end

data/lib/pretentious/version.rb

@@ -1,3 +1,3 @@
 module Pretentious
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/run_test.sh

@@ -2,5 +2,5 @@
 
 git add .
 gem build pretentious.gemspec
-gem install pretentious-0.1.2.gem
+gem install pretentious-0.1.3.gem
 ruby test/test_generator.rb

data/spec/generator_spec.rb

@@ -198,19 +198,48 @@ RSpec.describe Pretentious::Generator do
       Pretentious::Generator.test_generator= nil
     end
 
-    it "removes unused variables" do
-
-      call_artifacts = Pretentious::Generator.generate_for(TestClass3) do
+    it "inlines strings when possible" do
+      message = nil
+      object = nil
+      call_artifacts = Pretentious::Generator.generate_for(TestClass1) do
         message = "test"
-        another_object = TestClass1.new(message)
-        test_class_one = TestClass1.new({hello: "world", test: another_object, arr_1: [1,2,3,4,5, another_object],
-                                         sub_hash: {yes: true, obj: another_object}})
-        test_class_two = TestClass2.new("This is message 2", message)
-
-        class_to_test = TestClass3.new(test_class_one, test_class_two)
-        class_to_test.show_messages
-        class_to_test.change_message(message)
+        object = TestClass1.new(message)
+        object.message
       end
+
+      expect(call_artifacts[TestClass1]).to eq({output: [
+                                       {begin: TestClass1},
+                                       {
+                                         :generate => "TestClass1Impostor",
+                                         :instance_count => 1
+                                       },
+                                       {
+                                         :id => message.object_id,
+                                         :class => String,
+                                         :value => "test",
+                                         :used_by => :inline
+                                       },
+                                      {
+                                               :id => object.object_id,
+                                               :class => TestClass1,
+                                               :params_types => [[:req, :message]],
+                                               :used_by => [],
+                                               :ref => [ {id: message.object_id, class: String, value: "test", used_by: :inline}]
+
+                                       },
+                                      {
+                                              :method => :message,
+                                              :params => [],
+                                              :block => nil,
+                                              :names => [],
+                                              :context => {
+                                                  :calls => []
+                                              },
+                                              :result => "test"
+                                      },
+                                     :generate_end, :end],
+                                     generator: DummyGenerator2})
+
     end
 
   end

data/spec/prententious_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 RSpec.describe Pretentious::Generator do
 
-  context 'Pretentious::Deconstructor#build_tree' do
+  context 'Pretentious::Generator' do
 
     before do
       @fixture = Pretentious::Generator.new
@@ -15,14 +15,72 @@ RSpec.describe Pretentious::Generator do
     end
 
     it "tracks object calls" do
+      klass = Fibonacci
+
       result = Pretentious::Generator.generate_for(Fibonacci) do
+        expect(klass == Fibonacci).to_not be
         Fibonacci.say_hello
       end
+      #should clean up after block
+      expect(klass == Fibonacci).to be
+
+      #should still work
+      fib = Fibonacci.new
+      expect(fib.fib(6)).to eq(8)
+
       expect(result).to eq({
         Fibonacci =>{output: "#This file was automatically generated by the pretentious gem\nrequire 'spec_helper'\n\nRSpec.describe Fibonacci do\n\n    it 'should pass current expectations' do\n      # Fibonacci::say_hello  should return hello\n      expect( Fibonacci.say_hello ).to eq(\"hello\")\n\n    end\nend\n",
                      generator: Pretentious::RspecGenerator}})
     end
-
   end
 
+  context "unobstrusive generator" do
+    it "declare watched classes beforehand and capture when certain methods are invoked" do
+      #declare intention
+      Pretentious.on(TestClass5).method_called(:test_method).spec_for(Fibonacci) do |results|
+        expect(results[Fibonacci][:output]).to eq("#This file was automatically generated by the pretentious gem\nrequire 'spec_helper'\n\nRSpec.describe Fibonacci do\n\n  context 'Scenario 1' do\n    before do\n      @fixture = Fibonacci.new\n    end\n\n    it 'should pass current expectations' do\n\n      # Fibonacci#fib when passed n = 5 should return 5\n      expect( @fixture.fib(5) ).to eq(5)\n\n    end\n  end\n\nend\n")
+      end
+
+      expect(Pretentious::Generator).to receive(:generate_for).with(Fibonacci).and_call_original
+      #execute code
+      class_that_uses_fib = TestClass5.new
+      result = class_that_uses_fib.test_method
+      expect(result).to eq(5)
+    end
+
+    it "outputs to a file when no block is given" do
+      Pretentious.on(TestClass5).method_called(:test_method).spec_for(Fibonacci)
+
+      expect(Pretentious::Trigger).to receive(:output_file)
+
+      class_that_uses_fib = TestClass5.new
+      result = class_that_uses_fib.test_method
+      expect(result).to eq(5)
+    end
+
+    it "works on class methods" do
+      Pretentious.on(TestClass5).class_method_called(:class_test_method).spec_for(Fibonacci)
+
+      expect(Pretentious::Trigger).to receive(:output_file)
+      expect(Pretentious::Generator).to receive(:generate_for).with(Fibonacci).and_call_original
+      result = TestClass5.class_test_method
+
+      expect(result).to eq(8)
+    end
+
+    it "works on multiple methods" do
+      Pretentious.on(TestClass5).method_called(:test_method, :test_method2).spec_for(Fibonacci)
+
+      expect(Pretentious::Trigger).to receive(:output_file).twice
+      expect(Pretentious::Generator).to receive(:generate_for).twice.with(Fibonacci).and_call_original
+
+      class_that_uses_fib = TestClass5.new
+      result1 = class_that_uses_fib.test_method
+      result2 = class_that_uses_fib.test_method2
+
+      expect(result1).to eq(5)
+      expect(result2).to eq(34)
+
+    end
+  end
 end

data/spec/test_class1_spec.rb

@@ -17,20 +17,20 @@ RSpec.describe TestClass1 do
 
   context 'Scenario 2' do
     before do
-      var_2167261360 = TestClass1.new("test")
-      message = {hello: "world", test: var_2167261360, arr_1: [1, 2, 3, 4, 5, var_2167261360], sub_hash: {yes: true, obj: var_2167261360}}
+      var_2190448620 = TestClass1.new("test")
+      message = {hello: "world", test: var_2190448620, arr_1: [1, 2, 3, 4, 5, var_2190448620], sub_hash: {yes: true, obj: var_2190448620}}
       @fixture = TestClass1.new(message)
     end
 
     it 'should pass current expectations' do
       another_object = TestClass1.new("test")
-      var_2167245200 = {hello: "world", test: another_object, arr_1: [1, 2, 3, 4, 5, another_object], sub_hash: {yes: true, obj: another_object}}
-      var_2167127140 = Proc.new { |message|
-            var_2167245200
+      var_2190448940 = {hello: "world", test: another_object, arr_1: [1, 2, 3, 4, 5, another_object], sub_hash: {yes: true, obj: another_object}}
+      var_2190309320 = Proc.new { |message|
+            var_2190448940
       }
 
       e = nil
-      var_2167121820 = Proc.new { 
+      var_2190303060 = Proc.new { 
             # Variable return values ... can't figure out what goes in here...
       }
 
@@ -41,11 +41,11 @@ RSpec.describe TestClass1 do
       # TestClass1#print_message  should return 
       expect( @fixture.print_message ).to be_nil
 
-      # TestClass1#set_block  should return #<Pretentious::RecordedProc:0x00000102575140@example.rb:73>
-      expect( @fixture.set_block  &var_2167127140 ).to eq(var_2167127140)
+      # TestClass1#set_block  should return #<Pretentious::RecordedProc:0x000001051ac178@example.rb:73>
+      expect( @fixture.set_block  &var_2190309320 ).to eq(var_2190309320)
 
-      # TestClass1#call_block  should return {:hello=>"world", :test=>#<TestClass1:0x000001025b3f30 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={2167261020=>"message"}>, :arr_1=>[1, 2, 3, 4, 5, #<TestClass1:0x000001025b3f30 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={2167261020=>"message"}>], :sub_hash=>{:yes=>true, :obj=>#<TestClass1:0x000001025b3f30 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={2167261020=>"message"}>}}
-      expect( @fixture.call_block  &var_2167121820 ).to eq(var_2167245200)
+      # TestClass1#call_block  should return {:hello=>"world", :test=>#<TestClass1:0x000001051f2ec0 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={2190448660=>"message"}>, :arr_1=>[1, 2, 3, 4, 5, #<TestClass1:0x000001051f2ec0 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={2190448660=>"message"}>], :sub_hash=>{:yes=>true, :obj=>#<TestClass1:0x000001051f2ec0 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={2190448660=>"message"}>}}
+      expect( @fixture.call_block  &var_2190303060 ).to eq(var_2190448940)
 
       # TestClass1#something_is_wrong  should return StandardError
       expect { @fixture.something_is_wrong }.to raise_error

data/spec/test_class3_spec.rb

@@ -5,9 +5,9 @@ RSpec.describe TestClass3 do
 
   context 'Scenario 1' do
     before do
-      var_2167261360 = TestClass1.new("test")
-      var_2167245200 = {hello: "world", test: var_2167261360, arr_1: [1, 2, 3, 4, 5, var_2167261360], sub_hash: {yes: true, obj: var_2167261360}}
-      testclass1 = TestClass1.new(var_2167245200)
+      var_2190448620 = TestClass1.new("test")
+      var_2190448940 = {hello: "world", test: var_2190448620, arr_1: [1, 2, 3, 4, 5, var_2190448620], sub_hash: {yes: true, obj: var_2190448620}}
+      testclass1 = TestClass1.new(var_2190448940)
       testclass2 = TestClass2.new("This is message 2", nil)
       @fixture = TestClass3.new(testclass1, testclass2)
     end
@@ -21,9 +21,9 @@ RSpec.describe TestClass3 do
 
   context 'Scenario 2' do
     before do
-      var_2167261360 = TestClass1.new("test")
-      var_2167245200 = {hello: "world", test: var_2167261360, arr_1: [1, 2, 3, 4, 5, var_2167261360], sub_hash: {yes: true, obj: var_2167261360}}
-      testclass1 = TestClass1.new(var_2167245200)
+      var_2190448620 = TestClass1.new("test")
+      var_2190448940 = {hello: "world", test: var_2190448620, arr_1: [1, 2, 3, 4, 5, var_2190448620], sub_hash: {yes: true, obj: var_2190448620}}
+      testclass1 = TestClass1.new(var_2190448940)
       testclass2 = TestClass2.new("This is message 2", nil)
       @fixture = TestClass3.new(testclass1, testclass2)
     end

data/spec/test_class4_spec.rb

@@ -6,11 +6,11 @@ RSpec.describe TestClass4 do
   context 'Scenario 1' do
     before do
       var_8 = nil
-      var_2167163460 = Proc.new { 
+      var_2190345740 = Proc.new { 
             # Variable return values ... can't figure out what goes in here...
       }
 
-      @fixture = TestClass4.new(&var_2167163460)
+      @fixture = TestClass4.new(&var_2190345740)
     end
 
     it 'should pass current expectations' do

data/spec/test_class_for_auto_stub_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe TestClassForAutoStub do
     end
 
     it 'should pass current expectations' do
-      var_2165345620 = ["Hello Glorious world", "HI THERE!!!!"]
+      var_2161910460 = ["Hello Glorious world", "HI THERE!!!!"]
 
       allow_any_instance_of(ClassUsedByTestClass).to receive(:stubbed_method).and_return("Hello Glorious world")
       allow_any_instance_of(AnotherClassUsedByTestClass).to receive(:get_message).and_return("HI THERE!!!!")

data/spec/test_class_for_mocks_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe TestClassForMocks do
     end
 
     it 'should pass current expectations' do
-      var_2165992020 = [2, 3, 4, 5]
+      var_2157696720 = [2, 3, 4, 5]
 
       allow_any_instance_of(TestMockSubClass).to receive(:test_method).and_return("a return string")
       allow_any_instance_of(TestMockSubClass).to receive(:increment_val).and_return(2, 3, 4, 5)
@@ -35,12 +35,12 @@ RSpec.describe TestClassForMocks do
     end
 
     it 'should pass current expectations' do
-      var_2165878780 = {val: 1, str: "hello world", message: "a message"}
+      var_2181121160 = {val: 1, str: "hello world", message: "a message"}
 
-      allow_any_instance_of(TestMockSubClass).to receive(:return_hash).and_return(var_2165878780)
+      allow_any_instance_of(TestMockSubClass).to receive(:return_hash).and_return(var_2181121160)
 
       # TestClassForMocks#method_with_usage3 when passed message = "a message" should return {:val=>1, :str=>"hello world", :message=>"a message"}
-      expect( @fixture.method_with_usage3("a message") ).to eq(var_2165878780)
+      expect( @fixture.method_with_usage3("a message") ).to eq(var_2181121160)
 
     end
   end

data/test/test_test_class1.rb

@@ -20,20 +20,20 @@ end
 
 class TestClass1Scenario2 < TestTestClass1
   def setup
-    var_2173943420 = TestClass1.new("test")
-    message = {hello: "world", test: var_2173943420, arr_1: [1, 2, 3, 4, 5, var_2173943420], sub_hash: {yes: true, obj: var_2173943420}}
+    var_2161877360 = TestClass1.new("test")
+    message = {hello: "world", test: var_2161877360, arr_1: [1, 2, 3, 4, 5, var_2161877360], sub_hash: {yes: true, obj: var_2161877360}}
     @fixture = TestClass1.new(message)
   end
 
   def test_current_expectation
     another_object = TestClass1.new("test")
-    var_2172900980 = {hello: "world", test: another_object, arr_1: [1, 2, 3, 4, 5, another_object], sub_hash: {yes: true, obj: another_object}}
-    var_2166428520 = Proc.new { |message|
-        var_2172900980
+    var_2157100180 = {hello: "world", test: another_object, arr_1: [1, 2, 3, 4, 5, another_object], sub_hash: {yes: true, obj: another_object}}
+    var_2156893060 = Proc.new { |message|
+        var_2157100180
     }
 
     e = nil
-    var_2166393560 = Proc.new { 
+    var_2156861020 = Proc.new { 
         # Variable return values ... can't figure out what goes in here...
     }
 
@@ -44,11 +44,11 @@ class TestClass1Scenario2 < TestTestClass1
     #TestClass1#print_message  should return 
     assert_nil @fixture.print_message
 
-    #TestClass1#set_block  should return #<Pretentious::RecordedProc:0x00000102412190@example.rb:73>
-    assert_equal var_2166428520, @fixture.set_block( &var_2166428520)
+    #TestClass1#set_block  should return #<Pretentious::RecordedProc:0x000001011e3190@example.rb:73>
+    assert_equal var_2156893060, @fixture.set_block( &var_2156893060)
 
-    #TestClass1#call_block  should return {:hello=>"world", :test=>#<TestClass1:0x00000103277af0 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={2173943480=>"message"}>, :arr_1=>[1, 2, 3, 4, 5, #<TestClass1:0x00000103277af0 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={2173943480=>"message"}>], :sub_hash=>{:yes=>true, :obj=>#<TestClass1:0x00000103277af0 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={2173943480=>"message"}>}}
-    assert_equal var_2172900980, @fixture.call_block( &var_2166393560)
+    #TestClass1#call_block  should return {:hello=>"world", :test=>#<TestClass1:0x00000101b740d8 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={2161877400=>"message"}>, :arr_1=>[1, 2, 3, 4, 5, #<TestClass1:0x00000101b740d8 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={2161877400=>"message"}>], :sub_hash=>{:yes=>true, :obj=>#<TestClass1:0x00000101b740d8 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={2161877400=>"message"}>}}
+    assert_equal var_2157100180, @fixture.call_block( &var_2156861020)
 
     #TestClass1#something_is_wrong  should return StandardError
     assert_raises(StandardError) { @fixture.something_is_wrong }

data/test/test_test_class3.rb

@@ -7,9 +7,9 @@ end
 
 class TestClass3Scenario1 < TestTestClass3
   def setup
-    var_2173943420 = TestClass1.new("test")
-    var_2172900980 = {hello: "world", test: var_2173943420, arr_1: [1, 2, 3, 4, 5, var_2173943420], sub_hash: {yes: true, obj: var_2173943420}}
-    testclass1 = TestClass1.new(var_2172900980)
+    var_2161877360 = TestClass1.new("test")
+    var_2157100180 = {hello: "world", test: var_2161877360, arr_1: [1, 2, 3, 4, 5, var_2161877360], sub_hash: {yes: true, obj: var_2161877360}}
+    testclass1 = TestClass1.new(var_2157100180)
     testclass2 = TestClass2.new("This is message 2", nil)
     @fixture = TestClass3.new(testclass1, testclass2)
   end
@@ -24,9 +24,9 @@ end
 
 class TestClass3Scenario2 < TestTestClass3
   def setup
-    var_2173943420 = TestClass1.new("test")
-    var_2172900980 = {hello: "world", test: var_2173943420, arr_1: [1, 2, 3, 4, 5, var_2173943420], sub_hash: {yes: true, obj: var_2173943420}}
-    testclass1 = TestClass1.new(var_2172900980)
+    var_2161877360 = TestClass1.new("test")
+    var_2157100180 = {hello: "world", test: var_2161877360, arr_1: [1, 2, 3, 4, 5, var_2161877360], sub_hash: {yes: true, obj: var_2161877360}}
+    testclass1 = TestClass1.new(var_2157100180)
     testclass2 = TestClass2.new("This is message 2", nil)
     @fixture = TestClass3.new(testclass1, testclass2)
   end

data/test/test_test_class4.rb

@@ -8,11 +8,11 @@ end
 class TestClass4Scenario1 < TestTestClass4
   def setup
     var_8 = nil
-    var_2166489580 = Proc.new { 
+    var_2156944080 = Proc.new { 
         # Variable return values ... can't figure out what goes in here...
     }
 
-    @fixture = TestClass4.new(&var_2166489580)
+    @fixture = TestClass4.new(&var_2156944080)
   end
 
   def test_current_expectation

data/test/test_test_class_for_mocks.rb

@@ -11,7 +11,7 @@ class TestClassForMocksScenario1 < TestTestClassForMocks
   end
 
   def test_current_expectation
-    var_2165696380 = [2, 3, 4, 5]
+    var_2162323640 = [2, 3, 4, 5]
 
     TestMockSubClass.stub_any_instance(:test_method, "a return string") do
       TestMockSubClass.stub_any_instance(:increment_val, 2) do
@@ -39,11 +39,11 @@ class TestClassForMocksScenario2 < TestTestClassForMocks
   end
 
   def test_current_expectation
-    var_2165567200 = {val: 1, str: "hello world", message: "a message"}
+    var_2162178880 = {val: 1, str: "hello world", message: "a message"}
 
-    TestMockSubClass.stub_any_instance(:return_hash, var_2165567200) do
+    TestMockSubClass.stub_any_instance(:return_hash, var_2162178880) do
       #TestClassForMocks#method_with_usage3 when passed message = "a message" should return {:val=>1, :str=>"hello world", :message=>"a message"}
-      assert_equal var_2165567200, @fixture.method_with_usage3("a message")
+      assert_equal var_2162178880, @fixture.method_with_usage3("a message")
 
     end
 

data/test_classes.rb

@@ -122,6 +122,24 @@ class TestClass4
 
 end
 
+class TestClass5
+
+  def test_method
+    fibonacci = Fibonacci.new
+    fibonacci.fib(5)
+  end
+
+  def test_method2
+    fibonacci = Fibonacci.new
+    fibonacci.fib(9)
+  end
+
+  def self.class_test_method
+    fibonacci = Fibonacci.new
+    fibonacci.fib(6)
+  end
+end
+
 class TestMockSubClass
 
   def initialize

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pretentious
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Joseph Emmanuel Dayo
@@ -131,6 +131,7 @@ files:
 - lib/pretentious/minitest_generator.rb
 - lib/pretentious/recorded_proc.rb
 - lib/pretentious/rspec_generator.rb
+- lib/pretentious/trigger.rb
 - lib/pretentious/version.rb
 - pretentious.gemspec
 - run_test.sh