pretentious 0.1.11 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad7ffc54896b981b06cc3c99e0bf0830bbedcd55
-  data.tar.gz: b97864d3c92ece3721f5dc26769ce493010f12d7
+  metadata.gz: 26d9f83bc47ec838a4083cb9327ddfa3c0406c25
+  data.tar.gz: 1ee258b52ab0f1b314eb48c0d19e26b14239b49a
 SHA512:
-  metadata.gz: e87e16f197e827a41cb33f1c0c7490470a765fcc547c0295a66acce3fa013e98774f531f99d41791df87fd48d449d99449e4e19e192c29980e8152cfee7bd24e
-  data.tar.gz: 1de33c5ded9cb5c9d9456ad6e5cf01bc0a5a0a8c44c9bf3eea8d4c60ccd9ef05f481620b0e406f4e730010855987164d4b9c0221647cbe7d7a277bcb42f0ad91
+  metadata.gz: 827f3f72f561d2cc279ad00a116d0d2872e2d28c4d71e36e5ef927d3f706e2f1ffc22c8eb8d6ae7ccbd4d29d41acc652006c727f0efc080cac4a74f4685e8343
+  data.tar.gz: 6b3bdb1d39be3cb193b7f3da75413464a38c51a310af595d541a4cc5292ca3cff310055a239624b9ca1d354ba8e5a7178514a4ac3bc6522603da6586d0a30445

data/CHANGELOG.md

@@ -1,38 +1,32 @@
-## 0.1.11 (2015-12-12)
-
+# 0.1.12 (2015-12-12)
 Bugfixes:
+- fix duplicate specs inside minitest
+- Attempt to at least initialize unresolvable objects
 
-  - fix code style
+# 0.1.11 (2015-12-12)
+Bugfixes:
+- fix code style
 
 Features:
+- matchers should now prefer variable references in assertions if previously declared
 
-  - matchers should now prefer variable references in assertions if previously declared
-
-## 0.1.10 (2015-12-11)
-
+# 0.1.10 (2015-12-11)
 Bugfixes:
-
-  - fix regression wherein method_missing is not handled properly
+- fix regression wherein method_missing is not handled properly
 
 Features:
+- Fix weird generated comments
 
-  - Fix weird generated comments
-
-## 0.1.9 (2015-12-10)
-
+# 0.1.9 (2015-12-10)
 Bugfixes:
-
-  - duplicate assertions are now removed
+- duplicate assertions are now removed
 
 Features:
+- use more realistic variable names for unamed variables
 
-  - use more realistic variable names for unamed variables
-
-## 0.1.8 (2015-12-07)
-
+# 0.1.8 (2015-12-07)
 Bugfixes:
 
 Features:
-
-  - renamed ddtgen cli to pretentious
-  - generated files are now placed on their own sub folder
+- renamed ddtgen cli to pretentious
+- generated files are now placed on their own sub folder

data/README.md

@@ -1,35 +1,26 @@
 [![Gem Version](https://badge.fury.io/rb/pretentious.svg)](https://badge.fury.io/rb/pretentious) [![Circle CI](https://circleci.com/gh/jedld/pretentious/tree/master.svg?style=svg)](https://circleci.com/gh/jedld/pretentious/tree/master)
 
 # Ruby::Pretentious
+Do you have a pretentious boss or development lead that pushes you to embrace BDD/TDD but for reasons hate it or them? here is a gem to deal with that. Now you CAN write your code first and then GENERATE tests later!! Yes you heard that right! To repeat, this gem allows you to write your code first and then automatically generate tests using the code you've written in a straightfoward manner!
 
-Do you have a pretentious boss or development lead that pushes you to embrace BDD/TDD but for reasons hate it or them?
-here is a gem to deal with that. Now you CAN write your code first and then GENERATE tests later!! Yes you heard that
-right! To repeat, this gem allows you to write your code first and then automatically generate tests using the code
-you've written in a straightfoward manner!
-
-On a serious note, this gem allows you to generate tests template used for "characterization tests"
-much better than those generated by default for various frameworks. It is also useful for "recording"
-current behavior of existing components in order to prepare for refactoring. As a bonus it also exposes
-an Object Deconstructor which allows you, given any object, to obtain a ruby code on how it was created.
-
+On a serious note, this gem allows you to generate tests template used for "characterization tests" much better than those generated by default for various frameworks. It is also useful for "recording" current behavior of existing components in order to prepare for refactoring. As a bonus it also exposes an Object Deconstructor which allows you, given any object, to obtain a ruby code on how it was created.
 
 ## Table of Contents
+1. [Installation](#installation)
+- [Usage](#usage)
+  1. [Minitest](#minitest)
 
-1.  [Installation](#installation)
-2.  [Usage](#usage)
-    1.  [Minitest](#minitest)
-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)
-8.  [Things to do after](#things-to-do-after)
-9.  [Limitations](#limitations)
+- [Declarative generation without using example files](#declarative-generation-without-using-example-files)
+2. [Handling complex parameters and object constructors](#handling-complex-parameters-and-object-constructors)
+3. [Capturing Exceptions](#capturing-exceptions)
+4. [Auto Stubbing](#auto-stubbing)
+- [Object Deconstruction Utility](#object-deconstruction-utility)
+  1. [Using the Object deconstructor in rails](#using-the-object-deconstructor-in-rails)
 
+- [Things to do after](#things-to-do-after)
+5. [Limitations](#limitations)
 
 ## Installation
-
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -38,16 +29,18 @@ gem 'pretentious'
 
 And then execute:
 
-    $ bundle
+```
+$ bundle
+```
 
 Or install it yourself as:
 
-    $ gem install pretentious
+```
+$ gem install pretentious
+```
 
 ## Usage
-
-First Create an example file (etc. example.rb) and define the classes that you want to test, if the class is
-already defined elsewhere just require them. Below is an example:
+First Create an example file (etc. example.rb) and define the classes that you want to test, if the class is already defined elsewhere just require them. Below is an example:
 
 ```ruby
 class Fibonacci
@@ -66,12 +59,10 @@ class Fibonacci
 end
 ```
 
-Inside a Pretentious.spec_for(...) block. Just write boring code that instantiates an object as well as calls the methods
-like how you'd normally use them. Finally Specify the classes that you want to test:
+Inside a Pretentious.spec_for(...) block. Just write boring code that instantiates an object as well as calls the methods like how you'd normally use them. Finally Specify the classes that you want to test:
 
 ```ruby
 class Fibonacci
-
   def fib(n)
     return 0 if (n == 0)
     return 1 if (n == 1)
@@ -82,12 +73,9 @@ class Fibonacci
   def self.say_hello
     "hello"
   end
-
 end
 
 Pretentious.spec_for(Fibonacci) do
-
-
   instance = Fibonacci.new
 
   (1..10).each do |n|
@@ -95,25 +83,24 @@ Pretentious.spec_for(Fibonacci) do
   end
 
   Fibonacci.say_hello
-
 end
 ```
 
 Save your file and then switch to the terminal to invoke:
 
-    $ pretentious example.rb
+```
+$ pretentious example.rb
+```
 
 This will automatically generate rspec tests for Fibonacci under /spec of the current working directory.
 
-You can actually invoke rspec at this point, but the tests will fail. Before you do that you should edit
-spec/spec_helper.rb and put the necessary requires and definitions there.
+You can actually invoke rspec at this point, but the tests will fail. Before you do that you should edit spec/spec_helper.rb and put the necessary requires and definitions there.
 
 For this example place the following into spec_helper.rb:
 
 ```ruby
 #inside spec_helper.rb
 class Fibonacci
-
   def fib(n)
     return 0 if (n == 0)
     return 1 if (n == 1)
@@ -124,58 +111,48 @@ class Fibonacci
   def self.say_hello
     "hello"
   end
-
 end
 ```
 
 The generated spec file should look something like this
 
 ```ruby
+# This file was automatically generated by the pretentious gem
 require 'spec_helper'
 
 RSpec.describe Fibonacci do
-
   context 'Scenario 1' do
     before do
-
-
       @fixture = Fibonacci.new
-
     end
 
     it 'should pass current expectations' do
-
       n = 1
       n_1 = 2
       n_2 = 3
       n_3 = 4
       n_4 = 5
-
       # Fibonacci#fib when passed n = 1 should return 1
-      expect( @fixture.fib(n) ).to eq(1)
+      expect(@fixture.fib(n)).to eq(n)
 
       # Fibonacci#fib when passed n = 2 should return 1
-      expect( @fixture.fib(n_1) ).to eq(1)
+      expect(@fixture.fib(n_1)).to eq(n)
 
       # Fibonacci#fib when passed n = 3 should return 2
-      expect( @fixture.fib(n_2) ).to eq(2)
+      expect(@fixture.fib(n_2)).to eq(n_1)
 
       # Fibonacci#fib when passed n = 4 should return 3
-      expect( @fixture.fib(n_3) ).to eq(3)
+      expect(@fixture.fib(n_3)).to eq(n_2)
 
       # Fibonacci#fib when passed n = 5 should return 5
-      expect( @fixture.fib(n_4) ).to eq(5)
-
+      expect(@fixture.fib(n_4)).to eq(n_4)
     end
   end
 
-    it 'should pass current expectations' do
-
-
-      # Fibonacci::say_hello when passed  should return hello
-      expect( Fibonacci.say_hello ).to eq("hello")
-
-    end
+  it 'should pass current expectations' do
+    # Fibonacci::say_hello  should return 'hello'
+    expect(Fibonacci.say_hello).to eq('hello')
+  end
 end
 ```
 
@@ -195,26 +172,21 @@ end
 You should get something like:
 
 ```ruby
+# This file was automatically generated by the pretentious gem
 require 'spec_helper'
 
 RSpec.describe Digest::MD5 do
-
-    it 'should pass current expectations' do
-
-      sample = "This is the digest"
-
-      # Digest::MD5::hexdigest when passed "This is the digest" should return 9f12248dcddeda976611d192efaaf72a
-      expect( Digest::MD5.hexdigest(sample) ).to eq("9f12248dcddeda976611d192efaaf72a")
-
-    end
+  it 'should pass current expectations' do
+    sample = 'This is the digest'
+    # Digest::MD5::hexdigest when passed "This is the digest" should return '9f12248dcddeda976611d192efaaf72a'
+    expect(Digest::MD5.hexdigest(sample)).to eq('9f12248dcddeda976611d192efaaf72a')
+  end
 end
 ```
 
-Note: If your test subject is already part of a larger application and would like to capture behavior in the manner that
-the application uses it, please look at [Declarative Generation](#declarative-generation-without-using-example-files).
+Note: If your test subject is already part of a larger application and would like to capture behavior in the manner that the application uses it, please look at [Declarative Generation](#declarative-generation-without-using-example-files).
 
 ## Minitest
-
 The minitest test framework is also supported, simply use Pretentious.minitest_for instead
 
 ```ruby
@@ -228,43 +200,38 @@ end
 outputs:
 
 ```ruby
-require 'test_helper'
-require "minitest/autorun"
+# This file was automatically generated by the pretentious gem
+require 'minitest_helper'
+require 'minitest/autorun'
 
-class TestMeme < Minitest::Test
+class MemeTest < Minitest::Test
 end
 
-class Scenario1 < TestMeme
+class MemeScenario1 < MemeTest
   def setup
     @fixture = Meme.new
   end
 
   def test_current_expectation
+    # Meme#i_can_has_cheezburger?  should return 'OHAI!'
+    assert_equal 'OHAI!', @fixture.i_can_has_cheezburger?
 
-      # Meme#i_can_has_cheezburger?  should return OHAI!
-    assert_equal "OHAI!", @fixture.i_can_has_cheezburger?
-
-      # Meme#will_it_blend?  should return YES!
-    assert_equal "YES!", @fixture.will_it_blend?
-
+    # Meme#will_it_blend?  should return 'YES!'
+    assert_equal 'YES!', @fixture.will_it_blend?
   end
 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.
 
-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:
-
+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.install_watcher # install watcher if not defined previously
+
 if Rails.env.test? #IMPORTANT don't run this when you don't need it!
   Pretentious.on(UsersController).method_called(:login).spec_for(UserAuthentication) #RSPEC
   Pretentious.on(UsersController).method_called(:login, :logout, ...).minitest_for(UserAuthentication) #minitest
@@ -275,14 +242,13 @@ end
 
 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.
+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 the output, for example
 
 ```ruby
 # initializers/pretentious.rb
+Pretentious.install_watcher # install watcher if not defined previously
 
 if Rails.env.test? #IMPORTANT don't run this when you don't need it!
     Pretentious.on(UsersController).method_called(:login).spec_for(UserAuthentication) do |results|
@@ -297,6 +263,7 @@ or, use the FileWriter utility to write it to a file
 
 ```ruby
 # initializers/pretentious.rb
+Pretentious.install_watcher # install watcher if not defined previously
 
 if Rails.env.test? #IMPORTANT don't run this when you don't need it!
     Pretentious.on(UsersController).method_called(:login).spec_for(UserAuthentication) do |results|
@@ -305,13 +272,11 @@ if Rails.env.test? #IMPORTANT don't run this when you don't need it!
     end
 end
 ```
-IMPORTANT: If using rails or if it is part of a larger app, make sure to enable this only when you intend to generate specs!
-delete the initializer or comment the code out when it is not needed.
 
-## Handling complex parameters and object constructors
+IMPORTANT: If using rails or if it is part of a larger app, make sure to enable this only when you intend to generate specs! delete the initializer or comment the code out when it is not needed.
 
-No need to do anything special, just do as what you would do normally and the pretentious gem will figure it out.
-see below for an example:
+## 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. see below for an example:
 
 ```ruby
     class TestClass1
@@ -340,7 +305,6 @@ see below for an example:
     end
 
     class TestClass3
-
       def initialize(testclass1, testclass2)
         @class1 = testclass1
         @class2 = testclass2
@@ -351,7 +315,6 @@ see below for an example:
         @class2.print_message
         "awesome!!!"
       end
-
     end
 ```
 
@@ -372,38 +335,30 @@ We then instantiate the class using all sorts of weird parameters:
 Creating tests for TestClass3 should yield
 
 ```ruby
-RSpec.describe TestClass3 do
+require 'spec_helper'
 
+RSpec.describe TestClass3 do
   context 'Scenario 1' do
     before do
-
-      var_2167529620 = "test"
-      another_object = TestClass1.new(var_2167529620)
-      args = {hello: "world", test: another_object, arr_1: [1, 2, 3, 4, 5, another_object], sub_hash: {yes: true, obj: another_object}}
-      test_class_one = TestClass1.new(args)
-      args_1 = "This is message 2"
-      test_class_two = TestClass2.new(args_1)
-
-      @fixture = TestClass3.new(test_class_one, test_class_two)
-
+      another_object = TestClass1.new('test')
+      b = { hello: 'world', test: another_object, arr_1: [1, 2, 3, 4, 5, another_object], sub_hash: { yes: true, obj: another_object } }
+      testclass1 = TestClass1.new(b)
+      testclass2 = TestClass2.new('This is message 2', nil)
+      @fixture = TestClass3.new(testclass1, testclass2)
     end
 
     it 'should pass current expectations' do
-
-
-      # TestClass3#show_messages when passed  should return awesome!!!
-      expect( @fixture.show_messages ).to eq("awesome!!!")
-
+      # TestClass3#show_messages  should return 'awesome!!!'
+      expect(@fixture.show_messages).to eq('awesome!!!')
     end
   end
+end
 ```
 
 Note that creating another instance of TestClass3 will result in the creation of another Scenario
 
 ## Capturing Exceptions
-
-Exceptions thrown by method calls should generate the appropriate exception test case. Just make sure
-that you rescue inside your example file like below:
+Exceptions thrown by method calls should generate the appropriate exception test case. Just make sure that you rescue inside your example file like below:
 
 ```ruby
   begin
@@ -420,23 +375,19 @@ should generate the following in rspec
 ```
 
 ## Auto stubbing
-
 Too lazy to generate rspec-mocks stubs? Let the Pretentious gem do 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 or minitest_for (see below):
+Simply call the _stub method on a class and pass the classes you want to generate stubs for when passing calling spec_for or minitest_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
 
@@ -474,8 +425,7 @@ end
 
 Note: Stubbing on minitest requires the minitest-stub_any_instance gem.
 
-stubs that return different values every call are automatically detected an the appropriate rspec stub return
-is generated (similar to below):
+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)
@@ -493,11 +443,7 @@ end
 Note: different return values are only supported on RSpec for now
 
 ## Object Deconstruction Utility
-
-As Pretentious as the gem is, there are other uses other than generating tests specs. Tools are also available to
-deconstruct objects. Object deconstruction basically means that the components used to create and initialize an object
-are extracted and decomposed until only primitive types remain. The pretentious gem will also generate the
-necessary ruby code to create one from scratch. Below is an example:
+As Pretentious as the gem is, there are other uses other than generating tests specs. Tools are also available to deconstruct objects. Object deconstruction basically means that the components used to create and initialize an object are extracted and decomposed until only primitive types remain. The pretentious gem will also generate the necessary ruby code to create one from scratch. Below is an example:
 
 Given an instance of an activerecord base connection for example
 
@@ -505,7 +451,13 @@ Given an instance of an activerecord base connection for example
 ActiveRecord::Base.connection
 ```
 
-running deconstruct would generate:
+running deconstruct on ActiveRecord::Base.connection
+
+```ruby
+ActiveRecord::Base.connection._deconstruct_to_ruby
+```
+
+will generate the output below:
 
 ```ruby
 var_70301267513280 = #<File:0x007fe094279f80>
@@ -514,6 +466,7 @@ connection_options = ["localhost", "root", "password", "test_db", nil, nil, 1310
 config = {adapter: "mysql", encoding: "utf8", reconnect: false, database: "test_db", pool: 5, username: "root", password: "password", host: "localhost"}
 var_70301281665660 = ActiveRecord::ConnectionAdapters::MysqlAdapter.new(connection, logger, connection_options, config)
 ```
+
 Note that
 
 ```ruby
@@ -523,10 +476,11 @@ var_70301267513280 = #<File:0x007fe094279f80>
 because the pretentious gem was not able to capture its init arguments.
 
 ## How to use
-
 Simply call:
 
-    Pretentious.install_watcher
+```
+Pretentious.install_watcher
+```
 
 before all your objects are initalized. This will add the following methods to all objects:
 
@@ -534,6 +488,7 @@ before all your objects are initalized. This will add the following methods to a
 object._deconstruct
 object._deconstruct_to_ruby
 ```
+
 The _deconstruct method generates a raw deconstruction data structure used by the _deconstruct_to_ruby method.
 
 Of course _deconstruct_to_ruby generates the ruby code necessary to create the object!
@@ -552,7 +507,6 @@ 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.
 
 ```ruby
@@ -563,11 +517,11 @@ end
 
 The do a bundle
 
-    $ bundle
-
+```
+$ bundle
+```
 
-Note: It is advisable to add it only in the test or development group!
-The way it logs objects would probably prevent anything from being GC'ed.
+Note: It is advisable to add it only in the test or development group! The way it logs objects would probably prevent anything from being GC'ed.
 
 For rails, including inside application.rb may be a good place to start:
 
@@ -622,40 +576,27 @@ var_70301339518120 = User::ActiveRecord_Relation.new(klass, table)
 2.2.0 :007 >
 ```
 
-Note: There are some objects it may fail to deconstruct properly because of certain [limitations](#limitations) or it
-may have failed to capture object creation early enough.
-
+Note: There are some objects it may fail to deconstruct properly because of certain [limitations](#limitations) or it may have failed to capture object creation early enough.
 
 ## Things to do after
+Since your tests are already written, and hopefully nobody notices its written by a machine, you may just leave it at that. Take note of the limitations though.
 
-Since your tests are already written, and hopefully nobody notices its written by a machine, you may just leave it
-at that. Take note of the limitations though.
-
-But if lest your conscience suffers, it is best to go back to the specs and refine them, add more tests and behave like
-a bdd'er/tdd'er.
+But if lest your conscience suffers, it is best to go back to the specs and refine them, add more tests and behave like a bdd'er/tdd'er.
 
 ## Limitations
+Computers are bad at mind reading (for now) and they don't really know your expectation of "correctness", as such it assumes your code is correct and can only use equality based matchers. It can also only reliably match primitive data types, hashes, Procs and arrays to a degree. More complex expectations are unfortunately left for the humans to resolve. This is expected to improve in future versions of the pretentious gem.
 
-Computers are bad at mind reading (for now) and they don't really know your expectation of "correctness", as such
-it assumes your code is correct and can only use equality based matchers. It can also only reliably match
-primitive data types, hashes, Procs and arrays to a degree. More complex expectations are unfortunately left for the humans
-to resolve. This is expected to improve in future versions of the pretentious gem.
-
-Procs that return a constant value will be resolved properly. However variable return values are currently still
-not generated properly will return a stub (future versions may use sourcify to resolve Procs for ruby 1.9)
+Procs that return a constant value will be resolved properly. However variable return values are currently still not generated properly will return a stub (future versions may use sourcify to resolve Procs for ruby 1.9)
 
-Also do note that it tries its best to determine how your fixtures are created, as well as the types
-of your parameters and does so by figuring out (recursively) the components that your object needs. Failure can happen during this process.
+Also do note that it tries its best to determine how your fixtures are created, as well as the types of your parameters and does so by figuring out (recursively) the components that your object needs. Failure can happen during this process.
 
 Finally, Limit this gem for test environments only.
 
 ## Bugs
-
 This is the first iteration and a lot of broken things could happen
 
 ## Contributing
-
-1. Fork it (https://github.com/jedld/pretentious.git)
+1. Fork it ([https://github.com/jedld/pretentious.git](https://github.com/jedld/pretentious.git))
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/lib/pretentious/deconstructor.rb

@@ -345,7 +345,7 @@ module Pretentious
         elsif definition[:value].is_a? Array
           output_array(context, definition[:value])
         elsif definition[:value].is_a? UnResolved
-          'nil #parameters unresolvable. cannot decompose'
+          "#{definition[:value].target_object.class.to_s}.new # parameters unresolvable. The watcher needs to be installed before this object is created"
         else
           context.value_of(definition[:value])
         end

data/lib/pretentious/minitest_generator.rb

@@ -140,11 +140,12 @@ module Pretentious
       indentation = ''
       indentation_level.times { indentation << @_indentation }
       method_calls.each_key do |k|
-        str = ''
+
         info_blocks_arr = method_calls[k]
 
         info_blocks_arr.each do |block|
-          params_desc_str =  if block[:params].size > 0
+          str = ''
+          params_desc_str = if block[:params].size > 0
                                "when passed #{desc_params(block)}"
                              else
                                ''

data/lib/pretentious/version.rb

@@ -1,4 +1,4 @@
 # Pretentious - version
 module Pretentious
-  VERSION = '0.1.11'
+  VERSION = '0.1.12'
 end

data/spec/deconstructor_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe Pretentious::Deconstructor do
 
   describe "#build_tree" do
     it "should decompose an object" do
-      message = "test"
+      message = 'test'
       another_object = Pretentious.watch {
         TestClass1.new(message)
       }
@@ -21,6 +21,36 @@ RSpec.describe Pretentious::Deconstructor do
                                                         params_types: [[:req, :message]])
 
     end
+
+    context "Special 'native' objects like File" do
+      it "Decomposes properly" do
+        file = nil
+        filename = nil
+        another_object = Pretentious.watch {
+          filename = "example.rb"
+          file = File.new(filename)
+          TestClass1.new(file)
+        }
+        result = @fixture.build_tree(another_object)
+        result[:composition][0][:composition][0][:id] = filename.object_id
+
+        expect(result)
+          .to eq(
+            class: TestClass1,
+            id: another_object.object_id,
+            composition: [
+              { class: File,
+                id: file.object_id,
+                composition: [
+                  {
+                    class: String,
+                    id: filename.object_id,
+                    composition: 'example.rb'
+                  }]
+                }],
+            params_types: [[:req, :message]])
+      end
+    end
   end
 
   describe "Object#_deconstruct_to_ruby" do
@@ -42,6 +72,29 @@ RSpec.describe Pretentious::Deconstructor do
       expect(output).to eq("message = [1, 2, 3, 'hello', { message: 'hello' }, ['subarray', 2, :symbol]]\ntest_class = TestClass1.new(message)\n")
     end
 
+    it "deconstructs 'native' types" do
+      file = nil
+      filename = nil
+      another_object = Pretentious.watch do
+        filename = "example.rb"
+        file = File.new(filename)
+        test_class = TestClass1.new(file)
+        test_class._deconstruct_to_ruby
+      end
+      expect(another_object).to eq("message = File.new('example.rb')\ntest_class = TestClass1.new(message)\n")
+    end
+
+    it "has special handling for unresolvable types" do
+      # objects outside of the watch scope
+      a = "Some type of string"
+      b = TestClass1.new("Hello world")
+      output = Pretentious.watch do
+        test_class = TestClass3.new(a, b)
+        test_class._deconstruct_to_ruby
+      end
+      expect(output).to eq("a = TestClass1.new # parameters unresolvable. The watcher needs to be installed before this object is created\ntestclass2 = TestClass1.new(a)\ntest_class = TestClass3.new('Some type of string', testclass2)\n")
+    end
+
     it "deconstructs hash types" do
       output = Pretentious.watch do
         hash = { message: "hello", arr: [1, 2, 3], hash: { message2: "msg" } }

data/spec/generated/test_class1_spec.rb

@@ -54,7 +54,7 @@ RSpec.describe TestClass1 do
 
     it 'should pass current expectations' do
       another_object = TestClass1.new('test')
-      # TestClass1#return_self when passed message = #<TestClass1:0x000000012813a0> should return another_object
+      # TestClass1#return_self when passed message = #<TestClass1:0x0000000162b3c0> should return another_object
       expect(@fixture.return_self(another_object)).to eq(another_object)
     end
   end

data/spec/minitest_generator_spec.rb

@@ -21,5 +21,51 @@ RSpec.describe Pretentious::Generator do
       expect(result).to eq(Fibonacci => { output: "# This file was automatically generated by the pretentious gem\nrequire 'minitest_helper'\nrequire 'minitest/autorun'\n\nclass FibonacciTest < Minitest::Test\nend\n\nclass FibonacciScenario1 < FibonacciTest\n  def test_current_expectation\n    # Fibonacci::say_hello  should return 'hello'\n    assert_equal 'hello', Fibonacci.say_hello\n  end\nend",
         generator: Pretentious::MinitestGenerator })
     end
+
+    context "proc handling" do
+      it 'handles blocks passed to methods' do
+        result = Pretentious.minitest_for(TestClass1) do
+          test_class = TestClass1.new('message')
+          test_class.set_block do
+            'a string'
+          end
+        end
+        expect(result[TestClass1][:output]).to be < 'expect(@fixture.set_block  &c).to eq(a)'
+      end
+    end
+
+    it 'Makes sure expectations are unique' do
+      result = Pretentious.minitest_for(TestClass1) do
+        test_class = TestClass1.new("message")
+        test_class.message
+        test_class.message
+      end
+      puts result[TestClass1][:output]
+      expect(result[TestClass1][:output]
+             .scan(/assert_equal\ 'message',\ @fixture\.message/).count)
+             .to eq(1)
+    end
+
+    it "handles exceptions" do
+      result = Pretentious.minitest_for(TestClass1) do
+        test_class = TestClass1.new('message')
+        begin
+          test_class.something_is_wrong
+        rescue StandardError => e
+          puts 'something is wrong'
+        end
+      end
+
+      expect(result[TestClass1][:output]).to match(/assert_raises\(StandardError\) \{ @fixture.something_is_wrong \}/)
+    end
+
+    it "handles method missing" do
+      result = Pretentious.minitest_for(TestClassMethodMissing) do
+        test_class = TestClassMethodMissing.new
+        test_class.handled_by_method_missing
+      end
+
+      expect(result[TestClassMethodMissing][:output]).to match("YOU GOT ME!!!!")
+    end
   end
 end

data/spec/prententious_spec.rb

@@ -71,7 +71,7 @@ RSpec.describe Pretentious::Generator do
       test_class.handled_by_method_missing
     end
 
-      expect(result[TestClassMethodMissing][:output]).to match("YOU GOT ME!!!!")
+    expect(result[TestClassMethodMissing][:output]).to match("YOU GOT ME!!!!")
   end
 
   context "proc handling" do

data/test/generated/test_fibonacci.rb

@@ -19,12 +19,16 @@ class FibonacciScenario1 < FibonacciTest
 
     # Fibonacci#fib when passed n = 1 should return 1
     assert_equal 1, @fixture.fib(n)
+
     # Fibonacci#fib when passed n = 2 should return 1
     assert_equal 1, @fixture.fib(n_1)
+
     # Fibonacci#fib when passed n = 3 should return 2
     assert_equal 2, @fixture.fib(n_2)
+
     # Fibonacci#fib when passed n = 4 should return 3
     assert_equal 3, @fixture.fib(n_3)
+
     # Fibonacci#fib when passed n = 5 should return 5
     assert_equal 5, @fixture.fib(n_4)
   end

data/test/generated/test_test_class1.rb

@@ -34,8 +34,6 @@ class TestClass1Scenario2 < TestClass1Test
     }
 
 
-    # TestClass1#print_message  should return nil
-    assert_nil @fixture.print_message
     # TestClass1#print_message  should return nil
     assert_nil @fixture.print_message
 
@@ -61,7 +59,7 @@ class TestClass1Scenario3 < TestClass1Test
   def test_current_expectation
     another_object = TestClass1.new('test')
 
-    # TestClass1#return_self when passed message = #<TestClass1:0x000000010f3808> should return another_object
+    # TestClass1#return_self when passed message = #<TestClass1:0x000000014a2eb8> should return another_object
     assert_equal another_object, @fixture.return_self(another_object)
   end
 end

data/test/generated/test_test_class2.rb

@@ -13,8 +13,6 @@ class TestClass2Scenario1 < TestClass2Test
   def test_current_expectation
     # TestClass2#print_message  should return nil
     assert_nil @fixture.print_message
-    # TestClass2#print_message  should return nil
-    assert_nil @fixture.print_message
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pretentious
 version: !ruby/object:Gem::Version
-  version: 0.1.11
+  version: 0.1.12
 platform: ruby
 authors:
 - Joseph Emmanuel Dayo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-11 00:00:00.000000000 Z
+date: 2015-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: binding_of_caller