pretentious 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c540e7a1a93193e951dbd73f85dd6ef78f2657a9
-  data.tar.gz: 51818210e6346db9ac4c30f549ca586cefeeb40e
+  metadata.gz: 594e3a65079d62df37a766461e810343529e990e
+  data.tar.gz: 1f3dc437941f264eb5790e630da2da760d7e9d97
 SHA512:
-  metadata.gz: e4812956f222bd0b479bc5721ad88dc66e1ab38f3f4879938824354f868010ba4b34bf8a261f1e23469ab2cd2534b9dd3df1b0bafdaf54310e25930205a2da2f
-  data.tar.gz: 2799fde8fdb2c36a929612ff94e642ae5986d83dd8fd77f76173b67dcb8c9513e2381daa5b2a45bdb568a7b4ef2754cefa567c9cda6b435f644076491683813c
+  metadata.gz: 7aa09793966b307e617c44c4776d6ca2c1176d3ce474094e5726e66c85e8026e7ac28f4066700f3eb2b1e08c2f8167f00f2cb1d713e93a0f7f5ba2ff5485b559
+  data.tar.gz: de79f80b3aa79eaf92e0fbcc64e04c88a024abd51127d9eff50497817b48078c0c5757fe8ff5b7a7267c72e018f26e6646ebb197e332f2134ed307d7a593ad7f

data/README.md

@@ -1,3 +1,5 @@
+[![Gem Version](https://badge.fury.io/rb/pretentious.svg)](https://badge.fury.io/rb/pretentious)
+
 # 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?
@@ -82,9 +84,9 @@ end
 
 Save your file and then switch to the terminal to invoke:
 
-    ddtgen example.rb
+    $ ddtgen example.rb
 
-This will automatically generate rspec tests for Fibonacci under spec of the current working directory.
+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.
@@ -110,7 +112,60 @@ class Fibonacci
 end
 ```
 
-You can also try this out with build in libraries like MD5 for example
+The generated spec file should look something like this
+
+```ruby
+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)
+
+      # Fibonacci#fib when passed n = 2 should return 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)
+
+      # Fibonacci#fib when passed n = 4 should return 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)
+
+    end
+  end
+
+    it 'should pass current expectations' do
+
+
+      # Fibonacci::say_hello when passed  should return hello
+      expect( Fibonacci.say_hello ).to eq("hello")
+
+    end
+end
+```
+
+awesome!
+
+You can also try this out with built-in libraries like MD5 for example ...
 
 ```ruby
 #example.rb
@@ -141,6 +196,98 @@ end
 
 Only RSpec is supported at this point. But other testing frameworks should be trivial to add support to.
 
+## 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
+
+      def initialize(message)
+        @message = message
+      end
+
+      def print_message
+        puts @message
+      end
+
+      def something_is_wrong
+        raise StandardError.new
+      end
+    end
+
+    class TestClass2
+      def initialize(message)
+        @message = {message: message}
+      end
+
+      def print_message
+        puts @message[:message]
+      end
+    end
+
+    class TestClass3
+
+      def initialize(testclass1, testclass2)
+        @class1 = testclass1
+        @class2 = testclass2
+      end
+
+      def show_messages
+        @class1.print_message
+        @class2.print_message
+        "awesome!!!"
+      end
+
+    end
+```
+
+We then instantiate the class using all sorts of weird parameters:
+
+```ruby
+  Pretentious.spec_for(TestClass3) do
+      another_object = TestClass1.new("test")
+      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")
+
+      class_to_test = TestClass3.new(test_class_one, test_class_two)
+      class_to_test.show_messages
+  end
+```
+
+Creating tests for TestClass3 should yield
+
+```ruby
+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)
+
+    end
+
+    it 'should pass current expectations' do
+
+
+      # TestClass3#show_messages when passed  should return awesome!!!
+      expect( @fixture.show_messages ).to eq("awesome!!!")
+
+    end
+  end
+```
+
+Note that creating another instance of TestClass3 will result in the creation of another Scenario
+
 ## Things to do after
 
 Since your tests are already written, and hopefully nobody notices its written by a machine, you may just leave it

data/bin/ddtgen

@@ -39,7 +39,7 @@ File.open(filename, "r") do |f|
   end
 end
 
-eval(example_body)
+eval(example_body, binding, filename, 1)
 
 #collect results
 

data/example.rb

@@ -1,70 +1,15 @@
-require 'digest/md5'
-
-class Fibonacci
-
-  def fib(n)
-    return 0 if (n == 0)
-    return 1 if (n == 1)
-    return 1 if (n == 2)
-    return fib(n - 1) + fib(n - 2)
-  end
-
-  def self.say_hello
-    "hello"
-  end
-
-end
-
-class TestClass1
+$LOAD_PATH << '.'
 
-  def initialize(message)
-    @message = message
-  end
-
-  def print_message
-    puts @message
-  end
-
-  def something_is_wrong
-    raise StandardError.new
-  end
-end
-
-class TestClass2
-  def initialize(message)
-    @message = {message: message}
-  end
-
-  def print_message
-    puts @message[:message]
-  end
-end
-
-class TestClass3
-
-  def initialize(testclass1, testclass2)
-    @class1 = testclass1
-    @class2 = testclass2
-  end
-
-  def get_hash
-    {hello: "world", message: {another: :hash}}
-  end
-
-  def show_messages
-    @class1.print_message
-    @class2.print_message
-    "awesome!!!"
-  end
+require 'digest/md5'
+require_relative './test_classes.rb'
 
-end
 
 Pretentious.spec_for(Fibonacci) do
 
 
   instance = Fibonacci.new
 
-  (1..10).each do |n|
+  (1..5).each do |n|
     instance.fib(n)
   end
 
@@ -72,7 +17,7 @@ Pretentious.spec_for(Fibonacci) do
 
 end
 
-Pretentious.spec_for(TestClass1, TestClass2, TestClass3) do
+Pretentious.spec_for(TestClass1, TestClass2, TestClass3, TestClass4) do
 
   another_object = TestClass1.new("test")
   test_class_one = TestClass1.new({hello: "world", test: another_object, arr_1: [1,2,3,4,5, another_object],
@@ -85,9 +30,21 @@ Pretentious.spec_for(TestClass1, TestClass2, TestClass3) do
   class_to_test = TestClass3.new(test_class_one, test_class_two)
   class_to_test.show_messages
 
+  class_to_test4 = TestClass4.new {
+    another_object.message
+  }
+
+  test_class_one.set_block { |message|
+    message
+  }
+
+  test_class_one.call_block {
+    class_to_test4.message
+  }
+
 end
 
 Pretentious.spec_for(Digest::MD5) do
   sample = "This is the digest"
   Digest::MD5.hexdigest(sample)
-end
+end

data/lib/pretentious.rb

@@ -25,6 +25,10 @@ module Pretentious
       ":#{value.to_s}"
     elsif (value.is_a? Hash)
       Pretentious::Deconstructor.pick_name(let_variables, value.object_id, declared_names)
+    elsif (value.is_a? Pretentious::RecordedProc)
+      Pretentious::Deconstructor.pick_name(let_variables, value.target_proc.object_id, declared_names)
+    elsif (value == nil)
+      "nil"
     else
       "#{value.to_s}"
     end
@@ -36,6 +40,46 @@ module Pretentious
     Pretentious::Generator.unwatch_new_instances
   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)
@@ -58,16 +102,26 @@ module Pretentious
                 @_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, &block)
+                  result = @_instance.send(method_sym, *arguments, &recordedProc)
                 else
-                  result = @_instance.send(:method_missing, method_sym, *arguments, &block)
+                  result = @_instance.send(:method_missing, method_sym, *arguments, &recordedProc)
                 end
                 info_block[:result] = result
               rescue Exception=>e
@@ -93,14 +147,26 @@ module Pretentious
       ")
 
       newStandInKlass.class_exec do
+
+
+
         def initialize(*args, &block)
 
           @_instance_init = {params: [], block: nil}
 
+          self.class.replace_procs_with_recorders(args)
+
           @_instance_init[:params] = args
-          @_instance_init[:block] = block
 
-          setup_instance(*args, &block)
+          recordedProc = if (block)
+                          RecordedProc.new(block, true)
+                         else
+                           nil
+                         end
+
+          @_instance_init[:block] = recordedProc
+
+          setup_instance(*args, &recordedProc)
 
 
           @_method_calls = []
@@ -183,6 +249,15 @@ module Pretentious
         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
@@ -285,7 +360,7 @@ module Pretentious
         newStandInKlass._instances.each do |instance|
           test_generator.generate(instance, num)
           num+=1
-        end
+        end unless newStandInKlass._instances.nil?
 
         test_generator.end_spec
 
@@ -296,7 +371,7 @@ module Pretentious
 
         all_results[klass] = test_generator.output
 
-      }
+      } unless klasses.nil?
 
       all_results
     end
@@ -310,7 +385,9 @@ module Pretentious
         def _set_init_arguments(*args, &block)
           @_init_arguments = @_init_arguments || {}
           @_init_arguments[:params]  = args
-          @_init_arguments[:block] = block
+          unless (block.nil?)
+            @_init_arguments[:block] = RecordedProc.new(block) {}
+          end
           @_variable_names= {}
 
           index = 0

data/lib/pretentious/deconstructor.rb

@@ -63,6 +63,15 @@ class Pretentious::Deconstructor
         definition[:value] = dfs_hash(tree[:composition], ref)
       elsif tree[:class] == Array
         definition[:value] = dfs_array(tree[:composition], ref)
+      elsif tree[:class] == Pretentious::RecordedProc
+        definition[:recorded_proc] = tree[:recorded_proc]
+
+        if (!tree[:composition].nil?)
+          ref << dfs(tree[:composition])
+        else
+          dfs(tree[:composition])
+        end
+
       elsif tree[:composition].is_a? Array
         tree[:composition].each { |t|
           ref << dfs(t)
@@ -71,6 +80,11 @@ class Pretentious::Deconstructor
         ref << dfs(tree[:composition])
       end
 
+      #evaluate given block composition
+      if (tree[:block])
+        ref << dfs(tree[:block])
+      end
+
       definition[:ref] = ref
 
       unless (@dependencies.include? tree[:id])
@@ -81,6 +95,41 @@ class Pretentious::Deconstructor
     end
   end
 
+  #creates a tree on how the object was created
+  def build_tree(target_object)
+
+    tree = {class: get_test_class(target_object), id: target_object.object_id, composition: []}
+    if (target_object.is_a? Array)
+      tree[:composition] = deconstruct_array(target_object)
+    elsif target_object.is_a? Hash
+      tree[:composition] = deconstruct_hash(target_object)
+    elsif target_object.is_a? Pretentious::RecordedProc
+      tree[:composition] = deconstruct_proc(target_object)
+      tree[:given_block] = target_object.given_block?
+      tree[:recorded_proc] = target_object
+      tree[:id] = target_object.target_proc.object_id
+      tree[:block_params] = self.class.block_param_names(target_object)
+    elsif target_object.methods.include? :_get_init_arguments
+      args = target_object._get_init_arguments
+
+      unless args.nil?
+
+        args[:params].each { |p|
+          tree[:composition] << build_tree(p)
+        }
+
+        tree[:block] = build_tree(args[:block]) unless args[:block].nil?
+      else
+        tree[:composition] = target_object
+      end
+
+    else
+      tree[:composition] = target_object
+    end
+    tree
+  end
+
+
   def deconstruct(*target_objects)
 
     @declaration_order = []
@@ -110,7 +159,7 @@ class Pretentious::Deconstructor
     declarations[:declaration].each do |d|
 
       var_name = Pretentious::Deconstructor.pick_name(variable_map, d[:id], declared_names)
-      output_buffer << "#{indentation}#{var_name} = #{construct(d, variable_map, declared_names)}\n"
+      output_buffer << "#{indentation}#{var_name} = #{construct(d, variable_map, declared_names, indentation)}\n"
 
     end
 
@@ -122,6 +171,42 @@ class Pretentious::Deconstructor
         value.is_a?(NilClass) || value.is_a?(Symbol)
   end
 
+  def self.block_param_names(proc)
+    parameters_to_join = []
+
+    parameters = proc.target_proc.parameters
+
+    parameters.each { |p|
+      parameters_to_join << p[1].to_s
+    }
+    parameters_to_join
+  end
+
+  def self.block_params_generator(proc, separator = '|')
+
+    if (proc.target_proc.parameters.size > 0)
+      return "#{separator}#{block_param_names(proc).join(', ')}#{separator}"
+    end
+
+    return ''
+  end
+
+  def proc_to_ruby(proc, let_variables, declared, indentation = '')
+    output_buffer = ""
+    output_buffer << "Proc.new { #{self.class.block_params_generator(proc)}\n"
+    output_buffer << self.class.proc_body(proc, let_variables, declared, indentation)
+    output_buffer << "#{indentation}}\n"
+    output_buffer
+  end
+
+  def self.proc_body(proc, let_variables, declared,indentation = '')
+    if (proc.return_value.size == 1)
+      "#{indentation * 2}#{Pretentious::value_ize(proc.return_value[0], let_variables, declared)}\n"
+    else
+      "#{indentation * 2}\# Variable return values ... can't figure out what goes in here...\n"
+    end
+  end
+
   def deconstruct_array(array)
     composition = []
     array.each { |v|
@@ -154,36 +239,21 @@ class Pretentious::Deconstructor
     composition
   end
 
+  def deconstruct_proc(proc)
+    if (proc.return_value.size == 1)
+      return build_tree(proc.return_value[0]) unless proc.return_value[0].nil?
+      return nil
+    else
+      nil
+    end
+  end
+
   def get_test_class(target_object)
     target_object.respond_to?(:test_class) ? target_object.test_class : target_object.class
   end
 
-  #creates a tree on how the object was created
-  def build_tree(target_object)
 
-    tree = {class: get_test_class(target_object), id: target_object.object_id, composition: []}
-    if (target_object.is_a? Array)
-      tree[:composition] = deconstruct_array(target_object)
-    elsif target_object.is_a? Hash
-      tree[:composition] = deconstruct_hash(target_object)
-    elsif target_object.methods.include? :_get_init_arguments
-
-      args = target_object._get_init_arguments
-      unless args.nil?
-        args[:params].each { |p|
-          tree[:composition] << build_tree(p)
-        }
-
-      else
-        tree[:composition] = target_object
-      end
-    else
-      tree[:composition] = target_object
-    end
-    tree
-  end
-
-  def self.pick_name(variable_map, object_id, declared_names = {})
+  def self.pick_name(variable_map, object_id, declared_names = {}, value = :no_value_passed)
     var_name = "var_#{object_id}"
 
     object_id_to_declared_names = {}
@@ -215,6 +285,10 @@ class Pretentious::Deconstructor
         end
 
       end
+    else
+      if value != :no_value_passed
+        return Pretentious::value_ize(value, let_variables,  declared_names)
+      end
     end
 
     var_name
@@ -266,8 +340,8 @@ class Pretentious::Deconstructor
     output_buffer
   end
 
-  def construct(definition, variable_map, declared_names)
-    if (definition[:value])
+  def construct(definition, variable_map, declared_names, indentation = '')
+    if (definition.include? :value)
       if (definition[:value].is_a? Hash)
         output_hash(definition[:value], variable_map, declared_names)
       elsif (definition[:value].is_a? Array)
@@ -275,11 +349,13 @@ class Pretentious::Deconstructor
       else
         Pretentious::value_ize(definition[:value], variable_map, declared_names)
       end
+    elsif (definition[:class] == Pretentious::RecordedProc)
+      proc_to_ruby(definition[:recorded_proc], variable_map, declared_names, indentation)
     else
       params = []
-      if (definition[:ref].size > 0)
+      if (definition[:ref] && definition[:ref].size > 0)
         definition[:ref].each do |v|
-          params << Pretentious::Deconstructor.pick_name(variable_map,v, declared_names)
+          params << Pretentious::Deconstructor.pick_name(variable_map, v, declared_names)
         end
         "#{definition[:class]}.new(#{params.join(', ')})"
       else

data/lib/pretentious/rspec_generator.rb

@@ -51,13 +51,30 @@ class Pretentious::RspecGenerator
 
       buffer("before do",2)
       whitespace
-      args = test_instance._init_arguments[:params]
+
       declarations = {}
-      buffer(declare_dependencies(args, test_instance.init_let_variables, 3 * @_indentation.length, declarations))
+      dependencies = []
+
+      args = test_instance._init_arguments[:params]
+      block = test_instance._init_arguments[:block]
+      dependencies = dependencies | args
+
+      unless block.nil?
+        dependencies << block
+      end
+
+      block_source = if !block.nil? && block.is_a?(Pretentious::RecordedProc)
+                       get_block_source(block, test_instance.init_let_variables, declarations, @_indentation * 3)
+                     else
+                       ''
+                     end
+
+
+      buffer(declare_dependencies(dependencies, test_instance.init_let_variables, 3 * @_indentation.length, declarations))
       if (args.size > 0)
-        buffer("@fixture = #{test_instance.test_class.name}.new(#{params_generator(args, test_instance.init_let_variables, declarations)})",3)
+        buffer("@fixture = #{test_instance.test_class.name}.new(#{params_generator(args, test_instance.init_let_variables, declarations)})#{block_source}",3)
       else
-        buffer("@fixture = #{test_instance.test_class.name}.new",3)
+        buffer("@fixture = #{test_instance.test_class.name}.new#{block_source}",3)
       end
       whitespace
       buffer("end",2)
@@ -75,11 +92,35 @@ class Pretentious::RspecGenerator
 
   private
 
-  def generate_expectation(fixture, method, let_variables, declarations, params, result)
+
+
+  def proc_function_generator(block, method)
+    "func_#{method.to_s}(#{Pretentious::Deconstructor.block_params_generator(block)})"
+  end
+
+  def get_block_source(block,let_variables, declared,indentation)
+    #output = ''
+    #output << "{ #{Pretentious::Deconstructor.block_params_generator(block)}\n"
+    #output << Pretentious::Deconstructor.proc_body(block, let_variables, declared,indentation)
+    #output << "#{indentation}}"
+    #output
+    " &#{Pretentious::Deconstructor.pick_name(let_variables, block.target_proc.object_id, declared)}"
+  end
+
+  def generate_expectation(fixture, method, let_variables, declarations, params, block, result)
+    block_source = if !block.nil? && block.is_a?(Pretentious::RecordedProc)
+                      get_block_source(block, let_variables, declarations, @_indentation * 3)
+                   else
+                     ''
+    end
+
     statement = if params.size > 0
-      "#{fixture}.#{method.to_s}(#{params_generator(params, let_variables, declarations)})"
+      "#{fixture}.#{method.to_s}(#{params_generator(params, let_variables, declarations)})#{block_source}"
     else
-      "#{fixture}.#{method.to_s}"
+      stmt = []
+      stmt << "#{fixture}.#{method.to_s}"
+      stmt << "#{block_source}" unless block_source.empty?
+      stmt.join(' ')
     end
 
     if (result.kind_of? Exception)
@@ -103,9 +144,16 @@ class Pretentious::RspecGenerator
         if (!Pretentious::Deconstructor.is_primitive?(block[:result]) && !block[:result].kind_of?(Exception))
           params_collection << block[:result]
         end
+
+        unless (block[:block].nil?)
+          params_collection << block[:block]
+        end
+
       end
+
     end
 
+
     buffer(declare_dependencies(params_collection, let_variables, 3 * @_indentation.length, declaration))
 
     method_calls.each_key do |k|
@@ -114,7 +162,7 @@ class Pretentious::RspecGenerator
       info_blocks_arr.each do |block|
 
         buffer("# #{context_prefix}#{k} when passed #{desc_params(block)} should return #{block[:result]}", 3)
-        generate_expectation(fixture, k, let_variables, declaration, block[:params], block[:result])
+        generate_expectation(fixture, k, let_variables, declaration, block[:params], block[:block], block[:result])
 
         whitespace
       end

data/lib/pretentious/version.rb

@@ -1,3 +1,3 @@
 module Pretentious
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/run_test.sh

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

data/spec/fibonacci_spec.rb

@@ -17,11 +17,6 @@ RSpec.describe Fibonacci do
       n_2 = 3
       n_3 = 4
       n_4 = 5
-      n_5 = 6
-      n_6 = 7
-      n_7 = 8
-      n_8 = 9
-      n_9 = 10
 
       # Fibonacci#fib when passed n = 1 should return 1
       expect( @fixture.fib(n) ).to eq(1)
@@ -38,21 +33,6 @@ RSpec.describe Fibonacci do
       # Fibonacci#fib when passed n = 5 should return 5
       expect( @fixture.fib(n_4) ).to eq(5)
 
-      # Fibonacci#fib when passed n = 6 should return 8
-      expect( @fixture.fib(n_5) ).to eq(8)
-
-      # Fibonacci#fib when passed n = 7 should return 13
-      expect( @fixture.fib(n_6) ).to eq(13)
-
-      # Fibonacci#fib when passed n = 8 should return 21
-      expect( @fixture.fib(n_7) ).to eq(21)
-
-      # Fibonacci#fib when passed n = 9 should return 34
-      expect( @fixture.fib(n_8) ).to eq(34)
-
-      # Fibonacci#fib when passed n = 10 should return 55
-      expect( @fixture.fib(n_9) ).to eq(55)
-
     end
   end
 

data/spec/spec_helper.rb

@@ -1,63 +1 @@
-require 'digest/md5'
-require 'json'
-require 'pretentious'
-
-class Fibonacci
-
-  def fib(n)
-    return 0 if (n == 0)
-    return 1 if (n == 1)
-    return 1 if (n == 2)
-    return fib(n - 1) + fib(n - 2)
-  end
-
-  def self.say_hello
-    "hello"
-  end
-
-end
-
-
-class TestClass1
-
-  def initialize(message)
-    @message = message
-  end
-
-  def print_message
-    puts @message
-  end
-
-  def something_is_wrong
-    raise StandardError.new
-  end
-end
-
-class TestClass2
-  def initialize(message)
-    @message = {message: message}
-  end
-
-  def print_message
-    puts @message[:message]
-  end
-end
-
-class TestClass3
-
-  def initialize(testclass1, testclass2)
-    @class1 = testclass1
-    @class2 = testclass2
-  end
-
-  def get_hash
-    {hello: "world", message: {another: :hash}}
-  end
-
-  def show_messages
-    @class1.print_message
-    @class2.print_message
-    "awesome!!!"
-  end
-
-end
+require_relative '../test_classes'

data/spec/test_class1_spec.rb

@@ -13,22 +13,37 @@ RSpec.describe TestClass1 do
     it 'should pass current expectations' do
 
 
+      # TestClass1#message when passed  should return test
+      expect( @fixture.message ).to eq("test")
+
     end
   end
 
   context 'Scenario 2' do
     before do
 
-      var_2167529620 = "test"
-      another_object = TestClass1.new(var_2167529620)
-      var_2167516320 = {hello: "world", test: another_object, arr_1: [1, 2, 3, 4, 5, another_object], sub_hash: {yes: true, obj: another_object}}
+      var_2165592540 = "test"
+      another_object = TestClass1.new(var_2165592540)
+      var_2165586880 = {hello: "world", test: another_object, arr_1: [1, 2, 3, 4, 5, another_object], sub_hash: {yes: true, obj: another_object}}
 
-      @fixture = TestClass1.new(var_2167516320)
+      @fixture = TestClass1.new(var_2165586880)
 
     end
 
     it 'should pass current expectations' do
 
+      var_2165592540 = "test"
+      another_object = TestClass1.new(var_2165592540)
+      var_2165586880 = {hello: "world", test: another_object, arr_1: [1, 2, 3, 4, 5, another_object], sub_hash: {yes: true, obj: another_object}}
+      var_2159732800 = Proc.new { |message|
+            var_2165586880
+      }
+
+      var_8 = nil
+      var_2159719320 = Proc.new { 
+            # Variable return values ... can't figure out what goes in here...
+      }
+
 
       # TestClass1#print_message when passed  should return 
       expect( @fixture.print_message ).to be_nil
@@ -36,6 +51,12 @@ RSpec.describe TestClass1 do
       # TestClass1#print_message when passed  should return 
       expect( @fixture.print_message ).to be_nil
 
+      # TestClass1#set_block when passed  should return #<Pretentious::RecordedProc:0x000001017568c0@example.rb:73>
+      expect( @fixture.set_block  &var_2159732800 ).to eq(var_2159732800)
+
+      # TestClass1#call_block when passed  should return {:hello=>"world", :test=>#<TestClass1:0x0000010228a1d8 @message="test", @_init_arguments={:params=>["test"]}, @_variable_names={2165592540=>"message"}>, :arr_1=>[1, 2, 3, 4, 5, #<TestClass1:0x0000010228a1d8 @message="test", @_init_arguments={:params=>["test"]}, @_variable_names={2165592540=>"message"}>], :sub_hash=>{:yes=>true, :obj=>#<TestClass1:0x0000010228a1d8 @message="test", @_init_arguments={:params=>["test"]}, @_variable_names={2165592540=>"message"}>}}
+      expect( @fixture.call_block  &var_2159719320 ).to eq(var_2165586880)
+
     end
   end
 

data/spec/test_class3_spec.rb

@@ -5,8 +5,8 @@ RSpec.describe TestClass3 do
   context 'Scenario 1' do
     before do
 
-      var_2167529620 = "test"
-      another_object = TestClass1.new(var_2167529620)
+      var_2165592540 = "test"
+      another_object = TestClass1.new(var_2165592540)
       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"
@@ -28,8 +28,8 @@ RSpec.describe TestClass3 do
   context 'Scenario 2' do
     before do
 
-      var_2167529620 = "test"
-      another_object = TestClass1.new(var_2167529620)
+      var_2165592540 = "test"
+      another_object = TestClass1.new(var_2165592540)
       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"

data/spec/test_class4_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+RSpec.describe TestClass4 do
+
+  context 'Scenario 1' do
+    before do
+
+      var_2165592540 = "test"
+      var_2159747700 = Proc.new { 
+            "test"
+      }
+
+
+      @fixture = TestClass4.new &var_2159747700
+
+    end
+
+    it 'should pass current expectations' do
+
+
+    end
+  end
+
+end

data/test/test_generator.rb

@@ -24,6 +24,14 @@ class TestClass1
     @message = message
   end
 
+  def set_block(&block)
+    @block=block
+  end
+
+  def call_block
+    @block.call(@message)
+  end
+
   def print_message
     puts @message
   end
@@ -33,6 +41,7 @@ class TestClass1
   end
 end
 
+
 class TestClass2
   def initialize(message)
     @message = {message: message}
@@ -56,49 +65,90 @@ class TestClass3
     "awesome!!!"
   end
 
-end
-
-#examples
-
-results_ddt = Pretentious::Generator.generate_for(Fibonacci) do
-
-  instance = Fibonacci.new
-
-  (1..10).each do |n|
-    instance.fib(n)
+  def swap_hash(j, &block)
+    h = []
+    j.each do |k,v|
+      h << block.call(v,k)
+    end
+    h
   end
 
-  Fibonacci.say_hello
-end
-
-results_ddt.each_value { |v| puts v}
+  def check_proc
+    @class2.call(1,2,3)
+  end
 
-results_md5 = Pretentious::Generator.generate_for(Digest::MD5) do
-  sample = "This is the digest"
-  Digest::MD5.hexdigest(sample)
 end
 
-results_md5.each_value { |v| puts v}
+#examples
+#
+#results_ddt = Pretentious::Generator.generate_for(Fibonacci) do
+#
+#  instance = Fibonacci.new
+#
+#  (1..10).each do |n|
+#    instance.fib(n)
+#  end
+#
+#  Fibonacci.say_hello
+#end
+#
+#results_ddt.each_value { |v| puts v}
+#
+#results_md5 = Pretentious::Generator.generate_for(Digest::MD5) do
+#  sample = "This is the digest"
+#  Digest::MD5.hexdigest(sample)
+#end
+#
+#results_md5.each_value { |v| puts v}
+
+#results_composition = Pretentious::Generator.generate_for(TestClass3, TestClass2, TestClass1) do
+#  another_object = TestClass1.new("test")
+#  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")
+#
+#  class_to_test = TestClass3.new(test_class_one, test_class_two)
+#  class_to_test.show_messages
+#
+#  class_to_test = TestClass3.new(test_class_one, test_class_two)
+#  class_to_test.show_messages
+#
+#  puts another_object._deconstruct_to_ruby
+#
+#  class_to_test.swap_hash({a: 1, b: 2}) do |v, k|
+#    "#{k}_#{v}"
+#  end
+#
+#  begin
+#    another_object.something_is_wrong
+#  rescue Exception=>e
+#  end
+#
+#  class_to_test = TestClass3.new(test_class_one, Proc.new { |a,b,c| "hello world!"})
+#  class_to_test.check_proc
+#
+#
+#
+#end
+
+results_composition = Pretentious::Generator.generate_for(TestClass1, TestClass2, TestClass3) do
 
-results_composition = Pretentious::Generator.generate_for(TestClass3, TestClass2, TestClass1) do
   another_object = TestClass1.new("test")
   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")
-
-  class_to_test = TestClass3.new(test_class_one, test_class_two)
-  class_to_test.show_messages
-
-  class_to_test = TestClass3.new(test_class_one, test_class_two)
-  class_to_test.show_messages
-
-  puts another_object._deconstruct_to_ruby
-
-  begin
-    another_object.something_is_wrong
-  rescue Exception=>e
-  end
-
+                                   sub_hash: {yes: true, obj: another_object}})
+  #test_class_two = TestClass2.new("This is message 2")
+  #
+  #class_to_test = TestClass3.new(test_class_one, test_class_two)
+  #class_to_test.show_messages
+  #
+  #class_to_test = TestClass3.new(test_class_one, test_class_two)
+  #class_to_test.show_messages
+
+  test_class_one.set_block { |message|
+    message
+  }
+
+  test_class_one.call_block
 
 end
 

data/test_classes.rb

@@ -0,0 +1,98 @@
+require 'digest/md5'
+
+class Fibonacci
+
+  def fib(n)
+    return 0 if (n == 0)
+    return 1 if (n == 1)
+    return 1 if (n == 2)
+    return fib(n - 1) + fib(n - 2)
+  end
+
+  def self.say_hello
+    "hello"
+  end
+
+end
+
+
+class TestClass1
+
+  def initialize(message)
+    @message = message
+  end
+
+  def set_block(&block)
+    @block = block
+  end
+
+  def call_block
+    @block.call(@message)
+  end
+
+  def message
+    @message
+  end
+
+  def print_message
+    puts @message
+  end
+
+  def something_is_wrong
+    raise StandardError.new
+  end
+end
+
+
+class TestClass2
+  def initialize(message)
+    @message = {message: message}
+  end
+
+  def print_message
+    puts @message[:message]
+  end
+end
+
+class TestClass3
+
+  def initialize(testclass1, testclass2)
+    @class1 = testclass1
+    @class2 = testclass2
+  end
+
+  def show_messages
+    @class1.print_message
+    @class2.print_message
+    "awesome!!!"
+  end
+
+  def swap_hash(j, &block)
+    h = []
+    j.each do |k,v|
+      h << block.call(v,k)
+    end
+    h
+  end
+
+  def check_proc
+    @class2.call(1,2,3)
+  end
+
+end
+
+class TestClass4
+
+  def initialize(&block)
+    @message = block.call
+  end
+
+  def message
+    @message
+  end
+
+  def to_s
+    @message
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pretentious
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Joseph Emmanuel Dayo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-28 00:00:00.000000000 Z
+date: 2015-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: binding_of_caller
@@ -80,8 +80,9 @@ files:
 - spec/test_class1_spec.rb
 - spec/test_class2_spec.rb
 - spec/test_class3_spec.rb
+- spec/test_class4_spec.rb
 - test/test_generator.rb
-- test_class3_spec.rb
+- test_classes.rb
 homepage: https://github.com/jedld/pretentious
 licenses:
 - MIT
@@ -114,5 +115,6 @@ test_files:
 - spec/test_class1_spec.rb
 - spec/test_class2_spec.rb
 - spec/test_class3_spec.rb
+- spec/test_class4_spec.rb
 - test/test_generator.rb
 has_rdoc: 

data/test_class3_spec.rb

@@ -1 +0,0 @@
-["RSpec.describe TestClass3 do\n\n  context 'Scenario 1' do\n    before do\n\n      var_2172810880 = \"test\"\n      another_object = TestClass1.new(var_2172810880)\n      message = {hello: \"world\", test: another_object, arr_1: [1, 2, 3, 4, 5, another_object], sub_hash: {yes: true, obj: another_object}}\n      test_class_one = TestClass1.new(message)\n      message_1 = \"This is message 2\"\n      test_class_two = TestClass2.new(message_1)\n\n      @fixture = TestClass3.new(test_class_one, test_class_two)\n\n    end\n\n    it 'should pass current expectations' do\n\n\n      # TestClass3#show_messages when passed  should return awesome!!!\n      expect ( @fixture.show_messages ).to equal(\"awesome!!!\")\n\n    end\n  end\n\n  context 'Scenario 2' do\n    before do\n\n      var_2172810880 = \"test\"\n      another_object = TestClass1.new(var_2172810880)\n      message = {hello: \"world\", test: another_object, arr_1: [1, 2, 3, 4, 5, another_object], sub_hash: {yes: true, obj: another_object}}\n      test_class_one = TestClass1.new(message)\n      message_1 = \"This is message 2\"\n      test_class_two = TestClass2.new(message_1)\n\n      @fixture = TestClass3.new(test_class_one, test_class_two)\n\n    end\n\n    it 'should pass current expectations' do\n\n\n      # TestClass3#show_messages when passed  should return awesome!!!\n      expect ( @fixture.show_messages ).to equal(\"awesome!!!\")\n\n    end\n  end\n\nend\n"]