pretentious 0.1.6 → 0.1.7

data/lib/pretentious/trigger.rb

@@ -1,5 +1,8 @@
 module Pretentious
+  # The trigger class is used for hooking into an existing method
+  # in order to record the usage of a target class
   class Trigger
+    # options that ca be passed to a trigger
     class Options
       attr_accessor :output_folder
     end
@@ -38,9 +41,7 @@ module Pretentious
       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])
-      }
+      File.open(filename, 'w') { |f| f.write(result[:output]) }
       filename
     end
 
@@ -48,55 +49,54 @@ module Pretentious
 
     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
+        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
+        results_block.call(generator_result, options) if results_block
 
-          result
-        end
+        result
+      end
     end
 
     def install_trigger
       @options = Pretentious::Trigger::Options.new
 
-      default_callback = Proc.new { |result_per_generator, options|
+      default_callback = proc do |result_per_generator, options|
         output_files = []
-        result_per_generator.each { |klass, result|
+        result_per_generator.each do |klass, result|
           output_folder = result[:generator].location(options.output_folder)
-          filename = Pretentious::Trigger::output_file(result, klass, output_folder)
+          filename = Pretentious::Trigger.output_file(result, klass, output_folder)
           output_files << filename
-        }
+        end
         output_files
-      }
+      end
 
       @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
-
+      @target_methods.each do |method|
+        @target_class.class_exec(@target_class, method) do |klass, m|
+          unless 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)
-      }
+        attach_generator(@generator, @target_class, method, @spec_classes, @results_block, @options)
+      end
 
-      @target_class_methods.each { |method|
+      @target_class_methods.each do |method|
         @target_class.singleton_class.class_exec(@target_class, method) do |klass, m|
-          if !klass.methods.include? :"_pretentious_orig_#{m}"
+          unless 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)
-      }
+        attach_generator(@generator, @target_class.singleton_class, method,
+                         @spec_classes, @results_block, @options)
+      end
 
       @options
     end
   end
-end
+end

data/lib/pretentious/version.rb

@@ -1,3 +1,4 @@
+# Pretentious - version
 module Pretentious
-  VERSION = "0.1.6"
+  VERSION = '0.1.7'
 end

data/pretentious.gemspec

@@ -24,4 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "minitest", "~> 5.7"
   spec.add_development_dependency "minitest-stub_any_instance", "~> 1.0"
   spec.add_development_dependency "awesome_print"
+  spec.add_development_dependency "rubocop", "~> 0.35"
+  spec.add_development_dependency "rspec_junit_formatter", '0.2.2'
+  spec.add_development_dependency "simplecov"
 end

data/run_test.sh

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

data/spec/deconstructor_spec.rb

@@ -1,60 +1,76 @@
 require 'spec_helper'
 
 RSpec.describe Pretentious::Deconstructor do
-
   before do
     @fixture = Pretentious::Deconstructor.new
   end
 
   describe "#build_tree" do
-
     it "should decompose an object" do
-
       message = "test"
       another_object = Pretentious.watch {
         TestClass1.new(message)
       }
 
       # Pretentious::Deconstructor#build_tree when passed target_object = #<TestClass1:0x00000102d82860> should return {:class=>TestClass1, :id=>2171343920, :composition=>[{:class=>String, :id=>2171343600, :composition=>"test"}]}
-      expect( @fixture.build_tree(another_object) ).to eq({:class=>TestClass1, :id=>another_object.object_id,
-                                                           :composition=>[{:class=>String, :id=>message.object_id,
-                                                                           :composition=>"test"}],
-                                                           :params_types=>[[:req, :message]]})
+      expect(@fixture.build_tree(another_object)).to eq(class: TestClass1,
+                                                        id: another_object.object_id,
+                                                        composition: [{ class: String,
+                                                                        id: message.object_id,
+                                                                        composition: "test"}],
+                                                        params_types: [[:req, :message]])
 
     end
-
   end
 
   describe "Object#_deconstruct_to_ruby" do
     it "generates the ruby code to create an object" do
-      output = Pretentious.watch {
+      output = Pretentious.watch do
         a = "Some type of string"
         a._deconstruct_to_ruby
-      }
-      expect(output).to eq("a = \"Some type of string\"\n")
+      end
+      expect(output).to eq("a = 'Some type of string'\n")
+    end
+
+    it "deconstructs arrays types" do
+      output = Pretentious.watch do
+        hash = { message: "hello" }
+        arr = [1, 2, 3, "hello", hash, ['subarray', 2, :symbol]]
+        test_class = TestClass1.new(arr)
+        test_class._deconstruct_to_ruby
+      end
+      expect(output).to eq("message = [1, 2, 3, 'hello', { message: 'hello' }, ['subarray', 2, :symbol]]\ntest_class = TestClass1.new(message)\n")
+    end
+
+    it "deconstructs hash types" do
+      output = Pretentious.watch do
+        hash = { message: "hello", arr: [1, 2, 3], hash: { message2: "msg" } }
+        test_class = TestClass1.new(hash)
+        test_class._deconstruct_to_ruby
+      end
+      expect(output).to eq("message = { message: 'hello', arr: [1, 2, 3], hash: { message2: 'msg' } }\ntest_class = TestClass1.new(message)\n")
     end
 
     it "deconstruct multiple objects" do
-      output = Pretentious.watch {
+      output = Pretentious.watch do
         a = "Some type of string"
         b = TestClass1.new("Hello world")
         test_class = TestClass3.new(a, b)
         test_class._deconstruct_to_ruby
-      }
-      expect(output).to eq("testclass2 = TestClass1.new(\"Hello world\")\ntest_class = TestClass3.new(\"Some type of string\", testclass2)\n")
+      end
+      expect(output).to eq("testclass2 = TestClass1.new('Hello world')\ntest_class = TestClass3.new('Some type of string', testclass2)\n")
     end
   end
 
   describe "#deconstruct" do
-
     it "should build list of variables to declare" do
       message = "test"
-      another_object = Pretentious.watch {
+      another_object = Pretentious.watch do
         TestClass1.new(message)
-      }
+      end
 
       decons = @fixture.deconstruct([], another_object)
-      expect( decons ).to eq({declaration:
+      expect(decons).to eq({declaration:
                                   [{id: message.object_id,
                                     class: String,
                                     value: "test",
@@ -73,7 +89,5 @@ RSpec.describe Pretentious::Deconstructor do
                                                                       :ref=>[{:id=>message.object_id,
                                                                               :class=>String, :value=>"test", :used_by=>:inline}]}}})
     end
-
   end
-
 end

data/spec/fibonacci_spec.rb

@@ -1,45 +1,38 @@
-#This file was automatically generated by the pretentious gem
+# 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(1)
 
       # Fibonacci#fib when passed n = 2 should return 1
-      expect( @fixture.fib(n_1) ).to eq(1)
+      expect(@fixture.fib(n_1)).to eq(1)
 
       # Fibonacci#fib when passed n = 3 should return 2
-      expect( @fixture.fib(n_2) ).to eq(2)
+      expect(@fixture.fib(n_2)).to eq(2)
 
       # Fibonacci#fib when passed n = 4 should return 3
-      expect( @fixture.fib(n_3) ).to eq(3)
+      expect(@fixture.fib(n_3)).to eq(3)
 
       # Fibonacci#fib when passed n = 5 should return 5
-      expect( @fixture.fib(n_4) ).to eq(5)
-
+      expect(@fixture.fib(n_4)).to eq(5)
     end
-
   end
 
     it 'should pass current expectations' do
-
       # Fibonacci::say_hello  should return hello
-      expect( Fibonacci.say_hello ).to eq("hello")
-
+      expect(Fibonacci.say_hello).to eq('hello')
     end
 
 end

data/spec/generator_spec.rb

@@ -8,7 +8,7 @@ end
 
 class TestClass
 
-  def initialize
+  def initialize(dep = nil)
     @test_class2 = TestSubClass.new
   end
 

data/spec/m_d5_spec.rb

@@ -1,15 +1,11 @@
-#This file was automatically generated by the pretentious gem
+# 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"
-
+      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")
-
+      expect(Digest::MD5.hexdigest(sample)).to eq('9f12248dcddeda976611d192efaaf72a')
     end
 
 end

data/spec/minitest_generator_spec.rb

@@ -18,8 +18,8 @@ RSpec.describe Pretentious::Generator do
       result = Pretentious::Generator.generate_for(Fibonacci) do
         Fibonacci.say_hello
       end
-      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\n\n  end\n\nend\n",
-        generator: Pretentious::MinitestGenerator }})
+      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\n  end\n\nend\n",
+        generator: Pretentious::MinitestGenerator })
     end
 
   end

data/spec/prententious_spec.rb

@@ -9,6 +9,16 @@ RSpec.describe Pretentious::Generator do
       Pretentious::Generator.test_generator = Pretentious::RspecGenerator
     end
 
+
+    it "uses instance variables when used both in test and in fixtures" do
+      call_artifacts = Pretentious::Generator.generate_for(TestClass1) do
+        message = {test: "message"}
+        object = TestClass1.new(message)
+        object.return_self(message)
+      end
+      expect(call_artifacts[TestClass1][:output]).to eq("# This file was automatically generated by the pretentious gem\nrequire 'spec_helper'\n\nRSpec.describe TestClass1 do\n  context 'Scenario 1' do\n    before do\n      @message = { test: 'message' }\n      @fixture = TestClass1.new(@message)\n    end\n\n    it 'should pass current expectations' do\n      # TestClass1#return_self when passed message = {:test=>\"message\"} should return {:test=>\"message\"}\n      expect(@fixture.return_self(@message)).to eq(@message)\n    end\n  end\n\nend\n")
+    end
+
     it "classes should have a stub class section" do
       Fibonacci._stub(String)
       expect(Fibonacci._get_mock_classes).to eq([String])
@@ -28,9 +38,9 @@ RSpec.describe Pretentious::Generator do
       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\n      # Fibonacci::say_hello  should return hello\n      expect( Fibonacci.say_hello ).to eq(\"hello\")\n\n    end\n\nend\n",
-                     generator: Pretentious::RspecGenerator}})
+      expect(result).to eq(
+        Fibonacci => { output:"# This file was automatically generated by the pretentious gem\nrequire 'spec_helper'\n\nRSpec.describe Fibonacci do\n    it 'should pass current expectations' do\n      # Fibonacci::say_hello  should return hello\n      expect(Fibonacci.say_hello).to eq('hello')\n    end\n\nend\n",
+                       generator: Pretentious::RspecGenerator })
     end
   end
 
@@ -38,7 +48,7 @@ RSpec.describe Pretentious::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\n  end\n\nend\n")
+        expect(results[Fibonacci][:output]).to eq("# This file was automatically generated by the pretentious gem\nrequire 'spec_helper'\n\nRSpec.describe Fibonacci do\n  context 'Scenario 1' do\n    before do\n      @fixture = Fibonacci.new\n    end\n\n    it 'should pass current expectations' do\n      # Fibonacci#fib when passed n = 5 should return 5\n      expect(@fixture.fib(5)).to eq(5)\n    end\n  end\n\nend\n")
       end
 
       expect(Pretentious::Generator).to receive(:generate_for).with(Fibonacci).and_call_original

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
-require 'pretentious'
+require 'simplecov'
 require 'awesome_print'
 require_relative '../test_classes'
+SimpleCov.start
+require 'pretentious'

data/spec/test_class1_spec.rb

@@ -1,92 +1,77 @@
-#This file was automatically generated by the pretentious gem
+# This file was automatically generated by the pretentious gem
 require 'spec_helper'
 
 RSpec.describe TestClass1 do
-
   context 'Scenario 1' do
     before do
-      @fixture = TestClass1.new("test")
+      @fixture = TestClass1.new('test')
     end
 
     it 'should pass current expectations' do
-
       # TestClass1#message  should return test
-      expect( @fixture.message ).to eq("test")
-
+      expect(@fixture.message).to eq('test')
     end
-
   end
 
   context 'Scenario 2' do
     before do
-      @another_object = TestClass1.new("test")
-      @message = {hello: "world", test: @another_object, arr_1: [1, 2, 3, 4, 5, @another_object], sub_hash: {yes: true, obj: @another_object}}
+      @another_object = TestClass1.new('test')
+      @message = { hello: 'world', test: @another_object, arr_1: [1, 2, 3, 4, 5, @another_object], sub_hash: { yes: true, obj: @another_object } }
       @fixture = TestClass1.new(@message)
     end
 
     it 'should pass current expectations' do
-
-      var_2169524400 = Proc.new { |message|
-            @message
+      var_14407380 = proc { |message|
+        @message
       }
 
       test_class1 = nil
-      var_2169511140 = Proc.new { 
-            # Variable return values ... can't figure out what goes in here...
+      var_14401180 = proc { 
+        # Variable return values ... can't figure out what goes in here...
       }
 
-
       # TestClass1#print_message  should return 
-      expect( @fixture.print_message ).to be_nil
+      expect(@fixture.print_message).to be_nil
 
       # TestClass1#print_message  should return 
-      expect( @fixture.print_message ).to be_nil
+      expect(@fixture.print_message).to be_nil
 
-      # TestClass1#set_block  should return #<Pretentious::RecordedProc:0x00000102a00f98@example.rb:73>
-      expect( @fixture.set_block  &var_2169524400 ).to eq(var_2169524400)
+      # TestClass1#set_block  should return #<Pretentious::RecordedProc:0x00000001b78030@example.rb:73>
+      expect(@fixture.set_block  &var_14407380).to eq(var_14407380)
 
-      # TestClass1#call_block  should return {:hello=>"world", :test=>#<TestClass1:0x00000101db0950 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={2163049820=>"message"}>, :arr_1=>[1, 2, 3, 4, 5, #<TestClass1:0x00000101db0950 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={2163049820=>"message"}>], :sub_hash=>{:yes=>true, :obj=>#<TestClass1:0x00000101db0950 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={2163049820=>"message"}>}}
-      expect( @fixture.call_block  &var_2169511140 ).to eq(@message)
+      # TestClass1#call_block  should return {:hello=>"world", :test=>#<TestClass1:0x00000001bab818 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={14507340=>"message"}>, :arr_1=>[1, 2, 3, 4, 5, #<TestClass1:0x00000001bab818 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={14507340=>"message"}>], :sub_hash=>{:yes=>true, :obj=>#<TestClass1:0x00000001bab818 @message="test", @_init_arguments={:params=>["test"], :params_types=>[[:req, :message]]}, @_variable_names={14507340=>"message"}>}}
+      expect(@fixture.call_block  &var_14401180).to eq(@message)
 
       # TestClass1#something_is_wrong  should return StandardError
       expect { @fixture.something_is_wrong }.to raise_error
 
       # TestClass1#just_returns_true  should return true
-      expect( @fixture.just_returns_true ).to be true
-
+      expect(@fixture.just_returns_true).to be true
     end
-
   end
 
   context 'Scenario 3' do
     before do
-      @fixture = TestClass1.new("Hello")
+      @fixture = TestClass1.new('Hello')
     end
 
     it 'should pass current expectations' do
-
-      another_object = TestClass1.new("test")
-
-      # TestClass1#return_self when passed message = #<TestClass1:0x00000101db0950> should return #<TestClass1:0x00000101db0950>
-      expect( @fixture.return_self(another_object) ).to eq(another_object)
-
+      another_object = TestClass1.new('test')
+      # TestClass1#return_self when passed message = #<TestClass1:0x00000001bab818> should return #<TestClass1:0x00000001bab818>
+      expect(@fixture.return_self(another_object)).to eq(another_object)
     end
-
   end
 
   context 'Scenario 4' do
     before do
-      @message = TestClass1.new("test")
+      @message = TestClass1.new('test')
       @fixture = TestClass1.new(@message)
     end
 
     it 'should pass current expectations' do
-
-      # TestClass1#message  should return #<TestClass1:0x00000101db0950>
-      expect( @fixture.message ).to eq(@message)
-
+      # TestClass1#message  should return #<TestClass1:0x00000001bab818>
+      expect(@fixture.message).to eq(@message)
     end
-
   end
 
 end