diff --git a/lib/puppet/type/concat_file.rb b/lib/puppet/type/concat_file.rb
index bbac0db..59e5c6f 100644
--- a/lib/puppet/type/concat_file.rb
+++ b/lib/puppet/type/concat_file.rb
@@ -1,154 +1,165 @@
 require 'puppet/type/file/owner'
 require 'puppet/type/file/group'
 require 'puppet/type/file/mode'
 require 'puppet/util/checksums'
 
 Puppet::Type.newtype(:concat_file) do
   @doc = "Gets all the file fragments and puts these into the target file.
     This will mostly be used with exported resources.
 
     example:
       Concat_fragment <<| tag == 'unique_tag' |>>
 
-      concat_file { '/tmp/file:
-        tag   => 'unique_tag', # Mandatory
-        path  => '/tmp/file',  # Optional. If given it overrides the resource name
-        owner => 'root',       # Optional. Default to undef
-        group => 'root',       # Optional. Default to undef
-        mode  => '0644'        # Optional. Default to undef
-        order => 'numeric'     # Optional, Default to 'numeric'
+      concat_file { '/tmp/file':
+        tag            => 'unique_tag', # Mandatory
+        path           => '/tmp/file',  # Optional. If given it overrides the resource name
+        owner          => 'root',       # Optional. Default to undef
+        group          => 'root',       # Optional. Default to undef
+        mode           => '0644'        # Optional. Default to undef
+        order          => 'numeric'     # Optional, Default to 'numeric'
+        ensure_newline => false         # Optional, Defaults to false
       }
   "
   ensurable do
     defaultvalues
 
     defaultto { :present }
   end
 
   def exists?
     self[:ensure] == :present
   end
 
   newparam(:name, :namevar => true) do
     desc "Resource name"
   end
 
   newparam(:tag) do
     desc "Tag reference to collect all concat_fragment's with the same tag"
   end
 
   newparam(:path) do
     desc "The output file"
     defaultto do
       resource.value(:name)
     end
   end
 
   newparam(:owner, :parent => Puppet::Type::File::Owner) do
     desc "Desired file owner."
   end
 
   newparam(:group, :parent => Puppet::Type::File::Group) do
     desc "Desired file group."
   end
 
   newparam(:mode, :parent => Puppet::Type::File::Mode) do
     desc "Desired file mode."
   end
 
   newparam(:order) do
     desc "Controls the ordering of fragments. Can be set to alphabetical or numeric."
     defaultto 'numeric'
   end
 
   newparam(:backup) do
     desc "Controls the filebucketing behavior of the final file and see File type reference for its use."
     defaultto 'puppet'
   end
 
   newparam(:replace) do
     desc "Whether to replace a file that already exists on the local system."
     defaultto true
   end
 
   newparam(:validate_cmd) do
     desc "Validates file."
   end
 
+  newparam(:ensure_newline) do
+    desc "Whether to ensure there is a newline after each fragment."
+    defaultto false
+  end
+
   autorequire(:concat_fragment) do
     catalog.resources.collect do |r|
       if r.is_a?(Puppet::Type.type(:concat_fragment)) && r[:tag] == self[:tag]
         r.name
       end
     end.compact
   end
 
   def should_content
     return @generated_content if @generated_content
     @generated_content = ""
     content_fragments = []
 
     resources = catalog.resources.select do |r|
       r.is_a?(Puppet::Type.type(:concat_fragment)) && r[:tag] == self[:tag]
     end
 
     resources.each do |r|
       content_fragments << ["#{r[:order]}___#{r[:name]}", fragment_content(r)]
     end
 
     if self[:order] == 'numeric'
       sorted = content_fragments.sort do |a, b|
         def decompound(d)
           d.split('___').map { |v| v =~ /^\d+$/ ? v.to_i : v }
         end
 
         decompound(a[0]) <=> decompound(b[0])
       end
     else
       sorted = content_fragments.sort do |a, b|
         def decompound(d)
           d.split('___').first
         end
 
         decompound(a[0]) <=> decompound(b[0])
       end
     end
 
     @generated_content = sorted.map { |cf| cf[1] }.join
 
     @generated_content
   end
 
   def fragment_content(r)
     if r[:content].nil? == false
       fragment_content = r[:content]
     elsif r[:source].nil? == false
       @source = nil
       Array(r[:source]).each do |source|
         if Puppet::FileServing::Metadata.indirection.find(source)
           @source = source 
           break
         end
       end
       self.fail "Could not retrieve source(s) #{r[:source].join(", ")}" unless @source
       tmp = Puppet::FileServing::Content.indirection.find(@source, :environment => catalog.environment)
       fragment_content = tmp.content unless tmp.nil?
     end
+
+    if self[:ensure_newline]
+      fragment_content<<"\n"
+    end
+
     fragment_content
   end
 
   def eval_generate
     file_opts = {
       :ensure => self[:ensure] == :absent ? :absent : :file,
       :content => self.should_content,
     }
 
     [:path, :owner, :group, :mode, :replace, :backup].each do |param|
       unless self[param].nil?
         file_opts[param] = self[param]
       end
     end
 
     [Puppet::Type.type(:file).new(file_opts)]
   end
 end
diff --git a/manifests/init.pp b/manifests/init.pp
index 986e6a7..3948fd5 100644
--- a/manifests/init.pp
+++ b/manifests/init.pp
@@ -1,113 +1,124 @@
 # == Define: concat
 #
 # Sets up so that you can use fragments to build a final config file,
 #
 # === Options:
 #
 # [*ensure*]
 #   Present/Absent
 # [*path*]
 #   The path to the final file. Use this in case you want to differentiate
 #   between the name of a resource and the file path.  Note: Use the name you
 #   provided in the target of your fragments.
 # [*owner*]
 #   Who will own the file
 # [*group*]
 #   Who will own the file
 # [*mode*]
 #   The mode of the final file
-# [*warn_header*]
+# [*warn*]
 #   Adds a normal shell style comment top of the file indicating that it is
 #   built by puppet
 # [*backup*]
 #   Controls the filebucketing behavior of the final file and see File type
 #   reference for its use.  Defaults to 'puppet'
 # [*replace*]
 #   Whether to replace a file that already exists on the local system
 # [*order*]
 #   Select whether to order associated fragments by 'alpha' or 'numeric'.
 #   Defaults to 'alpha'.
+# [*ensure_newline*]
+#   Specifies whether to ensure there's a new line at the end of each fragment.
+#   Valid options: 'true' and 'false'. Default value: 'false'.
+# [*validate_cmd*]
+#   Specifies a validation command to apply to the destination file.
+#   Requires Puppet version 3.5 or newer. Valid options: a string to be passed
+#   to a file resource. Default value: undefined.
 #
 
 define concat(
   $ensure         = 'present',
   $path           = $name,
   $owner          = undef,
   $group          = undef,
   $mode           = '0644',
   $warn           = false,
   $force          = undef,
   $backup         = 'puppet',
   $replace        = true,
   $order          = 'alpha',
+  $ensure_newline = false,
   $validate_cmd   = undef,
 ) {
   validate_re($ensure, '^present$|^absent$')
   validate_absolute_path($path)
   validate_string($owner)
   validate_string($group)
   validate_string($mode)
   if ! (is_string($warn) or $warn == true or $warn == false) {
     fail('$warn is not a string or boolean')
   }
   if ! is_bool($backup) and ! is_string($backup) {
     fail('$backup must be string or bool!')
   }
   validate_bool($replace)
   validate_re($order, '^alpha$|^numeric$')
+  validate_bool($ensure_newline)
+
   if $validate_cmd and ! is_string($validate_cmd) {
     fail('$validate_cmd must be a string')
   }
 
   if $force != undef {
     warning('The $force parameter to concat is deprecated and has no effect.')
   }
 
   $safe_name            = regsubst($name, '[/:\n\s]', '_', 'G')
   $default_warn_message = "# This file is managed by Puppet. DO NOT EDIT.\n"
 
   case $warn {
     true: {
       $warn_message = $default_warn_message
       $_append_header = true
     }
     false: {
       $warn_message = ''
       $_append_header = false
     }
     default: {
       $warn_message = $warn
       $_append_header = true
     }
   }
 
   if $ensure == 'present' {
     concat_file { $name:
-      tag          => $safe_name,
-      path         => $path,
-      owner        => $owner,
-      group        => $group,
-      mode         => $mode,
-      replace      => $replace,
-      backup       => $backup,
-      order        => $order,
-      validate_cmd => $validate_cmd,
+      tag            => $safe_name,
+      path           => $path,
+      owner          => $owner,
+      group          => $group,
+      mode           => $mode,
+      replace        => $replace,
+      backup         => $backup,
+      order          => $order,
+      ensure_newline => $ensure_newline,
+      validate_cmd   => $validate_cmd,
     }
 
     if $_append_header {
       concat_fragment { "#{$name}_header":
         tag     => $safe_name,
         content => $warn_message,
         order   => '0',
       }
     }
   } else {
     concat_file { $name:
       ensure => $ensure,
       tag    => $safe_name,
       path   => $path,
       backup => $backup,
     }
   }
 }
 
diff --git a/spec/acceptance/newline_spec.rb b/spec/acceptance/newline_spec.rb
new file mode 100644
index 0000000..c1fa16a
--- /dev/null
+++ b/spec/acceptance/newline_spec.rb
@@ -0,0 +1,67 @@
+require 'spec_helper_acceptance'
+
+describe 'concat ensure_newline parameter' do
+  basedir = default.tmpdir('concat')
+  context '=> false' do
+    before(:all) do
+      pp = <<-EOS
+        file { '#{basedir}':
+          ensure => directory
+        }
+      EOS
+
+      apply_manifest(pp)
+    end
+    pp = <<-EOS
+      concat { '#{basedir}/file':
+        ensure_newline => false,
+      }
+      concat::fragment { '1':
+        target  => '#{basedir}/file',
+        content => '1',
+      }
+      concat::fragment { '2':
+        target  => '#{basedir}/file',
+        content => '2',
+      }
+    EOS
+
+    it 'applies the manifest twice with no stderr' do
+      apply_manifest(pp, :catch_failures => true)
+      apply_manifest(pp, :catch_changes => true)
+    end
+
+    describe file("#{basedir}/file") do
+      it { should be_file }
+      its(:content) { should match '12' }
+    end
+  end
+
+  context '=> true' do
+    pp = <<-EOS
+      concat { '#{basedir}/file':
+        ensure_newline => true,
+      }
+      concat::fragment { '1':
+        target  => '#{basedir}/file',
+        content => '1',
+      }
+      concat::fragment { '2':
+        target  => '#{basedir}/file',
+        content => '2',
+      }
+    EOS
+
+    it 'applies the manifest twice with no stderr' do
+      apply_manifest(pp, :catch_failures => true)
+      apply_manifest(pp, :catch_changes => true)
+    end
+
+    describe file("#{basedir}/file") do
+      it { should be_file }
+      its(:content) {
+        should match /1\n2\n/
+      }
+    end
+  end
+end
diff --git a/spec/unit/defines/concat_spec.rb b/spec/unit/defines/concat_spec.rb
index 35767ae..b2254f4 100644
--- a/spec/unit/defines/concat_spec.rb
+++ b/spec/unit/defines/concat_spec.rb
@@ -1,251 +1,283 @@
 require 'spec_helper'
 
 describe 'concat', :type => :define do
 
   shared_examples 'concat' do |title, params, id| 
     params = {} if params.nil?
     id = 'root' if id.nil?
 
     # default param values
     p = {
       :ensure         => 'present',
       :path           => title,
       :owner          => nil,
       :group          => nil,
       :mode           => '0644',
       :warn           => false,
       :backup         => 'puppet',
       :replace        => true,
     }.merge(params)
 
     safe_name            = title.gsub('/', '_')
     concat_name          = 'fragments.concat.out'
     default_warn_message = "# This file is managed by Puppet. DO NOT EDIT.\n"
 
     file_defaults = {
       :backup  => p[:backup],
     }
 
     let(:title) { title }
     let(:params) { params }
     let(:facts) do
       {
         :id             => id,
         :osfamily       => 'Debian',
         :path           => '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
         :kernel         => 'Linux',
         :is_pe          => false,
       }
     end
 
     if p[:ensure] == 'present'
       it do
         should contain_concat(title).with(file_defaults.merge({
           :ensure       => 'present',
           :owner        => p[:owner],
           :group        => p[:group],
           :mode         => p[:mode],
           :path         => p[:path],
           :backup       => p[:backup],
           :replace      => p[:replace],
         }))
       end
     else
       it do
         should contain_concat(title).with(file_defaults.merge({
           :ensure => 'absent',
           :backup => p[:backup],
         }))
       end
     end
   end
 
   context 'title' do
     context 'without path param' do
       # title/name is the default value for the path param. therefore, the
       # title must be an absolute path unless path is specified
       ['/foo', '/foo/bar', '/foo/bar/baz'].each do |title|
         context title do
           it_behaves_like 'concat', '/etc/foo.bar'
         end
       end
 
       ['./foo', 'foo', 'foo/bar'].each do |title|
         context title do
           let(:title) { title }
           it 'should fail' do
             expect { catalogue }.to raise_error(Puppet::Error, /is not an absolute path/)
           end
         end
       end
     end
 
     context 'with path param' do
       ['/foo', 'foo', 'foo/bar'].each do |title|
         context title do
           it_behaves_like 'concat', title, { :path => '/etc/foo.bar' }
         end
       end
     end
   end # title =>
 
   context 'as non-root user' do
     it_behaves_like 'concat', '/etc/foo.bar', {}, 'bob'
   end
 
   context 'ensure =>' do
     ['present', 'absent'].each do |ens|
       context ens do
         it_behaves_like 'concat', '/etc/foo.bar', { :ensure => ens }
       end
     end
 
     context 'invalid' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :ensure => 'invalid' }}
       it 'should fail' do
         expect { catalogue }.to raise_error(Puppet::Error, /#{Regexp.escape('does not match "^present$|^absent$"')}/)
       end
     end
   end # ensure =>
 
   context 'path =>' do
     context '/foo' do
       it_behaves_like 'concat', '/etc/foo.bar', { :path => '/foo' }
     end
 
     ['./foo', 'foo', 'foo/bar', false].each do |path|
       context path do
         let(:title) { '/etc/foo.bar' }
         let(:params) {{ :path => path }}
         it 'should fail' do
           expect { catalogue }.to raise_error(Puppet::Error, /is not an absolute path/)
         end
       end
     end
   end # path =>
 
   context 'owner =>' do
     context 'apenney' do
       it_behaves_like 'concat', '/etc/foo.bar', { :owner => 'apenny' }
     end
 
     context 'false' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :owner => false }}
       it 'should fail' do
         expect { catalogue }.to raise_error(Puppet::Error, /is not a string/)
       end
     end
   end # owner =>
 
   context 'group =>' do
     context 'apenney' do
       it_behaves_like 'concat', '/etc/foo.bar', { :group => 'apenny' }
     end
 
     context 'false' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :group => false }}
       it 'should fail' do
         expect { catalogue }.to raise_error(Puppet::Error, /is not a string/)
       end
     end
   end # group =>
 
   context 'mode =>' do
     context '1755' do
       it_behaves_like 'concat', '/etc/foo.bar', { :mode => '1755' }
     end
 
     context 'false' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :mode => false }}
       it 'should fail' do
         expect { catalogue }.to raise_error(Puppet::Error, /is not a string/)
       end
     end
   end # mode =>
 
   context 'warn =>' do
     [true, false, '# foo'].each do |warn|
       context warn do
         it_behaves_like 'concat', '/etc/foo.bar', { :warn => warn }
       end
     end
 
     context '(stringified boolean)' do
       ['true', 'yes', 'on', 'false', 'no', 'off'].each do |warn|
         context warn do
           it_behaves_like 'concat', '/etc/foo.bar', { :warn => warn }
 
           it 'should create a warning' do
             skip('rspec-puppet support for testing warning()')
           end
         end
       end
     end
 
     context '123' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :warn => 123 }}
       it 'should fail' do
         expect { catalogue }.to raise_error(Puppet::Error, /is not a string or boolean/)
       end
     end
   end # warn =>
 
   context 'backup =>' do
     context 'reverse' do
       it_behaves_like 'concat', '/etc/foo.bar', { :backup => 'reverse' }
     end
 
     context 'false' do
       it_behaves_like 'concat', '/etc/foo.bar', { :backup => false }
     end
 
     context 'true' do
       it_behaves_like 'concat', '/etc/foo.bar', { :backup => true }
     end
 
     context 'true' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :backup => [] }}
       it 'should fail' do
         expect { catalogue }.to raise_error(Puppet::Error, /backup must be string or bool/)
       end
     end
   end # backup =>
 
   context 'replace =>' do
     [true, false].each do |replace|
       context replace do
         it_behaves_like 'concat', '/etc/foo.bar', { :replace => replace }
       end
     end
 
     context '123' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :replace => 123 }}
       it 'should fail' do
         expect { catalogue }.to raise_error(Puppet::Error, /is not a boolean/)
       end
     end
   end # replace =>
 
   context 'order =>' do
     ['alpha', 'numeric'].each do |order|
       context order do
         it_behaves_like 'concat', '/etc/foo.bar', { :order => order }
       end
     end
 
     context 'invalid' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :order => 'invalid' }}
       it 'should fail' do
         expect { catalogue }.to raise_error(Puppet::Error, /#{Regexp.escape('does not match "^alpha$|^numeric$"')}/)
       end
     end
   end # order =>
+
+  context 'ensure_newline =>' do
+    [true, false].each do |ensure_newline|
+      context 'true' do
+        it_behaves_like 'concat', '/etc/foo.bar', { :ensure_newline => ensure_newline}
+      end
+    end
+
+    context '123' do
+      let(:title) { '/etc/foo.bar' }
+      let(:params) {{ :ensure_newline => 123 }}
+      it 'should fail' do
+        expect { catalogue }.to raise_error(Puppet::Error, /is not a boolean/)
+      end
+    end
+  end # ensure_newline =>
+
+  context 'validate_cmd =>' do
+    context '/usr/bin/test -e %' do
+      it_behaves_like 'concat', '/etc/foo.bar', { :validate_cmd => '/usr/bin/test -e %' }
+    end
+
+    [ 1234, true ].each do |cmd|
+      context cmd do
+        let(:title) { '/etc/foo.bar' }
+        let(:params) {{ :validate_cmd => cmd }}
+        it 'should fail' do
+          expect { catalogue }.to raise_error(Puppet::Error, /\$validate_cmd must be a string/)
+        end
+      end
+    end
+  end # validate_cmd =>
 end