diff --git a/lib/puppet/face/module/install.rb b/lib/puppet/face/module/install.rb
index 39aab0276..c3e0754eb 100644
--- a/lib/puppet/face/module/install.rb
+++ b/lib/puppet/face/module/install.rb
@@ -1,173 +1,173 @@
 # encoding: UTF-8
 
 Puppet::Face.define(:module, '1.0.0') do
   action(:install) do
     summary "Install a module from a repository or release archive."
     description <<-EOT
       Installs a module from the Puppet Forge, from a release archive file
       on-disk, or from a private Forge-like repository.
 
       The specified module will be installed into the directory
       specified with the `--target-dir` option, which defaults to
       #{Puppet.settings[:modulepath].split(File::PATH_SEPARATOR).first}.
     EOT
 
     returns "Pathname object representing the path to the installed module."
 
     examples <<-EOT
       Install a module:
 
       $ puppet module install puppetlabs-vcsrepo
       Preparing to install into /etc/puppet/modules ...
       Downloading from http://forge.puppetlabs.com ...
       Installing -- do not interrupt ...
       /etc/puppet/modules
       └── puppetlabs-vcsrepo (v0.0.4)
 
       Install a module to a specific environment:
 
       $ puppet module install puppetlabs-vcsrepo --environment development
       Preparing to install into /etc/puppet/environments/development/modules ...
       Downloading from http://forge.puppetlabs.com ...
       Installing -- do not interrupt ...
       /etc/puppet/environments/development/modules
       └── puppetlabs-vcsrepo (v0.0.4)
 
       Install a specific module version:
 
       $ puppet module install puppetlabs-vcsrepo -v 0.0.4
       Preparing to install into /etc/puppet/modules ...
       Downloading from http://forge.puppetlabs.com ...
       Installing -- do not interrupt ...
       /etc/puppet/modules
       └── puppetlabs-vcsrepo (v0.0.4)
 
       Install a module into a specific directory:
 
       $ puppet module install puppetlabs-vcsrepo --target-dir=/usr/share/puppet/modules
       Preparing to install into /usr/share/puppet/modules ...
       Downloading from http://forge.puppetlabs.com ...
       Installing -- do not interrupt ...
       /usr/share/puppet/modules
       └── puppetlabs-vcsrepo (v0.0.4)
 
       Install a module into a specific directory and check for dependencies in other directories:
 
       $ puppet module install puppetlabs-vcsrepo --target-dir=/usr/share/puppet/modules --modulepath /etc/puppet/modules
       Preparing to install into /usr/share/puppet/modules ...
       Downloading from http://forge.puppetlabs.com ...
       Installing -- do not interrupt ...
       /usr/share/puppet/modules
       └── puppetlabs-vcsrepo (v0.0.4)
 
       Install a module from a release archive:
 
       $ puppet module install puppetlabs-vcsrepo-0.0.4.tar.gz
       Preparing to install into /etc/puppet/modules ...
       Downloading from http://forge.puppetlabs.com ...
       Installing -- do not interrupt ...
       /etc/puppet/modules
       └── puppetlabs-vcsrepo (v0.0.4)
 
       Install a module from a release archive and ignore dependencies:
 
       $ puppet module install puppetlabs-vcsrepo-0.0.4.tar.gz --ignore-dependencies
       Preparing to install into /etc/puppet/modules ...
       Installing -- do not interrupt ...
       /etc/puppet/modules
       └── puppetlabs-vcsrepo (v0.0.4)
 
     EOT
 
     arguments "<name>"
 
     option "--force", "-f" do
       summary "Force overwrite of existing module, if any."
       description <<-EOT
         Force overwrite of existing module, if any.
       EOT
     end
 
     option "--target-dir DIR", "-i DIR" do
       summary "The directory into which modules are installed."
       description <<-EOT
         The directory into which modules are installed; defaults to the first
         directory in the modulepath.
 
         Specifying this option will change the installation directory, and
         will use the existing modulepath when checking for dependencies. If
         you wish to check a different set of directories for dependencies, you
         must also use the `--environment` or `--modulepath` options.
       EOT
     end
 
     option "--ignore-dependencies" do
       summary "Do not attempt to install dependencies"
       description <<-EOT
         Do not attempt to install dependencies.
       EOT
     end
 
     option "--modulepath MODULEPATH" do
       default_to { Puppet.settings[:modulepath] }
       summary "Which directories to look for modules in"
       description <<-EOT
         The list of directories to check for modules. When installing a new
         module, this setting determines where the module tool will look for
         its dependencies. If the `--target dir` option is not specified, the
         first directory in the modulepath will also be used as the install
         directory.
 
         When installing a module into an environment whose modulepath is
         specified in puppet.conf, you can use the `--environment` option
         instead, and its modulepath will be used automatically.
 
         This setting should be a list of directories separated by the path
         separator character. (The path separator is `:` on Unix-like platforms
         and `;` on Windows.)
       EOT
     end
 
     option "--version VER", "-v VER" do
       summary "Module version to install."
       description <<-EOT
         Module version to install; can be an exact version or a requirement string,
         eg '>= 1.0.3'. Defaults to latest version.
       EOT
     end
 
     option "--environment NAME" do
       default_to { "production" }
       summary "The target environment to install modules into."
       description <<-EOT
         The target environment to install modules into. Only applicable if
         multiple environments (with different modulepaths) have been
         configured in puppet.conf.
       EOT
     end
 
     when_invoked do |name, options|
       sep = File::PATH_SEPARATOR
       if options[:target_dir]
         options[:modulepath] = "#{options[:target_dir]}#{sep}#{options[:modulepath]}"
       end
 
       Puppet.settings[:modulepath] = options[:modulepath]
       options[:target_dir] = Puppet.settings[:modulepath].split(sep).first
 
       Puppet.notice "Preparing to install into #{options[:target_dir]} ..."
       Puppet::Module::Tool::Applications::Installer.run(name, options)
     end
 
     when_rendering :console do |return_value, name, options|
       if return_value[:result] == :failure
         Puppet.err(return_value[:error][:multiline])
         exit 1
       else
-        tree = Puppet::Module::Tool.format_tree(return_value[:installed_modules], return_value[:install_dir])
+        tree = Puppet::Module::Tool.build_tree(return_value[:installed_modules], return_value[:install_dir])
         return_value[:install_dir] + "\n" +
-        Puppet::Module::Tool.build_tree(tree)
+        Puppet::Module::Tool.format_tree(tree)
       end
     end
   end
 end
diff --git a/lib/puppet/face/module/list.rb b/lib/puppet/face/module/list.rb
index 2126474ed..e3acbd9ae 100644
--- a/lib/puppet/face/module/list.rb
+++ b/lib/puppet/face/module/list.rb
@@ -1,285 +1,285 @@
 # encoding: UTF-8
 
 Puppet::Face.define(:module, '1.0.0') do
   action(:list) do
     summary "List installed modules"
     description <<-HEREDOC
       Lists the installed puppet modules. By default, this action scans the
       modulepath from puppet.conf's `[main]` block; use the --modulepath
       option to change which directories are scanned.
 
       The output of this action includes information from the module's
       metadata, including version numbers and unmet module dependencies.
     HEREDOC
     returns "hash of paths to module objects"
 
     option "--environment NAME" do
       default_to { "production" }
       summary "Which environments' modules to list"
       description <<-EOT
         Which environments' modules to list.
       EOT
     end
 
     option "--modulepath MODULEPATH" do
       summary "Which directories to look for modules in"
       description <<-EOT
         Which directories to look for modules in; use the system path separator
         character (`:` on Unix-like systems and `;` on Windows) to specify
         multiple directories.
       EOT
     end
 
     option "--tree" do
       summary "Whether to show dependencies as a tree view"
     end
 
     examples <<-EOT
       List installed modules:
 
       $ puppet module list
         /etc/puppet/modules
         ├── bodepd-create_resources (v0.0.1)
         ├── puppetlabs-bacula (v0.0.2)
         ├── puppetlabs-mysql (v0.0.1)
         ├── puppetlabs-sqlite (v0.0.1)
         └── puppetlabs-stdlib (v2.2.1)
         /usr/share/puppet/modules (no modules installed)
 
       List installed modules in a tree view:
 
       $ puppet module list --tree
         /etc/puppet/modules
         └─┬ puppetlabs-bacula (v0.0.2)
           ├── puppetlabs-stdlib (v2.2.1)
           ├─┬ puppetlabs-mysql (v0.0.1)
           │ └── bodepd-create_resources (v0.0.1)
           └── puppetlabs-sqlite (v0.0.1)
         /usr/share/puppet/modules (no modules installed)
 
       List installed modules from a specified environment:
 
       $ puppet module list --environment production
         /etc/puppet/modules
         ├── bodepd-create_resources (v0.0.1)
         ├── puppetlabs-bacula (v0.0.2)
         ├── puppetlabs-mysql (v0.0.1)
         ├── puppetlabs-sqlite (v0.0.1)
         └── puppetlabs-stdlib (v2.2.1)
         /usr/share/puppet/modules (no modules installed)
 
       List installed modules from a specified modulepath:
 
       $ puppet module list --modulepath /usr/share/puppet/modules
         /usr/share/puppet/modules (no modules installed)
     EOT
 
     when_invoked do |options|
       Puppet[:modulepath] = options[:modulepath] if options[:modulepath]
       environment = Puppet::Node::Environment.new(options[:environment])
 
       environment.modules_by_path
     end
 
     when_rendering :console do |modules_by_path, options|
       output = ''
 
       Puppet[:modulepath] = options[:modulepath] if options[:modulepath]
       environment = Puppet::Node::Environment.new(options[:production])
 
       error_types = {
         :non_semantic_version => {
           :title => "Non semantic version dependency"
         },
         :missing => {
           :title => "Missing dependency"
         },
         :version_mismatch => {
           :title => "Module '%s' (v%s) fails to meet some dependencies:"
         }
       }
 
       @unmet_deps = {}
       error_types.each_key do |type|
         @unmet_deps[type] = Hash.new do |hash, key|
           hash[key] = { :errors => [], :parent => nil }
         end
       end
 
       # Prepare the unmet dependencies for display on the console.
       environment.modules.sort_by {|mod| mod.name}.each do |mod|
         unmet_grouped = Hash.new { |h,k| h[k] = [] }
         unmet_grouped = mod.unmet_dependencies.inject(unmet_grouped) do |acc, dep|
           acc[dep[:reason]] << dep
           acc
         end
         unmet_grouped.each do |type, deps|
           unless deps.empty?
             unmet_grouped[type].sort_by { |dep| dep[:name] }.each do |dep|
               dep_name           = dep[:name].gsub('/', '-')
               installed_version  = dep[:mod_details][:installed_version]
               version_constraint = dep[:version_constraint]
               parent_name        = dep[:parent][:name].gsub('/', '-')
               parent_version     = dep[:parent][:version]
 
               msg = "'#{parent_name}' (#{parent_version})"
               msg << " requires '#{dep_name}' (#{version_constraint})"
               @unmet_deps[type][dep[:name]][:errors] << msg
               @unmet_deps[type][dep[:name]][:parent] = {
                 :name    => dep[:parent][:name],
                 :version => parent_version
               }
               @unmet_deps[type][dep[:name]][:version] = installed_version
             end
           end
         end
       end
 
       # Display unmet dependencies by category.
       error_display_order = [:non_semantic_version, :version_mismatch, :missing]
       error_display_order.each do |type|
         unless @unmet_deps[type].empty?
           @unmet_deps[type].keys.sort_by {|dep| dep }.each do |dep|
             name    = dep.gsub('/', '-')
             title   = error_types[type][:title]
             errors  = @unmet_deps[type][dep][:errors]
             version = @unmet_deps[type][dep][:version]
 
             msg = case type
                   when :version_mismatch
                     title % [name, version] + "\n"
                   when :non_semantic_version
                     title + " '#{name}' (v#{version}):\n"
                   else
                     title + " '#{name}':\n"
                   end
 
             errors.each { |error_string| msg << "  #{error_string}\n" }
             Puppet.warning msg.chomp
           end
         end
       end
 
       environment.modulepath.each do |path|
         modules = modules_by_path[path]
         no_mods = modules.empty? ? ' (no modules installed)' : ''
         output << "#{path}#{no_mods}\n"
 
         if options[:tree]
           # The modules with fewest things depending on them will be the
           # parent of the tree.  Can't assume to start with 0 dependencies
           # since dependencies may be cyclical.
           modules_by_num_requires = modules.sort_by {|m| m.required_by.size}
           @seen = {}
-          tree = list_format_tree(modules_by_num_requires, [], nil,
+          tree = list_build_tree(modules_by_num_requires, [], nil,
             :label_unmet => true, :path => path, :label_invalid => false)
         else
           tree = []
           modules.sort_by { |mod| mod.forge_name or mod.name  }.each do |mod|
-            tree << list_format_node(mod, path, :label_unmet => false,
+            tree << list_build_node(mod, path, :label_unmet => false,
                       :path => path, :label_invalid => true)
           end
         end
 
-        output << Puppet::Module::Tool.build_tree(tree)
+        output << Puppet::Module::Tool.format_tree(tree)
       end
 
       output
     end
   end
 
   # Prepare a list of module objects and their dependencies for print in a
   # tree view.
   #
   # Returns an Array of Hashes
   #
   # Example:
   #
   #   [
   #     {
   #       :text => "puppetlabs-bacula (v0.0.2)",
   #       :dependencies=> [
   #         { :text => "puppetlabs-stdlib (v2.2.1)", :dependencies => [] },
   #         {
   #           :text => "puppetlabs-mysql (v1.0.0)"
   #           :dependencies => [
   #             {
   #               :text => "bodepd-create_resources (v0.0.1)",
   #               :dependencies => []
   #             }
   #           ]
   #         },
   #         { :text => "puppetlabs-sqlite (v0.0.1)", :dependencies => [] },
   #       ]
   #     }
   #   ]
   #
   # When the above data structure is passed to Puppet::Module::Tool.build_tree
   # you end up with something like this:
   #
   #   /etc/puppet/modules
   #   └─┬ puppetlabs-bacula (v0.0.2)
   #     ├── puppetlabs-stdlib (v2.2.1)
   #     ├─┬ puppetlabs-mysql (v1.0.0)
   #     │ └── bodepd-create_resources (v0.0.1)
   #     └── puppetlabs-sqlite (v0.0.1)
   #
-  def list_format_tree(list, ancestors=[], parent=nil, params={})
+  def list_build_tree(list, ancestors=[], parent=nil, params={})
     list.map do |mod|
       next if @seen[(mod.forge_name or mod.name)]
-      node = list_format_node(mod, parent, params)
+      node = list_build_node(mod, parent, params)
       @seen[(mod.forge_name or mod.name)] = true
 
       unless ancestors.include?(mod)
         node[:dependencies] ||= []
         missing_deps = mod.unmet_dependencies.select do |dep|
           dep[:reason] == :missing
         end
         missing_deps.map do |mis_mod|
           str = "#{colorize(:bg_red, 'UNMET DEPENDENCY')} #{mis_mod[:name].gsub('/', '-')} "
           str << "(#{colorize(:cyan, mis_mod[:version_constraint])})"
           node[:dependencies] << { :text => str }
         end
-        node[:dependencies] += list_format_tree(mod.dependencies_as_modules,
+        node[:dependencies] += list_build_tree(mod.dependencies_as_modules,
           ancestors + [mod], mod, params)
       end
 
       node
     end.compact
   end
 
   # Prepare a module object for print in a tree view.  Each node in the tree
   # must be a Hash in the following format:
   #
   #    { :text => "puppetlabs-mysql (v1.0.0)" }
   #
   # The value of a module's :text is affected by three (3) factors: the format
   # of the tree, it's dependency status, and the location in the modulepath
   # relative to it's parent.
   #
   # Returns a Hash
   #
-  def list_format_node(mod, parent, params)
+  def list_build_node(mod, parent, params)
     str = ''
     str << (mod.forge_name ? mod.forge_name.gsub('/', '-') : mod.name)
     str << ' (' + colorize(:cyan, mod.version ? "v#{mod.version}" : '???') + ')'
 
     unless File.dirname(mod.path) == params[:path]
       str << " [#{File.dirname(mod.path)}]"
     end
 
     if @unmet_deps[:version_mismatch].include?(mod.forge_name)
       if params[:label_invalid]
         str << '  ' + colorize(:red, 'invalid')
       elsif parent.respond_to?(:forge_name)
         unmet_parent = @unmet_deps[:version_mismatch][mod.forge_name][:parent]
         if (unmet_parent[:name] == parent.forge_name &&
             unmet_parent[:version] == "v#{parent.version}")
           str << '  ' + colorize(:red, 'invalid')
         end
       end
     end
 
     { :text => str }
   end
 end
diff --git a/lib/puppet/face/module/upgrade.rb b/lib/puppet/face/module/upgrade.rb
index eac79c185..e62a7c535 100644
--- a/lib/puppet/face/module/upgrade.rb
+++ b/lib/puppet/face/module/upgrade.rb
@@ -1,84 +1,84 @@
 # encoding: UTF-8
 
 Puppet::Face.define(:module, '1.0.0') do
   action(:upgrade) do
     summary "Upgrade a puppet module."
     description <<-EOT
       Upgrades a puppet module.
     EOT
 
     returns "Hash"
 
     examples <<-EOT
       upgrade an installed module to the latest version
 
       $ puppet module upgrade puppetlabs-apache
       /etc/puppet/modules
       └── puppetlabs-apache (v1.0.0 -> v2.4.0)
 
       upgrade an installed module to a specific version
 
       $ puppet module upgrade puppetlabs-apache --version 2.1.0
       /etc/puppet/modules
       └── puppetlabs-apache (v1.0.0 -> v2.1.0)
 
       upgrade an installed module for a specific environment
 
       $ puppet module upgrade puppetlabs-apache --environment test
       /usr/share/puppet/environments/test/modules
       └── puppetlabs-apache (v1.0.0 -> v2.4.0)
     EOT
 
     arguments "<name>"
 
     option "--force", "-f" do
       summary "Force upgrade of an installed module."
       description <<-EOT
         Force the upgrade of an installed module even if there are local
         changes or the possibility of causing broken dependencies.
       EOT
     end
 
     option "--ignore-dependencies" do
       summary "Do not attempt to install dependencies."
       description <<-EOT
         Do not attempt to install dependencies
       EOT
     end
 
     option "--environment NAME" do
       default_to { "production" }
       summary "The target environment to search for modules."
       description <<-EOT
         The target environment to search for modules.
       EOT
     end
 
     option "--version=" do
       summary "The version of the module to upgrade to."
       description <<-EOT
         The version of the module to upgrade to.
       EOT
     end
 
     when_invoked do |name, options|
       name = name.gsub('/', '-')
       Puppet.notice "Preparing to upgrade '#{name}' ..."
       Puppet::Module::Tool::Applications::Upgrader.new(name, options).run
     end
 
     when_rendering :console do |return_value|
       if return_value[:result] == :failure
         Puppet.err(return_value[:error][:multiline])
         exit 1
       elsif return_value[:result] == :noop
         Puppet.err(return_value[:error][:multiline])
         exit 0
       else
-        tree = Puppet::Module::Tool.format_tree(return_value[:affected_modules], return_value[:base_dir])
+        tree = Puppet::Module::Tool.build_tree(return_value[:affected_modules], return_value[:base_dir])
         return_value[:base_dir] + "\n" +
-        Puppet::Module::Tool.build_tree(tree)
+        Puppet::Module::Tool.format_tree(tree)
       end
     end
   end
 end
diff --git a/lib/puppet/module_tool.rb b/lib/puppet/module_tool.rb
index 6ac1eb9e5..a05ac8e3a 100644
--- a/lib/puppet/module_tool.rb
+++ b/lib/puppet/module_tool.rb
@@ -1,101 +1,101 @@
 # encoding: UTF-8
 # Load standard libraries
 require 'pathname'
 require 'fileutils'
 require 'puppet/util/colors'
 
 # Define tool
 module Puppet
   class Module
     module Tool
       extend Puppet::Util::Colors
 
       # Directory and names that should not be checksummed.
       ARTIFACTS = ['pkg', /^\./, /^~/, /^#/, 'coverage', 'metadata.json', 'REVISION']
       FULL_MODULE_NAME_PATTERN = /\A([^-\/|.]+)[-|\/](.+)\z/
       REPOSITORY_URL = Puppet.settings[:module_repository]
 
       # Is this a directory that shouldn't be checksummed?
       #
       # TODO: Should this be part of Checksums?
       # TODO: Rename this method to reflect it's purpose?
       # TODO: Shouldn't this be used when building packages too?
       def self.artifact?(path)
         case File.basename(path)
         when *ARTIFACTS
           true
         else
           false
         end
       end
 
       # Return the +username+ and +modname+ for a given +full_module_name+, or raise an
       # ArgumentError if the argument isn't parseable.
       def self.username_and_modname_from(full_module_name)
         if matcher = full_module_name.match(FULL_MODULE_NAME_PATTERN)
           return matcher.captures
         else
           raise ArgumentError, "Not a valid full name: #{full_module_name}"
         end
       end
 
       def self.find_module_root(path)
         for dir in [path, Dir.pwd].compact
           if File.exist?(File.join(dir, 'Modulefile'))
             return dir
           end
         end
         raise ArgumentError, "Could not find a valid module at #{path ? path.inspect : 'current directory'}"
       end
 
       # Builds a formatted tree from a list of node hashes containing +:text+
       # and +:dependencies+ keys.
-      def self.build_tree(nodes, level = 0)
+      def self.format_tree(nodes, level = 0)
         str = ''
         nodes.each_with_index do |node, i|
           last_node = nodes.length - 1 == i
           deps = node[:dependencies] || []
 
           str << (indent = "  " * level)
           str << (last_node ? "└" : "├")
           str << "─"
           str << (deps.empty? ? "─" : "┬")
           str << " #{node[:text]}\n"
 
-          branch = build_tree(deps, level + 1)
+          branch = format_tree(deps, level + 1)
           branch.gsub!(/^#{indent} /, indent + '│') unless last_node
           str << branch
         end
 
         return str
       end
 
-      def self.format_tree(mods, dir)
+      def self.build_tree(mods, dir)
         mods.each do |mod|
           version_string = mod[:version][:vstring].sub(/^(?!v)/, 'v')
 
           if mod[:action] == :upgrade
             previous_version = mod[:previous_version].sub(/^(?!v)/, 'v')
             version_string = "#{previous_version} -> #{version_string}"
           end
 
           mod[:text] = "#{mod[:module]} (#{colorize(:cyan, version_string)})"
           mod[:text] += " [#{mod[:path]}]" unless mod[:path] == dir
-          format_tree(mod[:dependencies], dir)
+          build_tree(mod[:dependencies], dir)
         end
       end
     end
   end
 end
 
 # Load remaining libraries
 require 'puppet/module_tool/errors'
 require 'puppet/module_tool/applications'
 require 'puppet/module_tool/checksums'
 require 'puppet/module_tool/contents_description'
 require 'puppet/module_tool/dependency'
 require 'puppet/module_tool/metadata'
 require 'puppet/module_tool/modulefile'
 require 'puppet/module_tool/skeleton'
 require 'puppet/forge/cache'
 require 'puppet/forge'
diff --git a/spec/unit/module_tool_spec.rb b/spec/unit/module_tool_spec.rb
index 5ddb01fe1..1517f30f5 100644
--- a/spec/unit/module_tool_spec.rb
+++ b/spec/unit/module_tool_spec.rb
@@ -1,113 +1,113 @@
 # encoding: UTF-8
 
 require 'spec_helper'
 require 'puppet/module_tool'
 
 describe Puppet::Module::Tool, :fails_on_windows => true do
-  describe '.build_tree' do
+  describe '.format_tree' do
     it 'should return an empty tree when given an empty list' do
-      subject.build_tree([]).should == ''
+      subject.format_tree([]).should == ''
     end
 
     it 'should return a shallow when given a list without dependencies' do
       list = [ { :text => 'first' }, { :text => 'second' }, { :text => 'third' } ]
-      subject.build_tree(list).should == <<-TREE
+      subject.format_tree(list).should == <<-TREE
 ├── first
 ├── second
 └── third
 TREE
     end
 
     it 'should return a deeply nested tree when given a list with deep dependencies' do
       list = [
         {
           :text => 'first',
           :dependencies => [
             {
               :text => 'second',
               :dependencies => [
                 { :text => 'third' }
               ]
             }
           ]
         },
       ]
-      subject.build_tree(list).should == <<-TREE
+      subject.format_tree(list).should == <<-TREE
 └─┬ first
   └─┬ second
     └── third
 TREE
     end
 
     it 'should show connectors when deep dependencies are not on the last node of the top level' do
       list = [
         {
           :text => 'first',
           :dependencies => [
             {
               :text => 'second',
               :dependencies => [
                 { :text => 'third' }
               ]
             }
           ]
         },
         { :text => 'fourth' }
       ]
-      subject.build_tree(list).should == <<-TREE
+      subject.format_tree(list).should == <<-TREE
 ├─┬ first
 │ └─┬ second
 │   └── third
 └── fourth
 TREE
     end
 
     it 'should show connectors when deep dependencies are not on the last node of any level' do
       list = [
         {
           :text => 'first',
           :dependencies => [
             {
               :text => 'second',
               :dependencies => [
                 { :text => 'third' }
               ]
             },
             { :text => 'fourth' }
           ]
         }
       ]
-      subject.build_tree(list).should == <<-TREE
+      subject.format_tree(list).should == <<-TREE
 └─┬ first
   ├─┬ second
   │ └── third
   └── fourth
 TREE
     end
 
     it 'should show connectors in every case when deep dependencies are not on the last node' do
       list = [
         {
           :text => 'first',
           :dependencies => [
             {
               :text => 'second',
               :dependencies => [
                 { :text => 'third' }
               ]
             },
             { :text => 'fourth' }
           ]
         },
         { :text => 'fifth' }
       ]
-      subject.build_tree(list).should == <<-TREE
+      subject.format_tree(list).should == <<-TREE
 ├─┬ first
 │ ├─┬ second
 │ │ └── third
 │ └── fourth
 └── fifth
 TREE
     end
   end
 end