pretentious 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e0dde9fafa6d13f604e06b79bc3d7714698829c4
-  data.tar.gz: 7052900a02666fa5ea8a85997073a75bcee40cce
+  metadata.gz: 8025fc11bf85286be01fb1bde220c64e7cc49c54
+  data.tar.gz: ede071633cf959eb97125c7c173f445d406de366
 SHA512:
-  metadata.gz: 4549b4ab18d247874a2ae1d9b3f9eaba6ee3201f63a923a3ad4616bc3f46dc15515e4c703c999ffddfed99e5cb967bb51e535cdf2b1812a32e5d22a3afc638a1
-  data.tar.gz: b7cab761d44df23c0a08e256d24f8538ceb7a14372db3cafb6474f0feafafc9fa3509d0a6d3a986c913ef30bf67c718418cccb2b52642103e80fd2d39c446fd5
+  metadata.gz: 2d02f840b1b06223fc6cfcd6df9a5552fe698a08815b4c7a0b86adfd83e539085fe27d1551d05aca9e9521801b6a56dc3f10333b9ce9793efdb76192e0f7ba04
+  data.tar.gz: 6d73531a5d43c9b34d6094e10931c63d7feb0cf2efb1b884206bfc34cbf81d83d8a720e3203e1bdefa28586d9697ae9d836a6bd8297f981e6c0e5e1353e23d4d

data/bin/ddtgen

@@ -47,14 +47,18 @@ module DdtUtils
    end
 end
 
-Pretentious.last_results.each { |klass, result|
-  output_folder = result[:generator].location(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])
+
+Pretentious.last_results.each { |g, result_per_generator|
+  puts "#{g}:"
+  result_per_generator.each { |klass, result|
+    output_folder = result[:generator].location(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])
+    }
+    puts "#{filename}"
   }
-  puts "#{filename}"
 }
 

data/example.rb

@@ -22,7 +22,7 @@ end
     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")
+    test_class_two = TestClass2.new("This is message 2", nil)
 
     class_to_test = TestClass3.new(test_class_one, test_class_two)
     class_to_test.show_messages
@@ -42,6 +42,12 @@ end
       class_to_test4.message
     }
 
+    message3 = "This is message 3"
+    t = TestClass2.new(message3, nil)
+    test_class_two = TestClass2.new(t, message3)
+    test_class_two.test(message3)
+
+
     begin
       test_class_one.something_is_wrong
     rescue Exception=>e

data/lib/pretentious.rb

@@ -1,4 +1,5 @@
 require "pretentious/version"
+require "pretentious/generator_base"
 require "pretentious/rspec_generator"
 require "pretentious/minitest_generator"
 require "pretentious/recorded_proc"
@@ -43,23 +44,24 @@ end
 module Pretentious
 
   def self.spec_for(*klasses, &block)
-    @results ||= {}
+    @spec_results ||= {}
     Pretentious::Generator.test_generator = Pretentious::RspecGenerator
-    @results.merge!(Pretentious::Generator.generate_for(*klasses, &block))
+    @spec_results.merge!(Pretentious::Generator.generate_for(*klasses, &block))
   end
 
   def self.minitest_for(*klasses, &block)
-    @results ||= {}
+    @minitest_results ||= {}
     Pretentious::Generator.test_generator = Pretentious::MinitestGenerator
-    @results.merge!(Pretentious::Generator.generate_for(*klasses, &block))
+    @minitest_results.merge!(Pretentious::Generator.generate_for(*klasses, &block))
   end
 
   def self.clear_results
-    @results = {}
+    @spec_results = {}
+    @minitest_results = {}
   end
 
   def self.last_results
-    @results
+    {spec: @spec_results,  minitest: @minitest_results}
   end
 
   def self.install_watcher

data/lib/pretentious/deconstructor.rb

@@ -57,7 +57,7 @@ class Pretentious::Deconstructor
   def dfs(tree)
     if !tree.is_a? Hash
       value = tree
-      definition = {id: value.object_id, class: tree.class, value: value}
+      definition = {id: value.object_id, class: tree.class, value: value, used_by: []}
       unless (@dependencies.include? value.object_id)
         @dependencies[value.object_id] = definition
         @declaration_order << definition
@@ -66,7 +66,7 @@ class Pretentious::Deconstructor
     else
       ref = []
 
-      definition = {id: tree[:id], class: tree[:class]}
+      definition = {id: tree[:id], class: tree[:class], params_types: tree[:params_types], used_by: []}
 
       if tree[:class] == Hash
         definition[:value] = dfs_hash(tree[:composition], ref)
@@ -99,11 +99,41 @@ class Pretentious::Deconstructor
       unless (@dependencies.include? tree[:id])
         @declaration_order << definition
         @dependencies[tree[:id]] = definition
+
+        ref.each { |r|
+          @dependencies[r][:used_by] << definition
+        }
       end
+
       tree[:id]
     end
   end
 
+  def update_ref_counts(params_arr, method_call)
+    params_arr.each do |p|
+      if (@dependencies.include? p.object_id)
+        @dependencies[p.object_id][:used_by] << method_call
+      end
+    end
+  end
+
+  def inline
+    @dependencies.each { |id, definition|
+      if (definition[:used_by].size == 1)
+        if (definition.include?(:value) && self.class.is_primitive?(definition[:value]))
+          ref = definition[:used_by][0]
+          definition[:used_by] = :inline
+          references = ref[:ref]
+          if (references)
+            new_ref = references.collect { |c| c == id ? definition : c}
+            ref[:ref] = new_ref
+          end
+        end
+
+      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: []}
@@ -119,15 +149,15 @@ class Pretentious::Deconstructor
       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?
-
+        tree[:params_types] = args[:params_types]
         args[:params].each { |p|
           tree[:composition] << build_tree(p)
         }
 
         tree[:block] = build_tree(args[:block]) unless args[:block].nil?
       else
+
         if (self.class.is_primitive?(target_object))
           tree[:composition] = target_object
         elsif (target_object.class == File)
@@ -144,7 +174,7 @@ class Pretentious::Deconstructor
   end
 
 
-  def deconstruct(*target_objects)
+  def deconstruct(method_call_collection, *target_objects)
 
     @declaration_order = []
     @dependencies = {}
@@ -154,10 +184,16 @@ class Pretentious::Deconstructor
       dfs(tree)
     }
 
+    method_call_collection.each do |m|
+      update_ref_counts(m[:params], m)
+    end
+
+    inline
+
     {declaration: @declaration_order, dependency: @dependencies}
   end
 
-  def deconstruct_to_ruby(indentation_level = 0, variable_map = {}, declared_names = {}, *target_objects)
+  def deconstruct_to_ruby(indentation_level = 0, variable_map = {}, declared_names = {}, method_call_collection = [], *target_objects)
     output_buffer = ""
     indentation = ""
 
@@ -168,12 +204,13 @@ class Pretentious::Deconstructor
     target_objects.each { |target_object|
       variable_map.merge!(target_object._variable_map) if target_object.methods.include?(:_variable_map) && !target_object._variable_map.nil?
     }
-    declarations, dependencies = deconstruct *target_objects
-    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, indentation)}\n"
+    declarations, dependencies = deconstruct method_call_collection, *target_objects
 
+    declarations[:declaration].each do |d|
+      unless d[:used_by] == :inline
+        var_name = Pretentious::Deconstructor.pick_name(variable_map, d[:id], declared_names)
+        output_buffer << "#{indentation}#{var_name} = #{construct(d, variable_map, declared_names, indentation)}\n"
+      end
     end
 
     output_buffer
@@ -272,7 +309,7 @@ class Pretentious::Deconstructor
     object_id_to_declared_names = {}
 
     declared_names.each { |k,v|
-      object_id_to_declared_names[v[:object_id]] = k
+      object_id_to_declared_names[v[:object_id]] = k if v
     } if declared_names
 
     #return immediately if already mapped
@@ -281,7 +318,6 @@ class Pretentious::Deconstructor
     if (!variable_map.nil? && variable_map.include?(object_id))
 
       candidate_name = variable_map[object_id].to_s
-
       if !declared_names.include?(candidate_name)
         var_name = candidate_name
         declared_names[candidate_name] = {count: 1, object_id: object_id}
@@ -369,8 +405,27 @@ class Pretentious::Deconstructor
     else
       params = []
       if (definition[:ref] && definition[:ref].size > 0)
-        definition[:ref].each do |v|
-          params << Pretentious::Deconstructor.pick_name(variable_map, v, declared_names)
+
+        i = 0
+        params_types = definition[:params_types]
+        definition[:ref].each_with_index do |v, index|
+
+          type = :param
+          if (params_types)
+            type = params_types[index][0]
+            i+=1
+          end
+
+          #to inline?
+          if (v.is_a? Hash)
+            params << Pretentious::value_ize(v[:value], variable_map, declared_names)
+          else
+            if (type == :block)
+              params << "&#{Pretentious::Deconstructor.pick_name(variable_map, v, declared_names)}"
+            else
+              params << Pretentious::Deconstructor.pick_name(variable_map, v, declared_names)
+            end
+          end
         end
         "#{definition[:class]}.new(#{params.join(', ')})"
       else

data/lib/pretentious/generator.rb

@@ -40,12 +40,13 @@ module Pretentious
 
         def initialize(*args, &block)
 
-          @_instance_init = {params: [], block: nil}
+          @_instance_init = {object_id: self.object_id, params: [], block: nil}
 
           self.class.replace_procs_with_recorders(args)
 
           @_instance_init[:params] = args
 
+
           recordedProc = if (block)
                            RecordedProc.new(block, true)
                          else
@@ -55,7 +56,9 @@ module Pretentious
           @_instance_init[:block] = recordedProc
 
           setup_instance(*args, &recordedProc)
-
+          param_types = @_instance.method(:initialize).parameters
+          puts "#{@_instance.class.name} params -> #{param_types.inspect}"
+          @_instance_init[:params_types] = param_types
 
           @_method_calls = []
           @_method_calls_by_method = {}
@@ -73,6 +76,10 @@ module Pretentious
             @_init_let_variables[variable_value.object_id] = v
           }
 
+          args.each_with_index { |a, index|
+            @_init_let_variables[a.object_id] = param_types[index][1].to_s if param_types.size == 2
+          }
+
           self.class._add_instances(self)
         end
 
@@ -207,8 +214,6 @@ module Pretentious
               @_methods_for_test = @_methods_for_test || []
               @_let_variables = @_let_variables || {}
 
-
-              #puts \"local_variables\"
               v_locals = caller_context.eval('local_variables')
 
               v_locals.each { |v|
@@ -402,15 +407,18 @@ module Pretentious
           end
           @_variable_names= {}
 
-          index = 0
-          params = method(:initialize).parameters
+          params = if (self.respond_to? :test_class )
+                      test_class.instance_method(:initialize).parameters
+                    else
+                      method(:initialize).parameters
+                   end
+          @_init_arguments[:params_types] = params
 
-          args.each do |arg|
+          args.each_with_index do |arg, index|
             p = params[index]
             if p.size > 1
               @_variable_names[arg.object_id] = p[1].to_s
             end unless p.nil?
-            index+=1
           end unless args.nil?
 
         end
@@ -420,11 +428,11 @@ module Pretentious
         end
 
         def _deconstruct
-          Pretentious::Deconstructor.new().deconstruct(self)
+          Pretentious::Deconstructor.new().deconstruct([], self)
         end
 
-        def _deconstruct_to_ruby(indentation = 0)
-          Pretentious::Deconstructor.new().deconstruct_to_ruby(indentation, _variable_map, {}, self)
+        def _deconstruct_to_ruby(var_name = nil, indentation = 0)
+          Pretentious::Deconstructor.new().deconstruct_to_ruby(indentation, _variable_map.merge({self.object_id => var_name}), {}, [], self)
         end
 
       end

data/lib/pretentious/generator_base.rb

@@ -0,0 +1,13 @@
+module Pretentious
+  class GeneratorBase
+
+    def buffer(line, level = 0)
+      @output_buffer << "#{indentation(level)}#{line}\n"
+    end
+
+    def buffer_inline(line, level = 0)
+      @output_buffer << "#{indentation(level)}#{line}"
+    end
+
+  end
+end

data/lib/pretentious/minitest_generator.rb

@@ -1,4 +1,4 @@
-class Pretentious::MinitestGenerator
+class Pretentious::MinitestGenerator < Pretentious::GeneratorBase
 
   def initialize(options = {})
     @deconstructor = Pretentious::Deconstructor.new
@@ -18,10 +18,6 @@ class Pretentious::MinitestGenerator
     buffer
   end
 
-  def buffer(line, level = 0)
-    @output_buffer << "#{indentation(level)}#{line}\n" if !line.nil? && line.strip != ''
-  end
-
   def whitespace(level = 0)
     @output_buffer << "#{indentation(level)}\n"
   end
@@ -50,35 +46,10 @@ class Pretentious::MinitestGenerator
       class_method_calls = test_instance.method_calls_by_method
       generate_specs("#{test_instance.test_class.name}::",test_instance.test_class.name, class_method_calls, test_instance.let_variables)
     else
-      buffer("class Scenario#{instance_count} < Test#{@test_class.name}",0)
+      buffer("class #{test_instance.test_class.name}Scenario#{instance_count} < Test#{@test_class.name}",0)
 
       buffer("def setup",1)
-      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.length * 2)
-                     else
-                       ''
-                     end
-
-      if (dependencies.size > 0)
-        buffer(declare_dependencies(dependencies, test_instance.init_let_variables, 2, declarations))
-      end
-
-      if (args.size > 0)
-        buffer("@fixture = #{test_instance.test_class.name}.new(#{params_generator(args, test_instance.init_let_variables, declarations)})#{block_source}",2)
-      else
-        buffer("@fixture = #{test_instance.test_class.name}.new#{block_source}",2)
-      end
+      buffer_inline(test_instance._deconstruct_to_ruby('@fixture', 2 * @_indentation.length))
       buffer("end", 1)
       whitespace
 
@@ -137,7 +108,6 @@ class Pretentious::MinitestGenerator
 
   def generate_specs(context_prefix, fixture, method_calls, let_variables)
     buffer("def test_current_expectation",1)
-    whitespace
     declaration = {}
     #collect all params
     params_collection = []
@@ -310,7 +280,7 @@ class Pretentious::MinitestGenerator
     deconstructor = Pretentious::Deconstructor.new
 
     args = remove_primitives(args, variable_map)
-    deconstructor.deconstruct_to_ruby(level * @_indentation.length, variable_map, declarations, *args)
+    deconstructor.deconstruct_to_ruby(level * @_indentation.length, variable_map, declarations, [], *args)
   end
 
   def remove_primitives(args, let_lookup)

data/lib/pretentious/rspec_generator.rb

@@ -1,4 +1,4 @@
-class Pretentious::RspecGenerator
+class Pretentious::RspecGenerator < Pretentious::GeneratorBase
 
   def initialize(options = {})
     @deconstructor = Pretentious::Deconstructor.new
@@ -18,9 +18,6 @@ class Pretentious::RspecGenerator
     buffer
   end
 
-  def buffer(line, level = 0)
-    @output_buffer << "#{indentation(level)}#{line}\n"
-  end
 
   def whitespace(level = 0)
     @output_buffer << "#{indentation(level)}\n"
@@ -46,40 +43,13 @@ class Pretentious::RspecGenerator
     if (test_instance.is_a? Class)
       #class methods
       class_method_calls = test_instance.method_calls_by_method
-      generate_specs("#{test_instance.test_class.name}::",test_instance.test_class.name, class_method_calls, test_instance.let_variables)
+      generate_specs("#{test_instance.test_class.name}::", test_instance.test_class.name,
+                     class_method_calls, test_instance.let_variables)
     else
       buffer("context 'Scenario #{instance_count}' do",1)
 
       buffer("before do",2)
-      whitespace
-
-      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
-
-      if (dependencies.size > 0)
-        buffer(declare_dependencies(dependencies, test_instance.init_let_variables, 3 * @_indentation.length, declarations))
-      end
-
-      if (args.size > 0)
-        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#{block_source}",3)
-      end
-      whitespace
+      buffer_inline(test_instance._deconstruct_to_ruby('@fixture', 3 * @_indentation.length))
       buffer("end",2)
       whitespace
 
@@ -135,15 +105,16 @@ class Pretentious::RspecGenerator
 
   def generate_specs(context_prefix, fixture, method_calls, let_variables)
     buffer("it 'should pass current expectations' do",2)
-    whitespace
     declaration = {}
     #collect all params
     params_collection = []
     mocks_collection = {}
+    method_call_collection = []
 
     method_calls.each_key do |k|
       info_blocks_arr = method_calls[k]
       info_blocks_arr.each do |block|
+        method_call_collection << block
         params_collection = params_collection | block[:params]
         if (!Pretentious::Deconstructor.is_primitive?(block[:result]) && !block[:result].kind_of?(Exception))
           params_collection << block[:result]
@@ -171,7 +142,7 @@ class Pretentious::RspecGenerator
     end
 
     if (params_collection.size > 0)
-      buffer(declare_dependencies(params_collection, let_variables, 3 * @_indentation.length, declaration))
+      buffer(declare_dependencies(params_collection, let_variables, 3 * @_indentation.length, declaration, []))
     end
 
     if (mocks_collection.keys.size > 0)
@@ -282,11 +253,11 @@ class Pretentious::RspecGenerator
     params.join(" ,")
   end
 
-  def declare_dependencies(args, variable_map, level, declarations)
+  def declare_dependencies(args, variable_map, level, declarations, method_call_collection)
     deconstructor = Pretentious::Deconstructor.new
 
     args = remove_primitives(args, variable_map)
-    deconstructor.deconstruct_to_ruby(level, variable_map, declarations, *args)
+    deconstructor.deconstruct_to_ruby(level, variable_map, declarations, method_call_collection, *args)
   end
 
   def remove_primitives(args, let_lookup)