pretentious 0.1.6 → 0.1.7

data/lib/pretentious/recorded_proc.rb

@@ -1,6 +1,7 @@
 module Pretentious
-
+  # Sublass of Proc that records whatever was passed to it and whatever it returns
   class RecordedProc < Proc
+    attr_reader :target_proc, :return_value
 
     def initialize(target_proc, is_given_block = false)
       @target_proc = target_proc
@@ -14,14 +15,6 @@ module Pretentious
       @given_block
     end
 
-    def target_proc
-      @target_proc
-    end
-
-    def return_value
-      @return_value
-    end
-
     def is_called?
       @called
     end
@@ -31,13 +24,8 @@ module Pretentious
       @args << args
       return_value = @target_proc.call(*args, &block)
 
-      unless @return_value.include? return_value
-        @return_value << return_value
-      end
-
+      @return_value << return_value unless @return_value.include? return_value
       return_value
     end
-
   end
-
-end
+end

data/lib/pretentious/rspec_generator.rb

@@ -1,306 +1,195 @@
-class Pretentious::RspecGenerator < Pretentious::GeneratorBase
-
-  def initialize(options = {})
-    @deconstructor = Pretentious::Deconstructor.new
-    indentation_count = options[:indentation] || 2
-    @output_buffer = ""
-    @_indentation = ""
-    indentation_count.times do
-      @_indentation << " "
-    end
-  end
-
-  def indentation(level)
-    buffer = ""
-    level.times do
-      buffer << @_indentation
-    end
-    buffer
-  end
-
-
-  def whitespace(level = 0)
-    @output_buffer << "#{indentation(level)}\n"
-  end
-
-  def begin_spec(test_class)
-    buffer("#This file was automatically generated by the pretentious gem")
-    buffer("require 'spec_helper'")
-    whitespace
-    buffer("RSpec.describe #{test_class.name} do")
-    whitespace
-  end
-
-  def end_spec
-    buffer("end")
-  end
-
-  def output
-    @output_buffer
-  end
-
-  def generate(test_instance, instance_count)
-    global_variable_declaration = {}
-    if (test_instance.is_a? Class)
-      #class methods
-      class_method_calls = test_instance.method_calls_by_method
-      buffer(generate_specs("#{test_instance.test_class.name}::", test_instance.test_class.name,
-                     class_method_calls, test_instance.let_variables, global_variable_declaration, {}))
-    else
-      buffer("context 'Scenario #{instance_count}' do",1)
-
-      buffer("before do",2)
-
-      top_declarations, declarations, variable_map, global_declared_names = setup_fixture(test_instance)
-      method_calls = test_instance.method_calls_by_method
-      specs_buffer = generate_specs("#{test_instance.test_class.name}#", "@fixture", method_calls, variable_map,
-                                    global_variable_declaration, top_declarations)
-      buffer_inline(@deconstructor.build_output(3 * @_indentation.length, variable_map, declarations, global_variable_declaration, {}))
-      buffer("end",2)
-      whitespace
-      buffer(specs_buffer)
-      buffer('end',1)
+module Pretentious
+  class RspecGenerator < Pretentious::GeneratorBase
+    def begin_spec(test_class)
+      buffer('# This file was automatically generated by the pretentious gem')
+      buffer("require 'spec_helper'")
       whitespace
+      buffer("RSpec.describe #{test_class.name} do")
     end
 
-  end
-
-  private
-
-
-
-  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)
-    output = ""
-    block_source = if !block.nil? && block.is_a?(Pretentious::RecordedProc)
-                      get_block_source(block, let_variables, declarations, @_indentation * 3)
-                   else
-                     ''
+    def end_spec
+      buffer('end')
     end
 
-    statement = if params.size > 0
-      "#{fixture}.#{method.to_s}(#{params_generator(params, let_variables, declarations)})#{block_source}"
-    else
-      stmt = []
-      stmt << "#{fixture}.#{method.to_s}"
-      stmt << "#{block_source}" unless block_source.empty?
-      stmt.join(' ')
+    def output
+      @output_buffer
     end
 
-    if (result.kind_of? Exception)
-      buffer_to_string(output, "expect { #{statement} }.to #{pick_matcher(result, let_variables, declarations)}",3)
-    else
-      buffer_to_string(output, "expect( #{statement} ).to #{pick_matcher(result, let_variables, declarations)}",3)
+    def generate(test_instance, instance_count)
+      if test_instance.is_a? Class
+        context = Pretentious::Context.new(test_instance.let_variables)
+        # class methods
+        class_method_calls = test_instance.method_calls_by_method
+        buffer(generate_specs(context, "#{test_instance.test_class.name}::", test_instance.test_class.name,
+                              class_method_calls))
+      else
+        buffer("context 'Scenario #{instance_count}' do", 1)
+
+        buffer('before do', 2)
+
+        context, declarations = setup_fixture(test_instance)
+        method_calls = test_instance.method_calls_by_method
+        spec_context = context.subcontext(declarations[:declaration])
+        specs_buffer = generate_specs(spec_context, "#{test_instance.test_class.name}#", "@fixture", method_calls)
+        context.declared_names = {}
+        deconstruct_output = @deconstructor.build_output(context, 3 * @_indentation.length, declarations)
+
+        buffer_inline(deconstruct_output)
+        buffer('end', 2)
+        whitespace
+        buffer_inline(specs_buffer)
+        buffer('end', 1)
+        whitespace
+      end
     end
-    output
-  end
-
-  def generate_specs(context_prefix, fixture, method_calls, let_variables, declaration, previous_declaration)
-    output = ""
-    buffer_to_string(output, "it 'should pass current expectations' do\n", 2)
-    #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]
-        end
-
-        unless (block[:block].nil?)
-          params_collection << block[:block]
-        end
-
-        block[:context][:calls].each do |mock_block|
-          k = "#{mock_block[:class]}_#{mock_block[:method]}"
-
-          if mocks_collection[k].nil?
-            mocks_collection[k] = []
-          end
 
-          mocks_collection[k] << mock_block
-          params_collection << mock_block[:result]
-
-        end if block[:context]
-
-
-      end
+    private
 
+    def proc_function_generator(block, method)
+      "func_#{method}(#{Pretentious::Deconstructor.block_params_generator(block)})"
     end
 
-    if (params_collection.size > 0)
-      deps = declare_dependencies(params_collection, let_variables, 3 * @_indentation.length, declaration,
-                           [], previous_declaration)
-      buffer_to_string(output, deps) if deps!=''
+    def get_block_source(context, block)
+      " &#{context.pick_name(block.target_proc.object_id)}"
     end
 
-    if (mocks_collection.keys.size > 0)
-      buffer_to_string(output, generate_rspec_stub(mocks_collection, let_variables, 3 * @_indentation.length, declaration))
+    def generate_expectation(context, fixture, method, params, block, result)
+      output = ''
+      block_source = if !block.nil? && block.is_a?(Pretentious::RecordedProc)
+                      get_block_source(context, block)
+                     else
+                       ''
+      end
+
+      statement = if params.size > 0
+                    "#{fixture}.#{method}(#{params_generator(context, params)})#{block_source}"
+                  else
+                    stmt = []
+                    stmt << "#{fixture}.#{method}"
+                    stmt << "#{block_source}" unless block_source.empty?
+                    stmt.join(' ')
+                  end
+
+      if result.is_a? Exception
+        buffer_to_string(output, "expect { #{statement} }.to #{pick_matcher(context, result)}",3)
+      else
+        buffer_to_string(output, "expect(#{statement}).to #{pick_matcher(context, result)}",3)
+      end
+      output
     end
 
-    method_calls.each_key do |k|
-      info_blocks_arr = method_calls[k]
+    def generate_specs(context, context_prefix, fixture, method_calls)
+      output = ''
+      buffer_to_string(output, "it 'should pass current expectations' do", 2)
+      # 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 |= block[:params]
+          if !Pretentious::Deconstructor.primitive?(block[:result]) && !block[:result].kind_of?(Exception)
+            params_collection << block[:result]
+          end
 
-      info_blocks_arr.each do |block|
+          params_collection << block[:block] unless block[:block].nil?
 
-        params_desc_str =  if block[:params].size > 0
-                             "when passed #{desc_params(block)}"
-                           else
-                             ""
-                           end
+          next unless block[:context]
+          block[:context][:calls].each do |mock_block|
+            k = "#{mock_block[:class]}_#{mock_block[:method]}"
 
-        buffer_to_string(output, "# #{context_prefix}#{k} #{params_desc_str} should return #{block[:result]}", 3)
+            mocks_collection[k] = [] if mocks_collection[k].nil?
 
-        buffer_to_string(output, generate_expectation(fixture, k, let_variables, declaration, block[:params], block[:block], block[:result]))
+            mocks_collection[k] << mock_block
+            params_collection << mock_block[:result]
+          end
+        end
       end
-    end
 
-    buffer_to_string(output, "end", 2)
-    output
-  end
+      if params_collection.size > 0
+        deps = declare_dependencies(context, params_collection, 3)
+        buffer_inline_to_string(output, deps) if deps != ''
+      end
 
-  def generate_rspec_stub(mocks_collection, let_variables, indentation_level , declaration)
-    indentation = ""
+      if mocks_collection.keys.size > 0
+        buffer_to_string(output, generate_rspec_stub(context, mocks_collection,
+                                                     3 * @_indentation.length))
+      end
 
-    indentation_level.times {
-      indentation << ' '
-    }
-    str = ""
-    mocks_collection.each do |k,values|
-      vals = values.collect { |v| Pretentious::value_ize(v[:result], let_variables, declaration) }
+      expectations = []
+      method_calls.each_key do |k|
 
-      #check if all vals are the same and just use one
-      vals = [vals[0]] if vals.uniq.size == 1
+        info_blocks_arr = method_calls[k]
 
-      str << "#{indentation}allow_any_instance_of(#{values[0][:class].to_s}).to receive(:#{values[0][:method].to_s}).and_return(#{vals.join(', ')})\n"
-    end
-    str
-  end
+        info_blocks_arr.each do |block|
+          str = ''
+          params_desc_str = if block[:params].size > 0
+                               "when passed #{desc_params(block)}"
+                             else
+                               ''
+                             end
 
-  #def generate_specs(context_prefix, fixture, method_calls, let_variables)
-  #  method_calls.each_key do |k|
-  #    info_blocks_arr = method_calls[k]
-  #
-  #    buffer("context \"#{context_prefix}#{k}\" do", 1)
-  #
-  #    whitespace
-  #    info_blocks_arr.each do |block|
-  #      buffer("it '#{desc_params(block)} returns #{block[:result]}' do",2)
-  #      whitespace
-  #      if block[:params].size > 0
-  #        buffer(declare_dependencies(block[:params], let_variables, 3))
-  #        buffer("expect(#{fixture}.#{k.to_s}(#{params_generator(block[:params], let_variables)})).to #{pick_matcher(block[:result])}",3)
-  #      else
-  #        buffer("expect(#{fixture}.#{k.to_s}).to #{pick_matcher(block[:result])}",3)
-  #      end
-  #      whitespace
-  #      buffer("end",2)
-  #      whitespace
-  #    end
-  #
-  #    buffer("end", 1)
-  #    whitespace
-  #  end
-  #end
-
-  def pick_matcher(result, let_variables, declared_names)
-    if result.is_a? TrueClass
-     'be true'
-    elsif result.is_a? FalseClass
-      'be false'
-    elsif result.nil?
-      'be_nil'
-    elsif result.kind_of? Exception
-      'raise_error'
-    elsif let_variables && let_variables[result.object_id]
-      "eq(#{Pretentious::value_ize(result, let_variables, declared_names)})"
-    else
-      "eq(#{Pretentious::value_ize(result, nil, nil)})"
+          buffer_to_string(str, "# #{context_prefix}#{k} #{params_desc_str} should return #{block[:result]}", 3)
+          buffer_inline_to_string(str, generate_expectation(context, fixture, k, block[:params], block[:block], block[:result]))
+          expectations << str
+        end
+      end
+      buffer_inline_to_string(output, expectations.join("\n"))
+      buffer_to_string(output, 'end', 2)
+      output
     end
-  end
 
+    def generate_rspec_stub(context, mocks_collection, indentation_level)
+      indentation = ''
 
+      indentation_level.times { indentation << ' ' }
+      str = ''
+      mocks_collection.each do |_k, values|
+        vals = values.collect { |v| context.value_of(v[:result]) }
 
-  def desc_params(block)
-    params = []
-    args = block[:params]
-    names = block[:names]
-    n = 0
-    #puts args.inspect
-    return "" if args.nil?
+        # check if all vals are the same and just use one
+        vals = [vals[0]] if vals.uniq.size == 1
 
-    args.each do |arg|
-      param_name = names[n][1].to_s
-      arg_value = (arg.is_a? String) ? "#{arg.dump}" : "#{arg.to_s}"
-      if (param_name.empty?)
-        params << "#{arg_value}"
-      else
-        params << "#{param_name} = #{arg_value}"
+        str << "#{indentation}allow_any_instance_of(#{values[0][:class]}).to receive(:#{values[0][:method]}).and_return(#{vals.join(', ')})\n"
       end
-
-      n+=1
+      str
     end
-    params.join(" ,")
-  end
 
-  def declare_dependencies(args, variable_map, level, declarations, method_call_collection, top_level_declaration = {})
-    deconstructor = Pretentious::Deconstructor.new
-
-    args = remove_primitives(args, variable_map)
-    deconstructor.deconstruct_to_ruby(level, variable_map, declarations, top_level_declaration, method_call_collection, *args)
-  end
-
-  def remove_primitives(args, let_lookup)
-    args.select { |a| let_lookup.include?(a.object_id) || !Pretentious::Deconstructor.is_primitive?(a) }
-  end
-
-  def params_generator(args, let_variables, declared_names)
-    params = []
-    args.each do |arg|
-      if (!let_variables.nil? && let_variables[arg.object_id])
-        params <<  Pretentious::Deconstructor.pick_name(let_variables, arg.object_id, declared_names)
+    def pick_matcher(context, result)
+      if result.is_a? TrueClass
+        'be true'
+      elsif result.is_a? FalseClass
+        'be false'
+      elsif result.nil?
+        'be_nil'
+      elsif result.is_a? Exception
+        'raise_error'
+      elsif context.variable_map[result.object_id]
+        "eq(#{context.value_of(result)})"
       else
-        params << Pretentious::value_ize(arg, let_variables, declared_names)
+        "eq(#{Pretentious.value_ize(Pretentious::Context.new, result)})"
       end
-
     end
-    params.join(", ")
-  end
 
-  def self.location(output_folder)
-    output_folder.nil? ? "spec" : File.join(output_folder, "spec" )
-  end
+    def self.location(output_folder)
+      output_folder.nil? ? 'spec' : File.join(output_folder, 'spec')
+    end
 
-  def self.naming(output_folder, klass)
-    klass_name_parts = klass.name.split('::')
-    last_part = klass_name_parts.pop
-    File.join(output_folder, "#{Pretentious::DdtUtils.to_underscore(last_part)}_spec.rb")
-  end
+    def self.naming(output_folder, klass)
+      klass_name_parts = klass.name.split('::')
+      last_part = klass_name_parts.pop
+      File.join(output_folder, "#{Pretentious::DdtUtils.to_underscore(last_part)}_spec.rb")
+    end
 
-  def self.helper(output_folder)
-    filename = File.join(output_folder,"spec_helper.rb")
-    unless File.exists?(filename)
-      File.open(filename, 'w') {
-          |f| f.write("#Place your requires here")
-      }
-      puts "#{filename}"
+    def self.helper(output_folder)
+      filename = File.join(output_folder, 'spec_helper.rb')
+      unless File.exist?(filename)
+        File.open(filename, 'w') { |f| f.write('# Place your requires here') }
+        puts "#{filename}"
+      end
     end
   end
 end