diff --git a/lib/puppet/module_tool/metadata.rb b/lib/puppet/module_tool/metadata.rb
index e625c3fdb..4ba40c147 100644
--- a/lib/puppet/module_tool/metadata.rb
+++ b/lib/puppet/module_tool/metadata.rb
@@ -1,159 +1,167 @@
 require 'puppet/util/methodhelper'
 require 'puppet/module_tool'
 require 'puppet/network/format_support'
 require 'uri'
 require 'json'
 
 module Puppet::ModuleTool
 
   # This class provides a data structure representing a module's metadata.
   # @api private
   class Metadata
     include Puppet::Network::FormatSupport
 
     attr_accessor :module_name
 
     DEFAULTS = {
       'name'         => nil,
       'version'      => nil,
       'author'       => nil,
       'summary'      => nil,
       'license'      => 'Apache 2.0',
       'source'       => '',
       'project_page' => nil,
       'issues_url'   => nil,
       'dependencies' => [].freeze,
     }
 
     def initialize
       @data = DEFAULTS.dup
       @data['dependencies'] = @data['dependencies'].dup
     end
 
     # Returns a filesystem-friendly version of this module name.
     def dashed_name
       @data['name'].tr('/', '-') if @data['name']
     end
 
     # Returns a string that uniquely represents this version of this module.
     def release_name
       return nil unless @data['name'] && @data['version']
       [ dashed_name, @data['version'] ].join('-')
     end
 
     alias :name :module_name
     alias :full_module_name :dashed_name
 
     # Merges the current set of metadata with another metadata hash.  This
     # method also handles the validation of module names and versions, in an
     # effort to be proactive about module publishing constraints.
     def update(data)
       process_name(data) if data['name']
       process_version(data) if data['version']
       process_source(data) if data['source']
 
       @data.merge!(data)
       return self
     end
 
+    # Provides an accessor for the now defunct 'description' property.  This
+    # addresses a regression in Puppet 3.6.x where previously valid templates
+    # refering to the 'description' property were broken.
+    # @deprecated
+    def description
+      @data['description']
+    end
+
     # Returns a hash of the module's metadata.  Used by Puppet's automated
     # serialization routines.
     #
     # @see Puppet::Network::FormatSupport#to_data_hash
     def to_hash
       @data
     end
     alias :to_data_hash :to_hash
 
     def to_json
       # This is used to simulate an ordered hash.  In particular, some keys
       # are promoted to the top of the serialized hash (while others are
       # demoted) for human-friendliness.
       #
       # This particularly works around the lack of ordered hashes in 1.8.7.
       promoted_keys = %w[ name version author summary license source ]
       demoted_keys = %w[ dependencies ]
       keys = @data.keys
       keys -= promoted_keys
       keys -= demoted_keys
 
       contents = (promoted_keys + keys + demoted_keys).map do |k|
         value = (JSON.pretty_generate(@data[k]) rescue @data[k].to_json)
         "#{k.to_json}: #{value}"
       end
 
       "{\n" + contents.join(",\n").gsub(/^/, '  ') + "\n}\n"
     end
 
     # Expose any metadata keys as callable reader methods.
     def method_missing(name, *args)
       return @data[name.to_s] if @data.key? name.to_s
       super
     end
 
     private
 
     # Do basic validation and parsing of the name parameter.
     def process_name(data)
       validate_name(data['name'])
       author, @module_name = data['name'].split(/[-\/]/, 2)
 
       data['author'] ||= author if @data['author'] == DEFAULTS['author']
     end
 
     # Do basic validation on the version parameter.
     def process_version(data)
       validate_version(data['version'])
     end
 
     # Do basic parsing of the source parameter.  If the source is hosted on
     # GitHub, we can predict sensible defaults for both project_page and
     # issues_url.
     def process_source(data)
       if data['source'] =~ %r[://]
         source_uri = URI.parse(data['source'])
       else
         source_uri = URI.parse("http://#{data['source']}")
       end
 
       if source_uri.host =~ /^(www\.)?github\.com$/
         source_uri.scheme = 'https'
         source_uri.path.sub!(/\.git$/, '')
         data['project_page'] ||= @data['project_page'] || source_uri.to_s
         data['issues_url'] ||= @data['issues_url'] || source_uri.to_s.sub(/\/*$/, '') + '/issues'
       end
 
     rescue URI::Error
       return
     end
 
     # Validates that the given module name is both namespaced and well-formed.
     def validate_name(name)
       return if name =~ /\A[a-z0-9]+[-\/][a-z][a-z0-9_]*\Z/i
 
       namespace, modname = name.split(/[-\/]/, 2)
       modname = :namespace_missing if namespace == ''
 
       err = case modname
       when nil, '', :namespace_missing
         "the field must be a namespaced module name"
       when /[^a-z0-9_]/i
         "the module name contains non-alphanumeric (or underscore) characters"
       when /^[^a-z]/i
         "the module name must begin with a letter"
       else
         "the namespace contains non-alphanumeric characters"
       end
 
       raise ArgumentError, "Invalid 'name' field in metadata.json: #{err}"
     end
 
     # Validates that the version string can be parsed as per SemVer.
     def validate_version(version)
       return if SemVer.valid?(version)
 
       err = "version string cannot be parsed as a valid Semantic Version"
       raise ArgumentError, "Invalid 'version' field in metadata.json: #{err}"
     end
   end
 end
diff --git a/spec/unit/module_tool/metadata_spec.rb b/spec/unit/module_tool/metadata_spec.rb
index 3b925c644..a2f78661c 100644
--- a/spec/unit/module_tool/metadata_spec.rb
+++ b/spec/unit/module_tool/metadata_spec.rb
@@ -1,233 +1,246 @@
 require 'spec_helper'
 require 'puppet/module_tool'
 
 describe Puppet::ModuleTool::Metadata do
   let(:data) { {} }
   let(:metadata) { Puppet::ModuleTool::Metadata.new }
 
+  describe 'property lookups' do
+    subject { metadata }
+
+    %w[ name version author summary license source project_page issues_url
+    dependencies dashed_name release_name description ].each do |prop|
+      describe "##{prop}" do
+        it "responds to the property" do
+          subject.send(prop)
+        end
+      end
+    end
+  end
+
   describe "#update" do
     subject { metadata.update(data) }
 
     context "with a valid name" do
       let(:data) { { 'name' => 'billgates-mymodule' } }
 
       it "extracts the author name from the name field" do
         subject.to_hash['author'].should == 'billgates'
       end
 
       it "extracts a module name from the name field" do
         subject.module_name.should == 'mymodule'
       end
 
       context "and existing author" do
         before { metadata.update('author' => 'foo') }
 
         it "avoids overwriting the existing author" do
           subject.to_hash['author'].should == 'foo'
         end
       end
     end
 
     context "with a valid name and author" do
       let(:data) { { 'name' => 'billgates-mymodule', 'author' => 'foo' } }
 
       it "use the author name from the author field" do
         subject.to_hash['author'].should == 'foo'
       end
 
       context "and preexisting author" do
         before { metadata.update('author' => 'bar') }
 
         it "avoids overwriting the existing author" do
           subject.to_hash['author'].should == 'foo'
         end
       end
     end
 
     context "with an invalid name" do
       context "(short module name)" do
         let(:data) { { 'name' => 'mymodule' } }
 
         it "raises an exception" do
           expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the field must be a namespaced module name")
         end
       end
 
       context "(missing namespace)" do
         let(:data) { { 'name' => '/mymodule' } }
 
         it "raises an exception" do
           expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the field must be a namespaced module name")
         end
       end
 
       context "(missing module name)" do
         let(:data) { { 'name' => 'namespace/' } }
 
         it "raises an exception" do
           expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the field must be a namespaced module name")
         end
       end
 
       context "(invalid namespace)" do
         let(:data) { { 'name' => "dolla'bill$-mymodule" } }
 
         it "raises an exception" do
           expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the namespace contains non-alphanumeric characters")
         end
       end
 
       context "(non-alphanumeric module name)" do
         let(:data) { { 'name' => "dollabils-fivedolla'" } }
 
         it "raises an exception" do
           expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the module name contains non-alphanumeric (or underscore) characters")
         end
       end
 
       context "(module name starts with a number)" do
         let(:data) { { 'name' => "dollabills-5dollars" } }
 
         it "raises an exception" do
           expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the module name must begin with a letter")
         end
       end
     end
 
 
     context "with an invalid version" do
       let(:data) { { 'version' => '3.0' } }
 
       it "raises an exception" do
         expect { subject }.to raise_error(ArgumentError, "Invalid 'version' field in metadata.json: version string cannot be parsed as a valid Semantic Version")
       end
     end
 
     context "with a valid source" do
       context "which is a GitHub URL" do
         context "with a scheme" do
           before { metadata.update('source' => 'https://github.com/billgates/amazingness') }
 
           it "predicts a default project_page" do
             subject.to_hash['project_page'].should == 'https://github.com/billgates/amazingness'
           end
 
           it "predicts a default issues_url" do
             subject.to_hash['issues_url'].should == 'https://github.com/billgates/amazingness/issues'
           end
         end
 
         context "without a scheme" do
           before { metadata.update('source' => 'github.com/billgates/amazingness') }
 
           it "predicts a default project_page" do
             subject.to_hash['project_page'].should == 'https://github.com/billgates/amazingness'
           end
 
           it "predicts a default issues_url" do
             subject.to_hash['issues_url'].should == 'https://github.com/billgates/amazingness/issues'
           end
         end
       end
 
       context "which is not a GitHub URL" do
         before { metadata.update('source' => 'https://notgithub.com/billgates/amazingness') }
 
         it "does not predict a default project_page" do
           subject.to_hash['project_page'].should be nil
         end
 
         it "does not predict a default issues_url" do
           subject.to_hash['issues_url'].should be nil
         end
       end
 
       context "which is not a URL" do
         before { metadata.update('source' => 'my brain') }
 
         it "does not predict a default project_page" do
           subject.to_hash['project_page'].should be nil
         end
 
         it "does not predict a default issues_url" do
           subject.to_hash['issues_url'].should be nil
         end
       end
 
     end
 
   end
 
   describe '#dashed_name' do
     it 'returns nil in the absence of a module name' do
       expect(metadata.update('version' => '1.0.0').release_name).to be_nil
     end
 
     it 'returns a hyphenated string containing namespace and module name' do
       data = metadata.update('name' => 'foo-bar')
       data.dashed_name.should == 'foo-bar'
     end
 
     it 'properly handles slash-separated names' do
       data = metadata.update('name' => 'foo/bar')
       data.dashed_name.should == 'foo-bar'
     end
 
     it 'is unaffected by author name' do
       data = metadata.update('name' => 'foo/bar', 'author' => 'me')
       data.dashed_name.should == 'foo-bar'
     end
   end
 
   describe '#release_name' do
     it 'returns nil in the absence of a module name' do
       expect(metadata.update('version' => '1.0.0').release_name).to be_nil
     end
 
     it 'returns nil in the absence of a version' do
       expect(metadata.update('name' => 'foo/bar').release_name).to be_nil
     end
 
     it 'returns a hyphenated string containing module name and version' do
       data = metadata.update('name' => 'foo/bar', 'version' => '1.0.0')
       data.release_name.should == 'foo-bar-1.0.0'
     end
 
     it 'is unaffected by author name' do
       data = metadata.update('name' => 'foo/bar', 'version' => '1.0.0', 'author' => 'me')
       data.release_name.should == 'foo-bar-1.0.0'
     end
   end
 
   describe "#to_hash" do
     subject { metadata.to_hash }
 
     its(:keys) do
       subject.sort.should == %w[ name version author summary license source issues_url project_page dependencies ].sort
     end
 
     describe "['license']" do
       it "defaults to Apache 2" do
         subject['license'].should == "Apache 2.0"
       end
     end
 
     describe "['dependencies']" do
       it "defaults to an empty Array" do
         subject['dependencies'].should == []
       end
     end
 
     context "when updated with non-default data" do
       subject { metadata.update('license' => 'MIT', 'non-standard' => 'yup').to_hash }
 
       it "overrides the defaults" do
         subject['license'].should == 'MIT'
       end
 
       it 'contains unanticipated values' do
         subject['non-standard'].should == 'yup'
       end
     end
   end
 end