geminstaller 0.2.0

data/lib/geminstaller/gem_spec_manager.rb

@@ -0,0 +1,42 @@
+module GemInstaller
+  class GemSpecManager
+    attr_writer :gem_source_index_proxy, :valid_platform_selector, :output_filter
+
+    def search(gem_pattern, version_requirement)
+      @gem_source_index_proxy.refresh!
+      @gem_source_index_proxy.search(gem_pattern, version_requirement)
+    end
+    
+    def is_gem_installed?(gem)
+      return local_matching_gems(gem).size > 0
+    end
+    
+    def all_local_gems
+      all_local_specs = search('',GemInstaller::RubyGem.default_version)
+      return [] unless all_local_specs
+      all_local_gems = all_local_specs.collect do |spec|
+        gem = GemInstaller::RubyGem.new(spec.name, :version  => spec.version.version)
+      end
+      return all_local_gems
+    end
+    
+    def local_matching_gems(gem, exact_platform_match = true)
+      gem_name_regexp = /^#{gem.regexp_escaped_name}$/
+      found_gem_specs = search(gem_name_regexp,gem.version)
+      return [] unless found_gem_specs
+      matching_gem_specs = found_gem_specs.select do |gem_spec|
+        valid_platforms = @valid_platform_selector.select(gem.platform, exact_platform_match)
+        valid_platforms.include?(gem_spec.platform)
+      end
+      matching_gems = matching_gem_specs.map do |gem_spec|
+        GemInstaller::RubyGem.new(gem_spec.name, {:version => gem_spec.version.version, :platform => gem_spec.platform })
+      end
+      return matching_gems
+    end
+  end
+end
+
+
+
+
+

data/lib/geminstaller/geminstaller_error.rb

@@ -0,0 +1,13 @@
+module GemInstaller
+  class GemInstallerError < RuntimeError
+    def descriptive_exit_message(message, command, args, listener)
+      args_string = args.join(" ")
+      descriptive_exit_message = "\n=========================================================\n"
+      descriptive_exit_message += "#{message}\n"
+      descriptive_exit_message += "Gem command was:\n  #{command} #{args_string}\n\n"
+      descriptive_exit_message += "Gem command output was:\n"
+      descriptive_exit_message += listener.read!.join("\n")
+      descriptive_exit_message += "\n=========================================================\n\n"
+    end
+  end
+end

data/lib/geminstaller/hoe_extensions.rb

@@ -0,0 +1,5 @@
+class IndependentHoe < Hoe
+  def extra_deps
+    []
+  end
+end

data/lib/geminstaller/install_processor.rb

@@ -0,0 +1,56 @@
+module GemInstaller
+  class InstallProcessor
+    attr_writer :gem_list_checker, :gem_command_manager, :gem_spec_manager, :missing_dependency_finder, :options, :output_filter
+    def process(gems)
+      gems.each do |gem|
+        install_gem(gem)
+      end
+    end
+    
+    def install_gem(gem)
+      already_specified = false
+      if gem.check_for_upgrade
+        @gem_list_checker.verify_and_specify_remote_gem!(gem)
+        already_specified = true
+      end
+      gem_is_installed = @gem_spec_manager.is_gem_installed?(gem)
+      if gem_is_installed 
+        @output_filter.geminstaller_output(:debug,"Gem #{gem.name}, version #{gem.version} is already installed.\n")
+      else
+        @gem_list_checker.verify_and_specify_remote_gem!(gem) unless already_specified
+        @output_filter.geminstaller_output(:install,"Invoking gem install for #{gem.name}, version #{gem.version}.\n")
+        output_lines = @gem_command_manager.install_gem(gem)
+        print_dependency_install_messages(gem, output_lines) unless @options[:silent]
+      end
+      if gem.fix_dependencies
+        fix_dependencies(gem)
+      end
+    end
+    
+    def print_dependency_install_messages(gem, output_lines)
+      output_lines.each do |line|
+        line =~ /Successfully installed /
+        match = $'
+        next unless match
+        next if match =~ /#{gem.name}-/
+        @output_filter.geminstaller_output(:install,"Rubygems automatically installed dependency gem #{match}\n")
+      end
+    end
+
+    def fix_dependencies(gem)
+      missing_dependencies = @missing_dependency_finder.find(gem)
+      while (missing_dependencies.size > 0)
+        missing_dependencies.each do |missing_dependency|
+          @output_filter.geminstaller_output(:install,"Installing #{missing_dependency.name} (#{missing_dependency.version})\n")
+          # recursively call install_gem to install the missing dependency.  Since fix_dependencies
+          # should never be set on an auto-created missing dependency gem, there is no risk of an 
+          # endless loop or stack overflow.
+          install_gem(missing_dependency)
+        end
+        # continue to look for and install missing dependencies until none are found
+        missing_dependencies = @missing_dependency_finder.find(gem)
+      end
+    end
+    
+  end
+end

data/lib/geminstaller/missing_dependency_finder.rb

@@ -0,0 +1,41 @@
+module GemInstaller
+  class MissingDependencyFinder
+    attr_writer :gem_command_manager, :gem_spec_manager, :gem_arg_processor, :output_filter
+    def find(dependent_gem)
+      # NOTE: this doesn't resolve platforms, there's currently no way to know what
+      # platform should be selected for a dependency gem.  Best-effort handling
+      # of ambiguous platforms on dependency gems will be handled elsewhere
+      matching_dependent_gems = @gem_spec_manager.local_matching_gems(dependent_gem)
+      missing_dependencies = []
+      install_options = dependent_gem.install_options
+      add_include_dependency_option(install_options)
+      common_args = @gem_arg_processor.strip_non_common_gem_args(install_options)
+      matching_dependent_gems.each do |matching_dependent_gem|
+        message_already_printed = false
+        dependency_gems = @gem_command_manager.dependency(matching_dependent_gem.name, matching_dependent_gem.version.to_s, common_args)
+        dependency_gems.each do |dependency_gem|
+          dependency_gem.install_options = install_options
+          local_matching_dependency_gems = @gem_spec_manager.local_matching_gems(dependency_gem, false)
+          unless local_matching_dependency_gems.size > 0
+            unless message_already_printed
+              @output_filter.geminstaller_output(:info, "Missing dependencies found for #{matching_dependent_gem.name} (#{matching_dependent_gem.version}):\n")
+              message_already_printed = true
+            end
+            # TODO: print install options too?
+            @output_filter.geminstaller_output(:info, "  #{dependency_gem.name} (#{dependency_gem.version})\n")
+            missing_dependencies << dependency_gem
+          end        
+          # recurse to find any missing dependencies in the tree
+          sub_dependencies = find(dependency_gem)
+          missing_dependencies += sub_dependencies if sub_dependencies.size > 0 
+        end
+      end
+      return missing_dependencies
+    end
+    
+    def add_include_dependency_option(install_options)
+      return if install_options.index('-y') or install_options.index('--include-dependencies')
+      install_options << '--include-dependencies'
+    end
+  end
+end

data/lib/geminstaller/missing_file_error.rb

@@ -0,0 +1,4 @@
+module GemInstaller
+  class MissingFileError < GemInstaller::GemInstallerError
+  end
+end

data/lib/geminstaller/noninteractive_chooser.rb

@@ -0,0 +1,107 @@
+module GemInstaller
+  # Format for "install" prompt list: "#{spec.name} #{spec.version} (#{spec.platform})"
+  # Format for "uninstall" prompt list: "#{spec.name}-#{spec.version}" for ruby,  "#{spec.name}-#{spec.version}-#{spec.platform}" (gem.full_name) for binary
+  class NoninteractiveChooser
+    def initialize
+      @question = nil
+    end
+    
+    def choose(question, list, dependent_gem_name, dependent_gem_version, valid_platforms)
+      @question = question
+      @list = list
+      @dependent_gem_name = dependent_gem_name
+      @dependent_gem_version = dependent_gem_version
+      @valid_platforms = valid_platforms
+      raise GemInstaller::GemInstallerError.new("Internal GemInstaller Error, unexpected choice prompt question: '#{question}'") unless
+        install_list_type? or uninstall_list_type?
+
+      raise GemInstaller::GemInstallerError.new("valid_platforms must be passed as an array.") unless 
+        valid_platforms.respond_to? :shift
+
+      raise GemInstaller::GemInstallerError.new("Internal GemInstaller Error, multiple platforms cannot be specified for an uninstall prompt") if
+        uninstall_list_type? and valid_platforms.size > 1
+
+      index = nil
+      valid_platforms.each do |platform|
+        index = find_matching_line(platform)
+        break if index 
+      end
+      
+      return @list[index], index if index
+      
+      # if we didn't find a match, raise a descriptive error
+      action = install_list_type? ? 'install' : 'uninstall'
+      name = @dependent_gem_name ? "#{@dependent_gem_name}" : "'any name'"
+      version = @dependent_gem_version ? "#{@dependent_gem_version}" : "'any version'"
+      platform = @valid_platforms ? " (#{@valid_platforms.join(' or ')})" : ''
+      error_message = "Error: Unable to select gem from list: \"#{name} #{version}#{platform}\".  Available gems are:\n"
+      list.each do |item|
+        # skip last 'cancel' list entry, it's not a real gem
+        next if item == list.last
+        error_message += "  " + item + "\n"
+      end
+      raise GemInstaller::GemInstallerError.new(error_message)
+    end
+    
+    def find_matching_line(platform)
+      required_list_item_regexp = required_name_and_version_regexp + required_platform_regexp(platform)
+      line_selector = /^#{required_list_item_regexp}$/
+      @list.each_with_index do |item, index|
+        if item =~ line_selector
+          return index
+        end
+      end
+      return nil
+    end
+    
+    def required_name_and_version_regexp
+      required_name_regexp = ".*?"
+      required_version_regexp = ".*?"
+      if uninstall_list_type? or dependent_gem?
+         # match the exact name and version if it's an uninstall prompt or a dependent gem
+        required_name_regexp = Regexp.escape(@dependent_gem_name) if @dependent_gem_name
+        required_version_regexp = Regexp.escape(@dependent_gem_version) if @dependent_gem_version
+      end
+      "#{required_name_regexp}[\s-]{0,1}#{required_version_regexp}"
+    end
+
+    def required_platform_regexp(platform_to_match)
+      return "" unless platform_to_match
+      required_platform = ""
+      escaped_platform_to_match = Regexp.escape(platform_to_match)
+      platform_regex = nil
+      if dependent_gem?
+        # do an exact match on the platform if this is the dependent gem
+        platform_regex = "#{escaped_platform_to_match}"
+      else
+        # do a wildcard match on the platform if it's not the dependent gem
+        platform_regex = ".*?#{escaped_platform_to_match}.*?"
+      end
+      # install list types always have the platform for each gem in parenthesis, even if it is ruby
+      if (install_list_type?)
+        required_platform = " \\(#{platform_regex}\\)"
+      end
+      # uninstall list types have the gem full_name, which is the platform for each gem appended after a dash, but only if it is not ruby
+      if (uninstall_list_type? && platform_to_match.to_s != GemInstaller::RubyGem.default_platform)
+        required_platform = "-.*?#{platform_regex}.*?"
+      end
+      required_platform
+    end
+    
+    def install_list_type?(question = @question)
+      question =~ /to install/
+    end
+  
+    def uninstall_list_type?(question = @question)
+      question =~ /to uninstall/
+    end
+    
+    def dependent_gem?(dependent_gem_name = @dependent_gem_name, list = @list)
+      # return true if it's an install prompt, and the list contains the gem for which the original install request
+      # was made (in other words, it's a dependent gem, not a dependency gem)
+      install_format_exact_name_match_regexp = /^#{dependent_gem_name}\s.*/
+      install_list_type? and list[0] =~ install_format_exact_name_match_regexp
+    end
+  
+  end
+end

data/lib/geminstaller/output_filter.rb

@@ -0,0 +1,49 @@
+module GemInstaller
+  class OutputFilter
+    attr_writer :output_proxy, :options
+    
+    def rubygems_output(type, message)
+      return if @options[:silent]
+      return unless rubygems_output_type_matches?(type)
+      output(:rubygems, type, message)
+    end
+      
+    def geminstaller_output(type, message)
+      return if @options[:silent]
+      return unless geminstaller_output_type_matches?(type)
+      output(:geminstaller, type, message)
+    end
+      
+    def output(source, type, message)
+      message = format_rubygems_message(type,message) if source == :rubygems
+      if (source == :geminstaller and type == :error)
+        @output_proxy.syserr(message)
+        
+      else
+        @output_proxy.sysout(message)
+      end
+    end
+    
+    def format_rubygems_message(type, message)
+      prefix = case type
+      when :stdout : "[RubyGems:stdout] "
+      when :stderr : "[RubyGems:stderr] "
+      end
+      "#{prefix}#{message}"
+    end
+
+    def rubygems_output_type_matches?(type)
+      return false unless @options[:rubygems_output]
+      return true if @options[:rubygems_output].include?(:all)
+      return true if @options[:rubygems_output].include?(type)
+      return false
+    end
+
+    def geminstaller_output_type_matches?(type)
+      return false unless @options[:geminstaller_output]
+      return true if @options[:geminstaller_output].include?(:all)
+      return true if @options[:geminstaller_output].include?(type)
+      return false
+    end
+  end
+end

data/lib/geminstaller/output_listener.rb

@@ -0,0 +1,33 @@
+dir = File.dirname(__FILE__)
+require File.expand_path("#{dir}/requires.rb")
+
+module GemInstaller
+  class OutputListener
+    attr_writer :output_filter
+    
+    def initialize
+      @messages = []
+      @output_filter = nil
+    end
+    
+    def notify(msg, stream = :stdout)
+      @messages.push(msg)
+      return unless @output_filter
+      if stream == :stdout or stream == :stderr
+        @output_filter.rubygems_output(stream, msg)
+      else
+        raise GemInstaller::GemInstallerError.new("Invalid stream specified: #{@stream}")
+      end
+    end
+    
+    def read
+      @messages.dup
+    end
+
+    def read!
+      messages = @messages.dup
+      @messages.clear
+      messages
+    end
+  end
+end

data/lib/geminstaller/output_observer.rb

@@ -0,0 +1,32 @@
+module GemInstaller
+  class OutputObserver
+    attr_writer :stream
+    # TODO: GemRunnerProxy should raise exception if listener still has any leftover output when run is invoked. 
+    def initialize
+      @stream = :stdout
+      @listeners = []
+    end
+
+    def register(listener)
+      listener = [listener] unless listener.is_a?(Array)
+      @listeners += listener
+    end
+    
+    def unregister(listener)
+      @listeners.delete(listener)
+    end
+    
+    def print(output)
+      @listeners.each do |listener|
+        listener.notify(output, @stream)
+      end
+    end
+    
+    def puts(output)
+      print("#{output}\n")
+    end
+    
+    def flush
+    end
+  end
+end

data/lib/geminstaller/output_proxy.rb

@@ -0,0 +1,36 @@
+module GemInstaller
+  class OutputProxy
+    attr_writer :options
+    def default_stream=(stream)
+      raise GemInstaller::GemInstallerError.new("Invalid default stream: #{stream}") unless stream == :stderr or stream == :stdout
+      @default_stream = stream
+    end
+
+    def sysout(out)
+      return if silent?
+      $stdout.print out
+    end
+
+    def syserr(err)
+      return if silent?
+      if @options[:redirect_stderr_to_stdout]
+        $stdout.print err
+      else
+        $stderr.print err
+      end
+    end
+    
+    # TODO: should remove this, make callers explicitly choose.
+    def output(output)
+      if @default_stream == :stdout
+        sysout(output)
+      else
+        syserr(output)
+      end
+    end
+    
+    def silent?
+      @options && @options[:silent]
+    end
+  end
+end

data/lib/geminstaller/requires.rb

@@ -0,0 +1,59 @@
+dir = File.dirname(__FILE__)
+
+# requires for rubygems
+require 'rubygems'
+require 'rubygems/doc_manager'
+require 'rubygems/config_file'
+require 'rubygems/cmd_manager'
+require 'rubygems/gem_runner'
+require 'rubygems/remote_installer'
+require 'rubygems/installer'
+require 'rubygems/validator'
+
+# third party libs
+require 'erb'
+require 'optparse'
+require 'yaml'
+require 'fileutils'
+require 'tempfile'
+
+# third party lib extensions
+require File.expand_path("#{dir}/rubygems_extensions")
+
+# internal files
+require File.expand_path("#{dir}/../geminstaller")
+require File.expand_path("#{dir}/application")
+require File.expand_path("#{dir}/arg_parser")
+require File.expand_path("#{dir}/autogem")
+require File.expand_path("#{dir}/config")
+require File.expand_path("#{dir}/config_builder")
+require File.expand_path("#{dir}/dependency_injector")
+require File.expand_path("#{dir}/enhanced_stream_ui")
+require File.expand_path("#{dir}/exact_match_list_command")
+require File.expand_path("#{dir}/file_reader")
+require File.expand_path("#{dir}/gem_arg_processor")
+require File.expand_path("#{dir}/gem_command_line_proxy")
+require File.expand_path("#{dir}/gem_command_manager")
+require File.expand_path("#{dir}/gem_interaction_handler")
+require File.expand_path("#{dir}/gem_list_checker")
+require File.expand_path("#{dir}/gem_runner_proxy")
+require File.expand_path("#{dir}/gem_source_index_proxy")
+require File.expand_path("#{dir}/gem_spec_manager")
+require File.expand_path("#{dir}/geminstaller_error")
+require File.expand_path("#{dir}/install_processor")
+require File.expand_path("#{dir}/missing_dependency_finder")
+require File.expand_path("#{dir}/missing_file_error")
+require File.expand_path("#{dir}/noninteractive_chooser")
+require File.expand_path("#{dir}/output_filter")
+require File.expand_path("#{dir}/output_listener")
+require File.expand_path("#{dir}/output_observer")
+require File.expand_path("#{dir}/output_proxy")
+require File.expand_path("#{dir}/rogue_gem_finder")
+require File.expand_path("#{dir}/rubygems_exit")
+require File.expand_path("#{dir}/ruby_gem")
+require File.expand_path("#{dir}/unexpected_prompt_error")
+require File.expand_path("#{dir}/unauthorized_dependency_prompt_error")
+require File.expand_path("#{dir}/valid_platform_selector")
+require File.expand_path("#{dir}/version_specifier")
+require File.expand_path("#{dir}/yaml_loader")
+

data/lib/geminstaller/rogue_gem_finder.rb

@@ -0,0 +1,195 @@
+module GemInstaller
+  class RogueGemFinder
+    attr_writer :output_proxy, :gem_command_manager, :gem_spec_manager, :boilerplate_lines, :preinstalled_gem_names, :preinstalled_comment
+
+    def print_rogue_gems(config_gems, config_file_paths)
+      @boilerplate_lines ||= default_boilerplate_lines(config_gems, config_file_paths)
+      @preinstalled_gem_names ||= default_preinstalled_gem_names
+      @preinstalled_comment ||= default_preinstalled_comment
+      @config_gems_with_dependencies = []
+      config_gems.each do |config_gem|
+        process_gem(config_gem)
+      end
+      all_local_gems = @gem_spec_manager.all_local_gems
+      rogue_gems = []
+      all_local_gems.each do |local_gem|
+        config_match_found_for_local = false
+        @config_gems_with_dependencies.each do |config_gem|
+          name_matches = config_gem.name == local_gem.name
+          config_gem_version_requirement = Gem::Version::Requirement.new [config_gem.version]
+          local_gem_version = Gem::Version.new(local_gem.version)
+          version_matches = config_gem_version_requirement.satisfied_by?(local_gem_version)
+          if (name_matches and version_matches)
+            config_match_found_for_local = true
+            break
+          end
+        end
+        rogue_gems << local_gem unless config_match_found_for_local
+      end
+      yaml = format_to_yaml(rogue_gems)
+      
+      handle_output(yaml)
+    end
+    
+    def default_boilerplate_lines(config_gems, config_file_paths)
+      boilerplate = []
+      boilerplate <<  [
+        "#",
+        "# This is a GemInstaller config file (http://geminstaller.rubyforge.org)",
+        "# It was generated using the 'geminstaller --print-rogue-gems' option on #{Time.now}",
+        "#",
+        "# You can bootstrap your config by piping the output to a file: ",
+        "#   'geminstaller --print-rogue-gems > geminstaller.yml'",
+        "#",
+        "# You can then install these gems on another system by running geminstaller with this file.",
+        "#"
+      ]
+      
+      if config_file_paths.size == 0
+        boilerplate << "# Since there was no config file specified, the 'gems:' section below lists all gems on your system."
+      else
+        boilerplate << "# The following config file(s) and gems were already specified:"
+        boilerplate << "#   Files:"
+        config_file_paths.each do |config_file_path|
+          boilerplate << "#     * " + config_file_path
+        end
+        boilerplate << "#   Gems:"
+        if config_gems.size > 0
+          config_gems.each do |config_gem|
+            boilerplate << "#     * #{config_gem.name} #{config_gem.version}"
+          end
+        else
+          boilerplate << "#     No Gems"
+        end
+      end
+      boilerplate << "#"
+      boilerplate << "defaults:"
+      boilerplate << "  install_options: --include-dependencies"
+      return boilerplate
+    end
+    
+    def default_preinstalled_gem_names
+      # This is the list of preinstalled gems from the Ruby windows 1-click installer, v186-25
+      # 
+      # fxri (0.3.6)
+      #     Graphical interface to the RI documentation, with search engine.
+      # 
+      # fxruby (1.6.6)
+      #     FXRuby is the Ruby binding to the FOX GUI toolkit.
+      # 
+      # hpricot (0.4)
+      #     a swift, liberal HTML parser with a fantastic library
+      # 
+      # log4r (1.0.5)
+      #     Log4r is a comprehensive and flexible logging library for Ruby.
+      # 
+      # rake (0.7.2)
+      #     Ruby based make-like utility.
+      # 
+      # sources (0.0.1)
+      #     This package provides download sources for remote gem installation
+      # 
+      # win32-clipboard (0.4.1)
+      #     A package for interacting with the Windows clipboard
+      # 
+      # win32-dir (0.3.1)
+      #     Extra constants and methods for the Dir class on Windows.
+      # 
+      # win32-eventlog (0.4.3)
+      #     Interface for the MS Windows Event Log.
+      # 
+      # win32-file (0.5.3)
+      #     Extra or redefined methods for the File class on Windows.
+      # 
+      # win32-file-stat (1.2.3)
+      #     A File::Stat class tailored to MS Windows
+      # 
+      # win32-process (0.5.1)
+      #     Adds fork, wait, wait2, waitpid, waitpid2 and a special kill method
+      # 
+      # win32-sapi (0.1.3)
+      #     An interface to the MS SAPI (Sound API) library.
+      # 
+      # win32-sound (0.4.0)
+      #     A package for playing with sound on Windows.
+      # 
+      # windows-pr (0.6.2)
+      #     Windows functions and constants predefined via Win32API
+
+      if RUBY_PLATFORM =~ /mswin/
+        return [
+          'fxri',
+          'fxruby',
+          'hpricot',
+          'log4r',
+          'rake',
+          'sources',
+          'win32-clipboard',
+          'win32-dir',
+          'win32-eventlog',
+          'win32-file',
+          'win32-file-stat',
+          'win32-process',
+          'win32-sapi',
+          'win32-sound',
+          'windows-pr'
+        ]
+      end
+      return ['sources']
+    end
+    
+    def default_preinstalled_comment
+      "# NOTE: This gem may have been automatially installed with Ruby, and not actually be used by your app(s)."
+    end
+    
+    def handle_output(yaml)
+      yaml_lines = yaml.split("\n")
+      yaml_doc_separator = yaml_lines.delete_at(0)
+      
+      output = []
+      output.push(yaml_doc_separator)
+      
+      output << @boilerplate_lines
+      
+      yaml_lines.each do |yaml_line| 
+        name_parser_regexp = /- name: (.*)/
+        yaml_line =~  name_parser_regexp
+        gem_name = $1
+        preinstalled_comment = ''
+        if @preinstalled_gem_names.include?(gem_name)
+          preinstalled_comment = " " + @preinstalled_comment
+        end
+        output.push yaml_line + preinstalled_comment
+      end
+      
+      output_string = output.join("\n")
+      @output_proxy.sysout output_string
+      output_string
+    end
+    
+    def process_gem(gem)
+      @config_gems_with_dependencies << gem
+      process_gem_dependencies(gem)
+    end
+
+    def process_gem_dependencies(gem)
+      # TODO: this method is duplicated in autogem  Should abstract and take a block
+      matching_gems = @gem_spec_manager.local_matching_gems(gem)
+      matching_gems.each do |matching_gem|
+        dependency_gems = @gem_command_manager.dependency(matching_gem.name, matching_gem.version.to_s)
+        dependency_gems.each do |dependency_gem|
+          process_gem(dependency_gem)
+        end
+      end
+    end
+
+    def format_to_yaml(gems)
+      names_and_versions = []
+      gems.each do |gem|
+        names_and_versions << {'name' => gem.name, 'version' => gem.version}
+      end
+      hash_for_yaml = {'gems' => names_and_versions}
+      YAML.dump(hash_for_yaml)
+    end
+  end
+end