pretentious 0.1.6 → 0.1.7

data/lib/pretentious/generator.rb

@@ -1,4 +1,5 @@
 module Pretentious
+  # A class that generates specs by analyzing how an object is used
   class Generator
 
     def self.test_generator=(generator)
@@ -10,24 +11,24 @@ module Pretentious
     end
 
     def self.impostor_for(module_space, klass)
-      newStandInKlass = Class.new()
+      new_standin_klass = Class.new
       name = klass.name
 
-      #return if already an impostor
-      return klass if (klass.respond_to?(:test_class))
+      # return if already an impostor
+      return klass if klass.respond_to?(:test_class)
 
-      module_space.const_set "#{name.split('::').last}Impostor", newStandInKlass
+      module_space.const_set "#{name.split('::').last}Impostor", new_standin_klass
 
-      newStandInKlass.class_eval("
+      new_standin_klass.class_eval("
         def setup_instance(*args, &block)
           @_instance = #{klass.name}_ddt.new(*args, &block)
         end
       ")
 
-      newStandInKlass.class_eval("
+      new_standin_klass.class_eval("
         class << self
           def _get_standin_class
-            #{newStandInKlass}
+            #{new_standin_klass}
           end
 
           def test_class
@@ -40,26 +41,18 @@ module Pretentious
         end
       ")
 
-      newStandInKlass.class_exec do
-
+      new_standin_klass.class_exec do
         def initialize(*args, &block)
-
-          @_instance_init = {object_id: self.object_id, params: [], block: nil}
+          @_instance_init = { object_id: object_id, params: [], block: nil }
 
           self.class.replace_procs_with_recorders(args)
 
           @_instance_init[:params] = args
+          recorded_proc = block ? RecordedProc.new(block, true) : nil
 
+          @_instance_init[:block] = recorded_proc
 
-          recordedProc = if (block)
-                           RecordedProc.new(block, true)
-                         else
-                           nil
-                         end
-
-          @_instance_init[:block] = recordedProc
-
-          setup_instance(*args, &recordedProc)
+          setup_instance(*args, &recorded_proc)
           param_types = @_instance.method(:initialize).parameters
           @_instance_init[:params_types] = param_types
 
@@ -68,20 +61,19 @@ module Pretentious
           @_methods_for_test = []
           @_let_variables = {}
 
-
           @_init_let_variables = {}
 
           caller_context = binding.of_caller(2)
           v_locals = caller_context.eval('local_variables')
 
-          v_locals.each { |v|
+          v_locals.each do |v|
             variable_value = caller_context.eval("#{v.to_s}")
             @_init_let_variables[variable_value.object_id] = v
-          }
+          end
 
-          args.each_with_index { |a, index|
+          args.each_with_index do |a, index|
             @_init_let_variables[a.object_id] = param_types[index][1].to_s if param_types.size == 2
-          }
+          end
 
           self.class._add_instances(self)
         end
@@ -95,7 +87,7 @@ module Pretentious
         end
 
         def include_for_tests(method_list = [])
-          @_methods_for_test = @_methods_for_test + method_list
+          @_methods_for_test += method_list
         end
 
         def let_variables
@@ -119,11 +111,11 @@ module Pretentious
         end
 
         def ==(other)
-          @_instance==other
+          @_instance == other
         end
 
         def kind_of?(klass)
-          @_instance.kind_of? klass
+          @_instance.is_a? klass
         end
 
         def methods
@@ -158,7 +150,7 @@ module Pretentious
 
           def replace_procs_with_recorders(args)
             (0..args.size).each do |index|
-              if (args[index].kind_of? Proc)
+              if args[index].kind_of? Proc
                 args[index] = Pretentious::RecordedProc.new(args[index]) {}
               end
             end
@@ -169,12 +161,12 @@ module Pretentious
           end
 
           def _is_stub?
-            @_is_stub = @_is_stub || false
+            @_is_stub ||= false
             @_is_stub
           end
 
           def _add_instances(instance)
-            @_instances = @_instances || []
+            @_instances ||= []
             @_instances << instance unless @_instances.include? instance
           end
 
@@ -191,7 +183,7 @@ module Pretentious
           end
 
           def _add_instances(instance)
-            @_instances = @_instances || []
+            @_instances ||= []
             @_instances << instance unless @_instances.include? instance
           end
 
@@ -205,18 +197,18 @@ module Pretentious
           end
 
           def _call_method(target, method_sym, *arguments, &block)
-
             klass = nil
             begin
               klass = _get_standin_class
             rescue NameError=>e
               result = nil
               target.instance_exec do
-                result = if (@_instance.methods.include? method_sym)
-                  @_instance.send(method_sym, *arguments, &block)
-                else
-                  @_instance.send(:method_missing, method_sym, *arguments, &block)
-                end
+                result = if @_instance.methods.include? method_sym
+                           @_instance.send(method_sym, *arguments, &block)
+                         else
+                           @_instance.send(:method_missing, method_sym,
+                                           *arguments, &block)
+                         end
               end
               return result
             end
@@ -226,95 +218,85 @@ module Pretentious
             is_stub = _is_stub?
 
             target.instance_exec do
-              @_method_calls = @_method_calls || []
-              @_method_calls_by_method = @_method_calls_by_method || {}
-              @_methods_for_test = @_methods_for_test || []
-              @_let_variables = @_let_variables || {}
+              @_method_calls ||= []
+              @_method_calls_by_method ||= {}
+              @_methods_for_test ||= []
+              @_let_variables ||= {}
 
               v_locals = caller_context.eval('local_variables')
 
-              v_locals.each { |v|
-                variable_value = caller_context.eval("#{v.to_s}")
-                  @_let_variables[variable_value.object_id] = v
-                }
+              v_locals.each do |v|
+                variable_value = caller_context.eval("#{v}")
+                @_let_variables[variable_value.object_id] = v
+              end
 
-                klass.replace_procs_with_recorders(arguments)
+              klass.replace_procs_with_recorders(arguments)
 
-                info_block = {}
-                info_block[:method] = method_sym
-                info_block[:params] = 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
+              recorded_proc = block ? RecordedProc.new(block, true) : nil
 
-                info_block[:names] = @_instance.method(method_sym).parameters
+              info_block[:block] = recorded_proc
 
-                begin
+              info_block[:names] = @_instance.method(method_sym).parameters
 
-                  unless is_stub
-                    current_context = { calls: [] }
-                    info_block[:context] = current_context
+              begin
 
-                    Thread.current._push_context(current_context)
-                  end
+                unless is_stub
+                  current_context = { calls: [] }
+                  info_block[:context] = current_context
 
-                  if (@_instance.methods.include? method_sym)
-                    result = @_instance.send(method_sym, *arguments, &recordedProc)
-                  else
-                    result = @_instance.send(:method_missing, method_sym, *arguments, &recordedProc)
-                  end
+                  Thread.current._push_context(current_context)
+                end
 
-                  Thread.current._pop_context unless is_stub
+                if @_instance.methods.include? method_sym
+                  result = @_instance.send(method_sym, *arguments, &recorded_proc)
+                else
+                  result = @_instance.send(:method_missing, method_sym, *arguments, &recorded_proc)
+                end
 
-                  # methods that end with = are a special case with return values
-                  if method_sym.to_s.end_with? '='
-                    info_block[:result] = arguments[0]
-                  else
-                    info_block[:result] = result
-                  end
+                Thread.current._pop_context unless is_stub
 
-                rescue Exception=>e
-                  info_block[:result] = e
-                rescue StandardError=>e
-                  info_block[:result] = e
+                # methods that end with = are a special case with return values
+                if method_sym.to_s.end_with? '='
+                  info_block[:result] = arguments[0]
+                else
+                  info_block[:result] = result
                 end
+              rescue StandardError => e
+                info_block[:result] = e
+              end
 
-                if is_stub
-                  info_block[:class] = test_class
-                  Thread.current._all_context.each { |mock_context|
-                    mock_context[:calls] << info_block if mock_context
-                  }
+              if is_stub
+                info_block[:class] = test_class
+                Thread.current._all_context.each do |mock_context|
+                  mock_context[:calls] << info_block if mock_context
                 end
+              end
 
-                @_method_calls << info_block
+              @_method_calls << info_block
 
-                if (@_method_calls_by_method[method_sym].nil?)
-                  @_method_calls_by_method[method_sym] = []
-                end
+              if @_method_calls_by_method[method_sym].nil?
+                @_method_calls_by_method[method_sym] = []
+              end
 
-                @_method_calls_by_method[method_sym] << info_block
-                raise e if (e.kind_of? Exception)
-                result
+              @_method_calls_by_method[method_sym] << info_block
+              fail e if e.is_a? Exception
+              result
             end
           end
-
         end
-
       end
 
-      newStandInKlass.class_exec do
+      new_standin_klass.class_exec do
         def method_missing(method_sym, *arguments, &block)
-          #puts "#{method_sym} #{arguments}"
           self.class._call_method(self, method_sym, *arguments, &block)
         end
 
         class << self
             def method_missing(method_sym, *arguments, &block)
-              #puts "method #{method_sym.to_s}"
               _add_instances(self)
               @_instance = _current_old_class
               _call_method(self, method_sym, *arguments, &block)
@@ -322,7 +304,7 @@ module Pretentious
         end
       end
 
-      newStandInKlass
+      new_standin_klass
     end
 
     def self.replace_class(klass, stub = false)
@@ -331,27 +313,27 @@ module Pretentious
 
       module_space = Object
 
-      if (klass_name_parts.size > 0)
+      if klass_name_parts.size > 0
         klass_name_parts.each do |part|
           module_space = module_space.const_get(part)
         end
       end
 
-      newStandInKlass = impostor_for module_space, klass
-      newStandInKlass._set_is_stub if stub
+      new_standin_klass = impostor_for module_space, klass
+      new_standin_klass._set_is_stub if stub
 
-      module_space.send(:remove_const,last_part.to_sym)
+      module_space.send(:remove_const, last_part.to_sym)
       module_space.const_set("#{last_part}_ddt", klass)
-      module_space.const_set("#{last_part}", newStandInKlass)
+      module_space.const_set("#{last_part}", new_standin_klass)
 
-      [module_space, klass, last_part, newStandInKlass]
+      [module_space, klass, last_part, new_standin_klass]
     end
 
     def self.restore_class(module_space, klass, last_part)
-      module_space.send(:remove_const,"#{last_part}Impostor".to_sym)
-      module_space.send(:remove_const,"#{last_part}".to_sym)
+      module_space.send(:remove_const, "#{last_part}Impostor".to_sym)
+      module_space.send(:remove_const, "#{last_part}".to_sym)
       module_space.const_set(last_part, klass)
-      module_space.send(:remove_const,"#{last_part}_ddt".to_sym)
+      module_space.send(:remove_const, "#{last_part}_ddt".to_sym)
     end
 
     def self.generate_for(*klasses_or_instances, &block)
@@ -359,18 +341,18 @@ module Pretentious
       klasses = []
       mock_dict = {}
 
-      klasses_or_instances.each { |klass_or_instance|
+      klasses_or_instances.each do |klass_or_instance|
         klass = klass_or_instance.class == Class ? klass_or_instance : klass_or_instance.class
         klasses << replace_class(klass)
 
         mock_klasses = []
 
         klass._get_mock_classes.each do |mock_klass|
-          mock_klasses << replace_class(mock_klass , true)
+          mock_klasses << replace_class(mock_klass, true)
         end unless klass._get_mock_classes.nil?
 
         mock_dict[klass] = mock_klasses
-      }
+      end
 
       watch_new_instances
 
@@ -378,34 +360,30 @@ module Pretentious
 
       unwatch_new_instances
 
-      klasses.each { |module_space, klass, last_part, newStandInKlass|
-
-        #restore the previous class
+      klasses.each do |module_space, klass, last_part, new_standin_klass|
+        # restore the previous class
         restore_class module_space, klass, last_part
 
-        mock_dict[klass].each do |_module_space, _klass, _last_part, _newStandInKlass|
-          restore_class _module_space, _klass, _last_part
+        mock_dict[klass].each do |mock_module_space, mock_klass, mock_last_part, mock_new_standin_klass|
+          restore_class mock_module_space, mock_klass, mock_last_part
         end
 
         generator = test_generator.new
         generator.begin_spec(klass)
         num = 1
 
-        newStandInKlass._instances.each do |instance|
+        new_standin_klass._instances.each do |instance|
           generator.generate(instance, num)
-          num+=1
-        end unless newStandInKlass._instances.nil?
+          num += 1
+        end unless new_standin_klass._instances.nil?
 
         generator.end_spec
 
         result = all_results[klass]
-        if result.nil?
-          all_results[klass] = []
-        end
+        all_results[klass] = [] if result.nil?
 
-        all_results[klass] = {output: generator.output, generator: generator.class }
-
-      } unless klasses.nil?
+        all_results[klass] = { output: generator.output, generator: generator.class }
+      end unless klasses.nil?
 
       all_results
     end
@@ -424,18 +402,16 @@ module Pretentious
           end
           @_variable_names = {}
 
-          params = if (self.respond_to? :test_class )
-                      test_class.instance_method(:initialize).parameters
-                    else
-                      self.class.instance_method(:initialize).parameters
+          params = if self.respond_to? :test_class
+                     test_class.instance_method(:initialize).parameters
+                   else
+                     self.class.instance_method(:initialize).parameters
                    end
           @_init_arguments[:params_types] = params
 
           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?
+            @_variable_names[arg.object_id] = p[1].to_s if p && p.size > 1
           end unless args.nil?
 
         end
@@ -445,7 +421,7 @@ module Pretentious
         end
 
         def _deconstruct
-          Pretentious::Deconstructor.new().deconstruct([], self)
+          Pretentious::Deconstructor.new.deconstruct([], self)
         end
 
         def _deconstruct_to_ruby(var_name = nil, indentation = 0)
@@ -454,45 +430,44 @@ module Pretentious
           caller_context = binding.of_caller(1)
           v_locals = caller_context.eval('local_variables')
 
-          v_locals.each { |v|
-            variable_value = caller_context.eval("#{v.to_s}")
-            if self.object_id == variable_value.object_id
+          v_locals.each do |v|
+            variable_value = caller_context.eval("#{v}")
+            if object_id == variable_value.object_id
               variable_names[variable_value.object_id] = v
             end
-          }
+          end
 
-          variable_names = _variable_map.merge({self.object_id => var_name}) unless var_name.nil?
-          Pretentious::Deconstructor.new().deconstruct_to_ruby(indentation, variable_names, {}, {}, [], self)
-        end
+          context = Pretentious::Context.new(_variable_map.merge!(variable_names))
+          context.register(object_id, var_name) if var_name
 
+          Pretentious::Deconstructor.new.deconstruct_to_ruby(context, indentation, self)
+        end
       end
 
-      #make sure it is set only once
-      if (!Class.instance_methods.include?(:_ddt_old_new))
+      # make sure it is set only once
+      unless Class.instance_methods.include?(:_ddt_old_new)
         Class.class_eval do
           alias_method :_ddt_old_new, :new
 
           def new(*args, &block)
             instance = _ddt_old_new(*args, &block)
 
-            #rescues for handling native objects that don't have standard methoods
+            # rescues for handling native objects that don't have standard methods
             begin
-              if (instance.respond_to?(:_set_init_arguments))
+              if instance.respond_to?(:_set_init_arguments)
                 instance._set_init_arguments(*args, &block)
               end
-            rescue NoMethodError=>e
+            rescue NoMethodError
               begin
                 instance._set_init_arguments(*args, &block)
-              rescue NoMethodError=>e2
+              rescue NoMethodError
               end
             end
 
             instance
           end
-
         end
       end
-
     end
 
     def self.clean_watches
@@ -500,7 +475,7 @@ module Pretentious
     end
 
     def self.unwatch_new_instances
-      if (Class.respond_to?(:_ddt_old_new))
+      if Class.respond_to?(:_ddt_old_new)
         Class.class_eval do
           remove_method :new
           alias_method :new, :_ddt_old_new
@@ -508,7 +483,5 @@ module Pretentious
         end
       end
     end
-
   end
-
 end