pretentious 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f2d6ae04a184a2d01faa3d4b57870c670ed7a2d
-  data.tar.gz: e901c224433743d694beae8e5824dd79dbda0e12
+  metadata.gz: 573e7785c064f86ac8001339041dbb8387cb6679
+  data.tar.gz: aae975ba4c83fba283e0758a456674b0c5f0b86d
 SHA512:
-  metadata.gz: f03e00d1f288a00205e8aa7318bf8abf90262ecd534d6ccf292d54014706147eb679a4a4859d4a339c8a877b08012b691dbc104728229d0f1472126abc7b0b00
-  data.tar.gz: 6be334899e32a59c1f5930ea885d40a7639c74623de6a19b63f017dc02838ae2130343288fcb3d372667fbf16c108fb367af5289a179095bca38f367653de7aa
+  metadata.gz: fb6534fe86d6865035b3f5e160275dbdd194094920afeba24157820a1a0fcd87c78cb78246fe8139440369b96b4120f201c27a9af58724c7a20b7876f7538e77
+  data.tar.gz: dd0b37c00a1375b4323dd3041c9f0ed866499a3b38a58c86b9b03cd9631fd254a76d7acd6c7c73a7def5ea6e303ce7e059bf303394e01968546b0fc6dc4de0d6

data/README.md

@@ -210,6 +210,9 @@ RSpec.describe Digest::MD5 do
 end
 ```
 
+Note: If your test subject is already part of a larger application and would like to capture behavior in the manner that
+the application uses it, please look at [Declarative Generation](#declarative-generation-without-using-example-files).
+
 ## Minitest
 
 The minitest test framework is also supported, simply use Pretentious.minitest_for instead
@@ -256,14 +259,16 @@ modifying source codes. This is useful for testing code embedded inside framewor
 "example" is already embedded inside existing code.
 
 For example lets say you want to generate tests for UserAuthenticaion that is used inside the
-login method inside the UsersController inside a rails app. You'd simply define like below:
+login method inside the UsersController inside a Rails app. You'd simply define like below:
 
 
 ```ruby
 # initializers/pretentious.rb
 
-Pretentious.on(UsersController).method_called(:login).spec_for(UserAuthentication) #RSPEC
-Pretentious.on(UsersController).method_called(:login, :logout, ...).minitest_for(UserAuthentication) #minitest
+if Rails.env.test? #IMPORTANT don't run this when you don't need it!
+  Pretentious.on(UsersController).method_called(:login).spec_for(UserAuthentication) #RSPEC
+  Pretentious.on(UsersController).method_called(:login, :logout, ...).minitest_for(UserAuthentication) #minitest
+end
 
 # spec files will be written to the project root
 ```
@@ -279,13 +284,17 @@ You can pass a block for manually handling the output, for example
 ```ruby
 # initializers/pretentious.rb
 
-Pretentious.on(UsersController).method_called(:login).spec_for(UserAuthentication) do |results|
-  puts results[UserAuthentication][:output]
+if Rails.env.test? #IMPORTANT don't run this when you don't need it!
+    Pretentious.on(UsersController).method_called(:login).spec_for(UserAuthentication) do |results|
+      puts results[UserAuthentication][:output]
+    end
 end
 
 # spec files will be written to the project root
 ```
 
+IMPORTANT: If using rails or if it is part of a larger app, make sure to enable this only when you intend to generate specs!
+delete the initializer or comment the code out when it is not needed.
 
 ## Handling complex parameters and object constructors
 

data/bin/ddtgen

@@ -3,54 +3,48 @@
 require 'pretentious'
 require 'optparse'
 require 'ripper'
-require "readline"
+require 'readline'
 require 'json'
 require 'fileutils'
 
 # ddtgen example.rb -t rspec -o rspec/
 options = OptionParser.new do |o|
   o.banner =
-"Usage: ddtgen FILENAME [options] # Generates tests using the specified example file\n"
-  o.separator ""
+    "Usage: ddtgen FILENAME [options] # Generates tests using the specified example file\n"
+  o.separator ''
   o.separator "options:"
-  o.on('-o','--output-dir','folder to place the files in') { |b| $output_folder = b}
+  o.on('-o', '--output-dir', 'folder to place the files in') { |b| $output_folder = b}
   o.parse!
 end
 
-
 filename = ARGV[0]
 
 if filename.nil?
-  puts "an example file is required."
+  puts 'an example file is required.'
   puts options
   exit(1)
 end
 
-example_body = ""
+example_body = ''
 
 index = 0
 File.open(filename, "r") do |f|
   f.each_line do |line|
-     example_body << "#{line}\n"
+    example_body << "#{line}\n"
   end
 end
 
 eval(example_body, binding, filename, 1)
 
-#collect results
-
-
-Pretentious.last_results.each { |g, result_per_generator|
+# collect results
+Pretentious.last_results.each do |g, result_per_generator|
   puts "#{g}:"
-  result_per_generator.each { |klass, result|
+  result_per_generator.each do |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])
-    }
+    File.open(filename, 'w') { |f| f.write(result[:output]) }
     puts "#{filename}"
-  }
-}
-
+  end
+end

data/lib/pretentious.rb

@@ -1,15 +1,15 @@
-require "pretentious/version"
-require "pretentious/generator_base"
-require "pretentious/rspec_generator"
-require "pretentious/minitest_generator"
-require "pretentious/recorded_proc"
-require "pretentious/generator"
+require 'pretentious/version'
+require 'pretentious/context'
+require 'pretentious/generator_base'
+require 'pretentious/rspec_generator'
+require 'pretentious/minitest_generator'
+require 'pretentious/recorded_proc'
+require 'pretentious/generator'
 require 'binding_of_caller'
 require 'pretentious/deconstructor'
 require 'pretentious/trigger'
 
 Class.class_eval do
-
   def _stub(*classes)
     @classes = classes
     self
@@ -18,11 +18,9 @@ Class.class_eval do
   def _get_mock_classes
     @classes
   end
-
 end
 
 Thread.class_eval do
-
   def _push_context(context)
     @_context ||= []
     @_context << context
@@ -42,25 +40,27 @@ Thread.class_eval do
   end
 end
 
+# The main class to use for pretentious testing
 module Pretentious
-
+  # misc convenience tools
   module DdtUtils
     def self.to_underscore(str)
-      str.gsub(/(.)([A-Z])/,'\1_\2').downcase
+      str.gsub(/(.)([A-Z])/, '\1_\2').downcase
     end
   end
 
-
   def self.spec_for(*klasses, &block)
     @spec_results ||= {}
     Pretentious::Generator.test_generator = Pretentious::RspecGenerator
-    @spec_results.merge!(Pretentious::Generator.generate_for(*klasses, &block))
+    @spec_results.merge!(Pretentious::Generator
+                         .generate_for(*klasses, &block))
   end
 
   def self.minitest_for(*klasses, &block)
     @minitest_results ||= {}
     Pretentious::Generator.test_generator = Pretentious::MinitestGenerator
-    @minitest_results.merge!(Pretentious::Generator.generate_for(*klasses, &block))
+    @minitest_results.merge!(Pretentious::Generator
+                             .generate_for(*klasses, &block))
   end
 
   def self.clear_results
@@ -69,7 +69,7 @@ module Pretentious
   end
 
   def self.last_results
-    {spec: @spec_results,  minitest: @minitest_results}
+    { spec: @spec_results, minitest: @minitest_results }
   end
 
   def self.install_watcher
@@ -80,23 +80,23 @@ module Pretentious
     Pretentious::Generator.unwatch_new_instances
   end
 
-  def self.value_ize(value, let_variables, declared_names)
-    if (value.kind_of? String)
-      "#{value.dump}"
-    elsif (value.is_a? Symbol)
-      ":#{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"
-    elsif Pretentious::Deconstructor.is_primitive?(value)
-      "#{value.to_s}"
-    elsif let_variables && let_variables[value.object_id]
-      Pretentious::Deconstructor.pick_name(let_variables, value.object_id, declared_names)
+  def self.value_ize(context, value)
+    if value.is_a? String
+      "'#{value}'"
+    elsif value.is_a? Symbol
+      ":#{value}"
+    elsif value.is_a? Hash
+      context.pick_name(value.object_id)
+    elsif value.is_a? Pretentious::RecordedProc
+      context.pick_name(value.target_proc.object_id)
+    elsif value.nil?
+      'nil'
+    elsif Pretentious::Deconstructor.primitive?(value)
+      "#{value}"
+    elsif context.variable_map && context.variable_map[value.object_id]
+      context.pick_name(value.object_id)
     else
-      "#{value.to_s}"
+      "#{value}"
     end
   end
 

data/lib/pretentious/context.rb

@@ -0,0 +1,86 @@
+module Pretentious
+  # Contains references to scoped variables
+  class Context
+    attr_accessor :declared_names, :variable_map,
+                  :previous_declarations
+
+    def initialize(variable_map = {}, declared_names = {}, previous_declarations = {})
+      @declared_names = declared_names
+      @variable_map = variable_map
+      @previous_declarations = previous_declarations
+    end
+
+    def subcontext(declarations)
+      previous_declarations = {}
+
+      declarations.select { |d| d[:used_by] != :inline }.each do |d|
+        previous_declarations[d[:id]] = pick_name(d[:id])
+      end
+
+      Pretentious::Context.new(@variable_map, {}, previous_declarations)
+    end
+
+    def was_declared_previously?(object_id)
+      @previous_declarations.key? object_id
+    end
+
+    def merge_variable_map(target_object)
+      @variable_map.merge!(target_object._variable_map) if target_object.methods.include?(:_variable_map) && !target_object._variable_map.nil?
+    end
+
+    def register_instance_variable(object_id)
+      @variable_map[object_id] = "@#{@previous_declarations[object_id]}" if @previous_declarations[object_id][0]!='@'
+    end
+
+    def register(object_id, name)
+      @variable_map[object_id] = name
+    end
+
+    def dump
+      puts "v-map #{@variable_map.inspect}"
+      puts "d-map #{@declared_names.inspect}"
+      puts "p-map #{@previous_declarations.inspect}"
+    end
+
+    def pick_name(object_id, value = :no_value_passed)
+      var_name = "var_#{object_id}"
+
+      object_id_to_declared_names = {}
+
+      if @declared_names
+        @declared_names.each { |k, v| object_id_to_declared_names[v[:object_id]] = k if v }
+      end
+      # return immediately if already mapped
+      return object_id_to_declared_names[object_id] if object_id_to_declared_names.include? object_id
+
+      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 }
+        else
+
+          if @declared_names[candidate_name][:object_id] == object_id
+            var_name = candidate_name
+          else
+            new_name = "#{candidate_name}_#{@declared_names[candidate_name][:count]}"
+            var_name = "#{new_name}"
+
+            @declared_names[candidate_name][:count] += 1
+            @declared_names[new_name] = { count: 1, object_id: object_id }
+          end
+
+        end
+      else
+        return value_of(value) if value != :no_value_passed
+      end
+
+      var_name
+    end
+
+    def value_of(value)
+      Pretentious.value_ize(self, value)
+    end
+  end
+end

data/lib/pretentious/deconstructor.rb

@@ -1,446 +1,383 @@
-class Pretentious::Deconstructor
-
-  class UnResolved
-
-    attr_accessor :target_object
-
-    def initialize(object)
-      @target_object = object
+module Pretentious
+  # Deconstructor - decompose an object into its parts
+  class Deconstructor
+    # Represents an unresolved class
+    class UnResolved
+      attr_accessor :target_object
+
+      def initialize(object)
+        @target_object = object
+      end
     end
-  end
-
-  class Reference
-    attr_accessor :tree
 
-    def initialize(tree)
-      @tree = tree
-    end
-  end
+    # Represents a reference
+    class Reference
+      attr_accessor :tree
 
-  def dfs_array(arr, refs)
-    value = []
-    arr.each { |v|
-      if Pretentious::Deconstructor.is_primitive?(v)
-        value << v
-      elsif v.is_a? Hash
-        value << dfs_hash(v, refs)
-      elsif v.is_a? Array
-        value << dfs_array(v, refs)
-      elsif v.is_a? Reference
-        refs << v.tree[:id]
-        value << Reference.new(dfs(v.tree))
-      elsif value << v
+      def initialize(tree)
+        @tree = tree
       end
-    }
-    value
-  end
+    end
 
-  def dfs_hash(hash, refs)
-    value = {}
-    hash.each { |k, v|
-      if Pretentious::Deconstructor.is_primitive?(v)
-        value[k] = v
-      elsif v.is_a? Hash
-        value[k] = dfs_hash(v, refs)
-      elsif v.is_a? Array
-        value[k] = dfs_array(v, refs)
-      elsif v.is_a? Reference
-        refs << v.tree[:id]
-        value[k] = Reference.new(dfs(v.tree))
-      else
-        value[k] = v
+    def dfs_array(arr, refs)
+      value = []
+      arr.each do |v|
+        if Pretentious::Deconstructor.primitive?(v)
+          value << v
+        elsif v.is_a? Hash
+          value << dfs_hash(v, refs)
+        elsif v.is_a? Array
+          value << dfs_array(v, refs)
+        elsif v.is_a? Reference
+          refs << v.tree[:id]
+          value << Reference.new(dfs(v.tree))
+        elsif value << v
+        end
       end
-    }
-    value
-  end
+      value
+    end
 
-  def dfs(tree)
-    if !tree.is_a? Hash
-      value = tree
-      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
+    def dfs_hash(hash, refs)
+      value = {}
+      hash.each do |k, v|
+        if Pretentious::Deconstructor.primitive?(v)
+          value[k] = v
+        elsif v.is_a? Hash
+          value[k] = dfs_hash(v, refs)
+        elsif v.is_a? Array
+          value[k] = dfs_array(v, refs)
+        elsif v.is_a? Reference
+          refs << v.tree[:id]
+          value[k] = Reference.new(dfs(v.tree))
+        else
+          value[k] = v
+        end
       end
-      value.object_id
-    else
-      ref = []
-
-      definition = {id: tree[:id], class: tree[:class], params_types: tree[:params_types], used_by: []}
+      value
+    end
 
-      if tree[:class] == Hash
-        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]
+    def dfs(tree)
+      if !tree.is_a? Hash
+        value = tree
+        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
+        end
+        value.object_id
+      else
+        ref = []
+
+        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)
+        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
 
-        if (!tree[:composition].nil?)
-          ref << dfs(tree[:composition])
+        elsif tree[:composition].is_a? Array
+          tree[:composition].each { |t| ref << dfs(t) }
         else
-          dfs(tree[:composition])
+          ref << dfs(tree[:composition])
         end
 
-      elsif tree[:composition].is_a? Array
-        tree[:composition].each { |t|
-          ref << dfs(t)
-        }
-      else
-        ref << dfs(tree[:composition])
-      end
+        # evaluate given block composition
+        ref << dfs(tree[:block]) if tree[:block]
 
-      #evaluate given block composition
-      if (tree[:block])
-        ref << dfs(tree[:block])
-      end
+        definition[:ref] = ref
 
-      definition[:ref] = ref
+        unless @dependencies.include? tree[:id]
+          @declaration_order << definition
+          @dependencies[tree[:id]] = definition
 
-      unless (@dependencies.include? tree[:id])
-        @declaration_order << definition
-        @dependencies[tree[:id]] = definition
+          ref.each { |r| @dependencies[r][:used_by] << definition }
+        end
 
-        ref.each { |r|
-          @dependencies[r][:used_by] << definition
-        }
+        tree[:id]
       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
+    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
-  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
+    def inline
+      @dependencies.each do |id, definition|
+        next if definition[:used_by].size != 1
+        next if !definition.include?(:value) || !self.class.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
-
-  #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?
-        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
+    end
 
-        if (self.class.is_primitive?(target_object))
-          tree[:composition] = target_object
-        elsif (target_object.class == File)
-          tree[:composition] << build_tree(target_object.path)
+    # 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
+        if args.nil?
+          if self.class.primitive?(target_object)
+            tree[:composition] = target_object
+          elsif target_object.class == File
+            tree[:composition] << build_tree(target_object.path)
+          else
+            tree[:composition] = UnResolved.new(target_object)
+          end
         else
-          tree[:composition] = UnResolved.new(target_object)
+          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?
         end
-      end
 
-    else
-      tree[:composition] = target_object
+      else
+        tree[:composition] = target_object
+      end
+      tree
     end
-    tree
-  end
 
+    def deconstruct(method_call_collection, *target_objects)
+      @declaration_order = []
+      @dependencies = {}
 
-  def deconstruct(method_call_collection, *target_objects)
+      target_objects.each do |target_object|
+        tree = build_tree target_object
+        dfs(tree)
+      end
 
-    @declaration_order = []
-    @dependencies = {}
+      method_call_collection.each do |m|
+        update_ref_counts(m[:params], m)
+      end
 
-    target_objects.each { |target_object|
-      tree = build_tree target_object
-      dfs(tree)
-    }
+      inline
 
-    method_call_collection.each do |m|
-      update_ref_counts(m[:params], m)
+      { declaration: @declaration_order, dependency: @dependencies }
     end
 
-    inline
-
-    {declaration: @declaration_order, dependency: @dependencies}
-  end
-
-  def generate_declarations(variable_map = {}, previous_declarations = {}, method_call_collection = [], *target_objects)
-    target_objects.each { |target_object|
-      variable_map.merge!(target_object._variable_map) if target_object.methods.include?(:_variable_map) && !target_object._variable_map.nil?
-    }
-    deconstruct method_call_collection, *target_objects
-  end
-
-  def build_output(indentation_level, variable_map, declarations, declared_names, previous_declarations)
-    output_buffer = ""
-    indentation = ""
-
-    indentation_level.times {
-      indentation << ' '
-    }
-
-    declarations[:declaration].each do |d|
-      if (d[:used_by] != :inline) && !previous_declarations.has_key?(d[:id])
-        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"
-      elsif (d[:used_by]!=:inline) && previous_declarations[d[:id]]
-        variable_map[d[:id]] = "@#{previous_declarations[d[:id]]}" if previous_declarations[d[:id]][0]!='@'
+    def generate_declarations(context, method_call_collection, *target_objects)
+      target_objects.each do |target_object|
+        context.merge_variable_map(target_object)
       end
+      deconstruct method_call_collection, *target_objects
     end
-    output_buffer
-  end
 
-  def deconstruct_to_ruby(indentation_level = 0, variable_map = {}, declared_names = {}, previous_declarations = {}, method_call_collection = [], *target_objects)
-    declarations, dependencies = generate_declarations variable_map, previous_declarations, method_call_collection, *target_objects
-    build_output(indentation_level, variable_map, declarations, declared_names, previous_declarations)
-  end
-
-  def self.is_primitive?(value)
-    value.is_a?(String) || value.is_a?(Fixnum) || value.is_a?(TrueClass) || value.is_a?(FalseClass) ||
-        value.is_a?(NilClass) || value.is_a?(Symbol) || value.is_a?(Class)
-  end
+    def build_output(context, indentation_level, declarations)
+      output_buffer = ''
+      indentation = ''
+      indentation_level.times { indentation << ' ' }
+      declarations[:declaration].select { |d| d[:used_by] != :inline }.each do |d|
+        if !context.was_declared_previously?(d[:id])
+          var_name = context.pick_name(d[:id])
+          output_buffer << "#{indentation}#{var_name} = #{construct(context, d, indentation)}\n"
+        elsif context.was_declared_previously?(d[:id])
+          context.register_instance_variable(d[:id])
+        end
+      end
+      output_buffer
+    end
 
-  def self.block_param_names(proc)
-    parameters_to_join = []
+    def deconstruct_to_ruby(context, indentation_level = 0, *target_objects)
+      declarations, _dependencies = generate_declarations context, [], *target_objects
+      build_output(context, indentation_level, declarations)
+    end
 
-    parameters = proc.target_proc.parameters
+    def self.primitive?(value)
+      value.is_a?(String) || value.is_a?(Fixnum) || value.is_a?(TrueClass) || value.is_a?(FalseClass) ||
+      value.is_a?(NilClass) || value.is_a?(Symbol) || value.is_a?(Class)
+    end
 
-    parameters.each { |p|
-      parameters_to_join << p[1].to_s
-    }
-    parameters_to_join
-  end
+    def self.block_param_names(proc)
+      parameters_to_join = []
 
-  def self.block_params_generator(proc, separator = '|')
+      parameters = proc.target_proc.parameters
 
-    if (proc.target_proc.parameters.size > 0)
-      return "#{separator}#{block_param_names(proc).join(', ')}#{separator}"
+      parameters.each { |p| parameters_to_join << p[1].to_s }
+      parameters_to_join
     end
 
-    return ''
-  end
+    def self.block_params_generator(proc, separator = '|')
+      if proc.target_proc.parameters.size > 0
+        return "#{separator}#{block_param_names(proc).join(', ')}#{separator}"
+      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
+      ''
+    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"
+    def proc_to_ruby(context, proc, indentation = '')
+      output_buffer = ''
+      output_buffer << "proc { #{self.class.block_params_generator(proc)}\n"
+      output_buffer << self.class.proc_body(context, proc, indentation)
+      output_buffer << "#{indentation}}\n"
+      output_buffer
     end
-  end
 
-  def deconstruct_array(array)
-    composition = []
-    array.each { |v|
-      if (Pretentious::Deconstructor.is_primitive?(v))
-        composition << v
-      elsif v.is_a? Hash
-        composition << deconstruct_hash(v)
-      elsif v.is_a? Array
-        composition << deconstruct_array(v)
+    def self.proc_body(context, proc, indentation = '')
+      if proc.return_value.size == 1
+        "#{indentation}  #{context.value_of(proc.return_value[0])}\n"
       else
-        composition << Reference.new(build_tree(v))
+        "#{indentation}  \# Variable return values ... can't figure out what goes in here...\n"
       end
-    }
-    composition
-  end
+    end
 
-  def deconstruct_hash(hash)
-    composition = {}
-    hash.each { |k, v|
-      if (Pretentious::Deconstructor.is_primitive?(v))
-        composition[k] = v
-      elsif v.is_a? Hash
-        composition[k] = deconstruct_hash(v)
-      elsif v.is_a? Array
-        composition[k] = deconstruct_array(v)
-      else
-        composition[k] = Reference.new(build_tree(v))
+    def deconstruct_array(array)
+      composition = []
+      array.each do |v|
+        if Pretentious::Deconstructor.primitive?(v)
+          composition << v
+        elsif v.is_a? Hash
+          composition << deconstruct_hash(v)
+        elsif v.is_a? Array
+          composition << deconstruct_array(v)
+        else
+          composition << Reference.new(build_tree(v))
+        end
       end
-    }
-    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
+      composition
     end
-  end
-
-  def get_test_class(target_object)
-    target_object.respond_to?(:test_class) ? target_object.test_class : target_object.class
-  end
-
-
-  def self.pick_name(variable_map, object_id, declared_names = {}, value = :no_value_passed)
-    var_name = "var_#{object_id}"
 
-    object_id_to_declared_names = {}
-
-    declared_names.each { |k,v|
-      object_id_to_declared_names[v[:object_id]] = k if v
-    } if declared_names
-
-    #return immediately if already mapped
-    return object_id_to_declared_names[object_id] if (object_id_to_declared_names.include? object_id)
-
-    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}
-      else
-
-        if (declared_names[candidate_name][:object_id] == object_id)
-          var_name = candidate_name
+    def deconstruct_hash(hash)
+      composition = {}
+      hash.each do |k, v|
+        if Pretentious::Deconstructor.primitive?(v)
+          composition[k] = v
+        elsif v.is_a? Hash
+          composition[k] = deconstruct_hash(v)
+        elsif v.is_a? Array
+          composition[k] = deconstruct_array(v)
         else
-          new_name = "#{candidate_name}_#{declared_names[candidate_name][:count]}"
-          var_name = "#{new_name}"
-
-          declared_names[candidate_name][:count]+=1
-          declared_names[new_name] = {count: 1, object_id: object_id}
+          composition[k] = Reference.new(build_tree(v))
         end
-
-      end
-    else
-      if value != :no_value_passed
-        return Pretentious::value_ize(value, let_variables,  declared_names)
       end
+      composition
     end
 
-    var_name
-  end
-
-  private
+    def deconstruct_proc(proc)
+      return nil if proc.return_value.size != 1
+      return build_tree(proc.return_value[0]) unless proc.return_value[0].nil?
+    end
 
+    def get_test_class(target_object)
+      target_object.respond_to?(:test_class) ? target_object.test_class : target_object.class
+    end
 
-  def output_array(arr, variable_map, declared_names)
-    output_buffer = '['
-    array_elements = []
-    arr.each { |v|
-      value = Pretentious::value_ize(v, variable_map, declared_names)
-      if (v.is_a? Hash)
-        value = output_hash(v, variable_map, declared_names)
-      elsif (v.is_a? Array)
-        value = output_array(v, variable_map, declared_names)
-      elsif (v.is_a? Reference)
-        value = Pretentious::Deconstructor.pick_name(variable_map, v.tree, declared_names)
+    private
+
+    def output_array(context, arr)
+      output_buffer = '['
+      array_elements = []
+      arr.each do |v|
+        value = Pretentious.value_ize(context, v)
+        if v.is_a? Hash
+          value = output_hash(context, v)
+        elsif v.is_a? Array
+          value = output_array(context, v)
+        elsif v.is_a? Reference
+          value = context.pick_name(v.tree)
+        end
+        array_elements << value
       end
-      array_elements << value
-    }
-    output_buffer << array_elements.join(', ')
-    output_buffer << ']'
-    output_buffer
-  end
+      output_buffer << array_elements.join(', ')
+      output_buffer << ']'
+      output_buffer
+    end
 
-  def output_hash(hash, variable_map, declared_names)
-    output_buffer = '{'
-    hash_elements = []
-    hash.each { |k, v|
-      value = Pretentious::value_ize(v, variable_map, declared_names)
-      if (v.is_a? Hash)
-        value = output_hash(v, variable_map, declared_names)
-      elsif (v.is_a? Array)
-        value = output_array(v, variable_map, declared_names)
-      elsif (v.is_a? Reference)
-        value = Pretentious::Deconstructor.pick_name(variable_map, v.tree, declared_names)
-      end
+    def output_hash(context, hash)
+      output_buffer = '{ '
+      hash_elements = []
+      hash.each do |k, v|
+        value = context.value_of(v)
+        if v.is_a? Hash
+          value = output_hash(context, v)
+        elsif v.is_a? Array
+          value = output_array(context, v)
+        elsif v.is_a? Reference
+          value = context.pick_name(v.tree)
+        end
 
-      if (k.is_a? Symbol)
-        hash_elements << "#{k}: #{value}"
-      else
-        hash_elements << "#{Pretentious::value_ize(k, variable_map, declared_names)} => #{value}"
+        if k.is_a? Symbol
+          hash_elements << "#{k}: #{value}"
+        else
+          hash_elements << "#{context.value_of(k)} => #{value}"
+        end
       end
-    }
-    output_buffer << hash_elements.join(', ')
-    output_buffer << '}'
-    output_buffer
-  end
+      output_buffer << hash_elements.join(', ')
+      output_buffer << ' }'
+      output_buffer
+    end
 
-  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)
-        output_array(definition[:value], variable_map, declared_names)
-      elsif (definition[:value].is_a? UnResolved)
-        'nil #parameters unresolvable. cannot decompose'
+    def construct(context, definition, indentation = '')
+      if definition.include? :value
+        if definition[:value].is_a? Hash
+          output_hash(context, definition[:value])
+        elsif definition[:value].is_a? Array
+          output_array(context, definition[:value])
+        elsif definition[:value].is_a? UnResolved
+          'nil #parameters unresolvable. cannot decompose'
+        else
+          context.value_of(definition[:value])
+        end
+      elsif definition[:class] == Pretentious::RecordedProc
+        proc_to_ruby(context, definition[:recorded_proc], indentation)
       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] && definition[:ref].size > 0)
-
-        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
+        params = []
+        if definition[:ref] && definition[:ref].size > 0
+
+          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)}"
+            # to inline?
+            if v.is_a? Hash
+              params << context.value_of(v[:value])
             else
-              params << Pretentious::Deconstructor.pick_name(variable_map, v, declared_names)
+              params << (type == :block ? "&#{context.pick_name(v)}" : context.pick_name(v))
             end
           end
+          "#{definition[:class]}.new(#{params.join(', ')})"
+        else
+          "#{definition[:class]}.new"
         end
-        "#{definition[:class]}.new(#{params.join(', ')})"
-      else
-        "#{definition[:class]}.new"
-      end
 
+      end
     end
-  end
 
-end
+  end
+end